esuls 0.1.12__tar.gz → 0.1.14__tar.gz

{esuls-0.1.12/src/esuls.egg-info → esuls-0.1.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esuls
-Version: 0.1.12
+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.12 → esuls-0.1.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "esuls"
-version = "0.1.12"
+version = "0.1.14"
 description = "Utility library for async database operations, HTTP requests, and parallel execution"
 readme = "README.md"
 requires-python = ">=3.14"

{esuls-0.1.12 → esuls-0.1.14}/src/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."""
@@ -57,20 +59,40 @@ class AsyncDB(Generic[SchemaType]):
         if not hasattr(AsyncDB, '_initialized_schemas'):
             AsyncDB._initialized_schemas = set()
     
-    async def _get_connection(self) -> aiosqlite.Connection:
-        """Create a new optimized connection."""
-        db = await aiosqlite.connect(self.db_path)
-        # Fast WAL mode with minimal sync
-        await db.execute("PRAGMA journal_mode=WAL")
-        await db.execute("PRAGMA synchronous=NORMAL")
-        await db.execute("PRAGMA cache_size=10000")
-        
-        # Initialize schema if needed (check per unique schema)
-        if self._db_key not in AsyncDB._initialized_schemas:
-            await self._init_schema(db)
-            AsyncDB._initialized_schemas.add(self._db_key)
-            
-        return db
+    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:
+                db = await aiosqlite.connect(self.db_path, timeout=30.0)
+                # Fast WAL mode with minimal sync
+                await db.execute("PRAGMA journal_mode=WAL")
+                await db.execute("PRAGMA synchronous=NORMAL")
+                await db.execute("PRAGMA cache_size=10000")
+                await db.execute("PRAGMA busy_timeout=30000")  # 30s busy timeout
+
+                # Initialize schema if needed (with lock to prevent race condition)
+                if self._db_key not in AsyncDB._initialized_schemas:
+                    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:
+                last_error = e
+                if attempt < max_retries - 1:
+                    # Exponential backoff: 0.1s, 0.2s, 0.4s, 0.8s, 1.6s
+                    wait_time = 0.1 * (2 ** attempt)
+                    await asyncio.sleep(wait_time)
+                    continue
+                raise
+        raise last_error
     
     async def _init_schema(self, db: aiosqlite.Connection) -> None:
         """Generate schema from dataclass structure with support for field additions."""

esuls-0.1.14/src/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.12 → esuls-0.1.14/src/esuls.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esuls
-Version: 0.1.12
+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.12 → esuls-0.1.14}/src/esuls.egg-info/SOURCES.txt

@@ -10,4 +10,5 @@ src/esuls.egg-info/PKG-INFO
 src/esuls.egg-info/SOURCES.txt
 src/esuls.egg-info/dependency_links.txt
 src/esuls.egg-info/requires.txt
-src/esuls.egg-info/top_level.txt
+src/esuls.egg-info/top_level.txt
+src/esuls/tests/test_db_concurrent.py