xtr-cache 1.4.0__tar.gz → 2.0.0__tar.gz

{xtr_cache-1.4.0 → xtr_cache-2.0.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: xtr-cache
-Version: 1.4.0
+Version: 2.0.0
 Summary: Cache pools in memory, in files, in Redis, chained or tag-aware, with stampede protection.
 Keywords: cache,redis,stampede,tags,asyncio
-Author: Razvan Ceana
-Author-email: Razvan Ceana <razvan@ceana.ro>
+Author: Xterr
+Author-email: Xterr <me@xterr.dev>
 License-Expression: MIT
 License-File: LICENSE
 Classifier: Development Status :: 3 - Alpha
@@ -16,14 +16,14 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Typing :: Typed
 Requires-Dist: typing-extensions>=4.4
-Requires-Dist: xtr-cache-contracts>=1.0,<2
-Requires-Dist: xtr-clock>=1.0,<2
-Requires-Dist: xtr-lock>=1.0,<2
-Requires-Dist: xtr-logging-contracts>=1.0,<2
-Requires-Dist: xtr-console>=1.0,<2 ; extra == 'console'
-Requires-Dist: xtr-dependency-injection>=1.0,<2 ; extra == 'di'
-Requires-Dist: xtr-service-contracts>=1.0,<2 ; extra == 'di'
-Requires-Dist: xtr-logging>=1.0,<2 ; extra == 'logging'
+Requires-Dist: xtr-cache-contracts>=2.0,<3
+Requires-Dist: xtr-clock>=2.0,<3
+Requires-Dist: xtr-lock>=2.0,<3
+Requires-Dist: xtr-logging-contracts>=2.0,<3
+Requires-Dist: xtr-console>=2.0,<3 ; extra == 'console'
+Requires-Dist: xtr-dependency-injection>=2.0,<3 ; extra == 'di'
+Requires-Dist: xtr-service-contracts>=2.0,<3 ; extra == 'di'
+Requires-Dist: xtr-logging>=2.0,<3 ; extra == 'logging'
 Requires-Dist: redis>=5.0 ; extra == 'redis'
 Requires-Dist: pynacl>=1.5 ; extra == 'sodium'
 Requires-Python: >=3.11
@@ -174,7 +174,8 @@ first write. An expired file is removed when read; `await pool.prune()` removes
 Given no directory, a pool uses `xtr-cache` in the system's temporary directory, which any user
 may create first. Values are unpickled when read, so that directory is made readable by its owner
 alone, and one belonging to another user is refused: reads miss, writes fail, and the pool logs
-why. A directory you give is used as it is.
+why. A directory you give is used as it is. Where the system has no user ids to compare, as
+on Windows, neither check applies: the directory is created, but its owner is not checked.
 
 ### `RedisAdapter`
 
@@ -184,7 +185,7 @@ from xtr_cache import RedisAdapter
 
 pool = RedisAdapter(Redis.from_url("redis://cache:6379/0"), "app")  # your client, you close it
 pool = RedisAdapter.from_url("redis://cache:6379/0", "app")  # its own client ...
-await pool.aclose()  # ... which it closes
+await pool.close()  # ... which it closes
 ```
 
 Each value is a string key, `namespace:key`, expired by the server itself. Reads fetch many keys
@@ -226,6 +227,9 @@ deletes its version. Nothing is listed or scanned, so invalidating costs the sam
 items carry the tag. Versions read are trusted for `known_tag_versions_ttl` seconds (0.15 by
 default), which is how soon an invalidation elsewhere reaches this process. Items saved as
 deferred take their versions when committed, so an invalidation meanwhile does not apply to them.
+A tag's first version is given one save at a time in a process; two processes giving one at the
+same moment may each keep their own, and the items of the one that lost miss once and are
+computed again.
 
 Tagging an item of any other pool raises `LogicError`.
 
@@ -234,7 +238,9 @@ Tagging an item of any other pool raises `LogicError`.
 `get()` protects the backend three ways:
 
 - **One computation per key in a process.** Concurrent misses on one key share the first caller's
-  computation. If it fails or is cancelled, the others compute for themselves, side by side.
+  computation — and its result: they all get the very object computed, so copy it before changing
+  it; what is cached is not affected. If it fails or is cancelled, the others compute for
+  themselves, side by side.
 - **One computation per key across processes**, with a `LockRegistry`. Keys are spread over
   `slots` locks (20 by default); the caller that takes a key's slot computes and saves, the others
   wait for it and read what was saved — or compute themselves after `wait` seconds (30), so a stuck

{xtr_cache-1.4.0 → xtr_cache-2.0.0}/README.md

@@ -138,7 +138,8 @@ first write. An expired file is removed when read; `await pool.prune()` removes
 Given no directory, a pool uses `xtr-cache` in the system's temporary directory, which any user
 may create first. Values are unpickled when read, so that directory is made readable by its owner
 alone, and one belonging to another user is refused: reads miss, writes fail, and the pool logs
-why. A directory you give is used as it is.
+why. A directory you give is used as it is. Where the system has no user ids to compare, as
+on Windows, neither check applies: the directory is created, but its owner is not checked.
 
 ### `RedisAdapter`
 
@@ -148,7 +149,7 @@ from xtr_cache import RedisAdapter
 
 pool = RedisAdapter(Redis.from_url("redis://cache:6379/0"), "app")  # your client, you close it
 pool = RedisAdapter.from_url("redis://cache:6379/0", "app")  # its own client ...
-await pool.aclose()  # ... which it closes
+await pool.close()  # ... which it closes
 ```
 
 Each value is a string key, `namespace:key`, expired by the server itself. Reads fetch many keys
@@ -190,6 +191,9 @@ deletes its version. Nothing is listed or scanned, so invalidating costs the sam
 items carry the tag. Versions read are trusted for `known_tag_versions_ttl` seconds (0.15 by
 default), which is how soon an invalidation elsewhere reaches this process. Items saved as
 deferred take their versions when committed, so an invalidation meanwhile does not apply to them.
+A tag's first version is given one save at a time in a process; two processes giving one at the
+same moment may each keep their own, and the items of the one that lost miss once and are
+computed again.
 
 Tagging an item of any other pool raises `LogicError`.
 
@@ -198,7 +202,9 @@ Tagging an item of any other pool raises `LogicError`.
 `get()` protects the backend three ways:
 
 - **One computation per key in a process.** Concurrent misses on one key share the first caller's
-  computation. If it fails or is cancelled, the others compute for themselves, side by side.
+  computation — and its result: they all get the very object computed, so copy it before changing
+  it; what is cached is not affected. If it fails or is cancelled, the others compute for
+  themselves, side by side.
 - **One computation per key across processes**, with a `LockRegistry`. Keys are spread over
   `slots` locks (20 by default); the caller that takes a key's slot computes and saves, the others
   wait for it and read what was saved — or compute themselves after `wait` seconds (30), so a stuck

{xtr_cache-1.4.0 → xtr_cache-2.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xtr-cache"
-version = "1.4.0"
+version = "2.0.0"
 description = "Cache pools in memory, in files, in Redis, chained or tag-aware, with stampede protection."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -25,25 +25,25 @@ classifiers = [
 ]
 dependencies = [
     "typing-extensions>=4.4",
-    "xtr-cache-contracts>=1.0,<2",
-    "xtr-clock>=1.0,<2",
-    "xtr-lock>=1.0,<2",
-    "xtr-logging-contracts>=1.0,<2",
+    "xtr-cache-contracts>=2.0,<3",
+    "xtr-clock>=2.0,<3",
+    "xtr-lock>=2.0,<3",
+    "xtr-logging-contracts>=2.0,<3",
 ]
 
 [[project.authors]]
-name = "Razvan Ceana"
-email = "razvan@ceana.ro"
+name = "Xterr"
+email = "me@xterr.dev"
 
 [project.optional-dependencies]
 redis = ["redis>=5.0"]
 sodium = ["pynacl>=1.5"]
 di = [
-    "xtr-dependency-injection>=1.0,<2",
-    "xtr-service-contracts>=1.0,<2",
+    "xtr-dependency-injection>=2.0,<3",
+    "xtr-service-contracts>=2.0,<3",
 ]
-console = ["xtr-console>=1.0,<2"]
-logging = ["xtr-logging>=1.0,<2"]
+console = ["xtr-console>=2.0,<3"]
+logging = ["xtr-logging>=2.0,<3"]
 
 [project.entry-points."xtr_dependency_injection.bundles"]
 cache = "xtr_cache.bundle:CacheBundle"
@@ -58,10 +58,10 @@ dev = [
     "ty>=0.0.83",
     "pynacl>=1.5",
     "redis>=5.0",
-    "xtr-console>=1.0,<2",
-    "xtr-dependency-injection>=1.0,<2",
-    "xtr-logging>=1.0,<2",
-    "xtr-service-contracts>=1.0,<2",
+    "xtr-console>=2.0,<3",
+    "xtr-dependency-injection>=2.0,<3",
+    "xtr-logging>=2.0,<3",
+    "xtr-service-contracts>=2.0,<3",
 ]
 
 [build-system]

{xtr_cache-1.4.0 → xtr_cache-2.0.0}/pyproject.toml.orig

@@ -1,13 +1,13 @@
 [project]
 name = "xtr-cache"
-version = "1.4.0"
+version = "2.0.0"
 description = "Cache pools in memory, in files, in Redis, chained or tag-aware, with stampede protection."
 readme = "README.md"
 requires-python = ">=3.11"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [
-    { name = "Razvan Ceana", email = "razvan@ceana.ro" }
+    { name = "Xterr", email = "me@xterr.dev" }
 ]
 keywords = ["cache", "redis", "stampede", "tags", "asyncio"]
 classifiers = [
@@ -22,10 +22,10 @@ classifiers = [
 ]
 dependencies = [
     "typing-extensions>=4.4",
-    "xtr-cache-contracts>=1.0,<2",
-    "xtr-clock>=1.0,<2",
-    "xtr-lock>=1.0,<2",
-    "xtr-logging-contracts>=1.0,<2",
+    "xtr-cache-contracts>=2.0,<3",
+    "xtr-clock>=2.0,<3",
+    "xtr-lock>=2.0,<3",
+    "xtr-logging-contracts>=2.0,<3",
 ]
 
 [project.optional-dependencies]
@@ -36,14 +36,14 @@ sodium = [
     "pynacl>=1.5",
 ]
 di = [
-    "xtr-dependency-injection>=1.0,<2",
-    "xtr-service-contracts>=1.0,<2",
+    "xtr-dependency-injection>=2.0,<3",
+    "xtr-service-contracts>=2.0,<3",
 ]
 console = [
-    "xtr-console>=1.0,<2",
+    "xtr-console>=2.0,<3",
 ]
 logging = [
-    "xtr-logging>=1.0,<2",
+    "xtr-logging>=2.0,<3",
 ]
 
 # Advertises the bundle so debug:bundles can name it when installed but not listed.
@@ -61,10 +61,10 @@ dev = [
     "ty>=0.0.83",
     "pynacl>=1.5",
     "redis>=5.0",
-    "xtr-console>=1.0,<2",
-    "xtr-dependency-injection>=1.0,<2",
-    "xtr-logging>=1.0,<2",
-    "xtr-service-contracts>=1.0,<2",
+    "xtr-console>=2.0,<3",
+    "xtr-dependency-injection>=2.0,<3",
+    "xtr-logging>=2.0,<3",
+    "xtr-service-contracts>=2.0,<3",
 ]
 
 [build-system]

xtr_cache-2.0.0/src/xtr_cache/_digest.py

@@ -0,0 +1,18 @@
+"""A short, key-safe digest of a text, for what the pools store under names derived from it."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+
+__all__ = ["urlsafe_digest"]
+
+
+def urlsafe_digest(text: str, *, size: int = 32) -> str:
+    """Return the first ``size`` bytes of ``text``'s SHA-256, in URL-safe base64 without padding.
+
+    Stored identifiers and file names are made from it: its output must never
+    change, or what was stored could no longer be found.
+    """
+    digest = hashlib.sha256(text.encode()).digest()[:size]
+    return base64.urlsafe_b64encode(digest).decode().rstrip("=")

{xtr_cache-1.4.0 → xtr_cache-2.0.0}/src/xtr_cache/adapter/abstract_adapter.py

@@ -2,9 +2,7 @@
 
 from __future__ import annotations
 
-import base64
 import contextlib
-import hashlib
 import math
 import re
 from abc import ABC, abstractmethod
@@ -13,6 +11,7 @@ from typing import TYPE_CHECKING, ClassVar, Final, Self
 from typing_extensions import override
 from xtr_cache_contracts import InvalidArgumentError, NamespacedPoolInterface
 
+from xtr_cache._digest import urlsafe_digest
 from xtr_cache.cache_item import CacheItem
 from xtr_cache.exception.marshalling_error import MarshallingError
 
@@ -267,6 +266,7 @@ class AbstractAdapter(
 
     @override
     def with_sub_namespace(self, namespace: str, /) -> Self:
+        _ = self._flights()  # made now, so the view shares it rather than make its own
         clone = self._unqueued_copy()
         clone._namespace = (  # noqa: SLF001 — a copy of this very class.
             self._namespace + CacheItem.validate_key(namespace) + self.NS_SEPARATOR
@@ -323,8 +323,7 @@ class AbstractAdapter(
         if self.max_id_length is None or len(id_) <= self.max_id_length:
             return id_
 
-        digest = base64.urlsafe_b64encode(hashlib.sha256(key.encode()).digest()[:16]).decode()
-        return self._namespace + digest.rstrip("=") + self.NS_SEPARATOR
+        return self._namespace + urlsafe_digest(key, size=16) + self.NS_SEPARATOR
 
     def _unmarshall_found(
         self,

{xtr_cache-1.4.0 → xtr_cache-2.0.0}/src/xtr_cache/adapter/adapter_factory.py

@@ -4,7 +4,12 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Final, final
 
-from xtr_lock.store import is_redis_client, is_redis_dsn, redis_installed
+from xtr_lock.store import (
+    describe_connection_scheme,
+    is_redis_client,
+    is_redis_dsn,
+    redis_installed,
+)
 
 from xtr_cache.exception import InvalidArgumentError
 
@@ -128,7 +133,6 @@ class AdapterFactory:
                 raise InvalidArgumentError(RedisAdapter.MISSING_CLIENT)
             return
 
-        scheme, separator, _ = connection.partition(":")
-        described = f"{scheme}:" if separator else connection
-
-        raise InvalidArgumentError(f'Unsupported cache connection: "{described}".')
+        raise InvalidArgumentError(
+            f'Unsupported cache connection: "{describe_connection_scheme(connection)}".'
+        )

{xtr_cache-1.4.0 → xtr_cache-2.0.0}/src/xtr_cache/adapter/array_adapter.py

@@ -2,12 +2,14 @@
 
 from __future__ import annotations
 
+import dataclasses
 from typing import TYPE_CHECKING, cast, final
 
 from typing_extensions import override
 
 from xtr_cache.exception import InvalidArgumentError, MarshallingError
 from xtr_cache.marshaller.default_marshaller import DefaultMarshaller
+from xtr_cache.value_wrapper import ValueWrapper
 
 from .abstract_adapter import AbstractAdapter
 
@@ -144,6 +146,8 @@ class ArrayAdapter(AbstractAdapter):
         if self._max_lifetime and (not lifetime or lifetime > self._max_lifetime):
             lifetime = self._max_lifetime
         expiry = self._clock.now().timestamp() + lifetime if lifetime else None
+        if expiry is not None:
+            values = {id_: _capped(value, expiry) for id_, value in values.items()}
 
         failed: list[str] = []
         stored: Mapping[str, object] = values
@@ -163,3 +167,12 @@ class ArrayAdapter(AbstractAdapter):
     @override
     def __repr__(self) -> str:
         return f"{type(self).__name__}({self._default_lifetime!r})"
+
+
+def _capped(value: object, expiry: float) -> object:
+    """Return ``value``, its recorded expiry no later than ``expiry``, when the entry is."""
+    if not isinstance(value, ValueWrapper) or value.metadata.get("expiry", expiry) <= expiry:
+        return value
+    metadata = value.metadata.copy()
+    metadata["expiry"] = expiry
+    return dataclasses.replace(value, metadata=metadata)

{xtr_cache-1.4.0 → xtr_cache-2.0.0}/src/xtr_cache/adapter/contracts_mixin.py

@@ -44,8 +44,10 @@ class ContractsMixin(CacheMixin, LoggerAware, ABC):
 
     - It is saved with how long it took, which — with its expiry — is what
       makes early recomputation possible on a later read.
-    - Concurrent misses on one key in this process share one computation. If
-      it fails or is cancelled, each of the others computes for itself.
+    - Concurrent misses on one key in this process share one computation, and
+      its result: each of them gets the very object computed, so change it
+      only after copying it. What is cached stays apart. If the computation
+      fails or is cancelled, each of the others computes for itself.
     - With a :class:`~xtr_cache.lock_registry.LockRegistry`, misses in every
       process sharing its locks share one computation too.
     - A callback reading its own key — directly or through what it calls —

{xtr_cache-1.4.0 → xtr_cache-2.0.0}/src/xtr_cache/adapter/filesystem_adapter.py

@@ -3,8 +3,6 @@
 from __future__ import annotations
 
 import asyncio
-import base64
-import hashlib
 import os
 import secrets
 import stat
@@ -16,6 +14,7 @@ from urllib.parse import quote, unquote
 
 from typing_extensions import override
 
+from xtr_cache._digest import urlsafe_digest
 from xtr_cache.exception import InvalidArgumentError
 from xtr_cache.marshaller.default_marshaller import DefaultMarshaller
 from xtr_cache.pruneable_interface import PruneableInterface
@@ -149,8 +148,7 @@ class FilesystemAdapter(AbstractAdapter, PruneableInterface):
         return f"{name}({self._namespace!r}, {self._default_lifetime!r}, {str(self._directory)!r})"
 
     def _path(self, id_: str) -> Path:
-        digest = base64.urlsafe_b64encode(hashlib.sha256(id_.encode()).digest()).decode()
-        digest = digest.rstrip("=")
+        digest = urlsafe_digest(id_)
         return self._directory / digest[0] / digest[1] / digest[2:]
 
     def _read_all(self, ids: Sequence[str], now: float) -> dict[str, bytes]:
@@ -225,7 +223,9 @@ class FilesystemAdapter(AbstractAdapter, PruneableInterface):
         Only the default directory is checked: one the application chose is
         its own. Creating it makes it private; an existing one of this user's
         is made private too. Once found trustworthy, it stays so: in a
-        temporary directory nobody else may rename or remove it.
+        temporary directory nobody else may rename or remove it. Where the
+        system has no user ids, as on Windows, the owner compared is the
+        directory's own, so the check passes: the directory is taken as it is.
         """
         root = self._private_root
         if root is None or self._private_root_checked:

{xtr_cache-1.4.0 → xtr_cache-2.0.0}/src/xtr_cache/adapter/redis_adapter.py

@@ -134,7 +134,7 @@ class RedisAdapter(AbstractAdapter):
     ) -> RedisAdapter:
         """Connect to the server ``dsn`` names, on first use, and own the connection.
 
-        Close the adapter with :meth:`aclose` when done.
+        Close the adapter with :meth:`close` when done.
 
         Raises:
             InvalidArgumentError: When the scheme is not a Redis one, or the
@@ -168,10 +168,10 @@ class RedisAdapter(AbstractAdapter):
 
     @property
     def owns_connection(self) -> bool:
-        """Whether :meth:`aclose` closes the client, because :meth:`from_url` opened it."""
+        """Whether :meth:`close` closes the client, because :meth:`from_url` opened it."""
         return self._owns_connection
 
-    async def aclose(self) -> None:
+    async def close(self) -> None:
         """Close the connection, when :meth:`from_url` opened it; otherwise do nothing."""
         if self._owns_connection:
             await self._redis.aclose()

{xtr_cache-1.4.0 → xtr_cache-2.0.0}/src/xtr_cache/adapter/tag_aware_adapter.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import secrets
 from datetime import UTC, datetime
 from typing import TYPE_CHECKING, Final, Self, final
@@ -63,6 +64,7 @@ class TagAwareAdapter(
     _known_ttl: float
     _known: dict[str, tuple[str | None, float]]
     _deferred: dict[str, CacheItem]
+    _minting: asyncio.Lock
 
     def __init__(
         self,
@@ -89,6 +91,7 @@ class TagAwareAdapter(
         self._known_ttl = known_tag_versions_ttl
         self._known = {}
         self._deferred = {}
+        self._minting = asyncio.Lock()
         if clock is not None:
             self._clock = clock
 
@@ -175,6 +178,7 @@ class TagAwareAdapter(
 
     @override
     def with_sub_namespace(self, namespace: str, /) -> Self:
+        _ = self._flights()  # made now, so the view shares it rather than make its own
         clone = self._unqueued_copy()
         if isinstance(self._items, NamespacedPoolInterface):
             clone._items = self._items.with_sub_namespace(namespace)  # noqa: SLF001 — a copy of this very class.
@@ -242,19 +246,34 @@ class TagAwareAdapter(
         return versions
 
     async def _versions_for_saving(self, tags: Iterable[str]) -> dict[str, str]:
-        """Return each tag's version, giving a new one to every tag that has none."""
+        """Return each tag's version, giving a new one to every tag that has none.
+
+        New versions are given one save at a time: saves giving one tag a
+        version at once would each stamp their items with their own, and the
+        items of all but the last would never be hits.
+        """
         current = await self._current_versions(tags)
-        versions = {tag: found or secrets.token_hex(6) for tag, found in current.items()}
-        created = [tag for tag, found in current.items() if found is None]
-
-        for tag in created:
-            version = CacheItem(TAGS_PREFIX + tag, versions[tag], clock=self._clock)
-            _ = await self._tags.save_deferred(version.expires_after(_TAG_VERSION_LIFETIME))
-        # A version the tags pool did not keep must not be trusted here while others miss it.
-        if created and await self._tags.commit():
-            now = self._clock.now().timestamp()
+        if all(found is not None for found in current.values()):
+            return {tag: found for tag, found in current.items() if found is not None}
+
+        async with self._minting:
+            # A save holding the lock before this one may have given them one meanwhile.
+            current.update(
+                await self._current_versions(
+                    [tag for tag, found in current.items() if found is None]
+                )
+            )
+            versions = {tag: found or secrets.token_hex(6) for tag, found in current.items()}
+            created = [tag for tag, found in current.items() if found is None]
+
             for tag in created:
-                self._remember(tag, versions[tag], now)
+                version = CacheItem(TAGS_PREFIX + tag, versions[tag], clock=self._clock)
+                _ = await self._tags.save_deferred(version.expires_after(_TAG_VERSION_LIFETIME))
+            # A version the tags pool did not keep must not be trusted here while others miss it.
+            if created and await self._tags.commit():
+                now = self._clock.now().timestamp()
+                for tag in created:
+                    self._remember(tag, versions[tag], now)
 
         return versions
 

{xtr_cache-1.4.0 → xtr_cache-2.0.0}/src/xtr_cache/bundle/cache_bundle.py

@@ -19,8 +19,6 @@ container closes; between messages, the kernel's resetter commits it.
 
 from __future__ import annotations
 
-import base64
-import hashlib
 from collections.abc import AsyncIterator, Awaitable, Callable
 from typing import Final, final
 
@@ -48,6 +46,7 @@ from xtr_lock.store import RedisStore, StoreFactory
 from xtr_logging_contracts import LoggerAwareInterface, LoggerInterface
 from xtr_service_contracts import ContainerInterface
 
+from xtr_cache._digest import urlsafe_digest
 from xtr_cache.adapter.adapter_factory import AdapterFactory
 from xtr_cache.adapter.adapter_interface import AdapterInterface
 from xtr_cache.adapter.chain_adapter import ChainAdapter
@@ -96,7 +95,7 @@ class CacheBundle(Bundle[CacheConfig]):
         if not bundle_active(builder, "logging"):
             return
         # Logging is an optional peer, importable only once it is active.
-        from xtr_logging.bundle import LoggingConfig  # noqa: PLC0415
+        from xtr_logging.bundle import LoggingConfig  # noqa: PLC0415 — optional peer
 
         def add_cache_channel(config: LoggingConfig) -> LoggingConfig:
             return config.with_channels(CACHE_CHANNEL)
@@ -193,7 +192,7 @@ async def _lock_registry(
         yield registry
     finally:
         if isinstance(store, RedisStore):
-            await store.aclose()
+            await store.close()
 
 
 def _cache_pool_clearer(config: CacheConfig, container: ContainerInterface) -> CachePoolClearer:
@@ -254,7 +253,7 @@ def _pool_factory(
             finally:
                 for each in built:
                     if isinstance(each, RedisAdapter):
-                        await each.aclose()
+                        await each.close()
 
     return pool
 
@@ -285,5 +284,4 @@ async def _build_adapters(
 
 def _namespace(name: str, seed: str) -> str:
     """Derive a pool's namespace from its name and the seed: short, and a valid key."""
-    digest = hashlib.sha256(f"{name}.{seed}".encode()).digest()
-    return base64.urlsafe_b64encode(digest).decode("ascii")[:_NAMESPACE_LENGTH]
+    return urlsafe_digest(f"{name}.{seed}")[:_NAMESPACE_LENGTH]

{xtr_cache-1.4.0 → xtr_cache-2.0.0}/src/xtr_cache/marshaller/default_marshaller.py

@@ -51,7 +51,7 @@ class DefaultMarshaller(MarshallerInterface):
         try:
             # Only this application writes what is read here; see the class docstring.
             # pickle.loads is typed as returning Any; what it returns is any object.
-            return cast("object", pickle.loads(value))  # noqa: S301
+            return cast("object", pickle.loads(value))  # noqa: S301 — only this application writes it
         # Unpickling can raise whatever the stored object's reconstruction raises.
         except Exception as error:
             raise MarshallingError(f"the stored value cannot be unpickled: {error}") from error

{xtr_cache-1.4.0 → xtr_cache-2.0.0}/src/xtr_cache/marshaller/deflate_marshaller.py

@@ -3,10 +3,12 @@
 from __future__ import annotations
 
 import zlib
-from typing import TYPE_CHECKING, final
+from typing import TYPE_CHECKING, Final, final
 
 from typing_extensions import override
 
+from xtr_cache.exception import MarshallingError
+
 from .marshaller_interface import MarshallerInterface
 
 if TYPE_CHECKING:
@@ -14,6 +16,10 @@ if TYPE_CHECKING:
 
 __all__ = ["DeflateMarshaller"]
 
+_HEADER_LENGTH: Final = 2
+_DEFLATE: Final = 8
+"""The compression method a zlib header names in its low four bits."""
+
 
 @final
 class DeflateMarshaller(MarshallerInterface):
@@ -38,14 +44,32 @@ class DeflateMarshaller(MarshallerInterface):
 
     @override
     def unmarshall(self, value: bytes, /) -> object:
+        """Inflate ``value`` and decode it; bytes never compressed are decoded as they are.
+
+        Raises:
+            MarshallingError: If ``value`` is compressed but corrupt.
+        """
+        if not _compressed(value):
+            # Written before compression was switched on: read it as it is.
+            return self._marshaller.unmarshall(value)
         try:
             inflated = zlib.decompress(value)
-        except zlib.error:
-            # Written before compression was switched on: read it as it is.
-            inflated = value
+        except zlib.error as error:
+            raise MarshallingError(
+                f"the stored value is compressed but corrupt: {error}"
+            ) from error
 
         return self._marshaller.unmarshall(inflated)
 
     @override
     def __repr__(self) -> str:
         return f"{type(self).__name__}({self._marshaller!r})"
+
+
+def _compressed(value: bytes) -> bool:
+    """Tell whether ``value`` starts with a zlib header: deflate, and a check that adds up."""
+    return (
+        len(value) >= _HEADER_LENGTH
+        and value[0] & 0x0F == _DEFLATE
+        and ((value[0] << 8) | value[1]) % 31 == 0
+    )