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

omlish/dataclasses/impl/main.py

@@ -1,93 +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 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 .overrides import OverridesProcessor
-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 .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,
-            is_frozen=self._info.params.frozen,
-            weakref_slot=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/dataclasses/impl/metaclass.py

@@ -1,235 +0,0 @@
-"""
-TODO:
- - Rewrite lol
- - Enum - enforce Abstract or Final
-"""
-import abc
-import collections
-import dataclasses as dc
-import typing as ta
-
-from ... import lang
-from .api import MISSING
-from .api import dataclass
-from .api import field  # noqa
-from .params import MetaclassParams
-from .params import get_metaclass_params
-from .params import get_params
-from .params import get_params_extras
-
-
-T = ta.TypeVar('T')
-
-
-##
-
-
-_CONFER_PARAMS: tuple[str, ...] = (
-    'eq',
-    'frozen',
-    'kw_only',
-)
-
-_CONFER_PARAMS_EXTRAS: tuple[str, ...] = (
-    'reorder',
-    'cache_hash',
-    'generic_init',
-    'override',
-)
-
-_CONFER_METACLASS_PARAMS: tuple[str, ...] = (
-    'confer',
-    'final_subclasses',
-    'abstract_immediate_subclasses',
-)
-
-
-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 _CONFER_PARAMS:
-                confer_kwarg(out, ck, getattr(get_params(base), ck))
-
-            elif ck in _CONFER_PARAMS_EXTRAS:
-                confer_kwarg(out, ck, getattr(get_params_extras(base), ck))
-
-            elif ck in _CONFER_METACLASS_PARAMS:
-                confer_kwarg(out, ck, getattr(bmp, ck))
-
-            else:
-                raise KeyError(ck)
-
-    return out
-
-
-##
-
-
-class DataMeta(abc.ABCMeta):
-    def __new__(
-            mcls,
-            name,
-            bases,
-            namespace,
-            *,
-
-            abstract=False,
-            sealed=False,
-            final=False,
-
-            metadata=None,
-            **kwargs,
-    ):
-        ckw = confer_kwargs(bases, kwargs)
-        nkw = {**kwargs, **ckw}
-
-        mcp = MetaclassParams(**{
-            mpa: nkw.pop(mpa)
-            for mpa in _CONFER_METACLASS_PARAMS
-            if mpa in nkw
-        })
-
-        mmd = {
-            MetaclassParams: mcp,
-        }
-        if metadata is not None:
-            metadata = collections.ChainMap(mmd, metadata)
-        else:
-            metadata = mmd
-
-        #
-
-        xbs: list[type] = []
-
-        if any(get_metaclass_params(b).abstract_immediate_subclasses for b in bases if dc.is_dataclass(b)):
-            abstract = True
-
-        final |= (mcp.final_subclasses and not abstract)
-
-        if final and abstract:
-            raise TypeError(f'Class cannot be abstract and final: {name!r}')
-
-        if abstract:
-            xbs.append(lang.Abstract)
-        if sealed:
-            xbs.append(lang.Sealed)
-        if final:
-            xbs.append(lang.Final)
-
-        if xbs:
-            if bases and bases[-1] is ta.Generic:
-                bases = (*bases[:-1], *xbs, bases[-1])
-            else:
-                bases = (*bases, *xbs)
-            if ob := namespace.get('__orig_bases__'):
-                if getattr(ob[-1], '__origin__', None) is ta.Generic:
-                    namespace['__orig_bases__'] = (*ob[:-1], *xbs, ob[-1])
-                else:
-                    namespace['__orig_bases__'] = (*ob, *xbs)
-
-        #
-
-        ofs: set[str] = set()
-        if any(issubclass(b, lang.Abstract) for b in bases) and nkw.get('override'):
-            ofs.update(a for a in namespace.get('__annotations__', []) if a not in namespace)
-            namespace.update((a, MISSING) for a in ofs)
-
-        #
-
-        cls = lang.super_meta(
-            super(),
-            mcls,
-            name,
-            bases,
-            namespace,
-        )
-
-        #
-
-        for a in ofs:
-            delattr(cls, a)
-
-        #
-
-        return dataclass(cls, metadata=metadata, **nkw)
-
-
-##
-
-
-# @ta.dataclass_transform(field_specifiers=(field,))  # FIXME: ctor
-class Data(
-    eq=False,
-    order=False,
-    confer=frozenset([
-        'confer',
-        'final_subclasses',
-    ]),
-    metaclass=DataMeta,
-):
-    def __init__(self, *args, **kwargs):
-        # Typechecking barrier
-        super().__init__(*args, **kwargs)
-
-    def __init_subclass__(cls, **kwargs):
-        # Typechecking barrier
-        super().__init_subclass__(**kwargs)
-
-
-class Frozen(
-    Data,
-    frozen=True,
-    eq=False,
-    order=False,
-    confer=frozenset([
-        *get_metaclass_params(Data).confer,
-        'frozen',
-        'reorder',
-        'cache_hash',
-        'override',
-    ]),
-):
-    pass
-
-
-class Case(
-    Frozen,
-    abstract=True,
-    override=True,
-    final_subclasses=True,
-    abstract_immediate_subclasses=True,
-):
-    pass
-
-
-class Box(
-    Frozen,
-    ta.Generic[T],
-    generic_init=True,
-    confer=frozenset([
-        *get_metaclass_params(Frozen).confer,
-        'generic_init',
-    ]),
-):
-    v: T

omlish/dataclasses/impl/metadata.py

@@ -1,75 +0,0 @@
-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 Validate(lang.Marker):
-    pass
-
-
-def validate(fn: ta.Callable[..., bool] | staticmethod) -> None:
-    _append_cls_md(Validate, fn)
-
-
-##
-
-
-@_class_merged
-class Init(lang.Marker):
-    pass
-
-
-def init(obj):
-    _append_cls_md(Init, obj)
-    return obj

omlish/dataclasses/impl/order.py

@@ -1,57 +0,0 @@
-import typing as ta
-
-from .processing import Processor
-from .utils import Namespace
-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,  # noqa
-) -> 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,  # noqa
-                    name,
-                    cmp_fn(
-                        name,
-                        op,
-                        self_tuple,
-                        other_tuple,
-                        globals=self._info.globals,
-                    ),
-            ):
-                raise TypeError(
-                    f'Cannot overwrite attribute {name} in class {self._cls.__name__}. '
-                    f'Consider using functools.total_ordering',
-                )

omlish/dataclasses/impl/overrides.py

@@ -1,53 +0,0 @@
-from ... import lang
-from .fields import field_assign
-from .params import get_field_extras
-from .processing import Processor
-from .utils import create_fn
-from .utils import set_new_attribute
-
-
-class OverridesProcessor(Processor):
-    def _process(self) -> None:
-        for f in self._info.instance_fields:
-            fx = get_field_extras(f)
-            if not (fx.override or self._info.params_extras.override):
-                continue
-
-            if self._info.params.slots:
-                raise TypeError
-
-            self_name = '__dataclass_self__' if 'self' in self._info.fields else 'self'
-
-            getter = create_fn(
-                f.name,
-                (self_name,),
-                [f'return {self_name}.__dict__[{f.name!r}]'],
-                globals=self._info.globals,
-                return_type=lang.just(f.type),
-            )
-            prop = property(getter)
-
-            if not self._info.params.frozen:
-                setter = create_fn(
-                    f.name,
-                    (self_name, f'{f.name}: __dataclass_type_{f.name}__'),
-                    [
-                        field_assign(
-                            self._info.params.frozen,
-                            f.name,
-                            f.name,
-                            self_name,
-                            True,
-                        ),
-                    ],
-                    globals=self._info.globals,
-                    locals={f'__dataclass_type_{f.name}__': f.type},
-                    return_type=lang.just(None),
-                )
-                prop = prop.setter(setter)
-
-            set_new_attribute(
-                self._cls,
-                f.name,
-                prop,
-            )

omlish/dataclasses/impl/params.py

@@ -1,128 +0,0 @@
-"""
-@dc.dataclass(frozen=True)
-class 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
-
-    if sys.version_info >= (3, 13):
-        doc: str | None = None
-
-    _field_type: Any = None
-
-
-@dc.dataclass(frozen=True)
-class 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 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
-
-
-##
-
-
-@dc.dataclass(frozen=True, kw_only=True)
-class FieldExtras(lang.Final):
-    derive: ta.Callable[..., ta.Any] | None = None  # TODO
-    coerce: bool | ta.Callable[[ta.Any], ta.Any] | None = None
-    validate: ta.Callable[[ta.Any], bool] | None = None
-    check_type: bool | type | tuple[type | None, ...] | None = None
-    override: bool = False
-    repr_fn: ta.Callable[[ta.Any], str | None] | None = None
-    repr_priority: int | None = None
-    frozen: bool | None = None  # TODO
-
-
-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, kw_only=True)
-class ParamsExtras(lang.Final):
-    reorder: bool = False
-    cache_hash: bool = False
-    generic_init: bool = False
-    override: bool = False
-    repr_id: 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()
-    final_subclasses: bool = False
-    abstract_immediate_subclasses: bool = False
-
-
-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

@@ -1,24 +0,0 @@
-import typing as ta
-
-from ... import lang
-
-
-if ta.TYPE_CHECKING:
-    from .reflect import ClassInfo
-
-
-class Processor(lang.Abstract):
-    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()
-
-    def _process(self) -> None:
-        raise NotImplementedError

omlish/dataclasses/impl/replace.py

@@ -1,40 +0,0 @@
-import dataclasses as dc
-
-from .fields import field_type
-from .internals import FIELDS_ATTR
-from .internals import FieldType
-from .internals import is_dataclass_instance
-from .processing import Processor
-from .utils import set_new_attribute
-
-
-MISSING = dc.MISSING
-
-
-def replace(obj, /, **changes):  # noqa
-    if not is_dataclass_instance(obj):
-        raise TypeError('replace() should be called on dataclass instances')
-    return _replace(obj, **changes)
-
-
-def _replace(obj, /, **changes):
-    for f in getattr(obj, FIELDS_ATTR).values():
-        if (ft := field_type(f)) is FieldType.CLASS:
-            continue
-
-        if not f.init:
-            if f.name in changes:
-                raise TypeError(f'field {f.name} is declared with init=False, it cannot be specified with replace()')
-            continue
-
-        if f.name not in changes:
-            if ft is FieldType.INIT and f.default is MISSING:
-                raise TypeError(f'InitVar {f.name!r} must be specified with replace()')
-            changes[f.name] = getattr(obj, f.name)
-
-    return obj.__class__(**changes)
-
-
-class ReplaceProcessor(Processor):
-    def _process(self) -> None:
-        set_new_attribute(self._cls, '__replace__', _replace)