anyio-cysqlite 0.1.0__tar.gz

anyio_cysqlite-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vizonex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

anyio_cysqlite-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: anyio-cysqlite
+Version: 0.1.0
+Summary: a anyio and cysqlite library
+Author-email: Vizonex <VizonexBusiness@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anyio>=4.13.0
+Requires-Dist: cysqlite>=0.3.2
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+<img src="https://raw.githubusercontent.com/Vizonex/anyio-cysqlite/main/anyio-cysqlite-logo.PNG"/>
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# anyio-cysqlite
+A Bidning for cysqlite that makes the database asynchronous
+with any asynchronous library that can be binded to anyio 
+meaning that it will work with many server implementations and applications including FastAPI, Starlette and Litestar to name a few server libraries.
+
+```python
+from anyio_cysqlite import connect
+
+
+async def main():
+    async with await connect("cysqlite.db") as db:
+        await db.execute('create table IF NOT EXISTS data (k, v)')
+
+        async with db.atomic():
+            await db.executemany('insert into data (k, v) values (?, ?)',
+                           [(f'k{i:02d}', f'v{i:02d}') for i in range(10)])
+            print(await db.last_insert_rowid())  # 10.
+
+        curs = await db.execute('select * from data')
+        async for row in curs:
+            print(row)  # e.g., ('k00', 'v00')
+
+        # We can use named parameters with a dict as well.
+        row = await db.execute_one('select * from data where k = :key and v = :val',
+                             {'key': 'k05', 'val': 'v05'})
+        print(row)  # ('k05', 'v05')
+
+        await db.close()
+
+if __name__ == "__main__":
+    import anyio
+    anyio.run(main)
+```
+
+## Updated functionality is better
+When it comes to database execution updated functionality normally results in better performance such as providing wrappers for `atomic`, `transaction`, and `savepoint` functions which the standard sqlite3 library doesn't currently have. Instead of having a completely seperate thread for the database all operations are done using the anyio's `CapacityLimiter` and `run_sync` making the database less resource heavy.
+
+
+## Batteries included
+Unlike cysqlite (As of currently), this library retains access to typehints right out of the box making the library less of a function and attribute guessing game.
+
+
+
+
+

anyio_cysqlite-0.1.0/README.md

@@ -0,0 +1,49 @@
+<img src="https://raw.githubusercontent.com/Vizonex/anyio-cysqlite/main/anyio-cysqlite-logo.PNG"/>
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# anyio-cysqlite
+A Bidning for cysqlite that makes the database asynchronous
+with any asynchronous library that can be binded to anyio 
+meaning that it will work with many server implementations and applications including FastAPI, Starlette and Litestar to name a few server libraries.
+
+```python
+from anyio_cysqlite import connect
+
+
+async def main():
+    async with await connect("cysqlite.db") as db:
+        await db.execute('create table IF NOT EXISTS data (k, v)')
+
+        async with db.atomic():
+            await db.executemany('insert into data (k, v) values (?, ?)',
+                           [(f'k{i:02d}', f'v{i:02d}') for i in range(10)])
+            print(await db.last_insert_rowid())  # 10.
+
+        curs = await db.execute('select * from data')
+        async for row in curs:
+            print(row)  # e.g., ('k00', 'v00')
+
+        # We can use named parameters with a dict as well.
+        row = await db.execute_one('select * from data where k = :key and v = :val',
+                             {'key': 'k05', 'val': 'v05'})
+        print(row)  # ('k05', 'v05')
+
+        await db.close()
+
+if __name__ == "__main__":
+    import anyio
+    anyio.run(main)
+```
+
+## Updated functionality is better
+When it comes to database execution updated functionality normally results in better performance such as providing wrappers for `atomic`, `transaction`, and `savepoint` functions which the standard sqlite3 library doesn't currently have. Instead of having a completely seperate thread for the database all operations are done using the anyio's `CapacityLimiter` and `run_sync` making the database less resource heavy.
+
+
+## Batteries included
+Unlike cysqlite (As of currently), this library retains access to typehints right out of the box making the library less of a function and attribute guessing game.
+
+
+
+
+

anyio_cysqlite-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "anyio-cysqlite"
+dynamic = ["version"]
+description = "a anyio and cysqlite library"
+readme = "README.md"
+authors = [
+    { name = "Vizonex", email = "VizonexBusiness@gmail.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "anyio>=4.13.0",
+    "cysqlite>=0.3.2",
+]
+
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[tool.setuptools.dynamic]
+version = {attr = "anyio_cysqlite.__version__"}
+
+[build-system]
+requires = ["setuptools"]
+
+[tool.ruff]
+line-length = 79
+indent-width = 4
+target-version = "py310"
+fix = true
+
+[tool.ruff.lint]
+select = [
+    "I",
+    "E"
+]
+ignore = [
+    "F405",
+]

anyio_cysqlite-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

anyio_cysqlite-0.1.0/src/anyio_cysqlite/__init__.py

@@ -0,0 +1,23 @@
+from .db import (
+    Atomic,
+    Connection,
+    Cursor,
+    Savepoint,
+    Transaction,
+    connect,
+    exception_logger,
+)
+
+__version__ = "0.1.0"
+__author__ = "Vizonex"
+__license__ = "MIT"
+
+__all__ = (
+    "Atomic",
+    "Connection",
+    "Cursor",
+    "Savepoint",
+    "Transaction",
+    "connect",
+    "exception_logger",
+)

anyio_cysqlite-0.1.0/src/anyio_cysqlite/db.py

@@ -0,0 +1,499 @@
+import sys
+from collections import deque
+from collections.abc import Awaitable, Callable, Sequence
+from functools import partial, wraps
+from logging import Logger, getLogger
+from pathlib import Path
+from types import TracebackType
+from typing import Any
+
+import cysqlite
+from anyio import CapacityLimiter
+from anyio.to_thread import run_sync
+from cysqlite._cysqlite import Cursor as _Cursor
+
+from .typedefs import (
+    P,
+    T,
+    _Atomic,
+    _IsolationLevel,
+    _Parameters,
+    _Savepoint,
+    _Transaction,
+)
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self  # pragma: nocover
+
+if sys.version_info >= (3, 13):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
+Ts = TypeVarTuple("Ts", default=())
+
+SENTINEL = object()
+
+
+class AsyncAction:
+    """helper for handling other wrappers like atomic,
+    savepoint and transaction"""
+
+    __slots__ = ("_real", "_limiter")
+
+    async def __aenter__(self):
+        await run_sync(self._real.__enter__, limiter=self._limiter)
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ):
+        return await run_sync(
+            self._real.__exit__, exc_type, exc, tb, limiter=self._limiter
+        )
+
+    def __call__(
+        self, func: Callable[P, Awaitable[T]]
+    ) -> Callable[P, Awaitable[T]]:
+        """wraps function to the database note:
+        it's limited to non-async generators"""
+
+        @wraps(func)
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+            async with self:
+                return await func(*args, **kwargs)
+
+        return wrapper
+
+    async def run(
+        self, func: Callable[[Unpack[Ts]], Awaitable[T]], *args: Unpack[Ts]
+    ) -> T:
+        """
+        Custom function that Runs context manager inside a function without
+        having to setup a wrapper when database is not outside of a main
+        funciton
+        """
+        async with self:
+            return await func(*args)
+
+
+class Transaction(AsyncAction):
+    def __init__(self, real: _Transaction, limiter: CapacityLimiter):
+        self._real = real
+        self._limiter = limiter
+
+    async def commit(self, begin: bool = True) -> None:
+        await run_sync(self._real.commit, begin, limiter=self._limiter)
+
+    async def rollback(self, begin: bool = True) -> None:
+        await run_sync(self._real.rollback, begin, limiter=self._limiter)
+
+
+class Savepoint(AsyncAction):
+    def __init__(self, real: _Savepoint, limiter: CapacityLimiter):
+        self._real = real
+        self._limiter = limiter
+
+    async def commit(self, begin: bool = True):
+        await run_sync(self._real.commit, begin, limiter=self._limiter)
+
+    async def rollback(self):
+        await run_sync(self._real.rollback, limiter=self._limiter)
+
+
+class Atomic(AsyncAction):
+    def __init__(self, real: _Atomic, limiter: CapacityLimiter):
+        self._real = real
+        self._limiter = limiter
+
+    async def commit(self, begin: bool = True):
+        await run_sync(self._real.commit, begin, limiter=self._limiter)
+
+    # it varies. hence *args and not begin: bool = True
+    async def rollback(self, *args):
+        await run_sync(self._real.rollback, *args, limiter=self._limiter)
+
+
+# inspired by sqlite-anyio with a few of my own tweaks
+
+
+class Cursor:
+    def __init__(
+        self,
+        real_cursor: _Cursor,
+        limiter: CapacityLimiter,
+        exception_handler: Callable[
+            [type[BaseException], BaseException, TracebackType, Logger], bool
+        ]
+        | None,
+        log: Logger,
+    ) -> None:
+        self._real_cursor = real_cursor
+        self._limiter = limiter
+        self._exception_handler = exception_handler
+        self._log = log
+
+        # Deques can maker iterating a bit faster over the
+        # standard list object as linked lists are known to speed
+        # things up.
+        self._buffer: deque[Any | cysqlite.Row] = deque()
+
+    @property
+    def description(self) -> tuple[tuple[str, ...], ...] | None:
+        return self._real_cursor.description
+
+    @property
+    def lastrowid(self) -> int | None:
+        return self._real_cursor.lastrowid
+
+    @property
+    def rowcount(self) -> int:
+        return self._real_cursor.rowcount
+
+    async def close(self) -> None:
+        await run_sync(self._real_cursor.close, limiter=self._limiter)
+
+    async def execute(
+        self, sql: str, parameters: Sequence[_Parameters] = (), /
+    ) -> Self:
+        await run_sync(
+            self._real_cursor.execute, sql, parameters, limiter=self._limiter
+        )
+        return self
+
+    async def executemany(
+        self, sql: str, parameters: Sequence[_Parameters], /
+    ) -> Self:
+        await run_sync(
+            self._real_cursor.executemany,
+            sql,
+            parameters,
+            limiter=self._limiter,
+        )
+        return self
+
+    async def fetchall(self) -> list[tuple[Any, ...]]:
+        return await run_sync(
+            self._real_cursor.fetchall, limiter=self._limiter
+        )
+
+    async def fetchone(self) -> cysqlite.Row | None:
+        return await run_sync(
+            self._real_cursor.fetchone, limiter=self._limiter
+        )
+
+    async def scalar(self) -> Any:
+        return await run_sync(self._real_cursor.scalar, limiter=self._limiter)
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
+        await self.close()
+        if exc_val is None:
+            return None
+
+        assert exc_type is not None
+        assert exc_val is not None
+        assert exc_tb is not None
+        exception_handled = False
+        if self._exception_handler is not None:
+            exception_handled = self._exception_handler(
+                exc_type, exc_val, exc_tb, self._log
+            )
+        return exception_handled
+
+    async def fetchmany(self, size: int = 100) -> list[cysqlite.Row | Any]:
+        # next part comes form cysqlite/aio.py
+        def _fetch():
+            rows = []
+            for _ in range(size):
+                try:
+                    rows.append(self._real_cursor.__next__())
+                except StopIteration:
+                    break
+            return rows
+
+        return await run_sync(_fetch)
+
+    def __aiter__(self) -> Self:
+        return self
+
+    async def __anext__(self) -> Any | cysqlite.Row:
+        if not self._buffer:
+            self._buffer.extend(await self.fetchmany())
+            if not self._buffer:
+                raise StopAsyncIteration
+        return self._buffer.popleft()
+
+
+class Connection:
+    def __init__(
+        self,
+        real_connection: cysqlite.Connection,
+        exception_handler: Callable[
+            [type[BaseException], BaseException, TracebackType, Logger], bool
+        ]
+        | None = None,
+        log: Logger | None = None,
+    ) -> None:
+        self._conn = real_connection
+        self._exception_handler = exception_handler
+        self._log = log or getLogger(__name__)
+        self._limiter = CapacityLimiter(1)
+
+    def _cursor_factory(self, cursor: _Cursor) -> "Cursor":
+        return Cursor(
+            cursor,
+            self._limiter,
+            exception_handler=self._exception_handler,
+            log=self._log,
+        )
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
+        await self.close()
+
+        if exc_val is None:
+            return None
+
+        assert exc_type is not None
+        assert exc_val is not None
+        assert exc_tb is not None
+
+        exception_handled = False
+        if self._exception_handler is not None:
+            exception_handled = self._exception_handler(
+                exc_type, exc_val, exc_tb, self._log
+            )
+        return exception_handled
+
+    async def backup(
+        self,
+        dest: "Connection",
+        pages: int | None = None,
+        name: str | None = None,
+        progress: Callable[[int, int, bool], None] | None = None,
+        src_name: str | None = None,
+    ) -> None:
+        return await run_sync(
+            self._conn.backup,
+            dest._conn,
+            pages,
+            name,
+            progress,
+            src_name,
+        )
+
+    async def backup_to_file(
+        self,
+        filename: str,
+        pages: int | None = None,
+        name: str | None = None,
+        progress: Callable[[int, int, bool], None] | None = None,
+        src_name: str | None = None,
+    ) -> None:
+        await run_sync(
+            self._conn.backup_to_file,
+            filename,
+            pages,
+            name,
+            progress,
+            src_name,
+        )
+
+    async def begin(self, lock: _IsolationLevel = None) -> None:
+        await run_sync(self._conn.begin, lock, limiter=self._limiter)
+
+    async def execute(
+        self, sql: str, parameters: _Parameters | None = None, /
+    ) -> "Cursor":
+        cursor = await run_sync(
+            self._conn.execute,
+            sql,
+            parameters,
+            limiter=self._limiter,
+        )
+        return self._cursor_factory(cursor)
+
+    async def executemany(
+        self, sql: str, seq_of_params: Sequence[_Parameters] | None = None
+    ) -> "Cursor":
+        cursor = await run_sync(self._conn.executemany, sql, seq_of_params)
+        return self._cursor_factory(cursor)
+
+    async def executescript(self, sql: str) -> "Cursor":
+        cursor = await run_sync(self._conn.executescript, sql)
+        return self._cursor_factory(cursor)
+
+    async def close(self) -> None:
+        await run_sync(self._conn.close, limiter=self._limiter)
+
+    async def checkpoint(
+        self,
+        full: bool = False,
+        truncate: bool = False,
+        restart: bool = False,
+        name: str | None = None,
+    ) -> tuple[int, int]:
+        return await run_sync(
+            self._conn.checkpoint, full, truncate, restart, name
+        )
+
+    async def commit(self) -> None:
+        await run_sync(self._conn.commit, limiter=self._limiter)
+
+    async def rollback(self) -> None:
+        await run_sync(self._conn.rollback, limiter=self._limiter)
+
+    async def cursor(self) -> "Cursor":
+        return self._cursor_factory(
+            await run_sync(self._conn.cursor, limiter=self._limiter)
+        )
+
+    async def execute_one(self, sql: str, params: _Parameters | None = None):
+        return await run_sync(self._conn.execute_one, sql, params)
+
+    async def execute_scalar(
+        self, sql: str, params: _Parameters | None = None
+    ):
+        return await run_sync(self._conn.execute_scalar, sql, params)
+
+    async def autocommit(self) -> int:
+        return await run_sync(self._conn.autocommit)
+
+    def atomic(self) -> Atomic:
+        """Opens a new atomic function, this can be used
+        as both an async wrapper or wrappable function"""
+        return Atomic(self._conn.atomic(), self._limiter)
+
+    def savepoint(self, sid: str | None = None) -> Savepoint:
+        """Opens a new savepoint, this can be used
+        as both an async wrapper or wrappable function"""
+        return Savepoint(self._conn.savepoint(sid), self._limiter)
+
+    def transaction(self, lock: _IsolationLevel = None):
+        """Opens a new transaction, this can be used
+        as both an async wrapper or wrappable function"""
+        return Transaction(self._conn.transaction(lock), self._limiter)
+
+    async def last_insert_rowid(self) -> int:
+        return await run_sync(self._conn.last_insert_rowid)
+
+    @property
+    def in_transaction(self):
+        return self._conn.in_transaction
+
+    async def status(self, flag: int) -> tuple[int, int]:
+        return await run_sync(self._conn.status, flag)
+
+    async def pragma(
+        self,
+        key: str,
+        value: Any = SENTINEL,
+        database: str | None = None,
+        multi: bool = False,
+        permanent: bool = False,
+    ) -> Any:
+        if value != SENTINEL:
+            return await run_sync(
+                self._conn.pragma, key, value, database, multi, permanent
+            )
+        else:
+            # just make value empty we have a different SENTINEL anyways...
+            return await run_sync(
+                partial(
+                    self._conn.pragma,
+                    key=key,
+                    database=database,
+                    multi=multi,
+                    permanent=permanent,
+                )
+            )
+
+
+async def connect(
+    database: str | Path,
+    flags: int | None = None,
+    timeout: float = 5.0,
+    vfs: str | None = None,
+    uri: bool = False,
+    cached_statements: int = 100,
+    extensions: bool = True,
+    row_factory: Callable[..., "cysqlite.Row"] | None = None,
+    autoconnect: bool = True,
+    log: Logger | None = None,
+    exception_handler: Callable[
+        [type[BaseException], BaseException, TracebackType, Logger], bool
+    ]
+    | None = None,
+) -> Connection:
+    """
+    Open a Connection to the provided database.
+
+    :param database:  database filename or ':memory:'
+        for an in-memory database.
+    :type database: str | pathlib.Path
+    :param flags: control how database is opened. See Sqlite Connection Flags.
+    :type flags: int | None
+    :param timeout: seconds to retry acquiring write lock before raising a
+        OperationalError when table is locked.
+    :type timeout: float
+    :param vfs: VFS to use, optional.
+    :type vfs: str | None
+    :param uri: Allow connecting using a URI.
+    :type uri: bool
+    :param cached_statements: Size of statement cache.
+    :type cached_statements: int
+    :param extensions: Support run-time loadable extensions.
+    :type extensions: bool
+    :param row_factory: Factory implementation for constructing rows, e.g. Row
+    :type row_factory: Callable[..., _T] | None
+    :param autoconnect: Open connection when initiated
+    :type autoconnect: bool
+    :rtype: Connection
+    :returns: Connection to database under an anyio asynchronous wrapper
+    """
+    conn = await run_sync(
+        partial(
+            cysqlite.connect,
+            database=str(database),
+            flags=flags,
+            timeout=timeout,
+            vfs=vfs,
+            uri=uri,
+            cached_statements=cached_statements,
+            extensions=extensions,
+            row_factory=row_factory or cysqlite.Row,
+            autoconnect=autoconnect,
+        )
+    )
+    return Connection(conn, exception_handler, log)
+
+
+def exception_logger(
+    exc_type: type[BaseException] | None,
+    exc_val: BaseException | None,
+    exc_tb: TracebackType | None,
+    log: Logger,
+) -> bool:
+    """An exception handler that logs the exception and discards it."""
+    log.error("SQLite exception", exc_info=exc_val)
+    return True  # the exception was handled

anyio_cysqlite-0.1.0/src/anyio_cysqlite/typedefs.py

@@ -0,0 +1,116 @@
+import sys
+import types
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Mapping, Sequence
+from pathlib import Path
+from typing import Any, Literal, ParamSpec, TypeAlias, TypeVar
+
+import cysqlite
+from cysqlite.metadata import *
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+else:
+    from typing_extensions import Buffer
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+# cysqlite maintainer currently shows Zero intrest in the idea
+# of utilizing typehints so that users don't have to second guess
+# and validate code so we must do everything ourselves
+# luckily, sqlite3 has a typeshed stubfile with pleantly of helpful information
+# that we can safely utilize.
+
+_SqliteData: TypeAlias = str | Buffer | int | float | None
+_AdaptedInputData: TypeAlias = _SqliteData | Any
+_Parameters: TypeAlias = (
+    Sequence[_AdaptedInputData] | Mapping[str, _AdaptedInputData]
+)
+_IsolationLevel: TypeAlias = (
+    Literal["DEFERRED", "EXCLUSIVE", "IMMEDIATE"] | None
+)
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+# Cysqlite doesn't have good typehints avalible yet so we have to do a bit
+# Of hacking ourselves, The most optimal solution was to make
+# mimics of the function signatures as abstract classes to get around the issue
+# SEE: https://github.com/coleifer/cysqlite/issues/1
+
+# NOTE: in 0.3.1+ coleifer and cysqlite maintainers takes my advice seriously.
+
+
+# Know that these ABCs are not perfect but they try their best to typehint as a
+# workaround
+# this very bad issue.
+
+
+class _callable_context_manager(ABC):
+    @abstractmethod
+    def __call__(self, fn: Callable[P, T]) -> Callable[P, T]: ...
+
+
+class _Atomic(_callable_context_manager):
+    @abstractmethod
+    def __init__(
+        self, conn: "cysqlite.Connection", lock: _IsolationLevel | str = None
+    ) -> None: ...
+    @abstractmethod
+    def __enter__(self) -> Self: ...
+    @abstractmethod
+    def __exit__(
+        self,
+        type: type[BaseException] | None,
+        value: BaseException | None,
+        traceback: types.TracebackType | None,
+    ) -> bool | None: ...
+
+    @abstractmethod
+    def commit(self, begin: bool = True) -> None: ...
+    @abstractmethod
+    def rollback(self, begin: bool = True) -> None: ...
+
+
+class _Savepoint(_callable_context_manager):
+    @abstractmethod
+    def __init__(
+        self, conn: "cysqlite.Connection", sid: str | None = None
+    ) -> None: ...
+    @abstractmethod
+    def commit(self, begin: bool = True) -> None: ...
+    @abstractmethod
+    def rollback(self) -> None: ...
+    @abstractmethod
+    def __enter__(self) -> Self: ...
+    @abstractmethod
+    def __exit__(
+        self,
+        type: type[BaseException] | None,
+        value: BaseException | None,
+        traceback: types.TracebackType | None,
+    ) -> bool | None: ...
+
+
+class _Transaction(_callable_context_manager):
+    @abstractmethod
+    def __init__(
+        self, conn: "cysqlite.Connection", lock: _IsolationLevel = None
+    ) -> None: ...
+    @abstractmethod
+    def commit(self, begin: bool = True) -> None: ...
+    @abstractmethod
+    def rollback(self, begin: bool = True) -> None: ...
+    @abstractmethod
+    def __enter__(self) -> Self: ...
+    @abstractmethod
+    def __exit__(
+        self,
+        type: type[BaseException] | None,
+        value: BaseException | None,
+        traceback: types.TracebackType | None,
+    ) -> bool | None: ...

anyio_cysqlite-0.1.0/src/anyio_cysqlite.egg-info/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: anyio-cysqlite
+Version: 0.1.0
+Summary: a anyio and cysqlite library
+Author-email: Vizonex <VizonexBusiness@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anyio>=4.13.0
+Requires-Dist: cysqlite>=0.3.2
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+<img src="https://raw.githubusercontent.com/Vizonex/anyio-cysqlite/main/anyio-cysqlite-logo.PNG"/>
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# anyio-cysqlite
+A Bidning for cysqlite that makes the database asynchronous
+with any asynchronous library that can be binded to anyio 
+meaning that it will work with many server implementations and applications including FastAPI, Starlette and Litestar to name a few server libraries.
+
+```python
+from anyio_cysqlite import connect
+
+
+async def main():
+    async with await connect("cysqlite.db") as db:
+        await db.execute('create table IF NOT EXISTS data (k, v)')
+
+        async with db.atomic():
+            await db.executemany('insert into data (k, v) values (?, ?)',
+                           [(f'k{i:02d}', f'v{i:02d}') for i in range(10)])
+            print(await db.last_insert_rowid())  # 10.
+
+        curs = await db.execute('select * from data')
+        async for row in curs:
+            print(row)  # e.g., ('k00', 'v00')
+
+        # We can use named parameters with a dict as well.
+        row = await db.execute_one('select * from data where k = :key and v = :val',
+                             {'key': 'k05', 'val': 'v05'})
+        print(row)  # ('k05', 'v05')
+
+        await db.close()
+
+if __name__ == "__main__":
+    import anyio
+    anyio.run(main)
+```
+
+## Updated functionality is better
+When it comes to database execution updated functionality normally results in better performance such as providing wrappers for `atomic`, `transaction`, and `savepoint` functions which the standard sqlite3 library doesn't currently have. Instead of having a completely seperate thread for the database all operations are done using the anyio's `CapacityLimiter` and `run_sync` making the database less resource heavy.
+
+
+## Batteries included
+Unlike cysqlite (As of currently), this library retains access to typehints right out of the box making the library less of a function and attribute guessing game.
+
+
+
+
+

anyio_cysqlite-0.1.0/src/anyio_cysqlite.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/anyio_cysqlite/__init__.py
+src/anyio_cysqlite/db.py
+src/anyio_cysqlite/py.typed
+src/anyio_cysqlite/typedefs.py
+src/anyio_cysqlite.egg-info/PKG-INFO
+src/anyio_cysqlite.egg-info/SOURCES.txt
+src/anyio_cysqlite.egg-info/dependency_links.txt
+src/anyio_cysqlite.egg-info/requires.txt
+src/anyio_cysqlite.egg-info/top_level.txt
+tests/test_context_manager.py

anyio_cysqlite-0.1.0/src/anyio_cysqlite.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

anyio_cysqlite-0.1.0/src/anyio_cysqlite.egg-info/requires.txt

@@ -0,0 +1,5 @@
+anyio>=4.13.0
+cysqlite>=0.3.2
+
+[test]
+pytest

anyio_cysqlite-0.1.0/src/anyio_cysqlite.egg-info/top_level.txt

@@ -0,0 +1 @@
+anyio_cysqlite

anyio_cysqlite-0.1.0/tests/test_context_manager.py

@@ -0,0 +1,108 @@
+import logging
+
+import cysqlite
+import pytest
+
+import anyio_cysqlite
+
+
+async def test_context_manager_commit(anyio_backend):
+    mem_uri = f"file:{anyio_backend}_mem0?mode=memory&cache=shared"
+    async with await anyio_cysqlite.connect(mem_uri, uri=True) as acon0:
+        async with acon0.atomic():
+            await acon0.execute(
+                "CREATE TABLE IF NOT EXISTS lang(id INTEGER PRIMARY KEY,"
+                " name VARCHAR UNIQUE)"
+            )
+            await acon0.execute(
+                "INSERT INTO lang(name) VALUES(?)", ("Python",)
+            )
+
+        # Reason we don't open a new connection is due to how cysqlite
+        # handles memory. Otherwise the test with sqlite-anyio would be
+        # 1 to 1
+        acur1 = await acon0.cursor()
+        await acur1.execute("SELECT name FROM lang")
+        assert await acur1.fetchone() == ("Python",)
+        await acur1.execute("DROP TABLE IF EXISTS lang;")
+
+
+async def test_context_manager_execute(anyio_backend):
+    mem_uri = f"file:{anyio_backend}_mem0?mode=memory&cache=shared"
+    async with await anyio_cysqlite.connect(mem_uri, uri=True) as acon0:
+        await acon0.execute(
+            "CREATE TABLE lang(id INTEGER PRIMARY KEY, name VARCHAR UNIQUE)"
+        )
+        await acon0.execute("INSERT INTO lang(name) VALUES(?)", ("Python",))
+
+        acur1 = await acon0.cursor()
+        await acur1.execute("SELECT name FROM lang")
+        assert await acur1.fetchone() == ("Python",)
+        await acur1.execute("DROP TABLE IF EXISTS lang;")
+
+
+async def test_context_manager_rollback(anyio_backend):
+    mem_uri = f"file:{anyio_backend}_mem1?mode=memory&cache=shared"
+    with pytest.raises(RuntimeError):
+        async with await anyio_cysqlite.connect(mem_uri, uri=True) as acon0:
+            acur0 = await acon0.cursor()
+            await acur0.execute(
+                "CREATE TABLE lang(id INTEGER PRIMARY KEY,"
+                " name VARCHAR UNIQUE)"
+            )
+            await acur0.execute(
+                "INSERT INTO lang(name) VALUES(?)", ("Python",)
+            )
+            raise RuntimeError("foo")
+
+    async with await anyio_cysqlite.connect(mem_uri, uri=True) as db:
+        await db.execute("DROP TABLE IF EXISTS lang;")
+
+
+async def test_cursor_context_manager(anyio_backend, caplog):
+    caplog.set_level(logging.INFO)
+    mem_uri = f"file:{anyio_backend}_mem2?mode=memory&cache=shared"
+    log = logging.getLogger("logger")
+    async with await anyio_cysqlite.connect(
+        mem_uri,
+        uri=True,
+        exception_handler=anyio_cysqlite.exception_logger,
+        log=log,
+    ) as acon0:
+        async with await acon0.cursor() as acur0:
+            await acur0.execute(
+                "CREATE TABLE lang(id INTEGER PRIMARY KEY,"
+                " name VARCHAR UNIQUE)"
+            )
+
+        with pytest.raises(cysqlite.ProgrammingError):
+            await acur0.execute(
+                "INSERT INTO lang(name) VALUES(?)", ("Python",)
+            )
+
+        async with await acon0.cursor() as acur1:
+            await acur1.execute("SELECT name FROM lang")
+            assert await acur1.fetchone() is None
+            await acur1.execute("INSERT INTO foo(name) VALUES(?)", ("Python",))
+
+    assert "SQLite exception" in caplog.text
+
+
+async def test_exception_logger(anyio_backend, caplog):
+    caplog.set_level(logging.INFO)
+    mem_uri = f"file:{anyio_backend}_mem3?mode=memory&cache=shared"
+    log = logging.getLogger("logger")
+    async with await anyio_cysqlite.connect(
+        mem_uri,
+        uri=True,
+        exception_handler=anyio_cysqlite.exception_logger,
+        log=log,
+    ) as acon0:
+        acur0 = await acon0.cursor()
+        await acur0.execute(
+            "CREATE TABLE lang(id INTEGER PRIMARY KEY, name VARCHAR UNIQUE)"
+        )
+        await acur0.execute("INSERT INTO lang(name) VALUES(?)", ("Python",))
+        raise RuntimeError("foo")
+
+    assert "SQLite exception" in caplog.text