pyupgrade: 3.9

Signed-off-by: Guillaume Andreu Sabater <[email protected]>

Author: g-as

.pre-commit-config.yaml

@@ -41,7 +41,7 @@ repos:
     rev: v3.19.1
     hooks:
       - id: pyupgrade
-        args: [--py38-plus, --keep-runtime-typing]
+        args: [--py39-plus, --keep-runtime-typing]
 
   - repo: https://github.com/pycqa/pylint
     rev: v3.2.7

docs/source/dataframe_models.md

@@ -339,10 +339,8 @@ to python 3.6.
 ✅ Good:
 
 ```{code-cell} python
-try:
-    from typing import Annotated  # python 3.9+
-except ImportError:
-    from typing_extensions import Annotated
+from typing import Annotated
+
 
 class Schema(pa.DataFrameModel):
     col: Series[Annotated[pd.DatetimeTZDtype, "ns", "est"]]

docs/source/dtype_validation.md

@@ -112,10 +112,8 @@ express this same type with the class-based API, we need to use an
 {py:class}`~typing.Annotated` type:
 
 ```{code-cell} python
-try:
-    from typing import Annotated  # python 3.9+
-except ImportError:
-    from typing_extensions import Annotated
+from typing import Annotated
+
 
 class DateTimeModel(pa.DataFrameModel):
     dt: Series[Annotated[pd.DatetimeTZDtype, "ns", "UTC"]]
@@ -266,10 +264,7 @@ And when using class-based API, you must specify actual types (string aliases
 are not supported):
 
 ```{code-cell} python
-try:
-    from typing import Annotated  # python 3.9+
-except ImportError:
-    from typing_extensions import Annotated
+from typing import Annotated
 
 
 class PyarrowModel(pa.DataFrameModel):

docs/source/polars.md

@@ -484,10 +484,8 @@ schema = pa.DataFrameSchema(
 :::{tab-item} DataFrameModel (Annotated)
 
 ```{testcode} polars
-try:
-    from typing import Annotated  # python 3.9+
-except ImportError:
-    from typing_extensions import Annotated
+from typing import Annotated
+
 
 class ModelWithAnnotated(pa.DataFrameModel):
     list_col: Annotated[pl.List, pl.Int64()]

noxfile.py

@@ -10,7 +10,6 @@
 import shutil
 import sys
 import tempfile
-from typing import Dict, List
 
 try:
     import tomllib
@@ -116,7 +115,7 @@ def _build_requires() -> Dict[str, Dict[str, str]]:
     return requires
 
 
-REQUIRES: Dict[str, Dict[str, str]] = _build_requires()
+REQUIRES: dict[str, dict[str, str]] = _build_requires()
 
 CONDA_ARGS = [
     "--channel=conda-forge",

pandera/api/base/checks.py

@@ -5,16 +5,13 @@
 from typing import (
     Any,
     Callable,
-    Dict,
-    Iterable,
     NamedTuple,
     Optional,
-    Tuple,
-    Type,
     TypeVar,
     Union,
     no_type_check,
 )
+from collections.abc import Iterable
 
 import pandas as pd
 from pandera.api.function_dispatch import Dispatcher
@@ -36,8 +33,8 @@ class CheckResult(NamedTuple):
     pd.core.groupby.generic.DataFrameGroupBy,
 ]
 
-SeriesCheckObj = Union[pd.Series, Dict[str, pd.Series]]
-DataFrameCheckObj = Union[pd.DataFrame, Dict[str, pd.DataFrame]]
+SeriesCheckObj = Union[pd.Series, dict[str, pd.Series]]
+DataFrameCheckObj = Union[pd.DataFrame, dict[str, pd.DataFrame]]
 
 
 _T = TypeVar("_T", bound="BaseCheck")
@@ -46,15 +43,15 @@ class CheckResult(NamedTuple):
 class MetaCheck(type):  # pragma: no cover
     """Check metaclass."""
 
-    BACKEND_REGISTRY: Dict[Tuple[Type, Type], Type[BaseCheckBackend]] = (
+    BACKEND_REGISTRY: dict[tuple[type, type], type[BaseCheckBackend]] = (
         {}
     )  # noqa
     """Registry of check backends implemented for specific data objects."""
 
-    CHECK_FUNCTION_REGISTRY: Dict[str, Dispatcher] = {}  # noqa
+    CHECK_FUNCTION_REGISTRY: dict[str, Dispatcher] = {}  # noqa
     """Built-in check function registry."""
 
-    REGISTERED_CUSTOM_CHECKS: Dict[str, Callable] = {}  # noqa
+    REGISTERED_CUSTOM_CHECKS: dict[str, Callable] = {}  # noqa
     """User-defined custom checks."""
 
     def __getattr__(cls, name: str) -> Any:
@@ -85,7 +82,7 @@ def __dir__(cls) -> Iterable[str]:
     # see https://mypy.readthedocs.io/en/stable/metaclasses.html#gotchas-and-limitations-of-metaclass-support
     # pylint: enable=line-too-long
     @no_type_check
-    def __contains__(cls: Type[_T], item: Union[_T, str]) -> bool:
+    def __contains__(cls: type[_T], item: Union[_T, str]) -> bool:
         """Allow lookups for registered checks."""
         if isinstance(item, cls):
             name = item.name
@@ -102,7 +99,7 @@ def __init__(
         self,
         name: Optional[str] = None,
         error: Optional[str] = None,
-        statistics: Optional[Dict[str, Any]] = None,
+        statistics: Optional[dict[str, Any]] = None,
     ):
         self.name = name
         self.error = error
@@ -136,7 +133,7 @@ def from_builtin_check_name(
         name: str,
         init_kwargs,
         error: Union[str, Callable],
-        statistics: Optional[Dict[str, Any]] = None,
+        statistics: Optional[dict[str, Any]] = None,
         **check_kwargs,
     ):
         """Create a Check object from a built-in check's name."""
@@ -156,13 +153,13 @@ def from_builtin_check_name(
         )
 
     @classmethod
-    def register_backend(cls, type_: Type, backend: Type[BaseCheckBackend]):
+    def register_backend(cls, type_: type, backend: type[BaseCheckBackend]):
         """Register a backend for the specified type."""
         if (cls, type_) not in cls.BACKEND_REGISTRY:
             cls.BACKEND_REGISTRY[(cls, type_)] = backend
 
     @classmethod
-    def get_backend(cls, check_obj: Any) -> Type[BaseCheckBackend]:
+    def get_backend(cls, check_obj: Any) -> type[BaseCheckBackend]:
         """Get the backend associated with the type of ``check_obj`` ."""
 
         check_obj_cls = type(check_obj)

pandera/api/base/error_handler.py

@@ -2,7 +2,7 @@
 
 from collections import defaultdict
 from enum import Enum
-from typing import Any, Dict, List, Union
+from typing import Any, Union
 
 from pandera.api.checks import Check
 from pandera.config import ValidationDepth, get_config_context
@@ -28,8 +28,8 @@ def __init__(self, lazy: bool = True) -> None:
         Defaults to True.
         """
         self._lazy = lazy
-        self._collected_errors: List[Dict[str, Any]] = []
-        self._schema_errors: List[SchemaError] = []
+        self._collected_errors: list[dict[str, Any]] = []
+        self._schema_errors: list[SchemaError] = []
         self._summarized_errors = defaultdict(lambda: defaultdict(list))  # type: ignore
 
     @property
@@ -86,7 +86,7 @@ def collect_error(
 
     def collect_errors(
         self,
-        schema_errors: List[SchemaError],
+        schema_errors: list[SchemaError],
         original_exc: Union[BaseException, None] = None,
     ):
         """Collect schema errors from a SchemaErrors exception.
@@ -104,19 +104,19 @@ def collect_errors(
             )
 
     @property
-    def collected_errors(self) -> List[Dict[str, Any]]:
+    def collected_errors(self) -> list[dict[str, Any]]:
         """Retrieve error objects collected during lazy validation."""
         return self._collected_errors
 
     @collected_errors.setter
-    def collected_errors(self, value: List[Dict[str, Any]]):
+    def collected_errors(self, value: list[dict[str, Any]]):
         """Set the list of collected errors."""
         if not isinstance(value, list):
             raise ValueError("collected_errors must be a list")
         self._collected_errors = value
 
     @property
-    def schema_errors(self) -> List[SchemaError]:
+    def schema_errors(self) -> list[SchemaError]:
         """Retrieve SchemaError objects collected during lazy validation."""
         return self._schema_errors
 

pandera/api/base/model.py

@@ -1,17 +1,8 @@
 """Base classes for model api."""
 
 import os
-from typing import (
-    Any,
-    Dict,
-    List,
-    Mapping,
-    Optional,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-)
+from typing import Any, Optional, TypeVar, Union
+from collections.abc import Mapping
 
 from pandera.api.base.model_components import BaseFieldInfo
 from pandera.api.base.model_config import BaseModelConfig
@@ -34,24 +25,24 @@ def __str__(cls):
 class BaseModel(metaclass=MetaModel):
     """Base class for a Data Object Model."""
 
-    Config: Type[BaseModelConfig] = BaseModelConfig
-    __extras__: Optional[Dict[str, Any]] = None
+    Config: type[BaseModelConfig] = BaseModelConfig
+    __extras__: Optional[dict[str, Any]] = None
     __schema__: Optional[Any] = None
-    __config__: Optional[Type[BaseModelConfig]] = None
+    __config__: Optional[type[BaseModelConfig]] = None
 
     #: Key according to `FieldInfo.name`
-    __fields__: Mapping[str, Tuple[AnnotationInfo, BaseFieldInfo]] = {}
-    __checks__: Dict[str, List[Check]] = {}
-    __root_checks__: List[Check] = []
+    __fields__: Mapping[str, tuple[AnnotationInfo, BaseFieldInfo]] = {}
+    __checks__: dict[str, list[Check]] = {}
+    __root_checks__: list[Check] = []
 
     # This is syntantic sugar that delegates to the validate method
     def __new__(cls, *args, **kwargs) -> Any:
         raise NotImplementedError
 
     def __class_getitem__(
-        cls: Type[TBaseModel],
-        params: Union[Type[Any], Tuple[Type[Any], ...]],
-    ) -> Type[TBaseModel]:
+        cls: type[TBaseModel],
+        params: Union[type[Any], tuple[type[Any], ...]],
+    ) -> type[TBaseModel]:
         """
         Parameterize the class's generic arguments with the specified types.
 
@@ -71,7 +62,7 @@ def to_yaml(cls, stream: Optional[os.PathLike] = None):
 
     @classmethod
     def validate(
-        cls: Type[TBaseModel],
+        cls: type[TBaseModel],
         check_obj: Any,
         head: Optional[int] = None,
         tail: Optional[int] = None,
@@ -84,12 +75,12 @@ def validate(
         raise NotImplementedError
 
     @classmethod
-    def strategy(cls: Type[TBaseModel], *, size: Optional[int] = None):
+    def strategy(cls: type[TBaseModel], *, size: Optional[int] = None):
         """Create a data synthesis strategy."""
         raise NotImplementedError
 
     @classmethod
-    def example(cls: Type[TBaseModel], *, size: Optional[int] = None) -> Any:
+    def example(cls: type[TBaseModel], *, size: Optional[int] = None) -> Any:
         """Generate an example of this data model specification."""
         raise NotImplementedError
 

pandera/api/base/model_components.py

@@ -3,30 +3,27 @@
 from typing import (
     Any,
     Callable,
-    Dict,
-    Iterable,
-    List,
     Optional,
-    Type,
     Union,
     cast,
 )
+from collections.abc import Iterable
 
 from pandera.api.checks import Check
 from pandera.api.parsers import Parser
 
-CheckArg = Union[Check, List[Check]]
-ParserArg = Union[Parser, List[Parser]]
+CheckArg = Union[Check, list[Check]]
+ParserArg = Union[Parser, list[Parser]]
 AnyCallable = Callable[..., Any]
 
 
-def to_checklist(checks: Optional[CheckArg]) -> List[Check]:
+def to_checklist(checks: Optional[CheckArg]) -> list[Check]:
     """Convert value to list of checks."""
     checks = checks or []
     return [checks] if isinstance(checks, Check) else checks
 
 
-def to_parserlist(parsers: Optional[ParserArg]) -> List[Parser]:
+def to_parserlist(parsers: Optional[ParserArg]) -> list[Parser]:
     parsers = parsers or []
     return [parsers] if isinstance(parsers, Parser) else parsers
 
@@ -64,7 +61,7 @@ def __init__(
         regex: bool = False,
         alias: Any = None,
         check_name: Optional[bool] = None,
-        dtype_kwargs: Optional[Dict[str, Any]] = None,
+        dtype_kwargs: Optional[dict[str, Any]] = None,
         title: Optional[str] = None,
         description: Optional[str] = None,
         default: Optional[Any] = None,
@@ -92,10 +89,10 @@ def name(self) -> str:
             return self.alias
         return self.original_name
 
-    def __set_name__(self, owner: Type, name: str) -> None:
+    def __set_name__(self, owner: type, name: str) -> None:
         self.original_name = name
 
-    def __get__(self, instance: Any, owner: Type) -> str:
+    def __get__(self, instance: Any, owner: type) -> str:
         return self.name
 
     def __str__(self):
@@ -128,7 +125,7 @@ def __init__(self, check_fn: AnyCallable, **check_kwargs: Any):
         self.check_fn = check_fn
         self.check_kwargs = check_kwargs
 
-    def to_check(self, model_cls: Type) -> Check:
+    def to_check(self, model_cls: type) -> Check:
         """Create a Check from metadata."""
         name = self.check_kwargs.pop("name", None)
         if not name:
@@ -149,7 +146,7 @@ def __init__(self, parser_fn: AnyCallable, **parser_kwargs: Any) -> None:
         self.parser_fn = parser_fn
         self.parser_kwargs = parser_kwargs
 
-    def to_parser(self, model_cls: Type) -> Parser:
+    def to_parser(self, model_cls: type) -> Parser:
         """Create a Parser from metadata."""
         name = self.parser_kwargs.pop("name", None)
         if not name: