omlish 0.0.0.dev399__py3-none-any.whl → 0.0.0.dev401__py3-none-any.whl

omlish/__about__.py

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

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

@@ -1,165 +1,152 @@
+# fmt: off
 # 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/contextmanagers.py

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

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/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/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/lite/reprs.py

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

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/manifests/globals.py

@@ -1,4 +1,8 @@
+# ruff: noqa: UP045
 # @omlish-lite
+import threading
+import typing as ta
+
 from ..lite.marshal import unmarshal_obj
 from .loading import ManifestLoader
 
@@ -6,6 +10,59 @@ from .loading import ManifestLoader
 ##
 
 
-MANIFEST_LOADER = ManifestLoader(
-    cls_instantiator=lambda cls, **kwargs: unmarshal_obj(kwargs, cls),
-)
+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,
+        )

omlish/manifests/loading.py

@@ -5,6 +5,10 @@ Should be kept somewhat lightweight - used in cli entrypoints.
 
 TODO:
  - persisted caching support - {pkg_name: manifests}
+ - real relative cls names - shouldn't need parent package names
+ - *require* loaded class names - special All sentinel for explicit all
+  - ! late instantiation !
+ - per-manifest-item cache?
 """
 import dataclasses as dc
 import importlib.machinery
@@ -22,34 +26,101 @@ from .types import Manifest
 
 
 class ManifestLoader:
+    class LoadedManifest:
+        def __init__(
+                self,
+                package: 'ManifestLoader.LoadedPackage',
+                manifest: Manifest,
+        ) -> None:
+            super().__init__()
+
+            self._package = package
+            self._manifest = manifest
+
+        @property
+        def package(self) -> 'ManifestLoader.LoadedPackage':
+            return self._package
+
+        @property
+        def manifest(self) -> Manifest:
+            return self._manifest
+
+        @property
+        def loader(self) -> 'ManifestLoader':
+            return self._package.loader
+
+        @property
+        def class_key(self) -> str:
+            [(cls_key, value_dct)] = self._manifest.value.items()
+            return cls_key
+
+        _value: ta.Any
+
+        def value(self) -> ta.Any:
+            try:
+                return self._value
+            except AttributeError:
+                pass
+
+            value = self.loader._instantiate_loaded_manifest(self)  # noqa
+            self._value = value
+            return value
+
+    class LoadedPackage:
+        def __init__(
+                self,
+                loader: 'ManifestLoader',
+                name: str,
+        ) -> None:
+            super().__init__()
+
+            self._loader = loader
+            self._name = name
+
+        _manifests: ta.Sequence['ManifestLoader.LoadedManifest']
+
+        @property
+        def loader(self) -> 'ManifestLoader':
+            return self._loader
+
+        @property
+        def name(self) -> str:
+            return self._name
+
+        @property
+        def manifests(self) -> ta.Sequence['ManifestLoader.LoadedManifest']:
+            return self._manifests
+
     def __init__(
             self,
             *,
             module_remap: ta.Optional[ta.Mapping[str, str]] = None,
-            cls_instantiator: ta.Optional[ta.Callable[..., ta.Any]] = None,
+            value_instantiator: ta.Optional[ta.Callable[..., ta.Any]] = None,
     ) -> None:
         super().__init__()
 
-        self._cls_instantiator = cls_instantiator
+        self._value_instantiator = value_instantiator
+        self._module_remap = module_remap or {}
 
         self._lock = threading.RLock()
 
-        self._module_remap = module_remap or {}
         self._module_reverse_remap = {v: k for k, v in self._module_remap.items()}
 
-        self._cls_cache: ta.Dict[str, type] = {}
-        self._raw_cache: ta.Dict[str, ta.Optional[ta.Sequence[Manifest]]] = {}
+        self._loaded_classes: ta.Dict[str, type] = {}
+        self._loaded_packages: ta.Dict[str, ta.Optional[ManifestLoader.LoadedPackage]] = {}
+
+        self._scanned_package_root_dirs: ta.Dict[str, ta.Sequence[str]] = {}
 
     #
 
     @classmethod
-    def from_entry_point(
+    def kwargs_from_entry_point(
             cls,
             globals: ta.Mapping[str, ta.Any],  # noqa
             *,
             module_remap: ta.Optional[ta.Mapping[str, str]] = None,
             **kwargs: ta.Any,
-    ) -> 'ManifestLoader':
+    ) -> ta.Dict[str, ta.Any]:
         rm: ta.Dict[str, str] = {}
 
         if module_remap:
@@ -61,16 +132,11 @@ class ManifestLoader:
             if '__main__' not in rm and name == '__main__':
                 rm[spec.name] = '__main__'
 
-        return cls(module_remap=rm, **kwargs)
+        return dict(module_remap=rm, **kwargs)
 
     #
 
-    def _load_cls(self, key: str) -> type:
-        try:
-            return self._cls_cache[key]
-        except KeyError:
-            pass
-
+    def _load_class_uncached(self, key: str) -> type:
         if not key.startswith('$'):
             raise Exception(f'Bad key: {key}')
 
@@ -89,16 +155,25 @@ class ManifestLoader:
         if not isinstance(cls, type):
             raise TypeError(cls)
 
-        self._cls_cache[key] = cls
         return cls
 
-    def load_cls(self, key: str) -> type:
+    def _load_class_locked(self, key: str) -> type:
+        try:
+            return self._loaded_classes[key]
+        except KeyError:
+            pass
+
+        cls = self._load_class_uncached(key)
+        self._loaded_classes[key] = cls
+        return cls
+
+    def _load_class(self, key: str) -> type:
         with self._lock:
-            return self._load_cls(key)
+            return self._load_class_locked(key)
 
     #
 
-    def _load_contents(self, obj: ta.Any, pkg_name: str) -> ta.Sequence[Manifest]:
+    def _deserialize_raw_manifests(self, obj: ta.Any, pkg_name: str) -> ta.Sequence[Manifest]:
         if not isinstance(obj, (list, tuple)):
             raise TypeError(obj)
 
@@ -119,13 +194,9 @@ class ManifestLoader:
 
         return lst
 
-    def load_contents(self, obj: ta.Any, pkg_name: str) -> ta.Sequence[Manifest]:
-        with self._lock:
-            return self.load_contents(obj, pkg_name)
-
     #
 
-    def _read_pkg_file_text(self, pkg_name: str, file_name: str) -> ta.Optional[str]:
+    def _read_package_file_text(self, pkg_name: str, file_name: str) -> ta.Optional[str]:
         # importlib.resources.files actually imports the package - to avoid this, if possible, the file is read straight
         # off the filesystem.
         spec = importlib.util.find_spec(pkg_name)
@@ -149,45 +220,71 @@ class ManifestLoader:
 
     MANIFESTS_FILE_NAME: ta.ClassVar[str] = '.manifests.json'
 
-    def _load_raw(self, pkg_name: str) -> ta.Optional[ta.Sequence[Manifest]]:
-        try:
-            return self._raw_cache[pkg_name]
-        except KeyError:
-            pass
-
-        src = self._read_pkg_file_text(pkg_name, self.MANIFESTS_FILE_NAME)
+    def _load_package_uncached(self, pkg_name: str) -> ta.Optional[LoadedPackage]:
+        src = self._read_package_file_text(pkg_name, self.MANIFESTS_FILE_NAME)
         if src is None:
-            self._raw_cache[pkg_name] = None
             return None
 
         obj = json.loads(src)
         if not isinstance(obj, (list, tuple)):
             raise TypeError(obj)
 
-        lst = self._load_contents(obj, pkg_name)
+        raw_lst = self._deserialize_raw_manifests(obj, pkg_name)
 
-        self._raw_cache[pkg_name] = lst
-        return lst
+        ld_pkg = ManifestLoader.LoadedPackage(self, pkg_name)
+
+        ld_man_lst: ta.List[ManifestLoader.LoadedManifest] = []
+        for raw in raw_lst:
+            ld_man = ManifestLoader.LoadedManifest(ld_pkg, raw)
+
+            ld_man_lst.append(ld_man)
+
+        ld_pkg._manifests = ld_man_lst  # noqa
+
+        return ld_pkg
+
+    def _load_package_locked(self, pkg_name: str) -> ta.Optional[LoadedPackage]:
+        try:
+            return self._loaded_packages[pkg_name]
+        except KeyError:
+            pass
 
-    def load_raw(self, pkg_name: str) -> ta.Optional[ta.Sequence[Manifest]]:
+        pkg = self._load_package_uncached(pkg_name)
+        self._loaded_packages[pkg_name] = pkg
+        return pkg
+
+    def load_package(self, pkg_name: str) -> ta.Optional[LoadedPackage]:
         with self._lock:
-            return self._load_raw(pkg_name)
+            return self._load_package_locked(pkg_name)
 
     #
 
-    def instantiate_cls(self, cls: type, **kwargs: ta.Any) -> ta.Any:
-        if self._cls_instantiator is not None:
-            return self._cls_instantiator(cls, **kwargs)
+    def _instantiate_value(self, cls: type, **kwargs: ta.Any) -> ta.Any:
+        if self._value_instantiator is not None:
+            return self._value_instantiator(cls, **kwargs)
         else:
             return cls(**kwargs)
 
+    def _instantiate_loaded_manifest(self, ld_man: LoadedManifest) -> ta.Any:
+        [(cls_key, value_dct)] = ld_man.manifest.value.items()
+        cls = self._load_class(cls_key)
+        value = self._instantiate_value(cls, **value_dct)
+        return value
+
     #
 
+    class LOAD_ALL:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+        def __init_subclass__(cls, **kwargs):  # noqa
+            raise TypeError
+
     def _load(
             self,
             *pkg_names: str,
             only: ta.Optional[ta.Iterable[type]] = None,
-    ) -> ta.Sequence[Manifest]:
+    ) -> ta.Sequence[LoadedManifest]:
         only_keys: ta.Optional[ta.Set]
         if only is not None:
             only_keys = set()
@@ -200,18 +297,17 @@ class ManifestLoader:
         else:
             only_keys = None
 
-        lst: ta.List[Manifest] = []
+        lst: ta.List[ManifestLoader.LoadedManifest] = []
         for pn in pkg_names:
-            for manifest in (self.load_raw(pn) or []):
-                [(key, value_dct)] = manifest.value.items()
-                if only_keys is not None and key not in only_keys:
-                    continue
+            lp = self.load_package(pn)
+            if lp is None:
+                continue
 
-                cls = self._load_cls(key)
-                value = self.instantiate_cls(cls, **value_dct)
+            for m in lp.manifests:
+                if only_keys is not None and m.class_key not in only_keys:
+                    continue
 
-                manifest = dc.replace(manifest, value=value)
-                lst.append(manifest)
+                lst.append(m)
 
         return lst
 
@@ -219,7 +315,7 @@ class ManifestLoader:
             self,
             *pkg_names: str,
             only: ta.Optional[ta.Iterable[type]] = None,
-    ) -> ta.Sequence[Manifest]:
+    ) -> ta.Sequence[LoadedManifest]:
         with self._lock:
             return self._load(
                 *pkg_names,
@@ -228,42 +324,82 @@ class ManifestLoader:
 
     #
 
-    ENTRY_POINT_GROUP = 'omlish.manifests'
+    ENTRY_POINT_GROUP: ta.ClassVar[str] = 'omlish.manifests'
+
+    _discovered_packages: ta.ClassVar[ta.Optional[ta.Sequence[str]]] = None
+
+    @classmethod
+    def discover_packages(cls) -> ta.Sequence[str]:
+        if (x := cls._discovered_packages) is not None:
+            return x
 
-    def discover_pkgs(self) -> ta.Sequence[str]:
         # This is a fat dep so do it late.
-        importlib_metadata = __import__('importlib.metadata').metadata
+        from importlib import metadata as importlib_metadata  # noqa
 
-        return [
+        x = [
             ep.value
-            for ep in importlib_metadata.entry_points(group=self.ENTRY_POINT_GROUP)
+            for ep in importlib_metadata.entry_points(group=cls.ENTRY_POINT_GROUP)
         ]
 
-    def scan_pkg_root(self, root: str) -> ta.Sequence[str]:
+        cls._discovered_packages = x
+        return x
+
+    #
+
+    def _scan_package_root_dir_uncached(
+            self,
+            root_dir: str,
+    ) -> ta.Sequence[str]:
         pkgs: ta.List[str] = []
-        for n in os.listdir(root):
-            if os.path.isdir(p := os.path.join(root, n)) and os.path.exists(os.path.join(p, '__init__.py')):
+
+        for n in os.listdir(root_dir):
+            if (
+                    os.path.isdir(p := os.path.join(root_dir, n)) and
+                    os.path.exists(os.path.join(p, '__init__.py'))
+            ):
                 pkgs.append(n)
+
         return pkgs
 
-    def scan_or_discover_pkgs(
+    def _scan_package_root_dir_locked(
+            self,
+            root_dir: str,
+    ) -> ta.Sequence[str]:
+        try:
+            return self._scanned_package_root_dirs[root_dir]
+        except KeyError:
+            pass
+
+        ret = self._scan_package_root_dir_uncached(root_dir)
+        self._scanned_package_root_dirs[root_dir] = ret
+        return ret
+
+    def _scan_package_root_dir(
+            self,
+            root_dir: str,
+    ) -> ta.Sequence[str]:
+        with self._lock:
+            return self._scan_package_root_dir_locked(root_dir)
+
+    def scan_or_discover_packages(
             self,
             *,
-            specified_roots: ta.Optional[ta.Sequence[str]] = None,
-            fallback_root: ta.Optional[str] = None,
+            specified_root_dirs: ta.Optional[ta.Sequence[str]] = None,
+            fallback_root_dir: ta.Optional[str] = None,
     ) -> ta.Sequence[str]:
         pkgs: list[str] = []
 
-        if specified_roots is not None:
-            if isinstance(specified_roots, str):
-                raise TypeError(specified_roots)
-            for r in specified_roots:
-                pkgs.extend(self.scan_pkg_root(r))
+        if specified_root_dirs is not None:
+            if isinstance(specified_root_dirs, str):
+                raise TypeError(specified_root_dirs)
+
+            for r in specified_root_dirs:
+                pkgs.extend(self._scan_package_root_dir(r))
 
         else:
-            pkgs.extend(self.discover_pkgs())
+            pkgs.extend(self.discover_packages())
 
-            if not pkgs and fallback_root is not None:
-                pkgs.extend(self.scan_pkg_root(fallback_root))
+            if not pkgs and fallback_root_dir is not None:
+                pkgs.extend(self._scan_package_root_dir(fallback_root_dir))
 
         return pkgs

omlish/os/pidfiles/pinning.py

@@ -245,7 +245,8 @@ class LslocksPidfdPidfilePinner(PidfilePinner):
 
 if __name__ == '__main__':
     def _main() -> None:
-        argparse = __import__('argparse')
+        import argparse  # noqa
+
         parser = argparse.ArgumentParser()
         parser.add_argument('file')
         args = parser.parse_args()

{omlish-0.0.0.dev399.dist-info → omlish-0.0.0.dev401.dist-info}/METADATA

@@ -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.dist-info → omlish-0.0.0.dev401.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=aT8yZ-Zh-9wfHl5Ym5ouiWC1i0cy7Q7RlhzavB6VLPI,8587
-omlish/__about__.py,sha256=fsEaOnDS-IEelnR6gQvtXqr8_KRBvYJ0sk9zeUjWmkI,3576
+omlish/__about__.py,sha256=qgXlKBCqBWl3hZlS4yepho5vzin0hRyrGpM0ceofB74,3576
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=rer-TPOFDU6fYq_AWio_AmA-ckZ8JDY5shIzQ_yXfzA,8414
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -73,10 +73,10 @@ omlish/codecs/base.py,sha256=IVnJlduvhiH1imul4DPhl2gHBWS76774AV5h86dX0ls,2214
 omlish/codecs/bytes.py,sha256=3DxyQQCvFcP3mQ5G93f_mygXEb-7I8buM8EyzUcx2Is,2155
 omlish/codecs/chain.py,sha256=nbkL2nz0ZqT2lxYwSXktHh1YFTQ4Iii1Hp-fWjis6rc,532
 omlish/codecs/funcs.py,sha256=or0Jogczuzk7csDTRl-HURMEjl8LXXqxxXYK45xcM5w,855
-omlish/codecs/registry.py,sha256=PIf7XdwVX7Q85-MnyURtX9SKAYolK_r7wls9Z-qAsnA,3911
+omlish/codecs/registry.py,sha256=_s-RKf06dlZhmXNH7Z2qbO8LPEtWeP-wgDAaHp9DFlg,3933
 omlish/codecs/standard.py,sha256=eiZ4u9ep0XrA4Z_D1zJI0vmWyuN8HLrX4Se_r_Cq_ZM,60
 omlish/codecs/text.py,sha256=uHhV8jBgH0iZgcrV0nl4-0a_9ofln4iFH4OXoVm2CW4,5709
-omlish/collections/__init__.py,sha256=bNcBs7Z-IbvfzG37uF44Ao4cQFZkTl1IcmTYpjajh3M,2675
+omlish/collections/__init__.py,sha256=BIc806ri5Eq-kR03Ya2YfYTRI0g1rn_0haQPUqxXqys,2816
 omlish/collections/abc.py,sha256=p9zhL5oNV5WPyWmMn34fWfkuxPQAjOtL7WQA-Xsyhwk,2628
 omlish/collections/bimap.py,sha256=3szDCscPJlFRtkpyVQNWneg4s50mr6Rd0jdTzVEIcnE,1661
 omlish/collections/coerce.py,sha256=tAls15v_7p5bUN33R7Zbko87KW5toWHl9fRialCqyNY,7030
@@ -115,7 +115,7 @@ omlish/concurrent/threadlets.py,sha256=JfirbTDJgy9Ouokz_VmHeAAPS7cih8qMUJrN-owwX
 omlish/configs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/configs/all.py,sha256=xTfR7NySnlIeqhk0GlUOncPnWZ97cLhCtRDlN_Ny8og,1107
 omlish/configs/classes.py,sha256=sWBL1K90Ix5E-N_A6Uz7s-djpkS2rKEzOLFYB8pHk9k,1173
-omlish/configs/formats.py,sha256=DlaI_0mxrYmPl9pUWZFQ6xvqXz997uQOGtt9EKt6V9o,5307
+omlish/configs/formats.py,sha256=TenrNVqsgY5mwWJv3XBTaLTCbLxdKZEkH1U_9M1sNd8,5337
 omlish/configs/nginx.py,sha256=b4fMI8dIZBUgOjmveRINrmmwSt8DO3y7nfvd-__YxDo,2062
 omlish/configs/shadow.py,sha256=rc-loE5ex2GFwvdQJXqJsnSQa-MNF6Mizh4FlirSYUo,2234
 omlish/configs/types.py,sha256=vANNURlIos3fR3fgcL2EMW5t6RevzSHU-BnVZgwIDOM,110
@@ -210,7 +210,7 @@ omlish/diag/__init__.py,sha256=c1q8vuapGH1YiYdU300FIJXMI1MOcnLNBZXr-zc8BXk,1181
 omlish/diag/asts.py,sha256=MWh9XAG3m9L10FIJCyoNT2aU4Eft6tun_x9K0riq6Dk,3332
 omlish/diag/debug.py,sha256=ClED7kKXeVMyKrjGIxcq14kXk9kvUJfytBQwK9y7c4Q,1637
 omlish/diag/lslocks.py,sha256=VuA4MNNqXTcnHWsJvulGM6pNJRKmlXFXUZTfXpY0V6g,1750
-omlish/diag/lsof.py,sha256=A0u3aSh7-QBxV7ilR-Bp7IEy6-kFg0wjLfsVn4bVJfQ,9133
+omlish/diag/lsof.py,sha256=5N5aZQ7UqEBgV-hj3_a8QcvALOeLlVb8otqF2hvucxY,9107
 omlish/diag/procfs.py,sha256=KaGTAA2Gj8eEEp7MjClRe4aimwzd-HDABThFzvq2cBQ,9684
 omlish/diag/procstats.py,sha256=EJEe2Zc58ykBoTfqMXro7H52aQa_pd6uC2hsIPFceso,825
 omlish/diag/ps.py,sha256=MEpMU6fbkh0bSWrOHh_okOa0JDTUSUQUVSYBdh1TGvE,1672
@@ -308,7 +308,7 @@ omlish/formats/toml/codec.py,sha256=5HFGWEPd9IFxPlRMRheX8FEDlRIzLe1moHEOj2_PFKU,
 omlish/formats/toml/parser.py,sha256=O2M0penQV3t8NAsq_conJjvTsXI8iivUFuBg2a5J3dU,30643
 omlish/formats/toml/writer.py,sha256=kLLQNEA_Kzd3ue7UXPQ_torOKoaLT82W16Bt99sID-w,3231
 omlish/funcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/funcs/builders.py,sha256=mJkgvJxM98x5pbMQzRY95tRUsbAfy_ivHtt4fDKfzsM,3984
+omlish/funcs/builders.py,sha256=Av41RkDFbsVGzQ7cWzevCG-UqZhLCBSDT8DhyWKq1rQ,4006
 omlish/funcs/genmachine.py,sha256=D9dChaliNBIjYE6lJP5ctcVQUCffNBhceyaaLvBJ7ns,2578
 omlish/funcs/match.py,sha256=EPeKojvecnJuDEWaXEYuef0Sx1J6Y0uTL01h4Z8ldxc,6199
 omlish/funcs/pairs.py,sha256=m570hXCaW6tCJq2QITJ_CKFFzXDDOogKvskX7N7oICs,3904
@@ -431,7 +431,7 @@ omlish/lang/casing.py,sha256=cFUlbDdXLhwnWwcYx4qnM5c4zGX7hIRUfcjiZbxUD28,4636
 omlish/lang/clsdct.py,sha256=HAGIvBSbCefzRjXriwYSBLO7QHKRv2UsE78jixOb-fA,1828
 omlish/lang/collections.py,sha256=XI76WcSi4SclWmEGirErg7EzQUfjtmiK2xSK7jJISzY,2528
 omlish/lang/comparison.py,sha256=MOwEG0Yny-jBPHO9kQto9FSRyeNpQW24UABsghkrHxY,1356
-omlish/lang/contextmanagers.py,sha256=7atRNgR13cgynKIgrDZNLq5qAV52xWy8ISeOVaL6HrQ,7627
+omlish/lang/contextmanagers.py,sha256=na4T51jL0SMkC3oEJJsxdbAKgzSrfyFV6h9NCrQ3rX0,7685
 omlish/lang/datetimes.py,sha256=01tg21QOx-PWDlm-CSFTalym3vpqF0EKzeinmtcVNoU,379
 omlish/lang/descriptors.py,sha256=zBtgO9LjdSTGHNUgiIqswh78WOVoGH6KzS0NbgB1Wls,6572
 omlish/lang/enums.py,sha256=F9tflHfaAoV2MpyuhZzpfX9-H55M3zNa9hCszsngEo8,111
@@ -465,9 +465,9 @@ omlish/lang/classes/virtual.py,sha256=z0MYQD9Q5MkX8DzF325wDB4J9XoYbsB09jZ1omC62T
 omlish/lang/imports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/lang/imports/conditional.py,sha256=qxHYlE_xuwPJb6F9K8upagHxuYL0APPLWRVo5079Ipg,1007
 omlish/lang/imports/lazy.py,sha256=gDv7ffrGsPEAHZ9a1Myt7Uf-4vqWErhCd1DaS7SQL0c,1464
-omlish/lang/imports/proxyinit.py,sha256=fe9lVhBQ605OaJ8rEuF680yIqh4QFCUoioTEfesDYQc,12533
+omlish/lang/imports/proxyinit.py,sha256=prcQSZYdXSvZLsWZClNSOhIJVHNMuO8nD9NTtG-fFv4,12636
 omlish/lang/imports/resolution.py,sha256=DeRarn35Fryg5JhVhy8wbiC9lvr58AnllI9B_reswUE,2085
-omlish/lang/imports/traversal.py,sha256=lp1wPisPK-Op0i1dA3xmcQZeBUhYZxThIxoV6Ei0bgw,2523
+omlish/lang/imports/traversal.py,sha256=LLic4zfhsSBzKF33_0qABBcjxfajc57mYRkeuj_Zuns,2855
 omlish/lifecycles/__init__.py,sha256=1FjYceXs-4fc-S-C9zFYmc2axHs4znnQHcJVHdY7a6E,578
 omlish/lifecycles/abstract.py,sha256=c9UY7oxzYZ_neh5DPE4yv5HfuDv7B4Mj_9Zo-B8KDSs,1114
 omlish/lifecycles/base.py,sha256=DeUxARnOufWfBvhZQbonl1RVJgbrSeK5QNM6dWEuOwA,1398
@@ -483,7 +483,7 @@ omlish/lite/check.py,sha256=ytCkwZoKfOlJqylL-AGm8C2WfsWJd2q3kFbnZCzX3_M,13844
 omlish/lite/configs.py,sha256=4-1uVxo-aNV7vMKa7PVNhM610eejG1WepB42-Dw2xQI,914
 omlish/lite/contextmanagers.py,sha256=jpMxp5xwooRQJxsQ6J2ll4AJP9O7a5_YrLCGgwUFfD0,5703
 omlish/lite/dataclasses.py,sha256=aRSCZz1jN_UI-CWJhN0SJeKxa-79vXNUZ6YOMgG31SE,3610
-omlish/lite/imports.py,sha256=JDYRFxu-ofHEBfd5VV3b27oKOLhtTpuzte1_Nt7yLgw,1352
+omlish/lite/imports.py,sha256=GyEDKL-WuHtdOKIL-cc8aFd0-bHwZFDEjAB52ItabX0,1341
 omlish/lite/inject.py,sha256=xvmLmtD3_2INnkurJQv76_Rkh9usbApEQrXJ4cvuVAk,29019
 omlish/lite/json.py,sha256=m0Ce9eqUZG23-H7-oOp8n1sf4fzno5vtK4AK_4Vc-Mg,706
 omlish/lite/logs.py,sha256=CWFG0NKGhqNeEgryF5atN2gkPYbUdTINEw_s1phbINM,51
@@ -492,7 +492,7 @@ omlish/lite/maybes.py,sha256=0p_fzb6yiOjEpvMKaQ53Q6CH1VPW1or7v7Lt1JIKcgM,4359
 omlish/lite/maysyncs.py,sha256=MT3zF5kQ5rNlWU7db9Q_uXSM8K2C8LK85PIgdBsJyGE,7251
 omlish/lite/pycharm.py,sha256=FRHGcCDo42UzZXqNwW_DkhI-6kb_CmJKPiQ8F6mYkLA,1174
 omlish/lite/reflect.py,sha256=pzOY2PPuHH0omdtglkN6DheXDrGopdL3PtTJnejyLFU,2189
-omlish/lite/reprs.py,sha256=Tiqf_ciD8FfS0ury7FcJ5G21yY342fW0vPacYlb8EO4,2014
+omlish/lite/reprs.py,sha256=2Bc7ukhKvYNTKmxPIuv9glZIph13C37y_W4fg9pBnu8,2006
 omlish/lite/resources.py,sha256=YNSmX1Ohck1aoWRs55a-o5ChVbFJIQhtbqE-XwF55Oc,326
 omlish/lite/runtime.py,sha256=J59skBq9kwo1H2s36jAk-k87eKPUtua6CmuXh-3dgmE,464
 omlish/lite/secrets.py,sha256=YE9XOkGFEEMfNn-IzjIAulgEiuwS148o1wMZ3XmQDTY,827
@@ -517,9 +517,9 @@ omlish/logs/standard.py,sha256=w0jS824YDvlzrGgAxKiPk9RoZ5V1b0ADiFsBEpKLuLY,3152
 omlish/logs/timing.py,sha256=qsQ3DB6swts1pxrFlmLWQzhH-3nzDrq1MUu7PxjjUyU,1519
 omlish/logs/utils.py,sha256=OkFWf1exmWImmT7BaSiIC7c0Fk9tAis-PRqo8H4ny3c,398
 omlish/manifests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/manifests/base.py,sha256=YBK6jxMgY5G3hK0ZBlbU-tghzifkGhwRTyWa5XqOmno,939
-omlish/manifests/globals.py,sha256=LZm4ueBjlC023uxL8zvivSyzMgx5O8kSbo9oNfhF_DE,206
-omlish/manifests/loading.py,sha256=S-yEGsnBEu670ya6Bc09QqbRtA5rBp5rA4D3zuJUl9M,8070
+omlish/manifests/base.py,sha256=Z5afzBJgI0tyTS8mPbYY4pYvoZu_xtdhRBOtZ3IIwzA,929
+omlish/manifests/globals.py,sha256=nrA85o8zFTEYv440Y1wgr7SmtW6AE_3jF_Dls6RB_nE,1661
+omlish/manifests/loading.py,sha256=q9M6lpiGCqPOmQMR12ZWYm8F4iME32byaLlT5VsRB9c,11844
 omlish/manifests/static.py,sha256=7YwOVh_Ek9_aTrWsWNO8kWS10_j4K7yv3TpXZSHsvDY,501
 omlish/manifests/types.py,sha256=5hQuY-WZ9VMqHZXr-9Dayg380JsnX2vJzXyw6vC6UDs,317
 omlish/marshal/.dataclasses.json,sha256=wXWUy_IR8AolAa2RQnqn_mo2QnmVcvUJmayIykdVl0I,22
@@ -600,7 +600,7 @@ omlish/os/pidfiles/__main__.py,sha256=AF8TwjK4xgHVnoLAP9dIWgKvT0vGhHJlfDW0tKZ7tx
 omlish/os/pidfiles/cli.py,sha256=dAKukx4mrarH8t7KZM4n_XSfTk3ycShGAFqRrirK5dw,2079
 omlish/os/pidfiles/manager.py,sha256=oOnL90ttOG5ba_k9XPJ18reP7M5S-_30ln4OAfYV5W8,2357
 omlish/os/pidfiles/pidfile.py,sha256=KlqrW7I-lYVDNJspFHE89i_A0HTTteT5B99b7vpTfNs,4400
-omlish/os/pidfiles/pinning.py,sha256=L1MZp7UiBg3uzeDgvt8ScWJHwuIHXZGhgl47hTiiMjY,6636
+omlish/os/pidfiles/pinning.py,sha256=u81LRe3-6Xd6K_dsVbbEPVdsUvY7zy3Xv7413-5NBLQ,6627
 omlish/reflect/__init__.py,sha256=9pzXLXXNMHkLhhI79iUr-o0SMOtR6HMUmAEUplZkIdE,853
 omlish/reflect/inspect.py,sha256=WCo2YpBYauKw6k758FLlZ_H4Q05rgVPs96fEv9w6zHQ,1538
 omlish/reflect/ops.py,sha256=F77OTaw0Uw020cJCWX_Q4kL3wvxlJ8jV8wz7BctGL_k,2619
@@ -908,9 +908,9 @@ omlish/typedvalues/marshal.py,sha256=AtBz7Jq-BfW8vwM7HSxSpR85JAXmxK2T0xDblmm1HI0
 omlish/typedvalues/of_.py,sha256=UXkxSj504WI2UrFlqdZJbu2hyDwBhL7XVrc2qdR02GQ,1309
 omlish/typedvalues/reflect.py,sha256=PAvKW6T4cW7u--iX80w3HWwZUS3SmIZ2_lQjT65uAyk,1026
 omlish/typedvalues/values.py,sha256=ym46I-q2QJ_6l4UlERqv3yj87R-kp8nCKMRph0xQ3UA,1307
-omlish-0.0.0.dev399.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev399.dist-info/METADATA,sha256=Kezuj4MTMgqRhNq1Y3YMIosDiWl5vpGH3FlTb0FV60g,18825
-omlish-0.0.0.dev399.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omlish-0.0.0.dev399.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev399.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev399.dist-info/RECORD,,
+omlish-0.0.0.dev401.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev401.dist-info/METADATA,sha256=A-XCNmgKPIC0W6WqyFrKmVdtNNwE_zrRIJUW9ZxSez8,18825
+omlish-0.0.0.dev401.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omlish-0.0.0.dev401.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev401.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev401.dist-info/RECORD,,