ominfra 0.0.0.dev148__py3-none-any.whl → 0.0.0.dev150__py3-none-any.whl

ominfra/scripts/supervisor.py

@@ -34,6 +34,7 @@
 #   EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 import abc
 import base64
+import collections
 import collections.abc
 import contextlib
 import ctypes as ct
@@ -105,6 +106,11 @@ CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
 # ../../omlish/lite/check.py
 SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
+CheckMessage = ta.Union[str, ta.Callable[..., ta.Optional[str]], None]  # ta.TypeAlias
+CheckLateConfigureFn = ta.Callable[['Checks'], None]
+CheckOnRaiseFn = ta.Callable[[Exception], None]  # ta.TypeAlias
+CheckExceptionFactory = ta.Callable[..., Exception]  # ta.TypeAlias
+CheckArgsRenderer = ta.Callable[..., ta.Optional[str]]  # ta.TypeAlias
 
 # ../../omlish/lite/socket.py
 SocketAddress = ta.Any
@@ -119,12 +125,12 @@ A2 = ta.TypeVar('A2')
 EventCallback = ta.Callable[['Event'], None]
 ProcessOutputChannel = ta.Literal['stdout', 'stderr']  # ta.TypeAlias
 
+# ../../omlish/http/parsing.py
+HttpHeaders = http.client.HTTPMessage  # ta.TypeAlias
+
 # ../../omlish/lite/contextmanagers.py
 ExitStackedT = ta.TypeVar('ExitStackedT', bound='ExitStacked')
 
-# ../../omlish/lite/http/parsing.py
-HttpHeaders = http.client.HTTPMessage  # ta.TypeAlias
-
 # ../../omlish/lite/inject.py
 U = ta.TypeVar('U')
 InjectorKeyCls = ta.Union[type, ta.NewType]
@@ -135,10 +141,10 @@ InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
 # ../configs.py
 ConfigMapping = ta.Mapping[str, ta.Any]
 
-# ../../omlish/lite/http/handlers.py
+# ../../omlish/http/handlers.py
 HttpHandler = ta.Callable[['HttpHandlerRequest'], 'HttpHandlerResponse']
 
-# ../../omlish/lite/http/coroserver.py
+# ../../omlish/http/coroserver.py
 CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']
 
 
@@ -1431,160 +1437,26 @@ def parse_octal(arg: ta.Union[str, int]) -> int:
 
 
 ########################################
-# ../../../omlish/lite/cached.py
-
-
-##
-
-
-class _AbstractCachedNullary:
-    def __init__(self, fn):
-        super().__init__()
-        self._fn = fn
-        self._value = self._missing = object()
-        functools.update_wrapper(self, fn)
-
-    def __call__(self, *args, **kwargs):  # noqa
-        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 _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/check.py
-
-
-def check_isinstance(v: ta.Any, spec: ta.Union[ta.Type[T], tuple]) -> T:
-    if not isinstance(v, spec):
-        raise TypeError(v)
-    return v
-
+# ../../../omlish/http/versions.py
 
-def check_not_isinstance(v: T, spec: ta.Union[type, tuple]) -> T:
-    if isinstance(v, spec):
-        raise TypeError(v)
-    return v
-
-
-def check_none(v: T) -> None:
-    if v is not None:
-        raise ValueError(v)
-
-
-def check_not_none(v: ta.Optional[T]) -> T:
-    if v is None:
-        raise ValueError
-    return v
-
-
-def check_not(v: ta.Any) -> None:
-    if v:
-        raise ValueError(v)
-    return v
-
-
-def check_non_empty_str(v: ta.Optional[str]) -> str:
-    if not v:
-        raise ValueError
-    return v
-
-
-def check_state(v: bool, msg: str = 'Illegal state') -> None:
-    if not v:
-        raise ValueError(msg)
-
-
-def check_equal(l: T, r: T) -> T:
-    if l != r:
-        raise ValueError(l, r)
-    return l
-
-
-def check_not_equal(l: T, r: T) -> T:
-    if l == r:
-        raise ValueError(l, r)
-    return l
-
-
-def check_is(l: T, r: T) -> T:
-    if l is not r:
-        raise ValueError(l, r)
-    return l
-
-
-def check_is_not(l: T, r: ta.Any) -> T:
-    if l is r:
-        raise ValueError(l, r)
-    return l
-
-
-def check_in(v: T, c: ta.Container[T]) -> T:
-    if v not in c:
-        raise ValueError(v, c)
-    return v
-
-
-def check_not_in(v: T, c: ta.Container[T]) -> T:
-    if v in c:
-        raise ValueError(v, c)
-    return v
-
-
-def check_single(vs: ta.Iterable[T]) -> T:
-    [v] = vs
-    return v
 
+class HttpProtocolVersion(ta.NamedTuple):
+    major: int
+    minor: int
 
-def check_empty(v: SizedT) -> SizedT:
-    if len(v):
-        raise ValueError(v)
-    return v
+    def __str__(self) -> str:
+        return f'HTTP/{self.major}.{self.minor}'
 
 
-def check_non_empty(v: SizedT) -> SizedT:
-    if not len(v):
-        raise ValueError(v)
-    return v
+class HttpProtocolVersions:
+    HTTP_0_9 = HttpProtocolVersion(0, 9)
+    HTTP_1_0 = HttpProtocolVersion(1, 0)
+    HTTP_1_1 = HttpProtocolVersion(1, 1)
+    HTTP_2_0 = HttpProtocolVersion(2, 0)
 
 
 ########################################
-# ../../../omlish/lite/fdio/pollers.py
+# ../../../omlish/io/fdio/pollers.py
 
 
 ##
@@ -1794,161 +1666,650 @@ else:
 
 
 ########################################
-# ../../../omlish/lite/http/versions.py
-
+# ../../../omlish/lite/cached.py
 
-class HttpProtocolVersion(ta.NamedTuple):
-    major: int
-    minor: int
 
-    def __str__(self) -> str:
-        return f'HTTP/{self.major}.{self.minor}'
+##
 
 
-class HttpProtocolVersions:
-    HTTP_0_9 = HttpProtocolVersion(0, 9)
-    HTTP_1_0 = HttpProtocolVersion(1, 0)
-    HTTP_1_1 = HttpProtocolVersion(1, 1)
-    HTTP_2_0 = HttpProtocolVersion(2, 0)
+class _AbstractCachedNullary:
+    def __init__(self, fn):
+        super().__init__()
+        self._fn = fn
+        self._value = self._missing = object()
+        functools.update_wrapper(self, fn)
 
+    def __call__(self, *args, **kwargs):  # noqa
+        raise TypeError
 
-########################################
-# ../../../omlish/lite/json.py
+    def __get__(self, instance, owner):  # noqa
+        bound = instance.__dict__[self._fn.__name__] = self.__class__(self._fn.__get__(instance, owner))
+        return bound
 
 
 ##
 
 
-JSON_PRETTY_INDENT = 2
+class _CachedNullary(_AbstractCachedNullary):
+    def __call__(self, *args, **kwargs):  # noqa
+        if self._value is self._missing:
+            self._value = self._fn()
+        return self._value
 
-JSON_PRETTY_KWARGS: ta.Mapping[str, ta.Any] = dict(
-    indent=JSON_PRETTY_INDENT,
-)
 
-json_dump_pretty: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON_PRETTY_KWARGS)  # type: ignore
-json_dumps_pretty: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_PRETTY_KWARGS)
+def cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
+    return _CachedNullary(fn)
+
+
+def static_init(fn: CallableT) -> CallableT:
+    fn = cached_nullary(fn)
+    fn()
+    return fn
 
 
 ##
 
 
-JSON_COMPACT_SEPARATORS = (',', ':')
+class _AsyncCachedNullary(_AbstractCachedNullary):
+    async def __call__(self, *args, **kwargs):
+        if self._value is self._missing:
+            self._value = await self._fn()
+        return self._value
 
-JSON_COMPACT_KWARGS: ta.Mapping[str, ta.Any] = dict(
-    indent=None,
-    separators=JSON_COMPACT_SEPARATORS,
-)
 
-json_dump_compact: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON_COMPACT_KWARGS)  # type: ignore
-json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_COMPACT_KWARGS)
+def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
+    return _AsyncCachedNullary(fn)
 
 
 ########################################
-# ../../../omlish/lite/maybes.py
+# ../../../omlish/lite/check.py
+"""
+TODO:
+ - def maybe(v: lang.Maybe[T])
+ - patch / override lite.check ?
+  - checker interface?
+"""
 
 
-class Maybe(ta.Generic[T]):
-    @property
-    @abc.abstractmethod
-    def present(self) -> bool:
-        raise NotImplementedError
+##
 
-    @abc.abstractmethod
-    def must(self) -> T:
-        raise NotImplementedError
 
-    @classmethod
-    def just(cls, v: T) -> 'Maybe[T]':
-        return tuple.__new__(_Maybe, (v,))  # noqa
+class Checks:
+    def __init__(self) -> None:
+        super().__init__()
 
-    _empty: ta.ClassVar['Maybe']
+        self._config_lock = threading.RLock()
+        self._on_raise_fns: ta.Sequence[CheckOnRaiseFn] = []
+        self._exception_factory: CheckExceptionFactory = Checks.default_exception_factory
+        self._args_renderer: ta.Optional[CheckArgsRenderer] = None
+        self._late_configure_fns: ta.Sequence[CheckLateConfigureFn] = []
 
-    @classmethod
-    def empty(cls) -> 'Maybe[T]':
-        return Maybe._empty
+    @staticmethod
+    def default_exception_factory(exc_cls: ta.Type[Exception], *args, **kwargs) -> Exception:
+        return exc_cls(*args, **kwargs)  # noqa
 
+    #
 
-class _Maybe(Maybe[T], tuple):
-    __slots__ = ()
+    def register_on_raise(self, fn: CheckOnRaiseFn) -> None:
+        with self._config_lock:
+            self._on_raise_fns = [*self._on_raise_fns, fn]
 
-    def __init_subclass__(cls, **kwargs):
-        raise TypeError
+    def unregister_on_raise(self, fn: CheckOnRaiseFn) -> None:
+        with self._config_lock:
+            self._on_raise_fns = [e for e in self._on_raise_fns if e != fn]
 
-    @property
-    def present(self) -> bool:
-        return bool(self)
+    #
 
-    def must(self) -> T:
-        if not self:
-            raise ValueError
-        return self[0]
+    def set_exception_factory(self, factory: CheckExceptionFactory) -> None:
+        self._exception_factory = factory
 
+    def set_args_renderer(self, renderer: ta.Optional[CheckArgsRenderer]) -> None:
+        self._args_renderer = renderer
 
-Maybe._empty = tuple.__new__(_Maybe, ())  # noqa
+    #
 
+    def register_late_configure(self, fn: CheckLateConfigureFn) -> None:
+        with self._config_lock:
+            self._late_configure_fns = [*self._late_configure_fns, fn]
 
-########################################
-# ../../../omlish/lite/reflect.py
+    def _late_configure(self) -> None:
+        if not self._late_configure_fns:
+            return
 
+        with self._config_lock:
+            if not (lc := self._late_configure_fns):
+                return
 
-_GENERIC_ALIAS_TYPES = (
-    ta._GenericAlias,  # type: ignore  # noqa
-    *([ta._SpecialGenericAlias] if hasattr(ta, '_SpecialGenericAlias') else []),  # noqa
-)
+            for fn in lc:
+                fn(self)
 
+            self._late_configure_fns = []
 
-def is_generic_alias(obj, *, origin: ta.Any = None) -> bool:
-    return (
-        isinstance(obj, _GENERIC_ALIAS_TYPES) and
-        (origin is None or ta.get_origin(obj) is origin)
-    )
+    #
 
+    class _ArgsKwargs:
+        def __init__(self, *args, **kwargs):
+            self.args = args
+            self.kwargs = kwargs
 
-is_union_alias = functools.partial(is_generic_alias, origin=ta.Union)
-is_callable_alias = functools.partial(is_generic_alias, origin=ta.Callable)
+    def _raise(
+            self,
+            exception_type: ta.Type[Exception],
+            default_message: str,
+            message: CheckMessage,
+            ak: _ArgsKwargs = _ArgsKwargs(),
+            *,
+            render_fmt: ta.Optional[str] = None,
+    ) -> ta.NoReturn:
+        exc_args = ()
+        if callable(message):
+            message = ta.cast(ta.Callable, message)(*ak.args, **ak.kwargs)
+            if isinstance(message, tuple):
+                message, *exc_args = message  # type: ignore
 
+        if message is None:
+            message = default_message
 
-def is_optional_alias(spec: ta.Any) -> bool:
-    return (
-        isinstance(spec, _GENERIC_ALIAS_TYPES) and  # noqa
-        ta.get_origin(spec) is ta.Union and
-        len(ta.get_args(spec)) == 2 and
-        any(a in (None, type(None)) for a in ta.get_args(spec))
-    )
+        self._late_configure()
 
+        if render_fmt is not None and (af := self._args_renderer) is not None:
+            rendered_args = af(render_fmt, *ak.args)
+            if rendered_args is not None:
+                message = f'{message} : {rendered_args}'
 
-def get_optional_alias_arg(spec: ta.Any) -> ta.Any:
-    [it] = [it for it in ta.get_args(spec) if it not in (None, type(None))]
-    return it
+        exc = self._exception_factory(
+            exception_type,
+            message,
+            *exc_args,
+            *ak.args,
+            **ak.kwargs,
+        )
 
+        for fn in self._on_raise_fns:
+            fn(exc)
 
-def is_new_type(spec: ta.Any) -> bool:
-    if isinstance(ta.NewType, type):
-        return isinstance(spec, ta.NewType)
-    else:
-        # Before https://github.com/python/cpython/commit/c2f33dfc83ab270412bf243fb21f724037effa1a
-        return isinstance(spec, types.FunctionType) and spec.__code__ is ta.NewType.__code__.co_consts[1]  # type: ignore  # noqa
+        raise exc
 
+    #
 
-def deep_subclasses(cls: ta.Type[T]) -> ta.Iterator[ta.Type[T]]:
-    seen = set()
-    todo = list(reversed(cls.__subclasses__()))
-    while todo:
-        cur = todo.pop()
-        if cur in seen:
-            continue
-        seen.add(cur)
-        yield cur
-        todo.extend(reversed(cur.__subclasses__()))
+    def _unpack_isinstance_spec(self, spec: ta.Any) -> tuple:
+        if isinstance(spec, type):
+            return (spec,)
+        if not isinstance(spec, tuple):
+            spec = (spec,)
+        if None in spec:
+            spec = tuple(filter(None, spec)) + (None.__class__,)  # noqa
+        if ta.Any in spec:
+            spec = (object,)
+        return spec
+
+    def isinstance(self, v: ta.Any, spec: ta.Union[ta.Type[T], tuple], msg: CheckMessage = None) -> T:  # noqa
+        if not isinstance(v, self._unpack_isinstance_spec(spec)):
+            self._raise(
+                TypeError,
+                'Must be instance',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='not isinstance(%s, %s)',
+            )
 
+        return v
 
-########################################
-# ../../../omlish/lite/socket.py
-"""
-TODO:
- - SocketClientAddress family / tuple pairs
-  + codification of https://docs.python.org/3/library/socket.html#socket-families
-"""
+    def of_isinstance(self, spec: ta.Union[ta.Type[T], tuple], msg: CheckMessage = None) -> ta.Callable[[ta.Any], T]:
+        def inner(v):
+            return self.isinstance(v, self._unpack_isinstance_spec(spec), msg)
+
+        return inner
+
+    def cast(self, v: ta.Any, cls: ta.Type[T], msg: CheckMessage = None) -> T:  # noqa
+        if not isinstance(v, cls):
+            self._raise(
+                TypeError,
+                'Must be instance',
+                msg,
+                Checks._ArgsKwargs(v, cls),
+            )
+
+        return v
+
+    def of_cast(self, cls: ta.Type[T], msg: CheckMessage = None) -> ta.Callable[[T], T]:
+        def inner(v):
+            return self.cast(v, cls, msg)
+
+        return inner
+
+    def not_isinstance(self, v: T, spec: ta.Any, msg: CheckMessage = None) -> T:  # noqa
+        if isinstance(v, self._unpack_isinstance_spec(spec)):
+            self._raise(
+                TypeError,
+                'Must not be instance',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='isinstance(%s, %s)',
+            )
+
+        return v
+
+    def of_not_isinstance(self, spec: ta.Any, msg: CheckMessage = None) -> ta.Callable[[T], T]:
+        def inner(v):
+            return self.not_isinstance(v, self._unpack_isinstance_spec(spec), msg)
+
+        return inner
+
+    ##
+
+    def issubclass(self, v: ta.Type[T], spec: ta.Any, msg: CheckMessage = None) -> ta.Type[T]:  # noqa
+        if not issubclass(v, spec):
+            self._raise(
+                TypeError,
+                'Must be subclass',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='not issubclass(%s, %s)',
+            )
+
+        return v
+
+    def not_issubclass(self, v: ta.Type[T], spec: ta.Any, msg: CheckMessage = None) -> ta.Type[T]:  # noqa
+        if issubclass(v, spec):
+            self._raise(
+                TypeError,
+                'Must not be subclass',
+                msg,
+                Checks._ArgsKwargs(v, spec),
+                render_fmt='issubclass(%s, %s)',
+            )
+
+        return v
+
+    #
+
+    def in_(self, v: T, c: ta.Container[T], msg: CheckMessage = None) -> T:
+        if v not in c:
+            self._raise(
+                ValueError,
+                'Must be in',
+                msg,
+                Checks._ArgsKwargs(v, c),
+                render_fmt='%s not in %s',
+            )
+
+        return v
+
+    def not_in(self, v: T, c: ta.Container[T], msg: CheckMessage = None) -> T:
+        if v in c:
+            self._raise(
+                ValueError,
+                'Must not be in',
+                msg,
+                Checks._ArgsKwargs(v, c),
+                render_fmt='%s in %s',
+            )
+
+        return v
+
+    def empty(self, v: SizedT, msg: CheckMessage = None) -> SizedT:
+        if len(v) != 0:
+            self._raise(
+                ValueError,
+                'Must be empty',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    def iterempty(self, v: ta.Iterable[T], msg: CheckMessage = None) -> ta.Iterable[T]:
+        it = iter(v)
+        try:
+            next(it)
+        except StopIteration:
+            pass
+        else:
+            self._raise(
+                ValueError,
+                'Must be empty',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    def not_empty(self, v: SizedT, msg: CheckMessage = None) -> SizedT:
+        if len(v) == 0:
+            self._raise(
+                ValueError,
+                'Must not be empty',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    def unique(self, it: ta.Iterable[T], msg: CheckMessage = None) -> ta.Iterable[T]:
+        dupes = [e for e, c in collections.Counter(it).items() if c > 1]
+        if dupes:
+            self._raise(
+                ValueError,
+                'Must be unique',
+                msg,
+                Checks._ArgsKwargs(it, dupes),
+            )
+
+        return it
+
+    def single(self, obj: ta.Iterable[T], message: CheckMessage = None) -> T:
+        try:
+            [value] = obj
+        except ValueError:
+            self._raise(
+                ValueError,
+                'Must be single',
+                message,
+                Checks._ArgsKwargs(obj),
+                render_fmt='%s',
+            )
+
+        return value
+
+    def opt_single(self, obj: ta.Iterable[T], message: CheckMessage = None) -> ta.Optional[T]:
+        it = iter(obj)
+        try:
+            value = next(it)
+        except StopIteration:
+            return None
+
+        try:
+            next(it)
+        except StopIteration:
+            return value  # noqa
+
+        self._raise(
+            ValueError,
+            'Must be empty or single',
+            message,
+            Checks._ArgsKwargs(obj),
+            render_fmt='%s',
+        )
+
+        raise RuntimeError  # noqa
+
+    #
+
+    def none(self, v: ta.Any, msg: CheckMessage = None) -> None:
+        if v is not None:
+            self._raise(
+                ValueError,
+                'Must be None',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+    def not_none(self, v: ta.Optional[T], msg: CheckMessage = None) -> T:
+        if v is None:
+            self._raise(
+                ValueError,
+                'Must not be None',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    #
+
+    def equal(self, v: T, o: ta.Any, msg: CheckMessage = None) -> T:
+        if o != v:
+            self._raise(
+                ValueError,
+                'Must be equal',
+                msg,
+                Checks._ArgsKwargs(v, o),
+                render_fmt='%s != %s',
+            )
+
+        return v
+
+    def is_(self, v: T, o: ta.Any, msg: CheckMessage = None) -> T:
+        if o is not v:
+            self._raise(
+                ValueError,
+                'Must be the same',
+                msg,
+                Checks._ArgsKwargs(v, o),
+                render_fmt='%s is not %s',
+            )
+
+        return v
+
+    def is_not(self, v: T, o: ta.Any, msg: CheckMessage = None) -> T:
+        if o is v:
+            self._raise(
+                ValueError,
+                'Must not be the same',
+                msg,
+                Checks._ArgsKwargs(v, o),
+                render_fmt='%s is %s',
+            )
+
+        return v
+
+    def callable(self, v: T, msg: CheckMessage = None) -> T:  # noqa
+        if not callable(v):
+            self._raise(
+                TypeError,
+                'Must be callable',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v  # type: ignore
+
+    def non_empty_str(self, v: ta.Optional[str], msg: CheckMessage = None) -> str:
+        if not isinstance(v, str) or not v:
+            self._raise(
+                ValueError,
+                'Must be non-empty str',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+        return v
+
+    def replacing(self, expected: ta.Any, old: ta.Any, new: T, msg: CheckMessage = None) -> T:
+        if old != expected:
+            self._raise(
+                ValueError,
+                'Must be replacing',
+                msg,
+                Checks._ArgsKwargs(expected, old, new),
+                render_fmt='%s -> %s -> %s',
+            )
+
+        return new
+
+    def replacing_none(self, old: ta.Any, new: T, msg: CheckMessage = None) -> T:
+        if old is not None:
+            self._raise(
+                ValueError,
+                'Must be replacing None',
+                msg,
+                Checks._ArgsKwargs(old, new),
+                render_fmt='%s -> %s',
+            )
+
+        return new
+
+    #
+
+    def arg(self, v: bool, msg: CheckMessage = None) -> None:
+        if not v:
+            self._raise(
+                RuntimeError,
+                'Argument condition not met',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+    def state(self, v: bool, msg: CheckMessage = None) -> None:
+        if not v:
+            self._raise(
+                RuntimeError,
+                'State condition not met',
+                msg,
+                Checks._ArgsKwargs(v),
+                render_fmt='%s',
+            )
+
+
+check = Checks()
+
+
+########################################
+# ../../../omlish/lite/json.py
+
+
+##
+
+
+JSON_PRETTY_INDENT = 2
+
+JSON_PRETTY_KWARGS: ta.Mapping[str, ta.Any] = dict(
+    indent=JSON_PRETTY_INDENT,
+)
+
+json_dump_pretty: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON_PRETTY_KWARGS)  # type: ignore
+json_dumps_pretty: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_PRETTY_KWARGS)
+
+
+##
+
+
+JSON_COMPACT_SEPARATORS = (',', ':')
+
+JSON_COMPACT_KWARGS: ta.Mapping[str, ta.Any] = dict(
+    indent=None,
+    separators=JSON_COMPACT_SEPARATORS,
+)
+
+json_dump_compact: ta.Callable[..., bytes] = functools.partial(json.dump, **JSON_COMPACT_KWARGS)  # type: ignore
+json_dumps_compact: ta.Callable[..., str] = functools.partial(json.dumps, **JSON_COMPACT_KWARGS)
+
+
+########################################
+# ../../../omlish/lite/maybes.py
+
+
+class Maybe(ta.Generic[T]):
+    @property
+    @abc.abstractmethod
+    def present(self) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def must(self) -> T:
+        raise NotImplementedError
+
+    @classmethod
+    def just(cls, v: T) -> 'Maybe[T]':
+        return tuple.__new__(_Maybe, (v,))  # noqa
+
+    _empty: ta.ClassVar['Maybe']
+
+    @classmethod
+    def empty(cls) -> 'Maybe[T]':
+        return Maybe._empty
+
+
+class _Maybe(Maybe[T], tuple):
+    __slots__ = ()
+
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError
+
+    @property
+    def present(self) -> bool:
+        return bool(self)
+
+    def must(self) -> T:
+        if not self:
+            raise ValueError
+        return self[0]
+
+
+Maybe._empty = tuple.__new__(_Maybe, ())  # noqa
+
+
+########################################
+# ../../../omlish/lite/reflect.py
+
+
+_GENERIC_ALIAS_TYPES = (
+    ta._GenericAlias,  # type: ignore  # noqa
+    *([ta._SpecialGenericAlias] if hasattr(ta, '_SpecialGenericAlias') else []),  # noqa
+)
+
+
+def is_generic_alias(obj, *, origin: ta.Any = None) -> bool:
+    return (
+        isinstance(obj, _GENERIC_ALIAS_TYPES) and
+        (origin is None or ta.get_origin(obj) is origin)
+    )
+
+
+is_union_alias = functools.partial(is_generic_alias, origin=ta.Union)
+is_callable_alias = functools.partial(is_generic_alias, origin=ta.Callable)
+
+
+def is_optional_alias(spec: ta.Any) -> bool:
+    return (
+        isinstance(spec, _GENERIC_ALIAS_TYPES) and  # noqa
+        ta.get_origin(spec) is ta.Union and
+        len(ta.get_args(spec)) == 2 and
+        any(a in (None, type(None)) for a in ta.get_args(spec))
+    )
+
+
+def get_optional_alias_arg(spec: ta.Any) -> ta.Any:
+    [it] = [it for it in ta.get_args(spec) if it not in (None, type(None))]
+    return it
+
+
+def is_new_type(spec: ta.Any) -> bool:
+    if isinstance(ta.NewType, type):
+        return isinstance(spec, ta.NewType)
+    else:
+        # Before https://github.com/python/cpython/commit/c2f33dfc83ab270412bf243fb21f724037effa1a
+        return isinstance(spec, types.FunctionType) and spec.__code__ is ta.NewType.__code__.co_consts[1]  # type: ignore  # noqa
+
+
+def deep_subclasses(cls: ta.Type[T]) -> ta.Iterator[ta.Type[T]]:
+    seen = set()
+    todo = list(reversed(cls.__subclasses__()))
+    while todo:
+        cur = todo.pop()
+        if cur in seen:
+            continue
+        seen.add(cur)
+        yield cur
+        todo.extend(reversed(cur.__subclasses__()))
+
+
+########################################
+# ../../../omlish/lite/socket.py
+"""
+TODO:
+ - SocketClientAddress family / tuple pairs
+  + codification of https://docs.python.org/3/library/socket.html#socket-families
+"""
 
 
 ##
@@ -2564,250 +2925,7 @@ def get_user(name: str) -> User:
 
 
 ########################################
-# ../../../omlish/lite/contextmanagers.py
-
-
-##
-
-
-class ExitStacked:
-    _exit_stack: ta.Optional[contextlib.ExitStack] = None
-
-    def __enter__(self: ExitStackedT) -> ExitStackedT:
-        check_state(self._exit_stack is None)
-        es = self._exit_stack = contextlib.ExitStack()
-        es.__enter__()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if (es := self._exit_stack) is None:
-            return None
-        self._exit_contexts()
-        return es.__exit__(exc_type, exc_val, exc_tb)
-
-    def _exit_contexts(self) -> None:
-        pass
-
-    def _enter_context(self, cm: ta.ContextManager[T]) -> T:
-        es = check_not_none(self._exit_stack)
-        return es.enter_context(cm)
-
-
-##
-
-
-@contextlib.contextmanager
-def defer(fn: ta.Callable) -> ta.Generator[ta.Callable, None, None]:
-    try:
-        yield fn
-    finally:
-        fn()
-
-
-@contextlib.contextmanager
-def attr_setting(obj, attr, val, *, default=None):  # noqa
-    not_set = object()
-    orig = getattr(obj, attr, not_set)
-    try:
-        setattr(obj, attr, val)
-        if orig is not not_set:
-            yield orig
-        else:
-            yield default
-    finally:
-        if orig is not_set:
-            delattr(obj, attr)
-        else:
-            setattr(obj, attr, orig)
-
-
-########################################
-# ../../../omlish/lite/fdio/handlers.py
-
-
-class FdioHandler(abc.ABC):
-    @abc.abstractmethod
-    def fd(self) -> int:
-        raise NotImplementedError
-
-    #
-
-    @property
-    @abc.abstractmethod
-    def closed(self) -> bool:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def close(self) -> None:
-        raise NotImplementedError
-
-    #
-
-    def readable(self) -> bool:
-        return False
-
-    def writable(self) -> bool:
-        return False
-
-    #
-
-    def on_readable(self) -> None:
-        raise TypeError
-
-    def on_writable(self) -> None:
-        raise TypeError
-
-    def on_error(self, exc: ta.Optional[BaseException] = None) -> None:  # noqa
-        pass
-
-
-class SocketFdioHandler(FdioHandler, abc.ABC):
-    def __init__(
-            self,
-            addr: SocketAddress,
-            sock: socket.socket,
-    ) -> None:
-        super().__init__()
-
-        self._addr = addr
-        self._sock: ta.Optional[socket.socket] = sock
-
-    def fd(self) -> int:
-        return check_not_none(self._sock).fileno()
-
-    @property
-    def closed(self) -> bool:
-        return self._sock is None
-
-    def close(self) -> None:
-        if self._sock is not None:
-            self._sock.close()
-        self._sock = None
-
-
-########################################
-# ../../../omlish/lite/fdio/kqueue.py
-
-
-KqueueFdioPoller: ta.Optional[ta.Type[FdioPoller]]
-if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
-
-    class _KqueueFdioPoller(FdioPoller):
-        DEFAULT_MAX_EVENTS = 1000
-
-        def __init__(
-                self,
-                *,
-                max_events: int = DEFAULT_MAX_EVENTS,
-        ) -> None:
-            super().__init__()
-
-            self._max_events = max_events
-
-            self._kqueue: ta.Optional[ta.Any] = None
-
-        #
-
-        def _get_kqueue(self) -> 'select.kqueue':
-            if (kq := self._kqueue) is not None:
-                return kq
-            kq = select.kqueue()
-            self._kqueue = kq
-            return kq
-
-        def close(self) -> None:
-            if self._kqueue is not None:
-                self._kqueue.close()
-                self._kqueue = None
-
-        def reopen(self) -> None:
-            for fd in self._readable:
-                self._register_readable(fd)
-            for fd in self._writable:
-                self._register_writable(fd)
-
-        #
-
-        def _register_readable(self, fd: int) -> None:
-            self._update_registration(fd, 'read', 'add')
-
-        def _register_writable(self, fd: int) -> None:
-            self._update_registration(fd, 'write', 'add')
-
-        def _unregister_readable(self, fd: int) -> None:
-            self._update_registration(fd, 'read', 'del')
-
-        def _unregister_writable(self, fd: int) -> None:
-            self._update_registration(fd, 'write', 'del')
-
-        #
-
-        _CONTROL_FILTER_BY_READ_OR_WRITE: ta.ClassVar[ta.Mapping[ta.Literal['read', 'write'], int]] = {
-            'read': select.KQ_FILTER_READ,
-            'write': select.KQ_FILTER_WRITE,
-        }
-
-        _CONTROL_FLAGS_BY_ADD_OR_DEL: ta.ClassVar[ta.Mapping[ta.Literal['add', 'del'], int]] = {
-            'add': select.KQ_EV_ADD,
-            'del': select.KQ_EV_DELETE,
-        }
-
-        def _update_registration(
-                self,
-                fd: int,
-                read_or_write: ta.Literal['read', 'write'],
-                add_or_del: ta.Literal['add', 'del'],
-        ) -> None:  # noqa
-            ke = select.kevent(
-                fd,
-                filter=self._CONTROL_FILTER_BY_READ_OR_WRITE[read_or_write],
-                flags=self._CONTROL_FLAGS_BY_ADD_OR_DEL[add_or_del],
-            )
-            kq = self._get_kqueue()
-            try:
-                kq.control([ke], 0)
-
-            except OSError as exc:
-                if exc.errno == errno.EBADF:
-                    # log.debug('EBADF encountered in kqueue. Invalid file descriptor %s', ke.ident)
-                    pass
-                elif exc.errno == errno.ENOENT:
-                    # Can happen when trying to remove an already closed socket
-                    if add_or_del == 'add':
-                        raise
-                else:
-                    raise
-
-        #
-
-        def poll(self, timeout: ta.Optional[float]) -> FdioPoller.PollResult:
-            kq = self._get_kqueue()
-            try:
-                kes = kq.control(None, self._max_events, timeout)
-
-            except OSError as exc:
-                if exc.errno == errno.EINTR:
-                    return FdioPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
-                else:
-                    raise
-
-            r: ta.List[int] = []
-            w: ta.List[int] = []
-            for ke in kes:
-                if ke.filter == select.KQ_FILTER_READ:
-                    r.append(ke.ident)
-                if ke.filter == select.KQ_FILTER_WRITE:
-                    w.append(ke.ident)
-
-            return FdioPoller.PollResult(r, w)
-
-    KqueueFdioPoller = _KqueueFdioPoller
-else:
-    KqueueFdioPoller = None
-
-
-########################################
-# ../../../omlish/lite/http/parsing.py
+# ../../../omlish/http/parsing.py
 # PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
 # --------------------------------------------
 #
@@ -3182,28 +3300,493 @@ class HttpRequestParser:
         ):
             close_connection = False
 
-        # Check for expect directive
+        # Check for expect directive
+
+        expect = headers.get('Expect', '')
+        if (
+                expect.lower() == '100-continue' and
+                version >= HttpProtocolVersions.HTTP_1_1
+        ):
+            expects_continue = True
+        else:
+            expects_continue = False
+
+        # Return
+
+        return ParsedHttpRequest(
+            method=method,
+            path=path,
+            expects_continue=expects_continue,
+            **result_kwargs(),
+        )
+
+    def parse(self, read_line: ta.Callable[[int], bytes]) -> ParseHttpRequestResult:
+        return self._run_read_line_coro(self.coro_parse(), read_line)
+
+
+########################################
+# ../../../omlish/io/buffers.py
+
+
+class DelimitingBuffer:
+    """
+    https://github.com/python-trio/trio/issues/796 :|
+    """
+
+    #
+
+    class Error(Exception):
+        def __init__(self, buffer: 'DelimitingBuffer') -> None:
+            super().__init__(buffer)
+            self.buffer = buffer
+
+        def __repr__(self) -> str:
+            return attr_repr(self, 'buffer')
+
+    class ClosedError(Error):
+        pass
+
+    #
+
+    DEFAULT_DELIMITERS: bytes = b'\n'
+
+    def __init__(
+            self,
+            delimiters: ta.Iterable[int] = DEFAULT_DELIMITERS,
+            *,
+            keep_ends: bool = False,
+            max_size: ta.Optional[int] = None,
+    ) -> None:
+        super().__init__()
+
+        self._delimiters = frozenset(check.isinstance(d, int) for d in delimiters)
+        self._keep_ends = keep_ends
+        self._max_size = max_size
+
+        self._buf: ta.Optional[io.BytesIO] = io.BytesIO()
+
+    #
+
+    @property
+    def is_closed(self) -> bool:
+        return self._buf is None
+
+    def tell(self) -> int:
+        if (buf := self._buf) is None:
+            raise self.ClosedError(self)
+        return buf.tell()
+
+    def peek(self) -> bytes:
+        if (buf := self._buf) is None:
+            raise self.ClosedError(self)
+        return buf.getvalue()
+
+    def _find_delim(self, data: ta.Union[bytes, bytearray], i: int) -> ta.Optional[int]:
+        r = None  # type: int | None
+        for d in self._delimiters:
+            if (p := data.find(d, i)) >= 0:
+                if r is None or p < r:
+                    r = p
+        return r
+
+    def _append_and_reset(self, chunk: bytes) -> bytes:
+        buf = check.not_none(self._buf)
+        if not buf.tell():
+            return chunk
+
+        buf.write(chunk)
+        ret = buf.getvalue()
+        buf.seek(0)
+        buf.truncate()
+        return ret
+
+    class Incomplete(ta.NamedTuple):
+        b: bytes
+
+    def feed(self, data: ta.Union[bytes, bytearray]) -> ta.Generator[ta.Union[bytes, Incomplete], None, None]:
+        if (buf := self._buf) is None:
+            raise self.ClosedError(self)
+
+        if not data:
+            self._buf = None
+
+            if buf.tell():
+                yield self.Incomplete(buf.getvalue())
+
+            return
+
+        l = len(data)
+        i = 0
+        while i < l:
+            if (p := self._find_delim(data, i)) is None:
+                break
+
+            n = p + 1
+            if self._keep_ends:
+                p = n
+
+            yield self._append_and_reset(data[i:p])
+
+            i = n
+
+        if i >= l:
+            return
+
+        if self._max_size is None:
+            buf.write(data[i:])
+            return
+
+        while i < l:
+            remaining_data_len = l - i
+            remaining_buf_capacity = self._max_size - buf.tell()
+
+            if remaining_data_len < remaining_buf_capacity:
+                buf.write(data[i:])
+                return
+
+            p = i + remaining_buf_capacity
+            yield self.Incomplete(self._append_and_reset(data[i:p]))
+            i = p
+
+
+class ReadableListBuffer:
+    def __init__(self) -> None:
+        super().__init__()
+        self._lst: list[bytes] = []
+
+    def feed(self, d: bytes) -> None:
+        if d:
+            self._lst.append(d)
+
+    def _chop(self, i: int, e: int) -> bytes:
+        lst = self._lst
+        d = lst[i]
+
+        o = b''.join([
+            *lst[:i],
+            d[:e],
+        ])
+
+        self._lst = [
+            *([d[e:]] if e < len(d) else []),
+            *lst[i + 1:],
+        ]
+
+        return o
+
+    def read(self, n: ta.Optional[int] = None) -> ta.Optional[bytes]:
+        if n is None:
+            o = b''.join(self._lst)
+            self._lst = []
+            return o
+
+        if not (lst := self._lst):
+            return None
+
+        c = 0
+        for i, d in enumerate(lst):
+            r = n - c
+            if (l := len(d)) >= r:
+                return self._chop(i, r)
+            c += l
+
+        return None
+
+    def read_until(self, delim: bytes = b'\n') -> ta.Optional[bytes]:
+        if not (lst := self._lst):
+            return None
+
+        for i, d in enumerate(lst):
+            if (p := d.find(delim)) >= 0:
+                return self._chop(i, p + len(delim))
+
+        return None
+
+
+class IncrementalWriteBuffer:
+    def __init__(
+            self,
+            data: bytes,
+            *,
+            write_size: int = 0x10000,
+    ) -> None:
+        super().__init__()
+
+        check.not_empty(data)
+        self._len = len(data)
+        self._write_size = write_size
+
+        self._lst = [
+            data[i:i + write_size]
+            for i in range(0, len(data), write_size)
+        ]
+        self._pos = 0
+
+    @property
+    def rem(self) -> int:
+        return self._len - self._pos
+
+    def write(self, fn: ta.Callable[[bytes], int]) -> int:
+        lst = check.not_empty(self._lst)
+
+        t = 0
+        for i, d in enumerate(lst):  # noqa
+            n = fn(check.not_empty(d))
+            if not n:
+                break
+            t += n
+
+        if t:
+            self._lst = [
+                *([d[n:]] if n < len(d) else []),
+                *lst[i + 1:],
+            ]
+            self._pos += t
+
+        return t
+
+
+########################################
+# ../../../omlish/io/fdio/handlers.py
+
+
+class FdioHandler(abc.ABC):
+    @abc.abstractmethod
+    def fd(self) -> int:
+        raise NotImplementedError
+
+    #
+
+    @property
+    @abc.abstractmethod
+    def closed(self) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def close(self) -> None:
+        raise NotImplementedError
+
+    #
+
+    def readable(self) -> bool:
+        return False
+
+    def writable(self) -> bool:
+        return False
+
+    #
+
+    def on_readable(self) -> None:
+        raise TypeError
+
+    def on_writable(self) -> None:
+        raise TypeError
+
+    def on_error(self, exc: ta.Optional[BaseException] = None) -> None:  # noqa
+        pass
+
+
+class SocketFdioHandler(FdioHandler, abc.ABC):
+    def __init__(
+            self,
+            addr: SocketAddress,
+            sock: socket.socket,
+    ) -> None:
+        super().__init__()
+
+        self._addr = addr
+        self._sock: ta.Optional[socket.socket] = sock
+
+    def fd(self) -> int:
+        return check.not_none(self._sock).fileno()
+
+    @property
+    def closed(self) -> bool:
+        return self._sock is None
+
+    def close(self) -> None:
+        if self._sock is not None:
+            self._sock.close()
+        self._sock = None
+
+
+########################################
+# ../../../omlish/io/fdio/kqueue.py
+
+
+KqueueFdioPoller: ta.Optional[ta.Type[FdioPoller]]
+if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
+
+    class _KqueueFdioPoller(FdioPoller):
+        DEFAULT_MAX_EVENTS = 1000
+
+        def __init__(
+                self,
+                *,
+                max_events: int = DEFAULT_MAX_EVENTS,
+        ) -> None:
+            super().__init__()
+
+            self._max_events = max_events
+
+            self._kqueue: ta.Optional[ta.Any] = None
+
+        #
+
+        def _get_kqueue(self) -> 'select.kqueue':
+            if (kq := self._kqueue) is not None:
+                return kq
+            kq = select.kqueue()
+            self._kqueue = kq
+            return kq
+
+        def close(self) -> None:
+            if self._kqueue is not None:
+                self._kqueue.close()
+                self._kqueue = None
+
+        def reopen(self) -> None:
+            for fd in self._readable:
+                self._register_readable(fd)
+            for fd in self._writable:
+                self._register_writable(fd)
+
+        #
+
+        def _register_readable(self, fd: int) -> None:
+            self._update_registration(fd, 'read', 'add')
+
+        def _register_writable(self, fd: int) -> None:
+            self._update_registration(fd, 'write', 'add')
+
+        def _unregister_readable(self, fd: int) -> None:
+            self._update_registration(fd, 'read', 'del')
+
+        def _unregister_writable(self, fd: int) -> None:
+            self._update_registration(fd, 'write', 'del')
+
+        #
+
+        _CONTROL_FILTER_BY_READ_OR_WRITE: ta.ClassVar[ta.Mapping[ta.Literal['read', 'write'], int]] = {
+            'read': select.KQ_FILTER_READ,
+            'write': select.KQ_FILTER_WRITE,
+        }
+
+        _CONTROL_FLAGS_BY_ADD_OR_DEL: ta.ClassVar[ta.Mapping[ta.Literal['add', 'del'], int]] = {
+            'add': select.KQ_EV_ADD,
+            'del': select.KQ_EV_DELETE,
+        }
+
+        def _update_registration(
+                self,
+                fd: int,
+                read_or_write: ta.Literal['read', 'write'],
+                add_or_del: ta.Literal['add', 'del'],
+        ) -> None:  # noqa
+            ke = select.kevent(
+                fd,
+                filter=self._CONTROL_FILTER_BY_READ_OR_WRITE[read_or_write],
+                flags=self._CONTROL_FLAGS_BY_ADD_OR_DEL[add_or_del],
+            )
+            kq = self._get_kqueue()
+            try:
+                kq.control([ke], 0)
+
+            except OSError as exc:
+                if exc.errno == errno.EBADF:
+                    # log.debug('EBADF encountered in kqueue. Invalid file descriptor %s', ke.ident)
+                    pass
+                elif exc.errno == errno.ENOENT:
+                    # Can happen when trying to remove an already closed socket
+                    if add_or_del == 'add':
+                        raise
+                else:
+                    raise
+
+        #
+
+        def poll(self, timeout: ta.Optional[float]) -> FdioPoller.PollResult:
+            kq = self._get_kqueue()
+            try:
+                kes = kq.control(None, self._max_events, timeout)
+
+            except OSError as exc:
+                if exc.errno == errno.EINTR:
+                    return FdioPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
+                else:
+                    raise
+
+            r: ta.List[int] = []
+            w: ta.List[int] = []
+            for ke in kes:
+                if ke.filter == select.KQ_FILTER_READ:
+                    r.append(ke.ident)
+                if ke.filter == select.KQ_FILTER_WRITE:
+                    w.append(ke.ident)
+
+            return FdioPoller.PollResult(r, w)
+
+    KqueueFdioPoller = _KqueueFdioPoller
+else:
+    KqueueFdioPoller = None
+
+
+########################################
+# ../../../omlish/lite/contextmanagers.py
+
+
+##
+
+
+class ExitStacked:
+    _exit_stack: ta.Optional[contextlib.ExitStack] = None
+
+    def __enter__(self: ExitStackedT) -> ExitStackedT:
+        check.state(self._exit_stack is None)
+        es = self._exit_stack = contextlib.ExitStack()
+        es.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if (es := self._exit_stack) is None:
+            return None
+        self._exit_contexts()
+        return es.__exit__(exc_type, exc_val, exc_tb)
+
+    def _exit_contexts(self) -> None:
+        pass
+
+    def _enter_context(self, cm: ta.ContextManager[T]) -> T:
+        es = check.not_none(self._exit_stack)
+        return es.enter_context(cm)
+
+
+##
 
-        expect = headers.get('Expect', '')
-        if (
-                expect.lower() == '100-continue' and
-                version >= HttpProtocolVersions.HTTP_1_1
-        ):
-            expects_continue = True
-        else:
-            expects_continue = False
 
-        # Return
+@contextlib.contextmanager
+def defer(fn: ta.Callable) -> ta.Generator[ta.Callable, None, None]:
+    try:
+        yield fn
+    finally:
+        fn()
 
-        return ParsedHttpRequest(
-            method=method,
-            path=path,
-            expects_continue=expects_continue,
-            **result_kwargs(),
-        )
 
-    def parse(self, read_line: ta.Callable[[int], bytes]) -> ParseHttpRequestResult:
-        return self._run_read_line_coro(self.coro_parse(), read_line)
+@contextlib.contextmanager
+def attr_setting(obj, attr, val, *, default=None):  # noqa
+    not_set = object()
+    orig = getattr(obj, attr, not_set)
+    try:
+        setattr(obj, attr, val)
+        if orig is not not_set:
+            yield orig
+        else:
+            yield default
+    finally:
+        if orig is not_set:
+            delattr(obj, attr)
+        else:
+            setattr(obj, attr, orig)
 
 
 ########################################
@@ -3350,7 +3933,7 @@ class FnInjectorProvider(InjectorProvider):
     fn: ta.Any
 
     def __post_init__(self) -> None:
-        check_not_isinstance(self.fn, type)
+        check.not_isinstance(self.fn, type)
 
     def provider_fn(self) -> InjectorProviderFn:
         def pfn(i: Injector) -> ta.Any:
@@ -3364,7 +3947,7 @@ class CtorInjectorProvider(InjectorProvider):
     cls_: type
 
     def __post_init__(self) -> None:
-        check_isinstance(self.cls_, type)
+        check.isinstance(self.cls_, type)
 
     def provider_fn(self) -> InjectorProviderFn:
         def pfn(i: Injector) -> ta.Any:
@@ -3386,7 +3969,7 @@ class SingletonInjectorProvider(InjectorProvider):
     p: InjectorProvider
 
     def __post_init__(self) -> None:
-        check_isinstance(self.p, InjectorProvider)
+        check.isinstance(self.p, InjectorProvider)
 
     def provider_fn(self) -> InjectorProviderFn:
         v = not_set = object()
@@ -3406,7 +3989,7 @@ class LinkInjectorProvider(InjectorProvider):
     k: InjectorKey
 
     def __post_init__(self) -> None:
-        check_isinstance(self.k, InjectorKey)
+        check.isinstance(self.k, InjectorKey)
 
     def provider_fn(self) -> InjectorProviderFn:
         def pfn(i: Injector) -> ta.Any:
@@ -3603,7 +4186,7 @@ def build_injection_kwargs_target(
 
     skip_names: ta.Set[str] = set()
     if skip_kwargs is not None:
-        skip_names.update(check_not_isinstance(skip_kwargs, str))
+        skip_names.update(check.not_isinstance(skip_kwargs, str))
 
     seen: ta.Set[InjectorKey] = set()
     kws: ta.List[InjectionKwarg] = []
@@ -3664,8 +4247,8 @@ class _Injector(Injector):
     def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
         super().__init__()
 
-        self._bs = check_isinstance(bs, InjectorBindings)
-        self._p: ta.Optional[Injector] = check_isinstance(p, (Injector, type(None)))
+        self._bs = check.isinstance(bs, InjectorBindings)
+        self._p: ta.Optional[Injector] = check.isinstance(p, (Injector, type(None)))
 
         self._pfm = {k: v.provider_fn() for k, v in build_injector_provider_map(bs).items()}
 
@@ -3696,8 +4279,8 @@ class _Injector(Injector):
             return Maybe.empty()
 
         def handle_provision(self, key: InjectorKey, mv: Maybe) -> Maybe:
-            check_in(key, self._seen_keys)
-            check_not_in(key, self._provisions)
+            check.in_(key, self._seen_keys)
+            check.not_in(key, self._provisions)
             self._provisions[key] = mv
             return mv
 
@@ -3811,7 +4394,7 @@ class InjectorBinder:
 
     @classmethod
     def bind_as_fn(cls, icls: ta.Type[T]) -> ta.Type[T]:
-        check_isinstance(icls, type)
+        check.isinstance(icls, type)
         if icls not in cls._FN_TYPES:
             cls._FN_TYPES = (*cls._FN_TYPES, icls)
         return icls
@@ -3868,7 +4451,7 @@ class InjectorBinder:
             to_fn = obj
             if key is None:
                 insp = _injection_inspect(obj)
-                key_cls: ta.Any = check_valid_injector_key_cls(check_not_none(insp.type_hints.get('return')))
+                key_cls: ta.Any = check_valid_injector_key_cls(check.not_none(insp.type_hints.get('return')))
                 key = InjectorKey(key_cls)
         else:
             if to_const is not None:
@@ -4099,228 +4682,6 @@ class Injection:
 inj = Injection
 
 
-########################################
-# ../../../omlish/lite/io.py
-
-
-class DelimitingBuffer:
-    """
-    https://github.com/python-trio/trio/issues/796 :|
-    """
-
-    #
-
-    class Error(Exception):
-        def __init__(self, buffer: 'DelimitingBuffer') -> None:
-            super().__init__(buffer)
-            self.buffer = buffer
-
-        def __repr__(self) -> str:
-            return attr_repr(self, 'buffer')
-
-    class ClosedError(Error):
-        pass
-
-    #
-
-    DEFAULT_DELIMITERS: bytes = b'\n'
-
-    def __init__(
-            self,
-            delimiters: ta.Iterable[int] = DEFAULT_DELIMITERS,
-            *,
-            keep_ends: bool = False,
-            max_size: ta.Optional[int] = None,
-    ) -> None:
-        super().__init__()
-
-        self._delimiters = frozenset(check_isinstance(d, int) for d in delimiters)
-        self._keep_ends = keep_ends
-        self._max_size = max_size
-
-        self._buf: ta.Optional[io.BytesIO] = io.BytesIO()
-
-    #
-
-    @property
-    def is_closed(self) -> bool:
-        return self._buf is None
-
-    def tell(self) -> int:
-        if (buf := self._buf) is None:
-            raise self.ClosedError(self)
-        return buf.tell()
-
-    def peek(self) -> bytes:
-        if (buf := self._buf) is None:
-            raise self.ClosedError(self)
-        return buf.getvalue()
-
-    def _find_delim(self, data: ta.Union[bytes, bytearray], i: int) -> ta.Optional[int]:
-        r = None  # type: int | None
-        for d in self._delimiters:
-            if (p := data.find(d, i)) >= 0:
-                if r is None or p < r:
-                    r = p
-        return r
-
-    def _append_and_reset(self, chunk: bytes) -> bytes:
-        buf = check_not_none(self._buf)
-        if not buf.tell():
-            return chunk
-
-        buf.write(chunk)
-        ret = buf.getvalue()
-        buf.seek(0)
-        buf.truncate()
-        return ret
-
-    class Incomplete(ta.NamedTuple):
-        b: bytes
-
-    def feed(self, data: ta.Union[bytes, bytearray]) -> ta.Generator[ta.Union[bytes, Incomplete], None, None]:
-        if (buf := self._buf) is None:
-            raise self.ClosedError(self)
-
-        if not data:
-            self._buf = None
-
-            if buf.tell():
-                yield self.Incomplete(buf.getvalue())
-
-            return
-
-        l = len(data)
-        i = 0
-        while i < l:
-            if (p := self._find_delim(data, i)) is None:
-                break
-
-            n = p + 1
-            if self._keep_ends:
-                p = n
-
-            yield self._append_and_reset(data[i:p])
-
-            i = n
-
-        if i >= l:
-            return
-
-        if self._max_size is None:
-            buf.write(data[i:])
-            return
-
-        while i < l:
-            remaining_data_len = l - i
-            remaining_buf_capacity = self._max_size - buf.tell()
-
-            if remaining_data_len < remaining_buf_capacity:
-                buf.write(data[i:])
-                return
-
-            p = i + remaining_buf_capacity
-            yield self.Incomplete(self._append_and_reset(data[i:p]))
-            i = p
-
-
-class ReadableListBuffer:
-    def __init__(self) -> None:
-        super().__init__()
-        self._lst: list[bytes] = []
-
-    def feed(self, d: bytes) -> None:
-        if d:
-            self._lst.append(d)
-
-    def _chop(self, i: int, e: int) -> bytes:
-        lst = self._lst
-        d = lst[i]
-
-        o = b''.join([
-            *lst[:i],
-            d[:e],
-        ])
-
-        self._lst = [
-            *([d[e:]] if e < len(d) else []),
-            *lst[i + 1:],
-        ]
-
-        return o
-
-    def read(self, n: ta.Optional[int] = None) -> ta.Optional[bytes]:
-        if n is None:
-            o = b''.join(self._lst)
-            self._lst = []
-            return o
-
-        if not (lst := self._lst):
-            return None
-
-        c = 0
-        for i, d in enumerate(lst):
-            r = n - c
-            if (l := len(d)) >= r:
-                return self._chop(i, r)
-            c += l
-
-        return None
-
-    def read_until(self, delim: bytes = b'\n') -> ta.Optional[bytes]:
-        if not (lst := self._lst):
-            return None
-
-        for i, d in enumerate(lst):
-            if (p := d.find(delim)) >= 0:
-                return self._chop(i, p + len(delim))
-
-        return None
-
-
-class IncrementalWriteBuffer:
-    def __init__(
-            self,
-            data: bytes,
-            *,
-            write_size: int = 0x10000,
-    ) -> None:
-        super().__init__()
-
-        check_non_empty(data)
-        self._len = len(data)
-        self._write_size = write_size
-
-        self._lst = [
-            data[i:i + write_size]
-            for i in range(0, len(data), write_size)
-        ]
-        self._pos = 0
-
-    @property
-    def rem(self) -> int:
-        return self._len - self._pos
-
-    def write(self, fn: ta.Callable[[bytes], int]) -> int:
-        lst = check_non_empty(self._lst)
-
-        t = 0
-        for i, d in enumerate(lst):  # noqa
-            n = fn(check_non_empty(d))
-            if not n:
-                break
-            t += n
-
-        if t:
-            self._lst = [
-                *([d[n:]] if n < len(d) else []),
-                *lst[i + 1:],
-            ]
-            self._pos += t
-
-        return t
-
-
 ########################################
 # ../../../omlish/lite/journald.py
 
@@ -4789,10 +5150,10 @@ class ProxyObjMarshaler(ObjMarshaler):
     m: ta.Optional[ObjMarshaler] = None
 
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return check_not_none(self.m).marshal(o, ctx)
+        return check.not_none(self.m).marshal(o, ctx)
 
     def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return check_not_none(self.m).unmarshal(o, ctx)
+        return check.not_none(self.m).unmarshal(o, ctx)
 
 
 @dc.dataclass(frozen=True)
@@ -4951,19 +5312,19 @@ class DatetimeObjMarshaler(ObjMarshaler):
 
 class DecimalObjMarshaler(ObjMarshaler):
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return str(check_isinstance(o, decimal.Decimal))
+        return str(check.isinstance(o, decimal.Decimal))
 
     def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        return decimal.Decimal(check_isinstance(v, str))
+        return decimal.Decimal(check.isinstance(v, str))
 
 
 class FractionObjMarshaler(ObjMarshaler):
     def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        fr = check_isinstance(o, fractions.Fraction)
+        fr = check.isinstance(o, fractions.Fraction)
         return [fr.numerator, fr.denominator]
 
     def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
-        num, denom = check_isinstance(v, list)
+        num, denom = check.isinstance(v, list)
         return fractions.Fraction(num, denom)
 
 
@@ -5265,7 +5626,7 @@ def build_config_named_children(
     lst: ta.List[ConfigMapping] = []
     if isinstance(o, ta.Mapping):
         for k, v in o.items():
-            check_isinstance(v, ta.Mapping)
+            check.isinstance(v, ta.Mapping)
             if name_key in v:
                 n = v[name_key]
                 if k != n:
@@ -5275,7 +5636,7 @@ def build_config_named_children(
                 lst.append({name_key: k, **v})
 
     else:
-        check_not_isinstance(o, str)
+        check.not_isinstance(o, str)
         lst.extend(o)
 
     seen = set()
@@ -5406,7 +5767,7 @@ class SupervisorSetup(abc.ABC):
 
 
 ########################################
-# ../../../omlish/lite/http/handlers.py
+# ../../../omlish/http/handlers.py
 
 
 @dc.dataclass(frozen=True)
@@ -5581,7 +5942,7 @@ def parse_logging_level(value: ta.Union[str, int]) -> int:
 
 
 ########################################
-# ../../../omlish/lite/http/coroserver.py
+# ../../../omlish/http/coroserver.py
 # PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
 # --------------------------------------------
 #
@@ -5961,13 +6322,13 @@ class CoroHttpServer:
                     yield o
 
                 elif isinstance(o, self.AnyReadIo):
-                    i = check_isinstance((yield o), bytes)
+                    i = check.isinstance((yield o), bytes)
 
                 elif isinstance(o, self._Response):
                     i = None
                     r = self._preprocess_response(o)
                     b = self._build_response_bytes(r)
-                    check_none((yield self.WriteIo(b)))
+                    check.none((yield self.WriteIo(b)))
 
                 else:
                     raise TypeError(o)
@@ -5990,7 +6351,7 @@ class CoroHttpServer:
         sz = next(gen)
         while True:
             try:
-                line = check_isinstance((yield self.ReadLineIo(sz)), bytes)
+                line = check.isinstance((yield self.ReadLineIo(sz)), bytes)
                 sz = gen.send(line)
             except StopIteration as e:
                 parsed = e.value
@@ -6009,11 +6370,11 @@ class CoroHttpServer:
             yield self._build_error_response(err)
             return
 
-        parsed = check_isinstance(parsed, ParsedHttpRequest)
+        parsed = check.isinstance(parsed, ParsedHttpRequest)
 
         # Log
 
-        check_none((yield self.ParsedRequestLogIo(parsed)))
+        check.none((yield self.ParsedRequestLogIo(parsed)))
 
         # Handle CONTINUE
 
@@ -6029,7 +6390,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 self.ReadIo(int(cl))), bytes)
         else:
             request_data = None
 
@@ -6037,7 +6398,7 @@ class CoroHttpServer:
 
         handler_request = HttpHandlerRequest(
             client_address=self._client_address,
-            method=check_not_none(parsed.method),
+            method=check.not_none(parsed.method),
             path=parsed.path,
             headers=parsed.headers,
             data=request_data,
@@ -6321,7 +6682,7 @@ class ProcessGroup(
 
 
 ########################################
-# ../../../omlish/lite/fdio/corohttp.py
+# ../../../omlish/io/fdio/corohttp.py
 
 
 class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
@@ -6335,7 +6696,7 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
             write_size: int = 0x10000,
             log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpServer.AnyLogIo], None]] = None,
     ) -> None:
-        check_state(not sock.getblocking())
+        check.state(not sock.getblocking())
 
         super().__init__(addr, sock)
 
@@ -6359,7 +6720,7 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
     #
 
     def _next_io(self) -> None:  # noqa
-        coro = check_not_none(self._srv_coro)
+        coro = check.not_none(self._srv_coro)
 
         d: bytes | None = None
         o = self._cur_io
@@ -6392,7 +6753,7 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
                 o = None
 
             elif isinstance(o, CoroHttpServer.WriteIo):
-                check_none(self._write_buf)
+                check.none(self._write_buf)
                 self._write_buf = IncrementalWriteBuffer(o.data, write_size=self._write_size)
                 break
 
@@ -6413,7 +6774,7 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
 
     def on_readable(self) -> None:
         try:
-            buf = check_not_none(self._sock).recv(self._read_size)
+            buf = check.not_none(self._sock).recv(self._read_size)
         except BlockingIOError:
             return
         except ConnectionResetError:
@@ -6429,12 +6790,12 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
             self._next_io()
 
     def on_writable(self) -> None:
-        check_isinstance(self._cur_io, CoroHttpServer.WriteIo)
-        wb = check_not_none(self._write_buf)
+        check.isinstance(self._cur_io, CoroHttpServer.WriteIo)
+        wb = check.not_none(self._write_buf)
         while wb.rem > 0:
             def send(d: bytes) -> int:
                 try:
-                    return check_not_none(self._sock).send(d)
+                    return check.not_none(self._sock).send(d)
                 except ConnectionResetError:
                     self.close()
                     return 0
@@ -6827,7 +7188,7 @@ class ProcessGroupImpl(ProcessGroup):
 
         by_name: ta.Dict[str, Process] = {}
         for pconfig in self._config.processes or []:
-            p = check_isinstance(self._process_factory(pconfig, self), Process)
+            p = check.isinstance(self._process_factory(pconfig, self), Process)
             if p.name in by_name:
                 raise KeyError(f'name {p.name} of process {p} already registered by {by_name[p.name]}')
             by_name[pconfig.name] = p
@@ -7380,7 +7741,7 @@ class SocketServerFdioHandler(SocketFdioHandler):
         return True
 
     def on_readable(self) -> None:
-        cli_sock, cli_addr = check_not_none(self._sock).accept()
+        cli_sock, cli_addr = check.not_none(self._sock).accept()
         cli_sock.setblocking(False)
 
         self._on_connect(cli_sock, cli_addr)
@@ -7619,7 +7980,7 @@ class ProcessImpl(Process):
         if stdin_fd is None:
             raise OSError(errno.EPIPE, 'Process has no stdin channel')
 
-        dispatcher = check_isinstance(self._dispatchers[stdin_fd], ProcessInputDispatcher)
+        dispatcher = check.isinstance(self._dispatchers[stdin_fd], ProcessInputDispatcher)
         if dispatcher.closed:
             raise OSError(errno.EPIPE, "Process' stdin channel is closed")
 
@@ -8178,21 +8539,21 @@ class ProcessSpawningImpl(ProcessSpawning):
         dispatchers: ta.List[FdioHandler] = []
 
         if pipes.stdout is not None:
-            dispatchers.append(check_isinstance(self._output_dispatcher_factory(
+            dispatchers.append(check.isinstance(self._output_dispatcher_factory(
                 self.process,
                 ProcessCommunicationStdoutEvent,
                 pipes.stdout,
             ), ProcessOutputDispatcher))
 
         if pipes.stderr is not None:
-            dispatchers.append(check_isinstance(self._output_dispatcher_factory(
+            dispatchers.append(check.isinstance(self._output_dispatcher_factory(
                 self.process,
                 ProcessCommunicationStderrEvent,
                 pipes.stderr,
             ), ProcessOutputDispatcher))
 
         if pipes.stdin is not None:
-            dispatchers.append(check_isinstance(self._input_dispatcher_factory(
+            dispatchers.append(check.isinstance(self._input_dispatcher_factory(
                 self.process,
                 'stdin',
                 pipes.stdin,
@@ -8282,14 +8643,14 @@ class ProcessSpawningImpl(ProcessSpawning):
         raise RuntimeError('Unreachable')
 
     def _prepare_child_fds(self, pipes: ProcessPipes) -> None:
-        os.dup2(check_not_none(pipes.child_stdin), 0)
+        os.dup2(check.not_none(pipes.child_stdin), 0)
 
-        os.dup2(check_not_none(pipes.child_stdout), 1)
+        os.dup2(check.not_none(pipes.child_stdout), 1)
 
         if self.config.redirect_stderr:
-            os.dup2(check_not_none(pipes.child_stdout), 2)
+            os.dup2(check.not_none(pipes.child_stdout), 2)
         else:
-            os.dup2(check_not_none(pipes.child_stderr), 2)
+            os.dup2(check.not_none(pipes.child_stderr), 2)
 
         for i in range(3, self._server_config.min_fds):
             if i in self._inherited_fds:
@@ -8405,7 +8766,7 @@ class Supervisor:
         if self._process_groups.get(config.name) is not None:
             return False
 
-        group = check_isinstance(self._process_group_factory(config), ProcessGroup)
+        group = check.isinstance(self._process_group_factory(config), ProcessGroup)
         for process in group:
             process.after_setuid()