omlish 0.0.0.dev433__py3-none-any.whl → 0.0.0.dev435__py3-none-any.whl

omlish/inject/impl/sync.py

@@ -0,0 +1,42 @@
+import typing as ta
+
+from ... import lang
+from ..elements import Elements
+from ..injector import AsyncInjector
+from ..inspect import KwargsTarget
+from ..keys import Key
+from ..sync import Injector
+from .elements import ElementCollection
+from .injector import AsyncInjectorImpl
+
+
+##
+
+
+class InjectorImpl(Injector, lang.Final):
+    _ai: AsyncInjector
+
+    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
+        return lang.sync_await(self._ai.try_provide(key))
+
+    def provide(self, key: ta.Any) -> ta.Any:
+        return lang.sync_await(self._ai.provide(key))
+
+    def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
+        return lang.sync_await(self._ai.provide_kwargs(kt))
+
+    def inject(self, obj: ta.Any) -> ta.Any:
+        return lang.sync_await(self._ai.inject(obj))
+
+
+def create_injector(es: Elements) -> Injector:
+    si = InjectorImpl()
+    ai = AsyncInjectorImpl(
+        ElementCollection(es),
+        internal_consts={
+            Key(Injector): si,
+        },
+    )
+    si._ai = ai  # noqa
+    lang.sync_await(ai._init())  # noqa
+    return si

omlish/inject/injector.py

@@ -8,10 +8,8 @@ from .inspect import KwargsTarget
 from .keys import Key
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
     from .impl import injector as _injector
-else:
-    _injector = lang.proxy_import('.impl.injector', __package__)
 
 
 T = ta.TypeVar('T')
@@ -20,29 +18,29 @@ T = ta.TypeVar('T')
 ##
 
 
-class Injector(lang.Abstract):
+class AsyncInjector(lang.Abstract):
     @abc.abstractmethod
-    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
+    def try_provide(self, key: ta.Any) -> ta.Awaitable[lang.Maybe[ta.Any]]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def provide(self, key: ta.Any) -> ta.Any:
+    def provide(self, key: ta.Any) -> ta.Awaitable[ta.Any]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
+    def provide_kwargs(self, kt: KwargsTarget) -> ta.Awaitable[ta.Mapping[str, ta.Any]]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def inject(self, obj: ta.Any) -> ta.Any:
+    def inject(self, obj: ta.Any) -> ta.Awaitable[ta.Any]:
         raise NotImplementedError
 
     def __getitem__(
             self,
             target: Key[T] | type[T],
-    ) -> T:
+    ) -> ta.Awaitable[T]:
         return self.provide(target)
 
 
-def create_injector(*args: Elemental) -> Injector:
-    return _injector.create_injector(as_elements(*args))
+def create_async_injector(*args: Elemental) -> ta.Awaitable[AsyncInjector]:
+    return _injector.create_async_injector(as_elements(*args))

omlish/inject/inspect.py

@@ -4,10 +4,8 @@ from .. import lang
 from .keys import Key
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
     from .impl import inspect as _inspect
-else:
-    _inspect = lang.proxy_import('.impl.inspect', __package__)
 
 
 T = ta.TypeVar('T')

omlish/inject/listeners.py

@@ -4,7 +4,7 @@ from .. import dataclasses as dc
 from .. import lang
 from .bindings import Binding
 from .elements import Element
-from .injector import Injector
+from .injector import AsyncInjector
 from .keys import Key
 
 
@@ -12,11 +12,11 @@ from .keys import Key
 
 
 ProvisionListener: ta.TypeAlias = ta.Callable[[
-    Injector,
+    AsyncInjector,
     Key,
     Binding | None,
-    ta.Callable[[], ta.Any],
-], ta.Callable[[], ta.Any]]
+    ta.Callable[[], ta.Awaitable[ta.Any]],
+], ta.Awaitable[ta.Any]]
 
 
 @dc.dataclass(frozen=True)

omlish/inject/managed.py

@@ -9,14 +9,12 @@ from .. import lang
 from .binder import bind
 from .elements import Elemental
 from .impl.inspect import build_kwargs_target
-from .injector import Injector
-from .injector import create_injector
 
 
-if ta.TYPE_CHECKING:
-    from ..asyncs import all as _asyncs
-else:
-    _asyncs = lang.proxy_import('..asyncs.all', __package__)
+with lang.auto_proxy_import(globals()):
+    from . import injector as _injector
+    from . import maysync as _maysync
+    from . import sync as _sync
 
 
 T = ta.TypeVar('T')
@@ -25,9 +23,43 @@ T = ta.TypeVar('T')
 ##
 
 
+@contextlib.asynccontextmanager
+async def create_async_managed_injector(*args: Elemental) -> ta.AsyncGenerator['_injector.AsyncInjector']:
+    ai = await _injector.create_async_injector(
+        bind(contextlib.AsyncExitStack, singleton=True, eager=True),
+        *args,
+    )
+    async with (await ai[contextlib.AsyncExitStack]):
+        yield ai
+
+
+def make_async_managed_provider(
+        fac: ta.Callable[..., T],
+        *fns: ta.Callable[[T], ta.AsyncContextManager[T]],
+) -> ta.Callable[..., ta.Awaitable[T]]:
+    kt = build_kwargs_target(fac)
+
+    async def _provide(
+            ai: _injector.AsyncInjector,
+            aes: contextlib.AsyncExitStack,
+    ):
+        obj = await ai.inject(kt)
+        if not fns:
+            obj = await aes.enter_async_context(obj)
+        else:
+            for fn in fns:
+                await aes.enter_async_context(fn(obj))
+        return obj
+
+    return _provide
+
+
+##
+
+
 @contextlib.contextmanager
-def create_managed_injector(*args: Elemental) -> ta.Generator[Injector]:
-    i = create_injector(
+def create_managed_injector(*args: Elemental) -> ta.Generator['_sync.Injector']:
+    i = _sync.create_injector(
         bind(contextlib.ExitStack, singleton=True, eager=True),
         *args,
     )
@@ -42,7 +74,7 @@ def make_managed_provider(
     kt = build_kwargs_target(fac)
 
     def _provide(
-            i: Injector,
+            i: _sync.Injector,
             es: contextlib.ExitStack,
     ):
         obj = i.inject(kt)
@@ -59,32 +91,32 @@ def make_managed_provider(
 ##
 
 
-@contextlib.asynccontextmanager
-async def create_async_managed_injector(*args: Elemental) -> ta.AsyncGenerator[Injector]:
-    i = await _asyncs.s_to_a(create_injector)(
-        bind(contextlib.AsyncExitStack, singleton=True, eager=True),
+@contextlib.contextmanager
+def create_maysync_managed_injector(*args: Elemental) -> ta.Generator['_maysync.MaysyncInjector']:
+    i = _maysync.create_maysync_injector(
+        bind(contextlib.ExitStack, singleton=True, eager=True),
         *args,
     )
-    async with i[contextlib.AsyncExitStack]:
+    with i[contextlib.ExitStack]:
         yield i
 
 
-def make_async_managed_provider(
+def make_maysync_managed_provider(
         fac: ta.Callable[..., T],
-        *fns: ta.Callable[[T], ta.AsyncContextManager[T]],
+        *fns: ta.Callable[[T], ta.ContextManager[T]],
 ) -> ta.Callable[..., T]:
     kt = build_kwargs_target(fac)
 
     def _provide(
-            i: Injector,
-            aes: contextlib.AsyncExitStack,
+            i: _maysync.MaysyncInjector,
+            es: contextlib.ExitStack,
     ):
         obj = i.inject(kt)
         if not fns:
-            obj = _asyncs.a_to_s(aes.enter_async_context)(obj)
+            obj = es.enter_context(obj)
         else:
             for fn in fns:
-                _asyncs.a_to_s(aes.enter_async_context)(fn(obj))
+                es.enter_context(fn(obj))
         return obj
 
     return _provide

omlish/inject/maysync.py

@@ -0,0 +1,27 @@
+import typing as ta
+
+from .. import lang
+from .elements import Elemental
+from .elements import as_elements
+from .sync import Injector
+
+
+with lang.auto_proxy_import(globals()):
+    from .impl import maysync as _maysync
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class MaysyncInjector(Injector, lang.Abstract):
+    pass
+
+
+##
+
+
+def create_maysync_injector(*args: Elemental) -> MaysyncInjector:
+    return _maysync.create_maysync_injector(as_elements(*args))

omlish/inject/providers.py

@@ -17,6 +17,12 @@ class Provider(lang.Abstract):
     pass
 
 
+@dc.dataclass(frozen=True)
+@dc.extra_class_params(cache_hash=True)
+class AsyncFnProvider(Provider):
+    fn: ta.Any = dc.xfield(validate=callable)
+
+
 @dc.dataclass(frozen=True)
 @dc.extra_class_params(cache_hash=True)
 class FnProvider(Provider):

omlish/inject/scopes.py

@@ -7,16 +7,17 @@ from .. import dataclasses as dc
 from .. import lang
 from .bindings import Binding
 from .elements import Element
+from .injector import AsyncInjector
 from .keys import Key
 from .keys import as_key
 from .providers import Provider
 from .types import Scope
 
 
-if ta.TYPE_CHECKING:
-    from . import injector as injector_
-else:
-    injector_ = lang.proxy_import('.injector', __package__)
+with lang.auto_proxy_import(globals()):
+    from . import injector as _injector
+    from . import maysync as _maysync
+    from . import sync as _sync
 
 
 ##
@@ -65,7 +66,7 @@ class SeededScope(Scope, lang.Final):
 
     class Manager(lang.Abstract):
         @abc.abstractmethod
-        def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.ContextManager[None]:
+        def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.AsyncContextManager[None]:
             raise NotImplementedError
 
 
@@ -81,11 +82,38 @@ def bind_scope_seed(k: ta.Any, ss: SeededScope) -> Element:
     return Binding(k, ScopeSeededProvider(ss, k))
 
 
-@contextlib.contextmanager
-def enter_seeded_scope(
-        i: injector_.Injector,
+##
+
+
+@contextlib.asynccontextmanager
+async def async_enter_seeded_scope(
+        i: '_injector.AsyncInjector',
         ss: SeededScope,
         keys: ta.Mapping[Key, ta.Any],
-) -> ta.Generator[None]:
-    with i.provide(Key(SeededScope.Manager, tag=ss))(keys):
+) -> ta.AsyncGenerator[None]:
+    async with (await i.provide(Key(SeededScope.Manager, tag=ss)))(keys):
         yield
+
+
+def enter_seeded_scope(
+        i: '_sync.Injector',
+        ss: SeededScope,
+        keys: ta.Mapping[Key, ta.Any],
+) -> ta.ContextManager[None]:
+    return lang.run_maysync_context_manager(async_enter_seeded_scope(
+        i[AsyncInjector],
+        ss,
+        keys,
+    ))
+
+
+def maysync_enter_seeded_scope(
+        i: '_maysync.MaysyncInjector',
+        ss: SeededScope,
+        keys: ta.Mapping[Key, ta.Any],
+) -> ta.ContextManager[None]:
+    return lang.sync_async_context_manager(async_enter_seeded_scope(
+        i[AsyncInjector],
+        ss,
+        keys,
+    ))

omlish/inject/sync.py

@@ -0,0 +1,46 @@
+import abc
+import typing as ta
+
+from .. import lang
+from .elements import Elemental
+from .elements import as_elements
+from .inspect import KwargsTarget
+from .keys import Key
+
+
+with lang.auto_proxy_import(globals()):
+    from .impl import sync as _sync
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class Injector(lang.Abstract):
+    @abc.abstractmethod
+    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def provide(self, key: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def inject(self, obj: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    def __getitem__(
+            self,
+            target: Key[T] | type[T],
+    ) -> T:
+        return self.provide(target)
+
+
+def create_injector(*args: Elemental) -> Injector:
+    return _sync.create_injector(as_elements(*args))

omlish/lang/__init__.py

@@ -15,6 +15,9 @@ with _auto_proxy_init(
 
         sync_await,
         sync_async_list,
+
+        SyncAsyncContextManager,
+        sync_async_context_manager,
     )
 
     from .attrstorage import (  # noqa
@@ -184,6 +187,9 @@ with _auto_proxy_init(
         Timer,
 
         double_check_setdefault,
+
+        call_with_exit_stack,
+        call_with_async_exit_stack,
     )
 
     from .datetimes import (  # noqa
@@ -487,9 +493,6 @@ with _auto_proxy_init(
     )
 
     from ..lite.maysync import (  # noqa
-        mark_maysync,
-        is_maysync,
-
         AnyMaysyncFn,
 
         MaywaitableAlreadyConsumedError,
@@ -504,6 +507,12 @@ with _auto_proxy_init(
         is_running_maysync,
 
         run_maysync,
+
+        RunMaysyncContextManager,
+        run_maysync_context_manager,
+
+        mark_maysync,
+        is_maysync,
     )
 
     from ..lite.objects import (  # noqa

omlish/lang/asyncs.py

@@ -79,3 +79,21 @@ def sync_async_list(
         raise TypeError(lst)
 
     return lst
+
+
+@ta.final
+class SyncAsyncContextManager(ta.Generic[T]):
+    def __init__(self, acm: ta.AsyncContextManager[T]) -> None:
+        self._acm = acm
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._acm!r})'
+
+    def __enter__(self) -> T:
+        return sync_await(self._acm.__aenter__())
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return sync_await(self._acm.__aexit__(exc_type, exc_val, exc_tb))
+
+
+sync_async_context_manager = SyncAsyncContextManager

omlish/lang/contextmanagers.py

@@ -20,6 +20,8 @@ T = ta.TypeVar('T')
 K = ta.TypeVar('K')
 V = ta.TypeVar('V')
 
+P = ta.ParamSpec('P')
+
 
 ##
 
@@ -382,3 +384,24 @@ def double_check_setdefault(
         v = fn()
         dct[k] = v
         return v
+
+
+##
+
+
+def call_with_exit_stack(
+        fn: ta.Callable[ta.Concatenate[contextlib.ExitStack, P], T],
+        *args: ta.Any,
+        **kwargs: ta.Any,
+) -> T:
+    with contextlib.ExitStack() as es:
+        return fn(es, *args, **kwargs)
+
+
+async def call_with_async_exit_stack(
+        fn: ta.Callable[ta.Concatenate[contextlib.AsyncExitStack, P], ta.Awaitable[T]],
+        *args: ta.Any,
+        **kwargs: ta.Any,
+) -> T:
+    async with contextlib.AsyncExitStack() as aes:
+        return await fn(aes, *args, **kwargs)

omlish/lite/asyncs.py

@@ -18,3 +18,24 @@ def as_async(fn: ta.Callable[..., T], *, wrap: bool = False) -> ta.Callable[...,
         return fn(*args, **kwargs)
 
     return functools.wraps(fn)(inner) if wrap else inner
+
+
+##
+
+
+@ta.final
+class SyncToAsyncContextManager(ta.Generic[T]):
+    def __init__(self, cm: ta.ContextManager[T]) -> None:
+        self._cm = cm
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._cm!r})'
+
+    async def __aenter__(self) -> T:
+        return self._cm.__enter__()
+
+    async def __aexit__(self, exc_type, exc_value, traceback, /):
+        return self._cm.__exit__(exc_type, exc_value, traceback)
+
+
+as_async_context_manager = SyncToAsyncContextManager

omlish/lite/attrops.py

@@ -212,7 +212,7 @@ class AttrOps(ta.Generic[T]):
             return (
                 f'{o.__class__.__module__ + "." if self._with_module else ""}'
                 f'{o.__class__.__qualname__ if self._use_qualname else o.__class__.__name__}'
-                f'{("@" + hex(id(o))[2:]) if self._with_id else ""}'
+                f'{("@" + hex(id(o))[2:]) if self._with_id else ""}'  # noqa
                 f'({vs})'
             )
 

omlish/lite/inject.py

@@ -21,12 +21,12 @@ T = ta.TypeVar('T')
 U = ta.TypeVar('U')
 
 
-InjectorKeyCls = ta.Union[type, ta.NewType]
+InjectorKeyCls = ta.Union[type, ta.NewType]  # ta.TypeAlias
 
-InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
-InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']
+InjectorProviderFn = ta.Callable[['Injector'], ta.Any]  # ta.TypeAlias
+InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']  # ta.TypeAlias
 
-InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
+InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']  # ta.TypeAlias
 
 
 ###

omlish/lite/maysync.py

@@ -523,6 +523,27 @@ def run_maysync(m):
 ##
 
 
+@ta.final
+class RunMaysyncContextManager(ta.Generic[T]):
+    def __init__(self, acm: ta.AsyncContextManager[T]) -> None:
+        self._acm = acm
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._acm!r})'
+
+    def __enter__(self) -> T:
+        return run_maysync(self._acm.__aenter__())
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return run_maysync(self._acm.__aexit__(exc_type, exc_val, exc_tb))
+
+
+run_maysync_context_manager = RunMaysyncContextManager
+
+
+##
+
+
 _MAYSYNC_MARK_ATTR = '__maysync__'
 
 

omlish/marshal/__init__.py

@@ -1,14 +1,24 @@
 # ruff: noqa: I001
 """
 TODO:
- - redacted
- - strongly typed MarshalerFactory base class?
- - strongly typed Composite/Cached Marshaler/Unmarshaler factories - footgun
- - streaming? Start/EndObject, etc..
- - lang.Marker - class name, handle type[Foo]
-  - can't disambiguate from str - can't coexist in bare union
- - factories being free MatchFns does more harm than good - in practice these are such big guns you want to write a
-   class body if only ceremonially
+ - streaming?
+ - datatypes
+  - redacted
+  - lang.Marker - class name, handle type[Foo]
+  - pathlib.Path
+  - decimal.Decimal
+  - datetime.date, datetime.time
+  - ipaddress
+  - numpy types
+ - jackson switches
+  - accept_case_insensitive_enums
+  - accept_case_insensitive_properties
+  - accept_case_insensitive_values
+  - allow_coercion_of_scalars
+  - use_base_type_as_default_impl
+ - codegen
+ - context-local switches
+  - mutable_collections
  - simple lite interop like inj - alt ObjMarshalerManager impl for Context
 
 See:
@@ -16,6 +26,8 @@ See:
  - https://github.com/jcrist/msgspec
  - https://github.com/Fatal1ty/mashumaro
  - https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/serializers.md#custom-serializers
+ - https://github.com/yukinarit/pyserde
+ - https://github.com/FasterXML/jackson
 """
 from .. import dataclasses as _dc  # noqa
 

omlish/os/atomics.py

@@ -11,7 +11,7 @@ from ..lite.attrops import attr_repr
 from ..lite.check import check
 
 
-AtomicPathSwapKind = ta.Literal['dir', 'file']
+AtomicPathSwapKind = ta.Literal['dir', 'file']  # ta.TypeAlias
 AtomicPathSwapState = ta.Literal['open', 'committed', 'aborted']  # ta.TypeAlias
 
 

omlish/reflect/ops.py

@@ -1,3 +1,12 @@
+"""
+TODO:
+ - visitor / transformer
+  - gson had an ObjectNavigator:
+   - https://github.com/google/gson/blob/f291c4d33ea5fcc52afcfa5713e519e663378bda/gson/src/main/java/com/google/gson/ObjectNavigator.java
+   - removed in 25c6ae177b1ca56db7f3c29eb574bdd032a06165
+ - uniform collection isinstance - items() for mappings, iter() for other
+ - also check instance type in isinstance not just items lol
+"""  # noqa
 import dataclasses as dc
 import typing as ta