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

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/__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/antlr/__init__.py

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

omlish/antlr/parsing.py

@@ -1,19 +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 parse(
+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()
-    return parser_cls(stream)
+
+    parser = parser_cls(stream)
+    if silent_errors:
+        parser.removeErrorListeners()
+        parser.addErrorListener(SilentRaisingErrorListener())
+
+    return parser

omlish/asyncs/asyncio/asyncio.py

@@ -1,9 +1,13 @@
+# 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)
 
 
@@ -36,3 +40,33 @@ def draining_asyncio_tasks() -> ta.Iterator[None]:
     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/asyncs/ioproxy/__init__.py

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

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/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/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)