omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/lite/attrops.py

@@ -0,0 +1,415 @@
+# ruff: noqa: UP006 UP007 UP045
+# @omlish-lite
+"""
+TODO:
+ - dotted paths!
+ - per-attr repr transform / filter
+ - __ne__ ? cases where it still matters
+ - ordering ?
+ - repr_filter: ta.Union[ta.Callable[[ta.Any], ta.Optional[str]], ta.Literal['not_none', 'truthy']]] ?
+  - unify repr/repr_fn/repr_filter
+"""
+import types  # noqa
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@ta.final
+class AttrOps(ta.Generic[T]):
+    @ta.final
+    class Attr:
+        def __init__(
+                self,
+                name: str,
+                *,
+                display: ta.Optional[str] = None,
+
+                repr: bool = True,  # noqa
+                repr_fn: ta.Optional[ta.Callable[[ta.Any], ta.Optional[str]]] = None,
+
+                hash: bool = True,  # noqa
+                eq: bool = True,
+        ) -> None:
+            if '.' in name:
+                raise NotImplementedError('Dotted paths not yet supported')
+            if not name.isidentifier() or name.startswith('__'):
+                raise AttributeError(f'Invalid attr: {name!r}')
+            self._name = name
+
+            if display is None:
+                display = name[1:] if name.startswith('_') and len(name) > 1 else name
+            self._display = display
+
+            self._repr = repr
+            self._repr_fn = repr_fn
+
+            self._hash = hash
+            self._eq = eq
+
+        @classmethod
+        def of(
+                cls,
+                o: ta.Union[
+                    'AttrOps.Attr',
+                    str,
+                    ta.Tuple[str, ta.Union[str, ta.Mapping[str, ta.Any]]],
+                    ta.Mapping[str, ta.Any],
+                ],
+        ) -> 'AttrOps.Attr':
+            if isinstance(o, AttrOps.Attr):
+                return o
+            elif isinstance(o, str):
+                return cls(o)
+            elif isinstance(o, tuple):
+                name, x = o
+                kw: ta.Mapping[str, ta.Any]
+                if isinstance(x, str):
+                    kw = dict(display=x)
+                elif isinstance(x, ta.Mapping):
+                    kw = x
+                else:
+                    raise TypeError(x)
+                return cls(name, **kw)
+            elif isinstance(o, ta.Mapping):
+                return cls(**o)
+            else:
+                raise TypeError(o)
+
+        @property
+        def name(self) -> str:
+            return self._name
+
+        @property
+        def display(self) -> str:
+            return self._display
+
+        @property
+        def hash(self) -> bool:
+            return self._hash
+
+        @property
+        def eq(self) -> bool:
+            return self._eq
+
+    @staticmethod
+    def opt_repr(o: ta.Any) -> ta.Optional[str]:
+        return repr(o) if o is not None else None
+
+    @staticmethod
+    def truthy_repr(o: ta.Any) -> ta.Optional[str]:
+        return repr(o) if o else None
+
+    #
+
+    @ta.overload
+    def __init__(
+            self,
+            *attrs: ta.Sequence[ta.Union[
+                str,
+                ta.Tuple[str, ta.Union[str, ta.Mapping[str, ta.Any]]],
+                ta.Mapping[str, ta.Any],
+                Attr,
+            ]],
+
+            with_module: bool = False,
+            use_qualname: bool = False,
+            with_id: bool = False,
+            terse: bool = False,
+            repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = None,
+            recursive: bool = False,
+
+            cache_hash: ta.Union[bool, str] = False,
+            subtypes_eq: bool = False,
+    ) -> None:
+        ...
+
+    @ta.overload
+    def __init__(
+            self,
+            attrs_fn: ta.Callable[[T], ta.Tuple[ta.Union[
+                ta.Any,
+                ta.Tuple[ta.Any, ta.Union[str, ta.Mapping[str, ta.Any]]],
+                Attr,
+            ], ...]],
+            /,
+            *,
+
+            with_module: bool = False,
+            use_qualname: bool = False,
+            with_id: bool = False,
+            terse: bool = False,
+            repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = None,
+            recursive: bool = False,
+
+            cache_hash: ta.Union[bool, str] = False,
+            subtypes_eq: bool = False,
+    ) -> None:
+        ...
+
+    def __init__(
+            self,
+            *args,
+
+            with_module=False,
+            use_qualname=False,
+            with_id=False,
+            terse=False,
+            repr_filter=None,
+            recursive=False,
+
+            cache_hash=False,
+            subtypes_eq=False,
+    ) -> None:
+        if args and len(args) == 1 and callable(args[0]):
+            self._attrs: ta.Sequence[AttrOps.Attr] = self._capture_attrs(args[0])
+        else:
+            self._attrs = list(map(AttrOps.Attr.of, args))
+
+        self._with_module: bool = with_module
+        self._use_qualname: bool = use_qualname
+        self._with_id: bool = with_id
+        self._terse: bool = terse
+        self._repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = repr_filter
+        self._recursive: bool = recursive
+
+        self._cache_hash: ta.Union[bool, str] = cache_hash
+        self._subtypes_eq: bool = subtypes_eq
+
+    @property
+    def attrs(self) -> ta.Sequence[Attr]:
+        return self._attrs
+
+    #
+
+    @ta.final
+    class _AttrCapturer:
+        def __init__(self, fn):
+            self.__fn = fn
+
+        def __getattr__(self, attr):
+            return self.__fn(self, attr)
+
+    @classmethod
+    def _capture_attrs(cls, fn: ta.Callable) -> ta.Sequence[Attr]:
+        def access(parent, attr):
+            dct[(ret := cls._AttrCapturer(access))] = (parent, attr)
+            return ret
+
+        dct: dict = {}
+        raw = fn(root := cls._AttrCapturer(access))
+
+        def rec(cap):  # noqa
+            if cap is root:
+                return
+            parent, attr = dct[cap]
+            yield from rec(parent)
+            yield attr
+
+        attrs: ta.List[AttrOps.Attr] = []
+        for o in raw:
+            if isinstance(o, (AttrOps.Attr, ta.Mapping)):
+                attrs.append(AttrOps.Attr.of(o))
+                continue
+
+            kw: ta.Mapping[str, ta.Any]
+            if isinstance(o, tuple):
+                cap, x = o
+                if isinstance(x, str):
+                    kw = dict(display=x)
+                elif isinstance(x, ta.Mapping):
+                    kw = x
+                else:
+                    raise TypeError(x)
+            else:
+                cap, kw = o, {}
+
+            path = tuple(rec(cap))
+
+            attrs.append(AttrOps.Attr(
+                '.'.join(path),
+                **kw,
+            ))
+
+        return attrs
+
+    #
+
+    _repr: ta.Callable[[T], str]
+
+    @property
+    def repr(self) -> ta.Callable[[T], str]:
+        try:
+            return self._repr
+        except AttributeError:
+            pass
+
+        def _repr(o: T) -> str:
+            vs: ta.List[str] = []
+            for a in self._attrs:
+                if not a._repr:  # noqa
+                    continue
+                v = getattr(o, a._name)  # noqa
+                if self._repr_filter is not None and not self._repr_filter(v):
+                    continue
+                if (rfn := a._repr_fn) is None:  # noqa
+                    rfn = repr
+                if (vr := rfn(v)) is None:
+                    continue
+                if self._terse:
+                    vs.append(vr)
+                else:
+                    vs.append(f'{a._display}={vr}')  # noqa
+
+            return (
+                f'{o.__class__.__module__ + "." if self._with_module else ""}'
+                f'{o.__class__.__qualname__ if self._use_qualname else o.__class__.__name__}'
+                f'{("@" + hex(id(o))[2:]) if self._with_id else ""}'  # noqa
+                f'({", ".join(vs)})'
+            )
+
+        if self._recursive:
+            _repr = self._reprlib().recursive_repr()(_repr)
+
+        self._repr = _repr
+        return _repr
+
+    _reprlib_: ta.ClassVar[ta.Any]
+
+    @classmethod
+    def _reprlib(cls) -> ta.Any:
+        try:
+            return cls._reprlib_
+        except AttributeError:
+            pass
+
+        import reprlib  # noqa
+
+        cls._reprlib_ = reprlib
+        return reprlib
+
+    #
+
+    _DEFAULT_CACHED_HASH_ATTR: ta.ClassVar[str] = '__cached_hash__'
+
+    _hash: ta.Callable[[T], int]
+
+    @property
+    def hash(self) -> ta.Callable[[T], int]:
+        try:
+            return self._hash
+        except AttributeError:
+            pass
+
+        def _calc_hash(o: T) -> int:
+            return hash(tuple(
+                getattr(o, a._name)  # noqa
+                for a in self._attrs
+                if a._hash  # noqa
+            ))
+
+        if (ch := self._cache_hash) is not False:
+            if ch is True:
+                cha = self._DEFAULT_CACHED_HASH_ATTR
+            elif isinstance(ch, str):
+                cha = ch
+            else:
+                raise TypeError(ch)
+
+            def _cached_hash(o: T) -> int:
+                try:
+                    return object.__getattribute__(o, cha)
+                except AttributeError:
+                    object.__setattr__(o, cha, h := _calc_hash(o))
+                return h
+
+            _hash = _cached_hash
+
+        else:
+            _hash = _calc_hash
+
+        self._hash = _hash
+        return _hash
+
+    #
+
+    _eq: ta.Callable[[T, ta.Any], ta.Union[bool, 'types.NotImplementedType']]
+
+    @property
+    def eq(self) -> ta.Callable[[T, ta.Any], ta.Union[bool, 'types.NotImplementedType']]:
+        try:
+            return self._eq
+        except AttributeError:
+            pass
+
+        def _eq(o: T, x: ta.Any) -> 'ta.Union[bool, types.NotImplementedType]':
+            if self._subtypes_eq:
+                if not isinstance(x, type(o)):
+                    return NotImplemented
+            else:
+                if type(x) is not type(o):
+                    return NotImplemented
+
+            return all(
+                getattr(o, a._name) == getattr(x, a._name)  # noqa
+                for a in self._attrs
+                if a._eq  # noqa
+            )
+
+        self._eq = _eq
+        return _eq
+
+    @property
+    def hash_eq(self) -> ta.Tuple[
+        ta.Callable[[T], int],
+        ta.Callable[[T, ta.Any], ta.Union[bool, 'types.NotImplementedType']],
+    ]:
+        return (self.hash, self.eq)
+
+    #
+
+    @property
+    def repr_hash_eq(self) -> ta.Tuple[
+        ta.Callable[[T], str],
+        ta.Callable[[T], int],
+        ta.Callable[[T, ta.Any], ta.Union[bool, 'types.NotImplementedType']],
+    ]:
+        return (self.repr, self.hash, self.eq)
+
+    #
+
+    class NOT_SET:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    def install(
+            self,
+            locals_dct: ta.MutableMapping[str, ta.Any],
+            *,
+            repr: ta.Union[bool, ta.Type[NOT_SET]] = NOT_SET,  # noqa
+            hash: ta.Union[bool, ta.Type[NOT_SET]] = NOT_SET,  # noqa
+            eq: ta.Union[bool, ta.Type[NOT_SET]] = NOT_SET,
+    ) -> 'AttrOps[T]':
+        if all(a is self.NOT_SET for a in (repr, hash, eq)):
+            repr = hash = eq = True  # noqa
+        if repr:
+            locals_dct.update(__repr__=self.repr)
+        if hash:
+            locals_dct.update(__hash__=self.hash)
+        if eq:
+            locals_dct.update(__eq__=self.eq)
+        return self
+
+
+attr_ops = AttrOps[ta.Any]
+
+
+##
+
+
+def attr_repr(obj: ta.Any, *attrs: str, **kwargs: ta.Any) -> str:
+    return AttrOps(*attrs, **kwargs).repr(obj)

omlish/lite/cached.py

@@ -21,7 +21,7 @@ class _AbstractCachedNullary:
     def __call__(self, *args, **kwargs):  # noqa
         raise TypeError
 
-    def __get__(self, instance, owner):  # noqa
+    def __get__(self, instance, owner=None):  # noqa
         bound = instance.__dict__[self._fn.__name__] = self.__class__(self._fn.__get__(instance, owner))
         return bound
 
@@ -58,3 +58,59 @@ class _AsyncCachedNullary(_AbstractCachedNullary):
 
 def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
     return _AsyncCachedNullary(fn)
+
+
+##
+
+
+cached_property = functools.cached_property
+
+
+class _cached_property:  # noqa
+    """Backported to pick up https://github.com/python/cpython/commit/056dfc71dce15f81887f0bd6da09d6099d71f979 ."""
+
+    def __init__(self, func):
+        self.func = func
+        self.attrname = None  # noqa
+        self.__doc__ = func.__doc__
+        self.__module__ = func.__module__
+
+    _NOT_FOUND = object()
+
+    def __set_name__(self, owner, name):
+        if self.attrname is None:
+            self.attrname = name  # noqa
+        elif name != self.attrname:
+            raise TypeError(
+                f'Cannot assign the same cached_property to two different names ({self.attrname!r} and {name!r}).',
+            )
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        if self.attrname is None:
+            raise TypeError('Cannot use cached_property instance without calling __set_name__ on it.')
+
+        try:
+            cache = instance.__dict__
+        except AttributeError:  # not all objects have __dict__ (e.g. class defines slots)
+            raise TypeError(
+                f"No '__dict__' attribute on {type(instance).__name__!r} instance to cache {self.attrname!r} property.",
+            ) from None
+
+        val = cache.get(self.attrname, self._NOT_FOUND)
+
+        if val is self._NOT_FOUND:
+            val = self.func(instance)
+            try:
+                cache[self.attrname] = val
+            except TypeError:
+                raise TypeError(
+                    f"The '__dict__' attribute on {type(instance).__name__!r} instance does not support item "
+                    f"assignment for caching {self.attrname!r} property.",
+                ) from None
+
+        return val
+
+
+globals()['cached_property'] = _cached_property

omlish/lite/contextmanagers.py

@@ -54,7 +54,7 @@ class ExitStacked:
             es.__enter__()
             try:
                 self._enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 es.__exit__(*sys.exc_info())
                 raise
             return self
@@ -65,7 +65,7 @@ class ExitStacked:
             return None
         try:
             self._exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             es.__exit__(*sys.exc_info())
             raise
         return es.__exit__(exc_type, exc_val, exc_tb)
@@ -113,7 +113,7 @@ class AsyncExitStacked:
             await es.__aenter__()
             try:
                 await self._async_enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 await es.__aexit__(*sys.exc_info())
                 raise
             return self
@@ -124,7 +124,7 @@ class AsyncExitStacked:
             return None
         try:
             await self._async_exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             await es.__aexit__(*sys.exc_info())
             raise
         return await es.__aexit__(exc_type, exc_val, exc_tb)

omlish/lite/dataclasses.py

@@ -7,6 +7,17 @@ import typing as ta
 ##
 
 
+def dataclass_shallow_astuple(o: ta.Any) -> ta.Tuple[ta.Any, ...]:
+    return tuple(getattr(o, f.name) for f in dc.fields(o))
+
+
+def dataclass_shallow_asdict(o: ta.Any) -> ta.Dict[str, ta.Any]:
+    return {f.name: getattr(o, f.name) for f in dc.fields(o)}
+
+
+##
+
+
 def is_immediate_dataclass(cls: type) -> bool:
     if not isinstance(cls, type):
         raise TypeError(cls)
@@ -89,6 +100,36 @@ def dataclass_repr_omit_falsey(obj: ta.Any) -> str:
 ##
 
 
+def dataclass_descriptor_method(*bind_attrs: str, bind_owner: bool = False) -> ta.Callable:
+    if not bind_attrs:
+        def __get__(self, instance, owner=None):  # noqa
+            return self
+
+    elif bind_owner:
+        def __get__(self, instance, owner=None):  # noqa
+            # Guaranteed to return a new instance even with no attrs
+            return dc.replace(self, **{
+                a: v.__get__(instance, owner) if (v := getattr(self, a)) is not None else None
+                for a in bind_attrs
+            })
+
+    else:
+        def __get__(self, instance, owner=None):  # noqa
+            if instance is None:
+                return self
+
+            # Guaranteed to return a new instance even with no attrs
+            return dc.replace(self, **{
+                a: v.__get__(instance, owner) if (v := getattr(self, a)) is not None else None
+                for a in bind_attrs
+            })
+
+    return __get__
+
+
+##
+
+
 def dataclass_kw_only_init():
     def inner(cls):
         if not isinstance(cls, type) and dc.is_dataclass(cls):
@@ -150,3 +191,17 @@ def dataclass_kw_only_init():
         return cls
 
     return inner
+
+
+##
+
+
+@dc.dataclass()
+class DataclassFieldRequiredError(Exception):
+    name: str
+
+
+def dataclass_field_required(name: str) -> ta.Callable[[], ta.Any]:
+    def inner() -> ta.NoReturn:
+        raise DataclassFieldRequiredError(name)
+    return inner

omlish/lite/inject.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007 UP043 UP045
+# @omlish-amalg ../../omdev/scripts/lib/inject.py
 import abc
 import contextlib
 import contextvars
@@ -21,12 +22,12 @@ T = ta.TypeVar('T')
 U = ta.TypeVar('U')
 
 
-InjectorKeyCls = ta.Union[type, ta.NewType]
+InjectorKeyCls = ta.Union[type, ta.NewType]  # ta.TypeAlias
 
-InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
-InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']
+InjectorProviderFn = ta.Callable[['Injector'], ta.Any]  # ta.TypeAlias
+InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']  # ta.TypeAlias
 
-InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
+InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']  # ta.TypeAlias
 
 
 ###

omlish/lite/marshal.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007 UP045
+# @omlish-amalg ../../omdev/scripts/lib/marshal.py
 """
 TODO:
  - pickle stdlib objs? have to pin to 3.8 pickle protocol, will be cross-version

omlish/lite/maybes.py

@@ -1,6 +1,7 @@
 # ruff: noqa: UP007 UP045
 import abc
 import functools
+import operator
 import typing as ta
 
 from .abstract import Abstract
@@ -148,12 +149,11 @@ class _Maybe(Maybe[T], Abstract):
             return op and not sp
 
 
+@ta.final
 class _JustMaybe(_Maybe[T]):
     __slots__ = ('_v', '_hash')
 
     def __init__(self, v: T) -> None:
-        super().__init__()
-
         self._v = v
 
     @property
@@ -185,6 +185,7 @@ class _JustMaybe(_Maybe[T]):
         )
 
 
+@ta.final
 class _EmptyMaybe(_Maybe[T]):
     __slots__ = ()
 
@@ -208,3 +209,10 @@ class _EmptyMaybe(_Maybe[T]):
 
 
 Maybe._empty = _EmptyMaybe()  # noqa
+
+
+##
+
+
+setattr(Maybe, 'just', _JustMaybe)  # noqa
+setattr(Maybe, 'empty', functools.partial(operator.attrgetter('_empty'), Maybe))

omlish/lite/maysync.py

@@ -25,6 +25,7 @@ Internally, it's not really correct to say that there is 'no event loop' in the
 ===
 
 TODO:
+ - ! impl iterators not just generators !
  - __del__
  - (test) maysync context managers
  - CancelledError
@@ -33,11 +34,6 @@ TODO:
   - works down to 3.8
  - make_maysync_from_sync can run with asyncio.run_in_thread
  - make_maysync_from_async can run with asyncio.run_soon
-
-TODO OVERHAUL:
- - no more sync/async context, just one Context, and it means sync
- - make FpMaywaitable *not reusable*
-  - `cannot reuse already awaited coroutine`
 """
 import abc
 import inspect
@@ -523,6 +519,27 @@ def run_maysync(m):
 ##
 
 
+@ta.final
+class RunMaysyncContextManager(ta.Generic[T]):
+    def __init__(self, acm: ta.AsyncContextManager[T]) -> None:
+        self._acm = acm
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._acm!r})'
+
+    def __enter__(self) -> T:
+        return run_maysync(self._acm.__aenter__())
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return run_maysync(self._acm.__aexit__(exc_type, exc_val, exc_tb))
+
+
+run_maysync_context_manager = RunMaysyncContextManager
+
+
+##
+
+
 _MAYSYNC_MARK_ATTR = '__maysync__'