nodebpy 520.5.0__tar.gz → 520.5.1__tar.gz

{nodebpy-520.5.0 → nodebpy-520.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 520.5.0
+Version: 520.5.1
 Summary: Build nodes trees in Blender more elegantly with code
 Author: Brady Johnston
 Author-email: Brady Johnston <brady.johnston@me.com>

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

@@ -1,6 +1,6 @@
 [project]
 name = "nodebpy"
-version = "520.5.0"
+version = "520.5.1"
 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.1}/src/nodebpy/builder/tree.py

@@ -846,6 +846,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 ..web_render 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.1}/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])
 
@@ -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.0 → nodebpy-520.5.1}/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.1}/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.1/src/nodebpy/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>"
+    )