omextra 0.0.0.dev514__py3-none-any.whl → 0.0.0.dev516__py3-none-any.whl

omextra/asyncs/all.py

@@ -0,0 +1,18 @@
+from .flavors import (  # noqa
+    ContextManagerAdapter,
+    Flavor,
+    adapt,
+    adapt_context,
+    from_anyio,
+    from_anyio_context,
+    from_asyncio,
+    from_asyncio_context,
+    from_trio,
+    from_trio_context,
+    get_flavor,
+    mark_anyio,
+    mark_asyncio,
+    mark_flavor,
+    mark_trio,
+    with_adapter_loop,
+)

omextra/asyncs/bridge.py

@@ -41,7 +41,7 @@ import weakref
 
 from omlish import check
 from omlish import lang
-from omlish import sync
+from omlish.sync import all as sync
 from omlish.concurrent import threadlets
 
 

omextra/asyncs/flavors.py

@@ -0,0 +1,229 @@
+"""
+Tools for working with the different async loop implementations - currently anyio, asyncio, trio.
+
+TODO:
+ - mark whole class / module?
+"""
+import abc
+import dataclasses as dc
+import enum
+import functools
+import typing as ta
+
+from omlish import lang
+from omlish.asyncs.trio_asyncio import check_trio_asyncio
+from omlish.asyncs.trio_asyncio import with_trio_asyncio_loop
+
+
+if ta.TYPE_CHECKING:
+    import sniffio
+    import trio_asyncio
+else:
+    sniffio = lang.proxy_import('sniffio')
+    trio_asyncio = lang.proxy_import('trio_asyncio')
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+_FLAVOR_ATTR = '__async_flavor__'
+
+
+class _MISSING(lang.Marker):
+    pass
+
+
+class Flavor(enum.Enum):
+    ASYNCIO = enum.auto()
+    TRIO = enum.auto()
+    ANYIO = enum.auto()
+
+
+def mark_flavor(f: Flavor):
+    if not isinstance(f, Flavor):
+        raise TypeError(f)
+
+    def inner(fn):
+        setattr(fn, _FLAVOR_ATTR, f)
+        return fn
+
+    return inner
+
+
+mark_asyncio = mark_flavor(Flavor.ASYNCIO)
+mark_anyio = mark_flavor(Flavor.ANYIO)
+mark_trio = mark_flavor(Flavor.TRIO)
+
+PACKAGE_FLAVORS: ta.MutableMapping[str, Flavor] = {
+    'anyio': Flavor.ANYIO,
+    'asyncio': Flavor.ASYNCIO,
+    'trio': Flavor.TRIO,
+
+    'sqlalchemy.ext.asyncio': Flavor.ASYNCIO,
+}
+
+_MODULE_FLAVOR_CACHE: dict[str, Flavor | None] = {}
+
+
+def _get_module_flavor(p: str) -> Flavor | None:
+    try:
+        return _MODULE_FLAVOR_CACHE[p]
+    except KeyError:
+        pass
+
+    pf: Flavor | None = None
+    for cp, cf in PACKAGE_FLAVORS.items():
+        if p.startswith(cp) and (len(cp) == len(p) or p[len(cp)] == '.'):
+            pf = cf
+            break
+
+    _MODULE_FLAVOR_CACHE[p] = pf
+    return pf
+
+
+def get_flavor(obj: ta.Any, default: Flavor | type[_MISSING] | None = _MISSING) -> Flavor:
+    u = lang.unwrap_func(obj)
+
+    try:
+        return getattr(u, _FLAVOR_ATTR)
+    except AttributeError:
+        pass
+
+    if (mn := getattr(u, '__module__', None)) is not None:
+        if (pf := _get_module_flavor(mn)):
+            return pf
+
+    if default is not _MISSING:
+        return default  # type: ignore
+
+    raise TypeError(f'not marked with flavor: {obj}')
+
+
+##
+
+
+def with_adapter_loop(*, wait=False):
+    def outer(fn):
+        @functools.wraps(fn)
+        async def inner(*args, **kwargs):
+            cur_lib = sniffio.current_async_library()
+
+            if cur_lib == 'asyncio':
+                await fn(*args, **kwargs)
+
+            elif cur_lib == 'trio':
+                await with_trio_asyncio_loop(wait=wait)(fn)(*args, **kwargs)
+
+            else:
+                raise RuntimeError(f'Unknown async library: {cur_lib}')
+
+        return inner
+
+    return outer
+
+
+##
+
+
+class Adapter(lang.Abstract):
+    _FROM_METHODS_BY_FLAVOR: ta.ClassVar[ta.Mapping[Flavor, str]] = {
+        Flavor.ANYIO: 'from_anyio',
+        Flavor.ASYNCIO: 'from_asyncio',
+        Flavor.TRIO: 'from_trio',
+    }
+
+    def adapt(self, fn, fl=None):
+        if fl is None:
+            fl = get_flavor(fn)
+        return getattr(self, self._FROM_METHODS_BY_FLAVOR[fl])(fn)
+
+    #
+
+    def from_anyio(self, fn):
+        return fn
+
+    @abc.abstractmethod
+    def from_asyncio(self, fn):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def from_trio(self, fn):
+        raise NotImplementedError
+
+
+class AsyncioAdapter(Adapter):
+    def from_asyncio(self, fn):
+        return fn
+
+    def from_trio(self, fn):
+        check_trio_asyncio()
+        return trio_asyncio.trio_as_aio(fn)
+
+
+class TrioAdapter(Adapter):
+    def from_asyncio(self, fn):
+        check_trio_asyncio()
+        return trio_asyncio.aio_as_trio(fn)
+
+    def from_trio(self, fn):
+        return fn
+
+
+_ADAPTERS_BY_BACKEND: ta.Mapping[str, Adapter] = {
+    'asyncio': AsyncioAdapter(),
+    'trio': TrioAdapter(),
+}
+
+
+def get_adapter() -> Adapter:
+    return _ADAPTERS_BY_BACKEND[sniffio.current_async_library()]
+
+
+def adapt(fn, fl=None):
+    return get_adapter().adapt(fn, fl)
+
+
+def from_anyio(fn):
+    return get_adapter().from_anyio(fn)
+
+
+def from_asyncio(fn):
+    return get_adapter().from_asyncio(fn)
+
+
+def from_trio(fn):
+    return get_adapter().from_trio(fn)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ContextManagerAdapter(ta.Generic[T]):
+    obj: ta.AsyncContextManager[T]
+    adapt: ta.Callable[[ta.Callable], ta.Callable]
+
+    async def __aenter__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return await self.adapt(self.obj.__aenter__)(*args, **kwargs)
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        return await self.adapt(self.obj.__aexit__)(exc_type, exc_val, exc_tb)
+
+
+def adapt_context(obj):
+    return ContextManagerAdapter(obj, get_adapter().adapt)
+
+
+def from_anyio_context(obj):
+    return ContextManagerAdapter(obj, get_adapter().from_anyio)
+
+
+def from_asyncio_context(obj):
+    return ContextManagerAdapter(obj, get_adapter().from_asyncio)
+
+
+def from_trio_context(obj):
+    return ContextManagerAdapter(obj, get_adapter().from_trio)

omextra/io/trampoline.py

@@ -6,7 +6,7 @@ import typing as ta
 from omlish import check
 from omlish import lang
 from omlish.concurrent import threadlets as tls
-from omlish.sync import ConditionDeque
+from omlish.sync.conddeque import ConditionDeque
 
 
 if ta.TYPE_CHECKING:

omextra/sql/alchemy/__init__.py

@@ -0,0 +1,9 @@
+from .asyncs import (  # noqa
+    AsyncConnection,
+    AsyncConnectionLike,
+    AsyncEngine,
+    AsyncEngineLike,
+    AsyncTransaction,
+    AsyncTransactionLike,
+    async_adapt,
+)

omextra/sql/alchemy/asyncs.py

@@ -0,0 +1,154 @@
+"""
+TODO:
+ - Maysync impls?
+ - base Protocol so adapters and real sa impls can be used interchangeably (if in asyncio ctx)?
+"""
+import contextlib
+import typing as ta
+
+import sqlalchemy as sa
+import sqlalchemy.ext.asyncio as saa
+
+from ...asyncs import all as au
+
+
+T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
+
+
+AsyncEngineLike: ta.TypeAlias = ta.Union[saa.AsyncEngine, 'AsyncEngine']
+AsyncConnectionLike: ta.TypeAlias = ta.Union[saa.AsyncConnection, 'AsyncConnection']
+AsyncTransactionLike: ta.TypeAlias = ta.Union[saa.AsyncTransaction, 'AsyncTransaction']
+
+
+##
+
+
+class AsyncTransaction:
+    def __init__(self, underlying: saa.AsyncTransaction) -> None:
+        super().__init__()
+
+        self._underlying = underlying
+
+    @property
+    def underlying(self) -> saa.AsyncTransaction:
+        return self._underlying
+
+    ##
+
+    @au.mark_asyncio
+    async def close(self) -> None:
+        await au.from_asyncio(self._underlying.close)()
+
+    @au.mark_asyncio
+    async def rollback(self) -> None:
+        await au.from_asyncio(self._underlying.rollback)()
+
+    @au.mark_asyncio
+    async def commit(self) -> None:
+        await au.from_asyncio(self._underlying.commit)()
+
+
+class AsyncConnection:
+    def __init__(self, underlying: saa.AsyncConnection) -> None:
+        super().__init__()
+
+        self._underlying = underlying
+
+    @property
+    def underlying(self) -> saa.AsyncConnection:
+        return self._underlying
+
+    ##
+
+    @contextlib.asynccontextmanager
+    @au.mark_asyncio
+    async def begin(self) -> ta.AsyncIterator[AsyncTransaction]:
+        async with au.from_asyncio_context(self._underlying.begin()) as u:
+            yield AsyncTransaction(u)
+
+    @au.mark_asyncio
+    async def execute(
+            self,
+            statement: ta.Any,
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> sa.CursorResult[ta.Any]:
+        return await au.from_asyncio(self._underlying.execute)(statement, *args, **kwargs)
+
+    @au.mark_asyncio
+    async def run_sync(
+            self,
+            fn: ta.Callable[ta.Concatenate[sa.Connection, P], T],
+            *args: P.args,
+            **kwargs: P.kwargs,
+    ) -> T:
+        return await au.from_asyncio(self._underlying.run_sync)(fn, *args, **kwargs)
+
+
+class AsyncEngine:
+    def __init__(self, underlying: saa.AsyncEngine) -> None:
+        super().__init__()
+
+        self._underlying = underlying
+
+    @property
+    def underlying(self) -> saa.AsyncEngine:
+        return self._underlying
+
+    ##
+
+    @contextlib.asynccontextmanager
+    @au.mark_asyncio
+    async def connect(self) -> ta.AsyncIterator[AsyncConnection]:
+        async with au.from_asyncio_context(self._underlying.connect()) as u:
+            yield AsyncConnection(u)
+
+    @au.mark_asyncio
+    async def dispose(self, close: bool = True) -> None:
+        await au.from_asyncio(self._underlying.dispose)(close)
+
+
+##
+
+
+@ta.overload
+def async_adapt(obj: AsyncEngine) -> AsyncEngine:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: AsyncConnection) -> AsyncConnection:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: AsyncTransaction) -> AsyncTransaction:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: saa.AsyncEngine) -> AsyncEngine:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: saa.AsyncConnection) -> AsyncConnection:
+    ...
+
+
+@ta.overload
+def async_adapt(obj: saa.AsyncTransaction) -> AsyncTransaction:
+    ...
+
+
+def async_adapt(obj: ta.Any) -> ta.Any:
+    if isinstance(obj, (AsyncEngine, AsyncConnection, AsyncTransaction)):
+        return obj
+    if isinstance(obj, saa.AsyncTransaction):
+        return AsyncTransaction(obj)
+    if isinstance(obj, saa.AsyncConnection):
+        return AsyncConnection(obj)
+    if isinstance(obj, saa.AsyncEngine):
+        return AsyncEngine(obj)
+    raise TypeError(obj)

{omextra-0.0.0.dev514.dist-info → omextra-0.0.0.dev516.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omextra
-Version: 0.0.0.dev514
+Version: 0.0.0.dev516
 Summary: omextra
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev514
+Requires-Dist: omlish==0.0.0.dev516
 Dynamic: license-file
 
 # Overview

{omextra-0.0.0.dev514.dist-info → omextra-0.0.0.dev516.dist-info}/RECORD

@@ -5,7 +5,9 @@ omextra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omextra/defs.py,sha256=iMaDGj5VSG7QdYA1s7MvIYTbtTsXc1msINsuuZym1vs,4902
 omextra/dynamic.py,sha256=i3aJRWwHJOmsrXI9a2iWCLa7pUQXx5YbMvUOS5LZ_Bs,6531
 omextra/asyncs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omextra/asyncs/bridge.py,sha256=QHh4gtiSid5bjmV9lqQrGHHBkE0yPFFYGW_NbJ2KGhI,10162
+omextra/asyncs/all.py,sha256=zE9zBNepDSczQ-QhnzwFz59IZIex3HuUqfKIgwbJLgY,329
+omextra/asyncs/bridge.py,sha256=N-iJg2Yvk8zfEMh5hUB9V4dIIMosvJszoo54ZXydQ1Q,10174
+omextra/asyncs/flavors.py,sha256=gFKfaKiuSDj4W5sopf9DtYQBDrBFXhsZX6_UJ5jgSNI,4896
 omextra/asyncs/bluelet/LICENSE,sha256=q5Kpj4s30qpi8H66tXFlh5v8_fkaKMFIzqdGfnN0Hz0,555
 omextra/asyncs/bluelet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omextra/asyncs/bluelet/all.py,sha256=aUV6PwnR8DqnEBS9wsZuPW_UtP6G9M8_KY-mmxZeVG0,1516
@@ -39,19 +41,7 @@ omextra/formats/json5/_antlr/Json5Parser.py,sha256=psacqZWRzPNEZq70XKpOnelZXHuXj
 omextra/formats/json5/_antlr/Json5Visitor.py,sha256=fIp5GhQ2Sd-bKEBBcBd31FOoCLiV1SZYPRof0Az6v6k,1455
 omextra/formats/json5/_antlr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omextra/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omextra/io/trampoline.py,sha256=nzCXtL4qip3IjfHwSHqhWkh429iakUFikbYKgx66cLc,7221
-omextra/io/buffers/DESIGN.md,sha256=DAGa6EB_6B7MOvHybCmOegIFytYLxh2rZxPqua-ocb4,8301
-omextra/io/buffers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omextra/io/buffers/adapters.py,sha256=C54vjLyJNcqdb_JVY5ZcJBHRH0yx9tIp4ZkoVRMMk8Y,9314
-omextra/io/buffers/all.py,sha256=Z3nxE1QcvfOO0UYfye2ELDeYggIQUzlcjWtNVdvv1X0,1051
-omextra/io/buffers/errors.py,sha256=38DvoYULPOyUpNLhuvZ9PG4qVdVdadTBXuVz3LKawpg,1523
-omextra/io/buffers/framing.py,sha256=dZd429gldmzcmE95oTL-DF_pJodWCn4JGO8fsEoS7rE,7389
-omextra/io/buffers/linear.py,sha256=wlMjrdQ9_bzeYVmlzZ7GHMipVeFQBViQlUn_P1hH1RI,6658
-omextra/io/buffers/reading.py,sha256=_EQWxbazE4uJhjZTQ1A5WtDVH1DjbbbDP5ITS3McJZ4,3485
-omextra/io/buffers/scanning.py,sha256=prq6Kdryfy0z-LK0K3h35HBavVuftllmnfIysxvf-6U,3049
-omextra/io/buffers/segmented.py,sha256=pTamrfBnqJGcHe02s2JmmRmFQPbFgGS38PTZ4vf5U7k,20191
-omextra/io/buffers/types.py,sha256=zbDRk8S9HquN5wk5bFFs5H0ptNtfQvS_ENvjc6Sl05E,11780
-omextra/io/buffers/utils.py,sha256=QxBN73g1rEUeHHq62NMS23IG0rPPC-5AY-UqwwxjFu8,1709
+omextra/io/trampoline.py,sha256=oWEkwQonue4qk3lkpI5KE7_yR02Dyn2XN7Amngw3z4I,7231
 omextra/specs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omextra/specs/proto/Protobuf3.g4,sha256=chDrovFsuZaHf5W35WZNts3jOa1ssPwvWiJR4yVIgjw,5552
 omextra/specs/proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -63,6 +53,8 @@ omextra/specs/proto/_antlr/Protobuf3Parser.py,sha256=iOeqyU9lUJ-kpiDj3lS86XjnE-L
 omextra/specs/proto/_antlr/Protobuf3Visitor.py,sha256=K5NxkXvMEJVsqnpXsHxMAHJOUFEYKSCSdsNR4RWgrE4,8804
 omextra/specs/proto/_antlr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omextra/sql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omextra/sql/alchemy/__init__.py,sha256=pLv2EQmAwcGXN0Y3AE8K5JjyN_4GaHRMHyExaDFm5yU,181
+omextra/sql/alchemy/asyncs.py,sha256=3rBxco1B7iC4gEw2pX7Jk9X7aFL0pe9LMHz3g7uz9Gk,3742
 omextra/sql/parsing/Minisql.g4,sha256=Jw8xT-8UI6ySHAgStyCg5QX9NTCinvTenLJReWiZIJU,4578
 omextra/sql/parsing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omextra/sql/parsing/parsing.py,sha256=FkGpXcHoWzdEwxsxlSPhjAjpUip6U592rdFf0ymKenI,3374
@@ -163,9 +155,9 @@ omextra/text/antlr/cli/__main__.py,sha256=ckYkj0drxabBVwWYewH2SS36TTeAxllZtS4xEl
 omextra/text/antlr/cli/cli.py,sha256=LW8pJNmySBOV3g8QxquPjUgxFv7YblzEyi555hHH3_M,1234
 omextra/text/antlr/cli/consts.py,sha256=HUYJP9j4RfeuuQv6HFd2oFMS0piWJ9Sq1tbeAs4OlBc,290
 omextra/text/antlr/cli/gen.py,sha256=HYleVptrpynwcl6GspX6O9_oMRSxwdYAQGuUFfDYse8,5236
-omextra-0.0.0.dev514.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omextra-0.0.0.dev514.dist-info/METADATA,sha256=xsVoaoJsumnrTjy-kTUB8zC31UIS6k7rmYX8YClvMEo,1409
-omextra-0.0.0.dev514.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-omextra-0.0.0.dev514.dist-info/entry_points.txt,sha256=-MFAMks5HgZ60Ore0Wl5lKVKk8z4kf1Ls3WY9E_OlCU,37
-omextra-0.0.0.dev514.dist-info/top_level.txt,sha256=o1nCNRejLMcayDngLuWMWwaeOucz33BXbpuoVvvzjPc,8
-omextra-0.0.0.dev514.dist-info/RECORD,,
+omextra-0.0.0.dev516.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omextra-0.0.0.dev516.dist-info/METADATA,sha256=GW_ZH-CkwAqAJ82STqQeRklcZXXgr7G0SL5J32mncHg,1409
+omextra-0.0.0.dev516.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+omextra-0.0.0.dev516.dist-info/entry_points.txt,sha256=-MFAMks5HgZ60Ore0Wl5lKVKk8z4kf1Ls3WY9E_OlCU,37
+omextra-0.0.0.dev516.dist-info/top_level.txt,sha256=o1nCNRejLMcayDngLuWMWwaeOucz33BXbpuoVvvzjPc,8
+omextra-0.0.0.dev516.dist-info/RECORD,,