omlish 0.0.0.dev398__py3-none-any.whl → 0.0.0.dev400__py3-none-any.whl

omlish/__about__.py

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

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

@@ -1,165 +1,151 @@
 # ruff: noqa: I001
-import typing as _ta
-
 from .. import lang as _lang
 
 
-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,
-)
-
-if _ta.TYPE_CHECKING:
-    from . import kv
-else:
-    kv = _lang.proxy_import('.kv', __package__)
-
-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,
-)
-
-if _ta.TYPE_CHECKING:
+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,
     )
-else:
-    _lang.proxy_init(globals(), '.persistent.treapmap', [
-        'TreapMap',
-        'new_treap_map',
-    ])
 
-from .ranked import (  # noqa
-    RankedSeq,
-    RankedSetSeq,
-)
+    from .ranked import (  # noqa
+        RankedSeq,
+        RankedSetSeq,
+    )
 
-if _ta.TYPE_CHECKING:
     from .sorted.skiplist import (  # noqa
         SkipList,
         SkipListDict,
     )
-else:
-    _lang.proxy_init(globals(), '.sorted.skiplist', [
-        '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,
-)
+
+    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/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/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/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/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/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/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