Ryven
v3.5.0
Dieses Projekt erhält keine wesentlichen Aktualisierungen und ich werde in Zukunft nur begrenzte Zeit dafür haben. Mit der neuesten Version ist das Projekt genau das geworden, was ich mir vorgestellt habe: ein einfacher und flexibler Editor und ein Framework zum Erkunden von Anwendungsfällen für flussbasiertes visuelles Scripting in Python. Wenn Sie Fragen oder weitere Ideen haben, können Sie gerne Issues eröffnen oder das Projekt teilen und es selbst ausprobieren.
Ryven ist ein experimenteller Knoteneditor, der in Python geschrieben ist. Es implementiert eine Qt-basierte visuelle Schnittstelle für flussbasiertes visuelles Scripting in Python. Es bietet ein leistungsstarkes System zum Entwickeln von Knoten, die beliebigen Python-Code ausführen, sowie einen Editor zum Erstellen von Diagrammen mithilfe dieser Knoten. Ryven bietet eine Reihe von Konfigurationsoptionen und einen Headless-Modus zum Ausführen von Diagrammen ohne GUI. Einige relevante GitHub-Repos:
Die ryvencore-qt Bibliothek fügt Qt-basierte GUI-Klassen für ryvencore ( ./ryvencore-qt/ ) hinzu und der Ryven-Editor fügt sie zu einer voll ausgestatteten plattformübergreifenden Anwendung ( ./ryven-editor/ ) zusammen.
Sobald Sie Python und Pip installiert haben, ist Ryven auf PyPI über verfügbar
pip install ryven
Es gibt auch ein Conda-Forge-Paket ( conda install -c conda-forge ryven ).
Ryven kann über die Befehlszeile durch Eingabe von ryven gestartet werden. Wenn Sie Ryven in einer virtuellen Python-Umgebung (oder einer Conda-Umgebung) installiert haben, muss die Umgebung zuerst aktiviert werden.
Ryven selbst enthält nur einige kleine Beispielknoten. Sie sollten Ryven entweder zum Entwickeln von Knoten verwenden oder ein Knotenpaket eines Drittanbieters für Ihren Anwendungsfall verwenden, falls vorhanden. Die Beispielknoten sind tatsächlich nur Beispiele und in keiner Weise stabil, Sie sollten sich also nicht auf sie verlassen.
Nach der Installation erstellt ryven in Ihrem Benutzer-Home ein Verzeichnis ~/.ryven/ mit der folgenden Struktur:
~/.ryven
├── nodes
│ ├── your_nodes_pkg_1
│ ├── nodes.py
│ └── gui.py
│ └── ...
├── saves
│ ├── your_project_1.json
│ └── ...
└── ryven.cfg
Die Datei ryven.cfg enthält globale Konfigurationen für Ryven.
Ryven kann auf vier Arten konfiguriert werden:
ryven --nodes your_nodes_pkg_1 --no-animations~/.ryven/ryven.cfg : nodes = your_nodes_pkg_1 no_animations = True
import ryven ryven . run_ryven ( nodes = [ 'your_nodes_pkg_1' ], no_animations = True )
Geben Sie ryven --help ein, um eine Liste der verfügbaren Optionen anzuzeigen.
Um ein Ryven-Projekt kopflos (ohne GUI) bereitzustellen, verwenden Sie den Befehl ryven-console .
> ryven-console /home/leon/.ryven/saves/basics.json
Welcome to the Ryven Console ! Your project has been loaded.
You can access the ryvencore session by typing ` session ` .
For more information, visit https://leon-thomm.github.io/ryvencore/
>>> f = session.flows[0]
>>> ctr_var_result_node = f.nodes[2]
>>> ctr_set_var_node = f.nodes[8]
>>> ctr_var_result_node.val
3738
>>> ctr_set_var_node.update(0)
>>> ctr_var_result_node.val
3739ryven über die Befehlszeile ausführenFile -> Import Example Nodes und wählen Sie <installation_dir>/example_nodes/std/nodes.pyval -Knoten in die Szene+ -Knotenresult anzeigenctrl + scroll Ein Ryven-Knotenpaket ist einfach ein typisches Python-Paket, das mindestens eine nodes.py Datei enthält und die Ryven-Knoten-API aufruft, um Knotendefinitionen verfügbar zu machen.
Navigieren Sie zu ~/.ryven/nodes/ und erstellen Sie ein Unterverzeichnis mit der folgenden Struktur
~/.ryven/nodes
└── your_nodes_pkg_1
├── __init__.py
├── nodes.py
└── gui.py
mit folgendem Inhalt:
nodes.py :
from ryven . node_env import *
# your node definitions go here
export_nodes ([
# list your node classes here
])
@ on_gui_load
def load_gui ():
# import gui sources here only
from . import gui und gui.py :
from ryven . gui_env import *
from . import nodes
# your node gui definitions go hereSie können nun mit der Definition Ihrer eigenen Knoten beginnen. Definieren wir zwei grundlegende Knoten. Eines, das Zufallszahlen generiert ...
from random import random
class RandNode ( Node ):
"""Generates scaled random float values"""
title = 'Rand'
tags = [ 'random' , 'numbers' ]
init_inputs = [ NodeInputType ()]
init_outputs = [ NodeOutputType ()]
def update_event ( self , inp = - 1 ):
self . set_output_val ( 0 ,
Data ( random () * self . input ( 0 ). payload )
)...und noch einer, der sie druckt
class PrintNode ( Node ):
title = 'Print'
init_inputs = [ NodeInputType ()]
def update_event ( self , inp = - 1 ):
print ( self . input ( 0 ))und sie Ryven aussetzen
export_nodes ([
RandNode ,
PrintNode ,
]) Das ist es! Sie können Ihr Knotenpaket in Ryven importieren ( File -> Import Nodes ), die Knoten im Diagramm platzieren und sie vernetzen. Fügen Sie einen val -Knoten hinzu und verbinden Sie ihn mit dem Rand -Knoten, um dessen Eingabe mit Daten zu versorgen. Wenn Sie eine Zahl in das Widget des val -Knotens eingeben und die Eingabetaste drücken, wird die Zahl an den Rand Knoten gesendet, der eine skalierte Zufallszahl an den Print Knoten sendet, der sie auf der Standardausgabe ausgibt.
Beachten Sie, dass die Standardausgabe standardmäßig die In-Editor-Konsole ist, auf die Sie ganz unten im Editorfenster zugreifen können (ziehen Sie den blauen Griff nach oben, um ihn sichtbar zu machen).
Sie können Ihre Knoten jetzt mit einer grafischen Benutzeroberfläche aufpeppen. Ryven läuft auf Qt und verwendet entweder PySide2 oder PySide6 (über die qtpy-Bibliothek). Sie können die GUI Ihrer Knoten in einer separaten Datei konfigurieren und benutzerdefinierte Qt-Widgets zu Ihren Knoten hinzufügen. Achten Sie darauf, die Knotenlogik immer klar von den GUI-Komponenten zu trennen. Eine der zentralen Funktionen von Ryven ist die kopflose Ausführung von Projekten (auf Ryvencore) ohne GUI-Abhängigkeiten. Damit dies funktioniert, sollten Ihre nodes.py -Dateien niemals direkt von Qt abhängen. Stattdessen können Sie wie unten gezeigt eine benutzerdefinierte GUI aus den GUI-Dateien an Ihre Knoten anhängen.
Geben wir ihnen etwas Farbe und fügen wir einen Schieberegler zum Rand Knoten in gui.py hinzu:
from qtpy . QtWidgets import QSlider
from qtpy . QtCore import Qt
from ryven . gui_env import *
from . import nodes
class RandSliderWidget ( NodeInputWidget , QSlider ):
"""a standard Qt slider widget, which updates the node
input it is attached to, every time the slider value changes"""
def __init__ ( self , params ):
NodeInputWidget . __init__ ( self , params )
QSlider . __init__ ( self )
self . setOrientation ( Qt . Horizontal )
self . setMinimumWidth ( 100 )
self . setMinimum ( 0 )
self . setMaximum ( 100 )
self . setValue ( 50 )
self . valueChanged . connect ( self . value_changed )
def value_changed ( self , val ):
# updates the node input this widget is attached to
self . update_node_input ( Data ( val ))
def get_state ( self ) -> dict :
# return the state of the widget
return { 'value' : self . value ()}
def set_state ( self , state : dict ):
# set the state of the widget
self . setValue ( state [ 'value' ])
@ node_gui ( nodes . RandNode )
class RandNodeGui ( NodeGUI ):
color = '#fcba03'
# register the input widget class
input_widget_classes = { 'slider' : RandSliderWidget }
# attach the slider widget to the first node input
# display it _below_ the input pin
init_input_widgets = {
0 : { 'name' : 'slider' , 'pos' : 'below' }
} und das ist es! Ryven registriert nun RandNodeGui als „GUI-Klasse“ der RandNode -Klasse, die als Container für alle UI-Dinge dient. Sie können Ihren Knoten benutzerdefinierte primäre („Haupt“) Widgets hinzufügen, Widgets eingeben und das Aussehen der Knoten weiter anpassen.
Der von einem Eingabe-Widget (z. B. self.update_node_input(val) oben) bereitgestellte Wert wird im Knoten zurückgegeben, wenn input() aufgerufen wird (z. B. self.input(0) im RandNode ), jedoch nur, wenn die entsprechende Eingabe nicht vorhanden ist verbunden . Andernfalls wird der Wert des verbundenen Ausgangs zurückgegeben.
Weitere Ressourcen finden Sie auf der GitHub-Wiki-Seite in diesem Repository.
Sofern Sie nicht ausdrücklich etwas anderes angeben, unterliegt jeder Beitrag, der von Ihnen absichtlich zur Aufnahme in das Werk eingereicht wird, wie oben beschrieben, ohne zusätzliche Bedingungen oder Konditionen.
Beiträge werden sehr geschätzt. Dieses Projekt existiert nicht ohne die Open-Source-Community. Ich möchte insbesondere den in der Datei CREDITS.md aufgeführten Personen danken.
