style: apply ruff auto-fixes for py310 target version

Ruff UP rules now flag old-style typing (Optional[X] -> X | None, Union -> |,
typing.List -> list, typing.Tuple -> tuple, etc.) since target-version is py310.
Also fix import sorting and zip() strict parameter warnings.
Migrate tests/pyproject.toml ruff config to [tool.ruff.lint] section.

Author: wolf-j3blair

examples/in_memory/main.py

@@ -1,6 +1,6 @@
 # pyright: reportGeneralTypeIssues=false
+from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import AsyncIterator, Dict, Optional
 
 import pendulum
 import uvicorn
@@ -94,9 +94,9 @@ async def handler_method(self):
 # cache a Pydantic model instance; the return type annotation is required in this case
 class Item(BaseModel):
     name: str
-    description: Optional[str] = None
+    description: str | None = None
     price: float
-    tax: Optional[float] = None
+    tax: float | None = None
 
 
 @app.get("/pydantic_instance")
@@ -129,7 +129,7 @@ async def cached_put():
 @cache(namespace="test", expire=5, injected_dependency_namespace="monty_python") # pyright: ignore[reportArgumentType]
 def namespaced_injection(
     __fastapi_cache_request: int = 42, __fastapi_cache_response: int = 17
-) -> Dict[str, int]:
+) -> dict[str, int]:
     return {
         "__fastapi_cache_request": __fastapi_cache_request,
         "__fastapi_cache_response": __fastapi_cache_response,

examples/redis/main.py

@@ -1,9 +1,10 @@
 # pyright: reportGeneralTypeIssues=false
 import time
+from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import AsyncIterator
 
 import pendulum
+import redis.asyncio as redis
 import uvicorn
 from fastapi import FastAPI
 from fastapi.responses import HTMLResponse
@@ -13,12 +14,10 @@
 from fastapi_cache.backends.redis import RedisBackend
 from fastapi_cache.coder import PickleCoder
 from fastapi_cache.decorator import cache
+from redis.asyncio.connection import ConnectionPool
 from starlette.requests import Request
 from starlette.responses import JSONResponse, Response
 
-import redis.asyncio as redis
-from redis.asyncio.connection import ConnectionPool
-
 
 @asynccontextmanager
 async def lifespan(_: FastAPI) -> AsyncIterator[None]:

fastapi_cache/__init__.py

@@ -1,5 +1,5 @@
 from importlib.metadata import version
-from typing import ClassVar, Optional, Type
+from typing import ClassVar
 
 from fastapi_cache.coder import Coder, JsonCoder
 from fastapi_cache.key_builder import default_key_builder
@@ -17,22 +17,22 @@
 
 
 class FastAPICache:
-    _backend: ClassVar[Optional[Backend]] = None
-    _prefix: ClassVar[Optional[str]] = None
-    _expire: ClassVar[Optional[int]] = None
+    _backend: ClassVar[Backend | None] = None
+    _prefix: ClassVar[str | None] = None
+    _expire: ClassVar[int | None] = None
     _init: ClassVar[bool] = False
-    _coder: ClassVar[Optional[Type[Coder]]] = None
-    _key_builder: ClassVar[Optional[KeyBuilder]] = None
-    _cache_status_header: ClassVar[Optional[str]] = None
+    _coder: ClassVar[type[Coder] | None] = None
+    _key_builder: ClassVar[KeyBuilder | None] = None
+    _cache_status_header: ClassVar[str | None] = None
     _enable: ClassVar[bool] = True
 
     @classmethod
     def init(
         cls,
         backend: Backend,
         prefix: str = "",
-        expire: Optional[int] = None,
-        coder: Type[Coder] = JsonCoder,
+        expire: int | None = None,
+        coder: type[Coder] = JsonCoder,
         key_builder: KeyBuilder = default_key_builder,
         cache_status_header: str = "X-FastAPI-Cache",
         enable: bool = True,
@@ -70,11 +70,11 @@ def get_prefix(cls) -> str:
         return cls._prefix
 
     @classmethod
-    def get_expire(cls) -> Optional[int]:
+    def get_expire(cls) -> int | None:
         return cls._expire
 
     @classmethod
-    def get_coder(cls) -> Type[Coder]:
+    def get_coder(cls) -> type[Coder]:
         assert cls._coder, "You must call init first!"  # noqa: S101
         return cls._coder
 
@@ -94,7 +94,7 @@ def get_enable(cls) -> bool:
 
     @classmethod
     async def clear(
-        cls, namespace: Optional[str] = None, key: Optional[str] = None
+        cls, namespace: str | None = None, key: str | None = None
     ) -> int:
         assert (  # noqa: S101
             cls._backend and cls._prefix is not None

fastapi_cache/backends/dynamodb.py

@@ -1,5 +1,5 @@
 import datetime
-from typing import TYPE_CHECKING, Optional, Tuple
+from typing import TYPE_CHECKING
 
 from aiobotocore.client import AioBaseClient
 from aiobotocore.session import AioSession, get_session
@@ -33,9 +33,9 @@ class DynamoBackend(Backend):
     client: DynamoDBClient
     session: AioSession
     table_name: str
-    region: Optional[str]
+    region: str | None
 
-    def __init__(self, table_name: str, region: Optional[str] = None) -> None:
+    def __init__(self, table_name: str, region: str | None = None) -> None:
         self.session: AioSession = get_session()
         self.table_name = table_name
         self.region = region
@@ -48,7 +48,7 @@ async def init(self) -> None:
     async def close(self) -> None:
         self.client = await self.client.__aexit__(None, None, None)
 
-    async def get_with_ttl(self, key: str) -> Tuple[int, Optional[bytes]]:
+    async def get_with_ttl(self, key: str) -> tuple[int, bytes | None]:
         response = await self.client.get_item(TableName=self.table_name, Key={"key": {"S": key}})
 
         if "Item" in response:
@@ -65,13 +65,13 @@ async def get_with_ttl(self, key: str) -> Tuple[int, Optional[bytes]]:
 
         return 0, None
 
-    async def get(self, key: str) -> Optional[bytes]:
+    async def get(self, key: str) -> bytes | None:
         response = await self.client.get_item(TableName=self.table_name, Key={"key": {"S": key}})
         if "Item" in response:
             return response["Item"].get("value", {}).get("B")
         return None
 
-    async def set(self, key: str, value: bytes, expire: Optional[int] = None) -> None:
+    async def set(self, key: str, value: bytes, expire: int | None = None) -> None:
         ttl = (
             {
                 "ttl": {
@@ -99,5 +99,5 @@ async def set(self, key: str, value: bytes, expire: Optional[int] = None) -> Non
             },
         )
 
-    async def clear(self, namespace: Optional[str] = None, key: Optional[str] = None) -> int:
+    async def clear(self, namespace: str | None = None, key: str | None = None) -> int:
         raise NotImplementedError

fastapi_cache/backends/inmemory.py

@@ -1,7 +1,6 @@
 import time
 from asyncio import Lock
 from dataclasses import dataclass
-from typing import Dict, Optional, Tuple
 
 from fastapi_cache.types import Backend
 
@@ -13,14 +12,14 @@ class Value:
 
 
 class InMemoryBackend(Backend):
-    _store: Dict[str, Value] = {}
+    _store: dict[str, Value] = {}
     _lock = Lock()
 
     @property
     def _now(self) -> int:
         return int(time.time())
 
-    def _get(self, key: str) -> Optional[Value]:
+    def _get(self, key: str) -> Value | None:
         v = self._store.get(key)
         if v:
             if v.ttl_ts < self._now:
@@ -29,25 +28,25 @@ def _get(self, key: str) -> Optional[Value]:
                 return v
         return None
 
-    async def get_with_ttl(self, key: str) -> Tuple[int, Optional[bytes]]:
+    async def get_with_ttl(self, key: str) -> tuple[int, bytes | None]:
         async with self._lock:
             v = self._get(key)
             if v:
                 return v.ttl_ts - self._now, v.data
             return 0, None
 
-    async def get(self, key: str) -> Optional[bytes]:
+    async def get(self, key: str) -> bytes | None:
         async with self._lock:
             v = self._get(key)
             if v:
                 return v.data
             return None
 
-    async def set(self, key: str, value: bytes, expire: Optional[int] = None) -> None:
+    async def set(self, key: str, value: bytes, expire: int | None = None) -> None:
         async with self._lock:
             self._store[key] = Value(value, self._now + (expire or 0))
 
-    async def clear(self, namespace: Optional[str] = None, key: Optional[str] = None) -> int:
+    async def clear(self, namespace: str | None = None, key: str | None = None) -> int:
         count = 0
         if namespace:
             keys = list(self._store.keys())

fastapi_cache/backends/memcached.py

@@ -1,4 +1,3 @@
-from typing import Optional, Tuple
 
 from aiomcache import Client
 
@@ -9,14 +8,14 @@ class MemcachedBackend(Backend):
     def __init__(self, mcache: Client):
         self.mcache = mcache
 
-    async def get_with_ttl(self, key: str) -> Tuple[int, Optional[bytes]]:
+    async def get_with_ttl(self, key: str) -> tuple[int, bytes | None]:
         return 3600, await self.get(key)
 
-    async def get(self, key: str) -> Optional[bytes]:
+    async def get(self, key: str) -> bytes | None:
         return await self.mcache.get(key.encode())
 
-    async def set(self, key: str, value: bytes, expire: Optional[int] = None) -> None:
+    async def set(self, key: str, value: bytes, expire: int | None = None) -> None:
         await self.mcache.set(key.encode(), value, exptime=expire or 0)
 
-    async def clear(self, namespace: Optional[str] = None, key: Optional[str] = None) -> int:
+    async def clear(self, namespace: str | None = None, key: str | None = None) -> int:
         raise NotImplementedError

fastapi_cache/backends/redis.py

@@ -1,4 +1,4 @@
-from typing import Optional, Tuple, Union
+from typing import Union
 
 from redis.asyncio.client import Redis
 from redis.asyncio.cluster import RedisCluster
@@ -11,17 +11,17 @@ def __init__(self, redis: Union["Redis[bytes]", "RedisCluster[bytes]"]):
         self.redis = redis
         self.is_cluster: bool = isinstance(redis, RedisCluster)
 
-    async def get_with_ttl(self, key: str) -> Tuple[int, Optional[bytes]]:
+    async def get_with_ttl(self, key: str) -> tuple[int, bytes | None]:
         async with self.redis.pipeline(transaction=not self.is_cluster) as pipe:
             return await pipe.ttl(key).get(key).execute()  # type: ignore[union-attr,no-any-return]
 
-    async def get(self, key: str) -> Optional[bytes]:
+    async def get(self, key: str) -> bytes | None:
         return await self.redis.get(key)  # type: ignore[union-attr]
 
-    async def set(self, key: str, value: bytes, expire: Optional[int] = None) -> None:
+    async def set(self, key: str, value: bytes, expire: int | None = None) -> None:
         await self.redis.set(key, value, ex=expire)  # type: ignore[union-attr]
 
-    async def clear(self, namespace: Optional[str] = None, key: Optional[str] = None) -> int:
+    async def clear(self, namespace: str | None = None, key: str | None = None) -> int:
         if namespace:
             lua = f"for i, name in ipairs(redis.call('KEYS', '{namespace}:*')) do redis.call('DEL', name); end"
             return await self.redis.eval(lua, numkeys=0)  # type: ignore[union-attr,no-any-return]

fastapi_cache/coder.py

@@ -1,15 +1,12 @@
 import datetime
 import json
 import pickle  # nosec:B403
+from collections.abc import Callable
 from decimal import Decimal
 from typing import (
     Any,
-    Callable,
     ClassVar,
-    Dict,
-    Optional,
     TypeVar,
-    Union,
     overload,
 )
 
@@ -27,7 +24,7 @@ class ModelField:
 _T = TypeVar("_T", bound=type)
 
 
-CONVERTERS: Dict[str, Callable[[str], Any]] = {
+CONVERTERS: dict[str, Callable[[str], Any]] = {
     # Pendulum 3.0.0 adds parse to __all__, at which point these ignores can be removed
     "date": lambda x: pendulum.parse(x, exact=True),
     "datetime": lambda x: pendulum.parse(x, exact=True),
@@ -72,7 +69,7 @@ def decode(cls, value: bytes) -> Any:
     # decode_as_type method and then stores a different kind of field for a
     # given type, do make sure that the subclass provides its own class
     # attribute for this cache.
-    _type_field_cache: ClassVar[Dict[Any, ModelField]] = {}
+    _type_field_cache: ClassVar[dict[Any, ModelField]] = {}
 
     @overload
     @classmethod
@@ -85,7 +82,7 @@ def decode_as_type(cls, value: bytes, *, type_: None) -> Any:
         ...
 
     @classmethod
-    def decode_as_type(cls, value: bytes, *, type_: Optional[_T]) -> Union[_T, Any]:
+    def decode_as_type(cls, value: bytes, *, type_: _T | None) -> _T | Any:
         """Decode value to the specific given type
 
         The default implementation uses the Pydantic model system to convert the value.
@@ -122,7 +119,7 @@ def decode(cls, value: bytes) -> Any:
         return pickle.loads(value)  # noqa: S301
 
     @classmethod
-    def decode_as_type(cls, value: bytes, *, type_: Optional[_T]) -> Any:
+    def decode_as_type(cls, value: bytes, *, type_: _T | None) -> Any:
         # Pickle already produces the correct type on decoding, no point
         # in paying an extra performance penalty for pydantic to discover
         # the same.