Flow-based visual scripting for Python

Overview

drawing

A simple visual node editor for Python

Ryven combines flow-based visual scripting with Python. It gives you absolute freedom for your nodes and a simple system for programming them. While there are some example node packages, you will most likely rely mostly on your own nodes.

While Ryven has a large Qt-based frontend which affects performance of flow execution, you can disable particularly expensive features, and a project made in the editor can be deployed directly on the backend (ryvencore) via RyvenConsole, which does not have a single dependency!

Ryven repos on GitHub --------------------------------------------------------------------------------
ryvencore backend / core framework
ryvencore-qt Qt frontend
ryven-blender Ryven plugin for Blender
ryven-unreal Ryven plugin for Unreal Engine
ryven-website Ryven website sources
PythonOCC nodes for Ryven Ryven nodes for PythonOCC

To get started with Ryven, these are the resources that guide you through the process (in an order that makes the most sense):

  1. the quick start guide below
  2. the tutorials in the docs/node_tutorials directory
  3. a longer guide on the website for details

Ryven comes with some example nodes, but these are, indeed, just examples, and there's no guarantee that all of them will stay. I would like to open a repository for maintaining particularly useful (frameworks of) nodes, but I will need contributors for that.

Installation

pip install ryven

and now you can launch it by running ryven on your terminal, and ryven_console for RyvenConsole. If you want to start Ryven from a Python script, just import it and run it like this

import ryven

ryven.run_ryven(
    # args...
)

quick start

A super quick intro to Ryven.

editor usage

Open Ryven by typing ryven in your terminal (or running Ryven.py with python), and create a new project. Import some example nodes via File -> Import Example Nodes and select std/nodes.py. You should now see a long list of nodes on the left. Drag and drop them into the scene and get a feeling for how they work, everything is being executed at realtime. For instance, drag two val nodes into the scene, wire them together with a + node and display the result in a result node. Now replace one of them with a slider node generating real numbers. You can also get an interactive nodes list preview inside the scene by right-clicking. You can pan around also with the right mouse button, and zoom via ctrl + scroll. You can also create new scripts, rename and delete them.

Now let's check out the small example projects: open a new Ryven window and load one of them. Take a closer look and understand what they do.

At this point you are ready to start building your own nodes.

defining nodes

Navigate to the ~/.ryven/packages/ directory and create a new folder . Inside this folder create a python file nodes.py and fill it with the following content:

from ryven.NENV import *

# your node definitions go here

export_nodes(
    # list your node classes here, as tuple
)

and now you can define your own node classes. Reference the ones you want to expose to Ryven in the export_nodes function (for example export_nodes(MyNode, ) or export_nodes(Node1, Node2, )). Let's define two basic nodes:

one which generates random numbers

from random import random

class RandNode(Node):
    """Generates scaled random float values"""
    # the docstring will be shown as tooltip in the editor

    title = 'Rand'  # the display_title is title by default
    tags = ['random', 'numbers']  # for better search
    
    init_inputs = [  # one input
        NodeInputBP(dtype=dtypes.Data(default=1))
        # the dtype will automatically provide a suitable widget
    ]
    init_outputs = [  # and one output
        NodeOutputBP()
    ]
    color = '#fcba03'

    def update_event(self, inp=-1):
        # update first output
        self.set_output_val(0, 
            random() * self.input(0)  # random float between 0 and value at input
        )

and another one which prints them

class PrintNode(Node):
    title = 'Print'
    init_inputs = [
        NodeInputBP(),
    ]
    color = '#A9D5EF'

    def update_event(self, inp=-1):
        print(self.input(0))

and that's it! Go ahead and import your nodes package in Ryven. Place both in the scene and connect the Rand node to your Print node.


You can do a lot more than shown above. A summary of the main features:

  • many modifiable themes, including light themes
  • simple and unrestricted nodes system
  • actions / right-click operations system for nodes
  • variables system with update mechanism for nodes that automatically adapt to change of data
  • logging support
  • rendering flow images
  • stylus support for adding handwritten notes / drawings on touch devices
  • exec flow support like UnrealEngine BluePrints
  • Qt widgets support

and some examples for those:

actions / right-click operations system for nodes

which can be edited through the API at any time.

class MyNode(Node):
    ...

    def a_method(self):
        self.actions['do something'] = {
            'method': self.do_sth,
        }

    # with some method...
    def do_sth(self):
        ...

Qt widgets

You can add custom Qt widgets for your nodes. Define a widgets.py file next to your nodes.py with similar structure to nodes.py, see the guide for detailed instructions.

widgets.py

from ryven.NWENV import *
from qtpy.QtWidgets import QWidget

class SomeMainWidget(MWB, QWidget):
    def __init__(self, params):
        MWB.__init__(self, params)
        QWidget.__init__(self)
    ...

class SomeInputWidget(IWB, QWidget):
    def __init__(self, params):
        IWB.__init__(self, params)
        QWidget.__init__(self)
    ...

export_widgets(
    SomeMainWidget,
    SomeInputWidget,
)

nodes.py

class MyNode(Node):
    main_widget_class = MyNode_MainWidget
    main_widget_pos = 'below ports'  # alternatively 'between ports'

stylus support

drawing

logging support

import logging

class MyNode(Node):
    def somewhere(self):
        self.logger = self.new_logger('nice log')
    
    def update_event(self, inp=-1):
        self.logger.info('updated!')

variables system

with an update mechanism to build nodes that automatically adapt to change of data.

class MyNode(Node):
    def a_method(self):
        self.register_var_receiver('x', method=self.process)

    # with some method...
    def process(self, val_of_x):
        # processing new value of var 'x'
        ...

Contributions

Contributing guidelines: here.

Particularly effective ways to contribute outside direct development of the software include

  • creating examples
  • creating tutorials
  • creating node packages
  • improving documentation

Also notice that there's a discussions area in this repo.

The docs page on the website is made with Docsify, so you can improve it by simply editing the markdown. The whole website sources are also on GitHub.

Cheers.

Comments
  • Adds command line arguments (closes #95)

    Adds command line arguments (closes #95)

    As promised (and discussed) in #95, this is my take on adding command line arguments.

    • Arguments can be specified on the command line.
    • Arguments can be given in configuration files (these use argparse's feature, where you can intersperse configuration files with command line arguments). Configuration file names have to start with the at-sign '@'. Configuration files have the format key[: value] and can have comments.
    • run() can take the same arguments (positional and keyword) as the command line.
    • Call ryven -h to display all possible arguments (or just see below)

    Open questions:

    1. The code to assemble the editor's startup configuration can now be found both in run() (L443) and StartupDialog. Since StartupDialog is only called from run(), I would prefer to have that code just in the run() function.
    2. The available flow themes are hard coded (Ryven.py, L170). Is there an easy way to get all available flow themes?

    ToDos:

    • Set performance mode from command line/config file
    • Set animations from command line/config file
    • En/disable info messages from command line/config file

    Comments, suggestions, requests are always welcome!!

    ryven --help

    usage: ryven [-h] [-s] [-n NODE] [-x {basics,matrices}] [-w {dark,light}]
                 [-f {toy,darktron,ghost,blender,simple,ueli,pure dark,colorful,pure light,colorful light,industrial,fusion}]
                 [-d] [-q QT_API] [-t TITLE]
                 [PROJECT]
    
    Flow-based visual scripting with Python with absolute freedom for your nodes.
    See https://ryven.org/guide/ for a guide how to program them.
    
    positional arguments:
      PROJECT               the project file or example to be loaded; use "-" for
                            standard input
    
    optional arguments:
      -h, --help            show this help message and exit
      -s, --show-dialog     show start-up dialog (disables "--example", "--flow-
                            theme" and the loading of the project file)
    
    projects:
      -n NODE, --nodes NODE
                            load a nodes packages; (NODE is the path to the node
                            package without "/nodes.py")
      -x {basics,matrices}, --example {basics,matrices}
                            load an example project (do not give PROJECT argument)
    
    display:
      -w {dark,light}, --window-theme {dark,light}
                            set the window theme (default: dark)
      -f {toy,darktron,ghost,blender,simple,ueli,pure dark,colorful,pure light,colorful light,industrial,fusion}, --flow-theme {toy,darktron,ghost,blender,simple,ueli,pure dark,colorful,pure light,colorful light,industrial,fusion}
                            set the theme of the flow view (default: {pure
                            dark|pure light}, depending on the window theme)
    
    debug:
      -d, --debug           display messages on the console
      -q QT_API, --qt-api QT_API
                            the QT API to be used (default: pyside2)
      -t TITLE, --title TITLE
                            changes the window's title (default: Ryven)
    
    configuration files:
      One or more configuration files can be used at any position. • To mark an
      argument to be used as a configuration files, the file name must be
      preceded with the @-sign, e.g. "@ryven.cfg". The later command line
      arguments or configuration file takes precedence over earlier specified
      arguments. • The format is like the long command line argument, but with
      the leading two hyphens removed. If the argument takes a value, this comes
      after a colon, e.g. these three lines are identical: "example: basics" and
      "example=basics". • Comments can be inserted after the hash sign "#".
    
    Copyright (C) 2020-2022 Leon Thomm, licensed under MIT
    
    opened by sphh 106
  • Conda Package

    Conda Package

    I tried to build a Conda Package for ryven to simplify the installation process. So it can now be installed using:

    conda install -c conda-forge ryven
    

    So far it works fine on Mac OS X with python 3.9 - it fails with python 3.10. But maybe somebody can test it with Linux and Windows.

    opened by jan-janssen 23
  • Refactor dev branch with Python package structure

    Refactor dev branch with Python package structure

    First, thanks for the great work on this. In order to make full use of Ryven for my application, I needed to be able to easily pip install ryven. I did basic refactoring of your latest dev branch into a traditional Python package format, with a directory structure:

    Ryven/
    ├─ docs/
    ├─ ryven/
    │  ├─ core/
    │  │  ├─ <files that I thought are needed for basic Ryven operation>
    │  ├─ gui/
    │  │  ├─ <files related to the GUI execution>
    │  ├─ packages/
    │  ├─ resources/
    │  ├─ saves/
    │  ├─ stuff/
    ├─ setup.py
    ├─ setup.cfg
    ├─ <other top level files>
    

    I didn't make any functional changes to the code. In order to have everything still function and import properly, I changed all local relative imports to absolute imports (e.g. from NENV import * becomes from ryven.core.NENV import *.)

    If you find this useful, feel free to pull it, or if not, I'll just continue using it from my own fork.

    Best, Marcin

    opened by mmorys 10
  • TypeError: can only concatenate str (not

    TypeError: can only concatenate str (not "NoneType") to str.

    https://stackoverflow.com/questions/70619058/why-comes-error-when-set-a-attribute-to-a-cls-type-in-ryven

    I do not know,it is a buge about Ryven or about python.

    Could anyone get it?

    opened by lanhao945 9
  • MacOsX 10.13.6: Gui buttons can't be clicked

    MacOsX 10.13.6: Gui buttons can't be clicked

    Using python 3.6 and 3.8 under OsX 10.13.6, gui starts, but nothing happens if buttons are clicked in either Ryven.py (trying to click on "new project" or "load project") or the nodemanager (trying to click on "add new", "import nodes", "save")

    Thank you!

    opened by trondarild 9
  • Contributions?

    Contributions?

    So, I recently found your program through a web search (or youtube video, I can't remember) and I decided I'd like to help in possibly contributing to the project.

    With my projects I mainly do JS programming, though I've dabbled within Python quite a bit.

    I didn't see a contribution section within your README or site (unless I missed something), and I was wondering if you're welcome to contributions or not.

    opened by Krorenshima 5
  • Unable to install ryven (could be me and poetry)

    Unable to install ryven (could be me and poetry)

    Hi - I have a virtual environment based on python 3.8, and I am using poetry to help me install packages. I get the following error message when I try to add ryven.

    '[SolverProblemError] The current project's Python requirement (^3.8) is not compatible with some of the required packages Python requirement:

    • ryven requires Python !=3.10,>=3.6

    Because ryven (3.1.1) requires Python !=3.10,>=3.6 and no versions of ryven match >3.1.1,<4.0.0, ryven is forbidden. So, because project-701-ryven depends on ryven (^3.1.1), version solving failed.'

    Capture

    I have searched google for equivalent issues, but nothing specific to my problem. The message suggests I have my version correct so that it might be a poetry issue. Feel free to close if this issue is not considered ryven driven.

    opened by AJP4 4
  • Cannot create new node

    Cannot create new node

    I right-click in the canvas, and I see the dropdown list of available nodes. However, I cannot find a way to create a node. I have tried, enter, right-click, left-click, etc.. and nothing... I have downloaded the latest version of ryven today directly from github...

    opened by sarabiaf 4
  • Importing nodes?

    Importing nodes?

    I know this isn't a bug but couldn't find anywhere else to ask. as for the question, I was wondering if it was possible to import nodes from modules without having to define or create them from scratch?

    opened by festro 4
  • PyQtWebEngine Node error

    PyQtWebEngine Node error

    I tried creating a PyQtWebEngine widget to display html in a node. I did it with the following code:

    class HTMLDisplay_MainWidget(MWB, QWebEngineView): def __init__(self, params): MWB.__init__(self, params) QWebEngineView.__init__(self) #self.setLayout(QVBoxLayout()) #self.html_view = QWebEngineView() #self.layout().addWidget(self.html_view) raw_html = "<html><head></head><body style=""><div style=""><h1>This is an html</h1></div></body></html>" self.setHtml(raw_html)

    I get the following error

    "Qt WebEngine seems to be initialized from a plugin. Please set Qt::AA_ShareOpenGLContexts using QCoreApplication::setAttribute before constructing QGuiApplication. Attribute Qt::AA_ShareOpenGLContexts must be set before QCoreApplication is created. WebEngineContext used before QtWebEngine::initialize() or OpenGL context creation failed. LaunchProcess: failed to execvp: /usr/local/lib/python3.8/dist-packages/PySide2-5.15.2-py3.8-linux-x86_64.egg/PySide2/Qt/libexec/QtWebEngineProcess LaunchProcess: failed to execvp: /usr/local/lib/python3.8/dist-packages/PySide2-5.15.2-py3.8-linux-x86_64.egg/PySide2/Qt/libexec/QtWebEngineProcess Trace/breakpoint trap (core dumped) "

    please advice.

    Screenshot from 2021-11-08 17-12-33

    opened by kndidox 3
  • Feature request: add Delete as trigger for deletion of nodes

    Feature request: add Delete as trigger for deletion of nodes

    I don't know if I'm missing something, but it would be really helpful, to delete placed nodes. Since no related command is listed in the command list, I assume this is not possible at the moment.

    opened by jo-te 3
  • Is it possible to officially upgrade to Qt6 & PySide6?

    Is it possible to officially upgrade to Qt6 & PySide6?

    I see the App is developed by Qt5 & PySide2, I tried to upgrade to Qt6 & PySide6, but failed. Is it possible to officially upgrade to Qt6 & PySide6?

    opened by Oxygen-Chu 1
  • Updates to ryvencore API

    Updates to ryvencore API

    Following discussion in #126 this allows Ryven and ryvencore-qt to use the current dev branch of ryvencore. I implemented the ryvencore API changes (removal of Script, connections, view_place_event, load_data), updated the widgets and wrappers and fixed references to the addons so that Ryven can start and one is able to drop new nodes (tested only with Val and Results). This is a first step, and will require some more work as connections don't fully work yet, to see if you're okay with the direction. There's a few open questions:

    • The input widgets now don't have an object to store a value in (only output ports do so in the new ryvencore), so this is where I stopped. I was thinking this may be the moment to completely remove the input widgets, and store all the interactivity in the main Node widget.
    • I think I didn't follow your logic for imports, which would in any case benefit from some clarification/simplification.
    • Pushing the simplification thinking, I also wonder what use case there is for the Console in Ryven? This is what drives some complexity in the imports, and I'm not sure who would use that very bare-bones execution mode.
    opened by amaury-anciaux 1
  • UI/UX ideas

    UI/UX ideas

    I get that implementing all of this quickly isn't possible, but I just want to start the dialogue because I really like the capabilities of this project.

    • It'd be nice to save and load the position of the view splitters
    • Connection lines should respect node titles, right now they can easily overlap
    • Nodes with long names are not easy to see if the application is not full-screened
    • Nodes should be put into subsections with the node package name imo, The current alphabetical sort is messy and I would never prefer it over grouping the node modules together.
    • The node editor starts in the top left of some imaginary plane, it would be better if we started in the middle of some plane and could pan in every direction
    • zoom level should be saved with the project
    • If nodes are in the main os.getcwd() of the Ryven runtime, they should be saved and loaded with a relative path instead of an absolute one, so that the .json projects don't break when sending projects to different computers/colleagues
    opened by kevinlinxc 2
  • How to use set var and get var?

    How to use set var and get var?

    I can't find documentation for how to use the script variables.

    I would expect to use the set var block and then the get var block and for them to be linked, but even after executing input 0 of the set var block nothing happens. Creating a variable first in the variables panel seems to do something, but I can't recreate it successfully.

    What is the correct way to use variables?

    opened by kevinlinxc 0
  • Pypi release for arg parser?

    Pypi release for arg parser?

    It seems like there are lot of nice features introduced with the arg parser which is now in the dev branch. Will these be released to Pypi? Do you need help with anything?

    opened by kevinlinxc 1
  • Customize starting layout?

    Customize starting layout?

    I have some things I want to do with the layout, but would prefer not to split off a new fork, so i'm wondering if I could change it programatically somehow.

    For example:

    1. Start the app in fullscreen
    2. Pull the nodes tab all the way up and hide scripts
    3. Pull up source code/logs, but hide the logs so source code is more visible
    4. Hide the right pane with settings and variables
    opened by kevinlinxc 0
Releases(v3.1.0)
  • v3.1.0(Dec 7, 2021)

    This release brings mainly large architectural changes. Ryven is at this point more a platform than just an application. See also the new README for additional info about current state.

    main changes

    • Ryven is now a Python package on PyPI, the repository got restructured and cleaned accordingly (big thanks @mmorys)
    • ryvencore is now a fully independent library and has its own repository here
    • removed macros (see below)

    removing native macro support for now

    While the alpha release of Ryven 3 had native support for macros (/subgraphs/whatever you might call them), I decided to remove them, for the following reasons:

    • Ryven should be thought of rather as a platform which you use to build frameworks of node packages on top. Natively supporting macros, however, significantly complicates the development of all nodes that perform slightly more involved (but not necessarily unreasonable) actions (like analysing the graph), while many node packages might not really require macro support at all.
    • Furthermore, the concept or semantic specification of macros is not obvious, many different approaches might seem reasonable. For example: whenever a macro node instance received data on some input, should all data currently residing on inputs of that instance be propagated into the subgraph? In which order? How can this be done efficiently? How should data propagation work for macros with exec I/O? The answers to those questions strongly depend on the use case.
    • Also, abstraction functionality like macros provided it can totally be implemented purely based on Ryven's nodes system (meaning you can build node packages implementing this functionality). It often makes much more sense to apply this functionality only in an environment (nodes package/s) where a general abstraction system is already defined (for example, a system generating a source code from a graph, see also this example), which will answer all questions including the above for that environment. Then, nodes in that environment can be built with the implemented macro mechanics in mind.

    So, I'm not really 'removing' possibilities here, but I think it makes more sense to focus on the nodes for the particular use case and design the system on that level accordingly. I might publish macros with configuration options as nodes package at some point, but it doesn't need to be part of Ryven itself.

    translating your v3.0-alpha nodes and projects

    To bring your v3.0-alpha node packages to v3.1

    • change from NENV import .../from NWENV import ... to from ryven.NENV import .../from ryven.NWENV import ...
    • change the signature of Node.set_state from def set_state(self, data: dict): to def set_state(self, data: dict, version):
      • add static version fields with values like 'v0.0.1' to your nodes. the version parameter in set_state will reflect the node version under which the loaded node was saved (None if not set), so you can use it to provide backwards compatibility and translate older versions of nodes to new ones to ensure old projects can be loaded

    To bring your v3.0-alpha projects to v3.1

    • load the project in Ryven 3.1 (it should then run a function on it that turns macro scripts into normal scripts and removes all macro nodes from flows) and save it again
    Source code(tar.gz)
    Source code(zip)
  • v3.0.0-alpha(Jun 7, 2021)

    Complete Ryven remake Over the past 6 monts I've been abstracting away underlying frameworks reimplementing the core functionality of the software which led to a complete remake of Ryven itself. Ryven 3 is a completely new software (no backwards compatibility to Ryven 2).

    Most important change regarding Ryven is the new packages system. The NodeManager has been removed completely, the new nodes system is very different, much simpler and more scalable. Ryven 3 includes small exmaple projects and some default nodes. The new website now has a complete guide.

    The underlying frameworks are ryvencore (backend) and ryvencore-qt (frontend), the repository is here. ryvencore and ryvencore-qt are completely separated, which brings a whole lot of improvements, see ryvencore-qt and the website for more details.

    Source code(tar.gz)
    Source code(zip)
  • v2.4.2(Nov 22, 2020)

    Ryven Console is now "officially" supported. Once you created a flow in Ryven, if all nodes you used are compatible with Ryven Console (meaning they run without their GUI/widgets), you can then run the flow in Ryven Console, without any GUI. This way you can run intensive data processing tasks with much higher performance. Further changes:

    • New inheritance system for widgets: Widget classes should derive from fixed base classes from now on (I updated existing nodes and the template files). This makes them safer and the source code files cleaner (as you don't have to implement all possible methods, they are pre-defined in the base classes).
    • requirements: I added a requirements.txt file for all libraries to run Ryven and the example projects, so it's also convenient to set up a virtual environment now.
    Source code(tar.gz)
    Source code(zip)
  • v2.4.1(Nov 5, 2020)

    Ryven now includes a complete integrated python interpreter.

    • It is a fully functional REPL so you can do anything you would do in the normal python console
    • You can add references to individual nodes, by right-click operation, to access their full API in the console
    • All print() calls, exceptions, and debugging messages are automatically redirected to this console

    This is going to be one of the major features in the future, the possibilities are endless.

    Source code(tar.gz)
    Source code(zip)
  • v2.4.0(Oct 27, 2020)

    Some major additions and improvements, besides better examples/nodes. In particular:

    • new linalg package containing nodes representing most basic matrix operations with nice interface
    • two new designs
    • heavy improvements in the appearance of source code files, which makes programming nodes much cleaner
    • new variable update system: you can now create connections between script variables and methods, so that every time the variable changes, the connected method gets called - which enables much more responsive components that automatically adapt to change of data
    • a matplotlib example node
    • new internal design management system, it's easier now to create new designs, so there might be a few incoming
    • passive mode for set var node
    • and a long list of small fixes and improvements
    Source code(tar.gz)
    Source code(zip)
  • v2.3.1(Sep 26, 2020)

    The release also includes a prototype for a new tool (currently referred to as Ryven Console) to run a Ryven flow on the console, completely without GUI dependencies, with much higher performance which might become important for larger performance-intensive data processing tasks.

    Source code(tar.gz)
    Source code(zip)
  • v2.3.0(Aug 8, 2020)

    One major internal change: the default imports in custom NodeInstances and their widgets aren't done manually anymore. There are now two env files that automatically import all requirements when Ryven is running. This is much better as it ensures that the import list is always up to date. I updated all existing nodes' imports.

    Source code(tar.gz)
    Source code(zip)
  • v2.2.3(Aug 1, 2020)

    They work for data as well as execution connections. In exec mode, they also serve as sequence nodes, so you can dynamically add exec outputs that get executed from top to bottom sequentially.

    Source code(tar.gz)
    Source code(zip)
  • v2.2.2(Jul 31, 2020)

    Using a new viewport update mode feature you can now make a flow update the views of nodes when they get updated, even if the flow isn't fully finished with the current execution. That's really useful for larger pure data flows doing data processing (like in the OpenCV example, try it there). Furthermore, Flows now have their own settings which get saved and loaded to and from project files to choose an algorithm mode and the new viewport update mode. Also, I added a small 'bubble sort' example and some basic nodes (there are still quite a few missing, though).

    Source code(tar.gz)
    Source code(zip)
  • v2.2.1(Jul 27, 2020)

    • Ryven has now a Blender design!
    • I updated a few internal signatures like the remove_event() method in NodeInstances and widgets
    • I changed the way custom input widgets are specified (no widget_type argument anymore)
    • I fixed some nodes and widgets and added standard line edits including self resizing ones
    • I changed the widgets of a few nodes now using resizing and or borderless line edits which looks way nicer
    • I moved the package_path for widgets outside of their class (useful for imports of custom classes etc.)
    • there is a new Extract Property node which is really useful, an example is included in the examples project
    • and I changed the file extensions to .rpo for projects and .rpc for packages
    Source code(tar.gz)
    Source code(zip)
  • v2.2.0(Jul 14, 2020)

    Ryven finally supports simple node activation animations. Every time a node updates, it starts an animation, making it easy to see what's going on in the flow. They can be disabled. Furthermore, I updated some new designs and themes. In pretty mode nodes have now shadows.

    Internal changes I furtherly distributed the NodeInstance related classes. I extracted the whole painting process and put it in a separate class NodeInstancePainter. Also, animations are handled by a separate class.

    Source code(tar.gz)
    Source code(zip)
  • v2.1.2(Jul 10, 2020)

    Besides a lot of fine grinding (like adding shortcuts and stuff like that), I slightly changed the method reference retaining mechanism, now using a callable class M instead of the m() function (I updated the template files and existing nodes). Furthermore, the existing packages experienced a code revision, I updated many of the notations.

    Further changes

    • I fixed some problems with special_actions
    • I finally fixed the layout issues with NodeInstances when adding/removing/changing content. It still needs to rebuild the layout though, but update_shape() calls are not necessary anymore
    • I fixed a copy-paste-move undo/redo bug
    • I fixed a lot of nodes and updated notations in their source codes
    • I fixed a source code update check issue in the NodeManager
    • I changed the setup_ports() procedure. Now a port gets initialized after the NodeInstance itself.
    • I added a target option to the Log node to access the default logs

    And, there is a website in the making.

    Source code(tar.gz)
    Source code(zip)
  • v2.1.1(Jul 3, 2020)

    A lot of fine grinding and small fixes, and I did a big rework of the NodeManager.

    NodeManager changes

    • I reorganized some internal processing and made it much cleaner
    • it also has source code dialogs now to directly edit the metacodes
    • it detects changes in the original source file while editing inside, warns the user, and lets him choose whether to override those or not
    • I updated the stylesheets, now using the same as Ryven
    • a lot of small adjustments, enhancements, and improvements to significantly support the workflow

    Ryven changes

    • added a function for using method references in metacode files to enable successful method editing in Ryven
    • changed the source code editing info dialog
    • fixed a package bug in the val node
    • added an API method for NodeInstance to provide direct access to the window's stylesheet
    • changed the structure of saved points in DrawingObjects (Ryven can still load projects using the old signature though)
    Source code(tar.gz)
    Source code(zip)
  • v2.1.0(Jun 30, 2020)

    Besides reviewing the source code of nodes (NodeInstances) and their widgets inside Ryven, it is now also possible to actually edit a specific object's methods. More specifically:

    • Existing methods can be customized (e.g. for debugging) and further methods can be added. (Note that changing a method actually means relinking the method call to a different method and references linked to the original method still point to the original one, not the customized one. I am looking for a way to change that but I am not entirely sure if that is possible.)
    • All these changes apply to single instances instead of all objects of the same class.
    • What can be written manually in Ryven is equal to what can be parsed in the metacode files (the same module environment is being simulated), so all in the object's metacode file additionally added classes, for example, can still be accessed.
    • All this is accessible through an intuitive GUI in the source code preview area.
    • All changes are temporary, they do not get saved with the project, so nothing can sustainably be broken. There is also a reset option for every customized class.

    This is kinda ridiculous, I didn't think this was actually possible and so unlimited. And considering how unexpectedly useful the pure source code preview became, I am really excited about it.

    edit: there is a crucial package bug in the new val node when saving/loading a project which will be fixed in the next release.

    Source code(tar.gz)
    Source code(zip)
  • v2.0(Jun 28, 2020)

    pyScript became Ryven I am very pleased to present the first Ryven release. Ryven is the result of a huge intern code revision (of what was referred to as pyScript before), reimplementing and reorganizing a lot of intern processing, making it much cleaner. Furthermore, Ryven includes many features that make learning and using it more efficient and fun. A new big example project shows the use of OpenCV nodes which represents a very interesting field of application.

    A few of the main improvements for the user:

    • handy source code preview
    • performance mode for flow editing (important for use on weaker hardware like Raspberry Pi)
    • algorithm data synchronization modes (for advanced flow optimization, I will add that to the doc in the future)

    The main internal change is that the geometric organization of the contents of a NodeInstance now uses QGraphicsLayout - no ugly manual calculations anymore! And I reimplemented the whole selection process recently too, now using the built-in system by QGraphicsScene. Also, the undo/redo system was reimplemented recently, now using references and not relying on the complex index system anymore.

    This version runs pretty well and I can't wait to see what it is going to be used for in the future, I am really excited.

    Source code(tar.gz)
    Source code(zip)
  • v1.2(Jun 12, 2020)

    Added:

    • source code preview! You can now see the source code of a placed node inside the editor. A basic syntax highlighting works too. I will add the option to also show any node's widget classes in the future.
    • NodeInstance and OutputPin highlighting on mouse hover
    • direct data output value access on mouse hover (over the gate/pin)

    Reimplemented:

    • the whole selection procedure, now using the built-in system by QGraphicsScene and a std RubberBandSelection
    • undo/redo system which now does not rely on indices anymore but instead holds references to the actual objects. A removed object does not get recreated when undoing the remove anymore but the actual object just gets placed in the scene again which is pretty nice. (same for all flow commands)
    • Log enabling/disabling process, now working fine with the new undo/redo system

    And many small internal adjustments. The only big change left is the reimplementation of the geometric organization of a NodeInstance's contents via QGraphicsWidgets and QGraphicsLayouts. This will make the code much cleaner but isn't of the essence for the user.

    Source code(tar.gz)
    Source code(zip)
  • v1.1(Mar 30, 2020)

    I removed tokens. This enables slightly easier and more open programming of nodes. Along with that, I changed the algorithm executing the script, so that now data connections are always forward updated on change and not backward updated on request. This makes execution flows slower but pure data flows faster and simpler. I would like to create some live video and audio processing nodes in this version to show what it is capable of. The biggest issue is currently performance when combining dataflows with execution nodes.

    Source code(tar.gz)
    Source code(zip)
  • v1.0(Mar 26, 2020)

    First pre-release of this software! This is the prototype that can be seen in a demo YouTube video. It includes basic functionality including a system for dynamically creating and importing nodes and a mostly working flow execution algorithm.

    The next releases will be about improving the NodeManager and adding new content. The documentation will experience a lot of improvement too, I think.

    Source code(tar.gz)
    Source code(zip)
Owner
Leon Thomm
European undergrad CS student, hobby programmer, creator of Ryven, yay.
Leon Thomm
Visual Python is a GUI-based Python code generator, developed on the Jupyter Notebook environment as an extension.

Visual Python is a GUI-based Python code generator, developed on the Jupyter Notebook environment as an extension.

Visual Python 564 Jan 3, 2023
Lumen provides a framework for visual analytics, which allows users to build data-driven dashboards from a simple yaml specification

Lumen project provides a framework for visual analytics, which allows users to build data-driven dashboards from a simple yaml specification

HoloViz 120 Jan 4, 2023
Make visual music sheets for thatskygame (graphical representations of the Sky keyboard)

sky-python-music-sheet-maker This program lets you make visual music sheets for Sky: Children of the Light. It will ask you a few questions, and does

null 21 Aug 26, 2022
A small script written in Python3 that generates a visual representation of the Mandelbrot set.

Mandelbrot Set Generator A small script written in Python3 that generates a visual representation of the Mandelbrot set. Abstract The colors in the ou

null 1 Dec 28, 2021
This is a small program that prints a user friendly, visual representation, of your current bsp tree

bspcq, q for query A bspc analyzer (utility for bspwm) This is a small program that prints a user friendly, visual representation, of your current bsp

nedia 9 Apr 24, 2022
The visual framework is designed on the idea of module and implemented by mixin method

Visual Framework The visual framework is designed on the idea of module and implemented by mixin method. Its biggest feature is the mixins module whic

LEFTeyes 9 Sep 19, 2022
a plottling library for python, based on D3

Hello August 2013 Hello! Maybe you're looking for a nice Python interface to build interactive, javascript based plots that look as nice as all those

Mike Dewar 1.4k Dec 28, 2022
MPL Plotter is a Matplotlib based Python plotting library built with the goal of delivering publication-quality plots concisely.

MPL Plotter is a Matplotlib based Python plotting library built with the goal of delivering publication-quality plots concisely.

Antonio López Rivera 162 Nov 11, 2022
A python script editor for napari based on PyQode.

napari-script-editor A python script editor for napari based on PyQode. This napari plugin was generated with Cookiecutter using with @napari's cookie

Robert Haase 9 Sep 20, 2022
A Python-based non-fungible token (NFT) generator built using Samilla and Matplotlib

PyNFT A Pythonic NF (non-fungible token) generator built using Samilla and Matplotlib Use python pynft.py [amount] The intention behind this generato

Ayush Gundawar 6 Feb 7, 2022
An interactive GUI for WhiteboxTools in a Jupyter-based environment

whiteboxgui An interactive GUI for WhiteboxTools in a Jupyter-based environment GitHub repo: https://github.com/giswqs/whiteboxgui Documentation: http

Qiusheng Wu 105 Dec 15, 2022
Turn a STAC catalog into a dask-based xarray

StackSTAC Turn a list of STAC items into a 4D xarray DataArray (dims: time, band, y, x), including reprojection to a common grid. The array is a lazy

Gabe Joseph 148 Dec 19, 2022
A simple script that displays pixel-based animation on GitHub Activity

GitHub Activity Animator This project contains a simple Javascript snippet that produces an animation on your GitHub activity tracker. The project als

null 16 Nov 15, 2021
cqMore is a CadQuery plugin based on CadQuery 2.1.

cqMore (under construction) cqMore is a CadQuery plugin based on CadQuery 2.1. Installation Please use conda to install CadQuery and its dependencies

Justin Lin 36 Dec 21, 2022
The implementation of the paper "HIST: A Graph-based Framework for Stock Trend Forecasting via Mining Concept-Oriented Shared Information".

The HIST framework for stock trend forecasting The implementation of the paper "HIST: A Graph-based Framework for Stock Trend Forecasting via Mining C

Wentao Xu 111 Jan 3, 2023
A customized interface for single cell track visualisation based on pcnaDeep and napari.

pcnaDeep-napari A customized interface for single cell track visualisation based on pcnaDeep and napari. ?? Under construction You can get test image

ChanLab 2 Nov 7, 2021
The Metabolomics Integrator (MINT) is a post-processing tool for liquid chromatography-mass spectrometry (LCMS) based metabolomics.

MINT (Metabolomics Integrator) The Metabolomics Integrator (MINT) is a post-processing tool for liquid chromatography-mass spectrometry (LCMS) based m

Sören Wacker 0 May 4, 2022
Custom Plotly Dash components based on Mantine React Components library

Dash Mantine Components Dash Mantine Components is a Dash component library based on Mantine React Components Library. It makes it easier to create go

Snehil Vijay 239 Jan 8, 2023
Fast visualization of radar_scenes based on oleschum/radar_scenes

RadarScenes Tools About This python package provides fast visualization for the RadarScenes dataset. The Open GL based visualizer is smoother than ole

Henrik Söderlund 2 Dec 9, 2021