omlish 0.0.0.dev128__py3-none-any.whl → 0.0.0.dev130__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev128'
-__revision__ = '032185683e360475ef780c77bea913c965cebcc6'
+__version__ = '0.0.0.dev130'
+__revision__ = '04fd1bb83aa7700c60be8dc97b6530ddf15b6dd7'
 
 
 #

omlish/lite/check.py

@@ -3,6 +3,7 @@ import typing as ta
 
 
 T = ta.TypeVar('T')
+SizedT = ta.TypeVar('SizedT', bound=ta.Sized)
 
 
 def check_isinstance(v: ta.Any, spec: ta.Union[ta.Type[T], tuple]) -> T:
@@ -57,6 +58,42 @@ def check_not_equal(l: T, r: T) -> T:
     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
+
+
+def check_empty(v: SizedT) -> SizedT:
+    if len(v):
+        raise ValueError(v)
+    return v
+
+
+def check_non_empty(v: SizedT) -> SizedT:
+    if not len(v):
+        raise ValueError(v)
+    return v

omlish/lite/fdio/corohttp.py

@@ -0,0 +1,135 @@
+import socket
+import typing as ta
+
+from ..check import check_isinstance
+from ..check import check_none
+from ..check import check_not_none
+from ..check import check_state
+from ..http.coroserver import CoroHttpServer
+from ..http.handlers import HttpHandler
+from ..io import IncrementalWriteBuffer
+from ..io import ReadableListBuffer
+from ..socket import SocketAddress
+from .handlers import SocketFdIoHandler
+
+
+class CoroHttpServerConnectionFdIoHandler(SocketFdIoHandler):
+    def __init__(
+            self,
+            addr: SocketAddress,
+            sock: socket.socket,
+            handler: HttpHandler,
+            *,
+            read_size: int = 0x10000,
+            write_size: int = 0x10000,
+    ) -> None:
+        check_state(not sock.getblocking())
+
+        super().__init__(addr, sock)
+
+        self._handler = handler
+        self._read_size = read_size
+        self._write_size = write_size
+
+        self._read_buf = ReadableListBuffer()
+        self._write_buf: IncrementalWriteBuffer | None = None
+
+        self._coro_srv = CoroHttpServer(
+            addr,
+            handler=self._handler,
+        )
+        self._srv_coro: ta.Optional[ta.Generator[CoroHttpServer.Io, ta.Optional[bytes], None]] = self._coro_srv.coro_handle()  # noqa
+
+        self._cur_io: CoroHttpServer.Io | None = None
+        self._next_io()
+
+    #
+
+    def _next_io(self) -> None:  # noqa
+        coro = check_not_none(self._srv_coro)
+
+        d: bytes | None = None
+        o = self._cur_io
+        while True:
+            if o is None:
+                try:
+                    if d is not None:
+                        o = coro.send(d)
+                        d = None
+                    else:
+                        o = next(coro)
+                except StopIteration:
+                    self.close()
+                    o = None
+                    break
+
+            if isinstance(o, CoroHttpServer.AnyLogIo):
+                print(o)
+                o = None
+
+            elif isinstance(o, CoroHttpServer.ReadIo):
+                if (d := self._read_buf.read(o.sz)) is None:
+                    break
+                o = None
+
+            elif isinstance(o, CoroHttpServer.ReadLineIo):
+                if (d := self._read_buf.read_until(b'\n')) is None:
+                    break
+                o = None
+
+            elif isinstance(o, CoroHttpServer.WriteIo):
+                check_none(self._write_buf)
+                self._write_buf = IncrementalWriteBuffer(o.data, write_size=self._write_size)
+                break
+
+            else:
+                raise TypeError(o)
+
+        self._cur_io = o
+
+    #
+
+    def readable(self) -> bool:
+        return True
+
+    def writable(self) -> bool:
+        return self._write_buf is not None
+
+    #
+
+    def on_readable(self) -> None:
+        try:
+            buf = check_not_none(self._sock).recv(self._read_size)
+        except BlockingIOError:
+            return
+        except ConnectionResetError:
+            self.close()
+            return
+        if not buf:
+            self.close()
+            return
+
+        self._read_buf.feed(buf)
+
+        if isinstance(self._cur_io, CoroHttpServer.AnyReadIo):
+            self._next_io()
+
+    def on_writable(self) -> None:
+        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)
+                except ConnectionResetError:
+                    self.close()
+                    return 0
+                except BlockingIOError:
+                    return 0
+            if not wb.write(send):
+                break
+
+        if wb.rem < 1:
+            self._write_buf = None
+            self._cur_io = None
+            self._next_io()

omlish/lite/fdio/handlers.py

@@ -0,0 +1,67 @@
+# ruff: noqa: UP006 UP007
+import abc
+import socket
+import typing as ta
+
+from ..check import check_not_none
+from ..socket import SocketAddress
+
+
+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

@@ -0,0 +1,102 @@
+# ruff: noqa: UP006 UP007
+import errno
+import select
+import sys
+import typing as ta
+
+from .pollers import FdIoPoller
+
+
+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._control(fd, select.KQ_FILTER_READ, select.KQ_EV_ADD)
+
+        def _register_writable(self, fd: int) -> None:
+            self._control(fd, select.KQ_FILTER_WRITE, select.KQ_EV_ADD)
+
+        def _unregister_readable(self, fd: int) -> None:
+            self._control(fd, select.KQ_FILTER_READ, select.KQ_EV_DELETE)
+
+        def _unregister_writable(self, fd: int) -> None:
+            self._control(fd, select.KQ_FILTER_WRITE, select.KQ_EV_DELETE)
+
+        def _control(self, fd: int, filter: int, flags: int) -> None:  # noqa
+            ke = select.kevent(fd, filter=filter, flags=flags)
+            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
+                    pass
+                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/fdio/manager.py

@@ -0,0 +1,48 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from .handlers import FdIoHandler
+from .pollers import FdIoPoller
+
+
+class FdIoManager:
+    def __init__(
+            self,
+            poller: FdIoPoller,
+    ) -> None:
+        super().__init__()
+
+        self._poller = poller
+
+        self._handlers: ta.Dict[int, FdIoHandler] = {}  # Preserves insertion order
+
+    def register(self, h: FdIoHandler) -> None:
+        if (hid := id(h)) in self._handlers:
+            raise KeyError(h)
+        self._handlers[hid] = h
+
+    def unregister(self, h: FdIoHandler) -> None:
+        del self._handlers[id(h)]
+
+    def poll(self, *, timeout: float = 1.) -> None:
+        hs = list(self._handlers.values())
+        rd = {h.fd(): h for h in hs if h.readable()}
+        wd = {h.fd(): h for h in hs if h.writable()}
+
+        self._poller.update(set(rd), set(wd))
+
+        pr = self._poller.poll(timeout)
+
+        for f in pr.r:
+            if not (h := rd[f]).closed:
+                h.on_readable()
+        for f in pr.w:
+            if not (h := wd[f]).closed:
+                h.on_writable()
+
+        hs = list(self._handlers.values())
+        nh = {}
+        for h in hs:
+            if not h.closed:
+                nh[id(h)] = h
+        self._handlers = nh

omlish/lite/fdio/pollers.py

@@ -0,0 +1,212 @@
+# ruff: noqa: UP006 UP007
+import abc
+import dataclasses as dc
+import errno
+import select
+import typing as ta
+
+
+##
+
+
+class FdIoPoller(abc.ABC):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._readable: ta.Set[int] = set()
+        self._writable: ta.Set[int] = set()
+
+    #
+
+    def close(self) -> None:  # noqa
+        pass
+
+    def reopen(self) -> None:  # noqa
+        pass
+
+    #
+
+    @property
+    @ta.final
+    def readable(self) -> ta.AbstractSet[int]:
+        return self._readable
+
+    @property
+    @ta.final
+    def writable(self) -> ta.AbstractSet[int]:
+        return self._writable
+
+    #
+
+    @ta.final
+    def register_readable(self, fd: int) -> bool:
+        if fd in self._readable:
+            return False
+        self._readable.add(fd)
+        self._register_readable(fd)
+        return True
+
+    @ta.final
+    def register_writable(self, fd: int) -> bool:
+        if fd in self._writable:
+            return False
+        self._writable.add(fd)
+        self._register_writable(fd)
+        return True
+
+    @ta.final
+    def unregister_readable(self, fd: int) -> bool:
+        if fd not in self._readable:
+            return False
+        self._readable.discard(fd)
+        self._unregister_readable(fd)
+        return True
+
+    @ta.final
+    def unregister_writable(self, fd: int) -> bool:
+        if fd not in self._writable:
+            return False
+        self._writable.discard(fd)
+        self._unregister_writable(fd)
+        return True
+
+    #
+
+    def _register_readable(self, fd: int) -> None:  # noqa
+        pass
+
+    def _register_writable(self, fd: int) -> None:  # noqa
+        pass
+
+    def _unregister_readable(self, fd: int) -> None:  # noqa
+        pass
+
+    def _unregister_writable(self, fd: int) -> None:  # noqa
+        pass
+
+    #
+
+    def update(
+            self,
+            r: ta.AbstractSet[int],
+            w: ta.AbstractSet[int],
+    ) -> None:
+        for f in r - self._readable:
+            self.register_readable(f)
+        for f in w - self._writable:
+            self.register_writable(f)
+        for f in self._readable - r:
+            self.unregister_readable(f)
+        for f in self._writable - w:
+            self.unregister_writable(f)
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class PollResult:
+        r: ta.Sequence[int] = ()
+        w: ta.Sequence[int] = ()
+
+        inv: ta.Sequence[int] = ()
+
+        msg: ta.Optional[str] = None
+        exc: ta.Optional[BaseException] = None
+
+    @abc.abstractmethod
+    def poll(self, timeout: ta.Optional[float]) -> PollResult:
+        raise NotImplementedError
+
+
+##
+
+
+class SelectFdIoPoller(FdIoPoller):
+    def poll(self, timeout: ta.Optional[float]) -> FdIoPoller.PollResult:
+        try:
+            r, w, x = select.select(
+                self._readable,
+                self._writable,
+                [],
+                timeout,
+            )
+
+        except OSError as exc:
+            if exc.errno == errno.EINTR:
+                return FdIoPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
+            elif exc.errno == errno.EBADF:
+                return FdIoPoller.PollResult(msg='EBADF encountered in poll', exc=exc)
+            else:
+                raise
+
+        return FdIoPoller.PollResult(r, w)
+
+
+##
+
+
+PollFdIoPoller: ta.Optional[ta.Type[FdIoPoller]]
+if hasattr(select, 'poll'):
+
+    class _PollFdIoPoller(FdIoPoller):
+        def __init__(self) -> None:
+            super().__init__()
+
+            self._poller = select.poll()
+
+        #
+
+        _READ = select.POLLIN | select.POLLPRI | select.POLLHUP
+        _WRITE = select.POLLOUT
+
+        def _register_readable(self, fd: int) -> None:
+            self._update_registration(fd)
+
+        def _register_writable(self, fd: int) -> None:
+            self._update_registration(fd)
+
+        def _unregister_readable(self, fd: int) -> None:
+            self._update_registration(fd)
+
+        def _unregister_writable(self, fd: int) -> None:
+            self._update_registration(fd)
+
+        def _update_registration(self, fd: int) -> None:
+            r = fd in self._readable
+            w = fd in self._writable
+            if r or w:
+                self._poller.register(fd, (self._READ if r else 0) | (self._WRITE if w else 0))
+            else:
+                self._poller.unregister(fd)
+
+        #
+
+        def poll(self, timeout: ta.Optional[float]) -> FdIoPoller.PollResult:
+            polled: ta.List[ta.Tuple[int, int]]
+            try:
+                polled = self._poller.poll(timeout * 1000 if timeout is not None else None)
+
+            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] = []
+            inv: ta.List[int] = []
+            for fd, mask in polled:
+                if mask & select.POLLNVAL:
+                    self._poller.unregister(fd)
+                    self._readable.discard(fd)
+                    self._writable.discard(fd)
+                    inv.append(fd)
+                    continue
+                if mask & self._READ:
+                    r.append(fd)
+                if mask & self._WRITE:
+                    w.append(fd)
+            return FdIoPoller.PollResult(r, w, inv=inv)
+
+    PollFdIoPoller = _PollFdIoPoller
+else:
+    PollFdIoPoller = None

omlish/lite/inject.py

@@ -1,5 +1,6 @@
 # ruff: noqa: UP006 UP007
 import abc
+import contextlib
 import dataclasses as dc
 import functools
 import inspect
@@ -7,7 +8,9 @@ import types
 import typing as ta
 import weakref
 
+from .check import check_in
 from .check import check_isinstance
+from .check import check_not_in
 from .check import check_not_isinstance
 from .check import check_not_none
 from .maybes import Maybe
@@ -124,7 +127,7 @@ class InjectorError(Exception):
     pass
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass()
 class InjectorKeyError(InjectorError):
     key: InjectorKey
 
@@ -132,16 +135,18 @@ class InjectorKeyError(InjectorError):
     name: ta.Optional[str] = None
 
 
-@dc.dataclass(frozen=True)
 class UnboundInjectorKeyError(InjectorKeyError):
     pass
 
 
-@dc.dataclass(frozen=True)
 class DuplicateInjectorKeyError(InjectorKeyError):
     pass
 
 
+class CyclicDependencyInjectorKeyError(InjectorKeyError):
+    pass
+
+
 ###
 # keys
 
@@ -315,7 +320,11 @@ def build_injector_provider_map(bs: InjectorBindings) -> ta.Mapping[InjectorKey,
 
     for b in bs.bindings():
         if b.key.array:
-            am.setdefault(b.key, []).append(b.provider)
+            al = am.setdefault(b.key, [])
+            if isinstance(b.provider, ArrayInjectorProvider):
+                al.extend(b.provider.ps)
+            else:
+                al.append(b.provider)
         else:
             if b.key in pm:
                 raise KeyError(b.key)
@@ -463,6 +472,14 @@ def build_injection_kwargs_target(
 _INJECTOR_INJECTOR_KEY: InjectorKey[Injector] = InjectorKey(Injector)
 
 
+@dc.dataclass(frozen=True)
+class _InjectorEager:
+    key: InjectorKey
+
+
+_INJECTOR_EAGER_ARRAY_KEY: InjectorKey[_InjectorEager] = InjectorKey(_InjectorEager, array=True)
+
+
 class _Injector(Injector):
     def __init__(self, bs: InjectorBindings, p: ta.Optional[Injector] = None) -> None:
         super().__init__()
@@ -475,22 +492,69 @@ class _Injector(Injector):
         if _INJECTOR_INJECTOR_KEY in self._pfm:
             raise DuplicateInjectorKeyError(_INJECTOR_INJECTOR_KEY)
 
+        self.__cur_req: ta.Optional[_Injector._Request] = None
+
+        if _INJECTOR_EAGER_ARRAY_KEY in self._pfm:
+            for e in self.provide(_INJECTOR_EAGER_ARRAY_KEY):
+                self.provide(e.key)
+
+    class _Request:
+        def __init__(self, injector: '_Injector') -> None:
+            super().__init__()
+            self._injector = injector
+            self._provisions: ta.Dict[InjectorKey, Maybe] = {}
+            self._seen_keys: ta.Set[InjectorKey] = set()
+
+        def handle_key(self, key: InjectorKey) -> Maybe[Maybe]:
+            try:
+                return Maybe.just(self._provisions[key])
+            except KeyError:
+                pass
+            if key in self._seen_keys:
+                raise CyclicDependencyInjectorKeyError(key)
+            self._seen_keys.add(key)
+            return Maybe.empty()
+
+        def handle_provision(self, key: InjectorKey, mv: Maybe) -> Maybe:
+            check_in(key, self._seen_keys)
+            check_not_in(key, self._provisions)
+            self._provisions[key] = mv
+            return mv
+
+    @contextlib.contextmanager
+    def _current_request(self) -> ta.Generator[_Request, None, None]:
+        if (cr := self.__cur_req) is not None:
+            yield cr
+            return
+
+        cr = self._Request(self)
+        try:
+            self.__cur_req = cr
+            yield cr
+        finally:
+            self.__cur_req = None
+
     def try_provide(self, key: ta.Any) -> Maybe[ta.Any]:
         key = as_injector_key(key)
 
-        if key == _INJECTOR_INJECTOR_KEY:
-            return Maybe.just(self)
+        cr: _Injector._Request
+        with self._current_request() as cr:
+            if (rv := cr.handle_key(key)).present:
+                return rv.must()
 
-        fn = self._pfm.get(key)
-        if fn is not None:
-            return Maybe.just(fn(self))
+            if key == _INJECTOR_INJECTOR_KEY:
+                return cr.handle_provision(key, Maybe.just(self))
 
-        if self._p is not None:
-            pv = self._p.try_provide(key)
-            if pv is not None:
-                return Maybe.empty()
+            fn = self._pfm.get(key)
+            if fn is not None:
+                return cr.handle_provision(key, Maybe.just(fn(self)))
 
-        return Maybe.empty()
+            if self._p is not None:
+                pv = self._p.try_provide(key)
+                if pv is not None:
+                    return cr.handle_provision(key, Maybe.empty())
+
+            return cr.handle_provision(key, Maybe.empty())
 
     def provide(self, key: ta.Any) -> ta.Any:
         v = self.try_provide(key)
@@ -591,6 +655,8 @@ class InjectorBinder:
             to_key: ta.Any = None,
 
             singleton: bool = False,
+
+            eager: bool = False,
     ) -> InjectorBindingOrBindings:
         if obj is None or obj is inspect.Parameter.empty:
             raise TypeError(obj)
@@ -664,13 +730,21 @@ class InjectorBinder:
         if singleton:
             provider = SingletonInjectorProvider(provider)
 
+        binding = InjectorBinding(key, provider)
+
         ##
 
-        binding = InjectorBinding(key, provider)
+        extras: ta.List[InjectorBinding] = []
+
+        if eager:
+            extras.append(bind_injector_eager_key(key))
 
         ##
 
-        return binding
+        if extras:
+            return as_injector_bindings(binding, *extras)
+        else:
+            return binding
 
 
 ###
@@ -693,6 +767,26 @@ def make_injector_factory(
     return outer
 
 
+def bind_injector_array(
+        obj: ta.Any = None,
+        *,
+        tag: ta.Any = None,
+) -> InjectorBindingOrBindings:
+    key = as_injector_key(obj)
+    if tag is not None:
+        if key.tag is not None:
+            raise ValueError('Must not specify multiple tags')
+        key = dc.replace(key, tag=tag)
+
+    if key.array:
+        raise ValueError('Key must not be array')
+
+    return InjectorBinding(
+        dc.replace(key, array=True),
+        ArrayInjectorProvider([]),
+    )
+
+
 def make_injector_array_type(
         ele: ta.Union[InjectorKey, InjectorKeyCls],
         cls: U,
@@ -714,6 +808,10 @@ def make_injector_array_type(
     return inner
 
 
+def bind_injector_eager_key(key: ta.Any) -> InjectorBinding:
+    return InjectorBinding(_INJECTOR_EAGER_ARRAY_KEY, ConstInjectorProvider(_InjectorEager(as_injector_key(key))))
+
+
 ##
 
 
@@ -768,6 +866,8 @@ class Injection:
             to_key: ta.Any = None,
 
             singleton: bool = False,
+
+            eager: bool = False,
     ) -> InjectorBindingOrBindings:
         return InjectorBinder.bind(
             obj,
@@ -782,6 +882,8 @@ class Injection:
             to_key=to_key,
 
             singleton=singleton,
+
+            eager=eager,
         )
 
     # helpers
@@ -795,6 +897,15 @@ class Injection:
     ) -> InjectorBindingOrBindings:
         return cls.bind(make_injector_factory(fn, cls_, ann))
 
+    @classmethod
+    def bind_array(
+            cls,
+            obj: ta.Any = None,
+            *,
+            tag: ta.Any = None,
+    ) -> InjectorBindingOrBindings:
+        return bind_injector_array(obj, tag=tag)
+
     @classmethod
     def bind_array_type(
             cls,

omlish/lite/io.py

@@ -3,6 +3,7 @@ import io
 import typing as ta
 
 from .check import check_isinstance
+from .check import check_non_empty
 from .check import check_not_none
 from .strings import attr_repr
 
@@ -126,3 +127,100 @@ class DelimitingBuffer:
             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-0.0.0.dev128.dist-info → omlish-0.0.0.dev130.dist-info}/METADATA

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

{omlish-0.0.0.dev128.dist-info → omlish-0.0.0.dev130.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=CxGnj-UiRPlZgmgWoovDWrOnqpSEmBy_kqA7cdfSA3w,1431
-omlish/__about__.py,sha256=9lZ5XVEOu3HBl1htFmArMTPb8o6NmnVqnhMIpjv5mhc,3379
+omlish/__about__.py,sha256=PvbOOiIxO1ksGKnYclis2IJG4h8EtRZ-Qy1gtTkvgI4,3379
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/argparse.py,sha256=cqKGAqcxuxv_s62z0gq29L9KAvg_3-_rFvXKjVpRJjo,8126
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
@@ -300,11 +300,11 @@ omlish/lifecycles/states.py,sha256=zqMOU2ZU-MDNnWuwauM3_anIAiXM8LoBDElDEraptFg,1
 omlish/lifecycles/transitions.py,sha256=qQtFby-h4VzbvgaUqT2NnbNumlcOx9FVVADP9t83xj4,1939
 omlish/lite/__init__.py,sha256=Y3l4WY4JRi2uLG6kgbGp93fuGfkxkKwZDvhsa0Rwgtk,15
 omlish/lite/cached.py,sha256=Fs-ljXVJmHBjAaHc-JuJXMEV4MNSX5c_KHZIM3AEaIw,694
-omlish/lite/check.py,sha256=1mo1GK78Ro5-IC_jUrmNabmt--hz_9v1y5h28K2cqUY,1102
+omlish/lite/check.py,sha256=pQC412ffe_Zh7eHa4C1UYn6fA71Ls1vpVM0ZIOroPAY,1765
 omlish/lite/contextmanagers.py,sha256=_jfNdpYvxkbKwyjQLbK-o69W89GoEuUfl_NrCosE9lU,1308
 omlish/lite/docker.py,sha256=3IVZZtIm7-UdB2SwArmN_MosTva1_KifyYp3YWjODbE,337
-omlish/lite/inject.py,sha256=NTZl6VXhYDILPMm1zBx-CbqF7Vkpxv9w1JVKqmmUp5w,20407
-omlish/lite/io.py,sha256=lcpI1cS_Kn90tvYMg8ZWkSlYloS4RFqXCk-rKyclhdg,3148
+omlish/lite/inject.py,sha256=aRRmFb6azTKF208ogYwVCEopNZx7496Ta1GZmL_IKBA,23716
+omlish/lite/io.py,sha256=3ECgUXdRnXyS6pGTSoVr6oB4moI38EpWxTq08zaTM-U,5339
 omlish/lite/journald.py,sha256=f5Y2Q6-6O3iK_7MoGiwZwoQEOcP7LfkxxQNUR9tMjJM,3882
 omlish/lite/json.py,sha256=7-02Ny4fq-6YAu5ynvqoijhuYXWpLmfCI19GUeZnb1c,740
 omlish/lite/logs.py,sha256=1pcGu0ekhVCcLUckLSP16VccnAoprjtl5Vkdfm7y1Wg,6184
@@ -319,6 +319,12 @@ omlish/lite/socketserver.py,sha256=Esy9dAo9dPnNavNx5hW52YZi5hv504a8XQUudMrPs2A,1
 omlish/lite/strings.py,sha256=QURcE4-1pKVW8eT_5VCJpXaHDWR2dW2pYOChTJnZDiQ,1504
 omlish/lite/subprocesses.py,sha256=_YwUpvfaC2pV5TMC9-Ivuw1Ao-YxteD3a1NQwGERft4,3380
 omlish/lite/typing.py,sha256=U3-JaEnkDSYxK4tsu_MzUn3RP6qALBe5FXQXpD-licE,1090
+omlish/lite/fdio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/lite/fdio/corohttp.py,sha256=5kzuM1cssA2D7rfknHFxylpjBNfA5tQSPkIRY2Ilapo,3825
+omlish/lite/fdio/handlers.py,sha256=ukUiwF8-UCr4mzTTfOaTipC0k3k7THiHnohVdYfH69o,1341
+omlish/lite/fdio/kqueue.py,sha256=4SvSMwNdkXpQbkMhyLqiZIjFGPUGSgD22yr9mpxT2fk,3153
+omlish/lite/fdio/manager.py,sha256=-gMVzk4B1YTZS-d2TdM12woUme37pcNVUxNTiLe91lA,1250
+omlish/lite/fdio/pollers.py,sha256=zSFi19SGQ2WKtMO_ONiqaJ_mbQmhrK59zgH5CqMYcu8,5434
 omlish/lite/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/lite/http/coroserver.py,sha256=aBaYjP80yQHQxPxwi7PTYHub-fdRDKsMnB-tM8lBc2o,18095
 omlish/lite/http/handlers.py,sha256=Yu0P3nqz-frklwCM2PbiWvoJNE-NqeTFLBvpNpqcdtA,753
@@ -482,9 +488,9 @@ omlish/text/glyphsplit.py,sha256=Ug-dPRO7x-OrNNr8g1y6DotSZ2KH0S-VcOmUobwa4B0,329
 omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev128.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev128.dist-info/METADATA,sha256=lgogkc74fPcQs_ct8BCBruFkyE5sDH9QPyrnz90DRQE,4173
-omlish-0.0.0.dev128.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-omlish-0.0.0.dev128.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev128.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev128.dist-info/RECORD,,
+omlish-0.0.0.dev130.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev130.dist-info/METADATA,sha256=1UOC8pu3kIMCWi1vb1n83h4VZjHWkmZpcmwpEzxERlk,4173
+omlish-0.0.0.dev130.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+omlish-0.0.0.dev130.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev130.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev130.dist-info/RECORD,,