limits 5.0.0rc1__py3-none-any.whl → 5.0.0rc2__py3-none-any.whl

limits/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-04-09T18:20:47-0700",
+ "date": "2025-04-15T12:47:18-0700",
  "dirty": false,
  "error": null,
- "full-revisionid": "4a01f1090a5accfb05b7db6dc6469f7c51d4fa67",
- "version": "5.0.0rc1"
+ "full-revisionid": "ca0e9ca30c696af1102471218171c07ce8ee7644",
+ "version": "5.0.0rc2"
 }
 '''  # END VERSION_JSON
 

limits/aio/storage/{memcached.py → memcached/__init__.py}

@@ -1,24 +1,23 @@
 from __future__ import annotations
 
 import time
-import urllib.parse
-from collections.abc import Iterable
-from math import ceil, floor
-from typing import TYPE_CHECKING
+from math import floor
 
 from deprecated.sphinx import versionadded, versionchanged
+from packaging.version import Version
 
-from limits.aio.storage.base import SlidingWindowCounterSupport, Storage
+from limits.aio.storage import SlidingWindowCounterSupport, Storage
+from limits.aio.storage.memcached.bridge import MemcachedBridge
+from limits.aio.storage.memcached.emcache import EmcacheBridge
+from limits.aio.storage.memcached.memcachio import MemcachioBridge
 from limits.storage.base import TimestampedSlidingWindow
-
-if TYPE_CHECKING:
-    import memcachio
+from limits.typing import Literal
 
 
 @versionadded(version="2.1")
 @versionchanged(
     version="5.0",
-    reason="Switched to :pypi:`memcachio` for async memcached support",
+    reason="Switched default implementation to :pypi:`memcachio`",
 )
 class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingWindow):
     """
@@ -30,12 +29,19 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
     STORAGE_SCHEME = ["async+memcached"]
     """The storage scheme for memcached to be used in an async context"""
 
-    DEPENDENCIES = ["memcachio"]
+    DEPENDENCIES = {
+        "memcachio": Version("0.3"),
+        "emcache": Version("0.0"),
+    }
+
+    bridge: MemcachedBridge
+    storage_exceptions: tuple[Exception, ...]
 
     def __init__(
         self,
         uri: str,
         wrap_exceptions: bool = False,
+        implementation: Literal["memcachio", "emcache"] = "memcachio",
         **options: float | str | bool,
     ) -> None:
         """
@@ -43,77 +49,41 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
          ``async+memcached://host:port,host:port``
         :param wrap_exceptions: Whether to wrap storage exceptions in
          :exc:`limits.errors.StorageError` before raising it.
+        :param implementation: Whether to use the client implementation from
+
+         - ``memcachio``: :class:`memcachio.Client`
+         - ``emcache``: :class:`emcache.Client`
         :param options: all remaining keyword arguments are passed
          directly to the constructor of :class:`memcachio.Client`
         :raise ConfigurationError: when :pypi:`memcachio` is not available
         """
-        parsed = urllib.parse.urlparse(uri)
-        self.hosts = []
-
-        for host, port in (
-            loc.split(":") for loc in parsed.netloc.strip().split(",") if loc.strip()
-        ):
-            self.hosts.append((host, int(port)))
-
-        self._options = options
-        self._storage = None
+        if implementation == "emcache":
+            self.bridge = EmcacheBridge(
+                uri, self.dependencies["emcache"].module, **options
+            )
+        else:
+            self.bridge = MemcachioBridge(
+                uri, self.dependencies["memcachio"].module, **options
+            )
         super().__init__(uri, wrap_exceptions=wrap_exceptions, **options)
-        self.dependency = self.dependencies["memcachio"].module
 
     @property
     def base_exceptions(
         self,
     ) -> type[Exception] | tuple[type[Exception], ...]:  # pragma: no cover
-        return (
-            self.dependency.errors.NoNodeAvailable,
-            self.dependency.errors.MemcachioConnectionError,
-        )
-
-    async def get_storage(self) -> memcachio.Client[bytes]:
-        if not self._storage:
-            self._storage = self.dependency.Client(
-                [(h, p) for h, p in self.hosts],
-                **self._options,
-            )
-        assert self._storage
-        return self._storage
+        return self.bridge.base_exceptions
 
     async def get(self, key: str) -> int:
         """
         :param key: the key to get the counter value for
         """
-        item = (await self.get_many([key])).get(key.encode("utf-8"), None)
-        return item and int(item.value) or 0
-
-    async def get_many(
-        self, keys: Iterable[str]
-    ) -> dict[bytes, memcachio.MemcachedItem[bytes]]:
-        """
-        Return multiple counters at once
-
-        :param keys: the keys to get the counter values for
-        """
-        return await (await self.get_storage()).get(*[k.encode("utf-8") for k in keys])
+        return await self.bridge.get(key)
 
     async def clear(self, key: str) -> None:
         """
         :param key: the key to clear rate limits for
         """
-        await (await self.get_storage()).delete(key.encode("utf-8"))
-
-    async def decr(self, key: str, amount: int = 1, noreply: bool = False) -> int:
-        """
-        decrements the counter for a given rate limit key
-
-        retursn 0 if the key doesn't exist or if noreply is set to True
-
-        :param key: the key to decrement
-        :param amount: the number to decrement by
-        :param noreply: set to True to ignore the memcached response
-        """
-        storage = await self.get_storage()
-        limit_key = key.encode("utf-8")
-        return await storage.decr(limit_key, amount, noreply=noreply) or 0
+        await self.bridge.clear(key)
 
     async def incr(
         self,
@@ -131,60 +101,22 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
         :param amount: the number to increment by
         :param set_expiration_key: if set to False, the expiration time won't be stored but the key will still expire
         """
-        storage = await self.get_storage()
-        limit_key = key.encode("utf-8")
-        expire_key = self._expiration_key(key).encode()
-        if (value := (await storage.incr(limit_key, amount))) is None:
-            storage = await self.get_storage()
-            if await storage.add(limit_key, f"{amount}".encode(), expiry=ceil(expiry)):
-                if set_expiration_key:
-                    await storage.set(
-                        expire_key,
-                        str(expiry + time.time()).encode("utf-8"),
-                        expiry=ceil(expiry),
-                        noreply=False,
-                    )
-                return amount
-            else:
-                storage = await self.get_storage()
-                return await storage.incr(limit_key, amount) or amount
-        return value
+        return await self.bridge.incr(
+            key, expiry, amount, set_expiration_key=set_expiration_key
+        )
 
     async def get_expiry(self, key: str) -> float:
         """
         :param key: the key to get the expiry for
         """
-        storage = await self.get_storage()
-        expiration_key = self._expiration_key(key).encode("utf-8")
-        item = (await storage.get(expiration_key)).get(expiration_key, None)
-
-        return item and float(item.value) or time.time()
-
-    def _expiration_key(self, key: str) -> str:
-        """
-        Return the expiration key for the given counter key.
-
-        Memcached doesn't natively return the expiration time or TTL for a given key,
-        so we implement the expiration time on a separate key.
-        """
-        return key + "/expires"
-
-    async def check(self) -> bool:
-        """
-        Check if storage is healthy by calling the ``get`` command
-        on the key ``limiter-check``
-        """
-        try:
-            storage = await self.get_storage()
-            await storage.get(b"limiter-check")
-
-            return True
-        except:  # noqa
-            return False
+        return await self.bridge.get_expiry(key)
 
     async def reset(self) -> int | None:
         raise NotImplementedError
 
+    async def check(self) -> bool:
+        return await self.bridge.check()
+
     async def acquire_sliding_window_entry(
         self,
         key: str,
@@ -219,10 +151,10 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
                 previous_count * actualised_previous_ttl / expiry + current_count
             )
             if floor(weighted_count) > limit:
-                # Another hit won the race condition: revert the incrementation and refuse this hit
+                # Another hit won the race condition: revert the increment and refuse this hit
                 # Limitation: during high concurrency at the end of the window,
                 # the counter is shifted and cannot be decremented, so less requests than expected are allowed.
-                await self.decr(current_key, amount, noreply=True)
+                await self.bridge.decr(current_key, amount, noreply=True)
                 return False
             return True
 
@@ -238,13 +170,11 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
     async def _get_sliding_window_info(
         self, previous_key: str, current_key: str, expiry: int, now: float
     ) -> tuple[int, float, int, float]:
-        result = await self.get_many([previous_key, current_key])
+        result = await self.bridge.get_many([previous_key, current_key])
 
-        raw_previous_count = result.get(previous_key.encode("utf-8"))
-        raw_current_count = result.get(current_key.encode("utf-8"))
+        previous_count = result.get(previous_key.encode("utf-8"), 0)
+        current_count = result.get(current_key.encode("utf-8"), 0)
 
-        current_count = raw_current_count and int(raw_current_count.value) or 0
-        previous_count = raw_previous_count and int(raw_previous_count.value) or 0
         if previous_count == 0:
             previous_ttl = float(0)
         else:

limits/aio/storage/memcached/bridge.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import urllib
+from abc import ABC, abstractmethod
+from types import ModuleType
+
+from limits.typing import Iterable
+
+
+class MemcachedBridge(ABC):
+    def __init__(
+        self,
+        uri: str,
+        dependency: ModuleType,
+        **options: float | str | bool,
+    ) -> None:
+        self.uri = uri
+        self.parsed_uri = urllib.parse.urlparse(self.uri)
+        self.dependency = dependency
+        self.hosts = []
+        self.options = options
+
+        sep = self.parsed_uri.netloc.strip().find("@") + 1
+        for loc in self.parsed_uri.netloc.strip()[sep:].split(","):
+            host, port = loc.split(":")
+            self.hosts.append((host, int(port)))
+
+        if self.parsed_uri.username:
+            self.options["username"] = self.parsed_uri.username
+        if self.parsed_uri.password:
+            self.options["password"] = self.parsed_uri.password
+
+    def _expiration_key(self, key: str) -> str:
+        """
+        Return the expiration key for the given counter key.
+
+        Memcached doesn't natively return the expiration time or TTL for a given key,
+        so we implement the expiration time on a separate key.
+        """
+        return key + "/expires"
+
+    @property
+    @abstractmethod
+    def base_exceptions(
+        self,
+    ) -> type[Exception] | tuple[type[Exception], ...]: ...
+
+    @abstractmethod
+    async def get(self, key: str) -> int: ...
+
+    @abstractmethod
+    async def get_many(self, keys: Iterable[str]) -> dict[bytes, int]: ...
+
+    @abstractmethod
+    async def clear(self, key: str) -> None: ...
+
+    @abstractmethod
+    async def decr(self, key: str, amount: int = 1, noreply: bool = False) -> int: ...
+
+    @abstractmethod
+    async def incr(
+        self,
+        key: str,
+        expiry: float,
+        amount: int = 1,
+        set_expiration_key: bool = True,
+    ) -> int: ...
+
+    @abstractmethod
+    async def get_expiry(self, key: str) -> float: ...
+
+    @abstractmethod
+    async def check(self) -> bool: ...

limits/aio/storage/memcached/emcache.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import time
+from math import ceil
+from types import ModuleType
+
+from limits.typing import TYPE_CHECKING, Iterable
+
+from .bridge import MemcachedBridge
+
+if TYPE_CHECKING:
+    import emcache
+
+
+class EmcacheBridge(MemcachedBridge):
+    def __init__(
+        self,
+        uri: str,
+        dependency: ModuleType,
+        **options: float | str | bool,
+    ) -> None:
+        super().__init__(uri, dependency, **options)
+        self._storage = None
+
+    async def get_storage(self) -> emcache.Client:
+        if not self._storage:
+            self._storage = await self.dependency.create_client(
+                [self.dependency.MemcachedHostAddress(h, p) for h, p in self.hosts],
+                **self.options,
+            )
+        assert self._storage
+        return self._storage
+
+    async def get(self, key: str) -> int:
+        item = await (await self.get_storage()).get(key.encode("utf-8"))
+        return item and int(item.value) or 0
+
+    async def get_many(self, keys: Iterable[str]) -> dict[bytes, int]:
+        results = await (await self.get_storage()).get_many(
+            [k.encode("utf-8") for k in keys]
+        )
+        return {k: int(item.value) if item else 0 for k, item in results.items()}
+
+    async def clear(self, key: str) -> None:
+        try:
+            await (await self.get_storage()).delete(key.encode("utf-8"))
+        except self.dependency.NotFoundCommandError:
+            pass
+
+    async def decr(self, key: str, amount: int = 1, noreply: bool = False) -> int:
+        storage = await self.get_storage()
+        limit_key = key.encode("utf-8")
+        try:
+            value = await storage.decrement(limit_key, amount, noreply=noreply) or 0
+        except self.dependency.NotFoundCommandError:
+            value = 0
+        return value
+
+    async def incr(
+        self, key: str, expiry: float, amount: int = 1, set_expiration_key: bool = True
+    ) -> int:
+        storage = await self.get_storage()
+        limit_key = key.encode("utf-8")
+        expire_key = self._expiration_key(key).encode()
+        try:
+            return await storage.increment(limit_key, amount) or amount
+        except self.dependency.NotFoundCommandError:
+            storage = await self.get_storage()
+            try:
+                await storage.add(limit_key, f"{amount}".encode(), exptime=ceil(expiry))
+                if set_expiration_key:
+                    await storage.set(
+                        expire_key,
+                        str(expiry + time.time()).encode("utf-8"),
+                        exptime=ceil(expiry),
+                        noreply=False,
+                    )
+                value = amount
+            except self.dependency.NotStoredStorageCommandError:
+                # Coult not add the key, probably because a concurrent call has added it
+                storage = await self.get_storage()
+                value = await storage.increment(limit_key, amount) or amount
+            return value
+
+    async def get_expiry(self, key: str) -> float:
+        storage = await self.get_storage()
+        item = await storage.get(self._expiration_key(key).encode("utf-8"))
+
+        return item and float(item.value) or time.time()
+        pass
+
+    @property
+    def base_exceptions(
+        self,
+    ) -> type[Exception] | tuple[type[Exception], ...]:  # pragma: no cover
+        return (
+            self.dependency.ClusterNoAvailableNodes,
+            self.dependency.CommandError,
+        )
+
+    async def check(self) -> bool:
+        """
+        Check if storage is healthy by calling the ``get`` command
+        on the key ``limiter-check``
+        """
+        try:
+            storage = await self.get_storage()
+            await storage.get(b"limiter-check")
+
+            return True
+        except:  # noqa
+            return False

limits/aio/storage/memcached/memcachio.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import time
+from math import ceil
+from types import ModuleType
+from typing import TYPE_CHECKING, Iterable
+
+from .bridge import MemcachedBridge
+
+if TYPE_CHECKING:
+    import memcachio
+
+
+class MemcachioBridge(MemcachedBridge):
+    def __init__(
+        self,
+        uri: str,
+        dependency: ModuleType,
+        **options: float | str | bool,
+    ) -> None:
+        super().__init__(uri, dependency, **options)
+        self._storage: memcachio.Client[bytes] | None = None
+
+    @property
+    def base_exceptions(
+        self,
+    ) -> type[Exception] | tuple[type[Exception], ...]:
+        return (
+            self.dependency.errors.NoAvailableNodes,
+            self.dependency.errors.MemcachioConnectionError,
+        )
+
+    async def get_storage(self) -> memcachio.Client[bytes]:
+        if not self._storage:
+            self._storage = self.dependency.Client(
+                [(h, p) for h, p in self.hosts],
+                **self.options,
+            )
+        assert self._storage
+        return self._storage
+
+    async def get(self, key: str) -> int:
+        return (await self.get_many([key])).get(key.encode("utf-8"), 0)
+
+    async def get_many(self, keys: Iterable[str]) -> dict[bytes, int]:
+        """
+        Return multiple counters at once
+
+        :param keys: the keys to get the counter values for
+        """
+        results = await (await self.get_storage()).get(
+            *[k.encode("utf-8") for k in keys]
+        )
+        return {k: int(v.value) for k, v in results.items()}
+
+    async def clear(self, key: str) -> None:
+        await (await self.get_storage()).delete(key.encode("utf-8"))
+
+    async def decr(self, key: str, amount: int = 1, noreply: bool = False) -> int:
+        storage = await self.get_storage()
+        limit_key = key.encode("utf-8")
+        return await storage.decr(limit_key, amount, noreply=noreply) or 0
+
+    async def incr(
+        self, key: str, expiry: float, amount: int = 1, set_expiration_key: bool = True
+    ) -> int:
+        storage = await self.get_storage()
+        limit_key = key.encode("utf-8")
+        expire_key = self._expiration_key(key).encode()
+        if (value := (await storage.incr(limit_key, amount))) is None:
+            storage = await self.get_storage()
+            if await storage.add(limit_key, f"{amount}".encode(), expiry=ceil(expiry)):
+                if set_expiration_key:
+                    await storage.set(
+                        expire_key,
+                        str(expiry + time.time()).encode("utf-8"),
+                        expiry=ceil(expiry),
+                        noreply=False,
+                    )
+                return amount
+            else:
+                storage = await self.get_storage()
+                return await storage.incr(limit_key, amount) or amount
+        return value
+
+    async def get_expiry(self, key: str) -> float:
+        storage = await self.get_storage()
+        expiration_key = self._expiration_key(key).encode("utf-8")
+        item = (await storage.get(expiration_key)).get(expiration_key, None)
+
+        return item and float(item.value) or time.time()
+
+    async def check(self) -> bool:
+        """
+        Check if storage is healthy by calling the ``get`` command
+        on the key ``limiter-check``
+        """
+        try:
+            storage = await self.get_storage()
+            await storage.get(b"limiter-check")
+
+            return True
+        except:  # noqa
+            return False

limits/aio/storage/memory.py

@@ -62,25 +62,29 @@ class MemoryStorage(
         asyncio.ensure_future(self.__schedule_expiry())
 
     async def __expire_events(self) -> None:
-        now = time.time()
-        for key in list(self.events.keys()):
-            cutoff = await asyncio.to_thread(
-                lambda evts: bisect.bisect_left(
-                    evts, -now, key=lambda event: -event.expiry
-                ),
-                self.events[key],
-            )
-            async with self.locks[key]:
-                self.events[key] = self.events[key][:cutoff]
-                if not self.events.get(key, None):
-                    self.events.pop(key, None)
+        try:
+            now = time.time()
+            for key in list(self.events.keys()):
+                cutoff = await asyncio.to_thread(
+                    lambda evts: bisect.bisect_left(
+                        evts, -now, key=lambda event: -event.expiry
+                    ),
+                    self.events[key],
+                )
+                async with self.locks[key]:
+                    if self.events.get(key, []):
+                        self.events[key] = self.events[key][:cutoff]
+                    if not self.events.get(key, None):
+                        self.events.pop(key, None)
+                        self.locks.pop(key, None)
+
+            for key in list(self.expirations.keys()):
+                if self.expirations[key] <= time.time():
+                    self.storage.pop(key, None)
+                    self.expirations.pop(key, None)
                     self.locks.pop(key, None)
-
-        for key in list(self.expirations.keys()):
-            if self.expirations[key] <= time.time():
-                self.storage.pop(key, None)
-                self.expirations.pop(key, None)
-                self.locks.pop(key, None)
+        except asyncio.CancelledError:
+            return
 
     async def __schedule_expiry(self) -> None:
         if not self.timer or self.timer.done():
@@ -268,3 +272,10 @@ class MemoryStorage(
         self.locks.clear()
 
         return num_items
+
+    def __del__(self) -> None:
+        try:
+            if self.timer and not self.timer.done():
+                self.timer.cancel()
+        except RuntimeError:  # noqa
+            pass

limits/storage/memcached.py

@@ -153,6 +153,8 @@ class MemcachedStorage(Storage, SlidingWindowCounterSupport, TimestampedSlidingW
         Return multiple counters at once
 
         :param keys: the keys to get the counter values for
+
+        :meta private:
         """
         return self.storage.get_many(keys)
 

limits/storage/memory.py

@@ -57,11 +57,11 @@ class MemoryStorage(
     def __expire_events(self) -> None:
         for key in list(self.events.keys()):
             with self.locks[key]:
-                events = self.events.get(key, [])
-                oldest = bisect.bisect_left(
-                    events, -time.time(), key=lambda event: -event.expiry
-                )
-                self.events[key] = self.events[key][:oldest]
+                if events := self.events.get(key, []):
+                    oldest = bisect.bisect_left(
+                        events, -time.time(), key=lambda event: -event.expiry
+                    )
+                    self.events[key] = self.events[key][:oldest]
                 if not self.events.get(key, None):
                     self.locks.pop(key, None)
         for key in list(self.expirations.keys()):

limits/typing.py

@@ -107,6 +107,7 @@ __all__ = [
     "Callable",
     "ClassVar",
     "Counter",
+    "Iterable",
     "Literal",
     "MemcachedClientP",
     "MongoClient",

{limits-5.0.0rc1.dist-info → limits-5.0.0rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: limits
-Version: 5.0.0rc1
+Version: 5.0.0rc2
 Summary: Rate limiting utilities
 Home-page: https://limits.readthedocs.org
 Author: Ali-Akber Saifee
@@ -274,5 +274,6 @@ Links
 =====
 
 * `Documentation <http://limits.readthedocs.org/en/latest>`_
+* `Benchmarks <http://limits.readthedocs.org/en/latest/performance.html>`_
 * `Changelog <http://limits.readthedocs.org/en/stable/changelog.html>`_
 

{limits-5.0.0rc1.dist-info → limits-5.0.0rc2.dist-info}/RECORD

@@ -1,19 +1,22 @@
 limits/__init__.py,sha256=gPUFrt02kHF_syLjiVRSs-S4UVGpRMcM2VMFNhF6G24,748
-limits/_version.py,sha256=kltwWj42pO4gRxnH3YVXMAqHthKTyYt67Uzylwnaayo,500
+limits/_version.py,sha256=NfHJ8jCFa69gQxFo8GoNxy5o_PAmF3e9sDd1Q4gjLTU,500
 limits/errors.py,sha256=s1el9Vg0ly-z92guvnvYNgKi3_aVqpiw_sufemiLLTI,662
 limits/limits.py,sha256=YzzZP8_ay_zlMMnnY2xhAcFTTFvFe5HEk8NQlvUTru4,4907
 limits/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 limits/strategies.py,sha256=LeZ6lnE73EIQqQ8TfKaTzlxNvBMrZOOSXFB0l8D17fI,9946
-limits/typing.py,sha256=vmutp9AD8XXQ5U48fM7rVaBSoK9fWalkhnK_TGg8xxY,3267
+limits/typing.py,sha256=pVt5D23MhQSUGqi0MBG5FCSqDwta2ygu18BpKvJFxow,3283
 limits/util.py,sha256=nk5QYvezFuXPq1OTEj04RrZFSWIH-khT0e_Dim6zGCw,6002
 limits/version.py,sha256=YwkF3dtq1KGzvmL3iVGctA8NNtGlK_0arrzZkZGVjUs,47
 limits/aio/__init__.py,sha256=yxvWb_ZmV245Hg2LqD365WC5IDllcGDMw6udJ1jNp1g,118
 limits/aio/strategies.py,sha256=RzZExH2r6jnHra4SpDHqtZCC0Bo3085zUJYo2boAj6Y,9897
 limits/aio/storage/__init__.py,sha256=vKeArUnN1ld_0mQOBBZPCjaQgM5xI1GBPM7_F2Ydz5c,646
 limits/aio/storage/base.py,sha256=VfHpL9Z3RL76eKhoaSQKLKQsqcF5B2bnF6gfa-8ltWA,6296
-limits/aio/storage/memcached.py,sha256=q1t9wowCg04-pHavg0i5xEly4KMgVkW5ptyGNA4RiqU,9195
-limits/aio/storage/memory.py,sha256=HdkQPcjjHv1MhGoeYWOkBwwMj5e0tQbaO0OlECzh64A,9178
+limits/aio/storage/memory.py,sha256=sWrDzOe-6Opy9uFmfP1S38IbN2_wNCBaIHTS4UTRy6g,9562
 limits/aio/storage/mongodb.py,sha256=tIMfQrseONRMR2nuRmPO7ocp8dTCABfqBICS_kgp550,19141
+limits/aio/storage/memcached/__init__.py,sha256=VMWsH4XpaPswtPV7cQmsfckhVRbOOrKvoUPYnGt5MRY,6611
+limits/aio/storage/memcached/bridge.py,sha256=3CEruS6LvZWDQPGPLlwY4hemy6oN0WWduUE7t8vyXBI,2017
+limits/aio/storage/memcached/emcache.py,sha256=J01jP-Udd2fLgamCh2CX9NEIvhN8eZVTzUok096Bbe4,3833
+limits/aio/storage/memcached/memcachio.py,sha256=OoGVqOVG0pVX2McFeTGQ_AbiqQUu_FYwWItpQMtNV7g,3491
 limits/aio/storage/redis/__init__.py,sha256=lwoKk91YLEBlZ3W6hCnQ1e7Gc6LxpvSzZZW16saCyR4,14143
 limits/aio/storage/redis/bridge.py,sha256=eoRi9h2bSy194cVwoKgRYQV1HQ7SvwarL-4LeazrxeA,3145
 limits/aio/storage/redis/coredis.py,sha256=IzfEyXBvQbr4QUWML9xAd87a2aHCvglOBEjAg-Vq4z0,7420
@@ -27,15 +30,15 @@ limits/resources/redis/lua_scripts/moving_window.lua,sha256=zlieQwfET0BC7sxpfiOu
 limits/resources/redis/lua_scripts/sliding_window.lua,sha256=qG3Yg30Dq54QpRUcR9AOrKQ5bdJiaYpCacTm6Kxblvc,713
 limits/storage/__init__.py,sha256=9iNxIlwzLQw2d54EcMa2LBJ47wiWCPOnHgn6ddqKkDI,2652
 limits/storage/base.py,sha256=IdOL_iqR9KhaJO73M_h9c6OYe8Ox632pxx5uXaL9Dbo,6860
-limits/storage/memcached.py,sha256=7ZdT80OgQa0f16Tr2L2zGu8PZGzLryOvlb4D1Qk7z9I,10193
-limits/storage/memory.py,sha256=Qc13tGIOFPJ5maehxZdT0074qMvkW-RrzoyZIbFuRyE,8698
+limits/storage/memcached.py,sha256=5GUKGWS_BYTwUss2WmOlCwBtOieGT7AFUcpX65WYXdQ,10217
+limits/storage/memory.py,sha256=rVlsirSp9LDhuqNFp6KMLR85fJc9xwrU58IHIVz6eq4,8719
 limits/storage/mongodb.py,sha256=V4Ib_AwPFX6JpNI7oUUGJx_3MxD8EmYAi4Q6QcWnQ5U,18071
 limits/storage/redis.py,sha256=i_6qh4S6JQd-lG6eRJdTPxNnZIAkm4G0cA0mfow9OOk,10389
 limits/storage/redis_cluster.py,sha256=z6aONMl4p1AY78G3J0BbtK--uztz88krwnpiOsU61BM,4447
 limits/storage/redis_sentinel.py,sha256=AN0WtwHN88TvXk0C2uUE8l5Jhsd1ZxU8XSqrEyQSR20,4327
 limits/storage/registry.py,sha256=CxSaDBGR5aBJPFAIsfX9axCnbcThN3Bu-EH4wHrXtu8,650
-limits-5.0.0rc1.dist-info/licenses/LICENSE.txt,sha256=T6i7kq7F5gIPfcno9FCxU5Hcwm22Bjq0uHZV3ElcjsQ,1061
-limits-5.0.0rc1.dist-info/METADATA,sha256=iXK14MS_wl5xFrRblJE9Niv54qsuaGhW-_49-vIrSrY,10828
-limits-5.0.0rc1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-limits-5.0.0rc1.dist-info/top_level.txt,sha256=C7g5ahldPoU2s6iWTaJayUrbGmPK1d6e9t5Nn0vQ2jM,7
-limits-5.0.0rc1.dist-info/RECORD,,
+limits-5.0.0rc2.dist-info/licenses/LICENSE.txt,sha256=T6i7kq7F5gIPfcno9FCxU5Hcwm22Bjq0uHZV3ElcjsQ,1061
+limits-5.0.0rc2.dist-info/METADATA,sha256=0bbBoIEtEg06utKBNEGa7iCNVmbQZ6xLFaIfoxx5aDU,10903
+limits-5.0.0rc2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+limits-5.0.0rc2.dist-info/top_level.txt,sha256=C7g5ahldPoU2s6iWTaJayUrbGmPK1d6e9t5Nn0vQ2jM,7
+limits-5.0.0rc2.dist-info/RECORD,,