Merge pull request #1 from jimkring/PySide2-to-PySide6-Upgrade

.gitignore

@@ -103,4 +103,10 @@ venv.bak/
 # mypy
 .mypy_cache/
 
-temp
+temp
+
+#vscode settings
+settings.json
+
+
+*_Project

.pre-commit-config.yaml

@@ -0,0 +1,40 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.6.0  # Use the ref you want to point at
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: check-yaml
+    -   id: check-added-large-files
+
+-   repo: https://github.com/psf/black
+    rev: 24.8.0
+    hooks:
+    -   id: black
+        args: [--line-length=120]
+
+-   repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.11.2
+    hooks:
+    -   id: mypy
+        args: [--strict, --ignore-missing-imports]
+
+-   repo: https://github.com/pycqa/flake8
+    rev: 7.1.1
+    hooks:
+    -   id: flake8
+        additional_dependencies: [flake8-typing-imports==1.12.0]
+        args: [--max-line-length=120]
+
+-   repo: https://github.com/asottile/reorder_python_imports
+    rev: v3.13.0
+    hooks:
+    -   id: reorder-python-imports
+        args: [--py37-plus, --add-import, 'from __future__ import annotations']
+
+-   repo: https://github.com/asottile/setup-cfg-fmt
+    rev: v2.5.0
+    hooks:
+    -   id: setup-cfg-fmt

Example_Project/Add_node.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Optional
+from typing import Tuple
+
+from node_editor.node import Node
+
+
+class Add_Node(Node):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.title_text: str = "Add"
+        self.type_text: str = "Logic Nodes"
+        self.set_color(title_color=(0, 128, 0))
+
+        self.add_pin(name="Ex In", is_output=False, execution=True)
+        self.add_pin(name="Ex Out", is_output=True, execution=True)
+
+        self.add_pin(name="input A", is_output=False)
+        self.add_pin(name="input B", is_output=False)
+        self.add_pin(name="output", is_output=True)
+        self.build()
+
+    def set_color(
+        self,
+        title_color: Tuple[int, int, int],
+        background_color: Optional[Tuple[int, int, int]] = None,
+    ) -> None:
+        super().set_color(title_color, background_color)
+
+    def add_pin(self, name: str, is_output: bool, execution: bool = False) -> None:
+        # Assuming add_pin is defined in the parent class
+        super().add_pin(name=name, is_output=is_output, execution=execution)
+
+    def build(self) -> None:
+        # Assuming build is defined in the parent class
+        super().build()

Example_Project/Button_node.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from PySide6 import QtWidgets
+
+from node_editor.node import Node
+
+
+class Button_Node(Node):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.title_text = "Button"
+        self.type_text = "Inputs"
+        self.set_color(title_color=(128, 0, 0))
+
+        self.add_pin(name="Ex Out", is_output=True, execution=True)
+
+        self.build()
+
+    def init_widget(self) -> None:
+        self.widget = QtWidgets.QWidget()
+        layout = QtWidgets.QVBoxLayout()
+        layout.setContentsMargins(0, 0, 0, 0)
+
+        btn = QtWidgets.QPushButton("Button test")
+        btn.clicked.connect(self.btn_cmd)
+        layout.addWidget(btn)
+        self.widget.setLayout(layout)
+
+        proxy = QtWidgets.QGraphicsProxyWidget()
+        proxy.setWidget(self.widget)
+        proxy.setParentItem(self)
+
+        super().init_widget()
+
+    def btn_cmd(self) -> None:
+        print("btn command")
+        self.execute()

Example_Project/Print_node.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Optional
+from typing import Tuple
+
+from node_editor.node import Node
+
+
+class Print_Node(Node):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.title_text: str = "Print"
+        self.type_text: str = "Debug Nodes"
+        self.set_color(title_color=(160, 32, 240))
+
+        self.add_pin(name="Ex In", is_output=False, execution=True)
+
+        self.add_pin(name="input", is_output=False)
+        self.build()
+
+    def set_color(
+        self,
+        title_color: Tuple[int, int, int],
+        background_color: Optional[Tuple[int, int, int]] = None,
+    ) -> None:
+        super().set_color(title_color, background_color)
+
+    def add_pin(self, name: str, is_output: bool, execution: bool = False) -> None:
+        # Assuming add_pin is defined in the parent class
+        super().add_pin(name=name, is_output=is_output, execution=execution)
+
+    def build(self) -> None:
+        # Assuming build is defined in the parent class
+        super().build()

Example_Project/Scaler_node.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from PySide6 import QtWidgets
+
+from Example_Project.common_widgets import FloatLineEdit
+from node_editor.node import Node
+
+
+class Scaler_Node(Node):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.title_text = "Scaler"
+        self.type_text = "Constants"
+        self.set_color(title_color=(255, 165, 0))
+
+        self.add_pin(name="value", is_output=True)
+
+        self.build()
+
+    def init_widget(self) -> None:
+        self.widget = QtWidgets.QWidget()
+        self.widget.setFixedWidth(100)
+        layout = QtWidgets.QVBoxLayout()
+        layout.setContentsMargins(0, 0, 0, 0)
+        self.scaler_line = FloatLineEdit()
+        layout.addWidget(self.scaler_line)
+        self.widget.setLayout(layout)
+
+        proxy = QtWidgets.QGraphicsProxyWidget()
+        proxy.setWidget(self.widget)
+        proxy.setParentItem(self)
+
+        super().init_widget()

Example_Project/common_widgets.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Optional
+from typing import Tuple
+
+from PySide6 import QtGui
+from PySide6 import QtWidgets
+from PySide6.QtCore import Qt
+
+
+class FloatLineEdit(QtWidgets.QLineEdit):  # type: ignore
+    def __init__(self, parent: Optional[QtWidgets.QWidget] = None) -> None:
+        super().__init__(parent)
+        self.setValidator(FloatValidator())
+
+    def keyPressEvent(self, event: QtGui.QKeyEvent) -> None:
+        if event.key() == Qt.Key_Space:
+            event.ignore()
+        else:
+            super().keyPressEvent(event)
+
+
+class FloatValidator(QtGui.QDoubleValidator):  # type: ignore
+    def __init__(self, parent: Optional[QtGui.QObject] = None) -> None:
+        super().__init__(parent)
+
+    def validate(self, input_str: str, pos: int) -> Tuple[QtGui.QValidator.State, str, int]:
+        state, num, pos = super().validate(input_str, pos)
+        if state == QtGui.QValidator.Acceptable:
+            return QtGui.QValidator.Acceptable, num, pos
+        if str(num).count(".") > 1:
+            return QtGui.QValidator.Invalid, num, pos
+        if input_str[pos - 1] == ".":
+            return QtGui.QValidator.Acceptable, num, pos
+        return QtGui.QValidator.Invalid, num, pos

Example_Project/test.json

@@ -0,0 +1,66 @@
+{
+    "nodes": [
+        {
+            "type": "Scaler_Node",
+            "x": 4765,
+            "y": 5098,
+            "index": "4"
+        },
+        {
+            "type": "Scaler_Node",
+            "x": 4752,
+            "y": 5000,
+            "index": "3"
+        },
+        {
+            "type": "Print_Node",
+            "x": 5121,
+            "y": 4905,
+            "index": "2"
+        },
+        {
+            "type": "Button_Node",
+            "x": 4777,
+            "y": 4894,
+            "index": "1"
+        },
+        {
+            "type": "Add_Node",
+            "x": 4971,
+            "y": 4955,
+            "index": "0"
+        }
+    ],
+    "connections": [
+        {
+            "start_id": "4",
+            "end_id": "0",
+            "start_pin": "value",
+            "end_pin": "input B"
+        },
+        {
+            "start_id": "3",
+            "end_id": "0",
+            "start_pin": "value",
+            "end_pin": "input A"
+        },
+        {
+            "start_id": "0",
+            "end_id": "2",
+            "start_pin": "output",
+            "end_pin": "input"
+        },
+        {
+            "start_id": "0",
+            "end_id": "2",
+            "start_pin": "Ex Out",
+            "end_pin": "Ex In"
+        },
+        {
+            "start_id": "1",
+            "end_id": "0",
+            "start_pin": "Ex Out",
+            "end_pin": "Ex In"
+        }
+    ]
+}

README.md

@@ -1,7 +1,29 @@
-# Logic Node Editor
+# Python Node Editor
 
-A very basic minimal code for implementing a node graph or editor using PySide2. In this case we are building with logic nodes. All nodes are built using QGraphics items.
+This is a node based Python tool used for visual scripting that is designed to be used for composing high level Python code into reusable blocks. Nodes look and function similar to Unreal Engine blueprints. Each node consists of connection pins and a widget section enabling the developer to write a full custom PySide GUI for each node type.
 
-Example video: https://www.youtube.com/watch?v=DOsFJ8lm9dU
+The tool is designed to allow you to write Python code in individual files per class/node. This means that your code is self-contained, easily modifiable, and reusable across multiple projects. Additionally, the GUI is designed to be familiar to those who have used Unreal Engine's blueprinting system, making it easy to learn and use.
 
-![nodes](https://github.com/bhowiebkr/simple-node-editor/blob/master/images/node_editor.jpg)
+My goal with this project is to provide a new and innovative way of organizing and working with Python code. While the tool is still in the development phase, I am constantly working to improve its functionality and features.
+
+Visual scripting using nodes does have some benefits and drawbacks and it’s up to the end developer to decide when such a system is beneficial or not.
+
+![nodes](https://github.com/bhowiebkr/simple-node-editor/blob/master/images/node_editor2.jpg)
+
+Use it for:
+- high level composing/configurable code.  If a given system consists of many similar components but have a unique set of steps or requirements on similar tasks. Example a VFX or game pipeline.
+- readability for non programmers as a dependency graph with built-in functionality
+- enabling non-programmers a simple system to assemble blocks of logic
+- networks that require a high level of feedback throughout that network and not just the end result. Example shader building, sound synthesizing, machine learning, robotics and sensors. Each node can have a custom visual feedback such as images, graphs, sound timelines, spreadsheets etc.
+- prototyping logic.
+- Generator scripts. Taking an input or building up a result that gets saved for other uses. Example textures, images, sound, ML training data.
+
+Don’t use it for
+- Anything complex. 40 nodes or less. This is because the user not only needs to think of how nodes are logically connected, but also the visual composure of nodes in the graph. It’s always best to refactor code when a graph gets too complex to make sense of.
+- code that needs to run fast. The overhead of node based tools will increase processing in almost all cases.
+- Code that doesn’t need a GUI/human interface to use.
+
+For minimal GUI code for creating a node network see [GUI-nodes-only](https://github.com/bhowiebkr/simple-node-editor/tree/GUI-nodes-only) branch.
+
+
+[![Video](http://img.youtube.com/vi/DOsFJ8lm9dU/0.jpg)](http://www.youtube.com/watch?v=DOsFJ8lm9dU)

launch.bat

@@ -0,0 +1,7 @@
+@echo off
+
+:: Activate the virtual environment
+call venv\Scripts\activate
+
+:: Start the three Python programs in separate command windows
+start cmd /k python .\main.py