plexus-python-common 1.0.51__tar.gz → 1.0.52__tar.gz

{plexus_python_common-1.0.51 → plexus_python_common-1.0.52}/PKG-INFO

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

{plexus_python_common-1.0.51 → plexus_python_common-1.0.52}/src/plexus/common/utils/tagutils.py

@@ -15,7 +15,6 @@ import sqlalchemy as sa
 import sqlalchemy.dialects.sqlite as sa_sqlite
 import sqlalchemy.orm as sa_orm
 from iker.common.utils.dbutils import ConnectionMaker
-from iker.common.utils.dtutils import dt_utc_now
 from iker.common.utils.funcutils import memorized, singleton
 from iker.common.utils.iterutils import dicttree
 from iker.common.utils.iterutils import dicttree_add, dicttree_remove
@@ -27,8 +26,8 @@ from iker.common.utils.strutils import is_blank
 from sqlmodel import Field, SQLModel
 
 from plexus.common.resources.tags import predefined_tagset_specs
-from plexus.common.utils.datautils import validate_bag_name, validate_dt_timezone, validate_semver
 from plexus.common.utils.datautils import validate_colon_tag, validate_snake_case, validate_vehicle_name
+from plexus.common.utils.datautils import validate_dt_timezone, validate_semver, validate_slash_tag
 from plexus.common.utils.ormutils import SequenceModelMixinProtocol
 from plexus.common.utils.ormutils import clone_sequence_model_instance, make_base_model, make_sequence_model_mixin
 from plexus.common.utils.sqlutils import escape_sql_like
@@ -297,37 +296,38 @@ BaseModel = make_base_model()
 
 
 class TagTargetInfo(BaseModel):
+    name: str = Field(
+        sa_column=sa.Column(sa_sqlite.VARCHAR(256), nullable=False, unique=True),
+        default=None,
+        description="Name of the tag target",
+    )
     tagger_name: str = Field(
         sa_column=sa.Column(sa_sqlite.VARCHAR(128), nullable=False),
         default=None,
-        description="Name of the tagger",
+        description="Name of the tagger that generates the tag records for the target",
     )
     tagger_version: str = Field(
         sa_column=sa.Column(sa_sqlite.VARCHAR(64), nullable=False),
         default=None,
-        description="Version of the tagger",
+        description="Version of the tagger that generates the tag records for the target",
     )
-    run_at: datetime.datetime = Field(
+    begin_dt: datetime.datetime = Field(
         sa_column=sa.Column(sa_sqlite.TIMESTAMP, nullable=False),
-        default_factory=dt_utc_now,
-        description="Datetime when the tagger created the tag record",
-    )
-    bag_name: str | None = Field(
-        sa_column=sa.Column(sa_sqlite.VARCHAR(256), nullable=True),
-        default=None,
-        description="Name of the target bag associated with the tag record",
-    )
-    begin_dt: datetime.datetime | None = Field(
-        sa_column=sa.Column(sa_sqlite.TIMESTAMP, nullable=True),
         default=None,
         description="Begin datetime of the target range associated with the tag record",
     )
-    end_dt: datetime.datetime | None = Field(
-        sa_column=sa.Column(sa_sqlite.TIMESTAMP, nullable=True),
+    end_dt: datetime.datetime = Field(
+        sa_column=sa.Column(sa_sqlite.TIMESTAMP, nullable=False),
         default=None,
         description="End datetime of the target range associated with the tag record",
     )
 
+    @pdt.field_validator("name", mode="after")
+    @classmethod
+    def validate_name(cls, v: str) -> str:
+        validate_slash_tag(v)
+        return v
+
     @pdt.field_validator("tagger_name", mode="after")
     @classmethod
     def validate_tagger_name(cls, v: str) -> str:
@@ -340,45 +340,24 @@ class TagTargetInfo(BaseModel):
         validate_semver(v)
         return v
 
-    @pdt.field_validator("run_at", mode="after")
-    @classmethod
-    def validate_run_at(cls, v: datetime.datetime) -> datetime.datetime:
-        validate_dt_timezone(v)
-        return v
-
-    @pdt.field_validator("bag_name", mode="after")
-    @classmethod
-    def validate_bag_name(cls, v: str) -> str:
-        if v is not None:
-            validate_bag_name(v)
-        return v
-
     @pdt.field_validator("begin_dt", mode="after")
     @classmethod
     def validate_begin_dt(cls, v: datetime.datetime) -> datetime.datetime:
-        if v is not None:
-            validate_dt_timezone(v)
+        validate_dt_timezone(v)
         return v
 
     @pdt.field_validator("end_dt", mode="after")
     @classmethod
     def validate_end_dt(cls, v: datetime.datetime) -> datetime.datetime:
-        if v is not None:
-            validate_dt_timezone(v)
+        validate_dt_timezone(v)
         return v
 
     @pdt.model_validator(mode="after")
     def validate_begin_dt_end_dt(self) -> Self:
-        if self.begin_dt is not None and self.end_dt is not None and self.begin_dt > self.end_dt:
+        if self.begin_dt > self.end_dt:
             raise ValueError(f"begin_dt '{self.begin_dt}' is greater than end_dt '{self.end_dt}'")
         return self
 
-    @pdt.model_validator(mode="after")
-    def validate_bag_name_begin_dt_end_dt(self) -> Self:
-        if self.bag_name is None and (self.begin_dt is None or self.end_dt is None):
-            raise ValueError("bag_name is required when begin_dt or end_dt is not specified")
-        return self
-
 
 class TagRecord(BaseModel):
     target_sqn: int = Field(
@@ -448,15 +427,15 @@ class TagRecordTable(TagRecord, make_sequence_model_mixin("sqlite"), table=True)
 
 if typing.TYPE_CHECKING:
     class TagTargetInfoTable(SQLModel, SequenceModelMixinProtocol):
+        name: sa_orm.Mapped[str] = ...
         tagger_name: sa_orm.Mapped[str] = ...
         tagger_version: sa_orm.Mapped[str] = ...
-        run_at: sa_orm.Mapped[datetime.datetime] = ...
-        bag_name: sa_orm.Mapped[str | None] = ...
-        begin_dt: sa_orm.Mapped[datetime.datetime | None] = ...
-        end_dt: sa_orm.Mapped[datetime.datetime | None] = ...
+        begin_dt: sa_orm.Mapped[datetime.datetime] = ...
+        end_dt: sa_orm.Mapped[datetime.datetime] = ...
 
 
     class TagRecordTable(SQLModel, SequenceModelMixinProtocol):
+        target_sqn: sa_orm.Mapped[int] = ...
         vehicle_name: sa_orm.Mapped[str] = ...
         begin_dt: sa_orm.Mapped[datetime.datetime] = ...
         end_dt: sa_orm.Mapped[datetime.datetime] = ...
@@ -494,25 +473,26 @@ class TagCache(object):
             with self.conn_maker.make_session() as session:
                 yield session
 
+    def get_target(self, name: str) -> TagTargetInfoTable | None:
+        with self.make_session() as session:
+            return session.query(TagTargetInfoTable).filter(TagTargetInfoTable.name == name).one_or_none()
+
     def query_targets(
         self,
+        name: str | None = None,
         tagger_name: str | None = None,
         tagger_version: str | None = None,
-        run_at: datetime.datetime | None = None,
-        bag_name: str | None = None,
         begin_dt: datetime.datetime | None = None,
         end_dt: datetime.datetime | None = None,
     ) -> Generator[TagTargetInfoTable, None, None]:
         with self.make_session() as session:
             query = session.query(TagTargetInfoTable)
+            if name:
+                query = query.filter(TagTargetInfoTable.name == name)
             if tagger_name:
                 query = query.filter(TagTargetInfoTable.tagger_name == tagger_name)
             if tagger_version:
                 query = query.filter(TagTargetInfoTable.tagger_version == tagger_version)
-            if run_at:
-                query = query.filter(TagTargetInfoTable.run_at >= run_at)
-            if bag_name:
-                query = query.filter(TagTargetInfoTable.bag_name == bag_name)
             if begin_dt:
                 query = query.filter(TagTargetInfoTable.end_dt >= begin_dt)
             if end_dt:
@@ -522,48 +502,42 @@ class TagCache(object):
 
     def add_target(
         self,
+        name: str,
         tagger_name: str,
         tagger_version: str,
-        run_at: datetime.datetime | None = None,
-        bag_name: str | None = None,
-        begin_dt: datetime.datetime | None = None,
-        end_dt: datetime.datetime | None = None,
+        begin_dt: datetime.datetime,
+        end_dt: datetime.datetime,
     ) -> TagTargetInfoTable:
         with self.make_session() as session:
             target_info = TagTargetInfo(
+                name=name,
                 tagger_name=tagger_name,
                 tagger_version=tagger_version,
-                run_at=run_at or dt_utc_now(),
-                bag_name=bag_name,
                 begin_dt=begin_dt,
                 end_dt=end_dt,
             )
             db_target_info = clone_sequence_model_instance(TagTargetInfoTable, target_info)
             session.add(db_target_info)
             session.commit()
-            session.refresh(db_target_info)
 
-        return db_target_info
+        return self.get_target(name)
 
     def remove_targets(
         self,
+        name: str | None = None,
         tagger_name: str | None = None,
         tagger_version: str | None = None,
-        run_at: datetime.datetime | None = None,
-        bag_name: str | None = None,
         begin_dt: datetime.datetime | None = None,
         end_dt: datetime.datetime | None = None,
     ):
         with self.make_session() as session:
             query = session.query(TagTargetInfoTable)
+            if name:
+                query = query.filter(TagTargetInfoTable.name == name)
             if tagger_name:
                 query = query.filter(TagTargetInfoTable.tagger_name == tagger_name)
             if tagger_version:
                 query = query.filter(TagTargetInfoTable.tagger_version == tagger_version)
-            if run_at:
-                query = query.filter(TagTargetInfoTable.run_at >= run_at)
-            if bag_name:
-                query = query.filter(TagTargetInfoTable.bag_name == bag_name)
             if begin_dt:
                 query = query.filter(TagTargetInfoTable.end_dt >= begin_dt)
             if end_dt:
@@ -580,29 +554,17 @@ class TagCache(object):
             )
             session.commit()
 
-    def with_target(
-        self,
-        tagger_name: str | None = None,
-        tagger_version: str | None = None,
-        run_at: datetime.datetime | None = None,
-        bag_name: str | None = None,
-        begin_dt: datetime.datetime | None = None,
-        end_dt: datetime.datetime | None = None,
-        *,
-        target_info: TagTargetInfoTable | None = None,
-    ) -> "TargetedTagCache":
-        if target_info is not None:
-            return TargetedTagCache(cache=self, target_info=target_info)
-        return TargetedTagCache(
-            cache=self,
-            target_info=self.add_target(tagger_name, tagger_version, run_at, bag_name, begin_dt, end_dt),
-        )
+    def with_target(self, name: str) -> "TargetedTagCache":
+        target_info = self.get_target(name)
+        if target_info is None:
+            raise ValueError(f"target with name '{name}' not found in cache")
+        return TargetedTagCache(cache=self, target_info=target_info)
 
     def query(
         self,
         vehicle_name: str | None = None,
-        begin_time: datetime.datetime | None = None,
-        end_time: datetime.datetime | None = None,
+        begin_dt: datetime.datetime | None = None,
+        end_dt: datetime.datetime | None = None,
         tag_pattern: str | None = None,
         *,
         tagsets: Sequence[Tagset] | None = None,
@@ -612,8 +574,8 @@ class TagCache(object):
         Query tag records in the cache with optional filters.
 
         :param vehicle_name: Filter by vehicle name (exact match)
-        :param begin_time: Filter by begin time (inclusive)
-        :param end_time: Filter by end time (inclusive)
+        :param begin_dt: Filter by begin time (inclusive)
+        :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 tagsets: Filter by tagsets (match tags that are in any of the specified tagsets)
@@ -625,12 +587,79 @@ class TagCache(object):
             query = session.query(TagRecordTable)
             if vehicle_name:
                 query = query.filter(TagRecordTable.vehicle_name == vehicle_name)
-            if begin_time:
-                query = query.filter(TagRecordTable.end_dt >= begin_time)
-            if end_time:
-                query = query.filter(TagRecordTable.begin_dt <= end_time)
+            if begin_dt:
+                query = query.filter(TagRecordTable.end_dt >= begin_dt)
+            if end_dt:
+                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 tagsets:
+                if tagset_inverted:
+                    query = query.filter(
+                        TagRecordTable.tag.notin_([tag_name for tagset in tagsets for tag_name in tagset.tag_names]))
+                else:
+                    query = query.filter(
+                        TagRecordTable.tag.in_([tag_name for tagset in tagsets for tag_name in tagset.tag_names]))
+
+            yield from query.all()
+
+    def query_with_targets(
+        self,
+        vehicle_name: str | None = None,
+        begin_dt: datetime.datetime | None = None,
+        end_dt: datetime.datetime | None = None,
+        tag_pattern: str | None = None,
+        *,
+        target_name: str | None = None,
+        target_tagger_name: str | None = None,
+        target_tagger_version: str | None = None,
+        target_begin_dt: datetime.datetime | None = None,
+        target_end_dt: datetime.datetime | None = None,
+        tagsets: Sequence[Tagset] | None = None,
+        tagset_inverted: bool = False,
+    ) -> Generator[tuple[TagRecordTable, TagTargetInfoTable], None, None]:
+        """
+        Query tag records in the cache with their associated target info, with optional filters.
+
+        :param vehicle_name: Filter by vehicle name (exact match)
+        :param begin_dt: Filter by begin time (inclusive)
+        :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_tagger_name: Filter by target tagger name (exact match)
+        :param target_tagger_version: Filter by target tagger version (exact match)
+        :param target_begin_dt: Filter by target begin time (inclusive)
+        :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)
+        :return: Generator of ``TagRecordTable`` instances that match the filters
+        """
+        with self.make_session() as session:
+            query = (
+                session
+                .query(TagRecordTable, TagTargetInfoTable)
+                .join(TagTargetInfoTable, TagRecordTable.target_sqn == TagTargetInfoTable.sqn)
+            )
+            if vehicle_name:
+                query = query.filter(TagRecordTable.vehicle_name == vehicle_name)
+            if begin_dt:
+                query = query.filter(TagRecordTable.end_dt >= begin_dt)
+            if end_dt:
+                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_tagger_name:
+                query = query.filter(TagTargetInfoTable.tagger_name == target_tagger_name)
+            if target_tagger_version:
+                query = query.filter(TagTargetInfoTable.tagger_version == target_tagger_version)
+            if target_begin_dt:
+                query = query.filter(TagTargetInfoTable.end_dt >= target_begin_dt)
+            if target_end_dt:
+                query = query.filter(TagTargetInfoTable.begin_dt <= target_end_dt)
             if tagsets:
                 if tagset_inverted:
                     query = query.filter(
@@ -644,8 +673,8 @@ class TagCache(object):
     def remove(
         self,
         vehicle_name: str | None = None,
-        begin_time: datetime.datetime | None = None,
-        end_time: datetime.datetime | None = None,
+        begin_dt: datetime.datetime | None = None,
+        end_dt: datetime.datetime | None = None,
         tag_pattern: str | None = None,
         *,
         tagsets: Sequence[Tagset] | None = None,
@@ -655,23 +684,22 @@ class TagCache(object):
         Remove tag records from the cache that match the specified filters.
 
         :param vehicle_name: Filter by vehicle name (exact match)
-        :param begin_time: Filter by begin time (inclusive)
-        :param end_time: Filter by end time (inclusive)
+        :param begin_dt: Filter by begin time (inclusive)
+        :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 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)
-        :return: Self instance for chaining
         """
         with self.make_session() as session:
             query = session.query(TagRecordTable)
             if vehicle_name:
                 query = query.filter(TagRecordTable.vehicle_name == vehicle_name)
-            if begin_time:
-                query = query.filter(TagRecordTable.end_dt >= begin_time)
-            if end_time:
-                query = query.filter(TagRecordTable.begin_dt <= end_time)
+            if begin_dt:
+                query = query.filter(TagRecordTable.end_dt >= begin_dt)
+            if end_dt:
+                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 tagsets:
@@ -736,8 +764,8 @@ class TargetedTagCache(object):
     def query(
         self,
         vehicle_name: str | None = None,
-        begin_time: datetime.datetime | None = None,
-        end_time: datetime.datetime | None = None,
+        begin_dt: datetime.datetime | None = None,
+        end_dt: datetime.datetime | None = None,
         tag_pattern: str | None = None,
         *,
         tagsets: Sequence[Tagset] | None = None,
@@ -747,8 +775,8 @@ class TargetedTagCache(object):
         Query tag records in the cache with optional filters.
 
         :param vehicle_name: Filter by vehicle name (exact match)
-        :param begin_time: Filter by begin time (inclusive)
-        :param end_time: Filter by end time (inclusive)
+        :param begin_dt: Filter by begin time (inclusive)
+        :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 tagsets: Filter by tagsets (match tags that are in any of the specified tagsets)
@@ -761,10 +789,10 @@ class TargetedTagCache(object):
             query = session.query(TagRecordTable).filter(TagRecordTable.target_sqn == self.target_info.sqn)
             if vehicle_name:
                 query = query.filter(TagRecordTable.vehicle_name == vehicle_name)
-            if begin_time:
-                query = query.filter(TagRecordTable.end_dt >= begin_time)
-            if end_time:
-                query = query.filter(TagRecordTable.begin_dt <= end_time)
+            if begin_dt:
+                query = query.filter(TagRecordTable.end_dt >= begin_dt)
+            if end_dt:
+                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 tagsets:
@@ -780,8 +808,8 @@ class TargetedTagCache(object):
     def add(
         self,
         vehicle_name: str,
-        begin_time: datetime.datetime | None,
-        end_time: datetime.datetime | None,
+        begin_dt: datetime.datetime | None,
+        end_dt: datetime.datetime | None,
         tag: str | Tag,
         props: JsonType | None = None,
     ) -> Self:
@@ -789,8 +817,8 @@ class TargetedTagCache(object):
         Add a tag record to the cache.
 
         :param vehicle_name: Vehicle name associated with the tag record
-        :param begin_time: Begin datetime of the tag record
-        :param end_time: End datetime of the tag record
+        :param begin_dt: Begin datetime of the tag record
+        :param end_dt: End datetime of the tag record
         :param tag: Tag name or Tag instance to be added (if Tag instance is provided, its name will be used)
         :param props: Additional properties of the tag record in JSON format (optional)
         :return: Self instance for chaining
@@ -799,8 +827,8 @@ class TargetedTagCache(object):
             tag_record = TagRecord(
                 target_sqn=self.target_info.sqn,
                 vehicle_name=vehicle_name,
-                begin_dt=begin_time or self.target_info.begin_dt,
-                end_dt=end_time or self.target_info.end_dt,
+                begin_dt=begin_dt or self.target_info.begin_dt,
+                end_dt=end_dt or self.target_info.end_dt,
                 tag=tag.name if isinstance(tag, Tag) else tag,
                 props=props,
             )
@@ -809,11 +837,28 @@ class TargetedTagCache(object):
 
         return self
 
+    def add_for_target(self, vehicle_name: str, tag: str | Tag, props: JsonType | None = None) -> Self:
+        """
+        Add a tag record to the cache for the entire target range.
+
+        :param vehicle_name: Vehicle name associated with the tag record
+        :param tag: Tag name or Tag instance to be added (if Tag instance is provided, its name will be used)
+        :param props: Additional properties of the tag record in JSON format (optional)
+        :return: Self instance for chaining
+        """
+        return self.add(
+            vehicle_name=vehicle_name,
+            begin_dt=self.target_info.begin_dt,
+            end_dt=self.target_info.end_dt,
+            tag=tag,
+            props=props,
+        )
+
     def remove(
         self,
         vehicle_name: str | None = None,
-        begin_time: datetime.datetime | None = None,
-        end_time: datetime.datetime | None = None,
+        begin_dt: datetime.datetime | None = None,
+        end_dt: datetime.datetime | None = None,
         tag_pattern: str | None = None,
         *,
         tagsets: Sequence[Tagset] | None = None,
@@ -823,8 +868,8 @@ class TargetedTagCache(object):
         Remove tag records from the cache that match the specified filters.
 
         :param vehicle_name: Filter by vehicle name (exact match)
-        :param begin_time: Filter by begin time (inclusive)
-        :param end_time: Filter by end time (inclusive)
+        :param begin_dt: Filter by begin time (inclusive)
+        :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 tagsets: Filter by tagsets (match tags that are in any of the specified tagsets)
@@ -836,10 +881,10 @@ class TargetedTagCache(object):
             query = session.query(TagRecordTable).filter(TagRecordTable.target_sqn == self.target_info.sqn)
             if vehicle_name:
                 query = query.filter(TagRecordTable.vehicle_name == vehicle_name)
-            if begin_time:
-                query = query.filter(TagRecordTable.end_dt >= begin_time)
-            if end_time:
-                query = query.filter(TagRecordTable.begin_dt <= end_time)
+            if begin_dt:
+                query = query.filter(TagRecordTable.end_dt >= begin_dt)
+            if end_dt:
+                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 tagsets:

{plexus_python_common-1.0.51 → plexus_python_common-1.0.52}/src/plexus_python_common.egg-info/PKG-INFO

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

{plexus_python_common-1.0.51 → plexus_python_common-1.0.52}/test/plexus_tests/common/utils/tagutils_test.py

@@ -49,12 +49,13 @@ class TagUtilsTest(unittest.TestCase):
         self.assertEqual(cache.file_path, tag_cache_file_path())
         self.assertTrue(cache.file_path.exists())
 
-        target_cache = cache.with_target("awesome_tagger",
-                                         "1.0.0",
-                                         dt_parse_iso("2020-01-01T00:00:00+00:00"),
-                                         "20200101T000000-dummy_vehicle-0.bag",
-                                         dt_parse_iso("2020-01-01T00:00:00+00:00"),
-                                         dt_parse_iso("2020-01-01T01:00:00+00:00"))
+        cache.add_target("awesome_tagger/20200101_000000/dummy_vehicle/0",
+                         "awesome_tagger",
+                         "1.0.0",
+                         dt_parse_iso("2020-01-01T00:00:00+00:00"),
+                         dt_parse_iso("2020-01-01T01:00:00+00:00"))
+
+        target_cache = cache.with_target("awesome_tagger/20200101_000000/dummy_vehicle/0")
 
         tags_count = 1000
 
@@ -165,15 +166,15 @@ class TagUtilsTest(unittest.TestCase):
 
             target_caches_count = 10
 
-            target_caches = [
-                cache.with_target(f"concurrent_tagger_{i}",
-                                  "2.0.0",
-                                  dt_parse_iso("2020-01-01T00:00:00+00:00"),
-                                  f"20200101T000000-dummy_vehicle-{i}.bag",
-                                  dt_parse_iso("2020-01-01T00:00:00+00:00"),
-                                  dt_parse_iso("2020-01-01T01:00:00+00:00"))
-                for i in range(target_caches_count)
-            ]
+            for i in range(target_caches_count):
+                cache.add_target(f"concurrent_tagger/20200101_000000/dummy_vehicle/{i}",
+                                 "concurrent_tagger",
+                                 f"1.0.{i}",
+                                 dt_parse_iso("2020-01-01T00:00:00+00:00"),
+                                 dt_parse_iso("2020-01-01T01:00:00+00:00"))
+
+            target_caches = [cache.with_target(f"concurrent_tagger/20200101_000000/dummy_vehicle/{i}")
+                             for i in range(target_caches_count)]
 
             threads_count_per_target_cache = 10
             tasks_count_per_thread = 100
@@ -204,6 +205,6 @@ class TagUtilsTest(unittest.TestCase):
                 self.assertEqual(len(list(target_cache.query("dummy_vehicle", tag_pattern="dummy:bar"))),
                                  tasks_count_per_target_cache // len(tags))
 
-            self.assertEqual(len(list(cache.query("dummy_vehicle"))), total_tasks_count)
-            self.assertEqual(len(list(cache.query("dummy_vehicle", tag_pattern="dummy:bar"))),
+            self.assertEqual(len(list(cache.query_with_targets("dummy_vehicle"))), total_tasks_count)
+            self.assertEqual(len(list(cache.query_with_targets("dummy_vehicle", tag_pattern="dummy:bar"))),
                              total_tasks_count // len(tags))