omlish 0.0.0.dev339__tar.gz → 0.0.0.dev341__tar.gz

{omlish-0.0.0.dev339/omlish.egg-info → omlish-0.0.0.dev341}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev339
+Version: 0.0.0.dev341
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev339 → omlish-0.0.0.dev341}/README.md

@@ -14,7 +14,7 @@ Core utilities and foundational code. It's relatively large but completely self-
     late-loaded module globals.
   - **[classes](lang/classes)** - Class tools and bases, such as `Abstract` (which checks at subclass definition not
     instantiation), `Sealed` / `PackageSealed`, and `Final`.
-  - **[maybes](lang/maybes.py)** - A simple, nestable formalization of the presence or absence of an object, as in
+  - **[maybes](lite/maybes.py)** - A simple, nestable formalization of the presence or absence of an object, as in
     [many](https://en.cppreference.com/w/cpp/utility/optional)
     [other](https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html)
     [languages](https://doc.rust-lang.org/std/option/).

{omlish-0.0.0.dev339 → omlish-0.0.0.dev341}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev339'
-__revision__ = '0d8d4714d9a9ea7145586e0bce55833b86e980bd'
+__version__ = '0.0.0.dev341'
+__revision__ = '4154c2c5976e0a4a31e0d9647362a710be0805fa'
 
 
 #

{omlish-0.0.0.dev339 → omlish-0.0.0.dev341}/omlish/asyncs/bluelet/LICENSE

@@ -1,6 +1,6 @@
 Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
 
-THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{omlish-0.0.0.dev339 → omlish-0.0.0.dev341}/omlish/asyncs/bluelet/api.py

@@ -1,7 +1,7 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
 # Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{omlish-0.0.0.dev339 → omlish-0.0.0.dev341}/omlish/asyncs/bluelet/core.py

@@ -1,7 +1,7 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
 # Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{omlish-0.0.0.dev339 → omlish-0.0.0.dev341}/omlish/asyncs/bluelet/events.py

@@ -1,7 +1,7 @@
 # ruff: noqa: UP007
 # @omlish-lite
 # Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{omlish-0.0.0.dev339 → omlish-0.0.0.dev341}/omlish/asyncs/bluelet/files.py

@@ -1,7 +1,7 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
 # Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{omlish-0.0.0.dev339 → omlish-0.0.0.dev341}/omlish/asyncs/bluelet/runner.py

@@ -1,7 +1,7 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
 # Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

{omlish-0.0.0.dev339 → omlish-0.0.0.dev341}/omlish/asyncs/bluelet/sockets.py

@@ -1,7 +1,7 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
 # Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

omlish-0.0.0.dev341/omlish/check.py

@@ -0,0 +1,271 @@
+"""
+While the core functionality lives in `lite/check.py` and is available in lite code, this module re-exports the contents
+of its `check` API object as module-globals for convenience. It also sets up some non-lite integration, most notably
+`ArgsRenderer` for rendering the AST's and values of failed checks (if the necessary optional dependencies are present).
+"""
+import typing as ta
+
+from .lite.check import CheckArgsRenderer as ArgsRenderer  # noqa
+from .lite.check import CheckExceptionFactory as ExceptionFactory  # noqa
+from .lite.check import CheckLateConfigureFn as LateConfigureFn  # noqa
+from .lite.check import CheckMessage as Message  # noqa
+from .lite.check import CheckOnRaiseFn as OnRaiseFn  # noqa
+from .lite.check import Checks
+from .lite.check import check
+
+
+T = ta.TypeVar('T')
+SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
+
+
+_isinstance = isinstance
+_issubclass = issubclass
+_callable = callable
+
+
+##
+
+
+def register_on_raise(fn: OnRaiseFn) -> None:
+    check.register_on_raise(fn)
+
+
+def unregister_on_raise(fn: OnRaiseFn) -> None:
+    check.unregister_on_raise(fn)
+
+
+##
+
+
+def _try_get_args_rendering() -> ArgsRenderer | None:
+    try:
+        from .diag.asts import ArgsRenderer
+
+        ArgsRenderer.smoketest()
+
+    except Exception:  # noqa
+        return None
+
+    def _real_render_args(fmt: str, *args: ta.Any) -> str | None:
+        ra = ArgsRenderer(back=3).render_args(*args)
+        if ra is None:
+            return None
+
+        return fmt % tuple(str(a) for a in ra)
+
+    return _real_render_args
+
+
+def _try_enable_args_rendering(c: Checks) -> None:
+    if (rf := _try_get_args_rendering()) is not None:
+        c.set_args_renderer(rf)
+
+
+check.register_late_configure(_try_enable_args_rendering)
+
+
+##
+# The following code manually proxies to the lite code, as opposed to simply assigning global names to instance methods
+# of `check`, to assist type analysis in tools - pycharm for example has a hard time deducing the return types in such
+# cases. The functions are however dynamically overwritten below with direct references to the method to remove one
+# layer of call indirection at runtime.
+
+
+_CHECK_PROXY_FUNCTIONS: dict[str, ta.Any] = {}
+
+
+def _check_proxy_function(fn: T) -> T:
+    name = fn.__name__  # type: ignore[attr-defined]
+    if name in _CHECK_PROXY_FUNCTIONS:
+        raise NameError(fn)
+    _CHECK_PROXY_FUNCTIONS[name] = fn
+    return fn
+
+
+##
+
+
+@ta.overload
+def isinstance(v: ta.Any, spec: type[T], msg: Message = None) -> T:  # noqa
+    ...
+
+
+@ta.overload
+def isinstance(v: ta.Any, spec: ta.Any, msg: Message = None) -> ta.Any:  # noqa
+    ...
+
+
+@_check_proxy_function
+def isinstance(v, spec, msg=None):  # noqa
+    return check.isinstance(v, spec, msg=msg)
+
+
+@ta.overload
+def of_isinstance(spec: type[T], msg: Message = None) -> ta.Callable[[ta.Any], T]:
+    ...
+
+
+@ta.overload
+def of_isinstance(spec: ta.Any, msg: Message = None) -> ta.Callable[[ta.Any], ta.Any]:
+    ...
+
+
+@_check_proxy_function
+def of_isinstance(spec, msg=None):
+    return check.of_isinstance(spec, msg=msg)
+
+
+@_check_proxy_function
+def cast(v: ta.Any, cls: type[T], msg: Message = None) -> T:
+    return check.cast(v, cls, msg=msg)
+
+
+@_check_proxy_function
+def of_cast(cls: type[T], msg: Message = None) -> ta.Callable[[T], T]:
+    return check.of_cast(cls, msg=msg)
+
+
+@_check_proxy_function
+def not_isinstance(v: T, spec: ta.Any, msg: Message = None) -> T:
+    return check.not_isinstance(v, spec, msg=msg)
+
+
+@_check_proxy_function
+def of_not_isinstance(spec: ta.Any, msg: Message = None) -> ta.Callable[[T], T]:
+    return check.of_not_isinstance(spec, msg=msg)
+
+
+#
+
+
+@_check_proxy_function
+def issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:  # noqa
+    return check.issubclass(v, spec, msg=msg)
+
+
+@_check_proxy_function
+def not_issubclass(v: type[T], spec: ta.Any, msg: Message = None) -> type[T]:
+    return check.not_issubclass(v, spec, msg=msg)
+
+
+#
+
+
+@_check_proxy_function
+def in_(v: T, c: ta.Container[T], msg: Message = None) -> T:
+    return check.in_(v, c, msg=msg)
+
+
+@_check_proxy_function
+def not_in(v: T, c: ta.Container[T], msg: Message = None) -> T:
+    return check.not_in(v, c, msg=msg)
+
+
+@_check_proxy_function
+def empty(v: SizedT, msg: Message = None) -> SizedT:
+    return check.empty(v, msg=msg)
+
+
+@_check_proxy_function
+def iterempty(v: ta.Iterable[T], msg: Message = None) -> ta.Iterable[T]:
+    return check.iterempty(v, msg=msg)
+
+
+@_check_proxy_function
+def not_empty(v: SizedT, msg: Message = None) -> SizedT:
+    return check.not_empty(v, msg=msg)
+
+
+@_check_proxy_function
+def unique(it: ta.Iterable[T], msg: Message = None) -> ta.Iterable[T]:
+    return check.unique(it, msg=msg)
+
+
+@_check_proxy_function
+def single(obj: ta.Iterable[T], msg: Message = None) -> T:
+    return check.single(obj, msg=msg)
+
+
+@_check_proxy_function
+def opt_single(obj: ta.Iterable[T], msg: Message = None) -> T | None:
+    return check.opt_single(obj, msg=msg)
+
+
+#
+
+
+@_check_proxy_function
+def none(v: ta.Any, msg: Message = None) -> None:
+    return check.none(v, msg=msg)
+
+
+@_check_proxy_function
+def not_none(v: T | None, msg: Message = None) -> T:
+    return check.not_none(v, msg=msg)
+
+
+#
+
+
+@_check_proxy_function
+def equal(v: T, o: ta.Any, msg: Message = None) -> T:
+    return check.equal(v, o, msg=msg)
+
+
+@_check_proxy_function
+def not_equal(v: T, o: ta.Any, msg: Message = None) -> T:
+    return check.not_equal(v, o, msg=msg)
+
+
+@_check_proxy_function
+def is_(v: T, o: ta.Any, msg: Message = None) -> T:
+    return check.is_(v, o, msg=msg)
+
+
+@_check_proxy_function
+def is_not(v: T, o: ta.Any, msg: Message = None) -> T:
+    return check.is_not(v, o, msg=msg)
+
+
+@_check_proxy_function
+def callable(v: T, msg: Message = None) -> T:  # noqa
+    return check.callable(v, msg=msg)
+
+
+@_check_proxy_function
+def non_empty_str(v: str | None, msg: Message = None) -> str:
+    return check.non_empty_str(v, msg=msg)
+
+
+@_check_proxy_function
+def replacing(expected: ta.Any, old: ta.Any, new: T, msg: Message = None) -> T:
+    return check.replacing(expected, old, new, msg=msg)
+
+
+@_check_proxy_function
+def replacing_none(old: ta.Any, new: T, msg: Message = None) -> T:
+    return check.replacing_none(old, new, msg=msg)
+
+
+#
+
+
+@_check_proxy_function
+def arg(v: bool, msg: Message = None) -> None:
+    return check.arg(v, msg=msg)
+
+
+@_check_proxy_function
+def state(v: bool, msg: Message = None) -> None:
+    return check.state(v, msg=msg)
+
+
+##
+
+
+def _install_direct_check_proxy_functions() -> None:
+    for n in _CHECK_PROXY_FUNCTIONS:
+        globals()[n] = getattr(check, n)
+
+
+_install_direct_check_proxy_functions()

{omlish-0.0.0.dev339 → omlish-0.0.0.dev341}/omlish/collections/__init__.py

@@ -76,6 +76,25 @@ from .mappings import (  # noqa
     multikey_dict,
 )
 
+from .multimaps import (  # noqa
+    MultiMap,
+
+    SequenceMultiMap,
+    AbstractSetMultiMap,
+
+    BiMultiMap,
+    InverseBiMultiMap,
+
+    SequenceBiMultiMap,
+    AbstractSetBiMultiMap,
+
+    TupleBiMultiMap,
+    seq_bi_multi_map,
+
+    FrozensetBiMultiMap,
+    abs_set_bi_multi_map,
+)
+
 from .ordered import (  # noqa
     OrderedFrozenSet,
     OrderedSet,

omlish-0.0.0.dev341/omlish/collections/multimaps.py

@@ -0,0 +1,151 @@
+import abc
+import typing as ta
+
+from .. import lang
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+MV = ta.TypeVar('MV', bound=ta.Iterable)
+
+
+##
+
+
+class MultiMap(ta.Mapping[K, MV], abc.ABC, ta.Generic[K, V, MV]):
+    pass
+
+
+SequenceMultiMap: ta.TypeAlias = MultiMap[K, V, ta.Sequence[V]]
+AbstractSetMultiMap: ta.TypeAlias = MultiMap[K, V, ta.AbstractSet[V]]
+
+
+##
+
+
+class BiMultiMap(MultiMap[K, V, MV], abc.ABC, ta.Generic[K, V, MV]):
+    @abc.abstractmethod
+    def inverse(self) -> 'InverseBiMultiMap[K, V, MV]':
+        raise NotImplementedError
+
+
+class InverseBiMultiMap(ta.Mapping[V, K], abc.ABC, ta.Generic[K, V, MV]):
+    @abc.abstractmethod
+    def inverse(self) -> BiMultiMap[K, V, MV]:
+        raise NotImplementedError
+
+
+SequenceBiMultiMap: ta.TypeAlias = BiMultiMap[K, V, ta.Sequence[V]]
+AbstractSetBiMultiMap: ta.TypeAlias = BiMultiMap[K, V, ta.AbstractSet[V]]
+
+
+##
+
+
+class InverseBiMultiMapImpl(InverseBiMultiMap[K, V, MV], ta.Generic[K, V, MV]):
+    def __init__(self, m: BiMultiMap[K, V, MV], dct: ta.Mapping[V, K]) -> None:
+        super().__init__()
+
+        self._m = m
+        self._dct = dct
+
+    def inverse(self) -> BiMultiMap[K, V, MV]:
+        return self._m
+
+    def __getitem__(self, key: V, /) -> K:
+        return self._dct[key]
+
+    def __len__(self) -> int:
+        return len(self._dct)
+
+    def __iter__(self) -> ta.Iterator[V]:
+        return iter(self._dct)
+
+
+class BaseBiMultiMap(BiMultiMap[K, V, MV], abc.ABC, ta.Generic[K, V, MV]):
+    def __init__(self, *args: ta.Any, **kwargs: ta.Any) -> None:
+        super().__init__()
+
+        dct: dict[K, MV] = {}
+        i_dct: dict[V, K] = {}
+        for k, mv in lang.yield_dict_init(*args, **kwargs):
+            l: list[V] = []
+            for v in mv:
+                if v in i_dct:
+                    raise KeyError(v)
+                l.append(v)
+                i_dct[v] = k
+            dct[k] = self._aggregate_values(l)
+
+        self._dct = dct
+        self._i: InverseBiMultiMap[K, V, MV] = InverseBiMultiMapImpl(self, i_dct)
+
+    @abc.abstractmethod
+    def _aggregate_values(self, vs: list[V]) -> MV:
+        raise NotImplementedError
+
+    def inverse(self) -> 'InverseBiMultiMap[K, V, MV]':
+        return self._i
+
+    def __getitem__(self, key: K, /) -> MV:
+        return self._dct[key]
+
+    def __len__(self) -> int:
+        return len(self._dct)
+
+    def __iter__(self) -> ta.Iterator[K]:
+        return iter(self._dct)
+
+
+#
+
+
+class TupleBiMultiMap(BaseBiMultiMap[K, V, tuple[V, ...]], ta.Generic[K, V]):
+    def _aggregate_values(self, vs: list[V]) -> tuple[V, ...]:
+        return tuple(vs)
+
+
+# FIXME: lame
+# lang.static_check_issubclass[BiMultiMap[int, str, tuple[str, ...]]](TupleBiMultiMap[int, str])
+# lang.static_check_issubclass[BiMultiMap[int, str, ta.Sequence[str]]](TupleBiMultiMap[int, str])
+# lang.static_check_issubclass[SequenceBiMultiMap[int, str]](TupleBiMultiMap[int, str])
+
+
+@ta.overload
+def seq_bi_multi_map(dct: ta.Mapping[K, ta.Iterable[V]]) -> SequenceBiMultiMap[K, V]:
+    ...
+
+
+@ta.overload
+def seq_bi_multi_map(items: ta.Iterable[tuple[K, ta.Iterable[V]]]) -> SequenceBiMultiMap[K, V]:
+    ...
+
+
+def seq_bi_multi_map(*args, **kwargs):
+    return TupleBiMultiMap(*args, **kwargs)
+
+
+#
+
+
+class FrozensetBiMultiMap(BaseBiMultiMap[K, V, frozenset[V]], ta.Generic[K, V]):
+    def _aggregate_values(self, vs: list[V]) -> frozenset[V]:
+        return frozenset(vs)
+
+
+# FIXME: lame
+# lang.static_check_issubclass[AbstractSetBiMultiMap[int, str]](FrozensetBiMultiMap[int, str])
+
+
+@ta.overload
+def abs_set_bi_multi_map(dct: ta.Mapping[K, ta.Iterable[V]]) -> AbstractSetBiMultiMap[K, V]:
+    ...
+
+
+@ta.overload
+def abs_set_bi_multi_map(items: ta.Iterable[tuple[K, ta.Iterable[V]]]) -> AbstractSetBiMultiMap[K, V]:
+    ...
+
+
+def abs_set_bi_multi_map(*args, **kwargs):
+    return FrozensetBiMultiMap(*args, **kwargs)

{omlish-0.0.0.dev339 → omlish-0.0.0.dev341}/omlish/formats/json/__init__.py

@@ -12,10 +12,21 @@ from ... import lang as _lang
 from .backends import (  # noqa
     Backend,
 
-    DEFAULT_BACKED,
+    default_backend,
 
     StdBackend,
-    STD_BACKEND,
+    std_backend,
+)
+
+from .backends.default import (  # noqa
+    dump,
+    dump_compact,
+    dump_pretty,
+    dumps,
+    dumps_compact,
+    dumps_pretty,
+    load,
+    loads,
 )
 
 from .consts import (  # noqa
@@ -32,17 +43,6 @@ from .encoding import (  # noqa
     detect_encoding,
 )
 
-from .json import (  # noqa
-    dump,
-    dump_compact,
-    dump_pretty,
-    dumps,
-    dumps_compact,
-    dumps_pretty,
-    load,
-    loads,
-)
-
 if _ta.TYPE_CHECKING:
     from .rendering import (  # noqa
         JsonRenderer,

{omlish-0.0.0.dev339 → omlish-0.0.0.dev341}/omlish/formats/json/backends/__init__.py

@@ -3,10 +3,10 @@ from .base import (  # noqa
 )
 
 from .default import (  # noqa
-    DEFAULT_BACKED,
+    default_backend,
 )
 
 from .std import (  # noqa
     StdBackend,
-    STD_BACKEND,
+    std_backend,
 )

omlish-0.0.0.dev341/omlish/formats/json/backends/default.py

@@ -0,0 +1,57 @@
+import typing as ta
+
+from .... import lang
+from .base import Backend
+from .orjson import orjson_backend
+from .std import std_backend
+from .ujson import ujson_backend
+
+
+##
+
+
+@lang.cached_function
+def default_backend() -> Backend:
+    for fn in [
+        orjson_backend,
+        ujson_backend,
+    ]:
+        if (be := fn()) is not None:
+            return be
+
+    return std_backend()
+
+
+##
+
+
+def dump(obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+    return default_backend().dump(obj, fp, **kwargs)
+
+
+def dumps(obj: ta.Any, **kwargs: ta.Any) -> str:
+    return default_backend().dumps(obj, **kwargs)
+
+
+def load(fp: ta.Any, **kwargs: ta.Any) -> ta.Any:
+    return default_backend().load(fp, **kwargs)
+
+
+def loads(s: str | bytes | bytearray, **kwargs: ta.Any) -> ta.Any:
+    return default_backend().loads(s, **kwargs)
+
+
+def dump_pretty(obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+    return default_backend().dump_pretty(obj, fp, **kwargs)
+
+
+def dumps_pretty(obj: ta.Any, **kwargs: ta.Any) -> str:
+    return default_backend().dumps_pretty(obj, **kwargs)
+
+
+def dump_compact(obj: ta.Any, fp: ta.Any, **kwargs: ta.Any) -> None:
+    return default_backend().dump_compact(obj, fp, **kwargs)
+
+
+def dumps_compact(obj: ta.Any, **kwargs: ta.Any) -> str:
+    return default_backend().dumps_compact(obj, **kwargs)

{omlish-0.0.0.dev339 → omlish-0.0.0.dev341}/omlish/formats/json/backends/orjson.py

@@ -109,8 +109,9 @@ class OrjsonBackend(Backend):
         return self.dumps(obj, **kwargs)
 
 
-ORJSON_BACKEND: OrjsonBackend | None
-if lang.can_import('orjson'):
-    ORJSON_BACKEND = OrjsonBackend()
-else:
-    ORJSON_BACKEND = None
+@lang.cached_function
+def orjson_backend() -> OrjsonBackend | None:
+    if lang.can_import('orjson'):
+        return OrjsonBackend()
+    else:
+        return None

{omlish-0.0.0.dev339 → omlish-0.0.0.dev341}/omlish/formats/json/backends/std.py

@@ -8,6 +8,7 @@ import dataclasses as dc
 import json
 import typing as ta
 
+from .... import lang
 from ..consts import COMPACT_KWARGS
 from ..consts import PRETTY_KWARGS
 from .base import Backend
@@ -73,4 +74,6 @@ class StdBackend(Backend):
         return json.dumps(obj, **COMPACT_KWARGS, **kwargs)
 
 
-STD_BACKEND = StdBackend()
+@lang.cached_function
+def std_backend() -> StdBackend:
+    return StdBackend()