pydoptic-sql 0.0.2.post1.dev1__tar.gz → 0.0.2.post1.dev2__tar.gz

{pydoptic_sql-0.0.2.post1.dev1/src/pydoptic_sql.egg-info → pydoptic_sql-0.0.2.post1.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydoptic-sql
-Version: 0.0.2.post1.dev1
+Version: 0.0.2.post1.dev2
 Summary: A type-safe SQL query builder built on pydoptic
 Author: John Hungerford
 License-Expression: MIT

{pydoptic_sql-0.0.2.post1.dev1 → pydoptic_sql-0.0.2.post1.dev2}/src/pydoptic_sql/sql_computed.py

@@ -19,7 +19,7 @@ class AggregateFunction(Enum):
 class ComputedResult(Selectable['ComputedResult']):
     """
     Dict-backed holder for the computed (aggregate) columns of a query result row, keyed by each
-    `Computed`'s alias. Mirrors `PartialModel`'s shape but isn't backed by a model class -- there's
+    `Computed`'s alias. Mirrors `Partial`'s shape but isn't backed by a model class -- there's
     no schema behind an aggregate expression, just whatever aliases the query selected.
     """
     __slots__ = ['_dict']

{pydoptic_sql-0.0.2.post1.dev1 → pydoptic_sql-0.0.2.post1.dev2}/src/pydoptic_sql/sql_query.py

@@ -2,7 +2,7 @@
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Generic, List, Sequence, Tuple, Type, TypeVar, cast
-from pydoptic import PartialModel
+from pydoptic import Partial
 from pydoptic.selector import PropSelect, Prop, PropOpt, Param
 from pydoptic_sql import SqlTable
 from pydoptic_sql.sql_constraint import A, TC, TC1, TC2, TC3, Constraint, Constraint2, Constraint3, Constraint4, _qualified_label
@@ -25,7 +25,7 @@ from pydoptic_sql.sql_table import (
 R = TypeVar('R')
 
 class SqlQuery(Generic[R]):
-    # R is the result type of executing the query (e.g. PartialModel[TC], or None); table type(s) are tracked separately per subclass.
+    # R is the result type of executing the query (e.g. Partial[TC], or None); table type(s) are tracked separately per subclass.
     def to_sql(self) -> str:
         """Render this query as a single SQL string with values interpolated -- for display/debugging only."""
         raise NotImplementedError()
@@ -146,7 +146,7 @@ class JoinType(Enum):
 # calling incr_arity() on them when set, and QueryN/ComputedQueryN are directly executable
 # (to_sql()/to_sql_params()) at every stage, builder and "terminal" alike -- hence one class per arity
 # instead of two. select_computed(_more) still splits off into a separate ComputedQueryN from QueryN,
-# since the result type R differs (PartialModel[...] vs Tuple[..., ComputedResult]) and R can't vary
+# since the result type R differs (Partial[...] vs Tuple[..., ComputedResult]) and R can't vary
 # at runtime for a single dataclass.
 #
 # _order_by/_group_by/_computed still widen by one union member per table added (rather than gaining
@@ -155,7 +155,7 @@ class JoinType(Enum):
 # exactly as valid after it, with no re-wrapping needed.
 
 @dataclass(frozen=True)
-class Query1(Generic[TC], SqlQuery[PartialModel[TC]]):
+class Query1(Generic[TC], SqlQuery[Partial[TC]]):
     table1: Type[TC]
     _selection: Sequence[PropSelect[TC, Any]] | None = None
     _where: Constraint[TC] | None = None
@@ -225,7 +225,7 @@ class Query1(Generic[TC], SqlQuery[PartialModel[TC]]):
         return f'SELECT {selections} FROM {self.table1.__name__.lower()} WHERE {where_clause}{group_by_clause}{order_by_clause};', params
 
 @dataclass(frozen=True)
-class ComputedQuery1(Generic[TC], SqlQuery[Tuple[PartialModel[TC], ComputedResult]]):
+class ComputedQuery1(Generic[TC], SqlQuery[Tuple[Partial[TC], ComputedResult]]):
     table1: Type[TC]
     _selection: Sequence[PropSelect[TC, Any]] | None = None
     _where: Constraint[TC] | None = None
@@ -460,7 +460,7 @@ class DeleteQuery(Generic[TC], SqlQuery[None]):
 # --- 2 tables ---
 
 @dataclass(frozen=True)
-class Query2(Generic[TC, TC1], SqlQuery[Tuple[PartialModel[TC], PartialModel[TC1]]]):
+class Query2(Generic[TC, TC1], SqlQuery[Tuple[Partial[TC], Partial[TC1]]]):
     table1: Type[TC]
     table2: Type[TC1]
     join_type_2: JoinType
@@ -558,7 +558,7 @@ class Query2(Generic[TC, TC1], SqlQuery[Tuple[PartialModel[TC], PartialModel[TC1
         return f'SELECT {selections} FROM {from_clause} WHERE {where_clause}{group_by_clause}{order_by_clause};', params
 
 @dataclass(frozen=True)
-class ComputedQuery2(Generic[TC, TC1], SqlQuery[Tuple[PartialModel[TC], PartialModel[TC1], ComputedResult]]):
+class ComputedQuery2(Generic[TC, TC1], SqlQuery[Tuple[Partial[TC], Partial[TC1], ComputedResult]]):
     table1: Type[TC]
     table2: Type[TC1]
     join_type_2: JoinType
@@ -679,7 +679,7 @@ class ComputedQuery2(Generic[TC, TC1], SqlQuery[Tuple[PartialModel[TC], PartialM
 # --- 3 tables ---
 
 @dataclass(frozen=True)
-class Query3(Generic[TC, TC1, TC2], SqlQuery[Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2]]]):
+class Query3(Generic[TC, TC1, TC2], SqlQuery[Tuple[Partial[TC], Partial[TC1], Partial[TC2]]]):
     table1: Type[TC]
     table2: Type[TC1]
     table3: Type[TC2]
@@ -787,7 +787,7 @@ class Query3(Generic[TC, TC1, TC2], SqlQuery[Tuple[PartialModel[TC], PartialMode
         return f'SELECT {selections} FROM {from_clause} WHERE {where_clause}{group_by_clause}{order_by_clause};', params
 
 @dataclass(frozen=True)
-class ComputedQuery3(Generic[TC, TC1, TC2], SqlQuery[Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], ComputedResult]]):
+class ComputedQuery3(Generic[TC, TC1, TC2], SqlQuery[Tuple[Partial[TC], Partial[TC1], Partial[TC2], ComputedResult]]):
     table1: Type[TC]
     table2: Type[TC1]
     table3: Type[TC2]
@@ -918,7 +918,7 @@ class ComputedQuery3(Generic[TC, TC1, TC2], SqlQuery[Tuple[PartialModel[TC], Par
 # --- 4 tables ---
 
 @dataclass(frozen=True)
-class Query4(Generic[TC, TC1, TC2, TC3], SqlQuery[Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], PartialModel[TC3]]]):
+class Query4(Generic[TC, TC1, TC2, TC3], SqlQuery[Tuple[Partial[TC], Partial[TC1], Partial[TC2], Partial[TC3]]]):
     table1: Type[TC]
     table2: Type[TC1]
     table3: Type[TC2]
@@ -1022,7 +1022,7 @@ class Query4(Generic[TC, TC1, TC2, TC3], SqlQuery[Tuple[PartialModel[TC], Partia
         return f'SELECT {selections} FROM {from_clause} WHERE {where_clause}{group_by_clause}{order_by_clause};', params
 
 @dataclass(frozen=True)
-class ComputedQuery4(Generic[TC, TC1, TC2, TC3], SqlQuery[Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], PartialModel[TC3], ComputedResult]]):
+class ComputedQuery4(Generic[TC, TC1, TC2, TC3], SqlQuery[Tuple[Partial[TC], Partial[TC1], Partial[TC2], Partial[TC3], ComputedResult]]):
     table1: Type[TC]
     table2: Type[TC1]
     table3: Type[TC2]

{pydoptic_sql-0.0.2.post1.dev1 → pydoptic_sql-0.0.2.post1.dev2}/src/pydoptic_sql/sql_service.py

@@ -4,7 +4,7 @@ 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.base_model import Partial
 from pydoptic.selector import PropSelect
 from pydoptic_sql import SqlQuery
 from pydoptic_sql.sql_computed import Computed, ComputedResult
@@ -53,58 +53,58 @@ def _computed_record(computed: Sequence[Computed[Any, Any]], sql_record: Tuple[A
     return ComputedResult(**{c.label: sql_record[offset + i] for i, c in enumerate(computed)})
 
 @dataclass
-class PsycoPgSqlResponse(Generic[TC], SqlResponse[PartialModel[TC]]):
+class PsycoPgSqlResponse(Generic[TC], SqlResponse[Partial[TC]]):
     model: Type[TC]
     cursor: Cursor
     selection: Sequence[PropSelect[TC, Any]]
 
-    def __make_record(self, sql_record: Tuple[Any,...]) -> PartialModel[TC]:
+    def __make_record(self, sql_record: Tuple[Any,...]) -> Partial[TC]:
         data: Dict[str, Any] = {}
         for i, prop in enumerate(self.selection):
             data[prop.label] = sql_record[i]
-        return PartialModel(self.model, **data)
+        return Partial(self.model, **data)
 
-    def fetchone(self) -> PartialModel[TC] | None:
+    def fetchone(self) -> Partial[TC] | None:
         result = self.cursor.fetchone()
         if result is not None:
             return self.__make_record(result)
         return None
 
-    def stream(self) -> Iterator[PartialModel[TC]]:
+    def stream(self) -> Iterator[Partial[TC]]:
         for row in self.cursor:
             yield self.__make_record(row)
 
 @dataclass
-class PsycoPgComputedResponse1(Generic[TC], SqlResponse[Tuple[PartialModel[TC], ComputedResult]]):
+class PsycoPgComputedResponse1(Generic[TC], SqlResponse[Tuple[Partial[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]:
+    def __make_record(self, sql_record: Tuple[Any, ...]) -> Tuple[Partial[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))
+        return Partial(self.model, **data), _computed_record(self.computed, sql_record, len(self.selection))
 
-    def fetchone(self) -> Tuple[PartialModel[TC], ComputedResult] | None:
+    def fetchone(self) -> Tuple[Partial[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]]:
+    def stream(self) -> Iterator[Tuple[Partial[TC], ComputedResult]]:
         for row in self.cursor:
             yield self.__make_record(row)
 
 @dataclass
-class PsycoPgJoinResponse2(Generic[TC, TC1], SqlResponse[Tuple[PartialModel[TC], PartialModel[TC1]]]):
+class PsycoPgJoinResponse2(Generic[TC, TC1], SqlResponse[Tuple[Partial[TC], Partial[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]]:
+    def __make_record(self, sql_record: Tuple[Any, ...]) -> Tuple[Partial[TC], Partial[TC1]]:
         data1: Dict[str, Any] = {}
         data2: Dict[str, Any] = {}
         for i, prop in enumerate(self.selection):
@@ -112,27 +112,27 @@ class PsycoPgJoinResponse2(Generic[TC, TC1], SqlResponse[Tuple[PartialModel[TC],
                 data1[prop.label] = sql_record[i]
             else:
                 data2[prop.label] = sql_record[i]
-        return PartialModel(self.table1, **data1), PartialModel(self.table2, **data2)
+        return Partial(self.table1, **data1), Partial(self.table2, **data2)
 
-    def fetchone(self) -> Tuple[PartialModel[TC], PartialModel[TC1]] | None:
+    def fetchone(self) -> Tuple[Partial[TC], Partial[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]]]:
+    def stream(self) -> Iterator[Tuple[Partial[TC], Partial[TC1]]]:
         for row in self.cursor:
             yield self.__make_record(row)
 
 @dataclass
-class PsycoPgComputedResponse2(Generic[TC, TC1], SqlResponse[Tuple[PartialModel[TC], PartialModel[TC1], ComputedResult]]):
+class PsycoPgComputedResponse2(Generic[TC, TC1], SqlResponse[Tuple[Partial[TC], Partial[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]:
+    def __make_record(self, sql_record: Tuple[Any, ...]) -> Tuple[Partial[TC], Partial[TC1], ComputedResult]:
         data1: Dict[str, Any] = {}
         data2: Dict[str, Any] = {}
         for i, prop in enumerate(self.selection):
@@ -140,27 +140,27 @@ class PsycoPgComputedResponse2(Generic[TC, TC1], SqlResponse[Tuple[PartialModel[
                 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))
+        return Partial(self.table1, **data1), Partial(self.table2, **data2), _computed_record(self.computed, sql_record, len(self.selection))
 
-    def fetchone(self) -> Tuple[PartialModel[TC], PartialModel[TC1], ComputedResult] | None:
+    def fetchone(self) -> Tuple[Partial[TC], Partial[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]]:
+    def stream(self) -> Iterator[Tuple[Partial[TC], Partial[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]]]):
+class PsycoPgJoinResponse3(Generic[TC, TC1, TC2], SqlResponse[Tuple[Partial[TC], Partial[TC1], Partial[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]]:
+    def __make_record(self, sql_record: Tuple[Any, ...]) -> Tuple[Partial[TC], Partial[TC1], Partial[TC2]]:
         data1: Dict[str, Any] = {}
         data2: Dict[str, Any] = {}
         data3: Dict[str, Any] = {}
@@ -171,20 +171,20 @@ class PsycoPgJoinResponse3(Generic[TC, TC1, TC2], SqlResponse[Tuple[PartialModel
                 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)
+        return Partial(self.table1, **data1), Partial(self.table2, **data2), Partial(self.table3, **data3)
 
-    def fetchone(self) -> Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2]] | None:
+    def fetchone(self) -> Tuple[Partial[TC], Partial[TC1], Partial[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]]]:
+    def stream(self) -> Iterator[Tuple[Partial[TC], Partial[TC1], Partial[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]]):
+class PsycoPgComputedResponse3(Generic[TC, TC1, TC2], SqlResponse[Tuple[Partial[TC], Partial[TC1], Partial[TC2], ComputedResult]]):
     table1: Type[TC]
     table2: Type[TC1]
     table3: Type[TC2]
@@ -192,7 +192,7 @@ class PsycoPgComputedResponse3(Generic[TC, TC1, TC2], SqlResponse[Tuple[PartialM
     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]:
+    def __make_record(self, sql_record: Tuple[Any, ...]) -> Tuple[Partial[TC], Partial[TC1], Partial[TC2], ComputedResult]:
         data1: Dict[str, Any] = {}
         data2: Dict[str, Any] = {}
         data3: Dict[str, Any] = {}
@@ -203,20 +203,20 @@ class PsycoPgComputedResponse3(Generic[TC, TC1, TC2], SqlResponse[Tuple[PartialM
                 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))
+        return Partial(self.table1, **data1), Partial(self.table2, **data2), Partial(self.table3, **data3), _computed_record(self.computed, sql_record, len(self.selection))
 
-    def fetchone(self) -> Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], ComputedResult] | None:
+    def fetchone(self) -> Tuple[Partial[TC], Partial[TC1], Partial[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]]:
+    def stream(self) -> Iterator[Tuple[Partial[TC], Partial[TC1], Partial[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]]]):
+class PsycoPgJoinResponse4(Generic[TC, TC1, TC2, TC3], SqlResponse[Tuple[Partial[TC], Partial[TC1], Partial[TC2], Partial[TC3]]]):
     table1: Type[TC]
     table2: Type[TC1]
     table3: Type[TC2]
@@ -224,7 +224,7 @@ class PsycoPgJoinResponse4(Generic[TC, TC1, TC2, TC3], SqlResponse[Tuple[Partial
     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]]:
+    def __make_record(self, sql_record: Tuple[Any, ...]) -> Tuple[Partial[TC], Partial[TC1], Partial[TC2], Partial[TC3]]:
         data1: Dict[str, Any] = {}
         data2: Dict[str, Any] = {}
         data3: Dict[str, Any] = {}
@@ -238,20 +238,20 @@ class PsycoPgJoinResponse4(Generic[TC, TC1, TC2, TC3], SqlResponse[Tuple[Partial
                 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)
+        return Partial(self.table1, **data1), Partial(self.table2, **data2), Partial(self.table3, **data3), Partial(self.table4, **data4)
 
-    def fetchone(self) -> Tuple[PartialModel[TC], PartialModel[TC1], PartialModel[TC2], PartialModel[TC3]] | None:
+    def fetchone(self) -> Tuple[Partial[TC], Partial[TC1], Partial[TC2], Partial[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]]]:
+    def stream(self) -> Iterator[Tuple[Partial[TC], Partial[TC1], Partial[TC2], Partial[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]]):
+class PsycoPgComputedResponse4(Generic[TC, TC1, TC2, TC3], SqlResponse[Tuple[Partial[TC], Partial[TC1], Partial[TC2], Partial[TC3], ComputedResult]]):
     table1: Type[TC]
     table2: Type[TC1]
     table3: Type[TC2]
@@ -260,7 +260,7 @@ class PsycoPgComputedResponse4(Generic[TC, TC1, TC2, TC3], SqlResponse[Tuple[Par
     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]:
+    def __make_record(self, sql_record: Tuple[Any, ...]) -> Tuple[Partial[TC], Partial[TC1], Partial[TC2], Partial[TC3], ComputedResult]:
         data1: Dict[str, Any] = {}
         data2: Dict[str, Any] = {}
         data3: Dict[str, Any] = {}
@@ -274,15 +274,15 @@ class PsycoPgComputedResponse4(Generic[TC, TC1, TC2, TC3], SqlResponse[Tuple[Par
                 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))
+        return Partial(self.table1, **data1), Partial(self.table2, **data2), Partial(self.table3, **data3), Partial(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:
+    def fetchone(self) -> Tuple[Partial[TC], Partial[TC1], Partial[TC2], Partial[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]]:
+    def stream(self) -> Iterator[Tuple[Partial[TC], Partial[TC1], Partial[TC2], Partial[TC3], ComputedResult]]:
         for row in self.cursor:
             yield self.__make_record(row)
 
@@ -313,7 +313,7 @@ class PsycoPgSqlTransaction(SqlTransaction):
             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,
+                # Query1[TC]'s R is always Partial[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():

{pydoptic_sql-0.0.2.post1.dev1 → pydoptic_sql-0.0.2.post1.dev2/src/pydoptic_sql.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydoptic-sql
-Version: 0.0.2.post1.dev1
+Version: 0.0.2.post1.dev2
 Summary: A type-safe SQL query builder built on pydoptic
 Author: John Hungerford
 License-Expression: MIT

pydoptic_sql-0.0.2.post1.dev2/src/pydoptic_sql.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.0.2",
+  "distance": 2,
+  "node": "g9a2420ef5de99bf2d4026d1af9ef469fad88bcab",
+  "dirty": false,
+  "branch": "main",
+  "node_date": "2026-09-07"
+}

pydoptic_sql-0.0.2.post1.dev1/src/pydoptic_sql.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.0.2",
-  "distance": 1,
-  "node": "ga0068181cb2d8dfd1b14469d4ad3bdc4cfd63617",
-  "dirty": false,
-  "branch": "main",
-  "node_date": "2026-08-18"
-}