modernize remaining typing constructs

Change-Id: I00fbb4666ff29986539649143270cb9e1e58eb5f

Author: zzzeek

dogpile/cache/api.py

@@ -12,8 +12,6 @@
 from typing import cast
 from typing import Literal
 from typing import NamedTuple
-from typing import Optional
-from typing import Union
 
 from ..util.typing import Self
 
@@ -167,19 +165,19 @@ def age(self) -> float:
         return time.time() - self.cached_time
 
 
-CacheReturnType = Union[CachedValue, NoValueType]
+CacheReturnType = CachedValue | NoValueType
 """The non-serialized form of what may be returned from a backend
 get method.
 
 """
 
-SerializedReturnType = Union[bytes, NoValueType]
+SerializedReturnType = bytes | NoValueType
 """the serialized form of what may be returned from a backend get method."""
 
-BackendFormatted = Union[CacheReturnType, SerializedReturnType]
+BackendFormatted = CacheReturnType | SerializedReturnType
 """Describes the type returned from the :meth:`.CacheBackend.get` method."""
 
-BackendSetType = Union[CachedValue, bytes]
+BackendSetType = CachedValue | bytes
 """Describes the value argument passed to the :meth:`.CacheBackend.set`
 method."""
 
@@ -195,23 +193,23 @@ class CacheBackend:
 
     """
 
-    key_mangler: Optional[Callable[[KeyType], KeyType]] = None
+    key_mangler: Callable[[KeyType], KeyType] | None = None
     """Key mangling function.
 
     May be None, or otherwise declared
     as an ordinary instance method.
 
     """
 
-    serializer: Union[None, Serializer] = None
+    serializer: Serializer | None = None
     """Serializer function that will be used by default if not overridden
     by the region.
 
     .. versionadded:: 1.1
 
     """
 
-    deserializer: Union[None, Deserializer] = None
+    deserializer: Deserializer | None = None
     """deserializer function that will be used by default if not overridden
     by the region.
 
@@ -247,7 +245,7 @@ def from_config_dict(
     def has_lock_timeout(self) -> bool:
         return False
 
-    def get_mutex(self, key: KeyType) -> Optional[CacheMutex]:
+    def get_mutex(self, key: KeyType) -> CacheMutex | None:
         """Return an optional mutexing object for the given key.
 
         This object need only provide an ``acquire()``
@@ -499,8 +497,8 @@ def delete_multi(
 
 
 class DefaultSerialization:
-    serializer: Union[None, Serializer] = staticmethod(pickle.dumps)
-    deserializer: Union[None, Deserializer] = staticmethod(pickle.loads)
+    serializer: Serializer | None = staticmethod(pickle.dumps)
+    deserializer: Deserializer | None = staticmethod(pickle.loads)
 
 
 class BytesBackend(DefaultSerialization, CacheBackend):

dogpile/cache/proxy.py

@@ -15,7 +15,6 @@
 from collections.abc import Iterable
 from collections.abc import Mapping
 from collections.abc import Sequence
-from typing import Optional
 
 from .api import BackendFormatted
 from .api import BackendSetType
@@ -112,7 +111,7 @@ def set_multi(self, mapping: Mapping[KeyType, BackendSetType]) -> None:
     def delete_multi(self, keys: Iterable[KeyType]) -> None:
         self.proxied.delete_multi(keys)
 
-    def get_mutex(self, key: KeyType) -> Optional[CacheMutex]:
+    def get_mutex(self, key: KeyType) -> CacheMutex | None:
         return self.proxied.get_mutex(key)
 
     def get_serialized(self, key: KeyType) -> SerializedReturnType:

dogpile/cache/region.py

@@ -16,10 +16,8 @@
 import time
 from typing import Any
 from typing import cast
-from typing import Optional
 from typing import Type
 from typing import TYPE_CHECKING
-from typing import Union
 
 from decorator import decorate
 
@@ -65,7 +63,7 @@
     ["CacheRegion", KeyType, Callable[[], ValuePayload], CacheMutex], None
 ]
 
-ExpirationTimeCallable = Callable[[], Optional[float]]
+ExpirationTimeCallable = Callable[[], float | None]
 
 ToStr = Callable[[Any], str]
 
@@ -400,13 +398,13 @@ def runner():
 
     def __init__(
         self,
-        name: Optional[str] = None,
+        name: str | None = None,
         function_key_generator: FunctionKeyGenerator = function_key_generator,
         function_multi_key_generator: FunctionMultiKeyGenerator = function_multi_key_generator,  # noqa E501
-        key_mangler: Optional[Callable[[KeyType], KeyType]] = None,
-        serializer: Optional[Callable[[ValuePayload], bytes]] = None,
-        deserializer: Optional[Callable[[bytes], ValuePayload]] = None,
-        async_creation_runner: Optional[AsyncCreator] = None,
+        key_mangler: Callable[[KeyType], KeyType] | None = None,
+        serializer: Callable[[ValuePayload], bytes] | None = None,
+        deserializer: Callable[[bytes], ValuePayload] | None = None,
+        async_creation_runner: AsyncCreator | None = None,
     ):
         """Construct a new :class:`.CacheRegion`."""
         self.name = name
@@ -423,13 +421,13 @@ def __init__(
     def configure(
         self,
         backend: str,
-        expiration_time: Optional[Union[float, datetime.timedelta]] = None,
-        arguments: Optional[BackendArguments] = None,
-        _config_argument_dict: Optional[Mapping[str, Any]] = None,
-        _config_prefix: Optional[str] = None,
-        wrap: Sequence[Union[ProxyBackend, Type[ProxyBackend]]] = (),
+        expiration_time: float | datetime.timedelta | None = None,
+        arguments: BackendArguments | None = None,
+        _config_argument_dict: Mapping[str, Any] | None = None,
+        _config_prefix: str | None = None,
+        wrap: Sequence[ProxyBackend | Type[ProxyBackend]] = (),
         replace_existing_backend: bool = False,
-        region_invalidator: Optional[RegionInvalidationStrategy] = None,
+        region_invalidator: RegionInvalidationStrategy | None = None,
     ) -> Self:
         """Configure a :class:`.CacheRegion`.
 
@@ -505,10 +503,10 @@ def configure(
         else:
             self.backend = backend_cls(arguments or {})
 
-        self.expiration_time: Union[float, None]
+        self.expiration_time: float | None
 
         if not expiration_time or isinstance(expiration_time, Number):
-            self.expiration_time = cast(Union[None, float], expiration_time)
+            self.expiration_time = cast(None | float, expiration_time)
         elif isinstance(expiration_time, datetime.timedelta):
             self.expiration_time = int(expiration_time.total_seconds())
         else:
@@ -536,7 +534,7 @@ def configure(
 
         return self
 
-    def wrap(self, proxy: Union[ProxyBackend, Type[ProxyBackend]]) -> None:
+    def wrap(self, proxy: ProxyBackend | Type[ProxyBackend]) -> None:
         """Takes a ProxyBackend instance or class and wraps the
         attached backend."""
 
@@ -708,9 +706,9 @@ def is_configured(self) -> bool:
     def get(
         self,
         key: KeyType,
-        expiration_time: Optional[float] = None,
+        expiration_time: float | None = None,
         ignore_expiration: bool = False,
-    ) -> Union[ValuePayload, NoValueType]:
+    ) -> ValuePayload | NoValueType:
         """Return a value from the cache, based on the given key.
 
         If the value is not present, the method returns the token
@@ -788,9 +786,9 @@ def get(
     def get_value_metadata(
         self,
         key: KeyType,
-        expiration_time: Optional[float] = None,
+        expiration_time: float | None = None,
         ignore_expiration: bool = False,
-    ) -> Optional[CachedValue]:
+    ) -> CachedValue | None:
         """Return the :class:`.CachedValue` object directly from the cache.
 
         This is the enclosing datastructure that includes the value as well as
@@ -815,7 +813,7 @@ def get_value_metadata(
     def _get_cache_value(
         self,
         key: KeyType,
-        expiration_time: Optional[float] = None,
+        expiration_time: float | None = None,
         ignore_expiration: bool = False,
     ) -> CacheReturnType:
         if self.key_mangler:
@@ -827,7 +825,7 @@ def _get_cache_value(
         return value
 
     def _unexpired_value_fn(
-        self, expiration_time: Optional[float], ignore_expiration: bool
+        self, expiration_time: float | None, ignore_expiration: bool
     ) -> Callable[[CacheReturnType], CacheReturnType]:
         if ignore_expiration:
             return lambda value: value
@@ -942,9 +940,9 @@ def get_or_create(
         self,
         key: KeyType,
         creator: Callable[..., ValuePayload],
-        expiration_time: Optional[float] = None,
-        should_cache_fn: Optional[Callable[[ValuePayload], bool]] = None,
-        creator_args: Optional[tuple[Any, Mapping[str, Any]]] = None,
+        expiration_time: float | None = None,
+        should_cache_fn: Callable[[ValuePayload], bool] | None = None,
+        creator_args: tuple[Any, Mapping[str, Any]] | None = None,
     ) -> ValuePayload:
         """Return a cached value based on the given key.
 
@@ -1077,7 +1075,7 @@ def gen_value():
         if expiration_time == -1:
             expiration_time = None
 
-        async_creator: Optional[Callable[[CacheMutex], AsyncCreator]]
+        async_creator: Callable[[CacheMutex], AsyncCreator] | None
         if self.async_creation_runner:
             acr = self.async_creation_runner
 
@@ -1109,8 +1107,8 @@ def get_or_create_multi(
         self,
         keys: Iterable[KeyType],
         creator: Callable[[], ValuePayload],
-        expiration_time: Optional[float] = None,
-        should_cache_fn: Optional[Callable[[ValuePayload], bool]] = None,
+        expiration_time: float | None = None,
+        should_cache_fn: Callable[[ValuePayload], bool] | None = None,
     ) -> Sequence[ValuePayload]:
         """Return a sequence of cached values based on a sequence of keys.
 
@@ -1257,7 +1255,7 @@ def async_creator(mutexes, key, mutex):
                 mutex.release()
 
     def _value(
-        self, value: Any, metadata: Optional[MetaDataType] = None
+        self, value: Any, metadata: MetaDataType | None = None
     ) -> CachedValue:
         """Return a :class:`.CachedValue` given a value."""
 
@@ -1294,7 +1292,7 @@ def _serialize_cached_value_elements(
         )
 
     def _serialized_payload(
-        self, payload: ValuePayload, metadata: Optional[MetaDataType] = None
+        self, payload: ValuePayload, metadata: MetaDataType | None = None
     ) -> BackendFormatted:
         """Return a backend formatted representation of a value.
 
@@ -1446,11 +1444,11 @@ def delete_multi(self, keys: Iterable[KeyType]) -> None:
 
     def cache_on_arguments(
         self,
-        namespace: Optional[str] = None,
-        expiration_time: Union[float, ExpirationTimeCallable, None] = None,
-        should_cache_fn: Optional[Callable[[ValuePayload], bool]] = None,
+        namespace: str | None = None,
+        expiration_time: float | ExpirationTimeCallable | None = None,
+        should_cache_fn: Callable[[ValuePayload], bool] | None = None,
         to_str: Callable[[Any], str] = str,
-        function_key_generator: Optional[FunctionKeyGenerator] = None,
+        function_key_generator: FunctionKeyGenerator | None = None,
     ) -> Callable[[Callable[..., ValuePayload]], Callable[..., ValuePayload]]:
         """A function decorator that will cache the return
         value of the function using a key derived from the
@@ -1631,10 +1629,10 @@ def somemethod(self, x, y):
         def get_or_create_for_user_func(key_generator, user_func, *arg, **kw):
             key = key_generator(*arg, **kw)
 
-            timeout: Optional[float] = (
+            timeout: float | None = (
                 cast(ExpirationTimeCallable, expiration_time)()
                 if expiration_time_is_callable
-                else cast(Optional[float], expiration_time)
+                else cast(float | None, expiration_time)
             )
             return self.get_or_create(
                 key, user_func, timeout, should_cache_fn, (arg, kw)
@@ -1686,19 +1684,15 @@ def get(*arg, **kw):
 
     def cache_multi_on_arguments(
         self,
-        namespace: Optional[str] = None,
-        expiration_time: Union[float, ExpirationTimeCallable, None] = None,
-        should_cache_fn: Optional[Callable[[ValuePayload], bool]] = None,
+        namespace: str | None = None,
+        expiration_time: float | ExpirationTimeCallable | None = None,
+        should_cache_fn: Callable[[ValuePayload], bool] | None = None,
         asdict: bool = False,
         to_str: ToStr = str,
-        function_multi_key_generator: Optional[
-            FunctionMultiKeyGenerator
-        ] = None,
+        function_multi_key_generator: FunctionMultiKeyGenerator | None = None,
     ) -> Callable[
         [Callable[..., Sequence[ValuePayload]]],
-        Callable[
-            ..., Union[Sequence[ValuePayload], Mapping[KeyType, ValuePayload]]
-        ],
+        Callable[..., Sequence[ValuePayload] | Mapping[KeyType, ValuePayload]],
     ]:
         """A function decorator that will cache multiple return
         values from the function using a sequence of keys derived from the
@@ -1828,7 +1822,7 @@ def get_or_create_for_user_func(
             user_func: Callable[..., Sequence[ValuePayload]],
             *arg: Any,
             **kw: Any,
-        ) -> Union[Sequence[ValuePayload], Mapping[KeyType, ValuePayload]]:
+        ) -> Sequence[ValuePayload] | Mapping[KeyType, ValuePayload]:
             cache_keys = arg
             keys = key_generator(*arg, **kw)
             key_lookup = dict(zip(keys, cache_keys))
@@ -1837,15 +1831,13 @@ def get_or_create_for_user_func(
             def creator(*keys_to_create):
                 return user_func(*[key_lookup[k] for k in keys_to_create])
 
-            timeout: Optional[float] = (
+            timeout: float | None = (
                 cast(ExpirationTimeCallable, expiration_time)()
                 if expiration_time_is_callable
-                else cast(Optional[float], expiration_time)
+                else cast(float | None, expiration_time)
             )
 
-            result: Union[
-                Sequence[ValuePayload], Mapping[KeyType, ValuePayload]
-            ]
+            result: Sequence[ValuePayload] | Mapping[KeyType, ValuePayload]
 
             if asdict:
 

dogpile/cache/util.py

@@ -4,7 +4,6 @@
 from collections.abc import Iterable
 from hashlib import sha1
 from typing import Any
-from typing import Union
 
 from ..util import compat
 from ..util import langhelpers
@@ -139,7 +138,7 @@ def generate_key(*args, **kwargs):
     return generate_key
 
 
-def sha1_mangle_key(key: Union[str, bytes]) -> str:
+def sha1_mangle_key(key: str | bytes) -> str:
     """a SHA1 key mangler."""
 
     return sha1(