matrx-orm 3.1.211__tar.gz → 3.1.213__tar.gz

{matrx_orm-3.1.211 → matrx_orm-3.1.213}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: matrx-orm
-Version: 3.1.211
+Version: 3.1.213
 Summary: Async-first PostgreSQL ORM with bidirectional migrations, schema introspection, many-to-many relationships, and built-in state caching
 Project-URL: Homepage, https://github.com/AI-Matrix-Engine/aidream-current
 Project-URL: Repository, https://github.com/AI-Matrix-Engine/aidream-current

{matrx_orm-3.1.211 → matrx_orm-3.1.213}/matrx_orm/__init__.py

@@ -73,6 +73,7 @@ from .core.diagnostics import (
     log_pool_diagnostics,
     long_transactions,
     long_transactions_sql,
+    probe_server_vitals,
 )
 from .core.introspection import (
     introspect_column_shapes,
@@ -474,6 +475,7 @@ __all__ = [
     "LONG_TRANSACTION_SECONDS",
     "long_transactions",
     "long_transactions_sql",
+    "probe_server_vitals",
     "describe_transaction",
     "describe_transactions",
     "install_asyncpg_idle_close_filter",

{matrx_orm-3.1.211 → matrx_orm-3.1.213}/matrx_orm/core/diagnostics.py

@@ -339,3 +339,77 @@ async def introspect_lock_waits(
         int(query_chars),
     )
     return [dict(r) for r in rows]
+
+
+# ── Out-of-band server vitals ────────────────────────────────────────────────
+#
+# A watchdog that must notice the database being DOWN cannot borrow a pool
+# connection: the pool is exactly what is exhausted or hung when it matters.
+# ``probe_server_vitals`` opens ONE fresh connection with the registered
+# config's own parameters (host, port, user, password, TLS), runs ``select 1``
+# (timed) and one read-only catalog query, and closes it — the whole thing
+# under one deadline, so a hung server is a ``TimeoutError``, never a hang.
+
+_SERVER_VITALS_SQL = """
+SELECT
+    (SELECT count(*) FROM pg_stat_activity)::int AS connections,
+    current_setting('max_connections')::int AS max_connections,
+    (SELECT count(*) FROM pg_stat_activity WHERE wait_event_type = 'Lock')::int AS lock_waiters,
+    COALESCE((
+        SELECT max(EXTRACT(EPOCH FROM (clock_timestamp() - query_start)))
+          FROM pg_stat_activity
+         WHERE state = 'active'
+           AND backend_type = 'client backend'
+           AND pid <> pg_backend_pid()
+           AND query_start IS NOT NULL
+    ), 0)::float8 AS longest_active_seconds,
+    pg_postmaster_start_time() AS postmaster_started_at
+"""
+
+
+async def probe_server_vitals(config_name: str, *, timeout_s: float) -> dict[str, Any]:
+    """One fresh, short-lived connection's view of the server's health.
+
+    Returns ``latency_ms`` (the ``select 1`` round trip), ``connections``,
+    ``max_connections``, ``lock_waiters``, ``longest_active_seconds`` (the
+    oldest running client statement, excluding this probe and replication)
+    and ``postmaster_started_at`` (a change means the server restarted).
+
+    Read-only. Never touches the shared pool. RAISES on any failure —
+    including ``TimeoutError`` when connect + both queries exceed
+    ``timeout_s`` — because the caller's whole job is to count failures.
+    """
+    import asyncio
+    import time
+
+    import asyncpg
+
+    from matrx_orm.core.tls import resolve_asyncpg_ssl
+
+    config = get_database_config(config_name)
+    ssl = await resolve_asyncpg_ssl(config.get("ssl", "require"))
+
+    async def _run() -> dict[str, Any]:
+        conn = await asyncpg.connect(
+            host=config["host"],
+            port=config["port"],
+            database=config["database_name"],
+            user=config["user"],
+            password=config["password"],
+            ssl=ssl,
+            timeout=timeout_s,
+            statement_cache_size=0,
+            server_settings={"application_name": "matrx_server_vitals_probe"},
+        )
+        try:
+            started = time.perf_counter()
+            await conn.fetchval("SELECT 1")
+            latency_ms = (time.perf_counter() - started) * 1000.0
+            row = await conn.fetchrow(_SERVER_VITALS_SQL)
+        finally:
+            conn.terminate()
+        result = dict(row) if row is not None else {}
+        result["latency_ms"] = round(latency_ms, 1)
+        return result
+
+    return await asyncio.wait_for(_run(), timeout=timeout_s)

{matrx_orm-3.1.211 → matrx_orm-3.1.213}/matrx_orm/schema_builder/package_wiring.py

@@ -179,8 +179,36 @@ def _lookup(inventory: dict[tuple[str, str], TableInfo], table: str) -> TableInf
     return info
 
 
+def _lookup_view(
+    inventory: dict[tuple[str, str], TableInfo], view: str, python_root: str | Path | None
+) -> TableInfo:
+    if "." not in view:
+        raise PackageWiringError(f"package_wiring: view '{view}' must be '<schema>.<snake>'")
+    schema, snake = view.split(".", 1)
+    sibling = next((i for (s, _), i in inventory.items() if s == schema), None)
+    if sibling is None:
+        raise PackageWiringError(
+            f"package_wiring: view '{view}' — schema '{schema}' has no generated models module"
+        )
+    from matrx_orm.schema_builder.common import dt_utils, safe_model_class_name
+
+    pascal = safe_model_class_name(snake, schema, dt_utils.to_pascal_case)
+    if python_root is not None:
+        models_file = Path(python_root) / (sibling.models_module.replace(".", "/") + ".py")
+        tree = ast.parse(models_file.read_text(), filename=str(models_file))
+        if not any(isinstance(n, ast.ClassDef) and n.name == pascal for n in tree.body):
+            raise PackageWiringError(
+                f"package_wiring: view '{view}' has no generated class {pascal} in "
+                f"{models_file} — is the view in the schema and its view_primary_keys declared?"
+            )
+    return TableInfo(schema=schema, snake=snake, pascal=pascal, models_module=sibling.models_module)
+
+
 def resolve_manifest(
-    name: str, req: dict[str, Any], inventory: dict[tuple[str, str], TableInfo]
+    name: str,
+    req: dict[str, Any],
+    inventory: dict[tuple[str, str], TableInfo],
+    python_root: str | Path | None = None,
 ) -> ResolvedPackage:
     target = req.get("target") or {}
     configure_import = target.get("configure_import")
@@ -225,9 +253,14 @@ def resolve_manifest(
                 )
             )
 
-    # Explicit models.
+    # Explicit models. A VIEW has a generated model class but no auto_config entry, so a
+    # manifest names it with "view" instead of "table"; it resolves by the generator's own
+    # class-naming rule and must exist in the schema's generated models file.
     for entry in req.get("models") or []:
-        info = _lookup(inventory, entry["table"])
+        if "view" in entry:
+            info = _lookup_view(inventory, entry["view"], python_root)
+        else:
+            info = _lookup(inventory, entry["table"])
         assignments.append(Assignment("models", entry["key"], info.models_module, info.pascal))
 
     # Explicit bases.
@@ -421,7 +454,7 @@ def _resolve_all(cfg: dict[str, Any], python_root: str) -> tuple[str, list[Resol
                 f"package_wiring.packages entry needs 'name' and 'manifest_path': {entry}"
             )
         req = _load_manifest(Path(python_root) / manifest_path)
-        packages.append(resolve_manifest(name, req, inventory))
+        packages.append(resolve_manifest(name, req, inventory, python_root))
     return output_module, packages
 
 

{matrx_orm-3.1.211 → matrx_orm-3.1.213}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "matrx-orm"
-version = "3.1.211"
+version = "3.1.213"
 description = "Async-first PostgreSQL ORM with bidirectional migrations, schema introspection, many-to-many relationships, and built-in state caching"
 readme = "README.md"
 license = { text = "MIT" }
@@ -51,8 +51,6 @@ dependencies = [
 [project.entry-points.pytest11]
 matrx_write_spill_guard = "matrx_orm.pytest_plugin"
 matrx_shared_lock_guard = "matrx_orm.pytest_lock_guard"
-matrx_live_db_guard = "matrx_orm.pytest_live_db_guard"
-matrx_production_door = "matrx_orm.pytest_production_door"
 
 [project.urls]
 Homepage = "https://github.com/AI-Matrix-Engine/aidream-current"
@@ -84,9 +82,6 @@ dev = [
 packages = ["matrx_orm"]
 include = ["matrx_orm/py.typed", "matrx_orm/resources/*.json"]
 
-[tool.hatch.build.targets.wheel.force-include]
-"matrx_orm/matrx_orm_production_door.pth" = "matrx_orm_production_door.pth"
-
 [tool.hatch.metadata]
 allow-direct-references = true
 

matrx_orm-3.1.213/tests/test_package_wiring_views.py

@@ -0,0 +1,46 @@
+"""A manifest may wire a VIEW: views get a generated model class but no auto_config entry."""
+
+from pathlib import Path
+
+import pytest
+
+from matrx_orm.schema_builder.package_wiring import (
+    PackageWiringError,
+    TableInfo,
+    resolve_manifest,
+)
+
+INVENTORY = {("ai", "setting"): TableInfo("ai", "setting", "Setting", "db.models.ai")}
+
+
+def _req(entry):
+    return {"target": {"configure_import": "x", "configure_call": "configure"}, "models": [entry]}
+
+
+def _root(tmp_path: Path, classes: str) -> Path:
+    (tmp_path / "db" / "models").mkdir(parents=True)
+    (tmp_path / "db" / "models" / "ai.py").write_text(classes)
+    return tmp_path
+
+
+def test_a_view_resolves_to_its_generated_class(tmp_path):
+    root = _root(tmp_path, "class Setting: pass\nclass OfferingRulesCompiled: pass\n")
+    pkg = resolve_manifest(
+        "p", _req({"key": "AiOfferingRulesCompiled", "view": "ai.offering_rules_compiled"}),
+        INVENTORY, root,
+    )
+    [a] = [x for x in pkg.assignments if x.key == "AiOfferingRulesCompiled"]
+    assert (a.module, a.symbol) == ("db.models.ai", "OfferingRulesCompiled")
+
+
+def test_a_view_without_a_generated_class_is_refused(tmp_path):
+    root = _root(tmp_path, "class Setting: pass\n")
+    with pytest.raises(PackageWiringError, match="no generated class OfferingRulesCompiled"):
+        resolve_manifest(
+            "p", _req({"key": "K", "view": "ai.offering_rules_compiled"}), INVENTORY, root
+        )
+
+
+def test_a_table_entry_naming_a_view_is_still_refused():
+    with pytest.raises(PackageWiringError, match="not in the host inventory"):
+        resolve_manifest("p", _req({"key": "K", "table": "ai.offering_rules_compiled"}), INVENTORY)

matrx_orm-3.1.211/matrx_orm/matrx_orm_production_door.pth

@@ -1,3 +0,0 @@
-# Installed by matrx-orm: in a process whose environment carries MATRX_PRODUCTION_DOOR=1 (exported by the
-# pytest plugin matrx_orm.pytest_production_door), install the same production door before any user code.
-import os; exec("import sys, importlib.util as u, importlib.machinery as m\ns = m.PathFinder.find_spec('matrx_orm')\nif s and s.submodule_search_locations and 'matrx_orm.pytest_production_door' not in sys.modules:\n    sp = u.spec_from_file_location('matrx_orm.pytest_production_door', list(s.submodule_search_locations)[0] + '/pytest_production_door.py')\n    mod = u.module_from_spec(sp); sys.modules[sp.name] = mod; sp.loader.exec_module(mod); mod.install()") if os.environ.get("MATRX_PRODUCTION_DOOR") == "1" else None

matrx_orm-3.1.211/matrx_orm/pytest_live_db_guard.py

@@ -1,272 +0,0 @@
-"""Session-wide guard: a test run never reaches the LIVE platform database by accident.
-
-Registered as a ``pytest11`` entry point, so pytest loads it in every suite regardless of
-rootdir — the same mechanism as the spill guard (``matrx_orm.pytest_plugin``) and the lock
-guard (``matrx_orm.pytest_lock_guard``). This is the SEVENTH cross-suite hazard; the other six
-are catalogued in the aidream repo-root ``conftest.py``.
-
-WHY IT EXISTS (lane INTEG-SERVER, 2026-09-24). A developer's ``.env`` holds the five
-``SUPABASE_MATRIX_*`` variables for the LIVE database, because that is what the server runs
-on. Those variables SELECT a connection; they never AUTHORISED one. So every suite that
-imports the host's ``db`` package — ``aidream/services/agent_data/tests/test_rls_data_access.py``
-creates, edits and HARD-deletes notes — ran against production whenever it was collected,
-with nobody having decided that. The matrx-records suite closed this for itself on 2026-09-22
-(a declared target, default the rehearsal branch, main behind three locked doors); this closes
-it for every suite, once, in the package that owns the connection.
-
-THE RULE. Before any test module is imported, the connection the five variables (or the
-``.env`` that will supply them) resolve to is compared with the live database's identity —
-its project ref in the pooler user (``postgres.<ref>``) or a live host. When it IS the live
-database:
-
-* **Default:** the five variables are REPOINTED, in this process only, to the rehearsal
-  branch — ``MATRX_TEST_DATABASE_URL`` when set (any declared non-live target, e.g. the dev
-  clone), else ``SUPABASE_BRANCH_DATABASE_URL``. With neither, they point at an unreachable
-  placeholder (``127.0.0.1:1``), so a live test FAILS to connect instead of writing to
-  production. The banner says which, once.
-* **Live, on purpose:** ``--live-db --live-db-reason "<why>"`` inside the 1–4 AM Pacific
-  maintenance window leaves them alone and prints the reason. The environment cannot open
-  this door (an exported variable outlives the shell that set it); a missing reason or a
-  time outside the window is a usage error that stops the session.
-
-A connection that is NOT the live database — a local Postgres in CI, the branch, the clone —
-is never touched. Values are never printed.
-"""
-
-from __future__ import annotations
-
-import os
-from datetime import datetime
-from urllib.parse import unquote, urlsplit
-from zoneinfo import ZoneInfo
-
-import pytest
-
-#: The ONE live database (aidream CLAUDE.md), by the identities a connection can carry.
-LIVE_PROJECT_REFS = frozenset({"brsgrqvjdzwihsvnfqkf"})
-LIVE_HOSTS = frozenset({"db.matrxserver.com", "db.brsgrqvjdzwihsvnfqkf.supabase.co"})
-
-DB_VARS = (
-    "SUPABASE_MATRIX_HOST",
-    "SUPABASE_MATRIX_PORT",
-    "SUPABASE_MATRIX_USER",
-    "SUPABASE_MATRIX_PASSWORD",
-    "SUPABASE_MATRIX_DATABASE_NAME",
-)
-TARGET_URL_VARS = ("MATRX_TEST_DATABASE_URL", "SUPABASE_BRANCH_DATABASE_URL")
-WINDOW_TZ, WINDOW_START, WINDOW_END = "America/Los_Angeles", 1, 4
-PLACEHOLDER = {
-    "SUPABASE_MATRIX_HOST": "127.0.0.1",
-    "SUPABASE_MATRIX_PORT": "1",
-    "SUPABASE_MATRIX_USER": "live-db-refused-under-pytest",
-    "SUPABASE_MATRIX_PASSWORD": "refused",
-    "SUPABASE_MATRIX_DATABASE_NAME": "refused",
-}
-
-#: THE HTTP ROUTE to the same database (2026-09-27). PostgREST, the admin door and the
-#: Management API need no pool: a project URL plus the secret key (or the account access
-#: token) reaches production by itself. Under pytest without --live-db, a live URL sends
-#: every one of these to an unreachable placeholder too. Names cover the canonical
-#: variables and the aliases the host materializes from them.
-HTTP_URL_VARS = ("SUPABASE_MATRIX_URL", "SUPABASE_URL")
-HTTP_SECRET_VARS = (
-    "SUPABASE_MATRIX_SECRET_KEY",
-    "SUPABASE_SECRET_KEY",
-    "SUPABASE_MATRIX_SERVICE_ROLE_KEY",
-    "SUPABASE_SERVICE_ROLE_KEY",
-    "SUPABASE_ACCESS_TOKEN",
-)
-HTTP_PLACEHOLDER_URL = "http://127.0.0.1:1"
-HTTP_PLACEHOLDER_SECRET = "live-http-refused-under-pytest"
-
-
-def is_live_url(url: str) -> bool:
-    """Does this HTTP URL name the live project?"""
-    host = (urlsplit((url or "").strip()).hostname or "").lower()
-    return host in LIVE_HOSTS or any(host.startswith(f"{ref}.") for ref in LIVE_PROJECT_REFS)
-
-
-def decide_http(env: dict[str, str], dotenv: dict[str, str], *, live_flag: bool) -> dict[str, str] | None:
-    """The HTTP variables to overwrite, or None. Pure — the hook applies it.
-
-    Independent of the pool decision: a CI run on a local Postgres with a live URL
-    left in .env is exactly the case the pool guard cannot see.
-    """
-    if live_flag:
-        return None
-    urls = {k: env.get(k) or dotenv.get(k, "") for k in HTTP_URL_VARS}
-    if not any(is_live_url(u) for u in urls.values()):
-        return None
-    out = {k: HTTP_PLACEHOLDER_URL for k in HTTP_URL_VARS}
-    out.update({k: HTTP_PLACEHOLDER_SECRET for k in HTTP_SECRET_VARS})
-    return out
-
-
-#: The ONLY accounts a test may act as (workspace law: "use ONLY admin@admin.com, never Arman's
-#: personal account"; test@test.com is the non-admin seat). By id, because an id is what a test
-#: reads from ``TEST_USER_ID`` and an id cannot be mistaken for a similar email.
-TEST_ACCOUNT_IDS = {
-    "87a6e699-3622-4869-8843-d0867456c0dd": "admin@admin.com",
-    "4060701e-706a-4c76-b3ca-0bbc69fa5a14": "test@test.com",
-}
-
-
-def refuse_a_real_person(env: dict[str, str], dotenv: dict[str, str]) -> None:
-    """``TEST_USER_ID`` must be one of the test accounts, or the session does not start."""
-    user = (env.get("TEST_USER_ID") or dotenv.get("TEST_USER_ID") or "").strip()
-    if user and user not in TEST_ACCOUNT_IDS:
-        raise pytest.UsageError(
-            "REFUSED: TEST_USER_ID is not a test account. Tests act ONLY as admin@admin.com "
-            "(or test@test.com for a non-admin seat) — never a real person's account, and never "
-            "the owner's personal one. Set TEST_USER_ID to admin@admin.com's user id. Nothing ran."
-        )
-
-
-#: What this session decided, for tests and banners: "untouched" | "live" | "repointed:<var>"
-#: | "placeholder".
-DECISION: str = "untouched"
-
-
-def is_live(user: str, host: str) -> bool:
-    """Does this connection identity name the live database?"""
-    ref = user.split(".", 1)[1] if "." in (user or "") else ""
-    return ref in LIVE_PROJECT_REFS or (host or "").strip().lower() in LIVE_HOSTS
-
-
-def _dotenv_values() -> dict[str, str]:
-    """The ``.env`` a later ``load_dotenv()`` would read — it never overrides what is set here."""
-    try:
-        from dotenv import dotenv_values, find_dotenv
-    except ImportError:  # pragma: no cover — python-dotenv absent: env only
-        return {}
-    path = find_dotenv(usecwd=True)
-    return {k: v for k, v in (dotenv_values(path) if path else {}).items() if v is not None}
-
-
-def _five_from_url(url: str) -> dict[str, str]:
-    parts = urlsplit(url)
-    return {
-        "SUPABASE_MATRIX_HOST": parts.hostname or "",
-        "SUPABASE_MATRIX_PORT": str(parts.port or 5432),
-        "SUPABASE_MATRIX_USER": unquote(parts.username or ""),
-        "SUPABASE_MATRIX_PASSWORD": unquote(parts.password or ""),
-        "SUPABASE_MATRIX_DATABASE_NAME": (parts.path or "/postgres").lstrip("/") or "postgres",
-    }
-
-
-def decide(
-    env: dict[str, str],
-    dotenv: dict[str, str],
-    *,
-    live_flag: bool,
-    reason: str,
-    now: datetime,
-) -> tuple[str, dict[str, str] | None, str]:
-    """``(decision, five variables to set or None, banner)``. Pure — the hook applies it."""
-    effective = {k: env.get(k) or dotenv.get(k, "") for k in DB_VARS}
-    if not is_live(effective["SUPABASE_MATRIX_USER"], effective["SUPABASE_MATRIX_HOST"]):
-        return "untouched", None, ""
-    if live_flag:
-        if not reason.strip():
-            raise pytest.UsageError(
-                "--live-db needs --live-db-reason \"<why>\": nothing else records why a test run "
-                "touched the live database."
-            )
-        local = now.astimezone(ZoneInfo(WINDOW_TZ))
-        if not (WINDOW_START <= local.hour < WINDOW_END):
-            raise pytest.UsageError(
-                f"--live-db refused: it is {local:%H:%M} Pacific, and the live database is open "
-                f"to test runs only {WINDOW_START:02d}:00–{WINDOW_END:02d}:00 Pacific."
-            )
-        return "live", None, f"── LIVE DATABASE under pytest · reason: {reason.strip()}"
-    for var in TARGET_URL_VARS:
-        url = env.get(var) or dotenv.get(var, "")
-        if url:
-            five = _five_from_url(url)
-            if is_live(five["SUPABASE_MATRIX_USER"], five["SUPABASE_MATRIX_HOST"]):
-                raise pytest.UsageError(f"{var} names the LIVE database; it cannot be a test target.")
-            return (
-                f"repointed:{var}",
-                five,
-                f"── the live database was configured; this test run uses {var} instead "
-                "(pass --live-db --live-db-reason inside 1–4 AM Pacific to reach live on purpose).",
-            )
-    return (
-        "placeholder",
-        dict(PLACEHOLDER),
-        "── the live database was configured and no test target is set "
-        "(MATRX_TEST_DATABASE_URL / SUPABASE_BRANCH_DATABASE_URL); database connections in this "
-        "run go to an unreachable placeholder and FAIL instead of reaching production.",
-    )
-
-
-def pytest_addoption(parser: pytest.Parser) -> None:
-    group = parser.getgroup("matrx-live-db", "the live platform database under pytest")
-    group.addoption("--live-db", action="store_true", default=False,
-                    help="reach the LIVE database on purpose (needs --live-db-reason and 1-4 AM Pacific)")
-    group.addoption("--live-db-reason", action="store", default="",
-                    help="why this run needs the live database")
-
-
-_APPLIED = False
-
-
-def _apply(live_flag: bool, reason: str) -> None:
-    """Decide once per process and repoint the five variables. Idempotent."""
-    global DECISION, _APPLIED
-    if _APPLIED:
-        return
-    refuse_a_real_person(dict(os.environ), _dotenv_values())
-    decision, five, banner = decide(
-        dict(os.environ),
-        _dotenv_values(),
-        live_flag=live_flag,
-        reason=reason,
-        now=datetime.now(ZoneInfo(WINDOW_TZ)),
-    )
-    DECISION = decision
-    _APPLIED = True
-    if five is not None:
-        os.environ.update(five)
-    if banner:
-        print(banner)
-    http = decide_http(dict(os.environ), _dotenv_values(), live_flag=live_flag)
-    if http is not None:
-        os.environ.update(http)
-        print(
-            "── the live Supabase HTTP API was configured; its URL and secret keys point at an "
-            "unreachable placeholder in this run (pass --live-db --live-db-reason inside 1–4 AM "
-            "Pacific to reach live on purpose)."
-        )
-
-
-@pytest.hookimpl(tryfirst=True)
-def pytest_load_initial_conftests(early_config: pytest.Config, parser: pytest.Parser, args: list[str]) -> None:
-    """THE EARLIEST POINT a plugin can act, and the one that matters (2026-09-27).
-
-    pytest imports every command-line path's ``conftest.py`` — and that conftest's
-    package ``__init__`` — during THIS hook, before ``pytest_configure``. A package
-    ``__init__`` that imports a module which registers the database pool (aidream's
-    ``aidream/api/mcp/agent_service/__init__.py`` → server → ``db``) froze the LIVE
-    identity into the pool for the whole session while the repoint was still waiting in
-    ``pytest_configure``. The options are already parsed here
-    (``early_config.known_args_namespace``), so the decision runs before any conftest.
-    """
-    ns = early_config.known_args_namespace
-    _apply(
-        bool(getattr(ns, "live_db", False)),
-        str(getattr(ns, "live_db_reason", "") or ""),
-    )
-
-
-@pytest.hookimpl(tryfirst=True)
-def pytest_configure(config: pytest.Config) -> None:
-    # Normally a no-op: pytest_load_initial_conftests already decided. Kept for runs
-    # that bypass initial-conftest loading (pytest.main with plugins=, --noconftest).
-    _apply(
-        bool(config.getoption("--live-db", default=False)),
-        str(config.getoption("--live-db-reason", default="") or ""),
-    )
-
-
-__all__ = ["decide_http", "is_live_url", "DECISION", "TEST_ACCOUNT_IDS", "refuse_a_real_person", "LIVE_HOSTS", "LIVE_PROJECT_REFS", "decide", "is_live"]