plexus-python-common 1.0.70__tar.gz → 1.0.72__tar.gz

{plexus_python_common-1.0.70 → plexus_python_common-1.0.72}/PKG-INFO

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

{plexus_python_common-1.0.70 → plexus_python_common-1.0.72}/src/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",
@@ -894,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.
 
@@ -906,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)
@@ -930,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,
@@ -1025,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)
@@ -1040,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:
@@ -1068,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,
@@ -1091,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,
@@ -1109,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,
@@ -1154,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)
@@ -1167,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(TagRecordTable.target_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")
 
@@ -1193,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,
@@ -1207,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)
@@ -1218,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:
@@ -1242,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.70 → plexus_python_common-1.0.72}/src/plexus_python_common.egg-info/PKG-INFO

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

{plexus_python_common-1.0.70 → plexus_python_common-1.0.72}/test/plexus_tests/common/utils/tagutils_test.py

@@ -131,7 +131,7 @@ class TagUtilsTest(unittest.TestCase):
         for i in range(tag_records_count):
             tag_name = tag_names[i % len(tag_names)]
             tag = tagset.get_bound(tag_name) or tag_name
-            target_cache.add_ranged_tag(
+            target_cache.add_ranged_record(
                 dt_parse_iso("2020-01-01T00:00:00+00:00") + datetime.timedelta(seconds=i),
                 dt_parse_iso("2020-01-02T00:00:00+00:00") + datetime.timedelta(seconds=i + 1),
                 tag,
@@ -150,92 +150,93 @@ class TagUtilsTest(unittest.TestCase):
                 },
             )
 
-        self.assertEqual(target_cache.count_tags(), tag_records_count)
-        self.assertEqual(len(list(target_cache.iter_tags())), tag_records_count)
-        self.assertEqual(len(list(target_cache.iter_tags(tagsets=[tagset]))),
+        self.assertEqual(target_cache.count_records(), tag_records_count)
+        self.assertEqual(len(list(target_cache.iter_records())), tag_records_count)
+        self.assertEqual(len(list(target_cache.iter_records(tagsets=[tagset]))),
                          tag_records_count * tagset_tags_count // tags_count)
-        self.assertEqual(len(list(target_cache.iter_tags(tagsets=[tagset], tagset_inverted=True))),
+        self.assertEqual(len(list(target_cache.iter_records(tagsets=[tagset], tagset_inverted=True))),
                          tag_records_count * (tags_count - tagset_tags_count) // tags_count)
-        self.assertEqual(len(list(target_cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
+        self.assertEqual(len(list(target_cache.iter_records(tagsets=[tagset], tagset_inverted=False))),
                          tag_records_count * tagset_tags_count // tags_count)
-        self.assertEqual(len(list(target_cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
-                                                         dt_parse_iso("2020-01-01T00:01:00+00:00")))),
+        self.assertEqual(len(list(target_cache.iter_records(dt_parse_iso("2020-01-01T00:00:00+00:00"),
+                                                            dt_parse_iso("2020-01-01T00:01:00+00:00")))),
                          60 + 1)
-        self.assertEqual(len(list(target_cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
-                                                         dt_parse_iso("2020-01-01T00:01:00+00:00"),
-                                                         tag_prefix="dummy:foo"))),
+        self.assertEqual(len(list(target_cache.iter_records(dt_parse_iso("2020-01-01T00:00:00+00:00"),
+                                                            dt_parse_iso("2020-01-01T00:01:00+00:00"),
+                                                            tag_prefix="dummy:foo"))),
                          60 // tags_count + 1)
-        self.assertEqual(len(list(target_cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
-                                                         dt_parse_iso("2020-01-01T00:01:00+00:00"),
-                                                         tag_prefix="dummy:bar"))),
+        self.assertEqual(len(list(target_cache.iter_records(dt_parse_iso("2020-01-01T00:00:00+00:00"),
+                                                            dt_parse_iso("2020-01-01T00:01:00+00:00"),
+                                                            tag_prefix="dummy:bar"))),
                          60 // tags_count)
-        self.assertEqual(len(list(target_cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
-                                                         dt_parse_iso("2020-01-01T00:01:00+00:00"),
-                                                         tag_prefix="dummy"))),
+        self.assertEqual(len(list(target_cache.iter_records(dt_parse_iso("2020-01-01T00:00:00+00:00"),
+                                                            dt_parse_iso("2020-01-01T00:01:00+00:00"),
+                                                            tag_prefix="dummy"))),
                          60 + 1)
-        self.assertEqual(len(list(target_cache.iter_tags(tag_prefix="dummy:foo"))),
+        self.assertEqual(len(list(target_cache.iter_records(tag_prefix="dummy:foo"))),
                          tag_records_count // tags_count)
-        self.assertEqual(len(list(target_cache.iter_tags(tag_prefix="dummy:bar"))),
+        self.assertEqual(len(list(target_cache.iter_records(tag_prefix="dummy:bar"))),
                          tag_records_count // tags_count)
-        self.assertEqual(len(list(target_cache.iter_tags(tag_prefix="dummy"))), tag_records_count)
+        self.assertEqual(len(list(target_cache.iter_records(tag_prefix="dummy"))), tag_records_count)
 
-        self.assertEqual(len(list(cache.iter_tags())), tag_records_count)
-        self.assertEqual(len(list(cache.iter_tags(tagsets=[tagset]))), tag_records_count // 2)
-        self.assertEqual(len(list(cache.iter_tags(tagsets=[tagset], tagset_inverted=True))),
+        self.assertEqual(len(list(cache.iter_records())), tag_records_count)
+        self.assertEqual(len(list(cache.iter_records(tagsets=[tagset]))), tag_records_count // 2)
+        self.assertEqual(len(list(cache.iter_records(tagsets=[tagset], tagset_inverted=True))),
                          tag_records_count * (tags_count - tagset_tags_count) // tags_count)
-        self.assertEqual(len(list(cache.iter_tags(tagsets=[tagset], tagset_inverted=False))),
+        self.assertEqual(len(list(cache.iter_records(tagsets=[tagset], tagset_inverted=False))),
                          tag_records_count * tagset_tags_count // tags_count)
-        self.assertEqual(len(list(cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
-                                                  dt_parse_iso("2020-01-01T00:01:00+00:00")))),
+        self.assertEqual(len(list(cache.iter_records(dt_parse_iso("2020-01-01T00:00:00+00:00"),
+                                                     dt_parse_iso("2020-01-01T00:01:00+00:00")))),
                          60 + 1)
-        self.assertEqual(len(list(cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
-                                                  dt_parse_iso("2020-01-01T00:01:00+00:00"),
-                                                  tag_prefix="dummy:foo"))),
+        self.assertEqual(len(list(cache.iter_records(dt_parse_iso("2020-01-01T00:00:00+00:00"),
+                                                     dt_parse_iso("2020-01-01T00:01:00+00:00"),
+                                                     tag_prefix="dummy:foo"))),
                          60 // tags_count + 1)
-        self.assertEqual(len(list(cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
-                                                  dt_parse_iso("2020-01-01T00:01:00+00:00"),
-                                                  tag_prefix="dummy:bar"))),
+        self.assertEqual(len(list(cache.iter_records(dt_parse_iso("2020-01-01T00:00:00+00:00"),
+                                                     dt_parse_iso("2020-01-01T00:01:00+00:00"),
+                                                     tag_prefix="dummy:bar"))),
                          60 // tags_count)
-        self.assertEqual(len(list(cache.iter_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"),
-                                                  dt_parse_iso("2020-01-01T00:01:00+00:00"),
-                                                  tag_prefix="dummy"))),
+        self.assertEqual(len(list(cache.iter_records(dt_parse_iso("2020-01-01T00:00:00+00:00"),
+                                                     dt_parse_iso("2020-01-01T00:01:00+00:00"),
+                                                     tag_prefix="dummy"))),
                          60 + 1)
-        self.assertEqual(len(list(cache.iter_tags(tag_prefix="dummy:foo"))), tag_records_count // tags_count)
-        self.assertEqual(len(list(cache.iter_tags(tag_prefix="dummy:bar"))), tag_records_count // tags_count)
-        self.assertEqual(len(list(cache.iter_tags(tag_prefix="dummy"))), tag_records_count)
+        self.assertEqual(len(list(cache.iter_records(tag_prefix="dummy:foo"))), tag_records_count // tags_count)
+        self.assertEqual(len(list(cache.iter_records(tag_prefix="dummy:bar"))), tag_records_count // tags_count)
+        self.assertEqual(len(list(cache.iter_records(tag_prefix="dummy"))), tag_records_count)
 
-        target_cache.remove_tags(dt_parse_iso("2020-01-01T00:00:00+00:00"), dt_parse_iso("2020-01-01T00:01:00+00:00"))
+        target_cache.remove_records(dt_parse_iso("2020-01-01T00:00:00+00:00"),
+                                    dt_parse_iso("2020-01-01T00:01:00+00:00"))
 
-        self.assertEqual(target_cache.count_tags(), tag_records_count - (60 + 1))
-        self.assertEqual(len(list(target_cache.iter_tags())), tag_records_count - (60 + 1))
-        self.assertEqual(cache.count_tags(), tag_records_count - (60 + 1))
-        self.assertEqual(len(list(cache.iter_tags())), tag_records_count - (60 + 1))
+        self.assertEqual(target_cache.count_records(), tag_records_count - (60 + 1))
+        self.assertEqual(len(list(target_cache.iter_records())), tag_records_count - (60 + 1))
+        self.assertEqual(cache.count_records(), tag_records_count - (60 + 1))
+        self.assertEqual(len(list(cache.iter_records())), tag_records_count - (60 + 1))
 
-        target_cache.remove_tags(tagsets=[tagset], tagset_inverted=True)
+        target_cache.remove_records(tagsets=[tagset], tagset_inverted=True)
 
         self.assertEqual(
-            target_cache.count_tags(),
+            target_cache.count_records(),
             tag_records_count * tagset_tags_count // tags_count - (60 * tagset_tags_count // tags_count + 1),
         )
         self.assertEqual(
-            len(list(target_cache.iter_tags())),
+            len(list(target_cache.iter_records())),
             tag_records_count * tagset_tags_count // tags_count - (60 * tagset_tags_count // tags_count + 1),
         )
         self.assertEqual(
-            cache.count_tags(),
+            cache.count_records(),
             tag_records_count * tagset_tags_count // tags_count - (60 * tagset_tags_count // tags_count + 1),
         )
         self.assertEqual(
-            len(list(cache.iter_tags())),
+            len(list(cache.iter_records())),
             tag_records_count * tagset_tags_count // tags_count - (60 * tagset_tags_count // tags_count + 1),
         )
 
-        target_cache.remove_tags()
+        target_cache.remove_records()
 
-        self.assertEqual(target_cache.count_tags(), 0)
-        self.assertEqual(len(list(target_cache.iter_tags())), 0)
-        self.assertEqual(cache.count_tags(), 0)
-        self.assertEqual(len(list(cache.iter_tags())), 0)
+        self.assertEqual(target_cache.count_records(), 0)
+        self.assertEqual(len(list(target_cache.iter_records())), 0)
+        self.assertEqual(cache.count_records(), 0)
+        self.assertEqual(len(list(cache.iter_records())), 0)
 
     def test_tag_cache__multithread(self):
         tag_names = [
@@ -296,7 +297,7 @@ class TagUtilsTest(unittest.TestCase):
                 for i in range(tasks_count_per_thread):
                     tag_name = tag_names[i % len(tag_names)]
                     tag = old_tagset.get_bound(tag_name) or new_tagset.get_bound(tag_name) or tag_name
-                    target_cache.add_ranged_tag(
+                    target_cache.add_ranged_record(
                         dt_parse_iso("2020-01-01T00:00:00+00:00") + datetime.timedelta(seconds=i),
                         dt_parse_iso("2020-01-02T00:00:00+00:00") + datetime.timedelta(seconds=i + 1),
                         tag,
@@ -322,23 +323,27 @@ class TagUtilsTest(unittest.TestCase):
                 thread.join()
 
             for target_cache in target_caches:
-                self.assertEqual(target_cache.count_tags(), tasks_count_per_target_cache)
-                self.assertEqual(len(list(target_cache.iter_tags())), tasks_count_per_target_cache)
-                self.assertEqual(len(list(target_cache.iter_tags(tag_prefix="dummy:bar"))),
+                self.assertEqual(target_cache.count_records(), tasks_count_per_target_cache)
+                self.assertEqual(len(list(target_cache.iter_records())), tasks_count_per_target_cache)
+                self.assertEqual(len(list(target_cache.iter_records(tag_prefix="dummy:bar"))),
                                  tasks_count_per_target_cache // tags_count)
-                self.assertEqual(len(list(target_cache.iter_tags(tagset_namespace="tagset"))),
+                self.assertEqual(len(list(target_cache.iter_records(tagset_namespace="tagset"))),
                                  tasks_count_per_target_cache * tagset_tags_count // tags_count)
-                self.assertEqual(len(list(target_cache.iter_tags(tagset_namespace="tagset", tagset_version="1.0.0"))),
-                                 tasks_count_per_target_cache * old_tagset_tags_count // tags_count)
-
-            self.assertEqual(cache.count_tags(), total_tasks_count)
-            self.assertEqual(len(list(cache.iter_tag_and_targets())), total_tasks_count)
-            self.assertEqual(len(list(cache.iter_tag_and_targets(tag_prefix="dummy:bar"))),
+                self.assertEqual(
+                    len(list(target_cache.iter_records(tagset_namespace="tagset", tagset_version="1.0.0"))),
+                    tasks_count_per_target_cache * old_tagset_tags_count // tags_count,
+                )
+
+            self.assertEqual(cache.count_records(), total_tasks_count)
+            self.assertEqual(len(list(cache.iter_record_and_targets())), total_tasks_count)
+            self.assertEqual(len(list(cache.iter_record_and_targets(tag_prefix="dummy:bar"))),
                              total_tasks_count // tags_count)
-            self.assertEqual(len(list(cache.iter_tag_and_targets(tagset_namespace="tagset"))),
+            self.assertEqual(len(list(cache.iter_record_and_targets(tagset_namespace="tagset"))),
                              total_tasks_count * tagset_tags_count // tags_count)
-            self.assertEqual(len(list(cache.iter_tag_and_targets(tagset_namespace="tagset", tagset_version="1.0.0"))),
-                             total_tasks_count * old_tagset_tags_count // tags_count)
+            self.assertEqual(
+                len(list(cache.iter_record_and_targets(tagset_namespace="tagset", tagset_version="1.0.0"))),
+                total_tasks_count * old_tagset_tags_count // tags_count,
+            )
 
     def test_tag_cache__clone(self):
         tag_names = [