# Source code for apsw.aio

    "Implements async framework controllers, configuration, and helpers"

    from __future__ import annotations

    import contextlib
    import contextvars
    import logging
    import math
    import queue
    import sys
    import threading
    import time
    from collections.abc import Callable, Coroutine
    from typing import Any, TypeVar

    import apsw

    logger = logging.getLogger(__name__)

    T = TypeVar("T")

    deadline: contextvars.ContextVar[int | float | None] = contextvars.ContextVar("apsw.aio.deadline", default=None)
    """Absolute time deadline for a request in seconds

    This makes a best effort to timeout a database operation including any
    sync and async callbacks if the deadline is passed.  The default
    (``None``) is no deadline.

    The deadline is set at the point an APSW call is made, and changes
    after that are not observed.  It is based on the clock used by the
    event loop.  Typical usage is:

    .. code-block:: python

        # 10 seconds from now.  You'll need to get the time from your
        # framework as documented below.

        with apsw.aio.contextvar_set(apsw.aio.deadline,
            anyio.current_time() + 10):

            async for row in await db.execute("time consuming query ..."):
                print(f"{row=}")

    :class:`AsyncIO`

        :code:`apsw.aio.deadline` is the only way to set a deadline.
        :exc:`TimeoutError` will
        be raised if the deadline is exceeded.  The current time is
        available from  :meth:`asyncio.get_running_loop().time()
        <asyncio.loop.time>`

    :class:`Trio`

        If :code:`apsw.aio.deadline` is set then it is used for the
        deadline.  :exc:`trio.TooSlowError` is raised.  The current time
        is available from :func:`trio.current_time`.

        Otherwise the :func:`trio.current_effective_deadline` where the
        call is made is used.

    AnyIO

        If :code:`apsw.aio.deadline` is set then it is used for the
        deadline.  :exc:`TimeoutError` is raised.  The current time is
        available from :func:`anyio.current_time`.

        Otherwise the :func:`anyio.current_effective_deadline` where the
        call is made is used.

    """

    check_progress_steps: contextvars.ContextVar[int] = contextvars.ContextVar(
        "apsw.aio.check_progress_steps", default=50_000
    )
    """How many internal SQLite steps between checks for cancellation and deadlines

    While SQLite queries are executing, periodic checks are made to see if
    the request has been cancelled, or the deadline exceeded.  This is
    done in the :meth:`progress handler
    <apsw.Connection.set_progress_handler>`.

    The default should correspond to around 10 checks per second, but will
    vary a lot based on the queries.  The smaller the number, the more
    frequent the checks, but also more time consumed making the checks.

    This is only used during connection creation.  Typical usage is:

    .. code-block:: python

        with apsw.aio.contextvar_set(apsw.aio.check_progress_steps, 500):
            db = await apsw.Connection.as_async(...)
    """

    if sys.version_info >= (3, 14):

        def contextvar_set(var: contextvars.ContextVar[T], value: T) -> contextvars.Token[T]:
            """Wrapper for setting a :class:`~contextvars.ContextVar` during a :code:`with` block

            Python 3.14+ lets you do::

                with var.set(value):
                    # code here
                    ...

            This wrapper provides the same functionality for all
            Python versions::

                with apsw.aio.contextvar_set(var, value):
                    # code here
                    ...

            """
            return var.set(value)

    else:

        def contextvar_set(var: contextvars.ContextVar[T], value: T) -> contextvars.Token[T]:
            @contextlib.contextmanager
            def _contextvar_set_wrapper():
                token = var.set(value)
                try:
                    yield token
                finally:
                    var.reset(token)

            return _contextvar_set_wrapper()

    async def make_session(db: apsw.AsyncConnection, schema: str) -> apsw.AsyncSession:
        "Helper to create a :class:`~apsw.Session` in async mode for an async database"
        # This mainly exists to give IDEs and type checkers the clues they need
        if not hasattr(apsw, "Session"):
            # misuse is what SQLite uses
            raise apsw.MisuseError("The session extension is not enabled and available")
        return await db.async_run(apsw.Session, db, schema)

    class _Cancelled(BaseException):
        """
        Raised in the worker thread on seeing call cancellation.

        The original caller in async will get their framework's
        cancellation exception - this is just to terminate call processing
        back through the call stacks
        """

        pass

    # this is used to track the currently processing call for all controllers
    # as _tls.current_call
    _tls = threading.local()

    class _CallTracker:
        """
        All the details for the lifecycle of a call.
        """

        __slots__ = (
            # Used for result ready.  asyncio uses Future which also
            # includes the result/exception, while trio/anyio use the
            # result/is_exception fields
            "completion",
            # result value or exception
            "result",
            # is it an exception?
            "is_exception",
            # BoxedCall to make
            "call",
            # deadline in event loop clock
            "deadline_loop",
            # deadline in worker thread relative to monotonic clock
            "deadline_monotonic",
            # cancel indication
            "is_cancelled",
            # if a callback is async and run back in the event loop then
            # this can be called to cancel it
            "cancel_async_cb",
        )

        completion: asyncio.Future | anyio.Event | trio.Event
        result: Any | BaseException
        is_exception: bool
        call: Callable[[], Any]
        deadline_loop: None | float | int
        deadline_monotonic: None | float | int
        is_cancelled: bool
        cancel_async_cb: Callable[[], Any] | None

        def __init__(self, completion: asyncio.Event | anyio.Event | trio.Event, call: Callable[[], Any]) -> None:
            self.is_exception = False
            self.is_cancelled = False
            self.completion = completion
            self.call = call
            self.deadline_loop = None
            self.deadline_monotonic = None
            self.cancel_async_cb = None

        def set_deadline(self, value: int | float, loop_time: int | float):
            self.deadline_loop = value
            if value is not math.inf:
                self.deadline_monotonic = value - loop_time + time.monotonic()

        def monotonic_exceeded(self) -> bool:
            return self.deadline_monotonic is not None and time.monotonic() > self.deadline_monotonic

        def cancel(self):
            "Cancel the call"

            self.is_cancelled = True
            if self.cancel_async_cb is not None:
                self.cancel_async_cb()

    # These are used to directly return values and exceptions without
    # sending to the worker thread such as prefetched query rows.
    async def _coro_for_value(value):
        return value

    if sys.version_info < (3, 12):
        # Python 3.12 unified the exc type, value, and traceback into the single
        # exception object.

        async def _coro_for_exception(exc):
            raise exc[0](exc[1]).with_traceback(exc[2])

    else:

        async def _coro_for_exception(exc):
            raise exc

    # this is separate to avoid the version issues above
    async def _coro_for_stopasynciteration():
        raise StopAsyncIteration

    class AsyncIO:
        """:class:`Controller <apsw.AsyncConnectionController>` for :mod:`asyncio`"""

        def configure(self, db: apsw.Connection):
            "Setup database, just after it is created"
            apsw.async_run_coro = self.async_run_coro

            for hook in apsw.connection_hooks:
                hook(db)
            db.set_progress_handler(self.progress_checker, check_progress_steps.get(), id=self)

        async def send(self, call: Callable[[], Any]):
            "Send call to worker"
            tracker = _CallTracker(self.loop.create_future(), call)
            if (this_deadline := deadline.get()) is not None:
                tracker.set_deadline(this_deadline, self.loop.time())
            self.queue.put(tracker)
            try:
                await tracker.completion
                return tracker.completion.result()
            except:
                tracker.cancel()
                raise

        def close(self):
            "Called on connection close, so the worker thread can be stopped"
            # How we tell the worker thread to exit
            self.queue.put(None)

        def progress_checker(self):
            "Periodic check for cancellation and deadlines"
            if _tls.current_call.is_cancelled:
                raise _Cancelled("cancelled in progress checked")
            if _tls.current_call.monotonic_exceeded():
                raise TimeoutError()
            return False

        def worker_thread_run(self):
            "Does the enqueued call processing in the worker thread"

            q = self.queue

            while (tracker := q.get()) is not None:
                if not tracker.is_cancelled:
                    # we don't restore this because the queue is not
                    # re-entrant, so there is no point
                    _tls.current_call = tracker

                    try:
                        # should we even start?
                        if tracker.monotonic_exceeded():
                            raise TimeoutError()
                        self.loop.call_soon_threadsafe(self.set_future_result, tracker.completion, tracker.call())

                    except BaseException as exc:
                        # BaseException is deliberately used because CancelledError
                        # is a subclass of it
                        self.loop.call_soon_threadsafe(self.set_future_exception, tracker.completion, exc)

        def set_future_result(self, future: asyncio.Future, value: Any):
            if not future.done():
                future.set_result(value)

        def set_future_exception(self, future: asyncio.Future, exc: BaseException):
            if not future.done():
                future.set_exception(exc)

        def async_run_coro(self, coro: Coroutine):
            "Called in worker thread to run a coroutine in the event loop"

            tracker = _tls.current_call

            try:
                if tracker.is_cancelled:
                    raise _Cancelled("cancelled in async_run_coro")

                return asyncio.run_coroutine_threadsafe(
                    self.run_coro_in_loop(coro, tracker, contextvars.copy_context()), self.loop
                ).result()

            finally:
                coro.close()

        if sys.version_info < (3, 11):

            async def run_coro_in_loop(self, coro: Coroutine, tracker: _CallTracker, context: contextvars.Context) -> Any:
                "Executes the coro in the event loop"

                task = context.run(asyncio.create_task, coro)
                tracker.cancel_async_cb = task.cancel
                if tracker.is_cancelled:
                    return

                if tracker.deadline_loop is not None:
                    return await asyncio.wait_for(task, tracker.deadline_loop - self.loop.time())
                return await task

        elif sys.version_info < (3, 12):

            async def run_coro_in_loop(self, coro: Coroutine, tracker: _CallTracker, context: contextvars.Context) -> Any:
                "Executes the coro in the event loop"

                task = context.run(asyncio.create_task, coro)
                tracker.cancel_async_cb = task.cancel
                if tracker.is_cancelled:
                    return

                async with asyncio.timeout_at(tracker.deadline_loop):
                    return await task

        else:

            async def run_coro_in_loop(self, coro: Coroutine, tracker: _CallTracker, context: contextvars.Context) -> Any:
                "Executes the coro in the event loop"

                # Note: we don't set cancel_async_cb back to None on exit
                # because cancelling an already completed task is doesn't
                # error or cause problems.

                task = asyncio.create_task(coro, context=context)
                tracker.cancel_async_cb = task.cancel
                if tracker.is_cancelled:
                    return

                async with asyncio.timeout_at(tracker.deadline_loop):
                    return await task

        def __init__(self, *, thread_name: str = "asyncio apsw background worker"):
            global asyncio
            import asyncio

            self.queue: queue.SimpleQueue[_CallTracker | None] = queue.SimpleQueue()
            self.loop = asyncio.get_running_loop()
            threading.Thread(name=thread_name, target=self.worker_thread_run).start()

    class Trio:
        """:class:`Controller <apsw.AsyncConnectionController>` for |trio|"""

        def configure(self, db: apsw.Connection):
            "Setup database, just after it is created"
            apsw.async_run_coro = self.async_run_coro

            for hook in apsw.connection_hooks:
                hook(db)
            db.set_progress_handler(self.progress_checker, check_progress_steps.get(), id=self)

        async def send(self, call: Callable[[], Any]):
            "Enqueues call to worker thread"
            tracker = _CallTracker(trio.Event(), call)
            if (this_deadline := deadline.get()) is None:
                this_deadline = trio.current_effective_deadline()
            tracker.set_deadline(this_deadline, trio.current_time())

            self.queue.put(tracker)
            try:
                await tracker.completion.wait()
                if tracker.is_exception:
                    raise tracker.result
                return tracker.result
            except:
                tracker.cancel()
                raise

        def close(self):
            "Called on connection close, so the worker thread can be stopped"
            self.queue.put(None)

        def progress_checker(self):
            "Periodic check for cancellation and deadlines"
            if _tls.current_call.is_cancelled:
                raise _Cancelled("cancelled in progress handler")
            if _tls.current_call.monotonic_exceeded():
                raise trio.TooSlowError("deadline exceeded in progress handler")
            return False

        def worker_thread_run(self):
            "Does the enqueued call processing in the worker thread"
            q = self.queue

            while (tracker := q.get()) is not None:
                if not tracker.is_cancelled:
                    # we don't restore this because the queue is not
                    # re-entrant, so there is no point
                    _tls.current_call = tracker

                    try:
                        # should we even start?
                        if tracker.monotonic_exceeded():
                            raise trio.TooSlowError()
                        tracker.result = tracker.call()

                    except BaseException as exc:
                        # BaseException is deliberately used because Cancelled
                        # is a subclass of it
                        tracker.result = exc
                        tracker.is_exception = True

                    finally:
                        self.token.run_sync_soon(tracker.completion.set)

        def async_run_coro(self, coro: Coroutine):
            "Called in worker thread to run a coroutine in the event loop"
            try:
                tracker = _tls.current_call
                if tracker.is_cancelled:
                    raise _Cancelled("Cancelled in async_run_coro")

                return trio.from_thread.run(self.run_coro_in_loop, coro, tracker, trio_token=self.token)
            finally:
                coro.close()

        async def run_coro_in_loop(self, coro: Coroutine, tracker: _CallTracker):
            "Executes the coro in the event loop"
            with trio.fail_at(deadline=math.inf if tracker.deadline_loop is None else tracker.deadline_loop) as scope:
                tracker.cancel_async_cb = scope.cancel
                if tracker.is_cancelled:
                    return
                return await coro

        def __init__(self, *, thread_name: str = "trio apsw background worker"):
            global trio
            import trio

            self.queue: queue.SimpleQueue[_CallTracker | None] = queue.SimpleQueue()
            self.token = trio.lowlevel.current_trio_token()
            threading.Thread(name=thread_name, target=self.worker_thread_run).start()

    class AnyIO:
        """:class:`Controller <apsw.AsyncConnectionController>` for |anyio|"""

        def configure(self, db: apsw.Connection):
            "Setup database, just after it is created"
            apsw.async_run_coro = self.async_run_coro

            for hook in apsw.connection_hooks:
                hook(db)
            db.set_progress_handler(self.progress_checker, check_progress_steps.get(), id=self)

        async def send(self, call: Callable[[], Any]):
            "Enqueues call to worker thread"

            tracker = _CallTracker(anyio.Event(), call)
            if (this_deadline := deadline.get()) is None:
                this_deadline = anyio.current_effective_deadline()
            tracker.set_deadline(this_deadline, anyio.current_time())

            self.queue.put(tracker)
            try:
                await tracker.completion.wait()
                if tracker.is_exception:
                    raise tracker.result
                return tracker.result
            except:
                tracker.cancel()
                raise

        def close(self):
            "Called on connection close, so the worker thread can be stopped"
            self.queue.put(None)

        def progress_checker(self):
            "Periodic check for cancellation and deadlines"
            tracker = _tls.current_call
            if tracker.is_cancelled:
                raise _Cancelled("cancelled in progress handler")
            if tracker.monotonic_exceeded():
                raise TimeoutError("deadline exceeded in progress handler")
            return False

        def worker_thread_run(self):
            "Does the enqueued call processing in the worker thread"
            q = self.queue

            while (tracker := q.get()) is not None:
                if not tracker.is_cancelled:
                    # we don't restore this because the queue is not
                    # re-entrant, so there is no point
                    _tls.current_call = tracker

                    try:
                        # should we even start?
                        if tracker.monotonic_exceeded():
                            raise TimeoutError("Deadline exceeded in queue")
                        tracker.result = tracker.call()

                    except BaseException as exc:
                        # BaseException is deliberately used because CancelledError
                        # is a subclass of it
                        tracker.result = exc
                        tracker.is_exception = True

                    finally:
                        anyio.from_thread.run_sync(tracker.completion.set, token=self.token)

        def async_run_coro(self, coro: Coroutine):
            "Called in worker thread to run a coroutine in the event loop"

            try:
                tracker = _tls.current_call
                if tracker.is_cancelled:
                    raise _Cancelled("Cancelled in async_run_coro")
                if tracker.monotonic_exceeded():
                    raise TimeoutError("deadline exceeded in async_run_coro")
                return anyio.from_thread.run(self.run_coro_in_loop, coro, tracker, token=self.token)
            finally:
                coro.close()

        async def run_coro_in_loop(self, coro: Coroutine, tracker: _CallTracker):
            "Executes coro in the event loop"

            with anyio.fail_after(
                math.inf if tracker.deadline_loop is None else tracker.deadline_loop - anyio.current_time()
            ) as scope:
                tracker.cancel_async_cb = scope.cancel
                if tracker.is_cancelled:
                    return
                return await coro

        def __init__(self, *, thread_name: str = "anyio apsw background worker"):
            global anyio
            import anyio

            self.queue: queue.SimpleQueue[_CallTracker | None] = queue.SimpleQueue()
            self.token = anyio.lowlevel.current_token()
            threading.Thread(name=thread_name, target=self.worker_thread_run).start()

    # True means they can be tried, False means too old etc
    _anyio_usable = True
    _trio_usable = True

    def Auto() -> Trio | AsyncIO | AnyIO:
        """
        Automatically detects the current async framework running event
        loop and returns the appropriate controller.  This is the default
        for :attr:`apsw.async_controller`.

        **AnyIO note**

            The :class:`AnyIO` controller is only returned if
            :func:`anyio.run` is in the call stack.

            If you are simultaneously using anyio and another framework
            then you should manually configure
            :attr:`apsw.async_controller` to get the one you want.

            This matters especially for timeouts and cancellations where
            each framework is different.

        :exc:`RuntimeError` is raised if the framework can't be detected.

        """
        global _anyio_usable, _trio_usable
        # This variable tracks which class to use.  It is instantiated
        # outside of the try/except blocks so exceptions in its
        # initialization will be raised.
        found = None

        if found is None and "anyio" in sys.modules and _anyio_usable:
            try:
                import anyio

                # this checks if an anyio supported event loop is running
                # but anyio works with asyncio/trio as the loop ...
                anyio.get_current_task()

                # ... so we need to check if anyio.run is in the call stack
                anyio_run_code = anyio.run.__code__

                frame = sys._getframe()
                while frame:
                    if frame.f_code is anyio_run_code:
                        found = AnyIO
                        break
                    frame = frame.f_back

                if found:
                    found = None
                    # check its version is ok
                    import importlib.metadata
                    ver = tuple(map(int, importlib.metadata.version("anyio").split(".")))
                    if  ver >= (4, 11, 0):
                        found = AnyIO
                    else:
                        logger.error(f"anyio {ver} was found but is too old to be used with the AnyIO controller")
                        _anyio_usable = False

            except:
                pass

        if found is None and "trio" in sys.modules and _trio_usable:
            try:
                import trio

                trio.lowlevel.current_trio_token()

                # check its version is ok
                import importlib.metadata
                ver = tuple(map(int, importlib.metadata.version("trio").split(".")))
                if  ver >= (0, 20, 0):
                    found = Trio
                else:
                    logger.error(f"trio {ver=} was found but is too old to be used with the Trio controller")
                    _trio_usable = False

            except:
                pass

        if found is None and "asyncio" in sys.modules:
            try:
                import asyncio

                asyncio.get_running_loop()
                found = AsyncIO
            except:
                pass

        if not found:
            raise RuntimeError("Unable to determine current Async environment")

        return found()