plexus-python-common 1.0.15__tar.gz → 1.0.17__tar.gz

{plexus_python_common-1.0.15 → plexus_python_common-1.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-common
-Version: 1.0.15
+Version: 1.0.17
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{plexus_python_common-1.0.15 → plexus_python_common-1.0.17}/src/plexus/common/utils/bagutils.py

@@ -3,11 +3,8 @@ from collections.abc import Generator
 from contextlib import AbstractContextManager
 from typing import Literal
 
-import sqlalchemy
-from sqlalchemy import ForeignKey, Integer, LargeBinary, String
-from sqlalchemy import select
-from sqlalchemy.orm import DeclarativeBase, Mapped, Session
-from sqlalchemy.orm import mapped_column, relationship
+import sqlalchemy as sa
+import sqlalchemy.orm as sa_orm
 
 __all__ = [
     "SerializationFormat",
@@ -27,56 +24,56 @@ SerializationFormat = Literal["cdr", "cdr2", "json", "yaml"]
 default_bag_db_file = "bag.db"
 
 
-class BagBase(DeclarativeBase):
+class BagBase(sa_orm.DeclarativeBase):
     pass
 
 
 class BagSchema(BagBase):
     __tablename__ = "schema"
 
-    schema_version: Mapped[int] = mapped_column(Integer, primary_key=True)
-    ros_distro: Mapped[str] = mapped_column(String, nullable=False)
+    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: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    metadata_version: Mapped[int] = mapped_column(Integer, nullable=False)
-    metadata_text: Mapped[str] = mapped_column(String, nullable=False)
+    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)
+    metadata_text: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.String, nullable=False)
 
 
 class BagTopic(BagBase):
     __tablename__ = "topics"
 
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    name: Mapped[str] = mapped_column(String, nullable=False)
-    type: Mapped[str] = mapped_column(String, nullable=False)
-    serialization_format: Mapped[str] = mapped_column(String, nullable=False)
-    type_description_hash: Mapped[str] = mapped_column(String, nullable=False)
+    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)
+    type: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.String, 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: Mapped[list["BagMessage"]] = relationship("BagMessage", back_populates="topic")
+    messages: sa_orm.Mapped[list["BagMessage"]] = sa_orm.relationship("BagMessage", back_populates="topic")
 
 
 class BagMessageDefinition(BagBase):
     __tablename__ = "message_definitions"
 
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    topic_type: Mapped[str] = mapped_column(String, nullable=False)
-    encoding: Mapped[str] = mapped_column(String, nullable=False)
-    encoded_message_definition: Mapped[str] = mapped_column(String, nullable=False)
-    type_description_hash: Mapped[str] = mapped_column(String, nullable=False)
+    id: sa_orm.Mapped[int] = sa_orm.mapped_column(sa.Integer, primary_key=True, autoincrement=True)
+    topic_type: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.String, nullable=False)
+    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)
 
 
 class BagMessage(BagBase):
     __tablename__ = "messages"
 
-    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
-    topic_id: Mapped[int] = mapped_column(Integer, ForeignKey("topics.id"), nullable=False)
-    timestamp: Mapped[int] = mapped_column(Integer, nullable=False)
-    data: Mapped[bytes] = mapped_column(LargeBinary, nullable=False)
+    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: Mapped["BagTopic"] = relationship("BagTopic", back_populates="messages")
+    topic: sa_orm.Mapped["BagTopic"] = sa_orm.relationship("BagTopic", back_populates="messages")
 
 
 class BagReader(AbstractContextManager):
@@ -85,8 +82,8 @@ class BagReader(AbstractContextManager):
         if not os.path.exists(self.db_path):
             raise FileNotFoundError(f"could not find SQLite DB at '{db_dir}'")
 
-        self.engine = sqlalchemy.create_engine(f"sqlite:///{self.db_path}")
-        self.session = Session(self.engine)
+        self.engine = sa.create_engine(f"sqlite:///{self.db_path}")
+        self.session = sa_orm.Session(self.engine)
         self.topic_map = None
 
     def __enter__(self):
@@ -101,7 +98,7 @@ class BagReader(AbstractContextManager):
 
     def get_topics(self) -> dict[str, BagTopic]:
         if self.topic_map is None:
-            stmt = select(BagTopic)
+            stmt = sa.select(BagTopic)
             self.topic_map = {db_topic.name: db_topic for db_topic in self.session.scalars(stmt).all()}
         return self.topic_map
 
@@ -111,7 +108,7 @@ class BagReader(AbstractContextManager):
         begin_timestamp: int | None = None,
         end_timestamp: int | None = None,
     ) -> Generator[BagMessage, None, None]:
-        stmt = select(BagMessage)
+        stmt = sa.select(BagMessage)
         if topic_names is not None:
             topic_ids = [db_topic.id for db_topic in self.get_topics().values() if db_topic.name in topic_names]
             stmt = stmt.where(BagMessage.topic_id.in_(topic_ids))
@@ -129,8 +126,8 @@ class BagWriter(AbstractContextManager):
         if os.path.exists(self.db_path):
             os.remove(self.db_path)
 
-        self.engine = sqlalchemy.create_engine(f"sqlite:///{self.db_path}")
-        self.session = sqlalchemy.orm.Session(self.engine)
+        self.engine = sa.create_engine(f"sqlite:///{self.db_path}")
+        self.session = sa_orm.Session(self.engine)
         self.topic_map = {}
 
         BagBase.metadata.create_all(self.engine)

{plexus_python_common-1.0.15 → plexus_python_common-1.0.17}/src/plexus/common/utils/ormutils.py

@@ -36,6 +36,7 @@ __all__ = [
     "clone_record_model_instance",
     "clone_snapshot_model_instance",
     "make_snapshot_model_trigger",
+    "db_make_order_by_clause",
     "db_create_serial_model",
     "db_create_serial_models",
     "db_read_serial_model",
@@ -162,8 +163,7 @@ class SerialModelMixinProtocol(Protocol):
     sid: int | None
 
 
-class RecordModelMixinProtocol(Protocol):
-    sid: int | None
+class RecordModelMixinProtocol(SerialModelMixinProtocol):
     created_at: datetime.datetime | None
     updated_at: datetime.datetime | None
 
@@ -177,8 +177,7 @@ class RecordModelMixinProtocol(Protocol):
         ...
 
 
-class SnapshotModelMixinProtocol(Protocol):
-    sid: int | None
+class SnapshotModelMixinProtocol(SerialModelMixinProtocol):
     created_at: datetime.datetime | None
     expired_at: datetime.datetime | None
     record_sid: int | None
@@ -388,13 +387,18 @@ class SnapshotModel(make_base_model(), make_snapshot_model_mixin(), table=True):
     pass
 
 
+SerialModelT = TypeVar("SerialModelT", bound=SerialModelMixin)
+RecordModelT = TypeVar("RecordModelT", bound=RecordModelMixin)
+SnapshotModelT = TypeVar("SnapshotModelT", bound=SnapshotModelMixin)
+
+
 def clone_serial_model_instance(
-    model: type[SerialModelMixin],
+    model: type[SerialModelT],
     instance: SerialModelMixin,
     *,
     clear_meta_fields: bool = True,
     inplace: bool = False,
-) -> SerialModelMixin:
+) -> SerialModelT:
     result = model.model_validate(instance)
     result = instance if inplace else result
     if clear_meta_fields:
@@ -403,12 +407,12 @@ def clone_serial_model_instance(
 
 
 def clone_record_model_instance(
-    model: type[RecordModelMixin],
+    model: type[RecordModelT],
     instance: RecordModelMixin,
     *,
     clear_meta_fields: bool = True,
     inplace: bool = False,
-) -> RecordModelMixin:
+) -> RecordModelT:
     result = model.model_validate(instance)
     result = instance if inplace else result
     if clear_meta_fields:
@@ -419,12 +423,12 @@ def clone_record_model_instance(
 
 
 def clone_snapshot_model_instance(
-    model: type[SnapshotModelMixin],
+    model: type[SnapshotModelT],
     instance: SnapshotModelMixin,
     *,
     clear_meta_fields: bool = True,
     inplace: bool = False,
-) -> SnapshotModelMixin:
+) -> SnapshotModelT:
     result = model.model_validate(instance)
     result = instance if inplace else result
     if clear_meta_fields:
@@ -500,35 +504,48 @@ def make_snapshot_model_trigger(engine: sa.Engine, model: type[SQLModel]):
             conn.execute(sa.text(create_snapshot_auto_update_trigger_sql))
 
 
+def db_make_order_by_clause(model: type[SerialModelT], order_by: list[str] = None):
+    order_criteria = []
+    if order_by:
+        for field in order_by:
+            if field.startswith("-"):
+                order_criteria.append(sa.desc(getattr(model, field[1:])))
+            else:
+                order_criteria.append(sa.asc(getattr(model, field)))
+    else:
+        order_criteria.append(model.sid)
+    return order_criteria
+
+
 def db_create_serial_model(
     db: sa_orm.Session,
-    model: type[SerialModelMixin],
+    model: type[SerialModelT],
     instance: SerialModelMixin,
-) -> SerialModelMixin:
-    with db.begin(nested=db.in_transaction()):
-        db_instance = clone_serial_model_instance(model, instance)
-        db.add(db_instance)
+) -> SerialModelT:
+    db_instance = clone_serial_model_instance(model, instance)
+    db.add(db_instance)
+    db.flush()
 
     return db_instance
 
 
 def db_create_serial_models(
     db: sa_orm.Session,
-    model: type[SerialModelMixin],
+    model: type[SerialModelT],
     instances: list[SerialModelMixin],
-) -> list[SerialModelMixin]:
-    with db.begin(nested=db.in_transaction()):
-        db_instances = [clone_serial_model_instance(model, instance) for instance in instances]
-        db.bulk_save_objects(db_instances, return_defaults=True)
+) -> list[SerialModelT]:
+    db_instances = [clone_serial_model_instance(model, instance) for instance in instances]
+    db.add_all(db_instances)
+    db.flush()
 
     return db_instances
 
 
 def db_read_serial_model(
     db: sa_orm.Session,
-    model: type[SerialModelMixin],
+    model: type[SerialModelT],
     sid: int,
-) -> SerialModelMixin:
+) -> SerialModelT:
     db_instance = db.query(model).where(model.sid == sid).one_or_none()
     if db_instance is None:
         raise sa_exc.NoResultFound(f"'{model}' of specified sid '{sid}' not found")
@@ -538,136 +555,139 @@ def db_read_serial_model(
 
 def db_read_serial_models(
     db: sa_orm.Session,
-    model: type[SerialModelMixin],
+    model: type[SerialModelT],
     skip: int,
     limit: int,
-) -> list[SerialModelMixin]:
-    return db.query(model).order_by(model.sid).offset(skip).limit(limit).all()
+    order_by: list[str] = None,
+) -> list[SerialModelT]:
+    return db.query(model).order_by(*db_make_order_by_clause(model, order_by)).offset(skip).limit(limit).all()
 
 
 def db_update_serial_model(
     db: sa_orm.Session,
-    model: type[SerialModelMixin],
+    model: type[SerialModelT],
     instance: SerialModelMixin,
-) -> SerialModelMixin:
-    with db.begin(nested=db.in_transaction()):
-        db_instance = db.query(model).where(model.sid == instance.sid).one_or_none()
-        if db_instance is None:
-            raise sa_exc.NoResultFound(f"'{model}' of specified sid '{instance.sid}' not found")
+    sid: int,
+) -> SerialModelT:
+    db_instance = db.query(model).where(model.sid == sid).one_or_none()
+    if db_instance is None:
+        raise sa_exc.NoResultFound(f"'{model}' of specified sid '{sid}' not found")
 
-        db_instance = model_copy_from(db_instance, instance, exclude_none=True)
-        db_instance = clone_serial_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    db_instance = model_copy_from(db_instance, clone_serial_model_instance(model, instance), exclude_none=True)
+    db_instance = clone_serial_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    db.flush()
 
     return db_instance
 
 
 def db_delete_serial_model(
     db: sa_orm.Session,
-    model: type[SerialModelMixin],
+    model: type[SerialModelT],
     sid: int,
-) -> SerialModelMixin:
-    with db.begin(nested=db.in_transaction()):
-        db_instance = db.query(model).where(model.sid == sid).one_or_none()
-        if db_instance is None:
-            raise sa_exc.NoResultFound(f"'{model}' of specified sid '{sid}' not found")
+) -> SerialModelT:
+    db_instance = db.query(model).where(model.sid == sid).one_or_none()
+    if db_instance is None:
+        raise sa_exc.NoResultFound(f"'{model}' of specified sid '{sid}' not found")
 
-        db.delete(db_instance)
+    db.delete(db_instance)
+    db.flush()
 
     return db_instance
 
 
 def db_create_record_model(
     db: sa_orm.Session,
-    model: type[RecordModelMixin],
+    model: type[RecordModelT],
     instance: RecordModelMixin,
     created_at: datetime.datetime | None = None,
-) -> RecordModelMixin:
-    with db.begin(nested=db.in_transaction()):
-        db_instance = clone_record_model_instance(model, instance)
-        db_instance.created_at = created_at
-        db_instance.updated_at = created_at
-        db.add(db_instance)
+) -> RecordModelT:
+    db_instance = clone_record_model_instance(model, instance)
+    db_instance.created_at = created_at
+    db_instance.updated_at = created_at
+    db.add(db_instance)
+    db.flush()
 
     return db_instance
 
 
 def db_create_record_models(
     db: sa_orm.Session,
-    model: type[RecordModelMixin],
+    model: type[RecordModelT],
     instances: list[RecordModelMixin],
     created_at: datetime.datetime | None = None,
-) -> list[RecordModelMixin]:
-    with db.begin(nested=db.in_transaction()):
-        db_instances = [clone_record_model_instance(model, instance) for instance in instances]
-        for db_instance in db_instances:
-            db_instance.created_at = created_at
-            db_instance.updated_at = created_at
-        db.bulk_save_objects(db_instances, return_defaults=True)
+) -> list[RecordModelT]:
+    db_instances = [clone_record_model_instance(model, instance) for instance in instances]
+    for db_instance in db_instances:
+        db_instance.created_at = created_at
+        db_instance.updated_at = created_at
+    db.add_all(db_instances)
+    db.flush()
 
     return db_instances
 
 
 def db_update_record_model(
     db: sa_orm.Session,
-    model: type[RecordModelMixin],
+    model: type[RecordModelT],
     instance: RecordModelMixin,
     sid: int,
     updated_at: datetime.datetime,
-) -> RecordModelMixin:
-    with db.begin(nested=db.in_transaction()):
-        db_instance = db.query(model).where(model.sid == sid).one_or_none()
-        if db_instance is None:
-            raise sa_exc.NoResultFound(f"'{model}' of specified sid '{sid}' not found")
+) -> RecordModelT:
+    db_instance = db.query(model).where(model.sid == sid).one_or_none()
+    if db_instance is None:
+        raise sa_exc.NoResultFound(f"'{model}' of specified sid '{sid}' not found")
 
-        db_instance = model_copy_from(db_instance, instance, exclude_none=True)
-        db_instance.updated_at = updated_at
-        db_instance = clone_record_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    db_instance = model_copy_from(db_instance, clone_record_model_instance(model, instance), exclude_none=True)
+    db_instance.updated_at = updated_at
+    db_instance = clone_record_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    db.flush()
 
     return db_instance
 
 
 def db_create_snapshot_model(
     db: sa_orm.Session,
-    model: type[SnapshotModelMixin],
+    model: type[SnapshotModelT],
     instance: SnapshotModelMixin,
     created_at: datetime.datetime,
-) -> SnapshotModelMixin:
-    with db.begin(nested=db.in_transaction()):
-        db_instance = clone_snapshot_model_instance(model, instance)
+) -> SnapshotModelT:
+    db_instance = clone_snapshot_model_instance(model, instance)
+    db_instance.created_at = created_at
+    db_instance.expired_at = None
+    db.add(db_instance)
+    db.flush()
 
-        db_instance.created_at = created_at
-        db_instance.expired_at = None
-        db.add(db_instance)
-        db.flush([db_instance])
-        db_instance.record_sid = db_instance.sid
+    db_instance.record_sid = db_instance.sid
+    db.flush()
 
     return db_instance
 
 
 def db_create_snapshot_models(
     db: sa_orm.Session,
-    model: type[SnapshotModelMixin],
+    model: type[SnapshotModelT],
     instances: list[SnapshotModelMixin],
     created_at: datetime.datetime,
-) -> list[SnapshotModelMixin]:
-    with db.begin(nested=db.in_transaction()):
-        db_instances = [clone_snapshot_model_instance(model, instance) for instance in instances]
-        for db_instance in db_instances:
-            db_instance.created_at = created_at
-            db_instance.expired_at = None
-        db.bulk_save_objects(db_instances, return_defaults=True)
-        db.flush(db_instances)
-        for db_instance in db_instances:
-            db_instance.record_sid = db_instance.sid
+) -> list[SnapshotModelT]:
+    db_instances = [clone_snapshot_model_instance(model, instance) for instance in instances]
+    for db_instance in db_instances:
+        db_instance.created_at = created_at
+        db_instance.expired_at = None
+    db.add_all(db_instances)
+    db.flush()
+
+    for db_instance in db_instances:
+        db_instance.record_sid = db_instance.sid
+    db.flush()
 
     return db_instances
 
 
 def db_read_snapshot_models_of_record(
     db: sa_orm.Session,
-    model: type[SnapshotModelMixin],
+    model: type[SnapshotModelT],
     record_sid: int,
-) -> list[SnapshotModelMixin]:
+) -> list[SnapshotModelT]:
     return (
         db
         .query(model)
@@ -679,9 +699,9 @@ def db_read_snapshot_models_of_record(
 
 def db_read_latest_snapshot_model_of_record(
     db: sa_orm.Session,
-    model: type[SnapshotModelMixin],
+    model: type[SnapshotModelT],
     record_sid: int,
-) -> SnapshotModelMixin:
+) -> SnapshotModelT:
     db_instance = (
         db
         .query(model)
@@ -697,9 +717,9 @@ def db_read_latest_snapshot_model_of_record(
 
 def db_read_active_snapshot_model_of_record(
     db: sa_orm.Session,
-    model: type[SnapshotModelMixin],
+    model: type[SnapshotModelT],
     record_sid: int,
-) -> SnapshotModelMixin:
+) -> SnapshotModelT:
     db_instance = db.query(model).where(model.record_sid == record_sid, model.expired_at.is_(None)).one_or_none()
     if db_instance is None:
         raise sa_exc.NoResultFound(f"Active '{model}' of specified record_sid '{record_sid}' not found")
@@ -709,24 +729,25 @@ def db_read_active_snapshot_model_of_record(
 
 def db_read_expired_snapshot_models_of_record(
     db: sa_orm.Session,
-    model: type[SnapshotModelMixin],
+    model: type[SnapshotModelT],
     record_sid: int,
-) -> list[SnapshotModelMixin]:
+) -> list[SnapshotModelT]:
     return (
         db
         .query(model)
         .where(model.record_sid == record_sid, model.expired_at.is_not(None))
-        .order_by(model.expired_at.desc())
+        .order_by(model.created_at.desc())
         .all()
     )
 
 
 def db_read_latest_snapshot_models(
     db: sa_orm.Session,
-    model: type[SnapshotModelMixin],
+    model: type[SnapshotModelT],
     skip: int,
     limit: int,
-) -> list[SnapshotModelMixin]:
+    order_by: list[str] = None,
+) -> list[SnapshotModelT]:
     subquery = (
         db
         .query(model.record_sid,
@@ -740,7 +761,7 @@ def db_read_latest_snapshot_models(
         .query(model)
         .join(subquery,
               sa.and_(model.record_sid == subquery.c.record_sid, model.created_at == subquery.c.max_created_at))
-        .order_by(model.record_sid)
+        .order_by(*db_make_order_by_clause(model, order_by))
         .offset(skip)
         .limit(limit)
         .all()
@@ -749,88 +770,97 @@ def db_read_latest_snapshot_models(
 
 def db_read_active_snapshot_models(
     db: sa_orm.Session,
-    model: type[SnapshotModelMixin],
+    model: type[SnapshotModelT],
     skip: int,
     limit: int,
-) -> list[SnapshotModelMixin]:
-    return db.query(model).where(model.expired_at.is_(None)).offset(skip).limit(limit).all()
+    order_by: list[str] = None,
+) -> list[SnapshotModelT]:
+    return (
+        db
+        .query(model)
+        .where(model.expired_at.is_(None))
+        .order_by(*db_make_order_by_clause(model, order_by))
+        .offset(skip)
+        .limit(limit)
+        .all()
+    )
 
 
 def db_update_snapshot_model(
     db: sa_orm.Session,
-    model: type[SnapshotModelMixin],
+    model: type[SnapshotModelT],
     instance: SnapshotModelMixin,
     record_sid: int,
     updated_at: datetime.datetime,
-) -> SnapshotModelMixin:
-    with db.begin(nested=db.in_transaction()):
-        db_instance = db.query(model).where(model.record_sid == record_sid, model.expired_at.is_(None)).one_or_none()
-        if db_instance is None:
-            raise sa_exc.NoResultFound(f"Active '{model}' of specified record_sid '{record_sid}' not found")
+) -> SnapshotModelT:
+    db_instance = db.query(model).where(model.record_sid == record_sid, model.expired_at.is_(None)).one_or_none()
+    if db_instance is None:
+        raise sa_exc.NoResultFound(f"Active '{model}' of specified record_sid '{record_sid}' not found")
 
-        db_instance.expired_at = updated_at
-        db_instance = clone_snapshot_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    db_instance.expired_at = updated_at
+    db_instance = clone_snapshot_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    db.flush()
 
-        db_new_instance = clone_snapshot_model_instance(model, instance)
-        db_new_instance.record_sid = record_sid
-        db_new_instance.created_at = updated_at
-        db_new_instance.expired_at = None
-        db.add(db_new_instance)
+    db_new_instance = clone_snapshot_model_instance(model, instance)
+    db_new_instance.record_sid = record_sid
+    db_new_instance.created_at = updated_at
+    db_new_instance.expired_at = None
+    db.add(db_new_instance)
+    db.flush()
 
     return db_new_instance
 
 
 def db_expire_snapshot_model(
     db: sa_orm.Session,
-    model: type[SnapshotModelMixin],
+    model: type[SnapshotModelT],
     record_sid: int,
     updated_at: datetime.datetime,
-) -> SnapshotModelMixin:
-    with db.begin(nested=db.in_transaction()):
-        db_instance = (
-            db
-            .query(model)
-            .where(model.record_sid == record_sid, model.expired_at.is_(None))
-            .one_or_none()
-        )
-        if db_instance is None:
-            raise sa_exc.NoResultFound(f"Active '{model}' of specified record_sid '{record_sid}' not found")
+) -> SnapshotModelT:
+    db_instance = (
+        db
+        .query(model)
+        .where(model.record_sid == record_sid, model.expired_at.is_(None))
+        .one_or_none()
+    )
+    if db_instance is None:
+        raise sa_exc.NoResultFound(f"Active '{model}' of specified record_sid '{record_sid}' not found")
 
-        db_instance.expired_at = updated_at
-        db_instance = clone_snapshot_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    db_instance.expired_at = updated_at
+    db_instance = clone_snapshot_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    db.flush()
 
     return db_instance
 
 
 def db_activate_snapshot_model(
     db: sa_orm.Session,
-    model: type[SnapshotModelMixin],
+    model: type[SnapshotModelT],
     record_sid: int,
     updated_at: datetime.datetime,
-) -> SnapshotModelMixin:
-    with db.begin(nested=db.in_transaction()):
-        db_instance = db.query(model).where(model.record_sid == record_sid, model.expired_at.is_(None)).one_or_none()
-        if db_instance is not None:
-            raise sa_exc.MultipleResultsFound(f"Active '{model}' of specified record_sid '{record_sid}' already exists")
-
-        db_instance = (
-            db
-            .query(model)
-            .where(model.record_sid == record_sid, model.expired_at.is_not(None))
-            .order_by(model.expired_at.desc())
-            .first()
-        )
-        if db_instance is None:
-            raise sa_exc.NoResultFound(f"Expired '{model}' of specified record_sid '{record_sid}' not found")
-
-        db_new_instance = clone_snapshot_model_instance(model, db_instance)
-        db_new_instance.record_sid = record_sid
-        db_new_instance.created_at = db_instance.expired_at
-        db_new_instance.expired_at = updated_at
-
-        db_new_instance = clone_snapshot_model_instance(model, db_new_instance, clear_meta_fields=False, inplace=True)
-        db_new_instance.created_at = updated_at
-        db_new_instance.expired_at = None
-        db.add(db_new_instance)
+) -> SnapshotModelT:
+    db_instance = db.query(model).where(model.record_sid == record_sid, model.expired_at.is_(None)).one_or_none()
+    if db_instance is not None:
+        raise sa_exc.MultipleResultsFound(f"Active '{model}' of specified record_sid '{record_sid}' already exists")
+
+    db_instance = (
+        db
+        .query(model)
+        .where(model.record_sid == record_sid, model.expired_at.is_not(None))
+        .order_by(model.created_at.desc())
+        .first()
+    )
+    if db_instance is None:
+        raise sa_exc.NoResultFound(f"Expired '{model}' of specified record_sid '{record_sid}' not found")
+
+    db_new_instance = clone_snapshot_model_instance(model, db_instance)
+    db_new_instance.record_sid = record_sid
+    db_new_instance.created_at = db_instance.expired_at
+    db_new_instance.expired_at = updated_at
+    db_new_instance = clone_snapshot_model_instance(model, db_new_instance, clear_meta_fields=False, inplace=True)
+    db_new_instance.created_at = updated_at
+    db_new_instance.expired_at = None
+    db.add(db_new_instance)
+    db.flush()
 
     return db_new_instance

{plexus_python_common-1.0.15 → plexus_python_common-1.0.17}/src/plexus_python_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-common
-Version: 1.0.15
+Version: 1.0.17
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{plexus_python_common-1.0.15 → plexus_python_common-1.0.17}/test/plexus_tests/common/utils/ormutils_test.py

@@ -10,11 +10,12 @@ from iker.common.utils.dbutils import make_scheme
 from iker.common.utils.dtutils import dt_parse_iso
 from iker.common.utils.jsonutils import JsonType
 from iker.common.utils.randutils import randomizer
-from sqlmodel import Field
+from sqlmodel import Field, SQLModel
 
 from plexus.common.utils.ormutils import (
     db_activate_snapshot_model,
     db_create_record_model,
+    db_create_serial_model,
     db_create_snapshot_model,
     db_delete_serial_model,
     db_expire_snapshot_model,
@@ -26,6 +27,7 @@ from plexus.common.utils.ormutils import (
     db_read_serial_models,
     db_read_snapshot_models_of_record,
     db_update_record_model,
+    db_update_serial_model,
     db_update_snapshot_model,
 )
 from plexus.common.utils.ormutils import (
@@ -44,48 +46,151 @@ fixture_postgresql_test = pytest_postgresql.factories.postgresql("fixture_postgr
 DummyBaseModel = make_base_model()
 
 
-class DummySerialModel(DummyBaseModel, make_serial_model_mixin(), table=True):
-    __tablename__ = "dummy_serial_model"
+def make_dummy_model():
+    class Model(SQLModel):
+        dummy_str: str = Field(sa_column=sa.Column(sa_pg.VARCHAR(256)), default="")
+        dummy_int: int = Field(sa_column=sa.Column(sa_pg.BIGINT), default=0)
+        dummy_float: float = Field(sa_column=sa.Column(sa_pg.DOUBLE_PRECISION), default=0.0)
+        dummy_bool: bool = Field(sa_column=sa.Column(sa_pg.BOOLEAN), default=False)
+        dummy_array: list[str] = Field(sa_column=sa.Column(sa_pg.ARRAY(sa_pg.VARCHAR(64))))
+        dummy_json: JsonType = Field(sa_column=sa.Column(sa_pg.JSONB))
 
-    dummy_str: str = Field(sa_column=sa.Column(sa_pg.VARCHAR(256)), default="")
-    dummy_int: int = Field(sa_column=sa.Column(sa_pg.BIGINT), default=0)
-    dummy_float: float = Field(sa_column=sa.Column(sa_pg.DOUBLE_PRECISION), default=0.0)
-    dummy_bool: bool = Field(sa_column=sa.Column(sa_pg.BOOLEAN), default=False)
-    dummy_array: list[str] = Field(sa_column=sa.Column(sa_pg.ARRAY(sa_pg.VARCHAR(64))))
-    dummy_json: JsonType = Field(sa_column=sa.Column(sa_pg.JSONB))
+    return Model
 
 
-class DummyRecordModel(DummyBaseModel, make_record_model_mixin(), table=True):
-    __tablename__ = "dummy_record_model"
+DummyModel = make_dummy_model()
 
-    dummy_str: str = Field(sa_column=sa.Column(sa_pg.VARCHAR(256)), default="")
-    dummy_int: int = Field(sa_column=sa.Column(sa_pg.BIGINT), default=0)
-    dummy_float: float = Field(sa_column=sa.Column(sa_pg.DOUBLE_PRECISION), default=0.0)
-    dummy_bool: bool = Field(sa_column=sa.Column(sa_pg.BOOLEAN), default=False)
-    dummy_array: list[str] = Field(sa_column=sa.Column(sa_pg.ARRAY(sa_pg.VARCHAR(64))))
-    dummy_json: JsonType = Field(sa_column=sa.Column(sa_pg.JSONB))
 
+class DummySerialModel(DummyBaseModel, make_dummy_model(), make_serial_model_mixin(), table=True):
+    __tablename__ = "dummy_serial_model"
+
+
+class DummyRecordModel(DummyBaseModel, make_dummy_model(), make_record_model_mixin(), table=True):
+    __tablename__ = "dummy_record_model"
     __table_args__ = (
         record_model_mixin.make_index_created_at("ix_dummy_record_model_created_at"),
     )
 
 
-class DummySnapshotModel(DummyBaseModel, make_snapshot_model_mixin(), table=True):
+class DummySnapshotModel(DummyBaseModel, make_dummy_model(), make_snapshot_model_mixin(), table=True):
     __tablename__ = "dummy_snapshot_model"
-
-    dummy_str: str = Field(sa_column=sa.Column(sa_pg.VARCHAR(256)), default="")
-    dummy_int: int = Field(sa_column=sa.Column(sa_pg.BIGINT), default=0)
-    dummy_float: float = Field(sa_column=sa.Column(sa_pg.DOUBLE_PRECISION), default=0.0)
-    dummy_bool: bool = Field(sa_column=sa.Column(sa_pg.BOOLEAN), default=False)
-    dummy_array: list[str] = Field(sa_column=sa.Column(sa_pg.ARRAY(sa_pg.VARCHAR(64))))
-    dummy_json: JsonType = Field(sa_column=sa.Column(sa_pg.JSONB))
-
     __table_args__ = (
         snapshot_model_mixin.make_index_created_at_expired_at("ix_dummy_snapshot_model_created_at_expired_at"),
         snapshot_model_mixin.make_active_unique_index_record_sid("ix_au_dummy_snapshot_model_record_sid"),
     )
 
 
+def test_db_serial_model_crud(fixture_postgresql_test_proc, fixture_postgresql_test):
+    scheme = make_scheme(Dialects.postgresql, Drivers.psycopg)
+    host = fixture_postgresql_test.info.host
+    port = fixture_postgresql_test.info.port
+    user = fixture_postgresql_test.info.user
+    database = fixture_postgresql_test.info.dbname
+
+    maker = ConnectionMaker.create(scheme,
+                                   host,
+                                   port,
+                                   user,
+                                   None,
+                                   database,
+                                   session_opts=dict(expire_on_commit=False))
+
+    DummyBaseModel.metadata.create_all(maker.engine)
+
+    rng = randomizer()
+
+    def random_record() -> DummyModel:
+        return DummyModel(
+            dummy_int=rng.next_int(0, 1000),
+            dummy_str=rng.random_alphanumeric(rng.next_int(10, 20)),
+            dummy_float=rng.next_float(0.0, 100.0),
+            dummy_bool=rng.next_bool(),
+            dummy_array=list(rng.random_ascii(rng.next_int(10, 20)) for _ in range(rng.next_int(10, 20))),
+            dummy_json=rng.random_json_object(5),
+        )
+
+    with maker.make_session() as session:
+        session.execute(sa.sql.text("SET TIMEZONE TO 'UTC'"))
+        session.commit()
+
+        create_records = [random_record() for _ in range(0, 100)]
+        update_records = [random_record() for _ in range(0, 100)]
+
+        for i in range(0, 100):
+            with pytest.raises(sa_exc.NoResultFound):
+                db_read_serial_model(session, DummySerialModel, i + 1)
+
+        for i in range(0, 100):
+            result = db_create_serial_model(session, DummySerialModel, create_records[i])
+
+            assert result.sid == i + 1
+            assert result.dummy_int == create_records[i].dummy_int
+            assert result.dummy_str == create_records[i].dummy_str
+            assert result.dummy_float == create_records[i].dummy_float
+            assert result.dummy_bool == create_records[i].dummy_bool
+            assert result.dummy_array == create_records[i].dummy_array
+            assert result.dummy_json == create_records[i].dummy_json
+
+        for i in range(0, 100):
+            result = db_read_serial_model(session, DummySerialModel, i + 1)
+
+            assert result.sid == i + 1
+            assert result.dummy_int == create_records[i].dummy_int
+            assert result.dummy_str == create_records[i].dummy_str
+            assert result.dummy_float == create_records[i].dummy_float
+            assert result.dummy_bool == create_records[i].dummy_bool
+            assert result.dummy_array == create_records[i].dummy_array
+            assert result.dummy_json == create_records[i].dummy_json
+
+        for i in range(0, 100):
+            result = db_update_serial_model(session, DummySerialModel, update_records[i], i + 1)
+
+            assert result.sid == i + 1
+            assert result.dummy_int == update_records[i].dummy_int
+            assert result.dummy_str == update_records[i].dummy_str
+            assert result.dummy_float == update_records[i].dummy_float
+            assert result.dummy_bool == update_records[i].dummy_bool
+            assert result.dummy_array == update_records[i].dummy_array
+            assert result.dummy_json == update_records[i].dummy_json
+
+        results = db_read_serial_models(session, DummySerialModel, 0, 200)
+        assert len(results) == 100
+
+        for i, (result, update_record) in enumerate(zip(results, update_records)):
+            assert result.sid == i + 1
+            assert result.dummy_int == update_record.dummy_int
+            assert result.dummy_str == update_record.dummy_str
+            assert result.dummy_float == update_record.dummy_float
+            assert result.dummy_bool == update_record.dummy_bool
+            assert result.dummy_array == update_record.dummy_array
+            assert result.dummy_json == update_record.dummy_json
+
+        for i in range(0, 100):
+            result = db_read_serial_model(session, DummySerialModel, i + 1)
+
+            assert result.sid == i + 1
+            assert result.dummy_int == update_records[i].dummy_int
+            assert result.dummy_str == update_records[i].dummy_str
+            assert result.dummy_float == update_records[i].dummy_float
+            assert result.dummy_bool == update_records[i].dummy_bool
+            assert result.dummy_array == update_records[i].dummy_array
+            assert result.dummy_json == update_records[i].dummy_json
+
+        for i in range(0, 100):
+            result = db_delete_serial_model(session, DummySerialModel, i + 1)
+
+            assert result.sid == i + 1
+            assert result.dummy_int == update_records[i].dummy_int
+            assert result.dummy_str == update_records[i].dummy_str
+            assert result.dummy_float == update_records[i].dummy_float
+            assert result.dummy_bool == update_records[i].dummy_bool
+            assert result.dummy_array == update_records[i].dummy_array
+            assert result.dummy_json == update_records[i].dummy_json
+
+        results = db_read_serial_models(session, DummySerialModel, 0, 200)
+        assert len(results) == 0
+
+
 def test_db_record_model_crud(fixture_postgresql_test_proc, fixture_postgresql_test):
     scheme = make_scheme(Dialects.postgresql, Drivers.psycopg)
     host = fixture_postgresql_test.info.host
@@ -105,8 +210,8 @@ def test_db_record_model_crud(fixture_postgresql_test_proc, fixture_postgresql_t
 
     rng = randomizer()
 
-    def random_record() -> DummyRecordModel:
-        return DummyRecordModel(
+    def random_record() -> DummyModel:
+        return DummyModel(
             dummy_int=rng.next_int(0, 1000),
             dummy_str=rng.random_alphanumeric(rng.next_int(10, 20)),
             dummy_float=rng.next_float(0.0, 100.0),
@@ -215,6 +320,7 @@ def test_db_record_model_crud(fixture_postgresql_test_proc, fixture_postgresql_t
         results = db_read_serial_models(session, DummyRecordModel, 0, 200)
         assert len(results) == 0
 
+
 def test_db_snapshot_model_crud(fixture_postgresql_test_proc, fixture_postgresql_test):
     scheme = make_scheme(Dialects.postgresql, Drivers.psycopg)
     host = fixture_postgresql_test.info.host
@@ -235,8 +341,8 @@ def test_db_snapshot_model_crud(fixture_postgresql_test_proc, fixture_postgresql
 
     rng = randomizer()
 
-    def random_record() -> DummySnapshotModel:
-        return DummySnapshotModel(
+    def random_record() -> DummyModel:
+        return DummyModel(
             dummy_int=rng.next_int(0, 1000),
             dummy_str=rng.random_alphanumeric(rng.next_int(10, 20)),
             dummy_float=rng.next_float(0.0, 100.0),