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

omlish/lang/objects.py

@@ -2,6 +2,7 @@ import types
 import typing as ta
 import weakref
 
+from ..lite.maybes import Maybe
 from .classes.abstract import is_abstract_class
 
 
@@ -24,6 +25,18 @@ def opt_repr(obj: ta.Any) -> str | None:
     return repr(obj)
 
 
+def just_repr(obj: Maybe) -> str | None:
+    return obj.map(repr).or_none()
+
+
+def opt_or_just_repr(obj: ta.Any) -> str | None:
+    if isinstance(obj, Maybe):
+        if obj.present:
+            return repr(obj)
+        return None
+    return opt_repr(obj)
+
+
 ##
 
 

omlish/lang/outcomes.py

@@ -214,7 +214,7 @@ class Value(Outcome[ValueT_co], ta.Generic[ValueT_co]):
 
     @property
     def is_error(self) -> bool:
-        return True
+        return False
 
     def value(self) -> ValueT_co:
         return self._value

omlish/lang/recursion.py

@@ -65,7 +65,7 @@ def recursion_limiting_context(key: ta.Any, limit: int | None) -> ta.Iterator[in
     except KeyError:
         pd = None
     else:
-        if not isinstance(pd, int) and pd > 0:  # type: ignore[operator]
+        if not (isinstance(pd, int) and pd > 0):
             raise RuntimeError
 
     if pd is not None and pd >= limit:

omlish/lang/sequences.py

@@ -8,6 +8,7 @@ TODO:
  - shorter repr if __len__ > some threshold
   - use materialize()?
 """
+import operator
 import typing as ta
 
 
@@ -36,6 +37,38 @@ def iterrange(
 ##
 
 
+def seqs_all(
+        fn: ta.Callable[[T, T], bool],
+        l_seq: ta.Sequence[T],
+        *r_seqs: ta.Sequence[T],
+) -> bool:
+    if not all(len(r_seq) == len(l_seq) for r_seq in r_seqs):
+        return False
+
+    return all(
+        fn(l, r)
+        for r_seq in r_seqs
+        for l, r in zip(l_seq, r_seq, strict=True)
+    )
+
+
+def seqs_equal(
+        l_seq: ta.Sequence[T],
+        *r_seqs: ta.Sequence[T],
+) -> bool:
+    return seqs_all(operator.eq, l_seq, *r_seqs)
+
+
+def seqs_identical(
+        l_seq: ta.Sequence[T],
+        *r_seqs: ta.Sequence[T],
+) -> bool:
+    return seqs_all(operator.is_, l_seq, *r_seqs)
+
+
+##
+
+
 @ta.final
 class SeqView(ta.Sequence[T]):
     def __init__(self, data: ta.Sequence[T], slice_: slice = slice(None)) -> None:

omlish/lifecycles/README.md

@@ -0,0 +1,30 @@
+Lifecycle management, inspired by [governator](https://github.com/Netflix/governator/tree/master/governator-core/).
+
+A central idea is to 'hide the guts' of a given class's lifecycle management from code interacting with it.
+
+The main classes are as follows:
+
+- Lifecycle / AsyncLifecycle - the code 'managed by' the rest of the lifecycle machinery. In general, user code will
+  hide its implementations of these from the code that otherwise interacts with it. Being the lowest level / unit of
+  management callbacks, it intentionally provides no additional machinery, existing solely as a skeleton of methods
+  which will be called by lifecycle internals - this is to reduce friction with more functional / less OO code. However,
+  it still chooses to be a class with multiple nullary methods, rather than a more functional-style single unary free
+  function: the operations present in each method are generally intended to have no overlap in practice, and their
+  explicit division is a conscious choice.
+
+- LifecycleManaged / AsyncLifecycleManaged - a mixin which can be used to add lifecycle management behavior to a class.
+  This removes the need for manual subclassing of Lifecycle / AsyncLifecycle, providing private '\_lifecycle_<state>'
+  callback methods (with default no-op implementations) which subclasses may override.
+
+- LifecycleListener / AsyncLifecycleListener - callback interfaces whose methods will be called when a lifecycle object
+  goes through a lifecycle state transition.
+
+- LifecycleController / AsyncLifecycleController - these classes run the state machine for any single Lifecycle /
+  AsyncLifecycle instance. They are also responsible for maintaining a registry of lifecycle listeners and calling their
+  methods as necessary. Unlike user code, these classes are openly subclasses of Lifecycle / AsyncLifecycle, allowing
+  them to be called as application state dictates - they will internally ensure correct state transitions.
+
+- LifecycleManager / AsyncLifecycleManager - these classes are responsible for construction and operation of (acyclic)
+  graphs of lifecycle objects. They will ensure that, as necessary according to registered dependencies, lifecycle
+  objects are started in the correct order, and that they are stopped in the correct order. This class is itself a
+  LifecycleManaged / AsyncLifecycleManaged. Notably, AsyncLifecycleManager can also manage sync Lifecycles.

omlish/lifecycles/__init__.py

@@ -1,43 +1,71 @@
-from .abstract import (  # noqa
-    AbstractLifecycle,
+from .. import dataclasses as _dc
 
-    AbstractAsyncLifecycle,
+
+_dc.init_package(
+    globals(),
+    codegen=True,
 )
 
+
+##
+
+
 from .base import (  # noqa
-    AnyLifecycleCallback,
+    Lifecycle,
+    AsyncLifecycle,
     AnyLifecycle,
-    AnyCallbackLifecycle,
+    ANY_LIFECYCLE_TYPES,
 
-    LifecycleCallback,
-    CallbackLifecycle,
-    Lifecycle,
+    sync_to_async_lifecycle,
+    as_async_lifecycle,
+    async_to_sync_lifecycle,
+    as_sync_lifecycle,
 
-    AsyncLifecycleCallback,
+    CallbackLifecycle,
     CallbackAsyncLifecycle,
-    AsyncLifecycle,
 )
 
 from .contextmanagers import (  # noqa
     ContextManagerLifecycle,
+    AsyncContextManagerLifecycle,
+
     LifecycleContextManager,
+    AsyncLifecycleContextManager,
+
+    lifecycle_context_manage,
+    async_lifecycle_context_manage,
 )
 
 from .controller import (  # noqa
-    AnyLifecycleListener,
+    LifecycleController,
+    AsyncLifecycleController,
     AnyLifecycleController,
+    ANY_LIFECYCLE_CONTROLLER_TYPES,
+)
 
-    LifecycleController,
+from .listeners import (  # noqa
     LifecycleListener,
+    AsyncLifecycleListener,
+    AnyLifecycleListener,
+    ANY_LIFECYCLE_LISTENER_TYPES,
+)
+
+from .managed import (  # noqa
+    LifecycleManaged,
+    AsyncLifecycleManaged,
+    AnyLifecycleManaged,
+    ANY_LIFECYCLE_MANAGED_TYPES,
 )
 
 from .manager import (  # noqa
+    LifecycleManagerEntry,
     LifecycleManager,
+    AsyncLifecycleManager,
 )
 
 from .states import (  # noqa
-    LifecycleState,
     LifecycleStateError,
+    LifecycleState,
     LifecycleStates,
 )
 
@@ -45,3 +73,49 @@ from .transitions import (  # noqa
     LifecycleTransition,
     LifecycleTransitions,
 )
+
+from .unwrap import (  # noqa
+    unwrap_lifecycle,
+    unwrap_async_lifecycle,
+    unwrap_any_lifecycle,
+)
+
+
+##
+
+
+from .. import lang as _lang  # noqa
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from .injection import (  # noqa
+        bind_lifecycle_registrar,
+        bind_async_lifecycle_registrar,
+
+        bind_managed_lifecycle_manager,
+        bind_async_managed_lifecycle_manager,
+    )
+
+
+##
+
+
+NEW = LifecycleStates.NEW
+
+CONSTRUCTING = LifecycleStates.CONSTRUCTING
+FAILED_CONSTRUCTING = LifecycleStates.FAILED_CONSTRUCTING
+CONSTRUCTED = LifecycleStates.CONSTRUCTED
+
+STARTING = LifecycleStates.STARTING
+FAILED_STARTING = LifecycleStates.FAILED_STARTING
+STARTED = LifecycleStates.STARTED
+
+STOPPING = LifecycleStates.STOPPING
+FAILED_STOPPING = LifecycleStates.FAILED_STOPPING
+STOPPED = LifecycleStates.STOPPED
+
+DESTROYING = LifecycleStates.DESTROYING
+FAILED_DESTROYING = LifecycleStates.FAILED_DESTROYING
+DESTROYED = LifecycleStates.DESTROYED