cartesian-tree 0.3.0__tar.gz → 0.4.0__tar.gz

{cartesian_tree-0.3.0 → cartesian_tree-0.4.0}/Cargo.lock

@@ -4,13 +4,14 @@ version = 4
 
 [[package]]
 name = "CartesianTree"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "approx",
  "nalgebra",
  "pyo3",
  "serde",
  "serde_json",
+ "slotmap",
  "thiserror",
  "uuid",
 ]
@@ -383,6 +384,15 @@ dependencies = [
  "wide",
 ]
 
+[[package]]
+name = "slotmap"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038"
+dependencies = [
+ "version_check",
+]
+
 [[package]]
 name = "syn"
 version = "2.0.101"
@@ -449,6 +459,12 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
 [[package]]
 name = "wasi"
 version = "0.14.7+wasi-0.2.4"

{cartesian_tree-0.3.0 → cartesian_tree-0.4.0}/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 authors = ["Kn0g"]
 name = "CartesianTree"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2024"
 description = "Build hierarchical Cartesian coordinate systems to easily transform poses."
 homepage = "https://github.com/Kn0g/cartesian-tree"
@@ -13,16 +13,19 @@ keywords = ["Cartesian", "coordinate-systems", "transform", "poses"]
 categories = ["mathematics", "data-structures"]
 
 [lints.clippy]
-all = "warn"
-style = "warn"
-pedantic = "warn"
-cargo = "warn"
-nursery = "warn"
+all = { level = "warn", priority = -1 }
+style = { level = "warn", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+cargo = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
 missing_panics_doc = "warn"
 missing_errors_doc = "warn"
 missing_safety_doc = "warn"
 empty_line_after_outer_attr = "warn"
 empty_line_after_doc_comments = "warn"
+# Guards in this crate are already scoped as tightly as the borrow checker allows;
+# this nursery lint's suggestions frequently do not compile here.
+significant_drop_tightening = "allow"
 
 [dependencies]
 nalgebra = { version = "0.33.2", features = ["serde-serialize"] }
@@ -30,9 +33,12 @@ pyo3 = { version = "0.25.0", features = ["extension-module"] , optional = true}
 thiserror = "2.0.12"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-approx = "0.5.1"
+slotmap = "1"
 uuid = { version = "1", features = ["v4"] }
 
+[dev-dependencies]
+approx = "0.5.1"
+
 [features]
 bindings = ["dep:pyo3"]
 

{cartesian_tree-0.3.0 → cartesian_tree-0.4.0}/PKG-INFO

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: cartesian-tree
-Version: 0.3.0
+Version: 0.4.0
 Classifier: Programming Language :: Python
+Requires-Dist: maturin==1.8.6 ; extra == 'build'
 Requires-Dist: cartesian-tree[lint] ; extra == 'dev'
 Requires-Dist: cartesian-tree[test] ; extra == 'dev'
 Requires-Dist: cartesian-tree[build] ; extra == 'dev'
 Requires-Dist: ruff==0.12.4 ; extra == 'lint'
 Requires-Dist: mypy==1.17.0 ; extra == 'lint'
 Requires-Dist: pytest==8.4.1 ; extra == 'test'
-Requires-Dist: maturin==1.8.6 ; extra == 'build'
+Provides-Extra: build
 Provides-Extra: dev
 Provides-Extra: lint
 Provides-Extra: test
-Provides-Extra: build
 License-File: license-mit
 Summary: Build hierarchical Cartesian coordinate systems to easily transform poses.
 Keywords: Cartesian,coordinate systems,transform,poses
@@ -31,6 +31,7 @@ cartesian-tree is a library for managing and transforming poses in a tree-struct
 - Poses and Transformations: A Pose represents a position + orientation in a frame. Easily transform poses between frames of the same tree.
 - Unified Rotations: Supports quaternions and roll-pitch-yaw (RPY) interchangeably.
 - Lazy Operations: Quick adjustments like translations (`+ x(1.0)`) or rotations (`* rz(PI/4)`).
+- Thread Safety: Frames and poses can be shared across threads; every operation sees a consistent snapshot of the tree.
 
 ## Installation
 The project can be found on [crates.io](https://crates.io/crates/cartesiantree) and [pypi.org](https://pypi.org/project/cartesian-tree/#description)
@@ -60,7 +61,7 @@ fn main() {
     // Transform the pose to the child frame
     let pose_in_child = pose.in_frame(&child).unwrap();
 
-    println!("Pose in child: {:?}", pose_in_base.transformation());
+    println!("Pose in child: {:?}", pose_in_child.transformation());
 ```
 Python:
 

{cartesian_tree-0.3.0 → cartesian_tree-0.4.0}/README.md

@@ -7,6 +7,7 @@ cartesian-tree is a library for managing and transforming poses in a tree-struct
 - Poses and Transformations: A Pose represents a position + orientation in a frame. Easily transform poses between frames of the same tree.
 - Unified Rotations: Supports quaternions and roll-pitch-yaw (RPY) interchangeably.
 - Lazy Operations: Quick adjustments like translations (`+ x(1.0)`) or rotations (`* rz(PI/4)`).
+- Thread Safety: Frames and poses can be shared across threads; every operation sees a consistent snapshot of the tree.
 
 ## Installation
 The project can be found on [crates.io](https://crates.io/crates/cartesiantree) and [pypi.org](https://pypi.org/project/cartesian-tree/#description)
@@ -36,7 +37,7 @@ fn main() {
     // Transform the pose to the child frame
     let pose_in_child = pose.in_frame(&child).unwrap();
 
-    println!("Pose in child: {:?}", pose_in_base.transformation());
+    println!("Pose in child: {:?}", pose_in_child.transformation());
 ```
 Python:
 

{cartesian_tree-0.3.0 → cartesian_tree-0.4.0}/pyproject.toml

@@ -68,7 +68,7 @@ docstring-code-format = true
 disallow_untyped_defs = true
 warn_unused_ignores = true
 exclude = [
-    "scr/",
+    "src/",
     "venv.*/",
     "log/",
     "target/",

cartesian_tree-0.4.0/python/cartesian_tree/_cartesian_tree.pyi

@@ -0,0 +1,95 @@
+# Type stubs for the Rust extension module `cartesian_tree._cartesian_tree`.
+# Keep in sync with the pymethods in src/bindings/.
+
+class Vector3:
+    def __init__(self, x: float, y: float, z: float) -> None: ...
+    @property
+    def x(self) -> float: ...
+    @property
+    def y(self) -> float: ...
+    @property
+    def z(self) -> float: ...
+    def to_tuple(self) -> tuple[float, float, float]: ...
+
+class Rotation:
+    @classmethod
+    def from_quaternion(cls, x: float, y: float, z: float, w: float) -> Rotation: ...
+    @classmethod
+    def from_rpy(cls, roll: float, pitch: float, yaw: float) -> Rotation: ...
+    @classmethod
+    def identity(cls) -> Rotation: ...
+    def as_quaternion(self) -> tuple[float, float, float, float]: ...
+    def as_rpy(self) -> tuple[float, float, float]: ...
+
+class Isometry:
+    @classmethod
+    def identity(cls) -> Isometry: ...
+    @classmethod
+    def from_translation(cls, translation: Vector3) -> Isometry: ...
+    @classmethod
+    def from_rotation(cls, rotation: Rotation) -> Isometry: ...
+    @classmethod
+    def from_parts(cls, translation: Vector3, rotation: Rotation) -> Isometry: ...
+    def decompose(self) -> tuple[Vector3, Rotation]: ...
+    def translation(self) -> Vector3: ...
+    def rotation(self) -> Rotation: ...
+    def inverse(self) -> Isometry: ...
+    def __mul__(self, other: Isometry) -> Isometry: ...
+
+class LazyTranslation: ...
+class LazyRotation: ...
+
+class Frame:
+    def __init__(self, name: str) -> None: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def depth(self) -> int: ...
+    @property
+    def position(self) -> Vector3: ...
+    @property
+    def orientation(self) -> Rotation: ...
+    def add_child(self, name: str, position: Vector3, orientation: Rotation) -> Frame: ...
+    def remove_child(self, name: str) -> None: ...
+    def calibrate_child(
+        self,
+        name: str,
+        desired_position: Vector3,
+        desired_orientation: Rotation,
+        reference_pose: Pose,
+    ) -> Frame: ...
+    def add_pose(self, position: Vector3, orientation: Rotation) -> Pose: ...
+    def transformation(self) -> tuple[Vector3, Rotation]: ...
+    def set(self, position: Vector3, orientation: Rotation) -> None: ...
+    def apply_in_parent_frame(self, isometry: Isometry) -> None: ...
+    def apply_in_local_frame(self, isometry: Isometry) -> None: ...
+    def to_json(self) -> str: ...
+    def apply_config(self, json: str) -> None: ...
+    def root(self) -> Frame: ...
+    def parent(self) -> Frame | None: ...
+    def children(self) -> list[Frame]: ...
+    def __add__(self, other: LazyTranslation) -> Frame: ...
+    def __sub__(self, other: LazyTranslation) -> Frame: ...
+    def __mul__(self, other: LazyRotation) -> Frame: ...
+
+class Pose:
+    def frame(self) -> Frame | None: ...
+    @property
+    def position(self) -> Vector3: ...
+    @property
+    def orientation(self) -> Rotation: ...
+    def transformation(self) -> tuple[Vector3, Rotation]: ...
+    def set(self, position: Vector3, orientation: Rotation) -> None: ...
+    def apply_in_parent_frame(self, isometry: Isometry) -> None: ...
+    def apply_in_local_frame(self, isometry: Isometry) -> None: ...
+    def in_frame(self, target_frame: Frame) -> Pose: ...
+    def __add__(self, other: LazyTranslation) -> Pose: ...
+    def __sub__(self, other: LazyTranslation) -> Pose: ...
+    def __mul__(self, other: LazyRotation) -> Pose: ...
+
+def x(value: float) -> LazyTranslation: ...
+def y(value: float) -> LazyTranslation: ...
+def z(value: float) -> LazyTranslation: ...
+def rx(value: float) -> LazyRotation: ...
+def ry(value: float) -> LazyRotation: ...
+def rz(value: float) -> LazyRotation: ...

{cartesian_tree-0.3.0 → cartesian_tree-0.4.0}/python/cartesian_tree/angles.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from cartesian_tree import _cartesian_tree as _core  # type: ignore[attr-defined]
+from cartesian_tree import _cartesian_tree as _core
 
 
 class RPY:
@@ -56,6 +56,15 @@ class RPY:
         """
         return self._core_rotation.as_rpy()
 
+    def __eq__(self, other: object) -> bool:
+        """Exact component-wise equality of the angle values (no angle wrapping)."""
+        if not isinstance(other, RPY):
+            return NotImplemented
+        return self.as_tuple() == other.as_tuple()
+
+    def __hash__(self) -> int:
+        return hash(self.as_tuple())
+
     @classmethod
     def _from_rust(cls, rust_rotation: _core.Rotation) -> RPY:
         instance = cls.__new__(cls)

{cartesian_tree-0.3.0 → cartesian_tree-0.4.0}/python/cartesian_tree/base_types.py

@@ -6,7 +6,7 @@ from typing import Any
 
 from .angles import RPY
 from .quaternion import Quaternion
-from cartesian_tree import _cartesian_tree as _core  # type: ignore[attr-defined]
+from cartesian_tree import _cartesian_tree as _core
 
 
 class Rotation:
@@ -14,10 +14,23 @@ class Rotation:
 
     _core_rotation: _core.Rotation
 
+    def __init__(self) -> None:
+        """Rotations cannot be constructed directly.
+
+        Use one of the classmethods instead: from_quaternion, from_rpy, or identity.
+
+        Raises:
+            TypeError: Always.
+        """
+        msg = "Rotation cannot be constructed directly; use from_quaternion(), from_rpy(), or identity() instead."
+        raise TypeError(msg)
+
     @classmethod
     def from_quaternion(cls, x: float, y: float, z: float, w: float) -> Rotation:
         """Initializes the rotation from quaternion values.
 
+        Note, the quaternion does not need to be normalized; it is normalized internally.
+
         Args:
             x: The x value.
             y: The y value.
@@ -26,6 +39,9 @@ class Rotation:
 
         Returns:
             The initialized instance.
+
+        Raises:
+            ValueError: If the quaternion's norm is too close to zero to normalize.
         """
         instance = cls.__new__(cls)
         instance._core_rotation = _core.Rotation.from_quaternion(x, y, z, w)
@@ -70,6 +86,15 @@ class Rotation:
         """
         return RPY._from_rust(self._core_rotation)
 
+    def __eq__(self, other: object) -> bool:
+        """Whether both represent the same rotation, regardless of representation."""
+        if not isinstance(other, Rotation):
+            return NotImplemented
+        return self.as_quaternion() == other.as_quaternion()
+
+    def __hash__(self) -> int:
+        return hash(self.as_quaternion())
+
     @property
     def _binding_structure(self) -> Any:
         return self._core_rotation
@@ -124,6 +149,15 @@ class Vector3:
         """The z value."""
         return self._core_vector.z
 
+    def __eq__(self, other: object) -> bool:
+        """Exact component-wise equality."""
+        if not isinstance(other, Vector3):
+            return NotImplemented
+        return self.as_tuple() == other.as_tuple()
+
+    def __hash__(self) -> int:
+        return hash(self.as_tuple())
+
     @property
     def _binding_structure(self) -> Any:
         return self._core_vector
@@ -156,12 +190,26 @@ class Isometry:
 
     _core_isometry: _core.Isometry
 
+    def __init__(self) -> None:
+        """Isometries cannot be constructed directly.
+
+        Use one of the classmethods instead: identity, from_translation, from_rotation, or from_parts.
+
+        Raises:
+            TypeError: Always.
+        """
+        msg = (
+            "Isometry cannot be constructed directly; "
+            "use identity(), from_translation(), from_rotation(), or from_parts() instead."
+        )
+        raise TypeError(msg)
+
     @classmethod
     def identity(cls) -> Isometry:
-        """Initializes the identity isometry.
+        """Initializes the identity isometry (no translation, no rotation).
 
-        This isometry applies the rotation R with its axis passing through the point P.
-        This effectively lets P invariant.
+        Returns:
+            The identity isometry.
         """
         instance = cls.__new__(cls)
         instance._core_isometry = _core.Isometry.identity()
@@ -252,6 +300,15 @@ class Isometry:
     def __mul__(self, other: Isometry) -> Isometry:
         return Isometry._from_rust(self._core_isometry.__mul__(other._binding_structure))
 
+    def __eq__(self, other: object) -> bool:
+        """Whether translation and rotation are equal (rotation compared representation-independently)."""
+        if not isinstance(other, Isometry):
+            return NotImplemented
+        return self.translation() == other.translation() and self.rotation() == other.rotation()
+
+    def __hash__(self) -> int:
+        return hash((self.translation(), self.rotation()))
+
     @property
     def _binding_structure(self) -> Any:
         return self._core_isometry

{cartesian_tree-0.3.0 → cartesian_tree-0.4.0}/python/cartesian_tree/lazy_access.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from cartesian_tree import _cartesian_tree as _core  # type: ignore[attr-defined]
+from cartesian_tree import _cartesian_tree as _core
 
 
 class LazyTranslation:
@@ -10,6 +10,15 @@ class LazyTranslation:
 
     inner: _core.LazyTranslation
 
+    def __init__(self) -> None:
+        """Lazy translations cannot be constructed directly; use x(), y(), or z() instead.
+
+        Raises:
+            TypeError: Always.
+        """
+        msg = "LazyTranslation cannot be constructed directly; use x(), y(), or z() instead."
+        raise TypeError(msg)
+
     @classmethod
     def _from_rust(cls, rust_lazy_access: _core.LazyTranslation) -> LazyTranslation:
         instance = cls.__new__(cls)
@@ -61,6 +70,15 @@ class LazyRotation:
 
     inner: _core.LazyRotation
 
+    def __init__(self) -> None:
+        """Lazy rotations cannot be constructed directly; use rx(), ry(), or rz() instead.
+
+        Raises:
+            TypeError: Always.
+        """
+        msg = "LazyRotation cannot be constructed directly; use rx(), ry(), or rz() instead."
+        raise TypeError(msg)
+
     @classmethod
     def _from_rust(cls, rust_lazy_access: _core.LazyRotation) -> LazyRotation:
         instance = cls.__new__(cls)

{cartesian_tree-0.3.0 → cartesian_tree-0.4.0}/python/cartesian_tree/lib.py

@@ -1,11 +1,11 @@
-"""Defines a the main lib classes."""
+"""Defines the main library classes."""
 
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
 from .base_types import Isometry, Rotation, Vector3
-from cartesian_tree import _cartesian_tree as _core  # type: ignore[attr-defined]
+from cartesian_tree import _cartesian_tree as _core
 
 if TYPE_CHECKING:
     from .lazy_access import LazyRotation, LazyTranslation
@@ -16,6 +16,15 @@ class Frame:
 
     Each frame can have one parent and multiple children. The frame stores its
     transformation (position and orientation) relative to its parent.
+
+    All frames of a tree share ownership of the tree: keeping any Frame (or Pose)
+    alive keeps the whole tree alive, so a leaf reference is always enough to reach
+    the root. Frames removed via remove_child become stale, and operations on stale
+    frames raise a ValueError.
+
+    Frames can be shared freely across threads: all operations are synchronized
+    through a tree-wide read/write lock, and every operation sees a consistent
+    snapshot of the tree.
     """
 
     def __init__(self, name: str) -> None:
@@ -38,13 +47,21 @@ class Frame:
 
     @property
     def position(self) -> Vector3:
-        """The position of the frame relative to its parent."""
+        """The position of the frame relative to its parent.
+
+        Raises:
+            ValueError: If the frame has been removed from its tree.
+        """
         binding_position = self._core_frame.position
         return Vector3(*binding_position.to_tuple())
 
     @property
     def orientation(self) -> Rotation:
-        """The orientation of the frame relative to its parent."""
+        """The orientation of the frame relative to its parent.
+
+        Raises:
+            ValueError: If the frame has been removed from its tree.
+        """
         binding_orientation = self._core_frame.orientation
         return Rotation._from_rust(binding_orientation)
 
@@ -65,6 +82,20 @@ class Frame:
         binding_frame = self._core_frame.add_child(name, position._binding_structure, orientation._binding_structure)
         return Frame._from_rust(binding_frame)
 
+    def remove_child(self, name: str) -> None:
+        """Removes the child with the given name and its entire subtree from the tree.
+
+        Existing Frame objects referring to removed frames become stale and raise a
+        ValueError when used.
+
+        Args:
+            name: The name of the child frame to remove.
+
+        Raises:
+            ValueError: If no child with the given name exists.
+        """
+        self._core_frame.remove_child(name)
+
     def calibrate_child(
         self, name: str, desired_position: Vector3, desired_orientation: Rotation, reference_pose: Pose
     ) -> Frame:
@@ -168,15 +199,16 @@ class Frame:
     def apply_config(self, config_json: str) -> None:
         """Applies a JSON config to update matching transforms in the tree.
 
-        Deserializes the JSON to a temporary structure, then recursively updates transforms to the
-        parent frames where names match (partial apply; ignores unmatched frames in config).
+        Deserializes the JSON to a temporary structure, then recursively updates the transforms
+        of frames whose names match (partial apply; unmatched frames in the config are ignored).
         It is assumed this frame is the root.
 
         Args:
             config_json: The JSON string to apply.
 
         Raises:
-            ValueError: On deserialization or mismatch errors (e.g. if this frame is not the root).
+            ValueError: On deserialization or mismatch errors (e.g. if this frame is not the root),
+                or if an orientation in the config cannot be normalized.
         """
         self._core_frame.apply_config(config_json)
 
@@ -239,9 +271,26 @@ class Pose:
 
     _core_pose: _core.Pose
 
-    def frame(self) -> Frame:
-        """Returns the frame of the pose."""
-        return Frame._from_rust(self._core_pose.frame())
+    def __init__(self) -> None:
+        """Poses cannot be constructed directly; use Frame.add_pose instead.
+
+        Raises:
+            TypeError: Always.
+        """
+        msg = "Pose cannot be constructed directly; use Frame.add_pose() instead."
+        raise TypeError(msg)
+
+    def frame(self) -> Frame | None:
+        """Returns the frame of the pose.
+
+        Returns:
+            The frame the pose is attached to, or None if the frame has been removed
+            from the tree.
+        """
+        binding_frame = self._core_pose.frame()
+        if binding_frame is None:
+            return None
+        return Frame._from_rust(binding_frame)
 
     def transformation(self) -> tuple[Vector3, Rotation]:
         """Returns the transformation of the pose to its parent frame.
@@ -291,9 +340,6 @@ class Pose:
         Args:
             isometry: The isometry (describing a motion in this frame) to apply to the current
                 transformation.
-
-        Raises:
-            ValueError: If the frame has no parent.
         """
         self._core_pose.apply_in_local_frame(isometry._binding_structure)
 

{cartesian_tree-0.3.0 → cartesian_tree-0.4.0}/python/cartesian_tree/quaternion.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from cartesian_tree import _cartesian_tree as _core  # type: ignore[attr-defined]
+from cartesian_tree import _cartesian_tree as _core
 
 
 class Quaternion:
@@ -18,6 +18,9 @@ class Quaternion:
             y: The y value.
             z: The z value.
             w: The w value.
+
+        Raises:
+            ValueError: If the quaternion's norm is too close to zero to normalize.
         """
         self._core_rotation = _core.Rotation.from_quaternion(x, y, z, w)
 
@@ -72,6 +75,23 @@ class Quaternion:
         """
         return self._core_rotation.as_quaternion()
 
+    def _canonical(self) -> tuple[float, float, float, float]:
+        """Returns the components with the sign chosen such that q and -q map to the same tuple."""
+        q = self.as_tuple()
+        for component in q:
+            if component != 0.0:
+                return q if component > 0.0 else (-q[0], -q[1], -q[2], -q[3])
+        return q
+
+    def __eq__(self, other: object) -> bool:
+        """Exact component-wise equality, treating q and -q as the same rotation."""
+        if not isinstance(other, Quaternion):
+            return NotImplemented
+        return self._canonical() == other._canonical()
+
+    def __hash__(self) -> int:
+        return hash(self._canonical())
+
     @classmethod
     def _from_rust(cls, rust_rotation: _core.Rotation) -> Quaternion:
         instance = cls.__new__(cls)

{cartesian_tree-0.3.0 → cartesian_tree-0.4.0}/src/bindings/frame.rs

@@ -10,7 +10,7 @@ use crate::{
     tree::{HasChildren, HasParent, Walking},
 };
 
-#[pyclass(name = "Frame", unsendable)]
+#[pyclass(name = "Frame")]
 #[derive(Clone)]
 pub struct PyFrame {
     pub(crate) rust_frame: RustFrame,
@@ -46,6 +46,12 @@ impl PyFrame {
         })
     }
 
+    #[pyo3(signature = (name))]
+    fn remove_child(&self, name: &str) -> PyResult<()> {
+        self.rust_frame.remove_child(name)?;
+        Ok(())
+    }
+
     #[pyo3(signature = (name, desired_position, desired_orientation, reference_pose))]
     fn calibrate_child(
         &self,
@@ -86,17 +92,17 @@ impl PyFrame {
     }
 
     #[getter]
-    fn position(&self) -> PyVector3 {
-        PyVector3 {
-            inner: self.rust_frame.position(),
-        }
+    fn position(&self) -> PyResult<PyVector3> {
+        Ok(PyVector3 {
+            inner: self.rust_frame.position()?,
+        })
     }
 
     #[getter]
-    fn orientation(&self) -> PyRotation {
-        PyRotation {
-            rust_rotation: self.rust_frame.orientation(),
-        }
+    fn orientation(&self) -> PyResult<PyRotation> {
+        Ok(PyRotation {
+            rust_rotation: self.rust_frame.orientation()?,
+        })
     }
 
     #[pyo3(signature = (position, orientation))]

{cartesian_tree-0.3.0 → cartesian_tree-0.4.0}/src/bindings/lazy_access.rs

@@ -9,12 +9,12 @@ use crate::lazy_access::x as rust_x;
 use crate::lazy_access::y as rust_y;
 use crate::lazy_access::z as rust_z;
 
-#[pyclass(name = "LazyTranslation", unsendable)]
+#[pyclass(name = "LazyTranslation")]
 #[derive(Clone)]
 pub struct PyLazyTranslation {
     pub(crate) inner: LazyTranslation,
 }
-#[pyclass(name = "LazyRotation", unsendable)]
+#[pyclass(name = "LazyRotation")]
 #[derive(Clone)]
 pub struct PyLazyRotation {
     pub(crate) inner: LazyRotation,