plexus-python-pulse-common 1.1.75__py3-none-any.whl

plexus/pulse/common/utils/apiutils.py

@@ -0,0 +1,31 @@
+from contextlib import AbstractContextManager
+
+import sqlalchemy.orm as sa_orm
+from fastapi import HTTPException
+
+__all__ = [
+    "managed_db_session",
+]
+
+
+class DBSessionExceptionManager(AbstractContextManager):
+    def __init__(self, db: sa_orm.Session, commit_on_exit: bool):
+        self.db = db
+        self.commit_on_exit = commit_on_exit
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if isinstance(exc_type, HTTPException):
+            return False  # Propagate HTTPException
+        if exc_type is not None:
+            self.db.rollback()  # Raise a new HTTPException (or any other exception type)
+            raise HTTPException(status_code=500, detail=str(exc_value)) from exc_value
+        if self.commit_on_exit:
+            self.db.commit()
+        return True
+
+
+def managed_db_session(db: sa_orm.Session, commit_on_exit: bool = True) -> DBSessionExceptionManager:
+    return DBSessionExceptionManager(db, commit_on_exit)

plexus/pulse/common/utils/bagutils.py

@@ -0,0 +1,331 @@
+import contextlib
+import os
+from collections.abc import Generator
+from contextlib import AbstractContextManager
+from typing import Literal
+
+import sqlalchemy as sa
+import sqlalchemy.orm as sa_orm
+from plexus.common.utils.pathutils import make_path
+
+__all__ = [
+    "SerializationFormat",
+    "BagSchema",
+    "BagMetadata",
+    "BagMessageDefinition",
+    "BagTopic",
+    "BagMessage",
+    "BagReader",
+    "BagWriter",
+    "bag_reader",
+    "bag_writer",
+]
+
+SerializationFormat = Literal["cdr", "cdr2", "json", "yaml"]
+
+default_bag_db_file = "bag.db"
+
+
+class BagBase(sa_orm.DeclarativeBase):
+    pass
+
+
+class BagSchema(BagBase):
+    __tablename__ = "schema"
+
+    schema_version: sa_orm.Mapped[int] = sa_orm.mapped_column(sa.Integer, primary_key=True)
+    ros_distro: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.String, nullable=False)
+
+
+class BagMetadata(BagBase):
+    __tablename__ = "metadata"
+
+    id: sa_orm.Mapped[int] = sa_orm.mapped_column(sa.Integer, primary_key=True, autoincrement=True)
+    metadata_version: sa_orm.Mapped[int] = sa_orm.mapped_column(sa.Integer, nullable=False, unique=True)
+    metadata_text: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.String, nullable=False)
+
+
+class BagMessageDefinition(BagBase):
+    __tablename__ = "message_definitions"
+
+    id: sa_orm.Mapped[int] = sa_orm.mapped_column(sa.Integer, primary_key=True, autoincrement=True)
+    message_type: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.String, nullable=False, unique=True)
+    encoding: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.String, nullable=False)
+    encoded_message_definition: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.String, nullable=False)
+    type_description_hash: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.String, nullable=False)
+
+    topics: sa_orm.Mapped[list["BagTopic"]] = sa_orm.relationship("BagTopic", back_populates="message_definition")
+
+
+class BagTopic(BagBase):
+    __tablename__ = "topics"
+
+    id: sa_orm.Mapped[int] = sa_orm.mapped_column(sa.Integer, primary_key=True, autoincrement=True)
+    name: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.String, nullable=False, unique=True)
+    message_definition_id: sa_orm.Mapped[int] = sa_orm.mapped_column(sa.Integer,
+                                                                     sa.ForeignKey("message_definitions.id"),
+                                                                     nullable=False)
+    serialization_format: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.String, nullable=False)
+    type_description_hash: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.String, nullable=False)
+
+    messages: sa_orm.Mapped[list["BagMessage"]] = sa_orm.relationship("BagMessage", back_populates="topic")
+    message_definition: sa_orm.Mapped["BagMessageDefinition"] = sa_orm.relationship("BagMessageDefinition",
+                                                                                    back_populates="topics")
+
+
+class BagMessage(BagBase):
+    __tablename__ = "messages"
+
+    id: sa_orm.Mapped[int] = sa_orm.mapped_column(sa.Integer, primary_key=True, autoincrement=True)
+    topic_id: sa_orm.Mapped[int] = sa_orm.mapped_column(sa.Integer, sa.ForeignKey("topics.id"), nullable=False)
+    timestamp: sa_orm.Mapped[int] = sa_orm.mapped_column(sa.Integer, nullable=False)
+    data: sa_orm.Mapped[bytes] = sa_orm.mapped_column(sa.LargeBinary, nullable=False)
+
+    topic: sa_orm.Mapped["BagTopic"] = sa_orm.relationship("BagTopic", back_populates="messages")
+
+
+class BagIOBase(object):
+    def __init__(self, bag_file_path: str | os.PathLike[str]):
+        self.bag_file_path = make_path(bag_file_path)
+
+        self.engine: sa.Engine | None = None
+        self.session: sa_orm.Session | None = None
+
+        self.message_definitions_lookup: dict[str, int] = {}
+        self.topics_lookup: dict[str, int] = {}
+
+    @contextlib.contextmanager
+    def setup(self):
+        self.engine = sa.create_engine(f"sqlite:///{str(self.bag_file_path.absolute())}")
+        self.session = sa_orm.Session(self.engine)
+        try:
+            yield
+        finally:
+            self.message_definitions_lookup = {db_message_definition.message_type: db_message_definition.id
+                                               for db_message_definition in self.message_definitions()}
+            self.topics_lookup = {db_topic.name: db_topic.id for db_topic in self.topics()}
+
+    @contextlib.contextmanager
+    def teardown(self):
+        try:
+            yield
+        finally:
+            self.session.close()
+            self.engine.dispose()
+
+    def get_metadata(self, metadata_version: int) -> BagMetadata | None:
+        return (
+            self
+            .session
+            .query(BagMetadata)
+            .filter(BagMetadata.metadata_version == metadata_version)
+            .one_or_none()
+        )
+
+    def get_message_definition(self, message_type: str) -> BagMessageDefinition | None:
+        return (
+            self
+            .session
+            .query(BagMessageDefinition)
+            .filter(BagMessageDefinition.message_type == message_type)
+            .one_or_none()
+        )
+
+    def get_topic(self, name: str) -> BagTopic | None:
+        return self.session.query(BagTopic).filter(BagTopic.name == name).one_or_none()
+
+    def metadata(self) -> list[BagMetadata]:
+        return self.session.query(BagMetadata).all()
+
+    def message_definitions(self) -> list[BagMessageDefinition]:
+        return self.session.query(BagMessageDefinition).all()
+
+    def topics(self) -> list[BagTopic]:
+        return self.session.query(BagTopic).all()
+
+
+class BagReader(AbstractContextManager, BagIOBase):
+    @staticmethod
+    def open_ros2(db_dir: str | os.PathLike[str], db_filename: str = default_bag_db_file, **kwargs) -> "BagReader":
+        """
+        Creates a ``BagReader`` instance to read messages from a ROS2 bag file in the specified directory.
+
+        :param db_dir: path to the directory where the SQLite DB file is located.
+        :param db_filename: name of the SQLite DB file to read. Default is "bag.db".
+        :param kwargs: additional keyword arguments to pass to the ``BagReader`` constructor.
+        :return: a ``BagReader`` instance.
+        """
+        return BagReader(make_path(db_dir) / db_filename)
+
+    def __init__(self, bag_file_path: str | os.PathLike[str]):
+        """
+        Creates a ``BagReader`` instance to read messages from a ROS2 bag file.
+
+        :param bag_file_path: path to the SQLite DB file to read.
+        """
+        super().__init__(bag_file_path)
+
+        if not self.bag_file_path.exists():
+            raise FileNotFoundError(f"could not find SQLite DB at '{str(self.bag_file_path)}'")
+
+    def __enter__(self):
+        with self.setup():
+            pass
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        with self.teardown():
+            pass
+
+    def iter_messages(
+        self,
+        topic_names: list[str] | None = None,
+        begin_timestamp: int | None = None,
+        end_timestamp: int | None = None,
+        *,
+        batch_size: int = 1000,
+    ) -> Generator[BagMessage, None, None]:
+        query = self.session.query(BagMessage)
+        if topic_names is not None:
+            topic_ids = [topic_id for topic_name, topic_id in self.topics_lookup.items() if topic_name in topic_names]
+            query = query.where(BagMessage.topic_id.in_(topic_ids))
+        if begin_timestamp is not None:
+            query = query.where(BagMessage.timestamp >= begin_timestamp)
+        if end_timestamp is not None:
+            query = query.where(BagMessage.timestamp <= end_timestamp)
+
+        for db_message in query.order_by(BagMessage.timestamp.asc()).yield_per(batch_size):
+            yield db_message
+
+
+class BagWriter(AbstractContextManager, BagIOBase):
+    @staticmethod
+    def open_ros2(db_dir: str | os.PathLike[str], db_filename: str = default_bag_db_file, **kwargs) -> "BagWriter":
+        """
+        Creates a ``BagWriter`` instance to write messages to a ROS2 bag file in the specified directory.
+
+        :param db_dir: path to the directory where the SQLite DB file will be created.
+        :param db_filename: name of the SQLite DB file to create. Default is "bag.db".
+        :param kwargs: additional keyword arguments to pass to the ``BagWriter`` constructor.
+        :return: a ``BagWriter`` instance.
+        """
+        return BagWriter(make_path(db_dir) / db_filename, **kwargs)
+
+    def __init__(self, bag_file_path: str | os.PathLike[str], *, overwrite: bool = True, exist_ok: bool = False):
+        """
+        Creates a ``BagWriter`` instance to write messages to a ROS2 bag file.
+
+        :param bag_file_path: path to the SQLite DB file to create.
+        :param overwrite: whether to overwrite the SQLite DB file if it already exists. If ``False`` and the file
+                          already exists, a ``FileExistsError`` is raised. If ``True``, the existing file is deleted
+                          and a new one is created.
+        :param exist_ok: whether to ignore if the SQLite DB file already exists. If ``False`` and the file already
+                         exists, a ``FileExistsError`` is raised. If ``True``, the existing file is used and no new
+                         file is created.
+        """
+        super().__init__(bag_file_path)
+
+        if not self.bag_file_path.parent.exists():
+            self.bag_file_path.parent.mkdir(parents=True, exist_ok=True)
+        if self.bag_file_path.exists():
+            if not overwrite and not exist_ok:
+                raise FileExistsError(f"SQLite DB file already exists at '{str(self.bag_file_path)}'")
+            if overwrite:
+                self.bag_file_path.unlink()
+
+    def __enter__(self):
+        with self.setup():
+            BagBase.metadata.create_all(self.engine)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        with self.teardown():
+            if exc_type is None:
+                self.session.commit()
+            else:
+                self.session.rollback()
+
+    def add_metadata(self, metadata_version: int, metadata_text: str, *, return_existing: bool = False) -> BagMetadata:
+        if (db_metadata := self.get_metadata(metadata_version)) is not None:
+            if return_existing:
+                return db_metadata
+            raise ValueError(f"metadata with metadata_version '{metadata_version}' already exists in the bag file")
+
+        db_metadata = BagMetadata(metadata_version=metadata_version, metadata_text=metadata_text)
+        self.session.add(db_metadata)
+        self.session.flush()
+
+        return db_metadata
+
+    def add_message_definition(
+        self,
+        message_type: str,
+        encoding: str = "",
+        encoded_message_definition: str = "",
+        type_description_hash: str = "",
+        *,
+        return_existing: bool = False,
+    ) -> BagMessageDefinition:
+        if (db_message_definition := self.get_message_definition(message_type)) is not None:
+            if return_existing:
+                return db_message_definition
+            raise ValueError(f"message definition with message_type '{message_type}' already exists in the bag file")
+
+        db_message_definition = BagMessageDefinition(
+            message_type=message_type,
+            encoding=encoding,
+            encoded_message_definition=encoded_message_definition,
+            type_description_hash=type_description_hash,
+        )
+        self.session.add(db_message_definition)
+        self.session.flush()
+
+        self.message_definitions_lookup[db_message_definition.message_type] = db_message_definition.id
+
+        return db_message_definition
+
+    def add_topic(
+        self,
+        name: str,
+        message_type: str,
+        serialization_format: SerializationFormat = "cdr",
+        type_description_hash: str = "",
+        *,
+        return_existing: bool = False,
+    ) -> BagTopic:
+        message_definition_id = self.message_definitions_lookup.get(message_type)
+        if message_definition_id is None:
+            raise ValueError(f"message definition with message_type '{message_type}' does not exist in the bag file")
+
+        if (db_topic := self.get_topic(name)) is not None:
+            if return_existing:
+                return db_topic
+            raise ValueError(f"topic with name '{name}' already exists in the bag file")
+
+        db_topic = BagTopic(
+            name=name,
+            message_definition_id=message_definition_id,
+            serialization_format=serialization_format,
+            type_description_hash=type_description_hash,
+        )
+        self.session.add(db_topic)
+        self.session.flush()
+
+        self.topics_lookup[db_topic.name] = db_topic.id
+
+        return db_topic
+
+    def write_message(self, name: str, timestamp: int, data: bytes) -> BagMessage:
+        topic_id = self.topics_lookup.get(name)
+        if topic_id is None:
+            raise ValueError(f"topic with name '{name}' does not exist in the bag file")
+
+        db_message = BagMessage(topic_id=topic_id, timestamp=timestamp, data=data)
+        self.session.add(db_message)
+        self.session.flush()
+
+        return db_message
+
+
+bag_reader = BagReader
+bag_writer = BagWriter

plexus/pulse/common/utils/config.py

@@ -0,0 +1,63 @@
+import os
+
+from plexus.common.utils import logger
+from plexus.common.utils.config import Config
+from plexus.common.utils.funcutils import memorized
+from plexus.common.utils.pathutils import make_path
+
+
+@memorized()
+def config(config_path: str | os.PathLike[str] = "") -> Config:
+    default_items: list[tuple[str, str, str]] = [
+        ("plexus", "logging.level", "INFO"),
+        ("plexus", "logging.format", "%(asctime)s [%(levelname)s] %(name)s: %(message)s"),
+    ]
+
+    instance = Config(config_path or make_path("~/.plexus.cfg", expand=True, normalize=True, absolute=True))
+    instance.restore()
+    instance.update(default_items, overwrite=False)
+
+    return instance
+
+
+def config_print_or_set(config: Config, section: str, key: str, value: str):
+    if value is not None:
+        if section is None or key is None:
+            raise ValueError("cannot specify value without section and key")
+
+        old_value = config.get(section, key)
+        config.set(section, key, value)
+        config.persist()
+
+        print(f"Configuration file '{config.config_path}'", )
+        print(f"Section <{section}>")
+        print(f"  {key} = {old_value} -> {value}")
+
+    else:
+        if section is None and key is None:
+            print(f"Configuration file '{config.config_path}'", )
+            for section in config.config_parser.sections():
+                print(f"Section <{section}>")
+                for key, value in config.config_parser.items(section):
+                    print(f"  {key} = {value}")
+
+        elif section is not None and key is None:
+            if not config.has_section(section):
+                logger.warning("Configuration section '%s' not found", section)
+                return
+            print(f"Configuration file '{config.config_path}'", )
+            print(f"Section <{section}>")
+            for key, value in config.config_parser.items(section):
+                print(f"  {key} = {value}")
+
+        elif section is not None and key is not None:
+            value = config.get(section, key)
+            if value is None:
+                logger.warning("Configuration section '%s' key '%s' not found", section, key)
+                return
+            print(f"Configuration file '{config.config_path}'", )
+            print(f"Section <{section}>")
+            print(f"  {key} = {value}")
+
+        else:
+            raise ValueError("cannot specify key without section")

plexus/pulse/common/utils/datautils.py

@@ -0,0 +1,233 @@
+import datetime
+from collections.abc import Callable, Generator
+from typing import Any
+
+import pyparsing as pp
+import ujson as json
+from plexus.common.utils.funcutils import singleton
+from plexus.common.utils.jsonutils import JsonType
+from plexus.common.utils.randutils import randomizer
+
+from plexus.pulse.common.utils.strutils import BagName, UserName, VehicleName
+from plexus.pulse.common.utils.strutils import colon_tag_parser, slash_tag_parser
+from plexus.pulse.common.utils.strutils import dot_case_parser, kebab_case_parser, snake_case_parser
+from plexus.pulse.common.utils.strutils import hex_string_parser
+from plexus.pulse.common.utils.strutils import parse_bag_name, parse_user_name, parse_vehicle_name
+from plexus.pulse.common.utils.strutils import semver_parser, uuid_parser
+from plexus.pulse.common.utils.strutils import strict_abspath_parser, strict_relpath_parser
+from plexus.pulse.common.utils.strutils import strict_fragmented_abspath_parser, strict_fragmented_relpath_parser
+from plexus.pulse.common.utils.strutils import topic_parser, vin_code_chars, vin_code_parser
+
+__all__ = [
+    "compute_vin_code_check_digit",
+    "validate_hex_string",
+    "validate_snake_case",
+    "validate_kebab_case",
+    "validate_dot_case",
+    "validate_uuid",
+    "validate_strict_relpath",
+    "validate_strict_abspath",
+    "validate_strict_fragmented_relpath",
+    "validate_strict_fragmented_abspath",
+    "validate_semver",
+    "validate_colon_tag",
+    "validate_slash_tag",
+    "validate_topic",
+    "validate_vin_code",
+    "validate_user_name",
+    "validate_vehicle_name",
+    "validate_bag_name",
+    "validate_dt_timezone",
+    "validate_json_type_dump_size",
+    "random_vin_code",
+    "known_topics",
+    "known_user_names",
+    "known_vehicle_names",
+    "random_bag_names_sequence",
+]
+
+
+def make_compute_vin_code_check_digit() -> Callable[[str], str]:
+    trans_nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 7, 9, 2, 3, 4, 5, 6, 7, 8, 9]
+    weights = [8, 7, 6, 5, 4, 3, 2, 10, 0, 9, 8, 7, 6, 5, 4, 3, 2]
+
+    trans_dict = {vin_code_char: trans_num for vin_code_char, trans_num in zip(vin_code_chars, trans_nums)}
+
+    def func(vin_code: str) -> str:
+        remainder = sum(trans_dict[vin_code_char] * weight for vin_code_char, weight in zip(vin_code, weights)) % 11
+        return "X" if remainder == 10 else str(remainder)
+
+    return func
+
+
+compute_vin_code_check_digit = make_compute_vin_code_check_digit()
+
+
+def make_validate_string(element: pp.ParserElement) -> Callable[[str], None]:
+    def func(s: str) -> None:
+        try:
+            if not element.parse_string(s, parse_all=True):
+                raise ValueError(f"failed to parse '{s}'")
+        except Exception as e:
+            raise ValueError(f"encountered error while parsing '{s}'") from e
+
+    return func
+
+
+validate_hex_string = make_validate_string(hex_string_parser)
+
+validate_snake_case = make_validate_string(snake_case_parser)
+validate_kebab_case = make_validate_string(kebab_case_parser)
+validate_dot_case = make_validate_string(dot_case_parser)
+
+validate_uuid = make_validate_string(uuid_parser)
+
+validate_strict_relpath = make_validate_string(strict_relpath_parser)
+validate_strict_abspath = make_validate_string(strict_abspath_parser)
+validate_strict_fragmented_relpath = make_validate_string(strict_fragmented_relpath_parser)
+validate_strict_fragmented_abspath = make_validate_string(strict_fragmented_abspath_parser)
+
+validate_semver = make_validate_string(semver_parser)
+
+validate_colon_tag = make_validate_string(colon_tag_parser)
+validate_slash_tag = make_validate_string(slash_tag_parser)
+
+validate_topic = make_validate_string(topic_parser)
+
+
+def validate_vin_code(vin_code: str):
+    make_validate_string(vin_code_parser)(vin_code)
+    check_digit = compute_vin_code_check_digit(vin_code)
+    if check_digit != vin_code[8]:
+        raise ValueError(f"get wrong VIN code check digit from '{vin_code}', expected '{check_digit}'")
+
+
+def make_validate_parse_string(parse: Callable[[str], Any]) -> Callable[[str], None]:
+    def func(s: str) -> None:
+        try:
+            if not parse(s):
+                raise ValueError(f"failed to parse '{s}'")
+        except Exception as e:
+            raise ValueError(f"encountered error while parsing '{s}'") from e
+
+    return func
+
+
+validate_user_name = make_validate_parse_string(parse_user_name)
+validate_vehicle_name = make_validate_parse_string(parse_vehicle_name)
+validate_bag_name = make_validate_parse_string(parse_bag_name)
+
+
+def validate_dt_timezone(dt: datetime.datetime, *, allow_naive: bool = False):
+    if allow_naive and dt.tzinfo is None:
+        return
+    if dt.tzinfo != datetime.timezone.utc:
+        raise ValueError(f"dt '{dt}' is not in UTC")
+
+
+def validate_json_type_dump_size(json_type: JsonType, dump_size_limit: int = 10000):
+    dump_string = json.dumps(json_type, ensure_ascii=False)
+    if len(dump_string) > dump_size_limit:
+        raise ValueError(f"dump size exceeds the maximum length '{dump_size_limit}'")
+
+
+def random_vin_code() -> str:
+    vin_code = randomizer().random_string(vin_code_chars, 17)
+    check_digit = compute_vin_code_check_digit(vin_code)
+    return vin_code[:8] + check_digit + vin_code[9:]
+
+
+@singleton
+def known_topics() -> list[str]:
+    return [
+        "/sensor/camera/front_center",
+        "/sensor/camera/front_left",
+        "/sensor/camera/front_right",
+        "/sensor/camera/side_left",
+        "/sensor/camera/side_right",
+        "/sensor/camera/rear_left",
+        "/sensor/camera/rear_right",
+        "/sensor/lidar/front_center",
+        "/sensor/lidar/front_left_corner",
+        "/sensor/lidar/front_right_corner",
+        "/sensor/lidar/side_left",
+        "/sensor/lidar/side_right",
+    ]
+
+
+@singleton
+def known_user_names() -> list[UserName]:
+    return [
+        UserName("adam", "anderson"),
+        UserName("ben", "bennett"),
+        UserName("charlie", "clark"),
+        UserName("david", "dixon"),
+        UserName("evan", "edwards"),
+        UserName("frank", "fisher"),
+        UserName("george", "graham"),
+        UserName("henry", "harrison"),
+        UserName("isaac", "irving"),
+        UserName("jack", "jacobs"),
+        UserName("kevin", "kennedy"),
+        UserName("luke", "lawson"),
+        UserName("michael", "mitchell"),
+        UserName("nathan", "newton"),
+        UserName("oscar", "owens"),
+        UserName("paul", "peterson"),
+        UserName("quincy", "quinn"),
+        UserName("ryan", "robinson"),
+        UserName("sam", "stevens"),
+        UserName("tom", "thomas"),
+        UserName("umar", "underwood"),
+        UserName("victor", "vaughan"),
+        UserName("william", "walker"),
+        UserName("xander", "xavier"),
+        UserName("yale", "young"),
+        UserName("zane", "zimmerman"),
+    ]
+
+
+@singleton
+def known_vehicle_names() -> list[VehicleName]:
+    return [
+        VehicleName("cascadia", "antelope", "00000", "3AKJGLD5XLS000000"),
+        VehicleName("cascadia", "bear", "00001", "3AKJGLD51LS000001"),
+        VehicleName("cascadia", "cheetah", "00002", "3AKJGLD53LS000002"),
+        VehicleName("cascadia", "dolphin", "00003", "3AKJGLD55LS000003"),
+        VehicleName("cascadia", "eagle", "00004", "3AKJGLD57LS000004"),
+        VehicleName("cascadia", "falcon", "00005", "3AKJGLD59LS000005"),
+        VehicleName("cascadia", "gorilla", "00006", "3AKJGLD50LS000006"),
+        VehicleName("cascadia", "hawk", "00007", "3AKJGLD52LS000007"),
+        VehicleName("cascadia", "iguana", "00008", "3AKJGLD54LS000008"),
+        VehicleName("cascadia", "jaguar", "00009", "3AKJGLD56LS000009"),
+        VehicleName("cascadia", "koala", "00010", "3AKJGLD52LS000010"),
+        VehicleName("cascadia", "leopard", "00011", "3AKJGLD54LS000011"),
+        VehicleName("cascadia", "mongoose", "00012", "3AKJGLD56LS000012"),
+        VehicleName("cascadia", "narwhal", "00013", "3AKJGLD58LS000013"),
+        VehicleName("cascadia", "otter", "00014", "3AKJGLD5XLS000014"),
+        VehicleName("cascadia", "panther", "00015", "3AKJGLD51LS000015"),
+        VehicleName("cascadia", "quail", "00016", "3AKJGLD53LS000016"),
+        VehicleName("cascadia", "rhino", "00017", "3AKJGLD55LS000017"),
+        VehicleName("cascadia", "snake", "00018", "3AKJGLD57LS000018"),
+        VehicleName("cascadia", "tiger", "00019", "3AKJGLD59LS000019"),
+        VehicleName("cascadia", "urial", "00020", "3AKJGLD55LS000020"),
+        VehicleName("cascadia", "vulture", "00021", "3AKJGLD57LS000021"),
+        VehicleName("cascadia", "wolf", "00022", "3AKJGLD59LS000022"),
+        VehicleName("cascadia", "xerus", "00023", "3AKJGLD50LS000023"),
+        VehicleName("cascadia", "yak", "00024", "3AKJGLD52LS000024"),
+        VehicleName("cascadia", "zebra", "00025", "3AKJGLD54LS000025"),
+    ]
+
+
+def random_bag_names_sequence(
+    min_record_dt: datetime.datetime,
+    max_record_dt: datetime.datetime,
+    min_sequence_length: int,
+    max_sequence_length: int,
+) -> Generator[BagName, None, None]:
+    vehicle_name = randomizer().choose(known_vehicle_names())
+    record_dt = randomizer().random_datetime(begin=min_record_dt, end=max_record_dt)
+    bags_count = randomizer().next_int(min_sequence_length, max_sequence_length)
+
+    for record_sn in range(bags_count):
+        yield BagName(vehicle_name=vehicle_name, record_dt=record_dt, record_sn=record_sn)