dinao 2.2.0.dev178__tar.gz → 2.2.0.dev182__tar.gz

{dinao-2.2.0.dev178/dinao.egg-info → dinao-2.2.0.dev182}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dinao
-Version: 2.2.0.dev178
+Version: 2.2.0.dev182
 Summary: A simple database API
 Author-email: Jim Carreer <jim.carreer+dinao@gmail.com>
 License-Expression: ISC
@@ -24,6 +24,7 @@ Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-asyncio; extra == "tests"
 Requires-Dist: pytest-cov; extra == "tests"
+Requires-Dist: aiosqlite; extra == "tests"
 Requires-Dist: asyncpg; extra == "tests"
 Requires-Dist: psycopg2-binary; extra == "tests"
 Requires-Dist: psycopg[binary]; extra == "tests"

dinao-2.2.0.dev182/dinao/__version__.py

@@ -0,0 +1,2 @@
+# noqa: D100
+__version__ = "2.2.0.dev182"

{dinao-2.2.0.dev178 → dinao-2.2.0.dev182}/dinao/backend/__init__.py

@@ -21,7 +21,7 @@ from dinao.backend.postgres import (
     ConnectionPoolPSQLPsycopg2,
     ConnectionPoolPSQLPsycopg3,
 )
-from dinao.backend.sqlite import ConnectionPoolSQLite3
+from dinao.backend.sqlite import AsyncConnectionPoolAiosqlite, ConnectionPoolSQLite3
 
 ENGINE_DEFAULTS = {"postgresql": "psycopg2", "sqlite3": None, "mariadb": "mariadbconnector", "mysql": "mysqlconnector"}
 MODE_DEFAULTS = {
@@ -29,6 +29,7 @@ MODE_DEFAULTS = {
     ("postgresql", "psycopg"): "sync",
     ("postgresql", "asyncpg"): "async",
     ("sqlite3", None): "sync",
+    ("sqlite3", "aiosqlite"): "async",
     ("mariadb", "mariadbconnector"): "sync",
     ("mysql", "mysqlconnector"): "sync",
 }
@@ -94,6 +95,10 @@ def create_connection_pool(db_url: str) -> ConnectionPoolBase:
         if mode == "async":
             return AsyncConnectionPoolPSQLPsycopg3(db_url)
         return ConnectionPoolPSQLPsycopg3(db_url)
+    if backend == "sqlite3" and engine == "aiosqlite":
+        if mode == "sync":
+            raise UnsupportedBackendError("The aiosqlite driver does not support sync mode")
+        return AsyncConnectionPoolAiosqlite(db_url)
     if backend == "sqlite3":
         if mode == "async":
             raise UnsupportedBackendError("The sqlite3 backend does not support async mode")

dinao-2.2.0.dev182/dinao/backend/sqlite/__init__.py

@@ -0,0 +1,9 @@
+"""Implementation of SQLite backends."""
+
+from dinao.backend.sqlite.aiosqlite import AsyncConnectionPoolAiosqlite
+from dinao.backend.sqlite.stdlib import ConnectionPoolSQLite3
+
+__all__ = [
+    "AsyncConnectionPoolAiosqlite",
+    "ConnectionPoolSQLite3",
+]

dinao-2.2.0.dev182/dinao/backend/sqlite/aiosqlite.py

@@ -0,0 +1,96 @@
+"""Implementation of SQLite backend using aiosqlite."""
+
+from contextlib import asynccontextmanager
+
+from dinao.backend.base import AsyncConnection, AsyncConnectionPool, AsyncResultSet
+from dinao.backend.errors import BackendNotInstalledError
+from dinao.backend.sqlite.base import ConnectionPoolSQLiteMixin
+from dinao.mung import StaticMungSymbolProvider
+
+
+class ConnectionAiosqlite(AsyncConnection):
+    """Async Connection implementation wrapping an aiosqlite connection."""
+
+    async def _execute(self, cursor, sql: str, params: tuple = None):
+        """Execute SQL on the given cursor with optional parameters."""
+        if params:
+            await cursor.execute(sql, params)
+            return
+        await cursor.execute(sql)
+
+    @asynccontextmanager
+    async def query(self, sql: str, params: tuple = None):
+        """Execute the given SQL as a statement with the given parameters. Provide the results as context.
+
+        Overrides the base class because the aiosqlite ``connection.cursor()`` is a coroutine.
+
+        :param sql: the SQL statement(s) to execute
+        :param params: the values to bind to the execution of the given SQL
+        :returns: an async result set representing the query's results
+        """
+        cursor = await self._cnx.cursor()
+        await self._execute(cursor, sql, params)
+        try:
+            yield AsyncResultSet(cursor)
+        finally:
+            await cursor.close()
+
+    async def execute(self, sql: str, params: tuple = None, commit: bool = None) -> int:
+        """Execute the given SQL and return the affected row count.
+
+        Overrides the base class because the aiosqlite ``connection.cursor()`` is a coroutine.
+
+        :param sql: the SQL statement(s) to execute
+        :param params: the values to bind to the execution of the given SQL
+        :param commit: commit the changes after execution, defaults to value given in constructor
+        """
+        commit = commit if commit is not None else self._auto_commit
+        cursor = await self._cnx.cursor()
+        await self._execute(cursor, sql, params)
+        affected = cursor.rowcount
+        if commit:
+            await self.commit()
+        await cursor.close()
+        return affected
+
+
+class AsyncConnectionPoolAiosqlite(ConnectionPoolSQLiteMixin, AsyncConnectionPool):
+    """Async ConnectionPool implementation for aiosqlite."""
+
+    _mung_symbol = StaticMungSymbolProvider("?")
+
+    def __init__(self, db_url: str):
+        """Construct an async connection pool for the given connection URL.
+
+        The db_url is expected to be in the following format::
+
+            "sqlite3+aiosqlite://{filename}"
+
+        This is not a real pool; each call to ``lease()`` creates a new connection.
+
+        :param db_url: a url with the described format
+        :raises: ConfigurationError, BackendNotInstalledError
+        """
+        super().__init__(db_url)
+        try:
+            import aiosqlite  # noqa: F401
+        except ModuleNotFoundError:  # pragma: no cover
+            raise BackendNotInstalledError("Module aiosqlite not installed, cannot create async connection pool")
+        self._cnx_kwargs = self._url_to_cnx_kwargs()
+        self._raise_for_unexpected_args()
+
+    async def lease(self):  # noqa: D102
+        import aiosqlite
+
+        inner_cnx = await aiosqlite.connect(**self._cnx_kwargs)
+        return ConnectionAiosqlite(inner_cnx)
+
+    async def release(self, cnx):  # noqa: D102
+        await cnx._cnx.close()
+
+    async def dispose(self):  # noqa: D102
+        return
+
+    @property
+    def mung_symbol(self) -> StaticMungSymbolProvider:  # noqa: D102
+        return self._mung_symbol

dinao-2.2.0.dev182/dinao/backend/sqlite/base.py

@@ -0,0 +1,15 @@
+"""Shared base classes for SQLite backends."""
+
+import os.path
+
+
+class ConnectionPoolSQLiteMixin:
+    """Mixin providing shared SQLite URL parsing and connection kwargs construction."""
+
+    def _url_to_cnx_kwargs(self):
+        """Parse the URL and construct connection keyword arguments.
+
+        :returns: a dictionary of connection keyword arguments
+        """
+        file_path = os.path.abspath(os.path.expanduser(self._db_url.path))
+        return {"database": file_path}

dinao-2.2.0.dev178/dinao/backend/sqlite.py → dinao-2.2.0.dev182/dinao/backend/sqlite/stdlib.py

@@ -1,9 +1,9 @@
-"""Implementation of SQLite backends."""
+"""Implementation of SQLite backend using sqlite3."""
 
-import os.path
 import sqlite3
 
 from dinao.backend.base import Connection, ConnectionPool
+from dinao.backend.sqlite.base import ConnectionPoolSQLiteMixin
 from dinao.mung import StaticMungSymbolProvider
 
 
@@ -11,13 +11,14 @@ class ConnectionSQLite3(Connection):
     """Implementation of Connection for Sqlite3."""
 
     def _execute(self, cursor, sql: str, params: tuple = None):
+        """Execute SQL on the given cursor with optional parameters."""
         if params:
             cursor.execute(sql, params)
             return
         cursor.execute(sql)
 
 
-class ConnectionPoolSQLite3(ConnectionPool):
+class ConnectionPoolSQLite3(ConnectionPoolSQLiteMixin, ConnectionPool):
     """Implementation of ConnectionPool for SQLite3."""
 
     _mung_symbol = StaticMungSymbolProvider("?")
@@ -38,10 +39,6 @@ class ConnectionPoolSQLite3(ConnectionPool):
         self._cnx_kwargs = self._url_to_cnx_kwargs()
         self._raise_for_unexpected_args()
 
-    def _url_to_cnx_kwargs(self):
-        file_path = os.path.abspath(os.path.expanduser(self._db_url.path))
-        return {"database": file_path}
-
     def lease(self) -> Connection:  # noqa: D102
         inner_cnx = sqlite3.connect(**self._cnx_kwargs)
         return ConnectionSQLite3(inner_cnx)

{dinao-2.2.0.dev178 → dinao-2.2.0.dev182}/dinao/binding/mappers.py

@@ -69,10 +69,25 @@ class ClassRowMapper(DictRowMapper):
 class SingleValueRowMapper(RowMapper):
     """Implements a row mapper for a primitive type."""
 
+    def __init__(self, mapped_type: typing.Type):
+        """Construct a single value row mapper that casts the result to the target type.
+
+        :param mapped_type: the primitive type to cast the result to
+        """
+        self._mapped_type = mapped_type
+
     def __call__(self, row: typing.Tuple, description: typing.Tuple[ColumnDescriptor, ...]):  # noqa: D102
         if len(row) > 1:
             raise TooManyValuesError(f"Too many values, expected 1, got {len(row)}")
-        return row[0]
+        value = row[0]
+        if value is None:
+            return None
+        if isinstance(value, self._mapped_type):
+            return value
+        # SQLite special case, we should consider better adapter handling
+        if self._mapped_type is datetime and isinstance(value, str):
+            return datetime.fromisoformat(value)
+        return self._mapped_type(value)
 
 
 def get_row_mapper(row_type: typing.Type) -> typing.Optional[RowMapper]:
@@ -92,7 +107,7 @@ def get_row_mapper(row_type: typing.Type) -> typing.Optional[RowMapper]:
     elif row_type in DICT_GENERICS:
         return DictRowMapper()
     elif row_type in NATIVE_SINGLE:
-        return SingleValueRowMapper()
+        return SingleValueRowMapper(row_type)
     # Exclude typing special forms that look like classes in Python 3.14+
     # Bare Union/Optional without type parameters cannot be mapped
     elif row_type in TYPING_SPECIAL_FORMS:

{dinao-2.2.0.dev178 → dinao-2.2.0.dev182/dinao.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dinao
-Version: 2.2.0.dev178
+Version: 2.2.0.dev182
 Summary: A simple database API
 Author-email: Jim Carreer <jim.carreer+dinao@gmail.com>
 License-Expression: ISC
@@ -24,6 +24,7 @@ Provides-Extra: tests
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-asyncio; extra == "tests"
 Requires-Dist: pytest-cov; extra == "tests"
+Requires-Dist: aiosqlite; extra == "tests"
 Requires-Dist: asyncpg; extra == "tests"
 Requires-Dist: psycopg2-binary; extra == "tests"
 Requires-Dist: psycopg[binary]; extra == "tests"

{dinao-2.2.0.dev178 → dinao-2.2.0.dev182}/dinao.egg-info/SOURCES.txt

@@ -15,12 +15,15 @@ dinao/backend/base.py
 dinao/backend/errors.py
 dinao/backend/mariadb.py
 dinao/backend/mysql.py
-dinao/backend/sqlite.py
 dinao/backend/postgres/__init__.py
 dinao/backend/postgres/asyncpg.py
 dinao/backend/postgres/base.py
 dinao/backend/postgres/psycopg2.py
 dinao/backend/postgres/psycopg3.py
+dinao/backend/sqlite/__init__.py
+dinao/backend/sqlite/aiosqlite.py
+dinao/backend/sqlite/base.py
+dinao/backend/sqlite/stdlib.py
 dinao/binding/__init__.py
 dinao/binding/errors.py
 dinao/binding/mappers.py

{dinao-2.2.0.dev178 → dinao-2.2.0.dev182}/dinao.egg-info/requires.txt

@@ -18,6 +18,7 @@ pyspelling>=2.12.1
 pytest
 pytest-asyncio
 pytest-cov
+aiosqlite
 asyncpg
 psycopg2-binary
 psycopg[binary]

{dinao-2.2.0.dev178 → dinao-2.2.0.dev182}/pyproject.toml

@@ -31,6 +31,7 @@ tests = [
     "pytest",
     "pytest-asyncio",
     "pytest-cov",
+    "aiosqlite",
     "asyncpg",
     "psycopg2-binary",
     "psycopg[binary]",

dinao-2.2.0.dev178/dinao/__version__.py

@@ -1,2 +0,0 @@
-# noqa: D100
-__version__ = "2.2.0.dev178"