esuls 0.1.13__py3-none-any.whl → 0.1.14__py3-none-any.whl

esuls/db_cli.py

@@ -31,6 +31,8 @@ class AsyncDB(Generic[SchemaType]):
 
     # Shared write locks per database file (class-level)
     _db_locks: dict[str, asyncio.Lock] = {}
+    # Lock for schema initialization (class-level)
+    _schema_init_lock: asyncio.Lock = None
 
     def __init__(self, db_path: Union[str, Path], table_name: str, schema_class: Type[SchemaType]):
         """Initialize AsyncDB with a path and schema dataclass."""
@@ -59,6 +61,10 @@ class AsyncDB(Generic[SchemaType]):
     
     async def _get_connection(self, max_retries: int = 5) -> aiosqlite.Connection:
         """Create a new optimized connection with retry logic for concurrent access."""
+        # Ensure schema init lock exists (lazy init for asyncio compatibility)
+        if AsyncDB._schema_init_lock is None:
+            AsyncDB._schema_init_lock = asyncio.Lock()
+
         last_error = None
         for attempt in range(max_retries):
             try:
@@ -69,10 +75,13 @@ class AsyncDB(Generic[SchemaType]):
                 await db.execute("PRAGMA cache_size=10000")
                 await db.execute("PRAGMA busy_timeout=30000")  # 30s busy timeout
 
-                # Initialize schema if needed (check per unique schema)
+                # Initialize schema if needed (with lock to prevent race condition)
                 if self._db_key not in AsyncDB._initialized_schemas:
-                    await self._init_schema(db)
-                    AsyncDB._initialized_schemas.add(self._db_key)
+                    async with AsyncDB._schema_init_lock:
+                        # Double-check after acquiring lock
+                        if self._db_key not in AsyncDB._initialized_schemas:
+                            await self._init_schema(db)
+                            AsyncDB._initialized_schemas.add(self._db_key)
 
                 return db
             except Exception as e:

esuls/tests/test_db_concurrent.py

@@ -0,0 +1,161 @@
+"""
+Test concurrent database access to verify retry logic works.
+"""
+import asyncio
+import tempfile
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from esuls.db_cli import AsyncDB, BaseModel
+
+
+@dataclass
+class TestItem(BaseModel):
+    name: str = ""
+    value: int = 0
+
+
+async def test_concurrent_reads(temp_db):
+    """Test many concurrent read operations."""
+    db = AsyncDB(temp_db, "items", TestItem)
+
+    # Save some test data first
+    for i in range(10):
+        await db.save(TestItem(name=f"item_{i}", value=i))
+
+    # Run 100 concurrent reads
+    async def read_all():
+        return await db.find()
+
+    tasks = [read_all() for _ in range(100)]
+    results = await asyncio.gather(*tasks)
+
+    # All reads should succeed and return same data
+    assert all(len(r) == 10 for r in results)
+    print(f"✓ 100 concurrent reads completed successfully")
+
+
+async def test_concurrent_writes(temp_db):
+    """Test many concurrent write operations."""
+    db = AsyncDB(temp_db, "items", TestItem)
+
+    # Run 50 concurrent writes
+    async def write_item(i: int):
+        return await db.save(TestItem(name=f"concurrent_{i}", value=i))
+
+    tasks = [write_item(i) for i in range(50)]
+    results = await asyncio.gather(*tasks)
+
+    # All writes should succeed
+    assert all(r is True for r in results)
+
+    # Verify all items were saved
+    items = await db.find()
+    assert len(items) == 50
+    print(f"✓ 50 concurrent writes completed successfully")
+
+
+async def test_concurrent_mixed_operations(temp_db):
+    """Test concurrent reads and writes together."""
+    db = AsyncDB(temp_db, "items", TestItem)
+
+    # Seed some data
+    for i in range(5):
+        await db.save(TestItem(name=f"seed_{i}", value=i))
+
+    async def read_op():
+        return await db.find()
+
+    async def write_op(i: int):
+        return await db.save(TestItem(name=f"mixed_{i}", value=i))
+
+    async def count_op():
+        return await db.count()
+
+    # Mix of 100 reads, 50 writes, 50 counts - all concurrent
+    tasks = []
+    tasks.extend([read_op() for _ in range(100)])
+    tasks.extend([write_op(i) for i in range(50)])
+    tasks.extend([count_op() for _ in range(50)])
+
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    # Check no exceptions
+    exceptions = [r for r in results if isinstance(r, Exception)]
+    if exceptions:
+        print(f"✗ {len(exceptions)} exceptions occurred:")
+        for e in exceptions[:5]:
+            print(f"  - {type(e).__name__}: {e}")
+        raise AssertionError(f"{len(exceptions)} operations failed")
+
+    # Verify final state
+    items = await db.find()
+    assert len(items) == 55  # 5 seed + 50 writes
+    print(f"✓ 200 concurrent mixed operations completed successfully")
+
+
+async def test_stress_concurrent_access(temp_db):
+    """Stress test with very high concurrency."""
+    db = AsyncDB(temp_db, "items", TestItem)
+
+    # Run 500 concurrent operations
+    async def random_op(i: int):
+        if i % 3 == 0:
+            return await db.save(TestItem(name=f"stress_{i}", value=i))
+        elif i % 3 == 1:
+            return await db.find()
+        else:
+            return await db.count()
+
+    tasks = [random_op(i) for i in range(500)]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+
+    # Count successes and failures
+    exceptions = [r for r in results if isinstance(r, Exception)]
+    successes = len(results) - len(exceptions)
+
+    print(f"Results: {successes} successes, {len(exceptions)} failures")
+
+    if exceptions:
+        print(f"Sample exceptions:")
+        for e in exceptions[:3]:
+            print(f"  - {type(e).__name__}: {e}")
+
+    # Should have very few or no failures with retry logic
+    assert len(exceptions) == 0, f"{len(exceptions)} operations failed"
+    print(f"✓ 500 concurrent stress operations completed successfully")
+
+
+if __name__ == "__main__":
+    import sys
+
+    async def run_all_tests():
+        with tempfile.TemporaryDirectory() as tmpdir:
+            db_path = Path(tmpdir) / "test_concurrent.db"
+
+            print("\n" + "=" * 60)
+            print("CONCURRENT DATABASE ACCESS TESTS")
+            print("=" * 60)
+
+            print("\n[Test 1] Concurrent reads...")
+            await test_concurrent_reads(db_path)
+
+            # New db for each test
+            db_path2 = Path(tmpdir) / "test_concurrent2.db"
+            print("\n[Test 2] Concurrent writes...")
+            await test_concurrent_writes(db_path2)
+
+            db_path3 = Path(tmpdir) / "test_concurrent3.db"
+            print("\n[Test 3] Mixed operations...")
+            await test_concurrent_mixed_operations(db_path3)
+
+            db_path4 = Path(tmpdir) / "test_concurrent4.db"
+            print("\n[Test 4] Stress test (500 ops)...")
+            await test_stress_concurrent_access(db_path4)
+
+            print("\n" + "=" * 60)
+            print("ALL TESTS PASSED!")
+            print("=" * 60)
+
+    asyncio.run(run_all_tests())

{esuls-0.1.13.dist-info → esuls-0.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esuls
-Version: 0.1.13
+Version: 0.1.14
 Summary: Utility library for async database operations, HTTP requests, and parallel execution
 Author-email: IperGiove <ipergiove@gmail.com>
 License: MIT

esuls-0.1.14.dist-info/RECORD

@@ -0,0 +1,11 @@
+esuls/__init__.py,sha256=dtZtmjZZ8jNspOd17BWsE9D9ofeg3vZF0vIpSgKaZqk,529
+esuls/db_cli.py,sha256=s6uIUiezqmkEjw1gXPv90HmaCh4YUl2iTi1xOLWo8ro,19399
+esuls/download_icon.py,sha256=w-bWbyPSbWvonzq43aDDtdxIvdKSa7OSyZ7LaN0uudg,3623
+esuls/request_cli.py,sha256=pILF8J9IILpTmWacm1vCtvDaef-kOXjkWAbcE2S9_cA,17962
+esuls/utils.py,sha256=AAh9y8dSB1vGO8e7A10dpsYMPI5-e9gw-GPInYBoOvg,577
+esuls/tests/test_db_concurrent.py,sha256=kjaF8cOYcFo2sJJytrn04tcU65RZASjoopme0dcZj4c,4961
+esuls-0.1.14.dist-info/licenses/LICENSE,sha256=AY0N01ARt0kbKB7CkByYLqqNQU-yalb-rpv-eXITEWA,1066
+esuls-0.1.14.dist-info/METADATA,sha256=M4ZiuHzJVJsfACMB9k6bYl1qKSHpYXFbb0nWlbhxZZQ,7002
+esuls-0.1.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+esuls-0.1.14.dist-info/top_level.txt,sha256=WWBDHRhQ0DQLBZKD7Un8uFN93GvVQnP4WvJKkvbACVA,6
+esuls-0.1.14.dist-info/RECORD,,

esuls-0.1.13.dist-info/RECORD

@@ -1,10 +0,0 @@
-esuls/__init__.py,sha256=dtZtmjZZ8jNspOd17BWsE9D9ofeg3vZF0vIpSgKaZqk,529
-esuls/db_cli.py,sha256=_5qEsfHr_cSDGitAe33hTNjVkfbHQxnPhEl1WDsuBIc,18901
-esuls/download_icon.py,sha256=w-bWbyPSbWvonzq43aDDtdxIvdKSa7OSyZ7LaN0uudg,3623
-esuls/request_cli.py,sha256=pILF8J9IILpTmWacm1vCtvDaef-kOXjkWAbcE2S9_cA,17962
-esuls/utils.py,sha256=AAh9y8dSB1vGO8e7A10dpsYMPI5-e9gw-GPInYBoOvg,577
-esuls-0.1.13.dist-info/licenses/LICENSE,sha256=AY0N01ARt0kbKB7CkByYLqqNQU-yalb-rpv-eXITEWA,1066
-esuls-0.1.13.dist-info/METADATA,sha256=abi71dKeWsGmI0wB01XQUTtv9xKkN1bztcCze330m1Q,7002
-esuls-0.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-esuls-0.1.13.dist-info/top_level.txt,sha256=WWBDHRhQ0DQLBZKD7Un8uFN93GvVQnP4WvJKkvbACVA,6
-esuls-0.1.13.dist-info/RECORD,,