omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/dataclasses/impl/generation/processor.py

@@ -10,6 +10,7 @@ import typing as ta
 
 from .... import check
 from .... import lang
+from ....logs import all as logs
 from ..processing.base import ProcessingContext
 from ..processing.base import ProcessingOption
 from ..processing.base import Processor
@@ -21,7 +22,6 @@ 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
@@ -30,6 +30,9 @@ from .registry import all_generator_types
 from .registry import generator_type_for_plan_type
 
 
+log = logs.get_module_logger(globals())
+
+
 ##
 
 
@@ -38,9 +41,10 @@ class PlanOnly(ProcessingOption):
     b: bool
 
 
-@dc.dataclass(frozen=True)
-class Verbose(ProcessingOption):
-    b: bool
+@dc.dataclass(frozen=True, kw_only=True)
+class Verbosity(ProcessingOption):
+    warn: bool = False
+    debug: bool = False
 
 
 class CompileCallback(ta.Protocol):
@@ -53,13 +57,21 @@ class CompileCallback(ta.Protocol):
         ...
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass(frozen=True, kw_only=True)
 class Codegen(ProcessingOption):
-    callback: CompileCallback
+    style: ta.Literal['jit', 'aot'] = 'jit'
+
+    force: bool = False
+    callback: CompileCallback | None = None
+
+
+##
 
 
 @register_processor_type(priority=ProcessorPriority.GENERATION)
 class GeneratorProcessor(Processor):
+    PROCESS_FN_NAME: ta.ClassVar[str] = '_process_dataclass'
+
     class Mode(lang.Abstract):
         @abc.abstractmethod
         def _process(self, gp: 'GeneratorProcessor', cls: type) -> None:
@@ -85,36 +97,52 @@ class GeneratorProcessor(Processor):
 
             self._codegen = codegen
 
+        @classmethod
+        def build_standard_kwargs(cls, dc_cls: type) -> dict[str, ta.Any]:
+            kw: dict = {CLS_IDENT: dc_cls}
+            kw.update({
+                k.ident: v.value
+                for k, v in FN_GLOBALS.items()
+            })
+            return kw
+
         def _process(self, gp: 'GeneratorProcessor', cls: type) -> None:
-            compiler = OpCompiler(
-                OpCompiler.AotStyle(),
-                # OpCompiler.JitStyle(),
-            )
+            style: OpCompiler.Style = {
+                'jit': OpCompiler.JitStyle,
+                'aot': OpCompiler.AotStyle,
+            }[self._codegen.style]()
 
-            fn_name = '_process_dataclass__' + IDENT_MANGLER.mangle(cls.__qualname__)
+            compiler = OpCompiler(style)
 
             comp = compiler.compile(
-                fn_name,
+                GeneratorProcessor.PROCESS_FN_NAME,
                 gp.ops(),
             )
 
-            if (vo := gp._ctx.option(Verbose)) is not None and vo.b:  # noqa
+            comp_src = '\n'.join([
+                *comp.hdr_lines,
+                *(['', ''] if comp.hdr_lines else []),
+                *comp.fn_lines,
+            ])
+
+            if (vo := gp._ctx.option(Verbosity)) is not None and vo.debug:  # noqa
                 print(gp.prepare().plans.render(), file=sys.stderr)
                 print(file=sys.stderr)
-                print(comp.src, 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]
+            exec(comp_src, ns)
+            o_fn = ns[GeneratorProcessor.PROCESS_FN_NAME]
 
             if cls.__module__ in sys.modules:
                 gl = sys.modules[cls.__module__].__dict__
             else:
                 gl = {}
 
+            # TODO: comment why lol
             fn = lang.new_function(**{
                 **lang.new_function_kwargs(o_fn),
                 **dict(
@@ -122,12 +150,8 @@ class GeneratorProcessor(Processor):
                 ),
             })
 
-            kw: dict = {CLS_IDENT: cls}
-            kw.update({
-                k.ident: v.value
-                for k, v in FN_GLOBALS.items()
-                # if v.src.startswith('.')
-            })
+            kw = self.build_standard_kwargs(cls)
+
             orm = gp.prepare().ref_map
             for r in comp.refs:
                 if isinstance(r, OpRef):
@@ -140,7 +164,7 @@ class GeneratorProcessor(Processor):
             fn(**kw)
 
             if (cg := self._codegen) is not None and (cb := cg.callback) is not None:
-                cb(
+                cb(  # noqa
                     gp._ctx,  # noqa
                     gp.prepare(),
                     comp,
@@ -194,13 +218,70 @@ class GeneratorProcessor(Processor):
 
     #
 
+    def _process_from_codegen(self, cls: type) -> bool:
+        cg_pkg = check.not_none(self._ctx.pkg_cfg.pkg)
+        cg_mod_spec = f'{cg_pkg}._dataclasses'
+
+        try:
+            __import__(cg_mod_spec)
+        except ImportError:
+            if (vo := self._ctx.option(Verbosity)) is not None and vo.warn:  # noqa
+                log.warning(lambda: f'Codegen module missing for {cls.__module__}.{cls.__qualname__} at {cg_mod_spec}')
+            return False
+
+        cg_mod = sys.modules[cg_mod_spec]
+        cg_fn_reg = cg_mod.REGISTRY
+
+        #
+
+        prep = self.prepare()
+        prep_plan_repr = repr(prep.plans)
+
+        #
+
+        try:
+            cg_reg_item = cg_fn_reg[prep_plan_repr]
+        except KeyError:
+            if (vo := self._ctx.option(Verbosity)) is not None and vo.warn:  # noqa
+                log.warning(lambda: f'Codegen missing for {cls.__module__}.{cls.__qualname__} in {cg_mod_spec}')
+            return False
+
+        cg_kw, cg_fn = cg_reg_item
+
+        #
+
+        ref_map = {
+            ref.ident(): v
+            for ref, v in prep.ref_map.items()
+        }
+
+        #
+
+        fn_kw = {
+            **GeneratorProcessor.CompilerMode.build_standard_kwargs(cls),
+            **{k: ref_map[k] for k in cg_kw['op_ref_idents']},
+        }
+
+        fn = cg_fn()
+        fn(**fn_kw)
+
+        return True
+
+    #
+
     def process(self, cls: type) -> type:
         if (po := self._ctx.option(PlanOnly)) is not None and po.b:
             self.prepare()
             return cls
 
+        cg = self._ctx.option(Codegen)
+
+        if not (cg is not None and cg.force) and self._ctx.pkg_cfg.cfg.codegen:
+            if self._process_from_codegen(cls):
+                return cls
+
         mode: GeneratorProcessor.Mode
-        if (cg := self._ctx.option(Codegen)) is not None:  # noqa
+        if cg is not None:  # noqa
             mode = GeneratorProcessor.CompilerMode(codegen=cg)
         else:
             mode = GeneratorProcessor.ExecutorMode()

omlish/dataclasses/impl/processing/base.py

@@ -10,6 +10,8 @@ import typing as ta
 from .... import check
 from .... import lang
 from ...specs import ClassSpec
+from ..configs import DEFAULT_NAMED_PACKAGE_CONFIG
+from ..configs import NamedPackageConfig
 
 
 T = ta.TypeVar('T')
@@ -33,6 +35,7 @@ class ProcessingContext:
             cs: ClassSpec,
             item_factories: ta.Mapping[type, ProcessingContextItemFactory],
             *,
+            pkg_cfg: NamedPackageConfig = DEFAULT_NAMED_PACKAGE_CONFIG,
             options: ta.Sequence[ProcessingOption] | None = None,
     ) -> None:
         super().__init__()
@@ -40,6 +43,7 @@ class ProcessingContext:
         self._cls = cls
         self._cs = cs
         self._item_factories = item_factories
+        self._pkg_cfg = pkg_cfg
 
         options_dct: dict = {}
         for o in options or ():
@@ -57,6 +61,10 @@ class ProcessingContext:
     def cs(self) -> ClassSpec:
         return self._cs
 
+    @property
+    def pkg_cfg(self) -> NamedPackageConfig:
+        return self._pkg_cfg
+
     def __getitem__(self, ty: type[T]) -> T:
         try:
             return self._items[ty]

omlish/dataclasses/impl/processing/driving.py

@@ -5,7 +5,7 @@ import typing as ta
 from .... import lang
 from ...specs import ClassSpec
 from .. import concerns as _concerns  # noqa  # imported for registration
-from ..configs import DEFAULT_PACKAGE_CONFIG
+from ..configs import DEFAULT_NAMED_PACKAGE_CONFIG
 from ..configs import PACKAGE_CONFIG_CACHE
 from ..generation import processor as gp
 from .base import ProcessingContext
@@ -41,21 +41,20 @@ def drive_cls_processing(
         cs: ClassSpec,
         *,
         plan_only: bool = False,
-        verbose: bool = False,
+        warn: bool = False,
+        debug: bool = False,
 ) -> type:
     options: list[ProcessingOption] = list(_OPTIONS_CONTEXT_VAR.get())
     if plan_only:
         options.append(gp.PlanOnly(True))
-    if verbose:
-        options.append(gp.Verbose(True))
+    if warn or debug:
+        options.append(gp.Verbosity(warn=warn, debug=debug))
 
     #
 
-    pkg_config = DEFAULT_PACKAGE_CONFIG
     cls_mod = cls.__module__
-    if '.' in cls_mod:
-        cls_pkg = cls_mod.rpartition('.')[0]
-        pkg_cfg = PACKAGE_CONFIG_CACHE.get(cls_pkg, pkg_config)  # noqa
+    cls_pkg = cls_mod.rpartition('.')[0]
+    pkg_cfg = lang.coalesce(PACKAGE_CONFIG_CACHE.get(cls_pkg), DEFAULT_NAMED_PACKAGE_CONFIG)
 
     #
 
@@ -63,6 +62,7 @@ def drive_cls_processing(
         cls,
         cs,
         all_processing_context_item_factories(),
+        pkg_cfg=pkg_cfg,
         options=options,
     )
 

omlish/dataclasses/specs.py

@@ -1,6 +1,7 @@
 """Should be kept pure. No references to dc std, no references to impl detail."""
 import dataclasses as dc
 import enum
+import types
 import typing as ta
 
 from .. import check
@@ -28,6 +29,30 @@ class DefaultFactory(ta.NamedTuple):
 ##
 
 
+class _SpecBase:
+    _BOOL_FIELDS: ta.ClassVar[ta.Sequence[dc.Field]]
+    _OPT_BOOL_FIELDS: ta.ClassVar[ta.Sequence[dc.Field]]
+
+    def _check_spec_base_fields(self) -> None:
+        for f in self._BOOL_FIELDS:
+            if not isinstance(bv := getattr(self, f.name), bool):
+                raise TypeError(f'dataclass {self.__class__.__name__} attr {f.name} must be bool, got {bv!r}')
+
+        for f in self._OPT_BOOL_FIELDS:
+            if not isinstance(bv := getattr(self, f.name), (bool, types.NoneType)):
+                raise TypeError(f'dataclass {self.__class__.__name__} attr {f.name} must be bool or None, got {bv!r}')
+
+
+def _init_spec_base(cls):
+    cls._BOOL_FIELDS = [f for f in dc.fields(cls) if f.type is bool]  # noqa
+    cls._OPT_BOOL_FIELDS = [f for f in dc.fields(cls) if f.type in (bool | None, ta.Optional[bool])]  # noqa
+
+    return cls
+
+
+##
+
+
 class FieldType(enum.StrEnum):
     INSTANCE = enum.auto()
     CLASS_VAR = enum.auto()
@@ -36,8 +61,9 @@ class FieldType(enum.StrEnum):
     __repr__ = lang.enum_name_repr
 
 
+@_init_spec_base
 @dc.dataclass(frozen=True, kw_only=True, eq=False)
-class FieldSpec(lang.Final):
+class FieldSpec(_SpecBase, lang.Final):
     name: str
     annotation: ta.Any
 
@@ -95,6 +121,8 @@ class FieldSpec(lang.Final):
         check.non_empty_str(self.name)
         check.arg(self.name.isidentifier())
 
+        self._check_spec_base_fields()
+
         if self.field_type in (FieldType.CLASS_VAR, FieldType.INIT_VAR):
             if isinstance(self.default.or_else(None), DefaultFactory):
                 raise TypeError(f'field {self.name} cannot have a default factory')
@@ -121,8 +149,9 @@ class FieldSpec(lang.Final):
 ##
 
 
+@_init_spec_base
 @dc.dataclass(frozen=True, kw_only=True, eq=False)
-class ClassSpec(lang.Final):
+class ClassSpec(_SpecBase, lang.Final):
     ##
     # fields
 
@@ -187,6 +216,7 @@ class ClassSpec(lang.Final):
 
     repr_id: bool = False
     terse_repr: bool = False
+    default_repr_fn: ReprFn | None = None
 
     allow_redundant_decorator: bool = False
 
@@ -209,6 +239,8 @@ class ClassSpec(lang.Final):
     # validate
 
     def __post_init__(self) -> None:
+        self._check_spec_base_fields()
+
         fields_by_name: dict[str, FieldSpec] = {}
         for f in self.fields:
             check.not_in(f.name, fields_by_name)

omlish/dataclasses/tools/as_.py

@@ -1,6 +1,5 @@
 import copy
 import dataclasses as dc
-import typing as ta
 
 from .._internals import STD_ATOMIC_TYPES
 from .._internals import std_is_dataclass_instance
@@ -78,14 +77,3 @@ def _astuple_inner(obj, tuple_factory):
 
     else:
         return copy.deepcopy(obj)
-
-
-##
-
-
-def shallow_astuple(o: ta.Any) -> tuple[ta.Any, ...]:
-    return tuple(getattr(o, f.name) for f in dc.fields(o))
-
-
-def shallow_asdict(o: ta.Any) -> dict[str, ta.Any]:
-    return {f.name: getattr(o, f.name) for f in dc.fields(o)}

omlish/dataclasses/tools/modifiers.py

@@ -3,6 +3,7 @@ import typing as ta
 
 from ... import check
 from ... import lang
+from ...lite.dataclasses import is_immediate_dataclass
 
 
 if ta.TYPE_CHECKING:
@@ -40,6 +41,8 @@ def update_fields(
     def inner(cls):
         if issubclass(cls, meta.DataMeta):
             raise TypeError('update_fields() cannot be used on DataMeta subclasses')
+        if is_immediate_dataclass(cls):
+            raise TypeError('update_fields() cannot be used on already processed dataclasses')
 
         if fields is None:
             for a, v in list(cls.__dict__.items()):
@@ -51,6 +54,8 @@ def update_fields(
                 try:
                     v = cls.__dict__[a]
                 except KeyError:
+                    if hasattr(cls, a):
+                        raise TypeError('update_fields() cannot be used on parent dataclass fields') from None
                     v = dc.field()
                 else:
                     if not isinstance(v, dc.Field):

omlish/dataclasses/tools/static.py

@@ -142,7 +142,7 @@ class Static(lang.Abstract):
                     n_md[_ExtraFieldParamsMetadata] = {
                         fs_f.name: getattr(x_fs, fs_f.name)
                         for fs_f in dc.fields(FieldSpec)  # noqa
-                        if fs_f not in dc.Field.__slots__  # type: ignore[attr-defined]
+                        if fs_f not in dc.Field.__slots__
                         and fs_f.name not in ('default', 'default_factory')
                     }
                     new_fld.metadata = n_md  # type: ignore[assignment]

omlish/diag/_pycharm/runhack.py

@@ -51,7 +51,7 @@ class _cached_nullary:  # noqa
 
         return self._value
 
-    def __get__(self, instance, owner):  # noqa
+    def __get__(self, instance, owner=None):  # noqa
         bound = instance.__dict__[self._fn.__name__] = self.__class__(self._fn.__get__(instance, owner))
         return bound
 

omlish/diag/{lslocks.py → cmds/lslocks.py}

@@ -7,12 +7,12 @@ import dataclasses as dc
 import json
 import typing as ta
 
-from ..lite.check import check
-from ..lite.marshal import OBJ_MARSHALER_FIELD_KEY
-from ..lite.marshal import unmarshal_obj
-from ..subprocesses.run import SubprocessRun
-from ..subprocesses.run import SubprocessRunnable
-from ..subprocesses.run import SubprocessRunOutput
+from ...lite.check import check
+from ...lite.marshal import OBJ_MARSHALER_FIELD_KEY
+from ...lite.marshal import unmarshal_obj
+from ...subprocesses.run import SubprocessRun
+from ...subprocesses.run import SubprocessRunnable
+from ...subprocesses.run import SubprocessRunOutput
 
 
 ##

omlish/diag/{lsof.py → cmds/lsof.py}

@@ -7,12 +7,12 @@ import dataclasses as dc
 import enum
 import typing as ta
 
-from ..lite.check import check
-from ..lite.dataclasses import dataclass_repr_omit_falsey
-from ..lite.marshal import OBJ_MARSHALER_OMIT_IF_NONE
-from ..subprocesses.run import SubprocessRun
-from ..subprocesses.run import SubprocessRunnable
-from ..subprocesses.run import SubprocessRunOutput
+from ...lite.check import check
+from ...lite.dataclasses import dataclass_repr_omit_falsey
+from ...lite.marshal import OBJ_MARSHALER_OMIT_IF_NONE
+from ...subprocesses.run import SubprocessRun
+from ...subprocesses.run import SubprocessRunnable
+from ...subprocesses.run import SubprocessRunOutput
 
 
 ##

omlish/diag/{ps.py → cmds/ps.py}

@@ -4,12 +4,12 @@ import dataclasses as dc
 import os
 import typing as ta
 
-from ..lite.check import check
-from ..lite.timeouts import Timeout
-from ..subprocesses.run import SubprocessRun
-from ..subprocesses.run import SubprocessRunnable
-from ..subprocesses.run import SubprocessRunOutput
-from ..subprocesses.sync import subprocesses
+from ...lite.check import check
+from ...lite.timeouts import Timeout
+from ...subprocesses.run import SubprocessRun
+from ...subprocesses.run import SubprocessRunnable
+from ...subprocesses.run import SubprocessRunOutput
+from ...subprocesses.sync import subprocesses
 
 
 ##

omlish/diag/procfs.py

@@ -3,7 +3,6 @@ TODO:
  - dataclasses
 """
 import argparse
-import logging
 import os
 import re
 import resource
@@ -14,11 +13,12 @@ import typing as ta
 from .. import iterators as it
 from .. import lang
 from ..formats import json
+from ..logs import all as logs
 from ..os.sizes import PAGE_SIZE
 from .procstats import ProcStats
 
 
-log = logging.getLogger(__name__)
+log = logs.get_module_logger(globals())
 
 
 PidLike = int | str
@@ -235,7 +235,7 @@ PAGEMAP_KEYS = (
 )
 
 
-def get_process_range_pagemaps(start: int, end: int, pid: PidLike = 'self') -> ta.Iterable[dict[str, int]]:
+def get_process_range_pagemaps(start: int, end: int, pid: PidLike = 'self') -> ta.Iterator[dict[str, int]]:
     """https://www.kernel.org/doc/Documentation/vm/pagemap.txt"""
 
     _check_linux()
@@ -262,7 +262,7 @@ def get_process_range_pagemaps(start: int, end: int, pid: PidLike = 'self') -> t
         }
 
 
-def get_process_pagemaps(pid: PidLike = 'self') -> ta.Iterable[dict[str, int]]:
+def get_process_pagemaps(pid: PidLike = 'self') -> ta.Iterator[dict[str, int]]:
     _check_linux()
     for m in get_process_maps(pid):
         yield from get_process_range_pagemaps(m['address'], m['end_address'], pid)

omlish/diag/pycharm.py

@@ -191,9 +191,23 @@ def pycharm_remote_debugger_attach(prd: PycharmRemoteDebugger) -> None:
     else:
         pydevd_pycharm = _import_pydevd_pycharm(version=version)
 
+    import inspect
+    st_sig = inspect.signature(pydevd_pycharm.settrace)
+
+    kw: dict = {}
+    if 'stdoutToServer' in st_sig.parameters:
+        kw.update(
+            stdoutToServer=True,
+            stderrToServer=True,
+        )
+    else:
+        kw.update(
+            stdout_to_server=True,
+            stderr_to_server=True,
+        )
+
     pydevd_pycharm.settrace(
         host,
         port=prd.port,
-        stdoutToServer=True,
-        stderrToServer=True,
+        **kw,
     )