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

omlish/dataclasses/generation/execution.py

@@ -0,0 +1,195 @@
+"""
+TODO:
+ - 'setup' locals - for FrozenGenerator's `condition += ' or name in {' + ', '.join(repr(f.name) for f in fields) + '}'`
+   allow for `condition += ' or name in {fields_frozenset_ident}' with fields_frozenset_ident setup in preamble
+"""
+import sys
+import types
+import typing as ta
+
+from ... import lang
+from ..utils import repr_round_trip_value
+from .globals import FN_GLOBAL_VALUES
+from .globals import FnGlobal
+from .idents import CLS_IDENT
+from .ops import AddMethodOp
+from .ops import AddPropertyOp
+from .ops import IfAttrPresent
+from .ops import Op
+from .ops import OpRef
+from .ops import OpRefMap
+from .ops import Ref
+from .ops import SetAttrOp
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class OpExecutor:
+    def __init__(self, cls: type, orm: OpRefMap) -> None:
+        super().__init__()
+
+        self._cls = cls
+        self._orm = orm
+
+    #
+
+    @lang.cached_function(no_wrapper_update=True)
+    def _cls_globals(self) -> dict[str, ta.Any]:
+        if self._cls.__module__ in sys.modules:
+            return sys.modules[self._cls.__module__].__dict__
+        else:
+            return {}
+
+    #
+
+    def _set_fn_qualname(self, fn: types.FunctionType, name: str | None = None) -> types.FunctionType:
+        if name is None:
+            name = fn.__name__
+        fn.__qualname__ = f'{self._cls.__qualname__}.{name}'
+        return fn
+
+    def _create_fn(
+            self,
+            name: str,
+            src: str,
+            refs: ta.Iterable[Ref] = (),
+    ) -> types.FunctionType:
+        lo: dict = {
+            CLS_IDENT: self._cls,
+            **FN_GLOBAL_VALUES,
+        }
+        for r in refs:
+            if isinstance(r, OpRef):
+                lo[r.ident()] = self._orm[r]
+            elif isinstance(r, FnGlobal):
+                pass
+            else:
+                raise TypeError(r)
+
+        x_src = '\n'.join([
+            f'def __create_fn__(',
+            f'    *,',
+            *[
+                f'    {k},'
+                for k in lo
+            ],
+            f'):',
+            *[
+                f'    {l}'
+                for l in src.splitlines()
+            ],
+            f'',
+            f'    return {name}',
+        ])
+
+        ns: dict = {}
+        exec(
+            x_src,
+            self._cls_globals(),
+            ns,
+        )
+        x_fn = ns['__create_fn__']
+        fn = x_fn(**lo)
+
+        if not isinstance(fn, types.FunctionType):
+            raise TypeError(fn)
+
+        self._set_fn_qualname(fn, name)
+
+        return fn
+
+    def _create_opt_fn(
+            self,
+            name: str,
+            src: str | None,
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> types.FunctionType | None:
+        if src is None:
+            return None
+
+        return self._create_fn(
+            name,
+            src,
+            *args,
+            **kwargs,
+        )
+
+    #
+
+    def _execute_set_attr(
+            self,
+            attr_name: str,
+            value: ta.Any,
+            if_present: IfAttrPresent,
+    ) -> None:
+        if attr_name in self._cls.__dict__:
+            if if_present == 'skip':
+                return
+            elif if_present == 'replace':
+                pass
+            elif if_present == 'error':
+                raise TypeError(f'Cannot overwrite attribute {attr_name} in class {self._cls.__name__}')
+            else:
+                raise ValueError(if_present)
+
+        setattr(self._cls, attr_name, value)
+
+    def execute(self, op: Op) -> None:
+        if isinstance(op, SetAttrOp):
+            if isinstance(v := op.value, OpRef):
+                v = self._orm[v]
+                if isinstance(v, types.FunctionType):
+                    self._set_fn_qualname(v)
+            else:
+                v = repr_round_trip_value(v)
+
+            self._execute_set_attr(
+                op.name,
+                v,
+                op.if_present,
+            )
+
+        elif isinstance(op, AddMethodOp):
+            fn = self._create_fn(
+                op.name,
+                op.src,
+                op.refs,
+            )
+
+            self._execute_set_attr(
+                op.name,
+                fn,
+                op.if_present,
+            )
+
+        elif isinstance(op, AddPropertyOp):
+            get_fn = self._create_opt_fn(
+                op.name,
+                op.get_src,
+                op.refs,
+            )
+            set_fn = self._create_opt_fn(
+                op.name,
+                op.set_src,
+                op.refs,
+            )
+            del_fn = self._create_opt_fn(
+                op.name,
+                op.del_src,
+                op.refs,
+            )
+            prop = property(
+                get_fn,
+                set_fn,
+                del_fn,
+            )
+
+            setattr(self._cls, op.name, prop)
+
+        else:
+            raise TypeError(op)

omlish/dataclasses/generation/globals.py

@@ -0,0 +1,83 @@
+import dataclasses as dc
+import reprlib
+import types
+import typing as ta
+
+from ..errors import FieldFnValidationError
+from ..errors import FieldTypeValidationError
+from ..errors import FnValidationError
+from .idents import IDENT_PREFIX
+
+
+##
+
+
+class FnGlobal(ta.NamedTuple):
+    ident: str
+
+
+class FnGlobalValue(ta.NamedTuple):
+    value: ta.Any
+    src: str  # Leading '.' denotes a dataclasses-internal symbol
+
+
+FN_GLOBAL_IMPORTS: ta.Mapping[str, types.ModuleType] = {
+    'dataclasses': dc,
+    'reprlib': reprlib,
+    'types': types,
+}
+
+
+FN_GLOBALS: ta.Mapping[FnGlobal, FnGlobalValue] = {
+    (ISINSTANCE_GLOBAL := FnGlobal(IDENT_PREFIX + 'isinstance')): FnGlobalValue(isinstance, 'isinstance'),
+    (NONE_GLOBAL := FnGlobal(IDENT_PREFIX + 'None')): FnGlobalValue(None, 'None'),
+    (PROPERTY_GLOBAL := FnGlobal(IDENT_PREFIX + 'property')): FnGlobalValue(property, 'property'),
+    (TYPE_ERROR_GLOBAL := FnGlobal(IDENT_PREFIX + 'TypeError')): FnGlobalValue(TypeError, 'TypeError'),
+
+    (OBJECT_SETATTR_GLOBAL := FnGlobal(IDENT_PREFIX + 'object_setattr')): FnGlobalValue(
+        object.__setattr__,
+        'object.__setattr__',
+    ),
+
+    (FROZEN_INSTANCE_ERROR_GLOBAL := FnGlobal(IDENT_PREFIX + 'FrozenInstanceError')): FnGlobalValue(
+        dc.FrozenInstanceError,
+        'dataclasses.FrozenInstanceError',
+    ),
+    (HAS_DEFAULT_FACTORY_GLOBAL := FnGlobal(IDENT_PREFIX + 'HAS_DEFAULT_FACTORY')): FnGlobalValue(
+        dc._HAS_DEFAULT_FACTORY,  # type: ignore[attr-defined]  # noqa
+        'dataclasses._HAS_DEFAULT_FACTORY',
+    ),
+    (MISSING_GLOBAL := FnGlobal(IDENT_PREFIX + 'MISSING')): FnGlobalValue(
+        dc.MISSING,  # noqa
+        'dataclasses.MISSING',
+    ),
+
+    (REPRLIB_RECURSIVE_REPR_GLOBAL := FnGlobal(IDENT_PREFIX + '_recursive_repr')): FnGlobalValue(
+        reprlib.recursive_repr,
+        'reprlib.recursive_repr',
+    ),
+
+    (FUNCTION_TYPE_GLOBAL := FnGlobal(IDENT_PREFIX + 'FunctionType')): FnGlobalValue(
+        types.FunctionType,
+        'types.FunctionType',
+    ),
+
+    (FIELD_FN_VALIDATION_ERROR_GLOBAL := FnGlobal(IDENT_PREFIX + 'FieldFnValidationError')): FnGlobalValue(
+        FieldFnValidationError,
+        '.errors.FieldFnValidationError',
+    ),
+    (FIELD_TYPE_VALIDATION_ERROR_GLOBAL := FnGlobal(IDENT_PREFIX + 'FieldTypeValidationError')): FnGlobalValue(
+        FieldTypeValidationError,
+        '.errors.FieldTypeValidationError',
+    ),
+    (FN_VALIDATION_ERROR_GLOBAL := FnGlobal(IDENT_PREFIX + 'FnValidationError')): FnGlobalValue(
+        FnValidationError,
+        '.errors.FnValidationError',
+    ),
+}
+
+
+FN_GLOBAL_VALUES: ta.Mapping[str, ta.Any] = {
+    k.ident: v.value
+    for k, v in FN_GLOBALS.items()
+}

omlish/dataclasses/generation/idents.py

@@ -0,0 +1,6 @@
+IDENT_PREFIX = '__dataclass__'
+
+CLS_IDENT = IDENT_PREFIX + 'cls'
+SELF_IDENT = IDENT_PREFIX + 'self'
+SELF_DICT_IDENT = IDENT_PREFIX + 'self_dict'
+VALUE_IDENT = IDENT_PREFIX + 'value'

omlish/dataclasses/generation/mangling.py

@@ -0,0 +1,18 @@
+from ...text.mangle import StringMangler
+
+
+##
+
+
+ESCAPED_IDENT_CHARS = ''.join(
+    chr(i)
+    for i in range(128)
+    if not (
+        chr(i).isalpha() or
+        chr(i).isdigit() or
+        chr(i) == '_' or
+        ord(chr(i)) > 127
+    )
+)
+
+IDENT_MANGLER = StringMangler.of('_', ESCAPED_IDENT_CHARS)

omlish/dataclasses/generation/manifests.py

@@ -0,0 +1,20 @@
+import dataclasses as dc
+import json
+
+from .plans import Plans
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DataclassTransformManifest:
+    qualname: str
+    digest: str
+    plans: Plans
+
+    def to_json(self) -> str:
+        return json.dumps(
+            dc.asdict(self),  # noqa
+            indent=2,
+        )

omlish/dataclasses/generation/ops.py

@@ -0,0 +1,97 @@
+import abc
+import dataclasses as dc
+import typing as ta
+
+from .globals import FnGlobal
+from .idents import IDENT_PREFIX
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class _OpRef(ta.NamedTuple, ta.Generic[T]):
+    name: str
+
+
+class OpRef(_OpRef[T]):
+    def __repr__(self) -> str:
+        return f'OpRef(name={self.name!r})'
+
+    #
+
+    _ident: str
+
+    def ident(self) -> str:
+        try:
+            return self._ident
+        except AttributeError:
+            pass
+
+        ident = IDENT_PREFIX + self.name.replace('.', '__')
+        self._ident = ident  # noqa
+        return ident
+
+
+##
+
+
+OpRefMap: ta.TypeAlias = ta.Mapping[OpRef, ta.Any]
+
+Ref: ta.TypeAlias = OpRef | FnGlobal
+
+
+##
+
+
+IfAttrPresent: ta.TypeAlias = ta.Literal['skip', 'replace', 'error']
+
+
+@dc.dataclass(frozen=True)
+class Op(abc.ABC):  # noqa
+    pass
+
+
+@dc.dataclass(frozen=True)
+class SetAttrOp(Op):
+    name: str
+    value: Ref | ta.Any
+
+    if_present: IfAttrPresent = dc.field(default='replace', kw_only=True)
+
+
+@dc.dataclass(frozen=True)
+class AddMethodOp(Op):
+    name: str
+    src: str
+    refs: frozenset[Ref] = dc.field(default=frozenset())
+
+    if_present: IfAttrPresent = dc.field(default='error', kw_only=True)
+
+
+@dc.dataclass(frozen=True)
+class AddPropertyOp(Op):
+    name: str
+    get_src: str | None = None
+    set_src: str | None = None
+    del_src: str | None = None
+    refs: frozenset[Ref] = frozenset()
+
+
+##
+
+
+def get_op_refs(op: Op) -> frozenset[Ref]:
+    if isinstance(op, SetAttrOp):
+        if isinstance(v := op.value, (OpRef, FnGlobal)):
+            return frozenset([v])
+        else:
+            return frozenset()
+
+    elif isinstance(op, (AddMethodOp, AddPropertyOp)):
+        return op.refs
+
+    else:
+        raise TypeError(op)

omlish/dataclasses/generation/plans.py

@@ -0,0 +1,35 @@
+"""
+TODO:
+ - sha1 is slow :/ key by repr but name by sha1
+"""
+import dataclasses as dc
+import re
+import typing as ta
+
+from ... import lang
+from .base import Plan
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Plans:
+    tup: tuple[Plan, ...]
+
+    def __iter__(self) -> ta.Iterator[Plan]:
+        return iter(self.tup)
+
+    @lang.cached_function(no_wrapper_update=True)
+    def render(self) -> str:
+        return _render(self)
+
+
+##
+
+
+_WS_PAT = re.compile(r'\s+')
+
+
+def _render(plans: Plans) -> str:
+    return _WS_PAT.sub('', repr(plans.tup))

omlish/dataclasses/generation/processor.py

@@ -0,0 +1,179 @@
+"""
+TODO:
+ - untangle compilation from here
+ - populate linecache
+"""
+import abc
+import dataclasses as dc
+import sys
+import typing as ta
+
+from ... import check
+from ... import lang
+from ..processing.base import ProcessingContext
+from ..processing.base import Processor
+from ..processing.priority import ProcessorPriority
+from ..processing.registry import register_processor_type
+from .base import Plan
+from .compilation import OpCompiler
+from .execution import OpExecutor
+from .globals import FN_GLOBALS
+from .globals import FnGlobal
+from .idents import CLS_IDENT
+from .mangling import IDENT_MANGLER
+from .ops import Op
+from .ops import OpRef
+from .ops import OpRefMap
+from .plans import Plans
+from .registry import all_generator_types
+from .registry import generator_type_for_plan_type
+
+
+##
+
+
+class PlanOnly(ta.NamedTuple):
+    b: bool
+
+
+class Verbose(ta.NamedTuple):
+    b: bool
+
+
+@register_processor_type(priority=ProcessorPriority.GENERATION)
+class GeneratorProcessor(Processor):
+    class Mode(abc.ABC):
+        @abc.abstractmethod
+        def _process(self, gp: 'GeneratorProcessor', cls: type) -> None:
+            raise NotImplementedError
+
+    class ExecutorMode(Mode):
+        def _process(self, gp: 'GeneratorProcessor', cls: type) -> None:
+            opx = OpExecutor(
+                cls,
+                gp.prepare().ref_map,
+            )
+
+            for op in gp.ops():
+                opx.execute(op)
+
+    class CompilerMode(Mode):
+        def _process(self, gp: 'GeneratorProcessor', cls: type) -> None:
+            compiler = OpCompiler(
+                OpCompiler.AotStyle(),
+                # OpCompiler.JitStyle(),
+            )
+
+            fn_name = '_process_dataclass__' + IDENT_MANGLER.mangle(cls.__qualname__)
+
+            comp = compiler.compile(
+                fn_name,
+                gp.ops(),
+            )
+
+            if (vo := gp._ctx.option(Verbose)) is not None and vo.b:  # noqa
+                print(gp.prepare().plans.render(), file=sys.stderr)
+                print(file=sys.stderr)
+                print(comp.src, file=sys.stderr)
+                print(file=sys.stderr)
+
+            ns: dict = {}
+            ns.update(compiler.style.globals_ns())  # noqa
+
+            exec(comp.src, ns)
+            o_fn = ns[comp.fn_name]
+
+            if cls.__module__ in sys.modules:
+                gl = sys.modules[cls.__module__].__dict__
+            else:
+                gl = {}
+
+            fn = lang.new_function(**{
+                **lang.new_function_kwargs(o_fn),
+                **dict(
+                    globals=gl,
+                ),
+            })
+
+            kw: dict = {CLS_IDENT: cls}
+            kw.update({
+                k.ident: v.value
+                for k, v in FN_GLOBALS.items()
+                # if v.src.startswith('.')
+            })
+            orm = gp.prepare().ref_map
+            for r in comp.refs:
+                if isinstance(r, OpRef):
+                    kw[r.ident()] = orm[r]
+                elif isinstance(r, FnGlobal):
+                    pass
+                else:
+                    raise TypeError(r)
+
+            fn(**kw)
+
+    #
+
+    def __init__(
+            self,
+            ctx: ProcessingContext,
+            *,
+            mode: Mode = ExecutorMode(),
+            # mode: Mode = CompilerMode(),
+    ) -> None:
+        super().__init__(ctx)
+
+        self._mode = mode
+
+    @dc.dataclass(frozen=True)
+    class Prepared:
+        plans: Plans
+        ref_map: OpRefMap
+
+        def __post_init__(self) -> None:
+            hash(self.plans)
+
+    @lang.cached_function(no_wrapper_update=True)
+    def prepare(self) -> Prepared:
+        gs = [g_ty() for g_ty in all_generator_types()]
+
+        pll: list[Plan] = []
+        orm: dict[OpRef, ta.Any] = {}
+        for g in gs:
+            if (pr := g.plan(self._ctx)) is None:
+                continue
+
+            for k, v in (pr.ref_map or {}).items():
+                if k in orm:
+                    check.equal(orm[k], v)
+                else:
+                    orm[k] = v
+
+            pll.append(pr.plan)
+
+        plans = Plans(tuple(pll))
+
+        return self.Prepared(
+            plans,
+            orm,
+        )
+
+    @lang.cached_function(no_wrapper_update=True)
+    def ops(self) -> ta.Sequence[Op]:
+        prepared = self.prepare()
+
+        ops: list[Op] = []
+        for pl in prepared.plans:
+            g = generator_type_for_plan_type(type(pl))()
+            ops.extend(g.generate(pl))
+
+        return ops
+
+    #
+
+    def process(self, cls: type) -> type:
+        if (po := self._ctx.option(PlanOnly)) is not None and po.b:
+            self.prepare()
+        else:
+            self._mode._process(self, cls)  # noqa
+        return cls

omlish/dataclasses/generation/registry.py

@@ -0,0 +1,42 @@
+import typing as ta
+
+from ... import check
+from ... import lang
+from ..utils import SealableRegistry
+from .base import Generator
+from .base import Plan
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+GeneratorT = ta.TypeVar('GeneratorT', bound=Generator)
+
+
+##
+
+
+_GENERATOR_TYPES_BY_PLAN_TYPE: SealableRegistry[type[Plan], type[Generator]] = SealableRegistry()
+
+
+def register_generator_type(pl_ty: type[Plan]) -> ta.Callable[[type[GeneratorT]], type[GeneratorT]]:
+    def inner(g_ty):
+        check.issubclass(g_ty, Generator)
+        _GENERATOR_TYPES_BY_PLAN_TYPE[pl_ty] = g_ty
+        return g_ty
+
+    check.issubclass(pl_ty, Plan)
+    return inner
+
+
+@lang.cached_function
+def generator_type_for_plan_type(pl_ty: type[Plan]) -> type[Generator]:
+    return _GENERATOR_TYPES_BY_PLAN_TYPE[pl_ty]
+
+
+@lang.cached_function
+def all_generator_types() -> tuple[type[Generator], ...]:
+    return tuple(sorted(
+        {v for _, v in _GENERATOR_TYPES_BY_PLAN_TYPE.items()},
+        key=lambda g_ty: g_ty.__name__,
+    ))