sqlmodel 0.0.40__tar.gz → 0.0.42__tar.gz

{sqlmodel-0.0.40 → sqlmodel-0.0.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmodel
-Version: 0.0.40
+Version: 0.0.42
 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.40 → sqlmodel-0.0.42}/pyproject.toml

@@ -41,7 +41,7 @@ dependencies = [
     "pydantic>=2.11.0",
     "typing-extensions>=4.5.0",
 ]
-version = "0.0.40"
+version = "0.0.42"
 
 [project.urls]
 Homepage = "https://github.com/fastapi/sqlmodel"

{sqlmodel-0.0.40 → sqlmodel-0.0.42}/sqlmodel/__init__.py

@@ -1,4 +1,8 @@
-__version__ = "0.0.40"
+__version__ = "0.0.42"
+
+# Re-export from Pydantic
+from pydantic import Discriminator as Discriminator
+from pydantic import Tag as Tag
 
 # Re-export from SQLAlchemy
 from sqlalchemy.engine import create_engine as create_engine

{sqlmodel-0.0.40 → sqlmodel-0.0.42}/sqlmodel/main.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import builtins
 import ipaddress
 import uuid
+import warnings
 from collections.abc import Callable, Mapping, Sequence, Set
 from dataclasses import dataclass
 from datetime import date, datetime, time, timedelta
@@ -11,6 +12,7 @@ from enum import Enum
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
+    Annotated,
     Any,
     ClassVar,
     Literal,
@@ -22,7 +24,7 @@ from typing import (
     overload,
 )
 
-from pydantic import BaseModel, EmailStr
+from pydantic import BaseModel, Discriminator, EmailStr
 from pydantic.fields import FieldInfo as PydanticFieldInfo
 from sqlalchemy import (
     Boolean,
@@ -89,6 +91,13 @@ IncEx: TypeAlias = (
 )
 OnDeleteType = Literal["CASCADE", "SET NULL", "RESTRICT"]
 
+MIN_ITEMS_DEPRECATION_MSG = (
+    "`min_items` is deprecated and will be removed, use `min_length` instead"
+)
+MAX_ITEMS_DEPRECATION_MSG = (
+    "`max_items` is deprecated and will be removed, use `max_length` instead"
+)
+
 
 def __dataclass_transform__(
     *,
@@ -253,14 +262,20 @@ def Field(
     multiple_of: float | None = None,
     max_digits: int | None = None,
     decimal_places: int | None = None,
-    min_items: int | None = None,
-    max_items: int | None = None,
+    min_items: Annotated[
+        int | None,
+        deprecated(MIN_ITEMS_DEPRECATION_MSG),
+    ] = None,
+    max_items: Annotated[
+        int | None,
+        deprecated(MAX_ITEMS_DEPRECATION_MSG),
+    ] = None,
     unique_items: bool | None = None,
     min_length: int | None = None,
     max_length: int | None = None,
     allow_mutation: bool = True,
     regex: str | None = None,
-    discriminator: str | None = None,
+    discriminator: str | Discriminator | None = None,
     repr: bool = True,
     primary_key: bool | UndefinedType = Undefined,
     foreign_key: Any = Undefined,
@@ -296,14 +311,20 @@ def Field(
     multiple_of: float | None = None,
     max_digits: int | None = None,
     decimal_places: int | None = None,
-    min_items: int | None = None,
-    max_items: int | None = None,
+    min_items: Annotated[
+        int | None,
+        deprecated(MIN_ITEMS_DEPRECATION_MSG),
+    ] = None,
+    max_items: Annotated[
+        int | None,
+        deprecated(MAX_ITEMS_DEPRECATION_MSG),
+    ] = None,
     unique_items: bool | None = None,
     min_length: int | None = None,
     max_length: int | None = None,
     allow_mutation: bool = True,
     regex: str | None = None,
-    discriminator: str | None = None,
+    discriminator: str | Discriminator | None = None,
     repr: bool = True,
     primary_key: bool | UndefinedType = Undefined,
     foreign_key: str,
@@ -348,14 +369,20 @@ def Field(
     multiple_of: float | None = None,
     max_digits: int | None = None,
     decimal_places: int | None = None,
-    min_items: int | None = None,
-    max_items: int | None = None,
+    min_items: Annotated[
+        int | None,
+        deprecated(MIN_ITEMS_DEPRECATION_MSG),
+    ] = None,
+    max_items: Annotated[
+        int | None,
+        deprecated(MAX_ITEMS_DEPRECATION_MSG),
+    ] = None,
     unique_items: bool | None = None,
     min_length: int | None = None,
     max_length: int | None = None,
     allow_mutation: bool = True,
     regex: str | None = None,
-    discriminator: str | None = None,
+    discriminator: str | Discriminator | None = None,
     repr: bool = True,
     sa_column: Column[Any] | UndefinedType = Undefined,
     schema_extra: dict[str, Any] | None = None,
@@ -381,14 +408,20 @@ def Field(
     multiple_of: float | None = None,
     max_digits: int | None = None,
     decimal_places: int | None = None,
-    min_items: int | None = None,
-    max_items: int | None = None,
+    min_items: Annotated[
+        int | None,
+        deprecated(MIN_ITEMS_DEPRECATION_MSG),
+    ] = None,
+    max_items: Annotated[
+        int | None,
+        deprecated(MAX_ITEMS_DEPRECATION_MSG),
+    ] = None,
     unique_items: bool | None = None,
     min_length: int | None = None,
     max_length: int | None = None,
     allow_mutation: bool = True,
     regex: str | None = None,
-    discriminator: str | None = None,
+    discriminator: str | Discriminator | None = None,
     repr: bool = True,
     primary_key: bool | UndefinedType = Undefined,
     foreign_key: Any = Undefined,
@@ -403,6 +436,16 @@ def Field(
     schema_extra: dict[str, Any] | None = None,
 ) -> Any:
     current_schema_extra = schema_extra or {}
+
+    if min_items is not None:
+        warnings.warn(MIN_ITEMS_DEPRECATION_MSG, DeprecationWarning, stacklevel=2)
+        if min_length is None:
+            min_length = min_items
+    if max_items is not None:
+        warnings.warn(MAX_ITEMS_DEPRECATION_MSG, DeprecationWarning, stacklevel=2)
+        if max_length is None:
+            max_length = max_items
+
     # Extract possible alias settings from schema_extra so we can control precedence
     schema_validation_alias = current_schema_extra.pop("validation_alias", None)
     schema_serialization_alias = current_schema_extra.pop("serialization_alias", None)
@@ -420,8 +463,6 @@ def Field(
         "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,

sqlmodel-0.0.42/tests/test_pydantic/test_field.py

@@ -0,0 +1,122 @@
+from decimal import Decimal
+from typing import Annotated, Any, Literal
+
+import pytest
+from pydantic import ValidationError
+from sqlmodel import Discriminator, Field, SQLModel, Tag
+
+
+def test_decimal():
+    class Model(SQLModel):
+        dec: Decimal = Field(max_digits=4, decimal_places=2)
+
+    Model(dec=Decimal("3.14"))
+    Model(dec=Decimal("69.42"))
+
+    with pytest.raises(ValidationError):
+        Model(dec=Decimal("3.142"))
+    with pytest.raises(ValidationError):
+        Model(dec=Decimal("0.069"))
+    with pytest.raises(ValidationError):
+        Model(dec=Decimal("420"))
+
+
+def test_discriminator():
+    # Example adapted from
+    # [Pydantic docs](https://pydantic-docs.helpmanual.io/usage/types/#discriminated-unions-aka-tagged-unions):
+
+    class Cat(SQLModel):
+        pet_type: Literal["cat"]
+        meows: int
+
+    class Dog(SQLModel):
+        pet_type: Literal["dog"]
+        barks: float
+
+    class Lizard(SQLModel):
+        pet_type: Literal["reptile", "lizard"]
+        scales: bool
+
+    class Model(SQLModel):
+        pet: Cat | Dog | Lizard = Field(..., discriminator="pet_type")
+        n: int
+
+    Model(pet={"pet_type": "dog", "barks": 3.14}, n=1)  # type: ignore[arg-type]
+
+    with pytest.raises(ValidationError):
+        Model(pet={"pet_type": "dog"}, n=1)  # type: ignore[arg-type]
+
+
+def test_discriminator_callable():
+    # Example adapted from
+    # [Pydantic docs](https://docs.pydantic.dev/latest/concepts/unions/#discriminated-unions-with-callable-discriminator):
+
+    class Pie(SQLModel):
+        pass
+
+    class ApplePie(Pie):
+        fruit: Literal["apple"] = "apple"
+
+    class PumpkinPie(Pie):
+        filling: Literal["pumpkin"] = "pumpkin"
+
+    def get_discriminator_value(v: Any) -> str:
+        if isinstance(v, dict):
+            return v.get("fruit", v.get("filling"))
+        return getattr(v, "fruit", getattr(v, "filling", None))
+
+    class ThanksgivingDinner(SQLModel):
+        dessert: (
+            Annotated[ApplePie, Tag("apple")] | Annotated[PumpkinPie, Tag("pumpkin")]
+        ) = Field(
+            discriminator=Discriminator(get_discriminator_value),
+        )
+
+    apple_pie = ThanksgivingDinner.model_validate({"dessert": {"fruit": "apple"}})
+    assert isinstance(apple_pie.dessert, ApplePie)
+
+    pumpkin_pie = ThanksgivingDinner.model_validate({"dessert": {"filling": "pumpkin"}})
+    assert isinstance(pumpkin_pie.dessert, PumpkinPie)
+
+
+def test_repr():
+    class Model(SQLModel):
+        id: int | None = Field(primary_key=True)
+        foo: str = Field(repr=False)
+
+    instance = Model(id=123, foo="bar")
+    assert "foo=" not in repr(instance)
+
+
+def test_min_items():
+    with pytest.warns(
+        DeprecationWarning,
+        match="`min_items` is deprecated and will be removed, use `min_length` instead",
+    ):
+
+        class Model(SQLModel):
+            items: list[int] = Field(min_items=2)
+
+    Model(items=[1, 2])
+
+    with pytest.raises(ValidationError) as exc_info:
+        Model(items=[1])
+    assert len(exc_info.value.errors()) == 1
+    assert exc_info.value.errors()[0]["type"] == "too_short"
+
+
+def test_max_items():
+    with pytest.warns(
+        DeprecationWarning,
+        match="`max_items` is deprecated and will be removed, use `max_length` instead",
+    ):
+
+        class Model(SQLModel):
+            items: list[int] = Field(max_items=2)
+
+    Model(items=[1, 2])
+
+    with pytest.raises(ValidationError) as exc_info:
+        Model(items=[1, 2, 3])
+    assert len(exc_info.value.errors()) == 1
+    assert exc_info.value.errors()[0]["type"] == "too_long"

sqlmodel-0.0.40/tests/test_pydantic/test_field.py

@@ -1,56 +0,0 @@
-from decimal import Decimal
-from typing import Literal
-
-import pytest
-from pydantic import ValidationError
-from sqlmodel import Field, SQLModel
-
-
-def test_decimal():
-    class Model(SQLModel):
-        dec: Decimal = Field(max_digits=4, decimal_places=2)
-
-    Model(dec=Decimal("3.14"))
-    Model(dec=Decimal("69.42"))
-
-    with pytest.raises(ValidationError):
-        Model(dec=Decimal("3.142"))
-    with pytest.raises(ValidationError):
-        Model(dec=Decimal("0.069"))
-    with pytest.raises(ValidationError):
-        Model(dec=Decimal("420"))
-
-
-def test_discriminator():
-    # Example adapted from
-    # [Pydantic docs](https://pydantic-docs.helpmanual.io/usage/types/#discriminated-unions-aka-tagged-unions):
-
-    class Cat(SQLModel):
-        pet_type: Literal["cat"]
-        meows: int
-
-    class Dog(SQLModel):
-        pet_type: Literal["dog"]
-        barks: float
-
-    class Lizard(SQLModel):
-        pet_type: Literal["reptile", "lizard"]
-        scales: bool
-
-    class Model(SQLModel):
-        pet: Cat | Dog | Lizard = Field(..., discriminator="pet_type")
-        n: int
-
-    Model(pet={"pet_type": "dog", "barks": 3.14}, n=1)  # type: ignore[arg-type]
-
-    with pytest.raises(ValidationError):
-        Model(pet={"pet_type": "dog"}, n=1)  # type: ignore[arg-type]
-
-
-def test_repr():
-    class Model(SQLModel):
-        id: int | None = Field(primary_key=True)
-        foo: str = Field(repr=False)
-
-    instance = Model(id=123, foo="bar")
-    assert "foo=" not in repr(instance)