plexus-python-common 1.0.69__py3-none-any.whl → 1.0.71__py3-none-any.whl

plexus/common/utils/tagutils.py

@@ -33,14 +33,14 @@ from plexus.common.resources.tags import predefined_tagset_specs
 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.jsonutils import json_datetime_encoder
-from plexus.common.utils.ormutils import SQLiteDateTime
-from plexus.common.utils.ormutils import SequenceModelMixinProtocol
+from plexus.common.utils.ormutils import SQLiteDateTime, 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
 
 __all__ = [
     "RichDesc",
     "Tag",
+    "BoundTag",
     "Tagset",
     "MutableTagset",
     "populate_tagset",
@@ -394,15 +394,20 @@ def make_tag_target_model_mixin() -> type[pdt.BaseModel]:
         )
         vehicle_name: str = Field(
             sa_column=sa.Column(sa_sqlite.VARCHAR(128), nullable=False),
-            description="Vehicle name associated with the tag record",
+            description="Name of the tagger's applicability vehicle",
         )
         begin_dt: datetime.datetime = Field(
             sa_column=sa.Column(SQLiteDateTime, nullable=False),
-            description="Begin datetime of the target range associated with the tag record",
+            description="Beginning of the tagger's applicability time range",
         )
         end_dt: datetime.datetime = Field(
             sa_column=sa.Column(SQLiteDateTime, nullable=False),
-            description="End datetime of the target range associated with the tag record",
+            description="End of the tagger's applicability time range",
+        )
+        props: JsonType | None = Field(
+            sa_column=sa.Column(sa_sqlite.JSON, nullable=True),
+            default=None,
+            description="Additional properties of the tag target in JSON format",
         )
 
         @pdt.field_validator("identifier", mode="after")
@@ -414,7 +419,7 @@ def make_tag_target_model_mixin() -> type[pdt.BaseModel]:
         @pdt.field_validator("tagger_name", mode="after")
         @classmethod
         def validate_tagger_name(cls, v: str) -> str:
-            validate_snake_case(v)
+            validate_slash_tag(v)
             return v
 
         @pdt.field_validator("tagger_version", mode="after")
@@ -466,21 +471,21 @@ def make_tag_record_model_mixin() -> type[pdt.BaseModel]:
         )
         begin_dt: datetime.datetime = Field(
             sa_column=sa.Column(SQLiteDateTime, nullable=False),
-            description="Begin datetime of the tag record",
+            description="Begin of the tag record time range",
         )
         end_dt: datetime.datetime = Field(
             sa_column=sa.Column(SQLiteDateTime, nullable=False),
-            description="End datetime of the tag record",
+            description="End of the tag record time range",
         )
         tagset_namespace: str | None = Field(
             sa_column=sa.Column(sa_sqlite.VARCHAR(64), nullable=True),
             default=None,
-            description="Namespace of the tagset that the tag belongs to",
+            description="Namespace of the tagset that the tag in this record belongs to",
         )
         tagset_version: str | None = Field(
             sa_column=sa.Column(sa_sqlite.VARCHAR(32), nullable=True),
             default=None,
-            description="Version of the tagset that the tag belongs to",
+            description="Version of the tagset that the tag in this record belongs to",
         )
         tag: str = Field(
             sa_column=sa.Column(sa_sqlite.VARCHAR(256), nullable=False),
@@ -573,6 +578,7 @@ if typing.TYPE_CHECKING:
         vehicle_name: sa_orm.Mapped[str] = ...
         begin_dt: sa_orm.Mapped[datetime.datetime] = ...
         end_dt: sa_orm.Mapped[datetime.datetime] = ...
+        props: sa_orm.Mapped[JsonType | None] = ...
 
 
     class TagTargetTable(TagTarget, SequenceModelMixinProtocol):
@@ -669,6 +675,7 @@ class TagCache(object):
         vehicle_name: str,
         begin_dt: datetime.datetime,
         end_dt: datetime.datetime,
+        props: JsonType | None = None,
     ) -> TagTargetTable:
         with self.make_session() as session:
             tag_target = TagTarget(
@@ -678,6 +685,7 @@ class TagCache(object):
                 vehicle_name=vehicle_name,
                 begin_dt=begin_dt,
                 end_dt=end_dt,
+                props=props,
             )
             db_tag_target = clone_sequence_model_instance(TagTargetTable, tag_target)
             session.add(db_tag_target)
@@ -886,7 +894,7 @@ class TagCache(object):
         *,
         tagsets: Sequence[Tagset] | None = None,
         tagset_inverted: bool = False,
-    ):
+    ) -> Self:
         """
         Remove tag records from the cache that match the specified filters.
 
@@ -898,6 +906,7 @@ class TagCache(object):
         :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 for chaining
         """
         with self.make_session() as session:
             query_stmt = session.query(TagRecordTable)
@@ -922,86 +931,20 @@ class TagCache(object):
             query_stmt.delete()
             session.commit()
 
-    def clear(self):
-        with self.make_session() as session:
-            session.execute(sa.delete(TagRecordTable))
-            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.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.copy_to(source_tag_cache, self)
-
-    @staticmethod
-    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
-
-        with src.make_session() as src_session, dst.make_session() as dst_session:
-            src_db_tag_targets = src_session.query(TagTargetTable).all()
-            dst_db_tag_targets = [
-                clone_sequence_model_instance(TagTargetTable, db_tag_target, clear_meta_fields=True)
-                for db_tag_target in src_db_tag_targets
-            ]
-            dst_session.add_all(dst_db_tag_targets)
-            dst_session.flush()  # ensure new sqn values are assigned
-
-            sqn_map = {src_db_tag_target.sqn: dst_db_tag_target.sqn
-                       for src_db_tag_target, dst_db_tag_target in zip(src_db_tag_targets, dst_db_tag_targets)}
-
-            for db_tag_records in batched(src_session.query(TagRecordTable).yield_per(1000), 1000):
-                cloned_db_tag_records = []
-                for db_tag_record in db_tag_records:
-                    cloned_db_tag_record = clone_sequence_model_instance(TagRecordTable,
-                                                                         db_tag_record,
-                                                                         clear_meta_fields=True)
-                    try:
-                        cloned_db_tag_record.target_sqn = sqn_map[db_tag_record.target_sqn]
-                    except KeyError as e:
-                        raise ValueError(f"no cloned tag target for target_sqn '{db_tag_record.target_sqn}'") from e
-                    cloned_db_tag_records.append(cloned_db_tag_record)
-                dst_session.add_all(cloned_db_tag_records)
-            dst_session.commit()
-
-    count_tags = count_records
-    iter_tags = iter_records
-    iter_tag_and_targets = iter_record_and_targets
-    remove_tags = remove_records
-
-
-class TargetedTagCache(object):
-    def __init__(self, cache: TagCache, tag_target: TagTargetTable):
-        self.cache = cache
-        self.tag_target = tag_target
-
-    @contextlib.contextmanager
-    def make_session(self) -> Generator[sa_orm.Session, None, None]:
-        with self.cache.make_session() as session:
-            if not session.query(TagTargetTable).filter(TagTargetTable.sqn == self.tag_target.sqn).first():
-                raise ValueError(f"tag target with sqn '{self.tag_target.sqn}' is no longer present in cache")
-            yield session
+        return self
 
-    def count_records(self) -> int:
+    def target_count_records(self, target_sqn: int) -> int:
         with self.make_session() as session:
             return (
                 session
                 .query(sa.func.count(TagRecordTable.sqn))
-                .filter(TagRecordTable.target_sqn == self.tag_target.sqn)
+                .filter(TagRecordTable.target_sqn == target_sqn)
                 .scalar()
             )
 
-    def iter_records(
+    def target_iter_records(
         self,
+        target_sqn: int,
         begin_dt: datetime.datetime | None = None,
         end_dt: datetime.datetime | None = None,
         tagset_namespace: str | None = None,
@@ -1017,6 +960,7 @@ class TargetedTagCache(object):
         """
         Query tag records in the cache with optional filters.
 
+        :param target_sqn: Filter by target sequence number (exact match)
         :param begin_dt: Filter by begin time (inclusive)
         :param end_dt: Filter by end time (inclusive)
         :param tagset_namespace: Filter by tagset namespace (exact match)
@@ -1032,7 +976,7 @@ class TargetedTagCache(object):
         """
 
         with self.make_session() as session:
-            query_stmt = session.query(TagRecordTable).filter(TagRecordTable.target_sqn == self.tag_target.sqn)
+            query_stmt = session.query(TagRecordTable).filter(TagRecordTable.target_sqn == target_sqn)
             if begin_dt:
                 query_stmt = query_stmt.filter(TagRecordTable.end_dt >= begin_dt)
             if end_dt:
@@ -1060,19 +1004,20 @@ class TargetedTagCache(object):
             for result in query_stmt.yield_per(batch_size):
                 yield result
 
-    def add_ranged_record(
+    def target_add_record(
         self,
-        begin_dt: datetime.datetime | None,
-        end_dt: datetime.datetime | None,
+        target_sqn: int,
+        begin_dt: datetime.datetime,
+        end_dt: datetime.datetime,
         tag: str | Tag | BoundTag,
         props: JsonType | None = None,
         tagset_namespace: str | None = None,
         tagset_version: str | None = None,
     ) -> Chainable[Self, TagRecordTable]:
         """
-        Add a tag record to the cache for the specified time range. If ``begin_dt`` or ``end_dt`` is None, it will
-        default to the target's ``begin_dt`` or ``end_dt`` respectively.
+        Add a tag record to the cache for the specified time range.
 
+        :param target_sqn: Sequence number of the tag record's target
         :param begin_dt: Begin datetime of the tag record
         :param end_dt: End datetime of the tag record
         :param tag: Tag name or ``Tag``/``BoundTag`` instance to be added. If ``Tag``/``BoundTag`` instance is provided,
@@ -1083,13 +1028,13 @@ class TargetedTagCache(object):
                                  instance will be used.
         :param tagset_version: Version of the tagset that the tag belongs to. If the ``tag`` parameter is a ``BoundTag``
                                instance, this parameter will be ignored and the version from the instance will be used.
-        :return: Self instance for chaining
+        :return: Self instance for chaining along with the added ``TagRecordTable`` instance
         """
         with self.make_session() as session:
             tag_record = TagRecord(
-                target_sqn=self.tag_target.sqn,
-                begin_dt=begin_dt or self.tag_target.begin_dt,
-                end_dt=end_dt or self.tag_target.end_dt,
+                target_sqn=target_sqn,
+                begin_dt=begin_dt,
+                end_dt=end_dt,
                 tagset_namespace=tag.namespace if isinstance(tag, BoundTag) else tagset_namespace,
                 tagset_version=tag.version if isinstance(tag, BoundTag) else tagset_version,
                 tag=tag.name if isinstance(tag, Tag) else tag,
@@ -1101,38 +1046,9 @@ class TargetedTagCache(object):
 
             return chainable(self, db_tag_record)
 
-    def add_record(
-        self,
-        tag: str | Tag | BoundTag,
-        props: JsonType | None = None,
-        tagset_namespace: str | None = None,
-        tagset_version: str | None = None,
-    ) -> Chainable[Self, TagRecordTable]:
-        """
-        Add a tag record to the cache for the entire target range.
-
-        :param tag: Tag name or ``Tag``/``BoundTag`` instance to be added. If ``Tag``/``BoundTag`` instance is provided,
-                    its name will be used.
-        :param props: Additional properties of the tag record in JSON format (optional)
-        :param tagset_namespace: Namespace of the tagset that the tag belongs to. If the ``tag`` parameter is a
-                                 ``BoundTag`` instance, this parameter will be ignored and the namespace from the
-                                 instance will be used.
-        :param tagset_version: Version of the tagset that the tag belongs to. If the ``tag`` parameter is a
-                               ``BoundTag`` instance, this parameter will be ignored and the version from the instance
-                               will be used.
-        :return: Self instance for chaining
-        """
-        return self.add_ranged_record(
-            begin_dt=self.tag_target.begin_dt,
-            end_dt=self.tag_target.end_dt,
-            tag=tag,
-            tagset_namespace=tagset_namespace,
-            tagset_version=tagset_version,
-            props=props,
-        )
-
-    def update_record(
+    def target_update_record(
         self,
+        target_sqn: int,
         sqn: int,
         *,
         begin_dt: datetime.datetime | None = None,
@@ -1146,6 +1062,7 @@ class TargetedTagCache(object):
         """
         Update a tag record in the cache by its sequence number.
 
+        :param target_sqn: Sequence number of the tag record's target
         :param sqn: Sequence number of the tag record to be updated
         :param begin_dt: New begin datetime of the tag record (optional)
         :param end_dt: New end datetime of the tag record (optional)
@@ -1159,10 +1076,15 @@ class TargetedTagCache(object):
                                is a ``BoundTag`` instance, this parameter will be ignored and the version from the
                                instance will be used.
         :param flags: New integer bitmask storing status or metadata flags for this tag record (optional)
-        :return: Self instance for chaining
+        :return: Self instance for chaining along with the updated ``TagRecordTable`` instance
         """
         with self.make_session() as session:
-            db_tag_record = session.query(TagRecordTable).filter(TagRecordTable.sqn == sqn).one_or_none()
+            db_tag_record = (
+                session
+                .query(TagRecordTable)
+                .filter(TagTargetTable.sqn == target_sqn, TagRecordTable.sqn == sqn)
+                .one_or_none()
+            )
             if not db_tag_record:
                 raise ValueError(f"tag record with sqn '{sqn}' not found in cache")
 
@@ -1185,8 +1107,9 @@ class TargetedTagCache(object):
 
             return chainable(self, db_tag_record)
 
-    def remove_records(
+    def target_remove_records(
         self,
+        target_sqn: int,
         begin_dt: datetime.datetime | None = None,
         end_dt: datetime.datetime | None = None,
         tagset_namespace: str | None = None,
@@ -1199,6 +1122,7 @@ class TargetedTagCache(object):
         """
         Remove tag records from the cache that match the specified filters.
 
+        :param target_sqn: Filter by target sequence number (exact match)
         :param begin_dt: Filter by begin time (inclusive)
         :param end_dt: Filter by end time (inclusive)
         :param tagset_namespace: Filter by tagset namespace (exact match)
@@ -1210,7 +1134,7 @@ class TargetedTagCache(object):
         :return: Self instance for chaining
         """
         with self.make_session() as session:
-            query_stmt = session.query(TagRecordTable).filter(TagRecordTable.target_sqn == self.tag_target.sqn)
+            query_stmt = session.query(TagRecordTable).filter(TagRecordTable.target_sqn == target_sqn)
             if begin_dt:
                 query_stmt = query_stmt.filter(TagRecordTable.end_dt >= begin_dt)
             if end_dt:
@@ -1234,12 +1158,239 @@ class TargetedTagCache(object):
 
         return self
 
-    count_tags = count_records
-    iter_tags = iter_records
-    add_ranged_tag = add_ranged_record
-    add_tag = add_record
-    update_tag = update_record
-    remove_tags = remove_records
+    def clear(self):
+        with self.make_session() as session:
+            session.execute(sa.delete(TagRecordTable))
+            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.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.copy_to(source_tag_cache, self)
+
+    @staticmethod
+    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
+
+        with src.make_session() as src_session, dst.make_session() as dst_session:
+            src_db_tag_targets = src_session.query(TagTargetTable).all()
+            dst_db_tag_targets = [
+                clone_sequence_model_instance(TagTargetTable, db_tag_target, clear_meta_fields=True)
+                for db_tag_target in src_db_tag_targets
+            ]
+            dst_session.add_all(dst_db_tag_targets)
+            dst_session.flush()  # ensure new sqn values are assigned
+
+            sqn_map = {src_db_tag_target.sqn: dst_db_tag_target.sqn
+                       for src_db_tag_target, dst_db_tag_target in zip(src_db_tag_targets, dst_db_tag_targets)}
+
+            for db_tag_records in batched(src_session.query(TagRecordTable).yield_per(1000), 1000):
+                cloned_db_tag_records = []
+                for db_tag_record in db_tag_records:
+                    cloned_db_tag_record = clone_sequence_model_instance(TagRecordTable,
+                                                                         db_tag_record,
+                                                                         clear_meta_fields=True)
+                    try:
+                        cloned_db_tag_record.target_sqn = sqn_map[db_tag_record.target_sqn]
+                    except KeyError as e:
+                        raise ValueError(f"no cloned tag target for target_sqn '{db_tag_record.target_sqn}'") from e
+                    cloned_db_tag_records.append(cloned_db_tag_record)
+                dst_session.add_all(cloned_db_tag_records)
+            dst_session.commit()
+
+
+class TargetedTagCache(object):
+    def __init__(self, cache: TagCache, tag_target: TagTargetTable):
+        self.cache = cache
+        self.tag_target = tag_target
+
+    def count_records(self) -> int:
+        return self.cache.target_count_records(self.tag_target.sqn)
+
+    def iter_records(
+        self,
+        begin_dt: datetime.datetime | None = None,
+        end_dt: datetime.datetime | None = None,
+        tagset_namespace: str | None = None,
+        tagset_version: str | None = None,
+        tag_prefix: str | None = None,
+        *,
+        tagsets: Sequence[Tagset] | None = None,
+        tagset_inverted: bool = False,
+        skip: int | None = None,
+        limit: int | None = None,
+        batch_size: int = 1000,
+    ) -> Generator[TagRecordTable, None, None]:
+        return self.cache.target_iter_records(
+            target_sqn=self.tag_target.sqn,
+            begin_dt=begin_dt,
+            end_dt=end_dt,
+            tagset_namespace=tagset_namespace,
+            tagset_version=tagset_version,
+            tag_prefix=tag_prefix,
+            tagsets=tagsets,
+            tagset_inverted=tagset_inverted,
+            skip=skip,
+            limit=limit,
+            batch_size=batch_size,
+        )
+
+    def add_ranged_record(
+        self,
+        begin_dt: datetime.datetime | None,
+        end_dt: datetime.datetime | None,
+        tag: str | Tag | BoundTag,
+        props: JsonType | None = None,
+        tagset_namespace: str | None = None,
+        tagset_version: str | None = None,
+    ) -> Chainable[Self, TagRecordTable]:
+        """
+        Add a tag record to the cache for the specified time range. If ``begin_dt`` or ``end_dt`` is None, it will
+        default to the target's ``begin_dt`` or ``end_dt`` respectively.
+
+        :param begin_dt: Begin datetime of the tag record
+        :param end_dt: End datetime of the tag record
+        :param tag: Tag name or ``Tag``/``BoundTag`` instance to be added. If ``Tag``/``BoundTag`` instance is provided,
+                    its name will be used.
+        :param props: Additional properties of the tag record in JSON format (optional)
+        :param tagset_namespace: Namespace of the tagset that the tag belongs to. If the ``tag`` parameter is a
+                                 ``BoundTag`` instance, this parameter will be ignored and the namespace from the
+                                 instance will be used.
+        :param tagset_version: Version of the tagset that the tag belongs to. If the ``tag`` parameter is a ``BoundTag``
+                               instance, this parameter will be ignored and the version from the instance will be used.
+        :return: Self instance for chaining along with the added ``TagRecordTable`` instance
+        """
+        result = self.cache.target_add_record(
+            target_sqn=self.tag_target.sqn,
+            begin_dt=begin_dt or self.tag_target.begin_dt,
+            end_dt=end_dt or self.tag_target.end_dt,
+            tag=tag,
+            props=props,
+            tagset_namespace=tagset_namespace,
+            tagset_version=tagset_version,
+        )
+        return result.retarget(self)
+
+    def add_record(
+        self,
+        tag: str | Tag | BoundTag,
+        props: JsonType | None = None,
+        tagset_namespace: str | None = None,
+        tagset_version: str | None = None,
+    ) -> Chainable[Self, TagRecordTable]:
+        """
+        Add a tag record to the cache for the entire target range.
+
+        :param tag: Tag name or ``Tag``/``BoundTag`` instance to be added. If ``Tag``/``BoundTag`` instance is provided,
+                    its name will be used.
+        :param props: Additional properties of the tag record in JSON format (optional)
+        :param tagset_namespace: Namespace of the tagset that the tag belongs to. If the ``tag`` parameter is a
+                                 ``BoundTag`` instance, this parameter will be ignored and the namespace from the
+                                 instance will be used.
+        :param tagset_version: Version of the tagset that the tag belongs to. If the ``tag`` parameter is a
+                               ``BoundTag`` instance, this parameter will be ignored and the version from the instance
+                               will be used.
+        :return: Self instance for chaining along with the added ``TagRecordTable`` instance
+        """
+        result = self.add_ranged_record(
+            begin_dt=self.tag_target.begin_dt,
+            end_dt=self.tag_target.end_dt,
+            tag=tag,
+            tagset_namespace=tagset_namespace,
+            tagset_version=tagset_version,
+            props=props,
+        )
+        return result.retarget(self)
+
+    def update_record(
+        self,
+        sqn: int,
+        *,
+        begin_dt: datetime.datetime | None = None,
+        end_dt: datetime.datetime | None = None,
+        tag: str | Tag | BoundTag | None = None,
+        props: JsonType | None = None,
+        tagset_namespace: str | None = None,
+        tagset_version: str | None = None,
+        flags: int | None = None,
+    ) -> Chainable[Self, TagRecordTable]:
+        """
+        Update a tag record in the cache by its sequence number.
+
+        :param sqn: Sequence number of the tag record to be updated
+        :param begin_dt: New begin datetime of the tag record (optional)
+        :param end_dt: New end datetime of the tag record (optional)
+        :param tag: New tag name or ``Tag``/``BoundTag`` instance to be updated (optional). If ``Tag``/``BoundTag``
+                    instance is provided, its name will be used.
+        :param props: New additional properties of the tag record in JSON format (optional)
+        :param tagset_namespace: New namespace of the tagset that the tag belongs to (optional). If the ``tag``
+                                 parameter is a ``BoundTag`` instance, this parameter will be ignored and the namespace
+                                 from the instance will be used.
+        :param tagset_version: New version of the tagset that the tag belongs to (optional). If the ``tag`` parameter
+                               is a ``BoundTag`` instance, this parameter will be ignored and the version from the
+                               instance will be used.
+        :param flags: New integer bitmask storing status or metadata flags for this tag record (optional)
+        :return: Self instance for chaining along with the updated ``TagRecordTable`` instance
+        """
+        result = self.cache.target_update_record(
+            self.tag_target.sqn,
+            sqn,
+            begin_dt=begin_dt,
+            end_dt=end_dt,
+            tag=tag,
+            props=props,
+            tagset_namespace=tagset_namespace,
+            tagset_version=tagset_version,
+            flags=flags,
+        )
+        return result.retarget(self)
+
+    def remove_records(
+        self,
+        begin_dt: datetime.datetime | None = None,
+        end_dt: datetime.datetime | None = None,
+        tagset_namespace: str | None = None,
+        tagset_version: str | None = None,
+        tag_prefix: str | None = None,
+        *,
+        tagsets: Sequence[Tagset] | None = None,
+        tagset_inverted: bool = False,
+    ) -> Self:
+        """
+        Remove tag records from the cache that match the specified filters.
+
+        :param begin_dt: Filter by begin time (inclusive)
+        :param end_dt: Filter by end time (inclusive)
+        :param tagset_namespace: Filter by tagset namespace (exact match)
+        :param tagset_version: Filter by tagset version (exact match)
+        :param tag_prefix: Filter by tag name prefix, e.g. "dummy_tag:" to match all tags starting with "dummy_tag:"
+        :param tagsets: Filter by tagsets (match tags that are in any of the specified tagsets)
+        :param tagset_inverted: Whether to invert the tagset filter (match tags that are NOT in any of the specified
+                                tagsets)
+        :return: Self instance for chaining
+        """
+        self.cache.target_remove_records(
+            self.tag_target.sqn,
+            begin_dt=begin_dt,
+            end_dt=end_dt,
+            tagset_namespace=tagset_namespace,
+            tagset_version=tagset_version,
+            tag_prefix=tag_prefix,
+            tagsets=tagsets,
+            tagset_inverted=tagset_inverted,
+        )
+        return self
 
 
 @memorized

{plexus_python_common-1.0.69.dist-info → plexus_python_common-1.0.71.dist-info}/METADATA

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

{plexus_python_common-1.0.69.dist-info → plexus_python_common-1.0.71.dist-info}/RECORD

@@ -21,9 +21,9 @@ plexus/common/utils/pathutils.py,sha256=hGJqSLj08tuOeZ7WeC5d4BtjnPI732BuntVQBQsq
 plexus/common/utils/s3utils.py,sha256=zlO4kGs-c2gUeOfPfiKIE5liQZsbYxqAZYCwA8kL0Lo,36017
 plexus/common/utils/sqlutils.py,sha256=D6kTBjhO5YlNRt3uFlPt6z3uH61m9ajEzPYmsI6NoFc,231
 plexus/common/utils/strutils.py,sha256=O9Inv4ffUTf6Xjc5ftoZwbIua1NeG7itCT9S3zjZxBc,16436
-plexus/common/utils/tagutils.py,sha256=OaJ_iXbYPRRqq1-GwkqnZ-6UUj4jhhd8Myfu92VKg8Y,55419
+plexus/common/utils/tagutils.py,sha256=a49OLhIG8-3cR04DX4Cs3fyasbX551mBqg4V3bUsZNk,62206
 plexus/common/utils/testutils.py,sha256=N8ijLu7X-hlQlHzvv0TtSsQpIF4T1hbr-AjkILoV2Ac,6152
-plexus_python_common-1.0.69.dist-info/METADATA,sha256=kiAxXNij0yyE_PgMAVoCDuXjD_FPGgxA1abUHMLaB44,1481
-plexus_python_common-1.0.69.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-plexus_python_common-1.0.69.dist-info/top_level.txt,sha256=ug_g7CVwaMQuas5UzAXbHUrQvKGCn8ezc6ZNvvRlJOE,7
-plexus_python_common-1.0.69.dist-info/RECORD,,
+plexus_python_common-1.0.71.dist-info/METADATA,sha256=SbTPXbTTk_V68ThFajwP1hBuj1LvM0pyzrpsw4WclLM,1481
+plexus_python_common-1.0.71.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+plexus_python_common-1.0.71.dist-info/top_level.txt,sha256=ug_g7CVwaMQuas5UzAXbHUrQvKGCn8ezc6ZNvvRlJOE,7
+plexus_python_common-1.0.71.dist-info/RECORD,,