flask-postgresql-audit 1.0.5__tar.gz → 1.0.6__tar.gz

{flask_postgresql_audit-1.0.5 → flask_postgresql_audit-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flask-postgresql_audit
-Version: 1.0.5
+Version: 1.0.6
 Summary: Versioning and auditing extension for PostgreSQL and SQLAlchemy.
 Project-URL: Homepage, https://github.com/higamigu/flask-postgresql-audit
 Author-email: Higamigu <higamigu@gmail.com>, Konsta Vesterinen <konsta@fastmonkeys.com>

{flask_postgresql_audit-1.0.5 → flask_postgresql_audit-1.0.6}/flask_postgresql_audit/__init__.py

@@ -1,4 +1,4 @@
 # ruff: noqa: F401
 from .core import Audit, PostgreSQLAudit
 
-__version__ = "1.0.5"
+__version__ = "1.0.6"

{flask_postgresql_audit-1.0.5 → flask_postgresql_audit-1.0.6}/flask_postgresql_audit/core.py

@@ -1,5 +1,7 @@
+import inspect
 import typing as t
 from contextlib import contextmanager
+from itertools import groupby
 
 import sqlalchemy as sa
 import sqlalchemy.event as event
@@ -15,7 +17,8 @@ from .models import activity_model_factory, transaction_model_factory
 from .typing import AnyAttrribute
 from .utils import load_template
 
-Base = t.TypeVar("Base", bound=orm.DeclarativeBase)
+if t.TYPE_CHECKING:
+    from sqlalchemy.sql.functions import _FunctionGenerator
 
 
 class ImproperlyConfigured(Exception):
@@ -131,6 +134,12 @@ class PostgreSQLAudit:
             ctx["jsonb_subtract_join_type"] = "FULL"
         return ctx
 
+    @property
+    def func(self) -> "_FunctionGenerator":
+        if self.schema_name and self.schema_name != "public":
+            return getattr(sa.func, self.schema_name)
+        return sa.func
+
     @contextmanager
     def disable(self, session: orm.Session | orm.scoped_session[t.Any]):
         session.execute(self.set_local("'false'"))
@@ -238,3 +247,52 @@ class PostgreSQLAudit:
         self.attach_listeners()
 
         app.extensions["postgresql-audit"] = self
+
+    def fetch_activity(self, obj: type[Audit] | Audit | t.Sequence[Audit]):
+        if inspect.isclass(obj):
+            source = obj
+            activity_join_cond = self.Activity.table_name == source.__tablename__
+        else:
+            objects = list(obj) if isinstance(obj, t.Sequence) else list([obj])
+            unions = []
+            for key, group in groupby(objects, key=lambda o: o.__class__):
+                relid = sa.text(f"'{key.__tablename__}'::regclass::oid")
+                jsonb = sa.func.to_jsonb(key.__table__.table_valued())
+
+                union = sa.select(
+                    sa.literal(key.__tablename__).label("table_name"),
+                    self.func.get_pk_values(relid, jsonb).label("row_key"),
+                )
+
+                for pk in key.__table__.primary_key.columns:
+                    pk_attr: sa.ColumnElement[t.Any] = getattr(key, pk.name)
+                    pks = [getattr(o, pk.name) for o in group]
+                    union = union.filter(pk_attr.in_(pks))
+
+                unions.append(union)
+
+            source = sa.union(*unions).subquery("source")
+            activity_join_cond = sa.and_(
+                self.Activity.table_name == source.c.table_name,
+                self.Activity.row_key == source.c.row_key,
+            )
+
+        stmt = (
+            sa.select(
+                self.Activity.id,
+                self.Activity.verb,
+                self.Activity.table_name,
+                self.Activity.issued_at.label("activity_timestamp"),
+                self.Transaction.issued_at.label("transaction_timestamp"),
+                self.Transaction.client_addr.label("transaction_addr"),
+                self.Transaction.actor_id.label("transaction_actor"),
+                self.Activity.old_data,
+                self.Activity.changed_data,
+            )
+            .select_from(source)
+            .join(self.Activity, activity_join_cond)
+            .join(self.Transaction)
+            .order_by(self.Activity.id.desc())
+        )
+
+        return stmt

flask_postgresql_audit-1.0.6/flask_postgresql_audit/descriptors.py

@@ -0,0 +1,38 @@
+import typing as t
+
+_P = t.ParamSpec("_P")
+_R = t.TypeVar("_R")
+
+
+class hybridmethod(t.Generic[_P, _R]):
+    """A decorator which allows definition of a Python object method with both
+    instance-level and class-level behavior.
+
+    """
+
+    def __init__(
+        self,
+        inst_func: t.Callable[t.Concatenate[t.Any, _P], _R],
+        cls_func: t.Optional[t.Callable[t.Concatenate[t.Any, _P], _R]] = None,
+    ):
+        self.inst_func = inst_func
+        if cls_func is not None:
+            self.classmethod(cls_func)
+        else:
+            self.classmethod(inst_func)
+
+    def __get__(
+        self, instance: t.Optional[object], owner: t.Type[object]
+    ) -> t.Callable[t.Concatenate[t.Any, _P], _R]:
+        if instance is None:
+            return self.cls_func.__get__(owner, owner)
+        else:
+            return self.inst_func.__get__(instance, owner)
+
+    def classmethod(
+        self, cls_func: t.Callable[t.Concatenate[t.Any, _P], _R]
+    ) -> "hybridmethod[_P, _R]":
+        self.cls_func = cls_func
+        if not self.cls_func.__doc__:
+            self.cls_func.__doc__ = self.inst_func.__doc__
+        return self

flask_postgresql_audit-1.0.6/flask_postgresql_audit/extensions/__init__.py

@@ -0,0 +1 @@
+# ruff: noqa: F401

flask_postgresql_audit-1.0.6/flask_postgresql_audit/extensions/document_staging/__init__.py

@@ -0,0 +1,4 @@
+# ruff: noqa: F401
+from .enum import Docstatus
+from .listener import attach_listener
+from .model import DocumentStaging

flask_postgresql_audit-1.0.6/flask_postgresql_audit/extensions/document_staging/enum.py

@@ -0,0 +1,8 @@
+import enum
+
+
+class Docstatus(enum.Enum):
+    DRAFT = "draft"
+    SUBMITTED = "submitted"
+    CANCELLED = "cancelled"
+    REVISED = "revised"

flask_postgresql_audit-1.0.6/flask_postgresql_audit/extensions/document_staging/listener.py

@@ -0,0 +1,35 @@
+import typing as t
+from datetime import datetime
+
+import sqlalchemy.event as event
+import sqlalchemy.orm as orm
+from flask_sqlalchemy.session import Session
+
+from flask_postgresql_audit.core import _default_actor_id
+
+from .enum import Docstatus
+from .model import DocumentStaging
+
+_O = t.TypeVar("_O", bound=object)
+
+
+def attach_listener(actor_id_getter: t.Callable[[], t.Any] = _default_actor_id):
+    @event.listens_for(orm.Session, "before_flush")
+    def __receive_before_flush__(
+        session: Session,
+        flush_context: orm.UOWTransaction,
+        instances: t.Optional[t.Sequence[_O]],
+    ):
+        for obj in session.new:
+            if isinstance(obj, DocumentStaging):
+                if obj.docstatus == Docstatus.DRAFT or obj.docstatus is None:
+                    obj.created_by = actor_id_getter()
+                    obj.created_on = datetime.now()
+        for obj in session.dirty:
+            if isinstance(obj, DocumentStaging):
+                if obj.docstatus == Docstatus.SUBMITTED:
+                    obj.submitted_by = actor_id_getter()
+                    obj.submitted_on = datetime.now()
+                if obj.docstatus == Docstatus.CANCELLED:
+                    obj.cancelled_by = actor_id_getter()
+                    obj.cancelled_on = datetime.now()

flask_postgresql_audit-1.0.6/flask_postgresql_audit/extensions/document_staging/model.py

@@ -0,0 +1,123 @@
+import typing as t
+from datetime import datetime
+
+import sqlalchemy as sa
+import sqlalchemy.event as event
+import sqlalchemy.orm as orm
+from flask_sqlalchemy.session import Session
+from sqlalchemy.dialects.postgresql import ENUM as PGEnum
+
+from flask_postgresql_audit.typing import OMap
+
+from .enum import Docstatus
+
+
+class DocumentStaging:
+    __staging_configured__: t.ClassVar[bool]
+    __staging_fk_keys__: t.ClassVar[list[sa.ColumnClause[t.Any]]]
+
+    __bump_transitions__: t.ClassVar[dict[Docstatus, Docstatus]] = {
+        Docstatus.DRAFT: Docstatus.SUBMITTED,
+        Docstatus.SUBMITTED: Docstatus.CANCELLED,
+    }
+
+    __unique_docstatus__: t.ClassVar[list[Docstatus]] = [
+        Docstatus.DRAFT,
+        Docstatus.SUBMITTED,
+        Docstatus.CANCELLED,
+    ]
+
+    if t.TYPE_CHECKING:
+        __table__: sa.Table
+        __tablename__: str
+
+        def __init__(self, **kw: t.Any): ...
+
+    def __init_subclass__(cls, *args, **kwargs) -> None:
+        event.listen(cls, "instrument_class", cls.__init_staging__)
+        super().__init_subclass__(*args, **kwargs)
+
+    @classmethod
+    def __init_staging__(cls, mapper: orm.Mapper[t.Self], class_: type[t.Self]):
+        if not getattr(class_, "__staging_configured__", False):
+            table = class_.__table__
+
+            pk_cols = []
+            fk_cols = []
+
+            for pk in table.primary_key.columns:
+                fk_name = f"revision_{pk.name}"
+                fk = table.c.get(fk_name) or sa.Column(fk_name, pk.type, nullable=True)
+
+                if fk.name not in table.columns:
+                    table.append_column(fk)
+
+                if not hasattr(class_, fk.name):
+                    setattr(class_, fk.name, orm.mapped_column(pk.type, nullable=True))
+
+                pk_cols.append(pk)
+                fk_cols.append(fk)
+
+            fk_const = sa.ForeignKeyConstraint(
+                fk_cols,
+                pk_cols,
+                name=f"{class_.__tablename__}_revision_fkey",
+                ondelete="SET NULL",
+            )
+
+            if fk_const.name not in table.constraints:
+                table.append_constraint(fk_const)
+
+            class_.__staging_fk_keys__ = fk_cols
+            class_.__staging_configured__ = True
+
+    docstatus: orm.Mapped[Docstatus] = orm.mapped_column(
+        PGEnum(Docstatus, name="docstatus_enum", create_type=True),
+        default=Docstatus.DRAFT,
+    )
+
+    created_on: OMap[datetime] = orm.mapped_column(default=sa.func.now())
+    created_by: OMap[str]
+
+    submitted_by: OMap[str]
+    submitted_on: OMap[datetime]
+
+    cancelled_by: OMap[str]
+    cancelled_on: OMap[datetime]
+
+    @orm.declared_attr
+    @classmethod
+    def revision(cls) -> "orm.Mapped[t.Self]":
+        return orm.relationship(cls, uselist=False)
+
+    @orm.declared_attr
+    @classmethod
+    def revision_of(cls) -> "orm.Mapped[t.Self]":
+        return orm.relationship(
+            cls,
+            uselist=False,
+            remote_side=lambda: list(cls.__table__.primary_key.columns),
+            back_populates="revision",
+        )
+
+    def bump(self):
+        if self.docstatus not in self.__bump_transitions__:
+            msg = f"Invalid docstatus: {self.docstatus.name} cannot be bumped"
+            raise ValueError(msg)
+        self.docstatus = self.__bump_transitions__[self.docstatus]
+
+    def revise(self, new_doc: t.Self):
+        if self.docstatus != Docstatus.CANCELLED:
+            msg = f"Invalid docstatus: {self.docstatus.name} cannot be revised"
+            raise ValueError(msg)
+        self.docstatus = Docstatus.REVISED
+        self.revision = new_doc
+        return new_doc
+
+    def delete(self, session: orm.scoped_session[Session]):
+        if self.docstatus != Docstatus.DRAFT:
+            msg = f"Invalid docstatus: {self.docstatus.name} cannot be deleted"
+            raise ValueError(msg)
+        session.delete(self)
+        if parent := self.revision_of:
+            parent.docstatus = Docstatus.CANCELLED