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

omlish/dataclasses/impl/frozen.py

@@ -1,93 +0,0 @@
-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],
-        globals: Namespace,  # noqa
-) -> tuple[ta.Callable, ta.Callable]:
-    locals = {  # noqa
-        'cls': cls,
-        'FrozenInstanceError': dc.FrozenInstanceError,
-    }
-    condition = 'type(self) is cls'
-    if fields:
-        condition += ' or name in {' + ', '.join(repr(f.name) for f in fields) + '}'
-    return (
-        create_fn(
-            '__setattr__',
-            ('self', 'name', 'value'),
-            [
-                f'if {condition}:',
-                ' raise FrozenInstanceError(f"cannot assign to field {name!r}")',
-                f'super(cls, self).__setattr__(name, value)',
-            ],
-            locals=locals,
-            globals=globals,
-        ),
-        create_fn(
-            '__delattr__',
-            ('self', 'name'),
-            [
-                f'if {condition}:',
-                ' raise FrozenInstanceError(f"cannot delete field {name!r}")',
-                f'super(cls, self).__delattr__(name)',
-            ],
-            locals=locals,
-            globals=globals,
-        ),
-    )
-
-
-class FrozenProcessor(Processor):
-    def check(self) -> None:
-        check_frozen_bases(self._info)
-
-    def _process(self) -> None:
-        if not self._info.params.frozen:
-            return
-
-        for fn in frozen_get_del_attr(self._cls, self._info.instance_fields, self._info.globals):
-            if set_new_attribute(self._cls, fn.__name__, fn):
-                raise TypeError(f'Cannot overwrite attribute {fn.__name__} in class {self._cls.__name__}')

omlish/dataclasses/impl/hashing.py

@@ -1,86 +0,0 @@
-import dataclasses as dc
-import enum
-import typing as ta
-
-from .processing import Processor
-from .utils import create_fn
-from .utils import set_qualname
-from .utils import tuple_str
-
-
-class HashAction(enum.Enum):
-    SET_NONE = enum.auto()
-    ADD = enum.auto()
-    EXCEPTION = enum.auto()
-
-
-# See https://bugs.python.org/issue32929#msg312829 for an if-statement version of this table.
-HASH_ACTIONS: ta.Mapping[tuple[bool, bool, bool, bool], HashAction | None] = {
-    #
-    # +-------------------------------------- unsafe_hash?
-    # |      +------------------------------- eq?
-    # |      |      +------------------------ frozen?
-    # |      |      |      +----------------  has-explicit-hash?
-    # v      v      v      v
-    (False, False, False, False): None,
-    (False, False, False, True): None,
-    (False, False, True, False): None,
-    (False, False, True, True): None,
-    (False, True, False, False): HashAction.SET_NONE,
-    (False, True, False, True): None,
-    (False, True, True, False): HashAction.ADD,
-    (False, True, True, True): None,
-    (True, False, False, False): HashAction.ADD,
-    (True, False, False, True): HashAction.EXCEPTION,
-    (True, False, True, False): HashAction.ADD,
-    (True, False, True, True): HashAction.EXCEPTION,
-    (True, True, False, False): HashAction.ADD,
-    (True, True, False, True): HashAction.EXCEPTION,
-    (True, True, True, False): HashAction.ADD,
-    (True, True, True, True): HashAction.EXCEPTION,
-}
-
-
-class HashProcessor(Processor):
-    CACHED_HASH_ATTR = '__dataclass_hash__'
-
-    def _build_hash_fn(self) -> ta.Callable:
-        flds = [f for f in self._info.instance_fields if (f.compare if f.hash is None else f.hash)]
-        self_tuple = tuple_str('self', flds)
-        if self._info.params_extras.cache_hash:
-            body = [
-                f'try: return self.{self.CACHED_HASH_ATTR}',
-                f'except AttributeError: pass',
-                f'object.__setattr__(self, {self.CACHED_HASH_ATTR!r}, h := hash({self_tuple}))',
-                f'return h',
-            ]
-        else:
-            body = [f'return hash({self_tuple})']
-        hash_fn = create_fn(
-            '__hash__',
-            ('self',),
-            body,
-            globals=self._info.globals,
-        )
-        return set_qualname(self._cls, hash_fn)  # noqa
-
-    def _process(self) -> None:
-        class_hash = self._cls.__dict__.get('__hash__', dc.MISSING)
-        has_explicit_hash = not (class_hash is dc.MISSING or (class_hash is None and '__eq__' in self._cls.__dict__))
-
-        match (hash_action := HASH_ACTIONS[(
-            bool(self._info.params.unsafe_hash),
-            bool(self._info.params.eq),
-            bool(self._info.params.frozen),
-            has_explicit_hash,
-        )]):
-            case HashAction.SET_NONE:
-                self._cls.__hash__ = None  # type: ignore
-            case HashAction.ADD:
-                self._cls.__hash__ = self._build_hash_fn()  # type: ignore
-            case HashAction.EXCEPTION:
-                raise TypeError(f'Cannot overwrite attribute __hash__ in class {self._cls.__name__}')
-            case None:
-                pass
-            case _:
-                raise ValueError(hash_action)

omlish/dataclasses/impl/init.py

@@ -1,199 +0,0 @@
-import dataclasses as dc
-import inspect
-import typing as ta
-
-from ... import lang
-from .errors import ValidationError
-from .fields import field_init
-from .fields import field_type
-from .fields import has_default
-from .fields import raise_field_validation_error
-from .internals import HAS_DEFAULT_FACTORY
-from .internals import POST_INIT_NAME
-from .internals import FieldType
-from .metadata import Init
-from .metadata import Validate
-from .processing import Processor
-from .reflect import ClassInfo
-from .utils import Namespace
-from .utils import create_fn
-from .utils import set_new_attribute
-
-
-MISSING = dc.MISSING
-
-
-##
-
-
-def raise_validation_error(
-        obj: ta.Any,
-        fn: ta.Callable,
-) -> ta.NoReturn:
-    raise ValidationError(obj, fn)
-
-
-##
-
-
-class InitFields(ta.NamedTuple):
-    all: ta.Sequence[dc.Field]
-    ordered: ta.Sequence[dc.Field]
-    std: ta.Sequence[dc.Field]
-    kw_only: ta.Sequence[dc.Field]
-
-
-def get_init_fields(fields: ta.Iterable[dc.Field], *, reorder: bool = False) -> InitFields:
-    all_init_fields = [f for f in fields if field_type(f) in (FieldType.INSTANCE, FieldType.INIT)]
-    ordered_init_fields = list(all_init_fields)
-    if reorder:
-        ordered_init_fields.sort(key=lambda f: (has_default(f), not f.kw_only))
-    std_init_fields, kw_only_init_fields = (
-        tuple(f1 for f1 in ordered_init_fields if f1.init and not f1.kw_only),
-        tuple(f1 for f1 in ordered_init_fields if f1.init and f1.kw_only),
-    )
-    return InitFields(
-        all=all_init_fields,
-        ordered=ordered_init_fields,
-        std=std_init_fields,
-        kw_only=kw_only_init_fields,
-    )
-
-
-def init_param(f: dc.Field) -> str:
-    if not has_default(f):
-        default = ''
-    elif f.default is not MISSING:
-        default = f' = __dataclass_dflt_{f.name}__'
-    elif f.default_factory is not MISSING:
-        default = ' = __dataclass_HAS_DEFAULT_FACTORY__'
-    return f'{f.name}: __dataclass_type_{f.name}__{default}'  # noqa
-
-
-##
-
-
-class InitBuilder:
-    def __init__(
-            self,
-            info: ClassInfo,
-            fields: ta.Mapping[str, dc.Field],
-            has_post_init: bool,
-            self_name: str,
-            globals: Namespace,  # noqa
-    ) -> None:
-        super().__init__()
-
-        self._info = info
-        self._fields = fields
-        self._has_post_init = has_post_init
-        self._self_name = self_name
-        self._globals = globals
-
-    @lang.cached_function
-    def build(self) -> ta.Callable:
-        ifs = get_init_fields(self._fields.values(), reorder=self._info.params_extras.reorder)
-
-        seen_default = None
-        for f in ifs.std:
-            if f.init:
-                if has_default(f):
-                    seen_default = f
-                elif seen_default:
-                    raise TypeError(f'non-default argument {f.name!r} follows default argument {seen_default.name!r}')
-
-        locals: dict[str, ta.Any] = {}  # noqa
-
-        if self._info.params_extras.generic_init:
-            get_fty = lambda f: self._info.generic_replaced_field_annotations[f.name]
-        else:
-            get_fty = lambda f: f.type
-        locals.update({f'__dataclass_type_{f.name}__': get_fty(f) for f in ifs.all})
-
-        locals.update({
-            '__dataclass_HAS_DEFAULT_FACTORY__': HAS_DEFAULT_FACTORY,
-            '__dataclass_builtins_object__': object,
-            '__dataclass_builtins_isinstance__': isinstance,
-            '__dataclass_builtins_TypeError__': TypeError,
-            '__dataclass_raise_validation_error__': raise_validation_error,
-            '__dataclass_raise_field_validation_error__': raise_field_validation_error,
-        })
-
-        body_lines: list[str] = []
-        for f in ifs.all:
-            f_lines = field_init(
-                f,
-                self._info.params.frozen,
-                locals,
-                self._self_name,
-                self._info.params.slots,
-                self._info.params_extras.override,
-            )
-
-            if f_lines:
-                body_lines.extend(f_lines)
-
-        if self._has_post_init:
-            params_str = ','.join(f.name for f in ifs.all if field_type(f) is FieldType.INIT)
-            body_lines.append(f'{self._self_name}.{POST_INIT_NAME}({params_str})')
-
-        for i, fn in enumerate(self._info.merged_metadata.get(Validate, [])):
-            if isinstance(fn, staticmethod):
-                fn = fn.__func__
-            cn = f'__dataclass_validate_{i}__'
-            locals[cn] = fn
-            csig = inspect.signature(fn)
-            cas = ', '.join(p.name for p in csig.parameters.values())
-            body_lines.append(f'if not {cn}({cas}): __dataclass_raise_validation_error__({self._self_name}, {cn})')
-
-        inits = self._info.merged_metadata.get(Init, [])
-        mro_dct = lang.mro_dict(self._info.cls)
-        mro_v_ids = set(map(id, mro_dct.values()))
-        props_by_fget_id = {id(v.fget): v for v in mro_dct.values() if isinstance(v, property) and v.fget is not None}
-        for i, obj in enumerate(inits):
-            if (obj_id := id(obj)) not in mro_v_ids and obj_id in props_by_fget_id:
-                obj = props_by_fget_id[obj_id].__get__
-            elif isinstance(obj, property):
-                obj = obj.__get__
-            cn = f'__dataclass_init_{i}__'
-            locals[cn] = obj
-            body_lines.append(f'{cn}({self._self_name})')
-
-        if not body_lines:
-            body_lines = ['pass']
-
-        _init_params = [init_param(f) for f in ifs.std]
-        if ifs.kw_only:
-            _init_params += ['*']
-            _init_params += [init_param(f) for f in ifs.kw_only]
-
-        return create_fn(
-            '__init__',
-            [self._self_name, *_init_params],
-            body_lines,
-            locals=locals,
-            globals=self._globals,
-            return_type=lang.just(None),
-        )
-
-
-class InitProcessor(Processor):
-    def _process(self) -> None:
-        if not self._info.params.init:
-            return
-
-        has_post_init = hasattr(self._cls, POST_INIT_NAME)
-        self_name = '__dataclass_self__' if 'self' in self._info.fields else 'self'
-
-        init = InitBuilder(
-            ClassInfo(self._cls),
-            self._info.fields,
-            has_post_init,
-            self_name,
-            self._info.globals,
-        ).build()
-        set_new_attribute(
-            self._cls,
-            '__init__',
-            init,
-        )

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