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

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

@@ -3,6 +3,26 @@
 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.
+
 ## 1.1.2 (2026-08-21)
 
 -   Add dedicated `jsonb_array_subtract()` function to support set difference operations on JSONB arrays.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: flask-postgresql-audit
-Version: 1.1.2
+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.2 → 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.2 → 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.2"
+__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.2 → 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)
@@ -90,3 +87,13 @@ def jsonb_array_subtract_factory(**context):
         signature="jsonb_array_subtract(arg1 jsonb, arg2 jsonb)",
         definition=sql["definition"],
     )
+
+
+def jsonb_diff_factory(**context):
+    context.setdefault("jsonb_subtract_join_type", "LEFT")
+    sql = parse_template("jsonb_diff.sql", **context)
+    return PGFunction(
+        schema=context["schema_name"],
+        signature="jsonb_diff(arg1 jsonb, arg2 jsonb)",
+        definition=sql["definition"],
+    )

{flask_postgresql_audit-1.1.2 → 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,12 +145,12 @@ 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))
     audit.pg_audit_entities.add(entities.jsonb_subtract_factory(**audit.context))
     audit.pg_audit_entities.add(entities.jsonb_array_subtract_factory(**audit.context))
+    audit.pg_audit_entities.add(entities.jsonb_diff_factory(**audit.context))
     audit.pg_audit_entities.add(entities.create_activity_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.2 → 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.2 → 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: