omlish 0.0.0.dev3__py3-none-any.whl → 0.0.0.dev4__py3-none-any.whl

omlish/__about__.py

@@ -3,4 +3,4 @@ __url__ = 'https://github.com/wrmsr/omlish'
 __license__ = 'BSD-3-Clause'
 __requires_python__ = '>=3.12'
 
-__version__ = '0.0.0.dev3'
+__version__ = '0.0.0.dev4'

omlish/__init__.py

@@ -0,0 +1,8 @@
+import sys as _sys
+
+
+REQUIRED_PYTHON_VERSION = (3, 12)
+
+
+if _sys.version_info < REQUIRED_PYTHON_VERSION:
+    raise EnvironmentError(f'Python version {_sys.version_info=} < {REQUIRED_PYTHON_VERSION}')

omlish/asyncs/__init__.py

@@ -6,6 +6,23 @@ from .asyncs import (  # noqa
     syncable_iterable,
 )
 
+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,
+)
 
 from .futures import (  # noqa
     FutureError,
@@ -15,3 +32,7 @@ from .futures import (  # noqa
     wait_dependent_futures,
     wait_futures,
 )
+
+from .trio_asyncio import (  # noqa
+    with_trio_asyncio_loop,
+)

omlish/asyncs/flavors.py

@@ -0,0 +1,201 @@
+"""
+TODO:
+ - 'get current'? -> sniffio..
+ - mark whole class / module?
+ - sync/greenlet bridge
+"""
+import abc
+import dataclasses as dc
+import enum
+import typing as ta
+
+from .. import lang
+from .trio_asyncio import check_trio_asyncio
+
+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: ta.Union[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}')
+
+
+##
+
+
+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)

omlish/asyncs/trio_asyncio.py

@@ -0,0 +1,41 @@
+import functools
+import typing as ta
+
+from .. import lang
+
+if ta.TYPE_CHECKING:
+    import asyncio
+    import sniffio
+    import trio_asyncio
+else:
+    asyncio = lang.proxy_import('asyncio')
+    sniffio = lang.proxy_import('sniffio')
+    trio_asyncio = lang.proxy_import('trio_asyncio')
+
+
+def check_trio_asyncio() -> None:
+    if trio_asyncio.current_loop.get() is None:
+        raise RuntimeError('trio_asyncio loop not running')
+
+
+def with_trio_asyncio_loop(fn, *, wait=False):
+    @functools.wraps(fn)
+    async def inner(*args, **kwargs):
+        if trio_asyncio.current_loop.get() is not None:
+            await fn(*args, **kwargs)
+            return
+
+        if sniffio.current_async_library() != 'trio':
+            raise RuntimeError('trio loop not running')
+
+        loop: asyncio.BaseEventLoop
+        async with trio_asyncio.open_loop() as loop:
+            try:
+                await fn(*args, **kwargs)
+            finally:
+                if wait:
+                    # FIXME: lol
+                    while asyncio.all_tasks(loop):
+                        await asyncio.sleep(.2)
+
+    return inner

omlish/dynamic.py

@@ -49,7 +49,7 @@ class Var(ta.Generic[T]):
 
     def __init__(
             self,
-            default: type[MISSING] | T = MISSING,  # type: ignore
+            default: type[MISSING] | T = MISSING,
             *,
             new: ta.Callable[[], T] | type[MISSING] = MISSING,
             validate: ta.Callable[[T], None] | None = None,
@@ -138,7 +138,7 @@ class Var(ta.Generic[T]):
             frame = frame.f_back
 
         if self._new is not MISSING:
-            yield self._new()
+            yield self._new()  # type: ignore
 
     def __iter__(self) -> ta.Iterator[T]:
         return self.values

omlish/fnpairs.py

@@ -1,3 +1,16 @@
+"""
+TODO:
+ - objects
+  - csv
+  - csvloader
+  - cbor
+  - cloudpickle
+  - alt json backends
+ - compression
+  - snappy
+  - lz4
+ - wrapped (wait for usecase)
+"""
 import abc
 import codecs
 import dataclasses as dc
@@ -6,32 +19,41 @@ import typing as ta
 from . import lang
 
 if ta.TYPE_CHECKING:
-    import bzip2 as _bzip2
+    import bz2 as _bz2
+    import cloudpickle as _cloudpickle
     import gzip as _gzip
     import json as _json
+    import lz4.frame as _lz4_frame
     import lzma as _lzma
     import pickle as _pickle
+    import snappy as _snappy
     import struct as _struct
     import tomllib as _tomllib
+    import yaml as _yaml
+    import zstd as _zstd
 
 else:
-    _bzip2 = lang.proxy_import('bzip2')
+    _bz2 = lang.proxy_import('bz2')
+    _cloudpickle = lang.proxy_import('cloudpickle')
     _gzip = lang.proxy_import('gzip')
     _json = lang.proxy_import('json')
+    _lz4_frame = lang.proxy_import('lz4.frame')
     _lzma = lang.proxy_import('lzma')
     _pickle = lang.proxy_import('pickle')
+    _snappy = lang.proxy_import('snappy')
     _struct = lang.proxy_import('struct')
     _tomllib = lang.proxy_import('tomllib')
-
-_zstd = lang.proxy_import('zstd')
-_yaml = lang.proxy_import('yaml')
+    _yaml = lang.proxy_import('yaml')
+    _zstd = lang.proxy_import('zstd')
 
 
 ##
 
 
 F = ta.TypeVar('F')
+F2 = ta.TypeVar('F2')
 T = ta.TypeVar('T')
+T2 = ta.TypeVar('T2')
 U = ta.TypeVar('U')
 
 
@@ -44,6 +66,11 @@ class FnPair(ta.Generic[F, T], abc.ABC):
     def backward(self, t: T) -> F:
         raise NotImplementedError
 
+    ##
+
+    def __call__(self, f: F) -> T:
+        return self.forward(f)
+
     def invert(self) -> 'FnPair[T, F]':
         if isinstance(self, Inverted):
             return self.fp
@@ -76,6 +103,8 @@ Simple.__abstractmethods__ = frozenset()  # noqa
 
 of = Simple
 
+NOP: FnPair[ta.Any, ta.Any] = of(lang.identity, lang.identity)
+
 
 ##
 
@@ -91,9 +120,6 @@ class Inverted(FnPair[F, T]):
         return self.fp.forward(t)
 
 
-##
-
-
 @dc.dataclass(frozen=True)
 class Composite(FnPair[F, T]):
     children: ta.Sequence[FnPair]
@@ -109,6 +135,14 @@ class Composite(FnPair[F, T]):
         return ta.cast(F, t)
 
 
+def compose(*ps: FnPair) -> FnPair:
+    if not ps:
+        return NOP
+    if len(ps) == 1:
+        return ps[0]
+    return Composite(ps)
+
+
 ##
 
 
@@ -177,6 +211,10 @@ def _register_extension(*ss):
     return inner
 
 
+def get_for_extension(ext: str) -> FnPair:
+    return compose(*[_EXTENSION_REGISTRY[p]() for p in ext.split('.')])
+
+
 ##
 
 
@@ -184,28 +222,28 @@ class Compression(FnPair[bytes, bytes], abc.ABC):
     pass
 
 
-@_register_extension('gz')
+@_register_extension('bz2')
 @dc.dataclass(frozen=True)
-class Gzip(Compression):
+class Bz2(Compression):
     compresslevel: int = 9
 
     def forward(self, f: bytes) -> bytes:
-        return _gzip.compress(f, compresslevel=self.compresslevel)
+        return _bz2.compress(f, compresslevel=self.compresslevel)
 
     def backward(self, t: bytes) -> bytes:
-        return _gzip.decompress(t)
+        return _bz2.decompress(t)
 
 
-@_register_extension('bz2')
+@_register_extension('gz')
 @dc.dataclass(frozen=True)
-class Bzip2(Compression):
+class Gzip(Compression):
     compresslevel: int = 9
 
     def forward(self, f: bytes) -> bytes:
-        return _bzip2.compress(f, compresslevel=self.compresslevel)
+        return _gzip.compress(f, compresslevel=self.compresslevel)
 
     def backward(self, t: bytes) -> bytes:
-        return _bzip2.decompress(t)
+        return _gzip.decompress(t)
 
 
 @_register_extension('lzma')
@@ -220,6 +258,27 @@ class Lzma(Compression):
 #
 
 
+@_register_extension('lz4')
+@dc.dataclass(frozen=True)
+class Lz4(Compression):
+    compression_level: int = 0
+
+    def forward(self, f: bytes) -> bytes:
+        return _lz4_frame.compress(f, compression_level=self.compression_level)
+
+    def backward(self, t: bytes) -> bytes:
+        return _lz4_frame.decompress(t)
+
+
+@_register_extension('snappy')
+class Snappy(Compression):
+    def forward(self, f: bytes) -> bytes:
+        return _snappy.compress(f)
+
+    def backward(self, t: bytes) -> bytes:
+        return _snappy.decompress(t)
+
+
 @_register_extension('zstd')
 class Zstd(Compression):
     def forward(self, f: bytes) -> bytes:
@@ -243,9 +302,27 @@ class Struct(FnPair[tuple, bytes]):
         return _struct.unpack(self.fmt, t)
 
 
+##
+
+
+class Object(FnPair[ta.Any, T], lang.Abstract):  # noqa
+    pass
+
+
+class ObjectStr(Object[str], lang.Abstract):  # noqa
+    pass
+
+
+class ObjectBytes(Object[bytes], lang.Abstract):  # noqa
+    pass
+
+
+#
+
+
 @_register_extension('pkl')
 @dc.dataclass(frozen=True)
-class Pickle(FnPair[ta.Any, bytes]):
+class Pickle(ObjectBytes):
     protocol: int | None = None
 
     def forward(self, f: ta.Any) -> bytes:
@@ -257,7 +334,7 @@ class Pickle(FnPair[ta.Any, bytes]):
 
 @_register_extension('json')
 @dc.dataclass(frozen=True)
-class Json(FnPair[ta.Any, str]):
+class Json(ObjectStr):
     indent: int | str | None = dc.field(default=None, kw_only=True)
     separators: tuple[str, str] | None = dc.field(default=None, kw_only=True)
 
@@ -283,7 +360,7 @@ class JsonLines(FnPair[ta.Sequence[ta.Any], str]):
 
 
 @_register_extension('toml')
-class Toml(FnPair[ta.Any, str]):
+class Toml(ObjectStr):
     def forward(self, f: ta.Any) -> str:
         raise NotImplementedError
 
@@ -294,8 +371,20 @@ class Toml(FnPair[ta.Any, str]):
 #
 
 
+@_register_extension('cpkl')
+@dc.dataclass(frozen=True)
+class Cloudpickle(ObjectBytes):
+    protocol: int | None = None
+
+    def forward(self, f: ta.Any) -> bytes:
+        return _cloudpickle.dumps(f, protocol=self.protocol)
+
+    def backward(self, t: bytes) -> ta.Any:
+        return _cloudpickle.loads(t)
+
+
 @_register_extension('yml', 'yaml')
-class Yaml(FnPair[ta.Any, str]):
+class Yaml(ObjectStr):
     def forward(self, f: ta.Any) -> str:
         return _yaml.dump(f)
 
@@ -303,9 +392,9 @@ class Yaml(FnPair[ta.Any, str]):
         return _yaml.safe_load(t)
 
 
-class UnsafeYaml(FnPair[ta.Any, str]):
+class YamlUnsafe(ObjectStr):
     def forward(self, f: ta.Any) -> str:
         return _yaml.dump(f)
 
     def backward(self, t: str) -> ta.Any:
-        return _yaml.safe_load(t, loader=_yaml.FullLoader)
+        return _yaml.load(t, _yaml.FullLoader)

omlish/inject/impl/elements.py

@@ -14,7 +14,7 @@ Element Types:
  - Overrides
  - Expose
  - Private
- - ScopeSeed
+ - ScopeBinding
 """
 import typing as ta
 
@@ -31,6 +31,7 @@ from ..overrides import Overrides
 from ..private import Expose
 from ..private import Private
 from ..scopes import ScopeBinding
+from ..types import Scope
 from .bindings import BindingImpl
 from .providers import MultiProviderImpl
 from .providers import make_provider_impl
@@ -152,3 +153,14 @@ class ElementCollection(lang.Final):
     @lang.cached_function
     def binding_impl_map(self) -> ta.Mapping[Key, BindingImpl]:
         return self._build_binding_impl_map(self.element_multimap())
+
+    ##
+
+    @lang.cached_function
+    def eager_keys_by_scope(self) -> ta.Mapping[Scope, ta.Sequence[Key]]:
+        bim = self.binding_impl_map()
+        ret: dict[Scope, list[Key]] = {}
+        for e in self.elements_of_type(Eager):
+            bi = bim[e.key]
+            ret.setdefault(bi.scope, []).append(e.key)
+        return ret

omlish/inject/impl/injector.py

@@ -7,6 +7,8 @@ TODO:
   - config is probably shared with ElementCollection... but not 'bound', must be shared everywhere
   - InjectorRoot object?
  - ** eagers in any scope, on scope init/open
+ - injection listeners
+ - unions - raise on ambiguous - usecase: sql.AsyncEngineLike
 """
 import contextlib
 import typing as ta
@@ -14,7 +16,6 @@ import weakref
 
 from ... import check
 from ... import lang
-from ..eagers import Eager
 from ..elements import Elements
 from ..exceptions import CyclicDependencyError
 from ..exceptions import UnboundKeyError
@@ -52,6 +53,7 @@ class InjectorImpl(Injector, lang.Final):
         }
 
         self._bim = ec.binding_impl_map()
+        self._ekbs = ec.eager_keys_by_scope()
 
         self._cs: weakref.WeakSet[InjectorImpl] | None = None
         self._root: InjectorImpl = p._root if p is not None else self  # noqa
@@ -66,13 +68,13 @@ class InjectorImpl(Injector, lang.Final):
             s: make_scope_impl(s) for s in ss
         }
 
-        self._instantiate_eagers()
+        self._instantiate_eagers(Unscoped())
 
     _root: 'InjectorImpl'
 
-    def _instantiate_eagers(self) -> None:
-        for e in self._ec.elements_of_type(Eager):
-            self.provide(e.key)
+    def _instantiate_eagers(self, sc: Scope) -> None:
+        for k in self._ekbs.get(sc, ()):
+            self.provide(k)
 
     def get_scope_impl(self, sc: Scope) -> ScopeImpl:
         return self._scopes[sc]

omlish/inject/impl/scopes.py

@@ -141,8 +141,8 @@ class SeededScopeImpl(ScopeImpl):
         def __init__(self, ss: SeededScope, i: Injector) -> None:
             super().__init__()
             self._ss = check.isinstance(ss, SeededScope)
-            ii = check.isinstance(i, injector_.InjectorImpl)
-            self._ssi = check.isinstance(ii.get_scope_impl(self._ss), SeededScopeImpl)
+            self._ii = check.isinstance(i, injector_.InjectorImpl)
+            self._ssi = check.isinstance(self._ii.get_scope_impl(self._ss), SeededScopeImpl)
 
         @contextlib.contextmanager
         def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.Generator[None, None, None]:
@@ -150,6 +150,7 @@ class SeededScopeImpl(ScopeImpl):
                 if self._ssi._st is not None:  # noqa
                     raise ScopeAlreadyOpenError(self._ss)
                 self._ssi._st = SeededScopeImpl.State(dict(seeds))  # noqa
+                self._ii._instantiate_eagers(self._ss)  # noqa
                 yield
             finally:
                 if self._ssi._st is None:  # noqa

omlish/json.py

@@ -1,7 +1,142 @@
+"""
+json
+  dump
+    skipkeys=False
+    ensure_ascii=True
+    check_circular=True
+    allow_nan=True
+    cls=None
+    indent=None
+    separators=None
+    default=None
+    sort_keys=False
+  dumps
+    ^
+  load
+    cls=None
+    object_hook=None
+    parse_float=None
+    parse_int=None
+    parse_constant=None
+    object_pairs_hook=None
+  loads
+    ^
+
+ujson
+  dump
+    ensure_ascii
+    encode_html_chars
+    escape_forward_slashes
+    sort_keys
+    indent
+    allow_nan
+    reject_bytes
+    default
+    separators
+  dumps
+    ^
+  load
+  loads
+
+orjson
+  dumps
+    default
+    option
+      OPT_INDENT_2
+      OPT_NAIVE_UTC
+      OPT_NON_STR_KEYS
+      OPT_OMIT_MICROSECONDS
+      OPT_PASSTHROUGH_DATACLASS
+      OPT_PASSTHROUGH_DATETIME
+      OPT_PASSTHROUGH_SUBCLASS
+      OPT_SERIALIZE_DATACLASS
+      OPT_SERIALIZE_NUMPY
+      OPT_SERIALIZE_UUID
+      OPT_SORT_KEYS
+      OPT_STRICT_INTEGER
+      OPT_UTC_Z
+  loads
+
+rapidjson
+  dump
+    skipkeys=False,
+    ensure_ascii=True,
+    write_mode=WM_COMPACT,
+      WM_COMPACT
+      WM_PRETTY
+      WM_SINGLE_LINE_ARRAY
+    indent=4,
+    default=None,
+    sort_keys=False,
+    number_mode=None,
+      NM_NONE
+      NM_DECIMAL
+      NM_NAN
+      NM_NATIVE
+    datetime_mode=None,
+      DM_NONE
+      DM_ISO8601
+      DM_UNIX_TIME
+      DM_ONLY_SECONDS
+      DM_IGNORE_TZ
+      DM_NAIVE_IS_UTC
+      DM_SHIFT_TO_UTC
+    uuid_mode=None,
+      UM_NONE
+      UM_CANONICAL
+      UM_HEX
+    bytes_mode=BM_UTF8,
+      BM_NONE
+      BM_UTF8
+    iterable_mode=IM_ANY_ITERABLE,
+      IM_ANY_ITERABLE
+      IM_ONLY_LISTS
+    mapping_mode=MM_ANY_MAPPING,
+      MM_ANY_MAPPING
+      MM_ONLY_DICTS
+      MM_COERCE_KEYS_TO_STRINGS
+      MM_SKIP_NON_STRING_KEYS
+      MM_SORT_KEYS
+    chunk_size
+    allow_nan=True
+  dumps
+    ^
+    -chunk_size
+  load
+    object_hook=None,
+    number_mode=None,
+      ^
+    datetime_mode=None,
+      ^
+    uuid_mode=None,
+      ^
+    parse_mode=None,
+      PM_NONE
+      PM_COMMENTS
+      PM_TRAILING_COMMAS
+    chunk_size=65536,
+    allow_nan=True
+  loads
+    ^
+    -chunk_size
+
+"""
 import functools
 import json as _json
 import typing as ta
 
+from . import lang
+
+if ta.TYPE_CHECKING:
+    import orjson as _orjson
+    import ujson as _ujson
+else:
+    _orjson = lang.proxy_import('orjson')
+    _ujson = lang.proxy_import('ujson')
+
+
+##
+
 
 dump = _json.dump
 dumps = _json.dumps
@@ -11,6 +146,7 @@ detect_encoding = _json.detect_encoding
 load = _json.load
 loads = _json.loads
 
+
 ##
 
 

omlish/lang/__init__.py

@@ -156,6 +156,10 @@ from .strings import (  # noqa
     snake_case,
 )
 
+from .sys import (  # noqa
+    is_gil_enabled,
+)
+
 from .timeouts import (  # noqa
     DeadlineTimeout,
     InfiniteTimeout,

omlish/lang/classes/restrict.py

@@ -89,7 +89,7 @@ class PackageSealed:
 class NotInstantiable(Abstract):
     __slots__ = ()
 
-    def __new__(cls, *args: ta.Any, **kwargs: ta.Any) -> ta.NoReturn:  # noqa
+    def __new__(cls, *args, **kwargs):
         raise TypeError
 
 

omlish/lang/sys.py

@@ -0,0 +1,7 @@
+import sys
+
+
+def is_gil_enabled() -> bool:
+    if (fn := getattr(sys, '_is_gil_enabled', None)) is not None:
+        return fn()
+    return True

omlish/sql/__init__.py

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

omlish/sql/asyncs.py

@@ -0,0 +1,148 @@
+"""
+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 .. import asyncs as au
+
+
+T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
+
+
+AsyncEngineLike = ta.Union[saa.AsyncEngine, 'AsyncEngine']
+AsyncConnectionLike = ta.Union[saa.AsyncConnection, 'AsyncConnection']
+AsyncTransactionLike = 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)

omlish/testing/pydevd.py

@@ -87,6 +87,8 @@ def silence_subprocess_check() -> None:
 
 @lang.cached_function
 def patch_for_trio_asyncio() -> None:
+    """Fix for `trio a callable object was expected by call_soon(), got Task`"""
+
     try:
         import pydevd_nest_asyncio  # noqa
     except ImportError:

{omlish-0.0.0.dev3.dist-info → omlish-0.0.0.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev3
+Version: 0.0.0.dev4
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -24,6 +24,9 @@ Provides-Extra: sql
 Requires-Dist: sqlalchemy ; extra == 'sql'
 Provides-Extra: test
 Requires-Dist: pytest ; extra == 'test'
+Provides-Extra: trio
+Requires-Dist: trio ; extra == 'trio'
+Requires-Dist: trio-asyncio ; extra == 'trio'
 Provides-Extra: wrapt
 Requires-Dist: wrapt ; extra == 'wrapt'
 Provides-Extra: yaml

{omlish-0.0.0.dev3.dist-info → omlish-0.0.0.dev4.dist-info}/RECORD

@@ -1,15 +1,15 @@
-omlish/__about__.py,sha256=PDr-dayjZF7uNCY78Cmj-DplO_IRgBlaOdS27ftVXMk,153
-omlish/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/__about__.py,sha256=NmLFQDO4CRzemxQzOuD9dQdlaNKZkVw4DwBlKkI355I,153
+omlish/__init__.py,sha256=WQMALSGEyPfcQUmuYQkwv3bC_A5v6IfQ6C6rOYETQHA,200
 omlish/argparse.py,sha256=QRQmX9G0-L_nATkFtGHvpd4qrpYzKATdjuFLbBqzJPM,6224
 omlish/c3.py,sha256=yhescciIJWoJ9nIWJSrUOtyqIu4uLyPjRHk8RbAJ3f4,8039
 omlish/cached.py,sha256=i7uWLRrUrE5N1ofzUf9D3OIsxf-dXkgu4OxCep0CCBk,197
 omlish/check.py,sha256=h66jWSwaiuaaIKPI6_pIfolWYYK3WTR43X1CBO5-PQA,5538
 omlish/defs.py,sha256=IvUL5i-iyBh5HUhf-gY6sonw3tIozL8066QL71CnoiY,4729
 omlish/docker.py,sha256=oLyJQg4Mu-k_WfDVP7PU9yK1cI-JCdcrTVjrQg2sQsE,4140
-omlish/dynamic.py,sha256=9LHfKegKnMFoczFfqIZuGpkR8xGxMxq_lAvNJTDJjWs,6541
-omlish/fnpairs.py,sha256=DgXK-AbcIFq7a-HI0a-7ctvKvoSAou4wW5B0fcorMIc,7252
+omlish/dynamic.py,sha256=35C_cCX_Vq2HrHzGk5T-zbrMvmUdiIiwDzDNixczoDo,6541
+omlish/fnpairs.py,sha256=f9UfdkDCvfKLivN1H-eKbdOYe-8y1f2aPB6AuRGKLIM,9124
 omlish/iterators.py,sha256=YJUTyfqY_calFFOU40TEuptYBqKeavi6L6kc2gXn9s4,5524
-omlish/json.py,sha256=P2T8yigNNGDVdYpgKfaA7gtYdJC2EQJ10XaS89MROoQ,4549
+omlish/json.py,sha256=ffsWL9o29ejtGoV0kzEMdDPn5gAI0Ezi3CSQasg41uY,6781
 omlish/libc.py,sha256=u0481imCiTFqP_e-v9g0pD-0WD249j5vYzhtn-fnNkY,15308
 omlish/math.py,sha256=AVqp5Y8yxKA-wO0BgrzaxA0Ga3PZiCXnYcwivMneC-0,3804
 omlish/os.py,sha256=T77P7_U7jShPXsm_byvXwPoumcmtA0a7KPRvE2GAOhw,950
@@ -17,12 +17,14 @@ omlish/reflect.py,sha256=3dJ9ZGrBan5RRW_Q0OTbl9--oi3B05-ZV4uu0VH-m1c,9891
 omlish/runmodule.py,sha256=PWvuAaJ9wQQn6bx9ftEL3_d04DyotNn8dR_twm2pgw0,700
 omlish/stats.py,sha256=uqjN-focDVssFZMagj22HqmyJ1TBO4Wt-XnHp8-EtVw,9927
 omlish/term.py,sha256=OmD3QXntycYHNDCZ-ZV5x2Rz9tw49CoYEn-rld7x_r8,5963
-omlish/asyncs/__init__.py,sha256=FIoKl3m_gSxEXL_JJU_dc4OAIKVqq9fLqom_byH3PGY,307
+omlish/asyncs/__init__.py,sha256=e7cMiu0S-Rqg98TT7NBVNZ_DkScqRBqJLxI7Aeb5ToY,680
 omlish/asyncs/anyio.py,sha256=oYU7FGxMlzPhj5Aa1p7XSdKeD6icoyTPxZRWDc9-YGc,3226
 omlish/asyncs/asyncio.py,sha256=pSldCmtE9AgVATXb_Vnhjhhz0v2LtqgVXxe7-OFjH0g,414
 omlish/asyncs/asyncs.py,sha256=MmIz8Gw4PbZd0LUIro_u5kUjobR8i2qGCo6l2hb4U74,2014
+omlish/asyncs/flavors.py,sha256=c8w0M_lTtpm38Vi78cy2jk6pRH7MH_DgR_H9z6PoCpE,4247
 omlish/asyncs/futures.py,sha256=3KkTj5TOPmvNOcuK9LtOQwmkuLzoEYQfcuaHTXSQ0Ts,5424
 omlish/asyncs/trio.py,sha256=GKG3wgelFr7gIKKHZhcflvMyCvxXHNZe862KB0Xw2uA,370
+omlish/asyncs/trio_asyncio.py,sha256=-CV9hjjIl3JcLIDhcRNkhoNhbVLIyzoJFe-_dvyOyc0,1112
 omlish/collections/__init__.py,sha256=H1_J6VNBqdmdMb8vjc7LBJ8ULoiawxoz-1cR41twB2k,1526
 omlish/collections/_abc.py,sha256=sP7BpTVhx6s6C59mTFeosBi4rHOWC6tbFBYbxdZmvh0,2365
 omlish/collections/_io_abc.py,sha256=Cxs8KB1B_69rxpUYxI-MTsilAmNooJJn3w07DKqYKkE,1255
@@ -106,13 +108,13 @@ omlish/inject/scopes.py,sha256=hecYiZwZ3H31cnTgfP01-duTM8OgllwxtvQKpzyHDSU,2033
 omlish/inject/types.py,sha256=CP3ltWxRtmR2Iqz1Qd7CvaTHQYV4st5FPiNDBN8tmn0,235
 omlish/inject/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/inject/impl/bindings.py,sha256=8H586RCgmvwq53XBL9WMbb-1-Tdw_hh9zxIDCwcHA1c,414
-omlish/inject/impl/elements.py,sha256=MnBtTF9bx07s8KRYQ7xMtbB6WdtkAJ8Si59l-4Yxn_w,4532
-omlish/inject/impl/injector.py,sha256=1jSWr8uvsUPAWRFXEj_HHY6efprMrMBPy0tWvKLUYJw,5528
+omlish/inject/impl/elements.py,sha256=f_eGd-AbyBO0g7Qsu8gA-IKPVKWSUOZcD2MbXxISXoE,4898
+omlish/inject/impl/injector.py,sha256=DeweCOLcij_kYkY1g6i3gjcJ2FSTAe83fO4vnbX7Qmo,5639
 omlish/inject/impl/inspect.py,sha256=ZQScAStbjWi_5InA6M52ll3cdyfPRuLwYo6kc4kFsmM,2525
 omlish/inject/impl/private.py,sha256=MiYvs-EiFrla4FQnoqmqGpYx784ij33p0obAS57HOCQ,2611
 omlish/inject/impl/providers.py,sha256=m0c9AAY849P6egYBOsSCkSoSBc8So7Zbmlo6gZwzTIw,3302
-omlish/inject/impl/scopes.py,sha256=Lc2Bw1hK0TrAt0_JrXwSQGCixZdBcqZlEz3_n2Q1bCA,5636
-omlish/lang/__init__.py,sha256=mxCgLE8RAq6kQs75cOjT8POZXLrN_EKji2ZLKTnnJ78,2718
+omlish/inject/impl/scopes.py,sha256=itwf_r8hhiYZVHHAzAvAEKRza4M2ST8LJJLOHrhSM2c,5711
+omlish/lang/__init__.py,sha256=mqnnt6K54ROzSLWVJZrLz51ufcSM66RUy9jPtczjegI,2768
 omlish/lang/cached.py,sha256=MgBHfT83Rrl8tFr98hGBgEeA3ugse077_w6n3S35QYM,7603
 omlish/lang/clsdct.py,sha256=LXwLCULeI_8Np-7-pZkyNAHpUZLcQiBEQiHwKYQ0WRo,1742
 omlish/lang/cmp.py,sha256=5vbzWWbqdzDmNKAGL19z6ZfUKe5Ci49e-Oegf9f4BsE,1346
@@ -127,11 +129,12 @@ omlish/lang/maybes.py,sha256=J2N3IDOnSSeGbrN342ln2adt0TDpz2SkyCIiZ0pVRDQ,3425
 omlish/lang/objects.py,sha256=TAD84PYsD0cGtaQpqo3fQSm99tP4-hckixkQ_K_Iaic,2820
 omlish/lang/resolving.py,sha256=UgrX-vxXtCGGEmnAMUYP4bUZ6-Ok0EcHVEKAZYbAS-o,1597
 omlish/lang/strings.py,sha256=wdLo3m9GkV76ZKak3QqtwiR6rWqUd1XlZ-divZppcek,2372
+omlish/lang/sys.py,sha256=Q316Bzy9cC6bFwztkgpc8CKnsCaz4ldYvjIGpTXlxf4,145
 omlish/lang/timeouts.py,sha256=vECdWYhc_IZgcal1Ng1Y42wf2FV3KAx-i8As-MgGHIQ,1186
 omlish/lang/typing.py,sha256=pN7Eh8X-1iDqaZ_nZQJaheHBYdkuYTSs0yCN0LcKfDU,2341
 omlish/lang/classes/__init__.py,sha256=j1p0_uuMznKrY2EhMoj20uv6vx4LXljMzp7AaKe0mmU,530
 omlish/lang/classes/abstract.py,sha256=goIV14oY24EOs88eVe6E6NyrSPOOLMOcWTXTMuYKiqc,2304
-omlish/lang/classes/restrict.py,sha256=D3ICBbITr65xJpms3Q-KA-qygkZdb8FsrJAQBJuCzNg,3147
+omlish/lang/classes/restrict.py,sha256=Fb18KwWo-o7N0OEXpomzsdQpQvJZIK_dAf4d4oAiTsk,3108
 omlish/lang/classes/simple.py,sha256=p30A4dJxXrtG3ztRF50uBZoBwt84hMqOt_c7cyNx5ec,2672
 omlish/lang/classes/virtual.py,sha256=hEVeosXKwG4sK_9dqBoNjkK2jF2mV9QoZGOtLqg7L_Q,3315
 omlish/logs/__init__.py,sha256=V8jEdb5rj9Dli0b9qtR0ZYstRoIlxWqbU38UmEOXbfY,419
@@ -162,11 +165,12 @@ omlish/marshal/standard.py,sha256=MPmtJH3B_LqeoSwQsxKjUm65-cq6albBc8z-gxyKAj4,24
 omlish/marshal/utils.py,sha256=puKJpwPpuDlMOIrKMcLTRLJyMiL6n_Xs-p59AuDEymA,543
 omlish/marshal/uuids.py,sha256=_htkeMt1a6FUNBlstZIy2rrB1-1DiavV5dZrjSQNYVM,952
 omlish/marshal/values.py,sha256=ssHiWdg_L6M17kAn8GiGdPW7UeQOm3RDikWkvwblf5I,263
-omlish/sql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/sql/__init__.py,sha256=pLv2EQmAwcGXN0Y3AE8K5JjyN_4GaHRMHyExaDFm5yU,181
 omlish/sql/_abc.py,sha256=HLhnnLZ7l0r_N99I-RCqJe6VHth-9iluU7cR-7-5jfs,1519
+omlish/sql/asyncs.py,sha256=Wye3dwh7oZEGYz2Y4DZQSHtW4xjI2AH5qjW-BSS2IfU,3688
 omlish/sql/dbs.py,sha256=JxcJm3JIcsb7i-t9L0KU9WhAc26QsKUL6ZL6puy3IXI,1763
 omlish/testing/__init__.py,sha256=l13axR7dyVE9T1e6w1pMYtAkW3vS2J97nBcYQ1FUv18,136
-omlish/testing/pydevd.py,sha256=OV9RsVbzo7fYbA3EkoOdbxQ-VB4ex2Sm9jzG8poJHDk,6270
+omlish/testing/pydevd.py,sha256=xOeAithe-XMiwhc0sqnmVe4FRfr2DOkKVgSH0jp5C0U,6352
 omlish/testing/testing.py,sha256=TaLELNrPx42_-EEqJygDYyQOtEdjXP4KqgLGu6juHmU,2470
 omlish/testing/pytest/__init__.py,sha256=diebkOX565JdY7HIDMJVLlj3pcFnlK-spv6YIlD77oA,176
 omlish/testing/pytest/helpers.py,sha256=DKZXQGqKpDiQAh0SuYrzvJ8usJbTnuVQFDpuDmQD_Oc,912
@@ -184,8 +188,8 @@ omlish/text/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/text/delimit.py,sha256=gAdbVES35IT-maH_M084SJEaf1LRoyXG8Z3pIS6OSCI,4878
 omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/parts.py,sha256=KGgo0wHOIMVMZtDso-rhSWKAcAkYAH2IGpg9tULabu8,6505
-omlish-0.0.0.dev3.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev3.dist-info/METADATA,sha256=OIbDCU-yfhRj6eymUO_GHiLTfG0lhWtjQtRfh9mB2ys,953
-omlish-0.0.0.dev3.dist-info/WHEEL,sha256=rWxmBtp7hEUqVLOnTaDOPpR-cZpCDkzhhcBce-Zyd5k,91
-omlish-0.0.0.dev3.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev3.dist-info/RECORD,,
+omlish-0.0.0.dev4.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev4.dist-info/METADATA,sha256=nuRX2RRNrFfyR75hu2D3EK0MrAlueKOhq6dBz6khV-o,1058
+omlish-0.0.0.dev4.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+omlish-0.0.0.dev4.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev4.dist-info/RECORD,,

{omlish-0.0.0.dev3.dist-info → omlish-0.0.0.dev4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (71.0.4)
+Generator: setuptools (71.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any