esuls 0.1.13__tar.gz → 0.1.15__tar.gz

{esuls-0.1.13/src/esuls.egg-info → esuls-0.1.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esuls
-Version: 0.1.13
+Version: 0.1.15
 Summary: Utility library for async database operations, HTTP requests, and parallel execution
 Author-email: IperGiove <ipergiove@gmail.com>
 License: MIT
@@ -228,8 +228,7 @@ pip install -e .
 
 ```bash
 # With uv
-uv build
-twine upload dist/*
+uv build && twine upload dist/*
 
 # Or with traditional tools
 pip install build twine

{esuls-0.1.13 → esuls-0.1.15}/README.md

@@ -205,8 +205,7 @@ pip install -e .
 
 ```bash
 # With uv
-uv build
-twine upload dist/*
+uv build && twine upload dist/*
 
 # Or with traditional tools
 pip install build twine

{esuls-0.1.13 → esuls-0.1.15}/pyproject.toml

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

{esuls-0.1.13 → esuls-0.1.15}/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."""
@@ -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:
@@ -287,40 +296,51 @@ class AsyncDB(Generic[SchemaType]):
 
         saved_count = 0
 
-        async with self._write_lock:
-            async with self.transaction() as db:
-                for item in items:
-                    try:
-                        if not isinstance(item, self.schema_class):
-                            if not skip_errors:
-                                raise TypeError(f"Expected {self.schema_class.__name__}, got {type(item).__name__}")
-                            continue
-
-                        # Extract and process data
-                        data = asdict(item)
-                        item_id = data.pop('id', None) or str(uuid.uuid4())
-
-                        # Ensure created_at and updated_at are set
-                        now = datetime.now()
-                        if not data.get('created_at'):
-                            data['created_at'] = now
-                        data['updated_at'] = now
-
-                        # Prepare SQL and values
-                        field_names = tuple(sorted(data.keys()))
-                        sql = self._generate_save_sql(field_names)
-                        values = [self._serialize_value(data[name]) for name in field_names]
-                        values.append(item_id)
-
-                        # Execute save
-                        await db.execute(sql, values)
-                        saved_count += 1
-
-                    except Exception as e:
-                        if skip_errors:
-                            logger.warning(f"Save error (skipped): {e}")
-                            continue
-                        raise
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                async with self._write_lock:
+                    async with self.transaction() as db:
+                        for item in items:
+                            try:
+                                if not isinstance(item, self.schema_class):
+                                    if not skip_errors:
+                                        raise TypeError(f"Expected {self.schema_class.__name__}, got {type(item).__name__}")
+                                    continue
+
+                                # Extract and process data
+                                data = asdict(item)
+                                item_id = data.pop('id', None) or str(uuid.uuid4())
+
+                                # Ensure created_at and updated_at are set
+                                now = datetime.now()
+                                if not data.get('created_at'):
+                                    data['created_at'] = now
+                                data['updated_at'] = now
+
+                                # Prepare SQL and values
+                                field_names = tuple(sorted(data.keys()))
+                                sql = self._generate_save_sql(field_names)
+                                values = [self._serialize_value(data[name]) for name in field_names]
+                                values.append(item_id)
+
+                                # Execute save
+                                await db.execute(sql, values)
+                                saved_count += 1
+
+                            except Exception as e:
+                                if skip_errors:
+                                    logger.warning(f"Save error (skipped): {e}")
+                                    continue
+                                raise
+                break
+            except Exception as e:
+                if "database is locked" in str(e) and attempt < max_retries - 1:
+                    wait_time = 0.2 * (2 ** attempt)
+                    logger.debug(f"DB locked, retry {attempt + 1}/{max_retries} in {wait_time}s")
+                    await asyncio.sleep(wait_time)
+                    continue
+                raise
 
         return saved_count
 
@@ -356,10 +376,21 @@ class AsyncDB(Generic[SchemaType]):
             values = [self._serialize_value(data[name]) for name in field_names]
             values.append(item_id)
 
-            # Perform save with reliable transaction
-            async with self._write_lock:
-                async with self.transaction() as db:
-                    await db.execute(sql, values)
+            # Perform save with reliable transaction (retry on "database is locked")
+            max_retries = 3
+            for attempt in range(max_retries):
+                try:
+                    async with self._write_lock:
+                        async with self.transaction() as db:
+                            await db.execute(sql, values)
+                    break
+                except Exception as e:
+                    if "database is locked" in str(e) and attempt < max_retries - 1:
+                        wait_time = 0.2 * (2 ** attempt)
+                        logger.debug(f"DB locked, retry {attempt + 1}/{max_retries} in {wait_time}s")
+                        await asyncio.sleep(wait_time)
+                        continue
+                    raise
 
             return True
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esuls
-Version: 0.1.13
+Version: 0.1.15
 Summary: Utility library for async database operations, HTTP requests, and parallel execution
 Author-email: IperGiove <ipergiove@gmail.com>
 License: MIT
@@ -228,8 +228,7 @@ pip install -e .
 
 ```bash
 # With uv
-uv build
-twine upload dist/*
+uv build && twine upload dist/*
 
 # Or with traditional tools
 pip install build twine

{esuls-0.1.13 → esuls-0.1.15}/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