omlish 0.0.0.dev211__tar.gz → 0.0.0.dev213__tar.gz

{omlish-0.0.0.dev211/omlish.egg-info → omlish-0.0.0.dev213}/PKG-INFO

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

{omlish-0.0.0.dev211 → omlish-0.0.0.dev213}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev211'
-__revision__ = '429bd6e544b5a0e15db5196c05605127719166d9'
+__version__ = '0.0.0.dev213'
+__revision__ = '03c9d6a7f92cec54535af989bf531b8598a896c0'
 
 
 #

omlish-0.0.0.dev213/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-0.0.0.dev213/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-0.0.0.dev213/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-0.0.0.dev213/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-0.0.0.dev211 → omlish-0.0.0.dev213}/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-0.0.0.dev211 → omlish-0.0.0.dev213}/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-0.0.0.dev211 → omlish-0.0.0.dev213}/omlish/io/abc.py

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

omlish-0.0.0.dev213/omlish/io/fdio/__init__.py

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