omlish 0.0.0.dev255__py3-none-any.whl → 0.0.0.dev256__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev255'
-__revision__ = '68bcce87dfef9de1ab636cae14e4cbf5d71889cd'
+__version__ = '0.0.0.dev256'
+__revision__ = '41ce70ebb24f5066558a05aaf75e9f6b94de11c1'
 
 
 #

omlish/asyncs/anyio/__init__.py

@@ -0,0 +1,74 @@
+"""
+TODO:
+ - bane
+  - owned lock
+  - async once
+
+See:
+ - https://github.com/davidbrochart/sqlite-anyio/blob/a3ba4c6ef0535b14a5a60071fcd6ed565a514963/sqlite_anyio/sqlite.py
+ - https://github.com/rafalkrupinski/ratelimit-anyio/blob/2910a8a3d6fa54ed17ee6ba457686c9f7a4c4beb/src/ratelimit_anyio/__init__.py
+ - https://github.com/nekitdev/async-extensions/tree/main/async_extensions
+ - https://github.com/kinnay/anynet/tree/master/anynet
+ - https://github.com/M-o-a-T/asyncscope
+ - https://github.com/M-o-a-T/aevent
+ - https://github.com/florimondmanca/aiometer
+ - https://github.com/sanitizers/octomachinery/blob/b36c3d3d49da813ac46e361424132955a4e99ac8/octomachinery/utils/asynctools.py
+
+==
+
+async def killer(shutdown: anyio.Event, sleep_s: float) -> None:
+    log.warning('Killing in %d seconds', sleep_s)
+    await anyio.sleep(sleep_s)
+    log.warning('Killing')
+    shutdown.set()
+
+"""  # noqa
+
+from .backends import (  # noqa
+    BackendTask,
+    get_backend_task,
+    get_current_backend_task,
+)
+
+from .futures import (  # noqa
+    FutureError,
+    FutureOutcomeAlreadySetError,
+
+    Future,
+
+    create_future,
+)
+
+from .signals import (  # noqa
+    install_shutdown_signal_handler,
+)
+
+from .streams import (  # noqa
+    MemoryObjectReceiveStream,
+    MemoryObjectSendStream,
+
+    StapledByteStream,
+    StapledObjectStream,
+
+    MemoryStapledObjectStream,
+
+    split_memory_object_streams,
+    create_stapled_memory_object_stream,
+    create_memory_object_stream,
+    staple_memory_object_stream,
+    staple_memory_object_stream2,
+)
+
+from .sync import (  # noqa
+    Once,
+    Lazy,
+    LazyFn,
+)
+
+from .utils import (  # noqa
+    eof_to_empty,
+    gather,
+    first,
+
+    get_current_task,
+)

omlish/asyncs/anyio/backends.py

@@ -0,0 +1,52 @@
+import typing as ta
+
+import anyio
+
+from .utils import get_current_task
+
+
+##
+
+
+BackendTask: ta.TypeAlias = ta.Union[  # noqa
+    # asyncio.tasks.Task,
+    # trio.lowlevel.Task,
+    ta.Any,
+]
+
+
+def _is_class_named(obj: ta.Any, m: str, n: str) -> bool:
+    cls = obj.__class__
+    return cls.__module__ == m and cls.__name__ == n
+
+
+def get_backend_task(at: anyio.TaskInfo) -> BackendTask | None:
+    if _is_class_named(at, 'anyio._backends._asyncio', 'AsyncIOTaskInfo'):
+        # https://github.com/agronholm/anyio/blob/8907964926a24461840eee0925d3f355e729f15d/src/anyio/_backends/_asyncio.py#L1846  # noqa
+        # weakref.ref
+        obj = at._task()  # type: ignore  # noqa
+        if obj is not None and not (
+                _is_class_named(obj, '_asyncio', 'Task') or
+                _is_class_named(obj, 'asyncio.tasks', 'Task')
+        ):
+            raise TypeError(obj)
+        return obj
+
+    elif _is_class_named(at, 'anyio._backends._trio', 'TrioTaskInfo'):
+        # https://github.com/agronholm/anyio/blob/8907964926a24461840eee0925d3f355e729f15d/src/anyio/_backends/_trio.py#L850  # noqa
+        # weakref.proxy
+        # https://stackoverflow.com/a/62144308 :|
+        obj = at._task.__repr__.__self__  # type: ignore  # noqa
+        if obj is not None and not _is_class_named(obj, 'trio.lowlevel', 'Task'):
+            raise TypeError(obj)
+        return obj
+
+    else:
+        raise TypeError(at)
+
+
+def get_current_backend_task() -> BackendTask | None:
+    if (at := get_current_task()) is not None:
+        return get_backend_task(at)
+    else:
+        return None

omlish/asyncs/anyio/futures.py

@@ -0,0 +1,104 @@
+"""
+TODO:
+ - CancellableFuture
+"""
+import abc
+import typing as ta
+
+import anyio
+
+from ... import lang
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class FutureError(Exception):
+    pass
+
+
+class FutureOutcomeAlreadySetError(FutureError):
+    pass
+
+
+##
+
+
+class Future(lang.Abstract, ta.Awaitable[lang.Outcome[T]]):
+    @abc.abstractmethod
+    def __await__(self):
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def outcome(self) -> lang.Maybe[lang.Outcome[T]]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def set_outcome(self, o: lang.Outcome[T]) -> None:
+        raise NotImplementedError
+
+    def set_value(self, v: T) -> None:
+        self.set_outcome(lang.Value(v))
+
+    def set_error(self, e: BaseException) -> None:
+        self.set_outcome(lang.Error(e))
+
+
+##
+
+
+class _FutureImpl(Future[T]):
+    def __init__(self, *, event: anyio.Event | None = None) -> None:
+        super().__init__()
+
+        self._outcome: lang.Maybe[lang.Outcome[T]] = lang.empty()
+
+        if event is None:
+            event = anyio.Event()
+        self._event = event
+
+    def __await__(self):
+        if (o := self._outcome).present:
+            return o
+        yield from self._event.wait().__await__()
+        return self._outcome.must()
+
+    @property
+    def outcome(self) -> lang.Maybe[lang.Outcome[T]]:
+        return self._outcome
+
+    def set_outcome(self, o: lang.Outcome[T]) -> None:
+        if self._outcome.present:
+            raise FutureOutcomeAlreadySetError
+        self._outcome = lang.just(o)
+        self._event.set()
+
+
+##
+
+
+def _create_future() -> Future[T]:
+    return _FutureImpl()
+
+
+# PEP695 workaround
+class create_future(Future[T]):  # noqa
+    def __new__(cls) -> Future[T]:  # type: ignore[misc]
+        return _create_future()
+
+    def __init__(self) -> None:
+        raise TypeError
+
+    def __await__(self):
+        raise TypeError
+
+    @property
+    def outcome(self) -> lang.Maybe[lang.Outcome[T]]:
+        raise TypeError
+
+    def set_outcome(self, o: lang.Outcome[T]) -> None:
+        raise TypeError

omlish/asyncs/anyio/signals.py

@@ -0,0 +1,33 @@
+import signal
+import typing as ta
+
+import anyio.abc
+
+
+##
+
+
+async def install_shutdown_signal_handler(
+        tg: anyio.abc.TaskGroup,
+        event: anyio.Event | None = None,
+        *,
+        signals: ta.Iterable[int] = (signal.SIGINT, signal.SIGTERM),
+        echo: bool = False,
+) -> ta.Callable[..., ta.Awaitable[None]] | None:
+    if event is None:
+        event = anyio.Event()
+
+    async def _handler(*, task_status=anyio.TASK_STATUS_IGNORED):
+        with anyio.open_signal_receiver(*signals) as it:  # type: ignore
+            task_status.started()
+            async for signum in it:
+                if echo:
+                    if signum == signal.SIGINT:
+                        print('Ctrl+C pressed!')
+                    else:
+                        print('Terminated!')
+                event.set()
+                return
+
+    await tg.start(_handler)
+    return event.wait

omlish/asyncs/anyio/streams.py

@@ -0,0 +1,69 @@
+import dataclasses as dc
+import typing as ta
+
+import anyio.streams.memory
+import anyio.streams.stapled
+
+from ... import check
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+MemoryObjectReceiveStream: ta.TypeAlias = anyio.streams.memory.MemoryObjectReceiveStream
+MemoryObjectSendStream: ta.TypeAlias = anyio.streams.memory.MemoryObjectSendStream
+
+StapledByteStream: ta.TypeAlias = anyio.streams.stapled.StapledByteStream
+StapledObjectStream: ta.TypeAlias = anyio.streams.stapled.StapledObjectStream
+
+
+@dc.dataclass(eq=False)
+class MemoryStapledObjectStream(StapledObjectStream[T]):
+    send_stream: MemoryObjectSendStream[T]
+    receive_stream: MemoryObjectReceiveStream[T]
+
+
+def split_memory_object_streams(
+        *args: anyio.create_memory_object_stream[T],
+) -> tuple[
+    MemoryObjectSendStream[T],
+    MemoryObjectReceiveStream[T],
+]:
+    [tup] = args
+    return tup  # noqa
+
+
+def create_stapled_memory_object_stream(max_buffer_size: float = 0) -> MemoryStapledObjectStream:
+    return MemoryStapledObjectStream(*anyio.create_memory_object_stream(max_buffer_size))
+
+
+# FIXME: https://github.com/python/mypy/issues/15238
+# FIXME: https://youtrack.jetbrains.com/issues?q=tag:%20%7BPEP%20695%7D
+def create_memory_object_stream[T](max_buffer_size: float = 0) -> tuple[
+    MemoryObjectSendStream[T],
+    MemoryObjectReceiveStream[T],
+]:
+    return anyio.create_memory_object_stream[T](max_buffer_size)  # noqa
+
+
+def staple_memory_object_stream(
+        *args: anyio.create_memory_object_stream[T],
+) -> MemoryStapledObjectStream[T]:
+    send, receive = args
+    return MemoryStapledObjectStream(
+        check.isinstance(send, MemoryObjectSendStream),  # type: ignore
+        check.isinstance(receive, MemoryObjectReceiveStream),  # type: ignore
+    )
+
+
+# FIXME: https://github.com/python/mypy/issues/15238
+# FIXME: https://youtrack.jetbrains.com/issues?q=tag:%20%7BPEP%20695%7D
+def staple_memory_object_stream2[T](max_buffer_size: float = 0) -> MemoryStapledObjectStream[T]:
+    send, receive = anyio.create_memory_object_stream[T](max_buffer_size)
+    return MemoryStapledObjectStream(
+        check.isinstance(send, MemoryObjectSendStream),  # type: ignore
+        check.isinstance(receive, MemoryObjectReceiveStream),  # type: ignore
+    )

omlish/asyncs/anyio/sync.py

@@ -0,0 +1,69 @@
+import typing as ta
+
+import anyio
+
+from ... import lang
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class Once:
+    def __init__(self) -> None:
+        super().__init__()
+        self._done = False
+        self._lock = anyio.Lock()
+
+    async def do(self, fn: ta.Callable[[], ta.Awaitable[None]]) -> bool:
+        if self._done:
+            return False
+        async with self._lock:
+            if self._done:
+                return False  # type: ignore
+            try:
+                await fn()
+            finally:
+                self._done = True
+            return True
+
+
+class Lazy(ta.Generic[T]):
+    def __init__(self) -> None:
+        super().__init__()
+        self._once = Once()
+        self._v: lang.Maybe[T] = lang.empty()
+
+    def peek(self) -> lang.Maybe[T]:
+        return self._v
+
+    def set(self, v: T) -> None:
+        self._v = lang.just(v)
+
+    async def get(self, fn: ta.Callable[[], ta.Awaitable[T]]) -> T:
+        async def do():
+            self._v = lang.just(await fn())
+        await self._once.do(do)
+        return self._v.must()
+
+
+class LazyFn(ta.Generic[T]):
+    def __init__(self, fn: ta.Callable[[], ta.Awaitable[T]]) -> None:
+        super().__init__()
+        self._fn = fn
+        self._once = Once()
+        self._v: lang.Maybe[T] = lang.empty()
+
+    def peek(self) -> lang.Maybe[T]:
+        return self._v
+
+    def set(self, v: T) -> None:
+        self._v = lang.just(v)
+
+    async def get(self) -> T:
+        async def do():
+            self._v = lang.just(await self._fn())
+        await self._once.do(do)
+        return self._v.must()

omlish/asyncs/anyio/utils.py

@@ -0,0 +1,48 @@
+import typing as ta
+
+import anyio
+import sniffio
+
+from ... import lang
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+async def eof_to_empty(fn: ta.Callable[..., ta.Awaitable[T]], *args: ta.Any, **kwargs: ta.Any) -> T | bytes:
+    try:
+        return await fn(*args, **kwargs)
+    except anyio.EndOfStream:
+        return b''
+
+
+async def gather(*fns: ta.Callable[..., ta.Awaitable[T]], take_first: bool = False) -> list[lang.Maybe[T]]:
+    results: list[lang.Maybe[T]] = [lang.empty()] * len(fns)
+
+    async def inner(fn, i):
+        results[i] = lang.just(await fn())
+        if take_first:
+            tg.cancel_scope.cancel()
+
+    async with anyio.create_task_group() as tg:
+        for i, fn in enumerate(fns):
+            tg.start_soon(inner, fn, i)
+
+    return results
+
+
+async def first(*fns: ta.Callable[..., ta.Awaitable[T]], **kwargs: ta.Any) -> list[lang.Maybe[T]]:
+    return await gather(*fns, take_first=True, **kwargs)
+
+
+##
+
+
+def get_current_task() -> anyio.TaskInfo | None:
+    try:
+        return anyio.get_current_task()
+    except sniffio.AsyncLibraryNotFoundError:
+        return None

omlish/lang/__init__.py

@@ -209,6 +209,16 @@ from .objects import (  # noqa
     super_meta,
 )
 
+from .outcomes import (  # noqa
+    Either,
+    Error,
+    Outcome,
+    OutcomeAlreadyUnwrappedError,
+    Value,
+    acapture,
+    capture,
+)
+
 from .params import (  # noqa
     ArgsParam,
     KwOnlyParam,

omlish/{outcome.py → lang/outcomes.py}

@@ -18,8 +18,6 @@ import abc
 import dataclasses as dc
 import typing as ta
 
-from . import check
-
 
 ValueT_co = ta.TypeVar('ValueT_co', covariant=True)
 ResultT = ta.TypeVar('ResultT')
@@ -29,14 +27,15 @@ ArgsT = ta.ParamSpec('ArgsT')
 ##
 
 
-class AlreadyUsedError(RuntimeError):
+class OutcomeAlreadyUnwrappedError(RuntimeError):
     """An Outcome can only be unwrapped once."""
 
 
 def _remove_tb_frames(exc: BaseException, n: int) -> BaseException:
     tb: ta.Any = exc.__traceback__
     for _ in range(n):
-        check.not_none(tb)
+        if tb is None:
+            raise RuntimeError
         tb = tb.tb_next
     return exc.with_traceback(tb)
 
@@ -141,11 +140,24 @@ class Outcome(abc.ABC, ta.Generic[ValueT_co]):
     :class:`Outcome` objects are hashable if the contained objects are hashable.
     """
 
+    @property
+    @abc.abstractmethod
+    def is_error(self) -> bool:
+        raise NotImplementedError
+
+    def value(self) -> ValueT_co:
+        raise TypeError
+
+    def error(self) -> BaseException:
+        raise TypeError
+
+    #
+
     _unwrapped: bool = dc.field(default=False, compare=False, init=False)
 
     def _set_unwrapped(self) -> None:
         if self._unwrapped:
-            raise AlreadyUsedError
+            raise OutcomeAlreadyUnwrappedError
         object.__setattr__(self, '_unwrapped', True)
 
     @abc.abstractmethod
@@ -178,27 +190,44 @@ class Outcome(abc.ABC, ta.Generic[ValueT_co]):
         """
 
 
+#
+
+
 @ta.final
 @dc.dataclass(frozen=True, repr=False, slots=True, order=True)
 class Value(Outcome[ValueT_co], ta.Generic[ValueT_co]):
     """Concrete :class:`Outcome` subclass representing a regular value."""
 
-    value: ValueT_co
+    _value: ValueT_co
 
     def __repr__(self) -> str:
-        return f'Value({self.value!r})'
+        return f'Value({self._value!r})'
+
+    #
+
+    @property
+    def is_error(self) -> bool:
+        return True
+
+    def value(self) -> ValueT_co:
+        return self._value
+
+    #
 
     def unwrap(self) -> ValueT_co:
         self._set_unwrapped()
-        return self.value
+        return self._value
 
     def send(self, gen: ta.Generator[ResultT, ValueT_co, object]) -> ResultT:
         self._set_unwrapped()
-        return gen.send(self.value)
+        return gen.send(self._value)
 
     async def asend(self, agen: ta.AsyncGenerator[ResultT, ValueT_co]) -> ResultT:
         self._set_unwrapped()
-        return await agen.asend(self.value)
+        return await agen.asend(self._value)
+
+
+#
 
 
 @ta.final
@@ -206,21 +235,32 @@ class Value(Outcome[ValueT_co], ta.Generic[ValueT_co]):
 class Error(Outcome[ta.NoReturn]):
     """Concrete :class:`Outcome` subclass representing a raised exception."""
 
-    error: BaseException
+    _error: BaseException
 
     def __post_init__(self) -> None:
-        if not isinstance(self.error, BaseException):
-            raise TypeError(self.error)
+        if not isinstance(self._error, BaseException):
+            raise TypeError(self._error)
 
     def __repr__(self) -> str:
-        return f'Error({self.error!r})'
+        return f'Error({self._error!r})'
+
+    #
+
+    @property
+    def is_error(self) -> bool:
+        return True
+
+    def error(self) -> BaseException:
+        return self._error
+
+    #
 
     def unwrap(self) -> ta.NoReturn:
         self._set_unwrapped()
 
         # Tracebacks show the 'raise' line below out of context, so let's give this variable a name that makes sense out
         # of context.
-        captured_error = self.error
+        captured_error = self._error
 
         try:
             raise captured_error
@@ -239,12 +279,15 @@ class Error(Outcome[ta.NoReturn]):
 
     def send(self, gen: ta.Generator[ResultT, ta.NoReturn, object]) -> ResultT:
         self._set_unwrapped()
-        return gen.throw(self.error)
+        return gen.throw(self._error)
 
     async def asend(self, agen: ta.AsyncGenerator[ResultT, ta.NoReturn]) -> ResultT:
         self._set_unwrapped()
-        return await agen.athrow(self.error)
+        return await agen.athrow(self._error)
+
+
+##
 
 
 # A convenience alias to a union of both results, allowing exhaustiveness checking.
-Maybe = Value[ValueT_co] | Error
+Either = Value[ValueT_co] | Error

omlish/specs/jsonrpc/__init__.py

@@ -1,22 +1,34 @@
 from .errors import (  # noqa
-    CUSTOM_ERROR_BASE,
     KnownError,
     KnownErrors,
+
+    CUSTOM_ERROR_BASE,
 )
 
 from .types import (  # noqa
-    Error,
-    Id,
-    NotSpecified,
+    NUMBER_TYPES,
     Number,
     Object,
-    Request,
-    Response,
+    ID_TYPES,
+    Id,
+
     VERSION,
-    error,
-    notification,
+
+    NotSpecified,
+    is_not_specified,
+
+    Request,
     request,
+    notification,
+
+    Response,
     result,
+
+    Error,
+    error,
+
+    Message,
+    detect_message_type,
 )