cgmath 1.0.2__tar.gz → 1.0.4__tar.gz

{cgmath-1.0.2/cgmath.egg-info → cgmath-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgmath
-Version: 1.0.2
+Version: 1.0.4
 Summary: A DCC-agnostic CG math library: batched matrix, quaternion and euler math, mesh topology, deformers, resampling, skeletal hierarchies, SDFs, a software raytracer and asset IO, all numpy-native.
 Author-email: Eric Vignola <eric.vignola@gmail.com>
 License: ## License
@@ -52,12 +52,22 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: numba
-Requires-Dist: pillow
-Requires-Dist: opencv-python
-Requires-Dist: scikit-image
-Requires-Dist: pygltflib
-Requires-Dist: trimesh
-Requires-Dist: usd-core
+Provides-Extra: image
+Requires-Dist: pillow; extra == "image"
+Requires-Dist: opencv-python; extra == "image"
+Requires-Dist: scikit-image; extra == "image"
+Provides-Extra: gltf
+Requires-Dist: pygltflib; extra == "gltf"
+Requires-Dist: trimesh; extra == "gltf"
+Provides-Extra: usd
+Requires-Dist: usd-core; extra == "usd"
+Provides-Extra: all
+Requires-Dist: pillow; extra == "all"
+Requires-Dist: opencv-python; extra == "all"
+Requires-Dist: scikit-image; extra == "all"
+Requires-Dist: pygltflib; extra == "all"
+Requires-Dist: trimesh; extra == "all"
+Requires-Dist: usd-core; extra == "all"
 Dynamic: license-file
 
 # `cgmath` — a DCC-agnostic CG math library
@@ -234,13 +244,15 @@ follows — full detail in its [README](https://github.com/Eric-Vignola/cgmath/b
 ### Optional dependencies
 
 Imported lazily behind `try / except ImportError`, so the package loads
-without them and only the paths that need them complain.
+without them and only the paths that need them complain. A plain
+`pip install cgmath` brings in none of them; the PyPI ones come as extras,
+see [Requirements](#requirements).
 
 | Dependency | Used for | Missing behaviour |
 |---|---|---|
 | `pygltflib` | GLB / glTF read | `RuntimeError("pygltflib is not installed")` at call time |
 | Autodesk FBX SDK — not on PyPI, a manual install | FBX read / write | imports fine, with one `UserWarning` naming the SDK and where to get it; every FBX call raises `RuntimeError` with that same message |
-| `pxr`, from `usd-core` — installed with the wheel | `cgmath.formats.usd` stage / prim helpers; `from_prim` / `to_prim` / `load_usd` in `geometry` | always present after `pip install`. Run off `sys.path` without it, `import cgmath.formats.usd.prim` itself raises `ImportError` and the `geometry` paths raise `ImportError` at call time (`geometry.utils.pxr()` is the accessor) |
+| `pxr`, from `usd-core` or the host DCC's own USD | `cgmath.formats.usd` stage / prim helpers; `from_prim` / `to_prim` / `load_usd` in `geometry` | `import cgmath.formats.usd.prim` itself raises `ImportError`, and the `geometry` paths raise `ImportError` at call time (`geometry.utils.pxr()` is the accessor) |
 | `trimesh` | `GlbData.mesh_list` | that attribute is `None` |
 | `PIL` (Pillow) | `Frame.image` / `.save` / `.wireframe` / `.encode_gif`, `to_image`, texture I/O | `RuntimeError("... install Pillow.")` at call time |
 | `cv2` | `imshow()` windows; UV rasterization in `geometry.mesh` | `imshow` raises `RuntimeError`; rasterization falls back to `skimage` |
@@ -369,15 +381,22 @@ Start with [`CHEATSHEET.md`](https://github.com/Eric-Vignola/cgmath/blob/main/CH
 
 ## Requirements
 
-Numpy, Scipy and Numba python modules.
+Numpy, Scipy and Numba python modules, the only packages a plain
+`pip install cgmath` brings in.
 
-Optional, per feature (see the table above for how each degrades):
+Everything else is optional, per feature (see the table above for how each
+degrades), and comes as a pip extra:
 
-    Pillow                  texture I/O and rendered frames
-    pygltflib, trimesh      glTF / GLB read and write
-    Autodesk FBX SDK        FBX read and write
-    pxr (USD)               USD stage read and write
-    scikit-image or OpenCV  UV rasterization
+    pip install "cgmath[image]"   Pillow, OpenCV, scikit-image: texture I/O,
+                                  rendered frames, UV rasterization
+    pip install "cgmath[gltf]"    pygltflib, trimesh: glTF / GLB read and write
+    pip install "cgmath[usd]"     usd-core (pxr): USD stage read and write
+    pip install "cgmath[all]"     all of the above
+
+Inside a DCC that ships its own USD (Maya, Houdini), leave `usd` out: a
+second `pxr` on `sys.path` conflicts with the one the host has loaded.
+
+The Autodesk FBX SDK (FBX read and write) is not on PyPI; install it by hand.
 
 
 ## Author

{cgmath-1.0.2 → cgmath-1.0.4}/README.md

@@ -172,13 +172,15 @@ follows — full detail in its [README](https://github.com/Eric-Vignola/cgmath/b
 ### Optional dependencies
 
 Imported lazily behind `try / except ImportError`, so the package loads
-without them and only the paths that need them complain.
+without them and only the paths that need them complain. A plain
+`pip install cgmath` brings in none of them; the PyPI ones come as extras,
+see [Requirements](#requirements).
 
 | Dependency | Used for | Missing behaviour |
 |---|---|---|
 | `pygltflib` | GLB / glTF read | `RuntimeError("pygltflib is not installed")` at call time |
 | Autodesk FBX SDK — not on PyPI, a manual install | FBX read / write | imports fine, with one `UserWarning` naming the SDK and where to get it; every FBX call raises `RuntimeError` with that same message |
-| `pxr`, from `usd-core` — installed with the wheel | `cgmath.formats.usd` stage / prim helpers; `from_prim` / `to_prim` / `load_usd` in `geometry` | always present after `pip install`. Run off `sys.path` without it, `import cgmath.formats.usd.prim` itself raises `ImportError` and the `geometry` paths raise `ImportError` at call time (`geometry.utils.pxr()` is the accessor) |
+| `pxr`, from `usd-core` or the host DCC's own USD | `cgmath.formats.usd` stage / prim helpers; `from_prim` / `to_prim` / `load_usd` in `geometry` | `import cgmath.formats.usd.prim` itself raises `ImportError`, and the `geometry` paths raise `ImportError` at call time (`geometry.utils.pxr()` is the accessor) |
 | `trimesh` | `GlbData.mesh_list` | that attribute is `None` |
 | `PIL` (Pillow) | `Frame.image` / `.save` / `.wireframe` / `.encode_gif`, `to_image`, texture I/O | `RuntimeError("... install Pillow.")` at call time |
 | `cv2` | `imshow()` windows; UV rasterization in `geometry.mesh` | `imshow` raises `RuntimeError`; rasterization falls back to `skimage` |
@@ -307,15 +309,22 @@ Start with [`CHEATSHEET.md`](https://github.com/Eric-Vignola/cgmath/blob/main/CH
 
 ## Requirements
 
-Numpy, Scipy and Numba python modules.
+Numpy, Scipy and Numba python modules, the only packages a plain
+`pip install cgmath` brings in.
 
-Optional, per feature (see the table above for how each degrades):
+Everything else is optional, per feature (see the table above for how each
+degrades), and comes as a pip extra:
 
-    Pillow                  texture I/O and rendered frames
-    pygltflib, trimesh      glTF / GLB read and write
-    Autodesk FBX SDK        FBX read and write
-    pxr (USD)               USD stage read and write
-    scikit-image or OpenCV  UV rasterization
+    pip install "cgmath[image]"   Pillow, OpenCV, scikit-image: texture I/O,
+                                  rendered frames, UV rasterization
+    pip install "cgmath[gltf]"    pygltflib, trimesh: glTF / GLB read and write
+    pip install "cgmath[usd]"     usd-core (pxr): USD stage read and write
+    pip install "cgmath[all]"     all of the above
+
+Inside a DCC that ships its own USD (Maya, Houdini), leave `usd` out: a
+second `pxr` on `sys.path` conflicts with the one the host has loaded.
+
+The Autodesk FBX SDK (FBX read and write) is not on PyPI; install it by hand.
 
 
 ## Author

{cgmath-1.0.2 → cgmath-1.0.4}/__init__.py

@@ -4,4 +4,4 @@ The underlying matrix, quaternion, euler and vector math lives in
 :mod:`cgmath.transforms`.
 """
 
-__version__ = "1.0.2"
+__version__ = "1.0.4"

{cgmath-1.0.2 → cgmath-1.0.4/cgmath.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgmath
-Version: 1.0.2
+Version: 1.0.4
 Summary: A DCC-agnostic CG math library: batched matrix, quaternion and euler math, mesh topology, deformers, resampling, skeletal hierarchies, SDFs, a software raytracer and asset IO, all numpy-native.
 Author-email: Eric Vignola <eric.vignola@gmail.com>
 License: ## License
@@ -52,12 +52,22 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: numba
-Requires-Dist: pillow
-Requires-Dist: opencv-python
-Requires-Dist: scikit-image
-Requires-Dist: pygltflib
-Requires-Dist: trimesh
-Requires-Dist: usd-core
+Provides-Extra: image
+Requires-Dist: pillow; extra == "image"
+Requires-Dist: opencv-python; extra == "image"
+Requires-Dist: scikit-image; extra == "image"
+Provides-Extra: gltf
+Requires-Dist: pygltflib; extra == "gltf"
+Requires-Dist: trimesh; extra == "gltf"
+Provides-Extra: usd
+Requires-Dist: usd-core; extra == "usd"
+Provides-Extra: all
+Requires-Dist: pillow; extra == "all"
+Requires-Dist: opencv-python; extra == "all"
+Requires-Dist: scikit-image; extra == "all"
+Requires-Dist: pygltflib; extra == "all"
+Requires-Dist: trimesh; extra == "all"
+Requires-Dist: usd-core; extra == "all"
 Dynamic: license-file
 
 # `cgmath` — a DCC-agnostic CG math library
@@ -234,13 +244,15 @@ follows — full detail in its [README](https://github.com/Eric-Vignola/cgmath/b
 ### Optional dependencies
 
 Imported lazily behind `try / except ImportError`, so the package loads
-without them and only the paths that need them complain.
+without them and only the paths that need them complain. A plain
+`pip install cgmath` brings in none of them; the PyPI ones come as extras,
+see [Requirements](#requirements).
 
 | Dependency | Used for | Missing behaviour |
 |---|---|---|
 | `pygltflib` | GLB / glTF read | `RuntimeError("pygltflib is not installed")` at call time |
 | Autodesk FBX SDK — not on PyPI, a manual install | FBX read / write | imports fine, with one `UserWarning` naming the SDK and where to get it; every FBX call raises `RuntimeError` with that same message |
-| `pxr`, from `usd-core` — installed with the wheel | `cgmath.formats.usd` stage / prim helpers; `from_prim` / `to_prim` / `load_usd` in `geometry` | always present after `pip install`. Run off `sys.path` without it, `import cgmath.formats.usd.prim` itself raises `ImportError` and the `geometry` paths raise `ImportError` at call time (`geometry.utils.pxr()` is the accessor) |
+| `pxr`, from `usd-core` or the host DCC's own USD | `cgmath.formats.usd` stage / prim helpers; `from_prim` / `to_prim` / `load_usd` in `geometry` | `import cgmath.formats.usd.prim` itself raises `ImportError`, and the `geometry` paths raise `ImportError` at call time (`geometry.utils.pxr()` is the accessor) |
 | `trimesh` | `GlbData.mesh_list` | that attribute is `None` |
 | `PIL` (Pillow) | `Frame.image` / `.save` / `.wireframe` / `.encode_gif`, `to_image`, texture I/O | `RuntimeError("... install Pillow.")` at call time |
 | `cv2` | `imshow()` windows; UV rasterization in `geometry.mesh` | `imshow` raises `RuntimeError`; rasterization falls back to `skimage` |
@@ -369,15 +381,22 @@ Start with [`CHEATSHEET.md`](https://github.com/Eric-Vignola/cgmath/blob/main/CH
 
 ## Requirements
 
-Numpy, Scipy and Numba python modules.
+Numpy, Scipy and Numba python modules, the only packages a plain
+`pip install cgmath` brings in.
 
-Optional, per feature (see the table above for how each degrades):
+Everything else is optional, per feature (see the table above for how each
+degrades), and comes as a pip extra:
 
-    Pillow                  texture I/O and rendered frames
-    pygltflib, trimesh      glTF / GLB read and write
-    Autodesk FBX SDK        FBX read and write
-    pxr (USD)               USD stage read and write
-    scikit-image or OpenCV  UV rasterization
+    pip install "cgmath[image]"   Pillow, OpenCV, scikit-image: texture I/O,
+                                  rendered frames, UV rasterization
+    pip install "cgmath[gltf]"    pygltflib, trimesh: glTF / GLB read and write
+    pip install "cgmath[usd]"     usd-core (pxr): USD stage read and write
+    pip install "cgmath[all]"     all of the above
+
+Inside a DCC that ships its own USD (Maya, Houdini), leave `usd` out: a
+second `pxr` on `sys.path` conflicts with the one the host has loaded.
+
+The Autodesk FBX SDK (FBX read and write) is not on PyPI; install it by hand.
 
 
 ## Author

cgmath-1.0.4/cgmath.egg-info/requires.txt

@@ -0,0 +1,23 @@
+numpy
+scipy
+numba
+
+[all]
+pillow
+opencv-python
+scikit-image
+pygltflib
+trimesh
+usd-core
+
+[gltf]
+pygltflib
+trimesh
+
+[image]
+pillow
+opencv-python
+scikit-image
+
+[usd]
+usd-core

{cgmath-1.0.2 → cgmath-1.0.4}/formats/fbx.py

@@ -2363,21 +2363,6 @@ class SceneData(BaseData):
             self._filename = None
 
 
-def _enum_fields(enum_name: str) -> list:
-    """Splits a Maya enumName ("a=1:b=5:c") into (field, index) pairs.
-
-    A field without an explicit index follows the previous one, the way
-    Maya numbers them.
-    """
-    fields = []
-    index  = -1
-    for token in enum_name.split(":"):
-        name, _, given = token.partition("=")
-        index = int(given) if given else index + 1
-        fields.append((name, index))
-    return fields
-
-
 class FbxExporter:
     """Export fbx files from pipeline components"""
 
@@ -2461,6 +2446,7 @@ class FbxExporter:
         # never writes them as scene nodes. parents come first.
         # imported here, cgmath.hierarchy imports this module.
         from cgmath.hierarchy import SUPPORTED_NODE_TYPES
+        from cgmath.hierarchy.hierarchy import _enum_fields
 
         skipped_nodes = {}
         dropped       = set()

{cgmath-1.0.2 → cgmath-1.0.4}/geometry/_cdt.py

@@ -317,7 +317,7 @@ def maya_tiebreak(mesh):
     Only swaps when ALL conditions are met:
 
     1. The quad is convex (required for a valid flip).
-    2. The alternative diagonal is strictly longer.
+    2. The alternative diagonal is longer, by more than rounding noise.
     3. Min angles of both triangulations are nearly equal (< 0.005 rad).
     4. Circumcircle violation is small relative to quad geometry.
     """
@@ -353,9 +353,11 @@ def maya_tiebreak(mesh):
             if not check_convex(pts, c, d, a, b):
                 continue
 
+            # An exact tie (cocircular points, equal diagonals) must not flip:
+            # its last bits come from the SVD flattening and vary by numpy build.
             len_ab_sq = (pax - pbx) ** 2 + (pay - pby) ** 2
             len_cd_sq = (pcx - pdx) ** 2 + (pcy - pdy) ** 2
-            if len_cd_sq <= len_ab_sq:
+            if len_cd_sq <= len_ab_sq * (1.0 + 1e-9):
                 continue
 
             curr_min = min(

{cgmath-1.0.2 → cgmath-1.0.4}/hierarchy/hierarchy.py

@@ -4,7 +4,7 @@ import os
 import uuid
 from collections.abc import Iterable
 from dataclasses import dataclass
-from typing import List, Optional, Union
+from typing import Any, List, Optional, Union
 
 import numpy as np
 from cgmath.formats.glb import load_gltf, load_model
@@ -288,6 +288,262 @@ def _strip_namespace(name: str, namespace: Optional[str] = None) -> str:
     return ":".join(target[:-1] + spaces[depth:] + [short])
 
 
+# user defined attribute types, by the cmds.addAttr() name, grouped by how a
+# value converts to them
+_FLOAT_TYPES  = ("double", "float", "doubleAngle", "doubleLinear")
+_INT_TYPES    = ("long", "short", "byte", "char")
+_NUMBER_TYPES = _FLOAT_TYPES + _INT_TYPES
+
+# the types add_user_attribute() creates, as attributeType then as dataType
+_NEW_ATTRIBUTE_TYPES = _NUMBER_TYPES + ("bool", "enum")
+_NEW_DATA_TYPES = (
+    "string",
+    "stringArray",
+    "doubleArray",
+    "floatArray",
+    "Int32Array",
+    "vectorArray",
+    "pointArray",
+)
+
+
+def _enum_fields(enum_name: str) -> list:
+    """Splits a Maya enumName ("a=1:b=5:c") into (field, index) pairs.
+
+    A field without an explicit index follows the previous one, the way
+    Maya numbers them.
+    """
+    fields = []
+    index  = -1
+    for token in enum_name.split(":"):
+        name, _, given = token.partition("=")
+        index = int(given) if given else index + 1
+        fields.append((name, index))
+    return fields
+
+
+def _user_attr_type(spec: dict) -> str:
+    """the cmds.addAttr() type name of a user defined attribute spec"""
+    return spec.get("attributeType", spec.get("dataType"))
+
+
+def _to_float(value, label: str) -> float:
+    if isinstance(value, (bool, int, float, np.bool_, np.integer, np.floating)):
+        return float(value)
+    raise TypeError(f"{label} takes a number, got {value!r}")
+
+
+def _to_int(value, label: str) -> int:
+    if isinstance(value, (bool, int, np.bool_, np.integer)):
+        return int(value)
+    if isinstance(value, (float, np.floating)):
+        if float(value).is_integer():
+            return int(value)
+        raise ValueError(f"{label} takes a whole number, got {value!r}")
+    raise TypeError(f"{label} takes a whole number, got {value!r}")
+
+
+def _to_bool(value, label: str) -> bool:
+    if isinstance(value, (bool, np.bool_)):
+        return bool(value)
+    if isinstance(value, (int, float, np.integer, np.floating)):
+        if value in (0, 1):
+            return bool(value)
+        raise ValueError(f"{label} takes True, False, 0 or 1, got {value!r}")
+    raise TypeError(f"{label} takes True, False, 0 or 1, got {value!r}")
+
+
+def _to_enum(value, enum_name: Optional[str], label: str) -> int:
+    fields = _enum_fields(enum_name) if enum_name else []
+    if isinstance(value, str):
+        for field, index in fields:
+            if field == value:
+                return index
+        raise ValueError(
+            f"{label} has no field {value!r}, its fields are {enum_name!r}"
+        )
+    index = _to_int(value, label)
+    if fields and index not in {i for _, i in fields}:
+        raise ValueError(f"{label} has no field {index}, its fields are {enum_name!r}")
+    return index
+
+
+def _to_list(value, label: str) -> list:
+    if isinstance(value, (list, tuple, np.ndarray)):
+        return list(value)
+    raise TypeError(f"{label} takes a list, got {value!r}")
+
+
+def _to_rows(value, size: int, label: str) -> list:
+    rows = []
+    for item in _to_list(value, label):
+        row = [_to_float(x, label) for x in _to_list(item, label)]
+        if len(row) != size:
+            raise ValueError(f"{label} takes rows of {size} numbers, got {item!r}")
+        rows.append(row)
+    return rows
+
+
+def _convert_one(kind: str, spec: dict, value, label: str):
+    """``value`` converted to one value of a user defined attribute of ``kind``;
+    a kind without a rule is stored as given"""
+    if kind in _FLOAT_TYPES:
+        return _to_float(value, label)
+    if kind in _INT_TYPES:
+        return _to_int(value, label)
+    if kind == "bool":
+        return _to_bool(value, label)
+    if kind == "enum":
+        return _to_enum(value, spec.get("enumName"), label)
+    if kind == "string":
+        if isinstance(value, str):
+            return str(value)
+        raise TypeError(f"{label} takes a string, got {value!r}")
+    if kind == "stringArray":
+        items = _to_list(value, label)
+        if all(isinstance(x, str) for x in items):
+            return [str(x) for x in items]
+        raise TypeError(f"{label} takes a list of strings, got {value!r}")
+    if kind in ("doubleArray", "floatArray"):
+        return [_to_float(x, label) for x in _to_list(value, label)]
+    if kind == "Int32Array":
+        return [_to_int(x, label) for x in _to_list(value, label)]
+    if kind == "vectorArray":
+        return _to_rows(value, 3, label)
+    if kind == "pointArray":
+        return _to_rows(value, 4, label)
+    if kind == "matrix":
+        rows = _to_list(value, label)
+        if len(rows) == 4:
+            rows = [x for row in _to_rows(rows, 4, label) for x in row]
+        if len(rows) != 16:
+            raise ValueError(f"{label} takes 16 numbers or 4 rows of 4, got {value!r}")
+        return [_to_float(x, label) for x in rows]
+    return value
+
+
+def _convert_user_value(spec: dict, value, label: str):
+    """``value`` converted to what the user defined attribute ``spec`` stores; a
+    multi attribute stores ``[[index, value], ...]``"""
+    kind = _user_attr_type(spec)
+    if not spec.get("multi"):
+        return _convert_one(kind, spec, value, label)
+
+    pairs = []
+    for pair in _to_list(value, label):
+        if not isinstance(pair, (list, tuple, np.ndarray)) or len(pair) != 2:
+            raise TypeError(f"{label} takes [[index, value], ...], got {value!r}")
+        index = _to_int(pair[0], label)
+        if index < 0:
+            raise ValueError(f"{label} takes indices from 0, got {index}")
+        pairs.append([index, _convert_one(kind, spec, pair[1], label)])
+    return pairs
+
+
+def _compound_children(attrs: dict, name: str) -> list:
+    """the names of a compound user attribute's children, in order"""
+    return [child for child, spec in attrs.items() if spec.get("parent") == name]
+
+
+def _user_value(attrs: dict, name: str):
+    """a user defined attribute's value; a compound parent's comes from its
+    children, as an array when they are all numbers, else as a tuple"""
+    spec = attrs[name]
+    if "numberOfChildren" not in spec:
+        return spec.get("value")
+
+    children = _compound_children(attrs, name)
+    values   = [_user_value(attrs, child) for child in children]
+    numeric = all(
+        _user_attr_type(attrs[child]) in _NUMBER_TYPES
+        and "numberOfChildren" not in attrs[child]
+        and not attrs[child].get("multi")
+        for child in children
+    )
+    return np.array(values) if children and numeric else tuple(values)
+
+
+def _user_writes(attrs: dict, name: str, value, owner: str) -> list:
+    """the (spec, converted value) pairs that setting ``name`` to ``value``
+    stores, all converted before anything is written; a compound parent takes
+    one value per child"""
+    spec  = attrs[name]
+    label = f"{owner}.{name}"
+    if "numberOfChildren" not in spec:
+        return [(spec, _convert_user_value(spec, value, label))]
+
+    children = _compound_children(attrs, name)
+    items    = _to_list(value, label)
+    if len(items) != len(children):
+        raise ValueError(
+            f"{label} takes {len(children)} values, one per child, got {len(items)}"
+        )
+    writes = []
+    for child, item in zip(children, items):
+        writes.extend(_user_writes(attrs, child, item, owner))
+    return writes
+
+
+def _declares(cls: type, name: str) -> bool:
+    """whether ``cls`` or one of its parents annotates ``name`` at class level"""
+    return any(name in vars(c).get("__annotations__", {}) for c in cls.__mro__)
+
+
+def _has_user_attr(node: "TransformData", name: str) -> bool:
+    """whether ``node`` has a user attribute ``name`` a built-in does not hide"""
+    attrs = node.user_defined_attributes or {}
+    return name in attrs and not node._is_builtin_attr(name)
+
+
+def _infer_user_attr_type(value) -> str:
+    """the type a new user attribute takes from its first value"""
+    if isinstance(value, (bool, np.bool_)):
+        return "bool"
+    if isinstance(value, (int, np.integer)):
+        return "long"
+    if isinstance(value, (float, np.floating)):
+        return "double"
+    if isinstance(value, str):
+        return "string"
+    if isinstance(value, (list, tuple, np.ndarray)) and len(value):
+        items   = list(value)
+        numbers = (int, float, np.integer, np.floating)
+        flags   = (bool, np.bool_)
+        if all(isinstance(x, str) for x in items):
+            return "stringArray"
+        if all(isinstance(x, numbers) and not isinstance(x, flags) for x in items):
+            return "doubleArray"
+    raise TypeError(
+        f"cannot tell a user attribute type from {value!r}, pass attribute_type"
+    )
+
+
+def _new_user_attr(
+    value, attribute_type: Optional[str], keyable: bool, enum_names, label: str
+) -> dict:
+    """the spec of a new user defined attribute, in the form rig serializes"""
+    kind = attribute_type or _infer_user_attr_type(value)
+    if kind in _NEW_ATTRIBUTE_TYPES:
+        spec = {"attributeType": kind}
+    elif kind in _NEW_DATA_TYPES:
+        spec = {"dataType": kind}
+    else:
+        raise ValueError(f"add_user_attribute cannot create a {kind!r} attribute")
+
+    if kind == "enum":
+        if not enum_names:
+            raise ValueError(
+                "an enum user attribute needs enum_names, e.g. 'a=1:b=5:c'"
+            )
+        spec["enumName"] = enum_names
+
+    # Maya can not key strings or arrays
+    spec["value"]       = _convert_user_value(spec, value, label)
+    spec["keyable"]     = bool(keyable) and "attributeType" in spec
+    spec["channel_box"] = False
+    return spec
+
+
 @dataclass(repr=False, eq=False)
 class TransformData(Data):
     # name, node_type, uuid, and parent_node
@@ -1158,6 +1414,88 @@ class TransformData(Data):
                     )
         self.name = new
 
+    # --- user defined attributes, as properties --- #
+
+    def _is_builtin_attr(self, name: str) -> bool:
+        """whether ``name`` is a field, property or method of the class"""
+        return hasattr(type(self), name) or name in self._dataclass_field_names()
+
+    def __getattr__(self, name: str):
+        """a user defined attribute's value, read as ``node.heroHeight``
+
+        Only reached when normal lookup fails, so built-in names always win.
+        """
+        attrs = self.__dict__.get("user_defined_attributes")
+        if attrs and not name.startswith("_") and name in attrs:
+            return _user_value(attrs, name)
+        raise AttributeError(
+            f"{type(self).__name__!r} object has no attribute {name!r}"
+        )
+
+    def __setattr__(self, name: str, value) -> None:
+        """sets a user defined attribute the node has, as ``node.heroHeight =
+        3.1416``, converted to its type; anything else goes to Data, which
+        raises on names the class does not declare"""
+        if not name.startswith("_"):
+            attrs = self.__dict__.get("user_defined_attributes")
+            if attrs and name in attrs and not self._is_builtin_attr(name):
+                for spec, converted in _user_writes(attrs, name, value, self.name):
+                    spec["value"] = converted
+                return
+
+        try:
+            super().__setattr__(name, value)
+        except AttributeError as error:
+            if self._is_builtin_attr(name):
+                raise
+            raise AttributeError(
+                f"{error}; add_user_attribute() creates a user attribute"
+            ) from None
+
+    def __dir__(self):
+        attrs = self.__dict__.get("user_defined_attributes") or {}
+        return sorted(set(super().__dir__()) | set(attrs))
+
+    def _check_new_user_attr(self, name: str) -> None:
+        """raises ValueError when ``name`` can not be a new user attribute"""
+        if not isinstance(name, str) or not name.isidentifier() or name.startswith("_"):
+            raise ValueError(f"{name!r} is not a valid user attribute name")
+        if self._is_builtin_attr(name):
+            raise ValueError(
+                f"{name!r} is a built-in attribute of {type(self).__name__}"
+            )
+        if name in (self.user_defined_attributes or {}):
+            raise ValueError(f"{self.name} already has a user attribute {name!r}")
+
+    def add_user_attribute(
+        self,
+        name:           str,
+        value:          Any,
+        attribute_type: Optional[str] = None,
+        keyable:        bool          = True,
+        enum_names:     Optional[str] = None,
+    ) -> None:
+        """creates a user defined attribute, then read and set as ``node.name``
+
+        ``attribute_type`` is a cmds.addAttr() type: double, float, doubleAngle,
+        doubleLinear, long, short, byte, char, bool, enum, string, stringArray,
+        doubleArray, floatArray, Int32Array, vectorArray or pointArray. Without
+        one it comes from ``value``: bool, long, double, string, stringArray or
+        doubleArray. An enum needs ``enum_names``, e.g. ``"a=1:b=5:c"``. String
+        and array attributes are never keyable, as in Maya.
+
+        Raises ValueError when the name exists, is built in or is not a valid
+        attribute name, and TypeError or ValueError when the value does not
+        fit the type.
+        """
+        self._check_new_user_attr(name)
+        spec = _new_user_attr(
+            value, attribute_type, keyable, enum_names, f"{self.name}.{name}"
+        )
+        if self.user_defined_attributes is None:
+            self.user_defined_attributes = {}
+        self.user_defined_attributes[name] = spec
+
 
 def _read_fbx(filename: str, scale_factor: float):
     """opens an fbx and walks its joints into TransformData dicts
@@ -1625,6 +1963,72 @@ class TransformList(DataList):
         for node in self:
             node.name = renamed[id(node)]
 
+    # --- user defined attributes, as properties --- #
+
+    def __getattr__(self, name: str):
+        """a user defined attribute read on every node of the view, as
+        ``h.heroHeight``: one value per node, None where a node has none"""
+        nodes = None if name.startswith("_") else self.__dict__.get("list")
+        if nodes and any(_has_user_attr(node, name) for node in nodes):
+            return [
+                _user_value(node.user_defined_attributes, name)
+                if _has_user_attr(node, name)
+                else None
+                for node in nodes
+            ]
+        raise AttributeError(
+            f"{type(self).__name__!r} object has no attribute {name!r}"
+        )
+
+    def __setattr__(self, name: str, value) -> None:
+        """sets a user defined attribute on every node of the view that has it,
+        as ``h.heroHeight = 1.8``: every value is converted before any is
+        written. A name no node has raises instead of landing on the list,
+        unless the class declares it."""
+        own = name.startswith("_") or name == "list" or name in self.__dict__
+        if own or hasattr(type(self), name) or _declares(type(self), name):
+            super().__setattr__(name, value)
+            return
+
+        nodes = [n for n in self.__dict__.get("list", []) if _has_user_attr(n, name)]
+        if not nodes:
+            raise AttributeError(
+                f"{type(self).__name__!r} has no attribute {name!r} and no node has "
+                f"a user attribute of that name; add_user_attribute() creates one"
+            )
+        writes = []
+        for node in nodes:
+            attrs = node.user_defined_attributes
+            writes.extend(_user_writes(attrs, name, value, node.name))
+        for spec, converted in writes:
+            spec["value"] = converted
+
+    def __dir__(self):
+        names = set(super().__dir__())
+        for node in self.__dict__.get("list", []):
+            names.update(node.user_defined_attributes or {})
+        return sorted(names)
+
+    def add_user_attribute(
+        self,
+        name:           str,
+        value:          Any,
+        attribute_type: Optional[str] = None,
+        keyable:        bool          = True,
+        enum_names:     Optional[str] = None,
+    ) -> None:
+        """add_user_attribute() on every node of the view, all or nothing"""
+        specs = []
+        for node in self:
+            node._check_new_user_attr(name)
+            label = f"{node.name}.{name}"
+            spec  = _new_user_attr(value, attribute_type, keyable, enum_names, label)
+            specs.append((node, spec))
+        for node, spec in specs:
+            if node.user_defined_attributes is None:
+                node.user_defined_attributes = {}
+            node.user_defined_attributes[name] = spec
+
     def _parent_first(self) -> List[int]:
         """view indices ordered so an ancestor is always written before a child
 

{cgmath-1.0.2 → cgmath-1.0.4}/pyproject.toml

@@ -14,7 +14,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name            = "cgmath"
-version         = "1.0.2"
+version         = "1.0.4"
 description     = "A DCC-agnostic CG math library: batched matrix, quaternion and euler math, mesh topology, deformers, resampling, skeletal hierarchies, SDFs, a software raytracer and asset IO, all numpy-native."
 readme          = "README.md"
 requires-python = ">=3.9"
@@ -32,32 +32,47 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Mathematics",
 ]
 
-# THREE of these are the real dependencies -- numpy, scipy and numba.
-# Without them cgmath does not import. Everything after them is
-# OPTIONAL to the library: each is imported under a guard that degrades to
-# None, so cgmath runs without it and only the feature named beside it goes
-# quiet.
+# Only numpy, scipy and numba are required: without them cgmath does not
+# import. Everything else is OPTIONAL to the library -- each is imported under
+# a guard, so cgmath runs without it and only the feature named beside it
+# complains -- and comes as an extra:
 #
-# They are declared as requirements anyway, deliberately. A plain
-# `pip install` should hand somebody a complete tool rather than a core that
-# silently lacks half its file formats, and every one of them is a wheel on
-# PyPI that costs nothing but disk. Anyone who wants the three alone can
-# install them and drop the package on sys.path, which is how this library
-# was used before it was packaged.
+#   pip install cgmath                numpy, scipy and numba only
+#   pip install "cgmath[gltf,usd]"    plus the chosen features
+#   pip install "cgmath[all]"         everything on PyPI
+#
+# Up to 1.0.3 the extras were plain requirements, so that a bare
+# `pip install` handed over the complete tool. That broke DCC hosts: usd-core
+# brings its own `pxr`, and a second USD build on sys.path collides with the
+# one Maya or Houdini has already loaded. So inside a DCC, leave `usd` out.
+# The Autodesk FBX SDK is not on PyPI and is installed by hand.
 dependencies = [
-    # --- core ---------------------------------------------------------
     "numpy",
     "scipy",
     "numba",
+]
 
-    # --- optional: installed for convenience, guarded in the source -----
+[project.optional-dependencies]
+image = [
     "pillow",         # image read/write behind textures, frames and scenes
     "opencv-python",  # image ops in geometry.mesh and render.scene
     "scikit-image",   # image measurement helpers in geometry.mesh
+]
+gltf = [
     "pygltflib",      # GLB/glTF read and write, and the hierarchy importer
     "trimesh",        # mesh interchange behind the GLB path
+]
+usd = [
     "usd-core",       # USD stage and prim reading
 ]
+all = [
+    "pillow",
+    "opencv-python",
+    "scikit-image",
+    "pygltflib",
+    "trimesh",
+    "usd-core",
+]
 
 [project.urls]
 Homepage      = "https://github.com/Eric-Vignola/cgmath"

{cgmath-1.0.2 → cgmath-1.0.4}/render/scene.py

@@ -1714,6 +1714,18 @@ class Scene(HierarchyData):
       signature spec.
     """
 
+    # render settings __init__ and configure() set on the instance, declared so
+    # the hierarchy lists' strict setter accepts them
+    aspect_ratio:        Optional[float]
+    default_camera_name: Optional[str]
+    resolution:          Optional[Tuple[int, int]]
+    samples_per_pixel:   Optional[int]
+    autofit:             Optional[bool]
+    default_light:       Optional[bool]
+    return_depth:        Optional[bool]
+    angle_of_view:       Optional[float]
+    fit_padding:         Optional[float]
+
     def __init__(
         self,
         name:                str                                             = "scene",

cgmath-1.0.2/cgmath.egg-info/requires.txt

@@ -1,9 +0,0 @@
-numpy
-scipy
-numba
-pillow
-opencv-python
-scikit-image
-pygltflib
-trimesh
-usd-core