omlish 0.0.0.dev3__tar.gz → 0.0.0.dev5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev3
+Version: 0.0.0.dev5
 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.dev5}/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.dev5'

omlish-0.0.0.dev5/omlish/__init__.py

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

omlish-0.0.0.dev5/omlish/asyncs/__init__.py

@@ -0,0 +1,35 @@
+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,
+    with_adapter_loop,
+)
+
+from .futures import (  # noqa
+    FutureError,
+    FutureTimeoutError,
+    ImmediateExecutor,
+    new_thread_or_immediate_executor,
+    wait_dependent_futures,
+    wait_futures,
+)

{omlish-0.0.0.dev3 → omlish-0.0.0.dev5}/omlish/asyncs/anyio.py

@@ -1,4 +1,9 @@
 """
+TODO:
+ - bane
+  - owned lock
+  - async once
+
 lookit:
  - https://github.com/davidbrochart/sqlite-anyio/blob/a3ba4c6ef0535b14a5a60071fcd6ed565a514963/sqlite_anyio/sqlite.py
  - https://github.com/rafalkrupinski/ratelimit-anyio/blob/2910a8a3d6fa54ed17ee6ba457686c9f7a4c4beb/src/ratelimit_anyio/__init__.py
@@ -84,3 +89,64 @@ async def gather(*fns: ta.Callable[..., ta.Awaitable[T]], take_first: bool = Fal
 
 async def first(*fns: ta.Callable[..., ta.Awaitable[T]], **kwargs: ta.Any) -> list[lang.Maybe[T]]:
     return await gather(*fns, take_first=True, **kwargs)
+
+
+##
+
+
+class Once:
+    def __init__(self) -> None:
+        super().__init__()
+        self._done = False
+        self._lock = anyio.Lock()
+
+    async def do(self, fn: ta.Callable[[], ta.Awaitable[None]]) -> bool:
+        if self._done:
+            return False
+        async with self._lock:
+            if self._done:
+                return False  # type: ignore
+            try:
+                await fn()
+            finally:
+                self._done = True
+            return True
+
+
+class Lazy(ta.Generic[T]):
+    def __init__(self) -> None:
+        super().__init__()
+        self._once = Once()
+        self._v: lang.Maybe[T] = lang.empty()
+
+    def peek(self) -> lang.Maybe[T]:
+        return self._v
+
+    def set(self, v: T) -> None:
+        self._v = lang.just(v)
+
+    async def get(self, fn: ta.Callable[[], ta.Awaitable[T]]) -> T:
+        async def do():
+            self._v = lang.just(await fn())
+        await self._once.do(do)
+        return self._v.must()
+
+
+class LazyFn(ta.Generic[T]):
+    def __init__(self, fn: ta.Callable[[], ta.Awaitable[T]]) -> None:
+        super().__init__()
+        self._fn = fn
+        self._once = Once()
+        self._v: lang.Maybe[T] = lang.empty()
+
+    def peek(self) -> lang.Maybe[T]:
+        return self._v
+
+    def set(self, v: T) -> None:
+        self._v = lang.just(v)
+
+    async def get(self) -> T:
+        async def do():
+            self._v = lang.just(await self._fn())
+        await self._once.do(do)
+        return self._v.must()

omlish-0.0.0.dev5/omlish/asyncs/flavors.py

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

omlish-0.0.0.dev5/omlish/asyncs/trio_asyncio.py

@@ -0,0 +1,47 @@
+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(*, wait=False):
+    def outer(fn):
+        @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
+
+    return outer

{omlish-0.0.0.dev3 → omlish-0.0.0.dev5}/omlish/c3.py

@@ -144,7 +144,7 @@ def compose_mro(
 
     # Remove entries which are strict bases of other entries (they will end up in the MRO anyway.
     def is_strict_base(typ):
-        for other in types:
+        for other in types:  # noqa
             if typ != other and typ in (get_mro(other) or []):
                 return True
         return False

{omlish-0.0.0.dev3 → omlish-0.0.0.dev5}/omlish/cached.py

@@ -1,6 +1,5 @@
-from .lang.cached import cached_function
 from .lang.cached import _CachedProperty  # noqa
-
+from .lang.cached import cached_function
 
 function = cached_function
 

{omlish-0.0.0.dev3 → omlish-0.0.0.dev5}/omlish/collections/__init__.py

@@ -90,9 +90,12 @@ from .utils import (  # noqa
     all_not_equal,
     indexes,
     key_cmp,
+    multi_map,
+    multi_map_by,
     mut_toposort,
     partition,
     toposort,
     unique,
-    unique_dict,
+    unique_map,
+    unique_map_by,
 )

{omlish-0.0.0.dev3 → omlish-0.0.0.dev5}/omlish/collections/cache/impl.py

@@ -55,7 +55,7 @@ class CacheImpl(Cache[K, V]):
         if not ta.TYPE_CHECKING:
             from ..._ext.cy.collections.cache import CacheLink as Link
         else:
-            raise ImportError
+            raise ImportError  # noqa
 
     except ImportError:
         class Link:

{omlish-0.0.0.dev3 → omlish-0.0.0.dev5}/omlish/collections/utils.py

@@ -12,6 +12,9 @@ K = ta.TypeVar('K')
 V = ta.TypeVar('V')
 
 
+##
+
+
 def mut_toposort(data: dict[T, set[T]]) -> ta.Iterator[set[T]]:
     for k, v in data.items():
         v.discard(k)
@@ -31,6 +34,9 @@ def toposort(data: ta.Mapping[T, ta.AbstractSet[T]]) -> ta.Iterator[set[T]]:
     return mut_toposort({k: set(v) for k, v in data.items()})
 
 
+##
+
+
 def partition(items: ta.Iterable[T], pred: ta.Callable[[T], bool]) -> tuple[list[T], list[T]]:
     t: list[T] = []
     f: list[T] = []
@@ -54,13 +60,36 @@ def unique(it: ta.Iterable[T], *, identity: bool = False) -> list[T]:
     return ret
 
 
-def unique_dict(items: ta.Iterable[tuple[K, V]], *, identity: bool = False) -> ta.MutableMapping[K, V]:
-    dct: ta.MutableMapping[K, V] = IdentityKeyDict() if identity else {}
-    for k, v in items:
-        if k in dct:
+def unique_map(kvs: ta.Iterable[tuple[K, V]], *, identity: bool = False) -> ta.MutableMapping[K, V]:
+    d: ta.MutableMapping[K, V] = IdentityKeyDict() if identity else {}
+    for k, v in kvs:
+        if k in d:
             raise KeyError(k)
-        dct[k] = v
-    return dct
+        d[k] = v
+    return d
+
+
+def unique_map_by(fn: ta.Callable[[V], K], vs: ta.Iterable[V], *, identity: bool = False) -> ta.MutableMapping[K, V]:
+    return unique_map(((fn(v), v) for v in vs), identity=identity)
+
+
+def multi_map(kvs: ta.Iterable[tuple[K, V]], *, identity: bool = False) -> ta.MutableMapping[K, list[V]]:
+    d: ta.MutableMapping[K, list[V]] = IdentityKeyDict() if identity else {}
+    l: list[V]
+    for k, v in kvs:
+        try:
+            l = d[k]
+        except KeyError:
+            l = d[k] = []
+        l.append(v)
+    return d
+
+
+def multi_map_by(fn: ta.Callable[[V], K], vs: ta.Iterable[V], *, identity: bool = False) -> ta.MutableMapping[K, list[V]]:  # noqa
+    return multi_map(((fn(v), v) for v in vs), identity=identity)
+
+
+##
 
 
 def all_equal(it: ta.Iterable[T]) -> bool:
@@ -81,6 +110,9 @@ def all_not_equal(it: ta.Iterable[T]) -> bool:
     return True
 
 
+##
+
+
 def key_cmp(fn: ta.Callable[[K, K], int]) -> ta.Callable[[tuple[K, V], tuple[K, V]], int]:
     return lambda t0, t1: fn(t0[0], t1[0])
 

omlish-0.0.0.dev5/omlish/configs/__init__.py

@@ -0,0 +1,5 @@
+from .classes import (  # noqa
+    Config,
+    Configurable,
+    get_impl,
+)

omlish-0.0.0.dev5/omlish/configs/classes.py

@@ -0,0 +1,53 @@
+import typing as ta
+import weakref
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+
+
+class Config(
+    dc.Data,
+    lang.Abstract,
+    frozen=True,
+    reorder=True,
+    confer=frozenset([
+        'frozen',
+        'reorder',
+        'confer',
+    ]),
+):
+    pass
+
+
+ConfigT = ta.TypeVar('ConfigT', bound='Config')
+
+_CONFIG_CLS_MAP: ta.MutableMapping[type[Config], type['Configurable']] = weakref.WeakValueDictionary()
+
+
+class Configurable(ta.Generic[ConfigT], lang.Abstract):
+
+    # FIXME: https://github.com/python/mypy/issues/5144
+    Config: ta.ClassVar[type[ConfigT]]  # type: ignore  # noqa
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        cfg_cls = check.issubclass(cls.__dict__['Config'], Config)
+        check.not_in(cfg_cls, _CONFIG_CLS_MAP)
+        _CONFIG_CLS_MAP[cfg_cls] = cls
+
+    def __init__(self, config: ConfigT) -> None:
+        super().__init__()
+
+        self._config: ConfigT = check.isinstance(config, self.Config)
+
+
+def get_impl(cfg: type[Config] | Config) -> type[Configurable]:
+    if isinstance(cfg, type):
+        cfg_cls = check.issubclass(cfg, Config)  # noqa
+    elif isinstance(cfg, Config):
+        cfg_cls = type(cfg)
+    else:
+        raise TypeError(cfg)
+    return _CONFIG_CLS_MAP[cfg_cls]