hishel 0.0.29__py3-none-any.whl → 0.0.31__py3-none-any.whl

hishel/__init__.py

@@ -14,4 +14,4 @@ def install_cache() -> None:  # pragma: no cover
     httpx.Client = CacheClient  # type: ignore
 
 
-__version__ = "0.0.29"
+__version__ = "0.0.31"

hishel/_async/_pool.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime
 import types
 import typing as tp
 
@@ -134,23 +133,31 @@ class AsyncCacheConnectionPool(AsyncRequestInterface):
                 )
 
                 await final_response.aread()
+
+                # RFC 9111: 4.3.3. Handling a Validation Response
+                # A 304 (Not Modified) response status code indicates that the stored response can be updated and
+                # reused. A full response (i.e., one containing content) indicates that none of the stored responses
+                # nominated in the conditional request are suitable. Instead, the cache MUST use the full response to
+                # satisfy the request. The cache MAY store such a full response, subject to its constraints.
+                if revalidation_response.status != 304 and self._controller.is_cachable(
+                    request=request, response=final_response
+                ):
+                    await self._storage.store(key, response=final_response, request=request)
+
                 return await self._create_hishel_response(
                     key=key,
                     response=final_response,
                     request=request,
-                    metadata=metadata,
                     cached=revalidation_response.status == 304,
                     revalidated=True,
+                    metadata=metadata,
                 )
 
         regular_response = await self._pool.handle_async_request(request)
         await regular_response.aread()
 
         if self._controller.is_cachable(request=request, response=regular_response):
-            metadata = Metadata(
-                cache_key=key, created_at=datetime.datetime.now(datetime.timezone.utc), number_of_uses=0
-            )
-            await self._storage.store(key, response=regular_response, request=request, metadata=metadata)
+            await self._storage.store(key, response=regular_response, request=request)
 
         return await self._create_hishel_response(
             key=key, response=regular_response, request=request, cached=False, revalidated=False

hishel/_async/_storages.py

@@ -4,6 +4,7 @@ import datetime
 import logging
 import os
 import time
+import typing as t
 import typing as tp
 import warnings
 from copy import deepcopy
@@ -43,6 +44,7 @@ __all__ = (
 )
 
 StoredResponse: TypeAlias = tp.Tuple[Response, Request, Metadata]
+RemoveTypes = tp.Union[str, Response]
 
 try:
     import redis.asyncio as redis
@@ -62,6 +64,9 @@ class AsyncBaseStorage:
     async def store(self, key: str, response: Response, request: Request, metadata: Metadata | None = None) -> None:
         raise NotImplementedError()
 
+    async def remove(self, key: RemoveTypes) -> None:
+        raise NotImplementedError()
+
     async def update_metadata(self, key: str, response: Response, request: Request, metadata: Metadata) -> None:
         raise NotImplementedError()
 
@@ -137,6 +142,23 @@ class AsyncFileStorage(AsyncBaseStorage):
             )
         await self._remove_expired_caches(response_path)
 
+    async def remove(self, key: RemoveTypes) -> None:
+        """
+        Removes the response from the cache.
+
+        :param key: Hashed value of concatenated HTTP method and URI or an HTTP response
+        :type key: Union[str, Response]
+        """
+
+        if isinstance(key, Response):  # pragma: no cover
+            key = t.cast(str, key.extensions["cache_metadata"]["cache_key"])
+
+        response_path = self._base_path / key
+
+        async with self._lock:
+            if response_path.exists():
+                response_path.unlink()
+
     async def update_metadata(self, key: str, response: Response, request: Request, metadata: Metadata) -> None:
         """
         Updates the metadata of the stored response.
@@ -203,11 +225,15 @@ class AsyncFileStorage(AsyncBaseStorage):
 
         self._last_cleaned = time.monotonic()
         async with self._lock:
-            for file in self._base_path.iterdir():
-                if file.is_file():
-                    age = time.time() - file.stat().st_mtime
-                    if age > self._ttl:
-                        file.unlink()
+            with os.scandir(self._base_path) as entries:
+                for entry in entries:
+                    try:
+                        if entry.is_file():
+                            age = time.time() - entry.stat().st_mtime
+                            if age > self._ttl:
+                                os.unlink(entry.path)
+                    except FileNotFoundError:  # pragma: no cover
+                        pass
 
 
 class AsyncSQLiteStorage(AsyncBaseStorage):
@@ -282,6 +308,24 @@ class AsyncSQLiteStorage(AsyncBaseStorage):
             await self._connection.commit()
         await self._remove_expired_caches()
 
+    async def remove(self, key: RemoveTypes) -> None:
+        """
+        Removes the response from the cache.
+
+        :param key: Hashed value of concatenated HTTP method and URI or an HTTP response
+        :type key: Union[str, Response]
+        """
+
+        await self._setup()
+        assert self._connection
+
+        if isinstance(key, Response):  # pragma: no cover
+            key = t.cast(str, key.extensions["cache_metadata"]["cache_key"])
+
+        async with self._lock:
+            await self._connection.execute("DELETE FROM cache WHERE key = ?", [key])
+            await self._connection.commit()
+
     async def update_metadata(self, key: str, response: Response, request: Request, metadata: Metadata) -> None:
         """
         Updates the metadata of the stored response.
@@ -333,8 +377,8 @@ class AsyncSQLiteStorage(AsyncBaseStorage):
             return self._serializer.loads(cached_response)
 
     async def aclose(self) -> None:  # pragma: no cover
-        assert self._connection
-        await self._connection.close()
+        if self._connection is not None:
+            await self._connection.close()
 
     async def _remove_expired_caches(self) -> None:
         assert self._connection
@@ -404,6 +448,19 @@ class AsyncRedisStorage(AsyncBaseStorage):
             key, self._serializer.dumps(response=response, request=request, metadata=metadata), px=px
         )
 
+    async def remove(self, key: RemoveTypes) -> None:
+        """
+        Removes the response from the cache.
+
+        :param key: Hashed value of concatenated HTTP method and URI or an HTTP response
+        :type key: Union[str, Response]
+        """
+
+        if isinstance(key, Response):  # pragma: no cover
+            key = t.cast(str, key.extensions["cache_metadata"]["cache_key"])
+
+        await self._client.delete(key)
+
     async def update_metadata(self, key: str, response: Response, request: Request, metadata: Metadata) -> None:
         """
         Updates the metadata of the stored response.
@@ -504,6 +561,20 @@ class AsyncInMemoryStorage(AsyncBaseStorage):
             self._cache.put(key, (stored_response, time.monotonic()))
         await self._remove_expired_caches()
 
+    async def remove(self, key: RemoveTypes) -> None:
+        """
+        Removes the response from the cache.
+
+        :param key: Hashed value of concatenated HTTP method and URI or an HTTP response
+        :type key: Union[str, Response]
+        """
+
+        if isinstance(key, Response):  # pragma: no cover
+            key = t.cast(str, key.extensions["cache_metadata"]["cache_key"])
+
+        async with self._lock:
+            self._cache.remove_key(key)
+
     async def update_metadata(self, key: str, response: Response, request: Request, metadata: Metadata) -> None:
         """
         Updates the metadata of the stored response.
@@ -634,6 +705,20 @@ class AsyncS3Storage(AsyncBaseStorage):  # pragma: no cover
 
         await self._remove_expired_caches(key)
 
+    async def remove(self, key: RemoveTypes) -> None:
+        """
+        Removes the response from the cache.
+
+        :param key: Hashed value of concatenated HTTP method and URI or an HTTP response
+        :type key: Union[str, Response]
+        """
+
+        if isinstance(key, Response):  # pragma: no cover
+            key = t.cast(str, key.extensions["cache_metadata"]["cache_key"])
+
+        async with self._lock:
+            await self._s3_manager.remove_entry(key)
+
     async def update_metadata(self, key: str, response: Response, request: Request, metadata: Metadata) -> None:
         """
         Updates the metadata of the stored response.

hishel/_async/_transports.py

@@ -156,6 +156,7 @@ class AsyncCacheTransport(httpx.AsyncBaseTransport):
                     url=normalized_url(res.url),
                     headers=res.headers,
                     stream=AsyncCacheStream(res.stream),
+                    extensions=res.extensions,
                 )
                 try:
                     revalidation_response = await self._transport.handle_async_request(revalidation_request)
@@ -181,13 +182,25 @@ class AsyncCacheTransport(httpx.AsyncBaseTransport):
 
                 # Merge headers with the stale response.
                 final_httpcore_response = self._controller.handle_validation_response(
-                    old_response=stored_response, new_response=httpcore_revalidation_response
+                    old_response=stored_response,
+                    new_response=httpcore_revalidation_response,
                 )
 
                 await final_httpcore_response.aread()
                 await revalidation_response.aclose()
 
                 assert isinstance(final_httpcore_response.stream, tp.AsyncIterable)
+
+                # RFC 9111: 4.3.3. Handling a Validation Response
+                # A 304 (Not Modified) response status code indicates that the stored response can be updated and
+                # reused. A full response (i.e., one containing content) indicates that none of the stored responses
+                # nominated in the conditional request are suitable. Instead, the cache MUST use the full response to
+                # satisfy the request. The cache MAY store such a full response, subject to its constraints.
+                if revalidation_response.status_code != 304 and self._controller.is_cachable(
+                    request=httpcore_request, response=final_httpcore_response
+                ):
+                    await self._storage.store(key, response=final_httpcore_response, request=httpcore_request)
+
                 return await self._create_hishel_response(
                     key=key,
                     response=final_httpcore_response,

hishel/_controller.py

@@ -107,6 +107,7 @@ class Controller:
         self,
         cacheable_methods: tp.Optional[tp.List[str]] = None,
         cacheable_status_codes: tp.Optional[tp.List[int]] = None,
+        cache_private: bool = True,
         allow_heuristics: bool = False,
         clock: tp.Optional[BaseClock] = None,
         allow_stale: bool = False,
@@ -128,6 +129,7 @@ class Controller:
                 self._cacheable_methods.append(method.upper())
 
         self._cacheable_status_codes = cacheable_status_codes if cacheable_status_codes else [200, 301, 308]
+        self._cache_private = cache_private
         self._clock = clock if clock else Clock()
         self._allow_heuristics = allow_heuristics
         self._allow_stale = allow_stale
@@ -147,9 +149,6 @@ class Controller:
         method = request.method.decode("ascii")
         force_cache = request.extensions.get("force_cache", None)
 
-        if force_cache if force_cache is not None else self._force_cache:
-            return True
-
         if response.status not in self._cacheable_status_codes:
             return False
 
@@ -160,6 +159,9 @@ class Controller:
         if method not in self._cacheable_methods:
             return False
 
+        if force_cache if force_cache is not None else self._force_cache:
+            return True
+
         response_cache_control = parse_cache_control(extract_header_values_decoded(response.headers, b"cache-control"))
         request_cache_control = parse_cache_control(extract_header_values_decoded(request.headers, b"cache-control"))
 
@@ -176,6 +178,12 @@ class Controller:
         if response_cache_control.no_store and not response_cache_control.must_understand:
             return False
 
+        # a shared cache must not store a response with private directive
+        # Note that we do not implement special handling for the qualified form,
+        # which would only forbid storing specified headers.
+        if not self._cache_private and response_cache_control.private:
+            return False
+
         expires_presents = header_presents(response.headers, b"expires")
         # the response contains at least one of the following:
         # - a public response directive (see Section 5.2.2.9);

hishel/_s3.py

@@ -78,6 +78,10 @@ class S3Manager:
             if get_timestamp_in_ms() - float(obj["Metadata"]["created_at"]) > ttl:
                 self._client.delete_object(Bucket=self._bucket_name, Key=obj["Key"])
 
+    def remove_entry(self, key: str) -> None:
+        path = "hishel-" + key
+        self._client.delete_object(Bucket=self._bucket_name, Key=path)
+
 
 class AsyncS3Manager:  # pragma: no cover
     def __init__(
@@ -93,3 +97,6 @@ class AsyncS3Manager:  # pragma: no cover
 
     async def remove_expired(self, ttl: int, key: str) -> None:
         return await to_thread.run_sync(self._sync_manager.remove_expired, ttl, key)
+
+    async def remove_entry(self, key: str) -> None:
+        return await to_thread.run_sync(self._sync_manager.remove_entry, key)

hishel/_sync/_pool.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime
 import types
 import typing as tp
 
@@ -134,23 +133,31 @@ class CacheConnectionPool(RequestInterface):
                 )
 
                 final_response.read()
+
+                # RFC 9111: 4.3.3. Handling a Validation Response
+                # A 304 (Not Modified) response status code indicates that the stored response can be updated and
+                # reused. A full response (i.e., one containing content) indicates that none of the stored responses
+                # nominated in the conditional request are suitable. Instead, the cache MUST use the full response to
+                # satisfy the request. The cache MAY store such a full response, subject to its constraints.
+                if revalidation_response.status != 304 and self._controller.is_cachable(
+                    request=request, response=final_response
+                ):
+                    self._storage.store(key, response=final_response, request=request)
+
                 return self._create_hishel_response(
                     key=key,
                     response=final_response,
                     request=request,
-                    metadata=metadata,
                     cached=revalidation_response.status == 304,
                     revalidated=True,
+                    metadata=metadata,
                 )
 
         regular_response = self._pool.handle_request(request)
         regular_response.read()
 
         if self._controller.is_cachable(request=request, response=regular_response):
-            metadata = Metadata(
-                cache_key=key, created_at=datetime.datetime.now(datetime.timezone.utc), number_of_uses=0
-            )
-            self._storage.store(key, response=regular_response, request=request, metadata=metadata)
+            self._storage.store(key, response=regular_response, request=request)
 
         return self._create_hishel_response(
             key=key, response=regular_response, request=request, cached=False, revalidated=False

hishel/_sync/_storages.py

@@ -4,6 +4,7 @@ import datetime
 import logging
 import os
 import time
+import typing as t
 import typing as tp
 import warnings
 from copy import deepcopy
@@ -43,6 +44,7 @@ __all__ = (
 )
 
 StoredResponse: TypeAlias = tp.Tuple[Response, Request, Metadata]
+RemoveTypes = tp.Union[str, Response]
 
 try:
     import redis
@@ -62,6 +64,9 @@ class BaseStorage:
     def store(self, key: str, response: Response, request: Request, metadata: Metadata | None = None) -> None:
         raise NotImplementedError()
 
+    def remove(self, key: RemoveTypes) -> None:
+        raise NotImplementedError()
+
     def update_metadata(self, key: str, response: Response, request: Request, metadata: Metadata) -> None:
         raise NotImplementedError()
 
@@ -137,6 +142,23 @@ class FileStorage(BaseStorage):
             )
         self._remove_expired_caches(response_path)
 
+    def remove(self, key: RemoveTypes) -> None:
+        """
+        Removes the response from the cache.
+
+        :param key: Hashed value of concatenated HTTP method and URI or an HTTP response
+        :type key: Union[str, Response]
+        """
+
+        if isinstance(key, Response):  # pragma: no cover
+            key = t.cast(str, key.extensions["cache_metadata"]["cache_key"])
+
+        response_path = self._base_path / key
+
+        with self._lock:
+            if response_path.exists():
+                response_path.unlink()
+
     def update_metadata(self, key: str, response: Response, request: Request, metadata: Metadata) -> None:
         """
         Updates the metadata of the stored response.
@@ -203,11 +225,15 @@ class FileStorage(BaseStorage):
 
         self._last_cleaned = time.monotonic()
         with self._lock:
-            for file in self._base_path.iterdir():
-                if file.is_file():
-                    age = time.time() - file.stat().st_mtime
-                    if age > self._ttl:
-                        file.unlink()
+            with os.scandir(self._base_path) as entries:
+                for entry in entries:
+                    try:
+                        if entry.is_file():
+                            age = time.time() - entry.stat().st_mtime
+                            if age > self._ttl:
+                                os.unlink(entry.path)
+                    except FileNotFoundError:  # pragma: no cover
+                        pass
 
 
 class SQLiteStorage(BaseStorage):
@@ -282,6 +308,24 @@ class SQLiteStorage(BaseStorage):
             self._connection.commit()
         self._remove_expired_caches()
 
+    def remove(self, key: RemoveTypes) -> None:
+        """
+        Removes the response from the cache.
+
+        :param key: Hashed value of concatenated HTTP method and URI or an HTTP response
+        :type key: Union[str, Response]
+        """
+
+        self._setup()
+        assert self._connection
+
+        if isinstance(key, Response):  # pragma: no cover
+            key = t.cast(str, key.extensions["cache_metadata"]["cache_key"])
+
+        with self._lock:
+            self._connection.execute("DELETE FROM cache WHERE key = ?", [key])
+            self._connection.commit()
+
     def update_metadata(self, key: str, response: Response, request: Request, metadata: Metadata) -> None:
         """
         Updates the metadata of the stored response.
@@ -333,8 +377,8 @@ class SQLiteStorage(BaseStorage):
             return self._serializer.loads(cached_response)
 
     def close(self) -> None:  # pragma: no cover
-        assert self._connection
-        self._connection.close()
+        if self._connection is not None:
+            self._connection.close()
 
     def _remove_expired_caches(self) -> None:
         assert self._connection
@@ -404,6 +448,19 @@ class RedisStorage(BaseStorage):
             key, self._serializer.dumps(response=response, request=request, metadata=metadata), px=px
         )
 
+    def remove(self, key: RemoveTypes) -> None:
+        """
+        Removes the response from the cache.
+
+        :param key: Hashed value of concatenated HTTP method and URI or an HTTP response
+        :type key: Union[str, Response]
+        """
+
+        if isinstance(key, Response):  # pragma: no cover
+            key = t.cast(str, key.extensions["cache_metadata"]["cache_key"])
+
+        self._client.delete(key)
+
     def update_metadata(self, key: str, response: Response, request: Request, metadata: Metadata) -> None:
         """
         Updates the metadata of the stored response.
@@ -504,6 +561,20 @@ class InMemoryStorage(BaseStorage):
             self._cache.put(key, (stored_response, time.monotonic()))
         self._remove_expired_caches()
 
+    def remove(self, key: RemoveTypes) -> None:
+        """
+        Removes the response from the cache.
+
+        :param key: Hashed value of concatenated HTTP method and URI or an HTTP response
+        :type key: Union[str, Response]
+        """
+
+        if isinstance(key, Response):  # pragma: no cover
+            key = t.cast(str, key.extensions["cache_metadata"]["cache_key"])
+
+        with self._lock:
+            self._cache.remove_key(key)
+
     def update_metadata(self, key: str, response: Response, request: Request, metadata: Metadata) -> None:
         """
         Updates the metadata of the stored response.
@@ -634,6 +705,20 @@ class S3Storage(BaseStorage):  # pragma: no cover
 
         self._remove_expired_caches(key)
 
+    def remove(self, key: RemoveTypes) -> None:
+        """
+        Removes the response from the cache.
+
+        :param key: Hashed value of concatenated HTTP method and URI or an HTTP response
+        :type key: Union[str, Response]
+        """
+
+        if isinstance(key, Response):  # pragma: no cover
+            key = t.cast(str, key.extensions["cache_metadata"]["cache_key"])
+
+        with self._lock:
+            self._s3_manager.remove_entry(key)
+
     def update_metadata(self, key: str, response: Response, request: Request, metadata: Metadata) -> None:
         """
         Updates the metadata of the stored response.

hishel/_sync/_transports.py

@@ -156,6 +156,7 @@ class CacheTransport(httpx.BaseTransport):
                     url=normalized_url(res.url),
                     headers=res.headers,
                     stream=CacheStream(res.stream),
+                    extensions=res.extensions,
                 )
                 try:
                     revalidation_response = self._transport.handle_request(revalidation_request)
@@ -181,13 +182,25 @@ class CacheTransport(httpx.BaseTransport):
 
                 # Merge headers with the stale response.
                 final_httpcore_response = self._controller.handle_validation_response(
-                    old_response=stored_response, new_response=httpcore_revalidation_response
+                    old_response=stored_response,
+                    new_response=httpcore_revalidation_response,
                 )
 
                 final_httpcore_response.read()
                 revalidation_response.close()
 
                 assert isinstance(final_httpcore_response.stream, tp.Iterable)
+
+                # RFC 9111: 4.3.3. Handling a Validation Response
+                # A 304 (Not Modified) response status code indicates that the stored response can be updated and
+                # reused. A full response (i.e., one containing content) indicates that none of the stored responses
+                # nominated in the conditional request are suitable. Instead, the cache MUST use the full response to
+                # satisfy the request. The cache MAY store such a full response, subject to its constraints.
+                if revalidation_response.status_code != 304 and self._controller.is_cachable(
+                    request=httpcore_request, response=final_httpcore_response
+                ):
+                    self._storage.store(key, response=final_httpcore_response, request=httpcore_request)
+
                 return self._create_hishel_response(
                     key=key,
                     response=final_httpcore_response,

{hishel-0.0.29.dist-info → hishel-0.0.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: hishel
-Version: 0.0.29
+Version: 0.0.31
 Summary: Persistent cache implementation for httpx and httpcore
 Project-URL: Homepage, https://hishel.com
 Project-URL: Source, https://github.com/karpetrosyan/hishel
@@ -175,6 +175,21 @@ Help us grow and continue developing good software for you ❤️
 
 # Changelog
 
+## 0.0.31 (22nd Sep, 2024)
+
+- Ignore file not found error when cleaning up a file storage. (#264)  
+- Fix `AssertionError` on `client.close()` when use SQLiteStorage. (#269)  
+- Fix ignored flags when use `force_cache`. (#271)  
+
+## 0.0.30 (12th July, 2024)
+
+- Fix cache update on revalidation response with content (rfc9111 section 4.3.3) (#239)
+- Fix request extensions that were not passed into revalidation request for transport-based implementation (but were
+  passed for the pool-based impl) (#247).
+- Add `cache_private` property to the controller to support acting as shared cache. (#224)
+- Improve efficiency of scanning cached responses in `FileStorage` by reducing number of syscalls. (#252)
+- Add `remove` support for storages (#241)
+
 ## 0.0.29 (23th June, 2024)
 
 - Documentation hotfix. (#244)
@@ -236,11 +251,11 @@ Help us grow and continue developing good software for you ❤️
 - Add `cache_disabled` extension to temporarily disable the cache (#109)
 - Update `datetime.datetime.utcnow()` to `datetime.datetime.now(datetime.timezone.utc)` since `datetime.datetime.utcnow()` has been deprecated. (#111)
 
-## 0.0.17 (6th November, 2023) 
+## 0.0.17 (6th November, 2023)
 
 - Fix `Last-Modified` validation.
 
-## 0.0.16 (25th October, 2023) 
+## 0.0.16 (25th October, 2023)
 
 - Add `install_cache` function. (#95)
 - Add sqlite support. (#92)
@@ -260,19 +275,19 @@ Help us grow and continue developing good software for you ❤️
 
 - Add metadata into the response extensions. (#56)
 
-## 0.0.11 (15th August, 2023) 
+## 0.0.11 (15th August, 2023)
 
 - Add support for request `cache-control` directives. (#42)
 - Drop httpcore dependency. (#40)
 - Support HTTP methods only if they are defined as cacheable. (#37)
 
-## 0.0.10 (7th August, 2023) 
+## 0.0.10 (7th August, 2023)
 
 - Add Response metadata. (#33)
 - Add API Reference documentation. (#30)
 - Use stale responses only if the client is disconnected. (#28)
 
-## 0.0.9 (1st August, 2023) 
+## 0.0.9 (1st August, 2023)
 
 - Expose Controller API. (#23)
 
@@ -291,7 +306,7 @@ Help us grow and continue developing good software for you ❤️
 ## 0.0.6 (29th July, 2023)
 
 - Fix `Vary` header validation. (#8)
-- Dump original requests with the responses. (#7) 
+- Dump original requests with the responses. (#7)
 
 ## 0.0.5 (29th July, 2023)
 

{hishel-0.0.29.dist-info → hishel-0.0.31.dist-info}/RECORD

@@ -1,10 +1,10 @@
-hishel/__init__.py,sha256=tEkEGJBbvP_DYRcH8K3qWbq9bujyIN6grOMnTWL6Nsg,369
-hishel/_controller.py,sha256=WHpztkcL-eL04lQK4ZTLEOfg-FzmS3nHx82K5bhtT9M,15482
+hishel/__init__.py,sha256=XNbMtsi4tkqZZ6AgwVBDu6BumB6WkK3alKCqk-JVDWs,369
+hishel/_controller.py,sha256=kfWAAtgP4RCYNPH33XeDJRJ-zajqS_w0ZbM0M0CsKiY,15875
 hishel/_exceptions.py,sha256=qbg55RNlzwhv5JreWY9Zog_zmmiKdn5degtqJKijuRs,198
 hishel/_files.py,sha256=7J5uX7Nnzd7QQWfYuDGh8v6XGLG3eUDBjoJZ4aTaY1c,2228
 hishel/_headers.py,sha256=TWuHi7sRoeS2xxdNGujKmqWtgncUqfhNGCgHKYpRU-I,7329
 hishel/_lfu_cache.py,sha256=GBxToQI8u_a9TzYnLlZMLhgZ8Lb83boPHzTvIgqV6pA,2707
-hishel/_s3.py,sha256=DF9mXOzVDBgj_xgSJ8lud3nGGpWSacCJuzdfT5FvdRA,3456
+hishel/_s3.py,sha256=JqRlygITK5uAryviC15HZKQlKY7etUOPWcazTJeYKBI,3736
 hishel/_serializers.py,sha256=gepVb8JC4aBkGw9kLcbAsyo-1XgK_lzTssLr_8av4SQ,11640
 hishel/_synchronization.py,sha256=xOmU9_8KAWTAv3r8EpqPISrtSF3slyh1J0Sc7ZQO1rg,897
 hishel/_utils.py,sha256=cgLGjBI7H-T_DkYBXiHiEEf8SGjGeZ6Cc2IHbLAZybU,2501
@@ -12,16 +12,16 @@ hishel/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hishel/_async/__init__.py,sha256=_oAltH4emAtUF7_9SSxz_KKGYzSXL34o_EGgGvoPG7E,187
 hishel/_async/_client.py,sha256=AkVSSbNTTHmK0gX6PRYVQ-3aDbuCX2Im4VKbLkwLiBU,1101
 hishel/_async/_mock.py,sha256=995v9p5xiw3svGSOJATkLMqwodlhZhcwmGygLHM2VFw,1515
-hishel/_async/_pool.py,sha256=CWR-dJvl7_rRFrfckhl7TpULwpTL6U26mgDg4JDJbVY,7574
-hishel/_async/_storages.py,sha256=Ny3viIpJH9RfgeyYmbiLnDWeyJ-j9aNfgcbhHLyk550,25806
-hishel/_async/_transports.py,sha256=F_n0n5YL47Rnh-VdNVpA-rwWSwPSQQbf7YZoSjV-ic0,10277
+hishel/_async/_pool.py,sha256=li-921qyGzrV7SVUOUlMI0KE7IRsupSkE5iApzxmgqk,8175
+hishel/_async/_storages.py,sha256=SPWifKGSGAFP2wMFoxZf5weZFbuVgHFciyglY6Hb6fc,28699
+hishel/_async/_transports.py,sha256=moeH-eQLJHkMp83NnScgsQTSQntDCR1_4A1ByZ_fXjk,11174
 hishel/_sync/__init__.py,sha256=_oAltH4emAtUF7_9SSxz_KKGYzSXL34o_EGgGvoPG7E,187
 hishel/_sync/_client.py,sha256=O-gwm9DsveKtSFUfqdbBB-3I1FmXr5rE-uQ7X5frwDA,1060
 hishel/_sync/_mock.py,sha256=im88tZr-XhP9BpzvIt3uOjndAlNcJvFP7Puv3H-6lKU,1430
-hishel/_sync/_pool.py,sha256=VQlSJUQidskzRLIrOzh9vMDQbZbsyTYi967KUBqRi5E,7345
-hishel/_sync/_storages.py,sha256=rdAaQuO9y6kDXEiUPRX2O-uMrk0mjmYHWoOL6gP_VEE,25106
-hishel/_sync/_transports.py,sha256=CK3HsN5pFLPOWbc0dWMbgHWw5ZZB1JJLAaTbEGv8oZ0,9947
-hishel-0.0.29.dist-info/METADATA,sha256=vqxFQ8Xc4ESbWcnEYw43EztYYarWQrsH9YRN6039Ux0,10737
-hishel-0.0.29.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-hishel-0.0.29.dist-info/licenses/LICENSE,sha256=1qQj7pE0V2O9OIedvyOgLGLvZLaPd3nFEup3IBEOZjQ,1493
-hishel-0.0.29.dist-info/RECORD,,
+hishel/_sync/_pool.py,sha256=VcAknzyAL2i4-zcyE2fOTmTjfBZ2wkBVNYTvSw0OjVQ,7940
+hishel/_sync/_storages.py,sha256=RYzYXqnv0o2JO3RoEmlEUp0yOg_ungXfz4dLN7UTpIQ,27909
+hishel/_sync/_transports.py,sha256=G3_8SdPwlnrHZRvE1gqFLE4oZadVqNgg5mvxghDMih0,10838
+hishel-0.0.31.dist-info/METADATA,sha256=-hIw1fiLfsgB3RmeHqw4odYGvdE4iezkjqZijkD6JvM,11478
+hishel-0.0.31.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+hishel-0.0.31.dist-info/licenses/LICENSE,sha256=1qQj7pE0V2O9OIedvyOgLGLvZLaPd3nFEup3IBEOZjQ,1493
+hishel-0.0.31.dist-info/RECORD,,