omlish 0.0.0.dev1__py3-none-any.whl

omlish/dataclasses/impl/fields.py

@@ -0,0 +1,148 @@
+import dataclasses as dc
+import types
+import typing as ta
+
+from ... import check as check_
+from ... import lang
+from .internals import FieldType
+from .internals import is_classvar
+from .internals import is_initvar
+from .params import get_field_extras
+
+if ta.TYPE_CHECKING:
+    from . import api
+else:
+    api = lang.proxy_import('.api', __package__)
+
+
+MISSING = dc.MISSING
+
+
+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)
+
+
+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
+
+    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],
+        self_name: str,
+        slots: bool,
+) -> ta.Sequence[str]:
+    default_name = f'__dataclass_dflt_{f.name}__'
+    fx = get_field_extras(f)
+
+    lines = []
+
+    if fx.coerce is not None:
+        cn = f'__dataclass_coerce__{f.name}__'
+        locals[cn] = fx.coerce
+        lines.append(f'{f.name} = {cn}({f.name})')
+
+    if fx.check is not None:
+        cn = f'__dataclass_check__{f.name}__'
+        locals[cn] = fx.check
+        lines.append(f'if not {cn}({f.name}): raise __dataclass_CheckException__')
+
+    if fx.check_type:
+        cn = f'__dataclass_check_type__{f.name}__'
+        locals[cn] = f.type
+        lines.append(
+            f'if not __dataclass_builtins_isinstance__({f.name}, {cn}): '
+            f'raise __dataclass_builtins_TypeError__({f.name}, {cn})'
+        )
+
+    value: str | None = None
+    if f.default_factory is not MISSING:
+        if f.init:
+            locals[default_name] = f.default_factory
+            value = (
+                f'{default_name}() '
+                f'if {f.name} is __dataclass_HAS_DEFAULT_FACTORY__ '
+                f'else {f.name}'
+            )
+        else:
+            locals[default_name] = f.default_factory
+            value = f'{default_name}()'
+
+    elif f.init:
+        if f.default is MISSING:
+            value = f.name
+        elif f.default is not MISSING:
+            locals[default_name] = f.default
+            value = f.name
+
+    else:
+        if slots and f.default is not MISSING:
+            locals[default_name] = f.default
+            value = default_name
+        else:
+            pass
+
+    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))  # noqa
+
+    return lines

omlish/dataclasses/impl/frozen.py

@@ -0,0 +1,55 @@
+import dataclasses as dc
+import typing as ta
+
+from .processing import Processor
+from .utils import Namespace
+from .utils import create_fn
+from .utils import set_new_attribute
+
+
+def frozen_get_del_attr(
+        cls: type,
+        fields: ta.Sequence[dc.Field],
+        globals: Namespace,
+) -> tuple[ta.Callable, ta.Callable]:
+    locals = {
+        '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 _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

@@ -0,0 +1,85 @@
+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: 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

@@ -0,0 +1,173 @@
+import dataclasses as dc
+import inspect
+import typing as ta
+
+from ... import lang
+from .exceptions import CheckException
+from .fields import field_init
+from .fields import field_type
+from .fields import has_default
+from .internals import FieldType
+from .internals import HAS_DEFAULT_FACTORY
+from .internals import POST_INIT_NAME
+from .metadata import Check
+from .metadata import Init
+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
+
+
+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,
+    ) -> 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] = {}
+
+        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_CheckException__': CheckException,
+        })
+
+        body_lines: list[str] = []
+        for f in ifs.all:
+            f_lines = field_init(
+                f,
+                self._info.params.frozen,
+                locals,
+                self._self_name,
+                self._info.params12.slots,
+            )
+
+            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(Check, [])):
+            if isinstance(fn, staticmethod):
+                fn = fn.__func__
+            cn = f'__dataclass_check_{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}): raise __dataclass_CheckException__')
+
+        for i, fn in enumerate(self._info.merged_metadata.get(Init, [])):
+            cn = f'__dataclass_init_{i}__'
+            locals[cn] = fn
+            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/internals.py

@@ -0,0 +1,118 @@
+import dataclasses as dc
+import enum
+import sys
+import types
+import typing as ta
+
+
+##
+
+
+HAS_DEFAULT_FACTORY = dc._HAS_DEFAULT_FACTORY  # type: ignore  # noqa
+
+FIELDS_ATTR = dc._FIELDS  # type: ignore  # noqa
+PARAMS_ATTR = dc._PARAMS  # type: ignore  # noqa
+
+POST_INIT_NAME = dc._POST_INIT_NAME  # type: ignore  # noqa
+
+Params = dc._DataclassParams  # type: ignore  # noqa
+
+
+##
+
+
+is_dataclass_instance = dc._is_dataclass_instance  # type: ignore  # noqa
+
+
+##
+
+
+ATOMIC_TYPES: ta.FrozenSet[type]
+
+if hasattr(dc, '_ATOMIC_TYPES'):
+    ATOMIC_TYPES = getattr(dc, '_ATOMIC_TYPES')
+
+else:
+    ATOMIC_TYPES = frozenset({
+        types.NoneType,
+        bool,
+        int,
+        float,
+        str,
+
+        complex,
+        bytes,
+
+        types.EllipsisType,
+        types.NotImplementedType,
+        types.CodeType,
+        types.BuiltinFunctionType,
+        types.FunctionType,
+        type,
+        range,
+        property,
+    })
+
+
+##
+
+
+def _patch_missing_ctor() -> None:
+    # dc.asdict uses copy.deepcopy which instantiates new _MISSING_TYPE objects which do not pass the 'foo is MISSING'
+    # checks used throughout dataclasses code. Code should not depend on this behavior but it is a debugging landmine.
+    if dc._MISSING_TYPE.__new__ is object.__new__:  # noqa
+        def _MISSING_TYPE_new(cls):  # noqa
+            return dc.MISSING
+        dc._MISSING_TYPE.__new__ = _MISSING_TYPE_new  # type: ignore  # noqa
+
+
+##
+
+
+class FieldType(enum.Enum):
+    INSTANCE = dc._FIELD  # type: ignore  # noqa
+    CLASS = dc._FIELD_CLASSVAR  # type: ignore  # noqa
+    INIT = dc._FIELD_INITVAR  # type: ignore  # noqa
+
+
+_SELF_MODULE = None
+
+
+def _self_module():
+    global _SELF_MODULE
+    if _SELF_MODULE is None:
+        _SELF_MODULE = sys.modules[__package__.rpartition('.')[0]]
+    return _SELF_MODULE
+
+
+def is_classvar(cls: type, ty: ta.Any) -> bool:
+    return (
+        dc._is_classvar(ty, ta)  # type: ignore  # noqa
+        or (isinstance(ty, str) and dc._is_type(ty, cls, ta, ta.ClassVar, dc._is_classvar))  # type: ignore  # noqa
+    )
+
+
+def is_initvar(cls: type, ty: ta.Any) -> bool:
+    return (
+        dc._is_initvar(ty, dc)  # type: ignore  # noqa
+        or (
+            isinstance(ty, str)
+            and any(
+                dc._is_type(ty, cls, mod, dc.InitVar, dc._is_initvar)  # type: ignore  # noqa
+                for mod in (dc, _self_module())
+            )
+        )
+    )
+
+
+def is_kw_only(cls: type, ty: ta.Any) -> bool:
+    return (
+        dc._is_kw_only(ty, dc)  # type: ignore  # noqa
+        or (
+            isinstance(ty, str)
+            and any(
+                dc._is_type(ty, cls, mod, dc.KW_ONLY, dc._is_kw_only)  # type: ignore  # noqa
+                for mod in (dc, _self_module())
+            )
+        )
+    )