omlish 0.0.0.dev398__tar.gz → 0.0.0.dev400__tar.gz

{omlish-0.0.0.dev398/omlish.egg-info → omlish-0.0.0.dev400}/PKG-INFO

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

{omlish-0.0.0.dev398 → omlish-0.0.0.dev400}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev398'
-__revision__ = '36ad9ea49db19a697cb584dc80f1fac002db95f3'
+__version__ = '0.0.0.dev400'
+__revision__ = '4e9cb702d1d048bb8211070b471983d3b4d7bb6d'
 
 
 #

{omlish-0.0.0.dev398 → omlish-0.0.0.dev400}/omlish/bootstrap/__init__.py

@@ -37,6 +37,6 @@ from .sys import (  # noqa
 ##
 
 
-from ..lang.imports import _register_conditional_import  # noqa
+from .. import lang as _lang
 
-_register_conditional_import('..marshal', '.marshal', __package__)
+_lang.register_conditional_import('..marshal', '.marshal', __package__)

omlish-0.0.0.dev400/omlish/collections/__init__.py

@@ -0,0 +1,151 @@
+# ruff: noqa: I001
+from .. import lang as _lang
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from .bimap import (  # noqa
+        BiMap,
+
+        make_bi_map,
+    )
+
+    from .coerce import (  # noqa
+        abs_set,
+        abs_set_of,
+        abs_set_of_or_none,
+        abs_set_or_none,
+        frozenset_,
+        frozenset_of,
+        frozenset_of_or_none,
+        frozenset_or_none,
+        map,  # noqa
+        map_of,
+        map_of_or_none,
+        map_or_none,
+        opt_abs_set,
+        opt_abs_set_of,
+        opt_frozenset,
+        opt_frozenset_of,
+        opt_map,
+        opt_map_of,
+        opt_seq,
+        opt_seq_of,
+        seq,
+        seq_of,
+        seq_of_or_none,
+        seq_or_none,
+    )
+
+    from .frozen import (  # noqa
+        Frozen,
+        FrozenDict,
+        FrozenList,
+        frozendict,
+        frozenlist,
+    )
+
+    from .hasheq import (  # noqa
+        HashEq,
+        HashEqMap,
+        HashEq_,
+        hash_eq,
+    )
+
+    from .identity import (  # noqa
+        IdentityKeyDict,
+        IdentitySet,
+        IdentityWeakKeyDictionary,
+        IdentityWeakSet,
+    )
+
+    from . import kv  # noqa
+
+    from .mappings import (  # noqa
+        MissingDict,
+        TypeMap,
+        DynamicTypeMap,
+        guarded_map_update,
+        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,
+    )
+
+    from .persistent.persistent import (  # noqa
+        PersistentMap,
+        PersistentMapping,
+    )
+
+    from .persistent.treapmap import (  # noqa
+        TreapDict,
+        TreapMap,
+        new_treap_dict,
+        new_treap_map,
+    )
+
+    from .ranked import (  # noqa
+        RankedSeq,
+        RankedSetSeq,
+    )
+
+    from .sorted.skiplist import (  # noqa
+        SkipList,
+        SkipListDict,
+    )
+
+    from .sorted.sorted import (  # noqa
+        SortedCollection,
+        SortedItems,
+        SortedIter,
+        SortedListDict,
+        SortedMapping,
+        SortedMutableMapping,
+    )
+
+    from .trie import (  # noqa
+        Trie,
+    )
+
+    from .unmodifiable import (  # noqa
+        Unmodifiable,
+        UnmodifiableMapping,
+        UnmodifiableSequence,
+        UnmodifiableSet,
+    )
+
+    from .utils import (  # noqa
+        PartitionResult,
+        all_equal,
+        all_not_equal,
+        indexes,
+        key_cmp,
+        make_map,
+        make_map_by,
+        multi_map,
+        multi_map_by,
+        partition,
+        unique,
+    )

{omlish-0.0.0.dev398 → omlish-0.0.0.dev400}/omlish/configs/formats.py

@@ -150,14 +150,18 @@ class YamlConfigLoader(ConfigLoader[YamlConfigData]):
     file_exts = ('yaml', 'yml')
 
     def load_str(self, s: str) -> YamlConfigData:
-        return YamlConfigData(__import__('yaml').safe_load(s))
+        import yaml  # noqa
+
+        return YamlConfigData(yaml.safe_load(s))
 
 
 class YamlConfigRenderer(ConfigRenderer[YamlConfigData]):
     data_cls = YamlConfigData
 
     def render(self, d: YamlConfigData) -> str:
-        return __import__('yaml').safe_dump(d.obj)
+        import yaml  # noqa
+
+        return yaml.safe_dump(d.obj)
 
 
 ##

{omlish-0.0.0.dev398 → omlish-0.0.0.dev400}/omlish/diag/lsof.py

@@ -243,20 +243,21 @@ class LsofCommand(SubprocessRunnable[ta.List[LsofItem]]):
 
 if __name__ == '__main__':
     def _main() -> None:
-        argparse = __import__('argparse')
+        import argparse  # noqa
+        import importlib  # noqa
+        import json  # noqa
+
         parser = argparse.ArgumentParser()
         parser.add_argument('--pid', '-p', type=int)
         parser.add_argument('file', nargs='?')
         args = parser.parse_args()
 
-        importlib = __import__('importlib')
         subprocesses = importlib.import_module('..subprocesses.sync', package=__package__).subprocesses
         items = LsofCommand(
             pid=args.pid,
             file=args.file,
         ).run(subprocesses)
 
-        json = __import__('json')
         marshal_obj = importlib.import_module('..lite.marshal', package=__package__).marshal_obj
         print(json.dumps(marshal_obj(items), indent=2))
 

{omlish-0.0.0.dev398 → omlish-0.0.0.dev400}/omlish/funcs/builders.py

@@ -70,7 +70,8 @@ class DebugFnBuilder(FnBuilder):
         if self._given_src_dir is not None:
             return self._given_src_dir
         else:
-            return __import__('tempfile').mkdtemp(prefix=f'_{self.__class__.__name__}_{os.getpid()}__')  # noqa
+            import tempfile  # noqa
+            return tempfile.mkdtemp(prefix=f'_{self.__class__.__name__}_{os.getpid()}__')  # noqa
 
     @cached_nullary
     def _install_sys_path(self) -> None:

{omlish-0.0.0.dev398 → omlish-0.0.0.dev400}/omlish/lang/__init__.py

@@ -219,16 +219,33 @@ from .generators import (  # noqa
     nextgen,
 )
 
-from .imports import (  # noqa
-    LazyGlobals,
-    can_import,
-    get_real_module_name,
-    import_all,
+from .imports.conditional import (  # noqa
+    register_conditional_import,
+    trigger_conditional_imports,
+)
+
+from .imports.lazy import (  # noqa
     lazy_import,
     proxy_import,
+)
+
+from .imports.proxyinit import (  # noqa
     proxy_init,
+
+    AutoProxyInitError,
+    AutoProxyInitErrors,
+    auto_proxy_init,
+)
+
+from .imports.resolution import (  # noqa
+    can_import,
+    get_real_module_name,
     resolve_import_name,
     try_import,
+)
+
+from .imports.traversal import (  # noqa
+    import_all,
     yield_import_all,
     yield_importable,
 )
@@ -251,6 +268,10 @@ from .iterables import (  # noqa
     take,
 )
 
+from .lazyglobals import (  # noqa
+    LazyGlobals,
+)
+
 from .maysyncs import (  # noqa
     MaysyncP,
 

omlish-0.0.0.dev400/omlish/lang/imports/conditional.py

@@ -0,0 +1,33 @@
+import sys
+
+from .resolution import resolve_import_name
+
+
+##
+
+
+# dict[str, None] to preserve insertion order - we don't have OrderedSet here
+_REGISTERED_CONDITIONAL_IMPORTS: dict[str, dict[str, None] | None] = {}
+
+
+def register_conditional_import(when: str, then: str, package: str | None = None) -> None:
+    wn = resolve_import_name(when, package)
+    tn = resolve_import_name(then, package)
+    if tn in sys.modules:
+        return
+    if wn in sys.modules:
+        __import__(tn)
+    else:
+        tns = _REGISTERED_CONDITIONAL_IMPORTS.setdefault(wn, {})
+        if tns is None:
+            raise Exception(f'Conditional import trigger already cleared: {wn=} {tn=}')
+        tns[tn] = None
+
+
+def trigger_conditional_imports(package: str) -> None:
+    tns = _REGISTERED_CONDITIONAL_IMPORTS.get(package, {})
+    if tns is None:
+        raise Exception(f'Conditional import trigger already cleared: {package=}')
+    _REGISTERED_CONDITIONAL_IMPORTS[package] = None
+    for tn in tns:
+        __import__(tn)

omlish-0.0.0.dev400/omlish/lang/imports/lazy.py

@@ -0,0 +1,66 @@
+import importlib.util
+import types
+import typing as ta
+
+
+##
+
+
+def lazy_import(
+        name: str,
+        package: str | None = None,
+        *,
+        optional: bool = False,
+        cache_failure: bool = False,
+) -> ta.Callable[[], ta.Any]:
+    result = not_set = object()
+
+    def inner():
+        nonlocal result
+
+        if result is not not_set:
+            if isinstance(result, Exception):
+                raise result
+            return result
+
+        try:
+            mod = importlib.import_module(name, package=package)
+
+        except Exception as e:
+            if optional:
+                if cache_failure:
+                    result = None
+                return None
+
+            if cache_failure:
+                result = e
+            raise
+
+        result = mod
+        return mod
+
+    return inner
+
+
+def proxy_import(
+        name: str,
+        package: str | None = None,
+        extras: ta.Iterable[str] | None = None,
+) -> types.ModuleType:
+    if isinstance(extras, str):
+        raise TypeError(extras)
+
+    omod = None
+
+    def __getattr__(att):  # noqa
+        nonlocal omod
+        if omod is None:
+            omod = importlib.import_module(name, package=package)
+            if extras:
+                for x in extras:
+                    importlib.import_module(f'{name}.{x}', package=package)
+        return getattr(omod, att)
+
+    lmod = types.ModuleType(name)
+    lmod.__getattr__ = __getattr__  # type: ignore
+    return lmod