hishel 1.1.6__py3-none-any.whl → 1.1.8__py3-none-any.whl

hishel/_async_cache.py

@@ -197,12 +197,12 @@ class AsyncCacheProxy:
         return state.next(revalidation_response)
 
     async def _handle_update(self, state: NeedToBeUpdated) -> AnyState:
-        for entry in state.updating_entries:
+        for updating_entry in state.updating_entries:
             await self.storage.update_entry(
-                entry.id,
-                lambda entry: replace(
-                    entry,
-                    response=replace(entry.response, headers=entry.response.headers),
+                updating_entry.id,
+                lambda existing_entry: replace(
+                    existing_entry,
+                    response=replace(existing_entry.response, headers=updating_entry.response.headers),
                 ),
             )
         return state.next()

hishel/_core/_storages/_async_sqlite.py

@@ -35,6 +35,7 @@ BATCH_CLEANUP_CHUNK_SIZE = 200
 
 try:
     import anysqlite
+    from anyio import Lock
 
     class AsyncSqliteStorage(AsyncBaseStorage):
         _COMPLETE_CHUNK_NUMBER = -1
@@ -43,27 +44,32 @@ try:
             self,
             *,
             connection: Optional[anysqlite.Connection] = None,
-            database_path: str = "hishel_cache.db",
+            database_path: Union[str, Path] = "hishel_cache.db",
             default_ttl: Optional[float] = None,
             refresh_ttl_on_access: bool = True,
         ) -> None:
-            db_path = Path(database_path)
-
             self.connection = connection
-            self.database_path = (
-                ensure_cache_dict(db_path.parent if db_path.parent != Path(".") else None) / db_path.name
-            )
+            self.database_path: Path = database_path if isinstance(database_path, Path) else Path(database_path)
             self.default_ttl = default_ttl
             self.refresh_ttl_on_access = refresh_ttl_on_access
             self.last_cleanup = time.time() - BATCH_CLEANUP_INTERVAL + BATCH_CLEANUP_START_DELAY
             # When this storage instance was created. Used to delay the first cleanup.
             self._start_time = time.time()
             self._initialized = False
+            self._lock = Lock()
 
         async def _ensure_connection(self) -> anysqlite.Connection:
-            """Ensure connection is established and database is initialized."""
+            """
+            Ensure connection is established and database is initialized.
+
+            Note: This method assumes the caller has already acquired the lock.
+            """
+
             if self.connection is None:
-                self.connection = await anysqlite.connect(str(self.database_path))
+                # Create cache directory and resolve full path on first connection
+                parent = self.database_path.parent if self.database_path.parent != Path(".") else None
+                full_path = ensure_cache_dict(parent) / self.database_path.name
+                self.connection = await anysqlite.connect(str(full_path))
             if not self._initialized:
                 await self._initialize_database()
                 self._initialized = True
@@ -107,151 +113,156 @@ try:
         ) -> Entry:
             key_bytes = key.encode("utf-8")
 
-            connection = await self._ensure_connection()
-            cursor = await connection.cursor()
+            async with self._lock:
+                connection = await self._ensure_connection()
+                cursor = await connection.cursor()
 
-            # Create a new entry directly with both request and response
-            pair_id = id_ if id_ is not None else uuid.uuid4()
-            pair_meta = EntryMeta(
-                created_at=time.time(),
-            )
+                # Create a new entry directly with both request and response
+                pair_id = id_ if id_ is not None else uuid.uuid4()
+                pair_meta = EntryMeta(
+                    created_at=time.time(),
+                )
 
-            assert isinstance(response.stream, (AsyncIterator, AsyncIterable))
-            response_with_stream = replace(
-                response,
-                stream=self._save_stream(response.stream, pair_id.bytes),
-            )
+                assert isinstance(response.stream, (AsyncIterator, AsyncIterable))
+                response_with_stream = replace(
+                    response,
+                    stream=self._save_stream_unlocked(response.stream, pair_id.bytes),
+                )
 
-            complete_entry = Entry(
-                id=pair_id,
-                request=request,
-                response=response_with_stream,
-                meta=pair_meta,
-                cache_key=key_bytes,
-            )
+                complete_entry = Entry(
+                    id=pair_id,
+                    request=request,
+                    response=response_with_stream,
+                    meta=pair_meta,
+                    cache_key=key_bytes,
+                )
 
-            # Insert the complete entry into the database
-            await cursor.execute(
-                "INSERT INTO entries (id, cache_key, data, created_at, deleted_at) VALUES (?, ?, ?, ?, ?)",
-                (pair_id.bytes, key_bytes, pack(complete_entry, kind="pair"), pair_meta.created_at, None),
-            )
-            await connection.commit()
+                # Insert the complete entry into the database
+                await cursor.execute(
+                    "INSERT INTO entries (id, cache_key, data, created_at, deleted_at) VALUES (?, ?, ?, ?, ?)",
+                    (pair_id.bytes, key_bytes, pack(complete_entry, kind="pair"), pair_meta.created_at, None),
+                )
+                await connection.commit()
 
-            return complete_entry
+                return complete_entry
 
         async def get_entries(self, key: str) -> List[Entry]:
             final_pairs: List[Entry] = []
 
             now = time.time()
-            if now - self.last_cleanup >= BATCH_CLEANUP_INTERVAL:
-                try:
-                    await self._batch_cleanup()
-                except Exception:
-                    # don't let cleanup prevent reads; failures are non-fatal
-                    pass
+            async with self._lock:
+                if now - self.last_cleanup >= BATCH_CLEANUP_INTERVAL:
+                    try:
+                        await self._batch_cleanup()
+                    except Exception:
+                        # don't let cleanup prevent reads; failures are non-fatal
+                        pass
 
-            connection = await self._ensure_connection()
-            cursor = await connection.cursor()
-            # Query entries directly by cache_key
-            await cursor.execute(
-                "SELECT id, data FROM entries WHERE cache_key = ?",
-                (key.encode("utf-8"),),
-            )
+                connection = await self._ensure_connection()
+                cursor = await connection.cursor()
+                # Query entries directly by cache_key
+                await cursor.execute(
+                    "SELECT id, data FROM entries WHERE cache_key = ?",
+                    (key.encode("utf-8"),),
+                )
 
-            for row in await cursor.fetchall():
-                pair_data = unpack(row[1], kind="pair")
+                for row in await cursor.fetchall():
+                    pair_data = unpack(row[1], kind="pair")
 
-                if pair_data is None:
-                    continue
+                    if pair_data is None:
+                        continue
 
-                # Skip entries without a response (incomplete)
-                if not await self._is_stream_complete(pair_data.id, cursor=cursor):
-                    continue
-
-                # Skip expired entries
-                if await self._is_pair_expired(pair_data, cursor=cursor):
-                    continue
-
-                # Skip soft-deleted entries
-                if self.is_soft_deleted(pair_data):
-                    continue
-
-                final_pairs.append(pair_data)
-
-            pairs_with_streams: List[Entry] = []
-
-            # Only restore response streams from cache
-            for pair in final_pairs:
-                pairs_with_streams.append(
-                    replace(
-                        pair,
-                        response=replace(
-                            pair.response,
-                            stream=self._stream_data_from_cache(pair.id.bytes),
-                        ),
+                    # Skip entries without a response (incomplete)
+                    if not await self._is_stream_complete(pair_data.id, cursor=cursor):
+                        continue
+
+                    # Skip expired entries
+                    if await self._is_pair_expired(pair_data, cursor=cursor):
+                        continue
+
+                    # Skip soft-deleted entries
+                    if self.is_soft_deleted(pair_data):
+                        continue
+
+                    final_pairs.append(pair_data)
+
+                pairs_with_streams: List[Entry] = []
+
+                # Only restore response streams from cache
+                for pair in final_pairs:
+                    pairs_with_streams.append(
+                        replace(
+                            pair,
+                            response=replace(
+                                pair.response,
+                                stream=self._stream_data_from_cache(pair.id.bytes),
+                            ),
+                        )
                     )
-                )
-            return pairs_with_streams
+                return pairs_with_streams
 
         async def update_entry(
             self,
             id: uuid.UUID,
             new_pair: Union[Entry, Callable[[Entry], Entry]],
         ) -> Optional[Entry]:
-            connection = await self._ensure_connection()
-            cursor = await connection.cursor()
-            await cursor.execute("SELECT data FROM entries WHERE id = ?", (id.bytes,))
-            result = await cursor.fetchone()
-
-            if result is None:
-                return None
+            async with self._lock:
+                connection = await self._ensure_connection()
+                cursor = await connection.cursor()
+                await cursor.execute("SELECT data FROM entries WHERE id = ?", (id.bytes,))
+                result = await cursor.fetchone()
 
-            pair = unpack(result[0], kind="pair")
+                if result is None:
+                    return None
 
-            # Skip entries without a response (incomplete)
-            if not isinstance(pair, Entry) or pair.response is None:
-                return None
+                pair = unpack(result[0], kind="pair")
 
-            if isinstance(new_pair, Entry):
-                complete_pair = new_pair
-            else:
-                complete_pair = new_pair(pair)
+                # Skip entries without a response (incomplete)
+                if not isinstance(pair, Entry) or pair.response is None:
+                    return None
 
-            if pair.id != complete_pair.id:
-                raise ValueError("Pair ID mismatch")
+                if isinstance(new_pair, Entry):
+                    complete_pair = new_pair
+                else:
+                    complete_pair = new_pair(pair)
 
-            await cursor.execute(
-                "UPDATE entries SET data = ? WHERE id = ?",
-                (pack(complete_pair, kind="pair"), id.bytes),
-            )
+                if pair.id != complete_pair.id:
+                    raise ValueError("Pair ID mismatch")
 
-            if pair.cache_key != complete_pair.cache_key:
                 await cursor.execute(
-                    "UPDATE entries SET cache_key = ? WHERE id = ?",
-                    (complete_pair.cache_key, complete_pair.id.bytes),
+                    "UPDATE entries SET data = ? WHERE id = ?",
+                    (pack(complete_pair, kind="pair"), id.bytes),
                 )
 
-            await connection.commit()
+                if pair.cache_key != complete_pair.cache_key:
+                    await cursor.execute(
+                        "UPDATE entries SET cache_key = ? WHERE id = ?",
+                        (complete_pair.cache_key, complete_pair.id.bytes),
+                    )
 
-            return complete_pair
+                await connection.commit()
+
+                return complete_pair
 
         async def remove_entry(self, id: uuid.UUID) -> None:
-            connection = await self._ensure_connection()
-            cursor = await connection.cursor()
-            await cursor.execute("SELECT data FROM entries WHERE id = ?", (id.bytes,))
-            result = await cursor.fetchone()
+            async with self._lock:
+                connection = await self._ensure_connection()
+                cursor = await connection.cursor()
+                await cursor.execute("SELECT data FROM entries WHERE id = ?", (id.bytes,))
+                result = await cursor.fetchone()
 
-            if result is None:
-                return None
+                if result is None:
+                    return None
 
-            pair = unpack(result[0], kind="pair")
-            await self._soft_delete_pair(pair, cursor)
-            await connection.commit()
+                pair = unpack(result[0], kind="pair")
+                await self._soft_delete_pair(pair, cursor)
+                await connection.commit()
 
         async def close(self) -> None:
-            if self.connection is not None:
-                await self.connection.close()
-                self.connection = None
+            async with self._lock:
+                if self.connection is not None:
+                    await self.connection.close()
+                    self.connection = None
 
         async def _is_stream_complete(self, pair_id: uuid.UUID, cursor: anysqlite.Cursor) -> bool:
             # Check if there's a completion marker (chunk_number = -1) for response stream
@@ -364,36 +375,40 @@ try:
             """
             await cursor.execute("DELETE FROM streams WHERE entry_id = ?", (entry_id,))
 
-        async def _save_stream(
+        async def _save_stream_unlocked(
             self,
             stream: AsyncIterator[bytes],
             entry_id: bytes,
         ) -> AsyncIterator[bytes]:
             """
             Wrapper around an async iterator that also saves the response data to the cache in chunks.
+
+            Note: This method assumes the caller has already acquired the lock.
             """
             chunk_number = 0
             content_length = 0
             async for chunk in stream:
                 content_length += len(chunk)
+                async with self._lock:
+                    connection = await self._ensure_connection()
+                    cursor = await connection.cursor()
+                    await cursor.execute(
+                        "INSERT INTO streams (entry_id, chunk_number, chunk_data) VALUES (?, ?, ?)",
+                        (entry_id, chunk_number, chunk),
+                    )
+                    await connection.commit()
+                chunk_number += 1
+                yield chunk
+
+            async with self._lock:
+                # Mark end of stream with chunk_number = -1
                 connection = await self._ensure_connection()
                 cursor = await connection.cursor()
                 await cursor.execute(
                     "INSERT INTO streams (entry_id, chunk_number, chunk_data) VALUES (?, ?, ?)",
-                    (entry_id, chunk_number, chunk),
+                    (entry_id, self._COMPLETE_CHUNK_NUMBER, b""),
                 )
                 await connection.commit()
-                chunk_number += 1
-                yield chunk
-
-            # Mark end of stream with chunk_number = -1
-            connection = await self._ensure_connection()
-            cursor = await connection.cursor()
-            await cursor.execute(
-                "INSERT INTO streams (entry_id, chunk_number, chunk_data) VALUES (?, ?, ?)",
-                (entry_id, self._COMPLETE_CHUNK_NUMBER, b""),
-            )
-            await connection.commit()
 
         async def _stream_data_from_cache(
             self,
@@ -404,23 +419,25 @@ try:
             """
             chunk_number = 0
 
-            connection = await self._ensure_connection()
             while True:
-                cursor = await connection.cursor()
-                await cursor.execute(
-                    "SELECT chunk_data FROM streams WHERE entry_id = ? AND chunk_number = ?",
-                    (entry_id, chunk_number),
-                )
-                result = await cursor.fetchone()
+                async with self._lock:
+                    connection = await self._ensure_connection()
+                    cursor = await connection.cursor()
+                    await cursor.execute(
+                        "SELECT chunk_data FROM streams WHERE entry_id = ? AND chunk_number = ?",
+                        (entry_id, chunk_number),
+                    )
+                    result = await cursor.fetchone()
+
+                    if result is None:
+                        break
+                    chunk = result[0]
+                    # chunk_number = -1 is the completion marker with empty data
+                    if chunk == b"":
+                        break
+                    yield chunk
+                    chunk_number += 1
 
-                if result is None:
-                    break
-                chunk = result[0]
-                # chunk_number = -1 is the completion marker with empty data
-                if chunk == b"":
-                    break
-                yield chunk
-                chunk_number += 1
 except ImportError:
 
     class AsyncSqliteStorage:  # type: ignore[no-redef]

hishel/_core/_storages/_sync_sqlite.py

@@ -35,6 +35,7 @@ BATCH_CLEANUP_CHUNK_SIZE = 200
 
 try:
     import sqlite3
+    from threading import RLock
 
     class SyncSqliteStorage(SyncBaseStorage):
         _COMPLETE_CHUNK_NUMBER = -1
@@ -43,27 +44,32 @@ try:
             self,
             *,
             connection: Optional[sqlite3.Connection] = None,
-            database_path: str = "hishel_cache.db",
+            database_path: Union[str, Path] = "hishel_cache.db",
             default_ttl: Optional[float] = None,
             refresh_ttl_on_access: bool = True,
         ) -> None:
-            db_path = Path(database_path)
-
             self.connection = connection
-            self.database_path = (
-                ensure_cache_dict(db_path.parent if db_path.parent != Path(".") else None) / db_path.name
-            )
+            self.database_path: Path = database_path if isinstance(database_path, Path) else Path(database_path)
             self.default_ttl = default_ttl
             self.refresh_ttl_on_access = refresh_ttl_on_access
             self.last_cleanup = time.time() - BATCH_CLEANUP_INTERVAL + BATCH_CLEANUP_START_DELAY
             # When this storage instance was created. Used to delay the first cleanup.
             self._start_time = time.time()
             self._initialized = False
+            self._lock = RLock()
 
         def _ensure_connection(self) -> sqlite3.Connection:
-            """Ensure connection is established and database is initialized."""
+            """
+            Ensure connection is established and database is initialized.
+
+            Note: This method assumes the caller has already acquired the lock.
+            """
+
             if self.connection is None:
-                self.connection = sqlite3.connect(str(self.database_path))
+                # Create cache directory and resolve full path on first connection
+                parent = self.database_path.parent if self.database_path.parent != Path(".") else None
+                full_path = ensure_cache_dict(parent) / self.database_path.name
+                self.connection = sqlite3.connect(str(full_path))
             if not self._initialized:
                 self._initialize_database()
                 self._initialized = True
@@ -107,151 +113,156 @@ try:
         ) -> Entry:
             key_bytes = key.encode("utf-8")
 
-            connection = self._ensure_connection()
-            cursor = connection.cursor()
+            with self._lock:
+                connection = self._ensure_connection()
+                cursor = connection.cursor()
 
-            # Create a new entry directly with both request and response
-            pair_id = id_ if id_ is not None else uuid.uuid4()
-            pair_meta = EntryMeta(
-                created_at=time.time(),
-            )
+                # Create a new entry directly with both request and response
+                pair_id = id_ if id_ is not None else uuid.uuid4()
+                pair_meta = EntryMeta(
+                    created_at=time.time(),
+                )
 
-            assert isinstance(response.stream, (Iterator, Iterable))
-            response_with_stream = replace(
-                response,
-                stream=self._save_stream(response.stream, pair_id.bytes),
-            )
+                assert isinstance(response.stream, (Iterator, Iterable))
+                response_with_stream = replace(
+                    response,
+                    stream=self._save_stream_unlocked(response.stream, pair_id.bytes),
+                )
 
-            complete_entry = Entry(
-                id=pair_id,
-                request=request,
-                response=response_with_stream,
-                meta=pair_meta,
-                cache_key=key_bytes,
-            )
+                complete_entry = Entry(
+                    id=pair_id,
+                    request=request,
+                    response=response_with_stream,
+                    meta=pair_meta,
+                    cache_key=key_bytes,
+                )
 
-            # Insert the complete entry into the database
-            cursor.execute(
-                "INSERT INTO entries (id, cache_key, data, created_at, deleted_at) VALUES (?, ?, ?, ?, ?)",
-                (pair_id.bytes, key_bytes, pack(complete_entry, kind="pair"), pair_meta.created_at, None),
-            )
-            connection.commit()
+                # Insert the complete entry into the database
+                cursor.execute(
+                    "INSERT INTO entries (id, cache_key, data, created_at, deleted_at) VALUES (?, ?, ?, ?, ?)",
+                    (pair_id.bytes, key_bytes, pack(complete_entry, kind="pair"), pair_meta.created_at, None),
+                )
+                connection.commit()
 
-            return complete_entry
+                return complete_entry
 
         def get_entries(self, key: str) -> List[Entry]:
             final_pairs: List[Entry] = []
 
             now = time.time()
-            if now - self.last_cleanup >= BATCH_CLEANUP_INTERVAL:
-                try:
-                    self._batch_cleanup()
-                except Exception:
-                    # don't let cleanup prevent reads; failures are non-fatal
-                    pass
+            with self._lock:
+                if now - self.last_cleanup >= BATCH_CLEANUP_INTERVAL:
+                    try:
+                        self._batch_cleanup()
+                    except Exception:
+                        # don't let cleanup prevent reads; failures are non-fatal
+                        pass
 
-            connection = self._ensure_connection()
-            cursor = connection.cursor()
-            # Query entries directly by cache_key
-            cursor.execute(
-                "SELECT id, data FROM entries WHERE cache_key = ?",
-                (key.encode("utf-8"),),
-            )
+                connection = self._ensure_connection()
+                cursor = connection.cursor()
+                # Query entries directly by cache_key
+                cursor.execute(
+                    "SELECT id, data FROM entries WHERE cache_key = ?",
+                    (key.encode("utf-8"),),
+                )
 
-            for row in cursor.fetchall():
-                pair_data = unpack(row[1], kind="pair")
+                for row in cursor.fetchall():
+                    pair_data = unpack(row[1], kind="pair")
 
-                if pair_data is None:
-                    continue
+                    if pair_data is None:
+                        continue
 
-                # Skip entries without a response (incomplete)
-                if not self._is_stream_complete(pair_data.id, cursor=cursor):
-                    continue
-
-                # Skip expired entries
-                if self._is_pair_expired(pair_data, cursor=cursor):
-                    continue
-
-                # Skip soft-deleted entries
-                if self.is_soft_deleted(pair_data):
-                    continue
-
-                final_pairs.append(pair_data)
-
-            pairs_with_streams: List[Entry] = []
-
-            # Only restore response streams from cache
-            for pair in final_pairs:
-                pairs_with_streams.append(
-                    replace(
-                        pair,
-                        response=replace(
-                            pair.response,
-                            stream=self._stream_data_from_cache(pair.id.bytes),
-                        ),
+                    # Skip entries without a response (incomplete)
+                    if not self._is_stream_complete(pair_data.id, cursor=cursor):
+                        continue
+
+                    # Skip expired entries
+                    if self._is_pair_expired(pair_data, cursor=cursor):
+                        continue
+
+                    # Skip soft-deleted entries
+                    if self.is_soft_deleted(pair_data):
+                        continue
+
+                    final_pairs.append(pair_data)
+
+                pairs_with_streams: List[Entry] = []
+
+                # Only restore response streams from cache
+                for pair in final_pairs:
+                    pairs_with_streams.append(
+                        replace(
+                            pair,
+                            response=replace(
+                                pair.response,
+                                stream=self._stream_data_from_cache(pair.id.bytes),
+                            ),
+                        )
                     )
-                )
-            return pairs_with_streams
+                return pairs_with_streams
 
         def update_entry(
             self,
             id: uuid.UUID,
             new_pair: Union[Entry, Callable[[Entry], Entry]],
         ) -> Optional[Entry]:
-            connection = self._ensure_connection()
-            cursor = connection.cursor()
-            cursor.execute("SELECT data FROM entries WHERE id = ?", (id.bytes,))
-            result = cursor.fetchone()
-
-            if result is None:
-                return None
+            with self._lock:
+                connection = self._ensure_connection()
+                cursor = connection.cursor()
+                cursor.execute("SELECT data FROM entries WHERE id = ?", (id.bytes,))
+                result = cursor.fetchone()
 
-            pair = unpack(result[0], kind="pair")
+                if result is None:
+                    return None
 
-            # Skip entries without a response (incomplete)
-            if not isinstance(pair, Entry) or pair.response is None:
-                return None
+                pair = unpack(result[0], kind="pair")
 
-            if isinstance(new_pair, Entry):
-                complete_pair = new_pair
-            else:
-                complete_pair = new_pair(pair)
+                # Skip entries without a response (incomplete)
+                if not isinstance(pair, Entry) or pair.response is None:
+                    return None
 
-            if pair.id != complete_pair.id:
-                raise ValueError("Pair ID mismatch")
+                if isinstance(new_pair, Entry):
+                    complete_pair = new_pair
+                else:
+                    complete_pair = new_pair(pair)
 
-            cursor.execute(
-                "UPDATE entries SET data = ? WHERE id = ?",
-                (pack(complete_pair, kind="pair"), id.bytes),
-            )
+                if pair.id != complete_pair.id:
+                    raise ValueError("Pair ID mismatch")
 
-            if pair.cache_key != complete_pair.cache_key:
                 cursor.execute(
-                    "UPDATE entries SET cache_key = ? WHERE id = ?",
-                    (complete_pair.cache_key, complete_pair.id.bytes),
+                    "UPDATE entries SET data = ? WHERE id = ?",
+                    (pack(complete_pair, kind="pair"), id.bytes),
                 )
 
-            connection.commit()
+                if pair.cache_key != complete_pair.cache_key:
+                    cursor.execute(
+                        "UPDATE entries SET cache_key = ? WHERE id = ?",
+                        (complete_pair.cache_key, complete_pair.id.bytes),
+                    )
 
-            return complete_pair
+                connection.commit()
+
+                return complete_pair
 
         def remove_entry(self, id: uuid.UUID) -> None:
-            connection = self._ensure_connection()
-            cursor = connection.cursor()
-            cursor.execute("SELECT data FROM entries WHERE id = ?", (id.bytes,))
-            result = cursor.fetchone()
+            with self._lock:
+                connection = self._ensure_connection()
+                cursor = connection.cursor()
+                cursor.execute("SELECT data FROM entries WHERE id = ?", (id.bytes,))
+                result = cursor.fetchone()
 
-            if result is None:
-                return None
+                if result is None:
+                    return None
 
-            pair = unpack(result[0], kind="pair")
-            self._soft_delete_pair(pair, cursor)
-            connection.commit()
+                pair = unpack(result[0], kind="pair")
+                self._soft_delete_pair(pair, cursor)
+                connection.commit()
 
         def close(self) -> None:
-            if self.connection is not None:
-                self.connection.close()
-                self.connection = None
+            with self._lock:
+                if self.connection is not None:
+                    self.connection.close()
+                    self.connection = None
 
         def _is_stream_complete(self, pair_id: uuid.UUID, cursor: sqlite3.Cursor) -> bool:
             # Check if there's a completion marker (chunk_number = -1) for response stream
@@ -364,36 +375,40 @@ try:
             """
             cursor.execute("DELETE FROM streams WHERE entry_id = ?", (entry_id,))
 
-        def _save_stream(
+        def _save_stream_unlocked(
             self,
             stream: Iterator[bytes],
             entry_id: bytes,
         ) -> Iterator[bytes]:
             """
             Wrapper around an async iterator that also saves the response data to the cache in chunks.
+
+            Note: This method assumes the caller has already acquired the lock.
             """
             chunk_number = 0
             content_length = 0
             for chunk in stream:
                 content_length += len(chunk)
+                with self._lock:
+                    connection = self._ensure_connection()
+                    cursor = connection.cursor()
+                    cursor.execute(
+                        "INSERT INTO streams (entry_id, chunk_number, chunk_data) VALUES (?, ?, ?)",
+                        (entry_id, chunk_number, chunk),
+                    )
+                    connection.commit()
+                chunk_number += 1
+                yield chunk
+
+            with self._lock:
+                # Mark end of stream with chunk_number = -1
                 connection = self._ensure_connection()
                 cursor = connection.cursor()
                 cursor.execute(
                     "INSERT INTO streams (entry_id, chunk_number, chunk_data) VALUES (?, ?, ?)",
-                    (entry_id, chunk_number, chunk),
+                    (entry_id, self._COMPLETE_CHUNK_NUMBER, b""),
                 )
                 connection.commit()
-                chunk_number += 1
-                yield chunk
-
-            # Mark end of stream with chunk_number = -1
-            connection = self._ensure_connection()
-            cursor = connection.cursor()
-            cursor.execute(
-                "INSERT INTO streams (entry_id, chunk_number, chunk_data) VALUES (?, ?, ?)",
-                (entry_id, self._COMPLETE_CHUNK_NUMBER, b""),
-            )
-            connection.commit()
 
         def _stream_data_from_cache(
             self,
@@ -404,23 +419,25 @@ try:
             """
             chunk_number = 0
 
-            connection = self._ensure_connection()
             while True:
-                cursor = connection.cursor()
-                cursor.execute(
-                    "SELECT chunk_data FROM streams WHERE entry_id = ? AND chunk_number = ?",
-                    (entry_id, chunk_number),
-                )
-                result = cursor.fetchone()
+                with self._lock:
+                    connection = self._ensure_connection()
+                    cursor = connection.cursor()
+                    cursor.execute(
+                        "SELECT chunk_data FROM streams WHERE entry_id = ? AND chunk_number = ?",
+                        (entry_id, chunk_number),
+                    )
+                    result = cursor.fetchone()
+
+                    if result is None:
+                        break
+                    chunk = result[0]
+                    # chunk_number = -1 is the completion marker with empty data
+                    if chunk == b"":
+                        break
+                    yield chunk
+                    chunk_number += 1
 
-                if result is None:
-                    break
-                chunk = result[0]
-                # chunk_number = -1 is the completion marker with empty data
-                if chunk == b"":
-                    break
-                yield chunk
-                chunk_number += 1
 except ImportError:
 
     class SyncSqliteStorage:  # type: ignore[no-redef]

hishel/_sync_cache.py

@@ -197,12 +197,12 @@ class SyncCacheProxy:
         return state.next(revalidation_response)
 
     def _handle_update(self, state: NeedToBeUpdated) -> AnyState:
-        for entry in state.updating_entries:
+        for updating_entry in state.updating_entries:
             self.storage.update_entry(
-                entry.id,
-                lambda entry: replace(
-                    entry,
-                    response=replace(entry.response, headers=entry.response.headers),
+                updating_entry.id,
+                lambda existing_entry: replace(
+                    existing_entry,
+                    response=replace(existing_entry.response, headers=updating_entry.response.headers),
                 ),
             )
         return state.next()

{hishel-1.1.6.dist-info → hishel-1.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hishel
-Version: 1.1.6
+Version: 1.1.8
 Summary:  Elegant HTTP Caching for Python
 Project-URL: Homepage, https://hishel.com
 Project-URL: Source, https://github.com/karpetrosyan/hishel
@@ -406,6 +406,45 @@ Hishel is inspired by and builds upon the excellent work in the Python HTTP ecos
   <strong>Made with ❤️ by <a href="https://github.com/karpetrosyan">Kar Petrosyan</a></strong>
 </p>
 
+## What's Changed in 1.1.8
+### ⚙️ Miscellaneous Tasks
+
+* chore(ci): remove redis action by @karpetrosyan in [#428](https://github.com/karpetrosyan/hishel/pull/428)
+### 🐛 Bug Fixes
+
+* fix: prevent race conditions by @karpetrosyan in [#436](https://github.com/karpetrosyan/hishel/pull/436)
+
+### Contributors
+* @karpetrosyan
+
+**Full Changelog**: https://github.com/karpetrosyan/hishel/compare/1.1.7...1.1.8
+
+## What's Changed in 1.1.7
+### ♻️ Refactoring
+
+* refactor(storage): create sqlite database path only when creating connections by @jeefberkey in [#426](https://github.com/karpetrosyan/hishel/pull/426)
+### ⚙️ Miscellaneous Tasks
+
+* chore(deps-dev): bump the python-packages group with 5 updates by @dependabot[bot] in [#424](https://github.com/karpetrosyan/hishel/pull/424)
+### 🐛 Bug Fixes
+
+* fix(cache): Lambda parameter name clashes the loop variable being closed over by @dump247 in [#427](https://github.com/karpetrosyan/hishel/pull/427)
+### 📚 Documentation
+
+* add release process guidelines for maintainers by @karpetrosyan
+### 🚀 Features
+
+* Feature/accept pathlib path in SqliteStorage by @daudef in [#419](https://github.com/karpetrosyan/hishel/pull/419)
+
+### Contributors
+* @karpetrosyan
+* @daudef
+* @dependabot[bot]
+* @jeefberkey
+* @dump247
+
+**Full Changelog**: https://github.com/karpetrosyan/hishel/compare/1.1.6...1.1.7
+
 ## What's Changed in 1.1.6
 ### 📚 Documentation
 

{hishel-1.1.6.dist-info → hishel-1.1.8.dist-info}/RECORD

@@ -1,8 +1,8 @@
 hishel/__init__.py,sha256=1EdAEXWx41gmxUzG1Fchd_B4gQDtqlxlqQw0WkCBaUE,1826
-hishel/_async_cache.py,sha256=4wm6YBL9ClNOg4WbEkALTJVCIXuzQU80MVem2C3hHrQ,8785
+hishel/_async_cache.py,sha256=QprSuucR6OXYWNVS9lzM1jHjUEC33AGq8zpUT27Cngs,8839
 hishel/_async_httpx.py,sha256=89i92f2SlvgWrav_TDNU1iUzMxdR607apauxXA3pE3U,8127
 hishel/_policies.py,sha256=1ae_rmDF7oaG91-lQyOGVaTrRX8uI2GImmu5gN6WJa4,1135
-hishel/_sync_cache.py,sha256=k0AN0M--yR4Jc6SiAreaxPUFiwEt5Dx7wi9jqW9sy50,8510
+hishel/_sync_cache.py,sha256=afM1MfBlT3kitBJX-YmDEJ4i6Kc1d0A4PcrvCL6LlPI,8564
 hishel/_sync_httpx.py,sha256=z1pwVUQfRf72Q48PXXZ4FKwXGevll0X5iHcVRANiP38,7952
 hishel/_utils.py,sha256=kR7RnhFqLzFRmB-YNnZteQVP0iDPUouCscA0_FHHFls,3837
 hishel/asgi.py,sha256=ocXzqrrYGazeJxlKFcz1waoKvKGOqJ7YBEAmly4Towk,14998
@@ -14,11 +14,11 @@ hishel/_core/_headers.py,sha256=hGaT6o1F-gs1pm5RpdGb0IMQL3uJYDH1xpwJLy28Cys,1751
 hishel/_core/_spec.py,sha256=26mrK0MFSN_03ZecKem0asHYCXqzJ0tmcVmJXG7VHeI,105016
 hishel/_core/models.py,sha256=EabP2qnjYVzhPWhQer3QFmdDE6TDbqEBEqPHzv25VnA,7978
 hishel/_core/_storages/_async_base.py,sha256=iZ6Mb30P0ho5h4UU5bgOrcsSMZ1427j9tht-tupZs68,2106
-hishel/_core/_storages/_async_sqlite.py,sha256=IDMbtmbQ8e12HUlNJGyn6SIYColupuIbtvGfNl47_pM,15916
+hishel/_core/_storages/_async_sqlite.py,sha256=IAWAqTDyIMGiMy6qAySzPU_wMcNfqV76BJQTRTX65TI,17200
 hishel/_core/_storages/_packing.py,sha256=mC8LMFQ5uPfFOgingKm2WKFO_DwcZ1OjTgI6xc0hfJI,3708
 hishel/_core/_storages/_sync_base.py,sha256=qfOvcFY5qvrzSh4ztV2Trlxft-BF7An5SFsLlEb8EeE,2075
-hishel/_core/_storages/_sync_sqlite.py,sha256=MidCVhhzlf2bZQ2_UzZzh0r_14HGZpFEomkGU5POjuk,15385
-hishel-1.1.6.dist-info/METADATA,sha256=xQuRX_gSxX_sqXkwKnH7Mtsft7tUfym5L05CfbKeog4,20803
-hishel-1.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hishel-1.1.6.dist-info/licenses/LICENSE,sha256=1qQj7pE0V2O9OIedvyOgLGLvZLaPd3nFEup3IBEOZjQ,1493
-hishel-1.1.6.dist-info/RECORD,,
+hishel/_core/_storages/_sync_sqlite.py,sha256=VJRlNaZjAxg1YOdLajZNG404qykyDHEp4cfsVy5HBzw,16627
+hishel-1.1.8.dist-info/METADATA,sha256=stkghsijhi2i55XUAPh9IuLeWFw2t9ptsMn1ByDXes0,22164
+hishel-1.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hishel-1.1.8.dist-info/licenses/LICENSE,sha256=1qQj7pE0V2O9OIedvyOgLGLvZLaPd3nFEup3IBEOZjQ,1493
+hishel-1.1.8.dist-info/RECORD,,