sqlproof 0.1.0a1__py3-none-any.whl

sqlproof/schema/parse_sql.py

@@ -0,0 +1,206 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Literal, cast
+
+from pglast import parse_sql as parse_postgres_sql
+from pglast.enums import ConstrType
+from pglast.stream import RawStream
+
+from sqlproof.exceptions import SqlProofSchemaError
+from sqlproof.schema.model import CheckConstraint, Column, ForeignKey, PgType, SchemaInfo, Table
+
+
+def parse_schema_sql(sql: str, *, schema: str = "public") -> SchemaInfo:
+    try:
+        statements: tuple[Any, ...] = tuple(parse_postgres_sql(sql))
+    except Exception as exc:
+        raise SqlProofSchemaError(str(exc)) from exc
+
+    enums: list[PgType] = []
+    enum_names: dict[str, PgType] = {}
+    for raw_statement in statements:
+        statement: Any = raw_statement.stmt
+        if type(statement).__name__ == "CreateEnumStmt":
+            enum_schema, enum_name = _qualified_parts(statement.typeName, default_schema=schema)
+            enum = PgType(
+                kind="enum",
+                name=enum_name,
+                enum_values=tuple(_sval(value) for value in statement.vals),
+            )
+            enums.append(enum)
+            enum_names[enum_name] = enum
+            enum_names[f"{enum_schema}.{enum_name}"] = enum
+
+    tables = tuple(
+        _parse_table_statement(raw_statement.stmt, enum_names, schema)
+        for raw_statement in statements
+        if type(raw_statement.stmt).__name__ == "CreateStmt"
+    )
+    if not tables and "CREATE TABLE" in sql.upper():
+        raise SqlProofSchemaError("Could not parse CREATE TABLE statement.")
+    return SchemaInfo(tables=tables, enums=tuple(enums))
+
+
+def _parse_table_statement(statement: Any, enum_names: dict[str, PgType], schema: str) -> Table:
+    relation = statement.relation
+    table_schema = relation.schemaname or schema
+    table_name = relation.relname
+    columns: list[Column] = []
+    primary_key: tuple[str, ...] = ()
+    foreign_keys: list[ForeignKey] = []
+    unique_constraints: list[tuple[str, ...]] = []
+    check_constraints: list[CheckConstraint] = []
+
+    for element in statement.tableElts or ():
+        if type(element).__name__ == "ColumnDef":
+            column = _parse_column(element, enum_names)
+            columns.append(column)
+            for constraint in element.constraints or ():
+                if constraint.contype == ConstrType.CONSTR_PRIMARY:
+                    primary_key = (column.name,)
+                elif constraint.contype == ConstrType.CONSTR_UNIQUE:
+                    unique_constraints.append((column.name,))
+                elif constraint.contype == ConstrType.CONSTR_FOREIGN:
+                    foreign_keys.append(_parse_foreign_key(constraint, columns=(column.name,)))
+                elif constraint.contype == ConstrType.CONSTR_CHECK:
+                    check_constraints.append(_parse_check(constraint))
+            continue
+        if element.contype == ConstrType.CONSTR_PRIMARY:
+            primary_key = _constraint_keys(element)
+        elif element.contype == ConstrType.CONSTR_UNIQUE:
+            unique_constraints.append(_constraint_keys(element))
+        elif element.contype == ConstrType.CONSTR_FOREIGN:
+            foreign_keys.append(_parse_foreign_key(element))
+        elif element.contype == ConstrType.CONSTR_CHECK:
+            check_constraints.append(_parse_check(element))
+
+    return Table(
+        schema=table_schema,
+        name=table_name,
+        columns=tuple(columns),
+        primary_key=primary_key,
+        foreign_keys=tuple(foreign_keys),
+        unique_constraints=tuple(unique_constraints),
+        check_constraints=tuple(check_constraints),
+    )
+
+
+def _parse_column(column: Any, enum_names: dict[str, PgType]) -> Column:
+    constraints = tuple(column.constraints or ())
+    pg_type = _parse_type_node(column.typeName, enum_names)
+    identity = _identity_for_constraints(constraints)
+    primary = any(constraint.contype == ConstrType.CONSTR_PRIMARY for constraint in constraints)
+    not_null = (
+        column.is_not_null
+        or primary
+        or any(constraint.contype == ConstrType.CONSTR_NOTNULL for constraint in constraints)
+    )
+    return Column(
+        name=column.colname,
+        type=pg_type,
+        nullable=not not_null,
+        default=_default_for_constraints(constraints),
+        is_generated=pg_type.name in {"serial", "bigserial"} or identity is not None,
+        identity=identity,
+    )
+
+
+def _parse_type_node(type_node: Any, enum_names: dict[str, PgType]) -> PgType:
+    parts = tuple(_sval(part) for part in type_node.names)
+    name = _normalize_type_name(".".join(parts))
+    if name in enum_names:
+        return enum_names[name]
+    unqualified = name.rsplit(".", 1)[-1]
+    if unqualified in enum_names:
+        return enum_names[unqualified]
+    modifiers = tuple(_const_int(modifier) for modifier in type_node.typmods or ())
+    return PgType(kind="scalar", name=unqualified, modifiers=modifiers)
+
+
+def _parse_foreign_key(constraint: Any, *, columns: tuple[str, ...] | None = None) -> ForeignKey:
+    return ForeignKey(
+        columns=columns or tuple(_sval(value) for value in constraint.fk_attrs),
+        referenced_table=constraint.pktable.relname,
+        referenced_columns=tuple(_sval(value) for value in constraint.pk_attrs),
+        on_delete=_referential_action(constraint.fk_del_action),
+        on_update=_referential_action(constraint.fk_upd_action),
+        referenced_schema=getattr(constraint.pktable, "schemaname", None),
+    )
+
+
+def _parse_check(constraint: Any) -> CheckConstraint:
+    return CheckConstraint(_render(constraint.raw_expr))
+
+
+def _constraint_keys(constraint: Any) -> tuple[str, ...]:
+    return tuple(_sval(value) for value in constraint.keys)
+
+
+def _default_for_constraints(constraints: tuple[Any, ...]) -> str | None:
+    for constraint in constraints:
+        if constraint.contype == ConstrType.CONSTR_DEFAULT:
+            return _render(constraint.raw_expr)
+    return None
+
+
+def _identity_for_constraints(
+    constraints: tuple[Any, ...],
+) -> Literal["always", "by_default"] | None:
+    for constraint in constraints:
+        if constraint.contype == ConstrType.CONSTR_IDENTITY:
+            if constraint.generated_when == "a":
+                return "always"
+            if constraint.generated_when == "d":
+                return "by_default"
+    return None
+
+
+def _referential_action(
+    action: str,
+) -> Literal["NO ACTION", "RESTRICT", "CASCADE", "SET NULL", "SET DEFAULT"]:
+    return cast(
+        Literal["NO ACTION", "RESTRICT", "CASCADE", "SET NULL", "SET DEFAULT"],
+        {
+            "a": "NO ACTION",
+            "r": "RESTRICT",
+            "c": "CASCADE",
+            "n": "SET NULL",
+            "d": "SET DEFAULT",
+            "\x00": "NO ACTION",
+        }.get(action, "NO ACTION"),
+    )
+
+
+def _qualified_parts(parts: tuple[Any, ...], *, default_schema: str) -> tuple[str, str]:
+    values = tuple(_sval(part) for part in parts)
+    if len(values) == 1:
+        return default_schema, values[0]
+    return values[-2], values[-1]
+
+
+def _sval(node: Any) -> str:
+    return str(node.sval)
+
+
+def _const_int(node: Any) -> int:
+    return int(node.val.ival)
+
+
+def _render(node: Any) -> str:
+    stream = RawStream()  # type: ignore[no-untyped-call]
+    return str(stream(node))
+
+
+def _normalize_type_name(name: str) -> str:
+    normalized = re.sub(r"\s+", " ", name.lower())
+    return {
+        "pg_catalog.int2": "smallint",
+        "pg_catalog.int4": "integer",
+        "pg_catalog.int8": "bigint",
+        "pg_catalog.float4": "real",
+        "pg_catalog.float8": "double precision",
+        "pg_catalog.bool": "boolean",
+        "pg_catalog.varchar": "varchar",
+        "pg_catalog.bpchar": "char",
+    }.get(normalized, normalized)

sqlproof/testing.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from contextlib import AbstractContextManager, ExitStack
+from typing import TYPE_CHECKING, Any, ClassVar, TypeVar
+
+from hypothesis import strategies as st
+from hypothesis.stateful import RuleBasedStateMachine
+from hypothesis.strategies import SearchStrategy
+
+from sqlproof.exceptions import SqlProofUsageError
+from sqlproof.generators.graph import Dataset, SizeSpec, dataset_strategy
+from sqlproof.schema.model import Column, PgType, SchemaInfo, Table
+
+if TYPE_CHECKING:
+    from sqlproof.client import SqlProofClient
+    from sqlproof.core import SqlProof
+
+_T = TypeVar("_T")
+
+
+class SqlProofStateMachine(RuleBasedStateMachine):
+    """Base class for Hypothesis stateful tests against a SqlProof database.
+
+    Each example leases an isolated client via `proof.client_for_dataset(...)`
+    so that writes from one example are rolled back before the next begins.
+    Subclasses define `@rule`s and `@invariant`s as usual, and override
+    `on_setup()` for per-example fixture creation. `self.db` is the live
+    `SqlProofClient`.
+
+    Run a machine with `SqlProof.run_state_machine(MyMachine, settings=...)`,
+    which binds the proof and dispatches to `run_state_machine_as_test`.
+    """
+
+    initial_dataset: ClassVar[dict[str, list[dict[str, Any]]]] = {}
+    _sqlproof_proof: ClassVar[SqlProof | None] = None
+
+    db: SqlProofClient
+
+    def __init__(self) -> None:
+        if self._sqlproof_proof is None:
+            msg = (
+                "SqlProofStateMachine cannot be instantiated directly. "
+                "Use SqlProof.run_state_machine(YourMachine) to run it."
+            )
+            raise SqlProofUsageError(msg)
+        super().__init__()
+        self._stack = ExitStack()
+        self.db = self._stack.enter_context(
+            self._sqlproof_proof.client_for_dataset(dict(self.initial_dataset))
+        )
+        self.on_setup()
+
+    def on_setup(self) -> None:
+        """Override to seed per-example fixtures. `self.db` is ready."""
+
+    def enter(self, cm: AbstractContextManager[_T]) -> _T:
+        """Enter `cm` and tie its lifetime to this example.
+
+        Use for resources that need to live across rules within an example
+        and be released between examples — JWT-claim contexts, savepoints,
+        mocked clocks, etc. The context manager is closed during `teardown`
+        in reverse-entry order.
+        """
+        return self._stack.enter_context(cm)
+
+    def teardown(self) -> None:
+        if hasattr(self, "_stack"):
+            self._stack.close()
+
+
+def schemas(max_tables: int = 3, max_columns: int = 5) -> SearchStrategy[SchemaInfo]:
+    del max_columns
+    table_names = st.lists(
+        st.sampled_from(["users", "orders", "products", "scores", "events"]),
+        min_size=1,
+        max_size=max_tables,
+        unique=True,
+    )
+
+    def build(names: list[str]) -> SchemaInfo:
+        integer = PgType("scalar", "integer")
+        tables = tuple(
+            Table(
+                schema="public",
+                name=name,
+                columns=(Column("id", integer, False, None, False),),
+                primary_key=("id",),
+                foreign_keys=(),
+                unique_constraints=(),
+                check_constraints=(),
+            )
+            for name in names
+        )
+        return SchemaInfo(tables=tables)
+
+    return table_names.map(build)
+
+
+def datasets_for(schema: SchemaInfo, sizes: Mapping[str, SizeSpec]) -> SearchStrategy[Dataset]:
+    return dataset_strategy(schema, sizes=sizes)

sqlproof/types.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from sqlproof.schema.parse_sql import parse_schema_sql
+
+
+def generate_types(schema_file: Path, *, style: str = "typeddict") -> str:
+    schema = parse_schema_sql(schema_file.read_text(encoding="utf-8"))
+    lines = ["from __future__ import annotations"]
+    if style == "typeddict":
+        lines.append("from typing import TypedDict")
+        for table in schema.tables:
+            class_name = _class_name(table.name)
+            lines.extend(["", f"class {class_name}(TypedDict):"])
+            for column in table.columns:
+                lines.append(f"    {column.name}: object")
+    elif style == "dataclass":
+        lines.append("from dataclasses import dataclass")
+        for table in schema.tables:
+            lines.extend(["", "@dataclass", f"class {_class_name(table.name)}:"])
+            for column in table.columns:
+                lines.append(f"    {column.name}: object")
+    else:
+        lines.append("from pydantic import BaseModel")
+        for table in schema.tables:
+            lines.extend(["", f"class {_class_name(table.name)}(BaseModel):"])
+            for column in table.columns:
+                lines.append(f"    {column.name}: object")
+    return "\n".join(lines) + "\n"
+
+
+def _class_name(table_name: str) -> str:
+    return "".join(part.capitalize() for part in table_name.split("_")).removesuffix("s")

sqlproof-0.1.0a1.dist-info/METADATA

@@ -0,0 +1,248 @@
+Metadata-Version: 2.4
+Name: sqlproof
+Version: 0.1.0a1
+Summary: Property-based testing for PostgreSQL schemas and SQL behavior. Early-stage alpha — APIs may change.
+Project-URL: Homepage, https://sqlproof.com
+Project-URL: Documentation, https://sqlproof.com
+Project-URL: Repository, https://github.com/alialavia/sqlproof
+Project-URL: Issues, https://github.com/alialavia/sqlproof/issues
+Project-URL: Changelog, https://github.com/alialavia/sqlproof/blob/main/CHANGELOG.md
+Author: SqlProof contributors
+License: MIT
+Keywords: hypothesis,postgres,postgresql,property-based-testing,rls,sql,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Hypothesis
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Database Engines/Servers
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: hypothesis>=6.100
+Requires-Dist: pglast>=6.0
+Requires-Dist: psycopg[binary]>=3.1
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: mutmut; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pyright; extra == 'dev'
+Requires-Dist: pytest-benchmark; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-xdist; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: syrupy; extra == 'dev'
+Requires-Dist: uv; extra == 'dev'
+Provides-Extra: pydantic
+Requires-Dist: pydantic>=2.0; extra == 'pydantic'
+Provides-Extra: testcontainers
+Requires-Dist: testcontainers[postgres]>=4.0; extra == 'testcontainers'
+Description-Content-Type: text/markdown
+
+# SqlProof
+
+[![CI](https://github.com/alialavia/sqlproof/actions/workflows/ci.yml/badge.svg)](https://github.com/alialavia/sqlproof/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/alialavia/sqlproof/branch/main/graph/badge.svg)](https://codecov.io/gh/alialavia/sqlproof)
+[![PyPI](https://img.shields.io/pypi/v/sqlproof?include_prereleases)](https://pypi.org/project/sqlproof/)
+
+**→ Full docs: [sqlproof.com](https://sqlproof.com)**
+
+> ⚠️ **Early-stage alpha (`0.1.0a1`).** APIs are unstable and may change without
+> deprecation warnings until 0.x stabilizes. Postgres edge cases and Hypothesis
+> shrink behavior are still being discovered, and coverage of the schema surface
+> area is incomplete. **Do not rely on this for production test suites yet.**
+> Bug reports and reproductions welcome —
+> [open an issue](https://github.com/alialavia/sqlproof/issues).
+
+Property-based testing for PostgreSQL schemas and SQL behavior. Define properties about
+your database code; SqlProof generates valid datasets with Hypothesis, executes your
+queries through `psycopg`, and saves the smallest counterexample it finds.
+
+## Install
+
+Alpha releases are gated behind a pre-release flag so you don't get one by accident:
+
+```bash
+pip install --pre sqlproof
+# or:
+uv add --prerelease=allow sqlproof
+```
+
+Requires Python 3.11+ and PostgreSQL 13+.
+
+## Quick Start
+
+Given a schema file:
+
+```sql
+-- schema.sql
+CREATE TABLE orders (
+  id SERIAL PRIMARY KEY,
+  customer_id INTEGER NOT NULL,
+  total NUMERIC(10,2) NOT NULL CHECK (total >= 0)
+);
+
+CREATE TABLE line_items (
+  id SERIAL PRIMARY KEY,
+  order_id INTEGER NOT NULL REFERENCES orders(id),
+  quantity INTEGER NOT NULL CHECK (quantity > 0),
+  price NUMERIC(10,2) NOT NULL CHECK (price > 0)
+);
+```
+
+Write property tests with pytest:
+
+```python
+from sqlproof import SqlProof, sqlproof
+
+proof = SqlProof.from_schema_file("./schema.sql")
+
+
+@sqlproof(proof, sizes={"orders": 20, "line_items": 50}, runs=50)
+def test_no_orphan_line_items(db):
+    rows = db.query("""
+        SELECT li.id
+        FROM line_items li
+        LEFT JOIN orders o ON li.order_id = o.id
+        WHERE o.id IS NULL
+    """)
+    assert rows == []
+```
+
+SqlProof will:
+
+1. Parse your schema (tables, columns, FKs, CHECK constraints, enums)
+2. Topologically order tables by foreign-key dependencies
+3. Generate datasets that respect common type, FK, CHECK, UNIQUE, and NOT NULL constraints
+4. Run your property with Hypothesis-managed execution and shrinking
+5. Save the shrunk counterexample as JSON when a property fails
+
+## API
+
+See the full API reference at [sqlproof.com](https://sqlproof.com).
+
+### Quick reference
+
+```python
+proof = SqlProof.from_schema_file("./schema.sql")
+proof = SqlProof.from_connection_string("postgresql://localhost/postgres")
+
+proof.check("name", sizes={"orders": 10}, property=lambda db: ...)
+proof.invariant(
+    "no bad rows",
+    sizes={"orders": 10},
+    query="SELECT id FROM orders WHERE total < 0",
+    expect_empty=True,
+)
+
+proof.disconnect()
+```
+
+### Schema Sources
+
+**SQL file** — SqlProof parses `CREATE TABLE`, `CREATE TYPE ... AS ENUM`, foreign keys, CHECK constraints, UNIQUE constraints, and column types directly from `.sql` files.
+
+**Connection string** — Pass a `postgresql://` URL and SqlProof introspects the live database via `information_schema` and `pg_catalog`.
+
+```python
+proof = SqlProof.from_connection_string("postgresql://localhost:5432/mydb")
+```
+
+### Custom Column Generators
+
+SqlProof maps PostgreSQL types to Hypothesis strategies and refines simple range,
+`IN (...)`, length, FK, and unique constraints. The public customization API is present
+for v0.1 and will grow with richer per-column strategy overrides.
+
+### The `db` Client
+
+The property function receives a `SqlProofClient`:
+
+```python
+rows = db.query("SELECT id, total FROM orders WHERE total >= %s", 0)
+total = db.scalar("SELECT count(*) FROM orders")
+typed = db.query_typed("SELECT id, total FROM orders", OrderRow)
+data = db.get_generated_data()
+```
+
+- `query()` returns a list of dictionaries.
+- `query_typed()` maps rows into `TypedDict`, dataclass, or Pydantic models.
+- `get_generated_data()` returns the dataset for the current run.
+
+## Failure Output
+
+When a property fails, SqlProof throws with a formatted counterexample:
+
+```text
+Property failed: order totals match sum of line items
+Failure: AssertionError: expected totals to match
+Row context: {'order_id': 1}
+Dataset shape: {'orders': {'rows': 1}, 'line_items': {'rows': 2}}
+```
+
+Counterexamples are written under `.sqlproof/failures/` and can be inspected with:
+
+```bash
+sqlproof report .sqlproof/failures/test_name.json
+sqlproof report .sqlproof/failures/test_name.json --format json
+sqlproof replay .sqlproof/failures/test_name.json
+```
+
+## How It Works
+
+1. **Schema parsing** — Reads your SQL file (or introspects a live DB) to extract tables, columns, types, foreign keys, CHECK/UNIQUE constraints, and enums
+
+2. **Dependency ordering** — Topologically sorts tables by foreign key references so parent rows are always inserted first
+
+3. **Data generation** — Maps PostgreSQL types to Hypothesis strategies and applies constraint-aware generation for CHECK, UNIQUE, NOT NULL, and FK constraints
+
+4. **Isolated execution** — Schema-file proofs run against an in-memory client for fast local feedback. DSN-backed proofs introspect PostgreSQL, insert generated data inside savepoints, run the property, then roll back the run.
+
+5. **Shrinking** — When a property fails, Hypothesis shrinks the dataset to find the simplest counterexample
+
+## Supported PostgreSQL Types
+
+`integer`, `smallint`, `bigint`, `serial`, `bigserial`, `numeric(p,s)`, `real`, `double precision`, `boolean`, `text`, `varchar(n)`, `char(n)`, `uuid`, `timestamp`, `timestamptz`, `date`, `time`, `json`, `jsonb`, `bytea`, and custom `ENUM` types.
+
+## Development
+
+```bash
+git clone https://github.com/your-org/sqlproof.git
+cd sqlproof
+uv sync --extra dev
+
+uv run pytest
+uv run ruff check src tests
+uv run pyright src/sqlproof
+uv run mypy src/sqlproof
+```
+
+### Postgres-backed tests
+
+Integration tests are optional and read `SQLPROOF_TEST_DATABASE_URL`:
+
+```bash
+SQLPROOF_TEST_DATABASE_URL='postgresql://postgres:postgres@127.0.0.1:5432/postgres' uv run pytest tests/integration
+uv run pytest tests/benchmarks
+```
+
+The integration tests create a temporary schema named `sqlproof_it_*` and drop it at the end.
+
+### Why SqlProof tests itself with properties
+
+SqlProof uses Hypothesis internally, and its own tests use properties for schema
+fingerprinting, dependency ordering, FK validity, constraint generation, shrinking,
+parser idempotence, and counterexample replay. This keeps the library honest about
+the same invariants it asks users to write.
+
+## License
+
+MIT

sqlproof-0.1.0a1.dist-info/RECORD

@@ -0,0 +1,44 @@
+sqlproof/__init__.py,sha256=aweqOOTRvEusJ2wvHgojpnBWZtxrheQ39J1GkcfceGM,871
+sqlproof/_version.py,sha256=lmvUfjeqbjbsnD2PLlUjZbqEGZrq6yUD6t2LZsM61ak,24
+sqlproof/cli.py,sha256=24QggNSyi71nwrV_AJ6fTBoUSCbFud5FjhUZQi-W5N0,5516
+sqlproof/client.py,sha256=5rZn2OTDfMMvcPGkLVaj5R_lD4rwunptUgpqqMakjU0,5604
+sqlproof/config.py,sha256=ASE8RXF8bWeDdR8_ys1bBOdAbdqp8ItwsXP8iZnCj0I,1375
+sqlproof/core.py,sha256=j_bV9bxwWlTKSwdjjJ5XnjG_1wEvlOReuMTXJUAAZW0,11789
+sqlproof/exceptions.py,sha256=0lYb9pYsxtU6Or_JP2YYvLkbUJ024VeWMUiFtU2YiLw,1168
+sqlproof/pytest_plugin.py,sha256=0MbhCh7Sl5Pn5eD3QTRTjlpsAICxXJaKUAq8NEtH1Ug,942
+sqlproof/testing.py,sha256=X1FtKVMl_OILrQWlgUwpZ2aXVq56mF6Td7ZOW3xj6NQ,3551
+sqlproof/types.py,sha256=-MXEhHjd0vqPnVi5QYOeIQmsVimQP2qV_vyRq0I09ww,1404
+sqlproof/contrib/__init__.py,sha256=eEYYkxX5Hz9woXVOBJ2H2_CQoEih0vH6nRt3sH2Z8v8,49
+sqlproof/contrib/supabase.py,sha256=KeSTJXOCW6BeQkvnY8J765ZOM0wQcVtyDZ6A4Nr4gXY,4344
+sqlproof/coverage/__init__.py,sha256=Rdg4sB9kESdai9qXUJFzf4vl9Pl9EcwwwQoD09qgzIg,217
+sqlproof/coverage/diversity.py,sha256=s15dkD5O7kJb-Vp0Chsnbd0lrrCwsEhoobrdbwtKHKc,331
+sqlproof/coverage/plpgsql.py,sha256=0jUENbB-mwAKqbQE94oTPMFOZ0ujnXVIJ4Lgh5tq9ag,88
+sqlproof/coverage/schema_shape.py,sha256=JTx2ZQL3SLgbs3aymV1DtCnna_8bfvZ8zn04Epnjbmg,236
+sqlproof/generators/__init__.py,sha256=ak5kxCLHUn0V7dKnRUafPFBbhYpxRSQsi1wdkT1rUk0,595
+sqlproof/generators/columns.py,sha256=Tk-3vlXL6-zNpEEc5t5JP_YkMwDNQHw6g_c5QIZZwKk,3189
+sqlproof/generators/constraints.py,sha256=khuP9PTP25oTKsPN6gJKMk0m3rQ91jxHnopBnySrFF8,5635
+sqlproof/generators/functions.py,sha256=XqvPJ97VuaRIu-ca4I1nm6dfUB3juWaY56FWR076Q1E,164
+sqlproof/generators/graph.py,sha256=5WyX4MUt_zosLFUx6V0nkvtBVvGtXITGKAP8w7RrM9k,1549
+sqlproof/generators/rows.py,sha256=CJgWlaV-nnt5l3twVj81ZrJ4yj7sptWdDVLcqCunwHk,5526
+sqlproof/generators/sampling.py,sha256=D6xvP3txBy_4iPEblbSX_CYiMwxREjhFpBIGHaufpXY,400
+sqlproof/generators/well_known.py,sha256=bYfcXD87-DUC0lxP64BmcA-0deribng55awp2b3pYuQ,2245
+sqlproof/reporter/__init__.py,sha256=rKqWCGcE2XXz6DRLgO749jH7KKF6KmMIgACuijtcauE,131
+sqlproof/reporter/console.py,sha256=_pP6oHHmeJikJqgHW_Hb8u-CS-rxAhkveZIgxJkC5rI,752
+sqlproof/reporter/json_io.py,sha256=aSYNG8214flmspVJe-9D20S1x_6k3aCtO85OMXTnrkg,834
+sqlproof/runners/__init__.py,sha256=q3c-lvqx9-GzqiJEGM-zKGTYCfyjqQY8DRK2Cre9ppY,616
+sqlproof/runners/db.py,sha256=pzRTvBAwmeBIDyNQl5bzu2_IfGw05hyA18CuTqyY8Mc,1557
+sqlproof/runners/migration.py,sha256=ryvlKcPG8CBfYbCcI3Y8A4ghi5sERFDY9MGjWWQea8o,1472
+sqlproof/runners/overload.py,sha256=BSkkJUlGZzJBRJ3jrIOqS4jeygPBMvansSmHRdixlRE,1349
+sqlproof/runners/property.py,sha256=REnMlKld5V8_c8oZTz2viVAbF0qSb4ODn6XTsXg7Ch8,3534
+sqlproof/runners/rls.py,sha256=XnUFrMge_bVfun5K0ItvWi5URXpwLgUNG0H2VGK2pBE,1213
+sqlproof/runners/stateful.py,sha256=9TqcCgbJGN0vf3FJql5aXkuW0z221D7LhYIb4MlQcBI,1103
+sqlproof/schema/__init__.py,sha256=oNxJFeW6mq8ueeIV-S-J8I0NyDj7oeDCEXj-Y2kn-aI,533
+sqlproof/schema/dependency_graph.py,sha256=EfEHJVLv0F2REZXkPi4FRW_C29QZGp_bTk3boaX9S6M,1377
+sqlproof/schema/fingerprint.py,sha256=PKRCwnNXBz_E7-LeDrcm1TGmbAK9nuuL7xkLsripW6o,1111
+sqlproof/schema/introspect.py,sha256=Iem32N_Ol_XM0yLjtFnJ6vE3D361V9RrQzLOjXoF4Hs,8968
+sqlproof/schema/model.py,sha256=cEgdTdXpOjQqN9zU8XCf25p-cmxF_bvwLHaMVu6x9Sk,2738
+sqlproof/schema/parse_sql.py,sha256=kvMZ5D3Y9z_qOTH9k197bmLwv80GLPHKkWt-dH-67JY,7695
+sqlproof-0.1.0a1.dist-info/METADATA,sha256=Juw_FOQz4aOhGiNGyJcqM-412loodOMugl92zIEw5WI,8827
+sqlproof-0.1.0a1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sqlproof-0.1.0a1.dist-info/entry_points.txt,sha256=BLzK4-9qJ7cVkVwVE_eCQtBMTMSPmjxvQkFW8RAAli4,93
+sqlproof-0.1.0a1.dist-info/RECORD,,

sqlproof-0.1.0a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sqlproof-0.1.0a1.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+sqlproof = sqlproof.cli:main
+
+[pytest11]
+sqlproof = sqlproof.pytest_plugin