plexus-python-common 1.0.53__tar.gz → 1.0.54__tar.gz

{plexus_python_common-1.0.53 → plexus_python_common-1.0.54}/PKG-INFO

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

{plexus_python_common-1.0.53 → plexus_python_common-1.0.54}/src/plexus/common/utils/datautils.py

@@ -118,7 +118,9 @@ validate_vehicle_name = make_validate_parse_string(parse_vehicle_name)
 validate_bag_name = make_validate_parse_string(parse_bag_name)
 
 
-def validate_dt_timezone(dt: datetime.datetime):
+def validate_dt_timezone(dt: datetime.datetime, *, allow_naive: bool = False):
+    if allow_naive and dt.tzinfo is None:
+        return
     if dt.tzinfo != datetime.timezone.utc:
         raise ValueError(f"dt '{dt}' is not in UTC")
 

{plexus_python_common-1.0.53 → plexus_python_common-1.0.54}/src/plexus/common/utils/tagutils.py

@@ -348,13 +348,13 @@ class TagTargetInfo(BaseModel):
     @pdt.field_validator("begin_dt", mode="after")
     @classmethod
     def validate_begin_dt(cls, v: datetime.datetime) -> datetime.datetime:
-        validate_dt_timezone(v)
+        validate_dt_timezone(v, allow_naive=True)
         return v
 
     @pdt.field_validator("end_dt", mode="after")
     @classmethod
     def validate_end_dt(cls, v: datetime.datetime) -> datetime.datetime:
-        validate_dt_timezone(v)
+        validate_dt_timezone(v, allow_naive=True)
         return v
 
     @pdt.model_validator(mode="after")
@@ -390,13 +390,13 @@ class TagRecord(BaseModel):
     @pdt.field_validator("begin_dt", mode="after")
     @classmethod
     def validate_begin_dt(cls, v: datetime.datetime) -> datetime.datetime:
-        validate_dt_timezone(v)
+        validate_dt_timezone(v, allow_naive=True)
         return v
 
     @pdt.field_validator("end_dt", mode="after")
     @classmethod
     def validate_end_dt(cls, v: datetime.datetime) -> datetime.datetime:
-        validate_dt_timezone(v)
+        validate_dt_timezone(v, allow_naive=True)
         return v
 
     @pdt.model_validator(mode="after")
@@ -480,7 +480,7 @@ class TagCache(object):
         vehicle_name: str | None = None,
         begin_dt: datetime.datetime | None = None,
         end_dt: datetime.datetime | None = None,
-    ) -> Generator[TagTargetInfoTable, None, None]:
+    ) -> list[TagTargetInfoTable]:
         with self.make_session() as session:
             query = session.query(TagTargetInfoTable)
             if name:
@@ -496,7 +496,7 @@ class TagCache(object):
             if end_dt:
                 query = query.filter(TagTargetInfoTable.begin_dt <= end_dt)
 
-            yield from query.all()
+            return query.all()
 
     def add_target(
         self,
@@ -724,35 +724,47 @@ class TagCache(object):
         target_tag_cache = TagCache(file_path=target_file_path)
         if overwrite:
             target_tag_cache.clear()
-        TagCache.clone_to(self, target_tag_cache)
+        TagCache.copy_to(self, target_tag_cache)
 
     def merge_from(self, source_file_path: str, *, overwrite: bool = False):
         source_tag_cache = TagCache(file_path=source_file_path)
         if overwrite:
             self.clear()
-        TagCache.clone_to(source_tag_cache, self)
+        TagCache.copy_to(source_tag_cache, self)
 
     @staticmethod
-    def clone_to(source: "TagCache", target: "TagCache"):
-        if source == target:
+    def copy_to(src: "TagCache", dst: "TagCache"):
+        # If src and dst are the same instance or point to the same file path,
+        # do nothing to avoid accidentally clearing the cache
+        if src == dst or src.file_path == dst.file_path:
             return
 
-        target.clear()
-        with source.make_session() as source_session, target.make_session() as target_session:
-            target_session.add_all(
-                [clone_sequence_model_instance(TagTargetInfoTable, db_tag_target_info, clear_meta_fields=True)
-                 for db_tag_target_info in source_session.query(TagTargetInfoTable).all()],
-            )
-            for results in batched(source_session.query(TagRecordTable).yield_per(1000), 1000):
-                target_session.add_all(
-                    [clone_sequence_model_instance(TagRecordTable, db_tag_record, clear_meta_fields=True)
-                     for db_tag_record in results],
-                )
-            target_session.commit()
+        with src.make_session() as src_session, dst.make_session() as dst_session:
+            src_targets = src_session.query(TagTargetInfoTable).all()
+            dst_targets = [
+                clone_sequence_model_instance(TagTargetInfoTable, db_tag_target_info, clear_meta_fields=True)
+                for db_tag_target_info in src_targets
+            ]
+            dst_session.add_all(dst_targets)
+            dst_session.flush()  # ensure new sqn values are assigned
+
+            sqn_map = {src_target.sqn: dst_target.sqn for src_target, dst_target in zip(src_targets, dst_targets)}
+
+            for results in batched(src_session.query(TagRecordTable).yield_per(1000), 1000):
+                clones = []
+                for db_tag_record in results:
+                    cloned = clone_sequence_model_instance(TagRecordTable, db_tag_record, clear_meta_fields=True)
+                    try:
+                        cloned.target_sqn = sqn_map[db_tag_record.target_sqn]
+                    except KeyError as e:
+                        raise ValueError(f"no cloned target for target_sqn '{db_tag_record.target_sqn}'") from e
+                    clones.append(cloned)
+                dst_session.add_all(clones)
+            dst_session.commit()
 
 
 class TargetedTagCache(object):
-    def __init__(self, cache: "TagCache", target_info: TagTargetInfoTable):
+    def __init__(self, cache: TagCache, target_info: TagTargetInfoTable):
         self.target_info = target_info
         self.cache = cache
 
@@ -844,7 +856,7 @@ class TargetedTagCache(object):
         :param props: Additional properties of the tag record in JSON format (optional)
         :return: Self instance for chaining
         """
-        return self.add_ranged(
+        return self.add_ranged_tag(
             begin_dt=self.target_info.begin_dt,
             end_dt=self.target_info.end_dt,
             tag=tag,

{plexus_python_common-1.0.53 → plexus_python_common-1.0.54}/src/plexus_python_common.egg-info/PKG-INFO

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

{plexus_python_common-1.0.53 → plexus_python_common-1.0.54}/test/plexus_tests/common/utils/tagutils_test.py

@@ -196,3 +196,155 @@ class TagUtilsTest(unittest.TestCase):
             self.assertEqual(len(list(cache.iter_tag_and_targets())), total_tasks_count)
             self.assertEqual(len(list(cache.iter_tag_and_targets(tag_pattern="dummy:bar"))),
                              total_tasks_count // len(tags))
+
+    def test_tag_cache__clone(self):
+        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="Another dummy tag for testing"))
+
+        tags = [
+            "dummy:foo",
+            "dummy:bar",
+            "dummy:baz",
+            "dummy:qux",
+        ]
+
+        with tempfile.TemporaryDirectory() as temp_directory:
+            temp_directory = pathlib.Path(temp_directory)
+
+            src_cache = TagCache(file_path=temp_directory / "src_tag_cache.db")
+
+            src_cache.add_target("awesome_tagger/20200101_000000/dummy_vehicle/0",
+                                 "awesome_tagger",
+                                 "1.0.0",
+                                 "dummy_vehicle",
+                                 dt_parse_iso("2020-01-01T00:00:00+00:00"),
+                                 dt_parse_iso("2020-01-01T01:00:00+00:00"))
+
+            src_target_cache = src_cache.with_target("awesome_tagger/20200101_000000/dummy_vehicle/0")
+
+            tags_count = 1000
+
+            for i in range(tags_count):
+                src_target_cache.add_tag(tags[i % len(tags)])
+
+            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)])
+
+            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(tagsets=[tagset], tagset_inverted=True))),
+                             tags_count * 2 // 2)
+            self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
+                             tags_count * 2 // 2)
+
+            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(tagsets=[tagset], tagset_inverted=True))),
+                             tags_count // 2)
+            self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
+                             tags_count // 2)
+
+    def test_tag_cache__clone_same_file(self):
+        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="Another dummy tag for testing"))
+
+        tags = [
+            "dummy:foo",
+            "dummy:bar",
+            "dummy:baz",
+            "dummy:qux",
+        ]
+
+        # 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:
+            temp_directory = pathlib.Path(temp_directory)
+
+            src_cache = TagCache(file_path=temp_directory / "tag_cache.db")
+
+            src_cache.add_target("awesome_tagger/20200101_000000/dummy_vehicle/0",
+                                 "awesome_tagger",
+                                 "1.0.0",
+                                 "dummy_vehicle",
+                                 dt_parse_iso("2020-01-01T00:00:00+00:00"),
+                                 dt_parse_iso("2020-01-01T01:00:00+00:00"))
+
+            src_target_cache = src_cache.with_target("awesome_tagger/20200101_000000/dummy_vehicle/0")
+
+            tags_count = 1000
+
+            for i in range(tags_count):
+                src_target_cache.add_tag(tags[i % len(tags)])
+
+            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)])
+
+            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(tagsets=[tagset], tagset_inverted=True))),
+                             tags_count * 2 // 2)
+            self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
+                             tags_count * 2 // 2)
+
+            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(tagsets=[tagset], tagset_inverted=True))),
+                             tags_count * 2 // 2)
+            self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
+                             tags_count * 2 // 2)
+
+        with tempfile.TemporaryDirectory() as temp_directory:
+            temp_directory = pathlib.Path(temp_directory)
+
+            src_cache = TagCache(file_path=temp_directory / "tag_cache.db")
+
+            src_cache.add_target("awesome_tagger/20200101_000000/dummy_vehicle/0",
+                                 "awesome_tagger",
+                                 "1.0.0",
+                                 "dummy_vehicle",
+                                 dt_parse_iso("2020-01-01T00:00:00+00:00"),
+                                 dt_parse_iso("2020-01-01T01:00:00+00:00"))
+
+            src_target_cache = src_cache.with_target("awesome_tagger/20200101_000000/dummy_vehicle/0")
+
+            tags_count = 1000
+
+            for i in range(tags_count):
+                src_target_cache.add_tag(tags[i % len(tags)])
+
+            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)])
+
+            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(tagsets=[tagset], tagset_inverted=True))),
+                             tags_count * 2 // 2)
+            self.assertEqual(len(list(src_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
+                             tags_count * 2 // 2)
+
+            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(tagsets=[tagset], tagset_inverted=True))),
+                             tags_count * 2 // 2)
+            self.assertEqual(len(list(dst_target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
+                             tags_count * 2 // 2)