omlish 0.0.0.dev20__py3-none-any.whl → 0.0.0.dev21__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev20'
-__revision__ = '56a3421b375112818e306f2c17d467c7aac1d26b'
+__version__ = '0.0.0.dev21'
+__revision__ = '4cb4af9e253f312d5f301449f08dfa7168234e07'
 
 
 #

omlish/dataclasses/impl/fields.py

@@ -4,10 +4,13 @@ import typing as ta
 
 from ... import check as check_
 from ... import lang
+from .internals import FIELDS_ATTR
 from .internals import FieldType
 from .internals import is_classvar
 from .internals import is_initvar
+from .internals import is_kw_only
 from .params import get_field_extras
+from .processing import Processor
 
 
 if ta.TYPE_CHECKING:
@@ -19,6 +22,9 @@ else:
 MISSING = dc.MISSING
 
 
+##
+
+
 def field_type(f: dc.Field) -> FieldType:
     if (ft := getattr(f, '_field_type')) is not None:
         return FieldType(ft)
@@ -30,6 +36,51 @@ def has_default(f: dc.Field) -> bool:
     return not (f.default is MISSING and f.default_factory is MISSING)
 
 
+##
+
+
+class FieldsProcessor(Processor):
+    def _process(self) -> None:
+        cls = self._info.cls
+        fields: dict[str, dc.Field] = {}
+
+        for b in cls.__mro__[-1:0:-1]:
+            base_fields = getattr(b, FIELDS_ATTR, None)
+            if base_fields is not None:
+                for f in base_fields.values():
+                    fields[f.name] = f
+
+        cls_fields: list[dc.Field] = []
+
+        kw_only = self._info.params.kw_only
+        kw_only_seen = False
+        for name, ann in self._info.cls_annotations.items():
+            if is_kw_only(cls, ann):
+                if kw_only_seen:
+                    raise TypeError(f'{name!r} is KW_ONLY, but KW_ONLY has already been specified')
+                kw_only_seen = True
+                kw_only = True
+            else:
+                cls_fields.append(preprocess_field(cls, name, ann, kw_only))
+
+        for f in cls_fields:
+            fields[f.name] = f
+            if isinstance(getattr(cls, f.name, None), dc.Field):
+                if f.default is MISSING:
+                    delattr(cls, f.name)
+                else:
+                    setattr(cls, f.name, f.default)
+
+        for name, value in cls.__dict__.items():
+            if isinstance(value, dc.Field) and name not in self._info.cls_annotations:
+                raise TypeError(f'{name!r} is a field but has no type annotation')
+
+        setattr(cls, FIELDS_ATTR, fields)
+
+
+##
+
+
 def preprocess_field(
         cls: type,
         a_name: str,

omlish/dataclasses/impl/frozen.py

@@ -1,12 +1,47 @@
 import dataclasses as dc
 import typing as ta
 
+from ... import lang
+from .internals import FIELDS_ATTR
+from .internals import PARAMS_ATTR
 from .processing import Processor
+from .reflect import ClassInfo
 from .utils import Namespace
 from .utils import create_fn
 from .utils import set_new_attribute
 
 
+if ta.TYPE_CHECKING:
+    from . import metaclass
+else:
+    metaclass = lang.proxy_import('.metaclass', __package__)
+
+
+def check_frozen_bases(info: ClassInfo) -> None:
+    mc_base = getattr(metaclass, 'Data', None)
+    all_frozen_bases = None
+    any_frozen_base = False
+    has_dataclass_bases = False
+    for b in info.cls.__mro__[-1:0:-1]:
+        if b is mc_base:
+            continue
+        base_fields = getattr(b, FIELDS_ATTR, None)
+        if base_fields is not None:
+            has_dataclass_bases = True
+            if all_frozen_bases is None:
+                all_frozen_bases = True
+            current_frozen = getattr(b, PARAMS_ATTR).frozen
+            all_frozen_bases = all_frozen_bases and current_frozen
+            any_frozen_base = any_frozen_base or current_frozen
+
+    if has_dataclass_bases:
+        if any_frozen_base and not info.params.frozen:
+            raise TypeError('cannot inherit non-frozen dataclass from a frozen one')
+
+        if all_frozen_bases is False and info.params.frozen:
+            raise TypeError('cannot inherit frozen dataclass from a non-frozen one')
+
+
 def frozen_get_del_attr(
         cls: type,
         fields: ta.Sequence[dc.Field],
@@ -46,6 +81,9 @@ def frozen_get_del_attr(
 
 
 class FrozenProcessor(Processor):
+    def check(self) -> None:
+        check_frozen_bases(self._info)
+
     def _process(self) -> None:
         if not self._info.params.frozen:
             return

omlish/dataclasses/impl/main.py

@@ -5,14 +5,13 @@ import typing as ta
 from ... import check
 from ... import lang
 from .copy import CopyProcessor
-from .fields import preprocess_field
+from .fields import FieldsProcessor
 from .frozen import FrozenProcessor
 from .hashing import HashProcessor
 from .init import InitProcessor
 from .internals import FIELDS_ATTR
 from .internals import PARAMS_ATTR
 from .internals import Params
-from .internals import is_kw_only
 from .order import OrderProcessor
 from .params import ParamsExtras
 from .processing import Processor
@@ -26,12 +25,6 @@ from .simple import OverridesProcessor
 from .slots import add_slots
 
 
-if ta.TYPE_CHECKING:
-    from . import metaclass
-else:
-    metaclass = lang.proxy_import('.metaclass', __package__)
-
-
 MISSING = dc.MISSING
 
 
@@ -50,67 +43,6 @@ class MainProcessor:
         if self._info.params.order and not self._info.params.eq:
             raise ValueError('eq must be true if order is true')
 
-    def _check_frozen_bases(self) -> None:
-        mc_base = getattr(metaclass, 'Data', None)
-        all_frozen_bases = None
-        any_frozen_base = False
-        has_dataclass_bases = False
-        for b in self._cls.__mro__[-1:0:-1]:
-            if b is mc_base:
-                continue
-            base_fields = getattr(b, FIELDS_ATTR, None)
-            if base_fields is not None:
-                has_dataclass_bases = True
-                if all_frozen_bases is None:
-                    all_frozen_bases = True
-                current_frozen = getattr(b, PARAMS_ATTR).frozen
-                all_frozen_bases = all_frozen_bases and current_frozen
-                any_frozen_base = any_frozen_base or current_frozen
-
-        if has_dataclass_bases:
-            if any_frozen_base and not self._info.params.frozen:
-                raise TypeError('cannot inherit non-frozen dataclass from a frozen one')
-
-            if all_frozen_bases is False and self._info.params.frozen:
-                raise TypeError('cannot inherit frozen dataclass from a non-frozen one')
-
-    @lang.cached_function
-    def _process_fields(self) -> None:
-        fields: dict[str, dc.Field] = {}
-
-        for b in self._cls.__mro__[-1:0:-1]:
-            base_fields = getattr(b, FIELDS_ATTR, None)
-            if base_fields is not None:
-                for f in base_fields.values():
-                    fields[f.name] = f
-
-        cls_fields: list[dc.Field] = []
-
-        kw_only = self._info.params.kw_only
-        kw_only_seen = False
-        for name, ann in self._info.cls_annotations.items():
-            if is_kw_only(self._cls, ann):
-                if kw_only_seen:
-                    raise TypeError(f'{name!r} is KW_ONLY, but KW_ONLY has already been specified')
-                kw_only_seen = True
-                kw_only = True
-            else:
-                cls_fields.append(preprocess_field(self._cls, name, ann, kw_only))
-
-        for f in cls_fields:
-            fields[f.name] = f
-            if isinstance(getattr(self._cls, f.name, None), dc.Field):
-                if f.default is MISSING:
-                    delattr(self._cls, f.name)
-                else:
-                    setattr(self._cls, f.name, f.default)
-
-        for name, value in self._cls.__dict__.items():
-            if isinstance(value, dc.Field) and name not in self._info.cls_annotations:
-                raise TypeError(f'{name!r} is a field but has no type annotation')
-
-        setattr(self._cls, FIELDS_ATTR, fields)
-
     @lang.cached_function
     def _transform_slots(self) -> None:
         if self._info.params.weakref_slot and not self._info.params.slots:
@@ -119,28 +51,32 @@ class MainProcessor:
             return
         self._cls = add_slots(self._cls, self._info.params.frozen, self._info.params.weakref_slot)
 
+    PROCESSOR_TYPES: ta.ClassVar[ta.Sequence[type[Processor]]] = [
+        FieldsProcessor,
+        InitProcessor,
+        OverridesProcessor,
+        ReprProcessor,
+        EqProcessor,
+        OrderProcessor,
+        FrozenProcessor,
+        HashProcessor,
+        DocProcessor,
+        MatchArgsProcessor,
+        ReplaceProcessor,
+        CopyProcessor,
+    ]
+
     @lang.cached_function
     def process(self) -> type:
         self._check_params()
-        self._check_frozen_bases()
-
-        self._process_fields()
-
-        pcls: type[Processor]
-        for pcls in [
-            InitProcessor,
-            OverridesProcessor,
-            ReprProcessor,
-            EqProcessor,
-            OrderProcessor,
-            FrozenProcessor,
-            HashProcessor,
-            DocProcessor,
-            MatchArgsProcessor,
-            ReplaceProcessor,
-            CopyProcessor,
-        ]:
-            pcls(self._info).process()
+
+        ps = [pcls(self._info) for pcls in self.PROCESSOR_TYPES]
+
+        for p in ps:
+            p.check()
+
+        for p in ps:
+            p.process()
 
         self._transform_slots()
 

omlish/dataclasses/impl/processing.py

@@ -1,13 +1,21 @@
+import typing as ta
+
 from ... import lang
-from .reflect import ClassInfo
+
+
+if ta.TYPE_CHECKING:
+    from .reflect import ClassInfo
 
 
 class Processor(lang.Abstract):
-    def __init__(self, info: ClassInfo) -> None:
+    def __init__(self, info: 'ClassInfo') -> None:
         super().__init__()
         self._cls = info.cls
         self._info = info
 
+    def check(self) -> None:
+        pass
+
     @lang.cached_function
     def process(self) -> None:
         self._process()

omlish/lang/classes/simple.py

@@ -45,15 +45,18 @@ class _MarkerMeta(abc.ABCMeta):
 
     def __new__(mcls, name, bases, namespace):
         global _MARKER_NAMESPACE_KEYS
+
         if _MARKER_NAMESPACE_KEYS is None:
             if not (namespace.get('__module__') == __name__ and name == 'Marker'):
                 raise RuntimeError
             _MARKER_NAMESPACE_KEYS = set(namespace)
+
         else:
             if set(namespace) - _MARKER_NAMESPACE_KEYS:
                 raise TypeError('Markers must not include contents. Did you mean to use Namespace?')
             if Final not in bases:
                 bases += (Final,)
+
         return super().__new__(mcls, name, bases, namespace)
 
     def __instancecheck__(self, instance):

omlish/lang/clsdct.py

@@ -55,8 +55,10 @@ class ClassDctFn:
         except KeyError:
             f = sys._getframe(self._offset)  # noqa
             cls_dct = _skip_cls_dct_frames(f).f_locals
+
         if not is_possibly_cls_dct(cls_dct):
             raise TypeError(cls_dct)
+
         return self._fn(cls_dct, *args, **kwargs)
 
 

omlish/lang/contextmanagers.py

@@ -227,6 +227,47 @@ class ExitStacked:
             return superfn(exc_type, exc_val, exc_tb)
 
 
+class AsyncExitStacked:
+
+    @property
+    def _exit_stack(self) -> contextlib.AsyncExitStack:
+        try:
+            return self.__exit_stack  # type: ignore
+        except AttributeError:
+            es = self.__exit_stack = contextlib.AsyncExitStack()
+            return es
+
+    async def _enter_async_context(self, context_manager: ta.AsyncContextManager[T]) -> T:
+        return await self._exit_stack.enter_async_context(ta.cast(ta.AsyncContextManager, context_manager))
+
+    def _enter_context(self, context_manager: ta.ContextManager[T]) -> T:
+        return self._exit_stack.enter_context(ta.cast(ta.ContextManager, context_manager))
+
+    async def __aenter__(self) -> ta.Self:
+        try:
+            superfn = super().__aenter__  # type: ignore
+        except AttributeError:
+            ret = self
+        else:
+            ret = await superfn()
+        await self._exit_stack.__aenter__()
+        return ret
+
+    async def __aexit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: types.TracebackType | None,
+    ) -> bool | None:
+        await self._exit_stack.__aexit__(exc_type, exc_val, exc_tb)
+        try:
+            superfn = super().__aexit__  # type: ignore
+        except AttributeError:
+            return None
+        else:
+            return await superfn(exc_type, exc_val, exc_tb)
+
+
 ##
 
 

omlish/lang/descriptors.py

@@ -37,8 +37,10 @@ def _has_method_descriptor(obj: ta.Any) -> bool:
     while True:
         if is_method_descriptor(obj):
             return True
+
         elif isinstance(obj, functools.partial):
             obj = obj.func
+
         else:
             try:
                 obj = getattr(obj, '__wrapped__')
@@ -65,6 +67,7 @@ def unwrap_func_with_partials(fn: ta.Callable) -> tuple[ta.Callable, list[functo
     while True:
         if is_method_descriptor(fn) or isinstance(fn, types.MethodType):
             fn = fn.__func__  # type: ignore
+
         elif hasattr(fn, '__wrapped__'):
             nxt = fn.__wrapped__
             if not callable(nxt):
@@ -72,13 +75,16 @@ def unwrap_func_with_partials(fn: ta.Callable) -> tuple[ta.Callable, list[functo
             if nxt is fn:
                 raise TypeError(fn)
             fn = nxt
+
         # NOTE: __wrapped__ takes precedence - a partial might point to a bound Method when the important information is
         # still the unbound func. see _decorator_descriptor for an example of this.
         elif isinstance(fn, functools.partial):
             ps.append(fn)
             fn = fn.func
+
         else:
             break
+
     return fn, ps
 
 

omlish/lang/objects.py

@@ -105,20 +105,24 @@ def build_mro_dict(
 ) -> ta.Mapping[str, ta.Any]:
     if owner_cls is None:
         owner_cls = instance_cls
+
     mro = instance_cls.__mro__[-2::-1]
     try:
         pos = mro.index(owner_cls)
     except ValueError:
         raise TypeError(f'Owner class {owner_cls} not in mro of instance class {instance_cls}') from None
+
     dct: dict[str, ta.Any] = {}
     if not bottom_up_key_order:
         for cur_cls in mro[:pos + 1][::-1]:
             for k, v in cur_cls.__dict__.items():
                 if k not in dct:
                     dct[k] = v
+
     else:
         for cur_cls in mro[:pos + 1]:
             dct.update(cur_cls.__dict__)
+
     return dct
 
 

omlish/lang/resolving.py

@@ -10,37 +10,46 @@ class ResolvableClassNameError(NameError):
 def get_cls_fqcn(cls: type, *, nocheck: bool = False) -> str:
     if not isinstance(cls, type):
         raise TypeError(cls)
+
     mn = cls.__module__
     if set(mn) - set(string.ascii_lowercase + string.digits + '_.'):
         raise ResolvableClassNameError(cls)
+
     qn = cls.__qualname__
     if not all(qp[0].isupper() for qp in qn.split('.')) or (set(qn) - set(string.ascii_letters + string.digits + '.')):
         raise ResolvableClassNameError(cls)
+
     fqcn = '.'.join([cls.__module__, cls.__qualname__])
     if not nocheck:
         if get_fqcn_cls(fqcn, nocheck=True) is not cls:
             raise ResolvableClassNameError(cls, fqcn)
+
     return fqcn
 
 
 def get_fqcn_cls(fqcn: str, *, nocheck: bool = False) -> type:
     if not isinstance(fqcn, str) or not fqcn:
         raise TypeError(fqcn)
+
     parts = fqcn.split('.')
     pos = next(i for i, p in enumerate(parts) if p[0].isupper())
     mps, qps = parts[:pos], parts[pos:]
     mod = importlib.import_module('.'.join(mps))
+
     o: ta.Any = mod
     for qp in qps:
         o = getattr(o, qp)
         if not isinstance(o, type):
             raise TypeError(o)
+
     cls = o
     if not isinstance(cls, type):
         raise TypeError(cls)
+
     if not nocheck:
         if not get_cls_fqcn(cls, nocheck=True) == fqcn:
             raise ResolvableClassNameError(cls, fqcn)
+
     return o
 
 

omlish/lite/marshal.py

@@ -232,8 +232,10 @@ _OBJ_MARSHALER_GENERIC_MAPPING_TYPES: ta.Dict[ta.Any, type] = {
 
 _OBJ_MARSHALER_GENERIC_ITERABLE_TYPES: ta.Dict[ta.Any, type] = {
     **{t: t for t in (list, tuple, set, frozenset)},
-    **{t: frozenset for t in (collections.abc.Set, collections.abc.MutableSet)},
-    **{t: tuple for t in (collections.abc.Sequence, collections.abc.MutableSequence)},
+    collections.abc.Set: frozenset,
+    collections.abc.MutableSet: set,
+    collections.abc.Sequence: tuple,
+    collections.abc.MutableSequence: list,
 }
 
 

omlish/multiprocessing.py

@@ -47,19 +47,19 @@ class DummyValueProxy(ValueProxy[T]):
 
 @dc.dataclass(frozen=True, kw_only=True)
 class SpawnExtras:
-    fds: ta.AbstractSet[int] | None = None
+    pass_fds: ta.AbstractSet[int] | None = None
     deathsig: int | None = None
 
 
 class ExtrasSpawnPosixPopen(mp.popen_spawn_posix.Popen):
     def __init__(self, process_obj: 'ExtrasSpawnProcess', *, extras: SpawnExtras) -> None:
         self.__extras = extras
-        self.__extra_fds = extras.fds
+        self.__pass_fds = extras.pass_fds
         super().__init__(process_obj)
 
     def _launch(self, process_obj: 'ExtrasSpawnProcess') -> None:
-        if self.__extra_fds:
-            for fd in self.__extra_fds:
+        if self.__pass_fds:
+            for fd in self.__pass_fds:
                 self.duplicate_for_child(fd)
             self._extra_fds = None
 

omlish/specs/jsonschema/types.py

@@ -1,4 +1,5 @@
 import enum
+import typing as ta
 
 
 class JsonType(enum.Enum):
@@ -8,3 +9,13 @@ class JsonType(enum.Enum):
     ARRAY = enum.auto()
     NUMBER = enum.auto()
     STRING = enum.auto()
+
+
+TYPE_SETS_BY_JSON_TYPE: ta.Mapping[JsonType, ta.AbstractSet[type]] = {
+    JsonType.NULL: {type(None)},
+    JsonType.BOOLEAN: {bool},
+    JsonType.OBJECT: {dict},
+    JsonType.ARRAY: {list},
+    JsonType.NUMBER: {int, float},
+    JsonType.STRING: {str},
+}

{omlish-0.0.0.dev20.dist-info → omlish-0.0.0.dev21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev20
+Version: 0.0.0.dev21
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev20.dist-info → omlish-0.0.0.dev21.dist-info}/RECORD

@@ -1,4 +1,4 @@
-omlish/__about__.py,sha256=aaPwsrPbNAl3zQVkQ9n1ZeBGXbeIaqkXe-qJK-YhMn4,2451
+omlish/__about__.py,sha256=EGrVhtPidloIZMlJKawKWjhmKU4ZCiYWFt2sk2YMU54,2451
 omlish/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/argparse.py,sha256=QRQmX9G0-L_nATkFtGHvpd4qrpYzKATdjuFLbBqzJPM,6224
 omlish/c3.py,sha256=W5EwYx9Por3rWYLkKUitJ6OoRMLLgVTfLTyroOz41Y0,8047
@@ -14,7 +14,7 @@ omlish/iterators.py,sha256=GGLC7RIT86uXMjhIIIqnff_Iu5SI_b9rXYywYGFyzmo,7292
 omlish/libc.py,sha256=u0481imCiTFqP_e-v9g0pD-0WD249j5vYzhtn-fnNkY,15308
 omlish/matchfns.py,sha256=o2evI7q0CAMHR8RQ_Jks6L0UoNpEDltnLjOiamJDtmU,6155
 omlish/math.py,sha256=AVqp5Y8yxKA-wO0BgrzaxA0Ga3PZiCXnYcwivMneC-0,3804
-omlish/multiprocessing.py,sha256=Jbcr71p_HlsM5rIFl9obzSv9TCusPhxciwpBXLTYpmc,5179
+omlish/multiprocessing.py,sha256=QZT4C7I-uThCAjaEY3xgUYb-5GagUlnE4etN01LDyU4,5186
 omlish/os.py,sha256=cz4nL2ujaxH_-XRq3JUD8af8mSe1JXGPIoXP9XAEd0M,2607
 omlish/runmodule.py,sha256=PWvuAaJ9wQQn6bx9ftEL3_d04DyotNn8dR_twm2pgw0,700
 omlish/stats.py,sha256=uqjN-focDVssFZMagj22HqmyJ1TBO4Wt-XnHp8-EtVw,9927
@@ -68,17 +68,17 @@ omlish/dataclasses/impl/as_.py,sha256=CD-t7hkC1EP2F_jvZKIA_cVoDuwZ-Ln_xC4fJumPYX
 omlish/dataclasses/impl/copy.py,sha256=Tn8_n6Vohs-w4otbGdubBEvhd3TsSTaM3EfNGdS2LYo,591
 omlish/dataclasses/impl/descriptors.py,sha256=rEYE1Len99agTQCC25hSPMnM19BgPr0ZChABGi58Fdk,2476
 omlish/dataclasses/impl/exceptions.py,sha256=WD0Tr1TnjUN4OR3f3rs8CgqtP2KBA1tKjPIbZO8Tzm0,178
-omlish/dataclasses/impl/fields.py,sha256=zBa-XjJJQ7dOP_se-A8Q4Vv3ol2xjpTQXTUBCnr1UVs,4377
-omlish/dataclasses/impl/frozen.py,sha256=5wKtt8WvPYCkHPrwR024mpvbFzqcbPQfgiFvy3orRJo,1692
+omlish/dataclasses/impl/fields.py,sha256=6Ry-fTntJEPigSHBtaegssxeOi0L4hffLSL4SMtqjSE,5908
+omlish/dataclasses/impl/frozen.py,sha256=x87DSM8FIMZ3c_BIUE8NooCkExFjPsabeqIueEP5qKs,2988
 omlish/dataclasses/impl/hashing.py,sha256=FKnHuXCg9ylrzK2TLGqO5yfRN4HX3F415CSLlVYXtYE,3190
 omlish/dataclasses/impl/init.py,sha256=yw9iInFHaR_TFWRzsryr8vgStHMQwqubL-s7pY5k1sA,5652
 omlish/dataclasses/impl/internals.py,sha256=LTCqGT8AhyGTWwioGrBpTJzDzPvAtizQKb0NBNKcNs0,2989
-omlish/dataclasses/impl/main.py,sha256=vAVdqb4cgvyssA7rCFl9i2D0MAffX45YtQbGQ2te5_c,5189
+omlish/dataclasses/impl/main.py,sha256=Ti0PKbFKraKvfmoPuR-G7nLVNzRC8mvEuXhCuC-M2kc,2574
 omlish/dataclasses/impl/metaclass.py,sha256=dlQEIN9MHBirll7Nx3StpzxYxXjrqxJ-QsorMcCNt7w,2828
 omlish/dataclasses/impl/metadata.py,sha256=binwdG0cyKdGEypRKYTbcDyH_be4aTaSnVnK2V5rwB8,1402
 omlish/dataclasses/impl/order.py,sha256=zWvWDkSTym8cc7vO1cLHqcBhhjOlucHOCUVJcdh4jt0,1369
 omlish/dataclasses/impl/params.py,sha256=M-xg9IeFftVy795oqlp7Yw8jE-7wG2K4vaFhXHKmL1k,2538
-omlish/dataclasses/impl/processing.py,sha256=iUvaNwRAt8rQsLIIkvRye5rfk6xhgR35EbcdwZCZec8,366
+omlish/dataclasses/impl/processing.py,sha256=DFxyFjL_h3awRyF_5eyTnB8QkuApx7Zc4QFnVoltlao,459
 omlish/dataclasses/impl/reflect.py,sha256=13af257_sjjM-4wfH84nl7CoHHMV_eFZpkIgUawZ3TE,5307
 omlish/dataclasses/impl/replace.py,sha256=wS9GHX4fIwaPv1JBJzIewdBfXyK3X3V7_t55Da87dYo,1217
 omlish/dataclasses/impl/repr.py,sha256=oLXBTxqp88NKmz82HrJeGiTEiwK4l5LlXQT9Q0-tX3c,1605
@@ -156,17 +156,17 @@ omlish/inject/impl/proxy.py,sha256=1ko0VaKqzu9UG8bIldp9xtUrAVUOFTKWKTjOCqIGr4s,1
 omlish/inject/impl/scopes.py,sha256=M_RO_pGUr5mX84YyYmkr6CsMhkkV189_gOUsaYmYes4,5768
 omlish/lang/__init__.py,sha256=sjeN4p46itXbYfYJNqgin8olSU62xD700Af_vlgWiwI,3165
 omlish/lang/cached.py,sha256=0gjdxVELu69oRQ3kqSV3cGIHg6Nf4pcCIIRTEU52tCc,7607
-omlish/lang/clsdct.py,sha256=LXwLCULeI_8Np-7-pZkyNAHpUZLcQiBEQiHwKYQ0WRo,1742
+omlish/lang/clsdct.py,sha256=AjtIWLlx2E6D5rC97zQ3Lwq2SOMkbg08pdO_AxpzEHI,1744
 omlish/lang/cmp.py,sha256=5vbzWWbqdzDmNKAGL19z6ZfUKe5Ci49e-Oegf9f4BsE,1346
-omlish/lang/contextmanagers.py,sha256=C6FU_1ftMvp_Zbz9ixf_HsCSYQot_TZ7mpZBJEBc3Xc,8333
-omlish/lang/descriptors.py,sha256=J0oRWys9smHp9UYeearBATA7u-6t5pDnQgPfWiXN3B4,5902
+omlish/lang/contextmanagers.py,sha256=rzMSwJU7ObFXl46r6pGDbD45Zi_qZ9NHxDPnLNuux9o,9732
+omlish/lang/descriptors.py,sha256=VGbebrhWR0WLe3SASN444lBBvAreVMcwdam1FjcRxkQ,5908
 omlish/lang/exceptions.py,sha256=qJBo3NU1mOWWm-NhQUHCY5feYXR3arZVyEHinLsmRH4,47
 omlish/lang/functions.py,sha256=T4nPl46EHHGjMkz3FTRjsVhS9Y8HKcwM0jROU6_-Rv0,3619
 omlish/lang/imports.py,sha256=04ugFC8NI5sbL7NH4V0r0q_nFsP_AMkHLz697CVkMtQ,6274
 omlish/lang/iterables.py,sha256=_q6rHbdFfW3VBqez0IV3rUABoNxsA_oBv_sykm5zsbQ,2243
 omlish/lang/maybes.py,sha256=NYHZDjqDtwPMheDrj2VtUVujxRPf8Qpgk4ZlZCTvBZc,3492
-omlish/lang/objects.py,sha256=ewGWcbtjNQtoRba0uAEekLbn1e884ZJh09xPHzZkfy4,4306
-omlish/lang/resolving.py,sha256=UgrX-vxXtCGGEmnAMUYP4bUZ6-Ok0EcHVEKAZYbAS-o,1597
+omlish/lang/objects.py,sha256=1dY8dX5voIZf5FBYUiN0BRsWg2JCdsgRbDl9fLG7OtY,4310
+omlish/lang/resolving.py,sha256=OuN2mDTPNyBUbcrswtvFKtj4xgH4H4WglgqSKv3MTy0,1606
 omlish/lang/strings.py,sha256=ykeoou4JK7CEZXzrUJfqVOalEDvE--j0uhHt_SrsrUs,2834
 omlish/lang/sys.py,sha256=UoZz_PJYVKLQAKqYxxn-LHz1okK_38I__maZgnXMcxU,406
 omlish/lang/timeouts.py,sha256=vECdWYhc_IZgcal1Ng1Y42wf2FV3KAx-i8As-MgGHIQ,1186
@@ -174,7 +174,7 @@ omlish/lang/typing.py,sha256=pKDBHTYzoQtFCUxtlDDTpnKixZBxeE5Pblvv1nJbRYE,3236
 omlish/lang/classes/__init__.py,sha256=j1p0_uuMznKrY2EhMoj20uv6vx4LXljMzp7AaKe0mmU,530
 omlish/lang/classes/abstract.py,sha256=goIV14oY24EOs88eVe6E6NyrSPOOLMOcWTXTMuYKiqc,2304
 omlish/lang/classes/restrict.py,sha256=n_B-XqafVyO1caZzfbsv7tPxDJOBLl1BzQkoDSse0A4,3353
-omlish/lang/classes/simple.py,sha256=U9WB3S9svudIWF7bitptXzVjLHnlG_Xh72K-jIAekaU,3068
+omlish/lang/classes/simple.py,sha256=_OE6-eph3-pllGck83FcGZE8fDMUqPdWP9OeSDCSgww,3071
 omlish/lang/classes/virtual.py,sha256=54D4qOpDWHpP28Oc6bbBjdxquLvdvqMqLXj2XOnAeaQ,3323
 omlish/lifecycles/__init__.py,sha256=1FjYceXs-4fc-S-C9zFYmc2axHs4znnQHcJVHdY7a6E,578
 omlish/lifecycles/abstract.py,sha256=70CQyZy-c9a2o0ZJxPeUT7eYjWZTBrp2HpUBnrHdAOM,1109
@@ -190,7 +190,7 @@ omlish/lite/check.py,sha256=DR3Zj-7o4Y7pNheln68nN_BdX9zaotGQ2y8v97GDiWQ,535
 omlish/lite/contextmanagers.py,sha256=HnQJiyrOmSvTL22XRJrFl5CLpCyHD9fsntEUAr9G-60,427
 omlish/lite/json.py,sha256=7-02Ny4fq-6YAu5ynvqoijhuYXWpLmfCI19GUeZnb1c,740
 omlish/lite/logs.py,sha256=qgP0pNjkoG5gjQ6xuXM7qpsLwZX3WbS7WaZlDqQKry4,2641
-omlish/lite/marshal.py,sha256=5uwri-KzPiktnbYORkGXcJ4kulZvp_nS4MxPsU1Y-G0,8608
+omlish/lite/marshal.py,sha256=u6jYUN_AndvI6__HJBvSw5ElHWC0CfHqgiDS28Vpqjg,8593
 omlish/lite/reflect.py,sha256=9QYJwdINraq1JNMEgvoqeSlVvRRgOXpxAkpgX8EgRXc,1307
 omlish/lite/runtime.py,sha256=VUhmNQvwf8QzkWSKj4Q0ReieJA_PzHaJNRBivfTseow,452
 omlish/lite/secrets.py,sha256=FEc47dcU9M1CyMTnrihAAVwKf0ySZLahf83djOEDWXw,488
@@ -242,7 +242,7 @@ omlish/secrets/secrets.py,sha256=hFN82uYiBVx8YSE86leWNxb4IRp3qdwZPOi4w04h8u0,685
 omlish/secrets/subprocesses.py,sha256=EcnKlHHtnUMHGrBWXDfu8tv28wlgZx4P4GOiuPW9Vo8,1105
 omlish/specs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/specs/jsonschema/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/specs/jsonschema/types.py,sha256=aJrZq2oqjmbGa32YnWyGFPbEyNfm0YO9ixNy7qU-snE,189
+omlish/specs/jsonschema/types.py,sha256=qoxExgKfrI-UZXdk3qcVZIEyp1WckFbb85_eGInEoAY,467
 omlish/specs/jsonschema/keywords/__init__.py,sha256=Zt2g1BXd654uU2AQ5P7_-x2Wrtf6cNbP9mxI1wGN4wo,596
 omlish/specs/jsonschema/keywords/base.py,sha256=HA4OvsdvAl4o5JgJI_tuaHBGURjxT5QeFN6_ja5Z5xQ,1957
 omlish/specs/jsonschema/keywords/core.py,sha256=irJ5Rreg9hTeXu3FovSdzhFb3vUly-hYQVYflEgST3g,368
@@ -285,8 +285,8 @@ omlish/text/delimit.py,sha256=ubPXcXQmtbOVrUsNh5gH1mDq5H-n1y2R4cPL5_DQf68,4928
 omlish/text/glyphsplit.py,sha256=Ug-dPRO7x-OrNNr8g1y6DotSZ2KH0S-VcOmUobwa4B0,3296
 omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/parts.py,sha256=KGgo0wHOIMVMZtDso-rhSWKAcAkYAH2IGpg9tULabu8,6505
-omlish-0.0.0.dev20.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev20.dist-info/METADATA,sha256=BBHZ7D3ieK9P1cgSW23jGabeqRXDnzccCc8Tsby0J5Y,3718
-omlish-0.0.0.dev20.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-omlish-0.0.0.dev20.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev20.dist-info/RECORD,,
+omlish-0.0.0.dev21.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev21.dist-info/METADATA,sha256=xGxu7jRwygBxNlY-2GkuLO58zaPIx2lXCDxZg6N7GaI,3718
+omlish-0.0.0.dev21.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+omlish-0.0.0.dev21.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev21.dist-info/RECORD,,