sql-athame 0.4.0a6__py3-none-any.whl → 0.4.0a8__py3-none-any.whl

sql_athame/dataclasses.py

@@ -1,4 +1,5 @@
 import datetime
+import functools
 import uuid
 from collections.abc import AsyncGenerator, Iterable, Mapping
 from dataclasses import Field, InitVar, dataclass, fields
@@ -9,6 +10,7 @@ from typing import (
     Optional,
     TypeVar,
     Union,
+    get_args,
     get_origin,
     get_type_hints,
 )
@@ -29,31 +31,76 @@ Pool: TypeAlias = Any
 
 @dataclass
 class ColumnInfo:
-    type: str
-    create_type: str = ""
-    nullable: bool = False
+    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 self.create_type == "":
-            self.create_type = self.type
-            self.type = sql_create_type_map.get(self.type.upper(), self.type)
         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),
+        )
+
+
+@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 create_table_string(self) -> str:
         parts = (
             self.create_type,
             *(() if self.nullable else ("NOT NULL",)),
-            *self._constraints,
+            *self.constraints,
         )
         return " ".join(parts)
 
 
+NULLABLE_TYPES = (type(None), Any, object)
+
+
+def split_nullable(typ: type) -> tuple[bool, type]:
+    nullable = typ in NULLABLE_TYPES
+    if get_origin(typ) is Union:
+        args = []
+        for arg in get_args(typ):
+            if arg in NULLABLE_TYPES:
+                nullable = True
+            else:
+                args.append(arg)
+        return nullable, Union[tuple(args)]  # type: ignore
+    return nullable, typ
+
+
 sql_create_type_map = {
     "BIGSERIAL": "BIGINT",
     "SERIAL": "INTEGER",
@@ -61,23 +108,15 @@ sql_create_type_map = {
 }
 
 
-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),
+sql_type_map: dict[Any, str] = {
+    bool: "BOOLEAN",
+    bytes: "BYTEA",
+    datetime.date: "DATE",
+    datetime.datetime: "TIMESTAMP",
+    float: "DOUBLE PRECISION",
+    int: "INTEGER",
+    str: "TEXT",
+    uuid.UUID: "UUID",
 }
 
 
@@ -86,7 +125,7 @@ U = TypeVar("U")
 
 
 class ModelBase:
-    _column_info: Optional[dict[str, ColumnInfo]]
+    _column_info: Optional[dict[str, ConcreteColumnInfo]]
     _cache: dict[tuple, Any]
     table_name: str
     primary_key_names: tuple[str, ...]
@@ -138,19 +177,23 @@ class ModelBase:
             return cls._type_hints
 
     @classmethod
-    def column_info_for_field(cls, field: Field) -> ColumnInfo:
+    def column_info_for_field(cls, field: Field) -> ConcreteColumnInfo:
         type_info = cls.type_hints()[field.name]
         base_type = type_info
+        metadata = []
         if get_origin(type_info) is Annotated:
-            base_type = type_info.__origin__  # type: ignore
-            for md in type_info.__metadata__:  # type: ignore
-                if isinstance(md, ColumnInfo):
-                    return md
-        type, nullable = sql_type_map[base_type]
-        return ColumnInfo(type=type, nullable=nullable)
-
-    @classmethod
-    def column_info(cls, column: str) -> ColumnInfo:
+            base_type, *metadata = get_args(type_info)
+        nullable, base_type = split_nullable(base_type)
+        info = [ColumnInfo(nullable=nullable)]
+        if base_type in sql_type_map:
+            info.append(ColumnInfo(type=sql_type_map[base_type]))
+        for md in metadata:
+            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:

{sql_athame-0.4.0a6.dist-info → sql_athame-0.4.0a8.dist-info}/METADATA

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

{sql_athame-0.4.0a6.dist-info → sql_athame-0.4.0a8.dist-info}/RECORD

@@ -1,11 +1,11 @@
 sql_athame/__init__.py,sha256=7OBIMZOcrD2pvfIL-rjD1IGZ3TNQbwyu76a9PWk-yYg,79
 sql_athame/base.py,sha256=FR7EmC0VkX1VRgvAutSEfYSWhlEYpoqS1Kqxp1jHp6Y,10293
-sql_athame/dataclasses.py,sha256=qb4EESR6J-iv6UScktMLuKAwH3ZA3IOwCM0v6oMv8Q8,20848
+sql_athame/dataclasses.py,sha256=NRPGOlqaTMj49B4gbvC5nCRrFZFrivoRdhSmG8VTkAg,22167
 sql_athame/escape.py,sha256=kK101xXeFitlvuG-L_hvhdpgGJCtmRTprsn1yEfZKws,758
 sql_athame/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sql_athame/sqlalchemy.py,sha256=aWopfPh3j71XwKmcN_VcHRNlhscI0Sckd4AiyGf8Tpw,1293
 sql_athame/types.py,sha256=FQ06l9Uc-vo57UrAarvnukILdV2gN1IaYUnHJ_bNYic,475
-sql_athame-0.4.0a6.dist-info/LICENSE,sha256=xqV29vPFqITcKifYrGPgVIBjq4fdmLSwY3gRUtDKafg,1076
-sql_athame-0.4.0a6.dist-info/METADATA,sha256=8Ov07iCKPAo35uWW3t9WRRlXIgRlNGGrMpyXnOI6TRs,12845
-sql_athame-0.4.0a6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-sql_athame-0.4.0a6.dist-info/RECORD,,
+sql_athame-0.4.0a8.dist-info/LICENSE,sha256=xqV29vPFqITcKifYrGPgVIBjq4fdmLSwY3gRUtDKafg,1076
+sql_athame-0.4.0a8.dist-info/METADATA,sha256=dXFzs8L8wxnzsjKcL8jj3NyMJPi6l5tIbdZ01ALkzc8,12845
+sql_athame-0.4.0a8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+sql_athame-0.4.0a8.dist-info/RECORD,,