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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev19'
-__revision__ = '509bb451054d2d955e55cbcf1f271a9166a904eb'
+__version__ = '0.0.0.dev21'
+__revision__ = '4cb4af9e253f312d5f301449f08dfa7168234e07'
 
 
 #
@@ -88,7 +88,7 @@ class Project(ProjectBase):
         'sqlx': [
             'sqlean.py ~= 3.45; python_version < "3.13"',
 
-            'duckdb ~= 1.0',
+            'duckdb ~= 1.1',
         ],
 
         'testing': [

omlish/asyncs/anyio.py

@@ -23,6 +23,7 @@ async def killer(shutdown: anyio.Event, sleep_s: float) -> None:
     shutdown.set()
 
 """  # noqa
+import dataclasses as dc
 import signal
 import typing as ta
 
@@ -44,6 +45,12 @@ StapledByteStream: ta.TypeAlias = anyio.streams.stapled.StapledByteStream
 StapledObjectStream: ta.TypeAlias = anyio.streams.stapled.StapledObjectStream
 
 
+@dc.dataclass(eq=False)
+class MemoryStapledObjectStream(StapledObjectStream[T]):
+    send_stream: MemoryObjectSendStream[T]
+    receive_stream: MemoryObjectReceiveStream[T]
+
+
 ##
 
 
@@ -143,8 +150,8 @@ def split_memory_object_streams(
     return tup
 
 
-def create_stapled_memory_object_stream(max_buffer_size: float = 0) -> StapledObjectStream:
-    return StapledObjectStream(*anyio.create_memory_object_stream(max_buffer_size))
+def create_stapled_memory_object_stream(max_buffer_size: float = 0) -> MemoryStapledObjectStream:
+    return MemoryStapledObjectStream(*anyio.create_memory_object_stream(max_buffer_size))
 
 
 # FIXME: https://github.com/python/mypy/issues/15238
@@ -158,9 +165,9 @@ def create_memory_object_stream[T](max_buffer_size: float = 0) -> tuple[
 
 def staple_memory_object_stream(
         *args: anyio.create_memory_object_stream[T],
-) -> StapledObjectStream[T]:
+) -> MemoryStapledObjectStream[T]:
     send, receive = args
-    return StapledObjectStream(
+    return MemoryStapledObjectStream(
         check.isinstance(send, MemoryObjectSendStream),  # type: ignore
         check.isinstance(receive, MemoryObjectReceiveStream),  # type: ignore
     )
@@ -168,9 +175,9 @@ def staple_memory_object_stream(
 
 # FIXME: https://github.com/python/mypy/issues/15238
 # FIXME: https://youtrack.jetbrains.com/issues?q=tag:%20%7BPEP%20695%7D
-def staple_memory_object_stream2[T](max_buffer_size: float = 0) -> StapledObjectStream[T]:
+def staple_memory_object_stream2[T](max_buffer_size: float = 0) -> MemoryStapledObjectStream[T]:
     send, receive = anyio.create_memory_object_stream[T](max_buffer_size)
-    return StapledObjectStream(
+    return MemoryStapledObjectStream(
         check.isinstance(send, MemoryObjectSendStream),  # type: ignore
         check.isinstance(receive, MemoryObjectReceiveStream),  # type: ignore
     )

omlish/dataclasses/__init__.py

@@ -96,4 +96,6 @@ from .utils import (  # noqa
     opt_repr,
     update_field_extras,
     update_field_metadata,
+    update_fields,
+    update_fields_metadata,
 )

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/metadata.py

@@ -70,5 +70,6 @@ class Init(lang.Marker):
     pass
 
 
-def init(fn: ta.Callable[..., None]) -> None:
+def init(fn: ta.Callable):
     _append_cls_md(Init, fn)
+    return fn

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/dataclasses/utils.py

@@ -12,6 +12,9 @@ from .impl.params import get_field_extras
 T = ta.TypeVar('T')
 
 
+#
+
+
 def maybe_post_init(sup: ta.Any) -> bool:
     try:
         fn = sup.__post_init__
@@ -21,10 +24,16 @@ def maybe_post_init(sup: ta.Any) -> bool:
     return True
 
 
+#
+
+
 def opt_repr(o: ta.Any) -> str | None:
     return repr(o) if o is not None else None
 
 
+#
+
+
 class field_modifier:  # noqa
     def __init__(self, fn: ta.Callable[[dc.Field], dc.Field]) -> None:
         super().__init__()
@@ -58,6 +67,42 @@ def update_field_extras(f: dc.Field, *, unless_non_default: bool = False, **kwar
     })
 
 
+def update_fields(
+        fn: ta.Callable[[str, dc.Field], dc.Field],
+        fields: ta.Iterable[str] | None = None,
+) -> ta.Callable[[type[T]], type[T]]:
+    def inner(cls):
+        if fields is None:
+            for a, v in list(cls.__dict__.items()):
+                if isinstance(v, dc.Field):
+                    setattr(cls, a, fn(a, v))
+
+        else:
+            for a in fields:
+                v = cls.__dict__[a]
+                if not isinstance(v, dc.Field):
+                    v = dc.field(default=v)
+                setattr(cls, a, fn(a, v))
+
+        return cls
+
+    check.not_isinstance(fields, str)
+    return inner
+
+
+def update_fields_metadata(
+        nmd: ta.Mapping,
+        fields: ta.Iterable[str] | None = None,
+) -> ta.Callable[[type[T]], type[T]]:
+    def inner(a: str, f: dc.Field) -> dc.Field:
+        return update_field_metadata(f, nmd)
+
+    return update_fields(inner, fields)
+
+
+#
+
+
 def deep_replace(o: T, *args: str | ta.Callable[[ta.Any], ta.Mapping[str, ta.Any]]) -> T:
     if not args:
         return o

omlish/fnpairs.py

@@ -449,7 +449,7 @@ class Toml(ObjectStr_):
 #
 
 
-@_register_extension('cpkl')
+@_register_extension('clpkl')
 @dc.dataclass(frozen=True)
 class Cloudpickle(ObjectBytes_):
     protocol: int | None = None

omlish/formats/json.py

@@ -13,6 +13,7 @@ from .. import lang
 if ta.TYPE_CHECKING:
     import orjson as _orjson
     import ujson as _ujson
+
 else:
     _orjson = lang.proxy_import('orjson')
     _ujson = lang.proxy_import('ujson')

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
 
 
@@ -125,11 +131,13 @@ class _decorator_descriptor:  # noqa
 
         def __get__(self, instance, owner=None):
             fn = self._fn.__get__(instance, owner)
+
             if self._md or instance is not None:
                 @functools.wraps(fn)
                 def inner(*args, **kwargs):
                     return self._wrapper(fn, *args, **kwargs)
                 return inner
+
             else:
                 @functools.wraps(fn)
                 def outer(this, *args, **kwargs):

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