meta-memcache 2.2.0__tar.gz → 2.4.0__tar.gz

{meta_memcache-2.2.0/src/meta_memcache.egg-info → meta_memcache-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-memcache
-Version: 2.2.0
+Version: 2.4.0
 Summary: Modern, pure python, memcache client with support for new meta commands.
 Author-email: Guillermo Perez <bisho@revenuecat.com>
 License: MIT License
@@ -388,13 +388,17 @@ Invalidation...
         lease_policy: LeasePolicy,
         touch_ttl: Optional[int] = None,
         recache_policy: Optional[RecachePolicy] = None,
+        lease_wait_fn: Optional[Callable[[float], None]] = None,
     ) -> Optional[Any]:
         """
         Get a key. On miss try to get a lease.
 
         Guarantees only one cache client will get the miss and
         gets to repopulate cache, while the others are blocked
-        waiting (according to the settings in the LeasePolicy)
+        waiting (according to the settings in the LeasePolicy).
+
+        ``lease_wait_fn`` is invoked with the number of seconds to wait
+        between lease retries. Defaults to ``time.sleep``.
         """
 
     def get_or_lease_cas(
@@ -403,6 +407,7 @@ Invalidation...
         lease_policy: LeasePolicy,
         touch_ttl: Optional[int] = None,
         recache_policy: Optional[RecachePolicy] = None,
+        lease_wait_fn: Optional[Callable[[float], None]] = None,
     ) -> Tuple[Optional[Any], Optional[int]]:
         """
         Same as get_or_lease(), but also return the CAS token so
@@ -429,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],
@@ -643,8 +659,8 @@ class PoolCounters(NamedTuple):
     available: int
     # The # of connections active, currently in use, out of the pool
     active: int
-    # Current stablished connections (available + active)
-    stablished: int
+    # Current established connections (available + active)
+    established: int
     # Total # of connections created. If this keeps growing
     # might mean the pool size is too small and we are
     # constantly needing to create new connections:

{meta_memcache-2.2.0 → meta_memcache-2.4.0}/README.md

@@ -370,13 +370,17 @@ Invalidation...
         lease_policy: LeasePolicy,
         touch_ttl: Optional[int] = None,
         recache_policy: Optional[RecachePolicy] = None,
+        lease_wait_fn: Optional[Callable[[float], None]] = None,
     ) -> Optional[Any]:
         """
         Get a key. On miss try to get a lease.
 
         Guarantees only one cache client will get the miss and
         gets to repopulate cache, while the others are blocked
-        waiting (according to the settings in the LeasePolicy)
+        waiting (according to the settings in the LeasePolicy).
+
+        ``lease_wait_fn`` is invoked with the number of seconds to wait
+        between lease retries. Defaults to ``time.sleep``.
         """
 
     def get_or_lease_cas(
@@ -385,6 +389,7 @@ Invalidation...
         lease_policy: LeasePolicy,
         touch_ttl: Optional[int] = None,
         recache_policy: Optional[RecachePolicy] = None,
+        lease_wait_fn: Optional[Callable[[float], None]] = None,
     ) -> Tuple[Optional[Any], Optional[int]]:
         """
         Same as get_or_lease(), but also return the CAS token so
@@ -411,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],
@@ -625,8 +641,8 @@ class PoolCounters(NamedTuple):
     available: int
     # The # of connections active, currently in use, out of the pool
     active: int
-    # Current stablished connections (available + active)
-    stablished: int
+    # Current established connections (available + active)
+    established: int
     # Total # of connections created. If this keeps growing
     # might mean the pool size is too small and we are
     # constantly needing to create new connections:

{meta_memcache-2.2.0 → meta_memcache-2.4.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.2.0"
+version = "2.4.0"
 description = "Modern, pure python, memcache client with support for new meta commands."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -19,6 +19,11 @@ metrics = ["prometheus-client >= 0.17.1"]
 [project.urls]
 homepage = "https://github.com/RevenueCat/meta-memcache-py"
 
+[tool.uv]
+# Dependency cooldown: only resolve releases that are at least 7 days old.
+# Mitigates supply-chain risk from compromised fresh package versions.
+exclude-newer = "P7D"
+
 [tool.pytest.ini_options]
 addopts = "-ra"
 testpaths = ["tests"]
@@ -36,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.2.0 → meta_memcache-2.4.0}/src/meta_memcache/__init__.py

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

{meta_memcache-2.2.0 → meta_memcache-2.4.0}/src/meta_memcache/commands/high_level_commands.py

@@ -1,6 +1,7 @@
 import time
 from typing import (
     Any,
+    Callable,
     Dict,
     Iterable,
     Optional,
@@ -236,6 +237,7 @@ class HighLevelCommandsMixin:
         lease_policy: LeasePolicy,
         touch_ttl: Optional[int] = None,
         recache_policy: Optional[RecachePolicy] = None,
+        lease_wait_fn: Optional[Callable[[float], None]] = None,
     ) -> Optional[Any]:
         """
         Get a key. On miss try to get a lease.
@@ -243,12 +245,16 @@ class HighLevelCommandsMixin:
         Guarantees only one cache client will get the miss and
         gets to repopulate cache, while the others are blocked
         waiting (according to the settings in the LeasePolicy)
+
+        ``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(
             key=key,
             lease_policy=lease_policy,
             touch_ttl=touch_ttl,
             recache_policy=recache_policy,
+            lease_wait_fn=lease_wait_fn,
         )
         return value
 
@@ -258,6 +264,7 @@ class HighLevelCommandsMixin:
         lease_policy: LeasePolicy,
         touch_ttl: Optional[int] = None,
         recache_policy: Optional[RecachePolicy] = None,
+        lease_wait_fn: Optional[Callable[[float], None]] = None,
     ) -> Tuple[Optional[Any], Optional[int]]:
         """
         Same as get_or_lease(), but also return the CAS token so
@@ -267,10 +274,11 @@ class HighLevelCommandsMixin:
             raise ValueError(
                 "Wrong lease_policy: miss_retries needs to be greater than 0"
             )
+        wait = lease_wait_fn if lease_wait_fn is not None else time.sleep
         i = 0
         while True:
             if i > 0:
-                time.sleep(
+                wait(
                     min(
                         lease_policy.miss_max_retry_wait,
                         lease_policy.miss_retry_wait
@@ -344,6 +352,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]],

{meta_memcache-2.2.0 → meta_memcache-2.4.0}/src/meta_memcache/commands/meta_commands.py

@@ -110,6 +110,6 @@ class MetaCommandsMixin:
         )
         if not isinstance(result, (Success, NotStored, Conflict, Miss, Value)):
             raise MemcacheError(
-                f"Unexpected response for Meta Delete command: {result}"
+                f"Unexpected response for Meta Arithmetic command: {result}"
             )
         return result

{meta_memcache-2.2.0 → meta_memcache-2.4.0}/src/meta_memcache/connection/pool.py

@@ -52,8 +52,8 @@ class PoolCounters(NamedTuple):
     available: int
     # The # of connections active, currently in use, out of the pool
     active: int
-    # Current stablished connections (available + active)
-    stablished: int
+    # Current established connections (available + active)
+    established: int
     # Total # of connections created. If this keeps growing
     # might meen the pool size is too small and we are
     # constantly needing to create new connections:
@@ -125,13 +125,13 @@ class ConnectionPool:
     def get_counters(self) -> PoolCounters:
         available = len(self._pool)
         total_created, total_destroyed = self._created, self._destroyed
-        stablished = total_created - total_destroyed
-        active = available - stablished
+        established = total_created - total_destroyed
+        active = established - available
 
         return PoolCounters(
             available=available,
             active=active,
-            stablished=stablished,
+            established=established,
             total_created=total_created,
             total_errors=self._errors,
         )

{meta_memcache-2.2.0 → meta_memcache-2.4.0}/src/meta_memcache/interfaces/high_level_commands.py

@@ -1,4 +1,15 @@
-from typing import Any, Dict, Iterable, Optional, Protocol, Tuple, Type, TypeVar, Union
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    Optional,
+    Protocol,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
 
 from meta_memcache.configuration import LeasePolicy, RecachePolicy, StalePolicy
 from meta_memcache.protocol import Key, SetMode, Value
@@ -83,6 +94,7 @@ class HighLevelCommandsProtocol(Protocol):
         lease_policy: LeasePolicy,
         touch_ttl: Optional[int] = None,
         recache_policy: Optional[RecachePolicy] = None,
+        lease_wait_fn: Optional[Callable[[float], None]] = None,
     ) -> Optional[Any]: ...  # pragma: no cover
 
     def get_or_lease_cas(
@@ -91,6 +103,7 @@ class HighLevelCommandsProtocol(Protocol):
         lease_policy: LeasePolicy,
         touch_ttl: Optional[int] = None,
         recache_policy: Optional[RecachePolicy] = None,
+        lease_wait_fn: Optional[Callable[[float], None]] = None,
     ) -> Tuple[Optional[Any], Optional[int]]: ...  # pragma: no cover
 
     def get(
@@ -107,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.2.0 → meta_memcache-2.4.0/src/meta_memcache.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-memcache
-Version: 2.2.0
+Version: 2.4.0
 Summary: Modern, pure python, memcache client with support for new meta commands.
 Author-email: Guillermo Perez <bisho@revenuecat.com>
 License: MIT License
@@ -388,13 +388,17 @@ Invalidation...
         lease_policy: LeasePolicy,
         touch_ttl: Optional[int] = None,
         recache_policy: Optional[RecachePolicy] = None,
+        lease_wait_fn: Optional[Callable[[float], None]] = None,
     ) -> Optional[Any]:
         """
         Get a key. On miss try to get a lease.
 
         Guarantees only one cache client will get the miss and
         gets to repopulate cache, while the others are blocked
-        waiting (according to the settings in the LeasePolicy)
+        waiting (according to the settings in the LeasePolicy).
+
+        ``lease_wait_fn`` is invoked with the number of seconds to wait
+        between lease retries. Defaults to ``time.sleep``.
         """
 
     def get_or_lease_cas(
@@ -403,6 +407,7 @@ Invalidation...
         lease_policy: LeasePolicy,
         touch_ttl: Optional[int] = None,
         recache_policy: Optional[RecachePolicy] = None,
+        lease_wait_fn: Optional[Callable[[float], None]] = None,
     ) -> Tuple[Optional[Any], Optional[int]]:
         """
         Same as get_or_lease(), but also return the CAS token so
@@ -429,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],
@@ -643,8 +659,8 @@ class PoolCounters(NamedTuple):
     available: int
     # The # of connections active, currently in use, out of the pool
     active: int
-    # Current stablished connections (available + active)
-    stablished: int
+    # Current established connections (available + active)
+    established: int
     # Total # of connections created. If this keeps growing
     # might mean the pool size is too small and we are
     # constantly needing to create new connections: