omlish 0.0.0.dev20__tar.gz → 0.0.0.dev21__tar.gz

{omlish-0.0.0.dev20/omlish.egg-info → omlish-0.0.0.dev21}/PKG-INFO

@@ -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 → omlish-0.0.0.dev21}/omlish/__about__.py

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

{omlish-0.0.0.dev20 → omlish-0.0.0.dev21}/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-0.0.0.dev20 → omlish-0.0.0.dev21}/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-0.0.0.dev21/omlish/dataclasses/impl/main.py

@@ -0,0 +1,89 @@
+import abc
+import dataclasses as dc
+import typing as ta
+
+from ... import check
+from ... import lang
+from .copy import CopyProcessor
+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 .order import OrderProcessor
+from .params import ParamsExtras
+from .processing import Processor
+from .reflect import ClassInfo
+from .replace import ReplaceProcessor
+from .repr import ReprProcessor
+from .simple import DocProcessor
+from .simple import EqProcessor
+from .simple import MatchArgsProcessor
+from .simple import OverridesProcessor
+from .slots import add_slots
+
+
+MISSING = dc.MISSING
+
+
+class MainProcessor:
+    def __init__(self, cls: type) -> None:
+        super().__init__()
+
+        self._cls = check.isinstance(cls, type)
+        self._info = info = ClassInfo(cls, _constructing=True)
+
+        check.not_in(FIELDS_ATTR, cls.__dict__)
+        check.is_(check.isinstance(cls.__dict__[PARAMS_ATTR], Params), info.params)
+        check.is_(check.isinstance(check.not_none(info.cls_metadata)[ParamsExtras], ParamsExtras), info.params_extras)  # noqa
+
+    def _check_params(self) -> None:
+        if self._info.params.order and not self._info.params.eq:
+            raise ValueError('eq must be true if order is true')
+
+    @lang.cached_function
+    def _transform_slots(self) -> None:
+        if self._info.params.weakref_slot and not self._info.params.slots:
+            raise TypeError('weakref_slot is True but slots is False')
+        if not self._info.params.slots:
+            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()
+
+        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()
+
+        abc.update_abstractmethods(self._cls)  # noqa
+
+        return self._cls
+
+
+def process_class(cls: type) -> type:
+    return MainProcessor(cls).process()

{omlish-0.0.0.dev20 → omlish-0.0.0.dev21}/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-0.0.0.dev20 → omlish-0.0.0.dev21}/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-0.0.0.dev20 → omlish-0.0.0.dev21}/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-0.0.0.dev20 → omlish-0.0.0.dev21}/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-0.0.0.dev20 → omlish-0.0.0.dev21}/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-0.0.0.dev20 → omlish-0.0.0.dev21}/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-0.0.0.dev20 → omlish-0.0.0.dev21}/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-0.0.0.dev20 → omlish-0.0.0.dev21}/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-0.0.0.dev20 → omlish-0.0.0.dev21}/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-0.0.0.dev21/omlish/specs/jsonschema/types.py

@@ -0,0 +1,21 @@
+import enum
+import typing as ta
+
+
+class JsonType(enum.Enum):
+    NULL = enum.auto()
+    BOOLEAN = enum.auto()
+    OBJECT = enum.auto()
+    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 → omlish-0.0.0.dev21/omlish.egg-info}/PKG-INFO

@@ -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 → omlish-0.0.0.dev21}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '~=3.12'
-version = '0.0.0.dev20'
+version = '0.0.0.dev21'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',

omlish-0.0.0.dev20/omlish/dataclasses/impl/main.py

@@ -1,153 +0,0 @@
-import abc
-import dataclasses as dc
-import typing as ta
-
-from ... import check
-from ... import lang
-from .copy import CopyProcessor
-from .fields import preprocess_field
-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
-from .reflect import ClassInfo
-from .replace import ReplaceProcessor
-from .repr import ReprProcessor
-from .simple import DocProcessor
-from .simple import EqProcessor
-from .simple import MatchArgsProcessor
-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
-
-
-class MainProcessor:
-    def __init__(self, cls: type) -> None:
-        super().__init__()
-
-        self._cls = check.isinstance(cls, type)
-        self._info = info = ClassInfo(cls, _constructing=True)
-
-        check.not_in(FIELDS_ATTR, cls.__dict__)
-        check.is_(check.isinstance(cls.__dict__[PARAMS_ATTR], Params), info.params)
-        check.is_(check.isinstance(check.not_none(info.cls_metadata)[ParamsExtras], ParamsExtras), info.params_extras)  # noqa
-
-    def _check_params(self) -> None:
-        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:
-            raise TypeError('weakref_slot is True but slots is False')
-        if not self._info.params.slots:
-            return
-        self._cls = add_slots(self._cls, self._info.params.frozen, self._info.params.weakref_slot)
-
-    @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()
-
-        self._transform_slots()
-
-        abc.update_abstractmethods(self._cls)  # noqa
-
-        return self._cls
-
-
-def process_class(cls: type) -> type:
-    return MainProcessor(cls).process()