meta-memcache 2.3.0__tar.gz → 2.5.0__tar.gz

{meta_memcache-2.3.0/src/meta_memcache.egg-info → meta_memcache-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-memcache
-Version: 2.3.0
+Version: 2.5.0
 Summary: Modern, pure python, memcache client with support for new meta commands.
 Author-email: Guillermo Perez <bisho@revenuecat.com>
 License: MIT License
@@ -434,6 +434,17 @@ Invalidation...
         Get multiple keys at once
         """
 
+    def multi_get_cas(
+        self,
+        keys: List[Union[Key, str]],
+        touch_ttl: Optional[int] = None,
+        recache_policy: Optional[RecachePolicy] = None,
+    ) -> Dict[Key, Tuple[Optional[Any], Optional[int]]]:
+        """
+        Same as multi_get(), but also return the CAS tokens so
+        they can be used during writes and detect races
+        """
+
     def get_cas(
         self,
         key: Union[Key, str],

{meta_memcache-2.3.0 → meta_memcache-2.5.0}/README.md

@@ -416,6 +416,17 @@ Invalidation...
         Get multiple keys at once
         """
 
+    def multi_get_cas(
+        self,
+        keys: List[Union[Key, str]],
+        touch_ttl: Optional[int] = None,
+        recache_policy: Optional[RecachePolicy] = None,
+    ) -> Dict[Key, Tuple[Optional[Any], Optional[int]]]:
+        """
+        Same as multi_get(), but also return the CAS tokens so
+        they can be used during writes and detect races
+        """
+
     def get_cas(
         self,
         key: Union[Key, str],

{meta_memcache-2.3.0 → meta_memcache-2.5.0}/pyproject.toml

@@ -8,7 +8,7 @@ dependencies = [
 authors = [{ name = "Guillermo Perez", email = "bisho@revenuecat.com" }]
 license = { text = "MIT License" }
 name = "meta-memcache"
-version = "2.3.0"
+version = "2.5.0"
 description = "Modern, pure python, memcache client with support for new meta commands."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -41,6 +41,11 @@ show_missing = true
 [tool.ruff]
 line-length = 88
 
+[tool.ruff.lint]
+# Ruff 0.16 expanded the default rule set from 59 to 413 rules. Pin the selection
+# to the pre-0.16 default so version bumps don't silently add new rules.
+select = ["E4", "E7", "E9", "F"]
+
 [tool.ruff.lint.per-file-ignores]
 "tests/*.py" = ["E731"]
 "src/meta_memcache/__init__.py" = ["F401"]

{meta_memcache-2.3.0 → meta_memcache-2.5.0}/src/meta_memcache/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.3.0"
+__version__ = "2.5.0"
 
 from meta_memcache.cache_client import CacheClient
 from meta_memcache.configuration import (

{meta_memcache-2.3.0 → meta_memcache-2.5.0}/src/meta_memcache/commands/high_level_commands.py

@@ -18,6 +18,7 @@ from meta_memcache.interfaces.high_level_commands import HighLevelCommandsProtoc
 from meta_memcache.interfaces.meta_commands import MetaCommandsProtocol
 from meta_memcache.interfaces.router import FailureHandling
 from meta_memcache.protocol import (
+    MA_MODE_DEC,
     Key,
     Miss,
     ReadResponse,
@@ -25,7 +26,6 @@ from meta_memcache.protocol import (
     SetMode,
     Success,
     Value,
-    MA_MODE_DEC,
 )
 
 T = TypeVar("T")
@@ -59,6 +59,15 @@ class HighLevelCommandMixinWithMetaCommands(
         return_cas_token: bool = False,
     ) -> Optional[Value]: ...  # pragma: no cover
 
+    def _get_or_lease(
+        self,
+        key: Union[Key, str],
+        lease_policy: LeasePolicy,
+        touch_ttl: Optional[int] = None,
+        recache_policy: Optional[RecachePolicy] = None,
+        lease_wait_fn: Optional[Callable[[float], None]] = None,
+    ) -> Optional[Value]: ...  # pragma: no cover
+
     def _process_get_result(
         self, key: Union[Key, str], result: ReadResponse
     ) -> Optional[Value]: ...  # pragma: no cover
@@ -249,14 +258,14 @@ class HighLevelCommandsMixin:
         ``lease_wait_fn`` is invoked with the number of seconds to wait
         between lease retries. Defaults to ``time.sleep``.
         """
-        value, _ = self.get_or_lease_cas(
+        result = self._get_or_lease(
             key=key,
             lease_policy=lease_policy,
             touch_ttl=touch_ttl,
             recache_policy=recache_policy,
             lease_wait_fn=lease_wait_fn,
         )
-        return value
+        return result.value if result is not None else None
 
     def get_or_lease_cas(
         self: HighLevelCommandMixinWithMetaCommands,
@@ -270,6 +279,35 @@ class HighLevelCommandsMixin:
         Same as get_or_lease(), but also return the CAS token so
         it can be used during writes and detect races
         """
+        result = self._get_or_lease(
+            key=key,
+            lease_policy=lease_policy,
+            touch_ttl=touch_ttl,
+            recache_policy=recache_policy,
+            lease_wait_fn=lease_wait_fn,
+        )
+        if result is None:
+            return None, None
+        return result.value, result.flags.cas_token
+
+    def _get_or_lease(
+        self: HighLevelCommandMixinWithMetaCommands,
+        key: Union[Key, str],
+        lease_policy: LeasePolicy,
+        touch_ttl: Optional[int] = None,
+        recache_policy: Optional[RecachePolicy] = None,
+        lease_wait_fn: Optional[Callable[[float], None]] = None,
+    ) -> Optional[Value]:
+        """
+        Internal version of get_or_lease() that returns the raw Value, so
+        wrappers can inspect the response flags, i.e. to decide whether the
+        value is worth promoting into a local cache, or read the CAS token.
+
+        `Value.value` is None when the caller must behave as if this was a
+        miss: either it won the lease, or it lost and ran out of retries.
+        The Value itself is still returned in both cases, since the lease
+        winner needs its CAS token to write the value back.
+        """
         if lease_policy.miss_retries <= 0:
             raise ValueError(
                 "Wrong lease_policy: miss_retries needs to be greater than 0"
@@ -295,30 +333,25 @@ class HighLevelCommandsMixin:
                 return_cas_token=True,
             )
 
-            if isinstance(result, Value):
-                # It is a hit.
-                if result.flags.win:
-                    # Win flag present, meaning we got the lease to
-                    # recache/cache the item. We need to mimic a miss.
-                    return None, result.flags.cas_token
-                if result.size == 0 and result.flags.win is False:
-                    # The value is empty, this is a miss lease,
-                    # and we lost, so we must keep retrying and
-                    # wait for the.flags.winner to populate the value.
-                    if i < lease_policy.miss_retries:
-                        continue
-                    else:
-                        # We run out of retries, behave as a miss
-                        return None, result.flags.cas_token
-                else:
-                    # There is data, either the is no lease or
-                    # we lost and should use the stale value.
-                    return result.value, result.flags.cas_token
-            else:
+            if not isinstance(result, Value):
                 # With MISS_LEASE_TTL we should always get a value
                 # because on miss a lease empty value is generated
                 raise MemcacheError(f"Unexpected response: {result} for key {key}")
 
+            if (
+                result.size == 0
+                and result.flags.win is False
+                and i < lease_policy.miss_retries
+            ):
+                # This is a miss lease and we lost, so we must keep retrying
+                # and wait for the winner to populate the value.
+                continue
+
+            # Either there is data, or we got a placeholder: we won the lease,
+            # or we lost and ran out of retries. _process_get_result() already
+            # cleared the value of the placeholders, so both behave as a miss.
+            return result
+
     def get(
         self: HighLevelCommandMixinWithMetaCommands,
         key: Union[Key, str],
@@ -352,6 +385,27 @@ class HighLevelCommandsMixin:
         )
         return {k: v.value if v is not None else None for k, v in results.items()}
 
+    def multi_get_cas(
+        self: HighLevelCommandMixinWithMetaCommands,
+        keys: Iterable[Union[Key, str]],
+        touch_ttl: Optional[int] = None,
+        recache_policy: Optional[RecachePolicy] = None,
+    ) -> Dict[Key, Tuple[Optional[Any], Optional[int]]]:
+        """
+        Same as multi_get(), but also return the CAS tokens so
+        they can be used during writes and detect races
+        """
+        results = self._multi_get(
+            keys=keys,
+            touch_ttl=touch_ttl,
+            recache_policy=recache_policy,
+            return_cas_token=True,
+        )
+        return {
+            k: (v.value, v.flags.cas_token) if v is not None else (None, None)
+            for k, v in results.items()
+        }
+
     def _multi_get(
         self: HighLevelCommandMixinWithMetaCommands,
         keys: Iterable[Union[Key, str]],
@@ -423,6 +477,11 @@ class HighLevelCommandsMixin:
                 # recache the item. We need to mimic a miss, so
                 # we set the value to None.
                 result.value = None
+            elif result.size == 0 and result.flags.win is False:
+                # An empty value with a lose flag is the placeholder the
+                # server plants on a lease miss, while the winner
+                # repopulates it. There is no value to return either.
+                result.value = None
             return result
         elif isinstance(result, Miss):
             return None

{meta_memcache-2.3.0 → meta_memcache-2.5.0}/src/meta_memcache/extras/probabilistic_hot_cache.py

@@ -1,13 +1,13 @@
+import pickle
 import random
 import threading
 import time
 from dataclasses import dataclass
-from typing import Any, Dict, Iterable, List, Optional, Tuple, Union
-import pickle
+from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union
 
 from marisa_trie import Trie  # type: ignore
 
-from meta_memcache.configuration import RecachePolicy
+from meta_memcache.configuration import LeasePolicy, RecachePolicy
 from meta_memcache.extras.client_wrapper import ClientWrapper
 from meta_memcache.interfaces.cache_api import CacheApi
 from meta_memcache.metrics.base import BaseMetricsCollector, MetricDefinition
@@ -191,6 +191,39 @@ class ProbabilisticHotCache(ClientWrapper):
         key: Union[Key, str],
         touch_ttl: Optional[int] = None,
         recache_policy: Optional[RecachePolicy] = None,
+    ) -> Optional[Any]:
+        return self._hot_cache_get(
+            key=key,
+            touch_ttl=touch_ttl,
+            recache_policy=recache_policy,
+        )
+
+    def get_or_lease(
+        self,
+        key: Union[Key, str],
+        lease_policy: LeasePolicy,
+        touch_ttl: Optional[int] = None,
+        recache_policy: Optional[RecachePolicy] = None,
+        lease_wait_fn: Optional[Callable[[float], None]] = None,
+    ) -> Optional[Any]:
+        # A hot cache hit needs no lease: the value is already local and there
+        # is nothing to repopulate. Only the requests that fall through to the
+        # server take part in the lease.
+        return self._hot_cache_get(
+            key=key,
+            touch_ttl=touch_ttl,
+            recache_policy=recache_policy,
+            lease_policy=lease_policy,
+            lease_wait_fn=lease_wait_fn,
+        )
+
+    def _hot_cache_get(
+        self,
+        key: Union[Key, str],
+        touch_ttl: Optional[int] = None,
+        recache_policy: Optional[RecachePolicy] = None,
+        lease_policy: Optional[LeasePolicy] = None,
+        lease_wait_fn: Optional[Callable[[float], None]] = None,
     ) -> Optional[Any]:
         key = key if isinstance(key, Key) else Key(key)
         if self._allowed_prefixes and not self._allowed_prefixes.prefixes(key.key):
@@ -203,12 +236,26 @@ class ProbabilisticHotCache(ClientWrapper):
             if found:
                 return value
 
-        result = self._get(
-            key=key,
-            touch_ttl=touch_ttl,
-            recache_policy=recache_policy,
-            return_cas_token=False,
-        )
+        if lease_policy is not None:
+            result = self._get_or_lease(
+                key=key,
+                lease_policy=lease_policy,
+                touch_ttl=touch_ttl,
+                recache_policy=recache_policy,
+                lease_wait_fn=lease_wait_fn,
+            )
+            if result and result.value is None:
+                # Lease placeholder: we hold the lease, or we lost and ran out
+                # of retries. Behaves as a miss, and nothing worth promoting.
+                result = None
+        else:
+            result = self._get(
+                key=key,
+                touch_ttl=touch_ttl,
+                recache_policy=recache_policy,
+                return_cas_token=False,
+            )
+
         if result is None:
             allowed and self._metrics and self._metrics.metric_inc("candidate_misses")
             is_hot and self._clear_hot_cache_if_necessary(key)

{meta_memcache-2.3.0 → meta_memcache-2.5.0}/src/meta_memcache/interfaces/high_level_commands.py

@@ -120,6 +120,13 @@ class HighLevelCommandsProtocol(Protocol):
         recache_policy: Optional[RecachePolicy] = None,
     ) -> Dict[Key, Optional[Any]]: ...  # pragma: no cover
 
+    def multi_get_cas(
+        self,
+        keys: Iterable[Union[Key, str]],
+        touch_ttl: Optional[int] = None,
+        recache_policy: Optional[RecachePolicy] = None,
+    ) -> Dict[Key, Tuple[Optional[Any], Optional[int]]]: ...  # pragma: no cover
+
     def _multi_get(
         self,
         keys: Iterable[Union[Key, str]],

{meta_memcache-2.3.0 → meta_memcache-2.5.0/src/meta_memcache.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-memcache
-Version: 2.3.0
+Version: 2.5.0
 Summary: Modern, pure python, memcache client with support for new meta commands.
 Author-email: Guillermo Perez <bisho@revenuecat.com>
 License: MIT License
@@ -434,6 +434,17 @@ Invalidation...
         Get multiple keys at once
         """
 
+    def multi_get_cas(
+        self,
+        keys: List[Union[Key, str]],
+        touch_ttl: Optional[int] = None,
+        recache_policy: Optional[RecachePolicy] = None,
+    ) -> Dict[Key, Tuple[Optional[Any], Optional[int]]]:
+        """
+        Same as multi_get(), but also return the CAS tokens so
+        they can be used during writes and detect races
+        """
+
     def get_cas(
         self,
         key: Union[Key, str],