sqlite3-tool 0.1.0__py3-none-any.whl

sqlite3_tool-0.1.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: sqlite3_tool
+Version: 0.1.0
+Summary: Execute SQL queries against SQLite databases asynchronously using aiosqlite.
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: aiosqlite>=0.19.0
+Requires-Dist: openchadpy>=0.1.23
+
+# sqlite_tool

sqlite3_tool-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+sqlite_tool/__init__.py,sha256=P3aYF_xlUxrbIKEM-4PPtSq-TGMxANOQWhdeucOZdBI,22
+sqlite_tool/main.py,sha256=rB9LfQ388eGKRw0-8SMfwUhx6_e5Yfp7QlTMIHi3BPQ,4653
+sqlite3_tool-0.1.0.dist-info/METADATA,sha256=LsyaT_-InswWgpMp_MU_Zjxig6GPhyNHKq0Gj9tQOgI,288
+sqlite3_tool-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+sqlite3_tool-0.1.0.dist-info/top_level.txt,sha256=Mzx7AlIN1Bje_Qq5Aqx6YHzDw5bJ11YuOkFe4cfVpWY,12
+sqlite3_tool-0.1.0.dist-info/RECORD,,

sqlite3_tool-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sqlite3_tool-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sqlite_tool

sqlite_tool/__init__.py

@@ -0,0 +1 @@
+# sqlite_tool package

sqlite_tool/main.py

@@ -0,0 +1,131 @@
+"""
+sqlite Tool
+===========
+Execute SQL queries against an in-memory or persistent SQLite database using aiosqlite.
+
+Parameters:
+  query      - The SQL query or command to execute (required).
+  parameters - Optional list of parameters to bind to the query.
+  db_path    - Path to the persistent database file. If omitted, uses an in-memory database.
+"""
+
+import asyncio
+import os
+import logging
+import threading
+from typing import Any, Dict, List, Optional
+import aiosqlite
+from openchadpy.tool_base import ToolBase
+
+logger = logging.getLogger(__name__)
+
+# Per-database locks to synchronize write/read operations safely
+_db_locks: Dict[str, asyncio.Lock] = {}
+_db_lock_registry_lock = threading.Lock()
+
+def _get_db_lock(db_path: Optional[str]) -> asyncio.Lock:
+    canonical = os.path.normcase(os.path.realpath(db_path)) if db_path else "in-memory"
+    with _db_lock_registry_lock:
+        if canonical not in _db_locks:
+            _db_locks[canonical] = asyncio.Lock()
+        return _db_locks[canonical]
+
+class Tool(ToolBase):
+    name = "sqlite"
+    description = (
+        "Execute SQL queries or DDL/DML commands against in-memory or persistent SQLite databases asynchronously."
+    )
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "string",
+                "description": "The SQL query or statement to execute.",
+            },
+            "parameters": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Optional list of parameters to bind to prevent SQL injection.",
+            },
+            "db_path": {
+                "type": "string",
+                "description": "Absolute path to persistent SQLite database file. If omitted, uses in-memory database.",
+            }
+        },
+        "required": ["query"],
+    }
+    allowed_callers = ["direct", "code_execution"]
+
+    async def execute(self, **kwargs) -> Dict[str, Any]:
+        query: str = kwargs.get("query", "").strip()
+        parameters: Optional[List[Any]] = kwargs.get("parameters")
+        db_path: Optional[str] = kwargs.get("db_path")
+
+        if not query:
+            return {"error": "query is required and must not be empty."}
+
+        if db_path:
+            db_path = db_path.strip()
+
+        lock = _get_db_lock(db_path)
+        await lock.acquire()
+        
+        try:
+            return await self._run_query(query, parameters, db_path)
+        except Exception as e:
+            logger.error(f"[sqlite] Execution failed for query '{query}': {e}", exc_info=True)
+            return {"error": str(e)}
+        finally:
+            lock.release()
+
+    async def _run_query(self, query: str, parameters: Optional[List[Any]], db_path: Optional[str]) -> Dict[str, Any]:
+        target_db = db_path if db_path else ":memory:"
+        
+        if db_path:
+            parent_dir = os.path.dirname(db_path)
+            if parent_dir:
+                os.makedirs(parent_dir, exist_ok=True)
+                
+        async with aiosqlite.connect(target_db) as conn:
+            conn.row_factory = aiosqlite.Row
+            
+            async with conn.cursor() as cursor:
+                if parameters:
+                    await cursor.execute(query, parameters)
+                else:
+                    await cursor.execute(query)
+                    
+                await conn.commit()
+                
+                description = cursor.description
+                if description:
+                    columns = [col[0] for col in description]
+                    rows = await cursor.fetchall()
+                    
+                    results = []
+                    for row in rows:
+                        row_dict = {}
+                        for col in columns:
+                            row_dict[col] = self._serialize_val(row[col])
+                        results.append(row_dict)
+                        
+                    return {
+                        "columns": columns,
+                        "results": results,
+                        "row_count": len(results)
+                    }
+                else:
+                    return {
+                        "success": True,
+                        "message": "Query executed successfully, no rows returned.",
+                        "changes": conn.total_changes
+                    }
+
+    def _serialize_val(self, val: Any) -> Any:
+        if val is None:
+            return None
+        if isinstance(val, (int, float, str, bool, bytes)):
+            if isinstance(val, bytes):
+                return val.hex()
+            return val
+        return str(val)