esuls 0.1.15__tar.gz → 0.1.16__tar.gz

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

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

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

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

{esuls-0.1.15 → esuls-0.1.16}/src/esuls/db_cli.py

@@ -1,6 +1,10 @@
 import asyncio
 import aiosqlite
+import ast
 import json
+import re
+import threading
+import dataclasses
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List, Optional, TypeVar, Generic, Type, get_type_hints, Union, Tuple
@@ -11,6 +15,13 @@ import contextlib
 import enum
 from loguru import logger
 
+_VALID_IDENTIFIER = re.compile(r'^[a-zA-Z_][a-zA-Z0-9_]*$')
+
+def _validate_identifier(name: str) -> str:
+    if not _VALID_IDENTIFIER.match(name):
+        raise ValueError(f"Invalid SQL identifier: {name!r}")
+    return name
+
 T = TypeVar('T')
 SchemaType = TypeVar('SchemaType', bound='BaseModel')
 
@@ -33,6 +44,8 @@ class AsyncDB(Generic[SchemaType]):
     _db_locks: dict[str, asyncio.Lock] = {}
     # Lock for schema initialization (class-level)
     _schema_init_lock: asyncio.Lock = None
+    # Threading lock to guard class-level dict mutations
+    _db_locks_guard = threading.Lock()
 
     def __init__(self, db_path: Union[str, Path], table_name: str, schema_class: Type[SchemaType]):
         """Initialize AsyncDB with a path and schema dataclass."""
@@ -41,34 +54,49 @@ class AsyncDB(Generic[SchemaType]):
 
         self.db_path = Path(db_path).resolve()
         self.schema_class = schema_class
-        self.table_name = table_name
+        self.table_name = _validate_identifier(table_name)
         self.db_path.parent.mkdir(parents=True, exist_ok=True)
 
+        # Validate all field names upfront
+        for f in fields(schema_class):
+            _validate_identifier(f.name)
+
         # Make schema initialization unique per instance
         self._db_key = f"{str(self.db_path)}:{self.table_name}:{self.schema_class.__name__}"
 
         # Use shared lock per database file (not per instance)
         db_path_str = str(self.db_path)
-        if db_path_str not in AsyncDB._db_locks:
-            AsyncDB._db_locks[db_path_str] = asyncio.Lock()
-        self._write_lock = AsyncDB._db_locks[db_path_str]
+        with AsyncDB._db_locks_guard:
+            if db_path_str not in AsyncDB._db_locks:
+                AsyncDB._db_locks[db_path_str] = asyncio.Lock()
+            self._write_lock = AsyncDB._db_locks[db_path_str]
 
         self._type_hints = get_type_hints(schema_class)
-        
+
+        # Persistent connection (lazy init)
+        self._connection: Optional[aiosqlite.Connection] = None
+
         # Use a class-level set to track initialized schemas
         if not hasattr(AsyncDB, '_initialized_schemas'):
             AsyncDB._initialized_schemas = set()
     
-    async def _get_connection(self, max_retries: int = 5) -> aiosqlite.Connection:
-        """Create a new optimized connection with retry logic for concurrent access."""
+    async def _ensure_connection(self, max_retries: int = 5) -> aiosqlite.Connection:
+        """Return the persistent connection, creating it on first call with retry logic."""
+        if self._connection is not None:
+            return self._connection
+
         # Ensure schema init lock exists (lazy init for asyncio compatibility)
-        if AsyncDB._schema_init_lock is None:
-            AsyncDB._schema_init_lock = asyncio.Lock()
+        with AsyncDB._db_locks_guard:
+            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)
+                db = aiosqlite.connect(self.db_path, timeout=30.0)
+                # Mark aiosqlite's thread as daemon so it won't block process exit
+                db.daemon = True
+                db = await db
                 # Fast WAL mode with minimal sync
                 await db.execute("PRAGMA journal_mode=WAL")
                 await db.execute("PRAGMA synchronous=NORMAL")
@@ -83,6 +111,7 @@ class AsyncDB(Generic[SchemaType]):
                             await self._init_schema(db)
                             AsyncDB._initialized_schemas.add(self._db_key)
 
+                self._connection = db
                 return db
             except Exception as e:
                 last_error = e
@@ -93,7 +122,22 @@ class AsyncDB(Generic[SchemaType]):
                     continue
                 raise
         raise last_error
-    
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def close(self) -> None:
+        """Explicitly close the persistent connection."""
+        if self._connection is not None:
+            try:
+                await self._connection.close()
+            except Exception:
+                pass
+            self._connection = None
+
     async def _init_schema(self, db: aiosqlite.Connection) -> None:
         """Generate schema from dataclass structure with support for field additions."""
         logger.debug(f"Initializing schema for {self.schema_class.__name__} in table {self.table_name}")
@@ -146,7 +190,7 @@ class AsyncDB(Generic[SchemaType]):
                 constraints.append("PRIMARY KEY")
             if f.metadata.get('unique'):
                 constraints.append("UNIQUE")
-            if not f.default and not f.default_factory and f.metadata.get('required', True):
+            if f.default is dataclasses.MISSING and f.default_factory is dataclasses.MISSING and f.metadata.get('required', True):
                 constraints.append("NOT NULL")
                 
             field_def = f"{field_name} {sql_type} {' '.join(constraints)}"
@@ -193,16 +237,27 @@ class AsyncDB(Generic[SchemaType]):
     
     @contextlib.asynccontextmanager
     async def transaction(self):
-        """Run operations in a transaction with reliable cleanup."""
-        db = await self._get_connection()
+        """Run operations in a transaction with reliable cleanup and auto-reconnect."""
+        db = await self._ensure_connection()
         try:
             yield db
             await db.commit()
-        except Exception:
-            await db.rollback()
-            raise
-        finally:
-            await db.close()
+        except Exception as e:
+            try:
+                await db.rollback()
+            except Exception:
+                pass
+            if "closed" in str(e).lower() or "no active connection" in str(e).lower():
+                self._connection = None
+                db = await self._ensure_connection()
+                try:
+                    yield db
+                    await db.commit()
+                except Exception:
+                    await db.rollback()
+                    raise
+            else:
+                raise
     
     # @lru_cache(maxsize=128)
     def _serialize_value(self, value: Any) -> Any:
@@ -232,12 +287,15 @@ class AsyncDB(Generic[SchemaType]):
                 return value
             # If somehow stored as string, convert back
             if isinstance(value, str):
-                import ast
                 try:
                     return ast.literal_eval(value)
-                except:
+                except (ValueError, SyntaxError):
                     return value.encode('utf-8')
 
+        # Handle bool fields - SQLite stores as INTEGER, need to convert back
+        if field_type is bool:
+            return bool(value)
+
         # Handle string fields - ensure phone numbers are strings
         if field_type is str or (hasattr(field_type, '__origin__') and field_type.__origin__ is Union and str in getattr(field_type, '__args__', ())):
             return str(value)
@@ -250,12 +308,12 @@ class AsyncDB(Generic[SchemaType]):
             # Handle Optional[EnumType] case
             args = getattr(field_type, '__args__', ())
             for arg in args:
-                if arg is not type(None) and hasattr(arg, '__bases__') and enum.Enum in arg.__bases__:
+                if arg is not type(None) and isinstance(arg, type) and issubclass(arg, enum.Enum):
                     try:
                         return arg(value)
                     except (ValueError, TypeError):
                         pass
-        elif hasattr(field_type, '__bases__') and enum.Enum in field_type.__bases__:
+        elif isinstance(field_type, type) and issubclass(field_type, enum.Enum):
             # Handle direct enum types
             try:
                 return field_type(value)
@@ -281,6 +339,20 @@ class AsyncDB(Generic[SchemaType]):
             VALUES ({placeholders},?)
         """
     
+    def _prepare_item(self, item: SchemaType) -> Tuple[str, List[Any]]:
+        """Prepare an item for saving. Returns (sql, values)."""
+        data = asdict(item)
+        item_id = data.pop('id', None) or str(uuid.uuid4())
+        now = datetime.now()
+        if not data.get('created_at'):
+            data['created_at'] = now
+        data['updated_at'] = now
+        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)
+        return sql, values
+
     async def save_batch(self, items: List[SchemaType], skip_errors: bool = True) -> int:
         """Save multiple items in a single transaction for better performance.
 
@@ -299,6 +371,7 @@ class AsyncDB(Generic[SchemaType]):
         max_retries = 3
         for attempt in range(max_retries):
             try:
+                saved_count = 0
                 async with self._write_lock:
                     async with self.transaction() as db:
                         for item in items:
@@ -308,23 +381,7 @@ class AsyncDB(Generic[SchemaType]):
                                         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
+                                sql, values = self._prepare_item(item)
                                 await db.execute(sql, values)
                                 saved_count += 1
 
@@ -360,21 +417,7 @@ class AsyncDB(Generic[SchemaType]):
                     return False
                 raise TypeError(f"Expected {self.schema_class.__name__}, got {type(item).__name__}")
 
-            # 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)
+            sql, values = self._prepare_item(item)
 
             # Perform save with reliable transaction (retry on "database is locked")
             max_retries = 3
@@ -425,10 +468,6 @@ class AsyncDB(Generic[SchemaType]):
         values = []
         
         for key, value in filters.items():
-            # Handle special values
-            if value == 'now':
-                value = datetime.now()
-                
             # Parse field and operator
             parts = key.split('__', 1)
             field = parts[0]
@@ -451,22 +490,32 @@ class AsyncDB(Generic[SchemaType]):
                 
         return f"WHERE {' AND '.join(conditions)}", values
     
-    async def find(self, order_by=None, **filters) -> List[SchemaType]:
+    async def find(self, order_by=None, limit: int = None, offset: int = None, **filters) -> List[SchemaType]:
         """Query items with reliable connection handling."""
         where_clause, values = self._build_where_clause(filters)
-        
+
         # Build query
         query = f"SELECT * FROM {self.table_name} {where_clause}"
-        
+
         # Add ORDER BY clause if specified
         if order_by:
             order_fields = [order_by] if isinstance(order_by, str) else order_by
             order_clauses = [
-                f"{field[1:]} DESC" if field.startswith('-') else f"{field} ASC" 
+                f"{field[1:]} DESC" if field.startswith('-') else f"{field} ASC"
                 for field in order_fields
             ]
             query += f" ORDER BY {', '.join(order_clauses)}"
-        
+
+        # Add LIMIT/OFFSET (SQLite requires LIMIT before OFFSET)
+        if limit is not None:
+            query += " LIMIT ?"
+            values.append(limit)
+        elif offset is not None:
+            query += " LIMIT -1"
+        if offset is not None:
+            query += " OFFSET ?"
+            values.append(offset)
+
         # Execute query with reliable transaction
         async with self.transaction() as db:
             cursor = await db.execute(query, values)
@@ -504,4 +553,33 @@ class AsyncDB(Generic[SchemaType]):
         async with self._write_lock:
             async with self.transaction() as db:
                 cursor = await db.execute(f"DELETE FROM {self.table_name} WHERE id = ?", (id,))
+                return cursor.rowcount > 0
+
+    async def exists(self, **filters) -> bool:
+        """Check if any record matches the filters without fetching data."""
+        return await self.count(**filters) > 0
+
+    async def delete_many(self, **filters) -> int:
+        """Delete all items matching filters. Returns count of deleted rows."""
+        if not filters:
+            raise ValueError("delete_many() requires at least one filter to prevent accidental full table delete")
+        where_clause, values = self._build_where_clause(filters)
+        async with self._write_lock:
+            async with self.transaction() as db:
+                cursor = await db.execute(f"DELETE FROM {self.table_name} {where_clause}", values)
+                return cursor.rowcount
+
+    async def update_fields(self, id: str, **fields) -> bool:
+        """Update specific fields on a record by ID without fetching the full record."""
+        if not fields:
+            return False
+        fields['updated_at'] = datetime.now()
+        set_clause = ', '.join(f"{_validate_identifier(k)} = ?" for k in fields)
+        values = [self._serialize_value(v) for v in fields.values()]
+        values.append(id)
+        async with self._write_lock:
+            async with self.transaction() as db:
+                cursor = await db.execute(
+                    f"UPDATE {self.table_name} SET {set_clause} WHERE id = ?", values
+                )
                 return cursor.rowcount > 0

{esuls-0.1.15 → esuls-0.1.16}/src/esuls/tests/test_db_concurrent.py

@@ -33,6 +33,7 @@ async def test_concurrent_reads(temp_db):
 
     # All reads should succeed and return same data
     assert all(len(r) == 10 for r in results)
+    await db.close()
     print(f"✓ 100 concurrent reads completed successfully")
 
 
@@ -53,6 +54,7 @@ async def test_concurrent_writes(temp_db):
     # Verify all items were saved
     items = await db.find()
     assert len(items) == 50
+    await db.close()
     print(f"✓ 50 concurrent writes completed successfully")
 
 
@@ -92,6 +94,7 @@ async def test_concurrent_mixed_operations(temp_db):
     # Verify final state
     items = await db.find()
     assert len(items) == 55  # 5 seed + 50 writes
+    await db.close()
     print(f"✓ 200 concurrent mixed operations completed successfully")
 
 
@@ -124,6 +127,7 @@ async def test_stress_concurrent_access(temp_db):
 
     # Should have very few or no failures with retry logic
     assert len(exceptions) == 0, f"{len(exceptions)} operations failed"
+    await db.close()
     print(f"✓ 500 concurrent stress operations completed successfully")
 
 

esuls-0.1.16/src/esuls/tests/test_db_fixes.py

@@ -0,0 +1,443 @@
+"""
+Tests for specific fixes applied to AsyncDB.
+Covers: limit/offset, save_batch reset, enum deserialization,
+NOT NULL schema logic, identifier validation, connection pooling.
+"""
+import asyncio
+import enum
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from esuls.db_cli import AsyncDB, BaseModel, _validate_identifier
+
+
+# --- Test models ---
+
+class Color(enum.Enum):
+    RED = "red"
+    GREEN = "green"
+    BLUE = "blue"
+
+
+class Priority(enum.IntEnum):
+    LOW = 1
+    MEDIUM = 2
+    HIGH = 3
+
+
+class Status(str, enum.Enum):
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+
+
+@dataclass
+class EnumItem(BaseModel):
+    color: Optional[Color] = None
+    priority: Optional[Priority] = None
+    status: Optional[Status] = None
+
+
+@dataclass
+class DefaultsItem(BaseModel):
+    name: str = ""
+    count: int = 0
+    flag: bool = False
+    score: float = 0.0
+    required_field: str = field(default="", metadata={"required": False})
+
+
+@dataclass
+class TestItem(BaseModel):
+    name: str = ""
+    value: int = 0
+
+
+# --- Tests ---
+
+async def test_find_limit_offset(temp_db):
+    """Test limit and offset parameters on find()."""
+    db = AsyncDB(temp_db, "items", TestItem)
+
+    try:
+        # Insert 20 items with predictable ordering
+        for i in range(20):
+            await db.save(TestItem(name=f"item_{i:02d}", value=i))
+
+        # Test limit
+        results = await db.find(order_by="value", limit=5)
+        assert len(results) == 5
+        assert results[0].value == 0
+        assert results[4].value == 4
+
+        # Test offset
+        results = await db.find(order_by="value", limit=5, offset=10)
+        assert len(results) == 5
+        assert results[0].value == 10
+        assert results[4].value == 14
+
+        # Test offset beyond data
+        results = await db.find(order_by="value", limit=5, offset=18)
+        assert len(results) == 2
+        assert results[0].value == 18
+
+        # Test limit without offset
+        results = await db.find(order_by="value", limit=3)
+        assert len(results) == 3
+
+        # Test offset without limit (should return from offset to end)
+        results = await db.find(order_by="value", offset=17)
+        assert len(results) == 3
+
+        # Test no limit/offset (all results)
+        results = await db.find()
+        assert len(results) == 20
+
+        print("✓ find() limit/offset works correctly")
+    finally:
+        await db.close()
+
+
+async def test_save_batch_count_reset(temp_db):
+    """Test that saved_count resets properly on retry in save_batch()."""
+    db = AsyncDB(temp_db, "items", TestItem)
+
+    try:
+        items = [TestItem(name=f"batch_{i}", value=i) for i in range(10)]
+        count = await db.save_batch(items)
+        assert count == 10, f"Expected 10, got {count}"
+
+        # Save again (upsert) — count should still be exactly 10
+        count2 = await db.save_batch(items)
+        assert count2 == 10, f"Expected 10 on re-save, got {count2}"
+
+        print("✓ save_batch() count is accurate")
+    finally:
+        await db.close()
+
+
+async def test_enum_deserialization_subclasses(temp_db):
+    """Test enum deserialization with IntEnum, StrEnum, and regular Enum."""
+    db = AsyncDB(temp_db, "enums", EnumItem)
+
+    try:
+        # Save with all enum types
+        item = EnumItem(
+            color=Color.GREEN,
+            priority=Priority.HIGH,
+            status=Status.ACTIVE,
+        )
+        await db.save(item)
+
+        # Read back
+        results = await db.find()
+        assert len(results) == 1
+        loaded = results[0]
+
+        assert loaded.color == Color.GREEN, f"Expected Color.GREEN, got {loaded.color!r}"
+        assert loaded.priority == Priority.HIGH, f"Expected Priority.HIGH, got {loaded.priority!r}"
+        assert loaded.status == Status.ACTIVE, f"Expected Status.ACTIVE, got {loaded.status!r}"
+
+        # Test None values
+        item2 = EnumItem()
+        await db.save(item2)
+        results = await db.find()
+        none_items = [r for r in results if r.color is None]
+        assert len(none_items) == 1
+        assert none_items[0].priority is None
+        assert none_items[0].status is None
+
+        print("✓ Enum deserialization works for Enum, IntEnum, StrEnum")
+    finally:
+        await db.close()
+
+
+async def test_not_null_with_falsy_defaults(temp_db):
+    """Test that fields with falsy defaults (0, '', False) don't get NOT NULL."""
+    db = AsyncDB(temp_db, "defaults_test", DefaultsItem)
+
+    try:
+        # If the schema was created correctly, saving an item with default values should work
+        item = DefaultsItem()
+        result = await db.save(item)
+        assert result is True
+
+        # Verify roundtrip
+        items = await db.find()
+        assert len(items) == 1
+        loaded = items[0]
+        assert loaded.name == ""
+        assert loaded.count == 0
+        assert loaded.flag is False
+
+        print("✓ NOT NULL logic correctly handles falsy defaults")
+    finally:
+        await db.close()
+
+
+async def test_identifier_validation():
+    """Test that invalid SQL identifiers are rejected."""
+    # Valid identifiers
+    assert _validate_identifier("items") == "items"
+    assert _validate_identifier("my_table") == "my_table"
+    assert _validate_identifier("_private") == "_private"
+    assert _validate_identifier("Table123") == "Table123"
+
+    # Invalid identifiers
+    invalid_names = [
+        "Robert'; DROP TABLE students;--",
+        "my table",
+        "123abc",
+        "my-table",
+        "",
+        "table.name",
+        "col(umn)",
+    ]
+    for name in invalid_names:
+        try:
+            _validate_identifier(name)
+            raise AssertionError(f"Should have rejected: {name!r}")
+        except ValueError:
+            pass  # Expected
+
+    print("✓ Identifier validation rejects injection attempts")
+
+
+async def test_identifier_validation_in_constructor(temp_db):
+    """Test that AsyncDB constructor rejects invalid table names."""
+    try:
+        AsyncDB(temp_db, "valid_table; DROP TABLE x", TestItem)
+        raise AssertionError("Should have rejected invalid table name")
+    except ValueError:
+        pass
+
+    print("✓ Constructor rejects invalid table names")
+
+
+async def test_connection_pooling(temp_db):
+    """Test that persistent connection is reused across operations."""
+    db = AsyncDB(temp_db, "items", TestItem)
+
+    # First operation creates the connection
+    await db.save(TestItem(name="first", value=1))
+    conn1 = db._connection
+    assert conn1 is not None
+
+    # Subsequent operations reuse it
+    await db.find()
+    conn2 = db._connection
+    assert conn2 is conn1, "Connection should be reused"
+
+    await db.count()
+    conn3 = db._connection
+    assert conn3 is conn1, "Connection should still be reused"
+
+    await db.save(TestItem(name="second", value=2))
+    conn4 = db._connection
+    assert conn4 is conn1, "Connection should persist across saves"
+
+    # Explicit close
+    await db.close()
+    assert db._connection is None
+
+    # Next operation creates a new connection
+    await db.find()
+    conn5 = db._connection
+    assert conn5 is not None
+    assert conn5 is not conn1, "Should be a new connection after close"
+
+    await db.close()
+    print("✓ Connection pooling reuses connections correctly")
+
+
+async def test_close_idempotent(temp_db):
+    """Test that close() can be called multiple times safely."""
+    db = AsyncDB(temp_db, "items", TestItem)
+    await db.save(TestItem(name="test", value=1))
+
+    await db.close()
+    await db.close()  # Should not raise
+    await db.close()  # Should not raise
+
+    # Should still work after close
+    items = await db.find()
+    assert len(items) == 1
+
+    await db.close()
+    print("✓ close() is idempotent")
+
+
+async def test_exists(temp_db):
+    """Test exists() returns bool without fetching full records."""
+    db = AsyncDB(temp_db, "items", TestItem)
+
+    try:
+        assert await db.exists(name="nope") is False
+
+        await db.save(TestItem(name="hello", value=1))
+        assert await db.exists(name="hello") is True
+        assert await db.exists(name="nope") is False
+        assert await db.exists(value=1) is True
+        assert await db.exists(value=999) is False
+
+        print("✓ exists() works correctly")
+    finally:
+        await db.close()
+
+
+async def test_delete_many(temp_db):
+    """Test delete_many() deletes matching records and returns count."""
+    db = AsyncDB(temp_db, "items", TestItem)
+
+    try:
+        for i in range(10):
+            await db.save(TestItem(name="group_a" if i < 6 else "group_b", value=i))
+
+        # Delete group_a
+        deleted = await db.delete_many(name="group_a")
+        assert deleted == 6, f"Expected 6 deleted, got {deleted}"
+
+        remaining = await db.count()
+        assert remaining == 4, f"Expected 4 remaining, got {remaining}"
+
+        # Delete non-existent
+        deleted = await db.delete_many(name="group_c")
+        assert deleted == 0
+
+        # Must raise on empty filters
+        try:
+            await db.delete_many()
+            raise AssertionError("Should have raised ValueError")
+        except ValueError:
+            pass
+
+        print("✓ delete_many() works correctly")
+    finally:
+        await db.close()
+
+
+async def test_update_fields(temp_db):
+    """Test update_fields() updates specific fields without full fetch."""
+    db = AsyncDB(temp_db, "items", TestItem)
+
+    try:
+        item = TestItem(name="original", value=10)
+        await db.save(item)
+
+        # Update single field
+        result = await db.update_fields(item.id, name="updated")
+        assert result is True
+
+        loaded = await db.get_by_id(item.id)
+        assert loaded.name == "updated"
+        assert loaded.value == 10  # unchanged
+
+        # Update multiple fields
+        result = await db.update_fields(item.id, name="final", value=99)
+        assert result is True
+        loaded = await db.get_by_id(item.id)
+        assert loaded.name == "final"
+        assert loaded.value == 99
+
+        # Non-existent ID
+        result = await db.update_fields("nonexistent-id", name="x")
+        assert result is False
+
+        # Empty fields
+        result = await db.update_fields(item.id)
+        assert result is False
+
+        print("✓ update_fields() works correctly")
+    finally:
+        await db.close()
+
+
+async def test_context_manager(temp_db):
+    """Test async context manager for automatic cleanup."""
+    async with AsyncDB(temp_db, "items", TestItem) as db:
+        await db.save(TestItem(name="ctx", value=42))
+        items = await db.find()
+        assert len(items) == 1
+        assert items[0].name == "ctx"
+
+    # Connection should be closed after exiting context
+    assert db._connection is None
+
+    # Should still work when reopened
+    async with AsyncDB(temp_db, "items", TestItem) as db:
+        items = await db.find()
+        assert len(items) == 1
+
+    print("✓ Context manager works correctly")
+
+
+async def test_prepare_item_dedup(temp_db):
+    """Test that _prepare_item produces correct SQL and values for save."""
+    db = AsyncDB(temp_db, "items", TestItem)
+
+    try:
+        item = TestItem(name="test", value=5)
+        sql, values = db._prepare_item(item)
+        assert "INSERT OR REPLACE" in sql
+        assert "test" in values
+        assert 5 in values
+
+        # Verify save still works end-to-end
+        await db.save(item)
+        loaded = await db.get_by_id(item.id)
+        assert loaded.name == "test"
+        assert loaded.value == 5
+
+        # Verify batch save still works
+        items = [TestItem(name=f"batch_{i}", value=i) for i in range(5)]
+        count = await db.save_batch(items)
+        assert count == 5
+
+        print("✓ _prepare_item() deduplication works correctly")
+    finally:
+        await db.close()
+
+
+if __name__ == "__main__":
+    async def run_all_tests():
+        with tempfile.TemporaryDirectory() as tmpdir:
+            print("\n" + "=" * 60)
+            print("ASYNCDB FIX VERIFICATION TESTS")
+            print("=" * 60)
+
+            test_num = 0
+
+            async def run_test(name, coro):
+                nonlocal test_num
+                test_num += 1
+                # Use a fresh db for each test
+                db_path = Path(tmpdir) / f"test_fix_{test_num}.db"
+                print(f"\n[Test {test_num}] {name}...")
+                await coro(db_path)
+
+            async def run_test_no_db(name, coro):
+                nonlocal test_num
+                test_num += 1
+                print(f"\n[Test {test_num}] {name}...")
+                await coro()
+
+            await run_test("Limit/offset in find()", test_find_limit_offset)
+            await run_test("save_batch count reset", test_save_batch_count_reset)
+            await run_test("Enum subclass deserialization", test_enum_deserialization_subclasses)
+            await run_test("NOT NULL with falsy defaults", test_not_null_with_falsy_defaults)
+            await run_test_no_db("Identifier validation", test_identifier_validation)
+            await run_test("Constructor identifier validation", test_identifier_validation_in_constructor)
+            await run_test("Connection pooling", test_connection_pooling)
+            await run_test("Close idempotent", test_close_idempotent)
+            await run_test("exists()", test_exists)
+            await run_test("delete_many()", test_delete_many)
+            await run_test("update_fields()", test_update_fields)
+            await run_test("Context manager", test_context_manager)
+            await run_test("_prepare_item dedup", test_prepare_item_dedup)
+
+            print("\n" + "=" * 60)
+            print("ALL TESTS PASSED!")
+            print("=" * 60)
+
+    asyncio.run(run_all_tests())

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

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

{esuls-0.1.15 → esuls-0.1.16}/src/esuls.egg-info/SOURCES.txt

@@ -11,4 +11,5 @@ 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/tests/test_db_concurrent.py
+src/esuls/tests/test_db_concurrent.py
+src/esuls/tests/test_db_fixes.py