sqlspec 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

sqlspec/adapters/aiosqlite/config.py

@@ -2,7 +2,10 @@ from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Optional, Union
 
-from sqlspec.base import NoPoolSyncConfig
+from aiosqlite import Connection
+
+from sqlspec.adapters.aiosqlite.driver import AiosqliteDriver
+from sqlspec.base import NoPoolAsyncConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
@@ -11,13 +14,12 @@ if TYPE_CHECKING:
     from sqlite3 import Connection as SQLite3Connection
     from typing import Literal
 
-    from aiosqlite import Connection
 
-__all__ = ("AiosqliteConfig",)
+__all__ = ("Aiosqlite",)
 
 
 @dataclass
-class AiosqliteConfig(NoPoolSyncConfig["Connection"]):
+class Aiosqlite(NoPoolAsyncConfig["Connection", "AiosqliteDriver"]):
     """Configuration for Aiosqlite database connections.
 
     This class provides configuration options for Aiosqlite database connections, wrapping all parameters
@@ -42,6 +44,10 @@ class AiosqliteConfig(NoPoolSyncConfig["Connection"]):
     """The number of statements that SQLite will cache for this connection. The default is 128."""
     uri: "Union[bool, EmptyType]" = field(default=Empty)
     """If set to True, database is interpreted as a URI with supported options."""
+    connection_type: "type[Connection]" = field(init=False, default_factory=lambda: Connection)
+    """Type of the connection object"""
+    driver_type: "type[AiosqliteDriver]" = field(init=False, default_factory=lambda: AiosqliteDriver)  # type: ignore[type-abstract,unused-ignore]
+    """Type of the driver object"""
 
     @property
     def connection_config_dict(self) -> "dict[str, Any]":
@@ -50,7 +56,9 @@ class AiosqliteConfig(NoPoolSyncConfig["Connection"]):
         Returns:
             A string keyed dict of config kwargs for the aiosqlite.connect() function.
         """
-        return dataclass_to_dict(self, exclude_empty=True, convert_nested=False)
+        return dataclass_to_dict(
+            self, exclude_empty=True, convert_nested=False, exclude={"pool_instance", "connection_type", "driver_type"}
+        )
 
     async def create_connection(self) -> "Connection":
         """Create and return a new database connection.
@@ -76,11 +84,21 @@ class AiosqliteConfig(NoPoolSyncConfig["Connection"]):
         Yields:
             An Aiosqlite connection instance.
 
-        Raises:
-            ImproperConfigurationError: If the connection could not be established.
         """
         connection = await self.create_connection()
         try:
             yield connection
         finally:
             await connection.close()
+
+    @asynccontextmanager
+    async def provide_session(self, *args: Any, **kwargs: Any) -> "AsyncGenerator[AiosqliteDriver, None]":
+        """Create and provide a database connection.
+
+        Yields:
+            A Aiosqlite driver instance.
+
+
+        """
+        async with self.provide_connection(*args, **kwargs) as connection:
+            yield self.driver_type(connection)

sqlspec/adapters/aiosqlite/driver.py

@@ -0,0 +1,275 @@
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, Any, Optional, Union, cast
+
+from sqlspec.base import AsyncDriverAdapterProtocol, T
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator
+
+    from aiosqlite import Connection, Cursor
+
+    from sqlspec.typing import ModelDTOT, StatementParameterType
+
+__all__ = ("AiosqliteDriver",)
+
+
+class AiosqliteDriver(AsyncDriverAdapterProtocol["Connection"]):
+    """SQLite Async Driver Adapter."""
+
+    connection: "Connection"
+
+    def __init__(self, connection: "Connection") -> None:
+        self.connection = connection
+
+    @staticmethod
+    async def _cursor(connection: "Connection", *args: Any, **kwargs: Any) -> "Cursor":
+        return await connection.cursor(*args, **kwargs)
+
+    @asynccontextmanager
+    async def _with_cursor(self, connection: "Connection") -> "AsyncGenerator[Cursor, None]":
+        cursor = await self._cursor(connection)
+        try:
+            yield cursor
+        finally:
+            await cursor.close()
+
+    def _process_sql_params(
+        self, sql: str, parameters: "Optional[StatementParameterType]" = None
+    ) -> "tuple[str, Optional[Union[tuple[Any, ...], list[Any], dict[str, Any]]]]":
+        """Process SQL query and parameters for DB-API execution.
+
+        Converts named parameters (:name) to positional parameters (?) for SQLite.
+
+        Args:
+            sql: The SQL query string.
+            parameters: The parameters for the query (dict, tuple, list, or None).
+
+        Returns:
+            A tuple containing the processed SQL string and the processed parameters.
+        """
+        if not isinstance(parameters, dict) or not parameters:
+            # If parameters are not a dict, or empty dict, assume positional/no params
+            # Let the underlying driver handle tuples/lists directly
+            return sql, parameters
+
+        # Convert named parameters to positional parameters
+        processed_sql = sql
+        processed_params: list[Any] = []
+        for key, value in parameters.items():
+            # Replace :key with ? in the SQL
+            processed_sql = processed_sql.replace(f":{key}", "?")
+            processed_params.append(value)
+
+        return processed_sql, tuple(processed_params)
+
+    async def select(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        connection: Optional["Connection"] = None,
+        schema_type: "Optional[type[ModelDTOT]]" = None,
+    ) -> "list[Union[ModelDTOT, dict[str, Any]]]":
+        """Fetch data from the database.
+
+        Returns:
+            List of row data as either model instances or dictionaries.
+        """
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+        async with self._with_cursor(connection) as cursor:
+            await cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            results = await cursor.fetchall()  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            if not results:
+                return []
+            column_names = [c[0] for c in cursor.description or []]  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            if schema_type is None:
+                return [dict(zip(column_names, row)) for row in results]  # pyright: ignore[reportUnknownArgumentType]
+            return [cast("ModelDTOT", schema_type(**dict(zip(column_names, row)))) for row in results]  # pyright: ignore[reportUnknownArgumentType]
+
+    async def select_one(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        connection: Optional["Connection"] = None,
+        schema_type: "Optional[type[ModelDTOT]]" = None,
+    ) -> "Union[ModelDTOT, dict[str, Any]]":
+        """Fetch one row from the database.
+
+        Returns:
+            The first row of the query results.
+        """
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+        async with self._with_cursor(connection) as cursor:
+            await cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            result = await cursor.fetchone()  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            result = self.check_not_found(result)
+            column_names = [c[0] for c in cursor.description or []]  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            if schema_type is None:
+                return dict(zip(column_names, result))  # pyright: ignore[reportUnknownArgumentType, reportUnknownVariableType]
+            return cast("ModelDTOT", schema_type(**dict(zip(column_names, result))))  # pyright: ignore[reportUnknownArgumentType]
+
+    async def select_one_or_none(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        connection: Optional["Connection"] = None,
+        schema_type: "Optional[type[ModelDTOT]]" = None,
+    ) -> "Optional[Union[ModelDTOT, dict[str, Any]]]":
+        """Fetch one row from the database.
+
+        Returns:
+            The first row of the query results.
+        """
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+        async with self._with_cursor(connection) as cursor:
+            await cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            result = await cursor.fetchone()  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            if result is None:
+                return None
+            column_names = [c[0] for c in cursor.description or []]  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            if schema_type is None:
+                return dict(zip(column_names, result))  # pyright: ignore[reportUnknownArgumentType, reportUnknownVariableType]
+            return cast("ModelDTOT", schema_type(**dict(zip(column_names, result))))  # pyright: ignore[reportUnknownArgumentType]
+
+    async def select_value(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        connection: "Optional[Connection]" = None,
+        schema_type: "Optional[type[T]]" = None,
+    ) -> "Union[T, Any]":
+        """Fetch a single value from the database.
+
+        Returns:
+            The first value from the first row of results, or None if no results.
+        """
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+        async with self._with_cursor(connection) as cursor:
+            await cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            result = await cursor.fetchone()  # pyright: ignore[reportUnknownMemberType]
+            result = self.check_not_found(result)
+            if schema_type is None:
+                return result[0]
+            return schema_type(result[0])  # type: ignore[call-arg]
+
+    async def select_value_or_none(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        /,
+        connection: "Optional[Connection]" = None,
+        schema_type: "Optional[type[T]]" = None,
+    ) -> "Optional[Union[T, Any]]":
+        """Fetch a single value from the database.
+
+        Returns:
+            The first value from the first row of results, or None if no results.
+        """
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+
+        async with self._with_cursor(connection) as cursor:
+            await cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            result = await cursor.fetchone()  # pyright: ignore[reportUnknownMemberType]
+            if result is None:
+                return None
+            if schema_type is None:
+                return result[0]
+            return schema_type(result[0])  # type: ignore[call-arg]
+
+    async def insert_update_delete(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        connection: Optional["Connection"] = None,
+    ) -> int:
+        """Insert, update, or delete data from the database.
+
+        Returns:
+            Row count affected by the operation.
+        """
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+
+        async with self._with_cursor(connection) as cursor:
+            await cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            return cursor.rowcount if hasattr(cursor, "rowcount") else -1  # pyright: ignore[reportUnknownVariableType, reportGeneralTypeIssues]
+
+    async def insert_update_delete_returning(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        connection: Optional["Connection"] = None,
+        schema_type: "Optional[type[ModelDTOT]]" = None,
+    ) -> "Optional[Union[dict[str, Any], ModelDTOT]]":
+        """Insert, update, or delete data from the database and return result.
+
+        Returns:
+            The first row of results.
+        """
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+
+        async with self._with_cursor(connection) as cursor:
+            await cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            results = list(await cursor.fetchall())  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            if not results:  # Check if empty
+                return None
+            column_names = [c[0] for c in cursor.description or []]  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            if schema_type is not None:
+                return cast("ModelDTOT", schema_type(**dict(zip(column_names, results[0]))))  # pyright: ignore[reportUnknownArgumentType, reportUnknownVariableType]
+            return dict(zip(column_names, results[0]))  # pyright: ignore[reportUnknownArgumentType, reportUnknownVariableType]
+
+    async def execute_script(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        connection: Optional["Connection"] = None,
+    ) -> str:
+        """Execute a script.
+
+        Returns:
+            Status message for the operation.
+        """
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+
+        async with self._with_cursor(connection) as cursor:
+            await cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            return "DONE"
+
+    async def execute_script_returning(
+        self,
+        sql: str,
+        parameters: Optional["StatementParameterType"] = None,
+        /,
+        connection: Optional["Connection"] = None,
+        schema_type: "Optional[type[ModelDTOT]]" = None,
+    ) -> "Optional[Union[dict[str, Any], ModelDTOT]]":
+        """Execute a script and return result.
+
+        Returns:
+            The first row of results.
+        """
+        connection = self._connection(connection)
+        sql, parameters = self._process_sql_params(sql, parameters)
+
+        async with self._with_cursor(connection) as cursor:
+            await cursor.execute(sql, parameters)  # pyright: ignore[reportUnknownMemberType]
+            results = list(await cursor.fetchall())  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            if not results:  # Check if empty
+                return None
+            column_names = [c[0] for c in cursor.description or []]  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+            if schema_type is not None:
+                return cast("ModelDTOT", schema_type(**dict(zip(column_names, results[0]))))  # pyright: ignore[reportUnknownArgumentType, reportUnknownVariableType]
+            return dict(zip(column_names, results[0]))  # pyright: ignore[reportUnknownArgumentType, reportUnknownVariableType]

sqlspec/adapters/asyncmy/__init__.py

@@ -1,3 +1,8 @@
-from sqlspec.adapters.asyncmy.config import AsyncMyConfig, AsyncmyPoolConfig
+from sqlspec.adapters.asyncmy.config import Asyncmy, AsyncmyPool
+from sqlspec.adapters.asyncmy.driver import AsyncmyDriver  # type: ignore[attr-defined]
 
-__all__ = ("AsyncMyConfig", "AsyncmyPoolConfig")
+__all__ = (
+    "Asyncmy",
+    "AsyncmyDriver",
+    "AsyncmyPool",
+)

sqlspec/adapters/asyncmy/config.py

@@ -1,23 +1,23 @@
 from contextlib import asynccontextmanager
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional, TypeVar, Union
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
 from asyncmy.connection import Connection  # pyright: ignore[reportUnknownVariableType]
-from asyncmy.pool import Pool  # pyright: ignore[reportUnknownVariableType]
 
+from sqlspec.adapters.asyncmy.driver import AsyncmyDriver  # type: ignore[attr-defined]
 from sqlspec.base import AsyncDatabaseConfig, GenericPoolConfig
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.typing import Empty, EmptyType, dataclass_to_dict
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator
-    from typing import Any
 
     from asyncmy.cursors import Cursor, DictCursor  # pyright: ignore[reportUnknownVariableType]
+    from asyncmy.pool import Pool  # pyright: ignore[reportUnknownVariableType]
 
 __all__ = (
-    "AsyncMyConfig",
-    "AsyncmyPoolConfig",
+    "Asyncmy",
+    "AsyncmyPool",
 )
 
 
@@ -25,7 +25,7 @@ T = TypeVar("T")
 
 
 @dataclass
-class AsyncmyPoolConfig(GenericPoolConfig):
+class AsyncmyPool(GenericPoolConfig):
     """Configuration for Asyncmy's connection pool.
 
     This class provides configuration options for Asyncmy database connection pools.
@@ -104,20 +104,42 @@ class AsyncmyPoolConfig(GenericPoolConfig):
 
 
 @dataclass
-class AsyncMyConfig(AsyncDatabaseConfig[Connection, Pool]):
+class Asyncmy(AsyncDatabaseConfig["Connection", "Pool", "AsyncmyDriver"]):
     """Asyncmy Configuration."""
 
     __is_async__ = True
     __supports_connection_pooling__ = True
 
-    pool_config: "Optional[AsyncmyPoolConfig]" = None
+    pool_config: "Optional[AsyncmyPool]" = None
     """Asyncmy Pool configuration"""
-
+    connection_type: "type[Connection]" = field(init=False, default_factory=lambda: Connection)  # pyright: ignore
+    """Type of the connection object"""
+    driver_type: "type[AsyncmyDriver]" = field(init=False, default_factory=lambda: AsyncmyDriver)
+    """Type of the driver object"""
     pool_instance: "Optional[Pool]" = None  # pyright: ignore[reportUnknownVariableType]
-    """Optional pool to use.
+    """Instance of the pool"""
 
-    If set, the plugin will use the provided pool rather than instantiate one.
-    """
+    @property
+    def connection_config_dict(self) -> "dict[str, Any]":
+        """Return the connection configuration as a dict.
+
+        Returns:
+            A string keyed dict of config kwargs for the Asyncmy connect function.
+
+        Raises:
+            ImproperConfigurationError: If the connection configuration is not provided.
+        """
+        if self.pool_config:
+            # Filter out pool-specific parameters
+            pool_only_params = {"minsize", "maxsize", "echo", "pool_recycle"}
+            return dataclass_to_dict(
+                self.pool_config,
+                exclude_empty=True,
+                convert_nested=False,
+                exclude=pool_only_params.union({"pool_instance", "driver_type", "connection_type"}),
+            )
+        msg = "You must provide a 'pool_config' for this adapter."
+        raise ImproperConfigurationError(msg)
 
     @property
     def pool_config_dict(self) -> "dict[str, Any]":
@@ -130,10 +152,32 @@ class AsyncMyConfig(AsyncDatabaseConfig[Connection, Pool]):
             ImproperConfigurationError: If the pool configuration is not provided.
         """
         if self.pool_config:
-            return dataclass_to_dict(self.pool_config, exclude_empty=True, convert_nested=False)
+            return dataclass_to_dict(
+                self.pool_config,
+                exclude_empty=True,
+                convert_nested=False,
+                exclude={"pool_instance", "driver_type", "connection_type"},
+            )
         msg = "'pool_config' methods can not be used when a 'pool_instance' is provided."
         raise ImproperConfigurationError(msg)
 
+    async def create_connection(self) -> "Connection":  # pyright: ignore[reportUnknownParameterType]
+        """Create and return a new asyncmy connection.
+
+        Returns:
+            A Connection instance.
+
+        Raises:
+            ImproperConfigurationError: If the connection could not be created.
+        """
+        try:
+            import asyncmy  # pyright: ignore[reportMissingTypeStubs]
+
+            return await asyncmy.connect(**self.connection_config_dict)  # pyright: ignore
+        except Exception as e:
+            msg = f"Could not configure the Asyncmy connection. Error: {e!s}"
+            raise ImproperConfigurationError(msg) from e
+
     async def create_pool(self) -> "Pool":  # pyright: ignore[reportUnknownParameterType]
         """Return a pool. If none exists yet, create one.
 
@@ -179,3 +223,20 @@ class AsyncMyConfig(AsyncDatabaseConfig[Connection, Pool]):
         pool = await self.provide_pool(*args, **kwargs)  # pyright: ignore[reportUnknownVariableType,reportUnknownMemberType]
         async with pool.acquire() as connection:  # pyright: ignore[reportUnknownMemberType,reportUnknownVariableType]
             yield connection  # pyright: ignore[reportUnknownMemberType]
+
+    @asynccontextmanager
+    async def provide_session(self, *args: "Any", **kwargs: "Any") -> "AsyncGenerator[AsyncmyDriver, None]":
+        """Create and provide a database session.
+
+        Yields:
+            An Asyncmy driver instance.
+
+        """
+        async with self.provide_connection(*args, **kwargs) as connection:  # pyright: ignore[reportUnknownVariableType]
+            yield self.driver_type(connection)  # pyright: ignore[reportUnknownArgumentType]
+
+    async def close_pool(self) -> None:
+        """Close the connection pool."""
+        if self.pool_instance is not None:  # pyright: ignore[reportUnknownMemberType]
+            await self.pool_instance.close()  # pyright: ignore[reportUnknownMemberType]
+            self.pool_instance = None