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

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)
 
@@ -89,7 +90,7 @@ class PackageSealed:
 class NotInstantiable(Abstract):
     __slots__ = ()
 
-    def __new__(cls, *args, **kwargs):
+    def __new__(cls, *args, **kwargs):  # noqa
         raise TypeError
 
 

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/classes/virtual.py

@@ -3,8 +3,8 @@ import types
 import typing as ta
 
 from .abstract import make_abstract
-from .restrict import NotInstantiable
 from .restrict import Final
+from .restrict import NotInstantiable
 
 
 T = ta.TypeVar('T')
@@ -122,7 +122,7 @@ class Callable(NotInstantiable, Final, ta.Generic[T]):
 
     @classmethod
     def __subclasscheck__(cls, subclass: type) -> bool:
-        if not hasattr(subclass, '__call__'):
+        if not hasattr(subclass, '__call__'):  # noqa
             return False
         call = subclass.__call__
         if isinstance(call, types.MethodWrapperType) and call.__self__ is subclass:

omlish/lang/contextmanagers.py

@@ -1,3 +1,8 @@
+"""
+TODO:
+ - AsyncExitStacked
+"""
+import abc
 import contextlib
 import contextvars
 import functools
@@ -14,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__(
@@ -50,6 +55,69 @@ NOP_CONTEXT_MANAGER = NopContextManager()
 ##
 
 
+class ContextManager(abc.ABC, ta.Generic[T]):
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if not hasattr(cls.__contextmanager__, '_is_contextmanager'):
+            cls.__contextmanager__ = contextlib.contextmanager(cls.__contextmanager__)  # type: ignore  # noqa
+            cls.__contextmanager__._is_contextmanager = True  # type: ignore  # noqa
+
+    @abc.abstractmethod
+    def __contextmanager__(self) -> ta.Iterable[T]:
+        raise NotImplementedError
+
+    __contextmanager__._is_contextmanager = True  # type: ignore  # noqa
+
+    _contextmanager: ta.Any
+
+    def __enter__(self) -> T:
+        self._contextmanager = self.__contextmanager__()
+        return self._contextmanager.__enter__()  # type: ignore
+
+    def __exit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: types.TracebackType | None,
+    ) -> bool | None:
+        return self._contextmanager.__exit__(exc_type, exc_val, exc_tb)
+
+
+class AsyncContextManager(abc.ABC, ta.Generic[T]):
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if not hasattr(cls.__asynccontextmanager__, '_is_asynccontextmanager'):
+            cls.__asynccontextmanager__ = contextlib.asynccontextmanager(cls.__asynccontextmanager__)  # type: ignore  # noqa
+            cls.__asynccontextmanager__._is_asynccontextmanager = True  # type: ignore  # noqa
+
+    @abc.abstractmethod
+    def __asynccontextmanager__(self) -> ta.AsyncIterator[T]:
+        raise NotImplementedError
+
+    __asynccontextmanager__._is_asynccontextmanager = True  # type: ignore  # noqa
+
+    _asynccontextmanager: ta.Any
+
+    async def __aenter__(self) -> T:
+        self._asynccontextmanager = self.__asynccontextmanager__()
+        return await self._asynccontextmanager.__aenter__()  # type: ignore
+
+    async def __aexit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: types.TracebackType | None,
+    ) -> None:
+        return await self._asynccontextmanager.__aexit__(exc_type, exc_val, exc_tb)
+
+
+##
+
+
 @contextlib.contextmanager
 def defer(fn: ta.Callable) -> ta.Generator[ta.Callable, None, None]:
     try:
@@ -134,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:
@@ -242,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/datetimes.py

@@ -18,17 +18,18 @@ def months_ago(date: datetime.date, num: int) -> datetime.date:
     return datetime.date(ago_year, ago_month, 1)
 
 
-def parse_date(s: str) -> datetime.date:
+def parse_date(s: str, tz: datetime.timezone | None = None) -> datetime.date:
+
     if s.lower() in ['today', 'now']:
-        return datetime.date.today()
+        return datetime.datetime.now(tz=tz)
     elif s.lower() == 'yesterday':
-        return datetime.date.today() - datetime.timedelta(days=1)
+        return datetime.datetime.now(tz=tz) - datetime.timedelta(days=1)
     elif s.lower().endswith(' days ago'):
         num = int(s.split(' ', 1)[0])
-        return datetime.date.today() - datetime.timedelta(days=num)
+        return datetime.datetime.now(tz=tz) - datetime.timedelta(days=num)
     elif s.lower().endswith(' months ago'):
         months = int(s.split(' ', 1)[0])
-        return months_ago(datetime.date.today(), months)
+        return months_ago(datetime.datetime.now(tz=tz), months)
     else:
         return datetime.date(*map(int, s.split('-', 3)))
 

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
 
@@ -148,6 +128,16 @@ 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/imports.py

@@ -1,6 +1,6 @@
 import contextlib
 import functools
-import importlib.resources
+import importlib.util
 import sys
 import types
 import typing as ta
@@ -11,6 +11,13 @@ from .cached import cached_function
 ##
 
 
+def can_import(name: str, package: str | None = None) -> bool:
+    return importlib.util.find_spec(name, package) is not None
+
+
+##
+
+
 def lazy_import(name: str, package: str | None = None) -> ta.Callable[[], ta.Any]:
     return cached_function(functools.partial(importlib.import_module, name, package=package))
 
@@ -66,6 +73,8 @@ def yield_importable(
         filter: ta.Callable[[str], bool] | None = None,  # noqa
         include_special: bool = False,
 ) -> ta.Iterator[str]:
+    from importlib import resources
+
     def rec(cur):
         if cur.split('.')[-1] == '__pycache__':
             return
@@ -83,7 +92,7 @@ def yield_importable(
         if getattr(module, '__file__', None) is None:
             return
 
-        for file in importlib.resources.files(cur).iterdir():
+        for file in resources.files(cur).iterdir():
             if file.is_file() and file.name.endswith('.py'):
                 if not (include_special or file.name not in SPECIAL_IMPORTABLE):
                     continue

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

@@ -3,6 +3,7 @@ TODO:
  - typed_lambda is really kinda just 'annotate'
  - TypedLambda / TypedPartial classes, picklable, reprs
   - probably need to gen types per inst
+ - typed_factory
 """
 import functools
 import inspect
@@ -11,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

omlish/lifecycles/base.py

@@ -0,0 +1,51 @@
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+
+
+LifecycleT = ta.TypeVar('LifecycleT', bound='Lifecycle')
+LifecycleCallback: ta.TypeAlias = ta.Callable[[LifecycleT], None]
+
+
+class Lifecycle:
+
+    def lifecycle_construct(self) -> None:
+        pass
+
+    def lifecycle_start(self) -> None:
+        pass
+
+    def lifecycle_stop(self) -> None:
+        pass
+
+    def lifecycle_destroy(self) -> None:
+        pass
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class CallbackLifecycle(Lifecycle, lang.Final, ta.Generic[LifecycleT]):
+    on_construct: LifecycleCallback['CallbackLifecycle[LifecycleT]'] | None = None
+    on_start: LifecycleCallback['CallbackLifecycle[LifecycleT]'] | None = None
+    on_stop: LifecycleCallback['CallbackLifecycle[LifecycleT]'] | None = None
+    on_destroy: LifecycleCallback['CallbackLifecycle[LifecycleT]'] | None = None
+
+    @ta.override
+    def lifecycle_construct(self) -> None:
+        if self.on_construct is not None:
+            self.on_construct(self)
+
+    @ta.override
+    def lifecycle_start(self) -> None:
+        if self.on_start is not None:
+            self.on_start(self)
+
+    @ta.override
+    def lifecycle_stop(self) -> None:
+        if self.on_stop is not None:
+            self.on_stop(self)
+
+    @ta.override
+    def lifecycle_destroy(self) -> None:
+        if self.on_destroy is not None:
+            self.on_destroy(self)