omlish 0.0.0.dev286__tar.gz → 0.0.0.dev288__tar.gz

{omlish-0.0.0.dev286/omlish.egg-info → omlish-0.0.0.dev288}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev286
+Version: 0.0.0.dev288
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev286'
-__revision__ = '07fa507e06f16ab8f3ccba3d580382b07079b73e'
+__version__ = '0.0.0.dev288'
+__revision__ = 'e2dff59656486617fd3e4b01cd91263482b1dfa1'
 
 
 #

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/collections/persistent/treapmap.py

@@ -70,11 +70,11 @@ class TreapMap(PersistentMap[K, V]):
         return n.value
 
     def __iter__(self) -> ta.Iterator[tuple[K, V]]:
-        i = self.iterate()
+        i = self.items()
         while i.has_next():
             yield i.next()
 
-    def iterate(self) -> 'TreapMapIterator[K, V]':
+    def items(self) -> 'TreapMapIterator[K, V]':
         i = TreapMapIterator(
             _st=[],
             _n=self._n,
@@ -84,7 +84,7 @@ class TreapMap(PersistentMap[K, V]):
             i._n = n.left  # noqa
         return i
 
-    def iterate_from(self, k: K) -> 'TreapMapIterator[K, V]':
+    def items_from(self, k: K) -> 'TreapMapIterator[K, V]':
         lst = treap.place(self._n, (k, None), self._c)  # type: ignore
         i = TreapMapIterator(
             _st=lst,
@@ -92,7 +92,7 @@ class TreapMap(PersistentMap[K, V]):
         )
         return i
 
-    def reverse_iterate(self) -> 'TreapMapReverseIterator[K, V]':
+    def items_desc(self) -> 'TreapMapReverseIterator[K, V]':
         i = TreapMapReverseIterator(
             _st=[],
             _n=self._n,
@@ -102,7 +102,7 @@ class TreapMap(PersistentMap[K, V]):
             i._n = n.right  # noqa
         return i
 
-    def reverse_iterate_from(self, k: K) -> 'TreapMapReverseIterator[K, V]':
+    def items_from_desc(self, k: K) -> 'TreapMapReverseIterator[K, V]':
         lst = treap.place(self._n, (k, None), self._c, desc=True)  # type: ignore
         i = TreapMapReverseIterator(
             _st=lst,

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/collections/ranked.py

@@ -15,7 +15,10 @@ class RankedSeq(ta.Sequence[T]):
         super().__init__()
 
         self._lst = list(it)
-        self._ranks: ta.Mapping[T, int] = (IdentityKeyDict if identity else dict)((e, i) for i, e in enumerate(self._lst))  # noqa
+        self._ranks: ta.Mapping[T, int] = (
+            (IdentityKeyDict if identity else dict)
+            ((e, i) for i, e in enumerate(self._lst))
+        )
         if len(self._ranks) != len(self._lst):
             raise ValueError(f'{len(self._ranks)} != {len(self._lst)}')
 
@@ -51,7 +54,10 @@ class RankedSetSeq(ta.Sequence[ta.AbstractSet[T]]):
         super().__init__()
 
         self._lst = [(IdentitySet if identity else set)(e) for e in it]
-        self._ranks: ta.Mapping[T, int] = (IdentityKeyDict if identity else dict)((e, i) for i, es in enumerate(self._lst) for e in es)  # noqa
+        self._ranks: ta.Mapping[T, int] = (
+            (IdentityKeyDict if identity else dict)
+            ((e, i) for i, es in enumerate(self._lst) for e in es)
+        )
         if len(self._ranks) != sum(map(len, self._lst)):
             raise ValueError(f'{len(self._ranks)} != {sum(map(len, self._lst))}')
 

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/collections/sorted/skiplist.py

@@ -182,7 +182,7 @@ class SkipList(SortedCollection[T]):
             yield cur.value  # type: ignore
             cur = cur.next[0]
 
-    def riter(self, base: T | None = None) -> ta.Iterable[T]:
+    def iter_desc(self, base: T | None = None) -> ta.Iterable[T]:
         if base is not None:
             cur = self._find(base)
             while cur is not self._head and self._compare(base, cur.value) < 0:  # type: ignore

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/collections/sorted/sorted.py

@@ -51,7 +51,7 @@ class SortedCollection(lang.Abstract, ta.Collection[T]):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def riter(self, base: T | None = None) -> ta.Iterable[T]:
+    def iter_desc(self, base: T | None = None) -> ta.Iterable[T]:
         raise NotImplementedError
 
 
@@ -61,15 +61,15 @@ class SortedMapping(ta.Mapping[K, V]):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def ritems(self) -> ta.Iterator[tuple[K, V]]:
+    def items_desc(self) -> ta.Iterator[tuple[K, V]]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def itemsfrom(self, key: K) -> ta.Iterator[tuple[K, V]]:
+    def items_from(self, key: K) -> ta.Iterator[tuple[K, V]]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def ritemsfrom(self, key: K) -> ta.Iterator[tuple[K, V]]:
+    def items_from_desc(self, key: K) -> ta.Iterator[tuple[K, V]]:
         raise NotImplementedError
 
 
@@ -115,11 +115,11 @@ class SortedListDict(SortedMutableMapping[K, V]):
     def items(self) -> ta.Iterator[tuple[K, V]]:  # type: ignore
         yield from self._impl.iter()
 
-    def ritems(self) -> ta.Iterator[tuple[K, V]]:
-        yield from self._impl.riter()
+    def items_desc(self) -> ta.Iterator[tuple[K, V]]:
+        yield from self._impl.iter_desc()
 
-    def itemsfrom(self, key: K) -> ta.Iterator[tuple[K, V]]:
+    def items_from(self, key: K) -> ta.Iterator[tuple[K, V]]:
         yield from self._impl.iter((key, None))
 
-    def ritemsfrom(self, key: K) -> ta.Iterator[tuple[K, V]]:
-        yield from self._impl.riter((key, None))
+    def items_from_desc(self, key: K) -> ta.Iterator[tuple[K, V]]:
+        yield from self._impl.iter_desc((key, None))

omlish-0.0.0.dev288/omlish/configs/processing/__init__.py

@@ -0,0 +1,7 @@
+"""
+TODO:
+ - inline polymorph: 'ami: foo' -> 'image: {'ami': {'name': 'foo'}}
+ - parse duration and size settings, "512k" or "10 seconds"
+ - includes
+ - substitutions ("foo" : ${bar}, "foo" : Hello ${who})
+"""

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/dataclasses/api/fields/constructor.py

@@ -2,9 +2,11 @@ import collections
 import dataclasses as dc
 import typing as ta
 
+from .... import lang
 from ...specs import CoerceFn
 from ...specs import ReprFn
 from ...specs import ValidateFn
+from .metadata import _ExtraFieldParamsMetadata
 from .metadata import extra_field_params
 
 
@@ -29,14 +31,17 @@ def field(
         repr_fn: ReprFn | None = None,
         repr_priority: int | None = None,
 ) -> ta.Any:
-    efp = extra_field_params(
-        coerce=coerce,
-        validate=validate,
-        check_type=check_type,
-        override=override,
-        repr_fn=repr_fn,
-        repr_priority=repr_priority,
-    )
+    efp = extra_field_params(**{
+        **(metadata.get(_ExtraFieldParamsMetadata) or {} if metadata is not None else {}),
+        **lang.opt_kw(
+            coerce=coerce,
+            validate=validate,
+            check_type=check_type,
+            override=override,
+            repr_fn=repr_fn,
+            repr_priority=repr_priority,
+        ),
+    })
 
     md: ta.Any = metadata
     if md is None:

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/dataclasses/internals.py

@@ -75,9 +75,12 @@ class StdFieldType(enum.Enum):
     INIT_VAR = dc._FIELD_INITVAR  # type: ignore  # noqa
 
 
+STD_FIELD_TYPE_MAP: ta.Mapping[ta.Any, StdFieldType] = {v.value: v for v in StdFieldType}
+
+
 def std_field_type(f: dc.Field) -> StdFieldType:
     if (ft := getattr(f, '_field_type')) is not None:
-        return StdFieldType(ft)
+        return STD_FIELD_TYPE_MAP[ft]
     else:
         return StdFieldType.INSTANCE
 

omlish-0.0.0.dev288/omlish/dispatch/__init__.py

@@ -0,0 +1,12 @@
+from .dispatch import (  # noqa
+    Dispatcher,
+)
+
+from .functions import (  # noqa
+    function,
+)
+
+from .methods import (  # noqa
+    install_method,
+    method,
+)

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/dispatch/functions.py

@@ -6,6 +6,9 @@ from .dispatch import Dispatcher
 from .impls import get_impl_func_cls_set
 
 
+##
+
+
 # USE_EXTENSION = True
 USE_EXTENSION = False
 

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/dispatch/impls.py

@@ -5,8 +5,8 @@ TODO:
  - multidispatch? never solved..
   - just generic on tuple[A0, A1, ...]
 """
+import inspect
 import typing as ta
-import weakref
 
 from .. import c3
 from .. import check
@@ -19,15 +19,7 @@ T = ta.TypeVar('T')
 ##
 
 
-_IMPL_FUNC_CLS_SET_CACHE: ta.MutableMapping[ta.Callable, frozenset[type]] = weakref.WeakKeyDictionary()
-
-
-def get_impl_func_cls_set(func: ta.Callable) -> frozenset[type]:
-    try:
-        return _IMPL_FUNC_CLS_SET_CACHE[func]
-    except KeyError:
-        pass
-
+def get_impl_func_cls_set(func: ta.Callable, *, arg_offset: int = 0) -> frozenset[type]:
     ann = getattr(func, '__annotations__', {})
     if not ann:
         raise TypeError(f'Invalid impl func: {func!r}')
@@ -39,8 +31,11 @@ def get_impl_func_cls_set(func: ta.Callable) -> frozenset[type]:
             return check.isinstance(a, type)
 
     # Exclude 'return' to support difficult to handle return types - they are unimportant.
-    # TODO: only get hints for first arg - requires inspection, which requires chopping off `self`, which can be tricky.
-    _, cls = next(iter(rfl.get_filtered_type_hints(func, exclude=['return']).items()))
+    th_dct = rfl.get_filtered_type_hints(func, exclude=['return'])
+
+    ps = inspect.signature(func).parameters
+    p = list(ps.values())[arg_offset]
+    cls = th_dct[p.name]
 
     rty = rfl.type_(cls)
     if isinstance(rty, rfl.Union):
@@ -48,10 +43,12 @@ def get_impl_func_cls_set(func: ta.Callable) -> frozenset[type]:
     else:
         ret = frozenset([erase(rty)])
 
-    _IMPL_FUNC_CLS_SET_CACHE[func] = ret
     return ret
 
 
+##
+
+
 def find_impl(cls: type, registry: ta.Mapping[type, T]) -> T | None:
     mro = c3.compose_mro(cls, registry.keys())
 

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/dispatch/methods.py

@@ -18,14 +18,25 @@ from .impls import get_impl_func_cls_set
 T = ta.TypeVar('T')
 
 
+##
+
+
 class Method:
-    def __init__(self, func: ta.Callable) -> None:
+    def __init__(
+            self,
+            func: ta.Callable,
+            *,
+            installable: bool = False,
+    ) -> None:
+        super().__init__()
+
         if not callable(func) and not hasattr(func, '__get__'):  # type: ignore
             raise TypeError(f'{func!r} is not callable or a descriptor')
 
         self._func = func
+        self._installable = installable
 
-        self._impls: ta.MutableSet[ta.Callable] = weakref.WeakSet()
+        self._impls: ta.MutableMapping[ta.Callable, frozenset[type] | None] = weakref.WeakKeyDictionary()
 
         # bpo-45678: special-casing for classmethod/staticmethod in Python <=3.9, as functools.update_wrapper doesn't
         # work properly in singledispatchmethod.__get__ if it is applied to an unbound classmethod/staticmethod
@@ -48,6 +59,15 @@ class Method:
 
         self._dispatch_func_cache_remove = dispatch_func_cache_remove
 
+        self._owner: type | None = None
+        self._name: str | None = None
+
+    def __set_name__(self, owner, name):
+        if self._owner is None:
+            self._owner = owner
+        if self._name is None:
+            self._name = name
+
     def __repr__(self) -> str:
         return f'<{type(self).__module__}.{type(self).__qualname__}:{self._func} at 0x{id(self):x}>'
 
@@ -61,7 +81,7 @@ class Method:
         setattr(wrapper, '__isabstractmethod__', self._is_abstractmethod)  # noqa
         return wrapper
 
-    def register(self, impl: T) -> T:
+    def register(self, impl: T, cls_set: frozenset[type] | None = None) -> T:
         # bpo-39679: in Python <= 3.9, classmethods and staticmethods don't inherit __annotations__ of the wrapped
         # function (fixed in 3.10+ as a side-effect of bpo-43682) but we need that for annotation-derived
         # singledispatches. So we add that just-in-time here.
@@ -70,7 +90,7 @@ class Method:
 
         check.callable(impl)
         if impl not in self._impls:
-            self._impls.add(impl)  # type: ignore
+            self._impls[impl] = cls_set  # type: ignore
             self._dispatch_func_cache.clear()
 
         return impl
@@ -85,14 +105,23 @@ class Method:
                 hash(att)
             except TypeError:
                 continue
-            if att in self._impls:
-                try:
-                    ex_nam = seen[att]
-                except KeyError:
-                    pass
-                else:
-                    raise TypeError(f'Duplicate impl: {owner_cls} {instance_cls} {nam} {ex_nam}')
-                disp.register(nam, get_impl_func_cls_set(att))
+
+            if att not in self._impls:
+                continue
+            cls_set = self._impls[att]
+
+            if cls_set is None:
+                cls_set = get_impl_func_cls_set(att, arg_offset=1)
+                self._impls[att] = cls_set
+
+            try:
+                ex_nam = seen[att]
+            except KeyError:
+                pass
+            else:
+                raise TypeError(f'Duplicate impl: {owner_cls} {instance_cls} {nam} {ex_nam}')
+
+            disp.register(nam, cls_set)
 
         return disp
 
@@ -106,9 +135,11 @@ class Method:
         def __call__(self, *args, **kwargs):  # noqa
             if not args:
                 raise TypeError(f'{func_name} requires at least 1 positional argument')
+
             if (impl_att := dispatch(type_(args[0]))) is not None:
                 fn = getattr_(self, impl_att)
                 return fn(*args, **kwargs)
+
             return base_func.__get__(self)(*args, **kwargs)  # noqa
 
         self.update_wrapper(__call__)
@@ -148,5 +179,39 @@ class Method:
         return func.__get__(instance)(*args, **kwargs)  # noqa
 
 
-def method(func):  # noqa
-    return Method(func)
+def method(func=None, /, *, installable=False):  # noqa
+    kw = dict(installable=installable)
+    if func is None:
+        return functools.partial(Method, **kw)
+    return Method(func, **kw)
+
+
+def install_method(
+        mth: ta.Any,
+        *,
+        name: str | None = None,
+        on: type | None = None,
+) -> ta.Callable[[T], T]:
+    mth = check.isinstance(mth, Method)
+    if not mth._installable:  # noqa
+        raise TypeError(f'Method not installable: {mth}')
+
+    def inner(fn):
+        a = name
+        if a is None:
+            a = fn.__name__
+
+        owner: type = check.not_none(mth._owner)  # noqa
+        if on is None:
+            cls = owner
+        else:
+            cls = check.issubclass(on, owner)
+
+        check.arg(not hasattr(cls, a))
+        setattr(cls, a, fn)
+
+        mth.register(fn)
+
+        return fn
+
+    return inner

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/iterators/iterators.py

@@ -5,6 +5,9 @@ import typing as ta
 T = ta.TypeVar('T')
 
 
+##
+
+
 _MISSING = object()
 
 

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/iterators/recipes.py

@@ -9,6 +9,9 @@ import typing as ta
 T = ta.TypeVar('T')
 
 
+##
+
+
 def sliding_window(it: ta.Iterable[T], n: int) -> ta.Iterator[tuple[T, ...]]:
     # sliding_window('ABCDEFG', 4) -> ABCD BCDE CDEF DEFG
     iterator = iter(it)

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/iterators/tools.py

@@ -11,6 +11,9 @@ T = ta.TypeVar('T')
 U = ta.TypeVar('U')
 
 
+##
+
+
 def unzip(it: ta.Iterable[T], width: int | None = None) -> list:
     if width is None:
         if not isinstance(it, PeekIterator):

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/iterators/unique.py

@@ -7,6 +7,9 @@ from .. import lang
 T = ta.TypeVar('T')
 
 
+##
+
+
 @dc.dataclass()
 class UniqueStats:
     key: ta.Any

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/lang/__init__.py

@@ -1,11 +1,14 @@
 from .attrs import (  # noqa
     AttrOps,
+    AttributePresentError,
     DictAttrOps,
     STD_ATTR_OPS,
+    SetAttrIfPresent,
     StdAttrOps,
     TRANSIENT_ATTR_OPS,
     TransientAttrOps,
     TransientDict,
+    set_attr,
     transient_delattr,
     transient_getattr,
     transient_setattr,
@@ -130,6 +133,7 @@ from .functions import (  # noqa
     Args,
     VoidError,
     as_async,
+    call_with,
     coalesce,
     constant,
     finally_,

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/lang/attrs.py

@@ -1,8 +1,76 @@
 import abc
 import collections.abc
+import functools
 import typing as ta
 
 
+T = ta.TypeVar('T')
+
+
+##
+
+
+class AttributePresentError(Exception):
+    pass
+
+
+SetAttrIfPresent: ta.TypeAlias = ta.Literal['overwrite', 'leave', 'raise']
+
+
+_NO_SET_ATTR_VALUE = object()
+
+
+@ta.overload
+def set_attr(
+        obj: ta.Any,
+        name: str,
+        *,
+        if_present: SetAttrIfPresent = 'overwrite',
+) -> ta.Callable[[T], T]:
+    ...
+
+
+@ta.overload
+def set_attr(
+        obj: ta.Any,
+        name: str,
+        value: T,
+        *,
+        if_present: SetAttrIfPresent = 'overwrite',
+) -> T:
+    ...
+
+
+def set_attr(
+        obj,
+        name,
+        value=_NO_SET_ATTR_VALUE,
+        *,
+        if_present='overwrite',
+):
+    if value is _NO_SET_ATTR_VALUE:
+        return functools.partial(
+            set_attr,
+            obj,
+            name,
+            if_present=if_present,
+        )
+
+    if hasattr(obj, name):
+        if if_present == 'overwrite':
+            pass
+        elif if_present == 'leave':
+            return value
+        elif if_present == 'raise':
+            raise AttributePresentError(name)
+        else:
+            raise ValueError(if_present)
+
+    setattr(obj, name, value)
+
+    return value
+
+
 ##
 
 
@@ -24,7 +92,7 @@ class AttrOps(abc.ABC):
         raise NotImplementedError
 
 
-##
+#
 
 
 class StdAttrOps(AttrOps):
@@ -44,7 +112,7 @@ class StdAttrOps(AttrOps):
 STD_ATTR_OPS = StdAttrOps()
 
 
-##
+#
 
 
 class DictAttrOps(AttrOps):

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/lang/functions.py

@@ -22,7 +22,14 @@ def is_lambda(f: ta.Any) -> bool:
 ##
 
 
-def maybe_call(obj: ta.Any, att: str, *args, default: ta.Any = None, **kwargs) -> ta.Any:
+def call_with(fn: ta.Any, *args: ta.Any, **kwargs: ta.Any) -> ta.Callable[[T], T]:
+    def inner(obj):
+        fn(obj, *args, **kwargs)
+        return obj
+    return inner
+
+
+def maybe_call(obj: ta.Any, att: str, *args, default: ta.Any = None, **kwargs: ta.Any) -> ta.Any:
     try:
         fn = getattr(obj, att)
     except AttributeError:

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/metadata.py

@@ -125,7 +125,7 @@ class DecoratorObjectMetadata(ObjectMetadata, lang.Abstract):
             tts = tuple(object_metadata_target_types)
             for tt in tts:
                 check.issubclass(tt, _VALID_OBJECT_METADATA_TARGET_TYPES)
-            setattr(cls, '_OBJECT_METADATA_TARGET_TYPES', tts)
+            cls._OBJECT_METADATA_TARGET_TYPES = tts
 
     def __call__(self, obj: T) -> T:
         tgt: ta.Any = obj

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/omlish/text/templating.py

@@ -94,7 +94,7 @@ class MinjaTemplater(Templater):
 
 @dc.dataclass(frozen=True)
 class JinjaTemplater(Templater):
-    tmpl: jinja2.Template
+    tmpl: 'jinja2.Template'
 
     def render(self, ctx: Templater.Context) -> str:
         return self.tmpl.render(**(ctx.env or {}))
@@ -104,7 +104,7 @@ class JinjaTemplater(Templater):
             cls,
             src: str,
             *,
-            env: jinja2.Environment | None = None,
+            env: ta.Optional['jinja2.Environment'] = None,
             **kwargs: ta.Any,
     ) -> 'JinjaTemplater':
         if env is None:

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev286
+Version: 0.0.0.dev288
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev286 → omlish-0.0.0.dev288}/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.dev286'
+version = '0.0.0.dev288'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',

omlish-0.0.0.dev286/omlish/dispatch/__init__.py

@@ -1,3 +0,0 @@
-from .dispatch import Dispatcher  # noqa
-from .functions import function  # noqa
-from .methods import method  # noqa