sqlspec 0.17.1__py3-none-any.whl → 0.19.0__py3-none-any.whl

sqlspec/adapters/aiosqlite/pool.py

@@ -1,4 +1,4 @@
-"""Efficient multi-connection pool for aiosqlite with proper shutdown handling."""
+"""Multi-connection pool for aiosqlite."""
 
 import asyncio
 import logging
@@ -36,7 +36,7 @@ class AiosqliteConnectTimeoutError(SQLSpecError):
 
 
 class AiosqlitePoolConnection:
-    """Wrapper for database connections with pool lifecycle management."""
+    """Wrapper for database connections in the pool."""
 
     __slots__ = ("_closed", "connection", "id", "idle_since")
 
@@ -120,18 +120,18 @@ class AiosqlitePoolConnection:
 
 
 class AiosqliteConnectionPool:
-    """Multi-connection pool for aiosqlite with proper shutdown handling."""
+    """Multi-connection pool for aiosqlite."""
 
     __slots__ = (
-        "_closed_event",
+        "_closed_event_instance",
         "_connect_timeout",
         "_connection_parameters",
         "_connection_registry",
         "_idle_timeout",
-        "_lock",
+        "_lock_instance",
         "_operation_timeout",
         "_pool_size",
-        "_queue",
+        "_queue_instance",
         "_tracked_threads",
         "_wal_initialized",
     )
@@ -141,7 +141,7 @@ class AiosqliteConnectionPool:
         connection_parameters: "dict[str, Any]",
         pool_size: int = 5,
         connect_timeout: float = 30.0,
-        idle_timeout: float = 24 * 60 * 60,  # 24 hours
+        idle_timeout: float = 24 * 60 * 60,
         operation_timeout: float = 10.0,
     ) -> None:
         """Initialize connection pool.
@@ -159,13 +159,35 @@ class AiosqliteConnectionPool:
         self._idle_timeout = idle_timeout
         self._operation_timeout = operation_timeout
 
-        self._queue: asyncio.Queue[AiosqlitePoolConnection] = asyncio.Queue(maxsize=pool_size)
         self._connection_registry: dict[str, AiosqlitePoolConnection] = {}
-        self._lock = asyncio.Lock()
-        self._closed_event = asyncio.Event()
         self._tracked_threads: set[Union[threading.Thread, AiosqliteConnection]] = set()
         self._wal_initialized = False
 
+        self._queue_instance: Optional[asyncio.Queue[AiosqlitePoolConnection]] = None
+        self._lock_instance: Optional[asyncio.Lock] = None
+        self._closed_event_instance: Optional[asyncio.Event] = None
+
+    @property
+    def _queue(self) -> "asyncio.Queue[AiosqlitePoolConnection]":
+        """Lazy initialization of asyncio.Queue for Python 3.9 compatibility."""
+        if self._queue_instance is None:
+            self._queue_instance = asyncio.Queue(maxsize=self._pool_size)
+        return self._queue_instance
+
+    @property
+    def _lock(self) -> asyncio.Lock:
+        """Lazy initialization of asyncio.Lock for Python 3.9 compatibility."""
+        if self._lock_instance is None:
+            self._lock_instance = asyncio.Lock()
+        return self._lock_instance
+
+    @property
+    def _closed_event(self) -> asyncio.Event:
+        """Lazy initialization of asyncio.Event for Python 3.9 compatibility."""
+        if self._closed_event_instance is None:
+            self._closed_event_instance = asyncio.Event()
+        return self._closed_event_instance
+
     @property
     def is_closed(self) -> bool:
         """Check if pool is closed.
@@ -173,7 +195,7 @@ class AiosqliteConnectionPool:
         Returns:
             True if pool is closed
         """
-        return self._closed_event.is_set()
+        return self._closed_event_instance is not None and self._closed_event.is_set()
 
     def size(self) -> int:
         """Get total number of connections in pool.
@@ -189,6 +211,8 @@ class AiosqliteConnectionPool:
         Returns:
             Number of connections currently in use
         """
+        if self._queue_instance is None:
+            return len(self._connection_registry)
         return len(self._connection_registry) - self._queue.qsize()
 
     def _track_aiosqlite_thread(self, connection: "AiosqliteConnection") -> None:
@@ -200,7 +224,7 @@ class AiosqliteConnectionPool:
         self._tracked_threads.add(connection)
 
     async def _create_connection(self) -> AiosqlitePoolConnection:
-        """Create a new connection with SQLite optimizations.
+        """Create a new connection.
 
         Returns:
             New pool connection instance
@@ -209,7 +233,6 @@ class AiosqliteConnectionPool:
         connection.daemon = True
         connection = await connection
 
-        # Detect database type for appropriate optimization
         database_path = str(self._connection_parameters.get("database", ""))
         is_shared_cache = "cache=shared" in database_path
         is_memory_db = ":memory:" in database_path or "mode=memory" in database_path
@@ -234,10 +257,9 @@ class AiosqliteConnectionPool:
 
             if is_shared_cache:
                 self._wal_initialized = True
-                logger.debug("Database optimized for shared cache (memory: %s)", is_memory_db)
 
         except Exception as e:
-            logger.warning("Failed to optimize connection: %s", e)
+            logger.warning("Failed to configure connection: %s", e)
             await connection.execute("PRAGMA foreign_keys = ON")
             await connection.execute("PRAGMA busy_timeout = 30000")
             await connection.commit()
@@ -249,7 +271,7 @@ class AiosqliteConnectionPool:
         async with self._lock:
             self._connection_registry[pool_connection.id] = pool_connection
 
-        logger.debug("Created new aiosqlite connection: %s", pool_connection.id)
+        logger.debug("Created aiosqlite connection: %s", pool_connection.id)
         return pool_connection
 
     async def _claim_if_healthy(self, connection: AiosqlitePoolConnection) -> bool:
@@ -259,7 +281,7 @@ class AiosqliteConnectionPool:
             connection: Connection to check and claim
 
         Returns:
-            True if connection was successfully claimed
+            True if connection was claimed
         """
         if connection.idle_time > self._idle_timeout:
             logger.debug("Connection %s exceeded idle timeout, retiring", connection.id)
@@ -368,9 +390,6 @@ class AiosqliteConnectionPool:
     async def _wait_for_threads_to_terminate(self, timeout: float = 1.0) -> None:
         """Wait for all tracked aiosqlite connection threads to terminate.
 
-        Since we use daemon threads, this is just a best-effort cleanup.
-        The threads will terminate when the process exits regardless.
-
         Args:
             timeout: Maximum time to wait for thread termination in seconds
         """
@@ -396,13 +415,9 @@ class AiosqliteConnectionPool:
         elapsed = time.time() - start_time
 
         if remaining_threads > 0:
-            logger.debug(
-                "%d aiosqlite threads still running after %.2fs (daemon threads will terminate on exit)",
-                remaining_threads,
-                elapsed,
-            )
+            logger.debug("%d aiosqlite threads still running after %.2fs", remaining_threads, elapsed)
         else:
-            logger.debug("All aiosqlite connection threads terminated successfully in %.2fs", elapsed)
+            logger.debug("All aiosqlite connection threads terminated in %.2fs", elapsed)
 
     async def acquire(self) -> AiosqlitePoolConnection:
         """Acquire a connection from the pool.
@@ -461,32 +476,25 @@ class AiosqliteConnectionPool:
             await self.release(connection)
 
     async def close(self) -> None:
-        """Close the connection pool gracefully.
-
-        Ensures all connections are properly closed and background threads are terminated.
-        """
+        """Close the connection pool."""
         if self.is_closed:
             return
         self._closed_event.set()
 
-        # Clear the queue
         while not self._queue.empty():
             self._queue.get_nowait()
 
-        # Get all connections and clear registry
         async with self._lock:
             connections = list(self._connection_registry.values())
             self._connection_registry.clear()
 
-        # Close all connections
         if connections:
             close_tasks = [asyncio.wait_for(conn.close(), timeout=self._operation_timeout) for conn in connections]
             results = await asyncio.gather(*close_tasks, return_exceptions=True)
 
-            # Log any close errors
             for i, result in enumerate(results):
                 if isinstance(result, Exception):
                     logger.warning("Error closing connection %s: %s", connections[i].id, result)
 
         await self._wait_for_threads_to_terminate(timeout=1.0)
-        logger.debug("Aiosqlite connection pool closed successfully")
+        logger.debug("Aiosqlite connection pool closed")

sqlspec/adapters/asyncmy/config.py

@@ -1,4 +1,4 @@
-"""Asyncmy database configuration with direct field-based configuration."""
+"""Asyncmy database configuration."""
 
 import logging
 from collections.abc import AsyncGenerator
@@ -58,7 +58,7 @@ class AsyncmyPoolParams(AsyncmyConnectionParams, total=False):
 
 
 class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver]):  # pyright: ignore
-    """Configuration for Asyncmy database connections with direct field-based configuration."""
+    """Configuration for Asyncmy database connections."""
 
     driver_type: ClassVar[type[AsyncmyDriver]] = AsyncmyDriver
     connection_type: "ClassVar[type[AsyncmyConnection]]" = AsyncmyConnection  # pyright: ignore
@@ -70,6 +70,7 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
         pool_instance: "Optional[Pool]" = None,
         migration_config: Optional[dict[str, Any]] = None,
         statement_config: "Optional[StatementConfig]" = None,
+        driver_features: "Optional[dict[str, Any]]" = None,
     ) -> None:
         """Initialize Asyncmy configuration.
 
@@ -78,6 +79,7 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
             pool_instance: Existing pool instance to use
             migration_config: Migration configuration
             statement_config: Statement configuration override
+            driver_features: Driver feature configuration
         """
         processed_pool_config: dict[str, Any] = dict(pool_config) if pool_config else {}
         if "extra" in processed_pool_config:
@@ -97,7 +99,7 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
             pool_instance=pool_instance,
             migration_config=migration_config,
             statement_config=statement_config,
-            driver_features={},
+            driver_features=driver_features or {},
         )
 
     async def _create_pool(self) -> "Pool":  # pyright: ignore
@@ -107,7 +109,11 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
     async def _close_pool(self) -> None:
         """Close the actual async connection pool."""
         if self.pool_instance:
-            await self.pool_instance.close()
+            self.pool_instance.close()
+
+    async def close_pool(self) -> None:
+        """Close the connection pool."""
+        await self._close_pool()
 
     async def create_connection(self) -> AsyncmyConnection:  # pyright: ignore
         """Create a single async connection (not from pool).
@@ -166,9 +172,6 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
     def get_signature_namespace(self) -> "dict[str, type[Any]]":
         """Get the signature namespace for Asyncmy types.
 
-        This provides all Asyncmy-specific types that Litestar needs to recognize
-        to avoid serialization attempts.
-
         Returns:
             Dictionary mapping type names to types.
         """

sqlspec/adapters/asyncmy/driver.py

@@ -1,10 +1,7 @@
-"""AsyncMy MySQL driver implementation for async MySQL operations.
+"""AsyncMy MySQL driver implementation.
 
-Provides async MySQL/MariaDB connectivity with:
-- Parameter style conversion (QMARK to POSITIONAL_PYFORMAT)
-- MySQL-specific type coercion and data handling
-- Error categorization for MySQL/MariaDB
-- Transaction management
+Provides MySQL/MariaDB connectivity with parameter style conversion,
+type coercion, error handling, and transaction management.
 """
 
 import logging
@@ -34,7 +31,6 @@ logger = logging.getLogger(__name__)
 __all__ = ("AsyncmyCursor", "AsyncmyDriver", "AsyncmyExceptionHandler", "asyncmy_statement_config")
 
 
-# Enhanced AsyncMy statement configuration using core modules with performance optimizations
 asyncmy_statement_config = StatementConfig(
     dialect="mysql",
     parameter_config=ParameterStyleConfig(
@@ -42,12 +38,7 @@ asyncmy_statement_config = StatementConfig(
         supported_parameter_styles={ParameterStyle.QMARK, ParameterStyle.POSITIONAL_PYFORMAT},
         default_execution_parameter_style=ParameterStyle.POSITIONAL_PYFORMAT,
         supported_execution_parameter_styles={ParameterStyle.POSITIONAL_PYFORMAT},
-        type_coercion_map={
-            dict: to_json,
-            list: to_json,
-            tuple: lambda v: to_json(list(v)),
-            bool: int,  # MySQL represents booleans as integers
-        },
+        type_coercion_map={dict: to_json, list: to_json, tuple: lambda v: to_json(list(v)), bool: int},
         has_native_list_expansion=False,
         needs_static_script_compilation=True,
         preserve_parameter_format=True,
@@ -125,13 +116,10 @@ class AsyncmyExceptionHandler:
 
 
 class AsyncmyDriver(AsyncDriverAdapterBase):
-    """AsyncMy MySQL/MariaDB driver for async database operations.
+    """AsyncMy MySQL/MariaDB driver.
 
-    Provides MySQL/MariaDB connectivity with:
-    - Parameter style conversion (QMARK to POSITIONAL_PYFORMAT)
-    - MySQL-specific type coercion (bool -> int, dict/list -> JSON)
-    - Error categorization for MySQL/MariaDB
-    - Transaction management
+    Provides MySQL/MariaDB connectivity with parameter style conversion,
+    type coercion, error handling, and transaction management.
     """
 
     __slots__ = ()
@@ -145,18 +133,17 @@ class AsyncmyDriver(AsyncDriverAdapterBase):
     ) -> None:
         if statement_config is None:
             cache_config = get_cache_config()
-            enhanced_config = asyncmy_statement_config.replace(
+            statement_config = asyncmy_statement_config.replace(
                 enable_caching=cache_config.compiled_cache_enabled,
                 enable_parsing=True,
                 enable_validation=True,
                 dialect="mysql",
             )
-            statement_config = enhanced_config
 
         super().__init__(connection=connection, statement_config=statement_config, driver_features=driver_features)
 
     def with_cursor(self, connection: "AsyncmyConnection") -> "AsyncmyCursor":
-        """Create async context manager for AsyncMy cursor."""
+        """Create context manager for AsyncMy cursor."""
         return AsyncmyCursor(connection)
 
     def handle_database_exceptions(self) -> "AbstractAsyncContextManager[None]":
@@ -173,13 +160,12 @@ class AsyncmyDriver(AsyncDriverAdapterBase):
         Returns:
             None - always proceeds with standard execution for AsyncMy
         """
-        _ = (cursor, statement)  # Mark as intentionally unused
+        _ = (cursor, statement)
         return None
 
     async def _execute_script(self, cursor: Any, statement: "SQL") -> "ExecutionResult":
-        """Execute SQL script using enhanced statement splitting and parameter handling.
+        """Execute SQL script with statement splitting and parameter handling.
 
-        Uses core module optimization for statement parsing and parameter processing.
         Parameters are embedded as static values for script execution compatibility.
         """
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
@@ -197,38 +183,34 @@ class AsyncmyDriver(AsyncDriverAdapterBase):
         )
 
     async def _execute_many(self, cursor: Any, statement: "SQL") -> "ExecutionResult":
-        """Execute SQL with multiple parameter sets using optimized AsyncMy batch processing.
+        """Execute SQL with multiple parameter sets using AsyncMy batch processing.
 
-        Leverages core parameter processing for enhanced MySQL type handling and parameter conversion.
+        Handles MySQL type conversion and parameter processing.
         """
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
 
-        # Enhanced parameter validation for executemany
         if not prepared_parameters:
             msg = "execute_many requires parameters"
             raise ValueError(msg)
 
         await cursor.executemany(sql, prepared_parameters)
 
-        # Calculate affected rows based on parameter count for AsyncMy
         affected_rows = len(prepared_parameters) if prepared_parameters else 0
 
         return self.create_execution_result(cursor, rowcount_override=affected_rows, is_many_result=True)
 
     async def _execute_statement(self, cursor: Any, statement: "SQL") -> "ExecutionResult":
-        """Execute single SQL statement with enhanced AsyncMy MySQL data handling and performance optimization.
+        """Execute single SQL statement with AsyncMy MySQL data handling.
 
-        Uses core processing for optimal parameter handling and MySQL result processing.
+        Handles parameter processing and MySQL result processing.
         """
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
         await cursor.execute(sql, prepared_parameters or None)
 
-        # Enhanced SELECT result processing for MySQL
         if statement.returns_rows():
             fetched_data = await cursor.fetchall()
             column_names = [desc[0] for desc in cursor.description or []]
 
-            # AsyncMy may return tuples or dicts - ensure consistent dict format
             if fetched_data and not isinstance(fetched_data[0], dict):
                 data = [dict(zip(column_names, row)) for row in fetched_data]
             else:
@@ -238,19 +220,16 @@ class AsyncmyDriver(AsyncDriverAdapterBase):
                 cursor, selected_data=data, column_names=column_names, data_row_count=len(data), is_select_result=True
             )
 
-        # Enhanced non-SELECT result processing for MySQL
         affected_rows = cursor.rowcount if cursor.rowcount is not None else -1
         last_id = getattr(cursor, "lastrowid", None) if cursor.rowcount and cursor.rowcount > 0 else None
         return self.create_execution_result(cursor, rowcount_override=affected_rows, last_inserted_id=last_id)
 
-    # MySQL transaction management with enhanced async error handling
     async def begin(self) -> None:
-        """Begin a database transaction with enhanced async error handling.
+        """Begin a database transaction.
 
         Explicitly starts a MySQL transaction to ensure proper transaction boundaries.
         """
         try:
-            # Execute explicit BEGIN to start transaction
             async with AsyncmyCursor(self.connection) as cursor:
                 await cursor.execute("BEGIN")
         except asyncmy.errors.MySQLError as e:
@@ -258,7 +237,7 @@ class AsyncmyDriver(AsyncDriverAdapterBase):
             raise SQLSpecError(msg) from e
 
     async def rollback(self) -> None:
-        """Rollback the current transaction with enhanced async error handling."""
+        """Rollback the current transaction."""
         try:
             await self.connection.rollback()
         except asyncmy.errors.MySQLError as e:
@@ -266,7 +245,7 @@ class AsyncmyDriver(AsyncDriverAdapterBase):
             raise SQLSpecError(msg) from e
 
     async def commit(self) -> None:
-        """Commit the current transaction with enhanced async error handling."""
+        """Commit the current transaction."""
         try:
             await self.connection.commit()
         except asyncmy.errors.MySQLError as e:

sqlspec/adapters/asyncpg/config.py

@@ -144,6 +144,10 @@ class AsyncpgConfig(AsyncDatabaseConfig[AsyncpgConnection, "Pool[Record]", Async
         if self.pool_instance:
             await self.pool_instance.close()
 
+    async def close_pool(self) -> None:
+        """Close the connection pool."""
+        await self._close_pool()
+
     async def create_connection(self) -> "AsyncpgConnection":
         """Create a single async connection from the pool.