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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-common
-Version: 1.0.57
+Version: 1.0.58
 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.58}/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)

{plexus_python_common-1.0.57 → plexus_python_common-1.0.58}/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.58
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

plexus_python_common-1.0.58/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.58}/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))