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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flask-postgresql_audit
-Version: 1.0.4
+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.4 → 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.4"
+__version__ = "1.0.6"

{flask_postgresql_audit-1.0.4 → 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/alembic_utils/__init__.py

@@ -0,0 +1,9 @@
+import alembic_utils
+from alembic_utils.experimental import collect_subclasses
+from alembic_utils.replaceable_entity import ReplaceableEntity
+
+from .pg_aggregate import PGAggregate
+
+original_types = set(collect_subclasses(alembic_utils, ReplaceableEntity))
+extension_types = {PGAggregate}
+allowed_types = original_types | extension_types

flask_postgresql_audit-1.0.6/flask_postgresql_audit/extensions/alembic_utils/pg_aggregate.py

@@ -0,0 +1,119 @@
+import re
+import typing as t
+
+import sqlalchemy as sa
+from alembic_utils.exceptions import SQLParseFailure
+from alembic_utils.replaceable_entity import ReplaceableEntity
+from alembic_utils.statement import strip_terminating_semicolon
+from sqlalchemy.orm import Session
+
+T = t.TypeVar("T", bound="ReplaceableEntity")
+
+
+class PGAggregate(ReplaceableEntity):
+    def __init__(self, schema: str, signature: str, definition: str):
+        super().__init__(schema, signature, definition)
+        self.definition: str = strip_terminating_semicolon(definition)
+
+    @property
+    def type_(self):
+        return "aggregate"
+
+    @property
+    def literal_signature(self):
+        name, remainder = self.signature.split("(", 1)
+        return '"' + name.strip() + '"(' + remainder
+
+    @classmethod
+    def from_sql(cls, sql: str) -> "PGAggregate":
+        pattern = r"^CREATE\s+AGGREGATE\s+(?:(?P<schema>\w+)\.)?(?P<signature>.+)\s+(?P<definition>\(.*\))$"
+        result = re.search(pattern, sql, re.IGNORECASE)
+        if result is not None and isinstance(result, re.Match):
+            raw_signature: str = result["signature"]
+            signature = (
+                "".join(raw_signature.split('"', 2))
+                if raw_signature.startswith('"')
+                else raw_signature
+            )
+            return cls(
+                schema=result["schema"],
+                signature=signature,
+                definition=result["definition"],
+            )
+        raise SQLParseFailure(f'Failed to parse SQL into PGAggregate """{sql}"""')
+
+    def to_sql_statement_create(self, *, replace: bool = False):
+        return sa.text(
+            f"{'CREATE OR REPLACE' if replace else 'CREATE'} AGGREGATE "
+            f"{self.literal_schema}.{self.literal_signature} {self.definition}"
+        )
+
+    def to_sql_statement_create_or_replace(self):
+        return self.to_sql_statement_create(replace=True)
+
+    def to_sql_statement_drop(self, cascade=False):
+        return sa.text(
+            f"DROP AGGREGATE {self.literal_schema}.{self.literal_signature}"
+            + (" CASCADE" if cascade else "")
+        )
+
+    @classmethod
+    def from_database(cls, sess: Session, schema: str) -> "list[PGAggregate]":
+        PG_GTE_11 = """
+            and p.prokind = 'a'
+        """
+
+        # NOTE: not tested
+        # PG_LT_11 = """
+        #     and p.proisagg
+        #     and not p.proiswindow
+        # """
+
+        # Retrieve the postgres server version e.g. 90603 for 9.6.3 or 120003 for 12.3
+        pg_version_str = sess.execute(sa.text("show server_version_num")).scalar_one()
+        pg_version = int(pg_version_str)
+
+        sql = sa.text(
+            """
+            WITH extension_functions AS (
+                SELECT objid AS extension_function_oid, classid
+                FROM pg_depend
+                WHERE deptype='e' -- depends on an extension
+                    AND classid = 'pg_proc'::regclass -- is a proc/function
+            )
+
+            SELECT  n.nspname AS function_schema
+                ,   p.proname AS function_name
+                ,   pg_get_function_arguments(p.oid) AS function_arguments
+                ,   format('CREATE AGGREGATE %s (SFUNC = %s, STYPE = %s%s%s%s%s)'
+                    , format('%s.%s(%s)', n.nspname, p.proname, pg_get_function_arguments(p.oid))
+                    , r.aggtransfn
+                    , r.aggtranstype::regtype
+                    , ', SORTOP = '    || NULLIF(r.aggsortop, 0)::regoper
+                    , ', INITCOND = '  || quote_nullable(r.agginitval)
+                    , ', FINALFUNC = ' || NULLIF(r.aggfinalfn, 0)
+                    , CASE WHEN r.aggfinalextra THEN ', FINALFUNC_EXTRA' END
+            --         add more to cover special cases like moving-aggregate etc.
+                    ) AS create_statement
+                ,   t.typname AS return_type
+                ,   l.lanname AS function_language
+            FROM pg_aggregate r
+                LEFT JOIN pg_proc p ON p.oid = aggfnoid
+                LEFT JOIN pg_namespace n ON p.pronamespace = n.oid
+                LEFT JOIN pg_language l ON p.prolang = l.oid
+                LEFT JOIN pg_type t ON t.oid = p.prorettype
+                LEFT JOIN extension_functions ef ON p.oid = ef.extension_function_oid
+            WHERE n.nspname NOT IN ('pg_catalog', 'information_schema') 
+                AND ef.extension_function_oid IS NULL -- Filter out functions from extensions
+                AND n.nspname = :schema
+            """
+            + (PG_GTE_11 if pg_version >= 110000 else "")
+        ).bindparams(schema=schema)
+
+        rows = sess.execute(sql)
+        db_aggregates = [cls.from_sql(x[3]) for x in rows]
+
+        for agg in db_aggregates:
+            assert agg is not None
+
+        return db_aggregates

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