omlish 0.0.0.dev284__py3-none-any.whl → 0.0.0.dev285__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev284'
-__revision__ = 'e10caaddb37a1fedcbe1bf3e711062e82a8cc7cb'
+__version__ = '0.0.0.dev285'
+__revision__ = 'e95058137e322e352c2579564d041f21cdf1220c'
 
 
 #

omlish/dataclasses/__init__.py

@@ -1,3 +1,6 @@
+##
+# stdlib interface
+
 from dataclasses import (  # noqa
     FrozenInstanceError,
 
@@ -15,46 +18,28 @@ from dataclasses import (  # noqa
     fields,
 
     is_dataclass,
-
-    # asdict,
-    # astuple,
-
-    # replace,
 )
 
-from .impl.api import (  # noqa
-    field as xfield,
-
+from .api import (  # noqa
     dataclass as xdataclass,
+
     make_dataclass as xmake_dataclass,
 
-    extra_class_params,
+    field as xfield,
 )
 
-from .impl.as_ import (  # noqa
+from .tools.as_ import (  # noqa
     asdict,
     astuple,
 )
 
-from .impl.params import (  # noqa
-    FieldExtras,
-    get_field_extras,
-
-    get_params,
-
-    get_params_extras,
-
-    MetaclassParams,
-    get_metaclass_params,
-)
-
-from .impl.replace import (  # noqa
+from .concerns.replace import (  # noqa
     replace,
 )
 
 
 ##
-
+# globals hack
 
 globals()['field'] = xfield
 
@@ -63,69 +48,82 @@ globals()['make_dataclass'] = xmake_dataclass
 
 
 ##
+# additional interface
 
+from .api import (  # noqa
+    append_class_metadata,
+    extra_class_params,
+    init,
+    metadata,
+    validate,
 
-from .impl.errors import (  # noqa
+    extra_field_params,
+    set_field_metadata,
+    update_extra_field_params,
+)
+
+from .errors import (  # noqa
+    FieldFnValidationError,
+    FieldTypeValidationError,
     FieldValidationError,
+    FnValidationError,
+    TypeValidationError,
     ValidationError,
 )
 
-from .impl.metaclass import (  # noqa
-    DataMeta,
+from .metaclass.bases import (  # noqa
+    Box,
+    Case,
     Data,
     Frozen,
-    Case,
-    Box,
 )
 
-from .impl.metadata import (  # noqa
-    Metadata,
-
-    get_merged_metadata,
-
-    UserMetadata,
-    metadata,
-
-    Validate,
-    validate,
+from .metaclass.meta import (  # noqa
+    DataMeta,
+)
 
-    Init,
-    init,
+from .metaclass.specs import (  # noqa
+    get_metaclass_spec,
 )
 
-from .impl.reflect import (  # noqa
-    ClassInfo,
+from .reflection import (  # noqa
     reflect,
 )
 
-from .static import (  # noqa
-    Static,
+from .tools.as_ import (  # noqa
+    shallow_asdict,
+    shallow_astuple,
 )
 
-from .utils import (  # noqa
-    opt_repr,
-    truthy_repr,
-
+from .tools.iter import (  # noqa
     fields_dict,
+
+    iter_items,
+    iter_keys,
+    iter_values,
+)
+
+from .tools.modifiers import (  # noqa
     field_modifier,
-    chain_metadata,
-    update_class_metadata,
-    update_field_metadata,
-    update_field_extras,
     update_fields,
-    update_fields_metadata,
-
-    shallow_astuple,
-    shallow_asdict,
+)
 
+from .tools.replace import (  # noqa
     deep_replace,
+)
 
-    iter_items,
-    iter_keys,
-    iter_values,
+from .tools.repr import (  # noqa
+    opt_repr,
+    truthy_repr,
 )
 
+from .tools.static import (  # noqa
+    Static,
+)
+
+
 ##
+# lite imports
 
 from ..lite.dataclasses import (  # noqa
     is_immediate_dataclass,

omlish/dataclasses/api/__init__.py

@@ -0,0 +1,25 @@
+from .classes.decorator import (  # noqa
+    dataclass,
+)
+
+from .classes.make import (  # noqa
+    make_dataclass,
+)
+
+from .classes.metadata import (  # noqa
+    append_class_metadata,
+    extra_class_params,
+    init,
+    metadata,
+    validate,
+)
+
+from .fields.metadata import (  # noqa
+    extra_field_params,
+    set_field_metadata,
+    update_extra_field_params,
+)
+
+from .fields.constructor import (  # noqa
+    field,
+)

omlish/dataclasses/api/classes/conversion.py

@@ -0,0 +1,30 @@
+import typing as ta
+
+from .... import check
+from ...internals import StdParams
+from ...specs import ClassSpec
+from ...specs import FieldSpec
+
+
+#
+
+
+def std_params_to_class_spec(
+        p: StdParams,
+        fields: ta.Sequence[FieldSpec],
+) -> ClassSpec:
+    return ClassSpec(
+        fields=fields,
+
+        init=check.isinstance(p.init, bool),
+        repr=check.isinstance(p.repr, bool),
+        eq=check.isinstance(p.eq, bool),
+        order=check.isinstance(p.order, bool),
+        unsafe_hash=check.isinstance(p.unsafe_hash, bool),
+        frozen=check.isinstance(p.frozen, bool),
+
+        match_args=check.isinstance(p.match_args, bool),
+        kw_only=check.isinstance(p.kw_only, bool),
+        slots=check.isinstance(p.slots, bool),
+        weakref_slot=check.isinstance(p.weakref_slot, bool),
+    )

omlish/dataclasses/api/classes/decorator.py

@@ -0,0 +1,145 @@
+"""
+TODO:
+ - collect init_fn's / validate_fns from superclass ClassSpecs
+"""
+import inspect
+import typing as ta
+
+from .... import check
+from .... import lang
+from ...internals import STD_FIELDS_ATTR
+from ...internals import STD_PARAMS_ATTR
+from ...processing.driving import drive_cls_processing
+from ...specs import ClassSpec
+from ...utils import class_decorator
+from ..fields.building import build_cls_std_fields
+from ..fields.conversion import std_field_to_field_spec
+from .metadata import extract_cls_metadata
+from .params import build_spec_std_params
+
+
+##
+
+
+@class_decorator
+def dataclass(
+        cls=None,
+        /,
+        *,
+
+        init=True,
+        repr=True,  # noqa
+        eq=True,
+        order=False,
+        unsafe_hash=False,
+        frozen=False,
+
+        match_args=True,
+        kw_only=False,
+        slots=False,
+        weakref_slot=False,
+
+        #
+
+        metadata: ta.Sequence[ta.Any] | None = None,
+
+        reorder: bool | None = None,
+        cache_hash: bool | None = None,
+        generic_init: bool | None = None,
+        override: bool | None = None,
+        repr_id: bool | None = None,
+
+        #
+
+        _plan_only: bool = False,
+):
+    if isinstance(metadata, ta.Mapping):
+        raise TypeError(metadata)
+
+    #
+
+    cls = check.not_none(cls)
+
+    #
+
+    fields = build_cls_std_fields(
+        cls,
+        kw_only=kw_only,
+    )
+    setattr(cls, STD_FIELDS_ATTR, fields)
+
+    #
+
+    fsl = [
+        std_field_to_field_spec(
+            f,
+            set_metadata=True,
+        )
+        for f in fields.values()
+    ]
+
+    #
+
+    cmd = extract_cls_metadata(cls, deep=True)
+
+    vfp_lst: list[ClassSpec.ValidateFnWithParams] = []
+    for md_vf in cmd.validate_fns or []:
+        if isinstance(md_vf, staticmethod):
+            md_vf = md_vf.__func__
+        vfp_lst.append(ClassSpec.ValidateFnWithParams(
+            md_vf,
+            [p.name for p in inspect.signature(md_vf).parameters.values()],
+        ))
+
+    #
+
+    cs = ClassSpec(
+        fields=fsl,
+
+        init=init,
+        repr=repr,
+        eq=eq,
+        order=order,
+        unsafe_hash=unsafe_hash,
+        frozen=frozen,
+
+        match_args=match_args,
+        kw_only=kw_only,
+        slots=slots,
+        weakref_slot=weakref_slot,
+
+        #
+
+        metadata=(
+            *(cmd.user_metadata or []),
+            *(metadata or []),
+        ) or None,
+
+        **{
+            **(cmd.extra_params or {}),
+            **lang.opt_kw(
+                reorder=reorder,
+                cache_hash=cache_hash,
+                generic_init=generic_init,
+                override=override,
+                repr_id=repr_id,
+            ),
+        },
+
+        init_fns=cmd.init_fns or None,
+        validate_fns=vfp_lst or None,
+    )
+
+    #
+
+    std_params = build_spec_std_params(cs)
+    check.not_in(STD_PARAMS_ATTR, cls.__dict__)
+    setattr(cls, STD_PARAMS_ATTR, std_params)
+
+    #
+
+    return drive_cls_processing(
+        cls,
+        cs,
+        plan_only=_plan_only,
+    )

omlish/dataclasses/api/classes/make.py

@@ -0,0 +1,109 @@
+import contextlib
+import keyword
+import sys
+import types
+import typing as ta
+
+from .decorator import dataclass
+
+
+##
+
+
+def make_dataclass(  # noqa
+        cls_name,
+        fields,
+        *,
+        bases=(),
+        namespace=None,
+
+        init=True,
+        repr=True,  # noqa
+        eq=True,
+        order=False,
+        unsafe_hash=False,
+        frozen=False,
+
+        match_args=True,
+        kw_only=False,
+        slots=False,
+        weakref_slot=False,
+
+        module=None,
+
+        #
+
+        metadata: ta.Sequence[ta.Any] | None = None,
+
+        reorder: bool | None = None,
+        cache_hash: bool | None = None,
+        generic_init: bool | None = None,
+        override: bool | None = None,
+        repr_id: bool | None = None,
+):
+    if namespace is None:
+        namespace = {}
+
+    seen = set()
+    annotations = {}
+    defaults = {}
+    for item in fields:
+        if isinstance(item, str):
+            name = item
+            tp = 'typing.Any'
+        elif len(item) == 2:
+            name, tp, = item
+        elif len(item) == 3:
+            name, tp, spec = item
+            defaults[name] = spec
+        else:
+            raise TypeError(f'Invalid field: {item!r}')
+        if not isinstance(name, str) or not name.isidentifier():
+            raise TypeError(f'Field names must be valid identifiers: {name!r}')
+        if keyword.iskeyword(name):
+            raise TypeError(f'Field names must not be keywords: {name!r}')
+        if name in seen:
+            raise TypeError(f'Field name duplicated: {name!r}')
+
+        seen.add(name)
+        annotations[name] = tp
+
+    def exec_body_callback(ns):
+        ns.update(namespace)
+        ns.update(defaults)
+        ns['__annotations__'] = annotations
+
+    cls = types.new_class(cls_name, bases, {}, exec_body_callback)
+
+    if module is None:
+        try:
+            module = sys._getframemodulename(1) or '__main__'  # type: ignore  # noqa
+        except AttributeError:
+            with contextlib.suppress(AttributeError, ValueError):
+                module = sys._getframe(1).f_globals.get('__name__', '__main__')  # noqa
+    if module is not None:
+        cls.__module__ = module
+
+    return dataclass(
+        cls,
+        init=init,
+        repr=repr,
+        eq=eq,
+        order=order,
+        unsafe_hash=unsafe_hash,
+        frozen=frozen,
+        match_args=match_args,
+        kw_only=kw_only,
+        slots=slots,
+        weakref_slot=weakref_slot,
+
+        #
+
+        metadata=metadata,
+
+        reorder=reorder,
+        cache_hash=cache_hash,
+        generic_init=generic_init,
+        override=override,
+        repr_id=repr_id,
+    )

omlish/dataclasses/api/classes/metadata.py

@@ -0,0 +1,133 @@
+import dataclasses as dc
+import typing as ta
+
+from .... import check
+from .... import lang
+from ....lite.dataclasses import is_immediate_dataclass
+from ...specs import InitFn
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+METADATA_ATTR = '__dataclass_metadata__'
+
+
+def _get_cls_metadata_dct(cls: type) -> dict:
+    check.isinstance(cls, type)
+    check.arg(not is_immediate_dataclass(cls))
+    try:
+        return cls.__dict__[METADATA_ATTR]
+    except KeyError:
+        pass
+    dct: dict = {}
+    setattr(cls, METADATA_ATTR, dct)
+    return dct
+
+
+def _append_cls_metadata(cls, k, v):
+    _get_cls_metadata_dct(cls).setdefault(k, []).append(v)
+
+
+def _append_cls_dct_metadata(k, *vs):
+    lang.get_caller_cls_dct(1).setdefault(METADATA_ATTR, {}).setdefault(k, []).extend(vs)
+
+
+##
+
+
+class _ExtraClassParamsMetadata(lang.Marker):
+    pass
+
+
+def extra_class_params(**kwargs):
+    def inner(cls):
+        _append_cls_metadata(cls, _ExtraClassParamsMetadata, kwargs)
+        return cls
+    return inner
+
+
+##
+
+
+class _UserMetadata(lang.Marker):
+    pass
+
+
+def metadata(*objs) -> None:
+    _append_cls_dct_metadata(_InitMetadata, *objs)
+
+
+def append_class_metadata(cls: type[T], *args: ta.Any) -> type[T]:
+    _append_cls_metadata(cls, _UserMetadata, *args)
+    return cls
+
+
+#
+
+
+class _InitMetadata(lang.Marker):
+    pass
+
+
+def init(obj):
+    _append_cls_dct_metadata(_InitMetadata, obj)
+    return obj
+
+
+#
+
+
+class _ValidateMetadata(lang.Marker):
+    pass
+
+
+def validate(obj):
+    _append_cls_dct_metadata(_ValidateMetadata, obj)
+    return obj
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True, eq=False)
+class ClassMetadata:
+    extra_params: ta.Mapping[str, ta.Any] | None = None
+
+    user_metadata: ta.Sequence[ta.Any] | None = None
+    init_fns: ta.Sequence[InitFn | property] | None = None
+    validate_fns: ta.Sequence[ta.Any] | None = None
+
+
+def extract_cls_metadata(
+        cls: type,
+        *,
+        deep: bool,
+) -> ClassMetadata:
+    extra_params = {}
+
+    user_metadata: list[ta.Any] = []
+    init_fns: list[InitFn | property] = []
+    validate_fns: list[ta.Any] = []
+
+    for b_cls in (cls.__mro__[-2::-1] if deep else (cls,)):
+        cls_md_dct = b_cls.__dict__.get(METADATA_ATTR, {})
+
+        if b_cls is cls:
+            for kw in cls_md_dct.get(_ExtraClassParamsMetadata, []):
+                extra_params.update(kw)
+
+        user_metadata.extend(cls_md_dct.get(_UserMetadata) or [])
+        init_fns.extend(cls_md_dct.get(_InitMetadata) or [])
+        validate_fns.extend(cls_md_dct.get(_ValidateMetadata) or [])
+
+    return ClassMetadata(
+        extra_params=extra_params or None,
+
+        user_metadata=user_metadata,
+        init_fns=init_fns,
+        validate_fns=validate_fns,
+    )

omlish/dataclasses/api/classes/params.py

@@ -0,0 +1,78 @@
+import typing as ta
+
+from .... import check
+from ...internals import STD_PARAMS_ATTR
+from ...internals import StdParams
+from ...specs import ClassSpec
+
+
+##
+
+
+class SpecDataclassParams(StdParams):
+    __slots__ = (*StdParams.__slots__, '_spec')
+
+    def __init__(
+            self,
+            init,
+            repr,  # noqa
+            eq,
+            order,
+            unsafe_hash,
+            frozen,
+            match_args,
+            kw_only,
+            slots,
+            weakref_slot,
+            *args: ta.Any,
+            spec: ClassSpec,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(
+            init,
+            repr,
+            eq,
+            order,
+            unsafe_hash,
+            frozen,
+            match_args,
+            kw_only,
+            slots,
+            weakref_slot,
+            *args,
+            **kwargs,
+        )
+
+        self._spec = spec
+
+    def __repr__(self) -> str:
+        r = super().__repr__()
+        return f'{self.__class__.__name__}{r[r.index("("):]}'
+
+
+def build_spec_std_params(cs: ClassSpec) -> 'SpecDataclassParams':
+    return SpecDataclassParams(
+        init=cs.init,
+        repr=cs.repr,
+        eq=cs.eq,
+        order=cs.order,
+        unsafe_hash=cs.unsafe_hash,
+        frozen=cs.frozen,
+
+        match_args=cs.match_args,
+        kw_only=cs.kw_only,
+        slots=cs.slots,
+        weakref_slot=cs.weakref_slot,
+
+        spec=cs,
+    )
+
+
+def get_class_spec(cls: type) -> ClassSpec | None:
+    check.isinstance(cls, type)
+
+    sp = getattr(cls, STD_PARAMS_ATTR)
+    if not isinstance(sp, SpecDataclassParams):
+        return None
+
+    return check.isinstance(sp._spec, ClassSpec)  # noqa