omextra 0.0.0.dev514__tar.gz → 0.0.0.dev515__tar.gz

{omextra-0.0.0.dev514/omextra.egg-info → omextra-0.0.0.dev515}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omextra
-Version: 0.0.0.dev514
+Version: 0.0.0.dev515
 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.dev515
 Dynamic: license-file
 
 # Overview

omextra-0.0.0.dev515/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-0.0.0.dev514 → omextra-0.0.0.dev515}/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-0.0.0.dev515/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-0.0.0.dev514 → omextra-0.0.0.dev515}/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-0.0.0.dev515/omextra/sql/alchemy/__init__.py

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

omextra-0.0.0.dev515/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 → omextra-0.0.0.dev515/omextra.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omextra
-Version: 0.0.0.dev514
+Version: 0.0.0.dev515
 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.dev515
 Dynamic: license-file
 
 # Overview

{omextra-0.0.0.dev514 → omextra-0.0.0.dev515}/omextra.egg-info/SOURCES.txt

@@ -15,7 +15,9 @@ omextra.egg-info/entry_points.txt
 omextra.egg-info/requires.txt
 omextra.egg-info/top_level.txt
 omextra/asyncs/__init__.py
+omextra/asyncs/all.py
 omextra/asyncs/bridge.py
+omextra/asyncs/flavors.py
 omextra/asyncs/bluelet/LICENSE
 omextra/asyncs/bluelet/__init__.py
 omextra/asyncs/bluelet/all.py
@@ -50,18 +52,6 @@ omextra/formats/json5/_antlr/Json5Visitor.py
 omextra/formats/json5/_antlr/__init__.py
 omextra/io/__init__.py
 omextra/io/trampoline.py
-omextra/io/buffers/DESIGN.md
-omextra/io/buffers/__init__.py
-omextra/io/buffers/adapters.py
-omextra/io/buffers/all.py
-omextra/io/buffers/errors.py
-omextra/io/buffers/framing.py
-omextra/io/buffers/linear.py
-omextra/io/buffers/reading.py
-omextra/io/buffers/scanning.py
-omextra/io/buffers/segmented.py
-omextra/io/buffers/types.py
-omextra/io/buffers/utils.py
 omextra/specs/__init__.py
 omextra/specs/proto/Protobuf3.g4
 omextra/specs/proto/__init__.py
@@ -73,6 +63,8 @@ omextra/specs/proto/_antlr/Protobuf3Parser.py
 omextra/specs/proto/_antlr/Protobuf3Visitor.py
 omextra/specs/proto/_antlr/__init__.py
 omextra/sql/__init__.py
+omextra/sql/alchemy/__init__.py
+omextra/sql/alchemy/asyncs.py
 omextra/sql/parsing/Minisql.g4
 omextra/sql/parsing/__init__.py
 omextra/sql/parsing/parsing.py

omextra-0.0.0.dev515/omextra.egg-info/requires.txt

@@ -0,0 +1 @@
+omlish==0.0.0.dev515

{omextra-0.0.0.dev514 → omextra-0.0.0.dev515}/pyproject.toml

@@ -13,7 +13,7 @@ urls = {source = 'https://github.com/wrmsr/omlish'}
 license = 'BSD-3-Clause'
 readme = 'README.md'
 requires-python = '>=3.13'
-version = '0.0.0.dev514'
+version = '0.0.0.dev515'
 classifiers = [
     'Development Status :: 2 - Pre-Alpha',
     'Intended Audience :: Developers',
@@ -24,7 +24,7 @@ classifiers = [
 ]
 description = 'omextra'
 dependencies = [
-    'omlish == 0.0.0.dev514',
+    'omlish == 0.0.0.dev515',
 ]
 
 [project.optional-dependencies]