omlish 0.0.0.dev403__py3-none-any.whl → 0.0.0.dev405__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev403'
-__revision__ = '5403fd726d8c05e6b9edf0c3b0c86c6600809211'
+__version__ = '0.0.0.dev405'
+__revision__ = '2845f7bb7c8df0a75acb7e7dece1fc712a54aa05'
 
 
 #
@@ -65,7 +65,7 @@ class Project(ProjectBase):
 
         'formats': [
             'orjson ~= 3.11',
-            'ujson ~= 5.10',
+            'ujson ~= 5.11',
 
             'pyyaml ~= 6.0',
 

omlish/codecs/registry.py

@@ -106,10 +106,7 @@ def _install_standard_codecs(registry: CodecRegistry) -> None:
 
 @cached.function
 def _build_manifest_lazy_loaded_codecs() -> ta.Sequence[LazyLoadedCodec]:
-    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 manifest_globals.GlobalManifestLoader.load_values_of(LazyLoadedCodec)
 
 
 def _install_manifest_lazy_loaded_codecs(registry: CodecRegistry) -> None:

omlish/collections/identity.py

@@ -102,6 +102,9 @@ class IdentityWeakKeyDictionary(ta.MutableMapping[K, V]):
 
     See also:
     https://github.com/python-trio/trio/blob/efd785a20721707b52a6e2289a65e25722b30c96/src/trio/_core/_ki.py#L81
+
+    TODO:
+     - audit for freethreaded
     """
 
     def __init__(self, *args: ta.Any, **kwargs: ta.Any) -> None:

omlish/lite/contextmanagers.py

@@ -4,8 +4,6 @@ import functools
 import sys
 import typing as ta
 
-from .check import check
-
 
 T = ta.TypeVar('T')
 ExitStackedT = ta.TypeVar('ExitStackedT', bound='ExitStacked')
@@ -50,7 +48,8 @@ class ExitStacked:
         """
 
         with self._exit_stacked_init_wrapper():
-            check.state(self._exit_stack is None)
+            if self._exit_stack is not None:
+                raise RuntimeError
             es = self._exit_stack = contextlib.ExitStack()
             es.__enter__()
             try:
@@ -78,7 +77,8 @@ class ExitStacked:
         pass
 
     def _enter_context(self, cm: ta.ContextManager[T]) -> T:
-        es = check.not_none(self._exit_stack)
+        if (es := self._exit_stack) is None:
+            raise RuntimeError
         return es.enter_context(cm)
 
 
@@ -107,7 +107,8 @@ class AsyncExitStacked:
     @ta.final
     async def __aenter__(self: AsyncExitStackedT) -> AsyncExitStackedT:
         async with self._async_exit_stacked_init_wrapper():
-            check.state(self._exit_stack is None)
+            if self._exit_stack is not None:
+                raise RuntimeError
             es = self._exit_stack = contextlib.AsyncExitStack()
             await es.__aenter__()
             try:
@@ -135,11 +136,13 @@ class AsyncExitStacked:
         pass
 
     def _enter_context(self, cm: ta.ContextManager[T]) -> T:
-        es = check.not_none(self._exit_stack)
+        if (es := self._exit_stack) is None:
+            raise RuntimeError
         return es.enter_context(cm)
 
     async def _enter_async_context(self, cm: ta.AsyncContextManager[T]) -> T:
-        es = check.not_none(self._exit_stack)
+        if (es := self._exit_stack) is None:
+            raise RuntimeError
         return await es.enter_async_context(cm)
 
 

omlish/manifests/globals.py

@@ -1,5 +1,6 @@
-# ruff: noqa: UP045
+# ruff: noqa: UP006 UP045
 # @omlish-lite
+import os
 import threading
 import typing as ta
 
@@ -7,6 +8,9 @@ from ..lite.marshal import unmarshal_obj
 from .loading import ManifestLoader
 
 
+T = ta.TypeVar('T')
+
+
 ##
 
 
@@ -28,17 +32,20 @@ class GlobalManifestLoader:
         if (inst := cls._instance) is None:
             with cls._lock:
                 if (inst := cls._instance) is None:
-                    inst = cls._instance = ManifestLoader(**cls.default_kwargs())
+                    inst = cls._instance = ManifestLoader(cls.default_config())
 
         return inst
 
     @classmethod
-    def initialize(cls, **kwargs: ta.Any) -> ManifestLoader:
+    def initialize(cls, config: ta.Optional[ManifestLoader.Config] = None) -> ManifestLoader:
         with cls._lock:
             if cls._instance is not None:
-                raise Exception(f'{cls.__name__} already initialized')
+                raise RuntimeError(f'{cls.__name__} already initialized')
+
+            if config is None:
+                config = cls.default_config()
 
-            inst = cls._instance = ManifestLoader(**kwargs)
+            inst = cls._instance = ManifestLoader(config)
 
         return inst
 
@@ -49,8 +56,11 @@ class GlobalManifestLoader:
         return unmarshal_obj(kwargs, obj_cls)
 
     @classmethod
-    def default_kwargs(cls) -> ta.Mapping[str, ta.Any]:
-        return dict(
+    def default_config(cls) -> ManifestLoader.Config:
+        return ManifestLoader.Config(
+            discover_packages=True,
+            discover_packages_fallback_scan_root_dirs=[os.getcwd()],
+
             value_instantiator=cls.default_value_instantiator,
         )
 
@@ -59,10 +69,35 @@ class GlobalManifestLoader:
     @classmethod
     def load(
             cls,
-            *pkg_names: str,
-            only: ta.Optional[ta.Iterable[type]] = None,
+            *,
+            packages: ta.Optional[ta.Collection[str]] = None,
+            classes: ta.Optional[ta.Collection[type]] = None,
     ) -> ta.Sequence[ManifestLoader.LoadedManifest]:
         return cls.instance().load(
-            *pkg_names,
-            only=only,
+            packages=packages,
+            classes=classes,
+        )
+
+    @classmethod
+    def load_values(
+            cls,
+            *,
+            packages: ta.Optional[ta.Collection[str]] = None,
+            classes: ta.Optional[ta.Collection[type]] = None,
+    ) -> ta.Sequence[ta.Any]:
+        return cls.instance().load_values(
+            packages=packages,
+            classes=classes,
+        )
+
+    @classmethod
+    def load_values_of(
+            cls,
+            clz: ta.Type[T],
+            *,
+            packages: ta.Optional[ta.Collection[str]] = None,
+    ) -> ta.Sequence[T]:
+        return cls.instance().load_values_of(
+            clz,
+            packages=packages,
         )

omlish/manifests/loading.py

@@ -4,16 +4,13 @@
 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 !
  - TypeMap style weak cache of issubclass queries
   - wait.. lazily load the class for virtual subclass queries? xor support virtual bases?
+ - weakref class dict keys?
 """
 import dataclasses as dc
 import importlib.machinery
-import importlib.resources
 import importlib.util
 import json
 import os.path
@@ -23,6 +20,9 @@ import typing as ta
 from .types import Manifest
 
 
+T = ta.TypeVar('T')
+
+
 ##
 
 
@@ -38,6 +38,12 @@ class ManifestLoader:
             self._package = package
             self._manifest = manifest
 
+            [(cls_key, value_dct)] = self._manifest.value.items()  # noqa
+            self._cls_key = cls_key
+
+        def __repr__(self) -> str:
+            return f'{self.__class__.__name__}@{id(self):x}(package={self._package!r}, class_key={self._cls_key!r})'
+
         @property
         def package(self) -> 'ManifestLoader.LoadedPackage':
             return self._package
@@ -52,8 +58,7 @@ class ManifestLoader:
 
         @property
         def class_key(self) -> str:
-            [(cls_key, value_dct)] = self._manifest.value.items()
-            return cls_key
+            return self._cls_key
 
         _value: ta.Any
 
@@ -80,6 +85,9 @@ class ManifestLoader:
 
         _manifests: ta.Sequence['ManifestLoader.LoadedManifest']
 
+        def __repr__(self) -> str:
+            return f'{self.__class__.__name__}(name={self._name!r})'
+
         @property
         def loader(self) -> 'ManifestLoader':
             return self._loader
@@ -92,54 +100,199 @@ class ManifestLoader:
         def manifests(self) -> ta.Sequence['ManifestLoader.LoadedManifest']:
             return self._manifests
 
+        _manifests_by_class_key: ta.Mapping[str, ta.Sequence['ManifestLoader.LoadedManifest']]
+
+        @property
+        def manifests_by_class_key(self) -> ta.Mapping[str, ta.Sequence['ManifestLoader.LoadedManifest']]:
+            try:
+                return self._manifests_by_class_key
+            except AttributeError:
+                pass
+
+            dct: dict = {}
+            for m in self._manifests:
+                try:
+                    lst = dct[m.class_key]
+                except KeyError:
+                    lst = dct[m.class_key] = []
+                lst.append(m)
+            self._manifests_by_class_key = dct
+            return dct
+
+    ##
+
+    @dc.dataclass(frozen=True)
+    class Config:
+        package_scan_root_dirs: ta.Optional[ta.Collection[str]] = None
+
+        discover_packages: ta.Optional[bool] = None
+        discover_packages_fallback_scan_root_dirs: ta.Optional[ta.Collection[str]] = None
+
+        module_remap: ta.Optional[ta.Mapping[str, str]] = None
+
+        value_instantiator: ta.Optional[ta.Callable[..., ta.Any]] = None
+
+        def __post_init__(self) -> None:
+            if isinstance(self.package_scan_root_dirs, str):
+                raise TypeError(self.package_scan_root_dirs)
+            if isinstance(self.discover_packages_fallback_scan_root_dirs, bool):
+                raise TypeError(self.discover_packages_fallback_scan_root_dirs)
+
+        @classmethod
+        def merge(cls, *configs: 'ManifestLoader.Config') -> 'ManifestLoader.Config':
+            kw: dict = {}
+            for c in configs:
+                for k, v in dc.asdict(c).items():
+                    if v is None:
+                        continue
+                    elif k in ('package_scan_root_dirs', 'discover_packages_fallback_scan_root_dirs'):  # noqa
+                        kw[k] = [*kw.get(k, []), *v]
+                    elif k == 'module_remap':
+                        kw[k] = {**kw.get(k, {}), **v}
+                    else:
+                        kw[k] = v
+            return cls(**kw)
+
+        def __or__(self, other: 'ManifestLoader.Config') -> 'ManifestLoader.Config':
+            return ManifestLoader.Config.merge(self, other)
+
     def __init__(
             self,
-            *,
-            module_remap: ta.Optional[ta.Mapping[str, str]] = None,
-            value_instantiator: ta.Optional[ta.Callable[..., ta.Any]] = None,
+            config: Config,
     ) -> None:
         super().__init__()
 
-        self._value_instantiator = value_instantiator
-        self._module_remap = module_remap or {}
+        self._config = config
 
         self._lock = threading.RLock()
 
-        self._module_reverse_remap = {v: k for k, v in self._module_remap.items()}
+        self._module_remap = config.module_remap or {}
+        self._module_reverse_remap = {v: k for k, v in (self._module_remap or {}).items()}
 
         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]] = {}
 
-    #
+    @property
+    def config(self) -> Config:
+        return self._config
 
     @classmethod
-    def kwargs_from_entry_point(
+    def config_from_entry_point(
             cls,
             globals: ta.Mapping[str, ta.Any],  # noqa
-            *,
-            module_remap: ta.Optional[ta.Mapping[str, str]] = None,
-            **kwargs: ta.Any,
-    ) -> ta.Dict[str, ta.Any]:
+    ) -> Config:
         rm: ta.Dict[str, str] = {}
 
-        if module_remap:
-            rm.update(module_remap)
-
         if '__name__' in globals and '__spec__' in globals:
             name: str = globals['__name__']
             spec: importlib.machinery.ModuleSpec = globals['__spec__']
             if '__main__' not in rm and name == '__main__':
                 rm[spec.name] = '__main__'
 
-        return dict(module_remap=rm, **kwargs)
+        return ManifestLoader.Config(module_remap=rm)
 
-    #
+    ##
+
+    ENTRY_POINT_GROUP: ta.ClassVar[str] = 'omlish.manifests'
+
+    _discovered_packages: ta.ClassVar[ta.Optional[ta.Sequence[str]]] = None
+
+    @classmethod
+    def _discover_packages_uncached(cls) -> ta.Sequence[str]:
+        from importlib import metadata as importlib_metadata  # noqa
+        return [
+            ep.value
+            for ep in importlib_metadata.entry_points(group=cls.ENTRY_POINT_GROUP)
+        ]
+
+    @classmethod
+    def discover_packages(cls) -> ta.Sequence[str]:
+        if (x := cls._discovered_packages) is not None:
+            return x
+
+        x = cls._discover_packages_uncached()
+        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_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_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)
+
+    ##
+
+    _detected_packages: ta.Set[str]
+
+    def _do_initialize(self) -> None:
+        self._detected_packages = set()
+
+        for r in self._config.package_scan_root_dirs or []:
+            self._detected_packages.update(self._scan_package_root_dir_locked(r))
+
+        if self._config.discover_packages:
+            self._detected_packages.update(dps := self.discover_packages())
+            if not dps:
+                for r in self._config.discover_packages_fallback_scan_root_dirs or []:
+                    self._detected_packages.update(self._scan_package_root_dir_locked(r))
+
+    _has_initialized = False
+
+    def _initialize_locked(self) -> None:
+        if not self._has_initialized:
+            self._do_initialize()
+            self._has_initialized = True
+
+    def has_initialized(self) -> bool:
+        with self._lock:
+            return self._has_initialized
+
+    def initialize(self) -> None:
+        if not self._has_initialized:
+            with self._lock:
+                self._initialize_locked()
+
+    ##
+
+    class ClassKeyError(Exception):
+        pass
 
     def _load_class_uncached(self, key: str) -> type:
         if not key.startswith('$'):
-            raise Exception(f'Bad key: {key}')
+            raise ManifestLoader.ClassKeyError(key)
 
         parts = key[1:].split('.')
         pos = next(i for i, p in enumerate(parts) if p[0].isupper())
@@ -172,7 +325,14 @@ class ManifestLoader:
         with self._lock:
             return self._load_class_locked(key)
 
-    #
+    def get_class_key(self, cls: type) -> str:
+        if not (isinstance(cls, type) and dc.is_dataclass(cls)):
+            raise TypeError(cls)
+        mod_name = cls.__module__
+        mod_name = self._module_reverse_remap.get(mod_name, mod_name)
+        return f'${mod_name}.{cls.__qualname__}'
+
+    ##
 
     def _deserialize_raw_manifests(self, obj: ta.Any, pkg_name: str) -> ta.Sequence[Manifest]:
         if not isinstance(obj, (list, tuple)):
@@ -186,7 +346,7 @@ class ManifestLoader:
 
             [(key, value_dct)] = m.value.items()
             if not key.startswith('$'):
-                raise Exception(f'Bad key: {key}')
+                raise ManifestLoader.ClassKeyError(key)
             if key.startswith('$.'):
                 key = f'${pkg_name}{key[1:]}'
                 m = dc.replace(m, value={key: value_dct})
@@ -214,11 +374,14 @@ class ManifestLoader:
                 with open(file_path, encoding='utf-8') as f:
                     return f.read()
 
-        t = importlib.resources.files(pkg_name).joinpath(file_name)
+        from importlib import resources as importlib_resources  # noqa
+        t = importlib_resources.files(pkg_name).joinpath(file_name)
         if not t.is_file():
             return None
         return t.read_text('utf-8')
 
+    #
+
     MANIFESTS_FILE_NAME: ta.ClassVar[str] = '.manifests.json'
 
     def _load_package_uncached(self, pkg_name: str) -> ta.Optional[LoadedPackage]:
@@ -258,11 +421,11 @@ class ManifestLoader:
         with self._lock:
             return self._load_package_locked(pkg_name)
 
-    #
+    ##
 
     def _instantiate_value(self, cls: type, **kwargs: ta.Any) -> ta.Any:
-        if self._value_instantiator is not None:
-            return self._value_instantiator(cls, **kwargs)
+        if self._config.value_instantiator is not None:
+            return self._config.value_instantiator(cls, **kwargs)
         else:
             return cls(**kwargs)
 
@@ -272,136 +435,89 @@ class ManifestLoader:
         value = self._instantiate_value(cls, **value_dct)
         return value
 
-    #
+    ##
 
-    # FIXME:
-    # class LOAD_ALL:  # noqa
-    #     def __new__(cls, *args, **kwargs):  # noqa
-    #         raise TypeError
-    #
-    #     def __init_subclass__(cls, **kwargs):  # noqa
-    #         raise TypeError
-
-    def _load(
+    def _load_initialized(
             self,
-            *pkg_names: str,
-            only: ta.Optional[ta.Iterable[type]] = None,
+            *,
+            packages: ta.Optional[ta.Collection[str]] = None,
+            classes: ta.Optional[ta.Collection[type]] = None,
     ) -> ta.Sequence[LoadedManifest]:
-        only_keys: ta.Optional[ta.Set]
-        if only is not None:
-            only_keys = set()
-            for cls in only:
-                if not (isinstance(cls, type) and dc.is_dataclass(cls)):
-                    raise TypeError(cls)
-                mod_name = cls.__module__
-                mod_name = self._module_reverse_remap.get(mod_name, mod_name)
-                only_keys.add(f'${mod_name}.{cls.__qualname__}')
-        else:
-            only_keys = None
+        if isinstance(packages, str):
+            raise TypeError(packages)
+
+        class_keys: ta.Optional[ta.Set[str]] = None
+        if classes is not None:
+            class_keys = {self.get_class_key(cls) for cls in classes}
+
+        if packages is None:
+            packages = self._detected_packages
 
         lst: ta.List[ManifestLoader.LoadedManifest] = []
-        for pn in pkg_names:
-            lp = self.load_package(pn)
-            if lp is None:
+        for pn in packages:
+            if (lp := self._load_package_locked(pn)) is None:
                 continue
 
-            for m in lp.manifests:
-                if only_keys is not None and m.class_key not in only_keys:
-                    continue
+            if class_keys is not None:
+                for ck in class_keys:
+                    lst.extend(lp.manifests_by_class_key.get(ck, []))
 
-                lst.append(m)
+            else:
+                lst.extend(lp.manifests)
 
         return lst
 
-    def load(
+    def _load_locked(
             self,
-            *pkg_names: str,
-            only: ta.Optional[ta.Iterable[type]] = None,
+            *,
+            packages: ta.Optional[ta.Collection[str]] = None,
+            classes: ta.Optional[ta.Collection[type]] = None,
     ) -> ta.Sequence[LoadedManifest]:
-        with self._lock:
-            return self._load(
-                *pkg_names,
-                only=only,
-            )
-
-    #
-
-    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
-
-        # This is a fat dep so do it late.
-        from importlib import metadata as importlib_metadata  # noqa
-
-        x = [
-            ep.value
-            for ep in importlib_metadata.entry_points(group=cls.ENTRY_POINT_GROUP)
-        ]
-
-        cls._discovered_packages = x
-        return x
-
-    #
-
-    def _scan_package_root_dir_uncached(
-            self,
-            root_dir: str,
-    ) -> ta.Sequence[str]:
-        pkgs: ta.List[str] = []
+        self._initialize_locked()
+        return self._load_initialized(
+            packages=packages,
+            classes=classes,
+        )
 
-        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_package_root_dir_locked(
+    def load(
             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
+            *,
+            packages: ta.Optional[ta.Collection[str]] = None,
+            classes: ta.Optional[ta.Collection[type]] = None,
+    ) -> ta.Sequence[LoadedManifest]:
+        if isinstance(packages, str):
+            raise TypeError(packages)
 
-    def _scan_package_root_dir(
-            self,
-            root_dir: str,
-    ) -> ta.Sequence[str]:
         with self._lock:
-            return self._scan_package_root_dir_locked(root_dir)
+            return self._load_locked(
+                packages=packages,
+                classes=classes,
+            )
 
-    def scan_or_discover_packages(
+    def load_values(
             self,
             *,
-            specified_root_dirs: ta.Optional[ta.Sequence[str]] = None,
-            fallback_root_dir: ta.Optional[str] = None,
-    ) -> ta.Sequence[str]:
-        pkgs: list[str] = []
-
-        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_packages())
-
-            if not pkgs and fallback_root_dir is not None:
-                pkgs.extend(self._scan_package_root_dir(fallback_root_dir))
+            packages: ta.Optional[ta.Collection[str]] = None,
+            classes: ta.Optional[ta.Collection[type]] = None,
+    ) -> ta.Sequence[ta.Any]:
+        return [
+            lm.value()
+            for lm in self.load(
+                packages=packages,
+                classes=classes,
+            )
+        ]
 
-        return pkgs
+    def load_values_of(
+            self,
+            cls: ta.Type[T],
+            *,
+            packages: ta.Optional[ta.Collection[str]] = None,
+    ) -> ta.Sequence[T]:
+        return [
+            ta.cast(T, lm.value())
+            for lm in self.load(
+                packages=packages,
+                classes=[cls],
+            )
+        ]

omlish/testing/pytest/skip.py

@@ -17,20 +17,35 @@ from ... import lang
 
 def if_cant_import(*modules: str, **kwargs):
     missing = [m for m in modules if not lang.can_import(m, **kwargs)]
-    return pytest.mark.skipif(bool(missing), reason=f'requires import {", ".join(missing)}')
+    return pytest.mark.skipif(
+        bool(missing),
+        reason=f'requires import {", ".join(missing)}',
+    )
 
 
 def if_not_on_path(exe: str):
-    return pytest.mark.skipif(shutil.which(exe) is None, reason=f'requires exe on path {exe}')
+    return pytest.mark.skipif(
+        shutil.which(exe) is None,
+        reason=f'requires exe on path {exe}',
+    )
 
 
 def if_python_version_less_than(num: ta.Sequence[int]):
-    return pytest.mark.skipif(sys.version_info < tuple(num), reason=f'python version {tuple(sys.version_info)} < {tuple(num)}')  # noqa
+    return pytest.mark.skipif(
+        sys.version_info < tuple(num),
+        reason=f'python version {tuple(sys.version_info)} < {tuple(num)}',
+    )
 
 
 def if_not_platform(*platforms: str):
-    return pytest.mark.skipif(sys.platform not in platforms, reason=f'requires platform in {platforms}')
+    return pytest.mark.skipif(
+        sys.platform not in platforms,
+        reason=f'requires platform in {platforms}',
+    )
 
 
 def if_nogil():
-    return pytest.mark.skipif(sysconfig.get_config_var('Py_GIL_DISABLED'), reason='requires gil build')
+    return pytest.mark.skipif(
+        sysconfig.get_config_var('Py_GIL_DISABLED'),
+        reason='requires gil build',
+    )

{omlish-0.0.0.dev403.dist-info → omlish-0.0.0.dev405.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev403
+Version: 0.0.0.dev405
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -28,7 +28,7 @@ Requires-Dist: asttokens~=3.0; extra == "all"
 Requires-Dist: executing~=2.2; extra == "all"
 Requires-Dist: psutil~=7.0; extra == "all"
 Requires-Dist: orjson~=3.11; extra == "all"
-Requires-Dist: ujson~=5.10; extra == "all"
+Requires-Dist: ujson~=5.11; extra == "all"
 Requires-Dist: pyyaml~=6.0; extra == "all"
 Requires-Dist: cbor2~=5.7; extra == "all"
 Requires-Dist: cloudpickle~=3.1; extra == "all"
@@ -71,7 +71,7 @@ Requires-Dist: executing~=2.2; extra == "diag"
 Requires-Dist: psutil~=7.0; extra == "diag"
 Provides-Extra: formats
 Requires-Dist: orjson~=3.11; extra == "formats"
-Requires-Dist: ujson~=5.10; extra == "formats"
+Requires-Dist: ujson~=5.11; extra == "formats"
 Requires-Dist: pyyaml~=6.0; extra == "formats"
 Requires-Dist: cbor2~=5.7; extra == "formats"
 Requires-Dist: cloudpickle~=3.1; extra == "formats"

{omlish-0.0.0.dev403.dist-info → omlish-0.0.0.dev405.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=ftpXGlXqsqDmBh0eWXtndZBLj8Y6QVhS5g5lKgEAf3U,8587
-omlish/__about__.py,sha256=sS7mjsxVPH8xRx_p0z5qBpHSL6REnABss-XCt5y8_Pk,3601
+omlish/__about__.py,sha256=Zu2-AzTYNiCm8KVyeTpwqEU8oCTBUlyG8PBMsAwgeQI,3601
 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,7 +73,7 @@ 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=DxdfV1Ays5kPB-3fG_s3_ptNVbyUfY8BgjmvEmH2JSI,4132
+omlish/codecs/registry.py,sha256=PDfo0UtVZ96SILe5w4piPpWR-cjh1NiixKeSS7LgQKk,4003
 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=BIc806ri5Eq-kR03Ya2YfYTRI0g1rn_0haQPUqxXqys,2816
@@ -82,7 +82,7 @@ omlish/collections/bimap.py,sha256=3szDCscPJlFRtkpyVQNWneg4s50mr6Rd0jdTzVEIcnE,1
 omlish/collections/coerce.py,sha256=tAls15v_7p5bUN33R7Zbko87KW5toWHl9fRialCqyNY,7030
 omlish/collections/frozen.py,sha256=LMbAHYDENIQk1hvjCTvpnx66m1TalrHa4CSn8n_tsXQ,4142
 omlish/collections/hasheq.py,sha256=uHypfZlHhicQPvx9OOlpT9MSLwfc_mFil-WaxF9dTOo,3732
-omlish/collections/identity.py,sha256=S_W508EkU-AW0TZ7cv1wWUc6EG54vww4XbcfGjDFTgg,4793
+omlish/collections/identity.py,sha256=00UAYIjCRhyj73Es0jVNvOloXjRxHcjRxGQeWo75OEo,4834
 omlish/collections/mappings.py,sha256=lAzKP9RONLjFH7emIDoY-6jukuD-Sa7fdxzP7u6qrqU,3261
 omlish/collections/multimaps.py,sha256=8Sqi1iVxUObnL47s8b1esa2TERoiEyyY4RBWF1VjDiw,3820
 omlish/collections/ordered.py,sha256=XV_ufr3QycjQ3nIy9L3BufdBosWD-3wb5xVZEHpZocQ,2467
@@ -481,7 +481,7 @@ omlish/lite/args.py,sha256=ILJXAiN3KjIoJwY42aKpYPngUdxHIy9ssVIExFVz3fE,978
 omlish/lite/cached.py,sha256=O7ozcoDNFm1Hg2wtpHEqYSp_i_nCLNOP6Ueq_Uk-7mU,1300
 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/contextmanagers.py,sha256=QEqVxUtmr9aJJ_03A-YC4vVUy8jkiIDCYIGIOlXvn8U,5827
 omlish/lite/dataclasses.py,sha256=aRSCZz1jN_UI-CWJhN0SJeKxa-79vXNUZ6YOMgG31SE,3610
 omlish/lite/imports.py,sha256=GyEDKL-WuHtdOKIL-cc8aFd0-bHwZFDEjAB52ItabX0,1341
 omlish/lite/inject.py,sha256=xvmLmtD3_2INnkurJQv76_Rkh9usbApEQrXJ4cvuVAk,29019
@@ -518,8 +518,8 @@ 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=Z5afzBJgI0tyTS8mPbYY4pYvoZu_xtdhRBOtZ3IIwzA,929
-omlish/manifests/globals.py,sha256=nrA85o8zFTEYv440Y1wgr7SmtW6AE_3jF_Dls6RB_nE,1661
-omlish/manifests/loading.py,sha256=kzJwESneZB1mAK6PsVPXvfNjr-MOXL7bbKQ8gEmbVkU,11984
+omlish/manifests/globals.py,sha256=kVqQ-fT4kc7xWzLHoI731GviitFPv2v2yqw-p7t7Exs,2628
+omlish/manifests/loading.py,sha256=tnAxvyJRAncyKihaBH8oqcJmHKaunPXm1Y1OpAi3iQc,15870
 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
@@ -783,7 +783,7 @@ omlish/testing/testing.py,sha256=tlBeqVmzGhjRbWygJt3mZljq662qR4nAaGNE2VoAey4,361
 omlish/testing/pytest/__init__.py,sha256=i4ti6Q2rVYJ-XBk9UYDfUUagCrEDTC5jOeSykBjYYZQ,234
 omlish/testing/pytest/helpers.py,sha256=HxiKvpJQ4b6WCiQXOqQTqKbmr7CMAgCF6hViT6pfIuw,202
 omlish/testing/pytest/marks.py,sha256=g0RgdvFAd3xog3kKYyb9QtiUVPrEG3JX_abhDNrHJy0,285
-omlish/testing/pytest/skip.py,sha256=tra8FM5CZTh4M7ZWVf9YPmKUX4yhesf61XRoIkO4s9c,954
+omlish/testing/pytest/skip.py,sha256=d4ivXMnnCXVxiRfIN17RzweodExTeWY0qeFf8gmEJhM,1061
 omlish/testing/pytest/inject/__init__.py,sha256=pdRKv1HcDmJ_yArKJbYITPXXZthRSGgBJWqITr0Er38,117
 omlish/testing/pytest/inject/harness.py,sha256=uaFDli1ovhue-kfXV5WXyLn6cVOWNQf_2vFD13r-JyQ,5700
 omlish/testing/pytest/plugins/__init__.py,sha256=ys1zXrYrNm7Uo6YOIVJ6Bd3dQo6kv387k7MbTYlqZSI,467
@@ -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.dev403.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev403.dist-info/METADATA,sha256=AFfMDWuU93a0pAwqEi7fa2ctw0_KONoRYd-MEI5u9NI,18881
-omlish-0.0.0.dev403.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omlish-0.0.0.dev403.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev403.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev403.dist-info/RECORD,,
+omlish-0.0.0.dev405.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev405.dist-info/METADATA,sha256=y4Y668MaUQry-Qf4i3hWdu6-nugPJgTmu-hknnshYZI,18881
+omlish-0.0.0.dev405.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omlish-0.0.0.dev405.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev405.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev405.dist-info/RECORD,,