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

omlish/dataclasses/impl/fields.py

@@ -1,245 +0,0 @@
-"""
-TODO:
- - point validate / check exceptions to lambdas
-"""
-import dataclasses as dc
-import types
-import typing as ta
-
-from ... import check as check_
-from ... import lang
-from .errors import FieldValidationError
-from .internals import FIELDS_ATTR
-from .internals import FieldType
-from .internals import is_classvar
-from .internals import is_initvar
-from .internals import is_kw_only
-from .params import get_field_extras
-from .processing import Processor
-
-
-if ta.TYPE_CHECKING:
-    from . import api
-else:
-    api = lang.proxy_import('.api', __package__)
-
-
-MISSING = dc.MISSING
-
-
-##
-
-
-def raise_field_validation_error(
-        obj: ta.Any,
-        field: str,
-        fn: ta.Callable,
-        value: ta.Any,
-) -> ta.NoReturn:
-    raise FieldValidationError(
-        obj,
-        field,
-        fn,
-        value,
-    )
-
-
-##
-
-
-def field_type(f: dc.Field) -> FieldType:
-    if (ft := getattr(f, '_field_type')) is not None:
-        return FieldType(ft)
-    else:
-        return FieldType.INSTANCE
-
-
-def has_default(f: dc.Field) -> bool:
-    return not (f.default is MISSING and f.default_factory is MISSING)
-
-
-##
-
-
-class FieldsProcessor(Processor):
-    def _process(self) -> None:
-        cls = self._info.cls
-        fields: dict[str, dc.Field] = {}
-
-        for b in 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.params.kw_only
-        kw_only_seen = False
-        for name, ann in self._info.cls_annotations.items():
-            if 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(preprocess_field(cls, name, ann, kw_only))
-
-        for f in cls_fields:
-            fields[f.name] = f
-            if isinstance(getattr(cls, f.name, None), dc.Field):
-                if f.default is 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 self._info.cls_annotations:
-                raise TypeError(f'{name!r} is a field but has no type annotation')
-
-        setattr(cls, FIELDS_ATTR, fields)
-
-
-##
-
-
-def preprocess_field(
-        cls: type,
-        a_name: str,
-        a_type: ta.Any,
-        default_kw_only: bool,
-) -> dc.Field:
-    default = getattr(cls, a_name, 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 = MISSING
-        f = api.field(default=default)
-
-    f.name = a_name
-    f.type = a_type
-
-    ft = FieldType.INSTANCE
-    if is_classvar(cls, f.type):
-        ft = FieldType.CLASS
-    if is_initvar(cls, f.type):
-        ft = FieldType.INIT
-    if ft in (FieldType.CLASS, FieldType.INIT):
-        if f.default_factory is not MISSING:
-            raise TypeError(f'field {f.name} cannot have a default factory')
-    f._field_type = ft.value  # type: ignore  # noqa
-
-    if ft in (FieldType.INSTANCE, FieldType.INIT):
-        if f.kw_only is MISSING:
-            f.kw_only = default_kw_only
-    else:
-        check_.arg(ft is FieldType.CLASS)
-        if f.kw_only is not MISSING:
-            raise TypeError(f'field {f.name} is a ClassVar but specifies kw_only')
-
-    if ft is FieldType.INSTANCE and f.default is not MISSING and f.default.__class__.__hash__ is None:
-        raise ValueError(f'mutable default {type(f.default)} for field {f.name} is not allowed: use default_factory')
-
-    return f
-
-
-def field_assign(
-        frozen: bool,
-        name: str,
-        value: ta.Any,
-        self_name: str,
-        override: bool,
-) -> str:
-    if override:
-        return f'{self_name}.__dict__[{name!r}] = {value}'
-    if frozen:
-        return f'__dataclass_builtins_object__.__setattr__({self_name}, {name!r}, {value})'
-    return f'{self_name}.{name} = {value}'
-
-
-def field_init(
-        f: dc.Field,
-        frozen: bool,
-        locals: dict[str, ta.Any],  # noqa
-        self_name: str,
-        slots: bool,
-        cls_override: bool,
-) -> ta.Sequence[str]:
-    default_name = f'__dataclass_dflt_{f.name}__'
-    fx = get_field_extras(f)
-
-    lines = []
-
-    value: str | None = None
-    if f.default_factory is not MISSING:
-        locals[default_name] = f.default_factory
-        if f.init:
-            lines.append(f'if {f.name} is __dataclass_HAS_DEFAULT_FACTORY__: {f.name} = {default_name}()')
-        else:
-            lines.append(f'{f.name} = {default_name}()')
-        value = f.name
-
-    elif f.init:
-        if f.default is MISSING:
-            value = f.name
-        elif f.default is not MISSING:
-            locals[default_name] = f.default  # Not referenced her, just useful / consistent to have in function scope
-            value = f.name
-
-    elif slots and f.default is not MISSING:
-        locals[default_name] = f.default
-        lines.append(f'{f.name} = {default_name}')
-        value = default_name
-
-    else:
-        pass
-
-    if fx.derive is not None:
-        raise NotImplementedError
-
-    if fx.frozen:
-        raise NotImplementedError
-
-    if fx.coerce is not None:
-        cn = f'__dataclass_coerce__{f.name}__'
-        locals[cn] = fx.coerce
-        lines.append(f'{value} = {cn}({value})')
-
-    if fx.validate is not None:
-        cn = f'__dataclass_validate__{f.name}__'
-        locals[cn] = fx.validate
-        lines.append(
-            f'if not {cn}({value}): '
-            f'__dataclass_raise_field_validation_error__({self_name}, {f.name!r}, {cn}, {value})',
-        )
-
-    if fx.check_type:
-        cn = f'__dataclass_check_type__{f.name}__'
-        ct: ta.Any
-        if isinstance(fx.check_type, tuple):
-            ct = tuple(type(None) if e is None else check_.isinstance(e, type) for e in fx.check_type)
-        elif isinstance(fx.check_type, (type, tuple)):
-            ct = fx.check_type
-        # FIXME:
-        # elif info.params_extras.generic_init:
-        #     ct = info.generic_replaced_field_annotations[f.name]
-        else:
-            ct = f.type
-        locals[cn] = ct
-        lines.append(
-            f'if not __dataclass_builtins_isinstance__({value}, {cn}): '
-            f'raise __dataclass_builtins_TypeError__({value}, {cn})',
-        )
-
-    if value is not None and field_type(f) is not FieldType.INIT:
-        lines.append(field_assign(
-            frozen,
-            f.name,
-            value,
-            self_name,
-            fx.override or cls_override,
-        ))
-
-    return lines

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,
-        )