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

omlish/dataclasses/api/fields/building.py

@@ -0,0 +1,120 @@
+import dataclasses as dc
+import types
+import typing as ta
+
+from .... import check
+from ...inspect import get_cls_annotations
+from ...internals import STD_FIELDS_ATTR
+from ...internals import StdFieldType
+from ...internals import std_is_classvar
+from ...internals import std_is_initvar
+from ...internals import std_is_kw_only
+
+
+##
+
+
+def build_std_field(
+        cls: type,
+        a_name: str,
+        a_type: ta.Any,
+        *,
+        default_kw_only: bool,
+) -> dc.Field:
+    default: ta.Any = getattr(cls, a_name, dc.MISSING)
+    if isinstance(default, dc.Field):
+        f = default
+    else:
+        if isinstance(default, types.MemberDescriptorType):
+            # This is a field in __slots__, so it has no default value.
+            default = dc.MISSING
+        f = dc.field(default=default)
+
+    f.name = a_name
+    f.type = a_type
+
+    # field type
+
+    ft = StdFieldType.INSTANCE
+    if std_is_classvar(cls, f.type):
+        ft = StdFieldType.CLASS_VAR
+    if std_is_initvar(cls, f.type):
+        ft = StdFieldType.INIT_VAR
+    if ft in (StdFieldType.CLASS_VAR, StdFieldType.INIT_VAR):
+        if f.default_factory is not dc.MISSING:
+            raise TypeError(f'field {a_name} cannot have a default factory')
+    f._field_type = ft.value  # type: ignore[attr-defined]  # noqa
+
+    # kw_only
+
+    if ft in (StdFieldType.INSTANCE, StdFieldType.INIT_VAR):
+        if f.kw_only is dc.MISSING:
+            f.kw_only = default_kw_only
+    else:
+        check.arg(ft is StdFieldType.CLASS_VAR)
+        if f.kw_only is not dc.MISSING:
+            raise TypeError(f'field {a_name} is a ClassVar but specifies kw_only')
+
+    # defaults
+
+    if (
+            ft is StdFieldType.INSTANCE and
+            f.default is not dc.MISSING and
+            f.default.__class__.__hash__ is None
+    ):
+        raise ValueError(f'mutable default {type(f.default)} for field {a_name} is not allowed: use default_factory')
+
+    #
+
+    return f
+
+
+##
+
+
+def build_cls_std_fields(
+        cls: type,
+        *,
+        kw_only: bool,
+) -> ta.Mapping[str, dc.Field]:
+    fields: dict[str, dc.Field] = {}
+
+    for b in cls.__mro__[-1:0:-1]:
+        if not (base_fields := getattr(b, STD_FIELDS_ATTR, None)):
+            continue
+        for f in base_fields.values():
+            fields[f.name] = f
+
+    cls_annotations = get_cls_annotations(cls)
+
+    cls_fields: list[dc.Field] = []
+
+    kw_only_seen = False
+    for name, ann in cls_annotations.items():
+        if std_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(build_std_field(
+                cls,
+                name,
+                ann,
+                default_kw_only=kw_only,
+            ))
+
+    for f in cls_fields:
+        fields[f.name] = f
+        if isinstance(getattr(cls, f.name, None), dc.Field):
+            if f.default is dc.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 cls_annotations:
+            raise TypeError(f'{name!r} is a field but has no type annotation')
+
+    return fields

omlish/dataclasses/api/fields/constructor.py

@@ -0,0 +1,56 @@
+import collections
+import dataclasses as dc
+import typing as ta
+
+from ...specs import CoerceFn
+from ...specs import ReprFn
+from ...specs import ValidateFn
+from .metadata import extra_field_params
+
+
+##
+
+
+def field(
+        default=dc.MISSING,
+        *,
+        default_factory=dc.MISSING,
+        init=True,
+        repr=True,  # noqa
+        hash=None,  # noqa
+        compare=True,
+        metadata=None,
+        kw_only=dc.MISSING,
+
+        coerce: bool | CoerceFn | None = None,
+        validate: ValidateFn | None = None,  # noqa
+        check_type: bool | type | tuple[type | None, ...] | None = None,
+        override: bool | None = None,
+        repr_fn: ReprFn | None = None,
+        repr_priority: int | None = None,
+) -> ta.Any:
+    efp = extra_field_params(
+        coerce=coerce,
+        validate=validate,
+        check_type=check_type,
+        override=override,
+        repr_fn=repr_fn,
+        repr_priority=repr_priority,
+    )
+
+    md: ta.Any = metadata
+    if md is None:
+        md = efp
+    else:
+        md = collections.ChainMap(efp, md)  # type: ignore[arg-type]
+
+    return dc.field(
+        default=default,
+        default_factory=default_factory,
+        init=init,
+        repr=repr,
+        hash=hash,
+        compare=compare,
+        metadata=md,
+        kw_only=kw_only,
+    )

omlish/dataclasses/api/fields/conversion.py

@@ -0,0 +1,191 @@
+import dataclasses as dc
+import typing as ta
+
+from .... import check
+from .... import lang
+from ...debug import DEBUG
+from ...internals import StdFieldType
+from ...internals import std_field_type
+from ...specs import DefaultFactory
+from ...specs import FieldSpec
+from ...specs import FieldType
+from .metadata import _ExtraFieldParamsMetadata
+from .metadata import set_field_spec_metadata
+
+
+##
+
+
+STD_FIELD_TYPE_BY_SPEC_FIELD_TYPE: ta.Mapping[FieldType, StdFieldType] = {
+    FieldType.INSTANCE: StdFieldType.INSTANCE,
+    FieldType.CLASS_VAR: StdFieldType.CLASS_VAR,
+    FieldType.INIT_VAR: StdFieldType.INIT_VAR,
+}
+
+SPEC_FIELD_TYPE_BY_STD_FIELD_TYPE = {v: k for k, v in STD_FIELD_TYPE_BY_SPEC_FIELD_TYPE.items()}
+
+
+#
+
+
+def std_to_spec_field_default(
+        *,
+        default: ta.Any,
+        default_factory: ta.Any,
+) -> lang.Maybe[ta.Any]:
+    if default is not dc.MISSING:
+        check.state(default_factory is dc.MISSING)
+        return lang.just(default)
+    elif default_factory is not dc.MISSING:
+        return lang.just(DefaultFactory(default_factory))
+    else:
+        return lang.empty()
+
+
+def std_field_to_spec_field_default(f: dc.Field) -> lang.Maybe[ta.Any]:
+    return std_to_spec_field_default(
+        default=f.default,
+        default_factory=f.default_factory,
+    )
+
+
+class StdDefaults(ta.NamedTuple):
+    default: ta.Any
+    default_factory: ta.Any
+
+
+def spec_field_default_to_std_defaults(dfl: lang.Maybe[DefaultFactory | ta.Any]) -> StdDefaults:
+    if not dfl.present:
+        return StdDefaults(dc.MISSING, dc.MISSING)
+    elif isinstance(dfv := dfl.must(), DefaultFactory):
+        return StdDefaults(dc.MISSING, dfv.fn)
+    else:
+        return StdDefaults(dfv, dc.MISSING)
+
+
+#
+
+
+def std_field_to_field_spec(
+        f: dc.Field,
+        *,
+        ignore_metadata: bool = False,
+        ignore_extra_params: bool = False,
+        set_metadata: bool = False,
+) -> FieldSpec:
+    if not ignore_metadata:
+        try:
+            fs = f.metadata[FieldSpec]
+        except KeyError:
+            pass
+        else:
+            check_field_spec_against_field(f, fs)
+            return fs
+
+    extra_params = {}
+    if not ignore_extra_params:
+        extra_params.update(f.metadata.get(_ExtraFieldParamsMetadata, {}))
+
+    fs = FieldSpec(
+        name=check.non_empty_str(f.name),
+        annotation=check.is_not(f.type, dc.MISSING),
+
+        default=std_field_to_spec_field_default(f),
+
+        init=check.isinstance(f.init, bool) if DEBUG else f.init,
+        repr=check.isinstance(f.repr, bool) if DEBUG else f.repr,
+        hash=check.isinstance(f.hash, (bool, None)) if DEBUG else f.hash,
+        compare=check.isinstance(f.compare, bool) if DEBUG else f.compare,
+        metadata=f.metadata,
+        kw_only=None if f.kw_only is dc.MISSING else (check.isinstance(f.kw_only, bool) if DEBUG else f.kw_only),
+
+        **lang.opt_kw(
+            coerce=extra_params.get('coerce'),
+            validate=extra_params.get('validate'),
+            check_type=extra_params.get('check_type'),
+            override=extra_params.get('override'),
+            repr_fn=extra_params.get('repr_fn'),
+            repr_priority=extra_params.get('repr_priority'),
+        ),
+
+        field_type=SPEC_FIELD_TYPE_BY_STD_FIELD_TYPE[std_field_type(f)],
+    )
+
+    if set_metadata:
+        set_field_spec_metadata(f, fs)
+
+    return fs
+
+
+##
+
+
+def field_spec_to_std_field(fs: FieldSpec) -> dc.Field:
+    sdf = spec_field_default_to_std_defaults(fs.default)
+
+    f = dc.Field(
+        default=sdf.default,
+        default_factory=sdf.default_factory,
+
+        init=fs.init,
+        repr=fs.repr,
+        hash=fs.hash,
+        compare=fs.compare,
+        **lang.opt_kw(metadata=fs.metadata),
+        kw_only=dc.MISSING if fs.kw_only is None else fs.kw_only,  # type: ignore[arg-type]
+    )
+
+    f.name = fs.name
+    f.type = fs.annotation
+
+    f._field_type = STD_FIELD_TYPE_BY_SPEC_FIELD_TYPE[fs.field_type].value  # type: ignore[attr-defined]  # noqa
+
+    set_field_spec_metadata(f, fs)
+
+    return f
+
+
+##
+
+
+def check_field_spec_against_field(f: dc.Field, fs: FieldSpec) -> None:
+    f_dct = {
+        'name': f.name,
+        'type': f.type,
+
+        'default': f.default,
+        'default_factory': f.default_factory,
+
+        'repr': f.repr,
+        'hash': f.hash,
+        'init': f.init,
+        'compare': f.compare,
+        # f.metadata,
+        'kw_only': f.kw_only if f.kw_only is not dc.MISSING else None,
+
+        'std_field_type': f._field_type,  # type: ignore[attr-defined]  # noqa
+    }
+
+    fs_dct = {
+        'name': fs.name,
+        'type': fs.annotation,
+
+        **spec_field_default_to_std_defaults(fs.default)._asdict(),
+
+        'repr': fs.repr,
+        'hash': fs.hash,
+        'init': fs.init,
+        'compare': fs.compare,
+        # fs.metadata,
+        'kw_only': fs.kw_only,
+
+        'std_field_type': STD_FIELD_TYPE_BY_SPEC_FIELD_TYPE[fs.field_type].value,
+    }
+
+    if f_dct != fs_dct:
+        diff_dct = {
+            k: (f_v, fs_v)
+            for k, f_v in f_dct.items()
+            if (fs_v := fs_dct[k]) != f_v
+        }
+        raise RuntimeError(f'Field/FieldSpec mismatch: {diff_dct!r}')

omlish/dataclasses/api/fields/metadata.py

@@ -0,0 +1,94 @@
+import dataclasses as dc
+import typing as ta
+
+from .... import check
+from .... import lang
+from ...debug import DEBUG
+from ...specs import FieldSpec
+from ...utils import chain_mapping_proxy
+
+
+##
+
+
+class _ExtraFieldParamsMetadata(lang.Marker):
+    pass
+
+
+def extra_field_params(**kwargs: ta.Any) -> ta.Mapping[ta.Any, ta.Any]:
+    return {_ExtraFieldParamsMetadata: kwargs}
+
+
+##
+
+
+def get_field_spec(f: dc.Field) -> FieldSpec | None:
+    try:
+        fs = f.metadata[FieldSpec]
+    except KeyError:
+        return None
+
+    return check.isinstance(fs, FieldSpec)
+
+
+##
+
+
+def set_field_metadata(
+        f: dc.Field,
+        metadata: ta.Mapping[ta.Any, ta.Any],
+) -> dc.Field:
+    if DEBUG:
+        check.isinstance(f, dc.Field)
+
+    md: ta.Any = f.metadata
+
+    mdu: dict = {}
+    for k, v in metadata.items():
+        if md is None or md.get(k) != v:
+            mdu[k] = v  # noqa
+    if not mdu:
+        return f
+
+    if md is None:
+        ms = [mdu]
+    else:
+        ms = [mdu, md]
+
+    f.metadata = chain_mapping_proxy(*ms)
+    return f
+
+
+#
+
+
+def set_field_spec_metadata(
+        f: dc.Field,
+        fs: FieldSpec,
+) -> None:
+    set_field_metadata(
+        f,
+        {
+            FieldSpec: fs,
+            _ExtraFieldParamsMetadata: {},
+        },
+    )
+
+
+##
+
+
+def update_extra_field_params(
+        f: dc.Field,
+        *,
+        unless_non_default: bool = False,
+        **kwargs: ta.Any,
+) -> dc.Field:
+    fe = f.metadata.get(_ExtraFieldParamsMetadata, {})
+    return set_field_metadata(f, {
+        _ExtraFieldParamsMetadata: {
+            **(fe if not unless_non_default else {}),
+            **kwargs,
+            **(fe if unless_non_default else {}),
+        },
+    })

omlish/dataclasses/concerns/__init__.py

@@ -0,0 +1,17 @@
+from . import (  # noqa
+    abc,
+    copy,
+    doc,
+    eq,
+    fields,
+    frozen,
+    hash,  # noqa
+    init,
+    matchargs,
+    order,
+    override,
+    params,
+    replace,
+    repr,  # noqa
+    slots,
+)

omlish/dataclasses/concerns/abc.py

@@ -0,0 +1,15 @@
+import abc
+
+from ..processing.base import Processor
+from ..processing.priority import ProcessorPriority
+from ..processing.registry import register_processor_type
+
+
+##
+
+
+@register_processor_type(priority=ProcessorPriority.POST_SLOTS)
+class UpdateAbstractMethodsProcessor(Processor):
+    def process(self, cls: type) -> type:
+        abc.update_abstractmethods(cls)  # noqa
+        return cls

omlish/dataclasses/concerns/copy.py

@@ -0,0 +1,63 @@
+import dataclasses as dc
+import typing as ta
+
+from ..generation.base import Generator
+from ..generation.base import Plan
+from ..generation.base import PlanResult
+from ..generation.idents import CLS_IDENT
+from ..generation.ops import AddMethodOp
+from ..generation.ops import Op
+from ..generation.registry import register_generator_type
+from ..generation.utils import build_attr_kwargs_body_src_lines
+from ..processing.base import ProcessingContext
+from ..specs import FieldType
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class CopyPlan(Plan):
+    fields: tuple[str, ...]
+
+
+@register_generator_type(CopyPlan)
+class CopyGenerator(Generator[CopyPlan]):
+    def plan(self, ctx: ProcessingContext) -> PlanResult[CopyPlan] | None:
+        if '__copy__' in ctx.cls.__dict__:
+            return None
+
+        return PlanResult(CopyPlan(
+            tuple(f.name for f in ctx.cs.fields if f.field_type is not FieldType.CLASS_VAR),
+        ))
+
+    def generate(self, pl: CopyPlan) -> ta.Iterable[Op]:
+        return_lines: list[str]
+        if pl.fields:
+            return_lines = [
+                f'    return {CLS_IDENT}(  # noqa',
+                *build_attr_kwargs_body_src_lines(
+                    'self',
+                    *pl.fields,
+                    prefix='        ',
+                ),
+                f'    )',
+            ]
+        else:
+            return_lines = [
+                f'    return {CLS_IDENT}()  # noqa',
+            ]
+
+        lines = [
+            f'def __copy__(self):',
+            f'    if self.__class__ is not {CLS_IDENT}:',
+            f'        raise TypeError(self)',
+            *return_lines,
+        ]
+
+        return [
+            AddMethodOp(
+                '__copy__',
+                '\n'.join(lines),
+            ),
+        ]

omlish/dataclasses/concerns/doc.py

@@ -0,0 +1,53 @@
+import inspect
+
+from ..processing.base import ProcessingContext
+from ..processing.base import Processor
+from ..processing.priority import ProcessorPriority
+from ..processing.registry import register_processor_type
+
+
+##
+
+
+def _build_cls_doc(cls: type) -> str:
+    try:
+        text_sig = str(inspect.signature(cls)).replace(' -> None', '')
+    except (TypeError, ValueError):
+        text_sig = ''
+    return cls.__name__ + text_sig
+
+
+class _LazyClsDocDescriptor:
+    def __get__(self, instance, owner):
+        if instance is not None:
+            owner = instance.__class__
+        if not owner:
+            raise RuntimeError
+        doc = _build_cls_doc(owner)
+        owner.__doc__ = doc
+        return doc
+
+
+@register_processor_type(priority=ProcessorPriority.POST_GENERATION)
+class DocProcessor(Processor):
+    def __init__(
+            self,
+            ctx: ProcessingContext,
+            *,
+            lazy: bool = True,
+    ) -> None:
+        super().__init__(ctx)
+
+        self._lazy = lazy
+
+    def process(self, cls: type) -> type:
+        # FIXME: doesn't update doc in subclasses lol, as per stdlib
+        if getattr(cls, '__doc__'):
+            return cls
+
+        if self._lazy:
+            cls.__doc__ = _LazyClsDocDescriptor()  # type: ignore
+        else:
+            cls.__doc__ = _build_cls_doc(cls)
+
+        return cls

omlish/dataclasses/concerns/eq.py

@@ -0,0 +1,60 @@
+import dataclasses as dc
+import typing as ta
+
+from ..generation.base import Generator
+from ..generation.base import Plan
+from ..generation.base import PlanResult
+from ..generation.ops import AddMethodOp
+from ..generation.ops import Op
+from ..generation.registry import register_generator_type
+from ..processing.base import ProcessingContext
+from .fields import InstanceFields
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class EqPlan(Plan):
+    fields: tuple[str, ...]
+
+
+@register_generator_type(EqPlan)
+class EqGenerator(Generator[EqPlan]):
+    def plan(self, ctx: ProcessingContext) -> PlanResult[EqPlan] | None:
+        if not ctx.cs.eq or '__eq__' in ctx.cls.__dict__:
+            return None
+
+        return PlanResult(EqPlan(
+            tuple(f.name for f in ctx[InstanceFields] if f.compare),
+        ))
+
+    def generate(self, pl: EqPlan) -> ta.Iterable[Op]:
+        ret_lines: list[str]
+        if pl.fields:
+            ret_lines = [
+                f'    return (',
+                *[
+                    f'        self.{a} == other.{a}{" and" if i < len(pl.fields) - 1 else ""}'
+                    for i, a in enumerate(pl.fields)
+                ],
+                f'    )',
+            ]
+        else:
+            ret_lines = [
+                f'    return True',
+            ]
+
+        return [
+            AddMethodOp(
+                '__eq__',
+                '\n'.join([
+                    f'def __eq__(self, other):',
+                    f'    if self is other:',
+                    f'        return True',
+                    f'    if self.__class__ is not other.__class__:',
+                    f'        return NotImplemented',
+                    *ret_lines,
+                ]),
+            ),
+        ]