omlish 0.0.0.dev399__tar.gz → 0.0.0.dev401__tar.gz

{omlish-0.0.0.dev399/omlish.egg-info → omlish-0.0.0.dev401}/PKG-INFO

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

{omlish-0.0.0.dev399 → omlish-0.0.0.dev401}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev399'
-__revision__ = 'a8c0f1b2847879fa35db7e882438c69db3bd3b7c'
+__version__ = '0.0.0.dev401'
+__revision__ = '40d67dd6b213814fd76e662f51b8e4fca8dbc6c3'
 
 
 #

{omlish-0.0.0.dev399 → omlish-0.0.0.dev401}/omlish/codecs/registry.py

@@ -102,10 +102,10 @@ def _install_standard_codecs(registry: CodecRegistry) -> None:
 
 @cached.function
 def _build_manifest_lazy_loaded_codecs() -> ta.Sequence[LazyLoadedCodec]:
-    ldr = manifest_globals.MANIFEST_LOADER
-    pkgs = {__package__.split('.')[0], *ldr.discover_pkgs()}
+    ldr = manifest_globals.GlobalManifestLoader.instance()
+    pkgs = {__package__.split('.')[0], *ldr.discover_packages()}
     mns = ldr.load(*pkgs, only=[LazyLoadedCodec])
-    return [m.value for m in mns]
+    return [m.value() for m in mns]
 
 
 def _install_manifest_lazy_loaded_codecs(registry: CodecRegistry) -> None:

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

@@ -0,0 +1,152 @@
+# fmt: off
+# 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.dev399 → omlish-0.0.0.dev401}/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.dev399 → omlish-0.0.0.dev401}/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.dev399 → omlish-0.0.0.dev401}/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.dev399 → omlish-0.0.0.dev401}/omlish/lang/contextmanagers.py

@@ -1,6 +1,7 @@
 """
 TODO:
  - AsyncExitStacked
+ - lol does double_check_setdefault need a CowDict in FT?
 """
 import abc
 import contextlib

{omlish-0.0.0.dev399 → omlish-0.0.0.dev401}/omlish/lang/imports/proxyinit.py

@@ -69,6 +69,9 @@ class _ProxyInit:
                 self._imps_by_attr[attr] = self._Import(package, imp_attr)
                 self._lazy_globals.set_fn(attr, functools.partial(self.get, attr))
 
+    def _import_module(self, name: str) -> ta.Any:
+        return importlib.import_module(name, package=self._name_package.package)
+
     def get(self, attr: str) -> ta.Any:
         try:
             imp = self._imps_by_attr[attr]
@@ -78,13 +81,14 @@ class _ProxyInit:
         val: ta.Any
 
         if imp.attr is None:
-            val = importlib.import_module(imp.pkg, package=self._name_package.package)
+            val = self._import_module(imp.pkg)
 
         else:
             try:
                 mod = self._mods_by_pkgs[imp.pkg]
             except KeyError:
-                mod = importlib.import_module(imp.pkg, package=self._name_package.package)
+                mod = self._import_module(imp.pkg)
+                self._mods_by_pkgs[imp.pkg] = mod
 
             val = getattr(mod, imp.attr)
 

{omlish-0.0.0.dev399 → omlish-0.0.0.dev401}/omlish/lang/imports/traversal.py

@@ -1,3 +1,8 @@
+"""
+TODO:
+ - overhaul this - use pkgutil.walk_packages unless called needs non-importing (which this currently doesn't do anyway),
+   and support namespace packages if they do.
+"""
 import contextlib
 import sys
 import typing as ta
@@ -18,8 +23,9 @@ def yield_importable(
         recursive: bool = False,
         filter: ta.Callable[[str], bool] | None = None,  # noqa
         include_special: bool = False,
+        raise_on_failure: bool = False,
 ) -> ta.Iterator[str]:
-    from importlib import resources
+    import importlib.resources
 
     def rec(cur):
         if cur.split('.')[-1] == '__pycache__':
@@ -28,17 +34,13 @@ def yield_importable(
         try:
             module = sys.modules[cur]
         except KeyError:
-            try:
-                __import__(cur)
-            except ImportError:
-                return
-            module = sys.modules[cur]
+            module = importlib.import_module(cur)
 
         # FIXME: pyox
         if getattr(module, '__file__', None) is None:
             return
 
-        for file in resources.files(cur).iterdir():
+        for file in importlib.resources.files(cur).iterdir():
             if file.is_file() and file.name.endswith('.py'):
                 if not (include_special or file.name not in SPECIAL_IMPORTABLE):
                     continue
@@ -51,11 +53,17 @@ def yield_importable(
 
             elif recursive and file.is_dir():
                 name = cur + '.' + file.name
+
                 if filter is not None and not filter(name):
                     continue
-                with contextlib.suppress(ImportError, NotImplementedError):
+
+                if raise_on_failure:
                     yield from rec(name)
 
+                else:
+                    with contextlib.suppress(ImportError, NotImplementedError):
+                        yield from rec(name)
+
     yield from rec(package_root)
 
 
@@ -67,12 +75,14 @@ def yield_import_all(
         recursive: bool = False,
         filter: ta.Callable[[str], bool] | None = None,  # noqa
         include_special: bool = False,
+        raise_on_failure: bool = False,
 ) -> ta.Iterator[str]:
     for import_path in yield_importable(
             package_root,
             recursive=recursive,
             filter=filter,
             include_special=include_special,
+            raise_on_failure=raise_on_failure,
     ):
         __import__(import_path, globals=globals, locals=locals)
         yield import_path

{omlish-0.0.0.dev399 → omlish-0.0.0.dev401}/omlish/lite/imports.py

@@ -28,7 +28,7 @@ def import_module_attr(dotted_path: str) -> ta.Any:
 
 
 def import_attr(dotted_path: str) -> ta.Any:
-    importlib = __import__('importlib')
+    import importlib  # noqa
     parts = dotted_path.split('.')
     mod: ta.Any = None
     mod_pos = 0

{omlish-0.0.0.dev399 → omlish-0.0.0.dev401}/omlish/lite/reprs.py

@@ -75,7 +75,8 @@ class AttrRepr:
         except AttributeError:
             pass
 
-        reprlib = __import__('reprlib')
+        import reprlib  # noqa
+
         cls._reprlib_ = reprlib
         return reprlib
 

{omlish-0.0.0.dev399 → omlish-0.0.0.dev401}/omlish/manifests/base.py

@@ -16,7 +16,8 @@ class ModAttrManifest:
     attr_name: str
 
     def load(self) -> ta.Any:
-        importlib = __import__('importlib')
+        import importlib  # noqa
+
         mod = importlib.import_module(self.mod_name)
         return getattr(mod, self.attr_name)
 

omlish-0.0.0.dev401/omlish/manifests/globals.py

@@ -0,0 +1,68 @@
+# ruff: noqa: UP045
+# @omlish-lite
+import threading
+import typing as ta
+
+from ..lite.marshal import unmarshal_obj
+from .loading import ManifestLoader
+
+
+##
+
+
+class GlobalManifestLoader:
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+    def __init_subclass__(cls, **kwargs):  # noqa
+        raise TypeError
+
+    ##
+
+    _lock: ta.ClassVar[threading.RLock] = threading.RLock()
+
+    _instance: ta.ClassVar[ta.Optional[ManifestLoader]] = None
+
+    @classmethod
+    def instance(cls) -> ManifestLoader:
+        if (inst := cls._instance) is None:
+            with cls._lock:
+                if (inst := cls._instance) is None:
+                    inst = cls._instance = ManifestLoader(**cls.default_kwargs())
+
+        return inst
+
+    @classmethod
+    def initialize(cls, **kwargs: ta.Any) -> ManifestLoader:
+        with cls._lock:
+            if cls._instance is not None:
+                raise Exception(f'{cls.__name__} already initialized')
+
+            inst = cls._instance = ManifestLoader(**kwargs)
+
+        return inst
+
+    ##
+
+    @classmethod
+    def default_value_instantiator(cls, obj_cls: type, **kwargs: ta.Any) -> ta.Any:
+        return unmarshal_obj(kwargs, obj_cls)
+
+    @classmethod
+    def default_kwargs(cls) -> ta.Mapping[str, ta.Any]:
+        return dict(
+            value_instantiator=cls.default_value_instantiator,
+        )
+
+    ##
+
+    @classmethod
+    def load(
+            cls,
+            *pkg_names: str,
+            only: ta.Optional[ta.Iterable[type]] = None,
+    ) -> ta.Sequence[ManifestLoader.LoadedManifest]:
+        return cls.instance().load(
+            *pkg_names,
+            only=only,
+        )