omlish 0.0.0.dev3__tar.gz → 0.0.0.dev4__tar.gz

{omlish-0.0.0.dev3/omlish.egg-info → omlish-0.0.0.dev4}/PKG-INFO

@@ -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
@@ -13,6 +13,9 @@ Requires-Python: >=3.12
 License-File: LICENSE
 Provides-Extra: async
 Requires-Dist: anyio; extra == "async"
+Provides-Extra: trio
+Requires-Dist: trio; extra == "trio"
+Requires-Dist: trio-asyncio; extra == "trio"
 Provides-Extra: http
 Requires-Dist: httpx; extra == "http"
 Provides-Extra: sql

{omlish-0.0.0.dev3 → omlish-0.0.0.dev4}/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-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-0.0.0.dev4/omlish/asyncs/__init__.py

@@ -0,0 +1,38 @@
+from .asyncs import (  # noqa
+    SyncableIterable,
+    async_list,
+    sync_await,
+    sync_list,
+    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,
+    FutureTimeoutError,
+    ImmediateExecutor,
+    new_thread_or_immediate_executor,
+    wait_dependent_futures,
+    wait_futures,
+)
+
+from .trio_asyncio import (  # noqa
+    with_trio_asyncio_loop,
+)

omlish-0.0.0.dev4/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-0.0.0.dev4/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-0.0.0.dev3 → omlish-0.0.0.dev4}/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-0.0.0.dev3 → omlish-0.0.0.dev4}/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-0.0.0.dev3 → omlish-0.0.0.dev4}/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-0.0.0.dev3 → omlish-0.0.0.dev4}/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-0.0.0.dev3 → omlish-0.0.0.dev4}/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