parallax-postgres 0.1.0__cp315-cp315-win_amd64.whl

parallax/postgres/__init__.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from parallax.postgres._authorization import PostgresRole
+from parallax.postgres._endpoint import PostgresEndpoint
+from parallax.postgres._isolation import isolation_spelling
+from parallax.postgres._options import OnDemandOptions, PoolOptions
+from parallax.postgres.adapter import PostgresAdapter
+
+__all__ = [
+    "OnDemandOptions",
+    "PoolOptions",
+    "PostgresAdapter",
+    "PostgresEndpoint",
+    "PostgresRole",
+    "isolation_spelling",
+]

parallax/postgres/_authorization.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from psycopg.sql import SQL, Composed, Identifier
+
+from parallax.core.db_port import InvalidAuthorizationError
+from parallax.postgres._connection import (
+    _complete_first_send,  # pyright: ignore[reportPrivateUsage] - the lease's shared first-send markers
+    _start_first_send,  # pyright: ignore[reportPrivateUsage] - the lease's shared first-send markers
+)
+
+if TYPE_CHECKING:
+    import psycopg
+    from psycopg.rows import TupleRow
+
+    from parallax.postgres._context import PostgresConnectionContext
+
+__all__ = ["PostgresRole", "install_role", "restore_role"]
+
+
+@dataclass(frozen=True, slots=True)
+class PostgresRole:
+    """A non-empty PostgreSQL role name bound to principal execution."""
+
+    name: str
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.name, str):  # pyright: ignore[reportUnnecessaryIsInstance] - validates untyped callers at the public boundary
+            raise InvalidAuthorizationError("a PostgreSQL role name must be a string")
+        if not self.name:
+            raise InvalidAuthorizationError("a PostgreSQL role name must not be empty")
+
+
+def _role_statement(role: PostgresRole) -> Composed:
+    return SQL("SET ROLE {}").format(Identifier(role.name))
+
+
+def _install_role(
+    connection: psycopg.Connection[TupleRow],
+    context: PostgresConnectionContext | None,
+    statement: Composed,
+) -> None:
+    with connection.cursor() as cursor:
+        _start_first_send(context)
+        cursor.execute(statement)
+        _complete_first_send(context)
+
+
+def install_role(connection: Any, role: PostgresRole) -> None:
+    _install_role(connection, None, _role_statement(role))
+
+
+def restore_role(connection: Any) -> None:
+    connection.execute("RESET ROLE")

parallax/postgres/_cloaders_binary.pyi

@@ -0,0 +1,4 @@
+from psycopg.abc import Loader
+
+ExactFloat4Loader: type[Loader]
+InfinityTimestamptzLoader: type[Loader]

parallax/postgres/_cloaders_c.pyi

@@ -0,0 +1,4 @@
+from psycopg.abc import Loader
+
+ExactFloat4Loader: type[Loader]
+InfinityTimestamptzLoader: type[Loader]

parallax/postgres/_compiled_loaders.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import NamedTuple
+
+import psycopg
+from psycopg import _cmodule
+from psycopg.abc import Loader
+
+__all__ = ["CompiledLoaders", "compiled_loaders"]
+
+
+class CompiledLoaders(NamedTuple):
+    """The text loaders the adapter registers on every connection."""
+
+    float4: type[Loader]
+    timestamptz: type[Loader]
+
+
+def compiled_loaders(implementation: str) -> CompiledLoaders:
+    """The compiled loaders built for psycopg's ``implementation``, or an ``ImportError``.
+
+    psycopg's C Transformer calls a loader's decoding directly only when the
+    loader extends the C loader base of the build it runs, and calls anything
+    else through Python per cell. The loaders are compiled once against each
+    build, so the variant is chosen by the implementation psycopg selected, and
+    only that variant is imported: the other build need not be installed.
+
+    Nothing slower stands in for a refusal. The pure-Python implementation, a
+    variant that cannot be loaded, and a variant that does not extend the base
+    it was compiled against as that base is actually laid out are all refused,
+    since each would decode correctly at a cost nobody asked for, or not at all.
+    """
+    if implementation not in ("binary", "c"):
+        raise ImportError(
+            f"psycopg is running its {implementation!r} implementation, which decodes every "
+            f"cell through Python; parallax-postgres decodes with compiled loaders that only "
+            f"psycopg's 'binary' or 'c' implementation can run, so install psycopg[binary] or "
+            f"psycopg[c] and leave PSYCOPG_IMPL unset or naming one of them"
+        )
+    try:
+        loaders = _variant(implementation)
+    except Exception as exc:
+        raise ImportError(
+            f"parallax-postgres could not load its compiled loaders for psycopg's "
+            f"{implementation!r} implementation; reinstall parallax-postgres for this "
+            f"interpreter and platform"
+        ) from exc
+    base: type = _cmodule._psycopg.CLoader  # pyright: ignore[reportPrivateUsage] - the base the Transformer checks loaders against
+    # The Float32 loader adds no field of its own, so its size is the base's
+    # size as it was declared when the variant was compiled.
+    if not all(issubclass(loader, base) for loader in loaders) or (
+        loaders.float4.__basicsize__ != base.__basicsize__
+    ):
+        raise ImportError(
+            f"parallax-postgres's compiled loaders for psycopg's {implementation!r} "
+            f"implementation do not match the C loader layout of the installed psycopg "
+            f"{psycopg.__version__}; install the psycopg release parallax-postgres declares"
+        )
+    return loaders
+
+
+def _variant(implementation: str) -> CompiledLoaders:
+    if implementation == "binary":
+        from parallax.postgres import _cloaders_binary as variant
+    else:
+        from parallax.postgres import _cloaders_c as variant
+    return CompiledLoaders(variant.ExactFloat4Loader, variant.InfinityTimestamptzLoader)