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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-common
-Version: 1.0.53
+Version: 1.0.55
 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.55}/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.55}/src/plexus/common/utils/ormutils.py

@@ -1,4 +1,5 @@
 import datetime
+from collections.abc import Iterable, Sequence
 from typing import Protocol, Self
 
 import pydantic as pdt
@@ -7,7 +8,8 @@ import sqlalchemy.dialects.postgresql as sa_pg
 import sqlalchemy.dialects.sqlite as sa_sqlite
 import sqlalchemy.exc as sa_exc
 import sqlalchemy.orm as sa_orm
-from iker.common.utils.dbutils import dialects
+from iker.common.utils.dbutils import dialects, orm_to_dict
+from iker.common.utils.iterutils import head
 from sqlmodel import Field, SQLModel
 
 from plexus.common.utils.datautils import validate_dt_timezone
@@ -17,6 +19,7 @@ __all__ = [
     "compare_postgresql_types",
     "compare_sqlite_types",
     "model_name_of",
+    "print_model_results",
     "validate_model_extended",
     "collect_model_tables",
     "model_copy_from",
@@ -137,13 +140,56 @@ def compare_sqlite_types(type_a, type_b) -> bool:
     }
 
 
-def model_name_of(model: type[SQLModel], fallback_classname: bool = True) -> str | None:
+def model_name_of(model: type[SQLModel] | SQLModel, fallback_classname: bool = True) -> str | None:
     table_name = getattr(model, "__tablename__")
-    if not table_name:
-        return model.__name__ if fallback_classname else None
+    if not table_name and fallback_classname:
+        return getattr(model, "__name__") if isinstance(model, type) else getattr(model.__class__, "__name__")
     return table_name
 
 
+def print_model_results(results: Iterable[SQLModel | Sequence[SQLModel]]):
+    """
+    Pretty-print an iterable of ``SQLModel`` instances or sequences of ``SQLModel`` instances in a tabular format
+    using the ``rich`` library.
+
+    :param results: An iterable of ``SQLModel`` instances or sequences of ``SQLModel`` instances to print.
+    """
+    results = list(results)
+    if not results:
+        print("Query results: (empty)")
+        return
+
+    first_result = head(results)
+
+    cols = [f"{model_name_of(db_model)}.{key}"
+            for db_model in (first_result if isinstance(first_result, Sequence) else [first_result])
+            for key in orm_to_dict(db_model).keys()]
+
+    rows = [
+        {f"{model_name_of(db_model)}.{key}": str(value)
+         for db_model in (result if isinstance(result, Sequence) else (result,))
+         for key, value in orm_to_dict(db_model).items()}
+        for result in results
+    ]
+
+    col_widths = [len(col) for col in cols]
+    for row in rows:
+        for i, col in enumerate(cols):
+            col_widths[i] = max(col_widths[i], len(str(row.get(col, ""))))
+
+    from rich.console import Console
+    from rich.table import Table
+
+    console = Console()
+    table = Table(show_header=True)
+    for col, col_width in zip(cols, col_widths):
+        table.add_column(col, min_width=col_width)
+    for row in rows:
+        table.add_row(*[str(row.get(col)) for col in cols])
+
+    console.print(table, crop=False)
+
+
 def validate_model_extended(model_base: type[SQLModel], model_extended: type[SQLModel]) -> bool:
     """
     Validates if ``model_extended`` is an extension of ``model_base`` by checking if all fields in ``model_base``

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

@@ -40,9 +40,9 @@ __all__ = [
     "populate_tagset",
     "predefined_tagsets",
     "render_tagset_markdown_readme",
-    "TagTargetInfo",
+    "TagTarget",
     "TagRecord",
-    "TagTargetInfoTable",
+    "TagTargetTable",
     "TagRecordTable",
     "tag_cache_file_path",
     "TagCache",
@@ -295,10 +295,10 @@ def render_tagset_markdown_readme(tagset: Tagset) -> str:
 BaseModel = make_base_model()
 
 
-class TagTargetInfo(BaseModel):
-    name: str = Field(
+class TagTarget(BaseModel):
+    identifier: str = Field(
         sa_column=sa.Column(sa_sqlite.VARCHAR(256), nullable=False, unique=True),
-        description="Name of the tag target",
+        description="Identifier of the tag target",
     )
     tagger_name: str = Field(
         sa_column=sa.Column(sa_sqlite.VARCHAR(128), nullable=False),
@@ -321,9 +321,9 @@ class TagTargetInfo(BaseModel):
         description="End datetime of the target range associated with the tag record",
     )
 
-    @pdt.field_validator("name", mode="after")
+    @pdt.field_validator("identifier", mode="after")
     @classmethod
-    def validate_name(cls, v: str) -> str:
+    def validate_identifier(cls, v: str) -> str:
         validate_slash_tag(v)
         return v
 
@@ -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")
@@ -412,7 +412,7 @@ class TagRecord(BaseModel):
         return v
 
 
-class TagTargetInfoTable(TagTargetInfo, make_sequence_model_mixin("sqlite"), table=True):
+class TagTargetTable(TagTarget, make_sequence_model_mixin("sqlite"), table=True):
     __tablename__ = "tag_target_info"
 
 
@@ -421,8 +421,8 @@ class TagRecordTable(TagRecord, make_sequence_model_mixin("sqlite"), table=True)
 
 
 if typing.TYPE_CHECKING:
-    class TagTargetInfoTable(SQLModel, SequenceModelMixinProtocol):
-        name: sa_orm.Mapped[str] = ...
+    class TagTargetTable(SQLModel, SequenceModelMixinProtocol):
+        identifier: sa_orm.Mapped[str] = ...
         tagger_name: sa_orm.Mapped[str] = ...
         tagger_version: sa_orm.Mapped[str] = ...
         vehicle_name: sa_orm.Mapped[str] = ...
@@ -468,63 +468,63 @@ class TagCache(object):
             with self.conn_maker.make_session() as session:
                 yield session
 
-    def get_target(self, name: str) -> TagTargetInfoTable | None:
+    def get_target(self, identifier: str) -> TagTargetTable | None:
         with self.make_session() as session:
-            return session.query(TagTargetInfoTable).filter(TagTargetInfoTable.name == name).one_or_none()
+            return session.query(TagTargetTable).filter(TagTargetTable.identifier == identifier).one_or_none()
 
     def query_targets(
         self,
-        name: str | None = None,
+        identifier: str | None = None,
         tagger_name: str | None = None,
         tagger_version: str | None = None,
         vehicle_name: str | None = None,
         begin_dt: datetime.datetime | None = None,
         end_dt: datetime.datetime | None = None,
-    ) -> Generator[TagTargetInfoTable, None, None]:
+    ) -> list[TagTargetTable]:
         with self.make_session() as session:
-            query = session.query(TagTargetInfoTable)
-            if name:
-                query = query.filter(TagTargetInfoTable.name == name)
+            query = session.query(TagTargetTable)
+            if identifier:
+                query = query.filter(TagTargetTable.identifier == identifier)
             if tagger_name:
-                query = query.filter(TagTargetInfoTable.tagger_name == tagger_name)
+                query = query.filter(TagTargetTable.tagger_name == tagger_name)
             if tagger_version:
-                query = query.filter(TagTargetInfoTable.tagger_version == tagger_version)
+                query = query.filter(TagTargetTable.tagger_version == tagger_version)
             if vehicle_name:
-                query = query.filter(TagTargetInfoTable.vehicle_name == vehicle_name)
+                query = query.filter(TagTargetTable.vehicle_name == vehicle_name)
             if begin_dt:
-                query = query.filter(TagTargetInfoTable.end_dt >= begin_dt)
+                query = query.filter(TagTargetTable.end_dt >= begin_dt)
             if end_dt:
-                query = query.filter(TagTargetInfoTable.begin_dt <= end_dt)
+                query = query.filter(TagTargetTable.begin_dt <= end_dt)
 
-            yield from query.all()
+            return query.all()
 
     def add_target(
         self,
-        name: str,
+        identifier: str,
         tagger_name: str,
         tagger_version: str,
         vehicle_name: str,
         begin_dt: datetime.datetime,
         end_dt: datetime.datetime,
-    ) -> TagTargetInfoTable:
+    ) -> TagTargetTable:
         with self.make_session() as session:
-            target_info = TagTargetInfo(
-                name=name,
+            target_info = TagTarget(
+                identifier=identifier,
                 tagger_name=tagger_name,
                 tagger_version=tagger_version,
                 vehicle_name=vehicle_name,
                 begin_dt=begin_dt,
                 end_dt=end_dt,
             )
-            db_target_info = clone_sequence_model_instance(TagTargetInfoTable, target_info)
+            db_target_info = clone_sequence_model_instance(TagTargetTable, target_info)
             session.add(db_target_info)
             session.commit()
 
-        return self.get_target(name)
+        return self.get_target(identifier)
 
     def remove_targets(
         self,
-        name: str | None = None,
+        identifier: str | None = None,
         tagger_name: str | None = None,
         tagger_version: str | None = None,
         vehicle_name: str | None = None,
@@ -532,19 +532,19 @@ class TagCache(object):
         end_dt: datetime.datetime | None = None,
     ):
         with self.make_session() as session:
-            query = session.query(TagTargetInfoTable)
-            if name:
-                query = query.filter(TagTargetInfoTable.name == name)
+            query = session.query(TagTargetTable)
+            if identifier:
+                query = query.filter(TagTargetTable.identifier == identifier)
             if tagger_name:
-                query = query.filter(TagTargetInfoTable.tagger_name == tagger_name)
+                query = query.filter(TagTargetTable.tagger_name == tagger_name)
             if tagger_version:
-                query = query.filter(TagTargetInfoTable.tagger_version == tagger_version)
+                query = query.filter(TagTargetTable.tagger_version == tagger_version)
             if vehicle_name:
-                query = query.filter(TagTargetInfoTable.vehicle_name == vehicle_name)
+                query = query.filter(TagTargetTable.vehicle_name == vehicle_name)
             if begin_dt:
-                query = query.filter(TagTargetInfoTable.end_dt >= begin_dt)
+                query = query.filter(TagTargetTable.end_dt >= begin_dt)
             if end_dt:
-                query = query.filter(TagTargetInfoTable.begin_dt <= end_dt)
+                query = query.filter(TagTargetTable.begin_dt <= end_dt)
 
             query.delete()
             session.commit()
@@ -552,7 +552,7 @@ class TagCache(object):
             (
                 session
                 .query(TagRecordTable)
-                .filter(TagRecordTable.target_sqn.notin_(session.query(TagTargetInfoTable.sqn)))
+                .filter(TagRecordTable.target_sqn.notin_(session.query(TagTargetTable.sqn)))
                 .delete()
             )
             session.commit()
@@ -611,7 +611,7 @@ class TagCache(object):
         end_dt: datetime.datetime | None = None,
         tag_pattern: str | None = None,
         *,
-        target_name: str | None = None,
+        target_identifier: str | None = None,
         target_tagger_name: str | None = None,
         target_tagger_version: str | None = None,
         target_vehicle_name: str | None = None,
@@ -620,7 +620,7 @@ class TagCache(object):
         tagsets: Sequence[Tagset] | None = None,
         tagset_inverted: bool = False,
         batch_size: int = 1000,
-    ) -> Generator[tuple[TagRecordTable, TagTargetInfoTable], None, None]:
+    ) -> Generator[tuple[TagRecordTable, TagTargetTable], None, None]:
         """
         Query tag records along with their target info in the cache with optional filters.
 
@@ -628,7 +628,7 @@ class TagCache(object):
         :param end_dt: Filter by end time (inclusive)
         :param tag_pattern: Filter by tag name pattern (SQL LIKE syntax, e.g. "dummy_tag:%" to match all tags starting
         with "dummy_tag:")
-        :param target_name: Filter by target name (exact match)
+        :param target_identifier: Filter by target identifier (exact match)
         :param target_tagger_name: Filter by target tagger name (exact match)
         :param target_tagger_version: Filter by target tagger version (exact match)
         :param target_vehicle_name: Filter by target vehicle name (exact match)
@@ -643,8 +643,8 @@ class TagCache(object):
         with self.make_session() as session:
             query = (
                 session
-                .query(TagRecordTable, TagTargetInfoTable)
-                .join(TagTargetInfoTable, TagRecordTable.target_sqn == TagTargetInfoTable.sqn)
+                .query(TagRecordTable, TagTargetTable)
+                .join(TagTargetTable, TagRecordTable.target_sqn == TagTargetTable.sqn)
             )
             if begin_dt:
                 query = query.filter(TagRecordTable.end_dt >= begin_dt)
@@ -652,18 +652,18 @@ class TagCache(object):
                 query = query.filter(TagRecordTable.begin_dt <= end_dt)
             if tag_pattern:
                 query = query.filter(TagRecordTable.tag.like(f"{escape_sql_like(tag_pattern)}%", escape="\\"))
-            if target_name:
-                query = query.filter(TagTargetInfoTable.name == target_name)
+            if target_identifier:
+                query = query.filter(TagTargetTable.identifier == target_identifier)
             if target_tagger_name:
-                query = query.filter(TagTargetInfoTable.tagger_name == target_tagger_name)
+                query = query.filter(TagTargetTable.tagger_name == target_tagger_name)
             if target_tagger_version:
-                query = query.filter(TagTargetInfoTable.tagger_version == target_tagger_version)
+                query = query.filter(TagTargetTable.tagger_version == target_tagger_version)
             if target_vehicle_name:
-                query = query.filter(TagTargetInfoTable.vehicle_name == target_vehicle_name)
+                query = query.filter(TagTargetTable.vehicle_name == target_vehicle_name)
             if target_begin_dt:
-                query = query.filter(TagTargetInfoTable.end_dt >= target_begin_dt)
+                query = query.filter(TagTargetTable.end_dt >= target_begin_dt)
             if target_end_dt:
-                query = query.filter(TagTargetInfoTable.begin_dt <= target_end_dt)
+                query = query.filter(TagTargetTable.begin_dt <= target_end_dt)
             if tagsets:
                 if tagset_inverted:
                     query = query.filter(
@@ -717,49 +717,61 @@ class TagCache(object):
     def clear(self):
         with self.make_session() as session:
             session.execute(sa.delete(TagRecordTable))
-            session.execute(sa.delete(TagTargetInfoTable))
+            session.execute(sa.delete(TagTargetTable))
             session.commit()
 
     def append_to(self, target_file_path: str, *, overwrite: bool = False):
         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(TagTargetTable).all()
+            dst_targets = [
+                clone_sequence_model_instance(TagTargetTable, 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: TagTargetTable):
         self.target_info = target_info
         self.cache = cache
 
     @contextlib.contextmanager
     def make_session(self) -> Generator[sa_orm.Session, None, None]:
         with self.cache.make_session() as session:
-            if not session.query(TagTargetInfoTable).filter(TagTargetInfoTable.sqn == self.target_info.sqn).first():
+            if not session.query(TagTargetTable).filter(TagTargetTable.sqn == self.target_info.sqn).first():
                 raise ValueError(f"target info with sqn '{self.target_info.sqn}' is no longer present in cache")
             yield session
 
@@ -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.55}/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.55
 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.55}/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)