antioch-py 2.2.4__py3-none-any.whl → 3.0.0__py3-none-any.whl

common/message/vector.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 import numpy as np
-from pydantic import model_validator
+from foxglove.schemas import Vector2 as FoxgloveVector2, Vector3 as FoxgloveVector3
+from pydantic import Field, model_validator
 
-from common.message.base import Message
+from common.message.message import Message
 from common.message.point import Point2, Point3
-
-if TYPE_CHECKING:
-    from common.message.quaternion import Quaternion
+from common.message.quaternion import Quaternion
 
 try:
     from pxr import Gf  # type: ignore
@@ -23,37 +22,32 @@ class Vector2(Message):
     """
     A 2D vector (x, y).
 
-    Serializes as a tuple [x, y] for space efficiency.
-    Automatically converts from common Python types:
-    - Lists: Vector2.from_any([1.0, 2.0])
-    - Tuples: Vector2.from_any((1.0, 2.0))
-    - Dicts: Vector2.from_any({"x": 1.0, "y": 2.0})
-    - Numpy arrays: Vector2.from_any(np.array([1.0, 2.0]))
-
-    When used as a field in Messages, conversion happens automatically:
-        pose = SomeMessage(position_2d=[10.0, 20.0])  # List auto-converts!
-    """
-
-    _type = "antioch/vector2"
-    data: tuple[float, float]
-
-    @property
-    def x(self) -> float:
-        """Get the x component.
+    Supports multiple construction styles:
+    - Vector2(x=1.0, y=2.0) - keyword args
+    - Vector2.from_any([1.0, 2.0]) - from list/tuple
+    - Vector2.from_any((1.0, 2.0)) - from tuple
 
-        :return: The x component.
-        """
+    Example:
+        ```python
+        from common.message import Vector2
 
-        return self.data[0]
+        # Create a 2D vector
+        v = Vector2(x=3.0, y=4.0)
 
-    @property
-    def y(self) -> float:
-        """Get the y component.
+        # Vector operations
+        magnitude = v.magnitude()  # 5.0
+        normalized = v.normalize()
 
-        :return: The y component.
-        """
+        # Arithmetic operations
+        v2 = Vector2(x=1.0, y=2.0)
+        sum_v = v + v2
+        scaled = v * 2.0
+        ```
+    """
 
-        return self.data[1]
+    _type = "antioch/vector2"
+    x: float = Field(default=0.0, description="X component")
+    y: float = Field(default=0.0, description="Y component")
 
     def __len__(self) -> int:
         """
@@ -71,7 +65,7 @@ class Vector2(Message):
         :return: Iterator over [x, y].
         """
 
-        return iter(self.data)
+        return iter((self.x, self.y))
 
     def __getitem__(self, index: int) -> float:
         """
@@ -81,7 +75,7 @@ class Vector2(Message):
         :return: The component value.
         """
 
-        return self.data[index]
+        return (self.x, self.y)[index]
 
     def __eq__(self, other: object) -> bool:
         """
@@ -93,7 +87,7 @@ class Vector2(Message):
 
         if not isinstance(other, Vector2):
             return False
-        return self.data == other.data
+        return self.x == other.x and self.y == other.y
 
     def __repr__(self) -> str:
         """
@@ -102,7 +96,7 @@ class Vector2(Message):
         :return: String representation.
         """
 
-        return f"Vector2(x={self.x}, y={self.y})"
+        return f"Vector2({self.x}, {self.y})"
 
     def __str__(self) -> str:
         """
@@ -111,7 +105,7 @@ class Vector2(Message):
         :return: String representation.
         """
 
-        return f"Vector2(x={self.x}, y={self.y})"
+        return f"Vector2({self.x}, {self.y})"
 
     def __add__(self, other: Vector2) -> Vector2:
         """
@@ -121,7 +115,7 @@ class Vector2(Message):
         :return: The sum vector.
         """
 
-        return Vector2(data=(self.x + other.x, self.y + other.y))
+        return Vector2(x=self.x + other.x, y=self.y + other.y)
 
     def __sub__(self, other: Vector2) -> Vector2:
         """
@@ -131,7 +125,7 @@ class Vector2(Message):
         :return: The difference vector.
         """
 
-        return Vector2(data=(self.x - other.x, self.y - other.y))
+        return Vector2(x=self.x - other.x, y=self.y - other.y)
 
     def __mul__(self, scalar: float) -> Vector2:
         """
@@ -141,7 +135,7 @@ class Vector2(Message):
         :return: The scaled vector.
         """
 
-        return Vector2(data=(self.x * scalar, self.y * scalar))
+        return Vector2(x=self.x * scalar, y=self.y * scalar)
 
     def __rmul__(self, scalar: float) -> Vector2:
         """
@@ -164,7 +158,7 @@ class Vector2(Message):
 
         if scalar == 0:
             raise ZeroDivisionError("Cannot divide vector by zero")
-        return Vector2(data=(self.x / scalar, self.y / scalar))
+        return Vector2(x=self.x / scalar, y=self.y / scalar)
 
     def __neg__(self) -> Vector2:
         """
@@ -173,56 +167,7 @@ class Vector2(Message):
         :return: The negated vector.
         """
 
-        return Vector2(data=(-self.x, -self.y))
-
-    @model_validator(mode="before")
-    @classmethod
-    def convert_iterables(cls, data: Any) -> Any:
-        """
-        Automatically convert lists, tuples, dicts, and numpy arrays to Vector2 format.
-        """
-
-        # Already a Vector2 instance
-        if isinstance(data, cls):
-            return {"data": data.data}
-
-        # Tuple format - already correct
-        if isinstance(data, tuple) and len(data) == 2:
-            return {"data": (float(data[0]), float(data[1]))}
-
-        # Dict format with x, y - convert to tuple
-        if isinstance(data, dict):
-            if "data" in data:
-                return data
-            if "x" in data and "y" in data:
-                return {"data": (float(data["x"]), float(data["y"]))}
-            raise ValueError("Dict must have either 'data' or 'x' and 'y' fields")
-
-        # Numpy array - convert
-        if isinstance(data, np.ndarray):
-            if data.shape != (2,):
-                raise ValueError(f"Vector2 array must have shape (2,), got {data.shape}")
-            return {"data": (float(data[0]), float(data[1]))}
-
-        # List - convert
-        if isinstance(data, list):
-            if len(data) != 2:
-                raise ValueError(f"Vector2 requires 2 values, got {len(data)}")
-            return {"data": (float(data[0]), float(data[1]))}
-
-        return data
-
-    @classmethod
-    def new(cls, x: float, y: float) -> Vector2:
-        """
-        Create a new 2D vector.
-
-        :param x: The x component.
-        :param y: The y component.
-        :return: A 2D vector.
-        """
-
-        return cls(data=(x, y))
+        return Vector2(x=-self.x, y=-self.y)
 
     @classmethod
     def zeros(cls) -> Vector2:
@@ -232,7 +177,7 @@ class Vector2(Message):
         :return: A zero vector.
         """
 
-        return cls(data=(0.0, 0.0))
+        return cls(x=0.0, y=0.0)
 
     @classmethod
     def ones(cls) -> Vector2:
@@ -242,27 +187,29 @@ class Vector2(Message):
         :return: A ones vector.
         """
 
-        return cls(data=(1.0, 1.0))
+        return cls(x=1.0, y=1.0)
 
     @classmethod
-    def from_any(cls, data: Any) -> Vector2:
+    def from_any(cls, value: Vector2 | tuple | list | dict | np.ndarray | None) -> Vector2:
         """
-        Create Vector2 from any iterable (list, tuple, numpy array).
+        Create Vector2 from any compatible type.
+
+        Accepts:
+        - Vector2 instance (returned as-is)
+        - Tuple/list of 2 floats: (x, y)
+        - Dict with 'x' and 'y' keys
+        - Numpy array of shape (2,)
+        - None (returns zero vector)
 
-        :param data: Iterable with 2 values, dict, or a Vector2 instance.
+        :param value: Any compatible input type.
         :return: A Vector2 instance.
-        :raises ValueError: If conversion fails.
         """
 
-        # Already a Vector2 - return as-is
-        if isinstance(data, cls):
-            return data
-
-        try:
-            # Will be handled by validator
-            return cls.model_validate(data)
-        except Exception as e:
-            raise ValueError(f"Cannot convert to Vector2: {e}") from None
+        if value is None:
+            return cls(x=0.0, y=0.0)
+        if isinstance(value, cls):
+            return value
+        return cls.model_validate(value)
 
     @classmethod
     def from_numpy(cls, array: np.ndarray) -> Vector2:
@@ -276,7 +223,7 @@ class Vector2(Message):
 
         if array.shape != (2,):
             raise ValueError(f"Vector2 array must have shape (2,), got {array.shape}")
-        return cls(data=(float(array[0]), float(array[1])))
+        return cls(x=float(array[0]), y=float(array[1]))
 
     @classmethod
     def from_list(cls, values: list[float]) -> Vector2:
@@ -290,7 +237,7 @@ class Vector2(Message):
 
         if len(values) != 2:
             raise ValueError(f"Vector2 requires 2 values, got {len(values)}")
-        return cls(data=(values[0], values[1]))
+        return cls(x=values[0], y=values[1])
 
     def dot(self, other: Vector2) -> float:
         """
@@ -340,7 +287,7 @@ class Vector2(Message):
         :return: The numpy array.
         """
 
-        return np.array(self.data, dtype=np.float32)
+        return np.array([self.x, self.y], dtype=np.float32)
 
     def to_list(self) -> list[float]:
         """
@@ -349,7 +296,16 @@ class Vector2(Message):
         :return: The list of values.
         """
 
-        return list(self.data)
+        return [self.x, self.y]
+
+    def to_tuple(self) -> tuple[float, float]:
+        """
+        Convert to a tuple.
+
+        :return: The tuple of values.
+        """
+
+        return (self.x, self.y)
 
     def to_point(self) -> Point2:
         """
@@ -360,60 +316,67 @@ class Vector2(Message):
 
         return Point2(x=self.x, y=self.y)
 
-    def as_array(self) -> list[float]:
+    def to_foxglove(self) -> FoxgloveVector2:
         """
-        Convert to a list (alias for to_list for Rust compatibility).
+        Convert to Foxglove Vector2 for telemetry.
 
-        :return: The list of values.
+        :return: Foxglove Vector2 schema.
         """
 
-        return self.to_list()
+        return FoxgloveVector2(x=self.x, y=self.y)
 
+    @model_validator(mode="before")
+    @classmethod
+    def _convert_input(cls, data: Any) -> Any:
+        """
+        Convert various input types to Vector2 format.
+        """
 
-class Vector3(Message):
-    """
-    A 3D vector (x, y, z).
+        if isinstance(data, cls):
+            return {"x": data.x, "y": data.y}
+        if isinstance(data, (tuple, list)) and len(data) == 2:
+            return {"x": float(data[0]), "y": float(data[1])}
+        if isinstance(data, np.ndarray) and data.shape == (2,):
+            return {"x": float(data[0]), "y": float(data[1])}
+        if isinstance(data, dict) and "x" in data and "y" in data:
+            return {"x": float(data["x"]), "y": float(data["y"])}
+        return data
 
-    Serializes as a tuple [x, y, z] for space efficiency.
-    Automatically converts from common Python types:
-    - Lists: Vector3.from_any([1.0, 2.0, 3.0])
-    - Tuples: Vector3.from_any((1.0, 2.0, 3.0))
-    - Dicts: Vector3.from_any({"x": 1.0, "y": 2.0, "z": 3.0})
-    - Numpy arrays: Vector3.from_any(np.array([1.0, 2.0, 3.0]))
 
-    When used as a field in Messages, conversion happens automatically:
-        pose = SomeMessage(position=[10.0, 20.0, 30.0])  # List auto-converts!
+class Vector3(Message):
     """
+    A 3D vector (x, y, z).
 
-    _type = "antioch/vector3"
-    data: tuple[float, float, float]
-
-    @property
-    def x(self) -> float:
-        """Get the x component.
-
-        :return: The x component.
-        """
-
-        return self.data[0]
+    Supports multiple construction styles:
+    - Vector3(x=1.0, y=2.0, z=3.0) - keyword args
+    - Vector3.from_any([1.0, 2.0, 3.0]) - from list
+    - Vector3.from_any((1.0, 2.0, 3.0)) - from tuple
 
-    @property
-    def y(self) -> float:
-        """Get the y component.
+    Example:
+        ```python
+        from common.message import Vector3
 
-        :return: The y component.
-        """
+        # Create a 3D vector
+        v = Vector3(x=1.0, y=2.0, z=3.0)
 
-        return self.data[1]
+        # Vector operations
+        magnitude = v.magnitude()
+        normalized = v.normalize()
 
-    @property
-    def z(self) -> float:
-        """Get the z component.
+        # Cross and dot products
+        v2 = Vector3(x=0.0, y=1.0, z=0.0)
+        cross = v.cross(v2)
+        dot = v.dot(v2)
 
-        :return: The z component.
-        """
+        # Convert to numpy
+        arr = v.to_numpy()
+        ```
+    """
 
-        return self.data[2]
+    _type = "antioch/vector3"
+    x: float = Field(default=0.0, description="X component")
+    y: float = Field(default=0.0, description="Y component")
+    z: float = Field(default=0.0, description="Z component")
 
     def __len__(self) -> int:
         """
@@ -431,7 +394,7 @@ class Vector3(Message):
         :return: Iterator over [x, y, z].
         """
 
-        return iter(self.data)
+        return iter((self.x, self.y, self.z))
 
     def __getitem__(self, index: int) -> float:
         """
@@ -441,7 +404,7 @@ class Vector3(Message):
         :return: The component value.
         """
 
-        return self.data[index]
+        return (self.x, self.y, self.z)[index]
 
     def __eq__(self, other: object) -> bool:
         """
@@ -453,7 +416,7 @@ class Vector3(Message):
 
         if not isinstance(other, Vector3):
             return False
-        return self.data == other.data
+        return self.x == other.x and self.y == other.y and self.z == other.z
 
     def __repr__(self) -> str:
         """
@@ -462,7 +425,7 @@ class Vector3(Message):
         :return: String representation.
         """
 
-        return f"Vector3(x={self.x}, y={self.y}, z={self.z})"
+        return f"Vector3({self.x}, {self.y}, {self.z})"
 
     def __str__(self) -> str:
         """
@@ -471,7 +434,7 @@ class Vector3(Message):
         :return: String representation.
         """
 
-        return f"Vector3(x={self.x}, y={self.y}, z={self.z})"
+        return f"Vector3({self.x}, {self.y}, {self.z})"
 
     def __add__(self, other: Vector3) -> Vector3:
         """
@@ -481,7 +444,7 @@ class Vector3(Message):
         :return: The sum vector.
         """
 
-        return Vector3(data=(self.x + other.x, self.y + other.y, self.z + other.z))
+        return Vector3(x=self.x + other.x, y=self.y + other.y, z=self.z + other.z)
 
     def __sub__(self, other: Vector3) -> Vector3:
         """
@@ -491,7 +454,7 @@ class Vector3(Message):
         :return: The difference vector.
         """
 
-        return Vector3(data=(self.x - other.x, self.y - other.y, self.z - other.z))
+        return Vector3(x=self.x - other.x, y=self.y - other.y, z=self.z - other.z)
 
     def __mul__(self, scalar: float) -> Vector3:
         """
@@ -501,7 +464,7 @@ class Vector3(Message):
         :return: The scaled vector.
         """
 
-        return Vector3(data=(self.x * scalar, self.y * scalar, self.z * scalar))
+        return Vector3(x=self.x * scalar, y=self.y * scalar, z=self.z * scalar)
 
     def __rmul__(self, scalar: float) -> Vector3:
         """
@@ -524,7 +487,7 @@ class Vector3(Message):
 
         if scalar == 0:
             raise ZeroDivisionError("Cannot divide vector by zero")
-        return Vector3(data=(self.x / scalar, self.y / scalar, self.z / scalar))
+        return Vector3(x=self.x / scalar, y=self.y / scalar, z=self.z / scalar)
 
     def __neg__(self) -> Vector3:
         """
@@ -533,59 +496,7 @@ class Vector3(Message):
         :return: The negated vector.
         """
 
-        return Vector3(data=(-self.x, -self.y, -self.z))
-
-    @model_validator(mode="before")
-    @classmethod
-    def convert_iterables(cls, data: Any) -> Any:
-        """
-        Automatically convert lists, tuples, dicts, and numpy arrays to Vector3 format.
-        """
-
-        # Already a Vector3 instance
-        if isinstance(data, cls):
-            return {"data": data.data}
-
-        # Tuple format - already correct
-        if isinstance(data, tuple) and len(data) == 3:
-            return {"data": (float(data[0]), float(data[1]), float(data[2]))}
-
-        # Dict format with x, y, z - convert to tuple
-        if isinstance(data, dict):
-            if "data" in data:
-                return data
-            if "x" in data and "y" in data and "z" in data:
-                return {"data": (float(data["x"]), float(data["y"]), float(data["z"]))}
-            raise ValueError("Dict must have either 'data' or 'x', 'y', and 'z' fields")
-
-        # Numpy array - convert
-        if isinstance(data, np.ndarray):
-            if data.shape != (3,):
-                raise ValueError(f"Vector3 array must have shape (3,), got {data.shape}")
-            return {"data": (float(data[0]), float(data[1]), float(data[2]))}
-
-        # List - convert
-        if isinstance(data, list):
-            if len(data) != 3:
-                raise ValueError(f"Vector3 requires 3 values, got {len(data)}")
-            if all(item is None for item in data):
-                return {"data": (0.0, 0.0, 0.0)}
-            return {"data": (float(data[0]), float(data[1]), float(data[2]))}
-
-        return data
-
-    @classmethod
-    def new(cls, x: float, y: float, z: float) -> Vector3:
-        """
-        Create a new 3D vector.
-
-        :param x: The x component.
-        :param y: The y component.
-        :param z: The z component.
-        :return: A 3D vector.
-        """
-
-        return cls(data=(x, y, z))
+        return Vector3(x=-self.x, y=-self.y, z=-self.z)
 
     @classmethod
     def zeros(cls) -> Vector3:
@@ -595,7 +506,7 @@ class Vector3(Message):
         :return: A zero vector.
         """
 
-        return cls(data=(0.0, 0.0, 0.0))
+        return cls(x=0.0, y=0.0, z=0.0)
 
     @classmethod
     def ones(cls) -> Vector3:
@@ -605,27 +516,29 @@ class Vector3(Message):
         :return: A ones vector.
         """
 
-        return cls(data=(1.0, 1.0, 1.0))
+        return cls(x=1.0, y=1.0, z=1.0)
 
     @classmethod
-    def from_any(cls, data: Any) -> Vector3:
+    def from_any(cls, value: Vector3 | tuple | list | dict | np.ndarray | None) -> Vector3:
         """
-        Create Vector3 from any iterable (list, tuple, numpy array).
+        Create Vector3 from any compatible type.
+
+        Accepts:
+        - Vector3 instance (returned as-is)
+        - Tuple/list of 3 floats: (x, y, z)
+        - Dict with 'x', 'y', and 'z' keys
+        - Numpy array of shape (3,)
+        - None (returns zero vector)
 
-        :param data: Iterable with 3 values, dict, or a Vector3 instance.
+        :param value: Any compatible input type.
         :return: A Vector3 instance.
-        :raises ValueError: If conversion fails.
         """
 
-        # Already a Vector3 - return as-is
-        if isinstance(data, cls):
-            return data
-
-        try:
-            # Will be handled by validator
-            return cls.model_validate(data)
-        except Exception as e:
-            raise ValueError(f"Cannot convert to Vector3: {e}") from None
+        if value is None:
+            return cls(x=0.0, y=0.0, z=0.0)
+        if isinstance(value, cls):
+            return value
+        return cls.model_validate(value)
 
     @classmethod
     def from_numpy(cls, array: np.ndarray) -> Vector3:
@@ -639,7 +552,7 @@ class Vector3(Message):
 
         if array.shape != (3,):
             raise ValueError(f"Vector3 array must have shape (3,), got {array.shape}")
-        return cls(data=(float(array[0]), float(array[1]), float(array[2])))
+        return cls(x=float(array[0]), y=float(array[1]), z=float(array[2]))
 
     @classmethod
     def from_list(cls, values: list[float]) -> Vector3:
@@ -653,7 +566,7 @@ class Vector3(Message):
 
         if len(values) != 3:
             raise ValueError(f"Vector3 requires 3 values, got {len(values)}")
-        return cls(data=(values[0], values[1], values[2]))
+        return cls(x=values[0], y=values[1], z=values[2])
 
     def dot(self, other: Vector3) -> float:
         """
@@ -674,11 +587,9 @@ class Vector3(Message):
         """
 
         return Vector3(
-            data=(
-                self.y * other.z - self.z * other.y,
-                self.z * other.x - self.x * other.z,
-                self.x * other.y - self.y * other.x,
-            )
+            x=self.y * other.z - self.z * other.y,
+            y=self.z * other.x - self.x * other.z,
+            z=self.x * other.y - self.y * other.x,
         )
 
     def magnitude(self) -> float:
@@ -719,7 +630,7 @@ class Vector3(Message):
         :return: The numpy array.
         """
 
-        return np.array(self.data, dtype=np.float32)
+        return np.array([self.x, self.y, self.z], dtype=np.float32)
 
     def to_list(self) -> list[float]:
         """
@@ -728,7 +639,16 @@ class Vector3(Message):
         :return: The list of values.
         """
 
-        return list(self.data)
+        return [self.x, self.y, self.z]
+
+    def to_tuple(self) -> tuple[float, float, float]:
+        """
+        Convert to a tuple.
+
+        :return: The tuple of values.
+        """
+
+        return (self.x, self.y, self.z)
 
     def to_gf_vec3f(self) -> Gf.Vec3f:
         """
@@ -738,8 +658,8 @@ class Vector3(Message):
         :raises ImportError: If pxr is not installed.
         """
 
-        if not HAS_PXR:
-            raise ImportError("pxr is not installed")
+        from pxr import Gf
+
         return Gf.Vec3f(self.x, self.y, self.z)
 
     def to_gf_vec3d(self) -> Gf.Vec3d:
@@ -750,11 +670,11 @@ class Vector3(Message):
         :raises ImportError: If pxr is not installed.
         """
 
-        if not HAS_PXR:
-            raise ImportError("pxr is not installed")
+        from pxr import Gf
+
         return Gf.Vec3d(self.x, self.y, self.z)
 
-    def to_quat(self) -> "Quaternion":
+    def to_quat(self) -> Quaternion:
         """
         Convert RPY angles to quaternion.
 
@@ -763,8 +683,6 @@ class Vector3(Message):
         :return: Quaternion representation.
         """
 
-        from common.message.quaternion import Quaternion
-
         return Quaternion.from_rpy(self.x, self.y, self.z)
 
     def to_point(self) -> Point3:
@@ -776,11 +694,28 @@ class Vector3(Message):
 
         return Point3(x=self.x, y=self.y, z=self.z)
 
-    def as_array(self) -> list[float]:
+    def to_foxglove(self) -> FoxgloveVector3:
         """
-        Convert to a list (alias for to_list for Rust compatibility).
+        Convert to Foxglove Vector3 for telemetry.
 
-        :return: The list of values.
+        :return: Foxglove Vector3 schema.
         """
 
-        return self.to_list()
+        return FoxgloveVector3(x=self.x, y=self.y, z=self.z)
+
+    @model_validator(mode="before")
+    @classmethod
+    def _convert_input(cls, data: Any) -> Any:
+        """
+        Convert various input types to Vector3 format.
+        """
+
+        if isinstance(data, cls):
+            return {"x": data.x, "y": data.y, "z": data.z}
+        if isinstance(data, (tuple, list)) and len(data) == 3:
+            return {"x": float(data[0]), "y": float(data[1]), "z": float(data[2])}
+        if isinstance(data, np.ndarray) and data.shape == (3,):
+            return {"x": float(data[0]), "y": float(data[1]), "z": float(data[2])}
+        if isinstance(data, dict) and "x" in data and "y" in data and "z" in data:
+            return {"x": float(data["x"]), "y": float(data["y"]), "z": float(data["z"])}
+        return data