plexus-python-common 1.0.57__tar.gz → 1.0.59__tar.gz

{plexus_python_common-1.0.57 → plexus_python_common-1.0.59}/PKG-INFO

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

{plexus_python_common-1.0.57 → plexus_python_common-1.0.59}/src/plexus/common/utils/bagutils.py

@@ -148,18 +148,18 @@ class BagReader(AbstractContextManager, BagIOBase):
     @staticmethod
     def open_ros2(db_dir: str | os.PathLike[str], db_filename: str = default_bag_db_file, **kwargs) -> "BagReader":
         """
-        Creates a BagReader instance to read messages from a ROS2 bag file in the specified directory.
+        Creates a ``BagReader`` instance to read messages from a ROS2 bag file in the specified directory.
 
         :param db_dir: path to the directory where the SQLite DB file is located.
         :param db_filename: name of the SQLite DB file to read. Default is "bag.db".
-        :param kwargs: additional keyword arguments to pass to the BagReader constructor.
-        :return: a BagReader instance.
+        :param kwargs: additional keyword arguments to pass to the ``BagReader`` constructor.
+        :return: a ``BagReader`` instance.
         """
         return BagReader(make_path(db_dir) / db_filename)
 
     def __init__(self, bag_file_path: str | os.PathLike[str]):
         """
-        Creates a BagReader instance to read messages from a ROS2 bag file.
+        Creates a ``BagReader`` instance to read messages from a ROS2 bag file.
 
         :param bag_file_path: path to the SQLite DB file to read.
         """
@@ -202,24 +202,26 @@ class BagWriter(AbstractContextManager, BagIOBase):
     @staticmethod
     def open_ros2(db_dir: str | os.PathLike[str], db_filename: str = default_bag_db_file, **kwargs) -> "BagWriter":
         """
-        Creates a BagWriter instance to write messages to a ROS2 bag file in the specified directory.
+        Creates a ``BagWriter`` instance to write messages to a ROS2 bag file in the specified directory.
 
         :param db_dir: path to the directory where the SQLite DB file will be created.
         :param db_filename: name of the SQLite DB file to create. Default is "bag.db".
-        :param kwargs: additional keyword arguments to pass to the BagWriter constructor.
-        :return: a BagWriter instance.
+        :param kwargs: additional keyword arguments to pass to the ``BagWriter`` constructor.
+        :return: a ``BagWriter`` instance.
         """
         return BagWriter(make_path(db_dir) / db_filename, **kwargs)
 
     def __init__(self, bag_file_path: str | os.PathLike[str], *, overwrite: bool = True, exist_ok: bool = False):
         """
-        Creates a BagWriter instance to write messages to a ROS2 bag file.
+        Creates a ``BagWriter`` instance to write messages to a ROS2 bag file.
 
         :param bag_file_path: path to the SQLite DB file to create.
-        :param overwrite: whether to overwrite the SQLite DB file if it already exists. If False and the file already
-          exists, a FileExistsError is raised. If True, the existing file is deleted and a new one is created.
-        :param exist_ok: whether to ignore if the SQLite DB file already exists. If False and the file already exists,
-          a FileExistsError is raised. If True, the existing file is used and no new file is created.
+        :param overwrite: whether to overwrite the SQLite DB file if it already exists. If ``False`` and the file
+                          already exists, a ``FileExistsError`` is raised. If ``True``, the existing file is deleted
+                          and a new one is created.
+        :param exist_ok: whether to ignore if the SQLite DB file already exists. If ``False`` and the file already
+                         exists, a ``FileExistsError`` is raised. If ``True``, the existing file is used and no new
+                         file is created.
         """
         super().__init__(bag_file_path)
 

{plexus_python_common-1.0.57 → plexus_python_common-1.0.59}/src/plexus/common/utils/ormutils.py

@@ -451,11 +451,11 @@ def model_revision_type(dialect: str | None = None) -> sa.types.TypeEngine[int]:
 
 def make_sequence_model_mixin(dialect: str | None = None) -> type[SequenceModelMixin]:
     """
-    Creates a mixin class for SQLModel models that adds a unique identifier field `sqn`.
+    Creates a mixin class for SQLModel models that adds a unique identifier field ``sqn``.
     Use this mixin to add an auto-incremented primary key to your models.
 
-    :param dialect: The database dialect to determine the column type for the `sqn` field.
-    :return: A mixin class that can be used with SQLModel models to add the `sqn` field.
+    :param dialect: The database dialect to determine the column type for the ``sqn`` field.
+    :return: A mixin class that can be used with SQLModel models to add the ``sqn`` field.
     """
 
     class ModelMixin(SQLModel):
@@ -765,11 +765,11 @@ class RevisionModel(make_base_model(), make_revision_model_mixin(), table=True):
 def make_snapshot_model_trigger[SnapshotModelT: SnapshotModelMixin](engine: sa.Engine, model: type[SnapshotModelT]):
     """
     Creates the necessary database objects (sequence, function, trigger) to support automatic snapshot management
-    for the given snapshot model. This includes a sequence for `record_sqn`, a function to handle snapshot updates,
-    and a trigger to invoke the function before inserts. The model must extend `SnapshotModel`.
+    for the given snapshot model. This includes a sequence for ``record_sqn``, a function to handle snapshot updates,
+    and a trigger to invoke the function before inserts. The model must extend ``SnapshotModel``.
 
     :param engine: SQLAlchemy engine connected to the target database.
-    :param model: The snapshot model class extending `SnapshotModel`.
+    :param model: The snapshot model class extending ``SnapshotModel``.
     """
     table_name = model_name_of(model, fallback_classname=False)
     if not table_name:
@@ -834,11 +834,11 @@ def make_snapshot_model_trigger[SnapshotModelT: SnapshotModelMixin](engine: sa.E
 def make_revision_model_trigger[RevisionModelT: RevisionModelMixin](engine: sa.Engine, model: type[RevisionModelT]):
     """
     Creates the necessary database objects (sequence, function, trigger) to support automatic revision management
-    for the given revision model. This includes a sequence for `record_sqn`, a function to handle revision updates,
-    and a trigger to invoke the function before inserts. The model must extend `RevisionModel`.
+    for the given revision model. This includes a sequence for ``record_sqn``, a function to handle revision updates,
+    and a trigger to invoke the function before inserts. The model must extend ``RevisionModel``.
 
     :param engine: SQLAlchemy engine connected to the target database.
-    :param model: The revision model class extending `RevisionModel`.
+    :param model: The revision model class extending ``RevisionModel``.
     """
     table_name = model_name_of(model, fallback_classname=False)
     if not table_name:

{plexus_python_common-1.0.57 → plexus_python_common-1.0.59}/src/plexus/common/utils/tagutils.py

@@ -69,7 +69,8 @@ class Tag(object):
 
     @property
     def parent_tag_name(self) -> str | None:
-        return head_or_none(self.name.rsplit(":", 1))
+        name = head_or_none(self.name.rsplit(":", 1))
+        return None if is_blank(name) or name == self.name else name
 
     def unbind(self) -> Self:
         return self
@@ -155,18 +156,18 @@ class Tagset(Sequence[Tag], Mapping[str, Tag]):
     def tag_names(self) -> list[str]:
         return list(self.tags_dict.keys())
 
-    def child_tags(self, parent: str | Tag | BoundTag) -> list[BoundTag]:
+    def child_tags(self, parent: str | Tag | BoundTag) -> list[Tag]:
         parent = self.get(parent)
         if parent is None:
             return []
         subtree = dicttree_subtree(self.tags_tree, parent.tag_parts)
-        return list(self.bind(tag) for tag in dicttree_children(subtree)) if subtree else []
+        return list(dicttree_children(subtree)) if subtree else []
 
-    def parent_tags(self, child: str | Tag | BoundTag) -> list[BoundTag]:
+    def parent_tags(self, child: str | Tag | BoundTag) -> list[Tag]:
         child = self.get(child)
         if child is None:
             return []
-        return list(self.bind(tag) for tag in dicttree_lineage(self.tags_tree, child.tag_parts[:-1]))
+        return list(dicttree_lineage(self.tags_tree, child.tag_parts[:-1]))
 
     def validate(self, tag_name: str, props: JsonType | None, *, raise_on_error: bool = False) -> bool:
         tag = self.get(tag_name)
@@ -687,7 +688,7 @@ class TagCache(object):
         :param tag_prefix: Filter by tag name prefix, e.g. "dummy_tag:" to match all tags starting with "dummy_tag:"
         :param tagsets: Filter by tagsets (match tags that are in any of the specified tagsets)
         :param tagset_inverted: Whether to invert the tagset filter (match tags that are NOT in any of the specified
-          tagsets)
+                                tagsets)
         :param batch_size: Number of records to fetch per batch from the database (for memory efficiency)
         :return: Generator of ``TagRecordTable`` instances that match the filters
         """
@@ -748,7 +749,7 @@ class TagCache(object):
         :param target_end_dt: Filter by target end time (inclusive)
         :param tagsets: Filter by tagsets (match tags that are in any of the specified tagsets)
         :param tagset_inverted: Whether to invert the tagset filter (match tags that are NOT in any of the specified
-          tagsets)
+                                tagsets)
         :param batch_size: Number of records to fetch per batch from the database (for memory efficiency)
         :return: Generator of ``TagRecordTable`` instances that match the filters
         """
@@ -812,7 +813,7 @@ class TagCache(object):
         :param tag_prefix: Filter by tag name prefix, e.g. "dummy_tag:" to match all tags starting with "dummy_tag:"
         :param tagsets: Filter by tagsets (match tags that are in any of the specified tagsets)
         :param tagset_inverted: Whether to invert the tagset filter (match tags that are NOT in any of the specified
-          tagsets)
+                                tagsets)
         """
         with self.make_session() as session:
             query = session.query(TagRecordTable)
@@ -920,7 +921,7 @@ class TargetedTagCache(object):
         :param tag_prefix: Filter by tag name prefix, e.g. "dummy_tag:" to match all tags starting with "dummy_tag:"
         :param tagsets: Filter by tagsets (match tags that are in any of the specified tagsets)
         :param tagset_inverted: Whether to invert the tagset filter (match tags that are NOT in any of the specified
-          tagsets)
+                                tagsets)
         :param batch_size: Number of records to fetch per batch from the database (for memory efficiency)
         :return: Generator of ``TagRecordTable`` instances that match the filters
         """
@@ -964,12 +965,13 @@ class TargetedTagCache(object):
         :param begin_dt: Begin datetime of the tag record
         :param end_dt: End datetime of the tag record
         :param tag: Tag name or ``Tag``/``BoundTag`` instance to be added. If ``Tag``/``BoundTag`` instance is provided,
-          its name will be used.
+                    its name will be used.
         :param props: Additional properties of the tag record in JSON format (optional)
         :param tagset_namespace: Namespace of the tagset that the tag belongs to. If the ``tag`` parameter is a
-          ``BoundTag`` instance, this parameter will be ignored and the namespace from the instance will be used.
-        :param tagset_version: Version of the tagset that the tag belongs to. If the ``tag`` parameter is a
-          ``BoundTag`` instance, this parameter will be ignored and the version from the instance will be used.
+                                 ``BoundTag`` instance, this parameter will be ignored and the namespace from the
+                                 instance will be used.
+        :param tagset_version: Version of the tagset that the tag belongs to. If the ``tag`` parameter is a ``BoundTag``
+                               instance, this parameter will be ignored and the version from the instance will be used.
         :return: Self instance for chaining
         """
         with self.make_session() as session:
@@ -998,12 +1000,14 @@ class TargetedTagCache(object):
         Add a tag record to the cache for the entire target range.
 
         :param tag: Tag name or ``Tag``/``BoundTag`` instance to be added. If ``Tag``/``BoundTag`` instance is provided,
-          its name will be used.
+                    its name will be used.
         :param props: Additional properties of the tag record in JSON format (optional)
         :param tagset_namespace: Namespace of the tagset that the tag belongs to. If the ``tag`` parameter is a
-          ``BoundTag`` instance, this parameter will be ignored and the namespace from the instance will be used.
+                                 ``BoundTag`` instance, this parameter will be ignored and the namespace from the
+                                 instance will be used.
         :param tagset_version: Version of the tagset that the tag belongs to. If the ``tag`` parameter is a
-          ``BoundTag`` instance, this parameter will be ignored and the version from the instance will be used.
+                               ``BoundTag`` instance, this parameter will be ignored and the version from the instance
+                               will be used.
         :return: Self instance for chaining
         """
         return self.add_ranged_tag(
@@ -1036,7 +1040,7 @@ class TargetedTagCache(object):
         :param tag_prefix: Filter by tag name prefix, e.g. "dummy_tag:" to match all tags starting with "dummy_tag:"
         :param tagsets: Filter by tagsets (match tags that are in any of the specified tagsets)
         :param tagset_inverted: Whether to invert the tagset filter (match tags that are NOT in any of the specified
-          tagsets)
+                                tagsets)
         :return: Self instance for chaining
         """
         with self.make_session() as session:
@@ -1073,10 +1077,12 @@ def tag_cache(*, identifier: str | None = None, file_path: str | None = None) ->
     string and return a ``TagCache`` instance associated with a file path derived from the identifier.
 
     :param identifier: An optional string identifier for the tag cache. If provided, it must be in snake case format
-      and will be used to derive the file path for the tag cache. If not provided, a default file path will be used.
+                       and will be used to derive the file path for the tag cache. If not provided, a default file path
+                       will be used.
     :param file_path: An optional file path for the tag cache. If provided, it will be used directly. If not provided,
-      the file path will be derived from the identifier if it is provided, or a default file path will be used if the
-      identifier is not provided. Note that both 'identifier' and 'file_path' cannot be specified at the same time.
+                      the file path will be derived from the identifier if it is provided, or a default file path will
+                      be used if the identifier is not provided. Note that both ``identifier`` and ``file_path`` cannot
+                      be specified at the same time.
     :return: A ``TagCache`` instance associated with the specified or default file path.
     """
     if identifier is not None and file_path is not None:

{plexus_python_common-1.0.57 → plexus_python_common-1.0.59}/src/plexus_python_common.egg-info/PKG-INFO

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

plexus_python_common-1.0.59/test/plexus_tests/common/utils/jsonutils_test.py

@@ -0,0 +1,37 @@
+import os.path
+import unittest
+
+import ddt
+from iker.common.utils.dtutils import dt_parse_iso
+
+from plexus.common.utils.jsonutils import json_dumps, json_loads
+from plexus.common.utils.jsonutils import read_chunked_jsonl
+from testenv import resources_directory
+
+
+@ddt.ddt
+class JsonUtilsTest(unittest.TestCase):
+
+    def test_json_loads_dumps(self):
+        data = {
+            "int": 123,
+            "float": 123.456,
+            "string": "dummy_string",
+            "boolean": True,
+            "null": None,
+            "datetime": dt_parse_iso("2024-01-01T00:00:00.000000+00:00"),
+            "list": [123, 123.456, "dummy_string", True, None, dt_parse_iso("2024-01-01T00:00:00.000000+00:00")],
+            "dict": {
+                "int": 123,
+                "float": 123.456,
+                "string": "dummy_string",
+                "boolean": True,
+                "null": None,
+                "datetime": dt_parse_iso("2024-01-01T00:00:00.000000+00:00"),
+            },
+        }
+        self.assertEqual(data, json_loads(json_dumps(data)))
+
+    def test_read_chunked_jsonl(self):
+        for data, path in read_chunked_jsonl(str(resources_directory / "unittest" / "jsonutils" / "dummy.{{}}.jsonl")):
+            self.assertEqual(data["file"], os.path.basename(path))

{plexus_python_common-1.0.57 → plexus_python_common-1.0.59}/test/plexus_tests/common/utils/tagutils_test.py

@@ -6,6 +6,7 @@ import unittest
 
 import ddt
 from iker.common.utils.dtutils import dt_parse_iso
+from iker.common.utils.iterutils import last
 from iker.common.utils.jsonutils import JsonObject
 
 from plexus.common.utils.tagutils import MutableTagset, Tag, TagCache, Tagset
@@ -25,8 +26,19 @@ class TagUtilsTest(unittest.TestCase):
             for tag in tagset:
                 self.assertIn(tag, tagset)
                 self.assertIn(tag.name, tagset)
-                self.assertEqual(tag.name, tagset.get(tag).name)
-                self.assertEqual(tag.name, tagset.get(tag.name).name)
+                self.assertEqual(tag, tagset.get(tag))
+                self.assertEqual(tag.name, tagset.get_bound(tag).name)
+                self.assertEqual(tag, tagset.get_bound(tag).unbind())
+
+                if tag.parent_tag_name is not None:
+                    self.assertIn(tag.parent_tag_name, tagset)
+                    self.assertEqual(tag.parent_tag_name, tagset.get(tag.parent_tag_name).name)
+                    self.assertEqual(last(tagset.parent_tags(tag)), tagset.get(tag.parent_tag_name))
+
+                for child_tag in tagset.child_tags(tag):
+                    self.assertIn(child_tag, tagset)
+                    self.assertIn(child_tag.name, tagset)
+                    self.assertIn(tag, tagset.parent_tags(child_tag))
 
             markdown = render_tagset_markdown_readme(tagset)
             self.assertIsInstance(markdown, str)
@@ -84,17 +96,20 @@ class TagUtilsTest(unittest.TestCase):
                 tagset.validate(tag, props, raise_on_error=True)
 
     def test_tag_cache(self):
-        tagset = MutableTagset(namespace="tagset", version="1.0.0", 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="Another dummy tag for testing"))
-
-        tags = [
+        tag_names = [
             "dummy:foo",
             "dummy:bar",
             "dummy:baz",
             "dummy:qux",
         ]
 
+        tagset = MutableTagset(namespace="tagset", version="1.0.0", 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="Another dummy tag for testing"))
+
+        tags_count = len(tag_names)
+        tagset_tags_count = sum(1 for tag_name in tag_names if tag_name in tagset)
+
         cache = TagCache()
 
         self.assertEqual(cache.file_path, tag_cache_file_path())
@@ -109,72 +124,85 @@ class TagUtilsTest(unittest.TestCase):
 
         target_cache = cache.with_target("awesome_tagger/20200101_000000/dummy_vehicle/0")
 
-        tags_count = 1000
+        tag_records_count = 1000
 
-        for i in range(tags_count):
+        for i in range(tag_records_count):
+            tag_name = tag_names[i % len(tag_names)]
+            tag = tagset.get_bound(tag_name) or tag_name
             target_cache.add_ranged_tag(
                 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),
-                tags[i % len(tags)],
+                tag,
             )
 
-        self.assertEqual(len(list(target_cache.iter_tags())), tags_count)
-        self.assertEqual(len(list(target_cache.iter_tags(tagsets=[tagset]))), tags_count // 2)
-        self.assertEqual(len(list(target_cache.iter_tags(tagsets=[tagset], tagset_inverted=True))), tags_count // 2)
-        self.assertEqual(len(list(target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))), tags_count // 2)
+        self.assertEqual(len(list(target_cache.iter_tags())), tag_records_count)
+        self.assertEqual(len(list(target_cache.iter_tags(tagsets=[tagset]))),
+                         tag_records_count * tagset_tags_count // tags_count)
+        self.assertEqual(len(list(target_cache.iter_tags(tagsets=[tagset], tagset_inverted=True))),
+                         tag_records_count * (tags_count - tagset_tags_count) // tags_count)
+        self.assertEqual(len(list(target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
+                         tag_records_count * tagset_tags_count // tags_count)
         self.assertEqual(len(list(target_cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
                                                          dt_parse_iso("2020-01-01T00:01:00+00:00")))),
                          60 + 1)
         self.assertEqual(len(list(target_cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
                                                          dt_parse_iso("2020-01-01T00:01:00+00:00"),
                                                          tag_prefix="dummy:foo"))),
-                         60 // len(tags) + 1)
+                         60 // tags_count + 1)
         self.assertEqual(len(list(target_cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
                                                          dt_parse_iso("2020-01-01T00:01:00+00:00"),
                                                          tag_prefix="dummy:bar"))),
-                         60 // len(tags))
+                         60 // tags_count)
         self.assertEqual(len(list(target_cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
                                                          dt_parse_iso("2020-01-01T00:01:00+00:00"),
                                                          tag_prefix="dummy"))),
                          60 + 1)
         self.assertEqual(len(list(target_cache.iter_tags(tag_prefix="dummy:foo"))),
-                         tags_count // len(tags))
+                         tag_records_count // tags_count)
         self.assertEqual(len(list(target_cache.iter_tags(tag_prefix="dummy:bar"))),
-                         tags_count // len(tags))
-        self.assertEqual(len(list(target_cache.iter_tags(tag_prefix="dummy"))), tags_count)
-
-        self.assertEqual(len(list(cache.iter_tags())), tags_count)
-        self.assertEqual(len(list(cache.iter_tags(tagsets=[tagset]))), tags_count // 2)
-        self.assertEqual(len(list(cache.iter_tags(tagsets=[tagset], tagset_inverted=True))), tags_count // 2)
-        self.assertEqual(len(list(cache.iter_tags(tagsets=[tagset], tagset_inverted=False))), tags_count // 2)
+                         tag_records_count // tags_count)
+        self.assertEqual(len(list(target_cache.iter_tags(tag_prefix="dummy"))), tag_records_count)
+
+        self.assertEqual(len(list(cache.iter_tags())), tag_records_count)
+        self.assertEqual(len(list(cache.iter_tags(tagsets=[tagset]))), tag_records_count // 2)
+        self.assertEqual(len(list(cache.iter_tags(tagsets=[tagset], tagset_inverted=True))),
+                         tag_records_count * (tags_count - tagset_tags_count) // tags_count)
+        self.assertEqual(len(list(cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
+                         tag_records_count * tagset_tags_count // tags_count)
         self.assertEqual(len(list(cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
                                                   dt_parse_iso("2020-01-01T00:01:00+00:00")))),
                          60 + 1)
         self.assertEqual(len(list(cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
                                                   dt_parse_iso("2020-01-01T00:01:00+00:00"),
                                                   tag_prefix="dummy:foo"))),
-                         60 // len(tags) + 1)
+                         60 // tags_count + 1)
         self.assertEqual(len(list(cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
                                                   dt_parse_iso("2020-01-01T00:01:00+00:00"),
                                                   tag_prefix="dummy:bar"))),
-                         60 // len(tags))
+                         60 // tags_count)
         self.assertEqual(len(list(cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
                                                   dt_parse_iso("2020-01-01T00:01:00+00:00"),
                                                   tag_prefix="dummy"))),
                          60 + 1)
-        self.assertEqual(len(list(cache.iter_tags(tag_prefix="dummy:foo"))), tags_count // len(tags))
-        self.assertEqual(len(list(cache.iter_tags(tag_prefix="dummy:bar"))), tags_count // len(tags))
-        self.assertEqual(len(list(cache.iter_tags(tag_prefix="dummy"))), tags_count)
+        self.assertEqual(len(list(cache.iter_tags(tag_prefix="dummy:foo"))), tag_records_count // tags_count)
+        self.assertEqual(len(list(cache.iter_tags(tag_prefix="dummy:bar"))), tag_records_count // tags_count)
+        self.assertEqual(len(list(cache.iter_tags(tag_prefix="dummy"))), tag_records_count)
 
         target_cache.remove_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"), dt_parse_iso("2020-01-01T00:01:00+00:00"))
 
-        self.assertEqual(len(list(target_cache.iter_tags())), tags_count - (60 + 1))
-        self.assertEqual(len(list(cache.iter_tags())), tags_count - (60 + 1))
+        self.assertEqual(len(list(target_cache.iter_tags())), tag_records_count - (60 + 1))
+        self.assertEqual(len(list(cache.iter_tags())), tag_records_count - (60 + 1))
 
         target_cache.remove_tags(tagsets=[tagset], tagset_inverted=True)
 
-        self.assertEqual(len(list(target_cache.iter_tags())), tags_count // 2 - (60 // 2 + 1))
-        self.assertEqual(len(list(cache.iter_tags())), tags_count // 2 - (60 // 2 + 1))
+        self.assertEqual(
+            len(list(target_cache.iter_tags())),
+            tag_records_count * tagset_tags_count // tags_count - (60 * tagset_tags_count // tags_count + 1),
+        )
+        self.assertEqual(
+            len(list(cache.iter_tags())),
+            tag_records_count * tagset_tags_count // tags_count - (60 * tagset_tags_count // tags_count + 1),
+        )
 
         target_cache.remove_tags()
 
@@ -182,17 +210,27 @@ class TagUtilsTest(unittest.TestCase):
         self.assertEqual(len(list(cache.iter_tags())), 0)
 
     def test_tag_cache__multithread(self):
-        tagset = MutableTagset(namespace="tagset", version="1.0.0", 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="Another dummy tag for testing"))
-
-        tags = [
+        tag_names = [
             "dummy:foo",
             "dummy:bar",
             "dummy:baz",
             "dummy:qux",
         ]
 
+        old_tagset = MutableTagset(namespace="tagset", version="1.0.0", desc="A dummy tagset for testing")
+        old_tagset.add(Tag(name="dummy:foo", desc="A dummy tag for testing"))
+        old_tagset.add(Tag(name="dummy:bar", desc="Another dummy tag for testing"))
+
+        new_tagset = MutableTagset(namespace="tagset", version="1.1.0", desc="Updated dummy tagset for testing")
+        new_tagset.add(Tag(name="dummy:foo", desc="A dummy tag for testing"))
+        new_tagset.add(Tag(name="dummy:bar", desc="Another dummy tag for testing"))
+        new_tagset.add(Tag(name="dummy:baz", desc="Updated dummy tag for testing"))
+        new_tagset.remove("dummy:bar")
+
+        tags_count = len(tag_names)
+        tagset_tags_count = sum(1 for tag_name in tag_names if tag_name in old_tagset or tag_name in new_tagset)
+        old_tagset_tags_count = sum(1 for tag_name in tag_names if tag_name in old_tagset)
+
         with tempfile.TemporaryDirectory() as temp_directory:
             temp_directory = pathlib.Path(temp_directory)
 
@@ -223,14 +261,16 @@ class TagUtilsTest(unittest.TestCase):
             start_barrier = threading.Barrier(total_threads_count)
 
             def worker(tid):
-                tag_cache = target_caches[tid % target_caches_count]
+                target_cache = target_caches[tid % target_caches_count]
 
                 start_barrier.wait()
                 for i in range(tasks_count_per_thread):
-                    tag_cache.add_ranged_tag(
+                    tag_name = tag_names[i % len(tag_names)]
+                    tag = old_tagset.get_bound(tag_name) or new_tagset.get_bound(tag_name) or tag_name
+                    target_cache.add_ranged_tag(
                         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),
-                        tags[i % len(tags)],
+                        tag,
                     )
 
             threads = [threading.Thread(target=worker, args=(tid,)) for tid in range(total_threads_count)]
@@ -242,24 +282,35 @@ class TagUtilsTest(unittest.TestCase):
             for target_cache in target_caches:
                 self.assertEqual(len(list(target_cache.iter_tags())), tasks_count_per_target_cache)
                 self.assertEqual(len(list(target_cache.iter_tags(tag_prefix="dummy:bar"))),
-                                 tasks_count_per_target_cache // len(tags))
+                                 tasks_count_per_target_cache // tags_count)
+                self.assertEqual(len(list(target_cache.iter_tags(tagset_namespace="tagset"))),
+                                 tasks_count_per_target_cache * tagset_tags_count // tags_count)
+                self.assertEqual(len(list(target_cache.iter_tags(tagset_namespace="tagset", tagset_version="1.0.0"))),
+                                 tasks_count_per_target_cache * old_tagset_tags_count // tags_count)
 
             self.assertEqual(len(list(cache.iter_tag_and_targets())), total_tasks_count)
             self.assertEqual(len(list(cache.iter_tag_and_targets(tag_prefix="dummy:bar"))),
-                             total_tasks_count // len(tags))
+                             total_tasks_count // tags_count)
+            self.assertEqual(len(list(cache.iter_tag_and_targets(tagset_namespace="tagset"))),
+                             total_tasks_count * tagset_tags_count // tags_count)
+            self.assertEqual(len(list(cache.iter_tag_and_targets(tagset_namespace="tagset", tagset_version="1.0.0"))),
+                             total_tasks_count * old_tagset_tags_count // tags_count)
 
     def test_tag_cache__clone(self):
-        tagset = MutableTagset(namespace="tagset", version="1.0.0", 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="Another dummy tag for testing"))
-
-        tags = [
+        tag_names = [
             "dummy:foo",
             "dummy:bar",
             "dummy:baz",
             "dummy:qux",
         ]
 
+        tagset = MutableTagset(namespace="tagset", version="1.0.0", 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="Another dummy tag for testing"))
+
+        tags_count = len(tag_names)
+        tagset_tags_count = sum(1 for tag_name in tag_names if tag_name in tagset)
+
         with tempfile.TemporaryDirectory() as temp_directory:
             temp_directory = pathlib.Path(temp_directory)
 
@@ -274,46 +325,55 @@ class TagUtilsTest(unittest.TestCase):
 
             src_target_cache = src_cache.with_target("awesome_tagger/20200101_000000/dummy_vehicle/0")
 
-            tags_count = 1000
+            tag_records_count = 1000
 
-            for i in range(tags_count):
-                src_target_cache.add_tag(tags[i % len(tags)])
+            for i in range(tag_records_count):
+                tag_name = tag_names[i % len(tag_names)]
+                tag = tagset.get_bound(tag_name) or tag_name
+                src_target_cache.add_tag(tag)
 
             dst_cache = TagCache(file_path=temp_directory / "dst_tag_cache.db")
 
             TagCache.copy_to(src_cache, dst_cache)
 
-            for i in range(tags_count):
-                src_target_cache.add_tag(tags[i % len(tags)])
+            for i in range(tag_records_count):
+                tag_name = tag_names[i % len(tag_names)]
+                tag = tagset.get_bound(tag_name) or tag_name
+                src_target_cache.add_tag(tag)
 
             dst_target_cache = dst_cache.with_target("awesome_tagger/20200101_000000/dummy_vehicle/0")
 
-            self.assertEqual(len(list(src_target_cache.iter_tags())), tags_count * 2)
-            self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset]))), tags_count * 2 // 2)
+            self.assertEqual(len(list(src_target_cache.iter_tags())), tag_records_count * 2)
+            self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset]))),
+                             tag_records_count * 2 * tagset_tags_count // tags_count)
             self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=True))),
-                             tags_count * 2 // 2)
+                             tag_records_count * 2 * (tags_count - tagset_tags_count) // tags_count)
             self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
-                             tags_count * 2 // 2)
+                             tag_records_count * 2 * tagset_tags_count // tags_count)
 
-            self.assertEqual(len(list(dst_target_cache.iter_tags())), tags_count)
-            self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset]))), tags_count // 2)
+            self.assertEqual(len(list(dst_target_cache.iter_tags())), tag_records_count)
+            self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset]))),
+                             tag_records_count * tagset_tags_count // tags_count)
             self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=True))),
-                             tags_count // 2)
+                             tag_records_count * (tags_count - tagset_tags_count) // tags_count)
             self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
-                             tags_count // 2)
+                             tag_records_count * tagset_tags_count // tags_count)
 
     def test_tag_cache__clone_same_file(self):
-        tagset = MutableTagset(namespace="tagset", version="1.0.0", 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="Another dummy tag for testing"))
-
-        tags = [
+        tag_names = [
             "dummy:foo",
             "dummy:bar",
             "dummy:baz",
             "dummy:qux",
         ]
 
+        tagset = MutableTagset(namespace="tagset", version="1.0.0", 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="Another dummy tag for testing"))
+
+        tags_count = len(tag_names)
+        tagset_tags_count = sum(1 for tag_name in tag_names if tag_name in tagset)
+
         # Clone to the same file path should not cause any issue, and the cloned cache should be able to read
         # the tags added to the source cache after cloning.
         with tempfile.TemporaryDirectory() as temp_directory:
@@ -330,33 +390,39 @@ class TagUtilsTest(unittest.TestCase):
 
             src_target_cache = src_cache.with_target("awesome_tagger/20200101_000000/dummy_vehicle/0")
 
-            tags_count = 1000
+            tag_records_count = 1000
 
-            for i in range(tags_count):
-                src_target_cache.add_tag(tags[i % len(tags)])
+            for i in range(tag_records_count):
+                tag_name = tag_names[i % len(tag_names)]
+                tag = tagset.get_bound(tag_name) or tag_name
+                src_target_cache.add_tag(tag)
 
             dst_cache = TagCache(file_path=temp_directory / "tag_cache.db")
 
             TagCache.copy_to(src_cache, dst_cache)
 
-            for i in range(tags_count):
-                src_target_cache.add_tag(tags[i % len(tags)])
+            for i in range(tag_records_count):
+                tag_name = tag_names[i % len(tag_names)]
+                tag = tagset.get_bound(tag_name) or tag_name
+                src_target_cache.add_tag(tag)
 
             dst_target_cache = dst_cache.with_target("awesome_tagger/20200101_000000/dummy_vehicle/0")
 
-            self.assertEqual(len(list(src_target_cache.iter_tags())), tags_count * 2)
-            self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset]))), tags_count * 2 // 2)
+            self.assertEqual(len(list(src_target_cache.iter_tags())), tag_records_count * 2)
+            self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset]))),
+                             tag_records_count * 2 * tagset_tags_count // tags_count)
             self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=True))),
-                             tags_count * 2 // 2)
+                             tag_records_count * 2 * (tags_count - tagset_tags_count) // tags_count)
             self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
-                             tags_count * 2 // 2)
+                             tag_records_count * 2 * tagset_tags_count // tags_count)
 
-            self.assertEqual(len(list(dst_target_cache.iter_tags())), tags_count * 2)
-            self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset]))), tags_count * 2 // 2)
+            self.assertEqual(len(list(dst_target_cache.iter_tags())), tag_records_count * 2)
+            self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset]))),
+                             tag_records_count * 2 * tagset_tags_count // tags_count)
             self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=True))),
-                             tags_count * 2 // 2)
+                             tag_records_count * 2 * (tags_count - tagset_tags_count) // tags_count)
             self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
-                             tags_count * 2 // 2)
+                             tag_records_count * 2 * tagset_tags_count // tags_count)
 
         with tempfile.TemporaryDirectory() as temp_directory:
             temp_directory = pathlib.Path(temp_directory)
@@ -372,30 +438,36 @@ class TagUtilsTest(unittest.TestCase):
 
             src_target_cache = src_cache.with_target("awesome_tagger/20200101_000000/dummy_vehicle/0")
 
-            tags_count = 1000
+            tag_records_count = 1000
 
-            for i in range(tags_count):
-                src_target_cache.add_tag(tags[i % len(tags)])
+            for i in range(tag_records_count):
+                tag_name = tag_names[i % len(tag_names)]
+                tag = tagset.get_bound(tag_name) or tag_name
+                src_target_cache.add_tag(tag)
 
             dst_cache = src_cache
 
             TagCache.copy_to(src_cache, dst_cache)
 
-            for i in range(tags_count):
-                src_target_cache.add_tag(tags[i % len(tags)])
+            for i in range(tag_records_count):
+                tag_name = tag_names[i % len(tag_names)]
+                tag = tagset.get_bound(tag_name) or tag_name
+                src_target_cache.add_tag(tag)
 
             dst_target_cache = dst_cache.with_target("awesome_tagger/20200101_000000/dummy_vehicle/0")
 
-            self.assertEqual(len(list(src_target_cache.iter_tags())), tags_count * 2)
-            self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset]))), tags_count * 2 // 2)
+            self.assertEqual(len(list(src_target_cache.iter_tags())), tag_records_count * 2)
+            self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset]))),
+                             tag_records_count * 2 * tagset_tags_count // tags_count)
             self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=True))),
-                             tags_count * 2 // 2)
+                             tag_records_count * 2 * (tags_count - tagset_tags_count) // tags_count)
             self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
-                             tags_count * 2 // 2)
+                             tag_records_count * 2 * tagset_tags_count // tags_count)
 
-            self.assertEqual(len(list(dst_target_cache.iter_tags())), tags_count * 2)
-            self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset]))), tags_count * 2 // 2)
+            self.assertEqual(len(list(dst_target_cache.iter_tags())), tag_records_count * 2)
+            self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset]))),
+                             tag_records_count * 2 * tagset_tags_count // tags_count)
             self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=True))),
-                             tags_count * 2 // 2)
+                             tag_records_count * 2 * (tags_count - tagset_tags_count) // tags_count)
             self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
-                             tags_count * 2 // 2)
+                             tag_records_count * 2 * tagset_tags_count // tags_count)

plexus_python_common-1.0.57/test/plexus_tests/common/utils/jsonutils_test.py

@@ -1,15 +0,0 @@
-import os.path
-import unittest
-
-import ddt
-
-from plexus.common.utils.jsonutils import read_chunked_jsonl
-from testenv import resources_directory
-
-
-@ddt.ddt
-class JsonUtilsTest(unittest.TestCase):
-
-    def test_read_chunked_jsonl(self):
-        for data, path in read_chunked_jsonl(str(resources_directory / "unittest" / "jsonutils" / "dummy.{{}}.jsonl")):
-            self.assertEqual(data["file"], os.path.basename(path))