nodebpy 520.5.0__tar.gz → 520.5.2__tar.gz

nodebpy-520.5.2/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.3
+Name: nodebpy
+Version: 520.5.2
+Summary: Build nodes trees in Blender more elegantly with code
+Author: Brady Johnston
+Author-email: Brady Johnston <brady.johnston@me.com>
+License: GPL-3.0-or-later
+Requires-Dist: bpy==5.2.* ; extra == 'bpy'
+Requires-Dist: ruff>=0.14.11 ; extra == 'format'
+Requires-Dist: networkx>=3.6.1 ; extra == 'networkx'
+Requires-Python: >=3.13
+Provides-Extra: bpy
+Provides-Extra: format
+Provides-Extra: networkx
+Description-Content-Type: text/markdown
+
+# nodebpy
+
+[![Run
+Tests](https://github.com/BradyAJohnston/nodebpy/actions/workflows/tests.yml/badge.svg)](https://github.com/BradyAJohnston/nodebpy/actions/workflows/tests.yml)
+[![](https://codecov.io/gh/BradyAJohnston/nodebpy/graph/badge.svg?token=buThDQZUED)](https://codecov.io/gh/BradyAJohnston/nodebpy)
+
+Build node trees in Blender more elegantly with Python code. Geometry Nodes, Shader Nodes and Compositor nodes are all fully supported, with type hints and IDE auto-completion throughout.
+
+```bash
+pip install nodebpy
+```
+
+> A text-based version of nodes should bring the convenience of writing code with IDE auto-completion, type hinting, with overall compactness and readability, while staying as close as possible to what building a node tree via the GUI feels like.
+
+```python
+from nodebpy import geometry as g
+
+with g.tree("AnotherTree", collapse=True) as tree:
+    rotation = (
+        g.RandomValue.vector(min=-1, seed=2)
+        >> g.AlignRotationToVector()
+        >> g.RotateRotation(rotate_by=g.AxisAngleToRotation(angle=0.3))
+    )
+
+    _ = (
+        tree.inputs.integer("Count", 10)
+        >> g.Points(position=g.RandomValue.vector(min=-1))
+        >> g.InstanceOnPoints(instance=g.Cube(), rotation=rotation)
+        >> g.SetPosition(
+            position=g.Position() * 2.0 + (0, 0.2, 0.3),
+            offset=(0, 0, 0.1),
+        )
+        >> g.RealizeInstances()
+        >> g.InstanceOnPoints(g.Cube(), instance=...)
+        >> tree.outputs.geometry("Instances")
+    )
+```
+
+![](docs/images/paste-1.png)
+
+- Every node is a typed class named after the node it creates — 'Random Value' becomes `g.RandomValue()` — and node subtypes are class methods: `g.RandomValue.vector()`.
+- Trees are built inside a `with g.tree(...):` context; instantiating a node class adds it to the current tree, and the tree's interface is declared with `tree.inputs.*` / `tree.outputs.*`.
+- Nodes are linked with the `>>` operator, which picks the most compatible socket pair automatically (much like Node Wrangler's <kbd>Alt</kbd> + <kbd>Right Click</kbd> drag) — or address sockets explicitly through the `.i.*` / `.o.*` accessors.
+- Python's arithmetic, comparison and boolean operators create the matching `Math` / `VectorMath` / `Compare` / `BooleanMath` nodes: `g.Value(1.0) * 2 + (0, 0, 1)`.
+- Existing node trees — including ones wired up by hand in the GUI — can be exported back to `nodebpy` source with `to_python()`.
+
+## Documentation
+
+Guides and the full node reference live at [bradyajohnston.github.io/nodebpy](https://bradyajohnston.github.io/nodebpy):
+
+- [Writing node trees](https://bradyajohnston.github.io/nodebpy/introduction.html) — adding, linking and organising nodes
+- [Math operators](https://bradyajohnston.github.io/nodebpy/operators.html) — arithmetic, comparison and boolean expressions as nodes
+- [Node API design](https://bradyajohnston.github.io/nodebpy/node-api.html) — sockets, accessors, enum options and class methods
+- [Custom node groups](https://bradyajohnston.github.io/nodebpy/custom-node-groups.html) and [asset node groups](https://bradyajohnston.github.io/nodebpy/assets.html) — reusable groups as Python classes
+- [Nodes to code](https://bradyajohnston.github.io/nodebpy/nodes-to-code.html) — turn existing trees back into `nodebpy` code
+- [Using `nodebpy` in your add-on](https://bradyajohnston.github.io/nodebpy/using.html) — installation, bundling and the Blender-tracking versioning scheme
+- [Comparisons](https://bradyajohnston.github.io/nodebpy/comparisons.html) — how the API relates to [`geometry-script`](https://github.com/carson-katri/geometry-script), [`geonodes`](https://github.com/al1brn/geonodes), [NodeToPython](https://github.com/BrendanParmer/NodeToPython) and [TreeClipper](https://github.com/Algebraic-UG/tree_clipper)
+
+Like [`databpy`](https://github.com/BradyAJohnston/databpy), this project started as an internal tool inside [`molecularnodes`](https://github.com/BradyAJohnston/MolecularNodes) before being broken out into its own robustly typed and tested package.
+
+## Contributing
+
+Development setup, running the tests and regenerating the node classes (most of `src/nodebpy/nodes/` is auto-generated by the `gen/` package) are covered in [CONTRIBUTING.md](CONTRIBUTING.md).

nodebpy-520.5.2/README.md

@@ -0,0 +1,63 @@
+# nodebpy
+
+[![Run
+Tests](https://github.com/BradyAJohnston/nodebpy/actions/workflows/tests.yml/badge.svg)](https://github.com/BradyAJohnston/nodebpy/actions/workflows/tests.yml)
+[![](https://codecov.io/gh/BradyAJohnston/nodebpy/graph/badge.svg?token=buThDQZUED)](https://codecov.io/gh/BradyAJohnston/nodebpy)
+
+Build node trees in Blender more elegantly with Python code. Geometry Nodes, Shader Nodes and Compositor nodes are all fully supported, with type hints and IDE auto-completion throughout.
+
+```bash
+pip install nodebpy
+```
+
+> A text-based version of nodes should bring the convenience of writing code with IDE auto-completion, type hinting, with overall compactness and readability, while staying as close as possible to what building a node tree via the GUI feels like.
+
+```python
+from nodebpy import geometry as g
+
+with g.tree("AnotherTree", collapse=True) as tree:
+    rotation = (
+        g.RandomValue.vector(min=-1, seed=2)
+        >> g.AlignRotationToVector()
+        >> g.RotateRotation(rotate_by=g.AxisAngleToRotation(angle=0.3))
+    )
+
+    _ = (
+        tree.inputs.integer("Count", 10)
+        >> g.Points(position=g.RandomValue.vector(min=-1))
+        >> g.InstanceOnPoints(instance=g.Cube(), rotation=rotation)
+        >> g.SetPosition(
+            position=g.Position() * 2.0 + (0, 0.2, 0.3),
+            offset=(0, 0, 0.1),
+        )
+        >> g.RealizeInstances()
+        >> g.InstanceOnPoints(g.Cube(), instance=...)
+        >> tree.outputs.geometry("Instances")
+    )
+```
+
+![](docs/images/paste-1.png)
+
+- Every node is a typed class named after the node it creates — 'Random Value' becomes `g.RandomValue()` — and node subtypes are class methods: `g.RandomValue.vector()`.
+- Trees are built inside a `with g.tree(...):` context; instantiating a node class adds it to the current tree, and the tree's interface is declared with `tree.inputs.*` / `tree.outputs.*`.
+- Nodes are linked with the `>>` operator, which picks the most compatible socket pair automatically (much like Node Wrangler's <kbd>Alt</kbd> + <kbd>Right Click</kbd> drag) — or address sockets explicitly through the `.i.*` / `.o.*` accessors.
+- Python's arithmetic, comparison and boolean operators create the matching `Math` / `VectorMath` / `Compare` / `BooleanMath` nodes: `g.Value(1.0) * 2 + (0, 0, 1)`.
+- Existing node trees — including ones wired up by hand in the GUI — can be exported back to `nodebpy` source with `to_python()`.
+
+## Documentation
+
+Guides and the full node reference live at [bradyajohnston.github.io/nodebpy](https://bradyajohnston.github.io/nodebpy):
+
+- [Writing node trees](https://bradyajohnston.github.io/nodebpy/introduction.html) — adding, linking and organising nodes
+- [Math operators](https://bradyajohnston.github.io/nodebpy/operators.html) — arithmetic, comparison and boolean expressions as nodes
+- [Node API design](https://bradyajohnston.github.io/nodebpy/node-api.html) — sockets, accessors, enum options and class methods
+- [Custom node groups](https://bradyajohnston.github.io/nodebpy/custom-node-groups.html) and [asset node groups](https://bradyajohnston.github.io/nodebpy/assets.html) — reusable groups as Python classes
+- [Nodes to code](https://bradyajohnston.github.io/nodebpy/nodes-to-code.html) — turn existing trees back into `nodebpy` code
+- [Using `nodebpy` in your add-on](https://bradyajohnston.github.io/nodebpy/using.html) — installation, bundling and the Blender-tracking versioning scheme
+- [Comparisons](https://bradyajohnston.github.io/nodebpy/comparisons.html) — how the API relates to [`geometry-script`](https://github.com/carson-katri/geometry-script), [`geonodes`](https://github.com/al1brn/geonodes), [NodeToPython](https://github.com/BrendanParmer/NodeToPython) and [TreeClipper](https://github.com/Algebraic-UG/tree_clipper)
+
+Like [`databpy`](https://github.com/BradyAJohnston/databpy), this project started as an internal tool inside [`molecularnodes`](https://github.com/BradyAJohnston/MolecularNodes) before being broken out into its own robustly typed and tested package.
+
+## Contributing
+
+Development setup, running the tests and regenerating the node classes (most of `src/nodebpy/nodes/` is auto-generated by the `gen/` package) are covered in [CONTRIBUTING.md](CONTRIBUTING.md).

{nodebpy-520.5.0 → nodebpy-520.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nodebpy"
-version = "520.5.0"
+version = "520.5.2"
 description = "Build nodes trees in Blender more elegantly with code"
 readme = "README.md"
 authors = [
@@ -31,6 +31,7 @@ build-backend = "uv_build"
 [dependency-groups]
 dev = [
     "ipython>=8.0.0",
+    "ipykernel>=6.0.0",
     "networkx>=3.6.1",
     "fake-bpy-module>=20260501",
     "jsondiff>=2.2.1",
@@ -38,6 +39,7 @@ dev = [
     "pytest-cov>=7.0.0",
     "quarto-cli>=1.9",
     "quartodoc>=0.11.1",
+    "tree-clipper>=0.1.6",
     "ruff>=0.14.11",
     "syrupy>=5.0.0",
     "pytest-xdist>=3.8.0",

{nodebpy-520.5.0 → nodebpy-520.5.2}/src/nodebpy/builder/tree.py

@@ -15,6 +15,7 @@ from bpy.types import (
     ShaderNodeTree,
 )
 
+
 from ..types import (
     SOCKET_COMPATIBILITY,
     FloatInterfaceSubtypes,
@@ -846,6 +847,23 @@ class TreeBuilder(Generic[_TreeT]):
             print(f"Mermaid diagram generation failed: {e}")
             return None
 
+    def _repr_html_(self) -> str | None:
+        """
+        Return an interactive geonodes-web-render graph for Jupyter/Quarto.
+
+        This is called when the TreeBuilder is the return value of a cell. The
+        tree is exported to the Tree Clipper format and embedded as a Blender-
+        styled, pan/zoomable graph. Returning ``None`` on failure lets the
+        Mermaid ``_repr_markdown_`` fallback take over.
+        """
+        try:
+            from ..export import to_web_render_html
+
+            return to_web_render_html(self)
+        except Exception as e:
+            print(f"Web render generation failed: {e}")
+            return None
+
     def _input_node(self) -> Node:
         """Get or create the Group Input node."""
         try:

{nodebpy-520.5.0 → nodebpy-520.5.2}/src/nodebpy/export/__init__.py

@@ -1,7 +1,9 @@
 from .codegen import to_python
 from .diagram import to_mermaid
+from .web_render import to_web_render_html
 
 __all__ = [
     "to_python",
     "to_mermaid",
+    "to_web_render_html",
 ]

{nodebpy-520.5.0 → nodebpy-520.5.2}/src/nodebpy/export/codegen.py

@@ -1057,20 +1057,25 @@ class EmitContext:
         self.used_aliases.add(alias)
 
         by_socket: dict[str, list[tuple[int, Expr]]] = {}
+        multi_inputs: set[str] = set()
         for link in self.incoming.get(node.name, ()):
             if skip_input_id and link.to_socket.identifier == skip_input_id:
                 continue
-            by_socket.setdefault(_normalize(link.to_socket.identifier), []).append(
+            name = _normalize(link.to_socket.identifier)
+            if getattr(link.to_socket, "is_multi_input", False):
+                multi_inputs.add(name)
+            by_socket.setdefault(name, []).append(
                 (link.sort_id, self.upstream_expr(link))
             )
         socket_kwargs: dict[str, Expr] = {}
         for name, entries in by_socket.items():
-            if len(entries) == 1:
+            if len(entries) == 1 and name not in multi_inputs:
                 socket_kwargs[name] = entries[0][1]
             else:
-                # Multiple links on one multi-input socket become a tuple in
-                # creation order (descending sort_id) so the rebuilt tree
-                # gets the same multi-input ordering.
+                # Links on a multi-input socket become a tuple in creation
+                # order (descending sort_id) so the rebuilt tree gets the same
+                # multi-input ordering — even a single link, since manual
+                # classes (JoinGeometry, MeshBoolean, …) expect an iterable.
                 entries.sort(key=lambda e: e[0], reverse=True)
                 socket_kwargs[name] = TupleExpr([e[1] for e in entries])
 
@@ -1384,7 +1389,7 @@ def _non_default_props(node, cls: type) -> dict[str, Any]:
 # (``Compare.float.less_than``). Parsing those bodies at runtime yields a
 # reverse table from node state to factory path, so generated code uses the
 # same idiomatic spellings users write — with no separate table to keep in
-# sync with generate.py. Factories whose bodies are not statically analysable
+# sync with the generator. Factories whose bodies are not statically analysable
 # (positional args, helper indirection, **kwargs) are simply skipped and the
 # node falls back to the plain constructor.
 # ---------------------------------------------------------------------------
@@ -1817,7 +1822,9 @@ def _matrix_spec(method: str, output: str) -> SocketMethodSpec:
     )
 
 
-def _math_unary_spec(operation: str, method: str, *args: str) -> SocketMethodSpec:
+def _math_unary_spec(
+    operation: str, method: str, *args: str, always_args: int = 0
+) -> SocketMethodSpec:
     """A unary ``ShaderNodeMath`` op rendered as a float socket method —
     ``value.sqrt()`` / ``value.sign()``. ``receiver_socket_type="VALUE"`` keeps
     the round-trip faithful: the method only re-derives a float Math node when
@@ -1826,14 +1833,17 @@ def _math_unary_spec(operation: str, method: str, *args: str) -> SocketMethodSpe
         receiver="Value",
         method=method,
         output="Value",
-        params=tuple((f"Value_{int(i + 1)}", arg) for i, arg in enumerate(args)),
+        params=tuple((f"Value_{i + 1:03d}", arg) for i, arg in enumerate(args)),
         require=(("operation", operation),),
         consumed_props=("operation",),
         receiver_socket_type="VALUE",
+        always_args=always_args,
     )
 
 
-def _int_math_unary_spec(operation: str, method: str, *args: str) -> SocketMethodSpec:
+def _int_math_unary_spec(
+    operation: str, method: str, *args: str, always_args: int = 0
+) -> SocketMethodSpec:
     """A unary ``FunctionNodeIntegerMath`` op rendered as an integer socket
     method — ``value.sign()``. ``ABSOLUTE``/``NEGATE`` stay as the ``abs(x)`` /
     ``-x`` lifts and so are deliberately absent here."""
@@ -1841,10 +1851,11 @@ def _int_math_unary_spec(operation: str, method: str, *args: str) -> SocketMetho
         receiver="Value",
         method=method,
         output="Value",
-        params=tuple((f"Value_{int(i + 1)}", arg) for i, arg in enumerate(args)),
+        params=tuple((f"Value_{i + 1:03d}", arg) for i, arg in enumerate(args)),
         require=(("operation", operation),),
         consumed_props=("operation",),
         receiver_socket_type="INT",
+        always_args=always_args,
     )
 
 
@@ -2033,12 +2044,26 @@ _SOCKET_METHODS: dict[str, list[SocketMethodSpec]] = {
             ("MINIMUM", "min", "value_001"),
             ("MAXIMUM", "max", "value_001"),
             ("MULTIPLY_ADD", "mul_add", "multiplier", "addend"),
-            ("WRAP", "wrap", "min", "max"),
-            ("MODULO", "modulo", "divisor"),
             ("PINGPONG", "ping_pong", "value"),
             ("LOGARITHM", "log", "base"),
             ("ARCTAN2", "atan2", "value"),
         ]
+    ]
+    # No float modulo lift: the float mixin's modulo() builds FLOORED_MODULO,
+    # which the % operator lift already covers, and plain MODULO has no
+    # faithful method equivalent so it stays a factory call.
+    + [
+        # wrap()'s node sockets are swapped relative to the signature: the
+        # node's Value_001 is Max, Value_002 is Min.
+        SocketMethodSpec(
+            receiver="Value",
+            method="wrap",
+            output="Value",
+            params=(("Value_002", "min"), ("Value_001", "max")),
+            require=(("operation", "WRAP"),),
+            consumed_props=("operation",),
+            receiver_socket_type="VALUE",
+        ),
     ],
     "FunctionNodeIntegerMath": [
         _int_math_unary_spec(*args)
@@ -2046,9 +2071,9 @@ _SOCKET_METHODS: dict[str, list[SocketMethodSpec]] = {
             ("SIGN", "sign"),
             # ("ABSOLUTE", "abs"),
             ("MULTIPLY_ADD", "mul_add", "multiplier", "addend"),
-            ("MODULO", "modulo", "divisor"),
         )
-    ],
+    ]
+    + [_int_math_unary_spec("MODULO", "modulo", "divisor", always_args=1)],
     "GeometryNodeListLength": [
         _list_spec("list_length", "Length", type_prop="data_type"),
     ],

nodebpy-520.5.2/src/nodebpy/export/web_render.py

@@ -0,0 +1,113 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Render node trees as interactive graphs via geonodes-web-render.
+
+The live Blender node tree built by a :class:`~nodebpy.builder.tree.TreeBuilder`
+is exported to the Tree Clipper JSON format (using the ``tree_clipper`` package)
+and embedded into a small HTML snippet that mounts the ``geonodes-web-render``
+web component in the browser. This is what powers the rich ``_repr_html_`` shown
+for a tree in Jupyter and Quarto.
+
+Nothing here needs network access at build time: the Tree Clipper payload is
+inlined into the HTML, and only the (cached) JS/CSS are fetched from the CDN
+when the page is viewed.
+"""
+
+from __future__ import annotations
+
+import json
+import uuid
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..builder.tree import TreeBuilder
+
+#: geonodes-web-render version served from the CDN. A semver range (`"0.3"`)
+#: lets esm.sh serve the latest matching patch, so web-render bug fixes ship to
+#: the docs without re-pinning here. Use an exact version (e.g. "0.3.2") to lock.
+DEFAULT_VERSION = "0.3"
+
+#: Default ESM CDN. esm.sh transparently resolves the external react/react-dom.
+DEFAULT_CDN = "https://esm.sh"
+
+
+def to_tree_clipper_payload(builder: "TreeBuilder", *, compress: bool = True) -> str:
+    """Export *builder*'s node tree to a Tree Clipper payload.
+
+    With ``compress=True`` (the default) the result is the ``TreeClipper::`` +
+    base64(gzip(json)) string consumed directly by geonodes-web-render. With
+    ``compress=False`` it is indented JSON, handy for inspection.
+
+    Requires the optional ``tree_clipper`` package to be importable.
+    """
+    from tree_clipper.export_nodes import ExportIntermediate, ExportParameters
+    from tree_clipper.specific_handlers import BUILT_IN_EXPORTER
+
+    # A MaterialBuilder owns a bpy.types.Material; a plain TreeBuilder owns a
+    # node group. Tree Clipper looks the root up by name in the matching
+    # collection, so use the live name (Blender may have de-duplicated it).
+    material = getattr(builder, "material", None)
+    is_material = material is not None
+    name = material.name if is_material else builder.tree.name
+
+    export = ExportIntermediate(
+        parameters=ExportParameters(
+            is_material=is_material,
+            name=name,
+            # BUILT_IN_EXPORTER is a dict literal upstream, so ty infers its key
+            # type as NoneType (invariant dict) rather than the runtime `type`.
+            specific_handlers=BUILT_IN_EXPORTER,  # ty: ignore[invalid-argument-type]
+            export_sub_trees=True,
+            debug_prints=False,
+            write_from_roots=False,
+        )
+    )
+    while export.step():
+        pass
+    export.set_external(
+        # get_pointee() is typed as bare bpy_struct upstream; external items are
+        # always ID datablocks, which do carry a `.name`.
+        (external_id, item.pointed_to_by.get_pointee().name)  # ty: ignore[unresolved-attribute]
+        for external_id, item in export.get_external().items()
+    )
+    return export.export_to_str(compress=compress, json_indent=4)
+
+
+def to_web_render_html(
+    builder: "TreeBuilder",
+    *,
+    height: str = "480px",
+    version: str = DEFAULT_VERSION,
+    cdn: str = DEFAULT_CDN,
+) -> str:
+    """Return a self-contained HTML snippet rendering *builder* as a graph.
+
+    The snippet mounts one geonodes-web-render instance into its own container,
+    so multiple trees can be shown on the same page. The stylesheet is added to
+    ``<head>`` only once across all snippets.
+    """
+    payload = to_tree_clipper_payload(builder, compress=True)
+    container_id = f"gnwr-{uuid.uuid4().hex}"
+    module_url = f"{cdn}/geonodes-web-render@{version}/embed"
+    css_url = f"{cdn}/geonodes-web-render@{version}/dist/embed.css"
+    # json.dumps keeps the payload a valid, safely-quoted JS string literal.
+    payload_js = json.dumps(payload)
+    css_id = "gnwr-stylesheet"
+
+    return (
+        f'<div id="{container_id}" '
+        f'style="height: {height}; width: 100%; border-radius: 8px; overflow: hidden;">'
+        f"</div>\n"
+        f'<script type="module">\n'
+        f'if (!document.getElementById("{css_id}")) {{\n'
+        f'  const link = document.createElement("link");\n'
+        f'  link.id = "{css_id}";\n'
+        f'  link.rel = "stylesheet";\n'
+        f'  link.href = "{css_url}";\n'
+        f"  document.head.appendChild(link);\n"
+        f"}}\n"
+        f'import {{ mountGraphView }} from "{module_url}";\n'
+        f'mountGraphView(document.getElementById("{container_id}"), '
+        f"{{ payload: {payload_js}, showCopyButton: false, "
+        f"allowSelection: false }});\n"
+        f"</script>"
+    )

{nodebpy-520.5.0 → nodebpy-520.5.2}/src/nodebpy/nodes/_mixins.py

@@ -1,8 +1,8 @@
 """Hand-written mixins attached to auto-generated node classes.
 
 These hold reusable behaviour that the code generator cannot derive on its own
-(ergonomic flag accessors, items helpers, …). ``generate.py`` wires them onto
-the generated classes via :class:`~generate.NodeCustomization`, so the bulky
+(ergonomic flag accessors, items helpers, …). The ``gen`` package wires them
+onto the generated classes via :class:`~gen.NodeCustomization`, so the bulky
 boilerplate (sockets, docstrings, property accessors) stays generated while the
 bespoke behaviour lives here.
 """

{nodebpy-520.5.0 → nodebpy-520.5.2}/src/nodebpy/nodes/compositor/assets.py

@@ -144,8 +144,8 @@ class FilmGrain(AssetCompositorGroup):
         """Factor"""
         preset: MenuSocket
         """Preset"""
-        animated_: BooleanSocket
-        """Animated """
+        animated: BooleanSocket
+        """Animated"""
 
     class _Outputs(SocketAccessor):
         result: ColorSocket
@@ -162,15 +162,15 @@ class FilmGrain(AssetCompositorGroup):
         self,
         input: InputColor = None,
         factor: InputFloat = 1.0,
-        preset: InputMenu = "Super 8mm",
-        animated_: InputBoolean = False,
+        preset: InputMenu = "Super 8 mm",
+        animated: InputBoolean = False,
     ):
         super().__init__(
             **{
                 "Socket_1": input,
                 "Socket_7": factor,
                 "Socket_64": preset,
-                "Socket_10": animated_,
+                "Socket_10": animated,
             }
         )
 

{nodebpy-520.5.0 → nodebpy-520.5.2}/src/nodebpy/nodes/geometry/assets.py

@@ -200,7 +200,7 @@ class AttachmentInfo(AssetGeometryGroup):
         attachment_uv: VectorSocket
         """Attachment UV"""
         attachment_is_valid: BooleanSocket
-        """Attachment is Valid"""
+        """Attachment Is Valid"""
         surface_normal: VectorSocket
         """Surface Normal"""
 
@@ -2137,8 +2137,8 @@ class ProjectWithDepth(AssetGeometryGroup):
         """Projection"""
         transform: MatrixSocket
         """Transform"""
-        cip_start: FloatSocket
-        """Cip Start"""
+        clip_start: FloatSocket
+        """Clip Start"""
         clip_end: FloatSocket
         """Clip End"""
 
@@ -2159,7 +2159,7 @@ class ProjectWithDepth(AssetGeometryGroup):
         depth: InputFloat = 1.0,
         projection: InputMatrix = None,
         transform: InputMatrix = None,
-        cip_start: InputFloat = 0.1,
+        clip_start: InputFloat = 0.1,
         clip_end: InputFloat = 100.0,
     ):
         super().__init__(
@@ -2168,7 +2168,7 @@ class ProjectWithDepth(AssetGeometryGroup):
                 "Socket_2": depth,
                 "Socket_5": projection,
                 "Socket_6": transform,
-                "Socket_0": cip_start,
+                "Socket_0": clip_start,
                 "Socket_1": clip_end,
             }
         )

nodebpy-520.5.0/PKG-INFO

@@ -1,159 +0,0 @@
-Metadata-Version: 2.3
-Name: nodebpy
-Version: 520.5.0
-Summary: Build nodes trees in Blender more elegantly with code
-Author: Brady Johnston
-Author-email: Brady Johnston <brady.johnston@me.com>
-License: GPL-3.0-or-later
-Requires-Dist: bpy==5.2.* ; extra == 'bpy'
-Requires-Dist: ruff>=0.14.11 ; extra == 'format'
-Requires-Dist: networkx>=3.6.1 ; extra == 'networkx'
-Requires-Python: >=3.13
-Provides-Extra: bpy
-Provides-Extra: format
-Provides-Extra: networkx
-Description-Content-Type: text/markdown
-
-# nodebpy
-
-[![Run
-Tests](https://github.com/BradyAJohnston/nodebpy/actions/workflows/tests.yml/badge.svg)](https://github.com/BradyAJohnston/nodebpy/actions/workflows/tests.yml)
-[![](https://codecov.io/gh/BradyAJohnston/nodebpy/graph/badge.svg?token=buThDQZUED)](https://codecov.io/gh/BradyAJohnston/nodebpy)
-
-A package to build node trees in blender more elegantly with python code. Geometry Nodes, Shader Nodes and Compositor nodes are all fully supported. Look at the [documentation](https://bradyajohnston.github.io/nodebpy) for more examples.
-
-## Creating Nodes With Code
-
-> A text-based version of nodes should bring the convenience of writing code with IDE auto-completion, type hinting, with overall compactness and readability, while staying as close as possible to what building a node tree via the GUI feels like.
-
-```python
-from nodebpy import geometry as g
-
-with g.tree("AnotherTree", collapse=True) as tree:
-    rotation = (
-        g.RandomValue.vector(min=-1, seed=2)
-        >> g.AlignRotationToVector()
-        >> g.RotateRotation(rotate_by=g.AxisAngleToRotation(angle=0.3))
-    )
-
-    _ = (
-        tree.inputs.integer("Count", 10)
-        >> g.Points(position=g.RandomValue.vector(min=-1))
-        >> g.InstanceOnPoints(instance=g.Cube(), rotation=rotation)
-        >> g.SetPosition(
-            position=g.Position() * 2.0 + (0, 0.2, 0.3),
-            offset=(0, 0, 0.1),
-        )
-        >> g.RealizeInstances()
-        >> g.InstanceOnPoints(g.Cube(), instance=...)
-        >> tree.outputs.geometry("Instances")
-    )
-```
-
-![](docs/images/paste-1.png)
-
-Nodes are created by instantiating their classes. The node tree they are added to is determined by the context the code is executed in (while inside `with g.tree():`). The interface for the node tree is created with `tree.inputs` and `tree.inputs`, adding the sockets and returning the input or output socket for linking with other nodes.
-
-Nodes are linked by overloading the `>>` operator, to link from the previous node on the left to the input on the right. Suitable socket pairs are automatically selected or explicitly supplied.
-
-The layout / arrangement of the node tree is not important to Blender's evaluation of it - but an automatic layout algorithm is potentially applied upon exiting the node tree context.
-
-### `nodebpy` and the `>>` operator
-
-In `nodebpy` we use the `>>` operator to link from one node or socket into another.
-This should feel and behave much like the <kbd>Alt</kbd> + <kbd>Right Click</kbd> drag between nodes in [Node Wrangler](https://docs.blender.org/manual/en/latest/addons/node/node_wrangler.html). It will use some smart logic to match the most compatible sockets between the nodes, but if you ever want to be explicit you do so. The input and output sockets of a node are accessible as properties via the `i.*` and `o.*` prefixes, or you can use the `...` placeholder to specify the particular input to be user, or pass in the previous node as a named argument.
-
-```py
-# vector output will be linked into the first vector input (position)
-g.Vector() >> g.SetPosition()
-# vector output will be linked into the offset input
-g.Vector() >> g.SetPosition(offset=...)
-g.SetPosition(offset=g.Vector())
-```
-
-The `>>` operator will always look for the _most_ compatible sockets first (matching data types) before looking for other compatible but not identical socket data types to link.
-If a compatible match can't be found an error _will_ be thrown.
-
-### Contexts
-
-What node tree or node tree interface we are currently editing is determined based on contexts.
-Instantiating a node class outside of a tree context will throw an error. The easiest way to enter and exit a tree context is to use the `with` statement.
-
-Each time you instantiate a node class, a new node will be created and added to the current tree.
-If these nodes are given as arguments to other nodes or used with the `>>` operator, they will be automatically linked to the appropriate sockets.
-
-## Nodes
-
-Documentation for all of the nodes can be found in the [API Reference](https://bradyajohnston.github.io/nodebpy/reference/). This is mostly built automatically from the existing Blender node classes.
-
-Every node has all of it's input sockets and enum options exposed as arguments to the class constructor. Input sockets are prefixed with `.i.*` and output sockets are prefixed with `.o.*`. Properties that aren't exposed as sockets are available as class properties. Many properties are also available as class methods for convenience when constructing.
-
-The basic math operators also automatically add relevant nodes with their operations and values set.
-
-```py
-# operation is exposed as a property
-math = g.Math(1.0, 2.0, operation='ADD')
-math.operation = "SUBTRACT"
-
-# operation can be chose as a class method
-math = g.Math.subtract(1.0, 2.0)
-math = g.Value(1.0) - 2.0
-math = g.Math.add(1.0, 2.0)
-math = g.Value(1.0) + 2.0
-# the 3.0 + 2.0 is evaluated as regular python code first,
-# so the result with be a Math.add(g.Value(1.0), 5.0)
-math = g.Value(1.0) 3.0 + 2.0
-
-# these are equivalent, the g.Math.multiply is automatically added
-g.Value(1.0) * 2
-g.Math.multiply(g.Value(1.0), 2.0)
-```
-
-# Design Considerations
-
-The top priority of `nodebpy` has been type hinting and IDE auto-complete.
-Typical tooling that supports autoring regular python code should also support the authoring of node trees.
-Much like [`databpy`](https://github.com/BradyAJohnston/databpy), this started as an internal tool used inside of [`molecularnodes`](https://github.com/BradyAJohnston/molecularnodes) but has since been broken out into it's own separate project.
-This projects is robustly typed and tested, with the intent that it can be used internally for multiple other add-ons and projects.
-
-- Node classes are named after nodes 'Random Value' -> `RandomValue()`
-- Node 'subtypes' and methods should be accessible via dot (`.`) for easier IDE auto-complete and authoring:
-  - `RandomValue(data_type="FLOAT_VECTOR")` -> `RandomValue.vector()`
-- Node properties are available on the top level, with inputs and outputs available behind `.i.*` and `.o.*` accessors
-- Inputs and outputs from a node are prefixed with `i.*` and `o.*`:
-  - `AccumulateField().o.total` returns the output `Total` socket
-  - `AccumulateField().i.value` returns the input `Value` socket
-
-## Building
-
-Most of the code for classes are generated automatically with the `generate.py` script.
-Some nodes are manually specified in the `src/nodebpy/nodes/geometry/manual.py` if they require special handling.
-
-Run the build & format script as such:
-
-```bash
-uv run generate.py && uvx ruff format && uvx ruff check --fix && uvx ty check --fix src
-```
-
-## Other Projects
-
-There are several other notable projects which have also attempted interfacing with node trees via code. They mostly fit into two categories of either storing & retrieving node trees via code (`.json` or the `bpy` API), or authoring of node trees with custom API and syntax. This project mostly fits in to the latter category.
-
-
-
-### Storing node trees as code:
-Converting node trees to the python API calls or `.json` is great to have a robust storage method, but this approach falls down in human authorability / readability. These projects are great for storage but less useful when wanting to write / generate node trees froms scratch.
-
-  - [NodeToPython](https://github.com/BrendanParmer/NodeToPython)
-  - [TreeClipper](https://github.com/Algebraic-UG/tree_clipper) (used by this project for running tests & snapshots)
-
-### Authoring node trees with code:
-Two previous projects have made similar approaches to authoring node trees. `geometry-script` also auto-generated most of it's type hinting, code and docs. It uses the approach of method chaining with the `.` operator, but obfuscates some of the non-linear way of building node trees.
-
-The other project `geonodes` uses a similar context system for creating and authoring node trees, but doesn't use the same method of exposing each individual node as it's own class that `nodebpy` does.
-
-I personally found both of their APIs to _not quite_ fit how I wanted to work, leading to the creation of `nodebpy`.
-In comparison, this project is also the only one that is also distributed on `PyPi` and insallable via `pip` for easier use in other projects.
-
-  - [geometry-script](https://github.com/carson-katri/geometry-script),
-  - [geonodes](https://github.com/al1brn/geonodes)

nodebpy-520.5.0/README.md

@@ -1,143 +0,0 @@
-# nodebpy
-
-[![Run
-Tests](https://github.com/BradyAJohnston/nodebpy/actions/workflows/tests.yml/badge.svg)](https://github.com/BradyAJohnston/nodebpy/actions/workflows/tests.yml)
-[![](https://codecov.io/gh/BradyAJohnston/nodebpy/graph/badge.svg?token=buThDQZUED)](https://codecov.io/gh/BradyAJohnston/nodebpy)
-
-A package to build node trees in blender more elegantly with python code. Geometry Nodes, Shader Nodes and Compositor nodes are all fully supported. Look at the [documentation](https://bradyajohnston.github.io/nodebpy) for more examples.
-
-## Creating Nodes With Code
-
-> A text-based version of nodes should bring the convenience of writing code with IDE auto-completion, type hinting, with overall compactness and readability, while staying as close as possible to what building a node tree via the GUI feels like.
-
-```python
-from nodebpy import geometry as g
-
-with g.tree("AnotherTree", collapse=True) as tree:
-    rotation = (
-        g.RandomValue.vector(min=-1, seed=2)
-        >> g.AlignRotationToVector()
-        >> g.RotateRotation(rotate_by=g.AxisAngleToRotation(angle=0.3))
-    )
-
-    _ = (
-        tree.inputs.integer("Count", 10)
-        >> g.Points(position=g.RandomValue.vector(min=-1))
-        >> g.InstanceOnPoints(instance=g.Cube(), rotation=rotation)
-        >> g.SetPosition(
-            position=g.Position() * 2.0 + (0, 0.2, 0.3),
-            offset=(0, 0, 0.1),
-        )
-        >> g.RealizeInstances()
-        >> g.InstanceOnPoints(g.Cube(), instance=...)
-        >> tree.outputs.geometry("Instances")
-    )
-```
-
-![](docs/images/paste-1.png)
-
-Nodes are created by instantiating their classes. The node tree they are added to is determined by the context the code is executed in (while inside `with g.tree():`). The interface for the node tree is created with `tree.inputs` and `tree.inputs`, adding the sockets and returning the input or output socket for linking with other nodes.
-
-Nodes are linked by overloading the `>>` operator, to link from the previous node on the left to the input on the right. Suitable socket pairs are automatically selected or explicitly supplied.
-
-The layout / arrangement of the node tree is not important to Blender's evaluation of it - but an automatic layout algorithm is potentially applied upon exiting the node tree context.
-
-### `nodebpy` and the `>>` operator
-
-In `nodebpy` we use the `>>` operator to link from one node or socket into another.
-This should feel and behave much like the <kbd>Alt</kbd> + <kbd>Right Click</kbd> drag between nodes in [Node Wrangler](https://docs.blender.org/manual/en/latest/addons/node/node_wrangler.html). It will use some smart logic to match the most compatible sockets between the nodes, but if you ever want to be explicit you do so. The input and output sockets of a node are accessible as properties via the `i.*` and `o.*` prefixes, or you can use the `...` placeholder to specify the particular input to be user, or pass in the previous node as a named argument.
-
-```py
-# vector output will be linked into the first vector input (position)
-g.Vector() >> g.SetPosition()
-# vector output will be linked into the offset input
-g.Vector() >> g.SetPosition(offset=...)
-g.SetPosition(offset=g.Vector())
-```
-
-The `>>` operator will always look for the _most_ compatible sockets first (matching data types) before looking for other compatible but not identical socket data types to link.
-If a compatible match can't be found an error _will_ be thrown.
-
-### Contexts
-
-What node tree or node tree interface we are currently editing is determined based on contexts.
-Instantiating a node class outside of a tree context will throw an error. The easiest way to enter and exit a tree context is to use the `with` statement.
-
-Each time you instantiate a node class, a new node will be created and added to the current tree.
-If these nodes are given as arguments to other nodes or used with the `>>` operator, they will be automatically linked to the appropriate sockets.
-
-## Nodes
-
-Documentation for all of the nodes can be found in the [API Reference](https://bradyajohnston.github.io/nodebpy/reference/). This is mostly built automatically from the existing Blender node classes.
-
-Every node has all of it's input sockets and enum options exposed as arguments to the class constructor. Input sockets are prefixed with `.i.*` and output sockets are prefixed with `.o.*`. Properties that aren't exposed as sockets are available as class properties. Many properties are also available as class methods for convenience when constructing.
-
-The basic math operators also automatically add relevant nodes with their operations and values set.
-
-```py
-# operation is exposed as a property
-math = g.Math(1.0, 2.0, operation='ADD')
-math.operation = "SUBTRACT"
-
-# operation can be chose as a class method
-math = g.Math.subtract(1.0, 2.0)
-math = g.Value(1.0) - 2.0
-math = g.Math.add(1.0, 2.0)
-math = g.Value(1.0) + 2.0
-# the 3.0 + 2.0 is evaluated as regular python code first,
-# so the result with be a Math.add(g.Value(1.0), 5.0)
-math = g.Value(1.0) 3.0 + 2.0
-
-# these are equivalent, the g.Math.multiply is automatically added
-g.Value(1.0) * 2
-g.Math.multiply(g.Value(1.0), 2.0)
-```
-
-# Design Considerations
-
-The top priority of `nodebpy` has been type hinting and IDE auto-complete.
-Typical tooling that supports autoring regular python code should also support the authoring of node trees.
-Much like [`databpy`](https://github.com/BradyAJohnston/databpy), this started as an internal tool used inside of [`molecularnodes`](https://github.com/BradyAJohnston/molecularnodes) but has since been broken out into it's own separate project.
-This projects is robustly typed and tested, with the intent that it can be used internally for multiple other add-ons and projects.
-
-- Node classes are named after nodes 'Random Value' -> `RandomValue()`
-- Node 'subtypes' and methods should be accessible via dot (`.`) for easier IDE auto-complete and authoring:
-  - `RandomValue(data_type="FLOAT_VECTOR")` -> `RandomValue.vector()`
-- Node properties are available on the top level, with inputs and outputs available behind `.i.*` and `.o.*` accessors
-- Inputs and outputs from a node are prefixed with `i.*` and `o.*`:
-  - `AccumulateField().o.total` returns the output `Total` socket
-  - `AccumulateField().i.value` returns the input `Value` socket
-
-## Building
-
-Most of the code for classes are generated automatically with the `generate.py` script.
-Some nodes are manually specified in the `src/nodebpy/nodes/geometry/manual.py` if they require special handling.
-
-Run the build & format script as such:
-
-```bash
-uv run generate.py && uvx ruff format && uvx ruff check --fix && uvx ty check --fix src
-```
-
-## Other Projects
-
-There are several other notable projects which have also attempted interfacing with node trees via code. They mostly fit into two categories of either storing & retrieving node trees via code (`.json` or the `bpy` API), or authoring of node trees with custom API and syntax. This project mostly fits in to the latter category.
-
-
-
-### Storing node trees as code:
-Converting node trees to the python API calls or `.json` is great to have a robust storage method, but this approach falls down in human authorability / readability. These projects are great for storage but less useful when wanting to write / generate node trees froms scratch.
-
-  - [NodeToPython](https://github.com/BrendanParmer/NodeToPython)
-  - [TreeClipper](https://github.com/Algebraic-UG/tree_clipper) (used by this project for running tests & snapshots)
-
-### Authoring node trees with code:
-Two previous projects have made similar approaches to authoring node trees. `geometry-script` also auto-generated most of it's type hinting, code and docs. It uses the approach of method chaining with the `.` operator, but obfuscates some of the non-linear way of building node trees.
-
-The other project `geonodes` uses a similar context system for creating and authoring node trees, but doesn't use the same method of exposing each individual node as it's own class that `nodebpy` does.
-
-I personally found both of their APIs to _not quite_ fit how I wanted to work, leading to the creation of `nodebpy`.
-In comparison, this project is also the only one that is also distributed on `PyPi` and insallable via `pip` for easier use in other projects.
-
-  - [geometry-script](https://github.com/carson-katri/geometry-script),
-  - [geonodes](https://github.com/al1brn/geonodes)