omlish 0.0.0.dev248__py3-none-any.whl → 0.0.0.dev250__py3-none-any.whl

omlish/__about__.py

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

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/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/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/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.dist-info → omlish-0.0.0.dev250.dist-info}/METADATA

@@ -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.dist-info → omlish-0.0.0.dev250.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=x26AIwDzScUvnX-p4xlq6Zc5QYrAo0Vmgf1qHc1KL_M,8253
-omlish/__about__.py,sha256=vdUCdVH6QPJp23FjKOh9VC2Pxz8yofiz_tArVxvhOyU,3380
+omlish/__about__.py,sha256=LCIKYHw0FYdPvCdmhqyF7FaJsL17sOU3m3dX5HFBUbg,3380
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -400,7 +400,7 @@ omlish/iterators/iterators.py,sha256=iTQQwBE6Wzoy36dnbPIws17zbjE3zNN4KwVw4Fzh-gY
 omlish/iterators/recipes.py,sha256=53mkexitMhkwXQZbL6DrhpT0WePQ_56uXd5Jaw3DfzI,467
 omlish/iterators/tools.py,sha256=Pi4ybXytUXVZ3xwK89xpPImQfYYId9p1vIFQvVqVLqA,2551
 omlish/iterators/unique.py,sha256=0jAX3kwzVfRNhe0Tmh7kVP_Q2WBIn8POo_O-rgFV0rQ,1390
-omlish/lang/__init__.py,sha256=7UEkGV5eWdCQRSqWvr3QNOfLKjkzLkF_ngm6fK0SUTk,4700
+omlish/lang/__init__.py,sha256=TKxKq0L7Q34kdV0_UcxC81Umx64Uz_TPUgH6cy7Uzck,4892
 omlish/lang/attrs.py,sha256=fofCKN0X8TMu1yGqHpLpNLih9r9HWl3D3Vn3b6O791w,3891
 omlish/lang/clsdct.py,sha256=sJYadm-fwzti-gsi98knR5qQUxriBmOqQE_qz3RopNk,1743
 omlish/lang/cmp.py,sha256=5vbzWWbqdzDmNKAGL19z6ZfUKe5Ci49e-Oegf9f4BsE,1346
@@ -415,13 +415,14 @@ omlish/lang/imports.py,sha256=Gdl6xCF89xiMOE1yDmdvKWamLq8HX-XPianO58Jdpmw,9218
 omlish/lang/iterables.py,sha256=HOjcxOwyI5bBApDLsxRAGGhTTmw7fdZl2kEckxRVl-0,1994
 omlish/lang/maybes.py,sha256=dAgrUoAhCgyrHRqa73CkaGnpXwGc-o9n-NIThrNXnbU,3416
 omlish/lang/objects.py,sha256=65XsD7UtblRdNe2ID1-brn_QvRkJhBIk5nyZWcQNeqU,4574
+omlish/lang/params.py,sha256=AaUHI59qBLV7I-q1qPIEPTKGvgXzSRsmkNR2jTma5ZY,6688
 omlish/lang/resolving.py,sha256=OuN2mDTPNyBUbcrswtvFKtj4xgH4H4WglgqSKv3MTy0,1606
-omlish/lang/resources.py,sha256=N64KeVE-rYMxqBBRp91qzgVqpOVR2uX7k1WlS_bo5hM,2681
+omlish/lang/resources.py,sha256=WKkAddC3ctMK1bvGw-elGe8ZxAj2IaUTKVSu2nfgHTo,2839
 omlish/lang/strings.py,sha256=egdv8PxLNG40-5V93agP5j2rBUDIsahCx048zV7uEbU,4690
 omlish/lang/sys.py,sha256=UoZz_PJYVKLQAKqYxxn-LHz1okK_38I__maZgnXMcxU,406
 omlish/lang/typing.py,sha256=Zdad9Zv0sa-hIaUXPrzPidT7sDVpRcussAI7D-j-I1c,3296
 omlish/lang/cached/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/lang/cached/function.py,sha256=5pS3FCTxOradeMsrKg7JbXHsWhqdaa2C34apkXkwqqU,8785
+omlish/lang/cached/function.py,sha256=3AeTVfpzovMMWbnjFuT5mM7kT1dBuk7fa66FOJKikYw,9188
 omlish/lang/cached/property.py,sha256=kzbao_35PlszdK_9oJBWrMmFFlVK_Xhx7YczHhTJ6cc,2764
 omlish/lang/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/lang/classes/abstract.py,sha256=bIcuAetV_aChhpSURypmjjcqP07xi20uVYPKh1kvQNU,3710
@@ -734,9 +735,9 @@ omlish/text/mangle.py,sha256=kfzFLfvepH-chl1P89_mdc5vC4FSqyPA2aVtgzuB8IY,1133
 omlish/text/minja.py,sha256=jZC-fp3Xuhx48ppqsf2Sf1pHbC0t8XBB7UpUUoOk2Qw,5751
 omlish/text/parts.py,sha256=JkNZpyR2tv2CNcTaWJJhpQ9E4F0yPR8P_YfDbZfMtwQ,6182
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev248.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev248.dist-info/METADATA,sha256=2MDwQ1CC7YMd2LkHobPoRqjE_TqGmuPaic_MlQcnojI,4176
-omlish-0.0.0.dev248.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-omlish-0.0.0.dev248.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev248.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev248.dist-info/RECORD,,
+omlish-0.0.0.dev250.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev250.dist-info/METADATA,sha256=I94K5DI1DH2JEs5HA15SkuwlyDsnTF5PYIeSr5rKrGo,4176
+omlish-0.0.0.dev250.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+omlish-0.0.0.dev250.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev250.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev250.dist-info/RECORD,,