cachekit 0.7.0__tar.gz → 0.8.0__tar.gz

{cachekit-0.7.0 → cachekit-0.8.0}/Cargo.lock

@@ -17,6 +17,43 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
+[[package]]
+name = "aead"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
+dependencies = [
+ "crypto-common",
+ "generic-array",
+]
+
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+ "zeroize",
+]
+
+[[package]]
+name = "aes-gcm"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1"
+dependencies = [
+ "aead",
+ "aes",
+ "cipher",
+ "ctr",
+ "ghash",
+ "subtle",
+ "zeroize",
+]
+
 [[package]]
 name = "ahash"
 version = "0.8.12"
@@ -208,14 +245,17 @@ checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
 [[package]]
 name = "cachekit-core"
-version = "0.1.1"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e264be91367e582a103017104f2fcc6f6f12ca59ded81f53016bc60752a94ae"
+checksum = "9622b3c3e47fcf7abfde287c557e6171674e37842a2dd26fda03f63720542f17"
 dependencies = [
+ "aes",
+ "aes-gcm",
  "byteorder",
  "bytes",
  "cbindgen",
  "generic-array",
+ "getrandom 0.2.17",
  "hkdf",
  "hmac",
  "lz4_flex",
@@ -224,14 +264,14 @@ dependencies = [
  "serde",
  "serde_bytes",
  "sha2",
- "thiserror 1.0.69",
+ "thiserror 2.0.18",
  "xxhash-rust",
  "zeroize",
 ]
 
 [[package]]
 name = "cachekit-rs"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "cachekit-core",
  "criterion",
@@ -312,6 +352,16 @@ dependencies = [
  "half",
 ]
 
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
 [[package]]
 name = "clap"
 version = "4.6.0"
@@ -444,6 +494,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 dependencies = [
  "generic-array",
+ "rand_core 0.6.4",
  "typenum",
 ]
 
@@ -463,6 +514,15 @@ version = "0.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2931af7e13dc045d8e9d26afccc6fa115d64e115c9c84b1166288b46f6782c2"
 
+[[package]]
+name = "ctr"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
+dependencies = [
+ "cipher",
+]
+
 [[package]]
 name = "debugid"
 version = "0.8.0"
@@ -639,8 +699,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "wasi",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -668,6 +730,16 @@ dependencies = [
  "wasip3",
 ]
 
+[[package]]
+name = "ghash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"
+dependencies = [
+ "opaque-debug",
+ "polyval",
+]
+
 [[package]]
 name = "gimli"
 version = "0.32.3"
@@ -820,6 +892,15 @@ dependencies = [
  "str_stack",
 ]
 
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "is-terminal"
 version = "0.4.17"
@@ -909,9 +990,9 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lz4_flex"
-version = "0.11.6"
+version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "373f5eceeeab7925e0c1098212f2fbc4d416adec9d35051a6ab251e824c1854a"
+checksum = "90071f8077f8e40adfc4b7fe9cd495ce316263f19e75c2211eeff3fdf475a3d9"
 dependencies = [
  "twox-hash",
 ]
@@ -1006,6 +1087,12 @@ version = "11.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
 
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
 [[package]]
 name = "plotters"
 version = "0.3.7"
@@ -1034,6 +1121,18 @@ dependencies = [
  "plotters-backend",
 ]
 
+[[package]]
+name = "polyval"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "opaque-debug",
+ "universal-hash",
+]
+
 [[package]]
 name = "portable-atomic"
 version = "1.13.1"
@@ -1290,7 +1389,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
  "rand_chacha",
- "rand_core",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -1300,7 +1399,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.17",
 ]
 
 [[package]]
@@ -1318,7 +1426,7 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"
 dependencies = [
- "rand_core",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -1804,6 +1912,16 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
 
+[[package]]
+name = "universal-hash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
+dependencies = [
+ "crypto-common",
+ "subtle",
+]
+
 [[package]]
 name = "untrusted"
 version = "0.9.0"

{cachekit-0.7.0 → cachekit-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachekit
-Version: 0.7.0
+Version: 0.8.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{cachekit-0.7.0 → cachekit-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "cachekit"
-version = "0.7.0"
+version = "0.8.0"
 description = "Production-ready Redis caching for Python with intelligent reliability features and Rust-powered performance"
 readme = "README.md"
 license = {text = "MIT"}

{cachekit-0.7.0 → cachekit-0.8.0}/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cachekit-rs"
-version = "0.7.0"
+version = "0.8.0"
 edition = "2021"
 authors = ["cachekit Contributors"]
 description = "High-performance storage engine for caching with compression and encryption"
@@ -20,7 +20,7 @@ crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 # Compression, checksums, encryption (https://crates.io/crates/cachekit-core)
-cachekit-core = { version = "=0.1.1", features = ["compression", "checksum", "messagepack", "encryption"] }
+cachekit-core = { version = "0.2.0", features = ["compression", "checksum", "messagepack", "encryption"] }
 
 # Python integration - optional for Rust-only builds
 pyo3 = { workspace = true, optional = true }

{cachekit-0.7.0 → cachekit-0.8.0}/src/cachekit/__init__.py

@@ -68,7 +68,7 @@ Example Usage:
     ```
 """
 
-__version__ = "0.7.0"
+__version__ = "0.8.0"
 
 from typing import Any, Callable, TypeVar
 

{cachekit-0.7.0 → cachekit-0.8.0}/src/cachekit/backends/base.py

@@ -188,10 +188,23 @@ class LockableBackend(Protocol):
     - Local-only: SQLite, FileSystem (single-process locking)
     - Not supported: HTTP (stateless), Memcached, S3
 
+    Contract — bare cache key:
+        ``acquire_lock`` receives the **bare cache key**, identical to what
+        ``get``/``set``/``delete`` receive. Callers MUST NOT append suffixes
+        like ``:lock`` before passing the key. Each backend owns its own
+        lock-namespace derivation:
+
+        - Redis: derives ``<key>:lock`` internally for the on-wire lock name.
+        - CachekitIO (SaaS): the lock endpoint is ``POST /v1/cache/{key}/lock`` —
+          no key derivation needed.
+
+        This convergence keeps the Python SDK byte-for-byte compatible with
+        the cachekit-rs and cachekit-ts SDKs at the protocol boundary.
+
     Example:
         >>> # Distributed locking pattern (async context):
         >>> # if hasattr(backend, 'acquire_lock'):
-        >>> #     async with backend.acquire_lock("lock:compute", timeout=30) as acquired:
+        >>> #     async with backend.acquire_lock("user:123:profile", timeout=30) as acquired:
         >>> #         if acquired:
         >>> #             result = expensive_computation()
     """
@@ -205,7 +218,10 @@ class LockableBackend(Protocol):
         """Acquire a distributed lock on key.
 
         Args:
-            key: Lock key (e.g., "lock:user:123")
+            key: Bare cache key (e.g., ``"user:123"``) — the SAME shape passed
+                to ``get``/``set``/``delete``. Implementations are responsible
+                for any internal lock-namespace derivation; callers MUST NOT
+                pre-suffix the key.
             timeout: How long to hold the lock (seconds) before auto-release
             blocking_timeout: Max time to wait for lock acquisition (None = non-blocking)
 
@@ -217,7 +233,7 @@ class LockableBackend(Protocol):
             BackendError: If backend operation fails
 
         Example:
-            >>> async with backend.acquire_lock("lock:key", timeout=30, blocking_timeout=5) as acquired:  # doctest: +SKIP
+            >>> async with backend.acquire_lock("user:123:profile", timeout=30, blocking_timeout=5) as acquired:  # doctest: +SKIP
             ...     if acquired:  # doctest: +SKIP
             ...         # Lock held, safe to proceed
             ...         pass  # doctest: +SKIP

{cachekit-0.7.0 → cachekit-0.8.0}/src/cachekit/backends/cachekitio/backend.py

@@ -553,14 +553,21 @@ class CachekitIOBackend:
     async def _try_acquire_lock(self, lock_key: str, timeout: float) -> str | None:
         """Single attempt at the SaaS lock endpoint. Returns lock_id, or None if held.
 
+        ``lock_key`` is the bare cache key (LockableBackend contract). The SaaS lock
+        endpoint is ``POST /v1/cache/{key}/lock`` — no internal derivation is needed
+        because lock semantics live in the URL path, not the key namespace. Appending
+        ``:lock`` here would push the SaaS validator past its 7-segment canonical key
+        budget and trigger a 400 at the edge.
+
         Non-finite (NaN / ±inf) or non-positive ``timeout`` is clamped to 1ms — without
         the guard, ``int(NaN)`` / ``int(inf)`` would raise outside ``BackendError`` and
         escape the wrapper's degrade-to-no-lock branch.
 
         Raises:
-            BackendError: For AUTHENTICATION and PERMANENT failures (bad key, bad lock_key
-                format) — polling won't recover and the wrapper degrades to no-lock execution.
-                TRANSIENT/TIMEOUT/UNKNOWN are swallowed as None so the polling loop can retry.
+            BackendError: For AUTHENTICATION and PERMANENT failures (bad key, bad key
+                format rejected by SaaS validator) — polling won't recover and the wrapper
+                degrades to no-lock execution. TRANSIENT/TIMEOUT/UNKNOWN are swallowed as
+                None so the polling loop can retry.
         """
         # Clamp non-positive / non-finite timeouts before the int conversion.
         # int(NaN) / int(inf) raise ValueError/OverflowError that aren't BackendError, so

{cachekit-0.7.0 → cachekit-0.8.0}/src/cachekit/backends/provider.py

@@ -104,36 +104,85 @@ class DefaultCacheClientProvider(CacheClientProvider):
 class DefaultBackendProvider(BackendProviderInterface):
     """Default backend provider with env-based auto-detection.
 
-    Priority order (first matching env var wins):
-        1. CACHEKIT_API_KEY  → CachekitIOBackend (SaaS)
-        2. CACHEKIT_REDIS_URL or REDIS_URL → RedisBackend
-
-    For single-tenant deployments (default), sets tenant_context to "default".
-    For multi-tenant deployments, tenant_context must be set externally.
+    Selection is by a single, unambiguous environment signal. Priority order:
+        1. CACHEKIT_API_KEY            → CachekitIOBackend (SaaS)
+        2. CACHEKIT_REDIS_URL          → RedisBackend
+        3. CACHEKIT_MEMCACHED_SERVERS  → MemcachedBackend
+        4. CACHEKIT_FILE_CACHE_DIR     → FileBackend
+        5. REDIS_URL, or nothing set   → RedisBackend (12-factor / localhost default)
+
+    Setting more than one of the four prefixed selectors (1-4) raises
+    ``ConfigurationError`` — auto-detection must be unambiguous; pass
+    ``backend=`` explicitly to override. The non-prefixed ``REDIS_URL`` is only a
+    fallback and never counts as a conflict (12-factor convention).
+
+    CachekitIO/Memcached/File backends are stateless singletons (cached). Redis
+    backends are per-request tenant-scoped wrappers (not cached —
+    RedisBackendProvider.get_backend() reads the tenant_context ContextVar). For
+    single-tenant deployments (default), tenant_context is set to "default".
     """
 
+    # Prefixed selectors in priority order. REDIS_URL is the implicit fallback
+    # and intentionally excluded so it never triggers a conflict.
+    _SELECTORS = (
+        ("CACHEKIT_API_KEY", "cachekitio"),
+        ("CACHEKIT_REDIS_URL", "redis"),
+        ("CACHEKIT_MEMCACHED_SERVERS", "memcached"),
+        ("CACHEKIT_FILE_CACHE_DIR", "file"),
+    )
+
     def __init__(self):
         self._cachekitio_backend = None
         self._redis_provider = None
+        self._memcached_backend = None
+        self._file_backend = None
 
-    def get_backend(self):
-        """Get backend instance, auto-detected from environment on first call.
+    def _detect(self):
+        """Return the chosen backend key, or None to use the Redis fallback.
 
-        CachekitIO backends are stateless singletons (cached).
-        Redis backends are per-request tenant-scoped wrappers (not cached —
-        RedisBackendProvider.get_backend() reads tenant_context ContextVar).
+        Raises ConfigurationError if more than one prefixed selector is set.
         """
         import os
 
-        # Priority 1: CachekitIO SaaS backend (stateless, safe to cache)
-        if os.environ.get("CACHEKIT_API_KEY"):
+        matched = [(env_var, key) for env_var, key in self._SELECTORS if os.environ.get(env_var)]
+        if len(matched) > 1:
+            from cachekit.config.validation import ConfigurationError
+
+            names = ", ".join(env_var for env_var, _ in matched)
+            raise ConfigurationError(
+                f"Ambiguous backend auto-detection: multiple selectors set ({names}). "
+                "Set exactly one of CACHEKIT_API_KEY / CACHEKIT_REDIS_URL / "
+                "CACHEKIT_MEMCACHED_SERVERS / CACHEKIT_FILE_CACHE_DIR, or pass backend= explicitly."
+            )
+        return matched[0][1] if matched else None
+
+    def get_backend(self):
+        """Get backend instance, auto-detected from environment on first call."""
+        choice = self._detect()
+
+        if choice == "cachekitio":
             if self._cachekitio_backend is None:
                 from cachekit.backends.cachekitio import CachekitIOBackend
 
                 self._cachekitio_backend = CachekitIOBackend()
             return self._cachekitio_backend
 
-        # Priority 2: Redis backend (tenant-scoped, call provider each time)
+        if choice == "memcached":
+            if self._memcached_backend is None:
+                from cachekit.backends.memcached import MemcachedBackend, MemcachedBackendConfig
+
+                self._memcached_backend = MemcachedBackend(MemcachedBackendConfig.from_env())
+            return self._memcached_backend
+
+        if choice == "file":
+            if self._file_backend is None:
+                from cachekit.backends.file import FileBackend, FileBackendConfig
+
+                self._file_backend = FileBackend(FileBackendConfig.from_env())
+            return self._file_backend
+
+        # choice == "redis" (explicit CACHEKIT_REDIS_URL) or None (REDIS_URL / localhost fallback).
+        # Tenant-scoped: call the provider each time so it re-reads tenant_context.
         if self._redis_provider is None:
             from cachekit.backends.redis.config import RedisBackendConfig
             from cachekit.backends.redis.provider import RedisBackendProvider, tenant_context

{cachekit-0.7.0 → cachekit-0.8.0}/src/cachekit/backends/redis/provider.py

@@ -327,7 +327,10 @@ class PerRequestRedisBackend:
         """Acquire distributed lock (LockableBackend protocol).
 
         Args:
-            key: Lock key (will be tenant-scoped)
+            key: Bare cache key (will be tenant-scoped and ``:lock``-suffixed internally).
+                The LockableBackend protocol passes the same key as ``get``/``set``/``delete``;
+                the ``:lock`` namespace is a Redis-backend implementation detail kept
+                on-wire for zero-migration compatibility with existing deployments.
             timeout: How long to hold lock (seconds) before auto-release
             blocking_timeout: Max time to wait for lock (None = non-blocking)
 
@@ -343,7 +346,11 @@ class PerRequestRedisBackend:
         """
         import asyncio
 
-        scoped_key = self._scoped_key(key)
+        # Derive the on-wire Redis lock name from the bare cache key: ``<scoped_key>:lock``.
+        # Keeping this suffix on the wire preserves compatibility with existing Redis
+        # deployments — the lock identity didn't change, only the protocol boundary
+        # (the wrapper no longer pollutes the cache_key passed in).
+        scoped_key = f"{self._scoped_key(key)}:lock"
         lock = None
         try:
             from redis.lock import Lock

{cachekit-0.7.0 → cachekit-0.8.0}/src/cachekit/decorators/wrapper.py

@@ -1060,8 +1060,11 @@ def create_cache_wrapper(
                 )
 
             # CACHE MISS - Use distributed lock to prevent thundering herd
-            # This ensures only one request executes the function while others wait
-            lock_key = f"{cache_key}:lock"
+            # This ensures only one request executes the function while others wait.
+            # LockableBackend protocol contract: pass the bare cache_key. Each backend
+            # owns its internal lock-namespace derivation (Redis: ``<key>:lock``; SaaS:
+            # ``POST /v1/cache/{key}/lock``). Appending here would pollute the SaaS
+            # 7-segment canonical key and 400 at the edge.
             lock_timeout = 30.0  # Lock expires after 30 seconds to prevent deadlock
             blocking_timeout = 5.0  # Wait up to 5 seconds to acquire lock
 
@@ -1070,7 +1073,7 @@ def create_cache_wrapper(
                 try:
                     # Use backend's async lock protocol
                     async with _backend.acquire_lock(
-                        lock_key,
+                        cache_key,
                         timeout=lock_timeout,
                         blocking_timeout=blocking_timeout,
                     ) as lock_acquired:
@@ -1102,9 +1105,7 @@ def create_cache_wrapper(
                         else:
                             # Lock timeout - double-check cache before giving up
                             # Another request may have populated it while we waited
-                            logger().warning(
-                                f"Failed to acquire lock for {cache_key} (lock_key={lock_key}) after {blocking_timeout}s, checking cache"
-                            )
+                            logger().warning(f"Failed to acquire lock for {cache_key} after {blocking_timeout}s, checking cache")
                             try:
                                 cached_data = await operation_handler.cache_handler.get_async(cache_key)  # type: ignore[attr-defined]
                                 if cached_data is not None:
@@ -1202,7 +1203,7 @@ def create_cache_wrapper(
                             raise e.original_exception from e
 
                     # Lock operation failed - execute without lock
-                    logger().warning(f"Lock operation failed for {cache_key} (lock_key={lock_key}), executing without lock: {e}")
+                    logger().warning(f"Lock operation failed for {cache_key}, executing without lock: {e}")
                     # Fall through to execute without locking
 
             # Execute without locking (either backend doesn't support it or lock failed)

{cachekit-0.7.0 → cachekit-0.8.0}/src/cachekit/reliability/adaptive_timeout.py

@@ -161,11 +161,12 @@ class AdaptiveTimeoutManager:
         # Get adaptive timeouts for lock operations
         lock_timeout, blocking_timeout = timeout_manager.get_lock_timeouts()
 
-        redis_lock = redis_client.lock(
-            lock_key,
+        async with backend.acquire_lock(
+            cache_key,
             timeout=lock_timeout,
-            blocking_timeout=blocking_timeout
-        )
+            blocking_timeout=blocking_timeout,
+        ) as acquired:
+            ...
 
     Examples:
         Create manager with defaults:
@@ -360,11 +361,12 @@ class AdaptiveTimeoutManager:
 
         Example:
             lock_timeout, blocking_timeout = manager.get_lock_timeouts()
-            redis_lock = redis_client.lock(
-                lock_key,
+            async with backend.acquire_lock(
+                cache_key,
                 timeout=lock_timeout,
-                blocking_timeout=blocking_timeout
-            )
+                blocking_timeout=blocking_timeout,
+            ) as acquired:
+                ...
         """
         with self._lock:
             return (self._current_lock_timeout, self._current_blocking_timeout)