from collections.abc import AsyncGenerator, Generator, Callable, Coroutine
from typing import Any
import concurrent.futures as cf

type AENTER = Callable[[], Coroutine[Any, Any, AsyncGenerator[Any | None]]]
type AEXIT = Callable[[type[BaseException] | None, BaseException | None, object], Coroutine[Any, Any, bool]]

class ACTX[Y]:
    def __init__(self, g: AsyncGenerator[Y], f: cf.Future[None]) -> None:
        self.g = g
        self.f = f

    async def __aenter__(self) -> AsyncGenerator[Y]:
        return self.g

    async def __aexit__(
        self,
        exc_type: type[BaseException] | None,
        exc_value: BaseException | None,
        traceback: object,
    ) -> bool:
        if exc_value is not None:
            self.f.set_exception(exc_value)

        await self.g.aclose()
        return False


async def _a(ctx: ACTX[Any]) -> list[Any]:
    async with ctx as c:
        return [v async for v in c]
    return []


class ExecuteWrapper:
    def __init__(self, _c: ACTX[Any]):
        self._c = _c

    def __await__(self) -> Generator[Any, Any, list[Any]]:
        return _a(self._c).__await__()

    @property
    def __aenter__(self):
        return self._c.__aenter__
    
    @property
    def __aexit__(self):
        return self._c.__aexit__

    async def fetchone(self) -> Any | None:
        async with self as g:
            async for val in g:
                return val
        return None

from operator import attrgetter

class ExecuteWrapper:
    def __init__(self, _c: ACTX[Any]):
        self._c = _c

    def __await__(self) -> Generator[Any, Any, list[Any]]:
        return _a(self._c).__await__()

    __aenter__: AENTER = property(attrgetter("_c.__aenter__"))  # pyright: ignore[reportAssignmentType]
    __aexit__: AEXIT = property(attrgetter("_c.__aexit__"))  # pyright: ignore[reportAssignmentType]

    async def fetchone(self) -> Any | None:
        async with self as g:
            async for val in g:
                return val
        return None