omlish 0.0.0.dev4__py3-none-any.whl → 0.0.0.dev5__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.dev4'
+__version__ = '0.0.0.dev5'

omlish/__init__.py

@@ -5,4 +5,4 @@ REQUIRED_PYTHON_VERSION = (3, 12)
 
 
 if _sys.version_info < REQUIRED_PYTHON_VERSION:
-    raise EnvironmentError(f'Python version {_sys.version_info=} < {REQUIRED_PYTHON_VERSION}')
+    raise RuntimeError(f'Python version {_sys.version_info=} < {REQUIRED_PYTHON_VERSION}')

omlish/asyncs/__init__.py

@@ -22,6 +22,7 @@ from .flavors import (  # noqa
     mark_asyncio,
     mark_flavor,
     mark_trio,
+    with_adapter_loop,
 )
 
 from .futures import (  # noqa
@@ -32,7 +33,3 @@ from .futures import (  # noqa
     wait_dependent_futures,
     wait_futures,
 )
-
-from .trio_asyncio import (  # noqa
-    with_trio_asyncio_loop,
-)

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/asyncs/flavors.py

@@ -7,10 +7,13 @@ TODO:
 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
@@ -79,7 +82,7 @@ def _get_module_flavor(p: str) -> Flavor | None:
     return pf
 
 
-def get_flavor(obj: ta.Any, default: ta.Union[Flavor, type[_MISSING], None] = _MISSING) -> Flavor:
+def get_flavor(obj: ta.Any, default: Flavor | type[_MISSING] | None = _MISSING) -> Flavor:
     u = lang.unwrap_func(obj)
 
     try:
@@ -100,6 +103,29 @@ def get_flavor(obj: ta.Any, default: ta.Union[Flavor, type[_MISSING], None] = _M
 ##
 
 
+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',

omlish/asyncs/trio_asyncio.py

@@ -3,12 +3,15 @@ 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')
 
@@ -18,24 +21,27 @@ def check_trio_asyncio() -> 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
+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')
+            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)
+            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 inner
+    return outer

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/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/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/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/collections/indexed.py

@@ -1,7 +1,7 @@
 import typing as ta
 
-from .identity import IdentitySet
 from .identity import IdentityKeyDict
+from .identity import IdentitySet
 
 
 T = ta.TypeVar('T')

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/configs/__init__.py

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

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]