omlish 0.0.0.dev146__py3-none-any.whl → 0.0.0.dev148__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev146'
-__revision__ = '3e5441b65738d0b3c80a43abb47b62f9ef5a6bee'
+__version__ = '0.0.0.dev148'
+__revision__ = '01263e3c2d1b82ca19c3d1d6916041ca4276737b'
 
 
 #

omlish/lite/asyncio/asyncio.py

@@ -0,0 +1,63 @@
+# ruff: noqa: UP006 UP007
+import asyncio.base_subprocess
+import asyncio.subprocess
+import typing as ta
+
+
+AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
+
+
+##
+
+
+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,
+    )
+
+
+##
+
+
+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/lite/asyncio/subprocesses.py

@@ -0,0 +1,297 @@
+# ruff: noqa: UP006 UP007
+import asyncio.base_subprocess
+import asyncio.subprocess
+import contextlib
+import functools
+import logging
+import subprocess
+import sys
+import typing as ta
+
+from ..check import check_equal
+from ..check import check_isinstance
+from ..check import check_not_none
+from ..check import check_single
+from ..logs import log
+from ..subprocesses import DEFAULT_SUBPROCESS_TRY_EXCEPTIONS
+from ..subprocesses import prepare_subprocess_invocation
+from ..subprocesses import subprocess_common_context
+from .asyncio import asyncio_maybe_timeout
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@contextlib.asynccontextmanager
+async def asyncio_subprocess_popen(
+        *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 subprocess_common_context(
+            *cmd,
+            shell=shell,
+            timeout=timeout,
+            **kwargs,
+    ):
+        proc: asyncio.subprocess.Process
+        proc = await fac(**kwargs)
+        try:
+            yield proc
+
+        finally:
+            await asyncio_maybe_timeout(proc.wait(), timeout)
+
+
+##
+
+
+class AsyncioProcessCommunicator:
+    def __init__(
+            self,
+            proc: asyncio.subprocess.Process,
+            loop: ta.Optional[ta.Any] = None,
+    ) -> None:
+        super().__init__()
+
+        if loop is None:
+            loop = asyncio.get_running_loop()
+
+        self._proc = proc
+        self._loop = loop
+
+        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:
+                    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:
+                log.debug('%r communicate: stdin got %r', self, exc)
+
+        if self._debug:
+            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:
+            name = 'stdout' if fd == 1 else 'stderr'
+            log.debug('%r communicate: read %s', self, name)
+
+        output = await stream.read()
+
+        if self._debug:
+            name = 'stdout' if fd == 1 else 'stderr'
+            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)
+
+
+async def asyncio_subprocess_communicate(
+        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
+
+
+##
+
+
+async def _asyncio_subprocess_check_run(
+        *args: str,
+        input: ta.Any = None,  # noqa
+        timeout: ta.Optional[float] = None,
+        **kwargs: ta.Any,
+) -> ta.Tuple[ta.Optional[bytes], ta.Optional[bytes]]:
+    args, kwargs = prepare_subprocess_invocation(*args, **kwargs)
+
+    proc: asyncio.subprocess.Process
+    async with asyncio_subprocess_popen(*args, **kwargs) as proc:
+        stdout, stderr = await asyncio_subprocess_communicate(proc, input, timeout)
+
+    if proc.returncode:
+        raise subprocess.CalledProcessError(
+            proc.returncode,
+            args,
+            output=stdout,
+            stderr=stderr,
+        )
+
+    return stdout, stderr
+
+
+async def asyncio_subprocess_check_call(
+        *args: str,
+        stdout: ta.Any = sys.stderr,
+        input: ta.Any = None,  # noqa
+        timeout: ta.Optional[float] = None,
+        **kwargs: ta.Any,
+) -> None:
+    _, _ = await _asyncio_subprocess_check_run(
+        *args,
+        stdout=stdout,
+        input=input,
+        timeout=timeout,
+        **kwargs,
+    )
+
+
+async def asyncio_subprocess_check_output(
+        *args: str,
+        input: ta.Any = None,  # noqa
+        timeout: ta.Optional[float] = None,
+        **kwargs: ta.Any,
+) -> bytes:
+    stdout, stderr = await _asyncio_subprocess_check_run(
+        *args,
+        stdout=asyncio.subprocess.PIPE,
+        input=input,
+        timeout=timeout,
+        **kwargs,
+    )
+
+    return check_not_none(stdout)
+
+
+async def asyncio_subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
+    return (await asyncio_subprocess_check_output(*args, **kwargs)).decode().strip()
+
+
+##
+
+
+async def _asyncio_subprocess_try_run(
+        fn: ta.Callable[..., ta.Awaitable[T]],
+        *args: ta.Any,
+        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
+        **kwargs: ta.Any,
+) -> ta.Union[T, Exception]:
+    try:
+        return await fn(*args, **kwargs)
+    except try_exceptions as e:  # noqa
+        if log.isEnabledFor(logging.DEBUG):
+            log.exception('command failed')
+        return e
+
+
+async def asyncio_subprocess_try_call(
+        *args: str,
+        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
+        **kwargs: ta.Any,
+) -> bool:
+    if isinstance(await _asyncio_subprocess_try_run(
+            asyncio_subprocess_check_call,
+            *args,
+            try_exceptions=try_exceptions,
+            **kwargs,
+    ), Exception):
+        return False
+    else:
+        return True
+
+
+async def asyncio_subprocess_try_output(
+        *args: str,
+        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
+        **kwargs: ta.Any,
+) -> ta.Optional[bytes]:
+    if isinstance(ret := await _asyncio_subprocess_try_run(
+            asyncio_subprocess_check_output,
+            *args,
+            try_exceptions=try_exceptions,
+            **kwargs,
+    ), Exception):
+        return None
+    else:
+        return ret
+
+
+async def asyncio_subprocess_try_output_str(*args: str, **kwargs: ta.Any) -> ta.Optional[str]:
+    out = await asyncio_subprocess_try_output(*args, **kwargs)
+    return out.decode().strip() if out is not None else None

omlish/lite/cached.py

@@ -7,7 +7,10 @@ T = ta.TypeVar('T')
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
 
-class _cached_nullary:  # noqa
+##
+
+
+class _AbstractCachedNullary:
     def __init__(self, fn):
         super().__init__()
         self._fn = fn
@@ -15,20 +18,42 @@ class _cached_nullary:  # noqa
         functools.update_wrapper(self, fn)
 
     def __call__(self, *args, **kwargs):  # noqa
-        if self._value is self._missing:
-            self._value = self._fn()
-        return self._value
+        raise TypeError
 
     def __get__(self, instance, owner):  # noqa
         bound = instance.__dict__[self._fn.__name__] = self.__class__(self._fn.__get__(instance, owner))
         return bound
 
 
+##
+
+
+class _CachedNullary(_AbstractCachedNullary):
+    def __call__(self, *args, **kwargs):  # noqa
+        if self._value is self._missing:
+            self._value = self._fn()
+        return self._value
+
+
 def cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
-    return _cached_nullary(fn)
+    return _CachedNullary(fn)
 
 
 def static_init(fn: CallableT) -> CallableT:
     fn = cached_nullary(fn)
     fn()
     return fn
+
+
+##
+
+
+class _AsyncCachedNullary(_AbstractCachedNullary):
+    async def __call__(self, *args, **kwargs):
+        if self._value is self._missing:
+            self._value = await self._fn()
+        return self._value
+
+
+def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
+    return _AsyncCachedNullary(fn)

omlish/lite/deathsig.py

@@ -0,0 +1,22 @@
+import ctypes as ct
+import sys
+
+
+LINUX_PR_SET_PDEATHSIG = 1  # Second arg is a signal
+LINUX_PR_GET_PDEATHSIG = 2  # Second arg is a ptr to return the signal
+
+
+def set_process_deathsig(sig: int) -> bool:
+    if sys.platform == 'linux':
+        libc = ct.CDLL('libc.so.6')
+
+        # int prctl(int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);
+        libc.prctl.restype = ct.c_int
+        libc.prctl.argtypes = [ct.c_int, ct.c_ulong, ct.c_ulong, ct.c_ulong, ct.c_ulong]
+
+        libc.prctl(LINUX_PR_SET_PDEATHSIG, sig, 0, 0, 0, 0)
+
+        return True
+
+    else:
+        return False

omlish/lite/pycharm.py

@@ -36,7 +36,6 @@ def pycharm_debug_connect(prd: PycharmRemoteDebug) -> None:
 def pycharm_debug_preamble(prd: PycharmRemoteDebug) -> str:
     import inspect
     import textwrap
-
     return textwrap.dedent(f"""
         {inspect.getsource(pycharm_debug_connect)}
 

omlish/lite/subprocesses.py

@@ -1,15 +1,18 @@
 # ruff: noqa: UP006 UP007
+import contextlib
 import logging
 import os
 import shlex
 import subprocess
 import sys
+import time
 import typing as ta
 
 from .logs import log
 from .runtime import is_debugger_attached
 
 
+T = ta.TypeVar('T')
 SubprocessChannelOption = ta.Literal['pipe', 'stdout', 'devnull']
 
 
@@ -40,7 +43,7 @@ def subprocess_maybe_shell_wrap_exec(*args: str) -> ta.Tuple[str, ...]:
         return args
 
 
-def _prepare_subprocess_invocation(
+def prepare_subprocess_invocation(
         *args: str,
         env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
         extra_env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
@@ -48,9 +51,9 @@ def _prepare_subprocess_invocation(
         shell: bool = False,
         **kwargs: ta.Any,
 ) -> ta.Tuple[ta.Tuple[ta.Any, ...], ta.Dict[str, ta.Any]]:
-    log.debug(args)
+    log.debug('prepare_subprocess_invocation: args=%r', args)
     if extra_env:
-        log.debug(extra_env)
+        log.debug('prepare_subprocess_invocation: extra_env=%r', extra_env)
 
     if extra_env:
         env = {**(env if env is not None else os.environ), **extra_env}
@@ -69,14 +72,46 @@ def _prepare_subprocess_invocation(
     )
 
 
-def subprocess_check_call(*args: str, stdout=sys.stderr, **kwargs: ta.Any) -> None:
-    args, kwargs = _prepare_subprocess_invocation(*args, stdout=stdout, **kwargs)
-    return subprocess.check_call(args, **kwargs)  # type: ignore
+##
+
+
+@contextlib.contextmanager
+def subprocess_common_context(*args: ta.Any, **kwargs: ta.Any) -> ta.Iterator[None]:
+    start_time = time.time()
+    try:
+        log.debug('subprocess_common_context.try: args=%r', args)
+        yield
+
+    except Exception as exc:  # noqa
+        log.debug('subprocess_common_context.except: exc=%r', exc)
+        raise
+
+    finally:
+        end_time = time.time()
+        elapsed_s = end_time - start_time
+        log.debug('subprocess_common_context.finally: elapsed_s=%f args=%r', elapsed_s, args)
+
+
+##
+
+
+def subprocess_check_call(
+        *args: str,
+        stdout: ta.Any = sys.stderr,
+        **kwargs: ta.Any,
+) -> None:
+    args, kwargs = prepare_subprocess_invocation(*args, stdout=stdout, **kwargs)
+    with subprocess_common_context(*args, **kwargs):
+        return subprocess.check_call(args, **kwargs)  # type: ignore
 
 
-def subprocess_check_output(*args: str, **kwargs: ta.Any) -> bytes:
-    args, kwargs = _prepare_subprocess_invocation(*args, **kwargs)
-    return subprocess.check_output(args, **kwargs)
+def subprocess_check_output(
+        *args: str,
+        **kwargs: ta.Any,
+) -> bytes:
+    args, kwargs = prepare_subprocess_invocation(*args, **kwargs)
+    with subprocess_common_context(*args, **kwargs):
+        return subprocess.check_output(args, **kwargs)
 
 
 def subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
@@ -92,16 +127,31 @@ DEFAULT_SUBPROCESS_TRY_EXCEPTIONS: ta.Tuple[ta.Type[Exception], ...] = (
 )
 
 
-def subprocess_try_call(
-        *args: str,
+def _subprocess_try_run(
+        fn: ta.Callable[..., T],
+        *args: ta.Any,
         try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
         **kwargs: ta.Any,
-) -> bool:
+) -> ta.Union[T, Exception]:
     try:
-        subprocess_check_call(*args, **kwargs)
+        return fn(*args, **kwargs)
     except try_exceptions as e:  # noqa
         if log.isEnabledFor(logging.DEBUG):
             log.exception('command failed')
+        return e
+
+
+def subprocess_try_call(
+        *args: str,
+        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
+        **kwargs: ta.Any,
+) -> bool:
+    if isinstance(_subprocess_try_run(
+            subprocess_check_call,
+            *args,
+            try_exceptions=try_exceptions,
+            **kwargs,
+    ), Exception):
         return False
     else:
         return True
@@ -112,12 +162,15 @@ def subprocess_try_output(
         try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
         **kwargs: ta.Any,
 ) -> ta.Optional[bytes]:
-    try:
-        return subprocess_check_output(*args, **kwargs)
-    except try_exceptions as e:  # noqa
-        if log.isEnabledFor(logging.DEBUG):
-            log.exception('command failed')
+    if isinstance(ret := _subprocess_try_run(
+            subprocess_check_output,
+            *args,
+            try_exceptions=try_exceptions,
+            **kwargs,
+    ), Exception):
         return None
+    else:
+        return ret
 
 
 def subprocess_try_output_str(*args: str, **kwargs: ta.Any) -> ta.Optional[str]:

omlish/manifests/load.py

@@ -31,6 +31,8 @@ class ManifestLoader:
         self._cls_cache: ta.Dict[str, type] = {}
         self._raw_cache: ta.Dict[str, ta.Optional[ta.Sequence[Manifest]]] = {}
 
+    #
+
     @classmethod
     def from_entry_point(
             cls,
@@ -52,6 +54,8 @@ class ManifestLoader:
 
         return cls(module_remap=rm, **kwargs)
 
+    #
+
     def load_cls(self, key: str) -> type:
         try:
             return self._cls_cache[key]
@@ -153,6 +157,8 @@ class ManifestLoader:
 
         return lst
 
+    #
+
     ENTRY_POINT_GROUP = 'omlish.manifests'
 
     def discover(self) -> ta.Sequence[str]:

omlish/testing/pytest/plugins/asyncs.py

@@ -142,7 +142,12 @@ class AsyncsPlugin:
         if len(bes) > 1 and set(bes) != {'trio', 'trio_asyncio'}:
             raise Exception(f'{item.nodeid}: multiple async backends specified: {bes}')
         elif is_async_function(item.obj) and not bes:
-            raise Exception(f'{item.nodeid}: async def function and no async plugin specified')
+            from _pytest.unittest import UnitTestCase  # noqa
+            if isinstance(item.parent, UnitTestCase):
+                # unittest handles these itself.
+                pass
+            else:
+                raise Exception(f'{item.nodeid}: async def function and no async plugin specified')
 
         if 'trio_asyncio' in bes:
             obj = item.obj

{omlish-0.0.0.dev146.dist-info → omlish-0.0.0.dev148.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev146
+Version: 0.0.0.dev148
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev146.dist-info → omlish-0.0.0.dev148.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=RX24SRc6DCEg77PUVnaXOKCWa5TF_c9RQJdGIf7gl9c,1135
-omlish/__about__.py,sha256=G3zss6e134zxU5xmjngBc8mskjSdZxwZFcH8cUO87Sc,3409
+omlish/__about__.py,sha256=SGKzVFr0tcTK7dCoK2Y4-o8CVkBHmsj2aDPhw4bLYqc,3409
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/argparse.py,sha256=cqKGAqcxuxv_s62z0gq29L9KAvg_3-_rFvXKjVpRJjo,8126
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
@@ -311,9 +311,10 @@ omlish/lifecycles/manager.py,sha256=Au66KaO-fI-SEJALaPUJsCHYW2GE20xextk1wKn2BEU,
 omlish/lifecycles/states.py,sha256=zqMOU2ZU-MDNnWuwauM3_anIAiXM8LoBDElDEraptFg,1292
 omlish/lifecycles/transitions.py,sha256=qQtFby-h4VzbvgaUqT2NnbNumlcOx9FVVADP9t83xj4,1939
 omlish/lite/__init__.py,sha256=Y3l4WY4JRi2uLG6kgbGp93fuGfkxkKwZDvhsa0Rwgtk,15
-omlish/lite/cached.py,sha256=rrc_JEv3sKJIEmCBB6g7DwPvkb1hNFmhg0mxkvuXDJw,848
+omlish/lite/cached.py,sha256=hBW77-F7ZLtFqbLwVrlqaJ4-iFHMQleMWZXaZN1IubA,1308
 omlish/lite/check.py,sha256=pQC412ffe_Zh7eHa4C1UYn6fA71Ls1vpVM0ZIOroPAY,1765
 omlish/lite/contextmanagers.py,sha256=DRarS2gx15tbse1YzyI8ZLdBmWYjFgmKPe-i4CSNDYg,1458
+omlish/lite/deathsig.py,sha256=Etz04WX6R2PXQ-BgqJyVJ0C5Pqym6Ds6PAG7p1cqr5o,626
 omlish/lite/docker.py,sha256=Dj_7lQjs2sFPc_SmUn5CpJF3LnQQnckEBYGBKz8u5tE,392
 omlish/lite/inject.py,sha256=aRRmFb6azTKF208ogYwVCEopNZx7496Ta1GZmL_IKBA,23716
 omlish/lite/io.py,sha256=3ECgUXdRnXyS6pGTSoVr6oB4moI38EpWxTq08zaTM-U,5339
@@ -323,7 +324,7 @@ omlish/lite/logs.py,sha256=1pcGu0ekhVCcLUckLSP16VccnAoprjtl5Vkdfm7y1Wg,6184
 omlish/lite/marshal.py,sha256=1wqZWKapZ5rFgDxSkb447Xv2ce2SFEpiB1EMg1nh2BI,13530
 omlish/lite/maybes.py,sha256=7OlHJ8Q2r4wQ-aRbZSlJY7x0e8gDvufFdlohGEIJ3P4,833
 omlish/lite/pidfile.py,sha256=PRSDOAXmNkNwxh-Vwif0Nrs8RAmWroiNhLKIbdjwzBc,1723
-omlish/lite/pycharm.py,sha256=CUArgzaG8ZZ0evN7tdrML5WXyF-G_BvF_s3Z4SI2LA0,1164
+omlish/lite/pycharm.py,sha256=pUOJevrPClSqTCEOkQBO11LKX2003tfDcp18a03QFrc,1163
 omlish/lite/reflect.py,sha256=ad_ya_zZJOQB8HoNjs9yc66R54zgflwJVPJqiBXMzqA,1681
 omlish/lite/resources.py,sha256=YNSmX1Ohck1aoWRs55a-o5ChVbFJIQhtbqE-XwF55Oc,326
 omlish/lite/runtime.py,sha256=lVw5_yuQNHXZLwGf_l59u8IrAtBLZWPTml6owQ55uro,439
@@ -331,8 +332,11 @@ omlish/lite/secrets.py,sha256=3Mz3V2jf__XU9qNHcH56sBSw95L3U2UPL24bjvobG0c,816
 omlish/lite/socket.py,sha256=7OYgkXTcQv0wq7TQuLnl9y6dJA1ZT6Vbc1JH59QlxgY,1792
 omlish/lite/socketserver.py,sha256=Esy9dAo9dPnNavNx5hW52YZi5hv504a8XQUudMrPs2A,1595
 omlish/lite/strings.py,sha256=QURcE4-1pKVW8eT_5VCJpXaHDWR2dW2pYOChTJnZDiQ,1504
-omlish/lite/subprocesses.py,sha256=1we1S-YQ9kbH36hPWLoh6zKZUARRnq2__ewtX_dVdWU,3633
+omlish/lite/subprocesses.py,sha256=RTs8HJ1Lz8YOZTHw12Ja8KW7Eq4oyDFJZDiG0PSUBKY,4918
 omlish/lite/typing.py,sha256=U3-JaEnkDSYxK4tsu_MzUn3RP6qALBe5FXQXpD-licE,1090
+omlish/lite/asyncio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/lite/asyncio/asyncio.py,sha256=tsqQSLl5rG4GZHPYOBqI7V2yuw45ZVuGZEHe-J4QEhE,1320
+omlish/lite/asyncio/subprocesses.py,sha256=crG4FlkVIA19sO2QtIagOCtXk8ak9rLaHgbTjGDy3mk,8274
 omlish/lite/fdio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/lite/fdio/corohttp.py,sha256=FHdakDTGI2UYbCihahuwleyailclxQMUGhpkz3suww4,4080
 omlish/lite/fdio/handlers.py,sha256=Wr0O2cvIC8NuLs3yoDHj9ZG4n1g_oVEeT87B0WDsg0Y,1341
@@ -352,7 +356,7 @@ omlish/logs/handlers.py,sha256=UpzUf3kWBBzWOnrtljoZsLjISw3Ix-ePz3Nsmp6lRgE,255
 omlish/logs/noisy.py,sha256=Ubc-eTH6ZbGYsLfUUi69JAotwuUwzb-SJBeGo_0dIZI,348
 omlish/logs/utils.py,sha256=MgGovbP0zUrZ3FGD3qYNQWn-l0jy0Y0bStcQvv5BOmQ,391
 omlish/manifests/__init__.py,sha256=P2B0dpT8D7l5lJwRGPA92IcQj6oeXfd90X5-q9BJrKg,51
-omlish/manifests/load.py,sha256=Wn0Orrs65rLdXneT7tlixX5Q5OXW460-zzw6IkAye7k,4788
+omlish/manifests/load.py,sha256=8R-S5CyQpAbxDHt5wcNF6mAYri8bGndn6R2uEVOh52Y,4809
 omlish/manifests/types.py,sha256=d8bv5tknCJqclRfxCpao_8XxHo2yofhLpVHQTB-MfNw,260
 omlish/marshal/__init__.py,sha256=iVA7n31L08Bdub6HKPvYOXVvDhk2CMA6rPeKDL_u1to,2298
 omlish/marshal/any.py,sha256=e82OyYK3Emm1P1ClnsnxP7fIWC2iNVyW0H5nK4mLmWM,779
@@ -487,7 +491,7 @@ omlish/testing/pytest/inject/__init__.py,sha256=pdRKv1HcDmJ_yArKJbYITPXXZthRSGgB
 omlish/testing/pytest/inject/harness.py,sha256=v4DaKJ0KL8oQjzIMK43Gh8GHP4hiI6-lY37O9lyOHRk,5724
 omlish/testing/pytest/plugins/__init__.py,sha256=ys1zXrYrNm7Uo6YOIVJ6Bd3dQo6kv387k7MbTYlqZSI,467
 omlish/testing/pytest/plugins/_registry.py,sha256=IK04KlBgiOJxKAyCCgjpX2R-9tE-btalYJkgjLc8Te8,77
-omlish/testing/pytest/plugins/asyncs.py,sha256=SV6oKCy50CGkzLGYX-CT4MfWNqsrH8ONEbIWC3tFcHA,5324
+omlish/testing/pytest/plugins/asyncs.py,sha256=CG-cWWxCtxVIyKJKEjxfFV0MVwYBHPo1mb-umCGz9X8,5532
 omlish/testing/pytest/plugins/depskip.py,sha256=xithY-OMtjwhv8mcRNkv-WI_PSQtHldQ8H1s60MIXkk,2673
 omlish/testing/pytest/plugins/logging.py,sha256=1zs6Xe54wiaSjabCviaFXwKkoN97CKm3mA5mEoUeJGs,380
 omlish/testing/pytest/plugins/managermarks.py,sha256=AP3ty-QB-8O5DkulwUOudBlUOvXMHhBfNyY-0yCmejk,1520
@@ -504,9 +508,9 @@ omlish/text/glyphsplit.py,sha256=Ug-dPRO7x-OrNNr8g1y6DotSZ2KH0S-VcOmUobwa4B0,329
 omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev146.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev146.dist-info/METADATA,sha256=V8cPQmzScS8Lnw8b-HzO9Pg_uvOnOaPZxPJ_yrzxTc8,4264
-omlish-0.0.0.dev146.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-omlish-0.0.0.dev146.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev146.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev146.dist-info/RECORD,,
+omlish-0.0.0.dev148.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev148.dist-info/METADATA,sha256=78h6hQTFkljP4Axca6bTAYdlPCtJVukJDCFxbRrx__4,4264
+omlish-0.0.0.dev148.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+omlish-0.0.0.dev148.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev148.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev148.dist-info/RECORD,,