omlish 0.0.0.dev447__py3-none-any.whl → 0.0.0.dev493__py3-none-any.whl

omlish/lang/lazyglobals.py

@@ -1,3 +1,4 @@
+import threading
 import typing as ta
 
 
@@ -15,6 +16,10 @@ class AmbiguousLazyGlobalsFallbackError(Exception):
         return f'{self.__class__.__name__}({self.attr!r}, {self.fallbacks!r})'
 
 
+_LAZY_GLOBALS_LOCK = threading.RLock()
+
+
+@ta.final
 class LazyGlobals:
     def __init__(
             self,
@@ -22,8 +27,6 @@ class LazyGlobals:
             globals: ta.MutableMapping[str, ta.Any] | None = None,  # noqa
             update_globals: bool = False,
     ) -> None:
-        super().__init__()
-
         self._globals = globals
         self._update_globals = update_globals
 
@@ -37,18 +40,28 @@ class LazyGlobals:
         except KeyError:
             pass
         else:
-            if not isinstance(xga, cls):
+            if xga.__class__ is not cls:
                 raise RuntimeError(f'Module already has __getattr__ hook: {xga}')  # noqa
             return xga
 
-        lm = cls(
-            globals=globals,
-            update_globals=True,
-        )
+        with _LAZY_GLOBALS_LOCK:
+            try:
+                xga = globals['__getattr__']
+            except KeyError:
+                pass
+            else:
+                if xga.__class__ is not cls:
+                    raise RuntimeError(f'Module already has __getattr__ hook: {xga}')  # noqa
+                return xga
+
+            lm = cls(
+                globals=globals,
+                update_globals=True,
+            )
 
-        globals['__getattr__'] = lm
+            globals['__getattr__'] = lm
 
-        return lm
+            return lm
 
     def set_fn(self, attr: str, fn: ta.Callable[[], ta.Any]) -> 'LazyGlobals':
         self._attr_fns[attr] = fn

omlish/lang/params.py

@@ -1,6 +1,7 @@
 """
 TODO:
  - check validity
+ - signature vs getfullargspec - diff unwrapping + 'self' handling
 """
 import dataclasses as dc
 import enum
@@ -16,6 +17,13 @@ from .classes.restrict import Sealed
 T = ta.TypeVar('T')
 
 
+CanParamSpec: ta.TypeAlias = ta.Union[
+    'ParamSpec',
+    inspect.Signature,
+    ta.Callable,
+]
+
+
 ##
 
 
@@ -101,6 +109,15 @@ class ParamSpec(ta.Sequence[Param], Final):
 
     #
 
+    @classmethod
+    def of(cls, obj: CanParamSpec) -> 'ParamSpec':
+        if isinstance(obj, ParamSpec):
+            return obj
+        elif isinstance(obj, inspect.Signature):
+            return cls.of_signature(obj)
+        else:
+            return cls.inspect(obj)
+
     @classmethod
     def of_signature(
             cls,

omlish/lang/recursion.py

@@ -13,7 +13,6 @@ P = ta.ParamSpec('P')
 
 
 _LOCK = threading.RLock()
-
 _LOCAL: threading.local
 
 

omlish/lang/sequences.py

@@ -0,0 +1,124 @@
+"""
+TODO:
+ - StrView, BytesView - in lieu of hkt lol
+ - cext? even necessary?
+ - __eq__, cmp, __hash__
+ - __buffer__
+ - optimize `slice(None)`, keep as SeqView but fast path ops
+ - shorter repr if __len__ > some threshold
+  - use materialize()?
+"""
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+def iterslice(
+        seq: ta.Sequence[T],
+        slc: slice,
+) -> ta.Iterator[T]:
+    return map(seq.__getitem__, range(*slc.indices(len(seq))))
+
+
+def iterrange(
+        seq: ta.Sequence[T],
+        start: int | None = None,
+        stop: int | None = None,
+        step: int | None = None,
+) -> ta.Iterator[T]:
+    return iterslice(seq, slice(start, stop, step))
+
+
+##
+
+
+@ta.final
+class SeqView(ta.Sequence[T]):
+    def __init__(self, data: ta.Sequence[T], slice_: slice = slice(None)) -> None:
+        if data.__class__ is SeqView:
+            self._data = data._data  # type: ignore[attr-defined]  # noqa
+            self._range = data._range[slice_]  # type: ignore[attr-defined]  # noqa
+        else:
+            self._data = data
+            self._range = range(*slice_.indices(len(data)))
+
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
+    _data: ta.Sequence[T]
+    _range: range
+
+    @classmethod
+    def _from_range(cls, base: ta.Sequence[T], rng: range) -> 'SeqView[T]':
+        self = object.__new__(cls)
+        self._data = base
+        self._range = rng
+        return self
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._data!r}, {self.slice!r})'
+
+    #
+
+    def __len__(self) -> int:
+        return len(self._range)
+
+    def __getitem__(self, key: int | slice) -> ta.Union[T, 'SeqView[T]']:  # type: ignore[override]
+        if isinstance(key, slice):
+            nr = self._range[key]
+            return SeqView._from_range(self._data, nr)
+        return self._data[self._range[key]]
+
+    def __iter__(self) -> ta.Iterator[T]:
+        return map(self._data.__getitem__, self._range)
+
+    def __reversed__(self) -> ta.Iterator[T]:
+        return map(self._data.__getitem__, reversed(self._range))
+
+    def count(self, value: ta.Any) -> int:
+        c = 0
+        for i in self._range:
+            if self._data[i] == value:
+                c += 1
+        return c
+
+    def index(self, value: ta.Any, start: int = 0, stop: int | None = None) -> int:
+        sub = self._range[slice(start, stop, 1)]
+        for off, i in enumerate(sub):
+            if self._data[i] == value:
+                return off
+        raise ValueError(f'{value!r} is not in view')
+
+    #
+
+    @property
+    def data(self) -> ta.Sequence[T]:
+        return self._data
+
+    _slice: slice
+
+    @property
+    def slice(self) -> slice:
+        try:
+            return self._slice
+        except AttributeError:
+            pass
+
+        step = self._range.step
+        start = self._range.start
+        if len(self._range) == 0:
+            stop = start
+        else:
+            last = start + (len(self._range) - 1) * step
+            stop = last + (1 if step > 0 else -1)
+        slc = slice(start, stop, step)
+
+        self._slice = slc
+        return slc
+
+    def materialize(self) -> ta.Sequence[T]:
+        return self._data[self.slice]

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