hishel 1.0.0.dev1__tar.gz → 1.0.0.dev2__tar.gz

{hishel-1.0.0.dev1 → hishel-1.0.0.dev2}/CHANGELOG.md

@@ -2,44 +2,62 @@
 
 All notable changes to this project will be documented in this file.
 
-## 1.0.0dev1 - 2025-10-21
-### <!-- 7 -->⚙️ Miscellaneous Tasks
+## 1.0.0.dev2 - 2025-10-21
+### ⚙️ Miscellaneous Tasks
+- Remove redundant utils and tests
+- Add import without extras check in ci
+
+### 🐛 Bug Fixes
+- Fix check for storing auth requests
+- Don't raise an error on 3xx during revalidation
+
+### 🚀 Features
+- Add hishel_created_at response metadata
+
+## 1.0.0.dev1 - 2025-10-21
+### ⚙️ Miscellaneous Tasks
 - Remove some redundant utils methods
 
+### 📦 Dependencies
+- Make httpx and async libs optional dependencies
+- Make `anysqlite` optional dependency
+- Install async extra with httpx
+- Improve git-cliff
+
 ## 1.0.0.dev0 - 2025-10-19
-### <!-- 7 -->⚙️ Miscellaneous Tasks
+### ⚙️ Miscellaneous Tasks
 - Use mike powered versioning
 - Improve docs versioning, deploy dev doc on ci
 
 ## 0.1.5 - 2025-10-18
-### <!-- 0 -->🚀 Features
+### ⚙️ Miscellaneous Tasks
+- Remove some redundant files from repo
+
+### 🐛 Bug Fixes
+- Fix some line breaks
+
+### 🚀 Features
 - Set chunk size to 128KB for httpx to reduce SQLite read/writes
 - Better cache-control parsing
 - Add close method to storages API (#384)
 - Increase requests buffer size to 128KB, disable charset detection
 
-### <!-- 1 -->🐛 Bug Fixes
-- Fix some line breaks
+## 0.1.4 - 2025-10-14
+### ⚙️ Miscellaneous Tasks
+- Improve CI (#369)
+- Remove src folder (#373)
+- Temporary remove python3.14 from CI
+- Add sqlite tests for new storage
+- Move some tests to beta
 
-### <!-- 7 -->⚙️ Miscellaneous Tasks
-- Remove some redundant files from repo
+### 🐛 Bug Fixes
+- Create an sqlite file in a cache folder
+- Fix beta imports
 
-## 0.1.4 - 2025-10-14
-### <!-- 0 -->🚀 Features
+### 🚀 Features
 - Add support for a sans-IO API (#366)
 - Allow already consumed streams with `CacheTransport` (#377)
 - Add sqlite storage for beta storages
 - Get rid of some locks from sqlite storage
 - Better async implemetation for sqlite storage
 
-### <!-- 1 -->🐛 Bug Fixes
-- Create an sqlite file in a cache folder
-- Fix beta imports
-
-### <!-- 7 -->⚙️ Miscellaneous Tasks
-- Improve CI (#369)
-- Remove src folder (#373)
-- Temporary remove python3.14 from CI
-- Add sqlite tests for new storage
-- Move some tests to beta
-

{hishel-1.0.0.dev1 → hishel-1.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hishel
-Version: 1.0.0.dev1
+Version: 1.0.0.dev2
 Summary:  Elegant HTTP Caching for Python
 Project-URL: Homepage, https://hishel.com
 Project-URL: Source, https://github.com/karpetrosyan/hishel
@@ -255,44 +255,62 @@ Hishel is inspired by and builds upon the excellent work in the Python HTTP ecos
 
 All notable changes to this project will be documented in this file.
 
-## 1.0.0dev1 - 2025-10-21
-### <!-- 7 -->⚙️ Miscellaneous Tasks
+## 1.0.0.dev2 - 2025-10-21
+### ⚙️ Miscellaneous Tasks
+- Remove redundant utils and tests
+- Add import without extras check in ci
+
+### 🐛 Bug Fixes
+- Fix check for storing auth requests
+- Don't raise an error on 3xx during revalidation
+
+### 🚀 Features
+- Add hishel_created_at response metadata
+
+## 1.0.0.dev1 - 2025-10-21
+### ⚙️ Miscellaneous Tasks
 - Remove some redundant utils methods
 
+### 📦 Dependencies
+- Make httpx and async libs optional dependencies
+- Make `anysqlite` optional dependency
+- Install async extra with httpx
+- Improve git-cliff
+
 ## 1.0.0.dev0 - 2025-10-19
-### <!-- 7 -->⚙️ Miscellaneous Tasks
+### ⚙️ Miscellaneous Tasks
 - Use mike powered versioning
 - Improve docs versioning, deploy dev doc on ci
 
 ## 0.1.5 - 2025-10-18
-### <!-- 0 -->🚀 Features
+### ⚙️ Miscellaneous Tasks
+- Remove some redundant files from repo
+
+### 🐛 Bug Fixes
+- Fix some line breaks
+
+### 🚀 Features
 - Set chunk size to 128KB for httpx to reduce SQLite read/writes
 - Better cache-control parsing
 - Add close method to storages API (#384)
 - Increase requests buffer size to 128KB, disable charset detection
 
-### <!-- 1 -->🐛 Bug Fixes
-- Fix some line breaks
+## 0.1.4 - 2025-10-14
+### ⚙️ Miscellaneous Tasks
+- Improve CI (#369)
+- Remove src folder (#373)
+- Temporary remove python3.14 from CI
+- Add sqlite tests for new storage
+- Move some tests to beta
 
-### <!-- 7 -->⚙️ Miscellaneous Tasks
-- Remove some redundant files from repo
+### 🐛 Bug Fixes
+- Create an sqlite file in a cache folder
+- Fix beta imports
 
-## 0.1.4 - 2025-10-14
-### <!-- 0 -->🚀 Features
+### 🚀 Features
 - Add support for a sans-IO API (#366)
 - Allow already consumed streams with `CacheTransport` (#377)
 - Add sqlite storage for beta storages
 - Get rid of some locks from sqlite storage
 - Better async implemetation for sqlite storage
 
-### <!-- 1 -->🐛 Bug Fixes
-- Create an sqlite file in a cache folder
-- Fix beta imports
-
-### <!-- 7 -->⚙️ Miscellaneous Tasks
-- Improve CI (#369)
-- Remove src folder (#373)
-- Temporary remove python3.14 from CI
-- Add sqlite tests for new storage
-- Move some tests to beta
-

{hishel-1.0.0.dev1 → hishel-1.0.0.dev2}/hishel/_async_cache.py

@@ -25,7 +25,7 @@ from hishel import (
     create_idle_state,
 )
 from hishel._core._spec import InvalidatePairs, vary_headers_match
-from hishel._core.models import CompletePair
+from hishel._core.models import CompletePair, ResponseMetadata
 
 logger = logging.getLogger("hishel.integrations.clients")
 
@@ -90,7 +90,14 @@ class AsyncCacheProxy:
                 logger.debug(
                     "Found matching cached response for the request",
                 )
-                pair.response.metadata["hishel_from_cache"] = True  # type: ignore
+                response_meta = ResponseMetadata(
+                    hishel_spec_ignored=True,
+                    hishel_from_cache=True,
+                    hishel_created_at=pair.meta.created_at,
+                    hishel_revalidated=False,
+                    hishel_stored=False,
+                )
+                pair.response.metadata.update(response_meta)  # type: ignore
                 await self._maybe_refresh_pair_ttl(pair)
                 return pair.response
 

{hishel-1.0.0.dev1 → hishel-1.0.0.dev2}/hishel/_core/_spec.py

@@ -16,6 +16,7 @@ from typing import (
 )
 
 from hishel._core._headers import Headers, Range, Vary, parse_cache_control
+from hishel._core.models import ResponseMetadata
 from hishel._utils import parse_date, partition
 
 if TYPE_CHECKING:
@@ -1412,16 +1413,11 @@ class IdleClient(State):
             #
             # The Age header informs the client how old the cached response is.
 
-            # Mark all ready-to-use responses with metadata (for observability)
-            for pair in ready_to_use:
-                pair.response.metadata["hishel_from_cache"] = True  # type: ignore
-
             # Use the most recent response (first in sorted list)
             selected_pair = ready_to_use[0]
 
             # Calculate current age and update the Age header
             current_age = get_age(selected_pair.response)
-
             return FromCache(
                 pair=replace(
                     selected_pair,
@@ -1578,20 +1574,6 @@ class CacheMiss(State):
            * an s-maxage response directive (if cache is shared)
            * a status code that is defined as heuristically cacheable"
 
-        Side Effects:
-        ------------
-        Sets metadata flags on the response object:
-        - hishel_spec_ignored: False (caching spec is being followed)
-        - hishel_from_cache: False (response is from origin, not cache)
-        - hishel_revalidated: True (if after_revalidation is True)
-        - hishel_stored: True/False (whether response was stored)
-
-        Logging:
-        -------
-        When a response cannot be stored, detailed debug logs are emitted explaining
-        which specific RFC requirement failed, with direct links to the relevant
-        RFC sections.
-
         Examples:
         --------
         >>> # Cacheable response
@@ -1614,21 +1596,6 @@ class CacheMiss(State):
         True
         """
 
-        # ============================================================================
-        # STEP 1: Set Response Metadata
-        # ============================================================================
-        # Initialize metadata flags to track the response lifecycle
-
-        response.metadata["hishel_spec_ignored"] = False  # type: ignore
-        # We are following the caching specification
-
-        response.metadata["hishel_from_cache"] = False  # type: ignore
-        # This response came from origin server, not cache
-
-        if self.after_revalidation:
-            response.metadata["hishel_revalidated"] = True  # type: ignore
-            # Mark that this response is the result of a revalidation
-
         # ============================================================================
         # STEP 2: Parse Cache-Control Directive
         # ============================================================================
@@ -1723,11 +1690,14 @@ class CacheMiss(State):
         #
         # Requests with Authorization headers often contain user-specific data.
         # Shared caches must be careful not to serve one user's data to another.
-        #
-        # This check is inverted in the current implementation and needs review:
-        # TODO: Fix logic - should be: (not shared) OR (no auth header) OR (has explicit directive)
-        # Current logic: (shared) AND (no auth header)
-        is_shared_and_authorized = not (self.options.shared and "authorization" in request.headers)
+        has_explicit_directive = (
+            response_cache_control.public
+            or response_cache_control.s_maxage is not None
+            or response_cache_control.must_revalidate
+        )
+        can_cache_auth_request = (
+            not self.options.shared or "authorization" not in request.headers or has_explicit_directive
+        )
 
         # CONDITION 7: Response Contains Required Caching Information
         # RFC 9111 Section 3, paragraph 2.7:
@@ -1797,7 +1767,7 @@ class CacheMiss(State):
             or not understands_how_to_cache
             or not no_store_is_not_present
             or not private_directive_allows_storing
-            or not is_shared_and_authorized
+            or not can_cache_auth_request
             or not contains_required_component
         ):
             # --------------------------------------------------------------------
@@ -1833,10 +1803,11 @@ class CacheMiss(State):
                         "Cannot store the response because the `private` response directive does not "
                         "allow shared caches to store it. See: https://www.rfc-editor.org/rfc/rfc9111.html#section-3-2.5.1"
                     )
-                elif not is_shared_and_authorized:
+                elif not can_cache_auth_request:
                     logger.debug(
-                        "Cannot store the response because the cache is shared and the request contains "
-                        "an Authorization header field. See: https://www.rfc-editor.org/rfc/rfc9111.html#section-3-2.6.1"
+                        "Cannot store the response because the request contained an Authorization header "
+                        "and there was no explicit directive allowing shared caching. "
+                        "See: https://www.rfc-editor.org/rfc/rfc9111.html#section-3-5"
                     )
                 elif not contains_required_component:
                     logger.debug(
@@ -1844,10 +1815,9 @@ class CacheMiss(State):
                         "See: https://www.rfc-editor.org/rfc/rfc9111.html#section-3-2.7.1"
                     )
 
-            # Mark response as not stored
-            response.metadata["hishel_stored"] = False  # type: ignore
-
-            return CouldNotBeStored(response=response, pair_id=pair_id, options=self.options)
+            return CouldNotBeStored(
+                response=response, pair_id=pair_id, options=self.options, after_revalidation=self.after_revalidation
+            )
 
         # --------------------------------------------------------------------
         # Transition to: StoreAndUse
@@ -1856,9 +1826,6 @@ class CacheMiss(State):
 
         logger.debug("Storing response in cache")
 
-        # Mark response as stored
-        response.metadata["hishel_stored"] = True  # type: ignore
-
         # Remove headers that should not be stored
         # RFC 9111 Section 3.1: Storing Header and Trailer Fields
         # https://www.rfc-editor.org/rfc/rfc9111.html#section-3.1
@@ -1869,6 +1836,7 @@ class CacheMiss(State):
             pair_id=pair_id,
             response=cleaned_response,
             options=self.options,
+            after_revalidation=self.after_revalidation,
         )
 
 
@@ -1929,7 +1897,9 @@ class NeedRevalidation(State):
     The stored pairs that the request was sent for revalidation.
     """
 
-    def next(self, revalidation_response: Response) -> Union["NeedToBeUpdated", "InvalidatePairs", "CacheMiss"]:
+    def next(
+        self, revalidation_response: Response
+    ) -> Union["NeedToBeUpdated", "InvalidatePairs", "CacheMiss", "FromCache"]:
         """
         Handles the response to a conditional request and determines the next state.
 
@@ -2084,6 +2054,15 @@ class NeedRevalidation(State):
                     after_revalidation=True,
                 ).next(revalidation_response, pair_id=self.revalidating_pairs[-1].id),
             )
+        elif revalidation_response.status_code // 100 == 3:
+            # 3xx Redirects should have been followed by the HTTP client
+            return FromCache(
+                pair=replace(
+                    self.revalidating_pairs[-1],
+                    response=revalidation_response,
+                ),
+                options=self.options,
+            )
 
         # ============================================================================
         # STEP 4: Handle Unexpected Status Codes
@@ -2316,32 +2295,99 @@ class NeedRevalidation(State):
         return next_state
 
 
-@dataclass
+# @dataclass
+# class StoreAndUse(State):
+#     """
+#     The state that indicates that the response can be stored in the cache and used.
+#     """
+
+#     pair_id: uuid.UUID
+
+#     response: Response
+
+#     def next(self) -> None:
+#         return None  # pragma: nocover
+
+
 class StoreAndUse(State):
     """
     The state that indicates that the response can be stored in the cache and used.
-    """
 
-    pair_id: uuid.UUID
+    Attributes:
+    ----------
+    pair_id : uuid.UUID
+        The unique identifier for the cache pair.
+    response : Response
+        The HTTP response to be stored in the cache.
+    after_revalidation : bool
+        Indicates if the storage is occurring after a revalidation process.
+    """
 
-    response: Response
+    def __init__(
+        self, pair_id: uuid.UUID, response: Response, options: CacheOptions, after_revalidation: bool = False
+    ) -> None:
+        super().__init__(options)
+        self.pair_id = pair_id
+        self.response = response
+        self.after_revalidation = after_revalidation
+        response_meta = ResponseMetadata(
+            hishel_created_at=time.time(),
+            hishel_from_cache=False,
+            hishel_spec_ignored=False,
+            hishel_revalidated=after_revalidation,
+            hishel_stored=True,
+        )
+        self.response.metadata.update(response_meta)  # type: ignore
 
     def next(self) -> None:
-        return None  # pragma: nocover
+        return None
+
+
+# @dataclass
+# class CouldNotBeStored(State):
+#     """
+#     The state that indicates that the response could not be stored in the cache.
+#     """
+
+#     response: Response
+
+#     pair_id: uuid.UUID
+
+#     def next(self) -> None:
+#         return None  # pragma: nocover
 
 
-@dataclass
 class CouldNotBeStored(State):
     """
     The state that indicates that the response could not be stored in the cache.
-    """
 
-    response: Response
+    Attributes:
+    ----------
+    response : Response
+        The HTTP response that could not be stored.
+    pair_id : uuid.UUID
+        The unique identifier for the cache pair.
+    after_revalidation : bool
+        Indicates if the storage attempt occurred after a revalidation process.
+    """
 
-    pair_id: uuid.UUID
+    def __init__(
+        self, response: Response, pair_id: uuid.UUID, options: CacheOptions, after_revalidation: bool = False
+    ) -> None:
+        super().__init__(options)
+        self.response = response
+        self.pair_id = pair_id
+        response_meta = ResponseMetadata(
+            hishel_created_at=time.time(),
+            hishel_from_cache=False,
+            hishel_spec_ignored=False,
+            hishel_revalidated=after_revalidation,
+            hishel_stored=False,
+        )
+        self.response.metadata.update(response_meta)  # type: ignore
 
     def next(self) -> None:
-        return None  # pragma: nocover
+        return None
 
 
 @dataclass
@@ -2358,15 +2404,22 @@ class InvalidatePairs(State):
         return self.next_state
 
 
-@dataclass
 class FromCache(State):
-    pair: CompletePair
-    """
-    List of pairs that can be used to satisfy the request.
-    """
+    def __init__(self, pair: CompletePair, options: CacheOptions, after_revalidation: bool = False) -> None:
+        super().__init__(options)
+        self.pair = pair
+        self.after_revalidation = after_revalidation
+        response_meta = ResponseMetadata(
+            hishel_created_at=pair.meta.created_at,
+            hishel_from_cache=True,
+            hishel_spec_ignored=False,
+            hishel_revalidated=after_revalidation,
+            hishel_stored=False,
+        )
+        self.pair.response.metadata.update(response_meta)  # type: ignore
 
     def next(self) -> None:
-        return None  # pragma: nocover
+        return None
 
 
 @dataclass

{hishel-1.0.0.dev1 → hishel-1.0.0.dev2}/hishel/_core/models.py

@@ -109,18 +109,21 @@ class Request:
 
 class ResponseMetadata(TypedDict, total=False):
     # All the names here should be prefixed with "hishel_" to avoid collisions with user data
-    hishel_from_cache: bool | None
+    hishel_from_cache: bool
     """Indicates whether the response was served from cache."""
 
-    hishel_revalidated: bool | None
+    hishel_revalidated: bool
     """Indicates whether the response was revalidated with the origin server."""
 
-    hishel_spec_ignored: bool | None
+    hishel_spec_ignored: bool
     """Indicates whether the caching specification was ignored for this response."""
 
-    hishel_stored: bool | None
+    hishel_stored: bool
     """Indicates whether the response was stored in cache."""
 
+    hishel_created_at: float
+    """Timestamp when the response was cached."""
+
 
 @dataclass
 class Response:

{hishel-1.0.0.dev1 → hishel-1.0.0.dev2}/hishel/_sync_cache.py

@@ -25,7 +25,7 @@ from hishel import (
     create_idle_state,
 )
 from hishel._core._spec import InvalidatePairs, vary_headers_match
-from hishel._core.models import CompletePair
+from hishel._core.models import CompletePair, ResponseMetadata
 
 logger = logging.getLogger("hishel.integrations.clients")
 
@@ -90,7 +90,14 @@ class SyncCacheProxy:
                 logger.debug(
                     "Found matching cached response for the request",
                 )
-                pair.response.metadata["hishel_from_cache"] = True  # type: ignore
+                response_meta = ResponseMetadata(
+                    hishel_spec_ignored=True,
+                    hishel_from_cache=True,
+                    hishel_created_at=pair.meta.created_at,
+                    hishel_revalidated=False,
+                    hishel_stored=False,
+                )
+                pair.response.metadata.update(response_meta)  # type: ignore
                 self._maybe_refresh_pair_ttl(pair)
                 return pair.response
 

hishel-1.0.0.dev2/hishel/_utils.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import calendar
+import time
+import typing as tp
+from email.utils import parsedate_tz
+from typing import AsyncIterator, Iterable, Iterator
+
+HEADERS_ENCODING = "iso-8859-1"
+
+T = tp.TypeVar("T")
+
+
+def parse_date(date: str) -> tp.Optional[int]:
+    expires = parsedate_tz(date)
+    if expires is None:
+        return None
+    timestamp = calendar.timegm(expires[:6])
+    return timestamp
+
+
+def sleep(seconds: tp.Union[int, float]) -> None:
+    time.sleep(seconds)
+
+
+def partition(iterable: tp.Iterable[T], predicate: tp.Callable[[T], bool]) -> tp.Tuple[tp.List[T], tp.List[T]]:
+    """
+    Partition an iterable into two lists: one for matching items and one for non-matching items.
+
+    Args:
+        iterable (tp.Iterable[T]): The input iterable to partition.
+        predicate (tp.Callable[[T], bool]): A function that evaluates each item in the iterable.
+
+    Returns:
+        tp.Tuple[tp.List[T], tp.List[T]]: A tuple containing two lists: the first for matching items,
+        and the second for non-matching items.
+    Example:
+        ```
+        iterable = [1, 2, 3, 4, 5]
+        is_even = lambda x: x % 2 == 0
+        evens, odds = partition(iterable, is_even)
+        ```
+    """
+    matching, non_matching = [], []
+    for item in iterable:
+        if predicate(item):
+            matching.append(item)
+        else:
+            non_matching.append(item)
+    return matching, non_matching
+
+
+async def make_async_iterator(iterable: Iterable[bytes]) -> AsyncIterator[bytes]:
+    for item in iterable:
+        yield item
+
+
+def make_sync_iterator(iterable: Iterable[bytes]) -> Iterator[bytes]:
+    for item in iterable:
+        yield item
+
+
+def snake_to_header(text: str) -> str:
+    """
+    Convert snake_case string to Header-Case format.
+
+    Args:
+        text: Snake case string (e.g., "hishel_ttl")
+
+    Returns:
+        Header case string (e.g., "X-Hishel-Ttl")
+
+    Examples:
+        >>> snake_to_header("hishel_ttl")
+        'X-Hishel-Ttl'
+        >>> snake_to_header("cache_control")
+        'X-Cache-Control'
+        >>> snake_to_header("content_type")
+        'X-Content-Type'
+    """
+    # Split by underscore, capitalize each word, join with dash, add X- prefix
+    return "X-" + "-".join(word.capitalize() for word in text.split("_"))

{hishel-1.0.0.dev1 → hishel-1.0.0.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hishel"
-version = "1.0.0.dev1"
+version = "1.0.0.dev2"
 dynamic = ["readme"]
 description = " Elegant HTTP Caching for Python"
 license = "BSD-3-Clause"

hishel-1.0.0.dev1/hishel/_utils.py

@@ -1,218 +0,0 @@
-from __future__ import annotations
-
-import calendar
-import hashlib
-import time
-import typing as tp
-from email.utils import parsedate_tz
-from typing import AsyncIterator, Generator, Iterable, Iterator, TypeVar
-
-import httpcore
-import httpx
-
-HEADERS_ENCODING = "iso-8859-1"
-
-T = tp.TypeVar("T")
-
-
-class BaseClock:
-    def now(self) -> int:
-        raise NotImplementedError()
-
-
-class Clock(BaseClock):
-    def now(self) -> int:
-        return int(time.time())
-
-
-def normalized_url(url: tp.Union[httpcore.URL, str, bytes]) -> str:
-    if isinstance(url, str):  # pragma: no cover
-        return url
-
-    if isinstance(url, bytes):  # pragma: no cover
-        return url.decode("ascii")
-
-    if isinstance(url, httpcore.URL):
-        port = f":{url.port}" if url.port is not None else ""
-        return f"{url.scheme.decode('ascii')}://{url.host.decode('ascii')}{port}{url.target.decode('ascii')}"
-    assert False, "Invalid type for `normalized_url`"  # pragma: no cover
-
-
-def get_safe_url(url: httpcore.URL) -> str:
-    httpx_url = httpx.URL(bytes(url).decode("ascii"))
-
-    schema = httpx_url.scheme
-    host = httpx_url.host
-    path = httpx_url.path
-
-    return f"{schema}://{host}{path}"
-
-
-def generate_key(request: httpcore.Request, body: bytes = b"") -> str:
-    encoded_url = normalized_url(request.url).encode("ascii")
-
-    key_parts = [request.method, encoded_url, body]
-
-    # FIPs mode disables blake2 algorithm, use sha256 instead when not found.
-    blake2b_hasher = None
-    sha256_hasher = hashlib.sha256(usedforsecurity=False)
-    try:
-        blake2b_hasher = hashlib.blake2b(digest_size=16, usedforsecurity=False)
-    except (ValueError, TypeError, AttributeError):
-        pass
-
-    hexdigest: str
-    if blake2b_hasher:
-        for part in key_parts:
-            blake2b_hasher.update(part)
-
-        hexdigest = blake2b_hasher.hexdigest()
-    else:
-        for part in key_parts:
-            sha256_hasher.update(part)
-
-        hexdigest = sha256_hasher.hexdigest()
-    return hexdigest
-
-
-def extract_header_values(
-    headers: tp.List[tp.Tuple[bytes, bytes]],
-    header_key: tp.Union[bytes, str],
-    single: bool = False,
-) -> tp.List[bytes]:
-    if isinstance(header_key, str):
-        header_key = header_key.encode(HEADERS_ENCODING)
-    extracted_headers = []
-    for key, value in headers:
-        if key.lower() == header_key.lower():
-            extracted_headers.append(value)
-            if single:
-                break
-    return extracted_headers
-
-
-def extract_header_values_decoded(
-    headers: tp.List[tp.Tuple[bytes, bytes]], header_key: bytes, single: bool = False
-) -> tp.List[str]:
-    values = extract_header_values(headers=headers, header_key=header_key, single=single)
-    return [value.decode(HEADERS_ENCODING) for value in values]
-
-
-def header_presents(headers: tp.List[tp.Tuple[bytes, bytes]], header_key: bytes) -> bool:
-    return bool(extract_header_values(headers, header_key, single=True))
-
-
-def parse_date(date: str) -> tp.Optional[int]:
-    expires = parsedate_tz(date)
-    if expires is None:
-        return None
-    timestamp = calendar.timegm(expires[:6])
-    return timestamp
-
-
-def sleep(seconds: tp.Union[int, float]) -> None:
-    time.sleep(seconds)
-
-
-def float_seconds_to_int_milliseconds(seconds: float) -> int:
-    return int(seconds * 1000)
-
-
-def partition(iterable: tp.Iterable[T], predicate: tp.Callable[[T], bool]) -> tp.Tuple[tp.List[T], tp.List[T]]:
-    """
-    Partition an iterable into two lists: one for matching items and one for non-matching items.
-
-    Args:
-        iterable (tp.Iterable[T]): The input iterable to partition.
-        predicate (tp.Callable[[T], bool]): A function that evaluates each item in the iterable.
-
-    Returns:
-        tp.Tuple[tp.List[T], tp.List[T]]: A tuple containing two lists: the first for matching items,
-        and the second for non-matching items.
-    Example:
-        ```
-        iterable = [1, 2, 3, 4, 5]
-        is_even = lambda x: x % 2 == 0
-        evens, odds = partition(iterable, is_even)
-        ```
-    """
-    matching, non_matching = [], []
-    for item in iterable:
-        if predicate(item):
-            matching.append(item)
-        else:
-            non_matching.append(item)
-    return matching, non_matching
-
-
-async def make_async_iterator(iterable: Iterable[bytes]) -> AsyncIterator[bytes]:
-    for item in iterable:
-        yield item
-
-
-def make_sync_iterator(iterable: Iterable[bytes]) -> Iterator[bytes]:
-    for item in iterable:
-        yield item
-
-
-def snake_to_header(text: str) -> str:
-    """
-    Convert snake_case string to Header-Case format.
-
-    Args:
-        text: Snake case string (e.g., "hishel_ttl")
-
-    Returns:
-        Header case string (e.g., "X-Hishel-Ttl")
-
-    Examples:
-        >>> snake_to_header("hishel_ttl")
-        'X-Hishel-Ttl'
-        >>> snake_to_header("cache_control")
-        'X-Cache-Control'
-        >>> snake_to_header("content_type")
-        'X-Content-Type'
-    """
-    # Split by underscore, capitalize each word, join with dash, add X- prefix
-    return "X-" + "-".join(word.capitalize() for word in text.split("_"))
-
-
-_T = TypeVar("_T")
-
-
-class GeneratorWithReturnValue:
-    def __init__(
-        self, gen: Generator[None, bytes | None, bytes], stream: AsyncIterator[bytes] | Iterator[bytes]
-    ) -> None:
-        self.gen = gen
-        self.stream = stream
-        self.value: bytes | None = None
-
-    def __iter__(self) -> Iterator[bytes]:
-        return self
-
-    def __next__(self) -> bytes:
-        assert isinstance(self.stream, Iterator)
-
-        try:
-            chunk = next(self.stream)
-            self.gen.send(chunk)
-        except StopIteration as exc:
-            self.gen.send(None)
-            self.value = exc.value
-            raise
-        return chunk
-
-    def __aiter__(self) -> AsyncIterator[bytes]:
-        return self
-
-    async def __anext__(self) -> bytes:
-        assert isinstance(self.stream, AsyncIterator)
-        try:
-            chunk = await self.stream.__anext__()
-            self.gen.send(chunk)
-        except StopIteration as exc:
-            self.gen.send(None)
-            self.value = exc.value
-            raise
-        return chunk