omdev 0.0.0.dev440__py3-none-any.whl → 0.0.0.dev486__py3-none-any.whl

omdev/scripts/ci.py

@@ -49,6 +49,7 @@ import io
 import itertools
 import json
 import logging
+import operator
 import os
 import os.path
 import re
@@ -83,6 +84,122 @@ if sys.version_info < (3, 8):
     raise OSError(f'Requires python (3, 8), got {sys.version_info} from {sys.executable}')  # noqa
 
 
+def __omlish_amalg__():  # noqa
+    return dict(
+        src_files=[
+            dict(path='consts.py', sha1='ef00d55ab4cdd799b22f2e8b736eacd52ee8a80e'),
+            dict(path='github/env.py', sha1='c7a2389048f008f46f59f6bcc11e0d15655f2b1c'),
+            dict(path='shell.py', sha1='a59e59b812394d0502837f4c198e1cf604f90227'),
+            dict(path='utils.py', sha1='f0f9ef0778db316b1ba83e6eeac79c8fd132d86a'),
+            dict(path='../oci/compression.py', sha1='7d165bc51a77db13ff45927daecc42839cfd75ea'),
+            dict(path='../../omlish/asyncs/asyncio/utils.py', sha1='34691d4d0e5bab68f14e193a6200df040cfd0136'),
+            dict(path='../../omlish/docker/ports.py', sha1='a3202c69b85bc4f1034479df3400fddc86130e5c'),
+            dict(path='../../omlish/http/urllib.py', sha1='25431c5bdc7dd5cbecfcb8c0bdffaabf8c1691b9'),
+            dict(path='../../omlish/http/versions.py', sha1='197685ffbb62a457a0e8d4047a9df26aebd7dae4'),
+            dict(path='../../omlish/lite/abstract.py', sha1='a2fc3f3697fa8de5247761e9d554e70176f37aac'),
+            dict(path='../../omlish/lite/cached.py', sha1='0c33cf961ac8f0727284303c7a30c5ea98f714f2'),
+            dict(path='../../omlish/lite/check.py', sha1='bb6b6b63333699b84462951a854d99ae83195b94'),
+            dict(path='../../omlish/lite/contextmanagers.py', sha1='993f5ed96d3410f739a20363f55670d5e5267fa3'),
+            dict(path='../../omlish/lite/dataclasses.py', sha1='73b7f5e5493c7ed12ff0ce36e37b596e5984cb08'),
+            dict(path='../../omlish/lite/json.py', sha1='57eeddc4d23a17931e00284ffa5cb6e3ce089486'),
+            dict(path='../../omlish/lite/objects.py', sha1='9566bbf3530fd71fcc56321485216b592fae21e9'),
+            dict(path='../../omlish/lite/reflect.py', sha1='c4fec44bf144e9d93293c996af06f6c65fc5e63d'),
+            dict(path='../../omlish/lite/strings.py', sha1='89831ecbc34ad80e118a865eceb390ed399dc4d6'),
+            dict(path='../../omlish/logs/levels.py', sha1='91405563d082a5eba874da82aac89d83ce7b6152'),
+            dict(path='../../omlish/logs/std/filters.py', sha1='f36aab646d84d31e295b33aaaaa6f8b67ff38b3d'),
+            dict(path='../../omlish/logs/std/proxy.py', sha1='3e7301a2aa351127f9c85f61b2f85dcc3f15aafb'),
+            dict(path='../../omlish/logs/warnings.py', sha1='c4eb694b24773351107fcc058f3620f1dbfb6799'),
+            dict(path='../../omlish/os/files.py', sha1='32f4fe2e7d32a6b368619081bd300e6f150e312b'),
+            dict(path='../../omlish/os/paths.py', sha1='56c40b7c2aa84d1778d60ee4cda498f8c380cc8d'),
+            dict(path='../../omlish/secrets/ssl.py', sha1='68af8abad22d64afa1736a8363036aa2121ada78'),
+            dict(path='../../omlish/sockets/addresses.py', sha1='26533e88a8073f89646c0f77f1fbe0869282ab0e'),
+            dict(path='../../omlish/sockets/io.py', sha1='b6b8a73ac0f29893c7128f9d4f62240efbd917bb'),
+            dict(path='docker/utils.py', sha1='082e2b962ca1bc8e6b3f9bbe6ecfcadff310d54f'),
+            dict(path='github/api/v1/api.py', sha1='1985c16447f5d245b659936571d361285374c5d9'),
+            dict(path='github/api/v2/api.py', sha1='08322895cd895db1cbffceb1e5bfc7b10cac50cc'),
+            dict(path='github/bootstrap.py', sha1='9bf24b05603cd1a82db8be8b645bbad3e0d3f22f'),
+            dict(path='../oci/datarefs.py', sha1='793ce5f2774e052b28d04b226a5f1eff6eec0a72'),
+            dict(path='../oci/pack/unpacking.py', sha1='f43dee9a2eee79cbbb90f0721ed234a2bc35daa7'),
+            dict(path='../../omlish/argparse/cli.py', sha1='f4dc3cd353d14386b5da0306768700e396afd2b3'),
+            dict(path='../../omlish/http/coro/io.py', sha1='2cdf6529c37a37cc0c1db2e02032157cf906d5d6'),
+            dict(path='../../omlish/http/parsing.py', sha1='3fea28dc6341908ba7c8fad42bf7bbe711f21b82'),
+            dict(path='../../omlish/lite/marshal.py', sha1='96348f5f2a26dc27d842d33cc3927e9da163436b'),
+            dict(path='../../omlish/lite/maybes.py', sha1='bdf5136654ccd14b6a072588cad228925bdfbabd'),
+            dict(path='../../omlish/lite/runtime.py', sha1='2e752a27ae2bf89b1bb79b4a2da522a3ec360c70'),
+            dict(path='../../omlish/lite/timeouts.py', sha1='a0f673033a6943f242e35848d78a41892b9c62a1'),
+            dict(path='../../omlish/logs/infos.py', sha1='4dd104bd468a8c438601dd0bbda619b47d2f1620'),
+            dict(path='../../omlish/logs/protocols.py', sha1='05ca4d1d7feb50c4e3b9f22ee371aa7bf4b3dbd1'),
+            dict(path='../../omlish/logs/std/json.py', sha1='2a75553131e4d5331bb0cedde42aa183f403fc3b'),
+            dict(path='../../omlish/os/temp.py', sha1='fba3470ac095a6c3f893156cc4437bda1b8796cb'),
+            dict(path='../../omlish/sockets/bind.py', sha1='d0040d74960fb00c30ae9ece5252c270b59ae3f4'),
+            dict(path='../../omlish/sockets/handlers.py', sha1='733a4855d563001ad09df511531d710aa2632770'),
+            dict(path='../../omlish/text/mangle.py', sha1='5631de37ca659e064eb1afcf2213d317b626f8bd'),
+            dict(path='../dataserver/targets.py', sha1='661fc3e60ad436646c8acff3c547d5b86ceb0bd6'),
+            dict(path='../oci/data.py', sha1='9cfc3bb8e23fb4cd746c6e8f0e02624e8f63f234'),
+            dict(path='../oci/repositories.py', sha1='bd0ac0fb906f679a660c87124da268370733fcc6'),
+            dict(path='../oci/tars.py', sha1='3ed00e97a494bd92c6a6149d22d51469bc0af384'),
+            dict(path='../../omlish/asyncs/asyncio/sockets.py', sha1='8d24dae988a30bb73f167a9ab62d4fc9eef4ad06'),
+            dict(path='../../omlish/asyncs/asyncio/timeouts.py', sha1='4d31b02b3c39b8f2fa7e94db36552fde6942e36a'),
+            dict(path='../../omlish/http/handlers.py', sha1='40629060bac22ea5e94b720b57001861a4ec9031'),
+            dict(path='../../omlish/lite/inject.py', sha1='6f097e3170019a34ff6834d36fcc9cbeed3a7ab4'),
+            dict(path='../../omlish/logs/contexts.py', sha1='7456964ade9ac66460e9ade4e242dbdc24b39501'),
+            dict(path='../../omlish/logs/standard.py', sha1='818b674f7d15012f25b79f52f6e8e7368b633038'),
+            dict(path='../../omlish/logs/utils.py', sha1='8430cddbb7de34afb2793ab8a0cc6fbee47fef2c'),
+            dict(path='../../omlish/sockets/server/handlers.py', sha1='6f9adca9fa04774a28a488a4e2a11bb4492c71d0'),
+            dict(path='../../omlish/subprocesses/run.py', sha1='8200e48f0c49d164df3503cd0143038d0c4d30aa'),
+            dict(path='../../omlish/subprocesses/wrap.py', sha1='8a9b7d2255481fae15c05f5624b0cdc0766f4b3f'),
+            dict(path='../dataserver/handlers.py', sha1='f624715f2500087226ec3374315cc8a1ea47a29b'),
+            dict(path='../dataserver/routes.py', sha1='0186bb2e84ff4d5c05af2a57c61f6fd605eba790'),
+            dict(path='../oci/media.py', sha1='a20324c5b0661c9a9a7679406d019ab3ba4acd98'),
+            dict(path='../oci/pack/packing.py', sha1='7585c3dea6b8a62b6ca63fe78968497db915ea57'),
+            dict(path='../../omlish/http/coro/server/server.py', sha1='c0a980afa8346dbc20570acddb2b3b579bfc1ce0'),
+            dict(path='../../omlish/logs/base.py', sha1='a376460b11b9dc0555fd4ead5437af62c2109a4b'),
+            dict(path='../../omlish/logs/std/records.py', sha1='8bbf6ef9eccb3a012c6ca416ddf3969450fd8fc9'),
+            dict(path='../../omlish/secrets/tempssl.py', sha1='360d4cd98483357bcf013e156dafd92fd37ed220'),
+            dict(path='../../omlish/sockets/server/server.py', sha1='a93a74f6beb38d69e0fb9047c932f2a95aa37eca'),
+            dict(path='../../omlish/sockets/server/ssl.py', sha1='790dfd208f4d267c826d491d4eb5deeda5ebdddc'),
+            dict(path='../../omlish/sockets/server/threading.py', sha1='0ba3c7a3d15781326610b12feef94e53903d0ce9'),
+            dict(path='../../omlish/subprocesses/base.py', sha1='cb9f668be5422fecb27222caabb67daac6c1bab9'),
+            dict(path='docker/cacheserved/manifests.py', sha1='80a65d08319d152f0bc6f893351e23368b3de93b'),
+            dict(path='../dataserver/server.py', sha1='e1ba8ca6f85458a64ede4ca07836aa103246132a'),
+            dict(path='../oci/building.py', sha1='b4fea06c03ba02d3ecfc6d10d955dc76f263846a'),
+            dict(path='../oci/loading.py', sha1='64d806ffad8d24087ccc29f759f672e6d795bee2'),
+            dict(path='../../omlish/http/coro/server/sockets.py', sha1='40ef4aa43f94f1a1a2a431a012cb961f25905ff4'),
+            dict(path='../../omlish/logs/std/loggers.py', sha1='daa35bdc4adea5006e442688017f0de3392579b7'),
+            dict(path='../../omlish/subprocesses/asyncs.py', sha1='bba44d524c24c6ac73168aee6343488414e5bf48'),
+            dict(path='../../omlish/subprocesses/sync.py', sha1='8434919eba4da67825773d56918fdc0cb2f1883b'),
+            dict(path='requirements.py', sha1='c370a65958a00412e00608a0e1f12795e276aee1'),
+            dict(path='../dataserver/http.py', sha1='f85ca91015bac434281326ef7885babd9d6d834c'),
+            dict(path='../oci/dataserver.py', sha1='dd147b56282b054cef264556a0ff3b3d1719bcee'),
+            dict(path='../../omlish/asyncs/asyncio/subprocesses.py', sha1='b6b5f9ae3fd0b9c83593bad2e04a08f726e5904d'),
+            dict(path='../../omlish/http/coro/server/simple.py', sha1='2332079fe29993123c68d7dbc266b47cd44cd6a6'),
+            dict(path='../../omlish/logs/modules.py', sha1='99e73cde6872fd5eda6af3dbf0fc9322bdeb641a'),
+            dict(path='cache.py', sha1='9353e5c3b73bed47258680fd15ac49417113f0ca'),
+            dict(path='compose.py', sha1='d2bec1385701979c7ff9913456b72d8c7b31f70b'),
+            dict(path='docker/cmds.py', sha1='5528c384f68f9003732bfaf6be302e84747909dd'),
+            dict(path='docker/dataserver.py', sha1='949e561ab756846425a39c05964c0fb256ae61db'),
+            dict(path='../../omlish/lite/timing.py', sha1='af5022f5a508939f1b433ed0514ede340fd0d672'),
+            dict(path='docker/cache.py', sha1='07a9e3d00bdd60f1a0a9b55aca12430fa1b4e3d9'),
+            dict(path='docker/repositories.py', sha1='e4bfc0e91c3bf20259895ce7c95a1eb3f6507518'),
+            dict(path='github/api/clients.py', sha1='8ddc0f5ccf718f1b530f4a965f0cc56b68a6a2a8'),
+            dict(path='github/api/v2/azure.py', sha1='19052e8e2babb8b2953ec10e6b9dcee97c21419a'),
+            dict(path='../oci/pack/repositories.py', sha1='e9bf6fa8bdaae2031dd0967d07a56c93a2e099b6'),
+            dict(path='docker/buildcaching.py', sha1='7b2633d5b8dac6aab01dd459e273cb370c5b11c8'),
+            dict(path='docker/cacheserved/cache.py', sha1='69732c658dba7ccf260e784132ff0c60192e3c69'),
+            dict(path='docker/imagepulling.py', sha1='d6b1ca1ecb9aa5c593a25e6deb78e942c75ebcb4'),
+            dict(path='github/api/v1/client.py', sha1='6ddd600cd8a7ff72a6a3408ded14240bafab6944'),
+            dict(path='github/api/v2/client.py', sha1='e28f27c07011487d5a3f4ae32fdfa1a857d02459'),
+            dict(path='ci.py', sha1='87b82e2bd86aa886764f1e0067251b056e359650'),
+            dict(path='docker/inject.py', sha1='69acac65fae413cb58c1f9aa739d2cc1c3ffa09d'),
+            dict(path='github/cache.py', sha1='d91f9c87d167574e94c99817e6c3a0f75925dfb9'),
+            dict(path='github/cli.py', sha1='6d14b0eb4ca5f606ad2821b63b9707ce57f50406'),
+            dict(path='github/inject.py', sha1='99c0dd7c55767e7c49f70b7edac25da67f718b2e'),
+            dict(path='inject.py', sha1='e86b16d79a113a4f387e68ed0db1d067bcada93a'),
+            dict(path='cli.py', sha1='49bcd482bd814ba436237099b4bdb62f77d6c054'),
+        ],
+    )
+
+
 ########################################
 
 
@@ -345,6 +462,8 @@ async def asyncio_wait_concurrent(
     if isinstance(concurrency, asyncio.Semaphore):
         semaphore = concurrency
     elif isinstance(concurrency, int):
+        if concurrency < 1:
+            raise ValueError(f'Concurrency must be >= 1, got {concurrency}')
         semaphore = asyncio.Semaphore(concurrency)
     else:
         raise TypeError(concurrency)
@@ -508,25 +627,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
 
 
@@ -580,23 +723,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)}
+            if ams := compute_abstract_methods(cls):
+                amd = {
+                    a: mcls
+                    for mcls in cls.__mro__[::-1]
+                    for a in ams
+                    if a in mcls.__dict__
+                }
 
-            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:
                 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)]
                     ])),
                 )
 
@@ -670,6 +816,62 @@ def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
     return _AsyncCachedNullary(fn)
 
 
+##
+
+
+cached_property = functools.cached_property
+
+
+class _cached_property:  # noqa
+    """Backported to pick up https://github.com/python/cpython/commit/056dfc71dce15f81887f0bd6da09d6099d71f979 ."""
+
+    def __init__(self, func):
+        self.func = func
+        self.attrname = None  # noqa
+        self.__doc__ = func.__doc__
+        self.__module__ = func.__module__
+
+    _NOT_FOUND = object()
+
+    def __set_name__(self, owner, name):
+        if self.attrname is None:
+            self.attrname = name  # noqa
+        elif name != self.attrname:
+            raise TypeError(
+                f'Cannot assign the same cached_property to two different names ({self.attrname!r} and {name!r}).',
+            )
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        if self.attrname is None:
+            raise TypeError('Cannot use cached_property instance without calling __set_name__ on it.')
+
+        try:
+            cache = instance.__dict__
+        except AttributeError:  # not all objects have __dict__ (e.g. class defines slots)
+            raise TypeError(
+                f"No '__dict__' attribute on {type(instance).__name__!r} instance to cache {self.attrname!r} property.",
+            ) from None
+
+        val = cache.get(self.attrname, self._NOT_FOUND)
+
+        if val is self._NOT_FOUND:
+            val = self.func(instance)
+            try:
+                cache[self.attrname] = val
+            except TypeError:
+                raise TypeError(
+                    f"The '__dict__' attribute on {type(instance).__name__!r} instance does not support item "
+                    f"assignment for caching {self.attrname!r} property.",
+                ) from None
+
+        return val
+
+
+globals()['cached_property'] = _cached_property
+
+
 ########################################
 # ../../../omlish/lite/check.py
 """
@@ -1209,7 +1411,7 @@ class ExitStacked:
             es.__enter__()
             try:
                 self._enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 es.__exit__(*sys.exc_info())
                 raise
             return self
@@ -1220,7 +1422,7 @@ class ExitStacked:
             return None
         try:
             self._exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             es.__exit__(*sys.exc_info())
             raise
         return es.__exit__(exc_type, exc_val, exc_tb)
@@ -1268,7 +1470,7 @@ class AsyncExitStacked:
             await es.__aenter__()
             try:
                 await self._async_enter_contexts()
-            except Exception:  # noqa
+            except BaseException:  # noqa
                 await es.__aexit__(*sys.exc_info())
                 raise
             return self
@@ -1279,7 +1481,7 @@ class AsyncExitStacked:
             return None
         try:
             await self._async_exit_contexts()
-        except Exception:  # noqa
+        except BaseException:  # noqa
             await es.__aexit__(*sys.exc_info())
             raise
         return await es.__aexit__(exc_type, exc_val, exc_tb)
@@ -1366,6 +1568,17 @@ aclosing = AsyncClosingManager
 ##
 
 
+def dataclass_shallow_astuple(o: ta.Any) -> ta.Tuple[ta.Any, ...]:
+    return tuple(getattr(o, f.name) for f in dc.fields(o))
+
+
+def dataclass_shallow_asdict(o: ta.Any) -> ta.Dict[str, ta.Any]:
+    return {f.name: getattr(o, f.name) for f in dc.fields(o)}
+
+
+##
+
+
 def is_immediate_dataclass(cls: type) -> bool:
     if not isinstance(cls, type):
         raise TypeError(cls)
@@ -1448,6 +1661,36 @@ def dataclass_repr_omit_falsey(obj: ta.Any) -> str:
 ##
 
 
+def dataclass_descriptor_method(*bind_attrs: str, bind_owner: bool = False) -> ta.Callable:
+    if not bind_attrs:
+        def __get__(self, instance, owner=None):  # noqa
+            return self
+
+    elif bind_owner:
+        def __get__(self, instance, owner=None):  # noqa
+            # Guaranteed to return a new instance even with no attrs
+            return dc.replace(self, **{
+                a: v.__get__(instance, owner) if (v := getattr(self, a)) is not None else None
+                for a in bind_attrs
+            })
+
+    else:
+        def __get__(self, instance, owner=None):  # noqa
+            if instance is None:
+                return self
+
+            # Guaranteed to return a new instance even with no attrs
+            return dc.replace(self, **{
+                a: v.__get__(instance, owner) if (v := getattr(self, a)) is not None else None
+                for a in bind_attrs
+            })
+
+    return __get__
+
+
+##
+
+
 def dataclass_kw_only_init():
     def inner(cls):
         if not isinstance(cls, type) and dc.is_dataclass(cls):
@@ -1511,6 +1754,20 @@ def dataclass_kw_only_init():
     return inner
 
 
+##
+
+
+@dc.dataclass()
+class DataclassFieldRequiredError(Exception):
+    name: str
+
+
+def dataclass_field_required(name: str) -> ta.Callable[[], ta.Any]:
+    def inner() -> ta.NoReturn:
+        raise DataclassFieldRequiredError(name)
+    return inner
+
+
 ########################################
 # ../../../omlish/lite/json.py
 
@@ -2968,6 +3225,7 @@ TODO:
  - pre-run, post-run hooks
  - exitstack?
  - suggestion - difflib.get_close_matches
+ - add_argument_group - group kw on ArgparseKwarg?
 """
 
 
@@ -2978,6 +3236,7 @@ TODO:
 class ArgparseArg:
     args: ta.Sequence[ta.Any]
     kwargs: ta.Mapping[str, ta.Any]
+    group: ta.Optional[str] = None
     dest: ta.Optional[str] = None
 
     def __get__(self, instance, owner=None):
@@ -2987,7 +3246,11 @@ class ArgparseArg:
 
 
 def argparse_arg(*args, **kwargs) -> ArgparseArg:
-    return ArgparseArg(args, kwargs)
+    return ArgparseArg(
+        args=args,
+        group=kwargs.pop('group', None),
+        kwargs=kwargs,
+    )
 
 
 def argparse_arg_(*args, **kwargs) -> ta.Any:
@@ -3157,6 +3420,10 @@ class ArgparseCli:
                     subparser.set_defaults(_cmd=obj)
 
             elif isinstance(obj, ArgparseArg):
+                if obj.group is not None:
+                    # FIXME: add_argument_group
+                    raise NotImplementedError
+
                 if att in anns:
                     ann_kwargs = _get_argparse_arg_ann_kwargs(anns[att])
                     obj.kwargs = {**ann_kwargs, **obj.kwargs}
@@ -3202,7 +3469,7 @@ class ArgparseCli:
 
         if self._unknown_args and not (cmd is not None and cmd.accepts_unknown):
             msg = f'unrecognized arguments: {" ".join(self._unknown_args)}'
-            if (parser := self.get_parser()).exit_on_error:
+            if (parser := self.get_parser()).exit_on_error:  # noqa
                 parser.error(msg)
             else:
                 raise argparse.ArgumentError(None, msg)
@@ -3222,7 +3489,10 @@ class ArgparseCli:
         return fn()
 
     def cli_run_and_exit(self) -> ta.NoReturn:
-        sys.exit(rc if isinstance(rc := self.cli_run(), int) else 0)
+        rc = self.cli_run()
+        if not isinstance(rc, int):
+            rc = 0
+        raise SystemExit(rc)
 
     def __call__(self, *, exit: bool = False) -> ta.Optional[int]:  # noqa
         if exit:
@@ -3254,6 +3524,72 @@ class ArgparseCli:
             return fn()
 
 
+########################################
+# ../../../omlish/http/coro/io.py
+
+
+##
+
+
+class CoroHttpIo:
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+    def __init_subclass__(cls, **kwargs):  # noqa
+        raise TypeError
+
+    #
+
+    MAX_LINE: ta.ClassVar[int] = 65536
+
+    #
+
+    class Io(Abstract):
+        pass
+
+    #
+
+    class AnyLogIo(Io, Abstract):
+        pass
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class ConnectIo(Io):
+        args: ta.Tuple[ta.Any, ...]
+        kwargs: ta.Optional[ta.Dict[str, ta.Any]] = None
+
+        server_hostname: ta.Optional[str] = None
+
+    #
+
+    class CloseIo(Io):
+        pass
+
+    #
+
+    class AnyReadIo(Io):  # noqa
+        pass
+
+    @dc.dataclass(frozen=True)
+    class ReadIo(AnyReadIo):
+        sz: ta.Optional[int]
+
+    @dc.dataclass(frozen=True)
+    class ReadLineIo(AnyReadIo):
+        sz: int
+
+    @dc.dataclass(frozen=True)
+    class PeekIo(AnyReadIo):
+        sz: int
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class WriteIo(Io):
+        data: bytes
+
+
 ########################################
 # ../../../omlish/http/parsing.py
 # PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
@@ -4587,8 +4923,6 @@ class _JustMaybe(_Maybe[T]):
     __slots__ = ('_v', '_hash')
 
     def __init__(self, v: T) -> None:
-        super().__init__()
-
         self._v = v
 
     @property
@@ -4646,6 +4980,13 @@ class _EmptyMaybe(_Maybe[T]):
 Maybe._empty = _EmptyMaybe()  # noqa
 
 
+##
+
+
+setattr(Maybe, 'just', _JustMaybe)  # noqa
+setattr(Maybe, 'empty', functools.partial(operator.attrgetter('_empty'), Maybe))
+
+
 ########################################
 # ../../../omlish/lite/runtime.py
 
@@ -7927,7 +8268,7 @@ def configure_standard_logging(
 ##
 
 
-def error_logging(log):  # noqa
+def exception_logging(log):  # noqa
     def outer(fn):
         @functools.wraps(fn)
         def inner(*args, **kwargs):
@@ -9247,48 +9588,21 @@ class CoroHttpServer:
 
     #
 
-    class Io(Abstract):
-        pass
-
-    #
-
-    class AnyLogIo(Io):
-        pass
-
     @dc.dataclass(frozen=True)
-    class ParsedRequestLogIo(AnyLogIo):
+    class ParsedRequestLogIo(CoroHttpIo.AnyLogIo):
         request: ParsedHttpRequest
 
     @dc.dataclass(frozen=True)
-    class ErrorLogIo(AnyLogIo):
+    class ErrorLogIo(CoroHttpIo.AnyLogIo):
         error: 'CoroHttpServer.Error'
 
     #
 
-    class AnyReadIo(Io):  # noqa
-        pass
-
-    @dc.dataclass(frozen=True)
-    class ReadIo(AnyReadIo):
-        sz: int
-
-    @dc.dataclass(frozen=True)
-    class ReadLineIo(AnyReadIo):
-        sz: int
-
-    #
-
-    @dc.dataclass(frozen=True)
-    class WriteIo(Io):
-        data: bytes
-
-    #
-
     @dc.dataclass(frozen=True)
     class CoroHandleResult:
         close_reason: ta.Literal['response', 'internal', None] = None
 
-    def coro_handle(self) -> ta.Generator[Io, ta.Optional[bytes], CoroHandleResult]:
+    def coro_handle(self) -> ta.Generator[CoroHttpIo.Io, ta.Optional[bytes], CoroHandleResult]:
         return self._coro_run_handler(self._coro_handle_one())
 
     class Close(Exception):  # noqa
@@ -9297,20 +9611,20 @@ class CoroHttpServer:
     def _coro_run_handler(
             self,
             gen: ta.Generator[
-                ta.Union[AnyLogIo, AnyReadIo, _Response],
+                ta.Union[CoroHttpIo.AnyLogIo, CoroHttpIo.AnyReadIo, _Response],
                 ta.Optional[bytes],
                 None,
             ],
-    ) -> ta.Generator[Io, ta.Optional[bytes], CoroHandleResult]:
+    ) -> ta.Generator[CoroHttpIo.Io, ta.Optional[bytes], CoroHandleResult]:
         i: ta.Optional[bytes]
         o: ta.Any = next(gen)
         while True:
             try:
-                if isinstance(o, self.AnyLogIo):
+                if isinstance(o, CoroHttpIo.AnyLogIo):
                     i = None
                     yield o
 
-                elif isinstance(o, self.AnyReadIo):
+                elif isinstance(o, CoroHttpIo.AnyReadIo):
                     i = check.isinstance((yield o), bytes)
 
                 elif isinstance(o, self._Response):
@@ -9318,10 +9632,10 @@ class CoroHttpServer:
 
                     r = self._preprocess_response(o)
                     hb = self._build_response_head_bytes(r)
-                    check.none((yield self.WriteIo(hb)))
+                    check.none((yield CoroHttpIo.WriteIo(hb)))
 
                     for b in self._yield_response_data(r):
-                        yield self.WriteIo(b)
+                        yield CoroHttpIo.WriteIo(b)
 
                     o.close()
                     if o.close_connection:
@@ -9349,7 +9663,7 @@ class CoroHttpServer:
                 raise
 
     def _coro_handle_one(self) -> ta.Generator[
-        ta.Union[AnyLogIo, AnyReadIo, _Response],
+        ta.Union[CoroHttpIo.AnyLogIo, CoroHttpIo.AnyReadIo, _Response],
         ta.Optional[bytes],
         None,
     ]:
@@ -9359,7 +9673,7 @@ class CoroHttpServer:
         sz = next(gen)
         while True:
             try:
-                line = check.isinstance((yield self.ReadLineIo(sz)), bytes)
+                line = check.isinstance((yield CoroHttpIo.ReadLineIo(sz)), bytes)
                 sz = gen.send(line)
             except StopIteration as e:
                 parsed = e.value
@@ -9398,7 +9712,7 @@ class CoroHttpServer:
 
         request_data: ta.Optional[bytes]
         if (cl := parsed.headers.get('Content-Length')) is not None:
-            request_data = check.isinstance((yield self.ReadIo(int(cl))), bytes)
+            request_data = check.isinstance((yield CoroHttpIo.ReadIo(int(cl))), bytes)
         else:
             request_data = None
 
@@ -10753,6 +11067,10 @@ class VerboseCalledProcessError(subprocess.CalledProcessError):
 class BaseSubprocesses(Abstract):
     DEFAULT_LOGGER: ta.ClassVar[ta.Optional[LoggerLike]] = None
 
+    PIPE: ta.ClassVar[int] = subprocess.PIPE
+    STDOUT: ta.ClassVar[int] = subprocess.STDOUT
+    DEVNULL: ta.ClassVar[int] = subprocess.DEVNULL
+
     def __init__(
             self,
             *,
@@ -11443,7 +11761,7 @@ class CoroHttpServerSocketHandler(SocketHandler_):
             server_factory: CoroHttpServerFactory,
             *,
             keep_alive: bool = False,
-            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpServer.AnyLogIo], None]] = None,
+            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpIo.AnyLogIo], None]] = None,
     ) -> None:
         super().__init__()
 
@@ -11472,18 +11790,18 @@ class CoroHttpServerSocketHandler(SocketHandler_):
 
         o = next(gen)
         while True:
-            if isinstance(o, CoroHttpServer.AnyLogIo):
+            if isinstance(o, CoroHttpIo.AnyLogIo):
                 i = None
                 if self._log_handler is not None:
                     self._log_handler(server, o)
 
-            elif isinstance(o, CoroHttpServer.ReadIo):
-                i = fp.r.read(o.sz)
+            elif isinstance(o, CoroHttpIo.ReadIo):
+                i = fp.r.read(check.not_none(o.sz))
 
-            elif isinstance(o, CoroHttpServer.ReadLineIo):
+            elif isinstance(o, CoroHttpIo.ReadLineIo):
                 i = fp.r.readline(o.sz)
 
-            elif isinstance(o, CoroHttpServer.WriteIo):
+            elif isinstance(o, CoroHttpIo.WriteIo):
                 i = None
                 fp.w.write(o.data)
                 fp.w.flush()
@@ -15376,7 +15694,7 @@ async def _async_main() -> ta.Optional[int]:
 def _main() -> None:
     configure_standard_logging('DEBUG')
 
-    sys.exit(rc if isinstance(rc := asyncio.run(_async_main()), int) else 0)
+    raise SystemExit(rc if isinstance(rc := asyncio.run(_async_main()), int) else 0)
 
 
 if __name__ == '__main__':