sql-athame 0.4.0a5__tar.gz → 0.4.0a7__tar.gz

{sql_athame-0.4.0a5 → sql_athame-0.4.0a7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sql-athame
-Version: 0.4.0a5
+Version: 0.4.0a7
 Summary: Python tool for slicing and dicing SQL
 Home-page: https://github.com/bdowning/sql-athame
 License: MIT

sql_athame-0.4.0a7/pyproject.toml

@@ -0,0 +1,103 @@
+[tool.poetry]
+name = "sql-athame"
+version = "0.4.0-alpha-7"
+description = "Python tool for slicing and dicing SQL"
+authors = ["Brian Downing <bdowning@lavos.net>"]
+license = "MIT"
+readme = "README.md"
+homepage = "https://github.com/bdowning/sql-athame"
+repository = "https://github.com/bdowning/sql-athame"
+
+[tool.poetry.extras]
+asyncpg = ["asyncpg"]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+asyncpg = { version = "*", optional = true }
+typing-extensions = "*"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "*"
+mypy = "*"
+flake8 = "*"
+ipython = "*"
+pytest-cov = "*"
+bump2version = "*"
+asyncpg = "*"
+pytest-asyncio = "*"
+grip = "*"
+SQLAlchemy = "*"
+ruff = "*"
+
+[build-system]
+requires = ["poetry>=0.12"]
+build-backend = "poetry.masonry.api"
+
+[tool.ruff]
+target-version = "py39"
+
+[tool.ruff.lint]
+select = [
+    "ASYNC",
+    "B",
+    "BLE",
+    "C4",
+    "DTZ",
+    "E",
+    "F",
+    "I",
+    "INP",
+    "ISC",
+    "LOG",
+    "N",
+    "PIE",
+    "PT",
+    "RET",
+    "RUF",
+    "SLOT",
+    "UP",
+]
+flake8-comprehensions.allow-dict-calls-with-keyword-arguments = true
+ignore = [
+    "E501",    # line too long
+    "E721",    # type checks, currently broken
+    "ISC001",  # conflicts with ruff format
+    "PT004",   # Fixture `...` does not return anything, add leading underscore
+    "RET505",  # Unnecessary `else` after `return` statement
+    "RET506",  # Unnecessary `else` after `raise` statement
+]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = [
+    "F401",  # wildcard import
+]
+
+[tool.pytest.ini_options]
+addopts = [
+    "-v",
+    "--cov",
+    "--cov-report", "xml:results/pytest/coverage.xml",
+    "--cov-report", "html:results/pytest/cov_html",
+    "--cov-report", "term-missing",
+    "--junitxml=results/pytest/results.xml",
+    "--durations=5",
+]
+junit_family = "legacy"
+asyncio_mode = "auto"
+
+[tool.coverage]
+run.include = [
+    "sql_athame/**/*.py",
+    "tests/**/*.py",
+]
+report.precision = 2
+
+[tool.mypy]
+disallow_incomplete_defs = true
+check_untyped_defs = true
+
+[[tool.mypy.overrides]]
+module = [
+    "asyncpg",
+]
+ignore_missing_imports = true

sql_athame-0.4.0a7/sql_athame/__init__.py

@@ -0,0 +1,2 @@
+from .base import Fragment, sql
+from .dataclasses import ColumnInfo, ModelBase

{sql_athame-0.4.0a5 → sql_athame-0.4.0a7}/sql_athame/base.py

@@ -2,16 +2,11 @@ import dataclasses
 import json
 import re
 import string
+from collections.abc import Iterable, Iterator, Sequence
 from typing import (
     Any,
     Callable,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
     Optional,
-    Sequence,
-    Tuple,
     Union,
     cast,
     overload,
@@ -34,7 +29,7 @@ def auto_numbered(field_name):
 def process_slot_value(
     name: str,
     value: Any,
-    placeholders: Dict[str, Placeholder],
+    placeholders: dict[str, Placeholder],
 ) -> Union["Fragment", Placeholder]:
     if isinstance(value, Fragment):
         return value
@@ -47,9 +42,9 @@ def process_slot_value(
 @dataclasses.dataclass
 class Fragment:
     __slots__ = ["parts"]
-    parts: List[Part]
+    parts: list[Part]
 
-    def flatten_into(self, parts: List[FlatPart]) -> None:
+    def flatten_into(self, parts: list[FlatPart]) -> None:
         for part in self.parts:
             if isinstance(part, Fragment):
                 part.flatten_into(parts)
@@ -70,10 +65,10 @@ class Fragment:
         for i, part in enumerate(flattened.parts):
             if isinstance(part, Slot):
                 func.append(
-                    f"  process_slot_value({repr(part.name)}, slots[{repr(part.name)}], placeholders),"
+                    f"  process_slot_value({part.name!r}, slots[{part.name!r}], placeholders),"
                 )
             elif isinstance(part, str):
-                func.append(f"  {repr(part)},")
+                func.append(f"  {part!r},")
             else:
                 env[f"part_{i}"] = part
                 func.append(f"  part_{i},")
@@ -82,9 +77,9 @@ class Fragment:
         return env["compiled"]  # type: ignore
 
     def flatten(self) -> "Fragment":
-        parts: List[FlatPart] = []
+        parts: list[FlatPart] = []
         self.flatten_into(parts)
-        out_parts: List[Part] = []
+        out_parts: list[Part] = []
         for part in parts:
             if isinstance(part, str) and out_parts and isinstance(out_parts[-1], str):
                 out_parts[-1] += part
@@ -93,9 +88,9 @@ class Fragment:
         return Fragment(out_parts)
 
     def fill(self, **kwargs: Any) -> "Fragment":
-        parts: List[Part] = []
-        self.flatten_into(cast(List[FlatPart], parts))
-        placeholders: Dict[str, Placeholder] = {}
+        parts: list[Part] = []
+        self.flatten_into(cast(list[FlatPart], parts))
+        placeholders: dict[str, Placeholder] = {}
         for i, part in enumerate(parts):
             if isinstance(part, Slot):
                 parts[i] = process_slot_value(
@@ -106,24 +101,24 @@ class Fragment:
     @overload
     def prep_query(
         self, allow_slots: Literal[True]
-    ) -> Tuple[str, List[Union[Placeholder, Slot]]]: ...  # pragma: no cover
+    ) -> tuple[str, list[Union[Placeholder, Slot]]]: ...  # pragma: no cover
 
     @overload
     def prep_query(
         self, allow_slots: Literal[False] = False
-    ) -> Tuple[str, List[Placeholder]]: ...  # pragma: no cover
+    ) -> tuple[str, list[Placeholder]]: ...  # pragma: no cover
 
-    def prep_query(self, allow_slots: bool = False) -> Tuple[str, List[Any]]:
-        parts: List[FlatPart] = []
+    def prep_query(self, allow_slots: bool = False) -> tuple[str, list[Any]]:
+        parts: list[FlatPart] = []
         self.flatten_into(parts)
-        args: List[Union[Placeholder, Slot]] = []
-        placeholder_ids: Dict[Placeholder, int] = {}
-        slot_ids: Dict[Slot, int] = {}
-        out_parts: List[str] = []
+        args: list[Union[Placeholder, Slot]] = []
+        placeholder_ids: dict[Placeholder, int] = {}
+        slot_ids: dict[Slot, int] = {}
+        out_parts: list[str] = []
         for part in parts:
             if isinstance(part, Slot):
                 if not allow_slots:
-                    raise ValueError(f"Unfilled slot: {repr(part.name)}")
+                    raise ValueError(f"Unfilled slot: {part.name!r}")
                 if part not in slot_ids:
                     args.append(part)
                     slot_ids[part] = len(args)
@@ -138,7 +133,7 @@ class Fragment:
                 out_parts.append(part)
         return "".join(out_parts).strip(), args
 
-    def query(self) -> Tuple[str, List[Any]]:
+    def query(self) -> tuple[str, list[Any]]:
         query, args = self.prep_query()
         placeholder_values = [arg.value for arg in args]
         return query, placeholder_values
@@ -146,16 +141,16 @@ class Fragment:
     def sqlalchemy_text(self) -> Any:
         return sqlalchemy_text_from_fragment(self)
 
-    def prepare(self) -> Tuple[str, Callable[..., List[Any]]]:
+    def prepare(self) -> tuple[str, Callable[..., list[Any]]]:
         query, args = self.prep_query(allow_slots=True)
-        env = dict()
+        env = {}
         func = [
             "def generate_args(**kwargs):",
             " return [",
         ]
         for i, arg in enumerate(args):
             if isinstance(arg, Slot):
-                func.append(f"  kwargs[{repr(arg.name)}],")
+                func.append(f"  kwargs[{arg.name!r}],")
             else:
                 env[f"value_{i}"] = arg.value
                 func.append(f"  value_{i},")
@@ -178,10 +173,10 @@ class SQLFormatter:
         if not preserve_formatting:
             fmt = newline_whitespace_re.sub(" ", fmt)
         fmtr = string.Formatter()
-        parts: List[Part] = []
-        placeholders: Dict[str, Placeholder] = {}
+        parts: list[Part] = []
+        placeholders: dict[str, Placeholder] = {}
         next_auto_field = 0
-        for literal_text, field_name, format_spec, conversion in fmtr.parse(fmt):
+        for literal_text, field_name, _format_spec, _conversion in fmtr.parse(fmt):
             parts.append(literal_text)
             if field_name is not None:
                 if auto_numbered(field_name):
@@ -258,12 +253,11 @@ class SQLFormatter:
             parts = parts[0]
         return Fragment(list(join_parts(parts, infix=", ")))
 
-    @staticmethod
-    def unnest(data: Iterable[Sequence[Any]], types: Iterable[str]) -> Fragment:
-        nested = list(nest_for_type(x, t) for x, t in zip(zip(*data), types))
+    def unnest(self, data: Iterable[Sequence[Any]], types: Iterable[str]) -> Fragment:
+        nested = [nest_for_type(x, t) for x, t in zip(zip(*data), types)]
         if not nested:
-            nested = list(nest_for_type([], t) for t in types)
-        return Fragment(["UNNEST(", sql.list(nested), ")"])
+            nested = [nest_for_type([], t) for t in types]
+        return Fragment(["UNNEST(", self.list(nested), ")"])
 
 
 sql = SQLFormatter()
@@ -296,7 +290,7 @@ def lit(text: str) -> Fragment:
     return Fragment([text])
 
 
-def any_all(frags: List[Fragment], op: str, base_case: str) -> Fragment:
+def any_all(frags: list[Fragment], op: str, base_case: str) -> Fragment:
     if not frags:
         return lit(base_case)
     parts = join_parts(frags, prefix="(", infix=f") {op} (", suffix=")")

{sql_athame-0.4.0a5 → sql_athame-0.4.0a7}/sql_athame/dataclasses.py

@@ -1,60 +1,87 @@
 import datetime
+import functools
 import uuid
-from dataclasses import dataclass, field, fields
+from collections.abc import AsyncGenerator, Iterable, Mapping
+from dataclasses import Field, InitVar, dataclass, fields
 from typing import (
+    Annotated,
     Any,
-    AsyncGenerator,
     Callable,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Mapping,
     Optional,
-    Set,
-    Tuple,
-    Type,
     TypeVar,
     Union,
+    get_origin,
+    get_type_hints,
 )
 
+from typing_extensions import TypeAlias
+
 from .base import Fragment, sql
 
-Where = Union[Fragment, Iterable[Fragment]]
+Where: TypeAlias = Union[Fragment, Iterable[Fragment]]
 # KLUDGE to avoid a string argument being valid
-SequenceOfStrings = Union[List[str], Tuple[str, ...]]
-FieldNames = SequenceOfStrings
-FieldNamesSet = Union[SequenceOfStrings, Set[str]]
+SequenceOfStrings: TypeAlias = Union[list[str], tuple[str, ...]]
+FieldNames: TypeAlias = SequenceOfStrings
+FieldNamesSet: TypeAlias = Union[SequenceOfStrings, set[str]]
 
-Connection = Any
-Pool = Any
+Connection: TypeAlias = Any
+Pool: TypeAlias = Any
 
 
 @dataclass
 class ColumnInfo:
-    type: str
-    create_type: str
-    constraints: Tuple[str, ...]
-
-    def create_table_string(self):
-        return " ".join((self.create_type, *self.constraints))
-
+    type: Optional[str] = None
+    create_type: Optional[str] = None
+    nullable: Optional[bool] = None
+    _constraints: tuple[str, ...] = ()
+
+    constraints: InitVar[Union[str, Iterable[str], None]] = None
+
+    def __post_init__(self, constraints: Union[str, Iterable[str], None]) -> None:
+        if constraints is not None:
+            if type(constraints) is str:
+                constraints = (constraints,)
+            self._constraints = tuple(constraints)
+
+    @staticmethod
+    def merge(a: "ColumnInfo", b: "ColumnInfo") -> "ColumnInfo":
+        return ColumnInfo(
+            type=b.type if b.type is not None else a.type,
+            create_type=b.create_type if b.create_type is not None else a.create_type,
+            nullable=b.nullable if b.nullable is not None else a.nullable,
+            _constraints=(*a._constraints, *b._constraints),
+        )
 
-def model_field_metadata(
-    type: str, constraints: Union[str, Iterable[str]] = ()
-) -> Dict[str, Any]:
-    if isinstance(constraints, str):
-        constraints = (constraints,)
-    info = ColumnInfo(
-        sql_create_type_map.get(type.upper(), type), type, tuple(constraints)
-    )
-    return {"sql_athame": info}
 
+@dataclass
+class ConcreteColumnInfo:
+    type: str
+    create_type: str
+    nullable: bool
+    constraints: tuple[str, ...]
+
+    @staticmethod
+    def from_column_info(name: str, *args: ColumnInfo) -> "ConcreteColumnInfo":
+        info = functools.reduce(ColumnInfo.merge, args, ColumnInfo())
+        if info.create_type is None and info.type is not None:
+            info.create_type = info.type
+            info.type = sql_create_type_map.get(info.type.upper(), info.type)
+        if type(info.type) is not str or type(info.create_type) is not str:
+            raise ValueError(f"Missing SQL type for column {name!r}")
+        return ConcreteColumnInfo(
+            type=info.type,
+            create_type=info.create_type,
+            nullable=bool(info.nullable),
+            constraints=info._constraints,
+        )
 
-def model_field(
-    *, type: str, constraints: Union[str, Iterable[str]] = (), **kwargs: Any
-) -> Any:
-    return field(**kwargs, metadata=model_field_metadata(type, constraints))
+    def create_table_string(self) -> str:
+        parts = (
+            self.create_type,
+            *(() if self.nullable else ("NOT NULL",)),
+            *self.constraints,
+        )
+        return " ".join(parts)
 
 
 sql_create_type_map = {
@@ -64,43 +91,37 @@ sql_create_type_map = {
 }
 
 
-sql_type_map = {
-    Optional[bool]: ("BOOLEAN",),
-    Optional[bytes]: ("BYTEA",),
-    Optional[datetime.date]: ("DATE",),
-    Optional[datetime.datetime]: ("TIMESTAMP",),
-    Optional[float]: ("DOUBLE PRECISION",),
-    Optional[int]: ("INTEGER",),
-    Optional[str]: ("TEXT",),
-    Optional[uuid.UUID]: ("UUID",),
-    bool: ("BOOLEAN", "NOT NULL"),
-    bytes: ("BYTEA", "NOT NULL"),
-    datetime.date: ("DATE", "NOT NULL"),
-    datetime.datetime: ("TIMESTAMP", "NOT NULL"),
-    float: ("DOUBLE PRECISION", "NOT NULL"),
-    int: ("INTEGER", "NOT NULL"),
-    str: ("TEXT", "NOT NULL"),
-    uuid.UUID: ("UUID", "NOT NULL"),
+sql_type_map: dict[Any, tuple[str, bool]] = {
+    Optional[bool]: ("BOOLEAN", True),
+    Optional[bytes]: ("BYTEA", True),
+    Optional[datetime.date]: ("DATE", True),
+    Optional[datetime.datetime]: ("TIMESTAMP", True),
+    Optional[float]: ("DOUBLE PRECISION", True),
+    Optional[int]: ("INTEGER", True),
+    Optional[str]: ("TEXT", True),
+    Optional[uuid.UUID]: ("UUID", True),
+    bool: ("BOOLEAN", False),
+    bytes: ("BYTEA", False),
+    datetime.date: ("DATE", False),
+    datetime.datetime: ("TIMESTAMP", False),
+    float: ("DOUBLE PRECISION", False),
+    int: ("INTEGER", False),
+    str: ("TEXT", False),
+    uuid.UUID: ("UUID", False),
 }
 
 
-def column_info_for_field(field):
-    if "sql_athame" in field.metadata:
-        return field.metadata["sql_athame"]
-    type, *constraints = sql_type_map[field.type]
-    return ColumnInfo(type, type, tuple(constraints))
-
-
 T = TypeVar("T", bound="ModelBase")
 U = TypeVar("U")
 
 
-class ModelBase(Mapping[str, Any]):
-    _column_info: Optional[Dict[str, ColumnInfo]]
-    _cache: Dict[tuple, Any]
+class ModelBase:
+    _column_info: Optional[dict[str, ConcreteColumnInfo]]
+    _cache: dict[tuple, Any]
     table_name: str
-    primary_key_names: Tuple[str, ...]
+    primary_key_names: tuple[str, ...]
     array_safe_insert: bool
+    _type_hints: dict[str, type]
 
     def __init_subclass__(
         cls,
@@ -138,27 +159,38 @@ class ModelBase(Mapping[str, Any]):
             cls._cache[key] = thunk()
             return cls._cache[key]
 
-    def keys(self):
-        return self.field_names()
-
-    def __getitem__(self, key: str) -> Any:
-        return getattr(self, key)
-
-    def __iter__(self) -> Iterator[Any]:
-        return iter(self.keys())
-
-    def __len__(self) -> int:
-        return len(self.keys())
-
-    def get(self, key: str, default: Any = None) -> Any:
-        return getattr(self, key, default)
-
     @classmethod
-    def column_info(cls, column: str) -> ColumnInfo:
+    def type_hints(cls) -> dict[str, type]:
+        try:
+            return cls._type_hints
+        except AttributeError:
+            cls._type_hints = get_type_hints(cls, include_extras=True)
+            return cls._type_hints
+
+    @classmethod
+    def column_info_for_field(cls, field: Field) -> ConcreteColumnInfo:
+        type_info = cls.type_hints()[field.name]
+        base_type = type_info
+        if get_origin(type_info) is Annotated:
+            base_type = type_info.__origin__  # type: ignore
+        info = []
+        if base_type in sql_type_map:
+            _type, nullable = sql_type_map[base_type]
+            info.append(ColumnInfo(type=_type, nullable=nullable))
+        if get_origin(type_info) is Annotated:
+            for md in type_info.__metadata__:  # type: ignore
+                if isinstance(md, ColumnInfo):
+                    info.append(md)
+        return ConcreteColumnInfo.from_column_info(field.name, *info)
+
+    @classmethod
+    def column_info(cls, column: str) -> ConcreteColumnInfo:
         try:
             return cls._column_info[column]  # type: ignore
         except AttributeError:
-            cls._column_info = {f.name: column_info_for_field(f) for f in cls._fields()}
+            cls._column_info = {
+                f.name: cls.column_info_for_field(f) for f in cls._fields()
+            }
             return cls._column_info[column]
 
     @classmethod
@@ -166,17 +198,17 @@ class ModelBase(Mapping[str, Any]):
         return sql.identifier(cls.table_name, prefix=prefix)
 
     @classmethod
-    def primary_key_names_sql(cls, *, prefix: Optional[str] = None) -> List[Fragment]:
+    def primary_key_names_sql(cls, *, prefix: Optional[str] = None) -> list[Fragment]:
         return [sql.identifier(pk, prefix=prefix) for pk in cls.primary_key_names]
 
     @classmethod
-    def field_names(cls, *, exclude: FieldNamesSet = ()) -> List[str]:
+    def field_names(cls, *, exclude: FieldNamesSet = ()) -> list[str]:
         return [f.name for f in cls._fields() if f.name not in exclude]
 
     @classmethod
     def field_names_sql(
         cls, *, prefix: Optional[str] = None, exclude: FieldNamesSet = ()
-    ) -> List[Fragment]:
+    ) -> list[Fragment]:
         return [
             sql.identifier(f, prefix=prefix) for f in cls.field_names(exclude=exclude)
         ]
@@ -186,9 +218,9 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     def _get_field_values_fn(
-        cls: Type[T], exclude: FieldNamesSet = ()
-    ) -> Callable[[T], List[Any]]:
-        env: Dict[str, Any] = dict()
+        cls: type[T], exclude: FieldNamesSet = ()
+    ) -> Callable[[T], list[Any]]:
+        env: dict[str, Any] = {}
         func = ["def get_field_values(self): return ["]
         for f in cls._fields():
             if f.name not in exclude:
@@ -197,7 +229,7 @@ class ModelBase(Mapping[str, Any]):
         exec(" ".join(func), env)
         return env["get_field_values"]
 
-    def field_values(self, *, exclude: FieldNamesSet = ()) -> List[Any]:
+    def field_values(self, *, exclude: FieldNamesSet = ()) -> list[Any]:
         get_field_values = self._cached(
             ("get_field_values", tuple(sorted(exclude))),
             lambda: self._get_field_values_fn(exclude),
@@ -206,7 +238,7 @@ class ModelBase(Mapping[str, Any]):
 
     def field_values_sql(
         self, *, exclude: FieldNamesSet = (), default_none: bool = False
-    ) -> List[Fragment]:
+    ) -> list[Fragment]:
         if default_none:
             return [
                 sql.literal("DEFAULT") if value is None else sql.value(value)
@@ -217,7 +249,7 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     def from_tuple(
-        cls: Type[T], tup: tuple, *, offset: int = 0, exclude: FieldNamesSet = ()
+        cls: type[T], tup: tuple, *, offset: int = 0, exclude: FieldNamesSet = ()
     ) -> T:
         names = (f.name for f in cls._fields() if f.name not in exclude)
         kwargs = {name: tup[offset] for offset, name in enumerate(names, start=offset)}
@@ -225,14 +257,14 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     def from_dict(
-        cls: Type[T], dct: Dict[str, Any], *, exclude: FieldNamesSet = ()
+        cls: type[T], dct: dict[str, Any], *, exclude: FieldNamesSet = ()
     ) -> T:
         names = {f.name for f in cls._fields() if f.name not in exclude}
         kwargs = {k: v for k, v in dct.items() if k in names}
         return cls(**kwargs)
 
     @classmethod
-    def ensure_model(cls: Type[T], row: Union[T, Mapping[str, Any]]) -> T:
+    def ensure_model(cls: type[T], row: Union[T, Mapping[str, Any]]) -> T:
         if isinstance(row, cls):
             return row
         return cls(**row)
@@ -286,7 +318,7 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     async def select_cursor(
-        cls: Type[T],
+        cls: type[T],
         connection: Connection,
         order_by: Union[FieldNames, str] = (),
         for_update: bool = False,
@@ -301,12 +333,12 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     async def select(
-        cls: Type[T],
+        cls: type[T],
         connection_or_pool: Union[Connection, Pool],
         order_by: Union[FieldNames, str] = (),
         for_update: bool = False,
         where: Where = (),
-    ) -> List[T]:
+    ) -> list[T]:
         return [
             cls(**row)
             for row in await connection_or_pool.fetch(
@@ -315,7 +347,7 @@ class ModelBase(Mapping[str, Any]):
         ]
 
     @classmethod
-    def create_sql(cls: Type[T], **kwargs: Any) -> Fragment:
+    def create_sql(cls: type[T], **kwargs: Any) -> Fragment:
         return sql(
             "INSERT INTO {table} ({fields}) VALUES ({values}) RETURNING {out_fields}",
             table=cls.table_name_sql(),
@@ -326,7 +358,7 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     async def create(
-        cls: Type[T], connection_or_pool: Union[Connection, Pool], **kwargs: Any
+        cls: type[T], connection_or_pool: Union[Connection, Pool], **kwargs: Any
     ) -> T:
         row = await connection_or_pool.fetchrow(*cls.create_sql(**kwargs))
         return cls(**row)
@@ -375,11 +407,10 @@ class ModelBase(Mapping[str, Any]):
             self.upsert_sql(self.insert_sql(exclude=exclude), exclude=exclude),
         )
         result = await connection_or_pool.fetchrow(*query)
-        is_update = result["xmax"] != 0
-        return is_update
+        return result["xmax"] != 0
 
     @classmethod
-    def delete_multiple_sql(cls: Type[T], rows: Iterable[T]) -> Fragment:
+    def delete_multiple_sql(cls: type[T], rows: Iterable[T]) -> Fragment:
         cached = cls._cached(
             ("delete_multiple_sql",),
             lambda: sql(
@@ -397,12 +428,12 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     async def delete_multiple(
-        cls: Type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
+        cls: type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
     ) -> str:
         return await connection_or_pool.execute(*cls.delete_multiple_sql(rows))
 
     @classmethod
-    def insert_multiple_sql(cls: Type[T], rows: Iterable[T]) -> Fragment:
+    def insert_multiple_sql(cls: type[T], rows: Iterable[T]) -> Fragment:
         cached = cls._cached(
             ("insert_multiple_sql",),
             lambda: sql(
@@ -419,7 +450,7 @@ class ModelBase(Mapping[str, Any]):
         )
 
     @classmethod
-    def insert_multiple_array_safe_sql(cls: Type[T], rows: Iterable[T]) -> Fragment:
+    def insert_multiple_array_safe_sql(cls: type[T], rows: Iterable[T]) -> Fragment:
         return sql(
             "INSERT INTO {table} ({fields}) VALUES {values}",
             table=cls.table_name_sql(),
@@ -432,13 +463,13 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     async def insert_multiple_unnest(
-        cls: Type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
+        cls: type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
     ) -> str:
         return await connection_or_pool.execute(*cls.insert_multiple_sql(rows))
 
     @classmethod
     async def insert_multiple_array_safe(
-        cls: Type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
+        cls: type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
     ) -> str:
         last = ""
         for chunk in chunked(rows, 100):
@@ -449,7 +480,7 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     async def insert_multiple(
-        cls: Type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
+        cls: type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
     ) -> str:
         if cls.array_safe_insert:
             return await cls.insert_multiple_array_safe(connection_or_pool, rows)
@@ -458,7 +489,7 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     async def upsert_multiple_unnest(
-        cls: Type[T],
+        cls: type[T],
         connection_or_pool: Union[Connection, Pool],
         rows: Iterable[T],
         insert_only: FieldNamesSet = (),
@@ -469,7 +500,7 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     async def upsert_multiple_array_safe(
-        cls: Type[T],
+        cls: type[T],
         connection_or_pool: Union[Connection, Pool],
         rows: Iterable[T],
         insert_only: FieldNamesSet = (),
@@ -485,7 +516,7 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     async def upsert_multiple(
-        cls: Type[T],
+        cls: type[T],
         connection_or_pool: Union[Connection, Pool],
         rows: Iterable[T],
         insert_only: FieldNamesSet = (),
@@ -501,9 +532,9 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     def _get_equal_ignoring_fn(
-        cls: Type[T], ignore: FieldNamesSet = ()
+        cls: type[T], ignore: FieldNamesSet = ()
     ) -> Callable[[T, T], bool]:
-        env: Dict[str, Any] = dict()
+        env: dict[str, Any] = {}
         func = ["def equal_ignoring(a, b):"]
         for f in cls._fields():
             if f.name not in ignore:
@@ -514,14 +545,14 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     async def replace_multiple(
-        cls: Type[T],
+        cls: type[T],
         connection: Connection,
         rows: Union[Iterable[T], Iterable[Mapping[str, Any]]],
         *,
         where: Where,
         ignore: FieldNamesSet = (),
         insert_only: FieldNamesSet = (),
-    ) -> Tuple[List[T], List[T], List[T]]:
+    ) -> tuple[list[T], list[T], list[T]]:
         ignore = sorted(set(ignore) | set(insert_only))
         equal_ignoring = cls._cached(
             ("equal_ignoring", tuple(ignore)),
@@ -556,32 +587,30 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     def _get_differences_ignoring_fn(
-        cls: Type[T], ignore: FieldNamesSet = ()
-    ) -> Callable[[T, T], List[str]]:
-        env: Dict[str, Any] = dict()
+        cls: type[T], ignore: FieldNamesSet = ()
+    ) -> Callable[[T, T], list[str]]:
+        env: dict[str, Any] = {}
         func = [
             "def differences_ignoring(a, b):",
             " diffs = []",
         ]
         for f in cls._fields():
             if f.name not in ignore:
-                func.append(
-                    f" if a.{f.name} != b.{f.name}: diffs.append({repr(f.name)})"
-                )
+                func.append(f" if a.{f.name} != b.{f.name}: diffs.append({f.name!r})")
         func += [" return diffs"]
         exec("\n".join(func), env)
         return env["differences_ignoring"]
 
     @classmethod
     async def replace_multiple_reporting_differences(
-        cls: Type[T],
+        cls: type[T],
         connection: Connection,
         rows: Union[Iterable[T], Iterable[Mapping[str, Any]]],
         *,
         where: Where,
         ignore: FieldNamesSet = (),
         insert_only: FieldNamesSet = (),
-    ) -> Tuple[List[T], List[Tuple[T, T, List[str]]], List[T]]:
+    ) -> tuple[list[T], list[tuple[T, T, list[str]]], list[T]]:
         ignore = sorted(set(ignore) | set(insert_only))
         differences_ignoring = cls._cached(
             ("differences_ignoring", tuple(ignore)),

{sql_athame-0.4.0a5 → sql_athame-0.4.0a7}/sql_athame/escape.py

@@ -1,19 +1,20 @@
 import math
 import uuid
-from typing import Any, Sequence
+from collections.abc import Sequence
+from typing import Any
 
 
 def escape(value: Any) -> str:
     if isinstance(value, str):
-        return f"E{repr(value)}"
+        return f"E{value!r}"
     elif isinstance(value, float) or isinstance(value, int):
         if math.isnan(value):
             raise ValueError("Can't escape NaN float")
         elif math.isinf(value):
             raise ValueError("Can't escape infinite float")
-        return f"{repr(value)}"
+        return f"{value!r}"
     elif isinstance(value, uuid.UUID):
-        return f"{repr(str(value))}::UUID"
+        return f"{str(value)!r}::UUID"
     elif isinstance(value, Sequence):
         args = ", ".join(escape(x) for x in value)
         return f"ARRAY[{args}]"

{sql_athame-0.4.0a5 → sql_athame-0.4.0a7}/sql_athame/sqlalchemy.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any
 
 from .types import FlatPart, Placeholder, Slot
 
@@ -7,10 +7,10 @@ try:
     from sqlalchemy.sql.elements import BindParameter
 
     def sqlalchemy_text_from_fragment(self: "Fragment") -> Any:
-        parts: List[FlatPart] = []
+        parts: list[FlatPart] = []
         self.flatten_into(parts)
-        bindparams: Dict[str, Any] = {}
-        out_parts: List[str] = []
+        bindparams: dict[str, Any] = {}
+        out_parts: list[str] = []
         for part in parts:
             if isinstance(part, Slot):
                 out_parts.append(f"(:{part.name})")

{sql_athame-0.4.0a5 → sql_athame-0.4.0a7}/sql_athame/types.py

@@ -1,6 +1,8 @@
 import dataclasses
 from typing import TYPE_CHECKING, Any, Union
 
+from typing_extensions import TypeAlias
+
 
 @dataclasses.dataclass(eq=False)
 class Placeholder:
@@ -15,8 +17,8 @@ class Slot:
     name: str
 
 
-Part = Union[str, Placeholder, Slot, "Fragment"]
-FlatPart = Union[str, Placeholder, Slot]
+Part: TypeAlias = Union[str, Placeholder, Slot, "Fragment"]
+FlatPart: TypeAlias = Union[str, Placeholder, Slot]
 
 if TYPE_CHECKING:
     from .base import Fragment

sql_athame-0.4.0a5/pyproject.toml

@@ -1,35 +0,0 @@
-[tool.poetry]
-name = "sql-athame"
-version = "0.4.0-alpha-5"
-description = "Python tool for slicing and dicing SQL"
-authors = ["Brian Downing <bdowning@lavos.net>"]
-license = "MIT"
-readme = "README.md"
-homepage = "https://github.com/bdowning/sql-athame"
-repository = "https://github.com/bdowning/sql-athame"
-
-[tool.poetry.extras]
-asyncpg = ["asyncpg"]
-
-[tool.poetry.dependencies]
-python = "^3.9"
-asyncpg = { version = "*", optional = true }
-typing-extensions = "*"
-
-[tool.poetry.dev-dependencies]
-black = "*"
-isort = "*"
-pytest = "*"
-mypy = "*"
-flake8 = "*"
-ipython = "*"
-pytest-cov = "*"
-bump2version = "*"
-asyncpg = "*"
-pytest-asyncio = "*"
-grip = "*"
-SQLAlchemy = "*"
-
-[build-system]
-requires = ["poetry>=0.12"]
-build-backend = "poetry.masonry.api"

sql_athame-0.4.0a5/sql_athame/__init__.py

@@ -1,2 +0,0 @@
-from .base import Fragment, sql  # noqa: F401
-from .dataclasses import ModelBase, model_field, model_field_metadata  # noqa: F401