OpenSMI-Core 0.4.1__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.4.1 → 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.4.1 → opensmi_core-0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenSMI-Core
-Version: 0.4.1
+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.4.1 → 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.4.1 → opensmi_core-0.6}/src/OpenSMI_Core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenSMI-Core
-Version: 0.4.1
+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.4.1 → 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.4.1 → 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.4.1 → 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.4.1 → opensmi_core-0.6}/src/opensmi/core/logging.py

@@ -10,7 +10,8 @@ import shutil
 import sys
 from collections.abc import Mapping, MutableMapping
 from enum import Enum
-from typing import Any
+from pathlib import PurePath
+from typing import Any, Final
 
 import structlog
 
@@ -31,8 +32,17 @@ def _elapsed_to_ms(_, __, event_dict: MutableMapping[str, Any]) -> MutableMappin
     return event_dict
 
 
+def _path_to_str(_, __, event_dict: MutableMapping[str, Any]) -> MutableMapping[str, Any]:  # noqa: ANN001
+    """Convert ``path`` entry in structlog processor event dict to simple string."""
+    if "path" in event_dict:
+        path = event_dict["path"]
+        if isinstance(path, PurePath):
+            event_dict["path"] = str(path)
+    return event_dict
+
+
 _logging_initialized = False
-""" Global flag indicated whether logging is initialized. """
+"""Global flag indicated whether logging is initialized."""
 
 
 class LogFormat(Enum):
@@ -46,11 +56,15 @@ class LogFormat(Enum):
     """JSON formatted logging output"""
 
 
-def _setup_console_logging() -> None:
+def _setup_key_value_logging(
+    *,
+    min_level: int | str = logging.NOTSET,
+    enable_rich_tracebacks: bool = True,
+) -> None:
     from importlib.util import find_spec
 
     # see https://www.structlog.org/en/stable/logging-best-practices.html#pretty-printing-vs-structured-output
-    if find_spec("rich") is not None:
+    if find_spec("rich") is not None and enable_rich_tracebacks:
         console_renderer = structlog.dev.ConsoleRenderer(
             sort_keys=False,
             exception_formatter=structlog.dev.RichTracebackFormatter(
@@ -62,10 +76,10 @@ def _setup_console_logging() -> None:
 
     processors = [
         structlog.contextvars.merge_contextvars,
-        structlog.stdlib.filter_by_level,
         structlog.stdlib.add_logger_name,
         structlog.stdlib.add_log_level,
         _elapsed_to_ms,
+        _path_to_str,
         structlog.processors.TimeStamper(fmt="iso", utc=False),
         structlog.processors.UnicodeDecoder(),
         console_renderer,
@@ -73,67 +87,91 @@ def _setup_console_logging() -> None:
 
     structlog.configure(
         processors=processors,
-        wrapper_class=structlog.make_filtering_bound_logger(logging.NOTSET),
+        wrapper_class=structlog.make_filtering_bound_logger(min_level=min_level),
         logger_factory=structlog.stdlib.LoggerFactory(),
         cache_logger_on_first_use=True,
     )
 
 
-def _setup_key_value_logging() -> None:
+def _setup_json_logging(
+    *,
+    min_level: int | str = logging.NOTSET,
+) -> None:
+
+    processors = [
+        structlog.contextvars.merge_contextvars,
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        _path_to_str,
+        structlog.processors.dict_tracebacks,
+        structlog.processors.TimeStamper(fmt="iso", utc=True),
+    ]
+
     try:
         import orjson
 
         _LOGGER.info("Using orjson serialization")
-        processors = [
-            structlog.contextvars.merge_contextvars,
-            # structlog.stdlib.filter_by_level,
-            # structlog.stdlib.add_logger_name,
-            structlog.stdlib.add_log_level,
-            _elapsed_to_ms,
-            structlog.processors.dict_tracebacks,
-            structlog.processors.JSONRenderer(serializer=orjson.dumps),
-        ]
+
+        processors.append(structlog.processors.JSONRenderer(serializer=orjson.dumps))
         logger_factory = structlog.BytesLoggerFactory()
     except ImportError:
-        _LOGGER.warning("Could not import orjson, fallback to buildin serializer.")
-
-        processors = [
-            structlog.contextvars.merge_contextvars,
-            # structlog.stdlib.filter_by_level,
-            # structlog.stdlib.add_logger_name,
-            structlog.stdlib.add_log_level,
-            _elapsed_to_ms,
-            structlog.processors.dict_tracebacks,
-            structlog.processors.JSONRenderer(),
-        ]
+        _LOGGER.warning("Could not import orjson, fallback to builtin serializer.")
+
+        processors.append(structlog.processors.JSONRenderer())
         logger_factory = structlog.stdlib.LoggerFactory()
 
     structlog.configure(
         processors=processors,
-        wrapper_class=structlog.make_filtering_bound_logger(logging.NOTSET),
+        wrapper_class=structlog.make_filtering_bound_logger(min_level=min_level),
         logger_factory=logger_factory,
         cache_logger_on_first_use=True,
     )
 
 
+DEFAULT_LOG_LEVELS: Final[dict[str, int | str]] = {
+    "opensmi": logging.INFO,
+    "asyncua": logging.ERROR,
+}
+
+
 def setup_logging(
     *,
+    log_min_level: int | str = logging.NOTSET,
     log_levels: Mapping[str, int | str] | None = None,
     log_format: LogFormat = LogFormat.AUTOMATIC,
+    enable_rich_tracebacks: bool = True,
+    force_basic_config: bool = False,
 ) -> None:
-    """Set up structured logging."""
+    """Set up structured logging.
+
+    ``log_format`` can be overridden with the ``LOG_FORMAT`` environment variable.
+
+    :param log_min_level: Minimum logging level for structlog loggers.
+    :param log_levels: Logging levels for *all* loggers. Maps logger name to level. Defaults to `DEFAULT_LOG_LEVELS`.
+    :param log_format: Logging format for *all* loggers.
+    :param enable_rich_tracebacks: Enable Rich tracebacks if `KEY_VALUE` log format is used.
+    :param force_basic_config: ``force`` parameter of ``logging.basicConfig``.
+    """
     global _logging_initialized
     if _logging_initialized:
         return
 
-    logging.basicConfig(force=True, format="")
+    logging.basicConfig(format="", force=force_basic_config)
+
+    if log_levels is None:
+        log_levels = DEFAULT_LOG_LEVELS
+
+    # structlog loggers created via structlog.stdlib.LoggerFactory are also gated by the stdlib level
+    if log_min_level != logging.NOTSET and (log_levels is None or "" not in log_levels):
+        logging.getLogger().setLevel(log_min_level)
+
     if log_levels is not None:
         for name, level in log_levels.items():
             try:
                 logging.getLogger(name).setLevel(level)
-                _LOGGER.debug(f"Set logger level of '{name}' to {level}")
+                _LOGGER.debug("Set logger level of %r to %s", name, level)
             except (TypeError, ValueError):
-                _LOGGER.exception(f"Could not set logger level of '{name}' to {level}")
+                _LOGGER.exception("Could not set logger level of %r to %s", name, level)
     if _LOGGER.level == logging.NOTSET:
         _LOGGER.setLevel(logging.INFO)
 
@@ -142,8 +180,8 @@ def setup_logging(
     if env_log_format is not None:
         try:
             log_format = LogFormat[env_log_format.upper()]
-        except ValueError:
-            _LOGGER.warning(f"Invalid log format '{env_log_format}'")
+        except KeyError:
+            _LOGGER.warning("Invalid log format %r", env_log_format)
 
     if log_format == LogFormat.AUTOMATIC:
         if sys.stderr.isatty():
@@ -154,8 +192,8 @@ def setup_logging(
             log_format = LogFormat.JSON
 
     if log_format == LogFormat.KEY_VALUE:
-        _setup_console_logging()
+        _setup_key_value_logging(min_level=log_min_level, enable_rich_tracebacks=enable_rich_tracebacks)
     else:  # JSON
-        _setup_key_value_logging()
+        _setup_json_logging(min_level=log_min_level)
 
     _logging_initialized = True

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),
+        )