hishel 1.1.7__tar.gz → 1.1.8__tar.gz

{hishel-1.1.7 → hishel-1.1.8}/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 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
 
@@ -16,11 +29,11 @@
 * Feature/accept pathlib path in SqliteStorage by @daudef in [#419](https://github.com/karpetrosyan/hishel/pull/419)
 
 ### Contributors
+* @karpetrosyan
 * @daudef
 * @dependabot[bot]
 * @jeefberkey
 * @dump247
-* @karpetrosyan
 
 **Full Changelog**: https://github.com/karpetrosyan/hishel/compare/1.1.6...1.1.7
 

{hishel-1.1.7 → hishel-1.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hishel
-Version: 1.1.7
+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,19 @@ 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
 
@@ -424,11 +437,11 @@ Hishel is inspired by and builds upon the excellent work in the Python HTTP ecos
 * Feature/accept pathlib path in SqliteStorage by @daudef in [#419](https://github.com/karpetrosyan/hishel/pull/419)
 
 ### Contributors
+* @karpetrosyan
 * @daudef
 * @dependabot[bot]
 * @jeefberkey
 * @dump247
-* @karpetrosyan
 
 **Full Changelog**: https://github.com/karpetrosyan/hishel/compare/1.1.6...1.1.7
 

{hishel-1.1.7 → hishel-1.1.8}/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
@@ -55,9 +56,15 @@ try:
             # 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:
                 # Create cache directory and resolve full path on first connection
                 parent = self.database_path.parent if self.database_path.parent != Path(".") else None
@@ -106,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),
+                    )
+
+                await connection.commit()
 
-            return complete_pair
+                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
@@ -363,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,
@@ -403,23 +419,24 @@ 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()
-
-                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
+                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
 
 except ImportError:
 

{hishel-1.1.7 → hishel-1.1.8}/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
@@ -55,9 +56,15 @@ try:
             # 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:
                 # Create cache directory and resolve full path on first connection
                 parent = self.database_path.parent if self.database_path.parent != Path(".") else None
@@ -106,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),
+                    )
+
+                connection.commit()
 
-            return complete_pair
+                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
@@ -363,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,
@@ -403,23 +419,24 @@ 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()
-
-                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
+                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
 
 except ImportError:
 

{hishel-1.1.7 → hishel-1.1.8}/pyproject.toml

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