omlish 0.0.0.dev424__py3-none-any.whl → 0.0.0.dev426__py3-none-any.whl

omlish/lang/classes/simple.py

@@ -63,7 +63,6 @@ class Marker(NotInstantiable, metaclass=_MarkerMeta):
 
 
 _SINGLETON_INSTANCE_ATTR = '__singleton_instance__'
-_SINGLETON_LOCK = threading.RLock()
 
 
 def _set_singleton_instance(inst):
@@ -85,7 +84,24 @@ def _set_singleton_instance(inst):
     return inst
 
 
-class Singleton:
+class _AnySingleton:
+    def __init__(self) -> None:
+        try:
+            type(self).__dict__[_SINGLETON_INSTANCE_ATTR]
+        except KeyError:
+            pass
+        else:
+            raise TypeError(f'Must not re-instantiate singleton {type(self)}')
+
+        super().__init__()
+
+    @ta.final
+    def __reduce__(self):
+        return (type(self), ())
+
+
+class Singleton(_AnySingleton):
+    @ta.final
     def __new__(cls):
         return cls.__dict__[_SINGLETON_INSTANCE_ATTR]
 
@@ -95,15 +111,21 @@ class Singleton:
         _set_singleton_instance(super().__new__(cls))  # noqa
 
 
-class LazySingleton:
+_LAZY_SINGLETON_LOCK = threading.RLock()
+
+
+class LazySingleton(_AnySingleton):
+    @ta.final
     def __new__(cls):
         try:
             return cls.__dict__[_SINGLETON_INSTANCE_ATTR]
         except KeyError:
             pass
-        with _SINGLETON_LOCK:
+
+        with _LAZY_SINGLETON_LOCK:
             try:
                 return cls.__dict__[_SINGLETON_INSTANCE_ATTR]
             except KeyError:
                 pass
+
             return _set_singleton_instance(super().__new__(cls))

omlish/lang/collections.py

@@ -9,7 +9,7 @@ V = ta.TypeVar('V')
 ##
 
 
-def yield_dict_init(*args: ta.Any, **kwargs: ta.Any) -> ta.Iterable[tuple[ta.Any, ta.Any]]:
+def yield_dict_init(*args: ta.Any, **kwargs: ta.Any) -> ta.Iterator[tuple[ta.Any, ta.Any]]:
     if len(args) > 1:
         raise TypeError
 

omlish/lang/functions.py

@@ -167,17 +167,6 @@ def void(*args: ta.Any, **kwargs: ta.Any) -> ta.NoReturn:
 ##
 
 
-def as_async(fn: ta.Callable[P, T]) -> ta.Callable[P, ta.Awaitable[T]]:
-    @functools.wraps(fn)
-    async def inner(*args, **kwargs):
-        return fn(*args, **kwargs)
-
-    return inner
-
-
-##
-
-
 _MISSING = object()
 
 

omlish/lang/iterables.py

@@ -46,14 +46,14 @@ def chunk(n: int, iterable: ta.Iterable[T], strict: bool = False) -> ta.Iterator
         return iterator
 
 
-def interleave(vs: ta.Iterable[T], d: T) -> ta.Iterable[T]:
+def interleave(vs: ta.Iterable[T], d: T) -> ta.Iterator[T]:
     for i, v in enumerate(vs):
         if i:
             yield d
         yield v
 
 
-def renumerate(it: ta.Iterable[T]) -> ta.Iterable[tuple[T, int]]:
+def renumerate(it: ta.Iterable[T]) -> ta.Iterator[tuple[T, int]]:
     return ((e, i) for i, e in enumerate(it))
 
 

omlish/lang/lazyglobals.py

@@ -4,6 +4,17 @@ import typing as ta
 ##
 
 
+class AmbiguousLazyGlobalsFallbackError(Exception):
+    def __init__(self, attr: str, fallbacks: list[ta.Callable[[str], ta.Any]]) -> None:
+        super().__init__()
+
+        self.attr = attr
+        self.fallbacks = fallbacks
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.attr!r}, {self.fallbacks!r})'
+
+
 class LazyGlobals:
     def __init__(
             self,
@@ -17,6 +28,7 @@ class LazyGlobals:
         self._update_globals = update_globals
 
         self._attr_fns: dict[str, ta.Callable[[], ta.Any]] = {}
+        self._fallback_fns: list[ta.Callable[[str], ta.Callable[[], ta.Any]]] = []
 
     @classmethod
     def install(cls, globals: ta.MutableMapping[str, ta.Any]) -> 'LazyGlobals':  # noqa
@@ -42,13 +54,23 @@ class LazyGlobals:
         self._attr_fns[attr] = fn
         return self
 
+    def add_fallback_fn(self, fn: ta.Callable[[str], ta.Callable[[], ta.Any]]) -> 'LazyGlobals':
+        self._fallback_fns.append(fn)
+        return self
+
     def get(self, attr: str) -> ta.Any:
-        try:
-            fn = self._attr_fns[attr]
-        except KeyError:
-            raise AttributeError(attr) from None
+        val: ta.Any
 
-        val = fn()
+        if (attr_fn := self._attr_fns.get(attr)) is not None:
+            val = attr_fn()
+
+        elif (fallbacks := [(fb_fn, fb_fn(attr)) for fb_fn in self._fallback_fns]):
+            if len(fallbacks) > 1:
+                raise AmbiguousLazyGlobalsFallbackError(attr, [fb_fn for fb_fn, _ in fallbacks])
+            [val] = fallbacks
+
+        else:
+            raise AttributeError(attr)
 
         if self._update_globals and self._globals is not None:
             self._globals[attr] = val

omlish/lang/maysync.py

@@ -3,7 +3,7 @@ import typing as ta
 from ..lite.maysync import MaysyncFn
 from ..lite.maysync import MaysyncGeneratorFn
 from ..lite.maysync import make_maysync as _make_maysync
-from .functions import as_async
+from .asyncs import as_async
 
 
 T = ta.TypeVar('T')
@@ -68,5 +68,5 @@ def make_maysync_from_sync(
 ) -> ta.Callable[P, ta.Awaitable[T]]:
     return _make_maysync(
         s,
-        a if a is not None else as_async(s),
+        a if a is not None else as_async(s, wrap=True),
     )

omlish/lifecycles/contextmanagers.py

@@ -2,7 +2,6 @@ import types
 import typing as ta
 
 from .. import dataclasses as dc
-from .. import defs
 from .. import lang
 from .base import Lifecycle
 from .controller import LifecycleController
@@ -37,7 +36,7 @@ class LifecycleContextManager(ta.Generic[LifecycleT]):
         self._lifecycle = lifecycle
         self._controller = lifecycle if isinstance(lifecycle, LifecycleController) else LifecycleController(lifecycle)
 
-    defs.repr('lifecycle', 'state')
+    __repr__ = lang.attr_ops('lifecycle', 'state').repr
 
     @property
     def lifecycle(self) -> LifecycleT:

omlish/lifecycles/controller.py

@@ -2,7 +2,6 @@ import abc
 import typing as ta
 
 from .. import check
-from .. import defs
 from .. import lang
 from .base import AnyLifecycle  # noqa
 from .base import Lifecycle  # noqa
@@ -48,7 +47,7 @@ class AnyLifecycleController(AnyLifecycle[R], lang.Abstract, ta.Generic[AnyLifec
         self._state = LifecycleStates.NEW
         self._listeners: list[AnyLifecycleListener[AnyLifecycleT, R]] = []
 
-    defs.repr('lifecycle', 'state')
+    __repr__ = lang.attr_ops('lifecycle', 'state').repr
 
     @property
     def lifecycle(self) -> AnyLifecycleT:

omlish/lite/asyncs.py

@@ -0,0 +1,20 @@
+# ruff: noqa: UP045
+import functools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+async def opt_await(aw: ta.Optional[ta.Awaitable[T]]) -> ta.Optional[T]:
+    return (await aw if aw is not None else None)
+
+
+def as_async(fn: ta.Callable[..., T], *, wrap: bool = False) -> ta.Callable[..., ta.Awaitable[T]]:
+    async def inner(*args, **kwargs):
+        return fn(*args, **kwargs)
+
+    return functools.wraps(fn)(inner) if wrap else inner

omlish/lite/attrops.py

@@ -0,0 +1,332 @@
+# ruff: noqa: UP006 UP007 UP045
+# @omlish-lite
+"""
+TODO:
+ - dotted paths!
+ - per-attr repr transform / filter
+ - __ne__ ? cases where it still matters
+ - ordering ?
+"""
+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
+                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._hash = hash
+            self._eq = eq
+
+        @classmethod
+        def of(
+                cls,
+                o: ta.Union[
+                    str,
+                    ta.Tuple[str, str],
+                    'AttrOps.Attr',
+                ],
+        ) -> 'AttrOps.Attr':
+            if isinstance(o, AttrOps.Attr):
+                return o
+            elif isinstance(o, str):
+                return cls(o)
+            else:
+                name, disp = o
+                return cls(
+                    name,
+                    display=disp,
+                )
+
+        @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
+
+    @ta.overload
+    def __init__(
+            self,
+            *attrs: ta.Sequence[ta.Union[
+                str,
+                ta.Tuple[str, str],
+                Attr,
+            ]],
+            with_module: bool = False,
+            use_qualname: bool = False,
+            with_id: bool = False,
+            repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = None,
+            recursive: bool = False,
+            subtypes_eq: bool = False,
+    ) -> None:
+        ...
+
+    @ta.overload
+    def __init__(
+            self,
+            attrs_fn: ta.Callable[[T], ta.Tuple[ta.Union[
+                ta.Any,
+                ta.Tuple[str, ta.Any],
+                Attr,
+            ], ...]],
+            /,
+            *,
+            with_module: bool = False,
+            use_qualname: bool = False,
+            with_id: bool = False,
+            repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = None,
+            recursive: bool = False,
+            subtypes_eq: bool = False,
+    ) -> None:
+        ...
+
+    def __init__(
+            self,
+            *args,
+            with_module=False,
+            use_qualname=False,
+            with_id=False,
+            repr_filter=None,
+            recursive=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._repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = repr_filter
+        self._recursive: bool = recursive
+        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):
+                attrs.append(o)
+                continue
+
+            if isinstance(o, tuple):
+                disp, cap, = o
+            else:
+                disp, cap = None, o
+
+            path = tuple(rec(cap))
+
+            attrs.append(AttrOps.Attr(
+                '.'.join(path),
+                display=disp,
+            ))
+
+        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 = ', '.join(
+                f'{a._display}={v!r}'  # noqa
+                for a in self._attrs
+                if a._repr  # noqa
+                for v in [getattr(o, a._name)]  # noqa
+                if self._repr_filter is None or self._repr_filter(v)
+            )
+
+            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 ""}'
+                f'({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
+
+    #
+
+    _hash: ta.Callable[[T], int]
+
+    @property
+    def hash(self) -> ta.Callable[[T], int]:
+        try:
+            return self._hash
+        except AttributeError:
+            pass
+
+        def _hash(o: T) -> int:
+            return hash(tuple(
+                getattr(o, a._name)  # noqa
+                for a in self._attrs
+                if a._hash  # noqa
+            ))
+
+        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)
+
+    #
+
+    def install(
+            self,
+            locals_dct: ta.MutableMapping[str, ta.Any],
+            *,
+            all: bool = False,  # noqa
+            repr: bool = False,  # noqa
+            hash: bool = False,  # noqa
+            eq: bool = False,
+    ) -> 'AttrOps[T]':
+        if repr or all:
+            locals_dct.update(__repr__=self.repr)
+        if hash or all:
+            locals_dct.update(__hash__=self.hash)
+        if eq or all:
+            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
 

omlish/lite/maybes.py

@@ -148,6 +148,7 @@ class _Maybe(Maybe[T], Abstract):
             return op and not sp
 
 
+@ta.final
 class _JustMaybe(_Maybe[T]):
     __slots__ = ('_v', '_hash')
 
@@ -185,6 +186,7 @@ class _JustMaybe(_Maybe[T]):
         )
 
 
+@ta.final
 class _EmptyMaybe(_Maybe[T]):
     __slots__ = ()
 

omlish/lite/strings.py

@@ -73,13 +73,6 @@ def split_keep_delimiter(s, d):
 ##
 
 
-def attr_repr(obj: ta.Any, *attrs: str) -> str:
-    return f'{type(obj).__name__}({", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)})'
-
-
-##
-
-
 FORMAT_NUM_BYTES_SUFFIXES: ta.Sequence[str] = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB']
 
 

omlish/lite/timing.py

@@ -1,6 +1,9 @@
-from ..logs.timing import LogTimingContext
-from ..logs.timing import log_timing_context
-from .logs import log
+from ..logs.modules import get_module_logger
+from ..logs.utils import LogTimingContext
+from ..logs.utils import log_timing_context
+
+
+log = get_module_logger(globals())  # noqa
 
 
 LogTimingContext.DEFAULT_LOG = log