gnomon-postgres 1.0.0__py3-none-any.whl

gnomon/pytest_plugin.py

@@ -0,0 +1,62 @@
+"""pytest fixtures: a scratch branch of one seeded database per test.
+
+    def test_signup(gnomon_conn):       # a psycopg connection on a fresh branch
+        gnomon_conn.execute("insert into users ...")
+
+Tests run in parallel against one database (pytest-xdist works): each gets its own branch, so
+nothing a test writes is seen by another, and nothing reaches main. Configure the database with
+``--gnomon-dsn`` or ``GNOMON_TEST_DSN``.
+"""
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from . import create_scratch, drop_branch, use
+
+
+def pytest_addoption(parser):
+    parser.addoption("--gnomon-dsn", default=os.environ.get("GNOMON_TEST_DSN"), help="database with gnomon (seeded)")
+    parser.addoption("--gnomon-keep", action="store_true", help="keep test branches for inspection")
+    parser.addoption("--gnomon-update-snapshots", action="store_true", help="record branch snapshots instead of comparing")
+    parser.addoption("--gnomon-snapshot-dir", default=None, help="where snapshots live (default: __gnomon_snapshots__ beside the test)")
+
+
+@pytest.fixture
+def gnomon_snapshot(request):
+    """Compare the test branch's diff with a stored snapshot: ``gnomon_snapshot.assert_match(gnomon_conn)``."""
+    from .testing import Snapshot, snapshot_dir
+    return Snapshot(snapshot_dir(request), request.config.getoption("--gnomon-update-snapshots"))
+
+
+@pytest.fixture(scope="session")
+def gnomon_dsn(request):
+    dsn = request.config.getoption("--gnomon-dsn")
+    if not dsn:
+        pytest.skip("set --gnomon-dsn or GNOMON_TEST_DSN")
+    return dsn
+
+
+@pytest.fixture
+def gnomon_branch(request, gnomon_dsn):
+    import psycopg
+
+    with psycopg.connect(gnomon_dsn, autocommit=True) as admin:
+        name = create_scratch(admin, prefix="pytest")
+    yield name
+    if not request.config.getoption("--gnomon-keep"):
+        with psycopg.connect(gnomon_dsn, autocommit=True) as admin:
+            drop_branch(admin, name)
+
+
+@pytest.fixture
+def gnomon_conn(gnomon_dsn, gnomon_branch):
+    import psycopg
+
+    conn = psycopg.connect(gnomon_dsn, autocommit=True)
+    use(conn, gnomon_branch)
+    try:
+        yield conn
+    finally:
+        conn.close()

gnomon/sqlalchemy.py

@@ -0,0 +1,32 @@
+"""SQLAlchemy integration.
+
+``branch_engine(url, "feature")`` returns an engine whose connections start on a branch.
+``attach_branch(engine, lambda: current_branch)`` puts every transaction on whatever branch the
+callable returns (``None`` or ``"main"`` for main), using gnomon.begin(), which is safe behind
+transaction poolers.
+"""
+from __future__ import annotations
+
+from typing import Callable, Optional
+
+from sqlalchemy import create_engine, event, text
+
+from . import branch_options
+
+
+def branch_engine(url: str, branch: str, *, c_module: bool = False, schemas=("public",), scratch: bool = False, **kw):
+    connect_args = dict(kw.pop("connect_args", {}))
+    connect_args["options"] = branch_options(branch, c_module=c_module, schemas=tuple(schemas), scratch=scratch)
+    return create_engine(url, connect_args=connect_args, **kw)
+
+
+def attach_branch(engine, get_branch: Callable[[], Optional[str]]) -> None:
+    @event.listens_for(engine, "begin")
+    def _begin(conn):  # pragma: no cover - exercised in tests
+        b = get_branch()
+        if b and b != "main":
+            conn.exec_driver_sql("select gnomon.begin(%(b)s)", {"b": b})
+
+
+def use(conn, branch: str = "main") -> None:
+    conn.execute(text("select gnomon.use(:b)"), {"b": branch})

gnomon/testing.py

@@ -0,0 +1,129 @@
+"""The testing layer: snapshot assertions on a branch's diff, normalized as the
+specification says (sdk/spec/SPEC.md, Snapshots), with the golden files the TypeScript SDK checks.
+
+    def test_signup(gnomon_conn, gnomon_snapshot):
+        ...
+        gnomon_snapshot.assert_match(gnomon_conn)     # pytest --gnomon-update-snapshots to record
+"""
+from __future__ import annotations
+
+import os
+from decimal import Decimal
+from pathlib import Path
+from typing import Any, Iterable, Optional
+
+from ._util import parse_json, stable_json
+
+
+def _short(t: str) -> str:
+    return t.split(".")[-1]
+
+
+def _sort_key(k: dict):
+    out = []
+    for name in sorted(k):
+        v = k[name]
+        out.append((0, v, "") if isinstance(v, (int, float, Decimal)) and not isinstance(v, bool) else (1, 0, str(v)))
+    return out
+
+
+def normalize_diff(diff: Iterable[dict], *, ignore: Iterable[str] = (), foreign_keys: Iterable[dict] = ()) -> list[str]:
+    rows = [{"table": str(d["table"]), "key": d["key"], "kind": d["kind"],
+             "col": d.get("column", d.get("col")), "old": d.get("old"), "new": d.get("new")} for d in diff]
+    ignore = set(ignore)
+    by_table: dict[str, list[dict]] = {}
+    for r in rows:
+        ks = by_table.setdefault(r["table"], [])
+        if not any(stable_json(k) == stable_json(r["key"]) for k in ks):
+            ks.append(r["key"])
+    ph: dict[str, str] = {}
+    idx: dict[str, int] = {}
+    for t, ks in by_table.items():
+        for i, k in enumerate(sorted(ks, key=_sort_key)):
+            ph[f"{t}|{stable_json(k)}"] = f"<{_short(t)}:{i + 1}>"
+            idx[f"{t}|{stable_json(k)}"] = i + 1
+    fks = list(foreign_keys)
+
+    def value(table: str, key: dict, col: str, v: Any) -> str:
+        if len(key) == 1 and col in key:
+            return ph.get(f"{table}|{stable_json(key)}", stable_json(v))
+        for f in fks:
+            if f["table"] == table and f["columns"] == [col]:
+                p = ph.get(f"{f['references']}|{stable_json({f['referenced_columns'][0]: v})}")
+                if p:
+                    return p
+        return stable_json(v)
+
+    lines: dict[str, tuple] = {}
+    for r in rows:
+        ident = f"{r['table']}|{stable_json(r['key'])}"
+        p, i = ph[ident], idx[ident]
+        if r["kind"] == "delete":
+            s = f"{r['table']} {p} delete"
+            lines[s] = (r["table"], i, s)
+        elif r["kind"] == "insert":
+            for c, v in (r["new"] or {}).items():
+                if c in ignore:
+                    continue
+                s = f"{r['table']} {p} insert {c} = {value(r['table'], r['key'], c, v)}"
+                lines[s] = (r["table"], i, s)
+        elif r["col"] is not None and r["col"] not in ignore:
+            s = f"{r['table']} {p} update {r['col']}: {value(r['table'], r['key'], r['col'], r['old'])} -> {value(r['table'], r['key'], r['col'], r['new'])}"
+            lines[s] = (r["table"], i, s)
+    return [x[2] for x in sorted(lines.values())]
+
+
+def branch_snapshot(conn, branch: str, *, ignore: Iterable[str] = ()) -> str:
+    """A branch's diff as snapshot text, through a psycopg connection."""
+    with conn.cursor() as cur:
+        cur.execute("select tbl::text, key::text, kind, col, old::text, new::text from gnomon.diff(%s)", (branch,))
+        diff = [{"table": t if "." in t else f"public.{t}", "key": parse_json(k), "kind": kind, "col": col, "old": parse_json(o), "new": parse_json(n)}
+                for t, k, kind, col, o, n in cur.fetchall()]
+        cur.execute("""select format('%%I.%%I', n.nspname, c.relname), (select array_agg(a.attname::text order by k.o) from unnest(f.conkey) with ordinality k(n, o) join pg_attribute a on a.attrelid = f.conrelid and a.attnum = k.n),
+                              format('%%I.%%I', pn.nspname, p.relname), (select array_agg(a.attname::text order by k.o) from unnest(f.confkey) with ordinality k(n, o) join pg_attribute a on a.attrelid = f.confrelid and a.attnum = k.n)
+                         from pg_constraint f join pg_class c on c.oid = f.conrelid join pg_namespace n on n.oid = c.relnamespace
+                         join pg_class p on p.oid = f.confrelid join pg_namespace pn on pn.oid = p.relnamespace where f.contype = 'f'""")
+        fks = [{"table": a, "columns": b, "references": c, "referenced_columns": d} for a, b, c, d in cur.fetchall()]
+    return "\n".join(normalize_diff(diff, ignore=ignore, foreign_keys=fks)) + "\n"
+
+
+class Snapshot:
+    """``assert_match`` compares a branch's diff with a stored file (recorded with --gnomon-update-snapshots)."""
+
+    def __init__(self, path: Path, update: bool):
+        self.path, self.update = path, update
+
+    def assert_match(self, conn, branch: Optional[str] = None, *, ignore: Iterable[str] = ()) -> None:
+        if branch is None:
+            with conn.cursor() as cur:
+                cur.execute("select gnomon.current_branch()")
+                branch = cur.fetchone()[0]
+        got = branch_snapshot(conn, branch, ignore=ignore)
+        if self.update or not self.path.exists():
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            self.path.write_text(got)
+            return
+        want = self.path.read_text()
+        assert got == want, f"the branch's changes differ from {self.path}:\n--- stored\n{want}--- now\n{got}"
+
+
+def assert_no_changes(conn, branch: str, tables: Optional[Iterable[str]] = None) -> None:
+    with conn.cursor() as cur:
+        cur.execute("select tbl::text, key from gnomon.diff(%s)", (branch,))
+        hit = [(t, k) for t, k in cur.fetchall() if tables is None or any(t == x or t.endswith("." + x) for x in tables)]
+    assert not hit, f"expected no changes, found {len(hit)}: {hit[:5]}"
+
+
+def assert_changed(conn, branch: str, table: str, key: dict, column: str, value: Any) -> None:
+    with conn.cursor() as cur:
+        cur.execute("select kind, col, new::text from gnomon.diff(%s, null, array[%s::regclass], %s::jsonb)", (branch, table, stable_json([key])))
+        for kind, col, new in cur.fetchall():
+            n = parse_json(new)
+            if (kind == "update" and col == column and n == value) or (kind == "insert" and (n or {}).get(column) == value):
+                return
+    raise AssertionError(f"expected {table} {key}.{column} = {value!r} on {branch}")
+
+
+def snapshot_dir(request) -> Path:
+    base = Path(request.config.getoption("--gnomon-snapshot-dir") or os.path.join(os.path.dirname(str(request.fspath)), "__gnomon_snapshots__"))
+    return base / (request.node.name.replace("/", "_") + ".txt")

gnomon/tools.json

@@ -0,0 +1,40 @@
+{
+  "version": 1,
+  "tools": [
+    {
+      "name": "sql",
+      "description": "Run one SQL statement on your working copy of the database (a branch). Reads see your own changes; writes never reach the real data until a person accepts them. One statement per call. Upserts (INSERT ... ON CONFLICT) are not supported unless the server has gnomon's C module: write an UPDATE, then an INSERT ... SELECT ... WHERE NOT EXISTS. Results are cut at a row limit; `truncated` says when.",
+      "input": {"type": "object", "properties": {"statement": {"type": "string", "description": "one SQL statement"}, "reason": {"type": "string", "description": "why, for writes: kept with the change"}}, "required": ["statement"]}
+    },
+    {
+      "name": "describe",
+      "description": "Describe the database: tables you can read, their columns and keys, foreign keys both ways, which tables you can change, masked columns, row estimates. Call it before writing SQL.",
+      "input": {"type": "object", "properties": {"schema": {"type": "string", "description": "one schema, default all"}}, "required": []}
+    },
+    {
+      "name": "diff",
+      "description": "What you have changed so far, field by field.",
+      "input": {"type": "object", "properties": {}, "required": []}
+    },
+    {
+      "name": "dry_run",
+      "description": "Try statements without keeping them: returns the changes they would make, the checks and any error. Nothing is kept.",
+      "input": {"type": "object", "properties": {"statements": {"type": "array", "items": {"type": "string"}}}, "required": ["statements"]}
+    },
+    {
+      "name": "checkpoint",
+      "description": "Remember the current state of your changes under a name, to rewind to it later.",
+      "input": {"type": "object", "properties": {"name": {"type": "string"}}, "required": ["name"]}
+    },
+    {
+      "name": "rewind",
+      "description": "Undo every change you made since a checkpoint.",
+      "input": {"type": "object", "properties": {"name": {"type": "string"}}, "required": ["name"]}
+    },
+    {
+      "name": "done",
+      "description": "Say you are finished: a person reviews your changes and accepts or rejects them. Summarize what you did and why.",
+      "input": {"type": "object", "properties": {"summary": {"type": "string"}}, "required": ["summary"]}
+    }
+  ]
+}

gnomon/tools.py

@@ -0,0 +1,103 @@
+"""Tools for models, bound to one run (sdk/spec/SPEC.md, Tools for models). The descriptions are
+the specification's (tools.json, checked against sdk/spec/tools.json).
+
+    from gnomon.tools import anthropic_tools
+    tools = anthropic_tools(run)                 # @beta_tool functions for the Anthropic tool runner
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from ._util import stable_json
+from .errors import GnomonError
+
+TOOL_SPECS: list[dict] = json.loads((Path(__file__).parent / "tools.json").read_text())["tools"]
+
+
+def run_tool(run, name: str, args: dict) -> tuple[str, bool]:
+    """Run one tool on a (sync) run: (text for the model, is_error). Errors are returned, not raised."""
+    try:
+        if name == "sql":
+            r = run.sql(str(args.get("statement", "")), reason=args.get("reason"))
+            v: Any = {"rows": r["rows"], "row_count": r["row_count"], "truncated": r["truncated"]}
+        elif name == "describe":
+            v = run.describe(args.get("schema"))
+        elif name == "diff":
+            v = run.diff()
+        elif name == "dry_run":
+            v = run.dry_run(list(args.get("statements") or []))
+        elif name == "checkpoint":
+            v = {"checkpoint": run.checkpoint(str(args["name"]))}
+        elif name == "rewind":
+            v = run.rewind(str(args["name"]))
+        elif name == "done":
+            summary = str(args.get("summary", ""))
+            v = {"change_request": run.submit(summary.split("\n")[0][:100] or None, summary).id, "note": "a person reviews it now"}
+        else:
+            raise GnomonError(f"unknown tool {name}")
+        return stable_json(v), False
+    except GnomonError as e:
+        return f"{type(e).__name__}: {e}" + (f"\nhint: {e.hint}" if e.hint else ""), True
+
+
+def tool_definitions() -> list[dict]:
+    """Plain definitions (name, description, input_schema) for any framework or the Messages API."""
+    return [{"name": f"gnomon_{t['name']}", "description": t["description"], "input_schema": t["input"]} for t in TOOL_SPECS]
+
+
+def handle_tool_use(run, block: dict) -> dict:
+    """Answer an Anthropic tool_use block with a tool_result block."""
+    text, err = run_tool(run, block["name"].removeprefix("gnomon_"), block.get("input") or {})
+    return {"type": "tool_result", "tool_use_id": block["id"], "content": text, "is_error": err}
+
+
+def anthropic_tools(run) -> list:
+    """Functions decorated with the Anthropic SDK's @beta_tool (needs anthropic). The input schemas
+    are the specification's: beta_tool would infer an empty one from the functions' ``**kw``."""
+    from anthropic import beta_tool  # type: ignore
+
+    def make(name: str):
+        def fn(**kw):
+            return run_tool(run, name, kw)[0]
+        return fn
+    return [beta_tool(make(t["name"]), name=f"gnomon_{t['name']}", description=t["description"], input_schema=t["input"])
+            for t in TOOL_SPECS]
+
+
+def openai_agents_tools(run) -> list:
+    """FunctionTool objects for the OpenAI Agents SDK (needs openai-agents)."""
+    from agents import FunctionTool  # type: ignore
+
+    def make(t):
+        async def invoke(_ctx, args_json: str) -> str:
+            return run_tool(run, t["name"], json.loads(args_json or "{}"))[0]
+        return FunctionTool(name=f"gnomon_{t['name']}", description=t["description"],
+                            params_json_schema={**t["input"], "additionalProperties": False}, on_invoke_tool=invoke, strict_json_schema=False)
+    return [make(t) for t in TOOL_SPECS]
+
+
+def langchain_tools(run) -> list:
+    """StructuredTool objects for LangChain and LangGraph (needs langchain-core)."""
+    from langchain_core.tools import StructuredTool  # type: ignore
+
+    return [StructuredTool.from_function(func=(lambda name: (lambda **kw: run_tool(run, name, kw)[0]))(t["name"]),
+                                         name=f"gnomon_{t['name']}", description=t["description"], args_schema=t["input"]) for t in TOOL_SPECS]
+
+
+def mcp_handler(run):
+    """A JSON-RPC handler bound to the run (tools/list, tools/call) for any MCP transport."""
+    def handle(req: dict) -> dict:
+        m, p = req.get("method"), req.get("params") or {}
+        if m == "initialize":
+            return {"jsonrpc": "2.0", "id": req.get("id"), "result": {"protocolVersion": p.get("protocolVersion", "2025-06-18"),
+                    "capabilities": {"tools": {}}, "serverInfo": {"name": "gnomon", "version": "1.0.0"}}}
+        if m == "tools/list":
+            return {"jsonrpc": "2.0", "id": req.get("id"), "result": {"tools": [{"name": t["name"], "description": t["description"], "inputSchema": t["input"]} for t in TOOL_SPECS],
+                    "ttlMs": 3600000, "cacheScope": "private"}}
+        if m == "tools/call":
+            text, err = run_tool(run, p.get("name", ""), p.get("arguments") or {})
+            return {"jsonrpc": "2.0", "id": req.get("id"), "result": {"content": [{"type": "text", "text": text}], "isError": err, "resultType": "complete"}}
+        return {"jsonrpc": "2.0", "id": req.get("id"), "error": {"code": -32601, "message": f"method not found: {m}"}}
+    return handle

gnomon_postgres-1.0.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: gnomon-postgres
+Version: 1.0.0
+Summary: Branches, time travel and merges for PostgreSQL apps: psycopg helpers, SQLAlchemy, Django and pytest fixtures for the gnomon extension
+License-Expression: PostgreSQL
+Project-URL: Homepage, https://gnomon.bitsinfra.com/
+Project-URL: Repository, https://github.com/bitsinfra/gnomon
+Project-URL: Issues, https://github.com/bitsinfra/gnomon/issues
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psycopg>=3.1
+Provides-Extra: sqlalchemy
+Requires-Dist: sqlalchemy>=2; extra == "sqlalchemy"
+Provides-Extra: django
+Requires-Dist: django>=4.2; extra == "django"
+Provides-Extra: asyncpg
+Requires-Dist: asyncpg>=0.29; extra == "asyncpg"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# gnomon-postgres (Python)
+
+Branches, time travel and merges for PostgreSQL apps on the gnomon extension: the SDK (runs for
+agents and tasks, review, the core), psycopg helpers, SQLAlchemy and Django, and pytest fixtures
+with snapshots. `import gnomon`.
+
+```python
+from gnomon import Gnomon
+
+gn = Gnomon(app="dbname=shop user=shop_app", runs="dbname=shop user=shop_runs")
+with gn.start_run("Refund order 3", actor="support-bot") as run:   # a branch for this task
+    run.sql("update orders set status = 'refunded' where id = 3")
+    if run.summary()["checks"]["passed"]: run.merge()
+    else: run.submit("Refund order 3")                               # a change request instead
+```
+
+Leaving the `with` block without `merge()` or `submit()` discards the branch. `run.url(base)` and
+`run.connection(base)` give a tool a connection string, or a psycopg connection, pinned to the run
+(a login of the run's own, confined to its branch, dropped when the run ends). With asyncpg:
+`AsyncGnomon(app=asyncpg_source(pool), runs=asyncpg_source(runs_pool))` (`from gnomon.asyncpg import
+asyncpg_source`; the `asyncpg` extra). `AsyncGnomon` is the
+same API for `psycopg.AsyncConnection` (the sync client is generated from it, so they cannot
+drift). `gn.requests`, `gn.branches`, `history`, `blame`, `revert`, `status()` and `doctor()` are
+the review and core layers. Tools for agent frameworks bound to one run:
+`gnomon.tools.anthropic_tools(run)`, `openai_agents_tools(run)`, `langchain_tools(run)`,
+`mcp_handler(run)`. The two logins, the envelope and the errors are as in the TypeScript SDK
+([sdk/ts/README.md](../../sdk/ts/README.md)); both pass the same conformance scenarios
+([sdk/spec](../../sdk/spec)).
+
+## Helpers
+
+```python
+import gnomon, psycopg
+conn = psycopg.connect(gnomon.branch_dsn("dbname=shop", "feature"))   # sessions start on a branch
+with gnomon.branch(conn, "feature"): ...                               # or switch one connection
+opts = gnomon.connection_options(admin_conn, "feature")                # what the database says the
+                                                                       # branch needs (schema versions, masks)
+```
+
+`use`, `begin` (one transaction, for poolers), `create_branch`, `create_scratch`, `drop_branch`,
+`diff`, `merge`. SQLAlchemy: `gnomon.sqlalchemy.branch_engine(url, branch)` and
+`attach_branch(engine, get_branch)` (each transaction on the branch a callable names). Django:
+`gnomon.django.BranchMiddleware` (a branch per request from `X-Gnomon-Branch`).
+
+## Tests on branches
+
+```python
+def test_signup(gnomon_conn, gnomon_snapshot):     # a psycopg connection on a fresh scratch branch
+    signup(gnomon_conn, "a@x.io")
+    gnomon_snapshot.assert_match(gnomon_conn)      # the branch's diff against a stored file
+```
+
+`GNOMON_TEST_DSN=... pytest` (the plugin loads itself when the package is installed;
+`--gnomon-update-snapshots` records, `--gnomon-keep` keeps the branches).
+`gnomon.testing.assert_no_changes` and `assert_changed` check a branch's diff directly.
+
+Install: `pip install gnomon-postgres` (extras: `sqlalchemy`, `django`, `test`).

gnomon_postgres-1.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+gnomon/__init__.py,sha256=VAeoRn9SWkDUYfqR8tMMxGxh9h8XXjURPYsKGsHVTWc,5702
+gnomon/_util.py,sha256=3bUAl6VLN8Z6pi07EhhHIUemGLvPFths55LRaWs2_m8,2798
+gnomon/aio.py,sha256=Olf-_huDimv9OkQ0jWWoxf5hOXPj75OLwVGIfueE8dE,18258
+gnomon/asyncpg.py,sha256=haL9WMtpJ3HM_JdkpSMfDD3H8iKpbAg0Aqk69ZRdqsA,5724
+gnomon/client.py,sha256=NLTco_gvD8zs1nxaBBpm0TD2ZVHKNmJZvgi3JcLzM2w,17298
+gnomon/django.py,sha256=GkA1ei2kYytV17hMaIrMuQeYYncv5abD_u9H6MXF4s4,2730
+gnomon/errors.py,sha256=lPpAgDEJJ0XyWjILutc1pe-os-WBPwLCqcAWiaSjl-0,2654
+gnomon/pytest_plugin.py,sha256=yirXfCCkuEGJ6zwB4NNXLuWA02rwdQxrt01et5YsCPc,2168
+gnomon/sqlalchemy.py,sha256=DO47QryXYNQbERvY1VF09BFqALPFKOcSyqX6nG8FxxA,1256
+gnomon/testing.py,sha256=KqhX3mRTjV3Mi6D4U7kBSiHHWam9JjCa-tF40ICTeHI,6507
+gnomon/tools.json,sha256=-nqaRQF-3Ppu4bjLAu3CcaWrLh0AmRDkzDmjSDafzHE,2327
+gnomon/tools.py,sha256=bSD_vfg7Maum6EK9JZO37C3pC9R0JkFOG7cBTUMVPbA,5145
+gnomon_postgres-1.0.0.dist-info/licenses/LICENSE,sha256=gMGd1ia320QA8YQVbOpx-VjCmZKQiAhpF6uRj3Rb96g,1004
+gnomon_postgres-1.0.0.dist-info/METADATA,sha256=d4s_h2SRNOWZ5dw-eiIvAv21ymWMF8NJJrDrV_2jSEo,3936
+gnomon_postgres-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+gnomon_postgres-1.0.0.dist-info/entry_points.txt,sha256=U5Ktr_pn9DXztumm1rhWGfZ4a6MYK23X86EFr7s2Qh4,41
+gnomon_postgres-1.0.0.dist-info/top_level.txt,sha256=OmatCqPQU5O9PKfuUnk9ISukfjNNHIqGJrkis6wc0pU,7
+gnomon_postgres-1.0.0.dist-info/RECORD,,

gnomon_postgres-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gnomon_postgres-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+gnomon = gnomon.pytest_plugin

gnomon_postgres-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,17 @@
+PostgreSQL License
+
+Copyright (c) 2026, The Gnomon Contributors
+
+Permission to use, copy, modify, and distribute this software and its documentation for any
+purpose, without fee, and without a written agreement is hereby granted, provided that the
+above copyright notice and this paragraph and the following two paragraphs appear in all copies.
+
+IN NO EVENT SHALL THE GNOMON CONTRIBUTORS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL,
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS
+SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE GNOMON CONTRIBUTORS HAVE BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+THE GNOMON CONTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED
+HEREUNDER IS ON AN "AS IS" BASIS, AND THE GNOMON CONTRIBUTORS HAVE NO OBLIGATIONS TO PROVIDE
+MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

gnomon_postgres-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gnomon