plexus-python-common 1.0.48__tar.gz → 1.0.49__tar.gz

{plexus_python_common-1.0.48 → plexus_python_common-1.0.49}/PKG-INFO

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

{plexus_python_common-1.0.48 → plexus_python_common-1.0.49}/src/plexus/common/utils/tagutils.py

@@ -36,6 +36,7 @@ __all__ = [
     "RichDesc",
     "Tag",
     "Tagset",
+    "MutableTagset",
     "populate_tagset",
     "predefined_tagsets",
     "render_tagset_markdown_readme",
@@ -132,8 +133,13 @@ class Tag(object):
     def parent_tag_name(self) -> str | None:
         return head_or_none(self.name.rsplit(":", 1))
 
-    def populate(self, vehicle_name: str, begin_dt: datetime.datetime, end_dt: datetime.datetime,
-                 props: JsonType) -> TagRecord:
+    def populate(
+        self,
+        vehicle_name: str,
+        begin_dt: datetime.datetime,
+        end_dt: datetime.datetime,
+        props: JsonType,
+    ) -> TagRecord:
         return TagRecord(
             vehicle_name=vehicle_name,
             begin_dt=begin_dt,
@@ -175,11 +181,49 @@ class Tagset(Sequence[Tag], Mapping[str, Tag]):
         tag_name = item.name if isinstance(item, Tag) else item
         return self.tags_dict.get(tag_name)
 
+    def clone(self) -> Self:
+        return clone_tagset(self)
+
+    def mutable(self):
+        return clone_mutable_tagset(self)
+
+    def frozen(self):
+        return self.clone()
+
     @property
     def tag_names(self) -> list[str]:
         return list(self.tags_dict.keys())
 
-    def add(self, tag: Tag) -> None:
+    def child_tags(self, parent: str | Tag) -> list[Tag]:
+        if parent is None:
+            return []
+        if isinstance(parent, str):
+            return self.child_tags(self.get(parent))
+
+        subtree = dicttree_subtree(self.tags_tree, parent.tag_parts)
+        return list(dicttree_children(subtree)) if subtree else []
+
+    def parent_tags(self, child: str | Tag) -> list[Tag]:
+        if child is None:
+            return []
+        if isinstance(child, str):
+            return self.parent_tags(self.get(child))
+
+        return list(dicttree_lineage(self.tags_tree, child.tag_parts[:-1]))
+
+
+class MutableTagset(Tagset):
+
+    def clone(self) -> Self:
+        return clone_mutable_tagset(self)
+
+    def mutable(self):
+        return self.clone()
+
+    def frozen(self):
+        return clone_tagset(self)
+
+    def add(self, tag: Tag) -> Self:
         if tag.name in self.tags_dict:
             raise ValueError(f"duplicate tag name '{tag.name}'")
 
@@ -188,7 +232,9 @@ class Tagset(Sequence[Tag], Mapping[str, Tag]):
 
         dicttree_add(self.tags_tree, tag.tag_parts, tag, create_prefix=True)
 
-    def remove(self, tag_name: str) -> None:
+        return self
+
+    def remove(self, tag_name: str) -> Self:
         tag = self.get(tag_name)
         if tag is None:
             raise ValueError(f"tag '{tag_name}' not found")
@@ -198,22 +244,23 @@ class Tagset(Sequence[Tag], Mapping[str, Tag]):
 
         dicttree_remove(self.tags_tree, tag.tag_parts, recursive=True)
 
-    def child_tags(self, parent: str | Tag) -> list[Tag]:
-        if parent is None:
-            return []
-        if isinstance(parent, str):
-            return self.child_tags(self.get(parent))
+        return self
 
-        subtree = dicttree_subtree(self.tags_tree, parent.tag_parts)
-        return list(dicttree_children(subtree)) if subtree else []
 
-    def parent_tags(self, child: str | Tag) -> list[Tag]:
-        if child is None:
-            return []
-        if isinstance(child, str):
-            return self.parent_tags(self.get(child))
+def clone_tagset(tagset: Tagset) -> Tagset:
+    tagset = clone_mutable_tagset(tagset)
+    new_tagset = Tagset(namespace=tagset.namespace, desc=tagset.desc)
+    new_tagset.tags = tagset.tags
+    new_tagset.tags_dict = tagset.tags_dict
+    new_tagset.tags_tree = tagset.tags_tree
+    return new_tagset
 
-        return list(dicttree_lineage(self.tags_tree, child.tag_parts[:-1]))
+
+def clone_mutable_tagset(tagset: Tagset) -> MutableTagset:
+    new_tagset = MutableTagset(namespace=tagset.namespace, desc=tagset.desc)
+    for tag in tagset.tags:
+        new_tagset.add(tag)
+    return new_tagset
 
 
 def populate_tagset(tagset_spec: JsonObject) -> Tagset:
@@ -268,12 +315,12 @@ def populate_tagset(tagset_spec: JsonObject) -> Tagset:
     if tags is None:
         raise ValueError("missing '$tags' in tagset spec")
 
-    tagset = Tagset(namespace=namespace, desc=desc)
+    tagset = MutableTagset(namespace=namespace, desc=desc)
 
     for tag in validate_and_collect("", tags):
         tagset.add(tag)
 
-    return tagset
+    return tagset.frozen()
 
 
 @singleton
@@ -330,25 +377,34 @@ def tag_cache_file_path() -> pathlib.Path:
 
 
 class TagCache(object):
-    def __init__(self, *, file_path: str | os.PathLike[str] | None = None, fail_if_exists: bool = False):
+    def __init__(
+        self,
+        *,
+        file_path: str | os.PathLike[str] | None = None,
+        fail_if_exists: bool = False,
+    ):
         self.file_path = pathlib.Path(file_path or tag_cache_file_path())
         if fail_if_exists and self.file_path.exists():
             raise FileExistsError(f"tag cache file '{str(self.file_path)}' already exists")
         self.file_path.parent.mkdir(parents=True, exist_ok=True)
+
         self.conn_maker = ConnectionMaker.from_url(f"sqlite:///{str(self.file_path.absolute())}",
                                                    engine_opts=dict(connect_args={"check_same_thread": False}))
         BaseModel.metadata.create_all(self.conn_maker.engine)
 
     def query(
         self,
-        vehicle_name: str,
+        vehicle_name: str | None = None,
         begin_time: datetime.datetime | None = None,
         end_time: datetime.datetime | None = None,
         tag_pattern: str | None = None,
-    ) -> list[TagRecordTable]:
+        *,
+        tagsets: Sequence[Tagset] | None = None,
+    ) -> Generator[TagRecordTable]:
         with self.conn_maker.make_session() as session:
-            query = session.query(TagRecordTable).where(TagRecordTable.vehicle_name == vehicle_name)
-
+            query = session.query(TagRecordTable)
+            if vehicle_name:
+                query = query.filter(TagRecordTable.vehicle_name == vehicle_name)
             if begin_time:
                 query = query.filter(TagRecordTable.end_dt >= begin_time)
             if end_time:
@@ -356,7 +412,15 @@ class TagCache(object):
             if tag_pattern:
                 query = query.filter(TagRecordTable.tag.like(f"{escape_sql_like(tag_pattern)}%", escape="\\"))
 
-            return query.all()
+            if not tagsets:
+                yield from query.all()
+            else:
+                yield from (db_tag_record for db_tag_record in query.all()
+                            if any(db_tag_record.tag in tagset for tagset in tagsets))
+
+    def undefined(self, tagsets: Sequence[Tagset]) -> Generator[TagRecordTable, None, None]:
+        yield from (db_tag_record for db_tag_record in self.query()
+                    if all(db_tag_record.tag not in tagset for tagset in tagsets))
 
     def add(
         self,
@@ -365,7 +429,7 @@ class TagCache(object):
         end_time: datetime.datetime,
         tag: str | Tag,
         props: JsonType | None = None,
-    ):
+    ) -> Self:
         with self.conn_maker.make_session() as session:
             tag_record = TagRecord(
                 vehicle_name=vehicle_name,
@@ -377,7 +441,9 @@ class TagCache(object):
             session.add(clone_sequence_model_instance(TagRecordTable, tag_record))
             session.commit()
 
-    def remove(self, vehicle_name: str, begin_time: datetime.datetime, end_time: datetime.datetime):
+        return self
+
+    def remove(self, vehicle_name: str, begin_time: datetime.datetime, end_time: datetime.datetime) -> Self:
         with self.conn_maker.make_session() as session:
             session.execute(
                 sa
@@ -390,6 +456,8 @@ class TagCache(object):
             )
             session.commit()
 
+        return self
+
     def clear(self):
         with self.conn_maker.make_session() as session:
             session.execute(sa.delete(TagRecordTable))

{plexus_python_common-1.0.48 → plexus_python_common-1.0.49}/src/plexus_python_common.egg-info/PKG-INFO

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

plexus_python_common-1.0.49/test/plexus_tests/common/utils/tagutils_test.py

@@ -0,0 +1,104 @@
+import datetime
+import unittest
+
+import ddt
+from iker.common.utils.dtutils import dt_parse_iso
+
+from plexus.common.utils.tagutils import MutableTagset, Tag, TagCache, Tagset
+from plexus.common.utils.tagutils import predefined_tagsets, render_tagset_markdown_readme
+from plexus.common.utils.tagutils import tag_cache_file_path
+
+
+@ddt.ddt
+class TagUtilsTest(unittest.TestCase):
+
+    def test_predefined_tagsets(self):
+        tagsets = predefined_tagsets()
+        for _, tagset in tagsets.items():
+            self.assertIsInstance(tagset, Tagset)
+            self.assertNotIsInstance(tagset, MutableTagset)
+
+            for tag in tagset:
+                self.assertIn(tag, tagset)
+                self.assertIn(tag.name, tagset)
+                self.assertEqual(tag, tagset.get(tag))
+                self.assertEqual(tag, tagset.get(tag.name))
+
+            markdown = render_tagset_markdown_readme(tagset)
+            self.assertIsInstance(markdown, str)
+
+            print(markdown)
+
+    def test_tag_cache(self):
+        tag_cache = TagCache()
+
+        self.assertEqual(tag_cache.file_path, tag_cache_file_path())
+        self.assertTrue(tag_cache.file_path.exists())
+
+        self.assertEqual(len(list(tag_cache.query("dummy_vehicle"))), 0)
+
+        tagset = MutableTagset(namespace="tagset", desc="A dummy tagset for testing")
+
+        tagset.add(Tag(name="dummy:foo", desc="A dummy tag for testing"))
+        tagset.add(Tag(name="dummy:bar", desc="A dummy tag for testing"))
+
+        tags = [
+            "dummy:foo",
+            "dummy:bar",
+            "dummy:baz",
+            "dummy:qux",
+        ]
+        for i in range(1000):
+            tag_cache.add(
+                "dummy_vehicle",
+                dt_parse_iso("2020-01-01T00:00:00.000000+00:00") + datetime.timedelta(seconds=i),
+                dt_parse_iso("2021-01-01T00:00:00.000000+00:00") + datetime.timedelta(seconds=i + 1),
+                tags[i % len(tags)],
+            )
+
+        self.assertEqual(len(list(tag_cache.query())), 1000)
+        self.assertEqual(len(list(tag_cache.query("dummy_vehicle"))), 1000)
+        self.assertEqual(len(list(tag_cache.query(tagsets=[tagset]))), 500)
+        self.assertEqual(
+            len(list(tag_cache.query("dummy_vehicle",
+                                     dt_parse_iso("2020-01-01T00:00:00.000000+00:00"),
+                                     dt_parse_iso("2020-01-01T00:01:00.000000+00:00")))),
+            61,
+        )
+        self.assertEqual(
+            len(list(tag_cache.query("dummy_vehicle",
+                                     dt_parse_iso("2020-01-01T00:00:00.000000+00:00"),
+                                     dt_parse_iso("2020-01-01T00:01:00.000000+00:00"),
+                                     tag_pattern="dummy:foo"))),
+            16,
+        )
+        self.assertEqual(
+            len(list(tag_cache.query("dummy_vehicle",
+                                     dt_parse_iso("2020-01-01T00:00:00.000000+00:00"),
+                                     dt_parse_iso("2020-01-01T00:01:00.000000+00:00"),
+                                     tag_pattern="dummy:bar"))),
+            15,
+        )
+        self.assertEqual(
+            len(list(tag_cache.query("dummy_vehicle",
+                                     dt_parse_iso("2020-01-01T00:00:00.000000+00:00"),
+                                     dt_parse_iso("2020-01-01T00:01:00.000000+00:00"),
+                                     tag_pattern="dummy"))),
+            61,
+        )
+        self.assertEqual(len(list(tag_cache.query("dummy_vehicle", tag_pattern="dummy:foo"))), 250)
+        self.assertEqual(len(list(tag_cache.query("dummy_vehicle", tag_pattern="dummy:bar"))), 250)
+        self.assertEqual(len(list(tag_cache.query("dummy_vehicle", tag_pattern="dummy"))), 1000)
+        self.assertEqual(len(list(tag_cache.query("another_dummy_vehicle"))), 0)
+
+        self.assertEqual(len(list(tag_cache.undefined([tagset]))), 500)
+
+        tag_cache.remove("dummy_vehicle",
+                         dt_parse_iso("2020-01-01T00:00:00.000000+00:00"),
+                         dt_parse_iso("2020-01-01T00:01:00.000000+00:00"))
+
+        self.assertEqual(len(list(tag_cache.query("dummy_vehicle"))), 939)
+
+        tag_cache.clear()
+
+        self.assertEqual(len(list(tag_cache.query("dummy_vehicle"))), 0)

plexus_python_common-1.0.48/test/plexus_tests/common/utils/tagutils_test.py

@@ -1,94 +0,0 @@
-import datetime
-import unittest
-
-import ddt
-from iker.common.utils.dtutils import dt_parse_iso
-
-from plexus.common.utils.tagutils import TagCache, Tagset
-from plexus.common.utils.tagutils import predefined_tagsets, render_tagset_markdown_readme
-from plexus.common.utils.tagutils import tag_cache_file_path
-
-
-@ddt.ddt
-class TagUtilsTest(unittest.TestCase):
-
-    def test_predefined_tagsets(self):
-        tagsets = predefined_tagsets()
-        for _, tagset in tagsets.items():
-            self.assertIsInstance(tagset, Tagset)
-
-            for tag in tagset:
-                self.assertIn(tag, tagset)
-                self.assertIn(tag.name, tagset)
-                self.assertEqual(tag, tagset.get(tag))
-                self.assertEqual(tag, tagset.get(tag.name))
-
-            markdown = render_tagset_markdown_readme(tagset)
-            self.assertIsInstance(markdown, str)
-
-            print(markdown)
-
-    def test_tag_cache(self):
-        tag_cache = TagCache()
-
-        self.assertEqual(tag_cache.file_path, tag_cache_file_path())
-        self.assertTrue(tag_cache.file_path.exists())
-
-        self.assertEqual(len(tag_cache.query("dummy_vehicle")), 0)
-
-        tags = [
-            "dummy:foo",
-            "dummy:bar",
-            "dummy:baz",
-            "dummy:qux",
-        ]
-        for i in range(1000):
-            tag_cache.add(
-                "dummy_vehicle",
-                dt_parse_iso("2020-01-01T00:00:00.000000+00:00") + datetime.timedelta(seconds=i),
-                dt_parse_iso("2021-01-01T00:00:00.000000+00:00") + datetime.timedelta(seconds=i + 1),
-                tags[i % len(tags)],
-            )
-
-        self.assertEqual(len(tag_cache.query("dummy_vehicle")), 1000)
-        self.assertEqual(
-            len(tag_cache.query("dummy_vehicle",
-                                dt_parse_iso("2020-01-01T00:00:00.000000+00:00"),
-                                dt_parse_iso("2020-01-01T00:01:00.000000+00:00"))),
-            61,
-        )
-        self.assertEqual(
-            len(tag_cache.query("dummy_vehicle",
-                                dt_parse_iso("2020-01-01T00:00:00.000000+00:00"),
-                                dt_parse_iso("2020-01-01T00:01:00.000000+00:00"),
-                                tag_pattern="dummy:foo")),
-            16,
-        )
-        self.assertEqual(
-            len(tag_cache.query("dummy_vehicle",
-                                dt_parse_iso("2020-01-01T00:00:00.000000+00:00"),
-                                dt_parse_iso("2020-01-01T00:01:00.000000+00:00"),
-                                tag_pattern="dummy:bar")),
-            15,
-        )
-        self.assertEqual(
-            len(tag_cache.query("dummy_vehicle",
-                                dt_parse_iso("2020-01-01T00:00:00.000000+00:00"),
-                                dt_parse_iso("2020-01-01T00:01:00.000000+00:00"),
-                                tag_pattern="dummy")),
-            61,
-        )
-        self.assertEqual(len(tag_cache.query("dummy_vehicle", tag_pattern="dummy:foo")), 250)
-        self.assertEqual(len(tag_cache.query("dummy_vehicle", tag_pattern="dummy:bar")), 250)
-        self.assertEqual(len(tag_cache.query("dummy_vehicle", tag_pattern="dummy")), 1000)
-        self.assertEqual(len(tag_cache.query("another_dummy_vehicle")), 0)
-
-        tag_cache.remove("dummy_vehicle",
-                         dt_parse_iso("2020-01-01T00:00:00.000000+00:00"),
-                         dt_parse_iso("2020-01-01T00:01:00.000000+00:00"))
-
-        self.assertEqual(len(tag_cache.query("dummy_vehicle")), 939)
-
-        tag_cache.clear()
-
-        self.assertEqual(len(tag_cache.query("dummy_vehicle")), 0)