Feature typeddict

dogpile/cache/api.py

@@ -348,7 +348,8 @@ def get_serialized_multi(
          :meth:`.CacheRegion.get_multi` method, which will also be processed
          by the "key mangling" function if one was present.
 
-        :return: list of bytes objects
+        :return: list of bytes objects or the :data:`.NO_VALUE` contant
+         if not present.
 
         The default implementation of this method for :class:`.CacheBackend`
         returns the value of the :meth:`.CacheBackend.get_multi` method.
@@ -543,7 +544,8 @@ def get_serialized_multi(
          :meth:`.CacheRegion.get_multi` method, which will also be processed
          by the "key mangling" function if one was present.
 
-        :return: list of bytes objects
+        :return: list of bytes objects or the :data:`.NO_VALUE`
+         constant if not present.
 
         .. versionadded:: 1.1
 

dogpile/cache/backends/file.py

@@ -6,10 +6,17 @@
 
 """
 
+from __future__ import annotations
+
 from contextlib import contextmanager
 import dbm
 import os
 import threading
+from typing import cast
+from typing import Dict
+from typing import Literal
+from typing import TypedDict
+from typing import Union
 
 from ..api import BytesBackend
 from ..api import NO_VALUE
@@ -18,6 +25,13 @@
 __all__ = ["DBMBackend", "FileLock", "AbstractFileLock"]
 
 
+class DBMBackendArguments(TypedDict, total=False):
+    filename: str
+    lock_factory: "AbstractFileLock"
+    rw_lockfile: Union[str, Literal[False], None]
+    dogpile_lockfile: Union[str, Literal[False], None]
+
+
 class DBMBackend(BytesBackend):
     """A file-backend using a dbm file to store keys.
 
@@ -137,18 +151,19 @@ def release_write_lock(self):
 
     """
 
-    def __init__(self, arguments):
+    def __init__(self, arguments: DBMBackendArguments):
+        _arguments = cast(Dict, arguments.copy())
         self.filename = os.path.abspath(
-            os.path.normpath(arguments["filename"])
+            os.path.normpath(_arguments["filename"])
         )
         dir_, filename = os.path.split(self.filename)
 
-        self.lock_factory = arguments.get("lock_factory", FileLock)
+        self.lock_factory = _arguments.get("lock_factory", FileLock)
         self._rw_lock = self._init_lock(
-            arguments.get("rw_lockfile"), ".rw.lock", dir_, filename
+            _arguments.get("rw_lockfile"), ".rw.lock", dir_, filename
         )
         self._dogpile_lock = self._init_lock(
-            arguments.get("dogpile_lockfile"),
+            _arguments.get("dogpile_lockfile"),
             ".dogpile.lock",
             dir_,
             filename,

dogpile/cache/backends/memcached.py

@@ -6,20 +6,29 @@
 
 """
 
+from __future__ import annotations
+
 import random
 import threading
 import time
 import typing
 from typing import Any
+from typing import cast
+from typing import Dict
 from typing import Mapping
+from typing import Optional
+from typing import Sequence
+from typing import TypedDict
+from typing import Union
 import warnings
 
 from ..api import CacheBackend
 from ..api import NO_VALUE
 from ... import util
 
-
 if typing.TYPE_CHECKING:
+    import ssl
+
     import bmemcached
     import memcache
     import pylibmc
@@ -41,6 +50,50 @@
 )
 
 
+class GenericMemcachedBackendArguments(TypedDict, total=False):
+    url: str
+    distributed_lock: bool
+    lock_timeout: int
+
+
+class MemcachedArgsArguments(GenericMemcachedBackendArguments, total=False):
+    min_compress_len: int
+    memcached_expire_time: int
+
+
+class MemcachedBackendArguments(GenericMemcachedBackendArguments, total=False):
+    min_compress_len: int
+    memcached_expire_time: int
+    dead_retry: int
+    socket_timeout: int
+
+
+class BMemcachedBackendArguments(
+    GenericMemcachedBackendArguments, total=False
+):
+    username: Optional[str]
+    password: Optional[bool]
+    tls_context: Optional["ssl.SSLContext"]
+
+
+class PyMemcacheBackendArguments(
+    GenericMemcachedBackendArguments, total=False
+):
+    serde: Optional[Any]
+    default_noreply: bool
+    tls_context: Optional["ssl.SSLContext"]
+    socket_keepalive: "pymemcache.client.base.KeepaliveOpts"
+    enable_retry_client: bool
+    retry_attempts: Optional[int]
+    retry_delay: Union[int, float, None]
+    retry_for: Optional[Sequence[Exception]]
+    do_not_retry_for: Optional[Sequence[Exception]]
+    hashclient_retry_attempts: int
+    hashclient_retry_timeout: int
+    hashclient_dead_timeout: int
+    memcached_expire_time: int
+
+
 class MemcachedLock:
     """Simple distributed lock using memcached."""
 
@@ -117,16 +170,17 @@ class GenericMemcachedBackend(CacheBackend):
     serializer = None
     deserializer = None
 
-    def __init__(self, arguments):
+    def __init__(self, arguments: GenericMemcachedBackendArguments):
+        _arguments = cast(Dict, arguments.copy())
         self._imports()
         # using a plain threading.local here.   threading.local
         # automatically deletes the __dict__ when a thread ends,
         # so the idea is that this is superior to pylibmc's
         # own ThreadMappedPool which doesn't handle this
         # automatically.
-        self.url = util.to_list(arguments["url"])
-        self.distributed_lock = arguments.get("distributed_lock", False)
-        self.lock_timeout = arguments.get("lock_timeout", 0)
+        self.url = util.to_list(_arguments["url"])
+        self.distributed_lock = _arguments.get("distributed_lock", False)
+        self.lock_timeout = _arguments.get("lock_timeout", 0)
 
     def has_lock_timeout(self):
         return self.lock_timeout != 0
@@ -226,17 +280,19 @@ class MemcacheArgs(GenericMemcachedBackend):
      of the value using the compressor
     """
 
-    def __init__(self, arguments):
-        self.min_compress_len = arguments.get("min_compress_len", 0)
+    def __init__(self, arguments: MemcachedArgsArguments):
+        _arguments = cast(Dict, arguments.copy())
+        self.min_compress_len = _arguments.get("min_compress_len", 0)
 
         self.set_arguments = {}
-        if "memcached_expire_time" in arguments:
-            self.set_arguments["time"] = arguments["memcached_expire_time"]
-        if "min_compress_len" in arguments:
-            self.set_arguments["min_compress_len"] = arguments[
+        if "memcached_expire_time" in _arguments:
+            self.set_arguments["time"] = _arguments["memcached_expire_time"]
+        if "min_compress_len" in _arguments:
+            self.set_arguments["min_compress_len"] = _arguments[
                 "min_compress_len"
             ]
-        super(MemcacheArgs, self).__init__(arguments)
+        _arguments_super = cast(GenericMemcachedBackendArguments, _arguments)
+        super(MemcacheArgs, self).__init__(_arguments_super)
 
 
 class PylibmcBackend(MemcacheArgs, GenericMemcachedBackend):
@@ -274,9 +330,11 @@ class PylibmcBackend(MemcacheArgs, GenericMemcachedBackend):
     """
 
     def __init__(self, arguments):
-        self.binary = arguments.get("binary", False)
-        self.behaviors = arguments.get("behaviors", {})
-        super(PylibmcBackend, self).__init__(arguments)
+        _arguments = cast(Dict, arguments.copy())
+        self.binary = _arguments.get("binary", False)
+        self.behaviors = _arguments.get("behaviors", {})
+        _arguments_super = cast(MemcachedArgsArguments, _arguments)
+        super(PylibmcBackend, self).__init__(_arguments_super)
 
     def _imports(self):
         global pylibmc
@@ -324,10 +382,12 @@ class MemcachedBackend(MemcacheArgs, GenericMemcachedBackend):
 
     """
 
-    def __init__(self, arguments):
-        self.dead_retry = arguments.get("dead_retry", 30)
-        self.socket_timeout = arguments.get("socket_timeout", 3)
-        super(MemcachedBackend, self).__init__(arguments)
+    def __init__(self, arguments: MemcachedBackendArguments):
+        _arguments = cast(Dict, arguments.copy())
+        self.dead_retry = _arguments.get("dead_retry", 30)
+        self.socket_timeout = _arguments.get("socket_timeout", 3)
+        _arguments_super = cast(MemcachedArgsArguments, _arguments)
+        super(MemcachedBackend, self).__init__(_arguments_super)
 
     def _imports(self):
         global memcache
@@ -400,11 +460,13 @@ class BMemcachedBackend(GenericMemcachedBackend):
 
     """
 
-    def __init__(self, arguments):
-        self.username = arguments.get("username", None)
-        self.password = arguments.get("password", None)
-        self.tls_context = arguments.get("tls_context", None)
-        super(BMemcachedBackend, self).__init__(arguments)
+    def __init__(self, arguments: BMemcachedBackendArguments):
+        _arguments = cast(Dict, arguments.copy())
+        self.username = _arguments.get("username", None)
+        self.password = _arguments.get("password", None)
+        self.tls_context = _arguments.get("tls_context", None)
+        _arguments_super = cast(GenericMemcachedBackendArguments, _arguments)
+        super(BMemcachedBackend, self).__init__(_arguments_super)
 
     def _imports(self):
         global bmemcached
@@ -560,7 +622,7 @@ class PyMemcacheBackend(GenericMemcachedBackend):
 
      .. versionadded:: 1.1.5
 
-    :param dead_timeout: Time in seconds before attempting to add a node
+    :param hashclient_dead_timeout: Time in seconds before attempting to add a node
      back in the pool in the HashClient's internal mechanisms.
 
      .. versionadded:: 1.1.5
@@ -589,25 +651,29 @@ class PyMemcacheBackend(GenericMemcachedBackend):
 
     """  # noqa E501
 
-    def __init__(self, arguments):
-        super().__init__(arguments)
-
-        self.serde = arguments.get("serde", pymemcache.serde.pickle_serde)
-        self.default_noreply = arguments.get("default_noreply", False)
-        self.tls_context = arguments.get("tls_context", None)
-        self.socket_keepalive = arguments.get("socket_keepalive", None)
-        self.enable_retry_client = arguments.get("enable_retry_client", False)
-        self.retry_attempts = arguments.get("retry_attempts", None)
-        self.retry_delay = arguments.get("retry_delay", None)
-        self.retry_for = arguments.get("retry_for", None)
-        self.do_not_retry_for = arguments.get("do_not_retry_for", None)
-        self.hashclient_retry_attempts = arguments.get(
+    def __init__(self, arguments: PyMemcacheBackendArguments):
+        _arguments = cast(Dict, arguments.copy())
+        _arguments_super = cast(GenericMemcachedBackendArguments, _arguments)
+        super().__init__(_arguments_super)
+
+        self.serde = _arguments.get("serde", pymemcache.serde.pickle_serde)
+        self.default_noreply = _arguments.get("default_noreply", False)
+        self.tls_context = _arguments.get("tls_context", None)
+        self.socket_keepalive = _arguments.get("socket_keepalive", None)
+        self.enable_retry_client = _arguments.get("enable_retry_client", False)
+        self.retry_attempts = _arguments.get("retry_attempts", None)
+        self.retry_delay = _arguments.get("retry_delay", None)
+        self.retry_for = _arguments.get("retry_for", None)
+        self.do_not_retry_for = _arguments.get("do_not_retry_for", None)
+        self.hashclient_retry_attempts = _arguments.get(
             "hashclient_retry_attempts", 2
         )
-        self.hashclient_retry_timeout = arguments.get(
+        self.hashclient_retry_timeout = _arguments.get(
             "hashclient_retry_timeout", 1
         )
-        self.dead_timeout = arguments.get("hashclient_dead_timeout", 60)
+        self.hashclient_dead_timeout = _arguments.get(
+            "hashclient_dead_timeout", 60
+        )
         if (
             self.retry_delay is not None
             or self.retry_attempts is not None
@@ -619,8 +685,8 @@ def __init__(self, arguments):
                 "will be ignored"
             )
         self.set_arguments = {}
-        if "memcached_expire_time" in arguments:
-            self.set_arguments["expire"] = arguments["memcached_expire_time"]
+        if "memcached_expire_time" in _arguments:
+            self.set_arguments["expire"] = _arguments["memcached_expire_time"]
 
     def _imports(self):
         global pymemcache
@@ -633,7 +699,7 @@ def _create_client(self):
             "tls_context": self.tls_context,
             "retry_attempts": self.hashclient_retry_attempts,
             "retry_timeout": self.hashclient_retry_timeout,
-            "dead_timeout": self.dead_timeout,
+            "dead_timeout": self.hashclient_dead_timeout,
         }
         if self.socket_keepalive is not None:
             _kwargs.update({"socket_keepalive": self.socket_keepalive})

dogpile/cache/backends/memory.py

@@ -10,11 +10,22 @@
 
 """
 
+from __future__ import annotations
+
+from typing import Any
+from typing import cast
+from typing import Dict
+from typing import TypedDict
+
 from ..api import CacheBackend
 from ..api import DefaultSerialization
 from ..api import NO_VALUE
 
 
+class MemoryBackendArguments(TypedDict):
+    cache_dict: Dict[Any, Any]
+
+
 class MemoryBackend(CacheBackend):
     """A backend that uses a plain dictionary.
 
@@ -49,8 +60,9 @@ class MemoryBackend(CacheBackend):
 
     """
 
-    def __init__(self, arguments):
-        self._cache = arguments.pop("cache_dict", {})
+    def __init__(self, arguments: MemoryBackendArguments):
+        _arguments = cast(Dict, arguments.copy())
+        self._cache = _arguments.pop("cache_dict", {})
 
     def get(self, key):
         return self._cache.get(key, NO_VALUE)

dogpile/cache/backends/null.py

@@ -10,6 +10,11 @@
 
 """
 
+from __future__ import annotations
+
+from typing import Any
+from typing import Dict
+
 from ..api import CacheBackend
 from ..api import NO_VALUE
 
@@ -41,7 +46,8 @@ class NullBackend(CacheBackend):
 
     """
 
-    def __init__(self, arguments):
+    def __init__(self, arguments: Dict[str, Any]):
+        # _arguments = typing.cast(typing.Dict, arguments.copy())
         pass
 
     def get_mutex(self, key):