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

omlish/dataclasses/concerns/fields.py

@@ -0,0 +1,119 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import check
+from ..debug import DEBUG
+from ..generation.idents import IDENT_PREFIX
+from ..inspect import FieldsInspection
+from ..internals import STD_FIELDS_ATTR
+from ..processing.base import ProcessingContext
+from ..processing.base import Processor
+from ..processing.priority import ProcessorPriority
+from ..processing.registry import register_processing_context_item_factory
+from ..processing.registry import register_processor_type
+from ..specs import FieldSpec
+from ..specs import FieldType
+
+
+##
+
+
+class InstanceFields(list[FieldSpec]):
+    pass
+
+
+def get_instance_fields(fields: ta.Iterable[FieldSpec]) -> InstanceFields:
+    return InstanceFields([f for f in fields if f.field_type is FieldType.INSTANCE])
+
+
+@register_processing_context_item_factory(InstanceFields)
+def _instance_fields_processing_context_item_factory(ctx: ProcessingContext) -> InstanceFields:
+    return get_instance_fields(ctx.cs.fields)
+
+
+##
+
+
+class InitFields(ta.NamedTuple):
+    all: ta.Sequence[FieldSpec]
+    ordered: ta.Sequence[FieldSpec]
+    std: ta.Sequence[FieldSpec]
+    kw_only: ta.Sequence[FieldSpec]
+
+
+def calc_init_fields(
+        fields: ta.Iterable[FieldSpec],
+        *,
+        reorder: bool,
+        class_kw_only: bool,
+) -> InitFields:
+    all_init_fields = [
+        f
+        for f in fields
+        if f.field_type in (FieldType.INSTANCE, FieldType.INIT_VAR)
+    ]
+
+    def f_kw_only(f: FieldSpec) -> bool:
+        return f.kw_only if f.kw_only is not None else class_kw_only
+
+    ordered_init_fields = list(all_init_fields)
+    if reorder:
+        ordered_init_fields.sort(key=lambda f: (f.default.present, not f_kw_only(f)))
+
+    std_init_fields = tuple(f1 for f1 in ordered_init_fields if f1.init and not f_kw_only(f1))
+    kw_only_init_fields = tuple(f1 for f1 in ordered_init_fields if f1.init and f_kw_only(f1))
+
+    return InitFields(
+        all=all_init_fields,
+        ordered=ordered_init_fields,
+        std=std_init_fields,
+        kw_only=kw_only_init_fields,
+    )
+
+
+@register_processing_context_item_factory(InitFields)
+def _init_fields_processing_context_item_factory(ctx: ProcessingContext) -> InitFields:
+    return calc_init_fields(
+        ctx.cs.fields,
+        reorder=ctx.cs.reorder,
+        class_kw_only=ctx.cs.kw_only,
+    )
+
+
+##
+
+
+StdFields = ta.NewType('StdFields', ta.Mapping[str, dc.Field])
+
+
+@register_processing_context_item_factory(StdFields)
+def _std_fields_processing_context_item_factory(ctx: ProcessingContext) -> StdFields:
+    fld_dct = ctx.cls.__dict__[STD_FIELDS_ATTR]
+    for fn, f in fld_dct.items():
+        if DEBUG:
+            check.isinstance(f, dc.Field)
+        check.equal(f.name, fn)
+    check.equal(set(fld_dct), set(ctx.cs.fields_by_name))
+    return StdFields(fld_dct)
+
+
+##
+
+
+@register_processing_context_item_factory(FieldsInspection)
+def _fields_inspection_processing_context_item_factory(ctx: ProcessingContext) -> FieldsInspection:
+    return FieldsInspection(
+        ctx.cls,
+        cls_fields=ctx[StdFields],
+    )
+
+
+##
+
+
+@register_processor_type(priority=ProcessorPriority.BOOTSTRAP)
+class FieldsProcessor(Processor):
+    def check(self) -> None:
+        check.not_none(self._ctx[StdFields])
+        for f in self._ctx.cs.fields:
+            check.arg(not f.name.startswith(IDENT_PREFIX))

omlish/dataclasses/concerns/frozen.py

@@ -0,0 +1,133 @@
+"""
+TODO:
+ - prebuild field frozenset for getters/setters
+  - and one field per line
+"""
+import dataclasses as dc
+import typing as ta
+import weakref
+
+from ... import check
+from ..generation.base import Generator
+from ..generation.base import Plan
+from ..generation.base import PlanResult
+from ..generation.globals import FROZEN_INSTANCE_ERROR_GLOBAL
+from ..generation.idents import CLS_IDENT
+from ..generation.idents import IDENT_PREFIX
+from ..generation.ops import AddMethodOp
+from ..generation.ops import Op
+from ..generation.registry import register_generator_type
+from ..internals import STD_FIELDS_ATTR
+from ..internals import STD_PARAMS_ATTR
+from ..processing.base import ProcessingContext
+
+
+##
+
+
+_UNCHECKED_FROZEN_BASES: ta.MutableSet[type] = weakref.WeakSet()
+
+
+def unchecked_frozen_base(cls):
+    _UNCHECKED_FROZEN_BASES.add(check.isinstance(cls, type))
+    return cls
+
+
+def check_frozen_bases(cls: type, frozen: bool) -> None:
+    all_frozen_bases = None
+    any_frozen_base = False
+    has_dataclass_bases = False
+
+    for b in cls.__mro__[-1:0:-1]:
+        if b in _UNCHECKED_FROZEN_BASES:
+            continue
+
+        base_fields = getattr(b, STD_FIELDS_ATTR, None)
+        if base_fields is None:
+            continue
+
+        has_dataclass_bases = True
+        if all_frozen_bases is None:
+            all_frozen_bases = True
+
+        current_frozen = getattr(b, STD_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 frozen:
+            raise TypeError('cannot inherit non-frozen dataclass from a frozen one')
+
+        if all_frozen_bases is False and frozen:
+            raise TypeError('cannot inherit frozen dataclass from a non-frozen one')
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class FrozenPlan(Plan):
+    fields: tuple[str, ...]
+
+
+@register_generator_type(FrozenPlan)
+class FrozenGenerator(Generator[FrozenPlan]):
+    def plan(self, ctx: ProcessingContext) -> PlanResult[FrozenPlan] | None:
+        check_frozen_bases(ctx.cls, ctx.cs.frozen)
+
+        if not ctx.cs.frozen:
+            return None
+
+        return PlanResult(FrozenPlan(tuple(f.name for f in ctx.cs.fields)))
+
+    def _generate_one(
+            self,
+            plan: FrozenPlan,
+            mth: str,
+            params: ta.Sequence[str],
+            exc_args: str,
+    ) -> AddMethodOp:
+        preamble = []
+        # https://github.com/python/cpython/commit/ee6f8413a99d0ee4828e1c81911e203d3fff85d5
+        condition = f'type(self) is {CLS_IDENT}'
+
+        if plan.fields:
+            set_ident = f'{IDENT_PREFIX}_{mth}_frozen_fields'
+            preamble.extend([
+                f'{set_ident} = {{',
+                *[
+                    f'    {f!r},'
+                    for f in plan.fields
+                ],
+                f'}}',
+                f'',
+            ])
+            condition += f' or name in {set_ident}'
+
+        return AddMethodOp(
+            f'__{mth}__',
+            '\n'.join([
+                *preamble,
+                f'def __{mth}__(self, {", ".join(params)}):',
+                f'    if {condition}:',
+                f'        raise {FROZEN_INSTANCE_ERROR_GLOBAL.ident}{exc_args}',
+                f'    super({CLS_IDENT}, self).__{mth}__({", ".join(params)})',
+            ]),
+            frozenset([FROZEN_INSTANCE_ERROR_GLOBAL]),
+        )
+
+    def generate(self, plan: FrozenPlan) -> ta.Iterable[Op]:
+        return [
+            self._generate_one(
+                plan,
+                'setattr',
+                ['name', 'value'],
+                '(f"cannot assign to field {name!r}")',
+            ),
+            self._generate_one(
+                plan,
+                'delattr',
+                ['name'],
+                '(f"cannot delete field {name!r}")',
+            ),
+        ]

omlish/dataclasses/concerns/hash.py

@@ -0,0 +1,165 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import check
+from ..generation.base import Generator
+from ..generation.base import Plan
+from ..generation.base import PlanResult
+from ..generation.ops import AddMethodOp
+from ..generation.ops import Op
+from ..generation.ops import SetAttrOp
+from ..generation.registry import register_generator_type
+from ..generation.utils import build_attr_tuple_body_src_lines
+from ..processing.base import ProcessingContext
+from .fields import InstanceFields
+
+
+##
+
+
+HashAction: ta.TypeAlias = ta.Literal['set_none', 'add', 'exception']
+
+
+# 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): 'set_none',
+    (False, True, False, True): None,
+    (False, True, True, False): 'add',
+    (False, True, True, True): None,
+    (True, False, False, False): 'add',
+    (True, False, False, True): 'exception',
+    (True, False, True, False): 'add',
+    (True, False, True, True): 'exception',
+    (True, True, False, False): 'add',
+    (True, True, False, True): 'exception',
+    (True, True, True, False): 'add',
+    (True, True, True, True): 'exception',
+}
+
+
+def _raise_hash_action_exception(cls: type) -> ta.NoReturn:
+    raise TypeError(f'Cannot overwrite attribute __hash__ in class {cls.__name__}')
+
+
+CACHED_HASH_ATTR = '__dataclass_hash__'
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class HashPlan(Plan):
+    action: HashAction
+
+    _: dc.KW_ONLY
+
+    fields: tuple[str, ...] | None = None
+    cache: bool | None = None
+
+
+@register_generator_type(HashPlan)
+class HashGenerator(Generator[HashPlan]):
+    def plan(self, ctx: ProcessingContext) -> PlanResult[HashPlan] | None:
+        class_hash = ctx.cls.__dict__.get('__hash__', dc.MISSING)
+        has_explicit_hash = not (class_hash is dc.MISSING or (class_hash is None and '__eq__' in ctx.cls.__dict__))
+
+        action = HASH_ACTIONS[(
+            bool(ctx.cs.unsafe_hash),
+            bool(ctx.cs.eq),
+            bool(ctx.cs.frozen),
+            has_explicit_hash,
+        )]
+
+        if action == 'set_none':
+            return PlanResult(HashPlan(action))  # noqa
+
+        elif action == 'exception':
+            _raise_hash_action_exception(ctx.cls)
+
+        elif action == 'add':
+            fields = tuple(
+                f.name
+                for f in ctx[InstanceFields]
+                if (f.compare if f.hash is None else f.hash)
+            )
+
+            return PlanResult(HashPlan(
+                'add',
+                fields=fields,
+                cache=ctx.cs.cache_hash,
+            ))
+
+        elif action is None:
+            return None
+
+        else:
+            raise ValueError(action)
+
+    def generate(self, pl: HashPlan) -> ta.Iterable[Op]:
+        if pl.action == 'set_none':
+            return [SetAttrOp('__hash__', None, if_present='replace')]
+
+        elif pl.action != 'add':
+            raise ValueError(pl.action)
+
+        lines = [
+            'def __hash__(self):',
+        ]
+
+        hash_lines: list[str]
+        if pl.fields:
+            hash_lines = [
+                'hash((',
+                *build_attr_tuple_body_src_lines(
+                    'self',
+                    *check.not_none(pl.fields),
+                    prefix='    ',
+                ),
+                '))',
+            ]
+        else:
+            hash_lines = ['hash(())']
+
+        if pl.cache:
+            lines.extend([
+                f'    try:',
+                f'        return self.{CACHED_HASH_ATTR}',
+                f'    except AttributeError:',
+                f'        pass',
+                f'    object.__setattr__(',
+                f'        self,',
+                f'        {CACHED_HASH_ATTR!r},',
+                f'        h := {hash_lines[0]}',
+                *[
+                    f'        {l}'
+                    for l in hash_lines[1:]
+                ],
+                f'    )',
+                f'    return h',
+            ])
+        else:
+            lines.extend([
+                f'    return {hash_lines[0]}',
+                *[
+                    f'    {l}'
+                    for l in hash_lines[1:]
+                ],
+            ])
+
+        return [
+            AddMethodOp(
+                '__hash__',
+                '\n'.join(lines),
+                if_present='replace',
+            ),
+        ]