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

omlish/lang/maybes.py

@@ -3,6 +3,7 @@ from ..lite.maybes import Maybe
 
 ##
 
-
+# These are classmethods on the lite `Maybe` class, and thus can't be directly `auto_proxy_init` imported in lang's
+# `__init__.py`.
 empty = Maybe.empty
 just = Maybe.just

omlish/lang/maysync.py

@@ -3,7 +3,7 @@ import typing as ta
 from ..lite.maysync import MaysyncFn
 from ..lite.maysync import MaysyncGeneratorFn
 from ..lite.maysync import make_maysync as _make_maysync
-from .functions import as_async
+from .asyncs import as_async
 
 
 T = ta.TypeVar('T')
@@ -68,5 +68,5 @@ def make_maysync_from_sync(
 ) -> ta.Callable[P, ta.Awaitable[T]]:
     return _make_maysync(
         s,
-        a if a is not None else as_async(s),
+        a if a is not None else as_async(s, wrap=True),
     )

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/resources.py

@@ -3,7 +3,7 @@ import functools
 import os.path
 import typing as ta
 
-from .imports.lazy import proxy_import
+from .imports.proxy import proxy_import
 
 
 if ta.TYPE_CHECKING:

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/contextmanagers.py

@@ -2,7 +2,6 @@ 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
@@ -37,7 +36,7 @@ class LifecycleContextManager(ta.Generic[LifecycleT]):
         self._lifecycle = lifecycle
         self._controller = lifecycle if isinstance(lifecycle, LifecycleController) else LifecycleController(lifecycle)
 
-    defs.repr('lifecycle', 'state')
+    __repr__ = lang.attr_ops(lambda o: (o.lifecycle, o.state)).repr
 
     @property
     def lifecycle(self) -> LifecycleT:

omlish/lifecycles/controller.py

@@ -2,7 +2,6 @@ import abc
 import typing as ta
 
 from .. import check
-from .. import defs
 from .. import lang
 from .base import AnyLifecycle  # noqa
 from .base import Lifecycle  # noqa
@@ -48,7 +47,7 @@ class AnyLifecycleController(AnyLifecycle[R], lang.Abstract, ta.Generic[AnyLifec
         self._state = LifecycleStates.NEW
         self._listeners: list[AnyLifecycleListener[AnyLifecycleT, R]] = []
 
-    defs.repr('lifecycle', 'state')
+    __repr__ = lang.attr_ops(lambda o: (o.lifecycle, o.state)).repr
 
     @property
     def lifecycle(self) -> AnyLifecycleT:

omlish/lite/abstract.py

@@ -3,6 +3,9 @@ import abc
 import typing as ta
 
 
+T = ta.TypeVar('T')
+
+
 ##
 
 
@@ -14,25 +17,49 @@ def is_abstract_method(obj: ta.Any) -> bool:
     return bool(getattr(obj, _IS_ABSTRACT_METHOD_ATTR, False))
 
 
-def update_abstracts(cls, *, force=False):
+def compute_abstract_methods(cls: type) -> ta.FrozenSet[str]:
+    # ~> https://github.com/python/cpython/blob/f3476c6507381ca860eec0989f53647b13517423/Modules/_abc.c#L358
+
+    # Stage 1: direct abstract methods
+
+    abstracts = {
+        a
+        # Get items as a list to avoid mutation issues during iteration
+        for a, v in list(cls.__dict__.items())
+        if is_abstract_method(v)
+    }
+
+    # Stage 2: inherited abstract methods
+
+    for base in cls.__bases__:
+        # Get __abstractmethods__ from base if it exists
+        if (base_abstracts := getattr(base, _ABSTRACT_METHODS_ATTR, None)) is None:
+            continue
+
+        # Iterate over abstract methods in base
+        for key in base_abstracts:
+            # Check if this class has an attribute with this name
+            try:
+                value = getattr(cls, key)
+            except AttributeError:
+                # Attribute not found in this class, skip
+                continue
+
+            # Check if it's still abstract
+            if is_abstract_method(value):
+                abstracts.add(key)
+
+    return frozenset(abstracts)
+
+
+def update_abstracts(cls: ta.Type[T], *, force: bool = False) -> ta.Type[T]:
     if not force and not hasattr(cls, _ABSTRACT_METHODS_ATTR):
         # Per stdlib: We check for __abstractmethods__ here because cls might by a C implementation or a python
         # implementation (especially during testing), and we want to handle both cases.
         return cls
 
-    abstracts: ta.Set[str] = set()
-
-    for scls in cls.__bases__:
-        for name in getattr(scls, _ABSTRACT_METHODS_ATTR, ()):
-            value = getattr(cls, name, None)
-            if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-                abstracts.add(name)
-
-    for name, value in cls.__dict__.items():
-        if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-            abstracts.add(name)
-
-    setattr(cls, _ABSTRACT_METHODS_ATTR, frozenset(abstracts))
+    abstracts = compute_abstract_methods(cls)
+    setattr(cls, _ABSTRACT_METHODS_ATTR, abstracts)
     return cls
 
 
@@ -86,23 +113,26 @@ class Abstract:
         super().__init_subclass__(**kwargs)
 
         if not (Abstract in cls.__bases__ or abc.ABC in cls.__bases__):
-            ams = {a: cls for a, o in cls.__dict__.items() if is_abstract_method(o)}
-
-            seen = set(cls.__dict__)
-            for b in cls.__bases__:
-                ams.update({a: b for a in set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen})  # noqa
-                seen.update(dir(b))
+            if ams := compute_abstract_methods(cls):
+                amd = {
+                    a: mcls
+                    for mcls in cls.__mro__[::-1]
+                    for a in ams
+                    if a in mcls.__dict__
+                }
 
-            if ams:
                 raise AbstractTypeError(
                     f'Cannot subclass abstract class {cls.__name__} with abstract methods: ' +
                     ', '.join(sorted([
                         '.'.join([
-                            *([m] if (m := getattr(c, '__module__')) else []),
-                            getattr(c, '__qualname__', getattr(c, '__name__')),
+                            *([
+                                *([m] if (m := getattr(c, '__module__')) else []),
+                                getattr(c, '__qualname__', getattr(c, '__name__')),
+                            ] if c is not None else '?'),
                             a,
                         ])
-                        for a, c in ams.items()
+                        for a in ams
+                        for c in [amd.get(a)]
                     ])),
                 )
 

omlish/lite/asyncs.py

@@ -0,0 +1,146 @@
+# ruff: noqa: UP006 UP045
+import functools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+async def opt_await(aw: ta.Optional[ta.Awaitable[T]]) -> ta.Optional[T]:
+    return (await aw if aw is not None else None)
+
+
+async def async_list(ai: ta.AsyncIterable[T]) -> ta.List[T]:
+    return [v async for v in ai]
+
+
+async def async_enumerate(ai: ta.AsyncIterable[T]) -> ta.AsyncIterable[ta.Tuple[int, T]]:
+    i = 0
+    async for e in ai:
+        yield (i, e)
+        i += 1
+
+
+##
+
+
+def as_async(fn: ta.Callable[..., T], *, wrap: bool = False) -> ta.Callable[..., ta.Awaitable[T]]:
+    async def inner(*args, **kwargs):
+        return fn(*args, **kwargs)
+
+    return functools.wraps(fn)(inner) if wrap else inner
+
+
+##
+
+
+class SyncAwaitCoroutineNotTerminatedError(Exception):
+    pass
+
+
+def sync_await(aw: ta.Awaitable[T]) -> T:
+    """
+    Allows for the synchronous execution of async functions which will never actually *externally* await anything. These
+    functions are allowed to await any number of other functions - including contextmanagers and generators - so long as
+    nothing ever actually 'leaks' out of the function, presumably to an event loop.
+    """
+
+    ret = missing = object()
+
+    async def thunk():
+        nonlocal ret
+
+        ret = await aw
+
+    cr = thunk()
+    try:
+        try:
+            cr.send(None)
+        except StopIteration:
+            pass
+
+        if ret is missing or cr.cr_await is not None or cr.cr_running:
+            raise SyncAwaitCoroutineNotTerminatedError('Not terminated')
+
+    finally:
+        cr.close()
+
+    return ta.cast(T, ret)
+
+
+#
+
+
+def sync_aiter(ai: ta.AsyncIterator[T]) -> ta.Iterator[T]:
+    while True:
+        try:
+            o = sync_await(ai.__anext__())
+        except StopAsyncIteration:
+            break
+        yield o
+
+
+def sync_async_list(ai: ta.AsyncIterable[T]) -> ta.List[T]:
+    """
+    Uses `sync_await` to synchronously read the full contents of a function call returning an async iterator, given that
+    the function never externally awaits anything.
+    """
+
+    lst: ta.Optional[ta.List[T]] = None
+
+    async def inner():
+        nonlocal lst
+
+        lst = [v async for v in ai]
+
+    sync_await(inner())
+
+    if not isinstance(lst, list):
+        raise TypeError(lst)
+
+    return lst
+
+
+#
+
+
+@ta.final
+class SyncAwaitContextManager(ta.Generic[T]):
+    def __init__(self, acm: ta.AsyncContextManager[T]) -> None:
+        self._acm = acm
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._acm!r})'
+
+    def __enter__(self) -> T:
+        return sync_await(self._acm.__aenter__())
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return sync_await(self._acm.__aexit__(exc_type, exc_val, exc_tb))
+
+
+sync_async_with = SyncAwaitContextManager
+
+
+##
+
+
+@ta.final
+class SyncToAsyncContextManager(ta.Generic[T]):
+    def __init__(self, cm: ta.ContextManager[T]) -> None:
+        self._cm = cm
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._cm!r})'
+
+    async def __aenter__(self) -> T:
+        return self._cm.__enter__()
+
+    async def __aexit__(self, exc_type, exc_value, traceback, /):
+        return self._cm.__exit__(exc_type, exc_value, traceback)
+
+
+as_async_context_manager = SyncToAsyncContextManager