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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-common
-Version: 1.0.47
+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.47 → plexus_python_common-1.0.49}/src/plexus/common/utils/ormutils.py

@@ -1146,7 +1146,7 @@ def db_read_active_snapshot_model_of_record[SnapshotModelT: SnapshotModelMixin](
 ) -> SnapshotModelT:
     db_instance = db.query(model).where(model.record_sqn == record_sqn, model.expired_at.is_(None)).one_or_none()
     if db_instance is None:
-        raise sa_exc.NoResultFound(f"Active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
+        raise sa_exc.NoResultFound(f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
 
     return db_instance
 
@@ -1218,7 +1218,7 @@ def db_update_snapshot_model[SnapshotModelT: SnapshotModelMixin](
 ) -> SnapshotModelT:
     db_instance = db.query(model).where(model.record_sqn == record_sqn, model.expired_at.is_(None)).one_or_none()
     if db_instance is None:
-        raise sa_exc.NoResultFound(f"Active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
+        raise sa_exc.NoResultFound(f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
 
     db_instance.expired_at = updated_at
     db_instance = clone_snapshot_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
@@ -1247,7 +1247,7 @@ def db_expire_snapshot_model[SnapshotModelT: SnapshotModelMixin](
         .one_or_none()
     )
     if db_instance is None:
-        raise sa_exc.NoResultFound(f"Active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
+        raise sa_exc.NoResultFound(f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
 
     db_instance.expired_at = updated_at
     db_instance = clone_snapshot_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
@@ -1275,7 +1275,7 @@ def db_activate_snapshot_model[SnapshotModelT: SnapshotModelMixin](
         .first()
     )
     if db_instance is None:
-        raise sa_exc.NoResultFound(f"Expired '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
+        raise sa_exc.NoResultFound(f"expired '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
 
     db_new_instance = clone_snapshot_model_instance(model, db_instance)
     db_new_instance.record_sqn = record_sqn
@@ -1371,7 +1371,7 @@ def db_read_active_revision_model_of_record[RevisionModelT: RevisionModelMixin](
 ) -> RevisionModelT:
     db_instance = db.query(model).where(model.record_sqn == record_sqn, model.expired_at.is_(None)).one_or_none()
     if db_instance is None:
-        raise sa_exc.NoResultFound(f"Active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
+        raise sa_exc.NoResultFound(f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
 
     return db_instance
 
@@ -1443,7 +1443,7 @@ def db_update_revision_model[RevisionModelT: RevisionModelMixin](
 ) -> RevisionModelT:
     db_instance = db.query(model).where(model.record_sqn == record_sqn, model.expired_at.is_(None)).one_or_none()
     if db_instance is None:
-        raise sa_exc.NoResultFound(f"Active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
+        raise sa_exc.NoResultFound(f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
 
     db_instance.expired_at = updated_at
     db_instance = clone_revision_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
@@ -1474,7 +1474,7 @@ def db_expire_revision_model[RevisionModelT: RevisionModelMixin](
         .one_or_none()
     )
     if db_instance is None:
-        raise sa_exc.NoResultFound(f"Active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
+        raise sa_exc.NoResultFound(f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
 
     db_instance.expired_at = updated_at
     db_instance = clone_revision_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
@@ -1492,7 +1492,7 @@ def db_activate_revision_model[RevisionModelT: RevisionModelMixin](
     db_instance = db.query(model).where(model.record_sqn == record_sqn, model.expired_at.is_(None)).one_or_none()
     if db_instance is not None:
         raise sa_exc.MultipleResultsFound(
-            f"Active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' already exists")
+            f"active '{model_name_of(model)}' of specified record_sqn '{record_sqn}' already exists")
 
     db_instance = (
         db
@@ -1502,7 +1502,7 @@ def db_activate_revision_model[RevisionModelT: RevisionModelMixin](
         .first()
     )
     if db_instance is None:
-        raise sa_exc.NoResultFound(f"Expired '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
+        raise sa_exc.NoResultFound(f"expired '{model_name_of(model)}' of specified record_sqn '{record_sqn}' not found")
 
     db_new_instance = clone_revision_model_instance(model, db_instance)
     db_new_instance.record_sqn = record_sqn

{plexus_python_common-1.0.47 → plexus_python_common-1.0.49}/src/plexus/common/utils/s3utils.py

@@ -843,7 +843,7 @@ def s3_archive_open_members(
 
     archive_size, member_zip_infos, missed_members = s3_archive_list_files(client, bucket, key, members)
     if missed_members:
-        raise FileNotFoundError(f"Archive members not found: {', '.join(missed_members)}")
+        raise FileNotFoundError(f"archive members not found: {', '.join(missed_members)}")
 
     if callable(use_ranged_requests):
         use_ranged_requests = use_ranged_requests(archive_size, member_zip_infos)

{plexus_python_common-1.0.47 → 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.47 → 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.47
+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.47 → plexus_python_common-1.0.49}/test/plexus_tests/common/utils/ormutils_test.py

@@ -30,9 +30,13 @@ from plexus.common.utils.ormutils import (
     db_activate_revision_model,
     db_activate_snapshot_model,
     db_create_changing_model,
+    db_create_changing_models,
     db_create_revision_model,
+    db_create_revision_models,
     db_create_sequence_model,
+    db_create_sequence_models,
     db_create_snapshot_model,
+    db_create_snapshot_models,
     db_delete_sequence_model,
     db_expire_revision_model,
     db_expire_snapshot_model,
@@ -223,6 +227,21 @@ def test_db_sequence_model_crud(fixture_postgresql_test_proc, fixture_postgresql
         results = db_read_sequence_models(session, DummySequenceModel, 0, 200)
         assert len(results) == 0
 
+        create_records = [random_record() for _ in range(0, 100)]
+
+        results = db_create_sequence_models(session, DummySequenceModel, create_records)
+        assert len(results) == len(create_records)
+
+        for i, result in zip(range(0, 100), results):
+            assert result.sqn == i + 101
+            assert result.dummy_uuid == create_records[i].dummy_uuid
+            assert result.dummy_int == create_records[i].dummy_int
+            assert result.dummy_str == create_records[i].dummy_str
+            assert result.dummy_float == create_records[i].dummy_float
+            assert result.dummy_bool == create_records[i].dummy_bool
+            assert result.dummy_array == create_records[i].dummy_array
+            assert result.dummy_json == create_records[i].dummy_json
+
 
 def test_db_changing_model_crud(fixture_postgresql_test_proc, fixture_postgresql_test):
     scheme = make_scheme(Dialects.postgresql, Drivers.psycopg)
@@ -359,6 +378,26 @@ def test_db_changing_model_crud(fixture_postgresql_test_proc, fixture_postgresql
         results = db_read_sequence_models(session, DummyChangingModel, 0, 200)
         assert len(results) == 0
 
+        create_records = [random_record() for _ in range(0, 100)]
+
+        results = db_create_changing_models(session,
+                                            DummyChangingModel,
+                                            create_records,
+                                            dt_parse_iso("2024-01-01T00:00:00+00:00"))
+        assert len(results) == len(create_records)
+
+        for i, result in zip(range(0, 100), results):
+            assert result.sqn == i + 101
+            assert result.created_at == dt_parse_iso("2024-01-01T00:00:00+00:00")
+            assert result.updated_at == dt_parse_iso("2024-01-01T00:00:00+00:00")
+            assert result.dummy_uuid == create_records[i].dummy_uuid
+            assert result.dummy_int == create_records[i].dummy_int
+            assert result.dummy_str == create_records[i].dummy_str
+            assert result.dummy_float == create_records[i].dummy_float
+            assert result.dummy_bool == create_records[i].dummy_bool
+            assert result.dummy_array == create_records[i].dummy_array
+            assert result.dummy_json == create_records[i].dummy_json
+
 
 def test_db_snapshot_model_crud(fixture_postgresql_test_proc, fixture_postgresql_test):
     scheme = make_scheme(Dialects.postgresql, Drivers.psycopg)
@@ -644,6 +683,27 @@ def test_db_snapshot_model_crud(fixture_postgresql_test_proc, fixture_postgresql
             assert result.dummy_array == update_records[i].dummy_array
             assert result.dummy_json == update_records[i].dummy_json
 
+        create_records = [random_record() for _ in range(0, 100)]
+
+        results = db_create_snapshot_models(session,
+                                            DummySnapshotModel,
+                                            create_records,
+                                            dt_parse_iso("2024-01-01T00:00:00+00:00"))
+        assert len(results) == len(create_records)
+
+        for i, result in zip(range(0, 100), results):
+            assert result.sqn == i + 301
+            assert result.record_sqn == i + 301
+            assert result.created_at == dt_parse_iso("2024-01-01T00:00:00+00:00")
+            assert result.expired_at is None
+            assert result.dummy_uuid == create_records[i].dummy_uuid
+            assert result.dummy_int == create_records[i].dummy_int
+            assert result.dummy_str == create_records[i].dummy_str
+            assert result.dummy_float == create_records[i].dummy_float
+            assert result.dummy_bool == create_records[i].dummy_bool
+            assert result.dummy_array == create_records[i].dummy_array
+            assert result.dummy_json == create_records[i].dummy_json
+
 
 def test_db_revision_model_crud(fixture_postgresql_test_proc, fixture_postgresql_test):
     scheme = make_scheme(Dialects.postgresql, Drivers.psycopg)
@@ -957,6 +1017,29 @@ def test_db_revision_model_crud(fixture_postgresql_test_proc, fixture_postgresql
             assert result.dummy_array == update_records[i].dummy_array
             assert result.dummy_json == update_records[i].dummy_json
 
+        create_records = [random_record() for _ in range(0, 100)]
+
+        results = db_create_revision_models(session,
+                                            DummyRevisionModel,
+                                            create_records,
+                                            dt_parse_iso("2024-01-01T00:00:00+00:00"))
+        assert len(results) == len(create_records)
+
+        for i, result in zip(range(0, 100), results):
+            assert result.sqn == i + 301
+            assert result.record_sqn == i + 301
+            assert result.revision == 1
+            assert result.created_at == dt_parse_iso("2024-01-01T00:00:00+00:00")
+            assert result.updated_at == dt_parse_iso("2024-01-01T00:00:00+00:00")
+            assert result.expired_at is None
+            assert result.dummy_uuid == create_records[i].dummy_uuid
+            assert result.dummy_int == create_records[i].dummy_int
+            assert result.dummy_str == create_records[i].dummy_str
+            assert result.dummy_float == create_records[i].dummy_float
+            assert result.dummy_bool == create_records[i].dummy_bool
+            assert result.dummy_array == create_records[i].dummy_array
+            assert result.dummy_json == create_records[i].dummy_json
+
 
 def test_make_snapshot_model_trigger(fixture_postgresql_test_proc, fixture_postgresql_test):
     scheme = make_scheme(Dialects.postgresql, Drivers.psycopg)

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.47/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)