Make most tests succeed

Only need to fix OPEN API things I think

Author: AntonDeMeester

pyproject.toml

@@ -46,7 +46,7 @@ pillow = "^9.3.0"
 cairosvg = "^2.5.2"
 mdx-include = "^1.4.1"
 coverage = {extras = ["toml"], version = ">=6.2,<8.0"}
-fastapi = "^0.68.1"
+fastapi = "^0.100.0"
 requests = "^2.26.0"
 ruff = "^0.1.2"
 

sqlmodel/compat.py

@@ -1,3 +1,9 @@
+import ipaddress
+import uuid
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from enum import Enum
+from pathlib import Path
 from types import NoneType
 from typing import (
     TYPE_CHECKING,
@@ -6,26 +12,47 @@
     Dict,
     ForwardRef,
     Optional,
+    Sequence,
     Type,
     TypeVar,
     Union,
+    cast,
     get_args,
     get_origin,
 )
 
 from pydantic import VERSION as PYDANTIC_VERSION
+from sqlalchemy import (
+    Boolean,
+    Column,
+    Date,
+    DateTime,
+    Float,
+    ForeignKey,
+    Integer,
+    Interval,
+    Numeric,
+)
+from sqlalchemy import Enum as sa_Enum
+from sqlalchemy.sql.sqltypes import LargeBinary, Time
+
+from .sql.sqltypes import GUID, AutoString
 
 IS_PYDANTIC_V2 = int(PYDANTIC_VERSION.split(".")[0]) >= 2
 
 
 if IS_PYDANTIC_V2:
     from pydantic import ConfigDict as PydanticModelConfig
+    from pydantic._internal._fields import PydanticMetadata
+    from pydantic._internal._model_construction import ModelMetaclass
     from pydantic_core import PydanticUndefined as PydanticUndefined  # noqa
     from pydantic_core import PydanticUndefinedType as PydanticUndefinedType
 else:
     from pydantic import BaseConfig as PydanticModelConfig
-    from pydantic.fields import ModelField  # noqa
-    from pydantic.fields import Undefined as PydanticUndefined, UndefinedType as PydanticUndefinedType, SHAPE_SINGLETON # noqa
+    from pydantic.fields import SHAPE_SINGLETON, ModelField
+    from pydantic.fields import Undefined as PydanticUndefined  # noqa
+    from pydantic.fields import UndefinedType as PydanticUndefinedType
+    from pydantic.main import ModelMetaclass as ModelMetaclass
     from pydantic.typing import resolve_annotations
 
 if TYPE_CHECKING:
@@ -37,11 +64,13 @@
 InstanceOrType = Union[T, Type[T]]
 
 if IS_PYDANTIC_V2:
+
     class SQLModelConfig(PydanticModelConfig, total=False):
         table: Optional[bool]
         registry: Optional[Any]
 
 else:
+
     class SQLModelConfig(PydanticModelConfig):
         table: Optional[bool] = None
         registry: Optional[Any] = None
@@ -78,14 +107,14 @@ def set_config_value(
 
 def get_model_fields(model: InstanceOrType["SQLModel"]) -> Dict[str, "FieldInfo"]:
     if IS_PYDANTIC_V2:
-        return model.model_fields # type: ignore
+        return model.model_fields  # type: ignore
     else:
         return model.__fields__  # type: ignore
 
 
 def get_fields_set(model: InstanceOrType["SQLModel"]) -> set[str]:
     if IS_PYDANTIC_V2:
-        return model.__pydantic_fields_set__ # type: ignore
+        return model.__pydantic_fields_set__  # type: ignore
     else:
         return model.__fields_set__  # type: ignore
 
@@ -115,21 +144,36 @@ def get_annotations(class_dict: dict[str, Any]) -> dict[str, Any]:
         )
 
 
-def is_table(class_dict: dict[str, Any]) -> bool:
+def class_dict_is_table(
+    class_dict: dict[str, Any], class_kwargs: dict[str, Any]
+) -> bool:
     config: SQLModelConfig = {}
     if IS_PYDANTIC_V2:
         config = class_dict.get("model_config", {})
     else:
         config = class_dict.get("__config__", {})
     config_table = config.get("table", PydanticUndefined)
     if config_table is not PydanticUndefined:
-        return config_table # type: ignore
-    kw_table = class_dict.get("table", PydanticUndefined)
+        return config_table  # type: ignore
+    kw_table = class_kwargs.get("table", PydanticUndefined)
     if kw_table is not PydanticUndefined:
-        return kw_table # type: ignore
+        return kw_table  # type: ignore
     return False
 
 
+def cls_is_table(cls: Type) -> bool:
+    if IS_PYDANTIC_V2:
+        config = getattr(cls, "model_config", None)
+        if not config:
+            return False
+        return config.get("table", False)
+    else:
+        config = getattr(cls, "__config__", None)
+        if not config:
+            return False
+        return getattr(config, "table", False)
+
+
 def get_relationship_to(
     name: str,
     rel_info: "RelationshipInfo",
@@ -186,17 +230,15 @@ def set_empty_defaults(annotations: Dict[str, Any], class_dict: Dict[str, Any])
                     value.default in (PydanticUndefined, Ellipsis)
                 ) and value.default_factory is None:
                     # So we can check for nullable
-                    value.original_default = value.default
                     value.default = None
 
 
-def is_field_noneable(field: "FieldInfo") -> bool:
+def _is_field_noneable(field: "FieldInfo") -> bool:
     if IS_PYDANTIC_V2:
         if getattr(field, "nullable", PydanticUndefined) is not PydanticUndefined:
-            return field.nullable # type: ignore
+            return field.nullable  # type: ignore
         if not field.is_required():
-            default = getattr(field, "original_default", field.default)
-            if default is PydanticUndefined:
+            if field.default is PydanticUndefined:
                 return False
             if field.annotation is None or field.annotation is NoneType:
                 return True
@@ -212,4 +254,163 @@ def is_field_noneable(field: "FieldInfo") -> bool:
             return field.allow_none and (
                 field.shape != SHAPE_SINGLETON or not field.sub_fields
             )
-        return False
+        return field.allow_none
+
+
+def get_sqlalchemy_type(field: Any) -> Any:
+    if IS_PYDANTIC_V2:
+        field_info = field
+    else:
+        field_info = field.field_info
+    sa_type = getattr(field_info, "sa_type", PydanticUndefined)  # noqa: B009
+    if sa_type is not PydanticUndefined:
+        return sa_type
+
+    type_ = get_type_from_field(field)
+    metadata = get_field_metadata(field)
+
+    # Check enums first as an enum can also be a str, needed by Pydantic/FastAPI
+    if issubclass(type_, Enum):
+        return sa_Enum(type_)
+    if issubclass(type_, str):
+        max_length = getattr(metadata, "max_length", None)
+        if max_length:
+            return AutoString(length=max_length)
+        return AutoString
+    if issubclass(type_, float):
+        return Float
+    if issubclass(type_, bool):
+        return Boolean
+    if issubclass(type_, int):
+        return Integer
+    if issubclass(type_, datetime):
+        return DateTime
+    if issubclass(type_, date):
+        return Date
+    if issubclass(type_, timedelta):
+        return Interval
+    if issubclass(type_, time):
+        return Time
+    if issubclass(type_, bytes):
+        return LargeBinary
+    if issubclass(type_, Decimal):
+        return Numeric(
+            precision=getattr(metadata, "max_digits", None),
+            scale=getattr(metadata, "decimal_places", None),
+        )
+    if issubclass(type_, ipaddress.IPv4Address):
+        return AutoString
+    if issubclass(type_, ipaddress.IPv4Network):
+        return AutoString
+    if issubclass(type_, ipaddress.IPv6Address):
+        return AutoString
+    if issubclass(type_, ipaddress.IPv6Network):
+        return AutoString
+    if issubclass(type_, Path):
+        return AutoString
+    if issubclass(type_, uuid.UUID):
+        return GUID
+    raise ValueError(f"{type_} has no matching SQLAlchemy type")
+
+
+def get_type_from_field(field: Any) -> type:
+    if IS_PYDANTIC_V2:
+        type_: type | None = field.annotation
+        # Resolve Optional fields
+        if type_ is None:
+            raise ValueError("Missing field type")
+        origin = get_origin(type_)
+        if origin is None:
+            return type_
+        if origin is Union:
+            bases = get_args(type_)
+            if len(bases) > 2:
+                raise ValueError(
+                    "Cannot have a (non-optional) union as a SQL alchemy field"
+                )
+            # Non optional unions are not allowed
+            if bases[0] is not NoneType and bases[1] is not NoneType:
+                raise ValueError(
+                    "Cannot have a (non-optional) union as a SQL alchemy field"
+                )
+            # Optional unions are allowed
+            return bases[0] if bases[0] is not NoneType else bases[1]
+        return origin
+    else:
+        if isinstance(field.type_, type) and field.shape == SHAPE_SINGLETON:
+            return field.type_
+        raise ValueError(f"The field {field.name} has no matching SQLAlchemy type")
+
+
+class FakeMetadata:
+    max_length: Optional[int] = None
+    max_digits: Optional[int] = None
+    decimal_places: Optional[int] = None
+
+
+def get_field_metadata(field: Any) -> Any:
+    if IS_PYDANTIC_V2:
+        for meta in field.metadata:
+            if isinstance(meta, PydanticMetadata):
+                return meta
+        return FakeMetadata()
+    else:
+        metadata = FakeMetadata()
+        metadata.max_length = field.field_info.max_length
+        metadata.max_digits = getattr(field.type_, "max_digits", None)
+        metadata.decimal_places = getattr(field.type_, "decimal_places", None)
+        return metadata
+
+
+def get_column_from_field(field: Any) -> Column:  # type: ignore
+    if IS_PYDANTIC_V2:
+        field_info = field
+    else:
+        field_info = field.field_info
+    sa_column = getattr(field_info, "sa_column", PydanticUndefined)
+    if isinstance(sa_column, Column):
+        return sa_column
+    sa_type = get_sqlalchemy_type(field)
+    primary_key = getattr(field_info, "primary_key", PydanticUndefined)
+    if primary_key is PydanticUndefined:
+        primary_key = False
+    index = getattr(field_info, "index", PydanticUndefined)
+    if index is PydanticUndefined:
+        index = False
+    nullable = not primary_key and _is_field_noneable(field)
+    # Override derived nullability if the nullable property is set explicitly
+    # on the field
+    field_nullable = getattr(field_info, "nullable", PydanticUndefined)  # noqa: B009
+    if field_nullable is not PydanticUndefined:
+        assert not isinstance(field_nullable, PydanticUndefinedType)
+        nullable = field_nullable
+    args = []
+    foreign_key = getattr(field_info, "foreign_key", PydanticUndefined)
+    if foreign_key is PydanticUndefined:
+        foreign_key = None
+    unique = getattr(field_info, "unique", PydanticUndefined)
+    if unique is PydanticUndefined:
+        unique = False
+    if foreign_key:
+        assert isinstance(foreign_key, str)
+        args.append(ForeignKey(foreign_key))
+    kwargs = {
+        "primary_key": primary_key,
+        "nullable": nullable,
+        "index": index,
+        "unique": unique,
+    }
+    sa_default = PydanticUndefined
+    if field_info.default_factory:
+        sa_default = field_info.default_factory
+    elif field_info.default is not PydanticUndefined:
+        sa_default = field_info.default
+    if sa_default is not PydanticUndefined:
+        kwargs["default"] = sa_default
+    sa_column_args = getattr(field_info, "sa_column_args", PydanticUndefined)
+    if sa_column_args is not PydanticUndefined:
+        args.extend(list(cast(Sequence[Any], sa_column_args)))
+    sa_column_kwargs = getattr(field_info, "sa_column_kwargs", PydanticUndefined)
+    if sa_column_kwargs is not PydanticUndefined:
+        kwargs.update(cast(Dict[Any, Any], sa_column_kwargs))
+    return Column(sa_type, *args, **kwargs)  # type: ignore