sqlmodel 0.0.31__tar.gz → 0.0.33__tar.gz

{sqlmodel-0.0.31 → sqlmodel-0.0.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmodel
-Version: 0.0.31
+Version: 0.0.33
 Summary: SQLModel, SQL databases in Python, designed for simplicity, compatibility, and robustness.
 Author-Email: =?utf-8?q?Sebasti=C3=A1n_Ram=C3=ADrez?= <tiangolo@gmail.com>
 License-Expression: MIT

{sqlmodel-0.0.31 → sqlmodel-0.0.33}/pdm_build.py

@@ -3,24 +3,23 @@ from typing import Any
 
 from pdm.backend.hooks import Context
 
-TIANGOLO_BUILD_PACKAGE = os.getenv("TIANGOLO_BUILD_PACKAGE", "sqlmodel")
+TIANGOLO_BUILD_PACKAGE = os.getenv("TIANGOLO_BUILD_PACKAGE")
 
 
 def pdm_build_initialize(context: Context) -> None:
     metadata = context.config.metadata
+    # Get main version
+    version = metadata["version"]
     # Get custom config for the current package, from the env var
-    config: dict[str, Any] = context.config.data["tool"]["tiangolo"][
+    all_configs_config: dict[str, Any] = context.config.data["tool"]["tiangolo"][
         "_internal-slim-build"
-    ]["packages"][TIANGOLO_BUILD_PACKAGE]
+    ]["packages"]
+
+    if TIANGOLO_BUILD_PACKAGE not in all_configs_config:
+        return
+
+    config = all_configs_config[TIANGOLO_BUILD_PACKAGE]
     project_config: dict[str, Any] = config["project"]
-    # Get main optional dependencies, extras
-    optional_dependencies: dict[str, list[str]] = metadata.get(
-        "optional-dependencies", {}
-    )
-    # Get custom optional dependencies name to always include in this (non-slim) package
-    include_optional_dependencies: list[str] = config.get(
-        "include-optional-dependencies", []
-    )
     # Override main [project] configs with custom configs for this package
     for key, value in project_config.items():
         metadata[key] = value
@@ -33,7 +32,9 @@ def pdm_build_initialize(context: Context) -> None:
         context.config.build_config[key] = value
     # Get main dependencies
     dependencies: list[str] = metadata.get("dependencies", [])
-    # Add optional dependencies to the default dependencies for this (non-slim) package
-    for include_optional in include_optional_dependencies:
-        optional_dependencies_group = optional_dependencies.get(include_optional, [])
-        dependencies.extend(optional_dependencies_group)
+    # Sync versions in dependencies
+    new_dependencies = []
+    for dep in dependencies:
+        new_dep = f"{dep}>={version}"
+        new_dependencies.append(new_dep)
+    metadata["dependencies"] = new_dependencies

{sqlmodel-0.0.31 → sqlmodel-0.0.33}/pyproject.toml

@@ -41,7 +41,7 @@ dependencies = [
     "SQLAlchemy >=2.0.14,<2.1.0",
     "pydantic>=2.7.0",
 ]
-version = "0.0.31"
+version = "0.0.33"
 
 [project.urls]
 Homepage = "https://github.com/fastapi/sqlmodel"
@@ -50,7 +50,47 @@ Repository = "https://github.com/fastapi/sqlmodel"
 Issues = "https://github.com/fastapi/sqlmodel/issues"
 Changelog = "https://sqlmodel.tiangolo.com/release-notes/"
 
-[project.optional-dependencies]
+[dependency-groups]
+dev = [
+    { include-group = "docs" },
+    { include-group = "tests" },
+    "prek>=0.2.24,<1.0.0",
+]
+docs = [
+    "black>=22.10",
+    "cairosvg==2.8.2",
+    "griffe-typingdoc==0.3.0",
+    "griffe-warnings-deprecated==1.1.0",
+    "markdown-include-variants==0.0.8",
+    "mdx-include>=1.4.1,<2.0.0",
+    "mkdocs-macros-plugin==1.5.0",
+    "mkdocs-material==9.7.1",
+    "mkdocs-redirects>=1.2.1,<1.3.0",
+    "mkdocstrings[python]==0.30.1",
+    "pillow==11.3.0",
+    "pyyaml>=5.3.1,<7.0.0",
+    "typer==0.21.2",
+]
+github-actions = [
+    "httpx>=0.27.0,<0.29.0",
+    "pydantic>=2.5.3,<3.0.0",
+    "pydantic-settings>=2.1.0,<3.0.0",
+    "pygithub>=2.3.0,<3.0.0",
+    "smokeshow>=0.5.0",
+]
+tests = [
+    "black>=22.10",
+    "coverage[toml]>=6.2,<8.0",
+    "dirty-equals==0.11",
+    "fastapi>=0.103.2",
+    "httpx==0.28.1",
+    "jinja2==3.1.6",
+    "mypy==1.19.1",
+    "pre-commit>=2.17.0,<5.0.0",
+    "pytest>=7.0.1,<9.0.0",
+    "ruff==0.15.0",
+    "typing-extensions==4.15.0",
+]
 
 [tool.pdm]
 distribution = true
@@ -63,15 +103,31 @@ path = "sqlmodel/__init__.py"
 source-includes = [
     "tests/",
     "docs_src/",
-    "requirements*.txt",
     "scripts/",
     "sqlmodel/sql/expression.py.jinja2",
 ]
 
 [tool.tiangolo._internal-slim-build.packages.sqlmodel-slim.project]
 name = "sqlmodel-slim"
+readme = "sqlmodel-slim/README.md"
+dependencies = [
+    "sqlmodel",
+]
+
+[tool.tiangolo._internal-slim-build.packages.sqlmodel-slim.project.optional-dependencies]
 
-[tool.tiangolo._internal-slim-build.packages.sqlmodel.project.optional-dependencies]
+[tool.tiangolo._internal-slim-build.packages.sqlmodel-slim.project.scripts]
+
+[tool.tiangolo._internal-slim-build.packages.sqlmodel-slim.tool.pdm.build]
+excludes = [
+    "sqlmodel",
+    "docs_src",
+    "tests",
+    "pdm_build.py",
+]
+source-includes = [
+    "",
+]
 
 [tool.coverage.run]
 parallel = true

{sqlmodel-0.0.31 → sqlmodel-0.0.33}/sqlmodel/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.0.31"
+__version__ = "0.0.33"
 
 # Re-export from SQLAlchemy
 from sqlalchemy.engine import create_engine as create_engine

{sqlmodel-0.0.31 → sqlmodel-0.0.33}/sqlmodel/ext/asyncio/session.py

@@ -116,13 +116,15 @@ class AsyncSession(_AsyncSession):
         For example:
 
         ```Python
-        heroes = await session.execute(select(Hero)).scalars().all()
+        result = await session.execute(select(Hero))
+        heroes = result.scalars().all()
         ```
 
         instead you could use `exec()`:
 
         ```Python
-        heroes = await session.exec(select(Hero)).all()
+        result = await session.exec(select(Hero))
+        heroes = result.all()
         ```
         """
     )
@@ -145,13 +147,15 @@ class AsyncSession(_AsyncSession):
         For example:
 
         ```Python
-        heroes = await session.execute(select(Hero)).scalars().all()
+        result = await session.execute(select(Hero))
+        heroes = result.scalars().all()
         ```
 
         instead you could use `exec()`:
 
         ```Python
-        heroes = await session.exec(select(Hero)).all()
+        result = await session.exec(select(Hero))
+        heroes = result.all()
         ```
         """
         return await super().execute(

{sqlmodel-0.0.31 → sqlmodel-0.0.33}/sqlmodel/main.py

@@ -5,6 +5,7 @@ import ipaddress
 import uuid
 import weakref
 from collections.abc import Mapping, Sequence, Set
+from dataclasses import dataclass
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
 from enum import Enum
@@ -14,6 +15,7 @@ from typing import (
     Any,
     Callable,
     ClassVar,
+    Literal,
     Optional,
     TypeVar,
     Union,
@@ -48,7 +50,7 @@ from sqlalchemy.orm.decl_api import DeclarativeMeta
 from sqlalchemy.orm.instrumentation import is_instrumented
 from sqlalchemy.sql.schema import MetaData
 from sqlalchemy.sql.sqltypes import LargeBinary, Time, Uuid
-from typing_extensions import Literal, TypeAlias, deprecated, get_origin
+from typing_extensions import TypeAlias, deprecated, get_origin
 
 from ._compat import (  # type: ignore[attr-defined]
     PYDANTIC_MINOR_VERSION,
@@ -199,6 +201,38 @@ class RelationshipInfo(Representation):
         self.sa_relationship_kwargs = sa_relationship_kwargs
 
 
+@dataclass
+class FieldInfoMetadata:
+    primary_key: Union[bool, UndefinedType] = Undefined
+    nullable: Union[bool, UndefinedType] = Undefined
+    foreign_key: Any = Undefined
+    ondelete: Union[OnDeleteType, UndefinedType] = Undefined
+    unique: Union[bool, UndefinedType] = Undefined
+    index: Union[bool, UndefinedType] = Undefined
+    sa_type: Union[type[Any], UndefinedType] = Undefined
+    sa_column: Union[Column[Any], UndefinedType] = Undefined
+    sa_column_args: Union[Sequence[Any], UndefinedType] = Undefined
+    sa_column_kwargs: Union[Mapping[str, Any], UndefinedType] = Undefined
+
+
+def _get_sqlmodel_field_metadata(field_info: Any) -> Optional[FieldInfoMetadata]:
+    metadata_items = getattr(field_info, "metadata", None)
+    if metadata_items:
+        for meta in metadata_items:
+            if isinstance(meta, FieldInfoMetadata):
+                return meta
+    return None
+
+
+def _get_sqlmodel_field_value(
+    field_info: Any, attribute: str, default: Any = Undefined
+) -> Any:
+    metadata = _get_sqlmodel_field_metadata(field_info)
+    if metadata is not None and hasattr(metadata, attribute):
+        return getattr(metadata, attribute)
+    return getattr(field_info, attribute, default)
+
+
 # include sa_type, sa_column_args, sa_column_kwargs
 @overload
 def Field(
@@ -422,6 +456,20 @@ def Field(
         default_factory=default_factory,
         **field_info_kwargs,
     )
+    field_metadata = FieldInfoMetadata(
+        primary_key=primary_key,
+        nullable=nullable,
+        foreign_key=foreign_key,
+        ondelete=ondelete,
+        unique=unique,
+        index=index,
+        sa_type=sa_type,
+        sa_column=sa_column,
+        sa_column_args=sa_column_args,
+        sa_column_kwargs=sa_column_kwargs,
+    )
+    if hasattr(field_info, "metadata"):
+        field_info.metadata.append(field_metadata)
     return field_info
 
 
@@ -531,7 +579,9 @@ class SQLModelMetaclass(ModelMetaclass, DeclarativeMeta):
         config_kwargs = {
             key: kwargs[key] for key in kwargs.keys() & allowed_config_kwargs
         }
-        new_cls = super().__new__(cls, name, bases, dict_used, **config_kwargs)
+        new_cls = cast(
+            "SQLModel", super().__new__(cls, name, bases, dict_used, **config_kwargs)
+        )
         new_cls.__annotations__ = {
             **relationship_annotations,
             **pydantic_annotations,
@@ -559,10 +609,10 @@ class SQLModelMetaclass(ModelMetaclass, DeclarativeMeta):
             # This could be done by reading new_cls.model_config['table'] in FastAPI, but
             # that's very specific about SQLModel, so let's have another config that
             # other future tools based on Pydantic can use.
-            new_cls.model_config["read_from_attributes"] = True
+            new_cls.model_config["read_from_attributes"] = True  # type: ignore[typeddict-unknown-key]
             # For compatibility with older versions
             # TODO: remove this in the future
-            new_cls.model_config["read_with_orm_mode"] = True
+            new_cls.model_config["read_with_orm_mode"] = True  # type: ignore[typeddict-unknown-key]
 
         config_registry = get_config("registry")
         if config_registry is not Undefined:
@@ -636,7 +686,7 @@ class SQLModelMetaclass(ModelMetaclass, DeclarativeMeta):
 
 def get_sqlalchemy_type(field: Any) -> Any:
     field_info = field
-    sa_type = getattr(field_info, "sa_type", Undefined)  # noqa: B009
+    sa_type = _get_sqlmodel_field_value(field_info, "sa_type", Undefined)  # noqa: B009
     if sa_type is not Undefined:
         return sa_type
 
@@ -690,39 +740,39 @@ def get_sqlalchemy_type(field: Any) -> Any:
 
 def get_column_from_field(field: Any) -> Column:  # type: ignore
     field_info = field
-    sa_column = getattr(field_info, "sa_column", Undefined)
+    sa_column = _get_sqlmodel_field_value(field_info, "sa_column", Undefined)
     if isinstance(sa_column, Column):
         return sa_column
     sa_type = get_sqlalchemy_type(field)
-    primary_key = getattr(field_info, "primary_key", Undefined)
+    primary_key = _get_sqlmodel_field_value(field_info, "primary_key", Undefined)
     if primary_key is Undefined:
         primary_key = False
-    index = getattr(field_info, "index", Undefined)
+    index = _get_sqlmodel_field_value(field_info, "index", Undefined)
     if index is Undefined:
         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", Undefined)  # noqa: B009
+    field_nullable = _get_sqlmodel_field_value(field_info, "nullable", Undefined)
     if field_nullable is not Undefined:
         assert not isinstance(field_nullable, UndefinedType)
         nullable = field_nullable
     args = []
-    foreign_key = getattr(field_info, "foreign_key", Undefined)
+    foreign_key = _get_sqlmodel_field_value(field_info, "foreign_key", Undefined)
     if foreign_key is Undefined:
         foreign_key = None
-    unique = getattr(field_info, "unique", Undefined)
+    unique = _get_sqlmodel_field_value(field_info, "unique", Undefined)
     if unique is Undefined:
         unique = False
     if foreign_key:
-        if field_info.ondelete == "SET NULL" and not nullable:
+        ondelete_value = _get_sqlmodel_field_value(field_info, "ondelete", Undefined)
+        if ondelete_value is Undefined:
+            ondelete_value = None
+        if ondelete_value == "SET NULL" and not nullable:
             raise RuntimeError('ondelete="SET NULL" requires nullable=True')
         assert isinstance(foreign_key, str)
-        ondelete = getattr(field_info, "ondelete", Undefined)
-        if ondelete is Undefined:
-            ondelete = None
-        assert isinstance(ondelete, (str, type(None)))  # for typing
-        args.append(ForeignKey(foreign_key, ondelete=ondelete))
+        assert isinstance(ondelete_value, (str, type(None)))  # for typing
+        args.append(ForeignKey(foreign_key, ondelete=ondelete_value))
     kwargs = {
         "primary_key": primary_key,
         "nullable": nullable,
@@ -736,13 +786,15 @@ def get_column_from_field(field: Any) -> Column:  # type: ignore
         sa_default = field_info.default
     if sa_default is not Undefined:
         kwargs["default"] = sa_default
-    sa_column_args = getattr(field_info, "sa_column_args", Undefined)
+    sa_column_args = _get_sqlmodel_field_value(field_info, "sa_column_args", Undefined)
     if sa_column_args is not Undefined:
         args.extend(list(cast(Sequence[Any], sa_column_args)))
-    sa_column_kwargs = getattr(field_info, "sa_column_kwargs", Undefined)
+    sa_column_kwargs = _get_sqlmodel_field_value(
+        field_info, "sa_column_kwargs", Undefined
+    )
     if sa_column_kwargs is not Undefined:
         kwargs.update(cast(dict[Any, Any], sa_column_kwargs))
-    return Column(sa_type, *args, **kwargs)  # type: ignore
+    return Column(sa_type, *args, **kwargs)
 
 
 class_registry = weakref.WeakValueDictionary()  # type: ignore

{sqlmodel-0.0.31 → sqlmodel-0.0.33}/sqlmodel/sql/expression.py

@@ -1,6 +1,7 @@
 from collections.abc import Iterable, Mapping, Sequence
 from typing import (
     Any,
+    Literal,
     Optional,
     TypeVar,
     Union,
@@ -34,7 +35,6 @@ from sqlalchemy.sql.elements import (
     UnaryExpression,
 )
 from sqlalchemy.sql.type_api import TypeEngine
-from typing_extensions import Literal
 
 from ._expression_select_cls import Select as Select
 from ._expression_select_cls import SelectOfScalar as SelectOfScalar
@@ -44,7 +44,7 @@ _T = TypeVar("_T")
 
 _TypeEngineArgument = Union[type[TypeEngine[_T]], TypeEngine[_T]]
 
-# Redefine operatos that would only take a column expresion to also take the (virtual)
+# Redefine operators that would only take a column expression to also take the (virtual)
 # types of Pydantic models, e.g. str instead of only Mapped[str].
 
 

{sqlmodel-0.0.31 → sqlmodel-0.0.33}/tests/test_field_sa_column.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Annotated, Optional
 
 import pytest
 from sqlalchemy import Column, Integer, String
@@ -17,6 +17,17 @@ def test_sa_column_takes_precedence() -> None:
     assert isinstance(Item.id.type, String)  # type: ignore
 
 
+def test_sa_column_with_annotated_metadata() -> None:
+    class Item(SQLModel, table=True):
+        id: Annotated[Optional[int], "meta"] = Field(
+            default=None,
+            sa_column=Column(String, primary_key=True, nullable=False),
+        )
+
+    assert Item.id.nullable is False  # type: ignore
+    assert isinstance(Item.id.type, String)  # type: ignore
+
+
 def test_sa_column_no_sa_args() -> None:
     with pytest.raises(RuntimeError):
 

sqlmodel-0.0.33/tests/test_future_annotations.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Annotated, Optional
+
+from sqlmodel import Field, Session, SQLModel, create_engine, select
+
+
+def test_model_with_future_annotations(clear_sqlmodel):
+    class Hero(SQLModel, table=True):
+        id: Annotated[Optional[int], Field(primary_key=True)] = None
+        name: str
+        secret_name: str
+        age: Optional[int] = None
+
+    hero = Hero(name="Deadpond", secret_name="Dive Wilson", age=25)
+
+    engine = create_engine("sqlite://")
+    SQLModel.metadata.create_all(engine)
+
+    with Session(engine) as session:
+        session.add(hero)
+        session.commit()
+        session.refresh(hero)
+
+        assert hero.id is not None
+        assert hero.name == "Deadpond"
+        assert hero.secret_name == "Dive Wilson"
+        assert hero.age == 25
+
+    with Session(engine) as session:
+        heroes = session.exec(select(Hero)).all()
+        assert len(heroes) == 1
+        assert heroes[0].name == "Deadpond"
+
+
+def test_model_with_string_annotations(clear_sqlmodel):
+    class Team(SQLModel, table=True):
+        id: Annotated[Optional[int], Field(primary_key=True)] = None
+        name: str
+
+    class Player(SQLModel, table=True):
+        id: Annotated[Optional[int], Field(primary_key=True)] = None
+        name: str
+        team_id: Annotated[Optional[int], Field(foreign_key="team.id")] = None
+
+    engine = create_engine("sqlite://")
+    SQLModel.metadata.create_all(engine)
+
+    team = Team(name="Champions")
+    player = Player(name="Alice", team_id=None)
+
+    with Session(engine) as session:
+        session.add(team)
+        session.commit()
+        session.refresh(team)
+
+        player.team_id = team.id
+        session.add(player)
+        session.commit()
+        session.refresh(player)
+
+        assert team.id is not None
+        assert player.team_id == team.id

{sqlmodel-0.0.31 → sqlmodel-0.0.33}/tests/test_main.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Annotated, Optional
 
 import pytest
 from sqlalchemy.exc import IntegrityError
@@ -125,3 +125,94 @@ def test_sa_relationship_property(clear_sqlmodel):
         # The next statement should not raise an AttributeError
         assert hero_rusty_man.team
         assert hero_rusty_man.team.name == "Preventers"
+
+
+def test_composite_primary_key(clear_sqlmodel):
+    class UserPermission(SQLModel, table=True):
+        user_id: int = Field(primary_key=True)
+        resource_id: int = Field(primary_key=True)
+        permission: str
+
+    engine = create_engine("sqlite://")
+    SQLModel.metadata.create_all(engine)
+
+    pk_column_names = {column.name for column in UserPermission.__table__.primary_key}
+    assert pk_column_names == {"user_id", "resource_id"}
+
+    with Session(engine) as session:
+        perm1 = UserPermission(user_id=1, resource_id=1, permission="read")
+        perm2 = UserPermission(user_id=1, resource_id=2, permission="write")
+        session.add(perm1)
+        session.add(perm2)
+        session.commit()
+
+    with pytest.raises(IntegrityError):
+        with Session(engine) as session:
+            perm3 = UserPermission(user_id=1, resource_id=1, permission="admin")
+            session.add(perm3)
+            session.commit()
+
+
+def test_composite_primary_key_and_validator(clear_sqlmodel):
+    from pydantic import AfterValidator
+
+    def validate_resource_id(value: int) -> int:
+        if value < 1:
+            raise ValueError("Resource ID must be positive")
+        return value
+
+    class UserPermission(SQLModel, table=True):
+        user_id: int = Field(primary_key=True)
+        resource_id: Annotated[int, AfterValidator(validate_resource_id)] = Field(
+            primary_key=True
+        )
+        permission: str
+
+    engine = create_engine("sqlite://")
+    SQLModel.metadata.create_all(engine)
+
+    pk_column_names = {column.name for column in UserPermission.__table__.primary_key}
+    assert pk_column_names == {"user_id", "resource_id"}
+
+    with Session(engine) as session:
+        perm1 = UserPermission(user_id=1, resource_id=1, permission="read")
+        perm2 = UserPermission(user_id=1, resource_id=2, permission="write")
+        session.add(perm1)
+        session.add(perm2)
+        session.commit()
+
+    with pytest.raises(IntegrityError):
+        with Session(engine) as session:
+            perm3 = UserPermission(user_id=1, resource_id=1, permission="admin")
+            session.add(perm3)
+            session.commit()
+
+
+def test_foreign_key_ondelete_with_annotated(clear_sqlmodel):
+    from pydantic import AfterValidator
+
+    def ensure_positive(value: int) -> int:
+        if value < 0:
+            raise ValueError("Team ID must be positive")
+        return value
+
+    class Team(SQLModel, table=True):
+        id: int = Field(primary_key=True)
+        name: str
+
+    class Hero(SQLModel, table=True):
+        id: int = Field(primary_key=True)
+        team_id: Annotated[int, AfterValidator(ensure_positive)] = Field(
+            foreign_key="team.id",
+            ondelete="CASCADE",
+        )
+        name: str
+
+    engine = create_engine("sqlite://")
+    SQLModel.metadata.create_all(engine)
+
+    team_id_column = Hero.__table__.c.team_id  # type: ignore[attr-defined]
+    foreign_keys = list(team_id_column.foreign_keys)
+    assert len(foreign_keys) == 1
+    assert foreign_keys[0].ondelete == "CASCADE"
+    assert team_id_column.nullable is False

{sqlmodel-0.0.31 → sqlmodel-0.0.33}/tests/test_pydantic/test_field.py

@@ -1,10 +1,9 @@
 from decimal import Decimal
-from typing import Optional, Union
+from typing import Literal, Optional, Union
 
 import pytest
 from pydantic import ValidationError
 from sqlmodel import Field, SQLModel
-from typing_extensions import Literal
 
 
 def test_decimal():