procfunc 0.30.0__py3-none-any.whl

procfunc/util/bpy_info.py

@@ -0,0 +1,145 @@
+import logging
+import uuid
+from enum import Enum
+from typing import Any
+
+import bpy
+import numpy as np
+
+from procfunc import types as t
+
+logger = logging.getLogger(__name__)
+
+
+# Attribute data type dimensions
+DATATYPE_DIMS = {
+    "FLOAT": 1,
+    "INT": 1,
+    "INT8": 1,
+    "FLOAT_VECTOR": 3,
+    "FLOAT2": 2,
+    "FLOAT_COLOR": 4,
+    "BYTE_COLOR": 4,
+    "RGBA": 4,
+    "BOOLEAN": 1,
+    "INT32_2D": 2,
+    "QUATERNION": 4,
+    "FLOAT4X4": 16,
+}
+
+# Attribute data type field names for foreach_get/foreach_set
+DATATYPE_FIELDS = {
+    "FLOAT": "value",
+    "INT": "value",
+    "INT8": "value",
+    "FLOAT_VECTOR": "vector",
+    "FLOAT2": "vector",
+    "FLOAT_COLOR": "color",
+    "BYTE_COLOR": "color",
+    "RGBA": "color",
+    "BOOLEAN": "value",
+    "INT32_2D": "value",
+    "QUATERNION": "value",
+    "FLOAT4X4": "value",
+}
+
+# Attribute data type to Python type mapping
+DATATYPE_TO_PYTYPE = {
+    "INT": int,
+    "FLOAT": np.float32,
+    "FLOAT_VECTOR": np.float64,
+    "FLOAT_COLOR": np.float32,
+    "RGBA": np.float32,
+    "BOOLEAN": bool,
+}
+
+# Python type to attribute data type mapping
+PYTYPE_DATATYPE_TABLE = [
+    (int, "INT"),
+    (np.dtype(np.int32), "INT"),
+    (float, "FLOAT"),
+    (np.dtype(np.float32), "FLOAT"),
+    (np.dtype(np.float64), "FLOAT"),
+    (bool, "BOOLEAN"),
+    (np.dtype(np.bool_), "BOOLEAN"),
+    (t.Color, "RGBA"),
+    (t.Vector, "FLOAT_VECTOR"),
+    (t.Euler, "FLOAT_VECTOR"),
+    (t.Quaternion, "FLOAT_VECTOR"),
+    (t.Matrix, "FLOAT_VECTOR"),
+]
+PYTYPE_TO_DATATYPE = {k: v for k, v in PYTYPE_DATATYPE_TABLE}
+DATATYPE_TO_PYTYPE = {v: k for k, v in PYTYPE_DATATYPE_TABLE}
+DATATYPE_TO_PYTYPE["FLOAT2"] = np.float32
+DATATYPE_TO_PYTYPE["INT8"] = np.int8
+DATATYPE_TO_PYTYPE["INT32_2D"] = np.int32
+DATATYPE_TO_PYTYPE["BYTE_COLOR"] = np.uint8
+DATATYPE_TO_PYTYPE["QUATERNION"] = np.float32
+DATATYPE_TO_PYTYPE["FLOAT4X4"] = np.float32
+
+UNSUPPORTED_DATATYPES = {"STRING"}
+UNSUPPORTED_DOMAINS = {"LAYER"}
+
+
+class NodeGroupType(Enum):
+    GEOMETRY = "GeometryNodeGroup"
+    SHADER = "ShaderNodeGroup"
+    COMPOSITOR = "CompositorNodeGroup"
+    TEXTURE = "TextureNodeGroup"
+
+    @classmethod
+    def from_str(cls, s: str) -> "NodeGroupType | None":
+        try:
+            return cls(s)
+        except ValueError:
+            return None
+
+
+class NodeTreeType(Enum):
+    GEOMETRY = "GeometryNodeTree"
+    SHADER = "ShaderNodeTree"
+    COMPOSITOR = "CompositorNodeTree"
+    TEXTURE = "TextureNodeTree"
+
+
+NODETREE_TO_NODEGROUP = {
+    NodeTreeType.GEOMETRY: NodeGroupType.GEOMETRY,
+    NodeTreeType.SHADER: NodeGroupType.SHADER,
+    NodeTreeType.COMPOSITOR: NodeGroupType.COMPOSITOR,
+    NodeTreeType.TEXTURE: NodeGroupType.TEXTURE,
+}
+
+NODETREE_TYPE_TO_MAIN_OUTPUT = {
+    NodeTreeType.GEOMETRY: "GeometryNodeOutput",
+    NodeTreeType.SHADER: "ShaderNodeOutputMaterial",
+    NodeTreeType.COMPOSITOR: "CompositorNodeOutput",
+    NodeTreeType.TEXTURE: "TextureNodeOutput",
+}
+
+NODEGROUP_TYPE_TO_INPUT_NODE = {
+    NodeGroupType.GEOMETRY: "GeometryNodeInput",
+    NodeGroupType.SHADER: "ShaderNodeInput",
+    NodeGroupType.COMPOSITOR: "CompositorNodeInput",
+    NodeGroupType.TEXTURE: "TextureNodeInput",
+}
+
+
+def bpy_nocollide_data_name(
+    x: Any,
+    bpy_data: bpy.types.bpy_prop_collection,
+    retries: int = 30,
+) -> str:
+    name = uuid.uuid4().hex[:12]
+    if name not in bpy_data:
+        return name
+
+    for i in range(retries):
+        newname = f"{name}_{len(bpy_data) + i}"
+        if newname not in bpy_data:
+            return newname
+    else:
+        logger.warning(
+            f"Could not find a unique name for {x} in {bpy_data} after {retries=}"
+        )
+
+    return newname

procfunc/util/keyframe.py

@@ -0,0 +1,70 @@
+from dataclasses import dataclass
+from typing import Any, Generic, TypeVar
+
+INTERPOLATION_TYPES = {
+    "LINEAR",
+    "BEZIER",
+    # TODO more
+}
+
+
+T = TypeVar("T")
+
+
+@dataclass
+class Keyframes(Generic[T]):
+    """
+    Represents keyframe animation data for a parameter.
+
+    Args:
+        keyframes: List of (frame, value) tuples where value can be any type
+        interpolation: Blender interpolation mode ('LINEAR', 'BEZIER', 'CONSTANT', etc.)
+    """
+
+    keyframes: list[tuple[int, T]]
+    interpolation: str = "LINEAR"
+
+    def __post_init__(self):
+        if not self.keyframes:
+            raise ValueError("Keyframes list cannot be empty")
+        if self.interpolation not in INTERPOLATION_TYPES:
+            raise ValueError(
+                f"Invalid interpolation mode: {self.interpolation}, "
+                f"current supported are {INTERPOLATION_TYPES}, adding more may be trivial"
+            )
+
+
+def apply_keyframes(
+    target: Any,
+    data_path_name: str,
+    keyframes: Keyframes,
+):
+    """
+    Apply keyframe animation to a node socket.
+
+    Args:
+        target_socket: The Blender node socket to animate
+        keyframes: Keyframes object containing frame/value pairs and interpolation mode
+    """
+    if not hasattr(target, data_path_name):
+        raise ValueError(
+            f"Cannot apply keyframes to {target} - no {data_path_name} attribute"
+        )
+
+    setattr(target, data_path_name, keyframes.keyframes[0][1])
+
+    # Apply all keyframes
+    for frame, value in keyframes.keyframes:
+        setattr(target, data_path_name, value)
+        target.keyframe_insert(data_path=data_path_name, frame=frame)
+
+    # Set interpolation mode for all keyframes
+    if hasattr(target, "id_data") and hasattr(target.id_data, "animation_data"):
+        anim_data = target.id_data.animation_data
+        if anim_data and anim_data.action:
+            for fcurve in anim_data.action.fcurves:
+                # Check if this fcurve corresponds to our socket
+                socket_path = target.path_from_id()
+                if socket_path and socket_path in fcurve.data_path:
+                    for keyframe in fcurve.keyframe_points:
+                        keyframe.interpolation = keyframes.interpolation

procfunc/util/log.py

@@ -0,0 +1,96 @@
+import logging
+import os
+import sys
+from contextlib import contextmanager
+from typing import Literal
+
+logger = logging.getLogger(__name__)
+
+
+class Suppress:
+    def __enter__(self, logfile=os.devnull):
+        open(logfile, "w").close()
+        self.old = os.dup(1)
+        sys.stdout.flush()
+        os.close(1)
+        os.open(logfile, os.O_WRONLY)
+        self.level = logging.root.manager.disable
+        logging.disable(logging.CRITICAL)
+
+    def __exit__(self, type, value, traceback):
+        os.close(1)
+        os.dup(self.old)
+        os.close(self.old)
+        logging.disable(self.level)
+
+
+class LogLevel:
+    def __init__(self, logger, level):
+        self.logger = logger
+        self.level = level
+        self.orig_level = None
+
+    def __enter__(self):
+        self.orig_level = self.logger.level
+        self.logger.setLevel(self.level)
+
+    def __exit__(self, *_):
+        self.logger.setLevel(self.orig_level)
+
+
+def clamp_with_log(val, logger, name, level=logging.WARNING, min=None, max=None):
+    if min is not None and val < min:
+        logger.log(level, f"{name} had {val} but will be clamped to {min=}")
+        val = min
+    if max is not None and val > max:
+        logger.log(level, f"{name} had {val} but will be clamped to {max=}")
+        val = max
+    return val
+
+
+def raise_error_or_warn(
+    msg: str,
+    mode: Literal["throw", "warn", "ignore"],
+    warning_logger: logging.Logger | None,
+    error_class: type = ValueError,
+):
+    if warning_logger is None:
+        warning_logger = logger
+
+    match mode:
+        case "throw":
+            raise error_class(msg)
+        case "warn":
+            warning_logger.warning(msg)
+        case "ignore":
+            pass
+        case _:
+            raise ValueError(f"Unknown mode: {mode}")
+
+
+@contextmanager
+def add_exception_context_msg(
+    prefix: str = "",
+    postfix: str = "",
+    unparseable_exception_throw: Literal["throw", "warn", "ignore"] = "throw",
+):
+    try:
+        yield
+    except Exception as e:
+        is_arg_msg = (
+            isinstance(e.args, tuple) and len(e.args) > 0 and isinstance(e.args[0], str)
+        )
+
+        orig_msg = e.args[0] if is_arg_msg else f"{type(e).__name__}: {str(e)}"
+
+        msg = orig_msg
+        if prefix:
+            msg = f"{prefix} {msg}"
+        if postfix and not msg.endswith(postfix):
+            msg = f"{msg} {postfix}"
+
+        if is_arg_msg:
+            e.args = (msg, *e.args[1:])
+            raise e from e
+        else:
+            raise ValueError(msg) from e

procfunc/util/manifest.py

@@ -0,0 +1,121 @@
+"""Utilities for reading and filtering manifest CSV files."""
+
+import importlib
+import logging
+from pathlib import Path
+from typing import Any, Callable
+
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+
+def module_path():
+    return Path(__file__).parent.parent
+
+
+def filter_manifest(
+    manifest: pd.DataFrame,
+    filter: dict[str, str] | None = None,
+    exclude: dict[str, list[str]] | None = None,
+    require_nonempty: list[str] | None = None,
+    min_entries: int | None = None,
+) -> pd.DataFrame:
+    if filter is None:
+        filter = {}
+    if exclude is None:
+        exclude = {}
+    if require_nonempty is None:
+        require_nonempty = []
+
+    for k, v in filter.items():
+        assert k in manifest.columns, (
+            f"Filter {k}={v} did not match any columns in {manifest.columns}"
+        )
+
+        before_count = len(manifest)
+        manifest = manifest.dropna(subset=[k])
+        manifest = manifest[manifest[k] == v]
+        after_count = len(manifest)
+        logger.debug(
+            f"Filter {k}={v}: {before_count} -> {after_count} (dropped {before_count - after_count})"
+        )
+
+    for column, patterns in exclude.items():
+        if not isinstance(patterns, list):
+            patterns = [patterns]
+
+        before_count = len(manifest)
+        if manifest[column].dtype == "object":
+            mask = pd.Series([False] * len(manifest), index=manifest.index)
+            for pattern in patterns:
+                if isinstance(pattern, str):
+                    mask |= manifest[column].str.contains(pattern, na=False)
+                else:
+                    mask |= manifest[column] == pattern
+        else:
+            mask = manifest[column].isin(patterns)
+        manifest = manifest[~mask]
+        after_count = len(manifest)
+        logger.debug(
+            f"Exclude {column} patterns {patterns}: {before_count} -> {after_count} (dropped {before_count - after_count})"
+        )
+
+    if require_nonempty:
+        before_count = len(manifest)
+        manifest = manifest.dropna(subset=require_nonempty)
+        after_count = len(manifest)
+        logger.debug(
+            f"Require nonempty {require_nonempty}: {before_count} -> {after_count} (dropped {before_count - after_count})"
+        )
+
+    if min_entries is not None and len(manifest) < min_entries:
+        raise ValueError(
+            f"Expected at least {min_entries} entries, got {len(manifest)} "
+            f"with {filter=} and {exclude=} and {require_nonempty=}"
+        )
+
+    return manifest
+
+
+def import_item(name: str) -> Any:
+    """
+    Find and import a function or class by its dotted module path.
+
+    Args:
+        name: Dotted module path like "mymodule.generators.objects.funcname"
+
+    Returns:
+        The imported function or class
+
+    Raises:
+        ModuleNotFoundError: If the module or attribute cannot be found
+    """
+    *path_parts, item_name = name.split(".")
+    try:
+        return importlib.import_module("." + item_name, ".".join(path_parts))
+    except Exception as e:
+        if not isinstance(e, ModuleNotFoundError):
+            raise e
+
+    mod = importlib.import_module(".".join(path_parts))
+    try:
+        return getattr(mod, item_name)
+    except AttributeError as e:
+        raise AttributeError(
+            f"Attribute {item_name} not found in module {mod.__name__}, {dir(mod)=}"
+        ) from e
+
+
+def import_item_iterative(name: str, from_mod: Any | None = None) -> Callable:
+    first, *rest = name.split(".")
+
+    if len(rest) == 0:
+        assert from_mod is not None, f"No module specified for {name}"
+        return getattr(from_mod, name)
+    elif from_mod is None:
+        mod = importlib.import_module(first)
+        return import_item_iterative(".".join(rest), mod)
+    else:
+        mod = getattr(from_mod, first)
+        return import_item_iterative(".".join(rest), mod)