nodebpy 520.36.0__tar.gz → 520.37.0__tar.gz

{nodebpy-520.36.0 → nodebpy-520.37.0}/PKG-INFO

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

{nodebpy-520.36.0 → nodebpy-520.37.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nodebpy"
-version = "520.36.0"
+version = "520.37.0"
 description = "Build nodes trees in Blender more elegantly with code"
 readme = "README.md"
 authors = [

{nodebpy-520.36.0 → nodebpy-520.37.0}/src/nodebpy/builder/_utils.py

@@ -5,8 +5,9 @@ import keyword
 import re
 import unicodedata
 import warnings
-from functools import cache
-from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
+from collections.abc import Callable
+from functools import cache, wraps
+from typing import TYPE_CHECKING, Any, Protocol, cast, runtime_checkable
 
 import bpy
 from bpy.types import NodeSocket
@@ -248,3 +249,29 @@ def _deprecated(old: str, new: str) -> None:
         DeprecationWarning,
         stacklevel=3,
     )
+
+
+def _accept_renamed[**P, R](
+    func: Callable[P, R], renames: dict[str, str], label: str
+) -> Callable[P, R]:
+    """Wrap ``func`` so each old keyword in ``renames`` (old -> new) still
+    works, with a deprecation warning, as its new name."""
+
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> R:
+        for old, new in renames.items():
+            if old in kwargs:
+                if new in kwargs:
+                    raise TypeError(f"{label}() got both {old}= and {new}=")
+                _deprecated(f"{label}({old}=...)", f"{new}=")
+                kwargs[new] = kwargs.pop(old)
+        return func(*args, **kwargs)
+
+    return cast("Callable[P, R]", wrapper)
+
+
+def _renamed_params[**P, R](
+    renames: dict[str, str], label: str
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """Decorator form of :func:`_accept_renamed`."""
+    return lambda func: _accept_renamed(func, renames, label)

{nodebpy-520.36.0 → nodebpy-520.37.0}/src/nodebpy/builder/node.py

@@ -27,7 +27,13 @@ from bpy.types import (
 
 from ..types import SOCKET_COMPATIBILITY, Default, InputAny
 from ._combine import holds_sockets, link_combined
-from ._utils import SocketError, _NodeLike, _SocketLike, enum_value_error
+from ._utils import (
+    SocketError,
+    _accept_renamed,
+    _NodeLike,
+    _SocketLike,
+    enum_value_error,
+)
 from .accessor import SocketAccessor
 from .mixins import LinkingMixin, OperatorMixin
 from .tree import TreeBuilder
@@ -97,6 +103,20 @@ class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
     _default_input_id: str | None = None
     _default_output_id: str | None = None
     _placeholder_inputs: list[str]
+    # Parameters renamed after their socket's display name, per method (old
+    # name -> new name); the old name keeps working with a DeprecationWarning.
+    _renamed_params: ClassVar[dict[str, dict[str, str]]] = {}
+
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        super().__init_subclass__(**kwargs)
+        for method, renames in cls.__dict__.get("_renamed_params", {}).items():
+            label = cls.__name__ if method == "__init__" else f"{cls.__name__}.{method}"
+            attr = cls.__dict__[method]
+            if isinstance(attr, classmethod):
+                func = _accept_renamed(attr.__func__, renames, label)
+                setattr(cls, method, classmethod(func))
+            else:
+                setattr(cls, method, _accept_renamed(attr, renames, label))
 
     def __init__(self, node: Node | None = None):
         tree = (

{nodebpy-520.36.0 → nodebpy-520.37.0}/src/nodebpy/export/codegen.py

@@ -639,6 +639,38 @@ def _tree_alias(ctx: EmitContext, name: str) -> str:
 # Signatures are read for every constructor call emitted; they do not change.
 _signature = cache(inspect.signature)
 
+# Constant input nodes, whose value is passed positionally whatever else the
+# call carries (``g.Integer(5)``, ``g.Vector((1.0, 0.0, 0.0), vector_dimensions=2)``).
+_CONSTANT_INPUT_NODES = frozenset(
+    {
+        "FunctionNodeInputBool",
+        "FunctionNodeInputColor",
+        "FunctionNodeInputInt",
+        "FunctionNodeInputIntVector",
+        "FunctionNodeInputRotation",
+        "FunctionNodeInputString",
+        "FunctionNodeInputVector",
+    }
+)
+
+
+def _constructor_call(func: str, cls: type, node, kwargs: dict[str, Expr]) -> Call:
+    """``func(**kwargs)``, passing the constructor's first parameter
+    positionally for a constant input node or when it is the only argument
+    (``g.Points(count)``, but ``g.SetPosition(offset=...)``)."""
+    if kwargs and (node.bl_idname in _CONSTANT_INPUT_NODES or len(kwargs) == 1):
+        params = list(_signature(cls.__init__).parameters.values())[1:]
+        if (
+            params
+            and params[0].kind is inspect.Parameter.POSITIONAL_OR_KEYWORD
+            and params[0].name in kwargs
+        ):
+            kwargs = dict(kwargs)
+            first = kwargs.pop(params[0].name)
+            return Call(func, args=[first], kwargs=kwargs)
+    return Call(func, kwargs=kwargs)
+
+
 # Probe trees kept open inside probe_trees(), by tree type.
 _PROBE_TREES: dict[str, Any] = {}
 _KEEP_PROBE_TREES = False
@@ -1262,7 +1294,7 @@ class EmitContext:
         for link in self.incoming.get(node.name, ()):
             if skip_input_id and link.to_socket.identifier == skip_input_id:
                 continue
-            name = _normalize(link.to_socket.identifier)
+            name = _socket_param(cls, link.to_socket.identifier)
             if getattr(link.to_socket, "is_multi_input", False):
                 multi_inputs.add(name)
             by_socket.setdefault(name, []).append(
@@ -1303,7 +1335,7 @@ class EmitContext:
         kwargs = dict(socket_kwargs)
         for name, value in prop_values.items():
             kwargs[name] = Lit(value)
-        return Call(f"{alias}.{cls.__name__}", kwargs=kwargs)
+        return _constructor_call(f"{alias}.{cls.__name__}", cls, node, kwargs)
 
     def _literal_kwargs(
         self, node, cls: type, existing: dict, skip_input_id: str | None
@@ -1337,7 +1369,7 @@ class EmitContext:
                 continue
             if not hasattr(socket, "default_value"):
                 continue
-            kwarg_name = _normalize(socket.identifier)
+            kwarg_name = _socket_param(cls, socket.identifier)
             if kwarg_name in existing:
                 continue
             try:
@@ -1599,7 +1631,7 @@ def _non_default_props(node, cls: type) -> dict[str, Any]:
         # property — even when its name happens to match a bpy property.
         # AxesToRotation's ``primary_axis`` is the Vector socket; the enum of
         # the same bpy name rides on the separate ``primary`` param instead.
-        if _input_socket_by_kwarg(node, name) is not None:
+        if _input_socket_by_kwarg(node, cls, name) is not None:
             continue
         # A constructor param represents a node setting only if it (or the
         # property it proxies) names an actual bpy property. This excludes
@@ -1866,15 +1898,24 @@ def _class_factories(cls: type) -> list[_Factory]:
     return factories
 
 
-def _input_socket_by_kwarg(node, kwarg_name: str):
+def _socket_param(cls: type, identifier: str) -> str:
+    """The constructor parameter for input socket ``identifier``: its
+    normalized identifier, unless the class renamed it after the socket's
+    display name (Color Ramp's ``Fac`` is ``factor``)."""
+    param = _normalize(identifier)
+    renames = getattr(cls, "_renamed_params", {}).get("__init__", {})
+    return renames.get(param, param)
+
+
+def _input_socket_by_kwarg(node, cls: type, kwarg_name: str):
     normalized = _normalize(kwarg_name)
     for socket in node.inputs:
-        if _normalize(socket.identifier) == normalized:
+        if _socket_param(cls, socket.identifier) == normalized:
             return socket
     return None
 
 
-def _factory_state_matches(node, props: dict[str, Any]) -> bool:
+def _factory_state_matches(node, cls: type, props: dict[str, Any]) -> bool:
     """True if every constant the factory sets equals the node's current state."""
     rna_props = getattr(getattr(node, "bl_rna", None), "properties", None)
     for key, value in props.items():
@@ -1884,7 +1925,7 @@ def _factory_state_matches(node, props: dict[str, Any]) -> bool:
             continue
         # Not an rna property — may be a constant on an input socket (menu
         # "type" sockets). Verify against the socket's default value.
-        socket = _input_socket_by_kwarg(node, key)
+        socket = _input_socket_by_kwarg(node, cls, key)
         if (
             socket is None
             or socket.is_linked
@@ -1921,11 +1962,11 @@ def _factory_call(
     parameters, and unlinked sockets whose factory-parameter default differs
     from the node's value get explicit literal kwargs.
     """
-    skip_key = _normalize(skip_input_id) if skip_input_id else None
+    skip_key = _socket_param(cls, skip_input_id) if skip_input_id else None
     best: tuple[_Factory, dict[str, Expr], tuple[bool, int, int]] | None = None
 
     for factory in _class_factories(cls):
-        if not _factory_state_matches(node, factory.props):
+        if not _factory_state_matches(node, cls, factory.props):
             continue
         covered = {_normalize(key) for key in factory.props}
         passed = {
@@ -1967,7 +2008,7 @@ def _factory_call(
                     or isinstance(default, Default)
                 ):
                     continue  # None / Default.* mean "leave the socket untouched"
-                socket = _input_socket_by_kwarg(node, key)
+                socket = _input_socket_by_kwarg(node, cls, key)
                 if socket is None:
                     faithful = False
                     break
@@ -5549,7 +5590,7 @@ def _items_node_ctor(
         if method is not None:
             return Call(f"{alias}.{cls.__name__}.{method}", kwargs=kwargs)
         kwargs[spec.factory_prop] = Lit(prop_value)
-    return Call(f"{alias}.{cls.__name__}", kwargs=kwargs)
+    return _constructor_call(f"{alias}.{cls.__name__}", cls, node, kwargs)
 
 
 def _emit_items_node(node, ctx: EmitContext) -> Expr | _Val | None: