pydoptic-sql 0.0.1.post1.dev2__py3-none-any.whl

pydoptic_sql/sql_service.py

@@ -0,0 +1,335 @@
+
+
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Any, Dict, Generic, Iterator, List, Sequence, Tuple, Type, cast
+
+from pydoptic.base_model import PartialModel
+from pydoptic.selector import PropSelect
+from pydoptic_sql import SqlQuery
+from pydoptic_sql.sql_computed import Computed, ComputedResult
+from pydoptic_sql.sql_query import TC, TC1, TC2, TC3, R, Query1, Query2, Query3, Query4, ComputedQuery1, ComputedQuery2, ComputedQuery3, ComputedQuery4
+
+from psycopg import Connection, Cursor
+
+
+class SqlClient:
+    @contextmanager
+    def open(self) -> Iterator['SqlTransaction']:
+        raise NotImplementedError()
+
+class SqlResponse(Generic[R]):
+    def fetchone(self) -> R | None:
+        raise NotImplementedError()
+
+    def stream(self) -> Iterator[R]:
+        raise NotImplementedError()
+
+class SqlTransaction:
+    def commit(self) -> None:
+        raise NotImplementedError()
+
+    def rollback(self) -> None:
+        raise NotImplementedError()
+
+    def close(self) -> None:
+        raise NotImplementedError()
+
+    def execute(self, query: SqlQuery[R]) -> SqlResponse[R]:
+        raise NotImplementedError()
+
+class EmptyPgSqlResponse(SqlResponse[R]):
+    def fetchone(self) -> R | None:
+        return None
+
+    def stream(self) -> Iterator[R]:
+        seq: Sequence[R] = []
+        return iter(seq)
+
+def _computed_record(computed: Sequence[Computed[Any, Any]], sql_record: Tuple[Any, ...], offset: int) -> ComputedResult:
+    """Build a ComputedResult from the trailing `len(computed)` columns of a row, keyed by each
+    Computed's alias -- the computed columns always come after the plain ones, in the same order
+    the query builder put them in (see _computed_sql_parts in sql_query.py)."""
+    return ComputedResult(**{c.label: sql_record[offset + i] for i, c in enumerate(computed)})
+
+@dataclass
+class PsycoPgSqlResponse(Generic[TC], SqlResponse[PartialModel[TC]]):
+    model: Type[TC]
+    cursor: Cursor
+    selection: Sequence[PropSelect[TC, Any]]
+
+    def __make_record(self, sql_record: Tuple[Any,...]) -> PartialModel[TC]:
+        data: Dict[str, Any] = {}
+        for i, prop in enumerate(self.selection):
+            data[prop.label] = sql_record[i]
+        return PartialModel(self.model, **data)
+
+    def fetchone(self) -> PartialModel[TC] | None:
+        result = self.cursor.fetchone()
+        if result is not None:
+            return self.__make_record(result)
+        return None
+
+    def stream(self) -> Iterator[PartialModel[TC]]:
+        for row in self.cursor:
+            yield self.__make_record(row)
+
+@dataclass
+class PsycoPgComputedResponse1(Generic[TC], SqlResponse[Tuple[PartialModel[TC], ComputedResult]]):
+    model: Type[TC]
+    cursor: Cursor
+    selection: Sequence[PropSelect[TC, Any]]
+    computed: Sequence[Computed[TC, Any]]
+
+    def __make_record(self, sql_record: Tuple[Any, ...]) -> Tuple[PartialModel[TC], ComputedResult]:
+        data: Dict[str, Any] = {}
+        for i, prop in enumerate(self.selection):
+            data[prop.label] = sql_record[i]
+        return PartialModel(self.model, **data), _computed_record(self.computed, sql_record, len(self.selection))
+
+    def fetchone(self) -> Tuple[PartialModel[TC], ComputedResult] | None:
+        result = self.cursor.fetchone()
+        if result is not None:
+            return self.__make_record(result)
+        return None
+
+    def stream(self) -> Iterator[Tuple[PartialModel[TC], ComputedResult]]:
+        for row in self.cursor:
+            yield self.__make_record(row)
+
+@dataclass
+class PsycoPgJoinResponse2(Generic[TC, TC1], SqlResponse[Tuple[PartialModel[TC], PartialModel[TC1]]]):
+    table1: Type[TC]
+    table2: Type[TC1]
+    cursor: Cursor
+    selection: Sequence[PropSelect[TC, Any] | PropSelect[TC1, Any]]
+
+    def __make_record(self, sql_record: Tuple[Any, ...]) -> Tuple[PartialModel[TC], PartialModel[TC1]]:
+        data1: Dict[str, Any] = {}
+        data2: Dict[str, Any] = {}
+        for i, prop in enumerate(self.selection):
+            if prop.origin is self.table1:
+                data1[prop.label] = sql_record[i]
+            else:
+                data2[prop.label] = sql_record[i]
+        return PartialModel(self.table1, **data1), PartialModel(self.table2, **data2)
+
+    def fetchone(self) -> Tuple[PartialModel[TC], PartialModel[TC1]] | None:
+        result = self.cursor.fetchone()
+        if result is not None:
+            return self.__make_record(result)
+        return None
+
+    def stream(self) -> Iterator[Tuple[PartialModel[TC], PartialModel[TC1]]]:
+        for row in self.cursor:
+            yield self.__make_record(row)
+
+@dataclass
+class PsycoPgComputedResponse2(Generic[TC, TC1], SqlResponse[Tuple[PartialModel[TC], PartialModel[TC1], ComputedResult]]):
+    table1: Type[TC]
+    table2: Type[TC1]
+    cursor: Cursor
+    selection: Sequence[PropSelect[TC, Any] | PropSelect[TC1, Any]]
+    computed: Sequence[Computed[TC, Any] | Computed[TC1, Any]]
+
+    def __make_record(self, sql_record: Tuple[Any, ...]) -> Tuple[PartialModel[TC], PartialModel[TC1], ComputedResult]:
+        data1: Dict[str, Any] = {}
+        data2: Dict[str, Any] = {}
+        for i, prop in enumerate(self.selection):
+            if prop.origin is self.table1:
+                data1[prop.label] = sql_record[i]
+            else:
+                data2[prop.label] = sql_record[i]
+        return PartialModel(self.table1, **data1), PartialModel(self.table2, **data2), _computed_record(self.computed, sql_record, len(self.selection))
+
+    def fetchone(self) -> Tuple[PartialModel[TC], PartialModel[TC1], ComputedResult] | None:
+        result = self.cursor.fetchone()
+        if result is not None:
+            return self.__make_record(result)
+        return None
+
+    def stream(self) -> Iterator[Tuple[PartialModel[TC], PartialModel[TC1], ComputedResult]]:
+        for row in self.cursor:
+            yield self.__make_record(row)
+
+@dataclass
+class PsycoPgJoinResponse3(Generic[TC, TC1, TC2], SqlResponse[Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2]]]):
+    table1: Type[TC]
+    table2: Type[TC1]
+    table3: Type[TC2]
+    cursor: Cursor
+    selection: Sequence[PropSelect[TC, Any] | PropSelect[TC1, Any] | PropSelect[TC2, Any]]
+
+    def __make_record(self, sql_record: Tuple[Any, ...]) -> Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2]]:
+        data1: Dict[str, Any] = {}
+        data2: Dict[str, Any] = {}
+        data3: Dict[str, Any] = {}
+        for i, prop in enumerate(self.selection):
+            if prop.origin is self.table1:
+                data1[prop.label] = sql_record[i]
+            elif prop.origin is self.table2:
+                data2[prop.label] = sql_record[i]
+            else:
+                data3[prop.label] = sql_record[i]
+        return PartialModel(self.table1, **data1), PartialModel(self.table2, **data2), PartialModel(self.table3, **data3)
+
+    def fetchone(self) -> Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2]] | None:
+        result = self.cursor.fetchone()
+        if result is not None:
+            return self.__make_record(result)
+        return None
+
+    def stream(self) -> Iterator[Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2]]]:
+        for row in self.cursor:
+            yield self.__make_record(row)
+
+@dataclass
+class PsycoPgComputedResponse3(Generic[TC, TC1, TC2], SqlResponse[Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], ComputedResult]]):
+    table1: Type[TC]
+    table2: Type[TC1]
+    table3: Type[TC2]
+    cursor: Cursor
+    selection: Sequence[PropSelect[TC, Any] | PropSelect[TC1, Any] | PropSelect[TC2, Any]]
+    computed: Sequence[Computed[TC, Any] | Computed[TC1, Any] | Computed[TC2, Any]]
+
+    def __make_record(self, sql_record: Tuple[Any, ...]) -> Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], ComputedResult]:
+        data1: Dict[str, Any] = {}
+        data2: Dict[str, Any] = {}
+        data3: Dict[str, Any] = {}
+        for i, prop in enumerate(self.selection):
+            if prop.origin is self.table1:
+                data1[prop.label] = sql_record[i]
+            elif prop.origin is self.table2:
+                data2[prop.label] = sql_record[i]
+            else:
+                data3[prop.label] = sql_record[i]
+        return PartialModel(self.table1, **data1), PartialModel(self.table2, **data2), PartialModel(self.table3, **data3), _computed_record(self.computed, sql_record, len(self.selection))
+
+    def fetchone(self) -> Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], ComputedResult] | None:
+        result = self.cursor.fetchone()
+        if result is not None:
+            return self.__make_record(result)
+        return None
+
+    def stream(self) -> Iterator[Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], ComputedResult]]:
+        for row in self.cursor:
+            yield self.__make_record(row)
+
+@dataclass
+class PsycoPgJoinResponse4(Generic[TC, TC1, TC2, TC3], SqlResponse[Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], PartialModel[TC3]]]):
+    table1: Type[TC]
+    table2: Type[TC1]
+    table3: Type[TC2]
+    table4: Type[TC3]
+    cursor: Cursor
+    selection: Sequence[PropSelect[TC, Any] | PropSelect[TC1, Any] | PropSelect[TC2, Any] | PropSelect[TC3, Any]]
+
+    def __make_record(self, sql_record: Tuple[Any, ...]) -> Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], PartialModel[TC3]]:
+        data1: Dict[str, Any] = {}
+        data2: Dict[str, Any] = {}
+        data3: Dict[str, Any] = {}
+        data4: Dict[str, Any] = {}
+        for i, prop in enumerate(self.selection):
+            if prop.origin is self.table1:
+                data1[prop.label] = sql_record[i]
+            elif prop.origin is self.table2:
+                data2[prop.label] = sql_record[i]
+            elif prop.origin is self.table3:
+                data3[prop.label] = sql_record[i]
+            else:
+                data4[prop.label] = sql_record[i]
+        return PartialModel(self.table1, **data1), PartialModel(self.table2, **data2), PartialModel(self.table3, **data3), PartialModel(self.table4, **data4)
+
+    def fetchone(self) -> Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], PartialModel[TC3]] | None:
+        result = self.cursor.fetchone()
+        if result is not None:
+            return self.__make_record(result)
+        return None
+
+    def stream(self) -> Iterator[Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], PartialModel[TC3]]]:
+        for row in self.cursor:
+            yield self.__make_record(row)
+
+@dataclass
+class PsycoPgComputedResponse4(Generic[TC, TC1, TC2, TC3], SqlResponse[Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], PartialModel[TC3], ComputedResult]]):
+    table1: Type[TC]
+    table2: Type[TC1]
+    table3: Type[TC2]
+    table4: Type[TC3]
+    cursor: Cursor
+    selection: Sequence[PropSelect[TC, Any] | PropSelect[TC1, Any] | PropSelect[TC2, Any] | PropSelect[TC3, Any]]
+    computed: Sequence[Computed[TC, Any] | Computed[TC1, Any] | Computed[TC2, Any] | Computed[TC3, Any]]
+
+    def __make_record(self, sql_record: Tuple[Any, ...]) -> Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], PartialModel[TC3], ComputedResult]:
+        data1: Dict[str, Any] = {}
+        data2: Dict[str, Any] = {}
+        data3: Dict[str, Any] = {}
+        data4: Dict[str, Any] = {}
+        for i, prop in enumerate(self.selection):
+            if prop.origin is self.table1:
+                data1[prop.label] = sql_record[i]
+            elif prop.origin is self.table2:
+                data2[prop.label] = sql_record[i]
+            elif prop.origin is self.table3:
+                data3[prop.label] = sql_record[i]
+            else:
+                data4[prop.label] = sql_record[i]
+        return PartialModel(self.table1, **data1), PartialModel(self.table2, **data2), PartialModel(self.table3, **data3), PartialModel(self.table4, **data4), _computed_record(self.computed, sql_record, len(self.selection))
+
+    def fetchone(self) -> Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], PartialModel[TC3], ComputedResult] | None:
+        result = self.cursor.fetchone()
+        if result is not None:
+            return self.__make_record(result)
+        return None
+
+    def stream(self) -> Iterator[Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], PartialModel[TC3], ComputedResult]]:
+        for row in self.cursor:
+            yield self.__make_record(row)
+
+@dataclass
+class PsycoPgSqlTransaction(SqlTransaction):
+    connection: Connection
+    cursor: Cursor
+
+    def commit(self) -> None:
+        self.connection.commit()
+
+    def rollback(self) -> None:
+        self.connection.rollback()
+
+    def close(self) -> None:
+        self.cursor.close()
+
+    def execute(self, query: SqlQuery[R]) -> SqlResponse[R]:
+        sql, params = query.to_sql_params()
+        self.cursor.execute(sql, params)
+        match query:
+            case ComputedQuery1():
+                return cast(SqlResponse[R], PsycoPgComputedResponse1(query.table1, self.cursor, query._resolved_selection(), query._computed))
+            case ComputedQuery2():
+                return cast(SqlResponse[R], PsycoPgComputedResponse2(query.table1, query.table2, self.cursor, query._resolved_selection(), query._computed))
+            case ComputedQuery3():
+                return cast(SqlResponse[R], PsycoPgComputedResponse3(query.table1, query.table2, query.table3, self.cursor, query._resolved_selection(), query._computed))
+            case ComputedQuery4():
+                return cast(SqlResponse[R], PsycoPgComputedResponse4(query.table1, query.table2, query.table3, query.table4, self.cursor, query._resolved_selection(), query._computed))
+            case Query1():
+                # Query1[TC]'s R is always PartialModel[TC], which is exactly the caller's R here,
+                # but match narrowing can't invert R back to TC to prove that statically.
+                return cast(SqlResponse[R], PsycoPgSqlResponse(query.table1, self.cursor, query._resolved_selection()))
+            case Query2():
+                return cast(SqlResponse[R], PsycoPgJoinResponse2(query.table1, query.table2, self.cursor, query._resolved_selection()))
+            case Query3():
+                return cast(SqlResponse[R], PsycoPgJoinResponse3(query.table1, query.table2, query.table3, self.cursor, query._resolved_selection()))
+            case Query4():
+                return cast(SqlResponse[R], PsycoPgJoinResponse4(query.table1, query.table2, query.table3, query.table4, self.cursor, query._resolved_selection()))
+            case _:
+                return EmptyPgSqlResponse()
+
+@dataclass(frozen=True)
+class PsycoPgSqlClient(SqlClient):
+    connection: Connection
+
+    @contextmanager
+    def open(self) -> Iterator['SqlTransaction']:
+        with self.connection.cursor() as cursor:
+            yield PsycoPgSqlTransaction(self.connection, cursor)

pydoptic_sql/sql_table.py

@@ -0,0 +1,188 @@
+from dataclasses import dataclass
+from datetime import date, datetime
+from enum import Enum
+from typing import Any, ClassVar, Generic, List, NotRequired, Type, TypeVar, TypedDict, Unpack
+from pydoptic import BaseModel, select
+from pydoptic.selector import PropSelect
+
+A = TypeVar('A')
+
+class SqlTable(BaseModel):
+    table_name: ClassVar[str]
+
+T = TypeVar('T', bound=SqlTable)
+
+class ColumnType:
+    def to_sql(self) -> str:
+        raise NotImplementedError()
+
+    @classmethod
+    def from_type(cls, type: Type[Any]):
+        if type is int:
+            return cls.INT()
+        if type is str:
+            return cls.TEXT()
+        if type is bool:
+            return cls.BOOL()
+        if type is float:
+            return cls.REAL()
+        if type is date:
+            return cls.DATE()
+        if type is datetime:
+            return cls.DATE()
+        raise ValueError(f'Unknown column type: {type}')
+        
+
+    @classmethod
+    def INT(cls) -> 'Int':
+        return Int.Int
+    
+    @classmethod
+    def SMALLINT(cls) -> 'Int':
+        return Int.SmallInt
+    
+    @classmethod
+    def BIGINT(cls) -> 'Int':
+        return Int.BigInt
+    
+    @classmethod
+    def REAL(cls) -> 'Float':
+        return Float.Real
+    
+    @classmethod
+    def DOUBLE(cls) -> 'Float':
+        return Float.Double
+    
+    @classmethod
+    def BOOL(cls) -> 'OtherType':
+        return OtherType.Bool
+    
+    @classmethod
+    def BLOB(cls) -> 'OtherType':
+        return OtherType.Blob
+    
+    @classmethod
+    def UUID(cls) -> 'OtherType':
+        return OtherType.UUID
+    
+    @classmethod
+    def JSON(cls) -> 'OtherType':
+        return OtherType.Json
+    
+    @classmethod
+    def DATE(cls) -> 'OtherType':
+        return OtherType.Date
+    
+    @classmethod
+    def TEXT(cls, unicode: bool = False) -> 'Text':
+        return Text.NText if unicode else Text.Text
+
+    @classmethod
+    def CHAR(cls, size: int, unicode: bool = False) -> 'Char':
+        return Char(size, unicode)
+    
+    @classmethod
+    def VARCHAR(cls, size: int, unicode: bool = False) -> 'VarChar':
+        return VarChar(size, unicode)
+    
+
+@dataclass(frozen=True)
+class Char(ColumnType):
+    size: int
+    unicode: bool = False
+
+    def to_sql(self) -> str:
+        if self.unicode:
+            return f'NCHAR({self.size})'
+        return f'CHAR({self.size})'
+
+@dataclass(frozen=True)
+class VarChar(ColumnType):
+    size: int
+    unicode: bool = False
+
+    def to_sql(self) -> str:
+        if self.unicode:
+            return f'NVARCHAR({self.size})'
+        return f'VARCHAR({self.size})'
+
+class Int(ColumnType, Enum):
+    Int = 'INTEGER'
+    SmallInt = 'SMALLINT'
+    BigInt = 'BIGINT'
+
+    def to_sql(self) -> str:
+        return self.value
+
+class Float(ColumnType, Enum):
+    Real = 'REAL'
+    Double = 'DOUBLE PRECISION'
+
+    def to_sql(self) -> str:
+        return self.value
+
+class Text(ColumnType, Enum):
+    Text = 'TEXT'
+    NText = 'NTEXT'
+
+    def to_sql(self) -> str:
+        return self.value
+
+class OtherType(ColumnType, Enum):
+    Bool = 'BOOLEAN'
+    UUID = 'UUID' # type: ignore[assignment]
+    Json = 'JSON'
+    Blob = 'BLOB'
+    Date = 'DATE'
+
+    def to_sql(self) -> str:
+        return self.value
+
+@dataclass(frozen=True)
+class ManualColumnType(ColumnType):
+    type: str
+
+@dataclass(frozen=True)
+class ColumnConstraint:
+    ...
+
+@dataclass(frozen=True)
+class __PrimaryKey(ColumnConstraint):
+    ...
+
+PrimaryKey = __PrimaryKey()
+
+@dataclass(frozen=True)
+class __Unique(ColumnConstraint):
+    ...
+
+Unique = __Unique()
+
+@dataclass(frozen=True)
+class __AutoIncrement(ColumnConstraint):
+    ...
+
+AutoIncrement = __AutoIncrement()
+
+@dataclass(frozen=True)
+class ForeignKey(Generic[T, A], ColumnConstraint):
+    references: PropSelect[T, A]
+
+@dataclass(frozen=True)
+class Check(ColumnConstraint):
+    constraint: str
+
+@dataclass(frozen=True)
+class Default(ColumnConstraint):
+    value: Any
+
+@dataclass(frozen=True)
+class ManualColumnConstraint(ColumnConstraint):
+    type: str
+
+class ColumnInfo(TypedDict):
+    type: NotRequired[ColumnType]
+    constraints: NotRequired[List[ColumnConstraint]]
+
+def column(name: str | None = None, **column_info: Unpack[ColumnInfo]) -> Any:
+    return select(name, **column_info)

pydoptic_sql-0.0.1.post1.dev2.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: pydoptic-sql
+Version: 0.0.1.post1.dev2
+Summary: A type-safe SQL query builder built on pydoptic
+Author: John Hungerford
+License-Expression: MIT
+Project-URL: Source, https://github.com/johnhungerford/pydoptic
+Requires-Python: <3.14,>=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydoptic
+Requires-Dist: psycopg[binary]==3.2.12
+Provides-Extra: test
+Requires-Dist: pytest~=8.4.2; extra == "test"
+Provides-Extra: types
+Requires-Dist: mypy~=1.18.2; extra == "types"
+Dynamic: license-file
+
+# pydoptic-sql
+
+A type-safe SQL query builder built on [pydoptic](https://pypi.org/project/pydoptic/).
+
+Join arity is tracked in the type system itself, so a WHERE/ON/HAVING clause can't reference a table
+that isn't actually in scope at that point in a join chain -- mypy catches it, not just Postgres at
+runtime.
+
+## Installation
+
+```bash
+pip install pydoptic-sql
+```
+
+Includes `psycopg` as a regular dependency, so no extras are needed to execute queries against
+Postgres.
+
+## Quickstart
+
+```python3
+from pydoptic import Prop
+from pydoptic_sql import SqlTable, ColumnType, PrimaryKey, column, SqlQuery, Constraint, PsycoPgSqlClient
+import psycopg
+
+class Worker(SqlTable):
+    id: Prop['Worker', int] = column(type=ColumnType.BIGINT(), constraints=[PrimaryKey])
+    name: Prop['Worker', str] = column(type=ColumnType.TEXT())
+    age: Prop['Worker', int] = column(type=ColumnType.INT())
+    department_id: Prop['Worker', int] = column(type=ColumnType.BIGINT())
+
+query = SqlQuery.from_table(Worker).select(Worker.name).where(Constraint.gte(Worker.age, 18))
+
+with psycopg.connect("host=localhost dbname=mydb user=postgres password=password") as conn:
+    client = PsycoPgSqlClient(conn)
+    with client.open() as tx:
+        for worker in tx.execute(query).stream():
+            print(Worker.name.get_val_safe(worker))
+```
+
+Joining a second table narrows and widens the query's type together -- `Constraint2` (not
+`Constraint`) is required for a WHERE/ON clause once a second table is in scope, and can reference
+either table directly:
+
+```python3
+class Department(SqlTable):
+    id: Prop['Department', int] = column(type=ColumnType.BIGINT(), constraints=[PrimaryKey])
+    name: Prop['Department', str] = column(type=ColumnType.TEXT())
+
+from pydoptic_sql import Constraint2
+
+query = SqlQuery.from_table(Worker).join_inner(
+    Department, Constraint2.eq(Worker.department_id, Department.id),
+).select(Worker.name, Department.name).where(Constraint2.gte(Worker.age, 18))
+```
+
+See the [pydoptic README](https://github.com/johnhungerford/pydoptic/tree/main/packages/pydoptic) for
+the underlying `Prop`/`Select` model this is built on.

pydoptic_sql-0.0.1.post1.dev2.dist-info/RECORD

@@ -0,0 +1,14 @@
+pydoptic_sql/__init__.py,sha256=nd5klqFo0xHwqbfsYbMiKYHlcGB-taANcTG4FcgJ0z4,1686
+pydoptic_sql/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydoptic_sql/sql_computed.py,sha256=4rbeWfhMLI7ST9fCHSvjIazuWN0x_6QNDTNggjnH20c,3769
+pydoptic_sql/sql_constraint.py,sha256=hn16pbc6DU_Ig8RLCIdX3nyOPFaKKrQv_-Q0DN3FBRo,37348
+pydoptic_sql/sql_having.py,sha256=V9L0nISf9X8NuMQXIt8-X5wJvqCvcF6itrsz16Z3XS0,43182
+pydoptic_sql/sql_order.py,sha256=y37XRRAZPIvvVPmZPljgP3Ht4Q6Oy-dEEBMvmlKVJk8,1036
+pydoptic_sql/sql_query.py,sha256=UXqy6T9oJQSlhs0e4416jwRcWkyiWUs41Keq6qYvOMw,75539
+pydoptic_sql/sql_service.py,sha256=AsYJcH1zTgzMllp6BchZm9TNYEQfk3SILqs1DRSTy5s,14898
+pydoptic_sql/sql_table.py,sha256=fNpsAqsg68E9HrJV7m0yDIUJu-Tqdo6o7pMSGJvtLQo,4202
+pydoptic_sql-0.0.1.post1.dev2.dist-info/licenses/LICENSE,sha256=mWq1sTRv24YgxnIenVK1P8FNY2YMof3kT7e6D-06KZY,1072
+pydoptic_sql-0.0.1.post1.dev2.dist-info/METADATA,sha256=mslfxHx2lsSJ-gJqiUDcEcoKEo53P1OxKT0KglvKGLA,2678
+pydoptic_sql-0.0.1.post1.dev2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pydoptic_sql-0.0.1.post1.dev2.dist-info/top_level.txt,sha256=01AdOUMZQBRcEVP-RL26QyHmtsB3yJgvBumE8SUx5Kw,13
+pydoptic_sql-0.0.1.post1.dev2.dist-info/RECORD,,

pydoptic_sql-0.0.1.post1.dev2.dist-info/WHEEL

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

pydoptic_sql-0.0.1.post1.dev2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 John Hungerford
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pydoptic_sql-0.0.1.post1.dev2.dist-info/top_level.txt

@@ -0,0 +1 @@
+pydoptic_sql