ominfra 0.0.0.dev149__py3-none-any.whl → 0.0.0.dev151__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]  # ta.TypeAlias
+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']
 
 
@@ -1430,6 +1436,25 @@ def parse_octal(arg: ta.Union[str, int]) -> int:
         raise ValueError(f'{arg} can not be converted to an octal type')  # noqa
 
 
+########################################
+# ../../../omlish/http/versions.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)
+
+
 ########################################
 # ../../../omlish/io/fdio/pollers.py
 
@@ -1698,123 +1723,454 @@ def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
 
 ########################################
 # ../../../omlish/lite/check.py
+"""
+TODO:
+ - def maybe(v: lang.Maybe[T])
+ - patch / override lite.check ?
+  - checker interface?
+"""
+
+
+##
 
 
-def check_isinstance(v: ta.Any, spec: ta.Union[ta.Type[T], tuple]) -> T:
-    if not isinstance(v, spec):
-        raise TypeError(v)
-    return v
+class Checks:
+    def __init__(self) -> None:
+        super().__init__()
 
+        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] = []
+
+    @staticmethod
+    def default_exception_factory(exc_cls: ta.Type[Exception], *args, **kwargs) -> Exception:
+        return exc_cls(*args, **kwargs)  # noqa
 
-def check_not_isinstance(v: T, spec: ta.Union[type, tuple]) -> T:
-    if isinstance(v, spec):
-        raise TypeError(v)
-    return v
+    #
 
+    def register_on_raise(self, fn: CheckOnRaiseFn) -> None:
+        with self._config_lock:
+            self._on_raise_fns = [*self._on_raise_fns, fn]
 
-def check_none(v: T) -> None:
-    if v is not None:
-        raise ValueError(v)
+    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]
 
+    #
 
-def check_not_none(v: ta.Optional[T]) -> T:
-    if v is None:
-        raise ValueError
-    return v
+    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
 
-def check_not(v: ta.Any) -> None:
-    if v:
-        raise ValueError(v)
-    return v
+    #
 
+    def register_late_configure(self, fn: CheckLateConfigureFn) -> None:
+        with self._config_lock:
+            self._late_configure_fns = [*self._late_configure_fns, fn]
 
-def check_non_empty_str(v: ta.Optional[str]) -> str:
-    if not v:
-        raise ValueError
-    return v
+    def _late_configure(self) -> None:
+        if not self._late_configure_fns:
+            return
 
+        with self._config_lock:
+            if not (lc := self._late_configure_fns):
+                return
 
-def check_arg(v: bool, msg: str = 'Illegal argument') -> None:
-    if not v:
-        raise ValueError(msg)
+            for fn in lc:
+                fn(self)
 
+            self._late_configure_fns = []
 
-def check_state(v: bool, msg: str = 'Illegal state') -> None:
-    if not v:
-        raise ValueError(msg)
+    #
 
+    class _ArgsKwargs:
+        def __init__(self, *args, **kwargs):
+            self.args = args
+            self.kwargs = kwargs
 
-def check_equal(l: T, r: T) -> T:
-    if l != r:
-        raise ValueError(l, r)
-    return l
+    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 check_not_equal(l: T, r: T) -> T:
-    if l == r:
-        raise ValueError(l, r)
-    return l
+        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 check_is(l: T, r: T) -> T:
-    if l is not r:
-        raise ValueError(l, r)
-    return l
+        exc = self._exception_factory(
+            exception_type,
+            message,
+            *exc_args,
+            *ak.args,
+            **ak.kwargs,
+        )
 
+        for fn in self._on_raise_fns:
+            fn(exc)
 
-def check_is_not(l: T, r: ta.Any) -> T:
-    if l is r:
-        raise ValueError(l, r)
-    return l
+        raise exc
 
+    #
 
-def check_in(v: T, c: ta.Container[T]) -> T:
-    if v not in c:
-        raise ValueError(v, c)
-    return v
+    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
 
-def check_not_in(v: T, c: ta.Container[T]) -> T:
-    if v in c:
-        raise ValueError(v, c)
-    return v
+    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 check_single(vs: ta.Iterable[T]) -> T:
-    [v] = vs
-    return v
+    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 check_empty(v: SizedT) -> SizedT:
-    if len(v):
-        raise ValueError(v)
-    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 check_not_empty(v: SizedT) -> SizedT:
-    if not len(v):
-        raise ValueError(v)
-    return v
+    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
 
-########################################
-# ../../../omlish/lite/http/versions.py
+    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
 
-class HttpProtocolVersion(ta.NamedTuple):
-    major: int
-    minor: int
+    ##
 
-    def __str__(self) -> str:
-        return f'HTTP/{self.major}.{self.minor}'
+    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
 
-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)
+    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()
 
 
 ########################################
@@ -2569,868 +2925,868 @@ def get_user(name: str) -> User:
 
 
 ########################################
-# ../../../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
+# ../../../omlish/http/parsing.py
+# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+# --------------------------------------------
+#
+# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
+# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
+# documentation.
+#
+# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
+# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
+# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
+# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+# 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights Reserved" are retained in Python
+# alone or in any derivative version prepared by Licensee.
+#
+# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
+# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
+# any such work a brief summary of the changes made to Python.
+#
+# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
+# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
+# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
+# RIGHTS.
+#
+# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
+# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
+# ADVISED OF THE POSSIBILITY THEREOF.
+#
+# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
+#
+# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
+# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
+# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
+#
+# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
+# License Agreement.
 
-        def __repr__(self) -> str:
-            return attr_repr(self, 'buffer')
 
-    class ClosedError(Error):
-        pass
+##
 
-    #
 
-    DEFAULT_DELIMITERS: bytes = b'\n'
+class ParseHttpRequestResult(abc.ABC):  # noqa
+    __slots__ = (
+        'server_version',
+        'request_line',
+        'request_version',
+        'version',
+        'headers',
+        'close_connection',
+    )
 
     def __init__(
             self,
-            delimiters: ta.Iterable[int] = DEFAULT_DELIMITERS,
             *,
-            keep_ends: bool = False,
-            max_size: ta.Optional[int] = None,
+            server_version: HttpProtocolVersion,
+            request_line: str,
+            request_version: HttpProtocolVersion,
+            version: HttpProtocolVersion,
+            headers: ta.Optional[HttpHeaders],
+            close_connection: bool,
     ) -> 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.server_version = server_version
+        self.request_line = request_line
+        self.request_version = request_version
+        self.version = version
+        self.headers = headers
+        self.close_connection = close_connection
 
-        self._buf: ta.Optional[io.BytesIO] = io.BytesIO()
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({", ".join(f"{a}={getattr(self, a)!r}" for a in self.__slots__)})'
 
-    #
 
-    @property
-    def is_closed(self) -> bool:
-        return self._buf is None
+class EmptyParsedHttpResult(ParseHttpRequestResult):
+    pass
 
-    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()
+class ParseHttpRequestError(ParseHttpRequestResult):
+    __slots__ = (
+        'code',
+        'message',
+        *ParseHttpRequestResult.__slots__,
+    )
 
-    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 __init__(
+            self,
+            *,
+            code: http.HTTPStatus,
+            message: ta.Union[str, ta.Tuple[str, str]],
 
-    def _append_and_reset(self, chunk: bytes) -> bytes:
-        buf = check_not_none(self._buf)
-        if not buf.tell():
-            return chunk
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(**kwargs)
 
-        buf.write(chunk)
-        ret = buf.getvalue()
-        buf.seek(0)
-        buf.truncate()
-        return ret
+        self.code = code
+        self.message = message
 
-    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)
+class ParsedHttpRequest(ParseHttpRequestResult):
+    __slots__ = (
+        'method',
+        'path',
+        'headers',
+        'expects_continue',
+        *[a for a in ParseHttpRequestResult.__slots__ if a != 'headers'],
+    )
 
-        if not data:
-            self._buf = None
+    def __init__(
+            self,
+            *,
+            method: str,
+            path: str,
+            headers: HttpHeaders,
+            expects_continue: bool,
 
-            if buf.tell():
-                yield self.Incomplete(buf.getvalue())
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(
+            headers=headers,
+            **kwargs,
+        )
 
-            return
+        self.method = method
+        self.path = path
+        self.expects_continue = expects_continue
 
-        l = len(data)
-        i = 0
-        while i < l:
-            if (p := self._find_delim(data, i)) is None:
-                break
+    headers: HttpHeaders
 
-            n = p + 1
-            if self._keep_ends:
-                p = n
 
-            yield self._append_and_reset(data[i:p])
+#
 
-            i = n
 
-        if i >= l:
-            return
+class HttpRequestParser:
+    DEFAULT_SERVER_VERSION = HttpProtocolVersions.HTTP_1_0
 
-        if self._max_size is None:
-            buf.write(data[i:])
-            return
+    # The default request version. This only affects responses up until the point where the request line is parsed, so
+    # it mainly decides what the client gets back when sending a malformed request line.
+    # Most web servers default to HTTP 0.9, i.e. don't send a status line.
+    DEFAULT_REQUEST_VERSION = HttpProtocolVersions.HTTP_0_9
 
-        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
+    DEFAULT_MAX_LINE: int = 0x10000
+    DEFAULT_MAX_HEADERS: int = 100
 
-            p = i + remaining_buf_capacity
-            yield self.Incomplete(self._append_and_reset(data[i:p]))
-            i = p
+    #
 
+    def __init__(
+            self,
+            *,
+            server_version: HttpProtocolVersion = DEFAULT_SERVER_VERSION,
 
-class ReadableListBuffer:
-    def __init__(self) -> None:
+            max_line: int = DEFAULT_MAX_LINE,
+            max_headers: int = DEFAULT_MAX_HEADERS,
+    ) -> None:
         super().__init__()
-        self._lst: list[bytes] = []
 
-    def feed(self, d: bytes) -> None:
-        if d:
-            self._lst.append(d)
+        if server_version >= HttpProtocolVersions.HTTP_2_0:
+            raise ValueError(f'Unsupported protocol version: {server_version}')
+        self._server_version = server_version
 
-    def _chop(self, i: int, e: int) -> bytes:
-        lst = self._lst
-        d = lst[i]
+        self._max_line = max_line
+        self._max_headers = max_headers
 
-        o = b''.join([
-            *lst[:i],
-            d[:e],
-        ])
+    #
 
-        self._lst = [
-            *([d[e:]] if e < len(d) else []),
-            *lst[i + 1:],
-        ]
+    @property
+    def server_version(self) -> HttpProtocolVersion:
+        return self._server_version
 
-        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
+    def _run_read_line_coro(
+            self,
+            gen: ta.Generator[int, bytes, T],
+            read_line: ta.Callable[[int], bytes],
+    ) -> T:
+        sz = next(gen)
+        while True:
+            try:
+                sz = gen.send(read_line(sz))
+            except StopIteration as e:
+                return e.value
 
-        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
+    def parse_request_version(self, version_str: str) -> HttpProtocolVersion:
+        if not version_str.startswith('HTTP/'):
+            raise ValueError(version_str)  # noqa
 
-        return None
+        base_version_number = version_str.split('/', 1)[1]
+        version_number_parts = base_version_number.split('.')
 
-    def read_until(self, delim: bytes = b'\n') -> ta.Optional[bytes]:
-        if not (lst := self._lst):
-            return None
+        # RFC 2145 section 3.1 says there can be only one "." and
+        #   - major and minor numbers MUST be treated as separate integers;
+        #   - HTTP/2.4 is a lower version than HTTP/2.13, which in turn is lower than HTTP/12.3;
+        #   - Leading zeros MUST be ignored by recipients.
+        if len(version_number_parts) != 2:
+            raise ValueError(version_number_parts)  # noqa
+        if any(not component.isdigit() for component in version_number_parts):
+            raise ValueError('non digit in http version')  # noqa
+        if any(len(component) > 10 for component in version_number_parts):
+            raise ValueError('unreasonable length http version')  # noqa
 
-        for i, d in enumerate(lst):
-            if (p := d.find(delim)) >= 0:
-                return self._chop(i, p + len(delim))
+        return HttpProtocolVersion(
+            int(version_number_parts[0]),
+            int(version_number_parts[1]),
+        )
 
-        return None
+    #
 
+    def coro_read_raw_headers(self) -> ta.Generator[int, bytes, ta.List[bytes]]:
+        raw_headers: ta.List[bytes] = []
+        while True:
+            line = yield self._max_line + 1
+            if len(line) > self._max_line:
+                raise http.client.LineTooLong('header line')
+            raw_headers.append(line)
+            if len(raw_headers) > self._max_headers:
+                raise http.client.HTTPException(f'got more than {self._max_headers} headers')
+            if line in (b'\r\n', b'\n', b''):
+                break
+        return raw_headers
 
-class IncrementalWriteBuffer:
-    def __init__(
-            self,
-            data: bytes,
-            *,
-            write_size: int = 0x10000,
-    ) -> None:
-        super().__init__()
+    def read_raw_headers(self, read_line: ta.Callable[[int], bytes]) -> ta.List[bytes]:
+        return self._run_read_line_coro(self.coro_read_raw_headers(), read_line)
 
-        check_not_empty(data)
-        self._len = len(data)
-        self._write_size = write_size
+    def parse_raw_headers(self, raw_headers: ta.Sequence[bytes]) -> HttpHeaders:
+        return http.client.parse_headers(io.BytesIO(b''.join(raw_headers)))
 
-        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 coro_parse(self) -> ta.Generator[int, bytes, ParseHttpRequestResult]:
+        raw_request_line = yield self._max_line + 1
 
-    def write(self, fn: ta.Callable[[bytes], int]) -> int:
-        lst = check_not_empty(self._lst)
+        # Common result kwargs
 
-        t = 0
-        for i, d in enumerate(lst):  # noqa
-            n = fn(check_not_empty(d))
-            if not n:
-                break
-            t += n
+        request_line = '-'
+        request_version = self.DEFAULT_REQUEST_VERSION
 
-        if t:
-            self._lst = [
-                *([d[n:]] if n < len(d) else []),
-                *lst[i + 1:],
-            ]
-            self._pos += t
+        # Set to min(server, request) when it gets that far, but if it fails before that the server authoritatively
+        # responds with its own version.
+        version = self._server_version
 
-        return t
+        headers: HttpHeaders | None = None
 
+        close_connection = True
 
-########################################
-# ../../../omlish/io/fdio/handlers.py
+        def result_kwargs():
+            return dict(
+                server_version=self._server_version,
+                request_line=request_line,
+                request_version=request_version,
+                version=version,
+                headers=headers,
+                close_connection=close_connection,
+            )
 
+        # Decode line
 
-class FdioHandler(abc.ABC):
-    @abc.abstractmethod
-    def fd(self) -> int:
-        raise NotImplementedError
+        if len(raw_request_line) > self._max_line:
+            return ParseHttpRequestError(
+                code=http.HTTPStatus.REQUEST_URI_TOO_LONG,
+                message='Request line too long',
+                **result_kwargs(),
+            )
 
-    #
+        if not raw_request_line:
+            return EmptyParsedHttpResult(**result_kwargs())
 
-    @property
-    @abc.abstractmethod
-    def closed(self) -> bool:
-        raise NotImplementedError
+        request_line = raw_request_line.decode('iso-8859-1').rstrip('\r\n')
 
-    @abc.abstractmethod
-    def close(self) -> None:
-        raise NotImplementedError
+        # Split words
 
-    #
+        words = request_line.split()
+        if len(words) == 0:
+            return EmptyParsedHttpResult(**result_kwargs())
 
-    def readable(self) -> bool:
-        return False
+        # Parse and set version
 
-    def writable(self) -> bool:
-        return False
+        if len(words) >= 3:  # Enough to determine protocol version
+            version_str = words[-1]
+            try:
+                request_version = self.parse_request_version(version_str)
 
-    #
+            except (ValueError, IndexError):
+                return ParseHttpRequestError(
+                    code=http.HTTPStatus.BAD_REQUEST,
+                    message=f'Bad request version ({version_str!r})',
+                    **result_kwargs(),
+                )
 
-    def on_readable(self) -> None:
-        raise TypeError
+            if (
+                    request_version < HttpProtocolVersions.HTTP_0_9 or
+                    request_version >= HttpProtocolVersions.HTTP_2_0
+            ):
+                return ParseHttpRequestError(
+                    code=http.HTTPStatus.HTTP_VERSION_NOT_SUPPORTED,
+                    message=f'Invalid HTTP version ({version_str})',
+                    **result_kwargs(),
+                )
 
-    def on_writable(self) -> None:
-        raise TypeError
+            version = min([self._server_version, request_version])
 
-    def on_error(self, exc: ta.Optional[BaseException] = None) -> None:  # noqa
-        pass
+            if version >= HttpProtocolVersions.HTTP_1_1:
+                close_connection = False
 
+        # Verify word count
 
-class SocketFdioHandler(FdioHandler, abc.ABC):
-    def __init__(
-            self,
-            addr: SocketAddress,
-            sock: socket.socket,
-    ) -> None:
-        super().__init__()
+        if not 2 <= len(words) <= 3:
+            return ParseHttpRequestError(
+                code=http.HTTPStatus.BAD_REQUEST,
+                message=f'Bad request syntax ({request_line!r})',
+                **result_kwargs(),
+            )
 
-        self._addr = addr
-        self._sock: ta.Optional[socket.socket] = sock
+        # Parse method and path
 
-    def fd(self) -> int:
-        return check_not_none(self._sock).fileno()
+        method, path = words[:2]
+        if len(words) == 2:
+            close_connection = True
+            if method != 'GET':
+                return ParseHttpRequestError(
+                    code=http.HTTPStatus.BAD_REQUEST,
+                    message=f'Bad HTTP/0.9 request type ({method!r})',
+                    **result_kwargs(),
+                )
 
-    @property
-    def closed(self) -> bool:
-        return self._sock is None
+        # gh-87389: The purpose of replacing '//' with '/' is to protect against open redirect attacks possibly
+        # triggered if the path starts with '//' because http clients treat //path as an absolute URI without scheme
+        # (similar to http://path) rather than a path.
+        if path.startswith('//'):
+            path = '/' + path.lstrip('/')  # Reduce to a single /
 
-    def close(self) -> None:
-        if self._sock is not None:
-            self._sock.close()
-        self._sock = None
+        # Parse headers
 
+        try:
+            raw_gen = self.coro_read_raw_headers()
+            raw_sz = next(raw_gen)
+            while True:
+                buf = yield raw_sz
+                try:
+                    raw_sz = raw_gen.send(buf)
+                except StopIteration as e:
+                    raw_headers = e.value
+                    break
 
-########################################
-# ../../../omlish/io/fdio/kqueue.py
+            headers = self.parse_raw_headers(raw_headers)
 
+        except http.client.LineTooLong as err:
+            return ParseHttpRequestError(
+                code=http.HTTPStatus.REQUEST_HEADER_FIELDS_TOO_LARGE,
+                message=('Line too long', str(err)),
+                **result_kwargs(),
+            )
 
-KqueueFdioPoller: ta.Optional[ta.Type[FdioPoller]]
-if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
+        except http.client.HTTPException as err:
+            return ParseHttpRequestError(
+                code=http.HTTPStatus.REQUEST_HEADER_FIELDS_TOO_LARGE,
+                message=('Too many headers', str(err)),
+                **result_kwargs(),
+            )
 
-    class _KqueueFdioPoller(FdioPoller):
-        DEFAULT_MAX_EVENTS = 1000
+        # Check for connection directive
 
-        def __init__(
-                self,
-                *,
-                max_events: int = DEFAULT_MAX_EVENTS,
-        ) -> None:
-            super().__init__()
+        conn_type = headers.get('Connection', '')
+        if conn_type.lower() == 'close':
+            close_connection = True
+        elif (
+                conn_type.lower() == 'keep-alive' and
+                version >= HttpProtocolVersions.HTTP_1_1
+        ):
+            close_connection = False
 
-            self._max_events = max_events
+        # Check for expect directive
 
-            self._kqueue: ta.Optional[ta.Any] = None
+        expect = headers.get('Expect', '')
+        if (
+                expect.lower() == '100-continue' and
+                version >= HttpProtocolVersions.HTTP_1_1
+        ):
+            expects_continue = True
+        else:
+            expects_continue = False
 
-        #
+        # Return
 
-        def _get_kqueue(self) -> 'select.kqueue':
-            if (kq := self._kqueue) is not None:
-                return kq
-            kq = select.kqueue()
-            self._kqueue = kq
-            return kq
+        return ParsedHttpRequest(
+            method=method,
+            path=path,
+            expects_continue=expects_continue,
+            **result_kwargs(),
+        )
 
-        def close(self) -> None:
-            if self._kqueue is not None:
-                self._kqueue.close()
-                self._kqueue = None
+    def parse(self, read_line: ta.Callable[[int], bytes]) -> ParseHttpRequestResult:
+        return self._run_read_line_coro(self.coro_parse(), read_line)
 
-        def reopen(self) -> None:
-            for fd in self._readable:
-                self._register_readable(fd)
-            for fd in self._writable:
-                self._register_writable(fd)
 
-        #
+########################################
+# ../../../omlish/io/buffers.py
 
-        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')
+class DelimitingBuffer:
+    """
+    https://github.com/python-trio/trio/issues/796 :|
+    """
 
-        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')
+    class Error(Exception):
+        def __init__(self, buffer: 'DelimitingBuffer') -> None:
+            super().__init__(buffer)
+            self.buffer = buffer
 
-        #
+        def __repr__(self) -> str:
+            return attr_repr(self, 'buffer')
 
-        _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,
-        }
+    class ClosedError(Error):
+        pass
 
-        _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)
+    DEFAULT_DELIMITERS: bytes = b'\n'
 
-            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 __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
 
-        def poll(self, timeout: ta.Optional[float]) -> FdioPoller.PollResult:
-            kq = self._get_kqueue()
-            try:
-                kes = kq.control(None, self._max_events, timeout)
+        self._buf: ta.Optional[io.BytesIO] = io.BytesIO()
 
-            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
+    @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()
 
-########################################
-# ../../../omlish/lite/contextmanagers.py
+    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 ExitStacked:
-    _exit_stack: ta.Optional[contextlib.ExitStack] = None
+    class Incomplete(ta.NamedTuple):
+        b: bytes
 
-    def __enter__(self: ExitStackedT) -> ExitStackedT:
-        check_state(self._exit_stack is None)
-        es = self._exit_stack = contextlib.ExitStack()
-        es.__enter__()
-        return self
+    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)
 
-    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)
+        if not data:
+            self._buf = None
 
-    def _exit_contexts(self) -> None:
-        pass
+            if buf.tell():
+                yield self.Incomplete(buf.getvalue())
 
-    def _enter_context(self, cm: ta.ContextManager[T]) -> T:
-        es = check_not_none(self._exit_stack)
-        return es.enter_context(cm)
+            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])
 
-@contextlib.contextmanager
-def defer(fn: ta.Callable) -> ta.Generator[ta.Callable, None, None]:
-    try:
-        yield fn
-    finally:
-        fn()
+            i = n
 
+        if i >= l:
+            return
 
-@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)
+        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()
 
-########################################
-# ../../../omlish/lite/http/parsing.py
-# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
-# --------------------------------------------
-#
-# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
-# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
-# documentation.
-#
-# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
-# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
-# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
-# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
-# 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights Reserved" are retained in Python
-# alone or in any derivative version prepared by Licensee.
-#
-# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
-# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
-# any such work a brief summary of the changes made to Python.
-#
-# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
-# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
-# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
-# RIGHTS.
-#
-# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
-# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
-# ADVISED OF THE POSSIBILITY THEREOF.
-#
-# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
-#
-# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
-# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
-# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
-#
-# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
-# License Agreement.
+            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] = []
 
-class ParseHttpRequestResult(abc.ABC):  # noqa
-    __slots__ = (
-        'server_version',
-        'request_line',
-        'request_version',
-        'version',
-        'headers',
-        'close_connection',
-    )
+    def feed(self, d: bytes) -> None:
+        if d:
+            self._lst.append(d)
 
-    def __init__(
-            self,
-            *,
-            server_version: HttpProtocolVersion,
-            request_line: str,
-            request_version: HttpProtocolVersion,
-            version: HttpProtocolVersion,
-            headers: ta.Optional[HttpHeaders],
-            close_connection: bool,
-    ) -> None:
-        super().__init__()
+    def _chop(self, i: int, e: int) -> bytes:
+        lst = self._lst
+        d = lst[i]
 
-        self.server_version = server_version
-        self.request_line = request_line
-        self.request_version = request_version
-        self.version = version
-        self.headers = headers
-        self.close_connection = close_connection
+        o = b''.join([
+            *lst[:i],
+            d[:e],
+        ])
 
-    def __repr__(self) -> str:
-        return f'{self.__class__.__name__}({", ".join(f"{a}={getattr(self, a)!r}" for a in self.__slots__)})'
+        self._lst = [
+            *([d[e:]] if e < len(d) else []),
+            *lst[i + 1:],
+        ]
 
+        return o
 
-class EmptyParsedHttpResult(ParseHttpRequestResult):
-    pass
+    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
 
-class ParseHttpRequestError(ParseHttpRequestResult):
-    __slots__ = (
-        'code',
-        'message',
-        *ParseHttpRequestResult.__slots__,
-    )
+        c = 0
+        for i, d in enumerate(lst):
+            r = n - c
+            if (l := len(d)) >= r:
+                return self._chop(i, r)
+            c += l
 
-    def __init__(
-            self,
-            *,
-            code: http.HTTPStatus,
-            message: ta.Union[str, ta.Tuple[str, str]],
+        return None
 
-            **kwargs: ta.Any,
-    ) -> None:
-        super().__init__(**kwargs)
+    def read_until(self, delim: bytes = b'\n') -> ta.Optional[bytes]:
+        if not (lst := self._lst):
+            return None
 
-        self.code = code
-        self.message = message
+        for i, d in enumerate(lst):
+            if (p := d.find(delim)) >= 0:
+                return self._chop(i, p + len(delim))
 
+        return None
 
-class ParsedHttpRequest(ParseHttpRequestResult):
-    __slots__ = (
-        'method',
-        'path',
-        'headers',
-        'expects_continue',
-        *[a for a in ParseHttpRequestResult.__slots__ if a != 'headers'],
-    )
 
+class IncrementalWriteBuffer:
     def __init__(
             self,
+            data: bytes,
             *,
-            method: str,
-            path: str,
-            headers: HttpHeaders,
-            expects_continue: bool,
-
-            **kwargs: ta.Any,
+            write_size: int = 0x10000,
     ) -> None:
-        super().__init__(
-            headers=headers,
-            **kwargs,
-        )
-
-        self.method = method
-        self.path = path
-        self.expects_continue = expects_continue
-
-    headers: HttpHeaders
+        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
 
-class HttpRequestParser:
-    DEFAULT_SERVER_VERSION = HttpProtocolVersions.HTTP_1_0
+    @property
+    def rem(self) -> int:
+        return self._len - self._pos
 
-    # The default request version. This only affects responses up until the point where the request line is parsed, so
-    # it mainly decides what the client gets back when sending a malformed request line.
-    # Most web servers default to HTTP 0.9, i.e. don't send a status line.
-    DEFAULT_REQUEST_VERSION = HttpProtocolVersions.HTTP_0_9
+    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
 
-    DEFAULT_MAX_LINE: int = 0x10000
-    DEFAULT_MAX_HEADERS: int = 100
+        if t:
+            self._lst = [
+                *([d[n:]] if n < len(d) else []),
+                *lst[i + 1:],
+            ]
+            self._pos += t
 
-    #
+        return t
 
-    def __init__(
-            self,
-            *,
-            server_version: HttpProtocolVersion = DEFAULT_SERVER_VERSION,
 
-            max_line: int = DEFAULT_MAX_LINE,
-            max_headers: int = DEFAULT_MAX_HEADERS,
-    ) -> None:
-        super().__init__()
+########################################
+# ../../../omlish/io/fdio/handlers.py
 
-        if server_version >= HttpProtocolVersions.HTTP_2_0:
-            raise ValueError(f'Unsupported protocol version: {server_version}')
-        self._server_version = server_version
 
-        self._max_line = max_line
-        self._max_headers = max_headers
+class FdioHandler(abc.ABC):
+    @abc.abstractmethod
+    def fd(self) -> int:
+        raise NotImplementedError
 
     #
 
     @property
-    def server_version(self) -> HttpProtocolVersion:
-        return self._server_version
+    @abc.abstractmethod
+    def closed(self) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def close(self) -> None:
+        raise NotImplementedError
 
     #
 
-    def _run_read_line_coro(
-            self,
-            gen: ta.Generator[int, bytes, T],
-            read_line: ta.Callable[[int], bytes],
-    ) -> T:
-        sz = next(gen)
-        while True:
-            try:
-                sz = gen.send(read_line(sz))
-            except StopIteration as e:
-                return e.value
+    def readable(self) -> bool:
+        return False
+
+    def writable(self) -> bool:
+        return False
 
     #
 
-    def parse_request_version(self, version_str: str) -> HttpProtocolVersion:
-        if not version_str.startswith('HTTP/'):
-            raise ValueError(version_str)  # noqa
+    def on_readable(self) -> None:
+        raise TypeError
 
-        base_version_number = version_str.split('/', 1)[1]
-        version_number_parts = base_version_number.split('.')
+    def on_writable(self) -> None:
+        raise TypeError
 
-        # RFC 2145 section 3.1 says there can be only one "." and
-        #   - major and minor numbers MUST be treated as separate integers;
-        #   - HTTP/2.4 is a lower version than HTTP/2.13, which in turn is lower than HTTP/12.3;
-        #   - Leading zeros MUST be ignored by recipients.
-        if len(version_number_parts) != 2:
-            raise ValueError(version_number_parts)  # noqa
-        if any(not component.isdigit() for component in version_number_parts):
-            raise ValueError('non digit in http version')  # noqa
-        if any(len(component) > 10 for component in version_number_parts):
-            raise ValueError('unreasonable length http version')  # noqa
+    def on_error(self, exc: ta.Optional[BaseException] = None) -> None:  # noqa
+        pass
 
-        return HttpProtocolVersion(
-            int(version_number_parts[0]),
-            int(version_number_parts[1]),
-        )
 
-    #
+class SocketFdioHandler(FdioHandler, abc.ABC):
+    def __init__(
+            self,
+            addr: SocketAddress,
+            sock: socket.socket,
+    ) -> None:
+        super().__init__()
 
-    def coro_read_raw_headers(self) -> ta.Generator[int, bytes, ta.List[bytes]]:
-        raw_headers: ta.List[bytes] = []
-        while True:
-            line = yield self._max_line + 1
-            if len(line) > self._max_line:
-                raise http.client.LineTooLong('header line')
-            raw_headers.append(line)
-            if len(raw_headers) > self._max_headers:
-                raise http.client.HTTPException(f'got more than {self._max_headers} headers')
-            if line in (b'\r\n', b'\n', b''):
-                break
-        return raw_headers
+        self._addr = addr
+        self._sock: ta.Optional[socket.socket] = sock
 
-    def read_raw_headers(self, read_line: ta.Callable[[int], bytes]) -> ta.List[bytes]:
-        return self._run_read_line_coro(self.coro_read_raw_headers(), read_line)
+    def fd(self) -> int:
+        return check.not_none(self._sock).fileno()
 
-    def parse_raw_headers(self, raw_headers: ta.Sequence[bytes]) -> HttpHeaders:
-        return http.client.parse_headers(io.BytesIO(b''.join(raw_headers)))
+    @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
 
-    def coro_parse(self) -> ta.Generator[int, bytes, ParseHttpRequestResult]:
-        raw_request_line = yield self._max_line + 1
 
-        # Common result kwargs
+########################################
+# ../../../omlish/io/fdio/kqueue.py
 
-        request_line = '-'
-        request_version = self.DEFAULT_REQUEST_VERSION
 
-        # Set to min(server, request) when it gets that far, but if it fails before that the server authoritatively
-        # responds with its own version.
-        version = self._server_version
+KqueueFdioPoller: ta.Optional[ta.Type[FdioPoller]]
+if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
 
-        headers: HttpHeaders | None = None
+    class _KqueueFdioPoller(FdioPoller):
+        DEFAULT_MAX_EVENTS = 1000
 
-        close_connection = True
+        def __init__(
+                self,
+                *,
+                max_events: int = DEFAULT_MAX_EVENTS,
+        ) -> None:
+            super().__init__()
 
-        def result_kwargs():
-            return dict(
-                server_version=self._server_version,
-                request_line=request_line,
-                request_version=request_version,
-                version=version,
-                headers=headers,
-                close_connection=close_connection,
-            )
+            self._max_events = max_events
 
-        # Decode line
+            self._kqueue: ta.Optional[ta.Any] = None
 
-        if len(raw_request_line) > self._max_line:
-            return ParseHttpRequestError(
-                code=http.HTTPStatus.REQUEST_URI_TOO_LONG,
-                message='Request line too long',
-                **result_kwargs(),
-            )
+        #
 
-        if not raw_request_line:
-            return EmptyParsedHttpResult(**result_kwargs())
+        def _get_kqueue(self) -> 'select.kqueue':
+            if (kq := self._kqueue) is not None:
+                return kq
+            kq = select.kqueue()
+            self._kqueue = kq
+            return kq
 
-        request_line = raw_request_line.decode('iso-8859-1').rstrip('\r\n')
+        def close(self) -> None:
+            if self._kqueue is not None:
+                self._kqueue.close()
+                self._kqueue = None
 
-        # Split words
+        def reopen(self) -> None:
+            for fd in self._readable:
+                self._register_readable(fd)
+            for fd in self._writable:
+                self._register_writable(fd)
 
-        words = request_line.split()
-        if len(words) == 0:
-            return EmptyParsedHttpResult(**result_kwargs())
+        #
 
-        # Parse and set version
+        def _register_readable(self, fd: int) -> None:
+            self._update_registration(fd, 'read', 'add')
 
-        if len(words) >= 3:  # Enough to determine protocol version
-            version_str = words[-1]
-            try:
-                request_version = self.parse_request_version(version_str)
+        def _register_writable(self, fd: int) -> None:
+            self._update_registration(fd, 'write', 'add')
 
-            except (ValueError, IndexError):
-                return ParseHttpRequestError(
-                    code=http.HTTPStatus.BAD_REQUEST,
-                    message=f'Bad request version ({version_str!r})',
-                    **result_kwargs(),
-                )
+        def _unregister_readable(self, fd: int) -> None:
+            self._update_registration(fd, 'read', 'del')
 
-            if (
-                    request_version < HttpProtocolVersions.HTTP_0_9 or
-                    request_version >= HttpProtocolVersions.HTTP_2_0
-            ):
-                return ParseHttpRequestError(
-                    code=http.HTTPStatus.HTTP_VERSION_NOT_SUPPORTED,
-                    message=f'Invalid HTTP version ({version_str})',
-                    **result_kwargs(),
-                )
+        def _unregister_writable(self, fd: int) -> None:
+            self._update_registration(fd, 'write', 'del')
 
-            version = min([self._server_version, request_version])
+        #
 
-            if version >= HttpProtocolVersions.HTTP_1_1:
-                close_connection = False
+        _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,
+        }
 
-        # Verify word count
+        _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,
+        }
 
-        if not 2 <= len(words) <= 3:
-            return ParseHttpRequestError(
-                code=http.HTTPStatus.BAD_REQUEST,
-                message=f'Bad request syntax ({request_line!r})',
-                **result_kwargs(),
+        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)
 
-        # Parse method and path
+            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
 
-        method, path = words[:2]
-        if len(words) == 2:
-            close_connection = True
-            if method != 'GET':
-                return ParseHttpRequestError(
-                    code=http.HTTPStatus.BAD_REQUEST,
-                    message=f'Bad HTTP/0.9 request type ({method!r})',
-                    **result_kwargs(),
-                )
+        #
 
-        # gh-87389: The purpose of replacing '//' with '/' is to protect against open redirect attacks possibly
-        # triggered if the path starts with '//' because http clients treat //path as an absolute URI without scheme
-        # (similar to http://path) rather than a path.
-        if path.startswith('//'):
-            path = '/' + path.lstrip('/')  # Reduce to a single /
+        def poll(self, timeout: ta.Optional[float]) -> FdioPoller.PollResult:
+            kq = self._get_kqueue()
+            try:
+                kes = kq.control(None, self._max_events, timeout)
 
-        # Parse headers
+            except OSError as exc:
+                if exc.errno == errno.EINTR:
+                    return FdioPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
+                else:
+                    raise
 
-        try:
-            raw_gen = self.coro_read_raw_headers()
-            raw_sz = next(raw_gen)
-            while True:
-                buf = yield raw_sz
-                try:
-                    raw_sz = raw_gen.send(buf)
-                except StopIteration as e:
-                    raw_headers = e.value
-                    break
+            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)
 
-            headers = self.parse_raw_headers(raw_headers)
+            return FdioPoller.PollResult(r, w)
 
-        except http.client.LineTooLong as err:
-            return ParseHttpRequestError(
-                code=http.HTTPStatus.REQUEST_HEADER_FIELDS_TOO_LARGE,
-                message=('Line too long', str(err)),
-                **result_kwargs(),
-            )
+    KqueueFdioPoller = _KqueueFdioPoller
+else:
+    KqueueFdioPoller = None
 
-        except http.client.HTTPException as err:
-            return ParseHttpRequestError(
-                code=http.HTTPStatus.REQUEST_HEADER_FIELDS_TOO_LARGE,
-                message=('Too many headers', str(err)),
-                **result_kwargs(),
-            )
 
-        # Check for connection directive
+########################################
+# ../../../omlish/lite/contextmanagers.py
 
-        conn_type = headers.get('Connection', '')
-        if conn_type.lower() == 'close':
-            close_connection = True
-        elif (
-                conn_type.lower() == 'keep-alive' and
-                version >= HttpProtocolVersions.HTTP_1_1
-        ):
-            close_connection = False
 
-        # 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
+class ExitStacked:
+    _exit_stack: ta.Optional[contextlib.ExitStack] = None
 
-        return ParsedHttpRequest(
-            method=method,
-            path=path,
-            expects_continue=expects_continue,
-            **result_kwargs(),
-        )
+    def __enter__(self: ExitStackedT) -> ExitStackedT:
+        check.state(self._exit_stack is None)
+        es = self._exit_stack = contextlib.ExitStack()
+        es.__enter__()
+        return self
 
-    def parse(self, read_line: ta.Callable[[int], bytes]) -> ParseHttpRequestResult:
-        return self._run_read_line_coro(self.coro_parse(), read_line)
+    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)
 
 
 ########################################
@@ -3577,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:
@@ -3591,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:
@@ -3613,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()
@@ -3633,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:
@@ -3830,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] = []
@@ -3891,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()}
 
@@ -3923,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
 
@@ -4038,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
@@ -4095,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:
@@ -4794,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)
@@ -4956,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)
 
 
@@ -5270,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:
@@ -5280,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()
@@ -5411,7 +5767,7 @@ class SupervisorSetup(abc.ABC):
 
 
 ########################################
-# ../../../omlish/lite/http/handlers.py
+# ../../../omlish/http/handlers.py
 
 
 @dc.dataclass(frozen=True)
@@ -5586,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
 # --------------------------------------------
 #
@@ -5966,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)
@@ -5995,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
@@ -6014,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
 
@@ -6034,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
 
@@ -6042,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,
@@ -6340,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)
 
@@ -6364,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
@@ -6397,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
 
@@ -6418,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:
@@ -6434,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
@@ -6832,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
@@ -7385,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)
@@ -7624,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")
 
@@ -8183,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,
@@ -8287,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:
@@ -8410,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()