omlish 0.0.0.dev212__tar.gz → 0.0.0.dev214__tar.gz

{omlish-0.0.0.dev212/omlish.egg-info → omlish-0.0.0.dev214}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev212
+Version: 0.0.0.dev214
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -23,11 +23,10 @@ Requires-Dist: python-snappy~=0.7; extra == "all"
 Requires-Dist: zstandard~=0.23; extra == "all"
 Requires-Dist: brotli~=1.1; extra == "all"
 Requires-Dist: asttokens~=3.0; extra == "all"
-Requires-Dist: executing~=2.1; extra == "all"
+Requires-Dist: executing~=2.2; extra == "all"
 Requires-Dist: psutil~=6.0; extra == "all"
 Requires-Dist: orjson~=3.10; extra == "all"
 Requires-Dist: ujson~=5.10; extra == "all"
-Requires-Dist: json5~=0.9; extra == "all"
 Requires-Dist: pyyaml~=6.0; extra == "all"
 Requires-Dist: cbor2~=5.6; extra == "all"
 Requires-Dist: cloudpickle~=3.1; extra == "all"
@@ -47,7 +46,7 @@ Requires-Dist: pytest~=8.0; extra == "all"
 Requires-Dist: anyio~=4.8; extra == "all"
 Requires-Dist: sniffio~=1.3; extra == "all"
 Requires-Dist: asttokens~=3.0; extra == "all"
-Requires-Dist: executing~=2.1; extra == "all"
+Requires-Dist: executing~=2.2; extra == "all"
 Requires-Dist: orjson~=3.10; extra == "all"
 Requires-Dist: pyyaml~=6.0; extra == "all"
 Requires-Dist: wrapt~=1.17; extra == "all"
@@ -64,12 +63,11 @@ Requires-Dist: zstandard~=0.23; extra == "compress"
 Requires-Dist: brotli~=1.1; extra == "compress"
 Provides-Extra: diag
 Requires-Dist: asttokens~=3.0; extra == "diag"
-Requires-Dist: executing~=2.1; extra == "diag"
+Requires-Dist: executing~=2.2; extra == "diag"
 Requires-Dist: psutil~=6.0; extra == "diag"
 Provides-Extra: formats
 Requires-Dist: orjson~=3.10; extra == "formats"
 Requires-Dist: ujson~=5.10; extra == "formats"
-Requires-Dist: json5~=0.9; extra == "formats"
 Requires-Dist: pyyaml~=6.0; extra == "formats"
 Requires-Dist: cbor2~=5.6; extra == "formats"
 Requires-Dist: cloudpickle~=3.1; extra == "formats"
@@ -96,7 +94,7 @@ Provides-Extra: plus
 Requires-Dist: anyio~=4.8; extra == "plus"
 Requires-Dist: sniffio~=1.3; extra == "plus"
 Requires-Dist: asttokens~=3.0; extra == "plus"
-Requires-Dist: executing~=2.1; extra == "plus"
+Requires-Dist: executing~=2.2; extra == "plus"
 Requires-Dist: orjson~=3.10; extra == "plus"
 Requires-Dist: pyyaml~=6.0; extra == "plus"
 Requires-Dist: wrapt~=1.17; extra == "plus"

{omlish-0.0.0.dev212 → omlish-0.0.0.dev214}/omlish/.manifests.json

@@ -108,13 +108,13 @@
     }
   },
   {
-    "module": ".formats.json5",
+    "module": ".formats.json5.codec",
     "attr": "_JSON5_LAZY_CODEC",
-    "file": "omlish/formats/json5.py",
-    "line": 30,
+    "file": "omlish/formats/json5/codec.py",
+    "line": 25,
     "value": {
       "$.codecs.base.LazyLoadedCodec": {
-        "mod_name": "omlish.formats.json5",
+        "mod_name": "omlish.formats.json5.codec",
         "attr_name": "JSON5_CODEC",
         "name": "json5",
         "aliases": null

{omlish-0.0.0.dev212 → omlish-0.0.0.dev214}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev212'
-__revision__ = 'bd253a140a7f57dc37a30f1a4f0b227123281988'
+__version__ = '0.0.0.dev214'
+__revision__ = '9512c6d71a63bb51772d9183f0205459f229de64'
 
 
 #
@@ -54,7 +54,7 @@ class Project(ProjectBase):
 
         'diag': [
             'asttokens ~= 3.0',
-            'executing ~= 2.1',
+            'executing ~= 2.2',
 
             'psutil ~= 6.0',
         ],
@@ -63,8 +63,6 @@ class Project(ProjectBase):
             'orjson ~= 3.10',
             'ujson ~= 5.10',
 
-            'json5 ~= 0.9',
-
             'pyyaml ~= 6.0',
 
             'cbor2 ~= 5.6',

omlish-0.0.0.dev214/omlish/antlr/__init__.py

@@ -0,0 +1,3 @@
+from . import errors  # noqa
+from . import parsing  # noqa
+from . import runtime  # noqa

omlish-0.0.0.dev214/omlish/antlr/parsing.py

@@ -0,0 +1,51 @@
+# ruff: noqa: N802 N803
+import typing as ta
+
+from .. import check
+from . import runtime as antlr4
+from .errors import SilentRaisingErrorListener
+
+
+LexerT = ta.TypeVar('LexerT', bound=antlr4.Lexer)
+ParserT = ta.TypeVar('ParserT', bound=antlr4.Parser)
+
+
+def is_eof_context(ctx: antlr4.ParserRuleContext) -> bool:
+    return ctx.getChildCount() == 1 and ctx.getChild(0).getSymbol().type == antlr4.Token.EOF
+
+
+class StandardParseTreeVisitor(antlr4.ParseTreeVisitor):
+    def visit(self, ctx: antlr4.ParserRuleContext):
+        check.isinstance(ctx, antlr4.ParserRuleContext)
+        return ctx.accept(self)
+
+    def aggregateResult(self, aggregate, nextResult):  # noqa
+        if aggregate is not None:
+            check.none(nextResult)
+            return aggregate
+        else:
+            check.none(aggregate)
+            return nextResult
+
+
+def make_parser(
+        buf: str,
+        lexer_cls: type[LexerT],
+        parser_cls: type[ParserT],
+        *,
+        silent_errors: bool = False,
+) -> ParserT:
+    lexer = lexer_cls(antlr4.InputStream(buf))
+    if silent_errors:
+        lexer.removeErrorListeners()
+        lexer.addErrorListener(SilentRaisingErrorListener())
+
+    stream = antlr4.CommonTokenStream(lexer)
+    stream.fill()
+
+    parser = parser_cls(stream)
+    if silent_errors:
+        parser.removeErrorListeners()
+        parser.addErrorListener(SilentRaisingErrorListener())
+
+    return parser

omlish-0.0.0.dev214/omlish/asyncs/asyncio/asyncio.py

@@ -0,0 +1,72 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import asyncio
+import contextlib
+import functools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
+
+
+def asyncio_once(fn: CallableT) -> CallableT:
+    future = None
+
+    @functools.wraps(fn)
+    async def inner(*args, **kwargs):
+        nonlocal future
+        if not future:
+            future = asyncio.create_task(fn(*args, **kwargs))
+        return await future
+
+    return ta.cast(CallableT, inner)
+
+
+def drain_tasks(loop=None):
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    while loop._ready or loop._scheduled:  # noqa
+        loop._run_once()  # noqa
+
+
+@contextlib.contextmanager
+def draining_asyncio_tasks() -> ta.Iterator[None]:
+    loop = asyncio.get_running_loop()
+    try:
+        yield
+    finally:
+        if loop is not None:
+            drain_tasks(loop)  # noqa
+
+
+async def asyncio_wait_concurrent(
+        coros: ta.Iterable[ta.Awaitable[T]],
+        concurrency: ta.Union[int, asyncio.Semaphore],
+        *,
+        return_when: ta.Any = asyncio.FIRST_EXCEPTION,
+) -> ta.List[T]:
+    if isinstance(concurrency, asyncio.Semaphore):
+        semaphore = concurrency
+    elif isinstance(concurrency, int):
+        semaphore = asyncio.Semaphore(concurrency)
+    else:
+        raise TypeError(concurrency)
+
+    async def limited_task(coro):
+        async with semaphore:
+            return await coro
+
+    tasks = [asyncio.create_task(limited_task(coro)) for coro in coros]
+    done, pending = await asyncio.wait(tasks, return_when=return_when)
+
+    for task in pending:
+        task.cancel()
+
+    for task in done:
+        if task.exception():
+            raise task.exception()  # type: ignore
+
+    return [task.result() for task in done]

omlish-0.0.0.dev214/omlish/asyncs/ioproxy/all.py

@@ -0,0 +1,32 @@
+from .io import (  # noqa
+    BufferedIOBase_AsyncIoProxy as BufferedIOBase,
+    BufferedRandom_AsyncIoProxy as BufferedRandom,
+    BufferedReader_AsyncIoProxy as BufferedReader,
+    BufferedRWPair_AsyncIoProxy as BufferedRWPair,
+    BufferedWriter_AsyncIoProxy as BufferedWriter,
+    BytesIO_AsyncIoProxy as BytesIO,
+    FileIO_AsyncIoProxy as FileIO,
+    IOBase_AsyncIoProxy as IOBase,
+    RawIOBase_AsyncIoProxy as RawIOBase,
+    StringIO_AsyncIoProxy as StringIO,
+    TextIOBase_AsyncIoProxy as TextIOBase,
+    TextIOWrapper_AsyncIoProxy as TextIOWrapper,
+)
+
+from .proxier import (  # noqa
+    AsyncIoProxier as Proxier,
+)
+
+from .proxy import (  # noqa
+    AsyncIoProxy as Proxy,
+    AsyncIoProxyRunner as Runer,
+    AsyncIoProxyTarget as Target,
+    async_io_proxy_cls_for as proxy_cls_for,
+    async_io_proxy_fn as proxy_fn,
+)
+
+from .typing import (  # noqa
+    TypingBinaryIO_AsyncIoProxy as TypingBinaryIO,
+    TypingIO_AsyncIoProxy as TypingIO,
+    TypingTextIO_AsyncIoProxy as TypingTextIO,
+)

omlish-0.0.0.dev214/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 IOBase_AsyncIoProxy(AsyncIoProxy, proxied_cls=io.IOBase):  # noqa
+    # 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 RawIOBase_AsyncIoProxy(IOBase_AsyncIoProxy, proxied_cls=io.RawIOBase):  # noqa
+    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 BufferedIOBase_AsyncIoProxy(IOBase_AsyncIoProxy, proxied_cls=io.BufferedIOBase):  # noqa
+    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 BufferedIOMixin_AsyncIoProxy(BufferedIOBase_AsyncIoProxy):  # noqa
+    @property
+    def raw(self):
+        raise TypeError
+
+    @property
+    def name(self):
+        raise TypeError
+
+    @property
+    def mode(self):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class BytesIO_AsyncIoProxy(BufferedIOBase_AsyncIoProxy, proxied_cls=io.BytesIO):  # noqa
+    async def getvalue(self):
+        raise TypeError
+
+    async def getbuffer(self):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class BufferedReader_AsyncIoProxy(BufferedIOMixin_AsyncIoProxy, proxied_cls=io.BufferedReader):  # noqa
+    async def peek(self, size=0):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class BufferedWriter_AsyncIoProxy(BufferedIOMixin_AsyncIoProxy, proxied_cls=io.BufferedWriter):  # noqa
+    pass
+
+
+@_register_async_io_proxy_cls
+class BufferedRWPair_AsyncIoProxy(BufferedIOBase_AsyncIoProxy, proxied_cls=io.BufferedRWPair):  # noqa
+    async def peek(self, size=0):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class BufferedRandom_AsyncIoProxy(BufferedWriter_AsyncIoProxy, BufferedReader_AsyncIoProxy, proxied_cls=io.BufferedRandom):  # noqa
+    pass
+
+
+@_register_async_io_proxy_cls
+class FileIO_AsyncIoProxy(RawIOBase_AsyncIoProxy, proxied_cls=io.FileIO):  # noqa
+    @property
+    def closefd(self):
+        raise TypeError
+
+    @property
+    def mode(self):
+        raise TypeError
+
+
+@_register_async_io_proxy_cls
+class TextIOBase_AsyncIoProxy(IOBase_AsyncIoProxy, proxied_cls=io.TextIOBase):  # noqa
+    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 TextIOWrapper_AsyncIoProxy(TextIOBase_AsyncIoProxy, proxied_cls=io.TextIOWrapper):  # noqa
+    @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 StringIO_AsyncIoProxy(TextIOWrapper_AsyncIoProxy, proxied_cls=io.StringIO):  # noqa
+    async def getvalue(self):
+        raise TypeError

omlish-0.0.0.dev214/omlish/asyncs/ioproxy/proxier.py

@@ -0,0 +1,154 @@
+# ruff: noqa: UP006 UP007
+import io
+import types
+import typing as ta
+
+from .io import BufferedIOBase_AsyncIoProxy
+from .io import BufferedRandom_AsyncIoProxy
+from .io import BufferedReader_AsyncIoProxy
+from .io import BufferedRWPair_AsyncIoProxy
+from .io import BufferedWriter_AsyncIoProxy
+from .io import BytesIO_AsyncIoProxy
+from .io import FileIO_AsyncIoProxy
+from .io import IOBase_AsyncIoProxy
+from .io import RawIOBase_AsyncIoProxy
+from .io import StringIO_AsyncIoProxy
+from .io import TextIOBase_AsyncIoProxy
+from .io import TextIOWrapper_AsyncIoProxy
+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 TypingBinaryIO_AsyncIoProxy
+from .typing import TypingIO_AsyncIoProxy
+from .typing import TypingTextIO_AsyncIoProxy
+
+
+##
+
+
+@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) -> StringIO_AsyncIoProxy:  # type: ignore[overload-overlap]  # 1
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.TextIOWrapper) -> TextIOWrapper_AsyncIoProxy:  # type: ignore[overload-overlap]  # 2
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.TextIOBase) -> TextIOBase_AsyncIoProxy:  # 3
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.FileIO) -> FileIO_AsyncIoProxy:  # type: ignore[overload-overlap]  # 4
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.BufferedRandom) -> BufferedRandom_AsyncIoProxy:  # type: ignore[overload-overlap]  # 5
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.BufferedRWPair) -> BufferedRWPair_AsyncIoProxy:  # 6
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.BufferedWriter) -> BufferedWriter_AsyncIoProxy:  # type: ignore[overload-overlap]  # 7
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.BufferedReader) -> BufferedReader_AsyncIoProxy:  # type: ignore[overload-overlap]  # 8
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.BytesIO) -> BytesIO_AsyncIoProxy:  # type: ignore[overload-overlap]  # 9
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.BufferedIOBase) -> BufferedIOBase_AsyncIoProxy:  # 10
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.RawIOBase) -> RawIOBase_AsyncIoProxy:  # 11
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: io.IOBase) -> IOBase_AsyncIoProxy:  # 12
+        ...
+
+    #
+
+    @ta.overload
+    def proxy_obj(self, obj: ta.TextIO) -> TypingTextIO_AsyncIoProxy:  # 13
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: ta.BinaryIO) -> TypingBinaryIO_AsyncIoProxy:  # 14
+        ...
+
+    @ta.overload
+    def proxy_obj(self, obj: ta.IO) -> TypingIO_AsyncIoProxy:  # 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)