*,
back_populates: Optional[str] = None,
link_model: Optional[Any] = None,
- sa_relationship: Optional[RelationshipProperty] = None,
+ sa_relationship: Optional[RelationshipProperty] = None, # type: ignore
sa_relationship_args: Optional[Sequence[Any]] = None,
sa_relationship_kwargs: Optional[Mapping[str, Any]] = None,
) -> None:
default: Any = Undefined,
*,
default_factory: Optional[NoArgAnyCallable] = None,
- alias: str = None,
- title: str = None,
- description: str = None,
+ alias: Optional[str] = None,
+ title: Optional[str] = None,
+ description: Optional[str] = None,
exclude: Union[
AbstractSet[Union[int, str]], Mapping[Union[int, str], Any], Any
] = None,
include: Union[
AbstractSet[Union[int, str]], Mapping[Union[int, str], Any], Any
] = None,
- const: bool = None,
- gt: float = None,
- ge: float = None,
- lt: float = None,
- le: float = None,
- multiple_of: float = None,
- min_items: int = None,
- max_items: int = None,
- min_length: int = None,
- max_length: int = None,
+ const: Optional[bool] = None,
+ gt: Optional[float] = None,
+ ge: Optional[float] = None,
+ lt: Optional[float] = None,
+ le: Optional[float] = None,
+ multiple_of: Optional[float] = None,
+ min_items: Optional[int] = None,
+ max_items: Optional[int] = None,
+ min_length: Optional[int] = None,
+ max_length: Optional[int] = None,
allow_mutation: bool = True,
- regex: str = None,
+ regex: Optional[str] = None,
primary_key: bool = False,
foreign_key: Optional[Any] = None,
nullable: Union[bool, UndefinedType] = Undefined,
index: Union[bool, UndefinedType] = Undefined,
- sa_column: Union[Column, UndefinedType] = Undefined,
+ sa_column: Union[Column, UndefinedType] = Undefined, # type: ignore
sa_column_args: Union[Sequence[Any], UndefinedType] = Undefined,
sa_column_kwargs: Union[Mapping[str, Any], UndefinedType] = Undefined,
schema_extra: Optional[Dict[str, Any]] = None,
*,
back_populates: Optional[str] = None,
link_model: Optional[Any] = None,
- sa_relationship: Optional[RelationshipProperty] = None,
+ sa_relationship: Optional[RelationshipProperty] = None, # type: ignore
sa_relationship_args: Optional[Sequence[Any]] = None,
sa_relationship_kwargs: Optional[Mapping[str, Any]] = None,
) -> Any:
# Replicate SQLAlchemy
def __setattr__(cls, name: str, value: Any) -> None:
- if getattr(cls.__config__, "table", False): # type: ignore
+ if getattr(cls.__config__, "table", False):
DeclarativeMeta.__setattr__(cls, name, value)
else:
super().__setattr__(name, value)
def __delattr__(cls, name: str) -> None:
- if getattr(cls.__config__, "table", False): # type: ignore
+ if getattr(cls.__config__, "table", False):
DeclarativeMeta.__delattr__(cls, name)
else:
super().__delattr__(name)
# From Pydantic
- def __new__(cls, name, bases, class_dict: dict, **kwargs) -> Any:
+ def __new__(
+ cls,
+ name: str,
+ bases: Tuple[Type[Any], ...],
+ class_dict: Dict[str, Any],
+ **kwargs: Any,
+ ) -> Any:
relationships: Dict[str, RelationshipInfo] = {}
dict_for_pydantic = {}
original_annotations = resolve_annotations(
)
relationship_to = temp_field.type_
if isinstance(temp_field.type_, ForwardRef):
- relationship_to = temp_field.type_.__forward_arg__ # type: ignore
+ relationship_to = temp_field.type_.__forward_arg__
rel_kwargs: Dict[str, Any] = {}
if rel_info.back_populates:
rel_kwargs["back_populates"] = rel_info.back_populates
rel_args.extend(rel_info.sa_relationship_args)
if rel_info.sa_relationship_kwargs:
rel_kwargs.update(rel_info.sa_relationship_kwargs)
- rel_value: RelationshipProperty = relationship(
+ rel_value: RelationshipProperty = relationship( # type: ignore
relationship_to, *rel_args, **rel_kwargs
)
dict_used[rel_name] = rel_value
return GUID
-def get_column_from_field(field: ModelField) -> Column:
+def get_column_from_field(field: ModelField) -> Column: # type: ignore
sa_column = getattr(field.field_info, "sa_column", Undefined)
if isinstance(sa_column, Column):
return sa_column
kwargs["default"] = sa_default
sa_column_args = getattr(field.field_info, "sa_column_args", Undefined)
if sa_column_args is not Undefined:
- args.extend(list(cast(Sequence, sa_column_args)))
+ args.extend(list(cast(Sequence[Any], sa_column_args)))
sa_column_kwargs = getattr(field.field_info, "sa_column_kwargs", Undefined)
if sa_column_kwargs is not Undefined:
- kwargs.update(cast(dict, sa_column_kwargs))
+ kwargs.update(cast(Dict[Any, Any], sa_column_kwargs))
return Column(sa_type, *args, **kwargs)
default_registry = registry()
-def _value_items_is_true(v) -> bool:
+def _value_items_is_true(v: Any) -> bool:
# Re-implement Pydantic's ValueItems.is_true() as it hasn't been released as of
# the current latest, Pydantic 1.8.2
return v is True or v is ...
+_TSQLModel = TypeVar("_TSQLModel", bound="SQLModel")
+
+
class SQLModel(BaseModel, metaclass=SQLModelMetaclass, registry=default_registry):
# SQLAlchemy needs to set weakref(s), Pydantic will set the other slots values
__slots__ = ("__weakref__",)
__tablename__: ClassVar[Union[str, Callable[..., str]]]
- __sqlmodel_relationships__: ClassVar[Dict[str, RelationshipProperty]]
+ __sqlmodel_relationships__: ClassVar[Dict[str, RelationshipProperty]] # type: ignore
__name__: ClassVar[str]
metadata: ClassVar[MetaData]
class Config:
orm_mode = True
- def __new__(cls, *args, **kwargs) -> Any:
+ def __new__(cls, *args: Any, **kwargs: Any) -> Any:
new_object = super().__new__(cls)
# SQLAlchemy doesn't call __init__ on the base class
# Ref: https://docs.sqlalchemy.org/en/14/orm/constructors.html
super().__setattr__(name, value)
@classmethod
- def from_orm(cls: Type["SQLModel"], obj: Any, update: Dict[str, Any] = None):
+ def from_orm(
+ cls: Type[_TSQLModel], obj: Any, update: Optional[Dict[str, Any]] = None
+ ) -> _TSQLModel:
# Duplicated from Pydantic
if not cls.__config__.orm_mode:
raise ConfigError(
# End SQLModel support dict
if not getattr(cls.__config__, "table", False):
# If not table, normal Pydantic code
- m = cls.__new__(cls)
+ m: _TSQLModel = cls.__new__(cls)
else:
# If table, create the new instance normally to make SQLAlchemy create
# the _sa_instance_state attribute
@classmethod
def parse_obj(
- cls: Type["SQLModel"], obj: Any, update: Dict[str, Any] = None
+ cls: Type["SQLModel"], obj: Any, update: Optional[Dict[str, Any]] = None
) -> "SQLModel":
obj = cls._enforce_dict_if_root(obj)
# SQLModel, support update dict
class GenericSelectMeta(GenericMeta, _Select.__class__): # type: ignore
pass
- class _Py36Select(_Select, Generic[_TSelect], metaclass=GenericSelectMeta): # type: ignore
+ class _Py36Select(_Select, Generic[_TSelect], metaclass=GenericSelectMeta):
pass
- class _Py36SelectOfScalar(_Select, Generic[_TSelect], metaclass=GenericSelectMeta): # type: ignore
+ class _Py36SelectOfScalar(_Select, Generic[_TSelect], metaclass=GenericSelectMeta):
pass
# Cast them for editors to work correctly, from several tricks tried, this works
_TScalar_0 = TypeVar(
"_TScalar_0",
- Column,
- Sequence,
- Mapping,
+ Column, # type: ignore
+ Sequence, # type: ignore
+ Mapping, # type: ignore
UUID,
datetime,
float,
_TScalar_1 = TypeVar(
"_TScalar_1",
- Column,
- Sequence,
- Mapping,
+ Column, # type: ignore
+ Sequence, # type: ignore
+ Mapping, # type: ignore
UUID,
datetime,
float,
_TScalar_2 = TypeVar(
"_TScalar_2",
- Column,
- Sequence,
- Mapping,
+ Column, # type: ignore
+ Sequence, # type: ignore
+ Mapping, # type: ignore
UUID,
datetime,
float,
_TScalar_3 = TypeVar(
"_TScalar_3",
- Column,
- Sequence,
- Mapping,
+ Column, # type: ignore
+ Sequence, # type: ignore
+ Mapping, # type: ignore
UUID,
datetime,
float,
# Generated overloads end
-def select(*entities: Any, **kw: Any) -> Union[Select, SelectOfScalar]:
+def select(*entities: Any, **kw: Any) -> Union[Select, SelectOfScalar]: # type: ignore
if len(entities) == 1:
return SelectOfScalar._create(*entities, **kw) # type: ignore
return Select._create(*entities, **kw) # type: ignore
# TODO: add several @overload from Python types to SQLAlchemy equivalents
-def col(column_expression: Any) -> ColumnClause:
+def col(column_expression: Any) -> ColumnClause: # type: ignore
if not isinstance(column_expression, (ColumnClause, Column, InstrumentedAttribute)):
raise RuntimeError(f"Not a SQLAlchemy column: {column_expression}")
return column_expression
import uuid
-from typing import Any, cast
+from typing import Any, Optional, cast
from sqlalchemy import types
from sqlalchemy.dialects.postgresql import UUID
from sqlalchemy.engine.interfaces import Dialect
+from sqlalchemy.sql.type_api import TypeEngine
from sqlalchemy.types import CHAR, TypeDecorator
-class AutoString(types.TypeDecorator):
+class AutoString(types.TypeDecorator): # type: ignore
impl = types.String
cache_ok = True
# Reference form SQLAlchemy docs: https://docs.sqlalchemy.org/en/14/core/custom_types.html#backend-agnostic-guid-type
# with small modifications
-class GUID(TypeDecorator):
+class GUID(TypeDecorator): # type: ignore
"""Platform-independent GUID type.
Uses PostgreSQL's UUID type, otherwise uses
impl = CHAR
cache_ok = True
- def load_dialect_impl(self, dialect):
+ def load_dialect_impl(self, dialect: Dialect) -> TypeEngine: # type: ignore
if dialect.name == "postgresql":
- return dialect.type_descriptor(UUID())
+ return dialect.type_descriptor(UUID()) # type: ignore
else:
- return dialect.type_descriptor(CHAR(32))
+ return dialect.type_descriptor(CHAR(32)) # type: ignore
- def process_bind_param(self, value, dialect):
+ def process_bind_param(self, value: Any, dialect: Dialect) -> Optional[str]:
if value is None:
return value
elif dialect.name == "postgresql":
# hexstring
return f"{value.int:x}"
- def process_result_value(self, value, dialect):
+ def process_result_value(self, value: Any, dialect: Dialect) -> Optional[uuid.UUID]:
if value is None:
return value
else:
if not isinstance(value, uuid.UUID):
value = uuid.UUID(value)
- return value
+ return cast(uuid.UUID, value)
projects / thirdparty / fastapi / sqlmodel.git / commitdiff
