sqlmodel 0.0.8__tar.gz → 0.0.10__tar.gz

{sqlmodel-0.0.8 → sqlmodel-0.0.10}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: sqlmodel
-Version: 0.0.8
+Version: 0.0.10
 Summary: SQLModel, SQL databases in Python, designed for simplicity, compatibility, and robustness.
 Home-page: https://github.com/tiangolo/sqlmodel
 License: MIT
 Author: Sebastián Ramírez
 Author-email: tiangolo@gmail.com
-Requires-Python: >=3.6.1,<4.0.0
+Requires-Python: >=3.7,<4.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
@@ -18,19 +18,16 @@ Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: Database
 Classifier: Topic :: Database :: Database Engines/Servers
 Classifier: Topic :: Internet
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Classifier: Typing :: Typed
-Requires-Dist: SQLAlchemy (>=1.4.17,<=1.4.41)
-Requires-Dist: pydantic (>=1.8.2,<2.0.0)
+Requires-Dist: SQLAlchemy (>=1.4.36,<2.0.0)
+Requires-Dist: pydantic (>=1.9.0,<2.0.0)
 Requires-Dist: sqlalchemy2-stubs
 Project-URL: Documentation, https://sqlmodel.tiangolo.com
 Project-URL: Repository, https://github.com/tiangolo/sqlmodel
@@ -49,9 +46,8 @@ Description-Content-Type: text/markdown
 <a href="https://github.com/tiangolo/sqlmodel/actions?query=workflow%3APublish" target="_blank">
     <img src="https://github.com/tiangolo/sqlmodel/workflows/Publish/badge.svg" alt="Publish">
 </a>
-<a href="https://codecov.io/gh/tiangolo/sqlmodel" target="_blank">
-    <img src="https://img.shields.io/codecov/c/github/tiangolo/sqlmodel?color=%2334D058" alt="Coverage">
-</a>
+<a href="https://coverage-badge.samuelcolvin.workers.dev/redirect/tiangolo/sqlmodel" target="_blank">
+    <img src="https://coverage-badge.samuelcolvin.workers.dev/tiangolo/sqlmodel.svg" alt="Coverage">
 <a href="https://pypi.org/project/sqlmodel" target="_blank">
     <img src="https://img.shields.io/pypi/v/sqlmodel?color=%2334D058&label=pypi%20package" alt="Package version">
 </a>
@@ -89,7 +85,7 @@ It combines SQLAlchemy and Pydantic and tries to simplify the code you write as
 
 ## Requirements
 
-A recent and currently supported version of Python (right now, <a href="https://www.python.org/downloads/" class="external-link" target="_blank">Python supports versions 3.6 and above</a>).
+A recent and currently supported <a href="https://www.python.org/downloads/" class="external-link" target="_blank">version of Python</a>.
 
 As **SQLModel** is based on **Pydantic** and **SQLAlchemy**, it requires them. They will be automatically installed when you install SQLModel.
 

{sqlmodel-0.0.8 → sqlmodel-0.0.10}/README.md

@@ -11,9 +11,8 @@
 <a href="https://github.com/tiangolo/sqlmodel/actions?query=workflow%3APublish" target="_blank">
     <img src="https://github.com/tiangolo/sqlmodel/workflows/Publish/badge.svg" alt="Publish">
 </a>
-<a href="https://codecov.io/gh/tiangolo/sqlmodel" target="_blank">
-    <img src="https://img.shields.io/codecov/c/github/tiangolo/sqlmodel?color=%2334D058" alt="Coverage">
-</a>
+<a href="https://coverage-badge.samuelcolvin.workers.dev/redirect/tiangolo/sqlmodel" target="_blank">
+    <img src="https://coverage-badge.samuelcolvin.workers.dev/tiangolo/sqlmodel.svg" alt="Coverage">
 <a href="https://pypi.org/project/sqlmodel" target="_blank">
     <img src="https://img.shields.io/pypi/v/sqlmodel?color=%2334D058&label=pypi%20package" alt="Package version">
 </a>
@@ -51,7 +50,7 @@ It combines SQLAlchemy and Pydantic and tries to simplify the code you write as
 
 ## Requirements
 
-A recent and currently supported version of Python (right now, <a href="https://www.python.org/downloads/" class="external-link" target="_blank">Python supports versions 3.6 and above</a>).
+A recent and currently supported <a href="https://www.python.org/downloads/" class="external-link" target="_blank">version of Python</a>.
 
 As **SQLModel** is based on **Pydantic** and **SQLAlchemy**, it requires them. They will be automatically installed when you install SQLModel.
 

{sqlmodel-0.0.8 → sqlmodel-0.0.10}/pyproject.toml

@@ -17,10 +17,10 @@ classifiers = [
     "Intended Audience :: System Administrators",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.6",
     "Programming Language :: Python :: 3.7",
     "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
     "Topic :: Database",
     "Topic :: Database :: Database Engines/Servers",
     "Topic :: Internet",
@@ -30,26 +30,24 @@ classifiers = [
 ]
 
 [tool.poetry.dependencies]
-python = "^3.6.1"
-SQLAlchemy = ">=1.4.17,<=1.4.41"
-pydantic = "^1.8.2"
+python = "^3.7"
+SQLAlchemy = ">=1.4.36,<2.0.0"
+pydantic = "^1.9.0"
 sqlalchemy2-stubs = {version = "*", allow-prereleases = true}
 
-[tool.poetry.dev-dependencies]
-pytest = "^6.2.4"
-mypy = "0.930"
-flake8 = "^3.9.2"
-black = {version = "^21.5-beta.1", python = "^3.7"}
-mkdocs = "^1.2.1"
-mkdocs-material = "^8.1.4"
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.0.1"
+mypy = "0.971"
+# Needed by the code generator using templates
+black = "^22.10.0"
+mkdocs-material = "9.1.21"
+pillow = "^9.3.0"
+cairosvg = "^2.5.2"
 mdx-include = "^1.4.1"
-coverage = {extras = ["toml"], version = "^5.5"}
+coverage = {extras = ["toml"], version = "^6.2"}
 fastapi = "^0.68.1"
 requests = "^2.26.0"
-autoflake = "^1.4"
-isort = "^5.9.3"
-async_generator = {version = "*", python = "~3.6"}
-async-exit-stack = {version = "*", python = "~3.6"}
+ruff = "^0.1.2"
 
 [build-system]
 requires = ["poetry-core"]
@@ -65,6 +63,7 @@ source = [
     "tests",
     "sqlmodel"
 ]
+context = '${CONTEXT}'
 
 [tool.coverage.report]
 exclude_lines = [
@@ -74,33 +73,36 @@ exclude_lines = [
     "if TYPE_CHECKING:",
 ]
 
-[tool.isort]
-profile = "black"
-known_third_party = ["sqlmodel"]
-skip_glob = [
-    "sqlmodel/__init__.py",
-    ]
-
-
 [tool.mypy]
-# --strict
-disallow_any_generics = true
-disallow_subclassing_any = true 
-disallow_untyped_calls = true 
-disallow_untyped_defs = true
-disallow_incomplete_defs = true 
-check_untyped_defs = true 
-disallow_untyped_decorators = true 
-no_implicit_optional = true
-warn_redundant_casts = true 
-warn_unused_ignores = true
-warn_return_any = true 
-implicit_reexport = false
-strict_equality = true
-# --strict end
+strict = true
 
 [[tool.mypy.overrides]]
 module = "sqlmodel.sql.expression"
 warn_unused_ignores = false
 
-# invalidate CI cache: 1
+[tool.ruff]
+select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "I",  # isort
+    "C",  # flake8-comprehensions
+    "B",  # flake8-bugbear
+    "UP", # pyupgrade
+]
+ignore = [
+    "E501",  # line too long, handled by black
+    "B008",  # do not perform function calls in argument defaults
+    "C901",  # too complex
+    "W191", # indentation contains tabs
+]
+
+[tool.ruff.per-file-ignores]
+# "__init__.py" = ["F401"]
+
+[tool.ruff.isort]
+known-third-party = ["sqlmodel", "sqlalchemy", "pydantic", "fastapi"]
+
+[tool.ruff.pyupgrade]
+# Preserve types, even if a file imports `from __future__ import annotations`.
+keep-runtime-typing = true

{sqlmodel-0.0.8 → sqlmodel-0.0.10}/sqlmodel/__init__.py

@@ -1,16 +1,16 @@
-__version__ = "0.0.8"
+__version__ = "0.0.10"
 
 # Re-export from SQLAlchemy
 from sqlalchemy.engine import create_mock_engine as create_mock_engine
 from sqlalchemy.engine import engine_from_config as engine_from_config
 from sqlalchemy.inspection import inspect as inspect
 from sqlalchemy.schema import BLANK_SCHEMA as BLANK_SCHEMA
+from sqlalchemy.schema import DDL as DDL
 from sqlalchemy.schema import CheckConstraint as CheckConstraint
 from sqlalchemy.schema import Column as Column
 from sqlalchemy.schema import ColumnDefault as ColumnDefault
 from sqlalchemy.schema import Computed as Computed
 from sqlalchemy.schema import Constraint as Constraint
-from sqlalchemy.schema import DDL as DDL
 from sqlalchemy.schema import DefaultClause as DefaultClause
 from sqlalchemy.schema import FetchedValue as FetchedValue
 from sqlalchemy.schema import ForeignKey as ForeignKey
@@ -23,6 +23,14 @@ from sqlalchemy.schema import Sequence as Sequence
 from sqlalchemy.schema import Table as Table
 from sqlalchemy.schema import ThreadLocalMetaData as ThreadLocalMetaData
 from sqlalchemy.schema import UniqueConstraint as UniqueConstraint
+from sqlalchemy.sql import LABEL_STYLE_DEFAULT as LABEL_STYLE_DEFAULT
+from sqlalchemy.sql import (
+    LABEL_STYLE_DISAMBIGUATE_ONLY as LABEL_STYLE_DISAMBIGUATE_ONLY,
+)
+from sqlalchemy.sql import LABEL_STYLE_NONE as LABEL_STYLE_NONE
+from sqlalchemy.sql import (
+    LABEL_STYLE_TABLENAME_PLUS_COL as LABEL_STYLE_TABLENAME_PLUS_COL,
+)
 from sqlalchemy.sql import alias as alias
 from sqlalchemy.sql import all_ as all_
 from sqlalchemy.sql import and_ as and_
@@ -48,14 +56,6 @@ from sqlalchemy.sql import insert as insert
 from sqlalchemy.sql import intersect as intersect
 from sqlalchemy.sql import intersect_all as intersect_all
 from sqlalchemy.sql import join as join
-from sqlalchemy.sql import LABEL_STYLE_DEFAULT as LABEL_STYLE_DEFAULT
-from sqlalchemy.sql import (
-    LABEL_STYLE_DISAMBIGUATE_ONLY as LABEL_STYLE_DISAMBIGUATE_ONLY,
-)
-from sqlalchemy.sql import LABEL_STYLE_NONE as LABEL_STYLE_NONE
-from sqlalchemy.sql import (
-    LABEL_STYLE_TABLENAME_PLUS_COL as LABEL_STYLE_TABLENAME_PLUS_COL,
-)
 from sqlalchemy.sql import lambda_stmt as lambda_stmt
 from sqlalchemy.sql import lateral as lateral
 from sqlalchemy.sql import literal as literal
@@ -85,55 +85,53 @@ from sqlalchemy.sql import values as values
 from sqlalchemy.sql import within_group as within_group
 from sqlalchemy.types import ARRAY as ARRAY
 from sqlalchemy.types import BIGINT as BIGINT
-from sqlalchemy.types import BigInteger as BigInteger
 from sqlalchemy.types import BINARY as BINARY
 from sqlalchemy.types import BLOB as BLOB
 from sqlalchemy.types import BOOLEAN as BOOLEAN
-from sqlalchemy.types import Boolean as Boolean
 from sqlalchemy.types import CHAR as CHAR
 from sqlalchemy.types import CLOB as CLOB
 from sqlalchemy.types import DATE as DATE
-from sqlalchemy.types import Date as Date
 from sqlalchemy.types import DATETIME as DATETIME
-from sqlalchemy.types import DateTime as DateTime
 from sqlalchemy.types import DECIMAL as DECIMAL
-from sqlalchemy.types import Enum as Enum
 from sqlalchemy.types import FLOAT as FLOAT
-from sqlalchemy.types import Float as Float
 from sqlalchemy.types import INT as INT
 from sqlalchemy.types import INTEGER as INTEGER
-from sqlalchemy.types import Integer as Integer
-from sqlalchemy.types import Interval as Interval
 from sqlalchemy.types import JSON as JSON
-from sqlalchemy.types import LargeBinary as LargeBinary
 from sqlalchemy.types import NCHAR as NCHAR
 from sqlalchemy.types import NUMERIC as NUMERIC
-from sqlalchemy.types import Numeric as Numeric
 from sqlalchemy.types import NVARCHAR as NVARCHAR
-from sqlalchemy.types import PickleType as PickleType
 from sqlalchemy.types import REAL as REAL
 from sqlalchemy.types import SMALLINT as SMALLINT
+from sqlalchemy.types import TEXT as TEXT
+from sqlalchemy.types import TIME as TIME
+from sqlalchemy.types import TIMESTAMP as TIMESTAMP
+from sqlalchemy.types import VARBINARY as VARBINARY
+from sqlalchemy.types import VARCHAR as VARCHAR
+from sqlalchemy.types import BigInteger as BigInteger
+from sqlalchemy.types import Boolean as Boolean
+from sqlalchemy.types import Date as Date
+from sqlalchemy.types import DateTime as DateTime
+from sqlalchemy.types import Enum as Enum
+from sqlalchemy.types import Float as Float
+from sqlalchemy.types import Integer as Integer
+from sqlalchemy.types import Interval as Interval
+from sqlalchemy.types import LargeBinary as LargeBinary
+from sqlalchemy.types import Numeric as Numeric
+from sqlalchemy.types import PickleType as PickleType
 from sqlalchemy.types import SmallInteger as SmallInteger
 from sqlalchemy.types import String as String
-from sqlalchemy.types import TEXT as TEXT
 from sqlalchemy.types import Text as Text
-from sqlalchemy.types import TIME as TIME
 from sqlalchemy.types import Time as Time
-from sqlalchemy.types import TIMESTAMP as TIMESTAMP
 from sqlalchemy.types import TypeDecorator as TypeDecorator
 from sqlalchemy.types import Unicode as Unicode
 from sqlalchemy.types import UnicodeText as UnicodeText
-from sqlalchemy.types import VARBINARY as VARBINARY
-from sqlalchemy.types import VARCHAR as VARCHAR
 
-# Extensions and modifications of SQLAlchemy in SQLModel
+# From SQLModel, modifications of SQLAlchemy or equivalents of Pydantic
 from .engine.create import create_engine as create_engine
+from .main import Field as Field
+from .main import Relationship as Relationship
+from .main import SQLModel as SQLModel
 from .orm.session import Session as Session
-from .sql.expression import select as select
 from .sql.expression import col as col
+from .sql.expression import select as select
 from .sql.sqltypes import AutoString as AutoString
-
-# Export SQLModel specifics (equivalent to Pydantic)
-from .main import SQLModel as SQLModel
-from .main import Field as Field
-from .main import Relationship as Relationship

{sqlmodel-0.0.8 → sqlmodel-0.0.10}/sqlmodel/default.py

@@ -6,7 +6,7 @@ class _DefaultPlaceholder:
     You shouldn't use this class directly.
 
     It's used internally to recognize when a default value has been overwritten, even
-    if the overriden default value was truthy.
+    if the overridden default value was truthy.
     """
 
     def __init__(self, value: Any):
@@ -27,6 +27,6 @@ def Default(value: _TDefaultType) -> _TDefaultType:
     You shouldn't use this function directly.
 
     It's used internally to recognize when a default value has been overwritten, even
-    if the overriden default value was truthy.
+    if the overridden default value was truthy.
     """
     return _DefaultPlaceholder(value)  # type: ignore

{sqlmodel-0.0.8 → sqlmodel-0.0.10}/sqlmodel/ext/asyncio/session.py

@@ -1,17 +1,17 @@
-from typing import Any, Mapping, Optional, Sequence, TypeVar, Union
+from typing import Any, Mapping, Optional, Sequence, TypeVar, Union, overload
 
 from sqlalchemy import util
 from sqlalchemy.ext.asyncio import AsyncSession as _AsyncSession
 from sqlalchemy.ext.asyncio import engine
 from sqlalchemy.ext.asyncio.engine import AsyncConnection, AsyncEngine
 from sqlalchemy.util.concurrency import greenlet_spawn
-from sqlmodel.sql.base import Executable
 
-from ...engine.result import ScalarResult
+from ...engine.result import Result, ScalarResult
 from ...orm.session import Session
-from ...sql.expression import Select
+from ...sql.base import Executable
+from ...sql.expression import Select, SelectOfScalar
 
-_T = TypeVar("_T")
+_TSelectParam = TypeVar("_TSelectParam")
 
 
 class AsyncSession(_AsyncSession):
@@ -40,14 +40,46 @@ class AsyncSession(_AsyncSession):
             Session(bind=bind, binds=binds, **kw)  # type: ignore
         )
 
+    @overload
     async def exec(
         self,
-        statement: Union[Select[_T], Executable[_T]],
+        statement: Select[_TSelectParam],
+        *,
+        params: Optional[Union[Mapping[str, Any], Sequence[Mapping[str, Any]]]] = None,
+        execution_options: Mapping[str, Any] = util.EMPTY_DICT,
+        bind_arguments: Optional[Mapping[str, Any]] = None,
+        _parent_execute_state: Optional[Any] = None,
+        _add_event: Optional[Any] = None,
+        **kw: Any,
+    ) -> Result[_TSelectParam]:
+        ...
+
+    @overload
+    async def exec(
+        self,
+        statement: SelectOfScalar[_TSelectParam],
+        *,
+        params: Optional[Union[Mapping[str, Any], Sequence[Mapping[str, Any]]]] = None,
+        execution_options: Mapping[str, Any] = util.EMPTY_DICT,
+        bind_arguments: Optional[Mapping[str, Any]] = None,
+        _parent_execute_state: Optional[Any] = None,
+        _add_event: Optional[Any] = None,
+        **kw: Any,
+    ) -> ScalarResult[_TSelectParam]:
+        ...
+
+    async def exec(
+        self,
+        statement: Union[
+            Select[_TSelectParam],
+            SelectOfScalar[_TSelectParam],
+            Executable[_TSelectParam],
+        ],
         params: Optional[Union[Mapping[str, Any], Sequence[Mapping[str, Any]]]] = None,
         execution_options: Mapping[Any, Any] = util.EMPTY_DICT,
         bind_arguments: Optional[Mapping[str, Any]] = None,
         **kw: Any,
-    ) -> ScalarResult[_T]:
+    ) -> Union[Result[_TSelectParam], ScalarResult[_TSelectParam]]:
         # TODO: the documentation says execution_options accepts a dict, but only
         # util.immutabledict has the union() method. Is this a bug in SQLAlchemy?
         execution_options = execution_options.union({"prebuffer_rows": True})  # type: ignore

{sqlmodel-0.0.8 → sqlmodel-0.0.10}/sqlmodel/main.py

@@ -11,6 +11,7 @@ from typing import (
     Callable,
     ClassVar,
     Dict,
+    ForwardRef,
     List,
     Mapping,
     Optional,
@@ -25,15 +26,24 @@ from typing import (
 
 from pydantic import BaseConfig, BaseModel
 from pydantic.errors import ConfigError, DictError
-from pydantic.fields import SHAPE_SINGLETON
+from pydantic.fields import SHAPE_SINGLETON, ModelField, Undefined, UndefinedType
 from pydantic.fields import FieldInfo as PydanticFieldInfo
-from pydantic.fields import ModelField, Undefined, UndefinedType
 from pydantic.main import ModelMetaclass, validate_model
-from pydantic.typing import ForwardRef, NoArgAnyCallable, resolve_annotations
+from pydantic.typing import NoArgAnyCallable, resolve_annotations
 from pydantic.utils import ROOT_KEY, Representation
-from sqlalchemy import Boolean, Column, Date, DateTime
+from sqlalchemy import (
+    Boolean,
+    Column,
+    Date,
+    DateTime,
+    Float,
+    ForeignKey,
+    Integer,
+    Interval,
+    Numeric,
+    inspect,
+)
 from sqlalchemy import Enum as sa_Enum
-from sqlalchemy import Float, ForeignKey, Integer, Interval, Numeric, inspect
 from sqlalchemy.orm import RelationshipProperty, declared_attr, registry, relationship
 from sqlalchemy.orm.attributes import set_attribute
 from sqlalchemy.orm.decl_api import DeclarativeMeta
@@ -135,12 +145,17 @@ def Field(
     lt: Optional[float] = None,
     le: Optional[float] = None,
     multiple_of: Optional[float] = None,
+    max_digits: Optional[int] = None,
+    decimal_places: Optional[int] = None,
     min_items: Optional[int] = None,
     max_items: Optional[int] = None,
+    unique_items: Optional[bool] = None,
     min_length: Optional[int] = None,
     max_length: Optional[int] = None,
     allow_mutation: bool = True,
     regex: Optional[str] = None,
+    discriminator: Optional[str] = None,
+    repr: bool = True,
     primary_key: bool = False,
     foreign_key: Optional[Any] = None,
     unique: bool = False,
@@ -166,12 +181,17 @@ def Field(
         lt=lt,
         le=le,
         multiple_of=multiple_of,
+        max_digits=max_digits,
+        decimal_places=decimal_places,
         min_items=min_items,
         max_items=max_items,
+        unique_items=unique_items,
         min_length=min_length,
         max_length=max_length,
         allow_mutation=allow_mutation,
         regex=regex,
+        discriminator=discriminator,
+        repr=repr,
         primary_key=primary_key,
         foreign_key=foreign_key,
         unique=unique,
@@ -304,9 +324,9 @@ class SQLModelMetaclass(ModelMetaclass, DeclarativeMeta):
             config_registry = cast(registry, config_registry)
             # If it was passed by kwargs, ensure it's also set in config
             new_cls.__config__.registry = config_table
-            setattr(new_cls, "_sa_registry", config_registry)
-            setattr(new_cls, "metadata", config_registry.metadata)
-            setattr(new_cls, "__abstract__", True)
+            setattr(new_cls, "_sa_registry", config_registry)  # noqa: B010
+            setattr(new_cls, "metadata", config_registry.metadata)  # noqa: B010
+            setattr(new_cls, "__abstract__", True)  # noqa: B010
         return new_cls
 
     # Override SQLAlchemy, allow both SQLAlchemy and plain Pydantic models
@@ -319,19 +339,16 @@ class SQLModelMetaclass(ModelMetaclass, DeclarativeMeta):
         # triggers an error
         base_is_table = False
         for base in bases:
-            config = getattr(base, "__config__")
+            config = getattr(base, "__config__")  # noqa: B009
             if config and getattr(config, "table", False):
                 base_is_table = True
                 break
         if getattr(cls.__config__, "table", False) and not base_is_table:
-            dict_used = dict_.copy()
-            for field_name, field_value in cls.__fields__.items():
-                dict_used[field_name] = get_column_from_field(field_value)
             for rel_name, rel_info in cls.__sqlmodel_relationships__.items():
                 if rel_info.sa_relationship:
                     # There's a SQLAlchemy relationship declared, that takes precedence
                     # over anything else, use that and continue with the next attribute
-                    dict_used[rel_name] = rel_info.sa_relationship
+                    setattr(cls, rel_name, rel_info.sa_relationship)  # Fix #315
                     continue
                 ann = cls.__annotations__[rel_name]
                 temp_field = ModelField.infer(
@@ -349,7 +366,7 @@ class SQLModelMetaclass(ModelMetaclass, DeclarativeMeta):
                     rel_kwargs["back_populates"] = rel_info.back_populates
                 if rel_info.link_model:
                     ins = inspect(rel_info.link_model)
-                    local_table = getattr(ins, "local_table")
+                    local_table = getattr(ins, "local_table")  # noqa: B009
                     if local_table is None:
                         raise RuntimeError(
                             "Couldn't find the secondary table for "
@@ -364,53 +381,57 @@ class SQLModelMetaclass(ModelMetaclass, DeclarativeMeta):
                 rel_value: RelationshipProperty = relationship(  # type: ignore
                     relationship_to, *rel_args, **rel_kwargs
                 )
-                dict_used[rel_name] = rel_value
                 setattr(cls, rel_name, rel_value)  # Fix #315
-            DeclarativeMeta.__init__(cls, classname, bases, dict_used, **kw)
+            # SQLAlchemy no longer uses dict_
+            # Ref: https://github.com/sqlalchemy/sqlalchemy/commit/428ea01f00a9cc7f85e435018565eb6da7af1b77
+            # Tag: 1.4.36
+            DeclarativeMeta.__init__(cls, classname, bases, dict_, **kw)
         else:
             ModelMetaclass.__init__(cls, classname, bases, dict_, **kw)
 
 
-def get_sqlachemy_type(field: ModelField) -> Any:
-    if issubclass(field.type_, str):
-        if field.field_info.max_length:
-            return AutoString(length=field.field_info.max_length)
-        return AutoString
-    if issubclass(field.type_, float):
-        return Float
-    if issubclass(field.type_, bool):
-        return Boolean
-    if issubclass(field.type_, int):
-        return Integer
-    if issubclass(field.type_, datetime):
-        return DateTime
-    if issubclass(field.type_, date):
-        return Date
-    if issubclass(field.type_, timedelta):
-        return Interval
-    if issubclass(field.type_, time):
-        return Time
-    if issubclass(field.type_, Enum):
-        return sa_Enum(field.type_)
-    if issubclass(field.type_, bytes):
-        return LargeBinary
-    if issubclass(field.type_, Decimal):
-        return Numeric(
-            precision=getattr(field.type_, "max_digits", None),
-            scale=getattr(field.type_, "decimal_places", None),
-        )
-    if issubclass(field.type_, ipaddress.IPv4Address):
-        return AutoString
-    if issubclass(field.type_, ipaddress.IPv4Network):
-        return AutoString
-    if issubclass(field.type_, ipaddress.IPv6Address):
-        return AutoString
-    if issubclass(field.type_, ipaddress.IPv6Network):
-        return AutoString
-    if issubclass(field.type_, Path):
-        return AutoString
-    if issubclass(field.type_, uuid.UUID):
-        return GUID
+def get_sqlalchemy_type(field: ModelField) -> Any:
+    if isinstance(field.type_, type) and field.shape == SHAPE_SINGLETON:
+        # Check enums first as an enum can also be a str, needed by Pydantic/FastAPI
+        if issubclass(field.type_, Enum):
+            return sa_Enum(field.type_)
+        if issubclass(field.type_, str):
+            if field.field_info.max_length:
+                return AutoString(length=field.field_info.max_length)
+            return AutoString
+        if issubclass(field.type_, float):
+            return Float
+        if issubclass(field.type_, bool):
+            return Boolean
+        if issubclass(field.type_, int):
+            return Integer
+        if issubclass(field.type_, datetime):
+            return DateTime
+        if issubclass(field.type_, date):
+            return Date
+        if issubclass(field.type_, timedelta):
+            return Interval
+        if issubclass(field.type_, time):
+            return Time
+        if issubclass(field.type_, bytes):
+            return LargeBinary
+        if issubclass(field.type_, Decimal):
+            return Numeric(
+                precision=getattr(field.type_, "max_digits", None),
+                scale=getattr(field.type_, "decimal_places", None),
+            )
+        if issubclass(field.type_, ipaddress.IPv4Address):
+            return AutoString
+        if issubclass(field.type_, ipaddress.IPv4Network):
+            return AutoString
+        if issubclass(field.type_, ipaddress.IPv6Address):
+            return AutoString
+        if issubclass(field.type_, ipaddress.IPv6Network):
+            return AutoString
+        if issubclass(field.type_, Path):
+            return AutoString
+        if issubclass(field.type_, uuid.UUID):
+            return GUID
     raise ValueError(f"The field {field.name} has no matching SQLAlchemy type")
 
 
@@ -418,7 +439,7 @@ 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
-    sa_type = get_sqlachemy_type(field)
+    sa_type = get_sqlalchemy_type(field)
     primary_key = getattr(field.field_info, "primary_key", False)
     index = getattr(field.field_info, "index", Undefined)
     if index is Undefined:
@@ -427,7 +448,7 @@ def get_column_from_field(field: ModelField) -> Column:  # type: ignore
     # Override derived nullability if the nullable property is set explicitly
     # on the field
     if hasattr(field.field_info, "nullable"):
-        field_nullable = getattr(field.field_info, "nullable")
+        field_nullable = getattr(field.field_info, "nullable")  # noqa: B009
         if field_nullable != Undefined:
             nullable = field_nullable
     args = []
@@ -576,7 +597,11 @@ class SQLModel(BaseModel, metaclass=SQLModelMetaclass, registry=default_registry
 
     def __repr_args__(self) -> Sequence[Tuple[Optional[str], Any]]:
         # Don't show SQLAlchemy private attributes
-        return [(k, v) for k, v in self.__dict__.items() if not k.startswith("_sa_")]
+        return [
+            (k, v)
+            for k, v in super().__repr_args__()
+            if not (isinstance(k, str) and k.startswith("_sa_"))
+        ]
 
     # From Pydantic, override to enforce validation with dict
     @classmethod

{sqlmodel-0.0.8 → sqlmodel-0.0.10}/sqlmodel/orm/session.py

@@ -4,11 +4,11 @@ from sqlalchemy import util
 from sqlalchemy.orm import Query as _Query
 from sqlalchemy.orm import Session as _Session
 from sqlalchemy.sql.base import Executable as _Executable
-from sqlmodel.sql.expression import Select, SelectOfScalar
 from typing_extensions import Literal
 
 from ..engine.result import Result, ScalarResult
 from ..sql.base import Executable
+from ..sql.expression import Select, SelectOfScalar
 
 _TSelectParam = TypeVar("_TSelectParam")
 

{sqlmodel-0.0.8 → sqlmodel-0.0.10}/sqlmodel/sql/expression.py

@@ -1,6 +1,5 @@
 # WARNING: do not modify this code, it is generated by expression.py.jinja2
 
-import sys
 from datetime import datetime
 from typing import (
     TYPE_CHECKING,
@@ -12,7 +11,6 @@ from typing import (
     Type,
     TypeVar,
     Union,
-    cast,
     overload,
 )
 from uuid import UUID
@@ -24,36 +22,17 @@ from sqlalchemy.sql.expression import Select as _Select
 
 _TSelect = TypeVar("_TSelect")
 
-# Workaround Generics incompatibility in Python 3.6
-# Ref: https://github.com/python/typing/issues/449#issuecomment-316061322
-if sys.version_info.minor >= 7:
 
-    class Select(_Select, Generic[_TSelect]):
-        inherit_cache = True
+class Select(_Select, Generic[_TSelect]):
+    inherit_cache = True
 
-    # This is not comparable to sqlalchemy.sql.selectable.ScalarSelect, that has a different
-    # purpose. This is the same as a normal SQLAlchemy Select class where there's only one
-    # entity, so the result will be converted to a scalar by default. This way writing
-    # for loops on the results will feel natural.
-    class SelectOfScalar(_Select, Generic[_TSelect]):
-        inherit_cache = True
 
-else:
-    from typing import GenericMeta  # type: ignore
-
-    class GenericSelectMeta(GenericMeta, _Select.__class__):  # type: ignore
-        pass
-
-    class _Py36Select(_Select, Generic[_TSelect], metaclass=GenericSelectMeta):
-        inherit_cache = True
-
-    class _Py36SelectOfScalar(_Select, Generic[_TSelect], metaclass=GenericSelectMeta):
-        inherit_cache = True
-
-    # Cast them for editors to work correctly, from several tricks tried, this works
-    # for both VS Code and PyCharm
-    Select = cast("Select", _Py36Select)  # type: ignore
-    SelectOfScalar = cast("SelectOfScalar", _Py36SelectOfScalar)  # type: ignore
+# This is not comparable to sqlalchemy.sql.selectable.ScalarSelect, that has a different
+# purpose. This is the same as a normal SQLAlchemy Select class where there's only one
+# entity, so the result will be converted to a scalar by default. This way writing
+# for loops on the results will feel natural.
+class SelectOfScalar(_Select, Generic[_TSelect]):
+    inherit_cache = True
 
 
 if TYPE_CHECKING:  # pragma: no cover

{sqlmodel-0.0.8 → sqlmodel-0.0.10}/sqlmodel/sql/sqltypes.py

@@ -8,7 +8,6 @@ from sqlalchemy.sql.type_api import TypeEngine
 
 
 class AutoString(types.TypeDecorator):  # type: ignore
-
     impl = types.String
     cache_ok = True
     mysql_default_length = 255

sqlmodel-0.0.8/setup.py

@@ -1,36 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-packages = \
-['sqlmodel',
- 'sqlmodel.engine',
- 'sqlmodel.ext',
- 'sqlmodel.ext.asyncio',
- 'sqlmodel.orm',
- 'sqlmodel.pool',
- 'sqlmodel.sql']
-
-package_data = \
-{'': ['*']}
-
-install_requires = \
-['SQLAlchemy>=1.4.17,<=1.4.41', 'pydantic>=1.8.2,<2.0.0', 'sqlalchemy2-stubs']
-
-setup_kwargs = {
-    'name': 'sqlmodel',
-    'version': '0.0.8',
-    'description': 'SQLModel, SQL databases in Python, designed for simplicity, compatibility, and robustness.',
-    'long_description': '<p align="center">\n  <a href="https://sqlmodel.tiangolo.com"><img src="https://sqlmodel.tiangolo.com/img/logo-margin/logo-margin-vector.svg" alt="SQLModel"></a>\n</p>\n<p align="center">\n    <em>SQLModel, SQL databases in Python, designed for simplicity, compatibility, and robustness.</em>\n</p>\n<p align="center">\n<a href="https://github.com/tiangolo/sqlmodel/actions?query=workflow%3ATest" target="_blank">\n    <img src="https://github.com/tiangolo/sqlmodel/workflows/Test/badge.svg" alt="Test">\n</a>\n<a href="https://github.com/tiangolo/sqlmodel/actions?query=workflow%3APublish" target="_blank">\n    <img src="https://github.com/tiangolo/sqlmodel/workflows/Publish/badge.svg" alt="Publish">\n</a>\n<a href="https://codecov.io/gh/tiangolo/sqlmodel" target="_blank">\n    <img src="https://img.shields.io/codecov/c/github/tiangolo/sqlmodel?color=%2334D058" alt="Coverage">\n</a>\n<a href="https://pypi.org/project/sqlmodel" target="_blank">\n    <img src="https://img.shields.io/pypi/v/sqlmodel?color=%2334D058&label=pypi%20package" alt="Package version">\n</a>\n</p>\n\n---\n\n**Documentation**: <a href="https://sqlmodel.tiangolo.com" target="_blank">https://sqlmodel.tiangolo.com</a>\n\n**Source Code**: <a href="https://github.com/tiangolo/sqlmodel" target="_blank">https://github.com/tiangolo/sqlmodel</a>\n\n---\n\nSQLModel is a library for interacting with <abbr title=\'Also called "Relational databases"\'>SQL databases</abbr> from Python code, with Python objects. It is designed to be intuitive, easy to use, highly compatible, and robust.\n\n**SQLModel** is based on Python type annotations, and powered by <a href="https://pydantic-docs.helpmanual.io/" class="external-link" target="_blank">Pydantic</a> and <a href="https://sqlalchemy.org/" class="external-link" target="_blank">SQLAlchemy</a>.\n\nThe key features are:\n\n* **Intuitive to write**: Great editor support. <abbr title="also known as auto-complete, autocompletion, IntelliSense">Completion</abbr> everywhere. Less time debugging. Designed to be easy to use and learn. Less time reading docs.\n* **Easy to use**: It has sensible defaults and does a lot of work underneath to simplify the code you write.\n* **Compatible**: It is designed to be compatible with **FastAPI**, Pydantic, and SQLAlchemy.\n* **Extensible**: You have all the power of SQLAlchemy and Pydantic underneath.\n* **Short**: Minimize code duplication. A single type annotation does a lot of work. No need to duplicate models in SQLAlchemy and Pydantic.\n\n## SQL Databases in FastAPI\n\n<a href="https://fastapi.tiangolo.com" target="_blank"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" style="width: 20%;"></a>\n\n**SQLModel** is designed to simplify interacting with SQL databases in <a href="https://fastapi.tiangolo.com" class="external-link" target="_blank">FastAPI</a> applications, it was created by the same <a href="https://tiangolo.com/" class="external-link" target="_blank">author</a>. 😁\n\nIt combines SQLAlchemy and Pydantic and tries to simplify the code you write as much as possible, allowing you to reduce the **code duplication to a minimum**, but while getting the **best developer experience** possible.\n\n**SQLModel** is, in fact, a thin layer on top of **Pydantic** and **SQLAlchemy**, carefully designed to be compatible with both.\n\n## Requirements\n\nA recent and currently supported version of Python (right now, <a href="https://www.python.org/downloads/" class="external-link" target="_blank">Python supports versions 3.6 and above</a>).\n\nAs **SQLModel** is based on **Pydantic** and **SQLAlchemy**, it requires them. They will be automatically installed when you install SQLModel.\n\n## Installation\n\n<div class="termy">\n\n```console\n$ pip install sqlmodel\n---> 100%\nSuccessfully installed sqlmodel\n```\n\n</div>\n\n## Example\n\nFor an introduction to databases, SQL, and everything else, see the <a href="https://sqlmodel.tiangolo.com" target="_blank">SQLModel documentation</a>.\n\nHere\'s a quick example. ✨\n\n### A SQL Table\n\nImagine you have a SQL table called `hero` with:\n\n* `id`\n* `name`\n* `secret_name`\n* `age`\n\nAnd you want it to have this data:\n\n| id | name | secret_name | age |\n-----|------|-------------|------|\n| 1  | Deadpond | Dive Wilson | null |\n| 2  | Spider-Boy | Pedro Parqueador | null |\n| 3  | Rusty-Man | Tommy Sharp | 48 |\n\n### Create a SQLModel Model\n\nThen you could create a **SQLModel** model like this:\n\n```Python\nfrom typing import Optional\n\nfrom sqlmodel import Field, SQLModel\n\n\nclass Hero(SQLModel, table=True):\n    id: Optional[int] = Field(default=None, primary_key=True)\n    name: str\n    secret_name: str\n    age: Optional[int] = None\n```\n\nThat class `Hero` is a **SQLModel** model, the equivalent of a SQL table in Python code.\n\nAnd each of those class attributes is equivalent to each **table column**.\n\n### Create Rows\n\nThen you could **create each row** of the table as an **instance** of the model:\n\n```Python\nhero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")\nhero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")\nhero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)\n```\n\nThis way, you can use conventional Python code with **classes** and **instances** that represent **tables** and **rows**, and that way communicate with the **SQL database**.\n\n### Editor Support\n\nEverything is designed for you to get the best developer experience possible, with the best editor support.\n\nIncluding **autocompletion**:\n\n<img class="shadow" src="https://sqlmodel.tiangolo.com/img/index/autocompletion01.png">\n\nAnd **inline errors**:\n\n<img class="shadow" src="https://sqlmodel.tiangolo.com/img/index/inline-errors01.png">\n\n### Write to the Database\n\nYou can learn a lot more about **SQLModel** by quickly following the **tutorial**, but if you need a taste right now of how to put all that together and save to the database, you can do this:\n\n```Python hl_lines="18  21  23-27"\nfrom typing import Optional\n\nfrom sqlmodel import Field, Session, SQLModel, create_engine\n\n\nclass Hero(SQLModel, table=True):\n    id: Optional[int] = Field(default=None, primary_key=True)\n    name: str\n    secret_name: str\n    age: Optional[int] = None\n\n\nhero_1 = Hero(name="Deadpond", secret_name="Dive Wilson")\nhero_2 = Hero(name="Spider-Boy", secret_name="Pedro Parqueador")\nhero_3 = Hero(name="Rusty-Man", secret_name="Tommy Sharp", age=48)\n\n\nengine = create_engine("sqlite:///database.db")\n\n\nSQLModel.metadata.create_all(engine)\n\nwith Session(engine) as session:\n    session.add(hero_1)\n    session.add(hero_2)\n    session.add(hero_3)\n    session.commit()\n```\n\nThat will save a **SQLite** database with the 3 heroes.\n\n### Select from the Database\n\nThen you could write queries to select from that same database, for example with:\n\n```Python hl_lines="15-18"\nfrom typing import Optional\n\nfrom sqlmodel import Field, Session, SQLModel, create_engine, select\n\n\nclass Hero(SQLModel, table=True):\n    id: Optional[int] = Field(default=None, primary_key=True)\n    name: str\n    secret_name: str\n    age: Optional[int] = None\n\n\nengine = create_engine("sqlite:///database.db")\n\nwith Session(engine) as session:\n    statement = select(Hero).where(Hero.name == "Spider-Boy")\n    hero = session.exec(statement).first()\n    print(hero)\n```\n\n### Editor Support Everywhere\n\n**SQLModel** was carefully designed to give you the best developer experience and editor support, **even after selecting data** from the database:\n\n<img class="shadow" src="https://sqlmodel.tiangolo.com/img/index/autocompletion02.png">\n\n## SQLAlchemy and Pydantic\n\nThat class `Hero` is a **SQLModel** model.\n\nBut at the same time, ✨ it is a **SQLAlchemy** model ✨. So, you can combine it and use it with other SQLAlchemy models, or you could easily migrate applications with SQLAlchemy to **SQLModel**.\n\nAnd at the same time, ✨ it is also a **Pydantic** model ✨. You can use inheritance with it to define all your **data models** while avoiding code duplication. That makes it very easy to use with **FastAPI**.\n\n## License\n\nThis project is licensed under the terms of the [MIT license](https://github.com/tiangolo/sqlmodel/blob/main/LICENSE).\n',
-    'author': 'Sebastián Ramírez',
-    'author_email': 'tiangolo@gmail.com',
-    'maintainer': 'None',
-    'maintainer_email': 'None',
-    'url': 'https://github.com/tiangolo/sqlmodel',
-    'packages': packages,
-    'package_data': package_data,
-    'install_requires': install_requires,
-    'python_requires': '>=3.6.1,<4.0.0',
-}
-
-
-setup(**setup_kwargs)