omlish 0.0.0.dev248__tar.gz → 0.0.0.dev250__tar.gz

{omlish-0.0.0.dev248/omlish.egg-info → omlish-0.0.0.dev250}/PKG-INFO

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

{omlish-0.0.0.dev248 → omlish-0.0.0.dev250}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev248'
-__revision__ = 'c1cc77db1e3c02c65fabdb24e9696526d61559e3'
+__version__ = '0.0.0.dev250'
+__revision__ = '0e6e1316b474c6f882784e2474e809a478c54732'
 
 
 #

{omlish-0.0.0.dev248 → omlish-0.0.0.dev250}/omlish/lang/__init__.py

@@ -209,6 +209,19 @@ from .objects import (  # noqa
     super_meta,
 )
 
+from .params import (  # noqa
+    ArgsParam,
+    KwOnlyParam,
+    KwargsParam,
+    Param,
+    ParamSeparator,
+    ParamSpec,
+    PosOnlyParam,
+    ValParam,
+    VarParam,
+    param_render,
+)
+
 from .resolving import (  # noqa
     Resolvable,
     ResolvableClassNameError,

{omlish-0.0.0.dev248 → omlish-0.0.0.dev250}/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 ValParam
+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.inspect(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.inspect(
+        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, ValParam) 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-0.0.0.dev250/omlish/lang/params.py

@@ -0,0 +1,273 @@
+"""
+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, unsafe_hash=True)
+class Param(Sealed, Abstract):
+    name: str
+
+    annotation: Maybe = empty()
+
+    prefix: ta.ClassVar[str] = ''
+
+    @property
+    def name_with_prefix(self) -> str:
+        return f'{self.prefix}{self.name}'
+
+
+#
+
+
+@dc.dataclass(frozen=True, unsafe_hash=True)
+class VarParam(Param, Abstract):
+    pass
+
+
+@dc.dataclass(frozen=True, unsafe_hash=True)
+class ArgsParam(VarParam, Final):
+    prefix: ta.ClassVar[str] = '*'
+
+
+@dc.dataclass(frozen=True, unsafe_hash=True)
+class KwargsParam(VarParam, Final):
+    prefix: ta.ClassVar[str] = '**'
+
+
+#
+
+
+@dc.dataclass(frozen=True, unsafe_hash=True)
+class ValParam(Param):
+    default: Maybe = empty()
+
+
+@dc.dataclass(frozen=True, unsafe_hash=True)
+class PosOnlyParam(ValParam, Final):
+    pass
+
+
+@dc.dataclass(frozen=True, unsafe_hash=True)
+class KwOnlyParam(ValParam, 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_annotations: bool | None = None
+        self._has_defaults: bool | None = None
+
+        self._with_seps: tuple[Param | ParamSeparator, ...] | None = None
+
+    #
+
+    @classmethod
+    def of_signature(
+            cls,
+            sig: inspect.Signature,
+            *,
+            offset: int = 0,
+            strip_annotations: bool = False,
+            strip_defaults: bool = False,
+    ) -> 'ParamSpec':
+        ps: list[Param] = []
+
+        ip: inspect.Parameter
+        for i, ip in enumerate(sig.parameters.values()):
+            if i < offset:
+                continue
+
+            ann = _inspect_empty_to_maybe(ip.annotation) if not strip_annotations else empty()
+            dfl = _inspect_empty_to_maybe(ip.default) if not strip_defaults else empty()
+
+            if ip.kind == inspect.Parameter.POSITIONAL_ONLY:
+                ps.append(PosOnlyParam(ip.name, ann, dfl))
+
+            elif ip.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD:
+                ps.append(ValParam(ip.name, ann, dfl))
+
+            elif ip.kind == inspect.Parameter.VAR_POSITIONAL:
+                ps.append(ArgsParam(ip.name, ann))
+
+            elif ip.kind == inspect.Parameter.KEYWORD_ONLY:
+                ps.append(KwOnlyParam(ip.name, ann, dfl))
+
+            elif ip.kind == inspect.Parameter.VAR_KEYWORD:
+                ps.append(KwargsParam(ip.name, ann))
+
+            else:
+                raise ValueError(ip.kind)
+
+        return cls(*ps)
+
+    @classmethod
+    def inspect(
+            cls,
+            obj: ta.Any,
+            **kwargs: ta.Any,
+    ) -> 'ParamSpec':
+        return cls.of_signature(
+            inspect.signature(obj),
+            **kwargs,
+        )
+
+    #
+
+    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_annotations(self) -> bool:
+        if (ha := self._has_annotations) is not None:
+            return ha
+        self._has_annotations = ha = any(
+            isinstance(p, (VarParam, ValParam)) and p.annotation.present
+            for p in self._ps
+        )
+        return ha
+
+    @property
+    def has_defaults(self) -> bool:
+        if (hd := self._has_defaults) is not None:
+            return hd
+        self._has_defaults = hd = any(
+            isinstance(p, ValParam) and p.default.present
+            for p in self._ps
+        )
+        return hd
+
+    #
+
+    @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_annotation: ta.Callable[[ta.Any], str] | None = None,
+        render_default: ta.Callable[[ta.Any], str] | None = None,
+) -> str:
+    if isinstance(p, Param):
+        dfl_s: str | None = None
+        ann_s: str | None = None
+        if isinstance(p, (VarParam, ValParam)) 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 isinstance(p, ValParam) 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())
+
+        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-0.0.0.dev248 → omlish-0.0.0.dev250}/omlish/lang/resources.py

@@ -1,9 +1,19 @@
 import dataclasses as dc
 import functools
-import importlib.resources
 import os.path
 import typing as ta
 
+from .imports import proxy_import
+
+
+if ta.TYPE_CHECKING:
+    import importlib.resources as importlib_resources
+else:
+    importlib_resources = proxy_import('importlib.resources')
+
+
+##
+
 
 @dc.dataclass(frozen=True)
 class ReadableResource:
@@ -18,7 +28,7 @@ class ReadableResource:
 def get_package_resources(anchor: str) -> ta.Mapping[str, ReadableResource]:
     lst: list[ReadableResource] = []
 
-    for pf in importlib.resources.files(anchor).iterdir():
+    for pf in importlib_resources.files(anchor).iterdir():
         lst.append(ReadableResource(
             name=pf.name,
             is_file=pf.is_file(),
@@ -65,7 +75,7 @@ def get_relative_resources(
         if num_up:
             pkg_parts = pkg_parts[:-num_up]
         anchor = '.'.join([*pkg_parts, *path_parts])
-        for pf in importlib.resources.files(anchor).iterdir():
+        for pf in importlib_resources.files(anchor).iterdir():
             lst.append(ReadableResource(
                 name=pf.name,
                 is_file=pf.is_file(),

{omlish-0.0.0.dev248 → omlish-0.0.0.dev250/omlish.egg-info}/PKG-INFO

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

{omlish-0.0.0.dev248 → omlish-0.0.0.dev250}/omlish.egg-info/SOURCES.txt

@@ -425,6 +425,7 @@ omlish/lang/imports.py
 omlish/lang/iterables.py
 omlish/lang/maybes.py
 omlish/lang/objects.py
+omlish/lang/params.py
 omlish/lang/resolving.py
 omlish/lang/resources.py
 omlish/lang/strings.py

{omlish-0.0.0.dev248 → omlish-0.0.0.dev250}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev248'
+version = '0.0.0.dev250'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',