nodeeditor-qtpy 0.8.1__tar.gz

nodeeditor_qtpy-0.8.1/CHANGES.md

@@ -0,0 +1,31 @@
+Changelog (PyNodeEditor)
+========================
+
+0.9.6
+-----
+
+- QDMGraphicsEdgeDirect and QDMGraphicsEdgeBezier no longer derive from QDMGraphicsEdge
+- QDMGraphicsEdge is now always used to represent graphics edge, and internaly got stored an instance of GraphicsEdgePathBase
+- logic of calculating Direct and Bezier edges has moved to node_graphics_edge_path.py file into respective classes GraphicsEdgePathDirect and GraphicsEdgePathBezier
+- possibility for NodeEditorWidget to override QDMGraphicsView class by setting `GraphicsView_class` class variable
+
+0.9.5
+-----
+
+- fixed panning issue when drag edge caused by DragEdge being selectable edge
+
+0.9.4
+-----
+
+- improvements to selection and edges
+
+0.9.3
+-----
+
+- improved deserialization even with selections now
+
+0.9.2
+-----
+
+- First polished and tested version of the library
+- After 54 tutorials: https://www.blenderfreak.com/tutorials/node-editor-tutorial-series/

nodeeditor_qtpy-0.8.1/HISTORY.rst

@@ -0,0 +1,249 @@
+History
+=======
+
+Release history for **qtpy-nodeeditor**.
+
+This file tracks releases of this project. For the pre-fork upstream
+`PyNodeEditor <https://github.com/benbyjones/PyQtNodeEditor>`_ lineage that
+this code started from, see `CHANGES.md <CHANGES.md>`_.
+
+0.8 - 2026-10-21
+----------------
+
+**Features**
+
+- Configurable socket shapes: nodes declare per-side, per-type socket shapes
+  through ``input_socket_shapes`` / ``output_socket_shapes`` (with an ``'*'``
+  wildcard, circle fallback), over a new ``nodeeditor.node_socket_shapes``
+  registry (`register_socket_shape`) with built-in ``circle``, ``square``,
+  ``triangle`` and ``chevron`` presets and support for custom point tuples,
+  shape classes, and drawing callbacks. Shape outlines double as hit areas, and
+  unknown names fall back to the circle instead of raising. Serialization is
+  unchanged.
+- Socket hover highlight: sockets now accept hover events and paint a highlight
+  when hovered, kept separate from the ``isHighlighted`` flag used for edge
+  snapping.
+- Per-element level-of-detail policy: the canvas' single "drop detail below the
+  zoom threshold" boolean became a policy map over the node's elements
+  (``content``, ``label``, ``sockets``), each ``always``, ``auto`` or ``never``
+  (`Scene.set_detail_policy`), with answers readable per element through
+  ``detail_enabled``. Applications can register and query elements of their own.
+- The level-of-detail threshold is a per-instance value
+  (``detail_lod_threshold``) instead of a class constant, so each scene can
+  move the point where it simplifies.
+- ``setDetailState`` broadcasts the resolved state to items; ``setDetailVisible``
+  stays for callers outside the scene with its old drop-everything meaning.
+
+**Performance**
+
+- Zoom-based detail switching and grid level culling for large graphs: a grid
+  level whose on-screen spacing falls under ``MIN_GRID_SPACING_PX`` is not
+  drawn, since it reads as a wash and costs time proportional to its line
+  count.
+
+**Docs**
+
+- Added ``docs/SOCKET_SHAPES.md`` with a usage guide, the
+  ``examples/example_socket_shapes.py`` demo (including a custom class and a
+  callback shape), and expanded ``docs/MULTI_INPUT_NODES.md``.
+
+**Tests**
+
+- Added ``tests/test_110_socket_shapes.py`` for shape registration, resolution,
+  hit areas, hover and serialization neutrality, and
+  ``tests/test_200_detail_policy.py`` for policy resolution, broadcasting and
+  threshold overrides.
+
+0.7 - 2026-09-29
+----------------
+
+**Features**
+
+- Added centralized color configuration for edges, sockets, and node hover
+  highlights, with scene helpers to refresh existing graphics items.
+- Added an interactive color configuration example with theme selection.
+
+**Fixes**
+
+- Preserve the existing socket type palette and transparent fallback when
+  applying color configuration, and restore node colors when resetting defaults.
+- Preserve upstream grouping behavior while applying color changes.
+- Renamed a case-colliding scene fixture for Windows compatibility.
+
+**Tests**
+
+- Added headless regression coverage for color updates, icon nodes, the color
+  demo, and group collapse/expand and serialization with node and edge labels.
+
+0.6 - 2026-09-27
+----------------
+
+**Features**
+
+- Added ``MultiInputNode``: a node whose input `Socket` accepts any number of
+  `Edges` and reads them in an explicit, persisted order. It defines no
+  ``__init__``, so it can be mixed into an existing node hierarchy without
+  changing its constructor chain. Every input socket is multi-edged by default;
+  set ``multi_input_socket`` with ``multi_input_all_inputs = False`` to make
+  only one socket do so.
+- Reading: ``getOrderedEdges``, ``getOrderedSources``, ``getOrderedValues``,
+  ``getOrderedNodes``, and ``describeInputOrder``. ``getOrderedValues`` returns
+  one entry per connected `Edge`, substituting ``None`` for a source that fails
+  to evaluate, so its length always matches the connection count.
+- Reordering: ``setEdgeOrder``, ``setEdgeOrderByNodes``, ``moveEdgeTo``,
+  ``moveEdgeBy`` (clamped at both ends), ``swapEdges``, ``reverseEdgeOrder``,
+  and ``compactEdgeOrder``. A partial order list is accepted; the remaining
+  `Edges` keep their relative order. Successful reorders mark the node and its
+  descendants dirty so they re-evaluate.
+- Order labels: when ``show_input_order_labels`` is ``True`` (the default), each
+  `Edge` on the ordered input is labeled ``#1``, ``#2``, ... Labels are kept in
+  sync on connection, reorder, and removal, and are cleared on detach only when
+  they still match the ``#N`` pattern, so a custom label set from code is never
+  destroyed. Set the flag to ``False`` to opt out.
+- ``Edge.input_index``: the 0-based read position of an `Edge` on its end
+  (input) `Socket`, settable at construction as ``Edge(..., input_index=n)`` to
+  insert at a slot instead of appending. Output sockets are never ordered and
+  reset the value to ``-1``.
+- ``Socket`` ordering API: ``addEdge`` accepts an ``index``, and
+  ``orderedEdges``, ``edgeIndex``, ``compactEdgeOrder``, ``setEdgeOrder``,
+  ``moveEdgeTo``, and ``swapEdges`` round out the set. The owning input `Socket`
+  keeps read positions gap free after every add and remove, so the order stays
+  compact through every connection path without per-path plumbing.
+- ``input_index`` is persisted by ``Edge.serialize()`` / ``deserialize()``.
+  Because the number travels on the `Edge`, the order survives save/load,
+  copy/paste, and undo/redo even when the file's ``"edges"`` array is shuffled.
+  Files written before this release load in connection order.
+- Calculator example: new ``Sum`` node (op code ``OP_NODE_SUM``), plus
+  *Reverse Input Order*, *Move First/Last Input to Last/First* in the node
+  context menu and *Move Input Earlier/Later* in the edge context menu. Each
+  action stores an undo-history entry. Menu entries are gated on the target
+  actually being a ``MultiInputNode`` with 2+ edges.
+
+**Fixes**
+
+- Rerouting an `Edge` onto a multi-edged input no longer drops the socket's
+  other `Edges`; each moved `Edge` lands at the read position it held on the
+  old socket. Single-edged inputs still replace, as before.
+
+**Docs and tests**
+
+- Added ``docs/MULTI_INPUT_NODES.md`` and the Sphinx page for
+  ``nodeeditor.node_multi_input_node``.
+- Added ``tests/test_100_multi_input.py`` covering read order, reordering,
+  label handling, and persistence.
+
+0.5 - 2026-09-27
+----------------
+
+**Features**
+
+- Node labels: added ``QDMGraphicsNodeLabel``, a floating single-line text box
+  that is editable by the user, integrated into both ``QDMGraphicsNode`` and
+  ``QDMIconGraphicsNode``. Supports styling, visibility, offset, and edit
+  handling.
+- Exposed the node label API on ``Node``: ``setNodeLabel``, ``getNodeLabel``,
+  ``clearNodeLabel``, ``setNodeLabelVisible``, ``isNodeLabelVisible``,
+  ``setNodeLabelOffset``, plus a ``labelChanged`` signal.
+- Edge labels: added a code-set, read-only label to ``QDMGraphicsEdge`` and
+  ``Edge``, constructible as ``Edge(..., label=...)`` and mutable through the
+  ``label`` property (``getLabel`` / ``setLabel``), with rendering and
+  bounding-box updates.
+- Node label ``label_text`` / ``label_visible`` / ``label_offset`` and edge
+  labels are persisted across ``serialize`` / ``deserialize``.
+- Added ``docs/NODE_LABELS.md`` and ``docs/EDGE_LABELS.md``.
+
+0.4 - 2026-09-26
+----------------
+
+**Features**
+
+- ``SceneHistory.restoring()``: nestable context manager backed by a
+  restore-depth counter, replacing the ``is_restoring_history`` flag. A callback
+  fired mid-restore can no longer re-enable history storage and record a bogus
+  stamp. ``is_restoring_history`` is retained as a property for legacy callers
+  that assign to it.
+- ``SceneHistory.storeHistory()`` gained ``merge_key`` and ``merge``, coalescing
+  consecutive related stores (for example a burst of keystrokes) into a single
+  undo step. Merging only happens at the tip of the stack, so a redo tail is
+  never rewritten.
+- ``history_limit`` is now an optional ``SceneHistory`` constructor argument;
+  ``None`` (the default) means unlimited. Previously hard-coded to 32.
+- ``storeHistory()`` now returns ``bool`` reporting whether a stamp was pushed.
+- Added ``SceneHistory.currentText()`` and ``nextText()`` for describing the
+  next undo/redo step, and ``removeHistoryModifiedListener()``.
+- Added ``Scene.undo()``, ``redo()``, ``canUndo()``, and ``canRedo()`` so
+  subclasses can layer an alternative undo backend. ``NodeEditorWindow`` now
+  routes Edit Undo/Redo through the ``Scene`` rather than calling
+  ``scene.history`` directly.
+
+**Fixes**
+
+- ``history_stamp_callback`` is resolved defensively via a dedicated dispatch
+  helper. A stamp whose node has since been deleted, or one whose content class
+  never implemented the callback, no longer aborts the restore. Exceptions
+  raised by the callback are logged instead of propagating.
+
+**Docs**
+
+- Rewrote ``docs/NODE_GROUPING.md`` as a complete usage guide: grouping API,
+  collapse/expand with per-edge stubs, appearance, serialization format,
+  selection model, the three distinct delete operations, and troubleshooting.
+
+0.3 - 2026-09-12
+----------------
+
+**Dependencies**
+
+- Pinned ``orjson>=3.12.0``.
+
+0.2 - 2026-09-11
+----------------
+
+**Features**
+
+- Node grouping, developed through a ``Group`` class refactor of the earlier
+  ``GroupNode`` container. ``Group`` is a pure visual container and
+  intentionally not a ``Node``: no sockets, no evaluation, no content widget.
+- Group actions for the Edit menu: group selected nodes, ungroup, and
+  collapse/expand, with keyboard shortcuts.
+- Drag-and-drop support for moving nodes into a group, with drop highlighting.
+- Group serialization, including collapse state, and saving/loading of
+  container expand/collapse.
+- Correct edge drawing and correct internal-edge handling for collapsed groups.
+- Hit-testing improvements: the expanded group body is click-through, and
+  header context-menu handling was refined.
+- ``Scene.addGroup`` / ``removeGroup`` / ``getGroupById`` /
+  ``findCollapsedGroupForNode`` / ``findGroupForDrop`` / ``dropNodesIntoGroup``
+  helpers, and a ``parent_group`` attribute on ``Node``.
+
+**Fixes**
+
+- Edge intersection logic now validates edges before modification, uses the
+  proper edge class, and notifies node connections on auto-splits.
+- Fixed a bug where internal edges of a group were removed on collapse.
+- More robust edge deserialization error handling, and a new
+  ``restoreExpandedVisuals`` method.
+
+**Project**
+
+- ``QDMNodeIconContentWidget`` accepts an optional ``parent`` argument.
+- Refactored child ID retrieval in ``Scene`` for readability.
+- Adopted ``uv`` for project and lock management.
+
+0.1.8 and earlier - 2025-01-28 to 2025-10-22
+--------------------------------------------
+
+Pre-grouping baseline. The project was imported from upstream at ``0.9.15``
+and renumbered from ``0.1.0``; ``pyproject.toml`` was introduced at ``0.1.0``
+on 2026-09-09.
+
+- Switched data transfer from node-based to socket-based, and the backing
+  format from ``json`` to ``orjson`` with a ``.tds`` file extension.
+- New undo/redo implementation, and shift+scroll to zoom horizontally.
+- Icon-based nodes, in the style of Alteryx / n8n, with enhanced icon handling
+  in the node UI and improved evaluation logging.
+- Type hints with ``mypy`` checks, and a ``py.typed`` marker.
+- Grid show/hide, and text inside sockets.
+- Edge-handling improvements: cancel with ``Esc`` or by clicking outside, and
+  alt+click on a socket to get the socket.
+- Fixed a bug where a rubber-band box was created when no item was created.

nodeeditor_qtpy-0.8.1/LICENCE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2019, Pavel Křupala
+Copyright (c) 2024-2026, Azad Kshitij
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

nodeeditor_qtpy-0.8.1/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: nodeeditor-qtpy
+Version: 0.8.1
+Summary: Framework for building node editors and graph UIs in Qt, independent of the Qt binding (PyQt5/PyQt6/PySide2/PySide6 via QtPy)
+Keywords: node editor,nodeeditor,node graph,graph,visual programming,qt,qtpy,pyqt6,pyside6
+Author: Azad Kshitij
+Author-email: Azad Kshitij <azadkshitij08302001@gmail.com>
+License-Expression: MIT
+License-File: LICENCE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Typing :: Typed
+Requires-Dist: orjson>=3.12.0
+Requires-Dist: qtpy>=2.4.3
+Requires-Dist: pyqt6>=6.0 ; extra == 'pyqt6'
+Requires-Dist: pyside6>=6.0 ; extra == 'pyside6'
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/AzadKshitij/qtpy-nodeeditor
+Project-URL: Repository, https://github.com/AzadKshitij/qtpy-nodeeditor.git
+Project-URL: Issues, https://github.com/AzadKshitij/qtpy-nodeeditor/issues
+Project-URL: Changelog, https://github.com/AzadKshitij/qtpy-nodeeditor/blob/master/HISTORY.rst
+Provides-Extra: pyqt6
+Provides-Extra: pyside6
+Description-Content-Type: text/markdown
+
+# nodeeditor-qtpy
+
+A node editor framework for Qt. Build interactive graph interfaces out of
+draggable nodes, connectable sockets and edges, with undo/redo, JSON
+serialization and support for your own evaluation logic.
+
+The distribution is called `nodeeditor-qtpy`; the import package is `nodeeditor`.
+The framework itself is binding-agnostic: it talks to Qt through
+[QtPy](https://github.com/spyder-ide/qtpy), so it runs on PyQt5, PySide2,
+PyQt6 and PySide6.
+
+![Calculator example](https://raw.githubusercontent.com/AzadKshitij/qtpy-nodeeditor/main/examples/calculator_ss_1.png)
+
+## Features
+
+- full framework for customizable nodes, sockets and edges
+- undo / redo and serialization into JSON files in a VCS friendly way
+- support for implementing evaluation logic
+- hovering effects, dragging edges, cutting lines, snapping and more
+- node groups, multi-input nodes, custom socket shapes and color schemes
+- ready-made examples you can copy from
+
+## Requirements
+
+- Python 3.10+
+- A Qt binding: PyQt6 or PySide6 (any Qt 5/6 binding QtPy supports works)
+
+## Installation
+
+From PyPI, including a Qt binding:
+
+```
+pip install nodeeditor-qtpy[pyqt6]
+```
+
+or, for PySide6:
+
+```
+pip install nodeeditor-qtpy[pyside6]
+```
+
+Without an extra, the package installs no binding and uses whichever
+PyQt5/PySide2/PyQt6/PySide6 you already have. When several are installed,
+QtPy picks one from the `QT_API` environment variable.
+
+Directly from source code to get the latest version:
+
+```
+pip install "nodeeditor-qtpy[pyqt6] @ git+https://github.com/AzadKshitij/qtpy-nodeeditor.git"
+```
+
+Or clone the repository:
+
+```
+git clone https://github.com/AzadKshitij/qtpy-nodeeditor.git
+```
+
+## Quick start
+
+A node is a `Node` belonging to a `Scene`. Give it sockets, then connect an
+output socket to an input socket with an `Edge`:
+
+```python
+import sys
+
+from qtpy.QtWidgets import QApplication
+
+from nodeeditor.node_editor_widget import NodeEditorWidget
+from nodeeditor.node_node import Node
+from nodeeditor.node_edge import Edge
+
+app = QApplication(sys.argv)
+
+editor = NodeEditorWidget()
+scene = editor.scene
+
+# a node with one output socket
+source = Node(scene, title="Value", outputs=[1], output_text=["out"])
+
+# a node with one input socket
+sink = Node(scene, title="Print", inputs=[1], input_text=["in"])
+
+# connect the output of the first node to the input of the second
+Edge(scene, source.outputs[0], sink.inputs[0])
+
+editor.show()
+sys.exit(app.exec())
+```
+
+`NodeEditorWidget` creates the `Scene` for you. Use `Scene` on its own when
+you want to drive the graph without a widget:
+
+```python
+from nodeeditor.node_scene import Scene
+from nodeeditor.node_node import Node
+
+scene = Scene()
+node = Node(scene, title="Value", outputs=[1], output_text=["out"])
+```
+
+The `inputs` and `outputs` lists hold socket types, and the matching
+`input_text` / `output_text` lists hold the labels drawn next to them. Both
+`Node` and `Edge` register themselves with the scene when created, so there is
+nothing to add by hand.
+
+## Import names
+
+```python
+from nodeeditor import NodeEditorColorScheme, get_socket_shape
+from nodeeditor.node_scene import Scene
+from nodeeditor.node_node import Node
+from nodeeditor.node_edge import Edge
+```
+
+## Credits
+
+This project is a fork of the original
+[PyQt Node Editor](https://gitlab.com/pavel.krupala/pyqt-node-editor) by
+[Pavel Křupala](https://gitlab.com/pavel.krupala), which is released under the
+MIT licence. The original author is credited in [LICENCE](LICENCE), and the
+history of the upstream project is kept in
+[CHANGES.md](CHANGES.md) and [HISTORY.rst](HISTORY.rst).
+
+## Links
+
+- [Documentation](https://azadkshitij.github.io/qtpy-nodeeditor/)
+- [Examples](https://github.com/AzadKshitij/qtpy-nodeeditor/tree/main/examples)
+- [Original project](https://gitlab.com/pavel.krupala/pyqt-node-editor)
+- [Contribute](https://github.com/AzadKshitij/qtpy-nodeeditor/blob/main/CONTRIBUTING.md)
+- [Issues](https://github.com/AzadKshitij/qtpy-nodeeditor/issues)
+- [Pull requests](https://github.com/AzadKshitij/qtpy-nodeeditor/pulls)
+- [Release history](https://github.com/AzadKshitij/qtpy-nodeeditor/blob/main/HISTORY.rst)
+- [Upstream changelog (pre-fork)](https://github.com/AzadKshitij/qtpy-nodeeditor/blob/main/CHANGES.md)

nodeeditor_qtpy-0.8.1/README.md

@@ -0,0 +1,133 @@
+# nodeeditor-qtpy
+
+A node editor framework for Qt. Build interactive graph interfaces out of
+draggable nodes, connectable sockets and edges, with undo/redo, JSON
+serialization and support for your own evaluation logic.
+
+The distribution is called `nodeeditor-qtpy`; the import package is `nodeeditor`.
+The framework itself is binding-agnostic: it talks to Qt through
+[QtPy](https://github.com/spyder-ide/qtpy), so it runs on PyQt5, PySide2,
+PyQt6 and PySide6.
+
+![Calculator example](https://raw.githubusercontent.com/AzadKshitij/qtpy-nodeeditor/main/examples/calculator_ss_1.png)
+
+## Features
+
+- full framework for customizable nodes, sockets and edges
+- undo / redo and serialization into JSON files in a VCS friendly way
+- support for implementing evaluation logic
+- hovering effects, dragging edges, cutting lines, snapping and more
+- node groups, multi-input nodes, custom socket shapes and color schemes
+- ready-made examples you can copy from
+
+## Requirements
+
+- Python 3.10+
+- A Qt binding: PyQt6 or PySide6 (any Qt 5/6 binding QtPy supports works)
+
+## Installation
+
+From PyPI, including a Qt binding:
+
+```
+pip install nodeeditor-qtpy[pyqt6]
+```
+
+or, for PySide6:
+
+```
+pip install nodeeditor-qtpy[pyside6]
+```
+
+Without an extra, the package installs no binding and uses whichever
+PyQt5/PySide2/PyQt6/PySide6 you already have. When several are installed,
+QtPy picks one from the `QT_API` environment variable.
+
+Directly from source code to get the latest version:
+
+```
+pip install "nodeeditor-qtpy[pyqt6] @ git+https://github.com/AzadKshitij/qtpy-nodeeditor.git"
+```
+
+Or clone the repository:
+
+```
+git clone https://github.com/AzadKshitij/qtpy-nodeeditor.git
+```
+
+## Quick start
+
+A node is a `Node` belonging to a `Scene`. Give it sockets, then connect an
+output socket to an input socket with an `Edge`:
+
+```python
+import sys
+
+from qtpy.QtWidgets import QApplication
+
+from nodeeditor.node_editor_widget import NodeEditorWidget
+from nodeeditor.node_node import Node
+from nodeeditor.node_edge import Edge
+
+app = QApplication(sys.argv)
+
+editor = NodeEditorWidget()
+scene = editor.scene
+
+# a node with one output socket
+source = Node(scene, title="Value", outputs=[1], output_text=["out"])
+
+# a node with one input socket
+sink = Node(scene, title="Print", inputs=[1], input_text=["in"])
+
+# connect the output of the first node to the input of the second
+Edge(scene, source.outputs[0], sink.inputs[0])
+
+editor.show()
+sys.exit(app.exec())
+```
+
+`NodeEditorWidget` creates the `Scene` for you. Use `Scene` on its own when
+you want to drive the graph without a widget:
+
+```python
+from nodeeditor.node_scene import Scene
+from nodeeditor.node_node import Node
+
+scene = Scene()
+node = Node(scene, title="Value", outputs=[1], output_text=["out"])
+```
+
+The `inputs` and `outputs` lists hold socket types, and the matching
+`input_text` / `output_text` lists hold the labels drawn next to them. Both
+`Node` and `Edge` register themselves with the scene when created, so there is
+nothing to add by hand.
+
+## Import names
+
+```python
+from nodeeditor import NodeEditorColorScheme, get_socket_shape
+from nodeeditor.node_scene import Scene
+from nodeeditor.node_node import Node
+from nodeeditor.node_edge import Edge
+```
+
+## Credits
+
+This project is a fork of the original
+[PyQt Node Editor](https://gitlab.com/pavel.krupala/pyqt-node-editor) by
+[Pavel Křupala](https://gitlab.com/pavel.krupala), which is released under the
+MIT licence. The original author is credited in [LICENCE](LICENCE), and the
+history of the upstream project is kept in
+[CHANGES.md](CHANGES.md) and [HISTORY.rst](HISTORY.rst).
+
+## Links
+
+- [Documentation](https://azadkshitij.github.io/qtpy-nodeeditor/)
+- [Examples](https://github.com/AzadKshitij/qtpy-nodeeditor/tree/main/examples)
+- [Original project](https://gitlab.com/pavel.krupala/pyqt-node-editor)
+- [Contribute](https://github.com/AzadKshitij/qtpy-nodeeditor/blob/main/CONTRIBUTING.md)
+- [Issues](https://github.com/AzadKshitij/qtpy-nodeeditor/issues)
+- [Pull requests](https://github.com/AzadKshitij/qtpy-nodeeditor/pulls)
+- [Release history](https://github.com/AzadKshitij/qtpy-nodeeditor/blob/main/HISTORY.rst)
+- [Upstream changelog (pre-fork)](https://github.com/AzadKshitij/qtpy-nodeeditor/blob/main/CHANGES.md)

nodeeditor_qtpy-0.8.1/docs/CONTRIBUTING.md

@@ -0,0 +1,89 @@
+# Documentation tooling
+
+The site is built with [MkDocs](https://www.mkdocs.org/) and the
+[Material for MkDocs](https://squidfunk.github.io/mkdocs-material/) theme.
+The API reference is generated from the source with
+[mkdocstrings](https://mkdocstrings.github.io/).
+
+## Requirements
+
+```
+pip install -r requirements_docs.txt
+```
+
+## Build locally
+
+```
+mkdocs serve
+```
+
+The site is then available at <http://127.0.0.1:8000/> and rebuilds on save.
+
+## Build once
+
+```
+mkdocs build --strict
+```
+
+`--strict` turns warnings into errors, which is what the CI workflow uses, so
+a broken link or a malformed docstring fails the build instead of shipping.
+
+## Layout
+
+```
+docs/
+  index.md          home page
+  installation.md   install options
+  quickstart.md     first graph
+  events.md         the event system
+  guides/           task-focused guides
+  api/              mkdocstrings pages, one per module group
+  images/           screenshots used by the guides
+```
+
+The `nav` section of `mkdocs.yml` decides the sidebar. Pages that exist but
+are not listed there are still built, they just do not show up in the
+navigation.
+
+## The images in the guides
+
+Every guide opens with a picture. The files live in `docs/images/`, and each
+one is referenced from the page listed below. To use your own screenshot
+instead, **replace the file with the same name** — no markdown needs editing.
+
+| File | Shows | Used by |
+| --- | --- | --- |
+| `docs/images/quickstart.png` | two connected nodes | `index.md`, `quickstart.md` |
+| `docs/images/socket-shapes.png` | circle, square, triangle and chevron sockets | `guides/socket-shapes.md` |
+| `docs/images/node-labels.png` | floating labels above nodes | `guides/node-labels.md` |
+| `docs/images/edge-labels.png` | edges carrying labels | `guides/edge-labels.md` |
+| `docs/images/group-nodes.png` | a group around two nodes | `guides/group-nodes.md`, `guides/node-grouping.md` |
+| `docs/images/group-collapsed.png` | the same group collapsed | `guides/group-nodes.md`, `guides/node-grouping.md` |
+| `docs/images/multi-input.png` | three nodes feeding one multi-input node | `guides/multi-input-nodes.md` |
+| `docs/images/graph-algorithms.png` | a graph with the shortest path highlighted | `guides/graph-algorithms.md` |
+| `docs/screenshot-calculator.png` | the calculator example | `index.md` |
+| `docs/screenshot-example.png` | the editor window | `quickstart.md` |
+
+To add a picture to a page, drop the file into `docs/images/` and reference it
+relative to the page:
+
+```markdown
+![What the picture shows](../images/my-picture.png)
+```
+
+Pages in `docs/` use `images/my-picture.png`, pages in `docs/guides/` use
+`../images/my-picture.png`.
+
+## Regenerating the images
+
+The screenshots in `docs/images/` are produced by a script, so they can be
+refreshed when the look of the editor changes:
+
+```
+python scripts/make_doc_images.py
+```
+
+The script paints the scene into a `QImage` instead of taking a screenshot of
+a window, so it needs a working Qt platform plugin but no visible screen. Do
+not run it with `QT_QPA_PLATFORM=offscreen`: that platform has no fonts, and
+the text comes out as empty boxes.