plexus-python-common 1.0.61__tar.gz → 1.0.63__tar.gz

{plexus_python_common-1.0.61 → plexus_python_common-1.0.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-common
-Version: 1.0.61
+Version: 1.0.63
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{plexus_python_common-1.0.61 → plexus_python_common-1.0.63}/src/plexus/common/carto/OSMFile.py

@@ -5,7 +5,7 @@ import lxml.etree
 from plexus.common.carto.OSMNode import OSMNode
 from plexus.common.carto.OSMTags import OSMTags
 from plexus.common.carto.OSMWay import OSMWay
-from plexus.common.proj import Coord, Proj
+from plexus.common.utils.gisutils import Coord, Proj
 
 
 class OSMFile(object):

{plexus_python_common-1.0.61 → plexus_python_common-1.0.63}/src/plexus/common/carto/OSMNode.py

@@ -1,7 +1,7 @@
 from iker.common.utils.strutils import repr_data
 
 from plexus.common.carto.OSMTags import OSMTags
-from plexus.common.proj import Coord
+from plexus.common.utils.gisutils import Coord
 
 
 class OSMNode(object):

plexus_python_common-1.0.61/src/plexus/common/proj.py → plexus_python_common-1.0.63/src/plexus/common/utils/gisutils.py

@@ -5,10 +5,111 @@ from typing import Annotated, Self
 import numpy as np
 import pydantic as pdt
 import pyproj
+import pyquaternion as pyquat
 from iker.common.utils.funcutils import singleton
 from iker.common.utils.strutils import parse_params_string, repr_data, str_conv
 
-from plexus.common.pose import Pose
+
+class Pose(object):
+    @classmethod
+    def from_numbers(
+        cls,
+        px: float,
+        py: float,
+        pz: float,
+        qx: float,
+        qy: float,
+        qz: float,
+        qw: float,
+        ts: float = 0,
+    ) -> Self:
+        """
+        Constructs a pose from numbers representing position and orientation
+        """
+        return Pose(ts, np.array([px, py, pz], dtype=np.float64), np.array([qw, qx, qy, qz], dtype=np.float64))
+
+    @classmethod
+    def add(cls, x: Self, d: Self) -> Self:
+        """
+        Performs pose SE3 addition, as x + d = y
+        """
+        xq = pyquat.Quaternion(x.q)
+        dq = pyquat.Quaternion(d.q)
+
+        yp = x.p + xq.rotate(d.p)
+        yq = xq * dq
+
+        return Pose(0, yp, yq.normalised.elements)
+
+    @classmethod
+    def sub(cls, y: Self, x: Self) -> Self:
+        """
+        Performs pose SE3 subtraction, as x + d = y => d = y - x
+        """
+        xq = pyquat.Quaternion(x.q)
+        yq = pyquat.Quaternion(y.q)
+
+        dp = xq.inverse.rotate(y.p - x.p)
+        dq = xq.inverse * yq
+
+        return Pose(0, dp, dq.normalised.elements)
+
+    @classmethod
+    def interpolate(cls, a: Self, b: Self, t: float) -> Self:
+        """
+        Interpolates between two given poses, as a * t + b * (1 - t)
+
+        :return: interpolated pose
+        """
+        ts = a.ts + (b.ts - a.ts) * t
+        p = a.p + (b.p - a.p) * t
+        q = pyquat.Quaternion.slerp(pyquat.Quaternion(a.q), pyquat.Quaternion(b.q), t)
+        return Pose(ts, p, q.normalised.elements)
+
+    def __init__(self, ts: float, p: np.ndarray, q: np.ndarray):
+        """
+        Represents a pose
+
+        :param ts: timestamp
+        :param p: position vector
+        :param q: orientation quaternion
+        """
+        self.ts = ts
+        self.p = p
+        self.q = q
+
+    def matrix(self) -> np.ndarray:
+        """
+        Returns the transformation matrix of this pose
+
+        :return: transformation matrix
+        """
+        r = pyquat.Quaternion(self.q).rotation_matrix
+        t = self.p[:, None]
+        return np.block([[r, t], [np.zeros((1, 3), dtype=np.float64), np.ones((1, 1), dtype=np.float64)]])
+
+    def translate(self, v: np.ndarray) -> np.ndarray:
+        """
+        Translate the given vector with the pose position
+
+        :param v: the vector to be translated
+
+        :return: translated vector
+        """
+        return self.p + v
+
+    def rotate(self, v: np.ndarray) -> np.ndarray:
+        """
+        Rotates the given vector with the pose orientation
+
+        :param v: the vector to be rotated
+
+        :return: rotated vector
+        """
+        return pyquat.Quaternion(self.q).rotate(v)
+
+    def __str__(self):
+        return repr_data(self)
 
 
 class Proj(ABC):

{plexus_python_common-1.0.61 → plexus_python_common-1.0.63}/src/plexus/common/utils/tagutils.py

@@ -382,11 +382,11 @@ class TagTarget(BaseModel):
         description="Name of the tagger that generates the tag records for the target",
     )
     tagger_version: str = Field(
-        sa_column=sa.Column(sa_sqlite.VARCHAR(64), nullable=False),
+        sa_column=sa.Column(sa_sqlite.VARCHAR(32), nullable=False),
         description="Version of the tagger that generates the tag records for the target",
     )
     vehicle_name: str = Field(
-        sa_column=sa.Column(sa_sqlite.TEXT, nullable=False),
+        sa_column=sa.Column(sa_sqlite.VARCHAR(128), nullable=False),
         description="Vehicle name associated with the tag record",
     )
     begin_dt: datetime.datetime = Field(
@@ -455,12 +455,12 @@ class TagRecord(BaseModel):
         description="End datetime of the tag record",
     )
     tagset_namespace: str | None = Field(
-        sa_column=sa.Column(sa_sqlite.VARCHAR(128), nullable=True),
+        sa_column=sa.Column(sa_sqlite.VARCHAR(64), nullable=True),
         default=None,
         description="Namespace of the tagset that the tag belongs to",
     )
     tagset_version: str | None = Field(
-        sa_column=sa.Column(sa_sqlite.VARCHAR(64), nullable=True),
+        sa_column=sa.Column(sa_sqlite.VARCHAR(32), nullable=True),
         default=None,
         description="Version of the tagset that the tag belongs to",
     )
@@ -469,7 +469,7 @@ class TagRecord(BaseModel):
         description="Tag name",
     )
     props: JsonType | None = Field(
-        sa_column=sa.Column(sa_sqlite.TEXT, nullable=True),
+        sa_column=sa.Column(sa_sqlite.JSON, nullable=True),
         default=None,
         description="Additional properties of the tag record in JSON format",
     )

{plexus_python_common-1.0.61 → plexus_python_common-1.0.63}/src/plexus_python_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-common
-Version: 1.0.61
+Version: 1.0.63
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{plexus_python_common-1.0.61 → plexus_python_common-1.0.63}/src/plexus_python_common.egg-info/SOURCES.txt

@@ -39,8 +39,6 @@ resources/unittest/s3utils/dir.foo/dir.foo.bar/dir.foo.bar.baz/file.foo.bar.baz
 resources/unittest/s3utils_archive/archive.compressed.zip
 resources/unittest/s3utils_archive/archive.uncompressed.zip
 src/plexus/common/__init__.py
-src/plexus/common/pose.py
-src/plexus/common/proj.py
 src/plexus/common/carto/OSMFile.py
 src/plexus/common/carto/OSMNode.py
 src/plexus/common/carto/OSMTags.py
@@ -56,6 +54,7 @@ src/plexus/common/utils/bagutils.py
 src/plexus/common/utils/config.py
 src/plexus/common/utils/datautils.py
 src/plexus/common/utils/dockerutils.py
+src/plexus/common/utils/gisutils.py
 src/plexus/common/utils/jsonutils.py
 src/plexus/common/utils/ormutils.py
 src/plexus/common/utils/pathutils.py
@@ -73,8 +72,6 @@ src/plexus_python_common.egg-info/top_level.txt
 test/testenv.py
 test/plexus_tests/__init__.py
 test/plexus_tests/common/__init__.py
-test/plexus_tests/common/pose_test.py
-test/plexus_tests/common/proj_test.py
 test/plexus_tests/common/carto/__init__.py
 test/plexus_tests/common/carto/osm_file_test.py
 test/plexus_tests/common/carto/osm_tags_test.py
@@ -82,6 +79,7 @@ test/plexus_tests/common/utils/__init__.py
 test/plexus_tests/common/utils/bagutils_test.py
 test/plexus_tests/common/utils/datautils_test.py
 test/plexus_tests/common/utils/dockerutils_test.py
+test/plexus_tests/common/utils/gisutils_test.py
 test/plexus_tests/common/utils/jsonutils_test.py
 test/plexus_tests/common/utils/ormutils_test.py
 test/plexus_tests/common/utils/pathutils_test.py

{plexus_python_common-1.0.61 → plexus_python_common-1.0.63}/test/plexus_tests/common/carto/osm_file_test.py

@@ -4,8 +4,8 @@ import unittest.mock
 import lxml.etree
 
 from plexus.common.carto import OSMFile
-from plexus.common.proj import Coord
-from plexus.common.proj import make_proj
+from plexus.common.utils.gisutils import Coord
+from plexus.common.utils.gisutils import make_proj
 
 
 class MockedTree(object):

plexus_python_common-1.0.61/test/plexus_tests/common/proj_test.py → plexus_python_common-1.0.63/test/plexus_tests/common/utils/gisutils_test.py

@@ -1,11 +1,73 @@
+import math
 import random
 import unittest
 
 import ddt
+import numpy as np
 import pydantic as pdt
+import pyquaternion as pyquat
+from iker.common.utils.randutils import randomizer
 
-from plexus.common.proj import Coord, EQDCProj, UTMProj, WebMercProj
-from plexus.common.proj import make_proj
+from plexus.common.utils.gisutils import Coord, EQDCProj, UTMProj, WebMercProj
+from plexus.common.utils.gisutils import Pose
+from plexus.common.utils.gisutils import make_proj
+
+
+@ddt.ddt
+class PoseTest(unittest.TestCase):
+
+    @staticmethod
+    def random_pose() -> Pose:
+        q = pyquat.Quaternion(axis=randomizer().random_unit_vector(3),
+                              angle=math.pi * randomizer().next_float(0.0, 0.5))
+        return Pose(0, np.array(randomizer().random_unit_vector(3)), q.normalised.elements)
+
+    def assert_array_almost_equal(self, xs: np.ndarray, ys: np.ndarray, delta: float):
+        self.assertEqual(len(xs), len(ys))
+        for x, y in zip(xs, ys):
+            self.assertAlmostEqual(x, y, delta=delta)
+
+    def test_builtin_init(self):
+        for _ in range(0, 10000):
+            expect = PoseTest.random_pose()
+            actual = Pose(0, expect.p, expect.q)
+
+            self.assert_array_almost_equal(expect.p, actual.p, delta=1e-9)
+            self.assert_array_almost_equal(expect.q, actual.q, delta=1e-9)
+
+    def test_add_sub(self):
+        for _ in range(0, 10000):
+            pose = PoseTest.random_pose()
+            delta = PoseTest.random_pose()
+
+            result = Pose.sub(Pose.add(pose, delta), pose)
+
+            self.assert_array_almost_equal(delta.p, result.p, delta=1e-9)
+            self.assert_array_almost_equal(delta.q, result.q, delta=1e-9)
+
+    def test_interpolate(self):
+        for _ in range(0, 10000):
+            t = randomizer().next_float()
+
+            pose1 = PoseTest.random_pose()
+            pose2 = PoseTest.random_pose()
+
+            inter1 = Pose.interpolate(pose1, pose2, t)
+            inter2 = Pose.interpolate(pose2, pose1, 1.0 - t)
+
+            self.assert_array_almost_equal(inter1.p, inter2.p, delta=1e-9)
+            self.assert_array_almost_equal(inter1.q, inter2.q, delta=1e-9)
+
+    def test_matrix(self):
+        for _ in range(0, 10000):
+            point = np.array(randomizer().random_unit_vector(3))
+
+            pose = PoseTest.random_pose()
+
+            expect = pose.translate(pose.rotate(point))
+            result = np.matmul(pose.matrix(), np.array([*point, 1.0])[:, None]).transpose()[0][:3]
+
+            self.assert_array_almost_equal(expect, result, delta=1e-9)
 
 
 @ddt.ddt

{plexus_python_common-1.0.61 → plexus_python_common-1.0.63}/test/plexus_tests/common/utils/tagutils_test.py

@@ -133,6 +133,19 @@ class TagUtilsTest(unittest.TestCase):
                 dt_parse_iso("2020-01-01T00:00:00+00:00") + datetime.timedelta(seconds=i),
                 dt_parse_iso("2020-01-02T00:00:00+00:00") + datetime.timedelta(seconds=i + 1),
                 tag,
+                props={
+                    "dummy_int": 1,
+                    "dummy_float": 1.0e-1,
+                    "dummy_bool": True,
+                    "dummy_str": "dummy_string",
+                    "dummy_list": [1, 1.0e-1, True, "dummy_string"],
+                    "dummy_dict": {
+                        "dummy_int": 1,
+                        "dummy_float": 1.0e-1,
+                        "dummy_bool": True,
+                        "dummy_str": "dummy_string",
+                    },
+                },
             )
 
         self.assertEqual(len(list(target_cache.iter_tags())), tag_records_count)
@@ -271,6 +284,19 @@ class TagUtilsTest(unittest.TestCase):
                         dt_parse_iso("2020-01-01T00:00:00+00:00") + datetime.timedelta(seconds=i),
                         dt_parse_iso("2020-01-02T00:00:00+00:00") + datetime.timedelta(seconds=i + 1),
                         tag,
+                        props={
+                            "dummy_int": 1,
+                            "dummy_float": 1.0e-1,
+                            "dummy_bool": True,
+                            "dummy_str": "dummy_string",
+                            "dummy_list": [1, 1.0e-1, True, "dummy_string"],
+                            "dummy_dict": {
+                                "dummy_int": 1,
+                                "dummy_float": 1.0e-1,
+                                "dummy_bool": True,
+                                "dummy_str": "dummy_string",
+                            },
+                        },
                     )
 
             threads = [threading.Thread(target=worker, args=(tid,)) for tid in range(total_threads_count)]

plexus_python_common-1.0.61/src/plexus/common/pose.py

@@ -1,107 +0,0 @@
-from typing import Self
-
-import numpy as np
-import pyquaternion as pyquat
-from iker.common.utils.strutils import repr_data
-
-
-class Pose(object):
-    @classmethod
-    def from_numbers(
-        cls,
-        px: float,
-        py: float,
-        pz: float,
-        qx: float,
-        qy: float,
-        qz: float,
-        qw: float,
-        ts: float = 0,
-    ) -> Self:
-        """
-        Constructs a pose from numbers representing position and orientation
-        """
-        return Pose(ts, np.array([px, py, pz], dtype=np.float64), np.array([qw, qx, qy, qz], dtype=np.float64))
-
-    @classmethod
-    def add(cls, x: Self, d: Self) -> Self:
-        """
-        Performs pose SE3 addition, as x + d = y
-        """
-        xq = pyquat.Quaternion(x.q)
-        dq = pyquat.Quaternion(d.q)
-
-        yp = x.p + xq.rotate(d.p)
-        yq = xq * dq
-
-        return Pose(0, yp, yq.normalised.elements)
-
-    @classmethod
-    def sub(cls, y: Self, x: Self) -> Self:
-        """
-        Performs pose SE3 subtraction, as x + d = y => d = y - x
-        """
-        xq = pyquat.Quaternion(x.q)
-        yq = pyquat.Quaternion(y.q)
-
-        dp = xq.inverse.rotate(y.p - x.p)
-        dq = xq.inverse * yq
-
-        return Pose(0, dp, dq.normalised.elements)
-
-    @classmethod
-    def interpolate(cls, a: Self, b: Self, t: float) -> Self:
-        """
-        Interpolates between two given poses, as a * t + b * (1 - t)
-
-        :return: interpolated pose
-        """
-        ts = a.ts + (b.ts - a.ts) * t
-        p = a.p + (b.p - a.p) * t
-        q = pyquat.Quaternion.slerp(pyquat.Quaternion(a.q), pyquat.Quaternion(b.q), t)
-        return Pose(ts, p, q.normalised.elements)
-
-    def __init__(self, ts: float, p: np.ndarray, q: np.ndarray):
-        """
-        Represents a pose
-
-        :param ts: timestamp
-        :param p: position vector
-        :param q: orientation quaternion
-        """
-        self.ts = ts
-        self.p = p
-        self.q = q
-
-    def matrix(self) -> np.ndarray:
-        """
-        Returns the transformation matrix of this pose
-
-        :return: transformation matrix
-        """
-        r = pyquat.Quaternion(self.q).rotation_matrix
-        t = self.p[:, None]
-        return np.block([[r, t], [np.zeros((1, 3), dtype=np.float64), np.ones((1, 1), dtype=np.float64)]])
-
-    def translate(self, v: np.ndarray) -> np.ndarray:
-        """
-        Translate the given vector with the pose position
-
-        :param v: the vector to be translated
-
-        :return: translated vector
-        """
-        return self.p + v
-
-    def rotate(self, v: np.ndarray) -> np.ndarray:
-        """
-        Rotates the given vector with the pose orientation
-
-        :param v: the vector to be rotated
-
-        :return: rotated vector
-        """
-        return pyquat.Quaternion(self.q).rotate(v)
-
-    def __str__(self):
-        return repr_data(self)

plexus_python_common-1.0.61/test/plexus_tests/common/pose_test.py

@@ -1,66 +0,0 @@
-import math
-import unittest
-
-import ddt
-import numpy as np
-import pyquaternion as pyquat
-from iker.common.utils.randutils import randomizer
-
-from plexus.common.pose import Pose
-
-
-@ddt.ddt
-class PoseTest(unittest.TestCase):
-
-    @staticmethod
-    def random_pose() -> Pose:
-        q = pyquat.Quaternion(axis=randomizer().random_unit_vector(3),
-                              angle=math.pi * randomizer().next_float(0.0, 0.5))
-        return Pose(0, np.array(randomizer().random_unit_vector(3)), q.normalised.elements)
-
-    def assert_array_almost_equal(self, xs: np.ndarray, ys: np.ndarray, delta: float):
-        self.assertEqual(len(xs), len(ys))
-        for x, y in zip(xs, ys):
-            self.assertAlmostEqual(x, y, delta=delta)
-
-    def test_builtin_init(self):
-        for _ in range(0, 10000):
-            expect = PoseTest.random_pose()
-            actual = Pose(0, expect.p, expect.q)
-
-            self.assert_array_almost_equal(expect.p, actual.p, delta=1e-9)
-            self.assert_array_almost_equal(expect.q, actual.q, delta=1e-9)
-
-    def test_add_sub(self):
-        for _ in range(0, 10000):
-            pose = PoseTest.random_pose()
-            delta = PoseTest.random_pose()
-
-            result = Pose.sub(Pose.add(pose, delta), pose)
-
-            self.assert_array_almost_equal(delta.p, result.p, delta=1e-9)
-            self.assert_array_almost_equal(delta.q, result.q, delta=1e-9)
-
-    def test_interpolate(self):
-        for _ in range(0, 10000):
-            t = randomizer().next_float()
-
-            pose1 = PoseTest.random_pose()
-            pose2 = PoseTest.random_pose()
-
-            inter1 = Pose.interpolate(pose1, pose2, t)
-            inter2 = Pose.interpolate(pose2, pose1, 1.0 - t)
-
-            self.assert_array_almost_equal(inter1.p, inter2.p, delta=1e-9)
-            self.assert_array_almost_equal(inter1.q, inter2.q, delta=1e-9)
-
-    def test_matrix(self):
-        for _ in range(0, 10000):
-            point = np.array(randomizer().random_unit_vector(3))
-
-            pose = PoseTest.random_pose()
-
-            expect = pose.translate(pose.rotate(point))
-            result = np.matmul(pose.matrix(), np.array([*point, 1.0])[:, None]).transpose()[0][:3]
-
-            self.assert_array_almost_equal(expect, result, delta=1e-9)