kailash 0.9.10__py3-none-any.whl → 0.9.12__py3-none-any.whl

kailash/__init__.py

@@ -50,7 +50,7 @@ except ImportError:
 # For backward compatibility
 WorkflowGraph = Workflow
 
-__version__ = "0.9.10"
+__version__ = "0.9.12"
 
 __all__ = [
     # Core workflow components

kailash/nodes/data/async_sql.py

@@ -434,22 +434,63 @@ class PostgreSQLAdapter(DatabaseAdapter):
         parameter_types: Optional[dict[str, str]] = None,
     ) -> Any:
         """Execute query and return results."""
+
+        import logging
+
+        logger = logging.getLogger(__name__)
+
         # Convert dict params to positional for asyncpg
         if isinstance(params, dict):
             # Simple parameter substitution for named params
-            # In production, use a proper SQL parser
+            # Fix: Use proper ordering and safe replacement to avoid collisions
             import json
+            import logging
+
+            logger = logging.getLogger(__name__)
 
             query_params = []
             param_names = []  # Track parameter names for type mapping
-            for i, (key, value) in enumerate(params.items(), 1):
-                query = query.replace(f":{key}", f"${i}")
+
+            # Keep original order for parameter values, but do replacements safely
+            original_items = list(params.items())
+
+            # Create parameter values in original order
+            for key, value in original_items:
                 param_names.append(key)
                 # For PostgreSQL, lists should remain as lists for array operations
                 # Only convert dicts to JSON strings
                 if isinstance(value, dict):
                     value = json.dumps(value)
+                # Fix for parameter $11 issue: Handle ambiguous integer values
+                # AsyncPG has trouble with certain integer values (especially 0)
+                # where it can't determine the PostgreSQL type automatically
+                elif isinstance(value, int) and value == 0:
+                    # Keep as int but we'll add explicit casting in the query later
+                    pass
                 query_params.append(value)
+
+            # Replace parameters in the query, processing longer keys first to avoid collision
+            # Sort keys by length (descending) for replacement order only
+            keys_by_length = sorted(params.keys(), key=len, reverse=True)
+
+            for key in keys_by_length:
+                # Find the position of this key in the original order
+                position = (
+                    next(i for i, (k, v) in enumerate(original_items) if k == key) + 1
+                )
+                value = original_items[position - 1][1]  # Get the actual value
+
+                # Fix for parameter $11 issue: Add explicit type casting for ambiguous values
+                # Note: Check boolean first since bool is a subclass of int in Python
+                if isinstance(value, bool):
+                    # Cast boolean parameters to avoid type ambiguity
+                    query = query.replace(f":{key}", f"${position}::boolean")
+                elif isinstance(value, int):
+                    # Cast integer parameters to avoid PostgreSQL type determination issues
+                    query = query.replace(f":{key}", f"${position}::integer")
+                else:
+                    query = query.replace(f":{key}", f"${position}")
+
             params = query_params
 
             # Apply parameter type casts if provided
@@ -462,6 +503,8 @@ class PostgreSQLAdapter(DatabaseAdapter):
                         query = query.replace(f"${i}", f"${i}::{pg_type}")
 
         else:
+            # Parameters are not dict - they might be list/tuple
+
             # For positional params, apply type casts if provided
             if parameter_types and isinstance(params, (list, tuple)):
                 # Build query with type casts for positional parameters
@@ -671,9 +714,11 @@ class MySQLAdapter(DatabaseAdapter):
         fetch_mode: FetchMode = FetchMode.ALL,
         fetch_size: Optional[int] = None,
         transaction: Optional[Any] = None,
+        parameter_types: Optional[dict[str, str]] = None,
     ) -> Any:
         """Execute query and return results."""
         # Use transaction connection if provided, otherwise get from pool
+        # Note: parameter_types is only used by PostgreSQL adapter
         if transaction:
             conn = transaction
             async with conn.cursor() as cursor:
@@ -774,6 +819,10 @@ class MySQLAdapter(DatabaseAdapter):
 class SQLiteAdapter(DatabaseAdapter):
     """SQLite adapter using aiosqlite."""
 
+    # Class-level shared connections for memory databases to solve isolation issues
+    _shared_memory_connections = {}
+    _connection_locks = {}
+
     async def connect(self) -> None:
         """Establish connection pool."""
         try:
@@ -784,13 +833,71 @@ class SQLiteAdapter(DatabaseAdapter):
             )
 
         # SQLite doesn't have true connection pooling
-        # We'll manage a single connection for simplicity
+        # We'll manage connections based on database type
         self._aiosqlite = aiosqlite
-        self._db_path = self.config.database
+
+        # Extract database path from connection string if database path not provided
+        if self.config.database:
+            self._db_path = self.config.database
+        elif self.config.connection_string:
+            # Parse SQLite connection string formats:
+            # sqlite:///path/to/file.db (absolute path)
+            # sqlite://path/to/file.db (relative path - rare)
+            # file:path/to/file.db (file URI scheme)
+            conn_str = self.config.connection_string
+            if conn_str.startswith("sqlite:///"):
+                # Absolute path: sqlite:///path/to/file.db -> /path/to/file.db
+                # Special case: sqlite:///:memory: -> :memory:
+                path_part = conn_str[9:]  # Remove "sqlite://" to keep the leading slash
+                if path_part == "/:memory:":
+                    self._db_path = ":memory:"
+                else:
+                    self._db_path = path_part
+            elif conn_str.startswith("sqlite://"):
+                # Relative path: sqlite://path/to/file.db -> path/to/file.db
+                self._db_path = conn_str[9:]  # Remove "sqlite://"
+            elif conn_str.startswith("file:"):
+                # File URI: file:path/to/file.db -> path/to/file.db
+                self._db_path = conn_str[5:]  # Remove "file:"
+            else:
+                # Assume the connection string IS the path
+                self._db_path = conn_str
+        else:
+            raise NodeExecutionError(
+                "SQLite requires either 'database' path or 'connection_string'"
+            )
+
+        # Set up connection sharing for memory databases to prevent isolation
+        self._is_memory_db = self._db_path == ":memory:"
+        if self._is_memory_db:
+            import asyncio
+
+            # All :memory: databases should share the same connection to avoid isolation
+            self._memory_key = "global_memory_db"
+            if self._memory_key not in self._connection_locks:
+                self._connection_locks[self._memory_key] = asyncio.Lock()
+
+    async def _get_connection(self):
+        """Get a database connection, using shared connection for memory databases."""
+        if self._is_memory_db:
+            # Use shared connection for memory databases to prevent isolation
+            async with self._connection_locks[self._memory_key]:
+                if self._memory_key not in self._shared_memory_connections:
+                    # Create the shared memory connection
+                    conn = await self._aiosqlite.connect(self._db_path)
+                    conn.row_factory = self._aiosqlite.Row
+                    self._shared_memory_connections[self._memory_key] = conn
+                return self._shared_memory_connections[self._memory_key]
+        else:
+            # For file databases, create new connections as before
+            conn = await self._aiosqlite.connect(self._db_path)
+            conn.row_factory = self._aiosqlite.Row
+            return conn
 
     async def disconnect(self) -> None:
         """Close connection."""
-        # Connections are managed per-operation for SQLite
+        # For memory databases, we keep the shared connection alive
+        # For file databases, connections are managed per-operation
         pass
 
     async def execute(
@@ -800,6 +907,7 @@ class SQLiteAdapter(DatabaseAdapter):
         fetch_mode: FetchMode = FetchMode.ALL,
         fetch_size: Optional[int] = None,
         transaction: Optional[Any] = None,
+        parameter_types: Optional[dict[str, str]] = None,
     ) -> Any:
         """Execute query and return results."""
         if transaction:
@@ -820,21 +928,43 @@ class SQLiteAdapter(DatabaseAdapter):
                 return [self._convert_row(dict(row)) for row in rows]
         else:
             # Create new connection for non-transactional queries
-            async with self._aiosqlite.connect(self._db_path) as db:
-                db.row_factory = self._aiosqlite.Row
+            if self._is_memory_db:
+                # Use shared connection for memory databases
+                db = await self._get_connection()
                 cursor = await db.execute(query, params or [])
 
                 if fetch_mode == FetchMode.ONE:
                     row = await cursor.fetchone()
-                    return self._convert_row(dict(row)) if row else None
+                    result = self._convert_row(dict(row)) if row else None
                 elif fetch_mode == FetchMode.ALL:
                     rows = await cursor.fetchall()
-                    return [self._convert_row(dict(row)) for row in rows]
+                    result = [self._convert_row(dict(row)) for row in rows]
                 elif fetch_mode == FetchMode.MANY:
                     if not fetch_size:
                         raise ValueError("fetch_size required for MANY mode")
                     rows = await cursor.fetchmany(fetch_size)
-                    return [self._convert_row(dict(row)) for row in rows]
+                    result = [self._convert_row(dict(row)) for row in rows]
+
+                # Commit for memory databases (needed for INSERT/UPDATE/DELETE)
+                await db.commit()
+                return result
+            else:
+                # Use context manager for file databases
+                async with self._aiosqlite.connect(self._db_path) as db:
+                    db.row_factory = self._aiosqlite.Row
+                    cursor = await db.execute(query, params or [])
+
+                    if fetch_mode == FetchMode.ONE:
+                        row = await cursor.fetchone()
+                        return self._convert_row(dict(row)) if row else None
+                    elif fetch_mode == FetchMode.ALL:
+                        rows = await cursor.fetchall()
+                        return [self._convert_row(dict(row)) for row in rows]
+                    elif fetch_mode == FetchMode.MANY:
+                        if not fetch_size:
+                            raise ValueError("fetch_size required for MANY mode")
+                        rows = await cursor.fetchmany(fetch_size)
+                        return [self._convert_row(dict(row)) for row in rows]
 
                 await db.commit()
 
@@ -851,26 +981,44 @@ class SQLiteAdapter(DatabaseAdapter):
             # Don't commit here - let transaction handling do it
         else:
             # Create new connection for non-transactional queries
-            async with self._aiosqlite.connect(self._db_path) as db:
+            if self._is_memory_db:
+                # Use shared connection for memory databases
+                db = await self._get_connection()
                 await db.executemany(query, params_list)
                 await db.commit()
+            else:
+                # Use context manager for file databases
+                async with self._aiosqlite.connect(self._db_path) as db:
+                    await db.executemany(query, params_list)
+                    await db.commit()
 
     async def begin_transaction(self) -> Any:
         """Begin a transaction."""
-        db = await self._aiosqlite.connect(self._db_path)
-        db.row_factory = self._aiosqlite.Row
-        await db.execute("BEGIN")
-        return db
+        if self._is_memory_db:
+            # Use shared connection for memory databases
+            db = await self._get_connection()
+            await db.execute("BEGIN")
+            return db
+        else:
+            # Create new connection for file databases
+            db = await self._aiosqlite.connect(self._db_path)
+            db.row_factory = self._aiosqlite.Row
+            await db.execute("BEGIN")
+            return db
 
     async def commit_transaction(self, transaction: Any) -> None:
         """Commit a transaction."""
         await transaction.commit()
-        await transaction.close()
+        # Don't close shared memory connections
+        if not self._is_memory_db:
+            await transaction.close()
 
     async def rollback_transaction(self, transaction: Any) -> None:
         """Rollback a transaction."""
         await transaction.rollback()
-        await transaction.close()
+        # Don't close shared memory connections
+        if not self._is_memory_db:
+            await transaction.close()
 
 
 class DatabaseConfigManager:
@@ -1421,8 +1569,44 @@ class AsyncSQLDatabaseNode(AsyncNode):
         # Re-initialize instance variables with updated config
         self._reinitialize_from_config()
 
-        # Validate database type
+        # Auto-detect database type from connection string if not explicitly set
         db_type = self.config.get("database_type", "").lower()
+        connection_string = self.config.get("connection_string")
+
+        # If database_type is the default and we have a connection string, try to auto-detect
+        if (
+            db_type == "postgresql"
+            and connection_string
+            and self.config.get("database_type")
+            == self.get_parameters()["database_type"].default
+        ):
+            try:
+                # Simple detection based on connection string patterns
+                conn_lower = connection_string.lower()
+                if (
+                    connection_string == ":memory:"
+                    or conn_lower.endswith(".db")
+                    or conn_lower.endswith(".sqlite")
+                    or conn_lower.endswith(".sqlite3")
+                    or conn_lower.startswith("sqlite")
+                    or
+                    # File path without URL scheme (likely SQLite)
+                    ("/" in connection_string and "://" not in connection_string)
+                ):
+                    db_type = "sqlite"
+                    self.config["database_type"] = "sqlite"
+                elif conn_lower.startswith("mysql"):
+                    db_type = "mysql"
+                    self.config["database_type"] = "mysql"
+                elif conn_lower.startswith(("postgresql", "postgres")):
+                    db_type = "postgresql"
+                    self.config["database_type"] = "postgresql"
+                # Otherwise keep default postgresql
+            except Exception:
+                # If detection fails, keep the default
+                pass
+
+        # Validate database type
         if db_type not in ["postgresql", "mysql", "sqlite"]:
             raise NodeValidationError(
                 f"Invalid database_type: {db_type}. "
@@ -1908,6 +2092,9 @@ class AsyncSQLDatabaseNode(AsyncNode):
             except Exception as e:
                 last_error = e
 
+                # Parameter type determination is now handled during dict-to-positional conversion
+                # No special retry logic needed for parameter $11
+
                 # Check if error is retryable
                 if not self._retry_config.should_retry(e):
                     raise

{kailash-0.9.10.dist-info → kailash-0.9.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kailash
-Version: 0.9.10
+Version: 0.9.12
 Summary: Python SDK for the Kailash container-node architecture
 Home-page: https://github.com/integrum/kailash-python-sdk
 Author: Integrum
@@ -105,7 +105,7 @@ Dynamic: requires-python
   <a href="https://pepy.tech/project/kailash"><img src="https://static.pepy.tech/badge/kailash" alt="Downloads"></a>
   <img src="https://img.shields.io/badge/license-Apache%202.0%20with%20Additional%20Terms-orange.svg" alt="Apache 2.0 with Additional Terms">
   <img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code style: black">
-  <img src="https://img.shields.io/badge/tests-2400%2B%20passing-brightgreen.svg" alt="Tests: 2400+ Passing">
+  <img src="https://img.shields.io/badge/tests-4000%2B%20passing-brightgreen.svg" alt="Tests: 4000+ Passing">
   <img src="https://img.shields.io/badge/performance-11x%20faster-yellow.svg" alt="Performance: 11x Faster">
   <img src="https://img.shields.io/badge/docker-integrated-blue.svg" alt="Docker: Integrated">
   <img src="https://img.shields.io/badge/AI-MCP%20validated-purple.svg" alt="AI: MCP Validated">
@@ -158,7 +158,7 @@ Not just a toolkit - complete production-ready applications built on enterprise-
 - **11x faster test execution** (117s → 10.75s) with smart isolation
 - **31.8M operations/second** query performance baseline
 - **30,000+ iterations/second** cyclic workflow execution
-- **100% test pass rate** across 2,400+ tests
+- **100% test pass rate** across 4,000+ tests
 
 ### 🤖 **AI-First Architecture**
 - **A2A Google Protocol** for enterprise multi-agent coordination
@@ -198,7 +198,7 @@ kailash_python_sdk/
 │   ├── kailash-mcp/      # Enterprise MCP platform
 │   ├── ai_registry/      # Advanced RAG capabilities
 │   └── user_management/  # Enterprise RBAC system
-├── tests/               # 2,400+ tests (100% pass rate)
+├── tests/               # 4,000+ tests (100% pass rate)
 ├── docs/                # Comprehensive documentation
 └── examples/            # Feature validation examples
 ```
@@ -299,7 +299,7 @@ results, run_id = runtime.execute(workflow.build())
 ## 🎯 Key Features
 
 ### 🧪 **Testing Excellence**
-- **2,400+ tests** with 100% pass rate
+- **4,000+ tests** with 100% pass rate
 - **11x performance improvement** (117s → 10.75s execution)
 - **Docker integration** for real PostgreSQL, Redis, MongoDB
 - **Smart isolation** without process forking overhead
@@ -347,7 +347,7 @@ results, run_id = runtime.execute(workflow.build())
 
 ### Recent Achievements
 - **11x faster test execution**: 117s → 10.75s with smart isolation
-- **100% test pass rate**: 2,400+ tests across all categories
+- **100% test pass rate**: 4,000+ tests across all categories
 - **31.8M operations/second**: Query performance baseline
 - **30,000+ iterations/second**: Cyclic workflow execution
 
@@ -401,7 +401,7 @@ pip install kailash-user-management
 
 ### Comprehensive Test Suite
 ```bash
-# All tests (2,400+ tests)
+# All tests (4,000+ tests)
 pytest
 
 # Fast unit tests (11x faster execution)
@@ -496,7 +496,7 @@ git clone https://github.com/integrum/kailash-python-sdk.git
 cd kailash-python-sdk
 uv sync
 
-# Run tests (2,400+ tests)
+# Run tests (4,000+ tests)
 pytest tests/unit/ --timeout=1      # Fast unit tests
 pytest tests/integration/ --timeout=5  # Integration tests
 pytest tests/e2e/ --timeout=10     # End-to-end tests
@@ -529,7 +529,7 @@ See [Contributing Guide](CONTRIBUTING.md) and [sdk-contributors/CLAUDE.md](sdk-c
 - **Complete Application Framework**: DataFlow, Nexus, AI Registry, User Management
 - **PyPI Integration**: All packages available with proper extras support
 - **Performance Breakthrough**: 11x faster test execution
-- **Testing Excellence**: 2,400+ tests with 100% pass rate
+- **Testing Excellence**: 4,000+ tests with 100% pass rate
 - **Enterprise Ready**: Production deployment patterns
 
 ### ✅ v0.7.0 - Major Framework Release

{kailash-0.9.10.dist-info → kailash-0.9.12.dist-info}/RECORD

@@ -1,4 +1,4 @@
-kailash/__init__.py,sha256=amrc4JD2yQaPHlYDEMvn1L-jk22-FDF8AZmh8ND_35I,2772
+kailash/__init__.py,sha256=rLudbyeIwYeEEJKd5sX5BAGJfIJULcTGe0hvtbVdP3c,2772
 kailash/__main__.py,sha256=vr7TVE5o16V6LsTmRFKG6RDKUXHpIWYdZ6Dok2HkHnI,198
 kailash/access_control.py,sha256=MjKtkoQ2sg1Mgfe7ovGxVwhAbpJKvaepPWr8dxOueMA,26058
 kailash/access_control_abac.py,sha256=FPfa_8PuDP3AxTjdWfiH3ntwWO8NodA0py9W8SE5dno,30263
@@ -203,7 +203,7 @@ kailash/nodes/compliance/data_retention.py,sha256=90bH_eGwlcDzUdklAJeXQM-RcuLUGQ
 kailash/nodes/compliance/gdpr.py,sha256=ZMoHZjAo4QtGwtFCzGMrAUBFV3TbZOnJ5DZGZS87Bas,70548
 kailash/nodes/data/__init__.py,sha256=f0h4ysvXxlyFcNJLvDyXrgJ0ixwDF1cS0pJ2QNPakhg,5213
 kailash/nodes/data/async_connection.py,sha256=wfArHs9svU48bxGZIiixSV2YVn9cukNgEjagwTRu6J4,17250
-kailash/nodes/data/async_sql.py,sha256=yKwX4_gFc_Qi6sCF134XCgtERyIhAZKK7DomYSZG3bo,105201
+kailash/nodes/data/async_sql.py,sha256=lVNbYaKnanK4Ejm6VZSPSUuPqBItlP7rAQ3Zvp-KeYg,114285
 kailash/nodes/data/async_vector.py,sha256=HtwQLO25IXu8Vq80qzU8rMkUAKPQ2qM0x8YxjXHlygU,21005
 kailash/nodes/data/bulk_operations.py,sha256=WVopmosVkIlweFxVt3boLdCPc93EqpYyQ1Ez9mCIt0c,34453
 kailash/nodes/data/directory.py,sha256=fbfLqD_ijRubk-4xew3604QntPsyDxqaF4k6TpfyjDg,9923
@@ -403,10 +403,10 @@ kailash/workflow/templates.py,sha256=XQMAKZXC2dlxgMMQhSEOWAF3hIbe9JJt9j_THchhAm8
 kailash/workflow/type_inference.py,sha256=i1F7Yd_Z3elTXrthsLpqGbOnQBIVVVEjhRpI0HrIjd0,24492
 kailash/workflow/validation.py,sha256=r2zApGiiG8UEn7p5Ji842l8OR1_KftzDkWc7gg0cac0,44675
 kailash/workflow/visualization.py,sha256=nHBW-Ai8QBMZtn2Nf3EE1_aiMGi9S6Ui_BfpA5KbJPU,23187
-kailash-0.9.10.dist-info/licenses/LICENSE,sha256=9GYZHXVUmx6FdFRNzOeE_w7a_aEGeYbqTVmFtJlrbGk,13438
-kailash-0.9.10.dist-info/licenses/NOTICE,sha256=9ssIK4LcHSTFqriXGdteMpBPTS1rSLlYtjppZ_bsjZ0,723
-kailash-0.9.10.dist-info/METADATA,sha256=uU7Mhecq6GvLVX5nPxKHbwxMFY_IdrV5IqdGWyRvBLA,23528
-kailash-0.9.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kailash-0.9.10.dist-info/entry_points.txt,sha256=M_q3b8PG5W4XbhSgESzIJjh3_4OBKtZFYFsOdkr2vO4,45
-kailash-0.9.10.dist-info/top_level.txt,sha256=z7GzH2mxl66498pVf5HKwo5wwfPtt9Aq95uZUpH6JV0,8
-kailash-0.9.10.dist-info/RECORD,,
+kailash-0.9.12.dist-info/licenses/LICENSE,sha256=9GYZHXVUmx6FdFRNzOeE_w7a_aEGeYbqTVmFtJlrbGk,13438
+kailash-0.9.12.dist-info/licenses/NOTICE,sha256=9ssIK4LcHSTFqriXGdteMpBPTS1rSLlYtjppZ_bsjZ0,723
+kailash-0.9.12.dist-info/METADATA,sha256=BeJ1vff7OZ9KO4Vw2_vDpXjCWBDonz30uREPxYa78pw,23528
+kailash-0.9.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kailash-0.9.12.dist-info/entry_points.txt,sha256=M_q3b8PG5W4XbhSgESzIJjh3_4OBKtZFYFsOdkr2vO4,45
+kailash-0.9.12.dist-info/top_level.txt,sha256=z7GzH2mxl66498pVf5HKwo5wwfPtt9Aq95uZUpH6JV0,8
+kailash-0.9.12.dist-info/RECORD,,