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

omlish/lang/iterables.py

@@ -1,8 +1,11 @@
+import dataclasses as dc
 import itertools
 import typing as ta
 
 
 T = ta.TypeVar('T')
+S = ta.TypeVar('S')
+R = ta.TypeVar('R')
 
 
 BUILTIN_SCALAR_ITERABLE_TYPES: tuple[type, ...] = (
@@ -34,7 +37,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 +61,53 @@ 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))
+
+
+flatten = itertools.chain.from_iterable
+
+
+def flatmap(fn: ta.Callable[[T], ta.Iterable[R]], it: ta.Iterable[T]) -> ta.Iterable[R]:
+    return flatten(map(fn, it))
+
+
+class Generator(ta.Generator[T, S, R]):
+    def __init__(self, gen: ta.Generator[T, S, R]) -> None:
+        super().__init__()
+        self.gen = gen
+
+    value: R
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return self.send(None)
+
+    def send(self, v):
+        try:
+            return self.gen.send(v)
+        except StopIteration as e:
+            self.value = e.value
+            raise
+
+    def throw(self, *args):
+        try:
+            return self.gen.throw(*args)
+        except StopIteration as e:
+            self.value = e.value
+            raise
+
+    def close(self):
+        self.gen.close()

omlish/lang/maybes.py

@@ -65,6 +65,9 @@ class Maybe(abc.ABC, ta.Generic[T]):
 class _Maybe(Maybe[T], tuple):
     __slots__ = ()
 
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
     @property
     def present(self) -> bool:
         return bool(self)

omlish/lang/objects.py

@@ -1,5 +1,6 @@
 import types
 import typing as ta
+import weakref
 
 
 T = ta.TypeVar('T')
@@ -28,6 +29,28 @@ def opt_repr(obj: ta.Any) -> str | None:
 ##
 
 
+_CAN_WEAKREF_TYPE_MAP: ta.MutableMapping[type, bool] = weakref.WeakKeyDictionary()
+
+
+def can_weakref(obj: ta.Any) -> bool:
+    _type = type(obj)
+    try:
+        return _CAN_WEAKREF_TYPE_MAP[_type]
+    except KeyError:
+        pass
+    try:
+        weakref.ref(obj)
+    except TypeError:
+        ret = False
+    else:
+        ret = True
+    _CAN_WEAKREF_TYPE_MAP[_type] = ret
+    return ret
+
+
+##
+
+
 def new_type(
         name: str,
         bases: ta.Sequence[ta.Any],
@@ -62,6 +85,21 @@ def super_meta(
 ##
 
 
+def deep_subclasses(cls: type) -> ta.Iterator[type]:
+    seen = set()
+    todo = list(reversed(cls.__subclasses__()))
+    while todo:
+        cur = todo.pop()
+        if cur in seen:
+            continue
+        seen.add(cur)
+        yield cur
+        todo.extend(reversed(cur.__subclasses__()))
+
+
+##
+
+
 class SimpleProxy(ta.Generic[T]):
 
     class Descriptor:

omlish/lang/strings.py

@@ -126,3 +126,28 @@ def is_ident_cont(c: str) -> bool:
 
 def is_ident(name: str) -> bool:
     return is_ident_start(name[0]) and all(is_ident_cont(c) for c in name[1:])
+
+
+##
+
+
+BOOL_STRINGS: ta.Sequence[tuple[str, str]] = [
+    ('n', 'y'),
+    ('no', 'yes'),
+    ('f', 't'),
+    ('false', 'true'),
+    ('off', 'on'),
+    ('0', '1'),
+]
+
+BOOL_FALSE_STRINGS = frozenset(tup[0] for tup in BOOL_STRINGS)
+BOOL_TRUE_STRINGS = frozenset(tup[1] for tup in BOOL_STRINGS)
+
+STRING_BOOL_VALUES: ta.Mapping[str, bool] = {
+    k: v
+    for ks, v in [
+        (BOOL_FALSE_STRINGS, False),
+        (BOOL_TRUE_STRINGS, True),
+    ]
+    for k in ks
+}

omlish/lang/sys.py

@@ -1,6 +1,15 @@
 import sys
 
 
+REQUIRED_PYTHON_VERSION = (3, 12)
+
+
+def check_runtime_version() -> None:
+    if sys.version_info < REQUIRED_PYTHON_VERSION:
+        raise OSError(
+            f'Requires python {REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
+
+
 def is_gil_enabled() -> bool:
     if (fn := getattr(sys, '_is_gil_enabled', None)) is not None:
         return fn()

omlish/lang/typing.py

@@ -5,6 +5,7 @@ TODO:
   - probably need to gen types per inst
  - typed_factory
 """
+import dataclasses as dc
 import functools
 import inspect
 import typing as ta
@@ -12,6 +13,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
 
@@ -91,3 +97,39 @@ def typed_partial(obj, **kw):  # noqa
         },
     )(inner)
     return _update_wrapper_no_anns(lam, obj)
+
+
+##
+# A workaround for typing deficiencies (like `Argument 2 to NewType(...) must be subclassable`).
+
+
+@dc.dataclass(frozen=True)
+class Func0(ta.Generic[T]):
+    fn: ta.Callable[[], T]
+
+    def __call__(self) -> T:
+        return self.fn()
+
+
+@dc.dataclass(frozen=True)
+class Func1(ta.Generic[A0, T]):
+    fn: ta.Callable[[A0], T]
+
+    def __call__(self, a0: A0) -> T:
+        return self.fn(a0)
+
+
+@dc.dataclass(frozen=True)
+class Func2(ta.Generic[A0, A1, T]):
+    fn: ta.Callable[[A0, A1], T]
+
+    def __call__(self, a0: A0, a1: A1) -> T:
+        return self.fn(a0, a1)
+
+
+@dc.dataclass(frozen=True)
+class Func3(ta.Generic[A0, A1, A2, T]):
+    fn: ta.Callable[[A0, A1, A2], T]
+
+    def __call__(self, a0: A0, a1: A1, a2: A2) -> T:
+        return self.fn(a0, a1, a2)

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)

omlish/lifecycles/contextmanagers.py

@@ -0,0 +1,74 @@
+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
+from .states import LifecycleState
+from .states import LifecycleStates
+
+
+LifecycleT = ta.TypeVar('LifecycleT', bound='Lifecycle')
+ContextManagerT = ta.TypeVar('ContextManagerT', bound=ta.ContextManager)
+
+
+@dc.dataclass(frozen=True)
+class ContextManagerLifecycle(Lifecycle, lang.Final, ta.Generic[ContextManagerT]):
+    cm: ContextManagerT
+
+    @ta.override
+    def lifecycle_start(self) -> None:
+        self.cm.__enter__()
+
+    @ta.override
+    def lifecycle_stop(self) -> None:
+        self.cm.__exit__(None, None, None)
+
+
+class LifecycleContextManager(ta.Generic[LifecycleT]):
+
+    def __init__(self, lifecycle: LifecycleT) -> None:
+        super().__init__()
+        self._lifecycle = lifecycle
+        self._controller = lifecycle if isinstance(lifecycle, LifecycleController) else LifecycleController(lifecycle)
+
+    defs.repr('lifecycle', 'state')
+
+    @property
+    def lifecycle(self) -> LifecycleT:
+        return self._lifecycle
+
+    @property
+    def controller(self) -> LifecycleController:
+        return self._controller
+
+    @property
+    def state(self) -> LifecycleState:
+        return self._controller.state
+
+    def __enter__(self) -> ta.Self:
+        try:
+            self._controller.lifecycle_construct()
+            self._controller.lifecycle_start()
+        except Exception:
+            self._controller.lifecycle_destroy()
+            raise
+        return self
+
+    def __exit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: types.TracebackType | None,
+    ) -> bool | None:
+        try:
+            if self._controller.state is LifecycleStates.STARTED:
+                self._controller.lifecycle_stop()
+        except Exception:
+            self._controller.lifecycle_destroy()
+            raise
+        else:
+            self._controller.lifecycle_destroy()
+        return None

omlish/lifecycles/controller.py

@@ -0,0 +1,116 @@
+import typing as ta
+
+from .. import check
+from .. import defs
+from .. import lang
+from .base import Lifecycle
+from .states import LifecycleState
+from .states import LifecycleStates
+from .transitions import LifecycleTransition
+from .transitions import LifecycleTransitions
+
+
+LifecycleT = ta.TypeVar('LifecycleT', bound='Lifecycle')
+
+
+class LifecycleListener(ta.Generic[LifecycleT]):
+
+    def on_starting(self, obj: LifecycleT) -> None:
+        pass
+
+    def on_started(self, obj: LifecycleT) -> None:
+        pass
+
+    def on_stopping(self, obj: LifecycleT) -> None:
+        pass
+
+    def on_stopped(self, obj: LifecycleT) -> None:
+        pass
+
+
+class LifecycleController(Lifecycle, ta.Generic[LifecycleT]):
+
+    def __init__(
+            self,
+            lifecycle: LifecycleT,
+            *,
+            lock: lang.DefaultLockable = None,
+    ) -> None:
+        super().__init__()
+
+        self._lifecycle: LifecycleT = check.isinstance(lifecycle, Lifecycle)  # type: ignore
+        self._lock = lang.default_lock(lock, False)
+
+        self._state = LifecycleStates.NEW
+        self._listeners: list[LifecycleListener[LifecycleT]] = []
+
+    defs.repr('lifecycle', 'state')
+
+    @property
+    def lifecycle(self) -> LifecycleT:
+        return self._lifecycle
+
+    @property
+    def state(self) -> LifecycleState:
+        return self._state
+
+    def add_listener(self, listener: LifecycleListener[LifecycleT]) -> 'LifecycleController':
+        self._listeners.append(check.isinstance(listener, LifecycleListener))  # type: ignore
+        return self
+
+    def _advance(
+            self,
+            transition: LifecycleTransition,
+            lifecycle_fn: ta.Callable[[], None],
+            pre_listener_fn: ta.Callable[[LifecycleListener[LifecycleT]], ta.Callable[[LifecycleT], None]] | None = None,  # noqa
+            post_listener_fn: ta.Callable[[LifecycleListener[LifecycleT]], ta.Callable[[LifecycleT], None]] | None = None,  # noqa
+    ) -> None:
+        with self._lock():
+            if pre_listener_fn is not None:
+                for listener in self._listeners:
+                    pre_listener_fn(listener)(self._lifecycle)
+            check.state(self._state in transition.old)
+            self._state = transition.new_intermediate
+            try:
+                lifecycle_fn()
+            except Exception:
+                self._state = transition.new_failed
+                raise
+            self._state = transition.new_succeeded
+            if post_listener_fn is not None:
+                for listener in self._listeners:
+                    post_listener_fn(listener)(self._lifecycle)
+
+    ##
+
+    @ta.override
+    def lifecycle_construct(self) -> None:
+        self._advance(
+            LifecycleTransitions.CONSTRUCT,
+            self._lifecycle.lifecycle_construct,
+        )
+
+    @ta.override
+    def lifecycle_start(self) -> None:
+        self._advance(
+            LifecycleTransitions.START,
+            self._lifecycle.lifecycle_start,
+            lambda l: l.on_starting,
+            lambda l: l.on_started,
+        )
+
+    @ta.override
+    def lifecycle_stop(self) -> None:
+        self._advance(
+            LifecycleTransitions.STOP,
+            self._lifecycle.lifecycle_stop,
+            lambda l: l.on_stopping,
+            lambda l: l.on_stopped,
+        )
+
+    @ta.override
+    def lifecycle_destroy(self) -> None:
+        self._advance(
+            LifecycleTransitions.DESTROY,
+            self._lifecycle.lifecycle_destroy,
+        )