ominfra 0.0.0.dev433__py3-none-any.whl → 0.0.0.dev501__py3-none-any.whl

ominfra/scripts/supervisor.py

@@ -65,6 +65,7 @@ import io
 import itertools
 import json
 import logging
+import operator
 import os
 import os.path
 import pwd
@@ -98,11 +99,98 @@ 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='errors.py', sha1='eed49133c64621fb5f081ba7f249e8c4c8745025'),
+            dict(path='privileges.py', sha1='80fffb4966565e70b6300381800ff849616a1daa'),
+            dict(path='states.py', sha1='7e80da5abde756a47bb01fff1967e35ee9f754e5'),
+            dict(path='utils/diag.py', sha1='65f6491a57b3b8ff6dc166c4136c39e49e008c8d'),
+            dict(path='utils/fs.py', sha1='f18fd3d60c863e05d91c8e4735b86629334f5181'),
+            dict(path='utils/ostypes.py', sha1='81aa9dc830189ae7095c2b8c823e28ce4a808e8d'),
+            dict(path='utils/signals.py', sha1='445bab01dcd0144194f330e55accee1277992626'),
+            dict(path='utils/strings.py', sha1='c4ced4877e366a64b7d366353ab9e5691c587f38'),
+            dict(path='../../omlish/configs/types.py', sha1='f7a5584cd6eccb77d18d729796072a162e9a8790'),
+            dict(path='../../omlish/formats/ini/sections.py', sha1='731c92cce82e183d1d4bdc23fc781fad62187394'),
+            dict(path='../../omlish/formats/toml/parser.py', sha1='73dac82289350ab951c4bcdbfe61167fa221f26f'),
+            dict(path='../../omlish/formats/toml/writer.py', sha1='6ea41d7e724bb1dcf6bd84b88993ff4e8798e021'),
+            dict(path='../../omlish/http/versions.py', sha1='197685ffbb62a457a0e8d4047a9df26aebd7dae4'),
+            dict(path='../../omlish/io/readers.py', sha1='4b19ab4a87f2fa2a6f6c3cad7e1f3892b7cbd3a4'),
+            dict(path='../../omlish/lite/abstract.py', sha1='a2fc3f3697fa8de5247761e9d554e70176f37aac'),
+            dict(path='../../omlish/lite/asyncs.py', sha1='b3f2251c56617ce548abf9c333ac996b63edb23e'),
+            dict(path='../../omlish/lite/attrops.py', sha1='c1ebfb8573d766d34593c452a2377208d02726dc'),
+            dict(path='../../omlish/lite/cached.py', sha1='0c33cf961ac8f0727284303c7a30c5ea98f714f2'),
+            dict(path='../../omlish/lite/check.py', sha1='bb6b6b63333699b84462951a854d99ae83195b94'),
+            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/lite/typing.py', sha1='048bb5fb8ecad5be101516f8f3b7996707f5bc42'),
+            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/sockets/addresses.py', sha1='26533e88a8073f89646c0f77f1fbe0869282ab0e'),
+            dict(path='events.py', sha1='d30d903b7d664f76e738ed939b7ec0e6e6861a0a'),
+            dict(path='utils/collections.py', sha1='f9c3c8a52e6057e938730746eaa28e48a5b757c6'),
+            dict(path='utils/fds.py', sha1='cf9b2a52cc74b2aaebed656ba16888e4322746ec'),
+            dict(path='utils/users.py', sha1='d440d9deb2f03b4611bc0eb0ad186f9a994d84f7'),
+            dict(path='../../omlish/configs/formats.py', sha1='9bc4f953b4b8700f6f109e6f49e2d70f8e48ce7c'),
+            dict(path='../../omlish/configs/processing/names.py', sha1='3ae4c9e921929eb64cee6150cc86f35fee0f2070'),
+            dict(path='../../omlish/http/coro/io.py', sha1='2cdf6529c37a37cc0c1db2e02032157cf906d5d6'),
+            dict(path='../../omlish/http/parsing.py', sha1='3fea28dc6341908ba7c8fad42bf7bbe711f21b82'),
+            dict(path='../../omlish/io/buffers.py', sha1='45a5f79c6d71f02ab82082a48d63ebbd10959031'),
+            dict(path='../../omlish/io/fdio/handlers.py', sha1='e81356d4d73a670c35a972476a6338d0b737662b'),
+            dict(path='../../omlish/io/fdio/pollers.py', sha1='022d5a8a24412764864ca95186a167698b739baf'),
+            dict(path='../../omlish/lite/marshal.py', sha1='96348f5f2a26dc27d842d33cc3927e9da163436b'),
+            dict(path='../../omlish/lite/maybes.py', sha1='04d2fcbea17028a5e6b8e7a7fb742375495ed233'),
+            dict(path='../../omlish/lite/runtime.py', sha1='2e752a27ae2bf89b1bb79b4a2da522a3ec360c70'),
+            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/journald.py', sha1='7485cad562f8b9b4f71efd41a6177660f7d62e55'),
+            dict(path='configs.py', sha1='61f986fc5c9591194f72c3b4ffa4b018770710ed'),
+            dict(path='pipes.py', sha1='ad9315c50bffe81ee204227163d85ab366ce5320'),
+            dict(path='setup.py', sha1='4be12354bb45cf7773fd98ad9695aa330ae07fe6'),
+            dict(path='utils/os.py', sha1='9f7314f1c0c34a8154e9acf38a5b916b2e310b4d'),
+            dict(path='../../omlish/http/handlers.py', sha1='40629060bac22ea5e94b720b57001861a4ec9031'),
+            dict(path='../../omlish/io/fdio/kqueue.py', sha1='c90ba13e9e5ee795b6af752a6f25f8bcfd7f88a0'),
+            dict(path='../../omlish/lite/configs.py', sha1='c8602e0e197ef1133e7e8e248935ac745bfd46cb'),
+            dict(path='../../omlish/lite/inject.py', sha1='6f097e3170019a34ff6834d36fcc9cbeed3a7ab4'),
+            dict(path='../../omlish/logs/contexts.py', sha1='1000a6d5ddfb642865ca532e34b1d50759781cf0'),
+            dict(path='../../omlish/logs/std/standard.py', sha1='5c97c1b9f7ead58d6127d047b873398f708f288d'),
+            dict(path='types.py', sha1='7ef67f710fb54c3af067aa596cb593f33eafe380'),
+            dict(path='../../omlish/http/coro/server/server.py', sha1='c0a980afa8346dbc20570acddb2b3b579bfc1ce0'),
+            dict(path='../../omlish/logs/base.py', sha1='8d06faee05fead6b1dd98c9035a5b042af4aebb1'),
+            dict(path='../../omlish/logs/std/records.py', sha1='8bbf6ef9eccb3a012c6ca416ddf3969450fd8fc9'),
+            dict(path='dispatchers.py', sha1='33fe5ae77e33b3cfabb97b1a1c0f06dd0cc54703'),
+            dict(path='groupsimpl.py', sha1='4fe587a6eaff7dd874b54450be62f9689283d230'),
+            dict(path='process.py', sha1='ec0903adbde7552ba8a6aad9030716ef57fc4a6c'),
+            dict(path='../../omlish/http/coro/server/fdio.py', sha1='3f1b4865e589a336f942a763dc11ce42fa5c8857'),
+            dict(path='../../omlish/logs/asyncs.py', sha1='ab11b70033d9f2e9a4e70254185aa1c6130c6077'),
+            dict(path='../../omlish/logs/std/loggers.py', sha1='a569179445d6a8a942b5dcfad1d1f77702868803'),
+            dict(path='groups.py', sha1='a02a602d28793e5c84fbe7bfbcfa6ccce2ee0788'),
+            dict(path='spawning.py', sha1='9e65e562395ad04e3f3a314f946b7a4e58a601da'),
+            dict(path='../../omlish/logs/modules.py', sha1='dd7d5f8e63fe8829dfb49460f3929ab64b68ee14'),
+            dict(path='dispatchersimpl.py', sha1='701947899daef9f68c4277495594031cf73d9a62'),
+            dict(path='http.py', sha1='6a144e4c93abefc5f9cdba207e807ea75f8f2d5d'),
+            dict(path='io.py', sha1='6ba708a8396c212afdd1d314c9b5804c2d66646e'),
+            dict(path='processimpl.py', sha1='7edbbcd39a8ed1fd195c760da894620617a9d969'),
+            dict(path='setupimpl.py', sha1='b4b8b8c3e1d71a0e6794fb0a845181f3662a6bfd'),
+            dict(path='signals.py', sha1='645361d922557b5cedddbd261b3f1485b96555dd'),
+            dict(path='spawningimpl.py', sha1='c770e0017c2388fe59897d12fe67c3b6b7b2ca5a'),
+            dict(path='supervisor.py', sha1='a97a13ec71deaf6eacabb1527f373b21b89209af'),
+            dict(path='inject.py', sha1='6ad254bcf1c78e0b8a1d7bb3940628857e3bb60c'),
+            dict(path='main.py', sha1='8bd55a46b4a4fc4ad0034205384b0b49b8374c7a'),
+        ],
+    )
+
+
 ########################################
 
 
 # ../../omlish/configs/types.py
-ConfigMap = ta.Mapping[str, ta.Any]
+ConfigMap = ta.Mapping[str, ta.Any]  # ta.TypeAlias
 
 # ../../omlish/formats/ini/sections.py
 IniSectionSettingsMap = ta.Mapping[str, ta.Mapping[str, ta.Union[str, ta.Sequence[str]]]]  # ta.TypeAlias
@@ -112,7 +200,7 @@ TomlParseFloat = ta.Callable[[str], ta.Any]  # ta.TypeAlias
 TomlKey = ta.Tuple[str, ...]  # ta.TypeAlias
 TomlPos = int  # ta.TypeAlias
 
-# ../../omlish/lite/attrops.py
+# ../../omlish/lite/abstract.py
 T = ta.TypeVar('T')
 
 # ../../omlish/lite/cached.py
@@ -135,7 +223,7 @@ A2 = ta.TypeVar('A2')
 LogLevel = int  # ta.TypeAlias
 
 # ../../omlish/sockets/addresses.py
-SocketAddress = ta.Any
+SocketAddress = ta.Any  # ta.TypeAlias
 
 # events.py
 EventCallback = ta.Callable[['Event'], None]  # ta.TypeAlias
@@ -166,16 +254,16 @@ HttpHandler = ta.Callable[['HttpHandlerRequest'], 'HttpHandlerResponse']  # ta.T
 HttpHandlerResponseData = ta.Union[bytes, 'HttpHandlerResponseStreamedData']  # ta.TypeAlias  # noqa
 
 # ../../omlish/lite/inject.py
-InjectorKeyCls = ta.Union[type, ta.NewType]
-InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
-InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']
-InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
+InjectorKeyCls = ta.Union[type, ta.NewType]  # ta.TypeAlias
+InjectorProviderFn = ta.Callable[['Injector'], ta.Any]  # ta.TypeAlias
+InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']  # ta.TypeAlias
+InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']  # ta.TypeAlias
 
 # ../../omlish/logs/contexts.py
 LoggingContextInfoT = ta.TypeVar('LoggingContextInfoT', bound=LoggingContextInfo)
 
 # ../../omlish/http/coro/server/server.py
-CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']
+CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']  # ta.TypeAlias
 
 
 ########################################
@@ -1725,6 +1813,36 @@ class HttpProtocolVersions:
     HTTP_2_0 = HttpProtocolVersion(2, 0)
 
 
+########################################
+# ../../../omlish/io/readers.py
+
+
+##
+
+
+class RawBytesReader(ta.Protocol):
+    def read1(self, n: int = -1, /) -> bytes: ...
+
+
+class BufferedBytesReader(RawBytesReader, ta.Protocol):
+    def read(self, n: int = -1, /) -> bytes: ...
+
+    def readall(self) -> bytes: ...
+
+
+#
+
+
+class AsyncRawBytesReader(ta.Protocol):
+    def read1(self, n: int = -1, /) -> ta.Awaitable[bytes]: ...
+
+
+class AsyncBufferedBytesReader(AsyncRawBytesReader, ta.Protocol):
+    def read(self, n: int = -1, /) -> ta.Awaitable[bytes]: ...
+
+    def readall(self) -> ta.Awaitable[bytes]: ...
+
+
 ########################################
 # ../../../omlish/lite/abstract.py
 
@@ -1740,25 +1858,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
 
 
@@ -1812,23 +1954,26 @@ class Abstract:
         super().__init_subclass__(**kwargs)
 
         if not (Abstract in cls.__bases__ or abc.ABC in cls.__bases__):
-            ams = {a: cls for a, o in cls.__dict__.items() if is_abstract_method(o)}
-
-            seen = set(cls.__dict__)
-            for b in cls.__bases__:
-                ams.update({a: b for a in set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen})  # noqa
-                seen.update(dir(b))
+            if ams := compute_abstract_methods(cls):
+                amd = {
+                    a: mcls
+                    for mcls in cls.__mro__[::-1]
+                    for a in ams
+                    if a in mcls.__dict__
+                }
 
-            if ams:
                 raise AbstractTypeError(
                     f'Cannot subclass abstract class {cls.__name__} with abstract methods: ' +
                     ', '.join(sorted([
                         '.'.join([
-                            *([m] if (m := getattr(c, '__module__')) else []),
-                            getattr(c, '__qualname__', getattr(c, '__name__')),
+                            *([
+                                *([m] if (m := getattr(c, '__module__')) else []),
+                                getattr(c, '__qualname__', getattr(c, '__name__')),
+                            ] if c is not None else '?'),
                             a,
                         ])
-                        for a, c in ams.items()
+                        for a in ams
+                        for c in [amd.get(a)]
                     ])),
                 )
 
@@ -1845,6 +1990,150 @@ class Abstract:
             update_abstracts(cls, force=True)
 
 
+########################################
+# ../../../omlish/lite/asyncs.py
+
+
+##
+
+
+async def opt_await(aw: ta.Optional[ta.Awaitable[T]]) -> ta.Optional[T]:
+    return (await aw if aw is not None else None)
+
+
+async def async_list(ai: ta.AsyncIterable[T]) -> ta.List[T]:
+    return [v async for v in ai]
+
+
+async def async_enumerate(ai: ta.AsyncIterable[T]) -> ta.AsyncIterable[ta.Tuple[int, T]]:
+    i = 0
+    async for e in ai:
+        yield (i, e)
+        i += 1
+
+
+##
+
+
+def as_async(fn: ta.Callable[..., T], *, wrap: bool = False) -> ta.Callable[..., ta.Awaitable[T]]:
+    async def inner(*args, **kwargs):
+        return fn(*args, **kwargs)
+
+    return functools.wraps(fn)(inner) if wrap else inner
+
+
+##
+
+
+class SyncAwaitCoroutineNotTerminatedError(Exception):
+    pass
+
+
+def sync_await(aw: ta.Awaitable[T]) -> T:
+    """
+    Allows for the synchronous execution of async functions which will never actually *externally* await anything. These
+    functions are allowed to await any number of other functions - including contextmanagers and generators - so long as
+    nothing ever actually 'leaks' out of the function, presumably to an event loop.
+    """
+
+    ret = missing = object()
+
+    async def thunk():
+        nonlocal ret
+
+        ret = await aw
+
+    cr = thunk()
+    try:
+        try:
+            cr.send(None)
+        except StopIteration:
+            pass
+
+        if ret is missing or cr.cr_await is not None or cr.cr_running:
+            raise SyncAwaitCoroutineNotTerminatedError('Not terminated')
+
+    finally:
+        cr.close()
+
+    return ta.cast(T, ret)
+
+
+#
+
+
+def sync_aiter(ai: ta.AsyncIterator[T]) -> ta.Iterator[T]:
+    while True:
+        try:
+            o = sync_await(ai.__anext__())
+        except StopAsyncIteration:
+            break
+        yield o
+
+
+def sync_async_list(ai: ta.AsyncIterable[T]) -> ta.List[T]:
+    """
+    Uses `sync_await` to synchronously read the full contents of a function call returning an async iterator, given that
+    the function never externally awaits anything.
+    """
+
+    lst: ta.Optional[ta.List[T]] = None
+
+    async def inner():
+        nonlocal lst
+
+        lst = [v async for v in ai]
+
+    sync_await(inner())
+
+    if not isinstance(lst, list):
+        raise TypeError(lst)
+
+    return lst
+
+
+#
+
+
+@ta.final
+class SyncAwaitContextManager(ta.Generic[T]):
+    def __init__(self, acm: ta.AsyncContextManager[T]) -> None:
+        self._acm = acm
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._acm!r})'
+
+    def __enter__(self) -> T:
+        return sync_await(self._acm.__aenter__())
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return sync_await(self._acm.__aexit__(exc_type, exc_val, exc_tb))
+
+
+sync_async_with = SyncAwaitContextManager
+
+
+##
+
+
+@ta.final
+class SyncToAsyncContextManager(ta.Generic[T]):
+    def __init__(self, cm: ta.ContextManager[T]) -> None:
+        self._cm = cm
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._cm!r})'
+
+    async def __aenter__(self) -> T:
+        return self._cm.__enter__()
+
+    async def __aexit__(self, exc_type, exc_value, traceback, /):
+        return self._cm.__exit__(exc_type, exc_value, traceback)
+
+
+as_async_context_manager = SyncToAsyncContextManager
+
+
 ########################################
 # ../../../omlish/lite/attrops.py
 """
@@ -1853,6 +2142,8 @@ TODO:
  - per-attr repr transform / filter
  - __ne__ ? cases where it still matters
  - ordering ?
+ - repr_filter: ta.Union[ta.Callable[[ta.Any], ta.Optional[str]], ta.Literal['not_none', 'truthy']]] ?
+  - unify repr/repr_fn/repr_filter
 """
 
 
@@ -1870,6 +2161,8 @@ class AttrOps(ta.Generic[T]):
                 display: ta.Optional[str] = None,
 
                 repr: bool = True,  # noqa
+                repr_fn: ta.Optional[ta.Callable[[ta.Any], ta.Optional[str]]] = None,
+
                 hash: bool = True,  # noqa
                 eq: bool = True,
         ) -> None:
@@ -1884,6 +2177,8 @@ class AttrOps(ta.Generic[T]):
             self._display = display
 
             self._repr = repr
+            self._repr_fn = repr_fn
+
             self._hash = hash
             self._eq = eq
 
@@ -1891,21 +2186,30 @@ class AttrOps(ta.Generic[T]):
         def of(
                 cls,
                 o: ta.Union[
-                    str,
-                    ta.Tuple[str, str],
                     'AttrOps.Attr',
+                    str,
+                    ta.Tuple[str, ta.Union[str, ta.Mapping[str, ta.Any]]],
+                    ta.Mapping[str, ta.Any],
                 ],
         ) -> 'AttrOps.Attr':
             if isinstance(o, AttrOps.Attr):
                 return o
             elif isinstance(o, str):
                 return cls(o)
+            elif isinstance(o, tuple):
+                name, x = o
+                kw: ta.Mapping[str, ta.Any]
+                if isinstance(x, str):
+                    kw = dict(display=x)
+                elif isinstance(x, ta.Mapping):
+                    kw = x
+                else:
+                    raise TypeError(x)
+                return cls(name, **kw)
+            elif isinstance(o, ta.Mapping):
+                return cls(**o)
             else:
-                name, disp = o
-                return cls(
-                    name,
-                    display=disp,
-                )
+                raise TypeError(o)
 
         @property
         def name(self) -> str:
@@ -1923,19 +2227,34 @@ class AttrOps(ta.Generic[T]):
         def eq(self) -> bool:
             return self._eq
 
+    @staticmethod
+    def opt_repr(o: ta.Any) -> ta.Optional[str]:
+        return repr(o) if o is not None else None
+
+    @staticmethod
+    def truthy_repr(o: ta.Any) -> ta.Optional[str]:
+        return repr(o) if o else None
+
+    #
+
     @ta.overload
     def __init__(
             self,
             *attrs: ta.Sequence[ta.Union[
                 str,
-                ta.Tuple[str, str],
+                ta.Tuple[str, ta.Union[str, ta.Mapping[str, ta.Any]]],
+                ta.Mapping[str, ta.Any],
                 Attr,
             ]],
+
             with_module: bool = False,
             use_qualname: bool = False,
             with_id: bool = False,
+            terse: bool = False,
             repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = None,
             recursive: bool = False,
+
+            cache_hash: ta.Union[bool, str] = False,
             subtypes_eq: bool = False,
     ) -> None:
         ...
@@ -1945,16 +2264,20 @@ class AttrOps(ta.Generic[T]):
             self,
             attrs_fn: ta.Callable[[T], ta.Tuple[ta.Union[
                 ta.Any,
-                ta.Tuple[str, ta.Any],
+                ta.Tuple[ta.Any, ta.Union[str, ta.Mapping[str, ta.Any]]],
                 Attr,
             ], ...]],
             /,
             *,
+
             with_module: bool = False,
             use_qualname: bool = False,
             with_id: bool = False,
+            terse: bool = False,
             repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = None,
             recursive: bool = False,
+
+            cache_hash: ta.Union[bool, str] = False,
             subtypes_eq: bool = False,
     ) -> None:
         ...
@@ -1962,11 +2285,15 @@ class AttrOps(ta.Generic[T]):
     def __init__(
             self,
             *args,
+
             with_module=False,
             use_qualname=False,
             with_id=False,
+            terse=False,
             repr_filter=None,
             recursive=False,
+
+            cache_hash=False,
             subtypes_eq=False,
     ) -> None:
         if args and len(args) == 1 and callable(args[0]):
@@ -1977,8 +2304,11 @@ class AttrOps(ta.Generic[T]):
         self._with_module: bool = with_module
         self._use_qualname: bool = use_qualname
         self._with_id: bool = with_id
+        self._terse: bool = terse
         self._repr_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = repr_filter
         self._recursive: bool = recursive
+
+        self._cache_hash: ta.Union[bool, str] = cache_hash
         self._subtypes_eq: bool = subtypes_eq
 
     @property
@@ -2013,20 +2343,27 @@ class AttrOps(ta.Generic[T]):
 
         attrs: ta.List[AttrOps.Attr] = []
         for o in raw:
-            if isinstance(o, AttrOps.Attr):
-                attrs.append(o)
+            if isinstance(o, (AttrOps.Attr, ta.Mapping)):
+                attrs.append(AttrOps.Attr.of(o))
                 continue
 
+            kw: ta.Mapping[str, ta.Any]
             if isinstance(o, tuple):
-                disp, cap, = o
+                cap, x = o
+                if isinstance(x, str):
+                    kw = dict(display=x)
+                elif isinstance(x, ta.Mapping):
+                    kw = x
+                else:
+                    raise TypeError(x)
             else:
-                disp, cap = None, o
+                cap, kw = o, {}
 
             path = tuple(rec(cap))
 
             attrs.append(AttrOps.Attr(
                 '.'.join(path),
-                display=disp,
+                **kw,
             ))
 
         return attrs
@@ -2043,19 +2380,27 @@ class AttrOps(ta.Generic[T]):
             pass
 
         def _repr(o: T) -> str:
-            vs = ', '.join(
-                f'{a._display}={v!r}'  # noqa
-                for a in self._attrs
-                if a._repr  # noqa
-                for v in [getattr(o, a._name)]  # noqa
-                if self._repr_filter is None or self._repr_filter(v)
-            )
+            vs: ta.List[str] = []
+            for a in self._attrs:
+                if not a._repr:  # noqa
+                    continue
+                v = getattr(o, a._name)  # noqa
+                if self._repr_filter is not None and not self._repr_filter(v):
+                    continue
+                if (rfn := a._repr_fn) is None:  # noqa
+                    rfn = repr
+                if (vr := rfn(v)) is None:
+                    continue
+                if self._terse:
+                    vs.append(vr)
+                else:
+                    vs.append(f'{a._display}={vr}')  # noqa
 
             return (
                 f'{o.__class__.__module__ + "." if self._with_module else ""}'
                 f'{o.__class__.__qualname__ if self._use_qualname else o.__class__.__name__}'
-                f'{("@" + hex(id(o))[2:]) if self._with_id else ""}'
-                f'({vs})'
+                f'{("@" + hex(id(o))[2:]) if self._with_id else ""}'  # noqa
+                f'({", ".join(vs)})'
             )
 
         if self._recursive:
@@ -2080,6 +2425,8 @@ class AttrOps(ta.Generic[T]):
 
     #
 
+    _DEFAULT_CACHED_HASH_ATTR: ta.ClassVar[str] = '__cached_hash__'
+
     _hash: ta.Callable[[T], int]
 
     @property
@@ -2089,13 +2436,33 @@ class AttrOps(ta.Generic[T]):
         except AttributeError:
             pass
 
-        def _hash(o: T) -> int:
+        def _calc_hash(o: T) -> int:
             return hash(tuple(
                 getattr(o, a._name)  # noqa
                 for a in self._attrs
                 if a._hash  # noqa
             ))
 
+        if (ch := self._cache_hash) is not False:
+            if ch is True:
+                cha = self._DEFAULT_CACHED_HASH_ATTR
+            elif isinstance(ch, str):
+                cha = ch
+            else:
+                raise TypeError(ch)
+
+            def _cached_hash(o: T) -> int:
+                try:
+                    return object.__getattribute__(o, cha)
+                except AttributeError:
+                    object.__setattr__(o, cha, h := _calc_hash(o))
+                return h
+
+            _hash = _cached_hash
+
+        else:
+            _hash = _calc_hash
+
         self._hash = _hash
         return _hash
 
@@ -2236,6 +2603,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
 """
@@ -3024,6 +3447,12 @@ def format_num_bytes(num_bytes: int) -> str:
 
 ##
 # A workaround for typing deficiencies (like `Argument 2 to NewType(...) must be subclassable`).
+#
+# Note that this problem doesn't happen at runtime - it happens in mypy:
+#
+#   mypy <(echo "import typing as ta; MyCallback = ta.NewType('MyCallback', ta.Callable[[], None])")
+#   /dev/fd/11:1:22: error: Argument 2 to NewType(...) must be subclassable (got "Callable[[], None]")  [valid-newtype]
+#
 
 
 @dc.dataclass(frozen=True)
@@ -3069,6 +3498,39 @@ class Func3(ta.Generic[A0, A1, A2, T]):
 ##
 
 
+@dc.dataclass(frozen=True)
+class CachedFunc0(ta.Generic[T]):
+    fn: ta.Callable[[], T]
+
+    def __call__(self) -> T:
+        try:
+            return object.__getattribute__(self, '_value')
+        except AttributeError:
+            pass
+
+        value = self.fn()
+        object.__setattr__(self, '_value', value)
+        return value
+
+
+@dc.dataclass(frozen=True)
+class AsyncCachedFunc0(ta.Generic[T]):
+    fn: ta.Callable[[], ta.Awaitable[T]]
+
+    async def __call__(self) -> T:
+        try:
+            return object.__getattribute__(self, '_value')
+        except AttributeError:
+            pass
+
+        value = await self.fn()
+        object.__setattr__(self, '_value', value)
+        return value
+
+
+##
+
+
 _TYPING_ANNOTATIONS_ATTR = '__annotate__' if sys.version_info >= (3, 14) else '__annotations__'
 
 
@@ -4114,6 +4576,72 @@ def build_config_named_children(
     return lst
 
 
+########################################
+# ../../../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
@@ -4529,6 +5057,10 @@ class HttpRequestParser:
 
 ########################################
 # ../../../omlish/io/buffers.py
+"""
+TODO:
+ - overhaul and just coro-ify pyio?
+"""
 
 
 ##
@@ -4707,6 +5239,9 @@ class ReadableListBuffer:
 
         self._lst: list[bytes] = []
 
+    def __bool__(self) -> ta.NoReturn:
+        raise TypeError("Use 'buf is not None' or 'len(buf)'.")
+
     def __len__(self) -> int:
         return sum(map(len, self._lst))
 
@@ -4732,6 +5267,9 @@ class ReadableListBuffer:
 
     def read(self, n: ta.Optional[int] = None) -> ta.Optional[bytes]:
         if n is None:
+            if not self._lst:
+                return b''
+
             o = b''.join(self._lst)
             self._lst = []
             return o
@@ -4770,6 +5308,110 @@ class ReadableListBuffer:
         r = self.read_until_(delim)
         return r if isinstance(r, bytes) else None
 
+    #
+
+    DEFAULT_BUFFERED_READER_CHUNK_SIZE: ta.ClassVar[int] = -1
+
+    @ta.final
+    class _BufferedBytesReader(BufferedBytesReader):
+        def __init__(
+                self,
+                raw: RawBytesReader,
+                buf: 'ReadableListBuffer',
+                *,
+                chunk_size: ta.Optional[int] = None,
+        ) -> None:
+            self._raw = raw
+            self._buf = buf
+            self._chunk_size = chunk_size or ReadableListBuffer.DEFAULT_BUFFERED_READER_CHUNK_SIZE
+
+        def read1(self, n: int = -1, /) -> bytes:
+            if n < 0:
+                n = self._chunk_size
+            if not n:
+                return b''
+            if 0 < n <= len(self._buf):
+                return self._buf.read(n) or b''
+            return self._raw.read1(n)
+
+        def read(self, /, n: int = -1) -> bytes:
+            if n < 0:
+                return self.readall()
+            while len(self._buf) < n:
+                if not (b := self._raw.read1(n)):
+                    break
+                self._buf.feed(b)
+            return self._buf.read(n) or b''
+
+        def readall(self) -> bytes:
+            buf = io.BytesIO()
+            buf.write(self._buf.read() or b'')
+            while (b := self._raw.read1(self._chunk_size)):
+                buf.write(b)
+            return buf.getvalue()
+
+    def new_buffered_reader(
+            self,
+            raw: RawBytesReader,
+            *,
+            chunk_size: ta.Optional[int] = None,
+    ) -> BufferedBytesReader:
+        return self._BufferedBytesReader(
+            raw,
+            self,
+            chunk_size=chunk_size,
+        )
+
+    @ta.final
+    class _AsyncBufferedBytesReader(AsyncBufferedBytesReader):
+        def __init__(
+                self,
+                raw: AsyncRawBytesReader,
+                buf: 'ReadableListBuffer',
+                *,
+                chunk_size: ta.Optional[int] = None,
+        ) -> None:
+            self._raw = raw
+            self._buf = buf
+            self._chunk_size = chunk_size or ReadableListBuffer.DEFAULT_BUFFERED_READER_CHUNK_SIZE
+
+        async def read1(self, n: int = -1, /) -> bytes:
+            if n < 0:
+                n = self._chunk_size
+            if not n:
+                return b''
+            if 0 < n <= len(self._buf):
+                return self._buf.read(n) or b''
+            return await self._raw.read1(n)
+
+        async def read(self, /, n: int = -1) -> bytes:
+            if n < 0:
+                return await self.readall()
+            while len(self._buf) < n:
+                if not (b := await self._raw.read1(n)):
+                    break
+                self._buf.feed(b)
+            return self._buf.read(n) or b''
+
+        async def readall(self) -> bytes:
+            buf = io.BytesIO()
+            buf.write(self._buf.read() or b'')
+            while b := await self._raw.read1(self._chunk_size):
+                buf.write(b)
+            return buf.getvalue()
+
+    def new_async_buffered_reader(
+            self,
+            raw: AsyncRawBytesReader,
+            *,
+            chunk_size: ta.Optional[int] = None,
+    ) -> AsyncBufferedBytesReader:
+        return self._AsyncBufferedBytesReader(
+            raw,
+            self,
+            chunk_size=chunk_size,
+        )
+
 
 ##
 
@@ -5960,6 +6602,13 @@ class Maybe(ta.Generic[T]):
         else:
             return other
 
+    @ta.final
+    def or_none(self) -> ta.Optional[T]:
+        if self.present:
+            return self.must()
+        else:
+            return None
+
     @ta.final
     def or_else_get(self, supplier: ta.Callable[[], ta.Union[T, U]]) -> ta.Union[T, U]:
         if self.present:
@@ -6014,8 +6663,6 @@ class _JustMaybe(_Maybe[T]):
     __slots__ = ('_v', '_hash')
 
     def __init__(self, v: T) -> None:
-        super().__init__()
-
         self._v = v
 
     @property
@@ -6073,6 +6720,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
 
@@ -8676,6 +9330,9 @@ class CaptureLoggingContextImpl(CaptureLoggingContext):
                 self._infos[type(info)] = info
         return self
 
+    def get_infos(self) -> ta.Mapping[ta.Type[LoggingContextInfo], LoggingContextInfo]:
+        return self._infos
+
     def get_info(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
         return self._infos.get(ty)
 
@@ -8698,7 +9355,7 @@ class CaptureLoggingContextImpl(CaptureLoggingContext):
     _stack_offset: int
     _stack_info: bool
 
-    def inc_stack_offset(self, ofs: int = 1) -> 'CaptureLoggingContext':
+    def inc_stack_offset(self, ofs: int = 1) -> 'CaptureLoggingContextImpl':
         if hasattr(self, '_stack_offset'):
             self._stack_offset += ofs
         return self
@@ -8730,10 +9387,9 @@ class CaptureLoggingContextImpl(CaptureLoggingContext):
 
 
 ########################################
-# ../../../omlish/logs/standard.py
+# ../../../omlish/logs/std/standard.py
 """
 TODO:
- - !! move to std !!
  - structured
  - prefixed
  - debug
@@ -9392,48 +10048,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
@@ -9442,20 +10071,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):
@@ -9463,10 +10092,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:
@@ -9494,7 +10123,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,
     ]:
@@ -9504,7 +10133,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
@@ -9543,7 +10172,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
 
@@ -9630,6 +10259,11 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     ##
 
+    # This will be 1 for [Sync]Logger and 0 for AsyncLogger - in sync loggers these methods remain present on the stack,
+    # in async loggers they return a coroutine to be awaited and thus aren't actually present when said coroutine is
+    # awaited.
+    _level_proxy_method_stack_offset: int
+
     @ta.overload
     def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
         ...
@@ -9644,7 +10278,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def log(self, level: LogLevel, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(level, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                level,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -9662,7 +10303,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def debug(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.DEBUG, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.DEBUG,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -9680,7 +10328,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def info(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.INFO, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.INFO,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -9698,7 +10353,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def warning(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.WARNING, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.WARNING,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -9716,7 +10378,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def error(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.ERROR, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.ERROR,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -9734,7 +10403,15 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def exception(self, *args, exc_info: LoggingExcInfoArg = True, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.ERROR, exc_info=exc_info, stack_offset=1), *args, **kwargs)  # noqa
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.ERROR,
+                exc_info=exc_info,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -9752,24 +10429,53 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def critical(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.CRITICAL, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.CRITICAL,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     ##
 
     @abc.abstractmethod
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> T:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> T:
         raise NotImplementedError
 
 
 class Logger(AnyLogger[None], Abstract):
+    _level_proxy_method_stack_offset: int = 1
+
     @abc.abstractmethod
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
         raise NotImplementedError
 
 
 class AsyncLogger(AnyLogger[ta.Awaitable[None]], Abstract):
+    _level_proxy_method_stack_offset: int = 0
+
     @abc.abstractmethod
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> ta.Awaitable[None]:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> ta.Awaitable[None]:
         raise NotImplementedError
 
 
@@ -9784,13 +10490,25 @@ class AnyNopLogger(AnyLogger[T], Abstract):
 
 @ta.final
 class NopLogger(AnyNopLogger[None], Logger):
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
         pass
 
 
 @ta.final
 class AsyncNopLogger(AnyNopLogger[ta.Awaitable[None]], AsyncLogger):
-    async def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+    async def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
         pass
 
 
@@ -10603,7 +11321,7 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
             *,
             read_size: int = 0x10000,
             write_size: int = 0x10000,
-            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpServer.AnyLogIo], None]] = None,
+            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpIo.AnyLogIo], None]] = None,
     ) -> None:
         check.state(not sock.getblocking())
 
@@ -10623,13 +11341,13 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
         )
         self._srv_coro: ta.Optional[
             ta.Generator[
-                CoroHttpServer.Io,
+                CoroHttpIo.Io,
                 ta.Optional[bytes],
                 CoroHttpServer.CoroHandleResult,
             ],
         ] = self._coro_srv.coro_handle()
 
-        self._cur_io: ta.Optional[CoroHttpServer.Io] = None
+        self._cur_io: ta.Optional[CoroHttpIo.Io] = None
         self._next_io()
 
     #
@@ -10652,22 +11370,22 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
                     o = None
                     break
 
-            if isinstance(o, CoroHttpServer.AnyLogIo):
+            if isinstance(o, CoroHttpIo.AnyLogIo):
                 if self._log_handler is not None:
                     self._log_handler(self._coro_srv, o)
                 o = None
 
-            elif isinstance(o, CoroHttpServer.ReadIo):
+            elif isinstance(o, CoroHttpIo.ReadIo):
                 if (d := self._read_buf.read(o.sz)) is None:
                     break
                 o = None
 
-            elif isinstance(o, CoroHttpServer.ReadLineIo):
+            elif isinstance(o, CoroHttpIo.ReadLineIo):
                 if (d := self._read_buf.read_until(b'\n')) is None:
                     break
                 o = None
 
-            elif isinstance(o, CoroHttpServer.WriteIo):
+            elif isinstance(o, CoroHttpIo.WriteIo):
                 check.none(self._write_buf)
                 self._write_buf = IncrementalWriteBuffer(o.data, write_size=self._write_size)
                 break
@@ -10701,11 +11419,11 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
 
         self._read_buf.feed(buf)
 
-        if isinstance(self._cur_io, CoroHttpServer.AnyReadIo):
+        if isinstance(self._cur_io, CoroHttpIo.AnyReadIo):
             self._next_io()
 
     def on_writable(self) -> None:
-        check.isinstance(self._cur_io, CoroHttpServer.WriteIo)
+        check.isinstance(self._cur_io, CoroHttpIo.WriteIo)
         wb = check.not_none(self._write_buf)
         while wb.rem > 0:
             def send(d: bytes) -> int:
@@ -10725,6 +11443,70 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
             self._next_io()
 
 
+########################################
+# ../../../omlish/logs/asyncs.py
+
+
+##
+
+
+class AsyncLoggerToLogger(Logger):
+    def __init__(self, u: AsyncLogger) -> None:
+        super().__init__()
+
+        self._u = u
+
+    def get_effective_level(self) -> LogLevel:
+        return self._u.get_effective_level()
+
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        # Nope out early to avoid sync_await if possible - don't bother in the LoggerToAsyncLogger.
+        if not self.is_enabled_for(ctx.must_get_info(LoggingContextInfos.Level).level):
+            return
+
+        # Note: we hardcode the stack offset of sync_await (which is 2 - sync_await + sync_await.thunk). In non-lite
+        # code, lang.sync_await uses a cext if present to avoid being on the py stack, which would obviously complicate
+        # this, but this is lite code so we will always have the non-c version.
+        sync_await(
+            self._u._log(  # noqa
+                check.isinstance(ctx, CaptureLoggingContextImpl).inc_stack_offset(3),
+                msg,
+                *args,
+                **kwargs,
+            ),
+        )
+
+
+class LoggerToAsyncLogger(AsyncLogger):
+    def __init__(self, u: Logger) -> None:
+        super().__init__()
+
+        self._u = u
+
+    def get_effective_level(self) -> LogLevel:
+        return self._u.get_effective_level()
+
+    async def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        return self._u._log(  # noqa
+            check.isinstance(ctx, CaptureLoggingContextImpl).inc_stack_offset(),
+            msg,
+            *args,
+            **kwargs,
+        )
+
+
 ########################################
 # ../../../omlish/logs/std/loggers.py
 
@@ -10748,7 +11530,12 @@ class StdLogger(Logger):
     def get_effective_level(self) -> LogLevel:
         return self._std.getEffectiveLevel()
 
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any) -> None:
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+    ) -> None:
         if not self.is_enabled_for(ctx.must_get_info(LoggingContextInfos.Level).level):
             return
 
@@ -10893,8 +11680,23 @@ class ProcessSpawning:
 ##
 
 
+def _get_module_std_logger(mod_globals: ta.Mapping[str, ta.Any]) -> logging.Logger:
+    return logging.getLogger(mod_globals.get('__name__'))
+
+
 def get_module_logger(mod_globals: ta.Mapping[str, ta.Any]) -> Logger:
-    return StdLogger(logging.getLogger(mod_globals.get('__name__')))  # noqa
+    return StdLogger(_get_module_std_logger(mod_globals))
+
+
+def get_module_async_logger(mod_globals: ta.Mapping[str, ta.Any]) -> AsyncLogger:
+    return LoggerToAsyncLogger(get_module_logger(mod_globals))
+
+
+def get_module_loggers(mod_globals: ta.Mapping[str, ta.Any]) -> ta.Tuple[Logger, AsyncLogger]:
+    return (
+        log := get_module_logger(mod_globals),
+        LoggerToAsyncLogger(log),
+    )
 
 
 ########################################