omlish 0.0.0.dev247__py3-none-any.whl → 0.0.0.dev249__py3-none-any.whl

omlish/lang/cached/function.py

@@ -1,5 +1,7 @@
 """
 TODO:
+ - !! reconcile A().f() with A.f(A())
+  - unbound descriptor *should* still hit instance cache
  - integrate / expose with collections.cache
  - weakrefs (selectable by arg)
  - more rigorous descriptor pickling
@@ -18,11 +20,18 @@ from ..contextmanagers import DefaultLockable
 from ..contextmanagers import default_lock
 from ..descriptors import unwrap_func
 from ..descriptors import unwrap_func_with_partials
+from ..params import KwargsParam
+from ..params import Param
+from ..params import ParamSeparator
+from ..params import ParamSpec
+from ..params import ValueParam
+from ..params import param_render
 
 
 P = ta.ParamSpec('P')
 T = ta.TypeVar('T')
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
+CacheKeyMaker: ta.TypeAlias = ta.Callable[..., tuple]
 
 
 ##
@@ -32,66 +41,100 @@ def _nullary_cache_key_maker():
     return ()
 
 
-def _simple_cache_key_maker(*args, **kwargs):
-    return (args, tuple(sorted(kwargs.items())))
+def _self_cache_key_maker(self):
+    return (self,)
 
 
-def _make_cache_key_maker(fn, *, simple=False, bound=False):
-    if simple:
-        return _simple_cache_key_maker
+_PRE_MADE_CACHE_KEY_MAKERS = [
+    _nullary_cache_key_maker,
+    _self_cache_key_maker,
+]
+
+
+_PRE_MADE_CACHE_KEY_MAKERS_BY_PARAM_SPEC: ta.Mapping[ParamSpec, CacheKeyMaker] = {
+    ParamSpec.of_signature(inspect.signature(fn)): fn  # type: ignore
+    for fn in _PRE_MADE_CACHE_KEY_MAKERS
+}
+
+
+##
 
-    fn, partials = unwrap_func_with_partials(fn)
 
+def _make_unwrapped_cache_key_maker(
+        fn: ta.Callable,
+        *,
+        bound: bool = False,
+) -> CacheKeyMaker:
     if inspect.isgeneratorfunction(fn) or inspect.iscoroutinefunction(fn):
         raise TypeError(fn)
 
-    sig = inspect.signature(fn)
-    sig_params = list(sig.parameters.values())[1 if bound else 0:]
-    if not sig_params:
+    ps = ParamSpec.of_signature(
+        inspect.signature(fn),
+        offset=1 if bound else 0,
+        strip_annotations=True,
+    )
+
+    if not len(ps):
         return _nullary_cache_key_maker
 
-    ns = {}
+    if not ps.has_defaults:
+        try:
+            return _PRE_MADE_CACHE_KEY_MAKERS_BY_PARAM_SPEC[ps]
+        except KeyError:
+            pass
+
+    builtin_pfx = '__cache_key_maker__'
+    ns = {
+        (builtin_tuple := builtin_pfx + 'tuple'): tuple,
+        (builtin_sorted := builtin_pfx + 'sorted'): sorted,
+    }
+
     src_params = []
     src_vals = []
     kwargs_name = None
-    render_pos_only_separator = False
-    render_kw_only_separator = True
-    for p in sig_params:
-        formatted = p.name
-        if p.default is not inspect.Parameter.empty:
+    for p in ps:
+        if isinstance(p, ParamSeparator):
+            src_params.append(p.value)
+            continue
+
+        if not isinstance(p, Param):
+            raise TypeError(p)
+
+        if isinstance(p, ValueParam) and p.default.present:
             ns[p.name] = p.default
-            formatted = f'{formatted}={formatted}'
-        kind = p.kind
-        if kind == inspect.Parameter.VAR_POSITIONAL:
-            formatted = '*' + formatted
-        elif kind == inspect.Parameter.VAR_KEYWORD:
-            formatted = '**' + formatted
-        if kind == inspect.Parameter.POSITIONAL_ONLY:
-            render_pos_only_separator = True
-        elif render_pos_only_separator:
-            src_params.append('/')
-            render_pos_only_separator = False
-        if kind == inspect.Parameter.VAR_POSITIONAL:
-            render_kw_only_separator = False
-        elif kind == inspect.Parameter.KEYWORD_ONLY and render_kw_only_separator:
-            src_params.append('*')
-            render_kw_only_separator = False
-        src_params.append(formatted)
-        if kind == inspect.Parameter.VAR_KEYWORD:
+
+        src_params.append(param_render(
+            p,
+            render_default=lambda _: p.name,  # noqa
+        ))
+
+        if isinstance(p, KwargsParam):
             kwargs_name = p.name
         else:
             src_vals.append(p.name)
-    if render_pos_only_separator:
-        src_params.append('/')
 
-    kwa = f', __builtins__.tuple(__builtins__.sorted({kwargs_name}.items()))' if kwargs_name else ''
+    if kwargs_name is not None:
+        src_vals.append(f'{builtin_tuple}({builtin_sorted}({kwargs_name}.items()))')
+
     rendered = (
         f'def __func__({", ".join(src_params)}):\n'
-        f'    return ({", ".join(src_vals)}{kwa})\n'
+        f'    return ({", ".join(src_vals)}{"," if len(src_vals) == 1 else ""})\n'
     )
     exec(rendered, ns)
 
-    kfn = ns['__func__']
+    kfn: CacheKeyMaker = ns['__func__']  # type: ignore[assignment]
+    return kfn
+
+
+def _make_cache_key_maker(
+        fn: ta.Any,
+        *,
+        bound: bool = False,
+):
+    fn, partials = unwrap_func_with_partials(fn)
+
+    kfn = _make_unwrapped_cache_key_maker(fn, bound=bound)
+
     for part in partials[::-1]:
         kfn = functools.partial(kfn, *part.args, **part.keywords)
 
@@ -105,7 +148,6 @@ class _CachedFunction(ta.Generic[T], Abstract):
     @dc.dataclass(frozen=True)
     class Opts:
         map_maker: ta.Callable[[], ta.MutableMapping] = dict
-        simple_key: bool = False
         lock: DefaultLockable = None
         transient: bool = False
 
@@ -122,7 +164,7 @@ class _CachedFunction(ta.Generic[T], Abstract):
 
         self._fn = (fn,)
         self._opts = opts
-        self._key_maker = key_maker if key_maker is not None else _make_cache_key_maker(fn, simple=opts.simple_key)
+        self._key_maker = key_maker if key_maker is not None else _make_cache_key_maker(fn)
 
         self._lock = default_lock(opts.lock, False)() if opts.lock is not None else None
         self._values = values if values is not None else opts.map_maker()
@@ -278,7 +320,7 @@ class _DescriptorCachedFunction(_CachedFunction[T]):
         name = self._name
         bound_fn = fn.__get__(instance, owner)
         if self._bound_key_maker is None:
-            self._bound_key_maker = _make_cache_key_maker(fn, simple=self._opts.simple_key, bound=True)
+            self._bound_key_maker = _make_cache_key_maker(fn, bound=True)
 
         bound = self.__class__(
             fn,

omlish/lang/collections.py

@@ -48,3 +48,39 @@ def merge_dicts(
             out[k] = v
 
     return out
+
+
+##
+
+
+class _EmptyMap(ta.Mapping[K, V]):
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
+    def __new__(cls, *args, **kwargs):
+        if args or kwargs:
+            raise TypeError
+        return _EMPTY_MAP
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}()'
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def __getitem__(self, k: K) -> V:
+        raise KeyError
+
+    def __len__(self) -> int:
+        return 0
+
+    def __iter__(self) -> ta.Iterator[K]:
+        return
+        yield  # noqa
+
+
+_EMPTY_MAP = object.__new__(_EmptyMap)
+
+
+def empty_map() -> ta.Mapping[K, V]:
+    return _EMPTY_MAP

omlish/lang/descriptors.py

@@ -204,7 +204,6 @@ class AccessForbiddenError(Exception):
 
 
 class AccessForbiddenDescriptor:
-
     def __init__(self, name: str | None = None) -> None:
         super().__init__()
 

omlish/lang/params.py

@@ -0,0 +1,261 @@
+"""
+TODO:
+ - check validity
+"""
+import dataclasses as dc
+import enum
+import inspect
+import typing as ta
+
+from .classes.abstract import Abstract
+from .classes.restrict import Final
+from .classes.restrict import Sealed
+from .maybes import Maybe
+from .maybes import empty
+from .maybes import just
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Param(Sealed, Abstract):
+    name: str
+
+    prefix: ta.ClassVar[str] = ''
+
+    @property
+    def name_with_prefix(self) -> str:
+        return f'{self.prefix}{self.name}'
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class VariadicParam(Param, Abstract):
+    annotation: Maybe = empty()
+
+
+@dc.dataclass(frozen=True)
+class ArgsParam(VariadicParam, Final):
+    prefix: ta.ClassVar[str] = '*'
+
+
+@dc.dataclass(frozen=True)
+class KwargsParam(VariadicParam, Final):
+    prefix: ta.ClassVar[str] = '**'
+
+
+#
+
+
+@dc.dataclass(frozen=True, unsafe_hash=True)
+class ValueParam(Param):
+    default: Maybe = empty()
+    annotation: Maybe = empty()
+
+
+@dc.dataclass(frozen=True, unsafe_hash=True)
+class PosOnlyParam(ValueParam, Final):
+    pass
+
+
+@dc.dataclass(frozen=True, unsafe_hash=True)
+class KwOnlyParam(ValueParam, Final):
+    pass
+
+
+#
+
+
+class ParamSeparator(enum.Enum):
+    POS_ONLY = '/'
+    KW_ONLY = '*'
+
+
+##
+
+
+def _inspect_empty_to_maybe(o: T) -> Maybe[T]:
+    if o is inspect.Parameter.empty:
+        return empty()
+    else:
+        return just(o)
+
+
+class ParamSpec(ta.Sequence[Param], Final):
+    def __init__(self, *ps: Param) -> None:
+        super().__init__()
+
+        self._ps = ps
+
+        self._hash: int | None = None
+
+        self._has_defaults: bool | None = None
+        self._has_annotations: bool | None = None
+
+        self._with_seps: tuple[Param | ParamSeparator, ...] | None = None
+
+    #
+
+    @classmethod
+    def of_signature(
+            cls,
+            sig: inspect.Signature,
+            *,
+            offset: int = 0,
+            strip_defaults: bool = False,
+            strip_annotations: bool = False,
+    ) -> 'ParamSpec':
+        ps: list[Param] = []
+
+        ip: inspect.Parameter
+        for i, ip in enumerate(sig.parameters.values()):
+            if i < offset:
+                continue
+
+            dfl = _inspect_empty_to_maybe(ip.default) if not strip_defaults else empty()
+            ann = _inspect_empty_to_maybe(ip.annotation) if not strip_annotations else empty()
+
+            if ip.kind == inspect.Parameter.POSITIONAL_ONLY:
+                ps.append(PosOnlyParam(ip.name, dfl, ann))
+
+            elif ip.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD:
+                ps.append(ValueParam(ip.name, dfl, ann))
+
+            elif ip.kind == inspect.Parameter.VAR_POSITIONAL:
+                ps.append(ArgsParam(ip.name))
+
+            elif ip.kind == inspect.Parameter.VAR_KEYWORD:
+                ps.append(KwargsParam(ip.name))
+
+            elif ip.kind == inspect.Parameter.KEYWORD_ONLY:
+                ps.append(KwOnlyParam(ip.name, dfl, ann))
+
+            else:
+                raise ValueError(ip.kind)
+
+        return cls(*ps)
+
+    #
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({", ".join(map(repr, self._ps))})'
+
+    def __hash__(self) -> int:
+        if (h := self._hash) is not None:
+            return h
+        self._hash = h = hash(self._ps)
+        return h
+
+    def __eq__(self, other: object) -> bool:
+        if type(other) is not ParamSpec:
+            raise TypeError(other)
+        return self._ps == other._ps  # noqa
+
+    #
+
+    @property
+    def has_defaults(self) -> bool:
+        if (hd := self._has_defaults) is not None:
+            return hd
+        self._has_defaults = hd = any(
+            isinstance(p, ValueParam) and p.default.present
+            for p in self._ps
+        )
+        return hd
+
+    @property
+    def has_annotations(self) -> bool:
+        if (ha := self._has_defaults) is not None:
+            return ha
+        self._has_annotations = ha = any(
+            isinstance(p, (VariadicParam, ValueParam)) and p.annotation.present
+            for p in self._ps
+        )
+        return ha
+
+    #
+
+    @property
+    def with_seps(self) -> ta.Sequence[Param | ParamSeparator]:
+        if (ws := self._with_seps) is not None:
+            return ws
+
+        l: list[Param | ParamSeparator] = []
+        needs_pos_only = False
+        seen_kw_only = False
+        for p in self._ps:
+            if isinstance(p, PosOnlyParam):
+                needs_pos_only = True
+            elif needs_pos_only:
+                l.append(ParamSeparator.POS_ONLY)
+                needs_pos_only = False
+
+            if isinstance(p, KwOnlyParam) and not seen_kw_only:
+                l.append(ParamSeparator.KW_ONLY)
+                seen_kw_only = True
+            elif isinstance(p, KwargsParam):
+                seen_kw_only = True
+
+            l.append(p)
+
+        self._with_seps = ws = tuple(l)
+        return ws
+
+    #
+
+    @ta.overload
+    def __getitem__(self, index: int) -> Param: ...
+
+    @ta.overload
+    def __getitem__(self, index: slice) -> ta.Sequence[Param]: ...
+
+    def __getitem__(self, index):
+        return self._ps[index]
+
+    def __len__(self) -> int:
+        return len(self._ps)
+
+
+##
+
+
+def param_render(
+        p: Param | ParamSeparator,
+        *,
+        render_default: ta.Callable[[ta.Any], str] | None = None,
+        render_annotation: ta.Callable[[ta.Any], str] | None = None,
+) -> str:
+    if isinstance(p, Param):
+        dfl_s: str | None = None
+        if isinstance(p, ValueParam) and p.default.present:
+            if render_default is None:
+                raise ValueError(f'Param {p.name} has a default but no default renderer provided')
+            dfl_s = render_default(p.default.must())
+
+        ann_s: str | None = None
+        if isinstance(p, (VariadicParam, ValueParam)) and p.annotation.present:
+            if render_annotation is None:
+                raise ValueError(f'Param {p.name} has an annotation but no annotation renderer provided')
+            ann_s = render_annotation(p.annotation.must())
+
+        if ann_s is not None:
+            if dfl_s is not None:
+                return f'{p.name_with_prefix}: {ann_s} = {dfl_s}'
+            else:
+                return f'{p.name_with_prefix}: {ann_s}'
+        elif dfl_s is not None:
+            return f'{p.name_with_prefix}={dfl_s}'
+        else:
+            return p.name_with_prefix
+
+    elif isinstance(p, ParamSeparator):
+        return p.value
+
+    else:
+        raise TypeError(p)

omlish/lifecycles/base.py

@@ -9,7 +9,6 @@ LifecycleCallback: ta.TypeAlias = ta.Callable[[LifecycleT], None]
 
 
 class Lifecycle:
-
     def lifecycle_construct(self) -> None:
         pass
 

omlish/lifecycles/contextmanagers.py

@@ -28,7 +28,6 @@ class ContextManagerLifecycle(Lifecycle, lang.Final, ta.Generic[ContextManagerT]
 
 
 class LifecycleContextManager(ta.Generic[LifecycleT]):
-
     def __init__(self, lifecycle: LifecycleT) -> None:
         super().__init__()
         self._lifecycle = lifecycle

omlish/lifecycles/controller.py

@@ -14,7 +14,6 @@ LifecycleT = ta.TypeVar('LifecycleT', bound='Lifecycle')
 
 
 class LifecycleListener(ta.Generic[LifecycleT]):
-
     def on_starting(self, obj: LifecycleT) -> None:
         pass
 
@@ -29,7 +28,6 @@ class LifecycleListener(ta.Generic[LifecycleT]):
 
 
 class LifecycleController(Lifecycle, ta.Generic[LifecycleT]):
-
     def __init__(
             self,
             lifecycle: LifecycleT,

omlish/lifecycles/manager.py

@@ -13,7 +13,6 @@ from .states import LifecycleStates
 
 
 class LifecycleManager(AbstractLifecycle):
-
     @dc.dataclass(frozen=True)
     class Entry(lang.Final):
         controller: LifecycleController

omlish/marshal/trivial/any.py

@@ -11,7 +11,6 @@ from ..values import Value
 
 
 class AnyMarshalerUnmarshaler(Marshaler, Unmarshaler):
-
     def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
         return ctx.make(type(o)).marshal(ctx, o)
 

omlish/math/bits.py

@@ -44,7 +44,6 @@ def _gen_tuple_proxy_method(name):
 
 
 class FixedWidthInt(int):
-
     BITS: ta.ClassVar[int]
     SIGNED: ta.ClassVar[bool]
 

omlish/math/stats.py

@@ -234,7 +234,6 @@ class Stats(ta.Sequence[float]):
 
 
 class SamplingHistogram:
-
     @dc.dataclass(frozen=True)
     class Entry:
         value: float

omlish/term/codes.py

@@ -27,7 +27,6 @@ def strip_ansi_codes(s: str) -> str:
 
 
 class ControlSequence:
-
     def __init__(self, fn: ta.Callable[..., str], desc: str) -> None:
         super().__init__()
         self._fn = fn

omlish/testing/pytest/plugins/logging.py

@@ -4,7 +4,6 @@ from ._registry import register
 
 @register
 class LoggingPlugin:
-
     def pytest_addoption(self, parser):
         parser.addoption('--log', action='store', help='Configures logging with given log level')
 

omlish/testing/pytest/plugins/pydevd.py

@@ -4,7 +4,6 @@ from ._registry import register
 
 @register
 class PydevdPlugin:
-
     def pytest_addoption(self, parser):
         parser.addoption('--no-pydevd', action='store_true', default=False, help='Disables pydevd debugging')
 

omlish/testing/pytest/plugins/repeat.py

@@ -6,7 +6,6 @@ PARAM_NAME = '__repeat'
 
 @register
 class RepeatPlugin:
-
     def pytest_addoption(self, parser):
         parser.addoption('--repeat', action='store', type=int, help='Number of times to repeat each test')
 

omlish/testing/pytest/plugins/skips.py

@@ -10,7 +10,6 @@ from ._registry import register
 
 @register
 class SkipsPlugin:
-
     def pytest_collection_modifyitems(self, session, items):
         dct: dict[str, set[str]] = {}
         for arg in session.config.args:

omlish/testing/pytest/plugins/spacing.py

@@ -3,7 +3,6 @@ from ._registry import register
 
 @register
 class SpacingPlugin:
-
     def pytest_addoption(self, parser):
         parser.addoption('--newlines-before', action='store', type=int, help='Adds newlines before tests')
         parser.addoption('--newlines-after', action='store', type=int, help='Adds newlines after tests')

omlish/testing/pytest/plugins/switches.py

@@ -75,7 +75,6 @@ def get_specified_switches(obj: Configable) -> ta.Mapping[str, SwitchState]:
 
 @register
 class SwitchesPlugin:
-
     def pytest_configure(self, config):
         for sw in SWITCH_ATTRS:
             config.addinivalue_line('markers', f'{sw}: mark test as {sw}')

omlish/text/delimit.py

@@ -7,7 +7,6 @@ import typing as ta
 
 
 class DelimitedEscaping:
-
     def __init__(
             self,
             delimit_char: str,

{omlish-0.0.0.dev247.dist-info → omlish-0.0.0.dev249.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev247
+Version: 0.0.0.dev249
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause