OpenSMI-Core 0.5__tar.gz → 0.6__tar.gz

opensmi_core-0.6/.github/workflows/checks.yml

@@ -0,0 +1,72 @@
+name: Checks
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+  workflow_call: # lets the publishing workflow reuse this one
+    secrets:
+      CODECOV_TOKEN:
+        required: false
+
+permissions:
+  contents: read
+
+jobs:
+  lint:
+    name: Ruff and basedpyright
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          python-version: "3.12"
+          enable-cache: true
+
+      - name: Install dependencies
+        run: uv sync --group dev --all-extras
+
+      # - name: Ruff lint
+      #   run: uv run ruff check .
+
+      - name: Ruff format check
+        run: uv run ruff format --check .
+
+      - name: basedpyright
+        run: uv run basedpyright
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: [ "3.11", "3.12", "3.13", "3.14" ]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+
+      - name: Install dependencies
+        run: uv sync --group dev
+
+      - name: Run tests with coverage
+        run: >
+          uv run pytest
+          -n auto
+          --cov
+          --cov-report=term-missing
+          --cov-report=xml
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: coverage.xml
+          flags: py${{ matrix.python-version }}
+          fail_ci_if_error: false   # don't block on Codecov outages or fork PRs without the token

{opensmi_core-0.5 → opensmi_core-0.6}/.github/workflows/python-publish.yml

@@ -10,12 +10,15 @@ name: Upload Python Package
 
 on:
   release:
-    types: [published]
+    types: [ published ]
 
 permissions:
   contents: read
 
 jobs:
+  checks:
+    uses: ./.github/workflows/checks.yml
+
   release-build:
     runs-on: ubuntu-latest
 

{opensmi_core-0.5 → opensmi_core-0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenSMI-Core
-Version: 0.5
+Version: 0.6
 Summary: Smart Machine Interface core functionality for server and client applications.
 Author-email: Carsten Harms <Carsten.Harms@dfki.de>, Simon Jungbluth <Simon.Jungbluth@smartfactory.de>
 License-Expression: MIT

{opensmi_core-0.5 → opensmi_core-0.6}/pyproject.toml

@@ -61,7 +61,9 @@ dev = [
     "pytest-xdist>=3",
     "pytest-html>=4",
     "pytest-timeout>=2",
-    "openpyxl"  # to load UNECE Excel to autogenerate units
+    "openpyxl", # to load UNECE Excel to autogenerate units
+    "scipy~=1.17.1", # for testing, serves as reference implementation. newer versions dropped Python 3.11
+    "numpy~=2.4.6"  # for scipy, newer versions dropped Python 3.11
 ]
 
 [tool.setuptools]
@@ -133,10 +135,10 @@ author = "OpenSMI Contributors"
 
 [tool.ruff.lint.per-file-ignores]
 "tests/**" = ["ANN", "D", "T", "SLF001"]
-"src/opensmi/core/unit_all.py" = [ # auto-generated
-    "E501",  # line too long
-    "RUF001",  # String contains ambiguous ~
-    "CPY",  # copyright
+"src/opensmi/core/unit_all.py" = [# auto-generated
+    "E501", # line too long
+    "RUF001", # String contains ambiguous ~
+    "CPY", # copyright
 ]
 
 [tool.ruff.format]
@@ -180,3 +182,7 @@ theme = "readthedocs"
 # verbose = 1
 # warnings-as-errors = true
 intersphinx = ["https://opcua-asyncio.readthedocs.io/en/latest/objects.inv"] # TODO(CaHa): does not work
+
+[tool.coverage.run]
+source = ["src/opensmi/core"]
+branch = true

{opensmi_core-0.5 → opensmi_core-0.6}/src/OpenSMI_Core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenSMI-Core
-Version: 0.5
+Version: 0.6
 Summary: Smart Machine Interface core functionality for server and client applications.
 Author-email: Carsten Harms <Carsten.Harms@dfki.de>, Simon Jungbluth <Simon.Jungbluth@smartfactory.de>
 License-Expression: MIT

{opensmi_core-0.5 → opensmi_core-0.6}/src/OpenSMI_Core.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ LICENSE
 README.md
 pyproject.toml
 .github/workflows/api-docs.yml
+.github/workflows/checks.yml
 .github/workflows/python-publish.yml
 LICENSES/MIT.txt
 src/OpenSMI_Core.egg-info/PKG-INFO
@@ -28,6 +29,7 @@ src/opensmi/core/meta.py
 src/opensmi/core/mixin_helpers.py
 src/opensmi/core/protocols.py
 src/opensmi/core/repr_mixin.py
+src/opensmi/core/rsl.py
 src/opensmi/core/signal.py
 src/opensmi/core/subscription_manager.py
 src/opensmi/core/ua.py
@@ -36,6 +38,7 @@ src/opensmi/core/ua_node_util.py
 src/opensmi/core/unit_all.py
 src/opensmi/core/unit_base.py
 src/opensmi/core/unset.py
+tests/test_rsl.py
 tests/test_signal.py
 tests/test_unit.py
 tools/auto_generate_units.py

{opensmi_core-0.5 → opensmi_core-0.6}/src/OpenSMI_Core.egg-info/scm_file_list.json

@@ -1,6 +1,7 @@
 {
   "files": [
     ".github/workflows/api-docs.yml",
+    ".github/workflows/checks.yml",
     ".github/workflows/python-publish.yml",
     ".gitignore",
     ".gitlab-ci.yml",
@@ -23,6 +24,7 @@
     "src/opensmi/core/mixin_helpers.py",
     "src/opensmi/core/protocols.py",
     "src/opensmi/core/repr_mixin.py",
+    "src/opensmi/core/rsl.py",
     "src/opensmi/core/signal.py",
     "src/opensmi/core/subscription_manager.py",
     "src/opensmi/core/ua.py",
@@ -31,6 +33,7 @@
     "src/opensmi/core/unit_all.py",
     "src/opensmi/core/unit_base.py",
     "src/opensmi/core/unset.py",
+    "tests/test_rsl.py",
     "tests/test_signal.py",
     "tests/test_unit.py",
     "tools/auto_generate_units.py"

opensmi_core-0.6/src/OpenSMI_Core.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.6",
+  "distance": 0,
+  "node": "g242780f6570d8852355c9ab5fe3335ccbba3e1e9",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-11-02"
+}

{opensmi_core-0.5 → opensmi_core-0.6}/src/opensmi/core/base_ua_object.py

@@ -50,9 +50,7 @@ class BaseUaObject(Generic[_ServerType]):
         if parent is not None:
             self.parent = parent  # via setter to allow optional runtime type checking
         self._ua_node: Node | None = None
-        self._logger: structlog.BoundLogger = structlog.get_logger(
-            f"opensmi.{self.__class__.__name__}", name=self.name
-        )
+        self._logger: structlog.BoundLogger = structlog.get_logger(f"opensmi.{self.__class__.__name__}", name=self.name)
 
         super().__init__(**kwargs)  # cooperative __init__() after we are done
 

opensmi_core-0.6/src/opensmi/core/rsl.py

@@ -0,0 +1,271 @@
+# SPDX-FileCopyrightText: 2026 OpenSMI Contributors
+#
+# SPDX-License-Identifier: MIT
+
+"""Pose types with unit handling for OPC UA, plus light-weight pose math.
+
+Based on the OPC UA Relative Spatial Location (OPC 10000-210), see
+https://reference.opcfoundation.org/specs/OPC-10000-210/full
+
+.. warning::
+
+    The math (``@``, ``inverse()``, ``transform()``) is pure Python on Euler angles,
+    meant for occasional use only. It is slow in bulk and accumulates rounding error when
+    chained. Use a dedicated library (e.g. NumPy, SciPy) for anything heavier.
+
+    Euler angles are not unique, so results may differ from the inputs while describing the
+    same rotation. Compare with ``isclose()``, not ``==``.
+
+Rotations are intrinsic z-y'-x'' (yaw, pitch, roll), equivalent to extrinsic x-y-z.
+``a @ b`` expresses ``b`` in the frame of ``a`` and uses the left operand's units.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable
+from dataclasses import dataclass, replace
+from functools import cache
+from typing import Final
+
+from asyncua import ua
+
+from opensmi.core import Unit
+
+_Vec = tuple[float, float, float]
+_Mat = tuple[float, float, float, float, float, float, float, float, float]  # row-major
+
+_GIMBAL_EPS: Final = 1e-12
+
+
+def _matrix_of(o: Orientation) -> _Mat:
+    """Rotation matrix R = Rz(c) @ Ry(b) @ Rx(a) (intrinsic z-y'-x'')."""
+    k = _angle_factor(o.unit, Unit.RADIAN)
+    sa, ca = math.sin(o.a * k), math.cos(o.a * k)
+    sb, cb = math.sin(o.b * k), math.cos(o.b * k)
+    sc, cc = math.sin(o.c * k), math.cos(o.c * k)
+    return (
+        cb * cc, sa * sb * cc - ca * sc, ca * sb * cc + sa * sc,
+        cb * sc, sa * sb * sc + ca * cc, ca * sb * sc - sa * cc,
+        -sb,     sa * cb,                ca * cb,
+    )  # fmt: skip
+
+
+def _orientation_from(m: _Mat, unit: Unit) -> Orientation:
+    """Inverse of ``_matrix_of``. At pitch ±90° (gimbal lock) yaw is set to 0."""
+    r00, _, _, r10, r11, r12, r20, r21, r22 = m
+    b = math.asin(max(-1.0, min(1.0, -r20)))
+    if abs(r20) < 1.0 - _GIMBAL_EPS:
+        a, c = math.atan2(r21, r22), math.atan2(r10, r00)
+    else:
+        a, c = math.atan2(-r12, r11), 0.0
+    k = _angle_factor(Unit.RADIAN, unit)
+    return Orientation(a * k, b * k, c * k, unit)
+
+
+def _matmul(p: _Mat, q: _Mat) -> _Mat:
+    return tuple(  # type: ignore
+        sum(p[3 * i + k] * q[3 * k + j] for k in range(3)) for i in range(3) for j in range(3)
+    )
+
+
+def _transpose(m: _Mat) -> _Mat:
+    return m[0], m[3], m[6], m[1], m[4], m[7], m[2], m[5], m[8]
+
+
+def _rotate(m: _Mat, v: _Vec) -> _Vec:
+    x, y, z = v
+    return (
+        m[0] * x + m[1] * y + m[2] * z,
+        m[3] * x + m[4] * y + m[5] * z,
+        m[6] * x + m[7] * y + m[8] * z,
+    )
+
+
+# TODO(CaHa): Maybe attach conversion factor to Unit. UNECE table has this information
+_LENGTH: Final = {
+    Unit.MILLIMETRE: 0.001,
+    Unit.CENTIMETRE: 0.01,
+    Unit.METRE: 1.0,
+}
+_ANGLE: Final = {
+    Unit.DEGREE_UNIT_OF_ANGLE: math.pi / 180,
+    Unit.RADIAN: 1.0,
+}
+
+
+def _require_supported(unit: Unit, table: dict[Unit, float]) -> None:
+    if unit not in table:
+        msg = f"unsupported unit {unit!r}, expected one of {list(table)}"
+        raise ValueError(msg)
+
+
+def _make_factor(table: dict[Unit, float]) -> Callable[[Unit, Unit], float]:
+    @cache
+    def factor(src: Unit, dst: Unit) -> float:
+        _require_supported(src, table)
+        _require_supported(dst, table)
+        return table[src] / table[dst]
+
+    return factor
+
+
+_length_factor: Final = _make_factor(_LENGTH)
+_angle_factor: Final = _make_factor(_ANGLE)
+
+
+@dataclass(frozen=True, slots=True)
+class Position:
+    """Cartesian position defined by X, Y, and Z coordinates.
+
+    see https://reference.opcfoundation.org/specs/OPC-10000-210/b-1
+    """
+
+    x: float = 0.0
+    y: float = 0.0
+    z: float = 0.0
+    unit: Unit = Unit.MILLIMETRE
+
+    def __post_init__(self) -> None:
+        """Verify unit post initialization."""
+        _require_supported(self.unit, _LENGTH)
+
+    def to(self, unit: Unit) -> Position:
+        """Convert this position to one with given ``unit``."""
+        if unit == self.unit:
+            return self
+        f = _length_factor(self.unit, unit)
+        return Position(f * self.x, f * self.y, f * self.z, unit)
+
+    def as_tuple(self) -> tuple[float, float, float]:
+        """Return ``(x, y, z)`` in this position's unit."""
+        return self.x, self.y, self.z
+
+    def is_close(self, other: Position, *, rel_tol: float = 1e-9, abs_tol: float = 1e-9) -> bool:
+        """Approximate equality; ``other`` is converted to this position's unit."""
+        o = other.to(self.unit)
+        return all(
+            math.isclose(p, q, rel_tol=rel_tol, abs_tol=abs_tol)
+            for p, q in zip(self.as_tuple(), o.as_tuple(), strict=True)
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class Orientation:
+    """Angular orientation defined by A=roll (X), B=pitch (Y), C=yaw (Z).
+
+    The rotations are applied as intrinsic ``z-y'-x''`` (yaw, then pitch, then roll),
+    which is equivalent to extrinsic ``x-y-z``.
+
+    see https://reference.opcfoundation.org/specs/OPC-10000-210/b-2
+    """
+
+    a: float = 0.0
+    """Rotation around x axis (roll)"""
+    b: float = 0.0
+    """Rotation around y axis (pitch)"""
+    c: float = 0.0
+    """Rotation around z axis (yaw)"""
+    unit: Unit = Unit.DEGREE_UNIT_OF_ANGLE
+
+    def __post_init__(self) -> None:
+        """Verify unit post initialization."""
+        _require_supported(self.unit, _ANGLE)
+
+    def to(self, unit: Unit) -> Orientation:
+        """Convert this orientation to one with given ``unit``."""
+        if unit == self.unit:
+            return self
+        f = _angle_factor(self.unit, unit)
+        return Orientation(f * self.a, f * self.b, f * self.c, unit)
+
+    def as_tuple(self) -> tuple[float, float, float]:
+        """Return ``(a, b, c)`` in this orientation's unit."""
+        return self.a, self.b, self.c
+
+    def is_close(self, other: Orientation, *, abs_tol: float = 1e-9) -> bool:
+        """Approximate equality of the *rotation*, regardless of Euler representation."""
+        return all(
+            math.isclose(p, q, rel_tol=0.0, abs_tol=abs_tol)
+            for p, q in zip(_matrix_of(self), _matrix_of(other), strict=True)
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class Pose:
+    """Pose defined by Cartesian `Position` and angular `Orientation`.
+
+    Corresponds to OPC UA data type ``3DFrameType``.
+    """
+
+    position: Position = Position()
+    orientation: Orientation = Orientation()
+
+    def with_position(self, position: Position) -> Pose:
+        """Return a copy of this Pose with given ``position`` keeping the orientation."""
+        return replace(self, position=position)
+
+    def with_orientation(self, orientation: Orientation) -> Pose:
+        """Return a copy of this Pose with given ``orientation`` keeping the position."""
+        return replace(self, orientation=orientation)
+
+    def __matmul__(self, other: Pose) -> Pose:
+        """Compose two poses.
+
+        ``other`` is expressed in this pose's frame; the result is expressed in this
+        pose's parent frame, in this pose's units::
+
+            position    = self.position + R_self · other.position
+            orientation = R_self · R_other
+
+        The resulting Euler angles describe an equivalent rotation, but not necessarily
+        the same triple one would compute by hand (gimbal lock, angle wrapping).
+        Use `is_close` to compare poses.
+        """
+        unit = self.position.unit
+        r = _matrix_of(self.orientation)
+        dx, dy, dz = _rotate(r, other.position.to(unit).as_tuple())
+        x, y, z = self.position.as_tuple()
+        return Pose(
+            Position(x + dx, y + dy, z + dz, unit),
+            _orientation_from(_matmul(r, _matrix_of(other.orientation)), self.orientation.unit),
+        )
+
+    def inverse(self) -> Pose:
+        """Return the pose that undoes this one, so ``p @ p.inverse()`` is the identity."""
+        rt = _transpose(_matrix_of(self.orientation))
+        x, y, z = _rotate(rt, self.position.as_tuple())
+        return Pose(
+            Position(-x, -y, -z, self.position.unit),
+            _orientation_from(rt, self.orientation.unit),
+        )
+
+    def transform(self, point: Position) -> Position:
+        """Express ``point`` (given in this pose's frame) in the parent frame."""
+        unit = self.position.unit
+        dx, dy, dz = _rotate(_matrix_of(self.orientation), point.to(unit).as_tuple())
+        x, y, z = self.position.as_tuple()
+        return Position(x + dx, y + dy, z + dz, unit)
+
+    def is_close(self, other: Pose, *, rel_tol: float = 1e-9, abs_tol: float = 1e-9) -> bool:
+        """Approximate equality, regardless of Euler representation."""
+        return self.position.is_close(other.position, rel_tol=rel_tol, abs_tol=abs_tol) and (
+            self.orientation.is_close(other.orientation, abs_tol=abs_tol)
+        )
+
+    def to_ua(self, *, length_unit: Unit, angle_unit: Unit) -> ua.ThreeDFrame:
+        """Convert to a OPC UA ``3DFrame``, expressed in the given units."""
+        p, o = self.position.to(length_unit), self.orientation.to(angle_unit)
+        return ua.ThreeDFrame(
+            CartesianCoordinates=ua.ThreeDCartesianCoordinates(X=p.x, Y=p.y, Z=p.z),  # type: ignore
+            Orientation=ua.ThreeDOrientation(A=o.a, B=o.b, C=o.c),  # type: ignore
+        )
+
+    @classmethod
+    def from_ua(cls, frame: ua.ThreeDFrame, *, length_unit: Unit, angle_unit: Unit) -> Pose:
+        """Convert from ``ThreeDFrame`` whose numbers are in the given units."""
+        p, o = frame.CartesianCoordinates, frame.Orientation
+        return cls(
+            position=Position(float(p.X), float(p.Y), float(p.Z), length_unit),
+            orientation=Orientation(float(o.A), float(o.B), float(o.C), angle_unit),
+        )

{opensmi_core-0.5 → opensmi_core-0.6}/src/opensmi/core/subscription_manager.py

@@ -84,7 +84,8 @@ class SubscriptionManager:
         """Create a new instance.
 
         :param ua_client: OPC UA client to use.
-        :param publishing_interval_ms: Publishing interval in milliseconds for OPC UA subscription
+        :param publishing_interval_ms: Requested publishing interval in milliseconds for OPC UA subscription.
+            May be revised by the server.
         :param heartbeat_stale_after: Time in seconds until any subscription should be received.
         :param max_items_per_call: Maximum number of OPC UA monitored items per call. If ``None``, will be read from the
             servers ``MaxMonitoredItemsPerCall``.
@@ -109,6 +110,12 @@ class SubscriptionManager:
             period=self._publishing_interval_ms, handler=self
         )
         self.logger.info("Created subscription!", parameters=self._ua_subscription.parameters)
+        actual = self._ua_subscription.parameters.RequestedPublishingInterval
+        if actual != self._publishing_interval_ms:
+            self.logger.warning(
+                "Requested publishing interval was revised!", requested=self._publishing_interval_ms, actual=actual
+            )
+            self._publishing_interval_ms = actual
 
     async def _read_max_items_per_call(self) -> None:
         fallback_value = 100

{opensmi_core-0.5 → opensmi_core-0.6}/src/opensmi/core/ua_enums.py

@@ -47,7 +47,7 @@ class SkillState(Enum):
     RESETTING = (19, "Resetting")
     """Intermediate state leading to `SkillState.READY` on success or `SkillState.HALTING` on failure."""
     SUSPENDING = (20, "Suspending")
-    """Intermediate state leading to `SkillState.SUSPENDING` on success or `SkillState.HALTING` on failure."""
+    """Intermediate state leading to `SkillState.SUSPENDED` on success or `SkillState.HALTING` on failure."""
 
     @property
     def localized_text(self) -> ua.LocalizedText:

{opensmi_core-0.5 → opensmi_core-0.6}/src/opensmi/core/ua_node_util.py

@@ -142,7 +142,7 @@ async def get_type_definition(ua_node: Node, *, default: str = "UNKNOWN") -> str
     if len(type_definition_list) > 0:
         return type_definition_list[0].BrowseName.Name
 
-    _LOGGER.warning("Could not determine type definition!", ua_node = ua_node.nodeid.to_string(), default=default)
+    _LOGGER.warning("Could not determine type definition!", ua_node=ua_node.nodeid.to_string(), default=default)
     return default
 
 
@@ -178,7 +178,9 @@ def get_node_id(
     return ua.NodeId(Identifier=identifier, NamespaceIndex=ua.Int16(ns_idx))
 
 
-async def get_child_without_ns(parent: Node, *, browse_name: str | None = None, display_name: str | None = None) -> Node:
+async def get_child_without_ns(
+    parent: Node, *, browse_name: str | None = None, display_name: str | None = None
+) -> Node:
     """Return the first child node with given ``browse_name`` or ``display_name`` while ignoring namespaces.
 
     For each child, ``BrowseName`` is matched first, ``DisplayName`` afterward. If both are given, a child matching

opensmi_core-0.6/tests/test_rsl.py

@@ -0,0 +1,495 @@
+# SPDX-FileCopyrightText: 2026 OpenSMI Contributors
+#
+# SPDX-License-Identifier: MIT
+
+"""Tests for Position / Orientation / Pose, including a SciPy cross-check.
+
+SciPy is a *test-only* dependency and the independent reference implementation.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import math
+from itertools import product
+
+import numpy as np
+import pytest
+from scipy.spatial.transform import Rotation as R  # noqa: N817
+
+from opensmi.core import Unit
+from opensmi.core.rsl import Orientation, Pose, Position, _matmul, _matrix_of, _orientation_from, _rotate, _transpose
+
+MM, CM, M = Unit.MILLIMETRE, Unit.CENTIMETRE, Unit.METRE
+DEG, RAD = Unit.DEGREE_UNIT_OF_ANGLE, Unit.RADIAN
+
+LENGTH_UNITS = [MM, CM, M]
+ANGLE_UNITS = [DEG, RAD]
+SEEDS = list(range(20))
+ATOL = 1e-9
+IDENTITY = (1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)
+
+
+# --------------------------------------------------------------------------- helpers
+
+
+def rand_orientation(g: np.random.Generator, unit: Unit = DEG, max_pitch: float = 85.0) -> Orientation:
+    """Random orientation, kept away from gimbal lock unless ``max_pitch`` says otherwise."""
+    o = Orientation(
+        float(g.uniform(-180, 180)),
+        float(g.uniform(-max_pitch, max_pitch)),
+        float(g.uniform(-180, 180)),
+        DEG,
+    )
+    return o.to(unit)
+
+
+def rand_position(g: np.random.Generator, unit: Unit = MM) -> Position:
+    return Position(*(float(v) for v in g.uniform(-1000, 1000, size=3)), MM).to(unit)
+
+
+def rand_pose(g: np.random.Generator, length: Unit = MM, angle: Unit = DEG) -> Pose:
+    return Pose(rand_position(g, length), rand_orientation(g, angle))
+
+
+def sp_rot(o: Orientation) -> R:
+    return R.from_euler("xyz", o.as_tuple(), degrees=o.unit == DEG)
+
+
+def sp_pose(p: Pose) -> tuple[R, np.ndarray]:
+    return sp_rot(p.orientation), np.array(p.position.to(M).as_tuple())
+
+
+def assert_matrix_equals(o: Orientation, rot: R, atol: float = 1e-12) -> None:
+    np.testing.assert_allclose(_matrix_of(o), rot.as_matrix().ravel(), atol=atol)
+
+
+def assert_pose_matches(p: Pose, rot: R, t_metres: np.ndarray, atol: float = ATOL) -> None:
+    np.testing.assert_allclose(p.position.to(M).as_tuple(), t_metres, atol=atol)
+    assert_matrix_equals(p.orientation, rot, atol=atol)
+
+
+def angle_diff_deg(x: float, y: float) -> float:
+    """Smallest absolute difference between two angles in degrees."""
+    return abs((x - y + 180.0) % 360.0 - 180.0)
+
+
+# --------------------------------------------------------------------------- units
+
+
+class TestUnits:
+    @pytest.mark.parametrize(
+        ("src", "dst", "factor"),
+        [
+            (M, MM, 1000.0),
+            (M, CM, 100.0),
+            (CM, MM, 10.0),
+            (MM, M, 0.001),
+            (MM, CM, 0.1),
+            (CM, M, 0.01),
+        ],
+    )
+    def test_position_conversion(self, src: Unit, dst: Unit, factor: float) -> None:
+        p = Position(1.0, -2.0, 3.0, src).to(dst)
+        assert p.unit == dst
+        assert p.as_tuple() == pytest.approx((factor, -2 * factor, 3 * factor))
+
+    def test_exact_when_scaling_up(self) -> None:
+        # The table is expressed relative to the smallest unit, so these are exact.
+        assert Position(1.5, 2.5, 3.5, M).to(MM).as_tuple() == (1500.0, 2500.0, 3500.0)
+
+    def test_orientation_conversion(self) -> None:
+        o = Orientation(90.0, -45.0, 180.0, DEG).to(RAD)
+        assert o.unit == RAD
+        assert o.as_tuple() == pytest.approx((math.pi / 2, -math.pi / 4, math.pi))
+        assert o.to(DEG).as_tuple() == pytest.approx((90.0, -45.0, 180.0))
+
+    @pytest.mark.parametrize("seed", SEEDS)
+    def test_position_round_trip(self, seed: int) -> None:
+        p = rand_position(np.random.default_rng(seed))
+        for unit in LENGTH_UNITS:
+            assert p.to(unit).to(MM).is_close(p)
+
+    @pytest.mark.parametrize("seed", SEEDS)
+    def test_orientation_round_trip(self, seed: int) -> None:
+        o = rand_orientation(np.random.default_rng(seed))
+        assert o.to(RAD).to(DEG).as_tuple() == pytest.approx(o.as_tuple())
+
+    def test_same_unit_returns_same_object(self) -> None:
+        p, o = Position(1, 2, 3, MM), Orientation(1, 2, 3, DEG)
+        assert p.to(MM) is p
+        assert o.to(DEG) is o
+
+    def test_unsupported_unit_in_constructor(self) -> None:
+        with pytest.raises(ValueError, match="unsupported unit"):
+            Position(unit=RAD)
+        with pytest.raises(ValueError, match="unsupported unit"):
+            Orientation(unit=MM)
+
+    def test_unsupported_target_unit_raises_every_time(self) -> None:
+        # Guards against exceptions being cached (they aren't) or swallowed.
+        p, o = Position(1, 2, 3, MM), Orientation(1, 2, 3, DEG)
+        for _ in range(3):
+            with pytest.raises(ValueError, match="unsupported unit"):
+                p.to(RAD)
+            with pytest.raises(ValueError, match="unsupported unit"):
+                o.to(MM)
+            with pytest.raises(ValueError, match="unsupported unit"):
+                p.to(Unit.SECOND_UNIT_OF_TIME)
+
+    def test_defaults(self) -> None:
+        assert Position() == Position(0.0, 0.0, 0.0, MM)
+        assert Orientation() == Orientation(0.0, 0.0, 0.0, DEG)
+
+
+# --------------------------------------------------------------------------- matrix
+
+
+class TestMatrix:
+    def test_identity(self) -> None:
+        assert _matrix_of(Orientation()) == IDENTITY
+
+    @pytest.mark.parametrize(("seed", "unit"), list(product(SEEDS, ANGLE_UNITS)))
+    def test_matches_scipy(self, seed: int, unit: Unit) -> None:
+        o = rand_orientation(np.random.default_rng(seed), unit, max_pitch=90.0)
+        assert_matrix_equals(o, sp_rot(o))
+
+    @pytest.mark.parametrize("seed", SEEDS)
+    def test_is_proper_rotation(self, seed: int) -> None:
+        m = _matrix_of(rand_orientation(np.random.default_rng(seed), max_pitch=90.0))
+        np.testing.assert_allclose(_matmul(m, _transpose(m)), IDENTITY, atol=1e-12)
+        assert np.linalg.det(np.array(m).reshape(3, 3)) == pytest.approx(1.0)
+
+    @pytest.mark.parametrize(
+        ("o", "v", "expected"),
+        [
+            # roll (x): y -> z
+            (Orientation(90, 0, 0), (0, 1, 0), (0, 0, 1)),
+            # pitch (y): z -> x
+            (Orientation(0, 90, 0), (0, 0, 1), (1, 0, 0)),
+            # yaw (z): x -> y
+            (Orientation(0, 0, 90), (1, 0, 0), (0, 1, 0)),
+        ],
+    )
+    def test_single_axis_rotations(self, o: Orientation, v: tuple[float, ...], expected: tuple[float, ...]) -> None:
+        assert _rotate(_matrix_of(o), v) == pytest.approx(expected, abs=1e-12)  # type: ignore[arg-type]
+
+    def test_order_is_yaw_then_pitch_then_roll(self) -> None:
+        # R = Rz(c) Ry(b) Rx(a): the roll is applied to the vector first.
+        o = Orientation(90, 0, 90)  # roll 90 then yaw 90
+        # y --roll--> z --yaw--> z
+        assert _rotate(_matrix_of(o), (0, 1, 0)) == pytest.approx((0, 0, 1), abs=1e-12)
+        # x --roll--> x --yaw--> y
+        assert _rotate(_matrix_of(o), (1, 0, 0)) == pytest.approx((0, 1, 0), abs=1e-12)
+
+    def test_rotate_and_transpose_are_inverse(self) -> None:
+        m = _matrix_of(Orientation(10, 20, 30))
+        v = (1.0, -2.0, 3.0)
+        assert _rotate(_transpose(m), _rotate(m, v)) == pytest.approx(v)
+
+
+# --------------------------------------------------------------------------- euler round trip
+
+
+class TestEulerExtraction:
+    @pytest.mark.parametrize(("seed", "unit"), list(product(SEEDS, ANGLE_UNITS)))
+    def test_round_trip_recovers_angles(self, seed: int, unit: Unit) -> None:
+        o = rand_orientation(np.random.default_rng(seed), unit)
+        back = _orientation_from(_matrix_of(o), unit)
+        assert back.unit == unit
+        for x, y in zip(o.to(DEG).as_tuple(), back.to(DEG).as_tuple()):
+            assert angle_diff_deg(x, y) == pytest.approx(0.0, abs=1e-9)
+
+    @pytest.mark.parametrize("seed", SEEDS)
+    def test_matches_scipy_as_euler(self, seed: int) -> None:
+        o = rand_orientation(np.random.default_rng(seed))
+        ours = _orientation_from(_matrix_of(o), DEG).as_tuple()
+        theirs = sp_rot(o).as_euler("xyz", degrees=True)
+        for x, y in zip(ours, theirs):
+            assert angle_diff_deg(x, float(y)) == pytest.approx(0.0, abs=1e-9)
+
+    @pytest.mark.parametrize("seed", SEEDS)
+    def test_output_unit_is_respected(self, seed: int) -> None:
+        o = rand_orientation(np.random.default_rng(seed))
+        m = _matrix_of(o)
+        assert _orientation_from(m, RAD).to(DEG).is_close(_orientation_from(m, DEG))
+
+    @pytest.mark.parametrize("pitch", [90.0, -90.0])
+    @pytest.mark.parametrize(("a", "c"), [(0, 0), (30, 10), (-120, 75), (179, -179)])
+    def test_exact_gimbal_lock(self, pitch: float, a: float, c: float) -> None:
+        o = Orientation(a, pitch, c)
+        back = _orientation_from(_matrix_of(o), DEG)
+        # Same rotation, canonical representation: yaw is folded into roll.
+        assert back.is_close(o)
+        assert back.b == pytest.approx(pitch)
+        assert back.c == 0.0
+        assert_matrix_equals(back, sp_rot(o))
+
+    @pytest.mark.parametrize(
+        ("delta_deg", "tol"),
+        [(1e-3, 1e-9), (1e-5, 1e-6), (1e-7, 1e-8), (0.0, 1e-12)],
+    )
+    @pytest.mark.parametrize("sign", [1, -1])
+    def test_near_gimbal_lock(self, delta_deg: float, tol: float, sign: int) -> None:
+        # Precision degrades near the singularity; tolerances reflect that.
+        o = Orientation(25.0, sign * (90.0 - delta_deg), 40.0)
+        back = _orientation_from(_matrix_of(o), DEG)
+        assert back.is_close(o, abs_tol=tol)
+
+    def test_pitch_is_clamped_against_rounding(self) -> None:
+        # An entry a hair beyond +-1 must not make asin() raise.
+        m = (0.0, 0.0, 1.0, 0.0, 1.0, 0.0, -1.0 - 1e-15, 0.0, 0.0)
+        assert _orientation_from(m, DEG).b == pytest.approx(90.0)
+
+
+# --------------------------------------------------------------------------- is_close
+
+
+class TestIsClose:
+    def test_position_reflexive_and_unit_aware(self) -> None:
+        p = Position(1, 2, 3, M)
+        assert p.is_close(p)
+        assert p.is_close(Position(1000, 2000, 3000, MM))
+        assert Position(1000, 2000, 3000, MM).is_close(p)
+
+    def test_position_tolerances(self) -> None:
+        p = Position(1.0, 1.0, 1.0, MM)
+        assert not p.is_close(Position(1.0, 1.0, 1.001, MM))
+        assert p.is_close(Position(1.0, 1.0, 1.001, MM), abs_tol=0.01)
+        assert p.is_close(Position(1.0, 1.0, 1.001, MM), rel_tol=0.01)
+
+    def test_position_zero_needs_abs_tol(self) -> None:
+        assert Position(0, 0, 0).is_close(Position(1e-12, 0, 0))
+        assert not Position(0, 0, 0).is_close(Position(1e-6, 0, 0))
+
+    @pytest.mark.parametrize(
+        ("x", "y"),
+        [
+            (Orientation(0, 0, 359), Orientation(0, 0, -1)),  # wrapping on yaw
+            (Orientation(360, 0, 0), Orientation(0, 0, 0)),  # full turn on roll
+            (Orientation(180, 0, 0), Orientation(-180, 0, 0)),
+            (Orientation(30, 90, 10), Orientation(20, 90, 0)),  # gimbal lock, +90
+            (Orientation(30, -90, 10), Orientation(40, -90, 0)),  # gimbal lock, -90
+            (Orientation(0, 0, 90, DEG), Orientation(0, 0, math.pi / 2, RAD)),  # mixed units
+            # the same rotation written two ways: (a, b, c) == (a+180, 180-b, c+180)
+            (Orientation(10, 20, 30), Orientation(190, 160, 210)),
+        ],
+    )
+    def test_orientation_equivalent_rotations(self, x: Orientation, y: Orientation) -> None:
+        assert x.is_close(y)
+        assert y.is_close(x)
+
+    @pytest.mark.parametrize(
+        ("x", "y"),
+        [
+            (Orientation(0, 0, 0), Orientation(0, 0, 1)),
+            (Orientation(10, 20, 30), Orientation(30, 20, 10)),
+            (Orientation(0, 0, 90), Orientation(0, 0, math.pi / 2, DEG)),  # unit mix-up
+        ],
+    )
+    def test_orientation_different_rotations(self, x: Orientation, y: Orientation) -> None:
+        assert not x.is_close(y)
+
+    @pytest.mark.parametrize("seed", SEEDS)
+    def test_orientation_matches_scipy_equivalence(self, seed: int) -> None:
+        g = np.random.default_rng(seed)
+        x, y = rand_orientation(g), rand_orientation(g)
+        sp_equal = bool(np.allclose(sp_rot(x).as_matrix(), sp_rot(y).as_matrix(), atol=1e-9))
+        assert x.is_close(y) == sp_equal
+        assert x.is_close(x)
+
+    def test_pose_is_close(self) -> None:
+        p = Pose(Position(1, 2, 3, M), Orientation(10, 20, 30))
+        assert p.is_close(p)
+        assert p.is_close(Pose(Position(1000, 2000, 3000, MM), Orientation(10, 20, 30 + 360)))
+        assert not p.is_close(Pose(Position(1, 2, 3.01, M), p.orientation))
+        assert not p.is_close(Pose(p.position, Orientation(10, 20, 31)))
+
+
+# --------------------------------------------------------------------------- accessors
+
+
+class TestAccessors:
+    def test_as_tuple(self) -> None:
+        assert Position(1, 2, 3, CM).as_tuple() == (1, 2, 3)
+        assert Orientation(4, 5, 6, RAD).as_tuple() == (4, 5, 6)
+
+    def test_not_iterable(self) -> None:
+        with pytest.raises(TypeError):
+            iter(Position())  # type: ignore[call-overload]
+
+
+# --------------------------------------------------------------------------- composition
+
+
+class TestComposition:
+    @pytest.mark.parametrize(
+        ("seed", "l1", "a1", "l2", "a2"),
+        [(s, *u) for s in range(8) for u in product(LENGTH_UNITS, ANGLE_UNITS, LENGTH_UNITS, ANGLE_UNITS)],
+    )
+    def test_matches_scipy(self, seed: int, l1: Unit, a1: Unit, l2: Unit, a2: Unit) -> None:
+        g = np.random.default_rng(seed)
+        a, b = rand_pose(g, l1, a1), rand_pose(g, l2, a2)
+        (ra, ta), (rb, tb) = sp_pose(a), sp_pose(b)
+
+        c = a @ b
+
+        assert c.position.unit == l1
+        assert c.orientation.unit == a1
+        assert_pose_matches(c, ra * rb, ta + ra.apply(tb))
+
+    @pytest.mark.parametrize("seed", SEEDS)
+    def test_identity_is_neutral(self, seed: int) -> None:
+        p = rand_pose(np.random.default_rng(seed))
+        assert (Pose() @ p).is_close(p)
+        assert (p @ Pose()).is_close(p)
+
+    @pytest.mark.parametrize("seed", SEEDS)
+    def test_associative(self, seed: int) -> None:
+        g = np.random.default_rng(seed)
+        a, b, c = (rand_pose(g, MM, DEG) for _ in range(3))
+        assert ((a @ b) @ c).is_close(a @ (b @ c), abs_tol=1e-8)
+
+    def test_not_commutative(self) -> None:
+        a = Pose(Position(1, 0, 0, M), Orientation(0, 0, 90))
+        b = Pose(Position(1, 0, 0, M), Orientation(0, 0, 0))
+        assert not (a @ b).is_close(b @ a)
+
+    def test_rotations_do_not_commute(self) -> None:
+        roll = Pose(orientation=Orientation(90, 0, 0))
+        yaw = Pose(orientation=Orientation(0, 0, 90))
+        assert not (roll @ yaw).is_close(yaw @ roll)
+
+    def test_known_example_yaw_then_translate(self) -> None:
+        # A frame 1 m along x, yawed 90 degrees. A child 1 m along its own x
+        # therefore ends up at (1, 1, 0) in the parent frame.
+        parent = Pose(Position(1, 0, 0, M), Orientation(0, 0, 90))
+        child = Pose(Position(1, 0, 0, M))
+        c = parent @ child
+        assert c.position.as_tuple() == pytest.approx((1, 1, 0), abs=1e-12)
+        assert c.orientation.as_tuple() == pytest.approx((0, 0, 90), abs=1e-9)
+
+    def test_pure_translations_add(self) -> None:
+        c = Pose(Position(1, 2, 3, MM)) @ Pose(Position(10, 20, 30, MM))
+        assert c.position.as_tuple() == pytest.approx((11, 22, 33))
+
+    def test_same_axis_rotations_add_angles(self) -> None:
+        c = Pose(orientation=Orientation(0, 0, 30)) @ Pose(orientation=Orientation(0, 0, 40))
+        assert c.orientation.as_tuple() == pytest.approx((0, 0, 70), abs=1e-9)
+
+    def test_composition_into_gimbal_lock(self) -> None:
+        a = Pose(orientation=Orientation(0, 45, 0))
+        c = a @ a
+        assert c.orientation.b == pytest.approx(90.0)
+        assert_matrix_equals(c.orientation, sp_rot(a.orientation) * sp_rot(a.orientation), atol=1e-9)
+
+    def test_does_not_mutate_operands(self) -> None:
+        a, b = rand_pose(np.random.default_rng(1)), rand_pose(np.random.default_rng(2))
+        a0, b0 = dataclasses.replace(a), dataclasses.replace(b)
+        _ = a @ b
+        assert (a, b) == (a0, b0)
+
+    def test_repeated_small_rotations_return_to_start(self) -> None:
+        step = Pose(orientation=Orientation(0, 0, 1))
+        acc = Pose()
+        for _ in range(360):
+            acc = acc @ step
+        assert acc.is_close(Pose(), abs_tol=1e-9)
+
+    def test_long_chain_matches_scipy_without_drift(self) -> None:
+        g = np.random.default_rng(42)
+        acc = Pose()
+        rot, t = R.identity(), np.zeros(3)
+        for _ in range(500):
+            step = rand_pose(g, M, RAD)
+            acc = acc @ step
+            sr, st = sp_pose(step)
+            t, rot = t + rot.apply(st), rot * sr
+        assert_pose_matches(acc, rot, t, atol=1e-9)
+
+
+# --------------------------------------------------------------------------- inverse
+
+
+class TestInverse:
+    @pytest.mark.parametrize(
+        ("seed", "length", "angle"),
+        [(s, *u) for s in SEEDS for u in product(LENGTH_UNITS, ANGLE_UNITS)],
+    )
+    def test_inverse_composes_to_identity(self, seed: int, length: Unit, angle: Unit) -> None:
+        p = rand_pose(np.random.default_rng(seed), length, angle)
+        assert (p @ p.inverse()).is_close(Pose(Position(unit=length), Orientation(unit=angle)))
+        assert (p.inverse() @ p).is_close(Pose(Position(unit=length), Orientation(unit=angle)))
+
+    @pytest.mark.parametrize("seed", SEEDS)
+    def test_matches_scipy(self, seed: int) -> None:
+        p = rand_pose(np.random.default_rng(seed))
+        rot, t = sp_pose(p)
+        inv = rot.inv()
+        assert_pose_matches(p.inverse(), inv, -inv.apply(t))
+
+    @pytest.mark.parametrize("seed", SEEDS)
+    def test_involution(self, seed: int) -> None:
+        p = rand_pose(np.random.default_rng(seed))
+        assert p.inverse().inverse().is_close(p)
+
+    @pytest.mark.parametrize(("length", "angle"), list(product(LENGTH_UNITS, ANGLE_UNITS)))
+    def test_units_are_preserved(self, length: Unit, angle: Unit) -> None:
+        inv = rand_pose(np.random.default_rng(0), length, angle).inverse()
+        assert inv.position.unit == length
+        assert inv.orientation.unit == angle
+
+    def test_identity_inverse(self) -> None:
+        assert Pose().inverse().is_close(Pose())
+
+    def test_inverse_of_composition(self) -> None:
+        g = np.random.default_rng(7)
+        a, b = rand_pose(g), rand_pose(g)
+        assert (a @ b).inverse().is_close(b.inverse() @ a.inverse(), abs_tol=1e-8)
+
+    def test_gimbal_lock_pose(self) -> None:
+        p = Pose(Position(1, 2, 3, M), Orientation(20, 90, 0))
+        assert (p @ p.inverse()).is_close(Pose(Position(unit=M)))
+
+
+# --------------------------------------------------------------------------- transform
+
+
+class TestTransform:
+    @pytest.mark.parametrize(("seed", "length"), list(product(SEEDS, LENGTH_UNITS)))
+    def test_matches_scipy(self, seed: int, length: Unit) -> None:
+        g = np.random.default_rng(seed)
+        pose = rand_pose(g, length, DEG)
+        point = rand_position(g, length)
+        rot, t = sp_pose(pose)
+
+        out = pose.transform(point)
+
+        assert out.unit == length
+        np.testing.assert_allclose(out.to(M).as_tuple(), t + rot.apply(point.to(M).as_tuple()), atol=ATOL)
+
+    def test_point_in_other_unit_is_converted(self) -> None:
+        pose = Pose(Position(1, 0, 0, M), Orientation(0, 0, 90))
+        out = pose.transform(Position(1000, 0, 0, MM))  # 1 m in mm
+        assert out.unit == M
+        assert out.as_tuple() == pytest.approx((1, 1, 0), abs=1e-12)
+
+    @pytest.mark.parametrize("seed", SEEDS)
+    def test_consistent_with_matmul(self, seed: int) -> None:
+        g = np.random.default_rng(seed)
+        pose, point = rand_pose(g), rand_position(g)
+        assert pose.transform(point).is_close((pose @ Pose(point)).position)
+
+    @pytest.mark.parametrize("seed", SEEDS)
+    def test_inverse_undoes_transform(self, seed: int) -> None:
+        g = np.random.default_rng(seed)
+        pose, point = rand_pose(g), rand_position(g)
+        assert pose.inverse().transform(pose.transform(point)).is_close(point, abs_tol=1e-8)
+
+    def test_identity_orientation_is_pure_translation(self) -> None:
+        out = Pose(Position(1, 2, 3, MM)).transform(Position(10, 20, 30, MM))
+        assert out.as_tuple() == pytest.approx((11, 22, 33))
+
+    def test_origin_maps_to_pose_position(self) -> None:
+        pose = rand_pose(np.random.default_rng(3))
+        assert pose.transform(Position(unit=MM)).is_close(pose.position)

{opensmi_core-0.5 → opensmi_core-0.6}/tools/auto_generate_units.py

@@ -129,6 +129,7 @@ def _write_python_file(path: Path, units: dict[str, _UneceUnit], class_name: str
             _write_unit(file, unit)
     _LOGGER.info(f"Written {class_name=} {doc=} to {path=}")
 
+
 def _check(path: Path) -> None:
     subprocess.run(["ruff", "check", "--fix", str(path)], check=True)
     subprocess.run(["ruff", "format", str(path)], check=True)
@@ -139,6 +140,7 @@ def _check(path: Path) -> None:
     # finally, make sure the file is valid python after formatting & linting
     compile(generated_code, path, "exec")
 
+
 def _main() -> None:
     units = _parse(SRC_PATH)
 
@@ -166,5 +168,6 @@ def _main() -> None:
     _write_python_file(DEST_PATH, units=units, class_name="Unit", doc="All units")
     _check(DEST_PATH)
 
+
 if __name__ == "__main__":
     _main()

opensmi_core-0.5/src/OpenSMI_Core.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.5",
-  "distance": 0,
-  "node": "gddccea703057c24b9ad0c2411b5d680aed029421",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-15"
-}