flask-postgresql-audit 1.1.0__tar.gz → 1.1.1__tar.gz

{flask_postgresql_audit-1.1.0 → flask_postgresql_audit-1.1.1}/.gitignore

@@ -22,6 +22,7 @@ var/
 *.egg-info/
 .installed.cfg
 *.egg
+.env*
 
 # PyInstaller
 #  Usually these files are written by a python script from a template

{flask_postgresql_audit-1.1.0 → flask_postgresql_audit-1.1.1}/CHANGES.md

@@ -3,6 +3,63 @@
 Here you can see the full list of changes between each Flask-PostgreSQL-Audit
 release.
 
+## 1.1.1 (2026-08-08)
+
+-   Fix test teardown downgrade error in migration listener.
+-   Fix `pg_audit_enabled` state thread-safety using `ContextVar`.
+-   Quote schema names and parameterize schema existence queries in Alembic operations.
+-   Remove unused templates and unused `hybridmethod` descriptor.
+-   Document `DocumentStaging` and `PGAggregate` extensions in `README.md`.
+
+## 1.1.0 (2026-08-07)
+
+-   Bump `alembic` dependency to `>=1.18.0`.
+-   Refactor Alembic integration to use the official Plugin API and DispatchPriority system.
+-   Add multi-schema test matrix and schema-aware support to the test suite.
+-   Modernize Python type annotations, imports, string formatting, and clean up code using Ruff.
+-   Simplify context managers and type-hint fixtures in tests.
+
+## 1.0.9 (2026-08-07)
+
+-   Change `fetch_activity` join clause to `outerjoin`.
+-   Resolve type checking errors.
+
+## 1.0.8 (2026-03-30)
+
+-   Update `Audit` mixin class and refactor `fetch_activity` method, removing rowkey filter on class scope.
+-   Add PostgreSQL function `get_table_relid`.
+-   Fix `get_pk_values` returns wrong jsonb type if primary key columns are null.
+
+## 1.0.7 (2025-12-15)
+
+-   Fix cartesian join when providing a table model to `fetch_activity()`.
+
+## 1.0.6 (2025-12-15)
+
+-   Add `fetch_activity()` statement constructor with optional `verb` filtering, ordered by ID descending.
+-   Add `hybridmethod` descriptor.
+-   Add extension `document_staging`.
+
+## 1.0.5 (2025-11-27)
+
+-   Add `alembic_utils` extension `pg_aggregate`.
+
+## 1.0.4 (2025-11-17)
+
+-   Fix: use explicit schema prefix to call `get_pk_values()` in `create_activity`.
+
+## 1.0.3 (2025-11-14)
+
+-   Fix: use schema prefix when calling `jsonb_subtract()` in audit trigger functions.
+
+## 1.0.2 (2025-11-14)
+
+-   Support optional verbose value comparison in `jsonb_subtract()`.
+
+## 1.0.1 (2025-10-30)
+
+-   Update authors in `pyproject.toml` and update `README.md`.
+
 ## 1.0.0 (2025-10-30)
 
 -   Forked from PostgreSQL-Audit.

{flask_postgresql_audit-1.1.0 → flask_postgresql_audit-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
-Name: flask-postgresql_audit
-Version: 1.1.0
+Name: flask-postgresql-audit
+Version: 1.1.1
 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>
@@ -52,7 +52,7 @@ uv add flask-postgresql-audit
 ```
 or install directly from this repo
 ```
-uv add git+https://github.com/higamigu/flask-postgresql-audit --tag v1.0.0
+uv add git+https://github.com/higamigu/flask-postgresql-audit --tag v1.1.0
 ```
 
 ## Usage
@@ -66,16 +66,18 @@ from my_app import app  # your flask app
 db = SQLAlchemy()
 audit = PostgreSQLAudit()
 
+
 class Article(db.Model, Audit):
-    __tablename__ = 'article'
+    __tablename__ = "article"
 
     id = db.Column(db.Integer, primary_key=True)
     name = db.Column(db.String)
 
+
 db.init_app(app)
 audit.init_app(app, db)
 
-article = Article(name='Some article')
+article = Article(name="Some article")
 db.session.add(article)
 db.session.commit()
 ```
@@ -89,24 +91,24 @@ Now we can check the newly created activity.
 
 ``` python
 activity = db.session.scalar(select(audit.Activity))
-activity.id             # 1
-activity.table_name     # 'article'
-activity.verb           # 'insert'
-activity.old_data       # None
-activity.changed_data   # {'id': '1', 'name': 'Some article'}
+activity.id  # 1
+activity.table_name  # 'article'
+activity.verb  # 'insert'
+activity.old_data  # None
+activity.changed_data  # {'id': '1', 'name': 'Some article'}
 ```
 
 ``` python
-article.name = 'Some other article'
+article.name = "Some other article"
 db.session.commit()
 
 activity = db.session.scalar(select(audit.Activity).order_by(desc("id")))
-activity.id             # 2
-activity.table_name     # 'article'
-activity.verb           # 'update'
-activity.object_id      # 1
-activity.old_data       # {'id': '1', 'name': 'Some article'}
-activity.changed_data   # {'name': 'Some other article'}
+activity.id  # 2
+activity.table_name  # 'article'
+activity.verb  # 'update'
+activity.object_id  # 1
+activity.old_data  # {'id': '1', 'name': 'Some article'}
+activity.changed_data  # {'name': 'Some other article'}
 ```
 
 ``` python
@@ -114,14 +116,34 @@ db.session.delete(article)
 db.session.commit()
 
 activity = db.session.scalar(select(audit.Activity).order_by(desc("id")))
-activity.id             # 3
-activity.table_name     # 'article'
-activity.verb           # 'delete'
-activity.object_id      # 1
-activity.old_data       # {'id': '1', 'name': 'Some other article'}
-activity.changed_data   # None
+activity.id  # 3
+activity.table_name  # 'article'
+activity.verb  # 'delete'
+activity.object_id  # 1
+activity.old_data  # {'id': '1', 'name': 'Some other article'}
+activity.changed_data  # None
+```
+
+## Querying Activity History
+
+Instead of querying `audit.Activity` manually, you can use `fetch_activity()` to retrieve the audit trail for a model class, a single model instance, or a sequence/list of model instances:
+
+``` python
+# Query activity for a specific model class (e.g. Article)
+stmt = audit.fetch_activity(Article)
+activities = db.session.execute(stmt).all()
+
+# Query activity for a specific article instance
+stmt = audit.fetch_activity(article)
+activities = db.session.execute(stmt).all()
+
+# Query activity for multiple instances
+stmt = audit.fetch_activity([article1, article2])
+activities = db.session.execute(stmt).all()
 ```
 
+The returned statement is a SQLAlchemy `select` object that joins `Activity` and `Transaction` tables, ordered by activity ID descending. You can further customize or execute this statement.
+
 ## Different Schema
 You can isolate `pg_audit` objects entirely to a different schema by doing
 
@@ -159,6 +181,7 @@ You can customize actor id getter function by doing the following. Here is an ex
 ``` python
 from flask_jwt_extended import jwt_required, current_user
 
+
 @jwt_required(optional=True)
 def actor_id_getter():
     try:
@@ -166,6 +189,7 @@ def actor_id_getter():
     except Exception:
         return None
 
+
 ...
 
 audit = PostgreSQLAudit(actor_id_getter=actor_id_getter)
@@ -188,6 +212,88 @@ handlers =
 qualname = pg_audit
 ```
 
+## Troubleshooting
+
+### Activity not being recorded?
+
+1. **Check triggers are installed**: Run `flask db upgrade` after installing the extension
+2. **Verify audit is initialized**: Ensure you called `audit.init_app(app, db)` before using models
+3. **Commit after changes**: Audit records are only created on `db.session.commit()`
+
+### Actor tracking not working?
+
+The default actor ID getter tries to import `flask_login.current_user`. If you're not using Flask-Login:
+
+1. Provide your own `actor_id_getter` function:
+   ```python
+   def my_actor_id():
+       return current_user.id if current_user.is_authenticated else None
+   ```
+
+2. Pass it to the extension: `audit = PostgreSQLAudit(actor_id_getter=my_actor_id)`
+
+### Using a custom schema?
+
+1. Set schema when creating audit: `audit = PostgreSQLAudit(schema_name="my_schema")`
+2. Configure Alembic to track multiple schemas (see "Different Schema" section)
+3. Add `"include_schemas=True"` to `alembic/env.py` in `run_migrations_online()`
+
+### Fetching activity for custom models?
+
+The `fetch_activity()` method works with:
+- A model class: `audit.fetch_activity(MyModel)`
+- A single instance: `audit.fetch_activity(my_instance)`
+- Multiple instances: `audit.fetch_activity([instance1, instance2])`
+
+## Extensions
+
+### Document Staging
+
+The `document_staging` extension provides document lifecycle management and version revision tracking for models.
+
+```python
+from flask_postgresql_audit.extensions.document_staging import (
+    DocumentStaging,
+    Docstatus,
+    attach_listener,
+)
+
+
+class Article(BaseModel, DocumentStaging):
+    __tablename__ = "article"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    title: Mapped[str]
+
+
+# Attach session listener for automatic actor and timestamp tracking
+attach_listener()
+```
+
+#### Lifecycle & Transitions
+
+- **`Docstatus` states**: `DRAFT` (0), `SUBMITTED` (1), `CANCELLED` (2), `REVISED` (3).
+- **`doc.bump()`**: Advances document status (`DRAFT` -> `SUBMITTED` -> `CANCELLED`).
+- **`doc.revise(new_doc)`**: Creates a new revision `new_doc` from a `CANCELLED` document and sets state to `REVISED`.
+- **`doc.delete(session)`**: Deletes a `DRAFT` document. If it was a revision, reverts parent document status back to `CANCELLED`.
+- **Automatic Fields**: `created_by`, `created_on`, `submitted_by`, `submitted_on`, `cancelled_by`, `cancelled_on` are automatically set during session flush events.
+
+### Custom PostgreSQL Aggregates (`alembic_utils`)
+
+`PGAggregate` extends `alembic_utils` to manage custom PostgreSQL aggregate functions in Alembic migrations.
+
+```python
+from flask_postgresql_audit.extensions.alembic_utils import PGAggregate
+
+# Example: Define custom aggregate function entity
+sum_agg = PGAggregate(
+    schema="public",
+    signature="custom_sum(numeric)",
+    definition="(SFUNC = numeric_add, STYPE = numeric, INITCOND = '0')",
+)
+```
+
+Automatically detects and tracks custom `CREATE AGGREGATE` definitions during `alembic revision --autogenerate`.
+
 ## Running the tests
 
     git clone https://github.com/higamigu/flask-postgresql-audit.git

flask_postgresql_audit-1.1.1/README.md

@@ -0,0 +1,276 @@
+# Flask-PostgreSQL-Audit
+
+![BuildStatus](https://github.com/higamigu/flask-postgresql-audit/actions/workflows/test.yml/badge.svg?branch=main)
+[![VersionStatus](https://img.shields.io/pypi/v/flask-postgresql-audit.svg)](https://pypi.org/project/flask-postgresql-audit/)
+
+Auditing extension for Flask-SQLAlchemy with PostgreSQL.
+Forked from [PostgreSQL-Audit](https://github.com/kvesteri/postgresql-audit), tries to combine the best of breed from existing solutions such as
+[SQLAlchemy-Continuum](https://github.com/kvesteri/SQLAlchemy-Continuum),
+[Papertrail](https://github.com/airblade/paper_trail) and especially
+[Audit Trigger by 2ndQuadrant](https://github.com/2ndQuadrant/audit-trigger).
+
+-   Stores audit recordss into single table called `pga_activity`
+-   Uses trigger based approach to keep INSERTs, UPDATEs
+    and DELETEs as fast as possible
+-   Tracks and stores actor identities into table called `pga_transaction`
+-   Uses Alembic and Alembic-Utils to generate necessary database objects for migration
+
+## Installation
+```
+pip install flask-postgresql-audit
+```
+or using `uv`
+```
+uv add flask-postgresql-audit
+```
+or install directly from this repo
+```
+uv add git+https://github.com/higamigu/flask-postgresql-audit --tag v1.1.0
+```
+
+## Usage
+
+``` python
+from flask_sqlalchemy import SQLAlchemy
+from flask_postgresql_audit import PostgreSQLAudit, Audit
+
+from my_app import app  # your flask app
+
+db = SQLAlchemy()
+audit = PostgreSQLAudit()
+
+
+class Article(db.Model, Audit):
+    __tablename__ = "article"
+
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String)
+
+
+db.init_app(app)
+audit.init_app(app, db)
+
+article = Article(name="Some article")
+db.session.add(article)
+db.session.commit()
+```
+Then generate migration file
+```
+flask db migrate -m "pg audit initial migration"
+flask db upgrade
+```
+
+Now we can check the newly created activity.
+
+``` python
+activity = db.session.scalar(select(audit.Activity))
+activity.id  # 1
+activity.table_name  # 'article'
+activity.verb  # 'insert'
+activity.old_data  # None
+activity.changed_data  # {'id': '1', 'name': 'Some article'}
+```
+
+``` python
+article.name = "Some other article"
+db.session.commit()
+
+activity = db.session.scalar(select(audit.Activity).order_by(desc("id")))
+activity.id  # 2
+activity.table_name  # 'article'
+activity.verb  # 'update'
+activity.object_id  # 1
+activity.old_data  # {'id': '1', 'name': 'Some article'}
+activity.changed_data  # {'name': 'Some other article'}
+```
+
+``` python
+db.session.delete(article)
+db.session.commit()
+
+activity = db.session.scalar(select(audit.Activity).order_by(desc("id")))
+activity.id  # 3
+activity.table_name  # 'article'
+activity.verb  # 'delete'
+activity.object_id  # 1
+activity.old_data  # {'id': '1', 'name': 'Some other article'}
+activity.changed_data  # None
+```
+
+## Querying Activity History
+
+Instead of querying `audit.Activity` manually, you can use `fetch_activity()` to retrieve the audit trail for a model class, a single model instance, or a sequence/list of model instances:
+
+``` python
+# Query activity for a specific model class (e.g. Article)
+stmt = audit.fetch_activity(Article)
+activities = db.session.execute(stmt).all()
+
+# Query activity for a specific article instance
+stmt = audit.fetch_activity(article)
+activities = db.session.execute(stmt).all()
+
+# Query activity for multiple instances
+stmt = audit.fetch_activity([article1, article2])
+activities = db.session.execute(stmt).all()
+```
+
+The returned statement is a SQLAlchemy `select` object that joins `Activity` and `Transaction` tables, ordered by activity ID descending. You can further customize or execute this statement.
+
+## Different Schema
+You can isolate `pg_audit` objects entirely to a different schema by doing
+
+``` python
+from flask_postgresql_audit import PostgreSQLAudit
+
+audit = PostgreSQLAudit(schema="audit")
+
+...
+```
+And then you need to tell alembic to track other than `public` schema by adding following line in `alembic/env.py`
+``` python
+...
+
+def run_migrations_online():
+    connectable = get_engine()
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=get_metadata(),
+            include_schemas=True, # add this arg
+            ...
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+...
+```
+
+## Custom Actor ID getter
+You can customize actor id getter function by doing the following. Here is an example using `current_user` from `flask_jwt_extended` library.
+
+``` python
+from flask_jwt_extended import jwt_required, current_user
+
+
+@jwt_required(optional=True)
+def actor_id_getter():
+    try:
+        return current_user.email or None
+    except Exception:
+        return None
+
+
+...
+
+audit = PostgreSQLAudit(actor_id_getter=actor_id_getter)
+
+...
+```
+
+## Enable Alembic Logger
+You can enable alembic logger for `pg_audit` by adding the following to your `alembic.ini`
+``` ini
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic,alembic_utils,pg_audit # add 'pg_audit' here
+
+...
+
+[logger_pg_audit]  # and add the logger for pg_audit here
+level = INFO
+handlers =
+qualname = pg_audit
+```
+
+## Troubleshooting
+
+### Activity not being recorded?
+
+1. **Check triggers are installed**: Run `flask db upgrade` after installing the extension
+2. **Verify audit is initialized**: Ensure you called `audit.init_app(app, db)` before using models
+3. **Commit after changes**: Audit records are only created on `db.session.commit()`
+
+### Actor tracking not working?
+
+The default actor ID getter tries to import `flask_login.current_user`. If you're not using Flask-Login:
+
+1. Provide your own `actor_id_getter` function:
+   ```python
+   def my_actor_id():
+       return current_user.id if current_user.is_authenticated else None
+   ```
+
+2. Pass it to the extension: `audit = PostgreSQLAudit(actor_id_getter=my_actor_id)`
+
+### Using a custom schema?
+
+1. Set schema when creating audit: `audit = PostgreSQLAudit(schema_name="my_schema")`
+2. Configure Alembic to track multiple schemas (see "Different Schema" section)
+3. Add `"include_schemas=True"` to `alembic/env.py` in `run_migrations_online()`
+
+### Fetching activity for custom models?
+
+The `fetch_activity()` method works with:
+- A model class: `audit.fetch_activity(MyModel)`
+- A single instance: `audit.fetch_activity(my_instance)`
+- Multiple instances: `audit.fetch_activity([instance1, instance2])`
+
+## Extensions
+
+### Document Staging
+
+The `document_staging` extension provides document lifecycle management and version revision tracking for models.
+
+```python
+from flask_postgresql_audit.extensions.document_staging import (
+    DocumentStaging,
+    Docstatus,
+    attach_listener,
+)
+
+
+class Article(BaseModel, DocumentStaging):
+    __tablename__ = "article"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    title: Mapped[str]
+
+
+# Attach session listener for automatic actor and timestamp tracking
+attach_listener()
+```
+
+#### Lifecycle & Transitions
+
+- **`Docstatus` states**: `DRAFT` (0), `SUBMITTED` (1), `CANCELLED` (2), `REVISED` (3).
+- **`doc.bump()`**: Advances document status (`DRAFT` -> `SUBMITTED` -> `CANCELLED`).
+- **`doc.revise(new_doc)`**: Creates a new revision `new_doc` from a `CANCELLED` document and sets state to `REVISED`.
+- **`doc.delete(session)`**: Deletes a `DRAFT` document. If it was a revision, reverts parent document status back to `CANCELLED`.
+- **Automatic Fields**: `created_by`, `created_on`, `submitted_by`, `submitted_on`, `cancelled_by`, `cancelled_on` are automatically set during session flush events.
+
+### Custom PostgreSQL Aggregates (`alembic_utils`)
+
+`PGAggregate` extends `alembic_utils` to manage custom PostgreSQL aggregate functions in Alembic migrations.
+
+```python
+from flask_postgresql_audit.extensions.alembic_utils import PGAggregate
+
+# Example: Define custom aggregate function entity
+sum_agg = PGAggregate(
+    schema="public",
+    signature="custom_sum(numeric)",
+    definition="(SFUNC = numeric_add, STYPE = numeric, INITCOND = '0')",
+)
+```
+
+Automatically detects and tracks custom `CREATE AGGREGATE` definitions during `alembic revision --autogenerate`.
+
+## Running the tests
+
+    git clone https://github.com/higamigu/flask-postgresql-audit.git
+    cd flask-postgresql-audit
+    pip install tox
+    createdb postgresql_audit_test
+    tox

{flask_postgresql_audit-1.1.0 → flask_postgresql_audit-1.1.1}/flask_postgresql_audit/__init__.py

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

{flask_postgresql_audit-1.1.0 → flask_postgresql_audit-1.1.1}/flask_postgresql_audit/alembic/schema.py

@@ -33,15 +33,15 @@ class SchemaDrop(SchemaOperation):
 @Operations.implementation_for(SchemaCreate)
 def create_schema(operations: Operations, operation: SchemaCreate):
     stmt = f"""
-        CREATE SCHEMA {operation.schema_name};
-        REVOKE ALL ON SCHEMA {operation.schema_name} FROM public;
+        CREATE SCHEMA "{operation.schema_name}";
+        REVOKE ALL ON SCHEMA "{operation.schema_name}" FROM public;
     """
     operations.execute(text(stmt))
 
 
 @Operations.implementation_for(SchemaDrop)
 def drop_schema(operations: Operations, operation: SchemaDrop):
-    stmt = f"DROP SCHEMA {operation.schema_name} CASCADE;"
+    stmt = f'DROP SCHEMA "{operation.schema_name}" CASCADE;'
     operations.execute(text(stmt))
 
 

{flask_postgresql_audit-1.1.0 → flask_postgresql_audit-1.1.1}/flask_postgresql_audit/alembic/setup.py

@@ -12,7 +12,7 @@ from sqlalchemy import Connection, text
 from sqlalchemy.orm import Session
 
 from . import entities
-from .schema import SchemaCreate
+from .schema import SchemaCreate, SchemaDrop
 
 if TYPE_CHECKING:
     from alembic_utils.replaceable_entity import ReplaceableEntity
@@ -37,9 +37,11 @@ def setup_db(audit: "PostgreSQLAudit"):
         if connection := autogen_context.connection:
             check_schema = """
                 SELECT TRUE FROM information_schema.schemata
-                WHERE schema_name = '{name}'
-            """.format(name=audit.context["schema_name"])
-            if not connection.scalar(text(check_schema)):
+                WHERE schema_name = :name
+            """
+            if not connection.scalar(
+                text(check_schema), {"name": audit.context["schema_name"]}
+            ):
                 upgrade_ops.ops.append(SchemaCreate(audit.context["schema_name"]))
 
             for ent in audit.pg_audit_entities:
@@ -83,6 +85,29 @@ def reorder_migration_ops(context, revision, directives: list[MigrationScript]):
         # Reassemble the ops sequence in strict dependency order
         directive.upgrade_ops.ops = schema_ops + extension_ops + other_ops + trigger_ops
 
+        if hasattr(directive, "downgrade_ops") and directive.downgrade_ops is not None:
+            downgrade_ops = directive.downgrade_ops.ops
+            d_schema_ops = []
+            d_extension_ops = []
+            d_trigger_ops = []
+            d_other_ops = []
+            for op in downgrade_ops:
+                target = getattr(op, "target", None)
+                if isinstance(op, SchemaDrop):
+                    d_schema_ops.append(op)
+                elif (
+                    target is not None
+                    and getattr(target, "signature", None) == "btree_gist"
+                ):
+                    d_extension_ops.append(op)
+                elif target is not None:
+                    d_trigger_ops.append(op)
+                else:
+                    d_other_ops.append(op)
+            directive.downgrade_ops.ops = (
+                d_trigger_ops + d_other_ops + d_extension_ops + d_schema_ops
+            )
+
 
 def chain_revision_directives(*callbacks):
     """

{flask_postgresql_audit-1.1.0 → flask_postgresql_audit-1.1.1}/flask_postgresql_audit/core.py

@@ -1,6 +1,7 @@
 import inspect
 import typing as t
 from contextlib import contextmanager
+from contextvars import ContextVar
 from itertools import groupby
 
 import sqlalchemy as sa
@@ -13,9 +14,11 @@ from sqlalchemy.util import OrderedSet
 
 from .alembic import register_triggers, setup_db
 from .models import activity_model_factory, transaction_model_factory
-from .typing import AnyAttrribute
+from .typing import AnyAttribute
 from .utils import load_template
 
+_pg_audit_enabled: ContextVar[bool] = ContextVar("pg_audit_enabled", default=True)
+
 if t.TYPE_CHECKING:
     from sqlalchemy.sql.functions import _FunctionGenerator
 
@@ -76,7 +79,7 @@ def get_modified_columns(obj: orm.DeclarativeBase):
         if not attr.history.has_changes():
             continue
 
-        cls_attr: AnyAttrribute = getattr(obj.__class__, key)
+        cls_attr: AnyAttribute = getattr(obj.__class__, key)
         prop = cls_attr.property
         if isinstance(prop, orm.ColumnProperty):
             modified.update(prop.columns)
@@ -139,11 +142,18 @@ def _default_client_addr() -> str | None:
 
 class PostgreSQLAudit:
     pg_audit_classes: set[type[Audit]]
-    pg_audit_enabled: bool
     pg_audit_entities: OrderedSet[ReplaceableEntity]
 
     options: dict[str, t.Any]
 
+    @property
+    def pg_audit_enabled(self) -> bool:
+        return _pg_audit_enabled.get()
+
+    @pg_audit_enabled.setter
+    def pg_audit_enabled(self, value: bool) -> None:
+        _pg_audit_enabled.set(value)
+
     def __init__(
         self,
         *,

{flask_postgresql_audit-1.1.0 → flask_postgresql_audit-1.1.1}/flask_postgresql_audit/typing.py

@@ -6,4 +6,4 @@ T = TypeVar("T")
 OMap = Mapped[T | None]  # Optional Mapped / Nullable
 
 
-AnyAttrribute = InstrumentedAttribute[Any]
+AnyAttribute = InstrumentedAttribute[Any]

{flask_postgresql_audit-1.1.0 → flask_postgresql_audit-1.1.1}/pyproject.toml

@@ -1,7 +1,7 @@
 
 
 [project]
-name = "flask-postgresql_audit"
+name = "flask-postgresql-audit"
 dynamic = ["version"]
 description = "Versioning and auditing extension for PostgreSQL and SQLAlchemy."
 readme = "README.md"

{flask_postgresql_audit-1.1.0 → flask_postgresql_audit-1.1.1}/tests/test_defaults.py

@@ -5,7 +5,7 @@ from .app import User, audit, db
 
 
 @pytest.mark.usefixtures("test_client")
-class TestCustomSchemaactivityCreation:
+class TestCustomSchemaActivityCreation:
     def test_insert(self, user):
         stmt = sa.select(audit.Activity).limit(1)
         if activity := db.session.scalar(stmt):

{flask_postgresql_audit-1.1.0 → flask_postgresql_audit-1.1.1}/tests/utils.py

@@ -76,7 +76,7 @@ def downgrade(engine: Engine, alembic_cfg_path: Path, **kw):
         alembic_config("downgrade", engine, alembic_cfg_path, **kw) as cfg,
         contextlib.redirect_stdout(stdout),
     ):
-        command.upgrade(cfg, **kw)
+        command.downgrade(cfg, **kw)
     return stdout.getvalue()
 
 

flask_postgresql_audit-1.1.0/README.md

@@ -1,170 +0,0 @@
-# Flask-PostgreSQL-Audit
-
-![BuildStatus](https://github.com/higamigu/flask-postgresql-audit/actions/workflows/test.yml/badge.svg?branch=main)
-[![VersionStatus](https://img.shields.io/pypi/v/flask-postgresql-audit.svg)](https://pypi.org/project/flask-postgresql-audit/)
-
-Auditing extension for Flask-SQLAlchemy with PostgreSQL.
-Forked from [PostgreSQL-Audit](https://github.com/kvesteri/postgresql-audit), tries to combine the best of breed from existing solutions such as
-[SQLAlchemy-Continuum](https://github.com/kvesteri/SQLAlchemy-Continuum),
-[Papertrail](https://github.com/airblade/paper_trail) and especially
-[Audit Trigger by 2ndQuadrant](https://github.com/2ndQuadrant/audit-trigger).
-
--   Stores audit recordss into single table called `pga_activity`
--   Uses trigger based approach to keep INSERTs, UPDATEs
-    and DELETEs as fast as possible
--   Tracks and stores actor identities into table called `pga_transaction`
--   Uses Alembic and Alembic-Utils to generate necessary database objects for migration
-
-## Installation
-```
-pip install flask-postgresql-audit
-```
-or using `uv`
-```
-uv add flask-postgresql-audit
-```
-or install directly from this repo
-```
-uv add git+https://github.com/higamigu/flask-postgresql-audit --tag v1.0.0
-```
-
-## Usage
-
-``` python
-from flask_sqlalchemy import SQLAlchemy
-from flask_postgresql_audit import PostgreSQLAudit, Audit
-
-from my_app import app  # your flask app
-
-db = SQLAlchemy()
-audit = PostgreSQLAudit()
-
-class Article(db.Model, Audit):
-    __tablename__ = 'article'
-
-    id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String)
-
-db.init_app(app)
-audit.init_app(app, db)
-
-article = Article(name='Some article')
-db.session.add(article)
-db.session.commit()
-```
-Then generate migration file
-```
-flask db migrate -m "pg audit initial migration"
-flask db upgrade
-```
-
-Now we can check the newly created activity.
-
-``` python
-activity = db.session.scalar(select(audit.Activity))
-activity.id             # 1
-activity.table_name     # 'article'
-activity.verb           # 'insert'
-activity.old_data       # None
-activity.changed_data   # {'id': '1', 'name': 'Some article'}
-```
-
-``` python
-article.name = 'Some other article'
-db.session.commit()
-
-activity = db.session.scalar(select(audit.Activity).order_by(desc("id")))
-activity.id             # 2
-activity.table_name     # 'article'
-activity.verb           # 'update'
-activity.object_id      # 1
-activity.old_data       # {'id': '1', 'name': 'Some article'}
-activity.changed_data   # {'name': 'Some other article'}
-```
-
-``` python
-db.session.delete(article)
-db.session.commit()
-
-activity = db.session.scalar(select(audit.Activity).order_by(desc("id")))
-activity.id             # 3
-activity.table_name     # 'article'
-activity.verb           # 'delete'
-activity.object_id      # 1
-activity.old_data       # {'id': '1', 'name': 'Some other article'}
-activity.changed_data   # None
-```
-
-## Different Schema
-You can isolate `pg_audit` objects entirely to a different schema by doing
-
-``` python
-from flask_postgresql_audit import PostgreSQLAudit
-
-audit = PostgreSQLAudit(schema="audit")
-
-...
-```
-And then you need to tell alembic to track other than `public` schema by adding following line in `alembic/env.py`
-``` python
-...
-
-def run_migrations_online():
-    connectable = get_engine()
-
-    with connectable.connect() as connection:
-        context.configure(
-            connection=connection,
-            target_metadata=get_metadata(),
-            include_schemas=True, # add this arg
-            ...
-        )
-
-        with context.begin_transaction():
-            context.run_migrations()
-
-...
-```
-
-## Custom Actor ID getter
-You can customize actor id getter function by doing the following. Here is an example using `current_user` from `flask_jwt_extended` library.
-
-``` python
-from flask_jwt_extended import jwt_required, current_user
-
-@jwt_required(optional=True)
-def actor_id_getter():
-    try:
-        return current_user.email or None
-    except Exception:
-        return None
-
-...
-
-audit = PostgreSQLAudit(actor_id_getter=actor_id_getter)
-
-...
-```
-
-## Enable Alembic Logger
-You can enable alembic logger for `pg_audit` by adding the following to your `alembic.ini`
-``` ini
-# Logging configuration
-[loggers]
-keys = root,sqlalchemy,alembic,alembic_utils,pg_audit # add 'pg_audit' here
-
-...
-
-[logger_pg_audit]  # and add the logger for pg_audit here
-level = INFO
-handlers =
-qualname = pg_audit
-```
-
-## Running the tests
-
-    git clone https://github.com/higamigu/flask-postgresql-audit.git
-    cd flask-postgresql-audit
-    pip install tox
-    createdb postgresql_audit_test
-    tox

flask_postgresql_audit-1.1.0/flask_postgresql_audit/descriptors.py

@@ -1,38 +0,0 @@
-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.Callable[t.Concatenate[t.Any, _P], _R] | None = 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: object | None, owner: 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.1.0/flask_postgresql_audit/templates/create_schema.sql

@@ -1,2 +0,0 @@
-CREATE SCHEMA ${schema_name};
-REVOKE ALL ON SCHEMA ${schema_name} FROM public;

flask_postgresql_audit-1.1.0/flask_postgresql_audit/templates/drop_schema.sql

@@ -1 +0,0 @@
-DROP SCHEMA ${schema_name} CASCADE;

flask_postgresql_audit-1.1.0/flask_postgresql_audit/templates/row_audit_trigger.sql

@@ -1,4 +0,0 @@
-CREATE TRIGGER audit_trigger AFTER INSERT OR UPDATE OR DELETE ON ${table_name}
-FOR EACH ROW
-WHEN (${schema_prefix}get_setting('flask_pga.enable_audit', 'true')::bool)
-EXECUTE PROCEDURE ${schema_prefix}create_activity(${excluded_columns})

flask_postgresql_audit-1.1.0/flask_postgresql_audit/templates/row_create_activity.sql

@@ -1,48 +0,0 @@
-CREATE OR REPLACE FUNCTION ${schema_prefix}create_activity() RETURNS TRIGGER AS $$
-DECLARE
-    audit_row ${schema_prefix}pga_activity;
-    excluded_cols text[] = ARRAY[]::text[];
-BEGIN
-    audit_row.id = nextval('${schema_prefix}pga_activity_id_seq');
-    audit_row.schema_name = TG_TABLE_SCHEMA::text;
-    audit_row.table_name = TG_TABLE_NAME::text;
-    audit_row.relid = TG_RELID;
-    audit_row.issued_at = statement_timestamp() AT TIME ZONE 'UTC';
-    audit_row.native_transaction_id = txid_current();
-    audit_row.transaction_id = (
-        SELECT id
-        FROM ${schema_prefix}pga_transaction
-        WHERE native_transaction_id = txid_current()
-            AND issued_at >= (NOW() - INTERVAL '1 day')
-        ORDER BY issued_at DESC
-        LIMIT 1
-    );
-    audit_row.verb = LOWER(TG_OP);
-    audit_row.old_data = '{}'::jsonb;
-    audit_row.changed_data = '{}'::jsonb;
-
-    IF TG_ARGV[0] IS NOT NULL THEN
-        excluded_cols = TG_ARGV[0]::text[];
-    END IF;
-
-    IF (TG_OP = 'UPDATE' AND TG_LEVEL = 'ROW') THEN
-        audit_row.old_data = row_to_json(OLD.*)::jsonb - excluded_cols;
-        audit_row.changed_data = (
-            row_to_json(NEW.*)::jsonb - audit_row.old_data - excluded_cols
-        );
-        IF audit_row.changed_data = '{}'::jsonb THEN
-            -- All changed fields are ignored. Skip this update.
-            RETURN NULL;
-        END IF;
-    ELSIF (TG_OP = 'DELETE' AND TG_LEVEL = 'ROW') THEN
-        audit_row.old_data = row_to_json(OLD.*)::jsonb - excluded_cols;
-    ELSIF (TG_OP = 'INSERT' AND TG_LEVEL = 'ROW') THEN
-        audit_row.changed_data = row_to_json(NEW.*)::jsonb - excluded_cols;
-    END IF;
-    INSERT INTO ${schema_prefix}pga_activity VALUES (audit_row.*);
-    RETURN NULL;
-END;
-$$
-LANGUAGE plpgsql
-SECURITY DEFINER
-SET search_path = pg_catalog, public;