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

omlish/dataclasses/concerns/replace.py

@@ -0,0 +1,48 @@
+import dataclasses as dc
+import typing as ta
+
+from ..internals import STD_FIELDS_ATTR
+from ..internals import StdFieldType
+from ..internals import std_field_type
+from ..internals import std_is_dataclass_instance
+from ..processing.base import Processor
+from ..processing.priority import ProcessorPriority
+from ..processing.registry import register_processor_type
+from ..utils import set_new_attribute
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+def replace(obj, /, **changes):  # noqa
+    if not std_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, STD_FIELDS_ATTR).values():
+        if (ft := std_field_type(f)) is StdFieldType.CLASS_VAR:
+            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 StdFieldType.INIT_VAR and f.default is dc.MISSING:
+                raise TypeError(f'InitVar {f.name!r} must be specified with replace()')
+            changes[f.name] = getattr(obj, f.name)
+
+    return obj.__class__(**changes)
+
+
+@register_processor_type(priority=ProcessorPriority.POST_GENERATION)
+class ReplaceProcessor(Processor):
+    def process(self, cls: type) -> type:
+        set_new_attribute(cls, '__replace__', _replace)
+        return cls

omlish/dataclasses/concerns/repr.py

@@ -0,0 +1,95 @@
+import dataclasses as dc
+import typing as ta
+
+from ..generation.base import Generator
+from ..generation.base import Plan
+from ..generation.base import PlanResult
+from ..generation.globals import REPRLIB_RECURSIVE_REPR_GLOBAL
+from ..generation.ops import AddMethodOp
+from ..generation.ops import Op
+from ..generation.ops import OpRef
+from ..generation.ops import Ref
+from ..generation.registry import register_generator_type
+from ..processing.base import ProcessingContext
+from ..specs import FieldType
+from ..specs import ReprFn
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ReprPlan(Plan):
+    fields: tuple[str, ...]
+
+    @dc.dataclass(frozen=True)
+    class Fn:
+        field: str
+        fn: OpRef[ReprFn]
+
+    fns: tuple[Fn, ...] = ()
+
+    id: bool = False
+
+
+@register_generator_type(ReprPlan)
+class ReprGenerator(Generator[ReprPlan]):
+    def plan(self, ctx: ProcessingContext) -> PlanResult[ReprPlan] | None:
+        if not ctx.cs.repr or '__repr__' in ctx.cls.__dict__:
+            return None
+
+        fs = sorted(ctx.cs.fields, key=lambda f: f.repr_priority or 0)
+
+        orm = {}
+        rfs: list[ReprPlan.Fn] = []
+        for i, f in enumerate(fs):
+            if f.repr_fn is None:
+                continue
+            r: OpRef = OpRef(f'repr.fns.{i}.fn')
+            orm[r] = f.repr_fn
+            rfs.append(ReprPlan.Fn(f.name, r))
+
+        return PlanResult(
+            ReprPlan(
+                fields=tuple(f.name for f in fs if f.field_type is FieldType.INSTANCE and f.repr),
+                fns=tuple(rfs),
+                id=ctx.cs.repr_id,
+            ),
+            orm,
+        )
+
+    def generate(self, pl: ReprPlan) -> ta.Iterable[Op]:
+        ors: set[Ref] = {REPRLIB_RECURSIVE_REPR_GLOBAL}
+
+        part_lines: list[str] = []
+
+        rfd = {rf.field: rf.fn for rf in pl.fns}
+        for f in pl.fields:
+            if (rf := rfd.get(f)) is not None:
+                ors.add(rf)
+                part_lines.extend([
+                    f'    if (s := {rf.ident()}(self.{f})) is not None:',
+                    f'        parts.append(f"{f}={{s}}")',
+                ])
+            else:
+                part_lines.append(
+                    f'    parts.append(f"{f}={{self.{f}!r}}")',
+                )
+
+        return [
+            AddMethodOp(
+                '__repr__',
+                '\n'.join([
+                    f'@{REPRLIB_RECURSIVE_REPR_GLOBAL.ident}()',
+                    f'def __repr__(self):',
+                    f'    parts = []',
+                    *part_lines,
+                    f'    return (',
+                    f'        f"{{self.__class__.__qualname__}}{'@{hex(id(self))[2:]}' if pl.id else ''}("',
+                    f'        f"{{\', \'.join(parts)}}"',
+                    f'        f")"',
+                    f'    )',
+                ]),
+                frozenset(ors),
+            ),
+        ]

omlish/dataclasses/{impl → concerns}/slots.py

@@ -3,8 +3,12 @@ import inspect
 import itertools
 import types
 
+from ..processing.base import Processor
+from ..processing.priority import ProcessorPriority
+from ..processing.registry import register_processor_type
 
-MISSING = dc.MISSING
+
+##
 
 
 def _dataclass_getstate(self):
@@ -133,3 +137,23 @@ def add_slots(
                 break
 
     return newcls
+
+
+##
+
+
+@register_processor_type(priority=ProcessorPriority.SLOTS)
+class SlotsProcessor(Processor):
+    def check(self) -> None:
+        if self._ctx.cs.weakref_slot and not self._ctx.cs.slots:
+            raise TypeError('weakref_slot is True but slots is False')
+
+    def process(self, cls: type) -> type:
+        if not self._ctx.cs.slots:
+            return cls
+
+        return add_slots(
+            cls,
+            is_frozen=self._ctx.cs.frozen,
+            weakref_slot=self._ctx.cs.weakref_slot,
+        )

omlish/dataclasses/debug.py

@@ -0,0 +1,2 @@
+DEBUG = False
+# DEBUG = True

omlish/dataclasses/errors.py

@@ -0,0 +1,115 @@
+import types
+import typing as ta
+
+
+##
+
+
+def _hands_off_repr(obj: ta.Any) -> str:
+    return f'{obj.__class__.__qualname__}@{hex(id(obj))[2:]}'
+
+
+def _fn_repr(fn: ta.Callable) -> str:
+    if (co := getattr(fn, '__code__', None)) is None or not isinstance(co, types.CodeType):
+        return repr(fn)
+
+    if not (co_filename := co.co_filename):
+        return repr(fn)
+
+    return f'{fn!r} ({co_filename}:{co.co_firstlineno})'
+
+
+##
+
+
+class ValidationError(Exception):
+    def __init__(
+            self,
+            *,
+            obj: ta.Any,
+    ) -> None:
+        self.obj = obj
+
+        super().__init__(
+            f'{self.__class__.__name__} '
+            f'{", ".join(f"{k} {v}" for k, v in self._message_parts.items())}',
+        )
+
+    @property
+    def _message_parts(self) -> ta.Mapping[str, str]:
+        return {
+            'obj': _hands_off_repr(self.obj),
+        }
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({", ".join([
+            f"{k}={v}" for k, v in self._message_parts.items()
+        ])})'
+
+
+class FnValidationError(ValidationError):
+    def __init__(
+            self,
+            *,
+            fn: ta.Callable,
+            **kwargs: ta.Any,
+    ) -> None:
+        self.fn = fn
+
+        super().__init__(**kwargs)
+
+    @property
+    def _message_parts(self) -> ta.Mapping[str, str]:
+        return {
+            **super()._message_parts,
+            'fn': _fn_repr(self.fn),
+        }
+
+
+class FieldValidationError(ValidationError):
+    def __init__(
+            self,
+            *,
+            field: str,
+            value: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        self.field = field
+        self.value = value
+
+        super().__init__(**kwargs)
+
+    @property
+    def _message_parts(self) -> ta.Mapping[str, str]:
+        return {
+            **super()._message_parts,
+            'field': repr(self.field),
+            'value': repr(self.value),
+        }
+
+
+class FieldFnValidationError(FieldValidationError, FnValidationError):
+    pass
+
+
+class TypeValidationError(ValidationError, TypeError):
+    def __init__(
+            self,
+            *,
+            type: ta.Any,  # noqa
+            **kwargs: ta.Any,
+    ) -> None:
+        self.type = type
+
+        super().__init__(**kwargs)
+
+    @property
+    def _message_parts(self) -> ta.Mapping[str, str]:
+        return {
+            **super()._message_parts,
+            'type': repr(self.type),
+        }
+
+
+class FieldTypeValidationError(FieldValidationError, TypeValidationError):
+    pass

omlish/dataclasses/generation/base.py

@@ -0,0 +1,38 @@
+import abc
+import dataclasses as dc
+import typing as ta
+
+from ..processing.base import ProcessingContext
+from .ops import Op
+from .ops import OpRefMap
+
+
+T = ta.TypeVar('T')
+PlanT = ta.TypeVar('PlanT')
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Plan(abc.ABC):  # noqa
+    pass
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class PlanResult(ta.Generic[PlanT]):
+    plan: PlanT
+    ref_map: OpRefMap | None = None
+
+
+class Generator(abc.ABC, ta.Generic[PlanT]):
+    @abc.abstractmethod
+    def plan(self, ctx: ProcessingContext) -> PlanResult[PlanT] | None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def generate(self, pl: PlanT) -> ta.Iterable[Op]:
+        raise NotImplementedError

omlish/dataclasses/generation/compilation.py

@@ -0,0 +1,258 @@
+"""
+TODO:
+ - md5 spec to fn name
+"""
+import abc
+import dataclasses as dc
+import typing as ta
+
+from ... import check
+from ..utils import repr_round_trip_value
+from .globals import FN_GLOBAL_IMPORTS
+from .globals import FN_GLOBALS
+from .globals import FUNCTION_TYPE_GLOBAL
+from .globals import PROPERTY_GLOBAL
+from .globals import TYPE_ERROR_GLOBAL
+from .idents import CLS_IDENT
+from .idents import IDENT_PREFIX
+from .ops import AddMethodOp
+from .ops import AddPropertyOp
+from .ops import IfAttrPresent
+from .ops import Op
+from .ops import OpRef
+from .ops import Ref
+from .ops import SetAttrOp
+from .ops import get_op_refs
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class OpCompiler:
+    class Style(abc.ABC):
+        @abc.abstractmethod
+        def header_lines(self) -> ta.Sequence[str]:
+            raise NotImplementedError
+
+        @abc.abstractmethod
+        def globals_ns(self) -> ta.Mapping[str, ta.Any]:
+            raise NotImplementedError
+
+    class JitStyle(Style):
+        def header_lines(self) -> ta.Sequence[str]:
+            return []
+
+        def globals_ns(self) -> ta.Mapping[str, ta.Any]:
+            return dict(FN_GLOBAL_IMPORTS)
+
+    class AotStyle(Style):
+        HEADER_LINES: ta.ClassVar[ta.Sequence[str]] = [
+            '# type: ignore',
+            '# ruff: noqa',
+            '# flake8: noqa',
+            '# @omlish-generated',
+        ]
+
+        def header_lines(self) -> ta.Sequence[str]:
+            return [
+                *self.HEADER_LINES,
+                *[
+                    f'import {i}'
+                    for i in FN_GLOBAL_IMPORTS
+                ],
+                '\n',
+            ]
+
+        def globals_ns(self) -> ta.Mapping[str, ta.Any]:
+            return {}
+
+    #
+
+    def __init__(
+            self,
+            style: Style,
+    ) -> None:
+        super().__init__()
+
+        self._style = style
+
+    @property
+    def style(self) -> Style:
+        return self._style
+
+    @dc.dataclass(frozen=True)
+    class CompileResult:
+        fn_name: str
+        params: ta.Sequence[str]
+        src: str
+        refs: frozenset[Ref]
+
+    @dc.dataclass(frozen=True)
+    class _FnParam:
+        name: str
+        src: str | None = None
+        noqa: bool = dc.field(default=False, kw_only=True)
+
+    def _compile_set_attr(
+            self,
+            attr_name: str,
+            value_src: str,
+            if_present: IfAttrPresent,
+    ) -> list[str]:
+        setattr_stmt = f'setattr({CLS_IDENT}, {attr_name!r}, {value_src})'
+
+        if if_present == 'skip':
+            return [
+                f'if {attr_name!r} not in {CLS_IDENT}.__dict__:',
+                f'    {setattr_stmt}',
+            ]
+
+        elif if_present == 'replace':
+            return [
+                setattr_stmt,
+            ]
+
+        elif if_present == 'error':
+            return [
+                f'if {attr_name!r} in {CLS_IDENT}.__dict__:',
+                (
+                    f'    '
+                    f'raise {TYPE_ERROR_GLOBAL.ident}'
+                    f'(f"Cannot overwrite attribute {attr_name} in class {{{CLS_IDENT}.__name__}}")'
+                ),
+                setattr_stmt,
+            ]
+
+        else:
+            raise ValueError(if_present)
+
+    def compile(
+            self,
+            fn_name: str,
+            ops: ta.Sequence[Op],
+    ) -> CompileResult:
+        body_lines: list[str] = []
+
+        for op in ops:
+            if isinstance(op, SetAttrOp):
+                if isinstance(v := op.value, OpRef):
+                    vs = v.ident()
+                    body_lines.extend([
+                        f'if isinstance({vs}, {FUNCTION_TYPE_GLOBAL.ident}):'
+                        f'    {vs}.__qualname__ = f"{{{CLS_IDENT}.__qualname__}}.{{{vs}.__name__}}"',
+                    ])
+                else:
+                    vs = repr(repr_round_trip_value(v))
+
+                body_lines.extend(self._compile_set_attr(
+                    op.name,
+                    vs,
+                    op.if_present,
+                ))
+
+            elif isinstance(op, AddMethodOp):
+                body_lines.extend([
+                    *op.src.splitlines(),
+                    f'',
+                    f'{op.name}.__qualname__ = f"{{{CLS_IDENT}.__qualname__}}.{op.name}"',
+                    *self._compile_set_attr(
+                        op.name,
+                        op.name,
+                        op.if_present,
+                    ),
+                ])
+
+            elif isinstance(op, AddPropertyOp):
+                gen_ident = IDENT_PREFIX + f'property__{op.name}'
+
+                gen_lines = [
+                    f'def {gen_ident}():',
+                    f'    @{PROPERTY_GLOBAL.ident}',
+                    *[
+                        f'    {l}'
+                        for l in check.not_none(op.get_src).splitlines()
+                    ],
+                ]
+                if op.set_src is not None:
+                    gen_lines.extend([
+                        f'',
+                        f'    @{op.name}.setter',
+                        *[
+                            f'    {l}'
+                            for l in op.set_src.splitlines()
+                        ],
+                    ])
+                if op.del_src is not None:
+                    raise NotImplementedError
+                gen_lines.extend([
+                    f'',
+                    f'    return {op.name}',
+                ])
+
+                body_lines.extend([
+                    *gen_lines,
+                    f'',
+                    f'setattr({CLS_IDENT}, {op.name!r}, {gen_ident}())',
+                ])
+
+            else:
+                raise TypeError(op)
+
+            body_lines.append('')
+
+        #
+
+        refs = frozenset.union(*[get_op_refs(o) for o in ops])
+
+        params: list[OpCompiler._FnParam] = [
+            OpCompiler._FnParam(CLS_IDENT),
+            *[
+                OpCompiler._FnParam(p)
+                for p in sorted(
+                    r.ident()
+                    for r in refs
+                    if isinstance(r, OpRef)
+                )
+            ],
+        ]
+
+        params.extend([
+            OpCompiler._FnParam(
+                k.ident,
+                src=f'{k.ident}={v.src}' if not v.src.startswith('.') else k.ident,
+                noqa=k.ident != k.ident.lower() or not v.src.startswith('.'),
+            )
+            for k, v in FN_GLOBALS.items()
+        ])
+
+        lines: list[str] = []
+
+        lines.extend(self._style.header_lines())
+
+        lines.extend([
+            f'def {fn_name}(',
+            f'    *,',
+            *[
+                f'    {p.src if p.src is not None else p.name},{"  # noqa" if p.noqa else ""}'
+                for p in params
+            ],
+            f'):',
+            *[
+                f'    {l}'
+                for l in body_lines
+            ],
+        ])
+
+        #
+
+        src = '\n'.join(lines)
+
+        return self.CompileResult(
+            fn_name,
+            [p.name for p in params],
+            src,
+            refs,
+        )