plexus-python-common 1.0.13__tar.gz → 1.0.14__tar.gz

{plexus_python_common-1.0.13 → plexus_python_common-1.0.14}/PKG-INFO

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

{plexus_python_common-1.0.13 → plexus_python_common-1.0.14}/src/plexus/common/utils/ormutils.py

@@ -4,6 +4,8 @@ from typing import Protocol, Self, TypeVar
 import pydantic as pdt
 import sqlalchemy as sa
 import sqlalchemy.dialects.postgresql as sa_pg
+import sqlalchemy.exc as sa_exc
+import sqlalchemy.orm as sa_orm
 from sqlmodel import Field, SQLModel
 
 from plexus.common.utils.datautils import validate_dt_timezone
@@ -30,7 +32,30 @@ __all__ = [
     "SerialModel",
     "RecordModel",
     "SnapshotModel",
+    "clone_serial_model_instance",
+    "clone_record_model_instance",
+    "clone_snapshot_model_instance",
     "make_snapshot_model_trigger",
+    "db_create_serial_model",
+    "db_create_serial_models",
+    "db_read_serial_model",
+    "db_read_serial_models",
+    "db_update_serial_model",
+    "db_delete_serial_model",
+    "db_create_record_model",
+    "db_create_record_models",
+    "db_update_record_model",
+    "db_create_snapshot_model",
+    "db_create_snapshot_models",
+    "db_read_snapshot_models_of_record",
+    "db_read_latest_snapshot_model_of_record",
+    "db_read_active_snapshot_model_of_record",
+    "db_read_expired_snapshot_models_of_record",
+    "db_read_latest_snapshot_models",
+    "db_read_active_snapshot_models",
+    "db_update_snapshot_model",
+    "db_expire_snapshot_model",
+    "db_activate_snapshot_model",
 ]
 
 ModelT = TypeVar("ModelT", bound=SQLModel)
@@ -363,7 +388,62 @@ class SnapshotModel(make_base_model(), make_snapshot_model_mixin(), table=True):
     pass
 
 
+def clone_serial_model_instance(
+    model: type[SerialModelMixin],
+    instance: SerialModelMixin,
+    *,
+    clear_meta_fields: bool = True,
+    inplace: bool = False,
+) -> SerialModelMixin:
+    result = model.model_validate(instance)
+    result = instance if inplace else result
+    if clear_meta_fields:
+        result.sid = None
+    return result
+
+
+def clone_record_model_instance(
+    model: type[RecordModelMixin],
+    instance: RecordModelMixin,
+    *,
+    clear_meta_fields: bool = True,
+    inplace: bool = False,
+) -> RecordModelMixin:
+    result = model.model_validate(instance)
+    result = instance if inplace else result
+    if clear_meta_fields:
+        result.sid = None
+        result.created_at = None
+        result.updated_at = None
+    return result
+
+
+def clone_snapshot_model_instance(
+    model: type[SnapshotModelMixin],
+    instance: SnapshotModelMixin,
+    *,
+    clear_meta_fields: bool = True,
+    inplace: bool = False,
+) -> SnapshotModelMixin:
+    result = model.model_validate(instance)
+    result = instance if inplace else result
+    if clear_meta_fields:
+        result.sid = None
+        result.created_at = None
+        result.expired_at = None
+        result.record_sid = None
+    return result
+
+
 def make_snapshot_model_trigger(engine: sa.Engine, model: type[SQLModel]):
+    """
+    Creates the necessary database objects (sequence, function, trigger) to support automatic snapshot management
+    for the given snapshot model. This includes a sequence for `record_sid`, a function to handle snapshot updates,
+    and a trigger to invoke the function before inserts. The model must extend `SnapshotModel`.
+
+    :param engine: SQLAlchemy engine connected to the target database.
+    :param model: The snapshot model class extending `SnapshotModel`.
+    """
     table_name = model.__tablename__
     if not table_name:
         raise ValueError("missing '__tablename__' attribute")
@@ -418,3 +498,342 @@ def make_snapshot_model_trigger(engine: sa.Engine, model: type[SQLModel]):
         conn.execute(sa.text(create_snapshot_auto_update_function_sql))
         conn.execute(sa.text(create_snapshot_auto_update_trigger_sql))
         conn.commit()
+
+
+def db_create_serial_model(
+    db: sa_orm.Session,
+    model: type[SerialModelMixin],
+    instance: SerialModelMixin,
+) -> SerialModelMixin:
+    db_instance = model.model_validate(instance)
+    db.add(db_instance)
+    db.commit()
+
+    return db_instance
+
+
+def db_create_serial_models(
+    db: sa_orm.Session,
+    model: type[SerialModelMixin],
+    instances: list[SerialModelMixin],
+) -> list[SerialModelMixin]:
+    db_instances = [model.model_validate(instance) for instance in instances]
+    db.bulk_save_objects(db_instances, return_defaults=True)
+    db.commit()
+
+    return db_instances
+
+
+def db_read_serial_model(
+    db: sa_orm.Session,
+    model: type[SerialModelMixin],
+    sid: int,
+) -> SerialModelMixin:
+    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")
+
+    return db_instance
+
+
+def db_read_serial_models(
+    db: sa_orm.Session,
+    model: type[SerialModelMixin],
+    skip: int,
+    limit: int,
+) -> list[SerialModelMixin]:
+    return db.query(model).order_by(model.sid).offset(skip).limit(limit).all()
+
+
+def db_update_serial_model(
+    db: sa_orm.Session,
+    model: type[SerialModelMixin],
+    instance: SerialModelMixin,
+) -> SerialModelMixin:
+    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")
+
+    db_instance = model_copy_from(db_instance, instance, exclude_none=True)
+    model.model_validate(db_instance)
+    db.commit()
+
+    return db_instance
+
+
+def db_delete_serial_model(
+    db: sa_orm.Session,
+    model: type[SerialModelMixin],
+    sid: int,
+) -> SerialModelMixin:
+    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.commit()
+
+    return db_instance
+
+
+def db_create_record_model(
+    db: sa_orm.Session,
+    model: type[RecordModelMixin],
+    instance: RecordModelMixin,
+    created_at: datetime.datetime | None = None,
+) -> RecordModelMixin:
+    db_instance = clone_serial_model_instance(model, instance)
+    db_instance.created_at = created_at
+    db_instance.updated_at = created_at
+    db.add(db_instance)
+    db.commit()
+
+    return db_instance
+
+
+def db_create_record_models(
+    db: sa_orm.Session,
+    model: type[RecordModelMixin],
+    instances: list[RecordModelMixin],
+    created_at: datetime.datetime | None = None,
+) -> list[RecordModelMixin]:
+    db_instances = [clone_serial_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)
+    db.commit()
+
+    return db_instances
+
+
+def db_update_record_model(
+    db: sa_orm.Session,
+    model: type[RecordModelMixin],
+    instance: RecordModelMixin,
+    sid: int,
+    updated_at: datetime.datetime,
+) -> RecordModelMixin:
+    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_serial_model_instance(model, db_instance, clear_meta_fields=False, inplace=True)
+    db.commit()
+
+    return db_instance
+
+
+def db_create_snapshot_model(
+    db: sa_orm.Session,
+    model: type[SnapshotModelMixin],
+    instance: SnapshotModelMixin,
+    created_at: datetime.datetime,
+) -> SnapshotModelMixin:
+    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.record_sid = db_instance.sid
+    db.commit()
+
+    return db_instance
+
+
+def db_create_snapshot_models(
+    db: sa_orm.Session,
+    model: type[SnapshotModelMixin],
+    instances: list[SnapshotModelMixin],
+    created_at: datetime.datetime,
+) -> list[SnapshotModelMixin]:
+    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()
+
+    for db_instance in db_instances:
+        db_instance.record_sid = db_instance.sid
+    db.commit()
+
+    return db_instances
+
+
+def db_read_snapshot_models_of_record(
+    db: sa_orm.Session,
+    model: type[SnapshotModelMixin],
+    record_sid: int,
+) -> list[SnapshotModelMixin]:
+    return (
+        db
+        .query(model)
+        .where(model.record_sid == record_sid)
+        .order_by(model.created_at.desc())
+        .all()
+    )
+
+
+def db_read_latest_snapshot_model_of_record(
+    db: sa_orm.Session,
+    model: type[SnapshotModelMixin],
+    record_sid: int,
+) -> SnapshotModelMixin:
+    db_instance = (
+        db
+        .query(model)
+        .where(model.record_sid == record_sid)
+        .order_by(model.created_at.desc())
+        .first()
+    )
+    if db_instance is None:
+        raise sa_exc.NoResultFound(f"'{model}' of specified record_sid '{record_sid}' not found")
+
+    return db_instance
+
+
+def db_read_active_snapshot_model_of_record(
+    db: sa_orm.Session,
+    model: type[SnapshotModelMixin],
+    record_sid: int,
+) -> SnapshotModelMixin:
+    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")
+
+    return db_instance
+
+
+def db_read_expired_snapshot_models_of_record(
+    db: sa_orm.Session,
+    model: type[SnapshotModelMixin],
+    record_sid: int,
+) -> list[SnapshotModelMixin]:
+    return (
+        db
+        .query(model)
+        .where(model.record_sid == record_sid, model.expired_at.is_not(None))
+        .order_by(model.expired_at.desc())
+        .all()
+    )
+
+
+def db_read_latest_snapshot_models(
+    db: sa_orm.Session,
+    model: type[SnapshotModelMixin],
+    skip: int,
+    limit: int,
+) -> list[SnapshotModelMixin]:
+    subquery = (
+        db
+        .query(model.record_sid,
+               sa.func.max(model.created_at).label("max_created_at"))
+        .group_by(model.record_sid)
+        .subquery()
+    )
+
+    return (
+        db
+        .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)
+        .offset(skip)
+        .limit(limit)
+        .all()
+    )
+
+
+def db_read_active_snapshot_models(
+    db: sa_orm.Session,
+    model: type[SnapshotModelMixin],
+    skip: int,
+    limit: int,
+) -> list[SnapshotModelMixin]:
+    return db.query(model).where(model.expired_at.is_(None)).offset(skip).limit(limit).all()
+
+
+def db_update_snapshot_model(
+    db: sa_orm.Session,
+    model: type[SnapshotModelMixin],
+    instance: SnapshotModelMixin,
+    record_sid: int,
+    updated_at: datetime.datetime,
+) -> SnapshotModelMixin:
+    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.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.commit()
+
+    return db_new_instance
+
+
+def db_expire_snapshot_model(
+    db: sa_orm.Session,
+    model: type[SnapshotModelMixin],
+    record_sid: int,
+    updated_at: datetime.datetime,
+) -> SnapshotModelMixin:
+    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.commit()
+
+    return db_instance
+
+
+def db_activate_snapshot_model(
+    db: sa_orm.Session,
+    model: type[SnapshotModelMixin],
+    record_sid: int,
+    updated_at: datetime.datetime,
+) -> SnapshotModelMixin:
+    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)
+    db.commit()
+
+    return db_new_instance

{plexus_python_common-1.0.13 → plexus_python_common-1.0.14}/src/plexus_python_common.egg-info/PKG-INFO

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