➖ Drop support for Python 3.8 (#1696)

Author: tiangolo

pdm_build.py

@@ -1,5 +1,5 @@
 import os
-from typing import Any, Dict, List
+from typing import Any
 
 from pdm.backend.hooks import Context
 
@@ -9,30 +9,30 @@
 def pdm_build_initialize(context: Context) -> None:
     metadata = context.config.metadata
     # Get custom config for the current package, from the env var
-    config: Dict[str, Any] = context.config.data["tool"]["tiangolo"][
+    config: dict[str, Any] = context.config.data["tool"]["tiangolo"][
         "_internal-slim-build"
     ]["packages"][TIANGOLO_BUILD_PACKAGE]
-    project_config: Dict[str, Any] = config["project"]
+    project_config: dict[str, Any] = config["project"]
     # Get main optional dependencies, extras
-    optional_dependencies: Dict[str, List[str]] = metadata.get(
+    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: 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
     # Get custom build config for the current package
-    build_config: Dict[str, Any] = (
+    build_config: dict[str, Any] = (
         config.get("tool", {}).get("pdm", {}).get("build", {})
     )
     # Override PDM build config with custom build config for this package
     for key, value in build_config.items():
         context.config.build_config[key] = value
     # Get main dependencies
-    dependencies: List[str] = metadata.get("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, [])

pyproject.toml

@@ -7,7 +7,7 @@ name = "sqlmodel"
 dynamic = ["version"]
 description = "SQLModel, SQL databases in Python, designed for simplicity, compatibility, and robustness."
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 authors = [
     { name = "Sebastián Ramírez", email = "[email protected]" },
 ]
@@ -21,7 +21,6 @@ classifiers = [
     "Intended Audience :: Science/Research",
     "Intended Audience :: System Administrators",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",

scripts/generate_select.py

@@ -1,7 +1,6 @@
 import os
 from itertools import product
 from pathlib import Path
-from typing import List, Tuple
 
 import black
 from jinja2 import Template
@@ -21,15 +20,15 @@ class Arg(BaseModel):
     annotation: str
 
 
-arg_groups: List[Arg] = []
+arg_groups: list[Arg] = []
 
-signatures: List[Tuple[List[Arg], List[str]]] = []
+signatures: list[tuple[list[Arg], list[str]]] = []
 
 for total_args in range(2, number_of_types + 1):
     arg_types_tuples = product(["model", "scalar"], repeat=total_args)
     for arg_type_tuple in arg_types_tuples:
-        args: List[Arg] = []
-        return_types: List[str] = []
+        args: list[Arg] = []
+        return_types: list[str] = []
         for i, arg_type in enumerate(arg_type_tuple):
             if arg_type == "scalar":
                 t_var = f"_TScalar_{i}"

scripts/mkdocs_hooks.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Union
+from typing import Any, Union
 
 from mkdocs.config.defaults import MkDocsConfig
 from mkdocs.structure.files import Files
@@ -7,9 +7,9 @@
 
 
 def generate_renamed_section_items(
-    items: List[Union[Page, Section, Link]], *, config: MkDocsConfig
-) -> List[Union[Page, Section, Link]]:
-    new_items: List[Union[Page, Section, Link]] = []
+    items: list[Union[Page, Section, Link]], *, config: MkDocsConfig
+) -> list[Union[Page, Section, Link]]:
+    new_items: list[Union[Page, Section, Link]] = []
     for item in items:
         if isinstance(item, Section):
             new_title = item.title

sqlmodel/_compat.py

@@ -1,28 +1,24 @@
 import sys
 import types
+from collections.abc import Generator, Mapping, Set
 from contextlib import contextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass
 from typing import (
     TYPE_CHECKING,
-    AbstractSet,
+    Annotated,
     Any,
     Callable,
-    Dict,
     ForwardRef,
-    Generator,
-    Mapping,
     Optional,
-    Set,
-    Type,
     TypeVar,
     Union,
 )
 
 from pydantic import VERSION as P_VERSION
 from pydantic import BaseModel
 from pydantic.fields import FieldInfo
-from typing_extensions import Annotated, get_args, get_origin
+from typing_extensions import get_args, get_origin
 
 # Reassign variable to make it reexported for mypy
 PYDANTIC_VERSION = P_VERSION
@@ -36,7 +32,7 @@
 UnionType = getattr(types, "UnionType", Union)
 NoneType = type(None)
 T = TypeVar("T")
-InstanceOrType = Union[T, Type[T]]
+InstanceOrType = Union[T, type[T]]
 _TSQLModel = TypeVar("_TSQLModel", bound="SQLModel")
 
 
@@ -49,7 +45,7 @@ class FakeMetadata:
 @dataclass
 class ObjectWithUpdateWrapper:
     obj: Any
-    update: Dict[str, Any]
+    update: dict[str, Any]
 
     def __getattribute__(self, __name: str) -> Any:
         update = super().__getattribute__("update")
@@ -103,7 +99,7 @@ def set_config_value(
     ) -> None:
         model.model_config[parameter] = value  # type: ignore[literal-required]
 
-    def get_model_fields(model: InstanceOrType[BaseModel]) -> Dict[str, "FieldInfo"]:
+    def get_model_fields(model: InstanceOrType[BaseModel]) -> dict[str, "FieldInfo"]:
         # TODO: refactor the usage of this function to always pass the class
         # not the instance, and then remove this extra check
         # this is for compatibility with Pydantic v3
@@ -115,16 +111,16 @@ def get_model_fields(model: InstanceOrType[BaseModel]) -> Dict[str, "FieldInfo"]
 
     def get_fields_set(
         object: InstanceOrType["SQLModel"],
-    ) -> Union[Set[str], Callable[[BaseModel], Set[str]]]:
+    ) -> Union[set[str], Callable[[BaseModel], set[str]]]:
         return object.model_fields_set
 
     def init_pydantic_private_attrs(new_object: InstanceOrType["SQLModel"]) -> None:
         object.__setattr__(new_object, "__pydantic_fields_set__", set())
         object.__setattr__(new_object, "__pydantic_extra__", None)
         object.__setattr__(new_object, "__pydantic_private__", None)
 
-    def get_annotations(class_dict: Dict[str, Any]) -> Dict[str, Any]:
-        raw_annotations: Dict[str, Any] = class_dict.get("__annotations__", {})
+    def get_annotations(class_dict: dict[str, Any]) -> dict[str, Any]:
+        raw_annotations: dict[str, Any] = class_dict.get("__annotations__", {})
         if sys.version_info >= (3, 14) and "__annotations__" not in class_dict:
             # See https://github.com/pydantic/pydantic/pull/11991
             from annotationlib import (
@@ -139,7 +135,7 @@ def get_annotations(class_dict: Dict[str, Any]) -> Dict[str, Any]:
                 )
         return raw_annotations
 
-    def is_table_model_class(cls: Type[Any]) -> bool:
+    def is_table_model_class(cls: type[Any]) -> bool:
         config = getattr(cls, "model_config", {})
         if config:
             return config.get("table", False) or False
@@ -243,15 +239,15 @@ def _calculate_keys(
         include: Optional[Mapping[Union[int, str], Any]],
         exclude: Optional[Mapping[Union[int, str], Any]],
         exclude_unset: bool,
-        update: Optional[Dict[str, Any]] = None,
-    ) -> Optional[AbstractSet[str]]:  # pragma: no cover
+        update: Optional[dict[str, Any]] = None,
+    ) -> Optional[Set[str]]:  # pragma: no cover
         return None
 
     def sqlmodel_table_construct(
         *,
         self_instance: _TSQLModel,
-        values: Dict[str, Any],
-        _fields_set: Union[Set[str], None] = None,
+        values: dict[str, Any],
+        _fields_set: Union[set[str], None] = None,
     ) -> _TSQLModel:
         # Copy from Pydantic's BaseModel.construct()
         # Ref: https://github.com/pydantic/pydantic/blob/v2.5.2/pydantic/main.py#L198
@@ -264,8 +260,8 @@ def sqlmodel_table_construct(
         old_dict = self_instance.__dict__.copy()
         # End SQLModel override
 
-        fields_values: Dict[str, Any] = {}
-        defaults: Dict[
+        fields_values: dict[str, Any] = {}
+        defaults: dict[
             str, Any
         ] = {}  # keeping this separate from `fields_values` helps us compute `_fields_set`
         for name, field in cls.model_fields.items():
@@ -279,7 +275,7 @@ def sqlmodel_table_construct(
             _fields_set = set(fields_values.keys())
         fields_values.update(defaults)
 
-        _extra: Union[Dict[str, Any], None] = None
+        _extra: Union[dict[str, Any], None] = None
         if cls.model_config.get("extra") == "allow":
             _extra = {}
             for k, v in values.items():
@@ -315,13 +311,13 @@ def sqlmodel_table_construct(
         return self_instance
 
     def sqlmodel_validate(
-        cls: Type[_TSQLModel],
+        cls: type[_TSQLModel],
         obj: Any,
         *,
         strict: Union[bool, None] = None,
         from_attributes: Union[bool, None] = None,
-        context: Union[Dict[str, Any], None] = None,
-        update: Union[Dict[str, Any], None] = None,
+        context: Union[dict[str, Any], None] = None,
+        update: Union[dict[str, Any], None] = None,
     ) -> _TSQLModel:
         if not is_table_model_class(cls):
             new_obj: _TSQLModel = cls.__new__(cls)
@@ -366,7 +362,7 @@ def sqlmodel_validate(
                     setattr(new_obj, key, value)
         return new_obj
 
-    def sqlmodel_init(*, self: "SQLModel", data: Dict[str, Any]) -> None:
+    def sqlmodel_init(*, self: "SQLModel", data: dict[str, Any]) -> None:
         old_dict = self.__dict__.copy()
         if not is_table_model_class(self.__class__):
             self.__pydantic_validator__.validate_python(
@@ -424,24 +420,24 @@ def set_config_value(
     ) -> None:
         setattr(model.__config__, parameter, value)  # type: ignore
 
-    def get_model_fields(model: InstanceOrType[BaseModel]) -> Dict[str, "FieldInfo"]:
+    def get_model_fields(model: InstanceOrType[BaseModel]) -> dict[str, "FieldInfo"]:
         return model.__fields__  # type: ignore
 
     def get_fields_set(
         object: InstanceOrType["SQLModel"],
-    ) -> Union[Set[str], Callable[[BaseModel], Set[str]]]:
+    ) -> Union[set[str], Callable[[BaseModel], set[str]]]:
         return object.__fields_set__
 
     def init_pydantic_private_attrs(new_object: InstanceOrType["SQLModel"]) -> None:
         object.__setattr__(new_object, "__fields_set__", set())
 
-    def get_annotations(class_dict: Dict[str, Any]) -> Dict[str, Any]:
+    def get_annotations(class_dict: dict[str, Any]) -> dict[str, Any]:
         return resolve_annotations(  # type: ignore[no-any-return]
             class_dict.get("__annotations__", {}),
             class_dict.get("__module__", None),
         )
 
-    def is_table_model_class(cls: Type[Any]) -> bool:
+    def is_table_model_class(cls: type[Any]) -> bool:
         config = getattr(cls, "__config__", None)
         if config:
             return getattr(config, "table", False)
@@ -492,8 +488,8 @@ def _calculate_keys(
         include: Optional[Mapping[Union[int, str], Any]],
         exclude: Optional[Mapping[Union[int, str], Any]],
         exclude_unset: bool,
-        update: Optional[Dict[str, Any]] = None,
-    ) -> Optional[AbstractSet[str]]:
+        update: Optional[dict[str, Any]] = None,
+    ) -> Optional[Set[str]]:
         if include is None and exclude is None and not exclude_unset:
             # Original in Pydantic:
             # return None
@@ -504,7 +500,7 @@ def _calculate_keys(
                 self.__fields__.keys()  # noqa
             )  # | self.__sqlmodel_relationships__.keys()
 
-        keys: AbstractSet[str]
+        keys: Set[str]
         if exclude_unset:
             keys = self.__fields_set__.copy()  # noqa
         else:
@@ -528,13 +524,13 @@ def _calculate_keys(
         return keys
 
     def sqlmodel_validate(
-        cls: Type[_TSQLModel],
+        cls: type[_TSQLModel],
         obj: Any,
         *,
         strict: Union[bool, None] = None,
         from_attributes: Union[bool, None] = None,
-        context: Union[Dict[str, Any], None] = None,
-        update: Union[Dict[str, Any], None] = None,
+        context: Union[dict[str, Any], None] = None,
+        update: Union[dict[str, Any], None] = None,
     ) -> _TSQLModel:
         # This was SQLModel's original from_orm() for Pydantic v1
         # Duplicated from Pydantic
@@ -573,7 +569,7 @@ def sqlmodel_validate(
         m._init_private_attributes()  # type: ignore[attr-defined] # noqa
         return m
 
-    def sqlmodel_init(*, self: "SQLModel", data: Dict[str, Any]) -> None:
+    def sqlmodel_init(*, self: "SQLModel", data: dict[str, Any]) -> None:
         values, fields_set, validation_error = validate_model(self.__class__, data)
         # Only raise errors if not a SQLModel model
         if (