omlish 0.0.0.dev212__py3-none-any.whl → 0.0.0.dev213__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev212'
-__revision__ = 'bd253a140a7f57dc37a30f1a4f0b227123281988'
+__version__ = '0.0.0.dev213'
+__revision__ = '03c9d6a7f92cec54535af989bf531b8598a896c0'
 
 
 #

omlish/asyncs/ioproxy/__init__.py

@@ -0,0 +1 @@
+# @omlish-lite

omlish/asyncs/ioproxy/io.py

@@ -0,0 +1,242 @@
+# ruff: noqa: UP006 UP007
+import io
+import typing as ta
+
+from .proxy import AsyncIoProxy
+from .proxy import _register_async_io_proxy_cls
+
+
+SelfT = ta.TypeVar('SelfT')
+
+
+##
+
+
+@_register_async_io_proxy_cls
+class IOBaseAsyncIoProxy(AsyncIoProxy, proxied_cls=io.IOBase):
+    # https://github.com/python/cpython/blob/e65a1eb93ae35f9fbab1508606e3fbc89123629f/Lib/_pyio.py#L305
+
+    ##
+    # Positioning
+
+    async def seek(self, pos, whence=0):
+        raise TypeError
+
+    async def tell(self):
+        raise TypeError
+
+    async def truncate(self, pos=None):
+        raise TypeError
+
+    ##
+    # Flush and close
+
+    async def flush(self):
+        raise TypeError
+
+    async def close(self):
+        raise TypeError
+
+    ##
+    # Inquiries
+
+    def seekable(self):
+        raise TypeError
+
+    def readable(self):
+        raise TypeError
+
+    def writable(self):
+        raise TypeError
+
+    @property
+    def closed(self):
+        raise TypeError
+
+    ##
+    # Context manager
+
+    async def __aenter__(self: SelfT) -> SelfT:
+        raise TypeError
+
+    async def __aexit__(self, exc_type, exc_value, exc_tb):
+        raise TypeError
+
+    ##
+    # Lower-level APIs
+
+    def fileno(self):
+        raise TypeError
+
+    def isatty(self):
+        raise TypeError
+
+    ##
+    # Readline[s] and writelines
+
+    async def readline(self, size=-1):
+        raise TypeError
+
+    # def __iter__(self):
+    #     raise TypeError
+
+    # def __next__(self):
+    #     raise TypeError
+
+    async def readlines(self, hint=None):
+        raise TypeError
+
+    async def writelines(self, lines):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class RawIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.RawIOBase):
+    async def read(self, size=-1):
+        raise TypeError
+
+    async def readall(self):
+        raise TypeError
+
+    async def readinto(self, b):
+        raise TypeError
+
+    async def write(self, b):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class BufferedIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.BufferedIOBase):
+    async def read(self, size=-1):
+        raise TypeError
+
+    async def read1(self, size=-1):
+        raise TypeError
+
+    async def readinto(self, b):
+        raise TypeError
+
+    async def readinto1(self, b):
+        raise TypeError
+
+    async def write(self, b):
+        raise TypeError
+
+    async def detach(self):
+        raise TypeError
+
+
+class BufferedIOMixinAsyncIoProxy(BufferedIOBaseAsyncIoProxy):
+    @property
+    def raw(self):
+        raise TypeError
+
+    @property
+    def name(self):
+        raise TypeError
+
+    @property
+    def mode(self):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class BytesIOAsyncIoProxy(BufferedIOBaseAsyncIoProxy, proxied_cls=io.BytesIO):
+    async def getvalue(self):
+        raise TypeError
+
+    async def getbuffer(self):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class BufferedReaderAsyncIoProxy(BufferedIOMixinAsyncIoProxy, proxied_cls=io.BufferedReader):
+    async def peek(self, size=0):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class BufferedWriterAsyncIoProxy(BufferedIOMixinAsyncIoProxy, proxied_cls=io.BufferedWriter):
+    pass
+
+
+@_register_async_io_proxy_cls
+class BufferedRWPairAsyncIoProxy(BufferedIOBaseAsyncIoProxy, proxied_cls=io.BufferedRWPair):
+    async def peek(self, size=0):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class BufferedRandomAsyncIoProxy(BufferedWriterAsyncIoProxy, BufferedReaderAsyncIoProxy, proxied_cls=io.BufferedRandom):
+    pass
+
+
+@_register_async_io_proxy_cls
+class FileIOAsyncIoProxy(RawIOBaseAsyncIoProxy, proxied_cls=io.FileIO):
+    @property
+    def closefd(self):
+        raise TypeError
+
+    @property
+    def mode(self):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class TextIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.TextIOBase):
+    async def read(self, size=-1):
+        raise TypeError
+
+    async def write(self, s):
+        raise TypeError
+
+    async def detach(self):
+        raise TypeError
+
+    @property
+    def encoding(self):
+        raise TypeError
+
+    @property
+    def newlines(self):
+        raise TypeError
+
+    @property
+    def errors(self):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class TextIOWrapperAsyncIoProxy(TextIOBaseAsyncIoProxy, proxied_cls=io.TextIOWrapper):
+    @property
+    def line_buffering(self):
+        raise TypeError
+
+    @property
+    def write_through(self):
+        raise TypeError
+
+    @property
+    def buffer(self):
+        raise TypeError
+
+    async def reconfigure(
+            self,
+            *,
+            encoding=None,
+            errors=None,
+            newline=Ellipsis,
+            line_buffering=None,
+            write_through=None,
+    ):
+        raise TypeError
+
+    @property
+    def name(self):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class StringIOAsyncIoProxy(TextIOWrapperAsyncIoProxy, proxied_cls=io.StringIO):
+    async def getvalue(self):
+        raise TypeError

omlish/asyncs/ioproxy/proxier.py

@@ -0,0 +1,154 @@
+# ruff: noqa: UP006 UP007
+import io
+import types
+import typing as ta
+
+from .io import BufferedIOBaseAsyncIoProxy
+from .io import BufferedRandomAsyncIoProxy
+from .io import BufferedReaderAsyncIoProxy
+from .io import BufferedRWPairAsyncIoProxy
+from .io import BufferedWriterAsyncIoProxy
+from .io import BytesIOAsyncIoProxy
+from .io import FileIOAsyncIoProxy
+from .io import IOBaseAsyncIoProxy
+from .io import RawIOBaseAsyncIoProxy
+from .io import StringIOAsyncIoProxy
+from .io import TextIOBaseAsyncIoProxy
+from .io import TextIOWrapperAsyncIoProxy
+from .proxy import AsyncIoProxyRunner
+from .proxy import AsyncIoProxyTarget
+from .proxy import async_io_proxy_cls_for
+from .proxy import async_io_proxy_fn
+from .typing import TypingBinaryIOAsyncIoProxy
+from .typing import TypingIOAsyncIoProxy
+from .typing import TypingTextIOAsyncIoProxy
+
+
+##
+
+
+@ta.final
+class AsyncIoProxier:
+    def __init__(self, runner_policy: ta.Callable[[ta.Any], AsyncIoProxyRunner]) -> None:
+        super().__init__()
+
+        self._runner_policy = runner_policy
+
+    def get_runner(self, obj: ta.Any) -> AsyncIoProxyRunner:
+        return self._runner_policy(obj)
+
+    ##
+
+    def target_obj(self, obj: ta.Any) -> AsyncIoProxyTarget:
+        runner = self.get_runner(obj)
+        return AsyncIoProxyTarget(obj, runner)
+
+    def proxy_obj_with_cls(self, obj, proxy_cls):
+        target = self.target_obj(obj)
+        proxy = proxy_cls(target)
+        return proxy
+
+    def maybe_proxy_obj(self, obj):
+        if (proxy_cls := async_io_proxy_cls_for(obj)) is None:
+            return obj
+        return self.proxy_obj_with_cls(obj, proxy_cls)
+
+    ##
+
+    @ta.overload
+    def proxy_obj(self, obj: io.StringIO) -> StringIOAsyncIoProxy:  # type: ignore[overload-overlap]  # 1
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.TextIOWrapper) -> TextIOWrapperAsyncIoProxy:  # type: ignore[overload-overlap]  # 2
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.TextIOBase) -> TextIOBaseAsyncIoProxy:  # 3
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.FileIO) -> FileIOAsyncIoProxy:  # type: ignore[overload-overlap]  # 4
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.BufferedRandom) -> BufferedRandomAsyncIoProxy:  # type: ignore[overload-overlap]  # 5
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.BufferedRWPair) -> BufferedRWPairAsyncIoProxy:  # 6
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.BufferedWriter) -> BufferedWriterAsyncIoProxy:  # type: ignore[overload-overlap]  # 7
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.BufferedReader) -> BufferedReaderAsyncIoProxy:  # type: ignore[overload-overlap]  # 8
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.BytesIO) -> BytesIOAsyncIoProxy:  # type: ignore[overload-overlap]  # 9
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.BufferedIOBase) -> BufferedIOBaseAsyncIoProxy:  # 10
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.RawIOBase) -> RawIOBaseAsyncIoProxy:  # 11
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.IOBase) -> IOBaseAsyncIoProxy:  # 12
+        ...
+
+    #
+
+    @ta.overload
+    def proxy_obj(self, obj: ta.TextIO) -> TypingTextIOAsyncIoProxy:  # 13
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: ta.BinaryIO) -> TypingBinaryIOAsyncIoProxy:  # 14
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: ta.IO) -> TypingIOAsyncIoProxy:  # 15
+        ...
+
+    #
+
+    def proxy_obj(self, obj):
+        if (proxy_cls := async_io_proxy_cls_for(obj)) is None:
+            raise TypeError(obj)
+        return self.proxy_obj_with_cls(obj, proxy_cls)
+
+    ##
+
+    def proxy_fn(self, fn, *, wrap_result='auto'):
+        if wrap_result == 'auto':
+            result_wrapper = self.maybe_proxy_obj
+        elif wrap_result is True:
+            result_wrapper = self.proxy_obj
+        elif wrap_result is False:
+            result_wrapper = None
+        else:
+            raise TypeError(wrap_result)
+        runner = self.get_runner(fn)
+        return async_io_proxy_fn(fn, runner, result_wrapper=result_wrapper)
+
+    ##
+
+    FN_TYPES: ta.Tuple[type, ...] = (
+        types.BuiltinFunctionType,
+        types.BuiltinMethodType,
+        types.FunctionType,
+        types.MethodType,
+    )
+
+    def proxy(self, obj):
+        if isinstance(obj, self.FN_TYPES):
+            return self.proxy_fn(obj)
+        else:
+            return self.proxy_obj(obj)

omlish/asyncs/ioproxy/proxy.py

@@ -0,0 +1,141 @@
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+import functools
+import inspect
+import typing as ta
+
+from ...lite.check import check
+
+
+AsyncIoProxyRunner = ta.Callable[[ta.Callable], ta.Awaitable]  # ta.TypeAlias
+
+
+##
+
+
+_ASYNC_IO_PROXY_WRAPPER_NAME_ATTRS = ('__name__', '__qualname__')
+_ASYNC_IO_PROXY_WRAPPER_ASSIGNMENTS = tuple(
+    a
+    for a in functools.WRAPPER_ASSIGNMENTS
+    if a not in _ASYNC_IO_PROXY_WRAPPER_NAME_ATTRS
+)
+
+
+def async_io_proxy_fn(fn, runner, *, result_wrapper=None):
+    @functools.wraps(fn, assigned=_ASYNC_IO_PROXY_WRAPPER_ASSIGNMENTS)
+    async def run(*args, **kwargs):
+        ret = await runner(functools.partial(fn, *args, **kwargs))
+        if result_wrapper is not None:
+            ret = result_wrapper(ret)
+        return ret
+
+    for na in _ASYNC_IO_PROXY_WRAPPER_NAME_ATTRS:
+        setattr(run, na, f'{getattr(run, na)}:{getattr(fn, na)}')
+
+    return run
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class AsyncIoProxyTarget:
+    obj: ta.Any
+    runner: AsyncIoProxyRunner
+
+
+class AsyncIoProxy:
+    def __init__(self, target: AsyncIoProxyTarget) -> None:
+        super().__init__()
+
+        self._target = check.isinstance(target, AsyncIoProxyTarget)
+
+    #
+
+    class _Descriptor:
+        def __init__(self, name) -> None:
+            super().__init__()
+
+            self._name = name
+
+        def __get__(self, instance, owner=None):
+            if instance is None:
+                return self
+
+            target: AsyncIoProxyTarget = instance._target  # noqa
+            v = self._get(target, instance)
+
+            setattr(instance, self._name, v)
+            return v
+
+        def _get(self, target: AsyncIoProxyTarget, instance: ta.Any) -> ta.Any:
+            raise NotImplementedError
+
+    class _Property(_Descriptor):
+        def _get(self, target: AsyncIoProxyTarget, instance: ta.Any) -> ta.Any:
+            return getattr(target.obj, self._name)
+
+    class _Method(_Descriptor):
+        def __call__(self, instance, *args, **kwargs):
+            return self.__get__(instance)(*args, **kwargs)
+
+    class _SyncMethod(_Method):
+        def _get(self, target: AsyncIoProxyTarget, instance: ta.Any) -> ta.Any:
+            return getattr(target.obj, self._name)
+
+    class _AsyncMethod(_Method):
+        SPECIAL_METHOD_NAMES: ta.ClassVar[ta.Mapping[str, str]] = {
+            '__aenter__': '__enter__',
+            '__aexit__': '__exit__',
+        }
+
+        def _get(self, target: AsyncIoProxyTarget, instance: ta.Any) -> ta.Any:
+            fa = self.SPECIAL_METHOD_NAMES.get(self._name, self._name)
+            fn = getattr(target.obj, fa)
+            if fa == '__enter__':
+                result_wrapper = lambda _: instance
+            else:
+                result_wrapper = None
+            run = async_io_proxy_fn(fn, target.runner, result_wrapper=result_wrapper)
+            return run
+
+    #
+
+    __proxied_cls__: ta.ClassVar[type]
+
+    def __init_subclass__(cls, *, proxied_cls=None, **kwargs):  # noqa
+        super().__init_subclass__()
+
+        cls.__proxied_cls__ = check.isinstance(proxied_cls, (type, None))
+
+        for n, v in dict(cls.__dict__).items():
+            if n.startswith('_') and n not in cls._AsyncMethod.SPECIAL_METHOD_NAMES:
+                continue
+
+            if isinstance(v, property):
+                setattr(cls, n, cls._Property(n))
+
+            elif callable(v):
+                if inspect.iscoroutinefunction(v):
+                    setattr(cls, n, cls._AsyncMethod(n))
+                else:
+                    setattr(cls, n, cls._SyncMethod(n))
+
+            else:
+                raise TypeError(v)
+
+
+##
+
+
+@functools.singledispatch
+def async_io_proxy_cls_for(obj: ta.Any) -> ta.Optional[ta.Type[AsyncIoProxy]]:
+    return None
+
+
+def _register_async_io_proxy_cls(cls):
+    async_io_proxy_cls_for.register(
+        check.isinstance(cls.__dict__['__proxied_cls__'], type),
+        lambda obj: cls,
+    )
+    return cls

omlish/asyncs/ioproxy/typing.py

@@ -0,0 +1,108 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from .proxy import AsyncIoProxy
+from .proxy import _register_async_io_proxy_cls
+
+
+SelfT = ta.TypeVar('SelfT')
+
+AnyStrT = ta.TypeVar('AnyStrT', bytes, str)
+
+
+##
+
+
+@_register_async_io_proxy_cls
+class TypingIOAsyncIoProxy(AsyncIoProxy, ta.Generic[AnyStrT], proxied_cls=ta.IO):
+    @property
+    def mode(self) -> str:
+        raise TypeError
+
+    @property
+    def name(self) -> str:
+        raise TypeError
+
+    async def close(self) -> None:
+        raise TypeError
+
+    @property
+    def closed(self) -> bool:
+        raise TypeError
+
+    def fileno(self) -> int:
+        raise TypeError
+
+    async def flush(self) -> None:
+        raise TypeError
+
+    def isatty(self) -> bool:
+        raise TypeError
+
+    async def read(self, n: int = -1) -> AnyStrT:
+        raise TypeError
+
+    def readable(self) -> bool:
+        raise TypeError
+
+    async def readline(self, limit: int = -1) -> AnyStrT:
+        raise TypeError
+
+    async def readlines(self, hint: int = -1) -> ta.List[AnyStrT]:
+        raise TypeError
+
+    async def seek(self, offset: int, whence: int = 0) -> int:
+        raise TypeError
+
+    def seekable(self) -> bool:
+        raise TypeError
+
+    async def tell(self) -> int:
+        raise TypeError
+
+    async def truncate(self, size: ta.Optional[int] = None) -> int:
+        raise TypeError
+
+    def writable(self) -> bool:
+        raise TypeError
+
+    async def write(self, s: AnyStrT) -> int:
+        raise TypeError
+
+    async def writelines(self, lines: ta.List[AnyStrT]) -> None:
+        raise TypeError
+
+    async def __aenter__(self: SelfT) -> SelfT:
+        raise TypeError
+
+    async def __aexit__(self, exc_type, exc_value, exc_tb):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class TypingBinaryIOAsyncIoProxy(TypingIOAsyncIoProxy[bytes], proxied_cls=ta.BinaryIO):
+    def write(self, s: ta.Union[bytes, bytearray]) -> int:  # type: ignore[override]
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class TypingTextIOAsyncIoProxy(TypingIOAsyncIoProxy[str], proxied_cls=ta.TextIO):
+    # @property
+    # def buffer(self) -> BinaryIO:
+    #     pass
+
+    @property
+    def encoding(self) -> str:
+        raise TypeError
+
+    @property
+    def errors(self) -> ta.Optional[str]:
+        raise TypeError
+
+    @property
+    def line_buffering(self) -> bool:
+        raise TypeError
+
+    @property
+    def newlines(self) -> ta.Any:
+        raise TypeError

omlish/check.py

@@ -85,6 +85,7 @@ not_none = check.not_none
 #
 
 equal = check.equal
+not_equal = check.not_equal
 is_ = check.is_
 is_not = check.is_not
 callable = check.callable  # noqa

omlish/configs/processing/matching.py

@@ -29,8 +29,16 @@ class MatchingConfigRewriter(ConfigRewriter):
         self._paths = frozenset(check.isinstance(p, tuple) for p in paths)
         self._recurse = recurse
 
+    def match_path(self, path: ConfigRewriterPath) -> bool:
+        for test in self._paths:
+            if len(test) != len(path):
+                continue
+            if all(t is None or p == t for p, t in zip(path, test)):
+                return True
+        return False
+
     def rewrite(self, ctx: ConfigRewriter.Context[T]) -> T:
-        if ctx.path in self._paths:
+        if self.match_path(ctx.path):
             no = self._fn(ctx.obj)
             if not self._recurse:
                 return no

omlish/io/abc.py

@@ -1,5 +1,6 @@
 # ruff: noqa: ANN204
 
+
 class IOBase:
     def seek(self, pos, whence=0): ...
 

omlish/lite/check.py

@@ -49,6 +49,17 @@ class Checks:
 
     #
 
+    def register_on_raise_breakpoint_if_env_var_set(self, key: str) -> None:
+        import os
+
+        def on_raise(exc: Exception) -> None:  # noqa
+            if key in os.environ:
+                breakpoint()  # noqa
+
+        self.register_on_raise(on_raise)
+
+    #
+
     def set_exception_factory(self, factory: CheckExceptionFactory) -> None:
         self._exception_factory = factory
 
@@ -364,6 +375,18 @@ class Checks:
 
         return v
 
+    def not_equal(self, v: T, o: ta.Any, msg: CheckMessage = None) -> T:
+        if o == v:
+            self._raise(
+                ValueError,
+                'Must not 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(

omlish/lite/contextmanagers.py

@@ -7,6 +7,7 @@ from .check import check
 
 T = ta.TypeVar('T')
 ExitStackedT = ta.TypeVar('ExitStackedT', bound='ExitStacked')
+AsyncExitStackedT = ta.TypeVar('AsyncExitStackedT', bound='AsyncExitStacked')
 
 
 ##
@@ -35,6 +36,33 @@ class ExitStacked:
         return es.enter_context(cm)
 
 
+class AsyncExitStacked:
+    _exit_stack: ta.Optional[contextlib.AsyncExitStack] = None
+
+    async def __aenter__(self: AsyncExitStackedT) -> AsyncExitStackedT:
+        check.state(self._exit_stack is None)
+        es = self._exit_stack = contextlib.AsyncExitStack()
+        await es.__aenter__()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if (es := self._exit_stack) is None:
+            return None
+        await self._async_exit_contexts()
+        return await es.__aexit__(exc_type, exc_val, exc_tb)
+
+    async def _async_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)
+
+    async def _enter_async_context(self, cm: ta.AsyncContextManager[T]) -> T:
+        es = check.not_none(self._exit_stack)
+        return await es.enter_async_context(cm)
+
+
 ##
 
 
@@ -46,6 +74,17 @@ def defer(fn: ta.Callable) -> ta.Generator[ta.Callable, None, None]:
         fn()
 
 
+@contextlib.asynccontextmanager
+async def adefer(fn: ta.Callable) -> ta.AsyncGenerator[ta.Callable, None]:
+    try:
+        yield fn
+    finally:
+        await fn()
+
+
+##
+
+
 @contextlib.contextmanager
 def attr_setting(obj, attr, val, *, default=None):  # noqa
     not_set = object()

{omlish-0.0.0.dev212.dist-info → omlish-0.0.0.dev213.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev212
+Version: 0.0.0.dev213
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev212.dist-info → omlish-0.0.0.dev213.dist-info}/RECORD

@@ -1,9 +1,9 @@
 omlish/.manifests.json,sha256=dyIpveH7Z8OnQp2pTn6NVv7LCDXVrozJWAzbk8PBavg,7950
-omlish/__about__.py,sha256=EVqT_pFn9H9Ehs4S5FdbIXxCF65SGUz2Q7kpn0C25PE,3409
+omlish/__about__.py,sha256=rTnrIQNQ5FRbHCr1olR3EzpCFMG4gqKht36KMpz3fPk,3409
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
 omlish/cached.py,sha256=UI-XTFBwA6YXWJJJeBn-WkwBkfzDjLBBaZf4nIJA9y0,510
-omlish/check.py,sha256=RzMJhp8_dDnpHXnPiHDyZTW13KGDTopeuMgpwKCowPs,1988
+omlish/check.py,sha256=THqm6jD1a0skAO5EC8SOVg58yq96Vk5wcuruBkCYxyU,2016
 omlish/datetimes.py,sha256=HajeM1kBvwlTa-uR1TTZHmZ3zTPnnUr1uGGQhiO1XQ0,2152
 omlish/defs.py,sha256=9uUjJuVIbCBL3g14fyzAp-9gH935MFofvlfOGwcBIaM,4913
 omlish/dynamic.py,sha256=35C_cCX_Vq2HrHzGk5T-zbrMvmUdiIiwDzDNixczoDo,6541
@@ -108,6 +108,11 @@ omlish/asyncs/bluelet/events.py,sha256=iXpRWmy64YcshT_nuyiJ39jbketZdtj8LrdlX3Jmp
 omlish/asyncs/bluelet/files.py,sha256=pgcLV_3oGbpqQmOrii8SeizyYLp8XKofQJhqM82RlKw,2389
 omlish/asyncs/bluelet/runner.py,sha256=F6Ep0th09f-FkIRJfMN3_u-iG21jNNv11WyqnHyITYU,15475
 omlish/asyncs/bluelet/sockets.py,sha256=RrC2vU52dOEBYKzvoh1qA39uUE8p3uCB_oxnhaP1AeA,6752
+omlish/asyncs/ioproxy/__init__.py,sha256=Y3l4WY4JRi2uLG6kgbGp93fuGfkxkKwZDvhsa0Rwgtk,15
+omlish/asyncs/ioproxy/io.py,sha256=nIvaKi5CEMrycj1N_gfBeMwILNfFA_H1rklgR87xKCM,4987
+omlish/asyncs/ioproxy/proxier.py,sha256=yhHud-00DuGZeSlJHJs6dpsXUpsmuD1Kw0vw9gTsdpU,4456
+omlish/asyncs/ioproxy/proxy.py,sha256=cPzwHRlptaRPAKC5XdqwnBEObGNfSUsI4JWaUgFoZ64,3905
+omlish/asyncs/ioproxy/typing.py,sha256=Aa9ysSEFww_P39Bza0p-CehRpvwg0UvcopeQ-L_isyc,2440
 omlish/bootstrap/__init__.py,sha256=-Rtsg7uPQNhh1dIT9nqrz96XlqizwoLnWf-FwOEstJI,730
 omlish/bootstrap/__main__.py,sha256=4jCwsaogp0FrJjJZ85hzF4-WqluPeheHbfeoKynKvNs,194
 omlish/bootstrap/base.py,sha256=d8hqn4hp1XMMi5PgcJBQXPKmW47epu8CxBlqDZiRZb4,1073
@@ -159,7 +164,7 @@ omlish/configs/processing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 omlish/configs/processing/all.py,sha256=roIQ7EZJXSzsyUxNHNJaZsXcD2jdT46Ly1XXfG8xEcI,722
 omlish/configs/processing/flattening.py,sha256=1duZH5zbrGuoYqaJco5LN5qx6e76QP5pHbIyItkQsFY,5021
 omlish/configs/processing/inheritance.py,sha256=lFD8eWRE0cG0Z3-eCu7pMsP2skWhUNaoAtWi9fNfn8k,1218
-omlish/configs/processing/matching.py,sha256=JMS9r58pMCBbpewOhPY5oPtBu3uD6z6YBfZq4jnLwBE,1236
+omlish/configs/processing/matching.py,sha256=R64RxpPB1uX5Ztvvk2dQ2xi_xwlaxkxQgZwtDVR9spY,1514
 omlish/configs/processing/names.py,sha256=weHmaTclzgM9lUn3aBtw-kwZ3mc2N-CZlFg3Kd_UsKo,1093
 omlish/configs/processing/rewriting.py,sha256=v7PfHtuTn5v_5Y6Au7oMN2Z0nxAMy1iYyO5CXnTvZhs,4226
 omlish/configs/processing/strings.py,sha256=qFS2oh6z02IaM_q4lTKLdufzkJqAJ6J-Qjrz5S-QJoM,826
@@ -325,7 +330,7 @@ omlish/inject/impl/providers.py,sha256=QnwhsujJFIHC0JTgd2Wlo1kP53i3CWTrj1nKU2DNx
 omlish/inject/impl/proxy.py,sha256=1ko0VaKqzu9UG8bIldp9xtUrAVUOFTKWKTjOCqIGr4s,1636
 omlish/inject/impl/scopes.py,sha256=hKnzNieB-fJSFEXDP_QG1mCfIKoVFIfFlf9LiIt5tk4,5920
 omlish/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/io/abc.py,sha256=Cxs8KB1B_69rxpUYxI-MTsilAmNooJJn3w07DKqYKkE,1255
+omlish/io/abc.py,sha256=M40QB2udYpCEqmlxCcHv6FlJYJY6ymmJQBlaklYv0U8,1256
 omlish/io/buffers.py,sha256=qo1hCqTfKvlbSmddneporqCtW0rZJ_Mv2GrQTI1Hbk0,5636
 omlish/io/pyio.py,sha256=q4RBFVpBE5PYjnGPGT-_4pcZb7dFJmLJ4LtI8OoDRQY,95433
 omlish/io/trampoline.py,sha256=oUKTQg1F5xQS1431Kt7MbK-NZpX509ubcXU-s86xJr8,7171
@@ -392,9 +397,9 @@ omlish/lifecycles/states.py,sha256=zqMOU2ZU-MDNnWuwauM3_anIAiXM8LoBDElDEraptFg,1
 omlish/lifecycles/transitions.py,sha256=qQtFby-h4VzbvgaUqT2NnbNumlcOx9FVVADP9t83xj4,1939
 omlish/lite/__init__.py,sha256=ISLhM4q0LR1XXTCaHdZOZxBRyIsoZqYm4u0bf1BPcVk,148
 omlish/lite/cached.py,sha256=O7ozcoDNFm1Hg2wtpHEqYSp_i_nCLNOP6Ueq_Uk-7mU,1300
-omlish/lite/check.py,sha256=0PD-GKtaDqDX6jU5KbzbMvH-vl6jH82xgYfplmfTQkg,12941
+omlish/lite/check.py,sha256=OLwtE2x6nlbGx4vS3Rda7zMHpgqzDSLJminTAX2lqLA,13529
 omlish/lite/configs.py,sha256=Ev_19sbII67pTWzInYjYqa9VyTiZBvyjhZqyG8TtufE,908
-omlish/lite/contextmanagers.py,sha256=m9JO--p7L7mSl4cycXysH-1AO27weDKjP3DZG61cwwM,1683
+omlish/lite/contextmanagers.py,sha256=ciaMl0D3QDHToM7M28-kwZ-Q48LtwgCxiud3nekgutA,2863
 omlish/lite/dataclasses.py,sha256=M6UD4VwGo0Ky7RNzKWbO0IOy7iBZVCIbTiC6EYbFnX8,1035
 omlish/lite/inject.py,sha256=qBUftFeXMiRgANYbNS2e7TePMYyFAcuLgsJiLyMTW5o,28769
 omlish/lite/json.py,sha256=7-02Ny4fq-6YAu5ynvqoijhuYXWpLmfCI19GUeZnb1c,740
@@ -609,9 +614,9 @@ omlish/text/indent.py,sha256=YjtJEBYWuk8--b9JU_T6q4yxV85_TR7VEVr5ViRCFwk,1336
 omlish/text/minja.py,sha256=jZC-fp3Xuhx48ppqsf2Sf1pHbC0t8XBB7UpUUoOk2Qw,5751
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev212.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev212.dist-info/METADATA,sha256=HJccL3nK4sY04Ozm3b3wHJwjuZciBHbzD9MHSNowj9E,4264
-omlish-0.0.0.dev212.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-omlish-0.0.0.dev212.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev212.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev212.dist-info/RECORD,,
+omlish-0.0.0.dev213.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev213.dist-info/METADATA,sha256=IpkbQXwChAhIh8w_W3662VHEfMYUAs1Kcq1NRDjAr6Q,4264
+omlish-0.0.0.dev213.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+omlish-0.0.0.dev213.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev213.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev213.dist-info/RECORD,,