omlish 0.0.0.dev5__py3-none-any.whl → 0.0.0.dev6__py3-none-any.whl

omlish/inject/providers.py

@@ -1,111 +1,38 @@
-import abc
 import typing as ta
 
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
-from .. import reflect as rfl
-from .elements import Element
-from .elements import Elements
-from .impl.inspect import signature
 from .keys import Key
-from .keys import as_key
 
 
 class _Missing(lang.NotInstantiable):
     pass
 
 
-##
-
-
 class Provider(lang.Abstract):
-    @abc.abstractmethod
-    def provided_ty(self) -> rfl.Type | None:
-        raise NotImplementedError
-
-
-##
-
-
-def as_provider(o: ta.Any) -> Provider:
-    check.not_isinstance(o, (Element, Elements))
-    if isinstance(o, Provider):
-        return o
-    if isinstance(o, Key):
-        return link(o)
-    if isinstance(o, type):
-        return ctor(o)
-    if callable(o):
-        return fn(o)
-    return const(o)
-
-
-##
+    pass
 
 
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class FnProvider(Provider):
-    fn: ta.Any
-    ty: rfl.Type | None = None
-
-    def provided_ty(self) -> rfl.Type | None:
-        return self.ty
-
-
-def fn(fn: ta.Any, ty: rfl.Type | None = _Missing) -> Provider:
-    check.not_isinstance(fn, type)
-    check.callable(fn)
-    if ty is _Missing:
-        sig = signature(fn)
-        ty = check.isinstance(sig.return_annotation, type)
-    return FnProvider(fn, ty)
-
-
-##
+    fn: ta.Any = dc.xfield(check=callable)
 
 
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class CtorProvider(Provider):
-    ty: type
+    ty: type = dc.xfield(coerce=check.of_isinstance(type))
 
-    def provided_ty(self) -> type:
-        return self.ty
 
-
-def ctor(ty: type) -> Provider:
-    check.isinstance(ty, type)
-    return CtorProvider(ty)
-
-
-##
-
-
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class ConstProvider(Provider):
     v: ta.Any
-    ty: rfl.Type | None = None
-
-    def provided_ty(self) -> rfl.Type | None:
-        return self.ty
-
 
-def const(v: ta.Any, ty: rfl.Type | None = _Missing) -> Provider:
-    if ty is _Missing:
-        ty = type(v)
-    return ConstProvider(v, ty)
 
-
-##
-
-
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class LinkProvider(Provider):
-    k: Key
-
-    def provided_ty(self) -> rfl.Type | None:
-        return None
-
-
-def link(k: ta.Any) -> Provider:
-    return LinkProvider(as_key(k))
+    k: Key = dc.xfield(coerce=check.of_isinstance(Key))

omlish/inject/scopes.py

@@ -7,7 +7,6 @@ from .. import dataclasses as dc
 from .. import lang
 from .. import reflect as rfl
 from .bindings import Binding
-from .bindings import as_binding
 from .elements import Element
 from .keys import Key
 from .keys import as_key
@@ -24,6 +23,9 @@ else:
 ##
 
 
+SCOPE_ALIASES: dict[str, Scope] = {}
+
+
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class ScopeBinding(Element, lang.Final):
@@ -34,22 +36,26 @@ def bind_scope(sc: Scope) -> Element:
     return ScopeBinding(sc)
 
 
-def in_(b: ta.Any, sc: Scope) -> 'Binding':
-    return dc.replace(as_binding(b), scope=check.isinstance(sc, Scope))
+##
 
 
 class Singleton(Scope, lang.Singleton, lang.Final):
     pass
 
 
-def singleton(b: ta.Any) -> 'Binding':
-    return in_(b, Singleton())
+SCOPE_ALIASES['singleton'] = Singleton()
+
+
+##
 
 
 class Thread(Scope, lang.Singleton, lang.Final):
     pass
 
 
+SCOPE_ALIASES['thread'] = Thread()
+
+
 ##
 
 
@@ -64,7 +70,8 @@ class SeededScope(Scope, lang.Final):
             raise NotImplementedError
 
 
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class ScopeSeededProvider(Provider):
     ss: SeededScope = dc.xfield(coerce=check.of_isinstance(SeededScope))
     key: Key = dc.xfield(coerce=check.of_isinstance(Key))

omlish/inject/types.py

@@ -1,7 +1,9 @@
+import collections
+
 from .. import lang
 
 
-##
+Tag = collections.namedtuple('Tag', 'tag')  # noqa
 
 
 class Scope(lang.Abstract):

omlish/lang/__init__.py

@@ -80,9 +80,13 @@ from .descriptors import (  # noqa
     access_forbidden,
     attr_property,
     classonly,
+    decorator,
     is_method_descriptor,
     item_property,
+    unwrap_func,
+    unwrap_func_with_partials,
     unwrap_method_descriptors,
+    update_wrapper_except_dict,
 )
 
 from .exceptions import (  # noqa
@@ -99,14 +103,14 @@ from .functions import (  # noqa
     is_lambda,
     is_none,
     is_not_none,
+    isinstance_of,
+    issubclass_of,
     maybe_call,
     periodically,
     raise_,
     raising,
     recurse,
     try_,
-    unwrap_func,
-    unwrap_func_with_partials,
     void,
 )
 
@@ -127,8 +131,10 @@ from .iterables import (  # noqa
     asrange,
     exhaust,
     ilen,
+    itergen,
     peek,
     prodrange,
+    renumerate,
     take,
 )
 

omlish/lang/cached.py

@@ -11,8 +11,8 @@ import typing as ta
 
 from .contextmanagers import DefaultLockable
 from .contextmanagers import default_lock
-from .functions import unwrap_func
-from .functions import unwrap_func_with_partials
+from .descriptors import unwrap_func
+from .descriptors import unwrap_func_with_partials
 
 
 P = ta.ParamSpec('P')

omlish/lang/classes/restrict.py

@@ -78,7 +78,8 @@ class PackageSealed:
         for base in cls.__bases__:
             if base is not Abstract:
                 if PackageSealed in base.__bases__:
-                    if cls.__module__.split('.')[:-1] != base.__module__.split('.')[:-1]:
+                    pfx = base.__module__.split('.')[:-1]
+                    if cls.__module__.split('.')[:len(pfx)] != pfx:
                         raise SealedError(base)
         super().__init_subclass__(**kwargs)
 

omlish/lang/classes/simple.py

@@ -14,13 +14,25 @@ V = ta.TypeVar('V')
 ##
 
 
-class _Namespace(Final):
+class _NamespaceMeta(abc.ABCMeta):
+    def __new__(mcls, name, bases, namespace):
+        if bases:
+            for nc in (NotInstantiable,):
+                if nc not in bases:
+                    bases += (nc,)
+        return super().__new__(mcls, name, bases, namespace)
 
-    def __mro_entries__(self, bases, **kwargs):
-        return (Final, NotInstantiable)
+    def __iter__(cls) -> ta.Iterator[tuple[str, ta.Any]]:
+        for a in dir(cls):
+            if not a.startswith('_'):
+                yield (a, getattr(cls, a))
 
+    def __getitem__(cls, n: str) -> ta.Any:
+        return getattr(cls, n)
 
-Namespace: type = _Namespace()  # type: ignore
+
+class Namespace(metaclass=_NamespaceMeta):
+    pass
 
 
 ##
@@ -54,8 +66,6 @@ class _MarkerMeta(abc.ABCMeta):
 class Marker(NotInstantiable, metaclass=_MarkerMeta):
     """A marker."""
 
-    __slots__ = ()
-
 
 ##
 
@@ -77,7 +87,7 @@ _SINGLETON_LOCK = threading.RLock()
 
 
 def _set_singleton_instance(inst):
-    cls = type(inst)
+    cls = inst.__class__
     if _SINGLETON_INSTANCE_ATTR in cls.__dict__:
         raise TypeError(cls)
 
@@ -86,7 +96,7 @@ def _set_singleton_instance(inst):
 
     @functools.wraps(old_init)
     def new_init(self):
-        if type(self) is not cls:
+        if self.__class__ is not cls:
             old_init(self)  # noqa
 
     setattr(cls, '__init__', new_init)

omlish/lang/contextmanagers.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - AsyncExitStacked
+"""
 import abc
 import contextlib
 import contextvars
@@ -15,7 +19,7 @@ T = ta.TypeVar('T')
 
 class ContextManaged:
 
-    def __enter__(self: ta.Self) -> ta.Self:
+    def __enter__(self) -> ta.Self:
         return self
 
     def __exit__(
@@ -77,7 +81,7 @@ class ContextManager(abc.ABC, ta.Generic[T]):
             exc_type: type[BaseException] | None,
             exc_val: BaseException | None,
             exc_tb: types.TracebackType | None,
-    ) -> None:
+    ) -> bool | None:
         return self._contextmanager.__exit__(exc_type, exc_val, exc_tb)
 
 
@@ -198,7 +202,7 @@ class ExitStacked:
     def _enter_context(self, context_manager: ta.ContextManager[T]) -> T:
         return self._exit_stack.enter_context(ta.cast(ta.ContextManager, context_manager))
 
-    def __enter__(self: ta.Self) -> ta.Self:
+    def __enter__(self) -> ta.Self:
         try:
             superfn = super().__enter__  # type: ignore
         except AttributeError:
@@ -306,14 +310,19 @@ DefaultLockable = bool | Lockable | ta.ContextManager | None
 def default_lock(value: DefaultLockable, default: DefaultLockable) -> Lockable:
     if value is None:
         value = default
+
     if value is True:
         lock = threading.RLock()
         return lambda: lock
+
     elif value is False or value is None:
         return NOP_CONTEXT_MANAGER
+
     elif callable(value):
         return value
+
     elif isinstance(value, ta.ContextManager):
         return lambda: value
+
     else:
         raise TypeError(value)

omlish/lang/descriptors.py

@@ -1,9 +1,11 @@
 import functools
 import operator
+import types
 import typing as ta
 
 
 T = ta.TypeVar('T')
+P = ta.ParamSpec('P')
 
 
 ##
@@ -31,6 +33,19 @@ def is_method_descriptor(obj: ta.Any) -> bool:
     return isinstance(obj, (*BUILTIN_METHOD_DESCRIPTORS, _MethodDescriptor))
 
 
+def _has_method_descriptor(obj: ta.Any) -> bool:
+    while True:
+        if is_method_descriptor(obj):
+            return True
+        elif isinstance(obj, functools.partial):
+            obj = obj.func
+        else:
+            try:
+                obj = getattr(obj, '__wrapped__')
+            except AttributeError:
+                return False
+
+
 def unwrap_method_descriptors(fn: ta.Callable) -> ta.Callable:
     while is_method_descriptor(fn):
         fn = fn.__func__  # type: ignore  # noqa
@@ -40,6 +55,122 @@ def unwrap_method_descriptors(fn: ta.Callable) -> ta.Callable:
 ##
 
 
+def unwrap_func(fn: ta.Callable) -> ta.Callable:
+    fn, _ = unwrap_func_with_partials(fn)
+    return fn
+
+
+def unwrap_func_with_partials(fn: ta.Callable) -> tuple[ta.Callable, list[functools.partial]]:
+    ps = []
+    while True:
+        if is_method_descriptor(fn) or isinstance(fn, types.MethodType):
+            fn = fn.__func__  # type: ignore
+        elif hasattr(fn, '__wrapped__'):
+            nxt = fn.__wrapped__
+            if not callable(nxt):
+                raise TypeError(nxt)
+            if nxt is fn:
+                raise TypeError(fn)
+            fn = nxt
+        # NOTE: __wrapped__ takes precedence - a partial might point to a bound Method when the important information is
+        # still the unbound func. see _decorator_descriptor for an example of this.
+        elif isinstance(fn, functools.partial):
+            ps.append(fn)
+            fn = fn.func
+        else:
+            break
+    return fn, ps
+
+
+##
+
+
+WRAPPER_UPDATES_EXCEPT_DICT = tuple(a for a in functools.WRAPPER_UPDATES if a != '__dict__')
+
+
+def update_wrapper_except_dict(
+        wrapper,
+        wrapped,
+        assigned=functools.WRAPPER_ASSIGNMENTS,
+        updated=WRAPPER_UPDATES_EXCEPT_DICT,
+):
+    return functools.update_wrapper(
+        wrapper,
+        wrapped,
+        assigned=assigned,
+        updated=updated,
+    )
+
+
+##
+
+
+_DECORATOR_HANDLES_UNBOUND_METHODS = True
+
+
+class _decorator_descriptor:  # noqa
+    if not _DECORATOR_HANDLES_UNBOUND_METHODS:
+        def __init__(self, wrapper, fn):
+            self._wrapper, self._fn = wrapper, fn
+            update_wrapper_except_dict(self, fn)
+
+        def __get__(self, instance, owner):
+            return functools.update_wrapper(functools.partial(self._wrapper, fn := self._fn.__get__(instance, owner)), fn)  # noqa
+
+    else:
+        def __init__(self, wrapper, fn):
+            self._wrapper, self._fn = wrapper, fn
+            self._md = _has_method_descriptor(fn)
+            update_wrapper_except_dict(self, fn)
+
+        def __get__(self, instance, owner):
+            fn = self._fn.__get__(instance, owner)
+            if self._md or instance is not None:
+                @functools.wraps(fn)
+                def inner(*args, **kwargs):
+                    return self._wrapper(fn, *args, **kwargs)
+                return inner
+            else:
+                @functools.wraps(fn)
+                def outer(this, *args, **kwargs):
+                    @functools.wraps(self._fn)
+                    def inner(*args2, **kwargs2):
+                        return fn(this, *args2, **kwargs2)
+                    return self._wrapper(inner, *args, **kwargs)
+                return outer
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}<{self._wrapper}, {self._fn}>'
+
+    def __call__(self, *args, **kwargs):
+        return self._wrapper(self._fn, *args, **kwargs)
+
+
+class _decorator:  # noqa
+    def __init__(self, wrapper):
+        self._wrapper = wrapper
+        update_wrapper_except_dict(self, wrapper)
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}<{self._wrapper}>'
+
+    def __call__(self, fn):
+        return _decorator_descriptor(self._wrapper, fn)  # noqa
+
+
+# FIXME:
+# def decorator(
+#         wrapper: ta.Callable[ta.Concatenate[ta.Any, P], T],  # FIXME: https://youtrack.jetbrains.com/issue/PY-72164  # noqa
+# ) -> ta.Callable[[ta.Callable[P, T]], ta.Callable[P, T]]:
+#     return _decorator(wrapper)
+
+
+decorator = _decorator
+
+
+##
+
+
 class AccessForbiddenError(Exception):
 
     def __init__(self, name: str | None = None, *args: ta.Any, **kwargs: ta.Any) -> None:

omlish/lang/functions.py

@@ -3,8 +3,6 @@ import functools
 import time
 import typing as ta
 
-from .descriptors import is_method_descriptor
-
 
 T = ta.TypeVar('T')
 P = ta.ParamSpec('P')
@@ -41,32 +39,6 @@ def recurse(fn: ta.Callable[..., T], *args, **kwargs) -> T:
 ##
 
 
-def unwrap_func(fn: ta.Callable) -> ta.Callable:
-    fn, _ = unwrap_func_with_partials(fn)
-    return fn
-
-
-def unwrap_func_with_partials(fn: ta.Callable) -> tuple[ta.Callable, list[functools.partial]]:
-    ps = []
-    while True:
-        if is_method_descriptor(fn):
-            fn = fn.__func__  # type: ignore
-        elif isinstance(fn, functools.partial):
-            ps.append(fn)
-            fn = fn.func
-        else:
-            nxt = getattr(fn, '__wrapped__', None)
-            if not callable(nxt):
-                break
-            if nxt is fn:
-                raise TypeError(fn)
-            fn = nxt
-    return fn, ps
-
-
-##
-
-
 def raise_(o: BaseException) -> ta.NoReturn:
     raise o
 
@@ -128,6 +100,14 @@ def is_not_none(o: ta.Any) -> bool:
     return o is not None
 
 
+def isinstance_of(class_or_tuple: ta.Any) -> ta.Callable[[ta.Any], bool]:
+    return lambda o: isinstance(o, class_or_tuple)
+
+
+def issubclass_of(class_or_tuple: ta.Any) -> ta.Callable[[ta.Any], bool]:
+    return lambda o: issubclass(o, class_or_tuple)
+
+
 class VoidError(Exception):
     pass
 

omlish/lang/iterables.py

@@ -1,3 +1,4 @@
+import dataclasses as dc
 import itertools
 import typing as ta
 
@@ -34,7 +35,13 @@ def peek(vs: ta.Iterable[T]) -> tuple[T, ta.Iterator[T]]:
     return v, itertools.chain(iter((v,)), it)
 
 
-Rangeable: ta.TypeAlias = int | tuple[int] | tuple[int, int] | ta.Iterable[int]
+Rangeable: ta.TypeAlias = ta.Union[  # noqa
+    int,
+    tuple[int],
+    tuple[int, int],
+    tuple[int, int, int],
+    ta.Iterable[int],
+]
 
 
 def asrange(i: Rangeable) -> ta.Iterable[int]:
@@ -52,3 +59,15 @@ def prodrange(*dims: Rangeable) -> ta.Iterable[ta.Sequence[int]]:
     if not dims:
         return []
     return itertools.product(*map(asrange, dims))
+
+
+@dc.dataclass(frozen=True)
+class itergen(ta.Generic[T]):  # noqa
+    fn: ta.Callable[[], ta.Iterable[T]]
+
+    def __iter__(self):
+        return iter(self.fn())
+
+
+def renumerate(it: ta.Iterable[T]) -> ta.Iterable[tuple[T, int]]:
+    return ((e, i) for i, e in enumerate(it))

omlish/lang/typing.py

@@ -12,6 +12,11 @@ import typing as ta
 
 Ty = ta.TypeVar('Ty', bound=type)
 
+T = ta.TypeVar('T')
+A0 = ta.TypeVar('A0')
+A1 = ta.TypeVar('A1')
+A2 = ta.TypeVar('A2')
+
 
 BytesLike: ta.TypeAlias = bytes | bytearray
 

omlish/lifecycles/__init__.py

@@ -0,0 +1,34 @@
+from .abstract import (  # noqa
+    AbstractLifecycle,
+)
+
+from .base import (  # noqa
+    CallbackLifecycle,
+    Lifecycle,
+    LifecycleCallback,
+)
+
+from .contextmanagers import (  # noqa
+    ContextManagerLifecycle,
+    LifecycleContextManager,
+)
+
+from .controller import (  # noqa
+    LifecycleController,
+    LifecycleListener,
+)
+
+from .manager import (  # noqa
+    LifecycleManager,
+)
+
+from .states import (  # noqa
+    LifecycleState,
+    LifecycleStateError,
+    LifecycleStates,
+)
+
+from .transitions import (  # noqa
+    LifecycleTransition,
+    LifecycleTransitions,
+)

omlish/lifecycles/abstract.py

@@ -0,0 +1,43 @@
+import typing as ta
+
+from .. import cached
+from .. import dataclasses as dc
+from .. import lang
+from .base import Lifecycle
+
+
+AbstractLifecycleT = ta.TypeVar('AbstractLifecycleT', bound='AbstractLifecycle')
+
+
+class AbstractLifecycle(lang.Abstract):
+    @dc.dataclass(frozen=True)
+    class _Lifecycle(Lifecycle, lang.Final, ta.Generic[AbstractLifecycleT]):
+        obj: AbstractLifecycleT
+
+        def lifecycle_construct(self) -> None:
+            self.obj._lifecycle_construct()  # noqa
+
+        def lifecycle_start(self) -> None:
+            self.obj._lifecycle_start()  # noqa
+
+        def lifecycle_stop(self) -> None:
+            self.obj._lifecycle_stop()  # noqa
+
+        def lifecycle_destroy(self) -> None:
+            self.obj._lifecycle_destroy()  # noqa
+
+    @cached.property
+    def _lifecycle(self) -> _Lifecycle[ta.Self]:
+        return AbstractLifecycle._Lifecycle(self)
+
+    def _lifecycle_construct(self) -> None:
+        pass
+
+    def _lifecycle_start(self) -> None:
+        pass
+
+    def _lifecycle_stop(self) -> None:
+        pass
+
+    def _lifecycle_destroy(self) -> None:
+        pass