➖ Drop support for Python 3.8

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 = "tiangolo@gmail.com" },
 ]
@@ -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 (

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 = "tiangolo@gmail.com" },
 ]
@@ -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 (

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 = "tiangolo@gmail.com" },
 ]
@@ -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 (

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 = "tiangolo@gmail.com" },
 ]
@@ -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 (

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 = "tiangolo@gmail.com" },
 ]
@@ -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 (

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 = "tiangolo@gmail.com" },
 ]
@@ -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 (

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 = "tiangolo@gmail.com" },
 ]
@@ -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 (

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 = "tiangolo@gmail.com" },
 ]
@@ -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 (