omlish 0.0.0.dev1__py3-none-any.whl

omlish/dataclasses/impl/main.py

@@ -0,0 +1,150 @@
+import abc
+import dataclasses as dc
+import typing as ta
+
+from ... import check
+from ... import lang
+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.params12.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.params12.weakref_slot and not self._info.params12.slots:
+            raise TypeError('weakref_slot is True but slots is False')
+        if not self._info.params12.slots:
+            return
+        self._cls = add_slots(self._cls, self._info.params.frozen, self._info.params12.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,
+        ]:
+            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()

omlish/dataclasses/impl/metaclass.py

@@ -0,0 +1,126 @@
+"""
+TODO:
+ - Enum
+"""
+import abc
+import collections
+import dataclasses as dc
+import typing as ta
+
+from ... import lang
+from .api import dataclass
+from .api import field  # noqa
+from .params import MetaclassParams
+from .params import get_metaclass_params
+from .params import get_params
+
+
+T = ta.TypeVar('T')
+
+
+def confer_kwarg(out: dict[str, ta.Any], k: str, v: ta.Any) -> None:
+    if k in out:
+        if out[k] != v:
+            raise ValueError
+    else:
+        out[k] = v
+
+
+def confer_kwargs(
+        bases: ta.Sequence[type],
+        kwargs: ta.Mapping[str, ta.Any],
+) -> dict[str, ta.Any]:
+    out: dict[str, ta.Any] = {}
+    for base in bases:
+        if not dc.is_dataclass(base):
+            continue
+        if not (bmp := get_metaclass_params(base)).confer:
+            continue
+        for ck in bmp.confer:
+            if ck in kwargs:
+                continue
+            if ck in ('frozen', 'generic_init', 'kw_only'):
+                confer_kwarg(out, ck, get_params(base).frozen)
+            elif ck == 'confer':
+                confer_kwarg(out, 'confer', bmp.confer)
+            else:
+                raise KeyError(ck)
+    return out
+
+
+class DataMeta(abc.ABCMeta):
+    def __new__(
+            mcls,
+            name,
+            bases,
+            namespace,
+            *,
+
+            # confer=frozenset(),
+
+            metadata=None,
+            **kwargs
+    ):
+        cls = lang.super_meta(
+            super(),
+            mcls,
+            name,
+            bases,
+            namespace,
+        )
+
+        ckw = confer_kwargs(bases, kwargs)
+        nkw = {**kwargs, **ckw}
+
+        mcp = MetaclassParams(
+            confer=nkw.pop('confer', frozenset()),
+        )
+
+        mmd = {
+            MetaclassParams: mcp,
+        }
+        if metadata is not None:
+            metadata = collections.ChainMap(mmd, metadata)
+        else:
+            metadata = mmd
+
+        return dataclass(cls, metadata=metadata, **nkw)
+
+
+# @ta.dataclass_transform(field_specifiers=(field,))  # FIXME: ctor
+class Data(metaclass=DataMeta):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def __post_init__(self, *args, **kwargs) -> None:
+        try:
+            spi = super().__post_init__  # type: ignore  # noqa
+        except AttributeError:
+            if args or kwargs:
+                raise TypeError(args, kwargs)
+        else:
+            spi(*args, **kwargs)
+
+
+class Frozen(
+    Data,
+    frozen=True,
+    confer=frozenset([
+        'frozen',
+        'confer',
+    ]),
+):
+    pass
+
+
+class Box(
+    Frozen,
+    ta.Generic[T],
+    generic_init=True,
+    confer=frozenset([
+        'frozen',
+        'generic_init',
+        'confer',
+    ]),
+):
+    v: T

omlish/dataclasses/impl/metadata.py

@@ -0,0 +1,74 @@
+import types
+import typing as ta
+
+from ... import lang
+
+
+METADATA_ATTR = '__dataclass_metadata__'
+
+Metadata: ta.TypeAlias = ta.Mapping[ta.Any, ta.Any]
+
+EMPTY_METADATA: Metadata = types.MappingProxyType({})
+
+_CLASS_MERGED_KEYS: set[str] = set()
+CLASS_MERGED_KEYS: ta.AbstractSet = _CLASS_MERGED_KEYS
+
+
+def _class_merged(o):
+    _CLASS_MERGED_KEYS.add(o)
+    return o
+
+
+def get_merged_metadata(obj: ta.Any) -> Metadata:
+    cls = obj if isinstance(obj, type) else type(obj)
+    dct: dict[ta.Any, ta.Any] = {}
+    for cur in cls.__mro__[::-1]:
+        if not (smd := cur.__dict__.get(METADATA_ATTR)):
+            continue
+        for k, v in smd.items():
+            if k in CLASS_MERGED_KEYS:
+                dct.setdefault(k, []).extend(v)
+            else:
+                dct[k] = v
+    return dct
+
+
+def _append_cls_md(k, v):
+    lang.get_caller_cls_dct(1).setdefault(METADATA_ATTR, {}).setdefault(k, []).append(v)
+
+
+##
+
+
+@_class_merged
+class UserMetadata(lang.Marker):
+    pass
+
+
+@lang.cls_dct_fn()
+def metadata(cls_dct, *args) -> None:
+    cls_dct.setdefault(METADATA_ATTR, {}).setdefault(UserMetadata, []).extend(args)
+
+
+##
+
+
+@_class_merged
+class Check(lang.Marker):
+    pass
+
+
+def check(fn: ta.Union[ta.Callable[..., bool], staticmethod]) -> None:
+    _append_cls_md(Check, fn)
+
+
+##
+
+
+@_class_merged
+class Init(lang.Marker):
+    pass
+
+
+def init(fn: ta.Callable[..., None]) -> None:
+    _append_cls_md(Init, fn)

omlish/dataclasses/impl/order.py

@@ -0,0 +1,47 @@
+import typing as ta
+
+from .utils import Namespace
+from .processing import Processor
+from .utils import create_fn
+from .utils import set_new_attribute
+from .utils import tuple_str
+
+
+def cmp_fn(
+        name: str,
+        op: str,
+        self_tuple: str,
+        other_tuple: str,
+        globals: Namespace,
+) -> ta.Callable:
+    return create_fn(
+        name,
+        ('self', 'other'),
+        [
+            'if other.__class__ is self.__class__:',
+            f' return {self_tuple}{op}{other_tuple}',
+            'return NotImplemented',
+        ],
+        globals=globals,
+    )
+
+
+class OrderProcessor(Processor):
+    def _process(self) -> None:
+        if not self._info.params.order:
+            return
+
+        flds = [f for f in self._info.instance_fields if f.compare]
+        self_tuple = tuple_str('self', flds)
+        other_tuple = tuple_str('other', flds)
+        for name, op in [
+            ('__lt__', '<'),
+            ('__le__', '<='),
+            ('__gt__', '>'),
+            ('__ge__', '>='),
+        ]:
+            if set_new_attribute(self._cls, name, cmp_fn(name, op, self_tuple, other_tuple, globals=self._info.globals)):  # noqa
+                raise TypeError(
+                    f'Cannot overwrite attribute {name} in class {self._cls.__name__}. '
+                    f'Consider using functools.total_ordering'
+                )

omlish/dataclasses/impl/params.py

@@ -0,0 +1,150 @@
+"""
+Field:
+    name: str | None = None
+    type: Any = None
+    default: Any | MISSING = MISSING
+    default_factory: Any | MISSING = MISSING
+    repr: bool = True
+    hash: bool | None = None
+    init: bool = True
+    compare: bool = True
+    metadata: Metadata | None = None
+    kw_only: bool | MISSING = MISSING
+
+    _field_type: Any = None
+
+
+Params:
+    init: bool = True
+    repr: bool = True
+    eq: bool = True
+    order: bool = False
+    unsafe_hash: bool = False
+    frozen: bool = False
+
+    match_args: bool = True
+    kw_only: bool = False
+    slots: bool = False
+    weakref_slot: bool = False
+"""
+import dataclasses as dc
+import sys
+import typing as ta
+
+from ... import lang
+from .internals import PARAMS_ATTR
+from .internals import Params
+from .metadata import EMPTY_METADATA
+from .metadata import METADATA_ATTR
+
+
+IS_12 = sys.version_info[1] >= 12
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class FieldExtras(lang.Final):
+    coerce: ta.Optional[ta.Union[bool, ta.Callable[[ta.Any], ta.Any]]] = None
+    check: ta.Optional[ta.Callable[[ta.Any], bool]] = None
+    check_type: ta.Optional[bool] = None
+    override: bool = False
+
+
+DEFAULT_FIELD_EXTRAS = FieldExtras()
+
+
+def get_field_extras(f: dc.Field) -> FieldExtras:
+    if not isinstance(f, dc.Field):
+        raise TypeError(f)
+    return f.metadata.get(FieldExtras, DEFAULT_FIELD_EXTRAS)
+
+
+##
+
+
+def get_params_cls(obj: ta.Any) -> type | None:
+    if not isinstance(obj, type):
+        obj = type(obj)
+    for cur in obj.__mro__:
+        if PARAMS_ATTR in cur.__dict__:
+            return cur
+    return None
+
+
+def get_params(obj: ta.Any) -> Params:
+    if not hasattr(obj, PARAMS_ATTR):
+        raise TypeError(obj)
+    return getattr(obj, PARAMS_ATTR)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Params12(lang.Final):
+    match_args: bool = True
+    kw_only: bool = False
+    slots: bool = False
+    weakref_slot: bool = False
+
+
+DEFAULT_PARAMS12 = Params12()
+
+
+def get_params12(obj: ta.Any) -> Params12:
+    if IS_12:
+        p = get_params(obj)
+        return Params12(
+            match_args=p.match_args,
+            kw_only=p.kw_only,
+            slots=p.slots,
+            weakref_slot=p.weakref_slot,
+        )
+
+    if (pcls := get_params_cls(obj)) is None:
+        raise TypeError(pcls)
+
+    md = pcls.__dict__.get(METADATA_ATTR, EMPTY_METADATA)
+    return md.get(Params12, DEFAULT_PARAMS12)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ParamsExtras(lang.Final):
+    reorder: bool = False
+    cache_hash: bool = False
+    generic_init: bool = False
+
+
+DEFAULT_PARAMS_EXTRAS = ParamsExtras()
+
+
+def get_params_extras(obj: ta.Any) -> ParamsExtras:
+    if (pcls := get_params_cls(obj)) is None:
+        raise TypeError(pcls)
+
+    md = pcls.__dict__.get(METADATA_ATTR, EMPTY_METADATA)
+    return md.get(ParamsExtras, DEFAULT_PARAMS_EXTRAS)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class MetaclassParams:
+    confer: frozenset[str] = frozenset()
+
+
+DEFAULT_METACLASS_PARAMS = MetaclassParams()
+
+
+def get_metaclass_params(obj: ta.Any) -> MetaclassParams:
+    if (pcls := get_params_cls(obj)) is None:
+        raise TypeError(pcls)
+
+    md = pcls.__dict__.get(METADATA_ATTR, EMPTY_METADATA)
+    return md.get(MetaclassParams, DEFAULT_METACLASS_PARAMS)

omlish/dataclasses/impl/processing.py

@@ -0,0 +1,16 @@
+from ... import lang
+from .reflect import ClassInfo
+
+
+class Processor(lang.Abstract):
+    def __init__(self, info: ClassInfo) -> None:
+        super().__init__()
+        self._cls = info.cls
+        self._info = info
+
+    @lang.cached_function
+    def process(self) -> None:
+        self._process()
+
+    def _process(self) -> None:
+        raise NotImplementedError