omlish 0.0.0.dev133__py3-none-any.whl → 0.0.0.dev177__py3-none-any.whl

omlish/asyncs/asyncio/streams.py

@@ -0,0 +1,45 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import asyncio
+import typing as ta
+
+
+ASYNCIO_DEFAULT_BUFFER_LIMIT = 2 ** 16
+
+
+async def asyncio_open_stream_reader(
+        f: ta.IO,
+        loop: ta.Any = None,
+        *,
+        limit: int = ASYNCIO_DEFAULT_BUFFER_LIMIT,
+) -> asyncio.StreamReader:
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    reader = asyncio.StreamReader(limit=limit, loop=loop)
+    await loop.connect_read_pipe(
+        lambda: asyncio.StreamReaderProtocol(reader, loop=loop),
+        f,
+    )
+
+    return reader
+
+
+async def asyncio_open_stream_writer(
+        f: ta.IO,
+        loop: ta.Any = None,
+) -> asyncio.StreamWriter:
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    writer_transport, writer_protocol = await loop.connect_write_pipe(
+        lambda: asyncio.streams.FlowControlMixin(loop=loop),
+        f,
+    )
+
+    return asyncio.streams.StreamWriter(
+        writer_transport,
+        writer_protocol,
+        None,
+        loop,
+    )

omlish/asyncs/asyncio/subprocesses.py

@@ -0,0 +1,238 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import asyncio.base_subprocess
+import asyncio.subprocess
+import contextlib
+import dataclasses as dc
+import functools
+import logging
+import subprocess
+import sys
+import typing as ta
+
+from ...lite.check import check
+from ...subprocesses import AbstractAsyncSubprocesses
+from .timeouts import asyncio_maybe_timeout
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class AsyncioProcessCommunicator:
+    def __init__(
+            self,
+            proc: asyncio.subprocess.Process,
+            loop: ta.Optional[ta.Any] = None,
+            *,
+            log: ta.Optional[logging.Logger] = None,
+    ) -> None:
+        super().__init__()
+
+        if loop is None:
+            loop = asyncio.get_running_loop()
+
+        self._proc = proc
+        self._loop = loop
+        self._log = log
+
+        self._transport: asyncio.base_subprocess.BaseSubprocessTransport = check.isinstance(
+            proc._transport,  # type: ignore  # noqa
+            asyncio.base_subprocess.BaseSubprocessTransport,
+        )
+
+    @property
+    def _debug(self) -> bool:
+        return self._loop.get_debug()
+
+    async def _feed_stdin(self, input: bytes) -> None:  # noqa
+        stdin = check.not_none(self._proc.stdin)
+        try:
+            if input is not None:
+                stdin.write(input)
+                if self._debug and self._log is not None:
+                    self._log.debug('%r communicate: feed stdin (%s bytes)', self, len(input))
+
+            await stdin.drain()
+
+        except (BrokenPipeError, ConnectionResetError) as exc:
+            # communicate() ignores BrokenPipeError and ConnectionResetError. write() and drain() can raise these
+            # exceptions.
+            if self._debug and self._log is not None:
+                self._log.debug('%r communicate: stdin got %r', self, exc)
+
+        if self._debug and self._log is not None:
+            self._log.debug('%r communicate: close stdin', self)
+
+        stdin.close()
+
+    async def _noop(self) -> None:
+        return None
+
+    async def _read_stream(self, fd: int) -> bytes:
+        transport: ta.Any = check.not_none(self._transport.get_pipe_transport(fd))
+
+        if fd == 2:
+            stream = check.not_none(self._proc.stderr)
+        else:
+            check.equal(fd, 1)
+            stream = check.not_none(self._proc.stdout)
+
+        if self._debug and self._log is not None:
+            name = 'stdout' if fd == 1 else 'stderr'
+            self._log.debug('%r communicate: read %s', self, name)
+
+        output = await stream.read()
+
+        if self._debug and self._log is not None:
+            name = 'stdout' if fd == 1 else 'stderr'
+            self._log.debug('%r communicate: close %s', self, name)
+
+        transport.close()
+
+        return output
+
+    class Communication(ta.NamedTuple):
+        stdout: ta.Optional[bytes]
+        stderr: ta.Optional[bytes]
+
+    async def _communicate(
+            self,
+            input: ta.Any = None,  # noqa
+    ) -> Communication:
+        stdin_fut: ta.Any
+        if self._proc.stdin is not None:
+            stdin_fut = self._feed_stdin(input)
+        else:
+            stdin_fut = self._noop()
+
+        stdout_fut: ta.Any
+        if self._proc.stdout is not None:
+            stdout_fut = self._read_stream(1)
+        else:
+            stdout_fut = self._noop()
+
+        stderr_fut: ta.Any
+        if self._proc.stderr is not None:
+            stderr_fut = self._read_stream(2)
+        else:
+            stderr_fut = self._noop()
+
+        stdin_res, stdout_res, stderr_res = await asyncio.gather(stdin_fut, stdout_fut, stderr_fut)
+
+        await self._proc.wait()
+
+        return AsyncioProcessCommunicator.Communication(stdout_res, stderr_res)
+
+    async def communicate(
+            self,
+            input: ta.Any = None,  # noqa
+            timeout: ta.Optional[float] = None,
+    ) -> Communication:
+        return await asyncio_maybe_timeout(self._communicate(input), timeout)
+
+
+##
+
+
+class AsyncioSubprocesses(AbstractAsyncSubprocesses):
+    async def communicate(
+            self,
+            proc: asyncio.subprocess.Process,
+            input: ta.Any = None,  # noqa
+            timeout: ta.Optional[float] = None,
+    ) -> ta.Tuple[ta.Optional[bytes], ta.Optional[bytes]]:
+        return await AsyncioProcessCommunicator(proc).communicate(input, timeout)  # noqa
+
+    #
+
+    @contextlib.asynccontextmanager
+    async def popen(
+            self,
+            *cmd: str,
+            shell: bool = False,
+            timeout: ta.Optional[float] = None,
+            **kwargs: ta.Any,
+    ) -> ta.AsyncGenerator[asyncio.subprocess.Process, None]:
+        fac: ta.Any
+        if shell:
+            fac = functools.partial(
+                asyncio.create_subprocess_shell,
+                check.single(cmd),
+            )
+        else:
+            fac = functools.partial(
+                asyncio.create_subprocess_exec,
+                *cmd,
+            )
+
+        with self.prepare_and_wrap( *cmd, shell=shell, **kwargs) as (cmd, kwargs):  # noqa
+            proc: asyncio.subprocess.Process = await fac(**kwargs)
+            try:
+                yield proc
+
+            finally:
+                await asyncio_maybe_timeout(proc.wait(), timeout)
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class RunOutput:
+        proc: asyncio.subprocess.Process
+        stdout: ta.Optional[bytes]
+        stderr: ta.Optional[bytes]
+
+    async def run(
+            self,
+            *cmd: str,
+            input: ta.Any = None,  # noqa
+            timeout: ta.Optional[float] = None,
+            check: bool = False,  # noqa
+            capture_output: ta.Optional[bool] = None,
+            **kwargs: ta.Any,
+    ) -> RunOutput:
+        if capture_output:
+            kwargs.setdefault('stdout', subprocess.PIPE)
+            kwargs.setdefault('stderr', subprocess.PIPE)
+
+        proc: asyncio.subprocess.Process
+        async with self.popen(*cmd, **kwargs) as proc:
+            stdout, stderr = await self.communicate(proc, input, timeout)
+
+        if check and proc.returncode:
+            raise subprocess.CalledProcessError(
+                proc.returncode,
+                cmd,
+                output=stdout,
+                stderr=stderr,
+            )
+
+        return self.RunOutput(
+            proc,
+            stdout,
+            stderr,
+        )
+
+    #
+
+    async def check_call(
+            self,
+            *cmd: str,
+            stdout: ta.Any = sys.stderr,
+            **kwargs: ta.Any,
+    ) -> None:
+        with self.prepare_and_wrap(*cmd, stdout=stdout, check=True, **kwargs) as (cmd, kwargs):  # noqa
+            await self.run(*cmd, **kwargs)
+
+    async def check_output(
+            self,
+            *cmd: str,
+            **kwargs: ta.Any,
+    ) -> bytes:
+        with self.prepare_and_wrap(*cmd, stdout=subprocess.PIPE, check=True, **kwargs) as (cmd, kwargs):  # noqa
+            return check.not_none((await self.run(*cmd, **kwargs)).stdout)
+
+
+asyncio_subprocesses = AsyncioSubprocesses()

omlish/asyncs/asyncio/timeouts.py

@@ -0,0 +1,16 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import asyncio
+import typing as ta
+
+
+AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
+
+
+def asyncio_maybe_timeout(
+        fut: AwaitableT,
+        timeout: ta.Optional[float] = None,
+) -> AwaitableT:
+    if timeout is not None:
+        fut = asyncio.wait_for(fut, timeout)  # type: ignore
+    return fut

omlish/asyncs/bluelet/LICENSE

@@ -0,0 +1,6 @@
+Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

omlish/asyncs/bluelet/all.py

@@ -0,0 +1,67 @@
+# ruff: noqa: I001
+from .api import (  # noqa
+    bluelet,
+)
+
+from .core import (  # noqa
+    BlueletCoro as Coro,
+    BlueletExcInfo as ExcInfo,
+    CoreBlueletEvent as CoreEvent,
+    DelegationBlueletEvent as DelegationEvent,
+    ExceptionBlueletEvent as ExceptionEvent,
+    JoinBlueletEvent as JoinEvent,
+    KillBlueletEvent as KillEvent,
+    ReturnBlueletEvent as ReturnEvent,
+    SleepBlueletEvent as SleepEvent,
+    SpawnBlueletEvent as SpawnEvent,
+    ValueBlueletEvent as ValueEvent,
+)
+
+from .events import (  # noqa
+    BlueletEvent as Event,
+    BlueletFuture as Future,
+    BlueletHasFileno as HasFileno,
+    BlueletWaitable as Waitable,
+    BlueletWaitables as Waitables,
+    WaitableBlueletEvent as WaitableEvent,
+)
+
+from .files import (  # noqa
+    FileBlueletEvent as FileEvent,
+    ReadBlueletEvent as ReadEvent,
+    WriteBlueletEvent as WriteEvent,
+)
+
+from .runner import (  # noqa
+    BlueletCoroException as CoroException,
+)
+
+from .sockets import (  # noqa
+    AcceptBlueletEvent as AcceptEvent,
+    BlueletConnection as Connection,
+    BlueletListener as Listener,
+    ReceiveBlueletEvent as ReceiveEvent,
+    SendBlueletEvent as SendEvent,
+    SocketBlueletEvent as SocketEvent,
+    SocketClosedBlueletError as SocketClosedError,
+)
+
+
+##
+
+
+call = bluelet.call
+end = bluelet.end
+join = bluelet.join
+kill = bluelet.kill
+null = bluelet.null
+sleep = bluelet.sleep
+spawn = bluelet.spawn
+
+read = bluelet.read
+write = bluelet.write
+
+run = bluelet.run
+
+connect = bluelet.connect
+server = bluelet.server

omlish/asyncs/bluelet/api.py

@@ -0,0 +1,23 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+# Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+from .core import _CoreBlueletApi
+from .files import _FilesBlueletApi
+from .runner import _RunnerBlueletApi
+from .sockets import _SocketsBlueletApi
+
+
+class BlueletApi(
+    _RunnerBlueletApi,
+    _SocketsBlueletApi,
+    _FilesBlueletApi,
+    _CoreBlueletApi,
+):
+    pass
+
+
+bluelet = BlueletApi()

omlish/asyncs/bluelet/core.py

@@ -0,0 +1,178 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+# Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+import abc
+import dataclasses as dc
+import time
+import types
+import typing as ta
+
+from .events import BlueletEvent
+from .events import BlueletFuture
+from .events import WaitableBlueletEvent
+
+
+T = ta.TypeVar('T')
+
+BlueletExcInfo = ta.Tuple[ta.Type[BaseException], BaseException, types.TracebackType]  # ta.TypeAlias
+
+BlueletCoro = ta.Generator[ta.Union['BlueletEvent', 'BlueletCoro'], ta.Any, None]  # ta.TypeAlias
+
+BlueletSpawnable = ta.Union[BlueletCoro, ta.Awaitable]  # ta.TypeAlias
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+class _BlueletAwaitableDriver:
+    a: ta.Awaitable
+
+    def __call__(self) -> BlueletCoro:
+        g = self.a.__await__()
+        gi = iter(g)
+        while True:
+            try:
+                f = gi.send(None)
+            except StopIteration as e:
+                yield ReturnBlueletEvent(e.value)
+                break
+            else:
+                if not isinstance(f, BlueletFuture):
+                    raise TypeError(f)
+                res = yield f.event
+                f.done = True
+                f.result = res
+
+
+##
+
+
+class CoreBlueletEvent(BlueletEvent, abc.ABC):  # noqa
+    pass
+
+
+@dc.dataclass(frozen=True, eq=False)
+class ValueBlueletEvent(CoreBlueletEvent, ta.Generic[T]):
+    """An event that does nothing but return a fixed value."""
+
+    value: T
+
+
+@dc.dataclass(frozen=True, eq=False)
+class ExceptionBlueletEvent(CoreBlueletEvent):
+    """Raise an exception at the yield point. Used internally."""
+
+    exc_info: BlueletExcInfo
+
+
+@dc.dataclass(frozen=True, eq=False)
+class SpawnBlueletEvent(CoreBlueletEvent):
+    """Add a new coroutine coro to the scheduler."""
+
+    spawned: BlueletSpawnable
+
+
+@dc.dataclass(frozen=True, eq=False)
+class JoinBlueletEvent(CoreBlueletEvent):
+    """Suspend the coro until the specified child coro has completed."""
+
+    child: BlueletCoro
+
+
+@dc.dataclass(frozen=True, eq=False)
+class KillBlueletEvent(CoreBlueletEvent):
+    """Unschedule a child coro."""
+
+    child: BlueletCoro
+
+
+@dc.dataclass(frozen=True, eq=False)
+class DelegationBlueletEvent(CoreBlueletEvent):
+    """
+    Suspend execution of the current coro, start a new coro and, once the child coro finished, return control to
+    the parent coro.
+    """
+
+    spawned: BlueletCoro
+
+
+@dc.dataclass(frozen=True, eq=False)
+class ReturnBlueletEvent(CoreBlueletEvent, ta.Generic[T]):
+    """Return a value the current coro's delegator at the point of delegation. Ends the current (delegate) coro."""
+
+    value: ta.Optional[T]
+
+
+@dc.dataclass(frozen=True, eq=False)
+class SleepBlueletEvent(WaitableBlueletEvent, CoreBlueletEvent):
+    """Suspend the coro for a given duration."""
+
+    wakeup_time: float
+
+    def time_left(self) -> float:
+        return max(self.wakeup_time - time.time(), 0.)
+
+
+##
+
+
+class _CoreBlueletApi:
+    def value(self, v: T) -> ValueBlueletEvent[T]:
+        """Event: yield a value."""
+
+        return ValueBlueletEvent(v)
+
+    def null(self) -> ValueBlueletEvent[None]:
+        """Event: yield to the scheduler without doing anything special."""
+
+        return ValueBlueletEvent(None)
+
+    def spawn(self, spawned: BlueletSpawnable) -> SpawnBlueletEvent:
+        """Event: add another coroutine to the scheduler. Both the parent and child coroutines run concurrently."""
+
+        if isinstance(spawned, types.CoroutineType):
+            spawned = _BlueletAwaitableDriver(spawned)()
+
+        if not isinstance(spawned, types.GeneratorType):
+            raise TypeError(f'{spawned} is not spawnable')
+
+        return SpawnBlueletEvent(spawned)
+
+    def join(self, coro: BlueletCoro) -> JoinBlueletEvent:
+        """Suspend the coro until another, previously `spawn`ed coro completes."""
+
+        return JoinBlueletEvent(coro)
+
+    def kill(self, coro: BlueletCoro) -> KillBlueletEvent:
+        """Halt the execution of a different `spawn`ed coro."""
+
+        return KillBlueletEvent(coro)
+
+    def call(self, spawned: BlueletSpawnable) -> DelegationBlueletEvent:
+        """
+        Event: delegate to another coroutine. The current coroutine is resumed once the sub-coroutine finishes. If the
+        sub-coroutine returns a value using end(), then this event returns that value.
+        """
+
+        if isinstance(spawned, types.CoroutineType):
+            spawned = _BlueletAwaitableDriver(spawned)()
+
+        if not isinstance(spawned, types.GeneratorType):
+            raise TypeError(f'{spawned} is not spawnable')
+
+        return DelegationBlueletEvent(spawned)
+
+    def end(self, value: ta.Optional[T] = None) -> ReturnBlueletEvent[T]:
+        """Event: ends the coroutine and returns a value to its delegator."""
+
+        return ReturnBlueletEvent(value)
+
+    def sleep(self, duration: float) -> SleepBlueletEvent:
+        """Event: suspend the coro for ``duration`` seconds."""
+
+        return SleepBlueletEvent(time.time() + duration)

omlish/asyncs/bluelet/events.py

@@ -0,0 +1,78 @@
+# ruff: noqa: UP007
+# @omlish-lite
+# Based on bluelet ( https://github.com/sampsyo/bluelet ) by Adrian Sampson, original license:
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+import abc
+import dataclasses as dc
+import typing as ta
+
+
+R = ta.TypeVar('R')
+
+BlueletEventT = ta.TypeVar('BlueletEventT', bound='BlueletEvent')  # ta.TypeAlias
+
+BlueletWaitable = ta.Union[int, 'BlueletHasFileno']  # ta.TypeAlias
+
+
+##
+
+
+class BlueletEvent(abc.ABC):  # noqa
+    """
+    Just a base class identifying Bluelet events. An event is an object yielded from a Bluelet coro coroutine to
+    suspend operation and communicate with the scheduler.
+    """
+
+    def __await__(self):
+        return BlueletFuture(self).__await__()
+
+
+##
+
+
+class BlueletHasFileno(ta.Protocol):
+    def fileno(self) -> int: ...
+
+
+@dc.dataclass(frozen=True)
+class BlueletWaitables:
+    r: ta.Sequence[BlueletWaitable] = ()
+    w: ta.Sequence[BlueletWaitable] = ()
+    x: ta.Sequence[BlueletWaitable] = ()
+
+
+class WaitableBlueletEvent(BlueletEvent, abc.ABC):  # noqa
+    """
+    A waitable event is one encapsulating an action that can be waited for using a select() call. That is, it's an event
+    with an associated file descriptor.
+    """
+
+    def waitables(self) -> BlueletWaitables:
+        """
+        Return "waitable" objects to pass to select(). Should return three iterables for input readiness, output
+        readiness, and exceptional conditions (i.e., the three lists passed to select()).
+        """
+        return BlueletWaitables()
+
+    def fire(self) -> ta.Any:
+        """Called when an associated file descriptor becomes ready (i.e., is returned from a select() call)."""
+
+
+##
+
+
+@dc.dataclass(eq=False)
+class BlueletFuture(ta.Generic[BlueletEventT, R]):
+    event: BlueletEventT
+    done: bool = False
+    result: ta.Optional[R] = None
+
+    def __await__(self):
+        if not self.done:
+            yield self
+        if not self.done:
+            raise RuntimeError("await wasn't used with event future")
+        return self.result