omlish 0.0.0.dev394__py3-none-any.whl → 0.0.0.dev396__py3-none-any.whl

omlish/dataclasses/{generation → impl/generation}/processor.py

@@ -8,8 +8,8 @@ import dataclasses as dc
 import sys
 import typing as ta
 
-from ... import check
-from ... import lang
+from .... import check
+from .... import lang
 from ..processing.base import ProcessingContext
 from ..processing.base import ProcessingOption
 from ..processing.base import Processor
@@ -43,6 +43,21 @@ class Verbose(ProcessingOption):
     b: bool
 
 
+class CompileCallback(ta.Protocol):
+    def __call__(
+            self,
+            ctx: ProcessingContext,
+            prepared: 'GeneratorProcessor.Prepared',
+            comp: OpCompiler.CompileResult,
+    ) -> None:
+        ...
+
+
+@dc.dataclass(frozen=True)
+class Codegen(ProcessingOption):
+    callback: CompileCallback
+
+
 @register_processor_type(priority=ProcessorPriority.GENERATION)
 class GeneratorProcessor(Processor):
     class Mode(abc.ABC):
@@ -61,6 +76,15 @@ class GeneratorProcessor(Processor):
                 opx.execute(op)
 
     class CompilerMode(Mode):
+        def __init__(
+                self,
+                *,
+                codegen: Codegen,
+        ) -> None:
+            super().__init__()
+
+            self._codegen = codegen
+
         def _process(self, gp: 'GeneratorProcessor', cls: type) -> None:
             compiler = OpCompiler(
                 OpCompiler.AotStyle(),
@@ -115,18 +139,14 @@ class GeneratorProcessor(Processor):
 
             fn(**kw)
 
-    #
+            if (cg := self._codegen) is not None and (cb := cg.callback) is not None:
+                cb(
+                    gp._ctx,  # noqa
+                    gp.prepare(),
+                    comp,
+                )
 
-    def __init__(
-            self,
-            ctx: ProcessingContext,
-            *,
-            mode: Mode = ExecutorMode(),
-            # mode: Mode = CompilerMode(),
-    ) -> None:
-        super().__init__(ctx)
-
-        self._mode = mode
+    #
 
     @dc.dataclass(frozen=True)
     class Prepared:
@@ -177,6 +197,13 @@ class GeneratorProcessor(Processor):
     def process(self, cls: type) -> type:
         if (po := self._ctx.option(PlanOnly)) is not None and po.b:
             self.prepare()
+            return cls
+
+        mode: GeneratorProcessor.Mode
+        if (cg := self._ctx.option(Codegen)) is not None:  # noqa
+            mode = GeneratorProcessor.CompilerMode(codegen=cg)
         else:
-            self._mode._process(self, cls)  # noqa
+            mode = GeneratorProcessor.ExecutorMode()
+
+        mode._process(self, cls)  # noqa
         return cls

omlish/dataclasses/{generation → impl/generation}/registry.py

@@ -1,7 +1,7 @@
 import typing as ta
 
-from ... import check
-from ... import lang
+from .... import check
+from .... import lang
 from ..utils import SealableRegistry
 from .base import Generator
 from .base import Plan

omlish/dataclasses/{processing → impl/processing}/base.py

@@ -7,9 +7,9 @@ TODO:
 """
 import typing as ta
 
-from ... import check
-from ... import lang
-from ..specs import ClassSpec
+from .... import check
+from .... import lang
+from ...specs import ClassSpec
 
 
 T = ta.TypeVar('T')

omlish/dataclasses/{processing → impl/processing}/driving.py

@@ -1,7 +1,11 @@
+import contextlib
+import contextvars
+import typing as ta
 
+from .... import lang
+from ...specs import ClassSpec
 from .. import concerns as _concerns  # noqa  # imported for registration
 from ..generation import processor as gp
-from ..specs import ClassSpec
 from .base import ProcessingContext
 from .base import ProcessingOption
 from .base import Processor
@@ -12,6 +16,24 @@ from .registry import ordered_processor_types
 ##
 
 
+_OPTIONS_CONTEXT_VAR: contextvars.ContextVar[ta.Sequence[ProcessingOption]] = contextvars.ContextVar(
+    f'{__name__}._OPTIONS_CONTEXT_VAR',
+    default=(),
+)
+
+
+@contextlib.contextmanager
+def processing_options_context(*opts: ProcessingOption) -> ta.Iterator[None]:
+    with lang.context_var_setting(
+            _OPTIONS_CONTEXT_VAR,
+            (*_OPTIONS_CONTEXT_VAR.get(), *opts),
+    ):
+        yield
+
+
+##
+
+
 def drive_cls_processing(
         cls: type,
         cs: ClassSpec,
@@ -19,7 +41,7 @@ def drive_cls_processing(
         plan_only: bool = False,
         verbose: bool = False,
 ) -> type:
-    options: list[ProcessingOption] = []
+    options: list[ProcessingOption] = list(_OPTIONS_CONTEXT_VAR.get())
     if plan_only:
         options.append(gp.PlanOnly(True))
     if verbose:

omlish/dataclasses/{processing → impl/processing}/registry.py

@@ -1,8 +1,8 @@
 import dataclasses as dc
 import typing as ta
 
-from ... import check
-from ... import lang
+from .... import check
+from .... import lang
 from ..utils import SealableRegistry
 from .base import ProcessingContextItemFactory
 from .base import Processor

omlish/dataclasses/{utils.py → impl/utils.py}

@@ -4,7 +4,7 @@ import functools
 import types
 import typing as ta
 
-from .. import check
+from ... import check
 
 
 T = ta.TypeVar('T')

omlish/dataclasses/inspect.py

@@ -7,10 +7,10 @@ from .. import check
 from .. import collections as col
 from .. import lang
 from .. import reflect as rfl
-from .internals import STD_FIELDS_ATTR
-from .internals import StdFieldType
-from .internals import std_field_type
-from .internals import std_is_kw_only
+from ._internals import STD_FIELDS_ATTR
+from ._internals import StdFieldType
+from ._internals import std_field_type
+from ._internals import std_is_kw_only
 
 
 ClassAnnotations: ta.TypeAlias = ta.Mapping[str, ta.Any]

omlish/dataclasses/metaclass/bases.py

@@ -1,7 +1,7 @@
 import typing as ta
 
-from ..api.classes.decorator import dataclass
-from ..concerns.frozen import unchecked_frozen_base
+from ..impl.api.classes.decorator import dataclass
+from ..impl.concerns.frozen import unchecked_frozen_base
 from .meta import DataMeta
 from .specs import get_metaclass_spec
 

omlish/dataclasses/metaclass/confer.py

@@ -1,7 +1,7 @@
 import dataclasses as dc
 import typing as ta
 
-from ..api.classes.params import get_class_spec
+from ..impl.api.classes.params import get_class_spec
 from .specs import get_metaclass_spec
 
 

omlish/dataclasses/metaclass/meta.py

@@ -8,7 +8,7 @@ import dataclasses as dc
 import typing as ta
 
 from ... import lang
-from ..api.classes.decorator import dataclass
+from ..impl.api.classes.decorator import dataclass
 from .confer import CONFER_METACLASS_PARAMS
 from .confer import confer_kwargs
 from .specs import MetaclassSpec

omlish/dataclasses/metaclass/specs.py

@@ -1,7 +1,7 @@
 import dataclasses as dc
 
 from ... import lang
-from ..api.classes.params import get_class_spec
+from ..impl.api.classes.params import get_class_spec
 from ..specs import ClassSpec
 
 

omlish/dataclasses/reflection.py

@@ -2,17 +2,17 @@ import dataclasses as dc
 import typing as ta
 
 from .. import lang
-from .api.classes.conversion import std_params_to_class_spec
-from .api.classes.metadata import extract_cls_metadata
-from .api.classes.params import get_class_spec
-from .api.fields.conversion import std_field_to_field_spec
-from .concerns.fields import InitFields
-from .concerns.fields import calc_init_fields
+from ._internals import STD_PARAMS_ATTR
+from ._internals import StdFieldType
+from ._internals import std_field_type
+from .impl.api.classes.conversion import std_params_to_class_spec
+from .impl.api.classes.metadata import extract_cls_metadata
+from .impl.api.classes.params import get_class_spec
+from .impl.api.fields.conversion import std_field_to_field_spec
+from .impl.concerns.fields import InitFields
+from .impl.concerns.fields import calc_init_fields
 from .inspect import FieldsInspection
 from .inspect import inspect_fields
-from .internals import STD_PARAMS_ATTR
-from .internals import StdFieldType
-from .internals import std_field_type
 from .specs import ClassSpec
 
 

omlish/dataclasses/tools/as_.py

@@ -2,8 +2,8 @@ import copy
 import dataclasses as dc
 import typing as ta
 
-from ..internals import STD_ATOMIC_TYPES
-from ..internals import std_is_dataclass_instance
+from .._internals import STD_ATOMIC_TYPES
+from .._internals import std_is_dataclass_instance
 
 
 ##

omlish/dataclasses/tools/static.py

@@ -10,7 +10,7 @@ import typing as ta
 
 from ... import lang
 from ...lite.dataclasses import is_immediate_dataclass
-from ..api.classes.decorator import dataclass
+from ..impl.api.classes.decorator import dataclass
 
 
 ##
@@ -123,7 +123,7 @@ class Static(lang.Abstract):
                     new_fld.default_factory = (lambda v2: lambda: v2)(v)  # noqa
 
                 # FIXME
-                from ..api.fields.metadata import _ExtraFieldParamsMetadata  # noqa
+                from ..impl.api.fields.metadata import _ExtraFieldParamsMetadata  # noqa
                 from ..specs import FieldSpec
                 try:
                     x_fs = fld.metadata[FieldSpec]

omlish/diag/pydevd.py

@@ -124,7 +124,7 @@ def is_present() -> bool:
 
 def get_setup() -> dict | None:
     if is_present():
-        return _pydevd().SetupHolder.setup
+        return check.not_none(_pydevd()).SetupHolder.setup
     else:
         return None
 
@@ -160,7 +160,7 @@ ARGS_ENV_VAR = 'PYDEVD_ARGS'
 def get_args() -> list[str]:
     check.state(is_present())
     setup: ta.Mapping[ta.Any, ta.Any] = check.isinstance(get_setup(), dict)
-    args = [_pydevd().__file__]
+    args = [check.not_none(check.not_none(_pydevd()).__file__)]
 
     for k in [
         'port',

omlish/diag/timers.py

@@ -0,0 +1,184 @@
+import atexit
+import contextlib
+import functools
+import sys
+import threading
+import time
+import typing as ta
+
+from .. import check
+from .. import lang
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class _GlobalTimer:
+    def __init__(
+            self,
+            registry: '_GlobalTimerRegistry',
+            name: str,
+            *,
+            clock: ta.Callable[[], float] | None = None,
+            report_at_exit: bool = False,
+            report_out: ta.Any | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._registry = registry
+        self._name = name
+
+        if clock is None:
+            clock = time.monotonic
+        self._clock = clock
+        self._report_out = report_out
+
+        self._lock = threading.Lock()
+
+        self._c = 0
+        self._t = 0.
+
+        if report_at_exit:
+            atexit.register(self.report)
+
+    def report(self) -> None:
+        msg = (
+            f'{self._registry.module_name}::{self._name}: '
+            f'{self._c} calls, '
+            f'{self._t:.3f}s total'
+        )
+
+        print(
+            msg,
+            file=self._report_out if self._report_out is not None else sys.stderr,
+        )
+
+    @contextlib.contextmanager
+    def __call__(self) -> ta.Iterator[None]:
+        start = self._clock()
+
+        try:
+            yield
+
+        finally:
+            end = self._clock()
+            took = end - start
+
+            with self._lock:
+                self._c += 1
+                self._t += took
+
+
+#
+
+
+class _GlobalTimerRegistry:
+    def __init__(
+            self,
+            module_name: str,
+    ) -> None:
+        super().__init__()
+
+        self._module_name = module_name
+
+        self._lock = threading.Lock()
+
+        self._timers: dict[str, _GlobalTimer] = {}
+
+    @property
+    def module_name(self) -> str:
+        return self._module_name
+
+    def get_timer(
+            self,
+            name: str,
+            **kwargs: ta.Any,
+    ) -> _GlobalTimer:
+        return lang.double_check_setdefault(
+            self._lock,
+            self._timers,
+            name,
+            lambda: _GlobalTimer(
+                self,
+                name,
+                **kwargs,
+            ),
+        )
+
+
+_GLOBAL_LOCK = threading.Lock()
+_GLOBAL_ATTR = '__global_timers_registry__'
+
+
+def _get_global_registry(
+        globals: ta.MutableMapping[str, ta.Any],  # noqa
+) -> _GlobalTimerRegistry:
+    reg = lang.double_check_setdefault(
+        _GLOBAL_LOCK,
+        globals,
+        _GLOBAL_ATTR,
+        lambda: _GlobalTimerRegistry(
+            globals['__name__'],
+        ),
+    )
+
+    return check.isinstance(reg, _GlobalTimerRegistry)
+
+
+#
+
+
+@contextlib.contextmanager
+def global_timer_context(
+        globals: ta.MutableMapping[str, ta.Any],  # noqa
+        name: str,
+        **kwargs: ta.Any,
+) -> ta.Iterator[None]:
+    reg = _get_global_registry(globals)
+    timer = reg.get_timer(name, **kwargs)
+    with timer():
+        yield
+
+
+#
+
+
+class _GlobalTimerContextWrapped:
+    def __init__(
+            self,
+            fn: ta.Any,
+            timer: _GlobalTimer,
+    ) -> None:
+        super().__init__()
+
+        self._fn = fn
+        self._timer = timer
+
+        functools.update_wrapper(self, fn)
+
+    def __get__(self, instance, owner=None):
+        return self.__class__(
+            self._fn.__get__(instance, owner),
+            self._timer,
+        )
+
+    def __call__(self, *args, **kwargs):
+        with self._timer():
+            return self._fn(*args, **kwargs)
+
+
+def global_timer_wrap(
+        globals: ta.MutableMapping[str, ta.Any],  # noqa
+        name: str,
+        **kwargs: ta.Any,
+) -> ta.Callable[[T], T]:
+    reg = _get_global_registry(globals)
+    timer = reg.get_timer(name, **kwargs)
+
+    def inner(fn):
+        return _GlobalTimerContextWrapped(fn, timer)
+
+    return inner

omlish/inject/impl/injector.py

@@ -69,7 +69,7 @@ class InjectorImpl(Injector, lang.Final):
         self._bim = ec.binding_impl_map()
         self._ekbs = ec.eager_keys_by_scope()
         self._pls: tuple[ProvisionListener, ...] = tuple(
-            b.listener
+            b.listener  # type: ignore[attr-defined]
             for b in itertools.chain(
                 ec.elements_of_type(ProvisionListenerBinding),
                 (p._pls if p is not None else ()),  # noqa

omlish/inject/listeners.py

@@ -14,7 +14,7 @@ from .keys import Key
 ProvisionListener: ta.TypeAlias = ta.Callable[[
     Injector,
     Key,
-    Binding,
+    Binding | None,
     ta.Callable[[], ta.Any],
 ], ta.Callable[[], ta.Any]]
 

omlish/lang/__init__.py

@@ -142,6 +142,7 @@ from .contextmanagers import (  # noqa
     context_wrapped,
     default_lock,
     disposing,
+    double_check_setdefault,
     maybe_managing,
 )
 

omlish/lang/cached/function.py

@@ -415,6 +415,16 @@ class _DescriptorCachedFunction(_CachedFunction[T]):
 #
 
 
+@ta.overload
+def cached_function(fn: None = None, **kwargs: ta.Any) -> ta.Callable[[CallableT], CallableT]:
+    ...
+
+
+@ta.overload
+def cached_function(fn: CallableT, **kwargs: ta.Any) -> CallableT:
+    ...
+
+
 def cached_function(fn=None, **kwargs):  # noqa
     if fn is None:
         return functools.partial(cached_function, **kwargs)

omlish/lang/contextmanagers.py

@@ -13,6 +13,8 @@ import typing as ta
 
 
 T = ta.TypeVar('T')
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
 
 
 ##
@@ -286,3 +288,28 @@ class Timer:
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         self._end = self._clock()
+
+
+##
+
+
+def double_check_setdefault(
+        cm: ta.ContextManager,
+        dct: ta.MutableMapping[K, V],
+        k: K,
+        fn: ta.Callable[[], V],
+) -> V:
+    try:
+        return dct[k]
+    except KeyError:
+        pass
+
+    with cm:
+        try:
+            return dct[k]
+        except KeyError:
+            pass
+
+        v = fn()
+        dct[k] = v
+        return v

omlish/reflect/subst.py

@@ -1,3 +1,4 @@
+import abc
 import dataclasses as dc
 import types
 import typing as ta
@@ -22,6 +23,9 @@ else:
     cache = lang.proxy_import('.collections.cache', __package__)
 
 
+GenericBasesMap: ta.TypeAlias = ta.Mapping[Type, tuple[Type, ...]]
+
+
 ##
 
 
@@ -69,22 +73,35 @@ def replace_type_vars(
     return rec(ty)
 
 
+##
+
+
+_DEFAULT_SIMPLE_GENERIC_BASES: dict[Type, tuple[Type, ...]] = {}
+DEFAULT_SIMPLE_GENERIC_BASES: GenericBasesMap = _DEFAULT_SIMPLE_GENERIC_BASES
+
+
 class GenericSubstitution:
     def __init__(
             self,
             *,
             update_aliases: bool = False,
             cache_size: int = 0,  # FIXME: ta.Generic isn't weakrefable..
+            simple_generic_bases: GenericBasesMap | None = None,
     ) -> None:
         super().__init__()
 
         self._update_aliases = update_aliases
+        self._simple_generic_bases = simple_generic_bases
 
         if cache_size > 0:
             self.get_generic_bases = cache.cache(weak_keys=True, max_size=cache_size)(self.get_generic_bases)  # type: ignore  # noqa
             self.generic_mro = cache.cache(weak_keys=True, max_size=cache_size)(self.generic_mro)  # type: ignore
 
     def get_generic_bases(self, ty: Type) -> tuple[Type, ...]:
+        if (sgm := self._simple_generic_bases) is not None:
+            if (sgb := sgm.get(ty)) is not None:
+                return sgb
+
         if (cty := get_concrete_type(ty)) is not None:
             rpl = get_type_var_replacements(ty)
             ret: list[Type] = []
@@ -97,6 +114,7 @@ class GenericSubstitution:
                 rty = replace_type_vars(bty, rpl, update_aliases=self._update_aliases)
                 ret.append(rty)
             return tuple(ret)
+
         return ()
 
     def generic_mro(self, obj: ta.Any) -> list[Type]:
@@ -108,9 +126,32 @@ class GenericSubstitution:
         return [ty for ty in mro if get_concrete_type(ty) is not ta.Generic]
 
 
-DEFAULT_GENERIC_SUBSTITUTION = GenericSubstitution()
+DEFAULT_GENERIC_SUBSTITUTION = GenericSubstitution(
+    simple_generic_bases=DEFAULT_SIMPLE_GENERIC_BASES,
+)
 
 get_generic_bases = DEFAULT_GENERIC_SUBSTITUTION.get_generic_bases
 generic_mro = DEFAULT_GENERIC_SUBSTITUTION.generic_mro
 
-ALIAS_UPDATING_GENERIC_SUBSTITUTION = GenericSubstitution(update_aliases=True)
+ALIAS_UPDATING_GENERIC_SUBSTITUTION = GenericSubstitution(
+    update_aliases=True,
+    simple_generic_bases=DEFAULT_SIMPLE_GENERIC_BASES,
+)
+
+
+##
+
+
+_DEFAULT_SIMPLE_GENERIC_BASE_LIST: ta.Sequence[Type] = [
+    object,
+    abc.ABC,
+    lang.Abstract,
+    lang.Sealed,
+    lang.PackageSealed,
+    lang.Final,
+]
+
+_DEFAULT_SIMPLE_GENERIC_BASES.update({
+    b: get_generic_bases(b)
+    for b in _DEFAULT_SIMPLE_GENERIC_BASE_LIST
+})