flask-postgresql-audit 1.1.3__tar.gz → 1.2.0__tar.gz

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/CHANGES.md

@@ -3,6 +3,22 @@
 Here you can see the full list of changes between each Flask-PostgreSQL-Audit
 release.
 
+## 1.2.0 (2026-11-13)
+
+-   Add support for psycopg 3 and make it the default PostgreSQL driver.
+-   Keep psycopg2 support available through the `psycopg2` optional dependency extra.
+-   Add support for Python 3.14 and 3.15.
+-   Run the test suite against both psycopg 3 and psycopg2.
+-   Add pre-commit hooks for Ruff and the ty type checker.
+-   Add PostgreSQL 15 through 18 as a tox matrix dimension.
+-   Run the tox matrix in parallel with isolated per-worker databases and migrations, capped by the number of PostgreSQL containers.
+-   Add `scripts/run_tox_matrix.py` to run the full tox matrix with one command, including temporary PostgreSQL containers.
+-   Replace deprecated `txid_current()` with `pg_current_xact_id()` and store `native_transaction_id` as PostgreSQL `xid8`. Existing `bigint` columns are migrated with `USING native_transaction_id::text::xid8` when `reorder_migration_ops` is used.
+-   Replace the `native_transaction_id` exclusion constraint with a unique constraint. This keeps one transaction row per database transaction without requiring the `btree_gist` extension, which is no longer created.
+-   Add Alembic autogenerate support for `xid8`, including type reflection and `USING` clauses when `native_transaction_id` changes between `bigint` and `xid8`.
+-   Drop the legacy `native_transaction_id` exclusion constraint during autogenerate and restore it on downgrade, so the generated migration runs without manual edits.
+-   Re-register audit entities after blind create detection, keeping repeated autogenerate runs in the same process accurate.
+
 ## 1.1.3 (2026-08-21)
 
 -   Add `jsonb_diff()` function to recursively compute differences across JSONB objects and arrays.

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: flask-postgresql-audit
-Version: 1.1.3
+Version: 1.2.0
 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>
@@ -15,6 +15,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
@@ -22,7 +24,9 @@ Requires-Dist: alembic-utils>=0.8.8
 Requires-Dist: alembic>=1.18.0
 Requires-Dist: flask-sqlalchemy>=3.1.1
 Requires-Dist: flask>=3.1.2
-Requires-Dist: psycopg2>=2.9.11
+Requires-Dist: psycopg[binary]>=3.2
+Provides-Extra: psycopg2
+Requires-Dist: psycopg2>=2.9.11; extra == 'psycopg2'
 Description-Content-Type: text/markdown
 
 # Flask-PostgreSQL-Audit
@@ -55,6 +59,30 @@ or install directly from this repo
 uv add git+https://github.com/higamigu/flask-postgresql-audit --tag v1.1.0
 ```
 
+The package installs [psycopg 3](https://www.psycopg.org/psycopg3/) as its default
+PostgreSQL driver. If your application uses the legacy `psycopg2` driver,
+install it with the optional extra:
+
+```
+pip install "flask-postgresql-audit[psycopg2]"
+```
+
+## Database Drivers
+
+Both psycopg 3 and psycopg2 are supported. Select the driver in your
+SQLAlchemy database URL:
+
+``` python
+# psycopg 3 (default)
+SQLALCHEMY_DATABASE_URI = "postgresql+psycopg://user:password@localhost/database"
+
+# psycopg2
+SQLALCHEMY_DATABASE_URI = "postgresql+psycopg2://user:password@localhost/database"
+```
+
+The extension requires Python 3.11 or newer and is tested on Python 3.11 through
+3.15.
+
 ## Usage
 
 ``` python
@@ -268,6 +296,13 @@ context.configure(
 )
 ```
 
+`reorder_migration_ops` also adds the required `USING` clauses when
+`native_transaction_id` is migrated between `bigint` and `xid8`. When the
+database still has the `1.0.x` exclusion constraint on
+`pga_transaction.native_transaction_id`, autogenerate drops it before creating
+the replacement unique constraint and restores it again on downgrade, so the
+generated migration can be applied as-is.
+
 ## Extensions
 
 ### Document Staging
@@ -322,5 +357,32 @@ Automatically detects and tracks custom `CREATE AGGREGATE` definitions during `a
     git clone https://github.com/higamigu/flask-postgresql-audit.git
     cd flask-postgresql-audit
     pip install tox
-    createdb postgresql_audit_test
-    tox
+    python scripts/run_tox_matrix.py
+
+The script provisions PostgreSQL 15 through 18 containers, distributes the tox
+environments across 4 parallel workers by default, and prints a pass/skip/fail
+summary. Each worker gets its own database and Alembic migration directory, so
+parallel runs cannot reset each other's schemas. Worker count is capped at the
+number of PostgreSQL containers in the matrix (currently 4). Use `--workers N`
+to change concurrency, `--verbose` to stream test output, `--fail-fast` to stop
+at the first failure (sequential), `--no-postgres` to use an existing database
+(sequential), or `--keep-postgres` to leave the containers running for
+debugging. Install missing interpreters with `mise install python@3.13` or
+`uv python install 3.13` to include them.
+
+To run a single environment, provide a matching PostgreSQL server yourself:
+
+    tox -e py315-pg18-schemaDefault-psycopg
+
+The default driver is psycopg 3. For psycopg2, select the matching environment:
+
+    tox -e py315-pg18-schemaDefault-psycopg2
+
+## Pre-commit hooks
+
+The repository uses [pre-commit](https://pre-commit.com/) to run Ruff and the
+[ty](https://github.com/astral-sh/ty) type checker before each commit:
+
+    pip install pre-commit
+    pre-commit install
+    pre-commit run --all-files

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/README.md

@@ -28,6 +28,30 @@ or install directly from this repo
 uv add git+https://github.com/higamigu/flask-postgresql-audit --tag v1.1.0
 ```
 
+The package installs [psycopg 3](https://www.psycopg.org/psycopg3/) as its default
+PostgreSQL driver. If your application uses the legacy `psycopg2` driver,
+install it with the optional extra:
+
+```
+pip install "flask-postgresql-audit[psycopg2]"
+```
+
+## Database Drivers
+
+Both psycopg 3 and psycopg2 are supported. Select the driver in your
+SQLAlchemy database URL:
+
+``` python
+# psycopg 3 (default)
+SQLALCHEMY_DATABASE_URI = "postgresql+psycopg://user:password@localhost/database"
+
+# psycopg2
+SQLALCHEMY_DATABASE_URI = "postgresql+psycopg2://user:password@localhost/database"
+```
+
+The extension requires Python 3.11 or newer and is tested on Python 3.11 through
+3.15.
+
 ## Usage
 
 ``` python
@@ -241,6 +265,13 @@ context.configure(
 )
 ```
 
+`reorder_migration_ops` also adds the required `USING` clauses when
+`native_transaction_id` is migrated between `bigint` and `xid8`. When the
+database still has the `1.0.x` exclusion constraint on
+`pga_transaction.native_transaction_id`, autogenerate drops it before creating
+the replacement unique constraint and restores it again on downgrade, so the
+generated migration can be applied as-is.
+
 ## Extensions
 
 ### Document Staging
@@ -295,5 +326,32 @@ Automatically detects and tracks custom `CREATE AGGREGATE` definitions during `a
     git clone https://github.com/higamigu/flask-postgresql-audit.git
     cd flask-postgresql-audit
     pip install tox
-    createdb postgresql_audit_test
-    tox
+    python scripts/run_tox_matrix.py
+
+The script provisions PostgreSQL 15 through 18 containers, distributes the tox
+environments across 4 parallel workers by default, and prints a pass/skip/fail
+summary. Each worker gets its own database and Alembic migration directory, so
+parallel runs cannot reset each other's schemas. Worker count is capped at the
+number of PostgreSQL containers in the matrix (currently 4). Use `--workers N`
+to change concurrency, `--verbose` to stream test output, `--fail-fast` to stop
+at the first failure (sequential), `--no-postgres` to use an existing database
+(sequential), or `--keep-postgres` to leave the containers running for
+debugging. Install missing interpreters with `mise install python@3.13` or
+`uv python install 3.13` to include them.
+
+To run a single environment, provide a matching PostgreSQL server yourself:
+
+    tox -e py315-pg18-schemaDefault-psycopg
+
+The default driver is psycopg 3. For psycopg2, select the matching environment:
+
+    tox -e py315-pg18-schemaDefault-psycopg2
+
+## Pre-commit hooks
+
+The repository uses [pre-commit](https://pre-commit.com/) to run Ruff and the
+[ty](https://github.com/astral-sh/ty) type checker before each commit:
+
+    pip install pre-commit
+    pre-commit install
+    pre-commit run --all-files

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/flask_postgresql_audit/__init__.py

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

flask_postgresql_audit-1.2.0/flask_postgresql_audit/alembic/__init__.py

@@ -0,0 +1,9 @@
+# ruff: noqa: F401
+from .constraint import NativeTransactionConstraintOp, legacy_constraint_op
+from .setup import (
+    chain_revision_directives,
+    register_triggers,
+    reorder_migration_ops,
+    setup_db,
+)
+from .xid8 import apply_xid8_type_changes, register_xid8_type

flask_postgresql_audit-1.2.0/flask_postgresql_audit/alembic/constraint.py

@@ -0,0 +1,105 @@
+"""Alembic support for the native transaction ID constraint swap.
+
+Version ``1.1.x`` replaced the ``gist`` exclusion constraint on
+``pga_transaction.native_transaction_id`` with a plain unique constraint.
+Alembic never reflects exclusion constraints, so autogenerate cannot see the
+legacy constraint and would emit ``create_unique_constraint`` while the old
+constraint still owns the name, failing with a duplicate constraint error.
+
+The operations below drop the legacy constraint before the ``bigint`` to
+``xid8`` type change and restore it again on downgrade.
+"""
+
+from __future__ import annotations
+
+import typing as t
+
+from alembic.autogenerate import renderers
+from alembic.operations import MigrateOperation
+from sqlalchemy import Connection, text
+
+if t.TYPE_CHECKING:
+    from alembic.autogenerate.api import AutogenContext
+
+CONSTRAINT_NAME = "pga_transaction_unique_native_tx_id"
+TABLE_NAME = "pga_transaction"
+EXCLUSION_ELEMENTS = (
+    "native_transaction_id WITH =",
+    "tsrange(issued_at - INTERVAL '1 hour', issued_at) WITH &&",
+)
+
+
+class NativeTransactionConstraintOp(MigrateOperation):
+    """Drop or create the legacy native transaction ID exclusion constraint."""
+
+    def __init__(self, *, drop_sql: str, create_sql: str, drop: bool = True) -> None:
+        self.drop_sql = drop_sql
+        self.create_sql = create_sql
+        self.drop = drop
+
+    @property
+    def sqltext(self) -> str:
+        return self.drop_sql if self.drop else self.create_sql
+
+    def reverse(self) -> NativeTransactionConstraintOp:
+        return NativeTransactionConstraintOp(
+            drop_sql=self.drop_sql,
+            create_sql=self.create_sql,
+            drop=not self.drop,
+        )
+
+    def to_diff_tuple(self) -> tuple[t.Any, ...]:
+        verb = (
+            "drop_exclusion_constraint" if self.drop else "create_exclusion_constraint"
+        )
+        return (verb, TABLE_NAME, CONSTRAINT_NAME)
+
+    def describe(self) -> str:  # pragma: no cover - debugging aid
+        return self.sqltext
+
+
+@renderers.dispatch_for(NativeTransactionConstraintOp)
+def render_native_transaction_constraint(
+    autogen_context: AutogenContext, op: NativeTransactionConstraintOp
+) -> str:
+    return f"op.execute({op.sqltext!r})"
+
+
+def legacy_constraint_op(
+    connection: Connection, schema_name: str | None
+) -> NativeTransactionConstraintOp | None:
+    """Return an operation dropping the legacy exclusion constraint if present."""
+    schema = schema_name or "public"
+    query = text(
+        """
+        SELECT c.contype
+        FROM pg_constraint AS c
+        JOIN pg_class AS t ON t.oid = c.conrelid
+        JOIN pg_namespace AS n ON n.oid = t.relnamespace
+        WHERE t.relname = :table
+          AND n.nspname = :schema
+          AND c.conname = :constraint
+        """
+    )
+    contype = connection.scalar(
+        query,
+        {
+            "table": TABLE_NAME,
+            "schema": schema,
+            "constraint": CONSTRAINT_NAME,
+        },
+    )
+    if contype != "x":
+        return None
+
+    preparer = connection.dialect.identifier_preparer
+    table = f"{preparer.quote_schema(schema)}.{preparer.quote(TABLE_NAME)}"
+    constraint = preparer.quote(CONSTRAINT_NAME)
+
+    return NativeTransactionConstraintOp(
+        drop_sql=f"ALTER TABLE {table} DROP CONSTRAINT {constraint}",
+        create_sql=(
+            f"ALTER TABLE {table} ADD CONSTRAINT {constraint}"
+            f" EXCLUDE USING gist ({', '.join(EXCLUSION_ELEMENTS)})"
+        ),
+    )

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/flask_postgresql_audit/alembic/entities.py

@@ -1,11 +1,8 @@
-from alembic_utils.pg_extension import PGExtension
 from alembic_utils.pg_function import PGFunction
 from alembic_utils.pg_trigger import PGTrigger
 
 from ..utils import parse_template
 
-btree_gist = PGExtension(schema="public", signature="btree_gist")
-
 
 def create_activity_factory(**context):
     sql = parse_template("create_activity.sql", **context)

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/flask_postgresql_audit/alembic/setup.py

@@ -12,7 +12,9 @@ from sqlalchemy import Connection, text
 from sqlalchemy.orm import Session
 
 from . import entities
+from .constraint import legacy_constraint_op
 from .schema import SchemaCreate, SchemaDrop
+from .xid8 import apply_xid8_type_changes, register_xid8_type
 
 if TYPE_CHECKING:
     from alembic_utils.replaceable_entity import ReplaceableEntity
@@ -22,8 +24,28 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger("pg_audit.setup")
 
+# Entities temporarily removed from the alembic_utils registry while blind
+# create operations are generated. They are re-registered after autogenerate
+# so a second autogenerate in the same process (test suites, compare_metadata)
+# still sees them.
+_blind_entities: list["ReplaceableEntity"] = []
+
+
+def restore_blind_entities() -> None:
+    """Re-register entities hidden by a previous blind-create comparison."""
+    if _blind_entities:
+        registry.register(_blind_entities)
+        _blind_entities.clear()
+
+
+def _hide_registry_entity(entity: "ReplaceableEntity") -> None:
+    hidden = registry._entities.pop(entity.identity, None)
+    if hidden is not None:
+        _blind_entities.append(hidden)
+
 
 def setup_db(audit: "PostgreSQLAudit"):
+    register_xid8_type()
     register_core_entities(audit)
     register_triggers(audit)
     register_entities(audit.pg_audit_entities)
@@ -34,6 +56,8 @@ def setup_db(audit: "PostgreSQLAudit"):
         upgrade_ops: ops.UpgradeOps,
         schemas: set[None] | set[str | None],
     ) -> None:
+        restore_blind_entities()
+
         if connection := autogen_context.connection:
             check_schema = """
                 SELECT TRUE FROM information_schema.schemata
@@ -44,9 +68,17 @@ def setup_db(audit: "PostgreSQLAudit"):
             ):
                 upgrade_ops.ops.append(SchemaCreate(audit.context["schema_name"]))
 
+            # Alembic cannot reflect exclusion constraints, so the legacy
+            # native transaction ID constraint of 1.0.x must be dropped
+            # explicitly before the unique constraint of 1.1.x is created.
+            if constraint_op := legacy_constraint_op(
+                connection, audit.context["schema_name"]
+            ):
+                upgrade_ops.ops.append(constraint_op)
+
             for ent in audit.pg_audit_entities:
                 if op := get_blind_migration_op(ent, connection):
-                    registry._entities.pop(ent.identity, None)
+                    _hide_registry_entity(ent)
                     upgrade_ops.ops.append(op)
 
 
@@ -54,10 +86,12 @@ def reorder_migration_ops(context, revision, directives: list[MigrationScript]):
     """
     Alembic directive listener that reorders upgrade operations into correct
     dependency order:
-    1. Schema creation & btree_gist extension
+    1. Schema creation
     2. Tables, indexes, foreign keys, etc.
     3. Triggers & Replaceable audit entities
     """
+    apply_xid8_type_changes(directives)
+
     for directive in directives:
         if not hasattr(directive, "upgrade_ops") or directive.upgrade_ops is None:
             continue
@@ -65,48 +99,36 @@ def reorder_migration_ops(context, revision, directives: list[MigrationScript]):
         upgrade_ops = directive.upgrade_ops.ops
 
         schema_ops = []
-        extension_ops = []
         trigger_ops = []
         other_ops = []
 
         for op in upgrade_ops:
             if isinstance(op, SchemaCreate):
                 schema_ops.append(op)
-            elif (
-                isinstance(op, CreateOp)
-                and getattr(op.target, "signature", None) == "btree_gist"
-            ):
-                extension_ops.append(op)
             elif isinstance(op, CreateOp):
                 trigger_ops.append(op)
             else:
                 other_ops.append(op)
 
         # Reassemble the ops sequence in strict dependency order
-        directive.upgrade_ops.ops = schema_ops + extension_ops + other_ops + trigger_ops
+        directive.upgrade_ops.ops = schema_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
-            )
+            directive.downgrade_ops.ops = d_trigger_ops + d_other_ops + d_schema_ops
+
+    restore_blind_entities()
 
 
 def chain_revision_directives(*callbacks):
@@ -123,7 +145,6 @@ def chain_revision_directives(*callbacks):
 
 
 def register_core_entities(audit: "PostgreSQLAudit"):
-    audit.pg_audit_entities.add(entities.btree_gist)
     audit.pg_audit_entities.add(entities.get_pk_values(**audit.context))
     audit.pg_audit_entities.add(entities.get_table_relid(**audit.context))
     audit.pg_audit_entities.add(entities.get_setting_factory(**audit.context))

flask_postgresql_audit-1.2.0/flask_postgresql_audit/alembic/xid8.py

@@ -0,0 +1,95 @@
+from typing import Any
+
+import sqlalchemy as sa
+from alembic.autogenerate import render, renderers
+from alembic.autogenerate.api import AutogenContext
+from alembic.operations import ops
+from sqlalchemy.dialects import postgresql
+from sqlalchemy.dialects.postgresql.base import PGDialect
+
+from ..types import XID8
+
+
+class XID8AlterColumnOp(ops.AlterColumnOp):
+    """Alter column operation that renders a PostgreSQL ``USING`` clause."""
+
+    def __init__(self, *args: Any, postgresql_using: str, **kw: Any) -> None:
+        super().__init__(*args, **kw)
+        self.postgresql_using = postgresql_using
+
+
+@renderers.dispatch_for(XID8AlterColumnOp)
+def render_xid8_alter_column(
+    autogen_context: AutogenContext, op: XID8AlterColumnOp
+) -> str:
+    text = render._alter_column(autogen_context, op)
+    return text[:-1] + f",\n           postgresql_using={op.postgresql_using!r})"
+
+
+def register_xid8_type() -> None:
+    """Register ``xid8`` with SQLAlchemy reflection and Alembic rendering."""
+    # Expose the type through the PostgreSQL dialect so Alembic renders it as
+    # ``postgresql.XID8()`` and imports the dialect in generated migrations.
+    XID8.__module__ = postgresql.__name__
+    if not hasattr(postgresql, "XID8"):
+        postgresql.XID8 = XID8  # ty: ignore[missing-attribute]
+
+    # Let SQLAlchemy reflect existing ``xid8`` columns with this type.
+    PGDialect.ischema_names.setdefault("xid8", XID8)  # ty: ignore[no-matching-overload]
+
+
+def _xid8_using_clause(op: ops.AlterColumnOp) -> str | None:
+    if op.column_name != "native_transaction_id":
+        return None
+
+    existing = op.existing_type
+    modify = op.modify_type
+
+    if isinstance(modify, XID8) and isinstance(existing, sa.BigInteger):
+        return f"{op.column_name}::text::xid8"
+    if isinstance(existing, XID8) and isinstance(modify, sa.BigInteger):
+        return f"{op.column_name}::text::bigint"
+    return None
+
+
+def _make_xid8_alter_column_op(op: ops.AlterColumnOp, using: str) -> XID8AlterColumnOp:
+    kw = dict(op.kw)
+    kw.pop("postgresql_using", None)
+    return XID8AlterColumnOp(
+        op.table_name,
+        op.column_name,
+        schema=op.schema,
+        existing_type=op.existing_type,
+        existing_server_default=op.existing_server_default,
+        existing_nullable=op.existing_nullable,
+        existing_comment=op.existing_comment,
+        modify_nullable=op.modify_nullable,
+        modify_comment=op.modify_comment,
+        modify_server_default=op.modify_server_default,
+        modify_name=op.modify_name,
+        modify_type=op.modify_type,
+        postgresql_using=using,
+        **kw,
+    )
+
+
+def _replace_xid8_ops(container: ops.OpContainer) -> None:
+    for index, op in enumerate(container.ops):
+        if isinstance(op, XID8AlterColumnOp):
+            continue
+        if isinstance(op, ops.AlterColumnOp):
+            if using := _xid8_using_clause(op):
+                container.ops[index] = _make_xid8_alter_column_op(op, using)
+        elif isinstance(op, ops.OpContainer):
+            _replace_xid8_ops(op)
+
+
+def apply_xid8_type_changes(directives: list[Any]) -> None:
+    """Add ``USING`` clauses for ``native_transaction_id`` type migrations."""
+    for directive in directives:
+        for container in (
+            getattr(directive, "upgrade_ops", None),
+            getattr(directive, "downgrade_ops", None),
+        ):
+            if container is not None:
+                _replace_xid8_ops(container)

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/flask_postgresql_audit/base.py

@@ -1,10 +1,11 @@
 from datetime import datetime
 from typing import TYPE_CHECKING, Any
 
-from sqlalchemy import BigInteger, Text, func, text
+from sqlalchemy import BigInteger, Text
 from sqlalchemy.dialects.postgresql import INET, JSONB
 from sqlalchemy.orm import Mapped, declared_attr, mapped_column
 
+from .types import XID8
 from .typing import OMap
 
 
@@ -19,7 +20,7 @@ class ActivityBase:
 
     relid: OMap[int]
     issued_at: OMap[datetime]
-    native_transaction_id: OMap[int] = mapped_column(BigInteger, index=True)
+    native_transaction_id: OMap[int] = mapped_column(XID8, index=True)
     verb: OMap[str] = mapped_column(Text)
 
     row_key: OMap[list[str]] = mapped_column(JSONB, default=[], server_default="[]")
@@ -37,15 +38,10 @@ class TransactionBase:
         actor_id: declared_attr[Any]
 
     id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
-    native_transaction_id: OMap[int] = mapped_column(BigInteger)
+    native_transaction_id: OMap[int] = mapped_column(XID8)
     issued_at: OMap[datetime]
     client_addr: OMap[str] = mapped_column(INET)
 
-    @classmethod
-    def __transaction_interval__(cls):
-        interval = text("INTERVAL '1 hour'")
-        return func.tsrange(cls.issued_at - interval, cls.issued_at)
-
     def __repr__(self):
         return (
             f"<{self.__class__.__name__} id={self.id!r} issued_at={self.issued_at!r}>"

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/flask_postgresql_audit/core.py

@@ -134,10 +134,12 @@ def _default_actor_id() -> int | str | None:
 
 def _default_client_addr() -> str | None:
     try:
-        from flask import request
+        from flask import has_request_context, request
     except ImportError:
         return None
-    return (request and request.remote_addr) or None
+    if not has_request_context():
+        return None
+    return request.remote_addr
 
 
 class PostgreSQLAudit:
@@ -219,7 +221,7 @@ class PostgreSQLAudit:
     def insert_transaction(self, session: orm.Session):
         if self.pg_audit_enabled:
             values = {
-                "native_transaction_id": sa.func.txid_current(),
+                "native_transaction_id": sa.func.pg_current_xact_id(),
                 "issued_at": sa.text("NOW() AT TIME ZONE 'UTC'"),
                 "client_addr": self.get_client_addr(),
                 "actor_id": self.get_actor_id(),
@@ -314,7 +316,7 @@ class PostgreSQLAudit:
         )
 
         if inspect.isclass(obj):
-            class_ = obj
+            class_ = t.cast(type[Audit], obj)
             stmt = stmt.filter(self.Activity.table_name == class_.__tablename__)
 
         else:

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/flask_postgresql_audit/extensions/document_staging/model.py

@@ -41,8 +41,8 @@ class DocumentStaging:
         if not getattr(class_, "__staging_configured__", False):
             table = class_.__table__
 
-            pk_cols = []
-            fk_cols = []
+            pk_cols: list[sa.ColumnClause[t.Any]] = []
+            fk_cols: list[sa.ColumnClause[t.Any]] = []
 
             for pk in table.primary_key.columns:
                 fk_name = f"revision_{pk.name}"

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/flask_postgresql_audit/models.py

@@ -2,7 +2,6 @@ import typing as t
 
 import sqlalchemy as sa
 from sqlalchemy import ForeignKey
-from sqlalchemy.dialects.postgresql import ExcludeConstraint
 from sqlalchemy.orm import declared_attr, mapped_column, relationship
 
 from .base import ActivityBase, TransactionBase
@@ -26,7 +25,7 @@ def activity_model_factory(
     schema_name: str | None = None,
     **kwargs,
 ):
-    class PGAuditActivity(base_cls, activity_base):
+    class PGAuditActivity(base_cls, activity_base):  # ty: ignore[unsupported-base]
         __tablename__ = "pga_activity"
         __table_args__: t.ClassVar[dict[str, t.Any]] = {"schema": schema_name}
 
@@ -53,13 +52,13 @@ def transaction_model_factory(
 
         actor_pk = actor_mapper.primary_key[0]
 
-    class PGAuditTransaction(base_cls, transaction_base):
+    class PGAuditTransaction(base_cls, transaction_base):  # ty: ignore[unsupported-base]
         __tablename__ = "pga_transaction"
 
         @declared_attr
         def actor_id(cls) -> OMap[t.Any]:
             if actor_cls:
-                return mapped_column(actor_pk.type, ForeignKey(actor_pk))  # type: ignore
+                return mapped_column(actor_pk.type, ForeignKey(actor_pk))
             return mapped_column(sa.Text)
 
         if actor_cls:
@@ -69,9 +68,8 @@ def transaction_model_factory(
         @classmethod
         def __table_args__(cls):
             return (
-                ExcludeConstraint(
-                    (cls.native_transaction_id, "="),
-                    (cls.__transaction_interval__(), "&&"),
+                sa.UniqueConstraint(
+                    cls.native_transaction_id,
                     name="pga_transaction_unique_native_tx_id",
                 ),
                 {"schema": schema_name},

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/flask_postgresql_audit/templates/create_activity.sql

@@ -7,7 +7,7 @@ BEGIN
     _transaction_id := (
         SELECT id
         FROM ${schema_prefix}pga_transaction
-        WHERE native_transaction_id = txid_current()
+        WHERE native_transaction_id = pg_current_xact_id()
             AND issued_at >= (NOW() - INTERVAL '1 day')
         ORDER BY issued_at DESC
         LIMIT 1
@@ -27,7 +27,7 @@ BEGIN
             TG_TABLE_NAME::text AS table_name,
             TG_RELID AS relid,
             statement_timestamp() AT TIME ZONE 'UTC' AS issued_at,
-            txid_current() AS native_transaction_id,
+            pg_current_xact_id() AS native_transaction_id,
             LOWER(TG_OP) AS verb,
             ${schema_prefix}get_pk_values(TG_RELID, new_data) AS row_key,
             old_data - excluded_cols AS old_data,
@@ -56,7 +56,7 @@ BEGIN
             TG_TABLE_NAME::text AS table_name,
             TG_RELID AS relid,
             statement_timestamp() AT TIME ZONE 'UTC' AS issued_at,
-            txid_current() AS native_transaction_id,
+            pg_current_xact_id() AS native_transaction_id,
             LOWER(TG_OP) AS verb,
             ${schema_prefix}get_pk_values(TG_RELID, to_jsonb(new_table)) AS row_key,
             '{}'::jsonb AS old_data,
@@ -73,7 +73,7 @@ BEGIN
             TG_TABLE_NAME::text AS table_name,
             TG_RELID AS relid,
             statement_timestamp() AT TIME ZONE 'UTC' AS issued_at,
-            txid_current() AS native_transaction_id,
+            pg_current_xact_id() AS native_transaction_id,
             LOWER(TG_OP) AS verb,
             ${schema_prefix}get_pk_values(TG_RELID, to_jsonb(old_table)) AS row_key,
             row_to_json(old_table.*)::jsonb - excluded_cols AS old_data,

flask_postgresql_audit-1.2.0/flask_postgresql_audit/types.py

@@ -0,0 +1,29 @@
+from typing import Any
+
+import sqlalchemy as sa
+from sqlalchemy.engine import Dialect
+
+
+class XID8(sa.types.UserDefinedType[int]):
+    """PostgreSQL 64-bit transaction identifier (``xid8``)."""
+
+    cache_ok = True
+
+    def get_col_spec(self, **kw: Any) -> str:
+        return "xid8"
+
+    def bind_processor(self, dialect: Dialect):
+        def process(value: int | None) -> str | None:
+            return str(value) if value is not None else None
+
+        return process
+
+    def result_processor(self, dialect: Dialect, coltype: Any):
+        def process(value: str | int | None) -> int | None:
+            return int(value) if value is not None else None
+
+        return process
+
+    @property
+    def python_type(self) -> type[int]:
+        return int

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/pyproject.toml

@@ -21,6 +21,8 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
@@ -29,6 +31,11 @@ dependencies = [
     "alembic-utils>=0.8.8",
     "flask>=3.1.2",
     "flask-sqlalchemy>=3.1.1",
+    "psycopg[binary]>=3.2",
+]
+
+[project.optional-dependencies]
+psycopg2 = [
     "psycopg2>=2.9.11",
 ]
 
@@ -37,10 +44,13 @@ Homepage = "https://github.com/higamigu/flask-postgresql-audit"
 
 [dependency-groups]
 dev = [
+    "pre-commit>=4.7.0",
+    "psycopg2-binary>=2.9.11",
     "pytest>=8.4.2",
     "ruff>=0.16.1",
     "setuptools>=80.9.0",
     "tox>=4.31.0",
+    "ty>=0.0.101",
 ]
 
 [tool.hatch.version]

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/tests/app.py

@@ -20,20 +20,22 @@ class DefaultConfig:
     DB_PASSWORD = os.environ.get("POSTGRES_PASSWORD", "postgres")
     DB_NAME = os.environ.get("POSTGRES_DB", "pg_audit_test")
     DB_PORT = os.environ.get("POSTGRES_PORT", "5432")
+    DB_DRIVER = os.environ.get("POSTGRES_DRIVER", "psycopg")
 
-    SQLALCHEMY_DATABASE_URI = (
-        f"postgresql://{DB_USER}:{DB_PASSWORD}@localhost:{DB_PORT}/{DB_NAME}"
-    )
+    SQLALCHEMY_DATABASE_URI = f"postgresql+{DB_DRIVER}://{DB_USER}:{DB_PASSWORD}@localhost:{DB_PORT}/{DB_NAME}"
     SQLALCHEMY_ECHO = False
 
-    PGA_SCHEMA_NAME = os.environ.get("SCHEMA_NAME", None)
+    # An empty SCHEMA_NAME means "use the default schema", not a schema
+    # literally named "". Passing "" down to SQLAlchemy puts the audit tables
+    # in an "" schema, which autogenerate cannot match against reflection.
+    PGA_SCHEMA_NAME = os.environ.get("SCHEMA_NAME") or None
 
 
 db = SQLAlchemy()
 audit = PostgreSQLAudit(schema_name=DefaultConfig.PGA_SCHEMA_NAME)
 
 
-class BaseModel(db.Model):
+class BaseModel(db.Model):  # ty: ignore[unsupported-base]
     __abstract__: bool = True
 
     if TYPE_CHECKING:

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/tests/conftest.py

@@ -1,10 +1,20 @@
+import os
+from pathlib import Path
+
 import pytest
 
 from tests.utils import REPO_ROOT, alembic_migration, test_session
 
 from .app import Article, User, app, db
 
-ALEMBIC_CONFIG = REPO_ROOT / "tests/migrations"
+ALEMBIC_CONFIG = Path(
+    os.environ.get("ALEMBIC_CONFIG", str(REPO_ROOT / "tests/migrations"))
+)
+
+
+@pytest.fixture(scope="session")
+def alembic_config_path():
+    return ALEMBIC_CONFIG
 
 
 @pytest.fixture(scope="session")

flask_postgresql_audit-1.2.0/tests/test_alembic_xid8.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+import sqlalchemy as sa
+from alembic.autogenerate import compare_metadata, render
+from alembic.autogenerate.api import AutogenContext
+from alembic.migration import MigrationContext
+from alembic.operations import ops
+
+from flask_postgresql_audit.alembic import apply_xid8_type_changes
+from flask_postgresql_audit.alembic.xid8 import XID8AlterColumnOp
+from flask_postgresql_audit.types import XID8
+
+from .app import audit, db
+from .utils import downgrade, revision, upgrade
+
+
+@pytest.mark.usefixtures("test_client")
+class TestXID8AlembicSupport:
+    def test_columns_reflect_as_xid8(self):
+        inspector = sa.inspect(db.engine)
+
+        schema = audit.schema_name or None
+        for table_name in ("pga_activity", "pga_transaction"):
+            columns = {
+                column["name"]: column["type"]
+                for column in inspector.get_columns(table_name, schema=schema)
+            }
+            assert isinstance(columns["native_transaction_id"], XID8)
+
+    def test_autogenerate_does_not_change_xid8_columns(self):
+        with db.engine.connect() as connection:
+            context = MigrationContext.configure(
+                connection, opts={"include_schemas": True}
+            )
+            diffs = compare_metadata(context, db.metadata)
+
+        assert not any(
+            isinstance(diff, tuple)
+            and diff[0] == "modify_type"
+            and diff[3] == "native_transaction_id"
+            for diff in diffs
+        )
+
+    def test_adds_using_clause_when_upgrading_to_xid8(self):
+        alter = ops.AlterColumnOp(
+            "pga_activity",
+            "native_transaction_id",
+            existing_type=sa.BigInteger(),
+            modify_type=XID8(),
+        )
+        directive = SimpleNamespace(
+            upgrade_ops=ops.UpgradeOps(ops=[alter]),
+            downgrade_ops=None,
+        )
+
+        apply_xid8_type_changes([directive])
+
+        result = directive.upgrade_ops.ops[0]
+        assert isinstance(result, XID8AlterColumnOp)
+        assert result.postgresql_using == "native_transaction_id::text::xid8"
+
+    def test_adds_using_clause_when_downgrading_to_bigint(self):
+        alter = ops.AlterColumnOp(
+            "pga_activity",
+            "native_transaction_id",
+            existing_type=XID8(),
+            modify_type=sa.BigInteger(),
+        )
+        directive = SimpleNamespace(
+            upgrade_ops=ops.UpgradeOps(ops=[]),
+            downgrade_ops=ops.DowngradeOps(ops=[alter]),
+        )
+
+        apply_xid8_type_changes([directive])
+
+        result = directive.downgrade_ops.ops[0]
+        assert isinstance(result, XID8AlterColumnOp)
+        assert result.postgresql_using == "native_transaction_id::text::bigint"
+
+    def test_renders_using_clause(self):
+        alter = XID8AlterColumnOp(
+            "pga_activity",
+            "native_transaction_id",
+            existing_type=sa.BigInteger(),
+            modify_type=XID8(),
+            postgresql_using="native_transaction_id::text::xid8",
+        )
+        context = AutogenContext(
+            MigrationContext.configure(dialect_name="postgresql"),
+            opts={
+                "alembic_module_prefix": "op.",
+                "sqlalchemy_module_prefix": "sa.",
+                "user_module_prefix": None,
+                "include_schemas": True,
+            },
+        )
+
+        rendered = render.render_op_text(context, alter)
+
+        assert "postgresql_using='native_transaction_id::text::xid8'" in rendered
+
+
+@pytest.mark.usefixtures("test_client")
+class TestXID8LegacyMigrationGeneration:
+    """Autogenerate must produce a runnable migration for a 1.0.x database."""
+
+    def _revert_to_legacy_layout(self):
+        schema = audit.schema_name or "public"
+        prefix = "" if schema == "public" else f"{schema}."
+
+        statements = [
+            "CREATE EXTENSION IF NOT EXISTS btree_gist",
+            (
+                f"ALTER TABLE {prefix}pga_transaction"
+                " DROP CONSTRAINT pga_transaction_unique_native_tx_id"
+            ),
+            (
+                f"ALTER TABLE {prefix}pga_transaction"
+                " ALTER COLUMN native_transaction_id TYPE bigint"
+                " USING native_transaction_id::text::bigint"
+            ),
+            (
+                f"ALTER TABLE {prefix}pga_activity"
+                " ALTER COLUMN native_transaction_id TYPE bigint"
+                " USING native_transaction_id::text::bigint"
+            ),
+            (
+                f"ALTER TABLE {prefix}pga_transaction"
+                " ADD CONSTRAINT pga_transaction_unique_native_tx_id"
+                " EXCLUDE USING gist ("
+                " native_transaction_id WITH =,"
+                " tsrange(issued_at - INTERVAL '1 hour', issued_at) WITH &&)"
+            ),
+        ]
+
+        with db.engine.begin() as connection:
+            for statement in statements:
+                connection.execute(sa.text(statement))
+
+    def _native_transaction_columns(self):
+        inspector = sa.inspect(db.engine)
+        schema = audit.schema_name or None
+
+        return {
+            table_name: {
+                column["name"]: column["type"]
+                for column in inspector.get_columns(table_name, schema=schema)
+            }["native_transaction_id"]
+            for table_name in ("pga_activity", "pga_transaction")
+        }
+
+    def _native_transaction_constraint(self):
+        schema = audit.schema_name or "public"
+        query = sa.text(
+            """
+            SELECT c.contype
+            FROM pg_constraint AS c
+            JOIN pg_class AS t ON t.oid = c.conrelid
+            JOIN pg_namespace AS n ON n.oid = t.relnamespace
+            WHERE t.relname = 'pga_transaction'
+              AND n.nspname = :schema
+              AND c.conname = 'pga_transaction_unique_native_tx_id'
+            """
+        )
+        with db.engine.connect() as connection:
+            return connection.scalar(query, {"schema": schema})
+
+    def test_autogenerated_migration_swaps_legacy_constraint(self, alembic_config_path):
+        self._revert_to_legacy_layout()
+
+        revision(
+            db.engine,
+            alembic_config_path,
+            autogenerate=True,
+            rev_id="2",
+            message="xid8",
+        )
+
+        generated = next((alembic_config_path / "versions").glob("2_*.py")).read_text()
+
+        drop_constraint = (
+            "ALTER TABLE public.pga_transaction"
+            " DROP CONSTRAINT pga_transaction_unique_native_tx_id"
+        )
+        if audit.schema_name:
+            drop_constraint = drop_constraint.replace(
+                "public.", f"{audit.schema_name}."
+            )
+
+        assert drop_constraint in generated
+        assert (
+            generated.count("postgresql_using='native_transaction_id::text::xid8'") == 2
+        )
+        assert generated.index(drop_constraint) < generated.index(
+            "create_unique_constraint('pga_transaction_unique_native_tx_id'"
+        )
+
+        upgrade(db.engine, alembic_config_path, revision="head")
+
+        assert all(
+            isinstance(type_, XID8)
+            for type_ in self._native_transaction_columns().values()
+        )
+        assert self._native_transaction_constraint() == "u"
+
+        downgrade(db.engine, alembic_config_path, revision="1")
+
+        assert all(
+            isinstance(type_, sa.BigInteger)
+            for type_ in self._native_transaction_columns().values()
+        )
+        assert self._native_transaction_constraint() == "x"
+
+        # Leave the database consistent with the model metadata again.
+        upgrade(db.engine, alembic_config_path, revision="head")
+
+        assert all(
+            isinstance(type_, XID8)
+            for type_ in self._native_transaction_columns().values()
+        )
+        assert self._native_transaction_constraint() == "u"

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/tests/test_defaults.py

@@ -13,9 +13,18 @@ class TestCustomSchemaActivityCreation:
             assert activity.old_data == {}
             assert activity.changed_data == {"id": user.id, "name": "John", "age": 15}
             assert activity.table_name == "user"
-            assert activity.native_transaction_id > 0  # type: ignore
+            assert activity.native_transaction_id > 0
             assert activity.verb == "insert"
 
+    def test_single_transaction_row_per_db_transaction(self):
+        db.session.add(User(name="Jack"))
+        db.session.flush()
+        db.session.add(User(name="John"))
+        db.session.flush()
+
+        stmt = sa.select(sa.func.count()).select_from(audit.Transaction)
+        assert db.session.scalar(stmt) == 1
+
     def test_activity_after_commit(self):
         user = User(name="Jack")
         db.session.add(user)

{flask_postgresql_audit-1.1.3 → flask_postgresql_audit-1.2.0}/tests/utils.py

@@ -82,7 +82,6 @@ def downgrade(engine: Engine, alembic_cfg_path: Path, **kw):
 
 def clear_migrations(engine: Engine, alembic_cfg_path: Path, **kw):
     with engine.begin() as connection:
-        connection.execute(text("DROP EXTENSION IF EXISTS btree_gist CASCADE;"))
         connection.execute(text("DROP SCHEMA IF EXISTS public CASCADE;"))
         connection.execute(text("DROP SCHEMA IF EXISTS audit CASCADE;"))
         connection.execute(text("CREATE SCHEMA public;"))

flask_postgresql_audit-1.1.3/flask_postgresql_audit/alembic/__init__.py

@@ -1,7 +0,0 @@
-# ruff: noqa: F401
-from .setup import (
-    chain_revision_directives,
-    register_triggers,
-    reorder_migration_ops,
-    setup_db,
-)