omlish 0.0.0.dev213__tar.gz → 0.0.0.dev215__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev213
+Version: 0.0.0.dev215
 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.dev213 → omlish-0.0.0.dev215}/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.dev213 → omlish-0.0.0.dev215}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev213'
-__revision__ = '03c9d6a7f92cec54535af989bf531b8598a896c0'
+__version__ = '0.0.0.dev215'
+__revision__ = 'c5c874e5a29ecc0725c701f47a3a498d9d5745f1'
 
 
 #
@@ -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.dev215/omlish/antlr/__init__.py

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

omlish-0.0.0.dev215/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.dev215/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.dev215/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.dev213 → omlish-0.0.0.dev215}/omlish/asyncs/ioproxy/io.py

@@ -13,7 +13,7 @@ SelfT = ta.TypeVar('SelfT')
 
 
 @_register_async_io_proxy_cls
-class IOBaseAsyncIoProxy(AsyncIoProxy, proxied_cls=io.IOBase):
+class IOBase_AsyncIoProxy(AsyncIoProxy, proxied_cls=io.IOBase):  # noqa
     # https://github.com/python/cpython/blob/e65a1eb93ae35f9fbab1508606e3fbc89123629f/Lib/_pyio.py#L305
 
     ##
@@ -91,7 +91,7 @@ class IOBaseAsyncIoProxy(AsyncIoProxy, proxied_cls=io.IOBase):
 
 
 @_register_async_io_proxy_cls
-class RawIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.RawIOBase):
+class RawIOBase_AsyncIoProxy(IOBase_AsyncIoProxy, proxied_cls=io.RawIOBase):  # noqa
     async def read(self, size=-1):
         raise TypeError
 
@@ -106,7 +106,7 @@ class RawIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.RawIOBase):
 
 
 @_register_async_io_proxy_cls
-class BufferedIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.BufferedIOBase):
+class BufferedIOBase_AsyncIoProxy(IOBase_AsyncIoProxy, proxied_cls=io.BufferedIOBase):  # noqa
     async def read(self, size=-1):
         raise TypeError
 
@@ -126,7 +126,7 @@ class BufferedIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.BufferedIOBa
         raise TypeError
 
 
-class BufferedIOMixinAsyncIoProxy(BufferedIOBaseAsyncIoProxy):
+class BufferedIOMixin_AsyncIoProxy(BufferedIOBase_AsyncIoProxy):  # noqa
     @property
     def raw(self):
         raise TypeError
@@ -141,7 +141,7 @@ class BufferedIOMixinAsyncIoProxy(BufferedIOBaseAsyncIoProxy):
 
 
 @_register_async_io_proxy_cls
-class BytesIOAsyncIoProxy(BufferedIOBaseAsyncIoProxy, proxied_cls=io.BytesIO):
+class BytesIO_AsyncIoProxy(BufferedIOBase_AsyncIoProxy, proxied_cls=io.BytesIO):  # noqa
     async def getvalue(self):
         raise TypeError
 
@@ -150,29 +150,29 @@ class BytesIOAsyncIoProxy(BufferedIOBaseAsyncIoProxy, proxied_cls=io.BytesIO):
 
 
 @_register_async_io_proxy_cls
-class BufferedReaderAsyncIoProxy(BufferedIOMixinAsyncIoProxy, proxied_cls=io.BufferedReader):
+class BufferedReader_AsyncIoProxy(BufferedIOMixin_AsyncIoProxy, proxied_cls=io.BufferedReader):  # noqa
     async def peek(self, size=0):
         raise TypeError
 
 
 @_register_async_io_proxy_cls
-class BufferedWriterAsyncIoProxy(BufferedIOMixinAsyncIoProxy, proxied_cls=io.BufferedWriter):
+class BufferedWriter_AsyncIoProxy(BufferedIOMixin_AsyncIoProxy, proxied_cls=io.BufferedWriter):  # noqa
     pass
 
 
 @_register_async_io_proxy_cls
-class BufferedRWPairAsyncIoProxy(BufferedIOBaseAsyncIoProxy, proxied_cls=io.BufferedRWPair):
+class BufferedRWPair_AsyncIoProxy(BufferedIOBase_AsyncIoProxy, proxied_cls=io.BufferedRWPair):  # noqa
     async def peek(self, size=0):
         raise TypeError
 
 
 @_register_async_io_proxy_cls
-class BufferedRandomAsyncIoProxy(BufferedWriterAsyncIoProxy, BufferedReaderAsyncIoProxy, proxied_cls=io.BufferedRandom):
+class BufferedRandom_AsyncIoProxy(BufferedWriter_AsyncIoProxy, BufferedReader_AsyncIoProxy, proxied_cls=io.BufferedRandom):  # noqa
     pass
 
 
 @_register_async_io_proxy_cls
-class FileIOAsyncIoProxy(RawIOBaseAsyncIoProxy, proxied_cls=io.FileIO):
+class FileIO_AsyncIoProxy(RawIOBase_AsyncIoProxy, proxied_cls=io.FileIO):  # noqa
     @property
     def closefd(self):
         raise TypeError
@@ -183,7 +183,7 @@ class FileIOAsyncIoProxy(RawIOBaseAsyncIoProxy, proxied_cls=io.FileIO):
 
 
 @_register_async_io_proxy_cls
-class TextIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.TextIOBase):
+class TextIOBase_AsyncIoProxy(IOBase_AsyncIoProxy, proxied_cls=io.TextIOBase):  # noqa
     async def read(self, size=-1):
         raise TypeError
 
@@ -207,7 +207,7 @@ class TextIOBaseAsyncIoProxy(IOBaseAsyncIoProxy, proxied_cls=io.TextIOBase):
 
 
 @_register_async_io_proxy_cls
-class TextIOWrapperAsyncIoProxy(TextIOBaseAsyncIoProxy, proxied_cls=io.TextIOWrapper):
+class TextIOWrapper_AsyncIoProxy(TextIOBase_AsyncIoProxy, proxied_cls=io.TextIOWrapper):  # noqa
     @property
     def line_buffering(self):
         raise TypeError
@@ -237,6 +237,6 @@ class TextIOWrapperAsyncIoProxy(TextIOBaseAsyncIoProxy, proxied_cls=io.TextIOWra
 
 
 @_register_async_io_proxy_cls
-class StringIOAsyncIoProxy(TextIOWrapperAsyncIoProxy, proxied_cls=io.StringIO):
+class StringIO_AsyncIoProxy(TextIOWrapper_AsyncIoProxy, proxied_cls=io.StringIO):  # noqa
     async def getvalue(self):
         raise TypeError

{omlish-0.0.0.dev213 → omlish-0.0.0.dev215}/omlish/asyncs/ioproxy/proxier.py

@@ -3,25 +3,25 @@ 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 .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 TypingBinaryIOAsyncIoProxy
-from .typing import TypingIOAsyncIoProxy
-from .typing import TypingTextIOAsyncIoProxy
+from .typing import TypingBinaryIO_AsyncIoProxy
+from .typing import TypingIO_AsyncIoProxy
+from .typing import TypingTextIO_AsyncIoProxy
 
 
 ##
@@ -56,65 +56,65 @@ class AsyncIoProxier:
     ##
 
     @ta.overload
-    def proxy_obj(self, obj: io.StringIO) -> StringIOAsyncIoProxy:  # type: ignore[overload-overlap]  # 1
+    def proxy_obj(self, obj: io.StringIO) -> StringIO_AsyncIoProxy:  # type: ignore[overload-overlap]  # 1
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.TextIOWrapper) -> TextIOWrapperAsyncIoProxy:  # type: ignore[overload-overlap]  # 2
+    def proxy_obj(self, obj: io.TextIOWrapper) -> TextIOWrapper_AsyncIoProxy:  # type: ignore[overload-overlap]  # 2
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.TextIOBase) -> TextIOBaseAsyncIoProxy:  # 3
+    def proxy_obj(self, obj: io.TextIOBase) -> TextIOBase_AsyncIoProxy:  # 3
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.FileIO) -> FileIOAsyncIoProxy:  # type: ignore[overload-overlap]  # 4
+    def proxy_obj(self, obj: io.FileIO) -> FileIO_AsyncIoProxy:  # type: ignore[overload-overlap]  # 4
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.BufferedRandom) -> BufferedRandomAsyncIoProxy:  # type: ignore[overload-overlap]  # 5
+    def proxy_obj(self, obj: io.BufferedRandom) -> BufferedRandom_AsyncIoProxy:  # type: ignore[overload-overlap]  # 5
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.BufferedRWPair) -> BufferedRWPairAsyncIoProxy:  # 6
+    def proxy_obj(self, obj: io.BufferedRWPair) -> BufferedRWPair_AsyncIoProxy:  # 6
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.BufferedWriter) -> BufferedWriterAsyncIoProxy:  # type: ignore[overload-overlap]  # 7
+    def proxy_obj(self, obj: io.BufferedWriter) -> BufferedWriter_AsyncIoProxy:  # type: ignore[overload-overlap]  # 7
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.BufferedReader) -> BufferedReaderAsyncIoProxy:  # type: ignore[overload-overlap]  # 8
+    def proxy_obj(self, obj: io.BufferedReader) -> BufferedReader_AsyncIoProxy:  # type: ignore[overload-overlap]  # 8
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.BytesIO) -> BytesIOAsyncIoProxy:  # type: ignore[overload-overlap]  # 9
+    def proxy_obj(self, obj: io.BytesIO) -> BytesIO_AsyncIoProxy:  # type: ignore[overload-overlap]  # 9
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.BufferedIOBase) -> BufferedIOBaseAsyncIoProxy:  # 10
+    def proxy_obj(self, obj: io.BufferedIOBase) -> BufferedIOBase_AsyncIoProxy:  # 10
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.RawIOBase) -> RawIOBaseAsyncIoProxy:  # 11
+    def proxy_obj(self, obj: io.RawIOBase) -> RawIOBase_AsyncIoProxy:  # 11
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: io.IOBase) -> IOBaseAsyncIoProxy:  # 12
+    def proxy_obj(self, obj: io.IOBase) -> IOBase_AsyncIoProxy:  # 12
         ...
 
     #
 
     @ta.overload
-    def proxy_obj(self, obj: ta.TextIO) -> TypingTextIOAsyncIoProxy:  # 13
+    def proxy_obj(self, obj: ta.TextIO) -> TypingTextIO_AsyncIoProxy:  # 13
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: ta.BinaryIO) -> TypingBinaryIOAsyncIoProxy:  # 14
+    def proxy_obj(self, obj: ta.BinaryIO) -> TypingBinaryIO_AsyncIoProxy:  # 14
         ...
 
     @ta.overload
-    def proxy_obj(self, obj: ta.IO) -> TypingIOAsyncIoProxy:  # 15
+    def proxy_obj(self, obj: ta.IO) -> TypingIO_AsyncIoProxy:  # 15
         ...
 
     #

{omlish-0.0.0.dev213 → omlish-0.0.0.dev215}/omlish/asyncs/ioproxy/typing.py

@@ -14,7 +14,7 @@ AnyStrT = ta.TypeVar('AnyStrT', bytes, str)
 
 
 @_register_async_io_proxy_cls
-class TypingIOAsyncIoProxy(AsyncIoProxy, ta.Generic[AnyStrT], proxied_cls=ta.IO):
+class TypingIO_AsyncIoProxy(AsyncIoProxy, ta.Generic[AnyStrT], proxied_cls=ta.IO):  # noqa
     @property
     def mode(self) -> str:
         raise TypeError
@@ -80,13 +80,13 @@ class TypingIOAsyncIoProxy(AsyncIoProxy, ta.Generic[AnyStrT], proxied_cls=ta.IO)
 
 
 @_register_async_io_proxy_cls
-class TypingBinaryIOAsyncIoProxy(TypingIOAsyncIoProxy[bytes], proxied_cls=ta.BinaryIO):
+class TypingBinaryIO_AsyncIoProxy(TypingIO_AsyncIoProxy[bytes], proxied_cls=ta.BinaryIO):  # noqa
     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):
+class TypingTextIO_AsyncIoProxy(TypingIO_AsyncIoProxy[str], proxied_cls=ta.TextIO):  # noqa
     # @property
     # def buffer(self) -> BinaryIO:
     #     pass

{omlish-0.0.0.dev213 → omlish-0.0.0.dev215}/omlish/formats/json/stream/lex.py

@@ -4,6 +4,7 @@ TODO:
  - max recursion depth
  - mark start pos of tokens, currently returning end
  - _do_string inner loop optimization somehow
+ - json5 mode
 """
 import dataclasses as dc
 import io