omlish 0.0.0.dev437__py3-none-any.whl → 0.0.0.dev439__py3-none-any.whl

omlish/formats/json/stream/utils.py

@@ -23,63 +23,136 @@ TODO:
    - Names and values separated by = or => instead of :.
    - Name/value pairs separated by ; instead of ,.
 """
-import dataclasses as dc
+import itertools
 import typing as ta
 
 from .... import lang
 from .building import JsonValueBuilder
+from .errors import JsonStreamError
 from .lexing import JsonStreamLexer
+from .lexing import Token
+from .parsing import Event
 from .parsing import JsonStreamParser
 
 
 ##
 
 
-@dc.dataclass(kw_only=True)
 class JsonStreamValueParser(lang.ExitStacked):
-    include_raw: bool = False
-    yield_object_lists: bool = False
+    class Machinery(ta.NamedTuple):
+        lex: JsonStreamLexer
+        parse: JsonStreamParser
+        build: JsonValueBuilder
 
-    json5: bool = False
+    def __init__(self, m: Machinery) -> None:
+        super().__init__()
 
-    #
+        self._m = m
 
-    _lex: JsonStreamLexer = dc.field(init=False)
-    _parse: JsonStreamParser = dc.field(init=False)
-    _build: JsonValueBuilder = dc.field(init=False)
+    #
 
     def _enter_contexts(self) -> None:
-        self._lex = JsonStreamLexer(
-            include_raw=self.include_raw,
-            allow_comments=self.json5,
-            allow_single_quotes=self.json5,
-        )
+        self._enter_context(self._m.lex)
+        self._enter_context(self._m.parse)
+
+    def feed(self, i: ta.Iterable[str]) -> ta.Iterator[ta.Any]:
+        for c in i:
+            for t in self._m.lex(c):
+                for e in self._m.parse(t):
+                    for v in self._m.build(e):  # noqa
+                        yield v
+
+    #
+
+    @classmethod
+    def parse_values(
+            cls,
+            m: Machinery,
+            i: ta.Iterable[str],
+    ) -> ta.Iterator[ta.Any]:
+        with cls(m) as p:
+            yield from p.feed(itertools.chain(i, ['']))
+
+    @classmethod
+    def parse_one_value(
+            cls,
+            m: Machinery,
+            i: ta.Iterable[str],
+    ) -> ta.Any:
+        with cls(m) as p:
+            return next(p.feed(itertools.chain(i, [''])))
+
+    @classmethod
+    def parse_exactly_one_value(
+            cls,
+            m: Machinery,
+            i: ta.Iterable[str],
+    ) -> ta.Any:
+        r: ta.Any
+        r = not_set = object()
+        with cls(m) as p:
+            for v in p.feed(itertools.chain(i, [''])):
+                if r is not_set:
+                    r = v
+                else:
+                    raise JsonStreamError('Unexpected input')
+        if r is not_set:
+            raise JsonStreamError('No value')
+        return r
+
+
+##
+
 
-        self._parse = JsonStreamParser()
+class DebugJsonStreamValueParser(JsonStreamValueParser):
+    def __init__(self, m: JsonStreamValueParser.Machinery) -> None:
+        super().__init__(m)
 
-        self._build = JsonValueBuilder(
-            yield_object_lists=self.yield_object_lists,
-        )
+        self._chars: list[str] = []
+        self._tokens: list[Token] = []
+        self._events: list[Event] = []
+        self._values: list[ta.Any] = []
 
     def feed(self, i: ta.Iterable[str]) -> ta.Iterator[ta.Any]:
         for c in i:
-            for t in self._lex(c):
-                for e in self._parse(t):
-                    for v in self._build(e):  # noqa
+            self._chars.append(c)
+            for t in self._m.lex(c):
+                self._tokens.append(t)
+                for e in self._m.parse(t):
+                    self._events.append(e)
+                    for v in self._m.build(e):
+                        self._values.append(v)
                         yield v
 
 
-def stream_parse_values(
-        i: ta.Iterable[str],
-        **kwargs: ta.Any,
-) -> ta.Generator[ta.Any]:
-    with JsonStreamValueParser(**kwargs) as p:
-        yield from p.feed(i)
+##
+
+
+def make_machinery(
+        *,
+        include_raw: bool = False,
+        yield_object_lists: bool = False,
+) -> JsonStreamValueParser.Machinery:
+    return JsonStreamValueParser.Machinery(
+        JsonStreamLexer(
+            include_raw=include_raw,
+        ),
+
+        JsonStreamParser(),
+
+        JsonValueBuilder(
+            yield_object_lists=yield_object_lists,
+        ),
+    )
+
+
+def stream_parse_values(i: ta.Iterable[str], **kwargs: ta.Any) -> ta.Iterator[ta.Any]:
+    return JsonStreamValueParser.parse_values(make_machinery(**kwargs), i)
+
+
+def stream_parse_one_value(i: ta.Iterable[str], **kwargs: ta.Any) -> ta.Any:
+    return JsonStreamValueParser.parse_one_value(make_machinery(**kwargs), i)
 
 
-def stream_parse_one_value(
-        i: ta.Iterable[str],
-        **kwargs: ta.Any,
-) -> ta.Any:
-    with JsonStreamValueParser(**kwargs) as p:
-        return next(p.feed(i))
+def stream_parse_exactly_one_value(i: ta.Iterable[str], **kwargs: ta.Any) -> ta.Any:
+    return JsonStreamValueParser.parse_exactly_one_value(make_machinery(**kwargs), i)

omlish/formats/json5/literals.py

@@ -124,7 +124,10 @@ def parse_string_literal(s: str) -> str:
 def parse_number_literal(s: str) -> int | float:
     s = s.lower()
 
-    if 'x' in s:
-        return int(s, 16)
-    else:
-        return float(s)
+    try:
+        if 'x' in s:
+            return int(s, 16)
+        else:
+            return float(s)
+    except ValueError as e:
+        raise Json5Error from e

omlish/formats/json5/parsing.py

@@ -1,100 +1,54 @@
-# ruff: noqa: N802 N803
 import typing as ta
 
-from ...text import antlr
-from ._antlr.Json5Lexer import Json5Lexer  # type: ignore
-from ._antlr.Json5Parser import Json5Parser  # type: ignore
-from ._antlr.Json5Visitor import Json5Visitor  # type: ignore
+from ..json.stream.errors import JsonStreamError
+from ..json.stream.utils import DebugJsonStreamValueParser
+from ..json.stream.utils import JsonStreamValueParser
 from .errors import Json5Error
-from .literals import LITERAL_VALUES
-from .literals import parse_number_literal
-from .literals import parse_string_literal
+from .stream import make_machinery
 
 
 ##
 
 
-class Json5ParseVisitor(antlr.parsing.StandardParseTreeVisitor, Json5Visitor):
-    def visitArr(self, ctx: Json5Parser.ArrContext):
-        return [self.visit(e) for e in ctx.value()]
+def parse(
+        buf: str,
+        *,
+        debug: bool = False,
+) -> ta.Any:
+    m = make_machinery()
 
-    def visitKey(self, ctx: Json5Parser.KeyContext):
-        if (s := ctx.STRING()) is not None:
-            return parse_string_literal(s.getText())
+    if debug:
+        vc: type[JsonStreamValueParser] = DebugJsonStreamValueParser
+    else:
+        vc = JsonStreamValueParser
 
-        elif (i := ctx.IDENTIFIER()) is not None:
-            return parse_string_literal(''.join(['"', i.getText(), '"']))
-
-        elif (l := ctx.LITERAL()) is not None:
-            return LITERAL_VALUES[l.getText()]
-
-        elif (n := ctx.NUMERIC_LITERAL()) is not None:
-            return n.getText()
-
-        else:
-            raise RuntimeError(ctx)
-
-    def visitNumber(self, ctx: Json5Parser.NumberContext):
-        return parse_number_literal(ctx.getText())
-
-    def visitObj(self, ctx: Json5Parser.ObjContext):
-        dct: dict[ta.Any, ta.Any] = {}
-        for pair in ctx.pair():
-            key, value = self.visit(pair)
-            dct[key] = value
-        return dct
-
-    def visitPair(self, ctx: Json5Parser.PairContext):
-        key = self.visit(ctx.key())
-        value = self.visit(ctx.value())
-        return (key, value)
-
-    def visitValue(self, ctx: Json5Parser.ValueContext):
-        if (s := ctx.STRING()) is not None:
-            return parse_string_literal(s.getText())
-
-        elif (n := ctx.LITERAL()) is not None:
-            return LITERAL_VALUES[n.getText()]
-
-        else:
-            return super().visitChildren(ctx)
-
-
-def _make_parser(buf: str) -> Json5Parser:
-    return antlr.parsing.make_parser(
-        buf,
-        Json5Lexer,
-        Json5Parser,
-        silent_errors=True,
-    )
-
-
-def parse(buf: str) -> ta.Any:
     try:
-        root = _make_parser(buf).json5()
+        return vc.parse_exactly_one_value(m, buf)
+
+    except Json5Error:
+        raise
 
-    except antlr.errors.ParseError as e:
+    except JsonStreamError as e:
         raise Json5Error from e
 
-    if antlr.parsing.is_eof_context(root):
-        raise Json5Error('Empty input')
 
-    visitor = Json5ParseVisitor()
-    return visitor.visit(root)
+def parse_many(
+        buf: str,
+        *,
+        debug: bool = False,
+) -> ta.Iterator[ta.Any]:
+    m = make_machinery()
 
+    if debug:
+        vc: type[JsonStreamValueParser] = DebugJsonStreamValueParser
+    else:
+        vc = JsonStreamValueParser
 
-def parse_many(buf: str) -> ta.Generator[ta.Any]:
     try:
-        parser = _make_parser(buf)
-
-        while True:
-            if parser.getInputStream().LT(1).type == antlr.runtime.Token.EOF:
-                break
-
-            value = parser.value()
+        yield from vc.parse_values(m, buf)
 
-            visitor = Json5ParseVisitor()
-            yield visitor.visit(value)
+    except Json5Error:
+        raise
 
-    except antlr.errors.ParseError as e:
+    except JsonStreamError as e:
         raise Json5Error from e

omlish/formats/json5/stream.py

@@ -1,82 +1,77 @@
 """
-TODO:
-
 Objects:
- - Object keys may be an ECMAScript 5.1 IdentifierName.
- - Objects may have a single trailing comma.
+ + Object keys may be an ECMAScript 5.1 IdentifierName.
+ + Objects may have a single trailing comma.
 Arrays:
- - Arrays may have a single trailing comma.
+ + Arrays may have a single trailing comma.
 Strings:
- - Strings may be single quoted.
- - Strings may span multiple lines by escaping new line characters.
- - Strings may include character escapes.
+ + Strings may be single quoted.
+ + Strings may span multiple lines by escaping new line characters.
+ + Strings may include character escapes.
 Numbers:
- - Numbers may be hexadecimal.
- - Numbers may have a leading or trailing decimal point.
- - Numbers may be IEEE 754 positive infinity, negative infinity, and NaN.
- - Numbers may begin with an explicit plus sign.
+ + Numbers may be hexadecimal.
+ + Numbers may have a leading or trailing decimal point.
+ + Numbers may be IEEE 754 positive infinity, negative infinity, and NaN.
+ + Numbers may begin with an explicit plus sign.
 Comments:
  + Single and multi-line comments are allowed.
 White Space:
- - Additional white space characters are allowed.
+ + Additional white space characters are allowed.
 """
-import dataclasses as dc
 import typing as ta
 
-from ... import lang
 from ..json.stream.building import JsonValueBuilder
 from ..json.stream.lexing import JsonStreamLexer
 from ..json.stream.parsing import JsonStreamParser
+from ..json.stream.utils import JsonStreamValueParser
+from .literals import parse_number_literal
 from .literals import parse_string_literal
 
 
 ##
 
 
-@dc.dataclass(kw_only=True)
-class JsonStreamValueParser(lang.ExitStacked):
-    include_raw: bool = False
-    yield_object_lists: bool = False
-
-    #
+def make_machinery(
+        *,
+        include_raw: bool = False,
+        yield_object_lists: bool = False,
+) -> JsonStreamValueParser.Machinery:
+    return JsonStreamValueParser.Machinery(
+        JsonStreamLexer(
+            include_raw=include_raw,
 
-    _lex: JsonStreamLexer = dc.field(init=False)
-    _parse: JsonStreamParser = dc.field(init=False)
-    _build: JsonValueBuilder = dc.field(init=False)
+            allow_extended_space=True,
 
-    def _enter_contexts(self) -> None:
-        self._lex = JsonStreamLexer(
-            include_raw=self.include_raw,
             allow_comments=True,
+
             allow_single_quotes=True,
             string_literal_parser=parse_string_literal,
-        )
 
-        self._parse = JsonStreamParser()
+            allow_extended_number_literals=True,
+            number_literal_parser=parse_number_literal,
+
+            allow_extended_idents=True,
+        ),
+
+        JsonStreamParser(
+            allow_trailing_commas=True,
+
+            allow_extended_idents=True,
+        ),
+
+        JsonValueBuilder(
+            yield_object_lists=yield_object_lists,
+        ),
+    )
 
-        self._build = JsonValueBuilder(
-            yield_object_lists=self.yield_object_lists,
-        )
 
-    def feed(self, i: ta.Iterable[str]) -> ta.Iterator[ta.Any]:
-        for c in i:
-            for t in self._lex(c):
-                for e in self._parse(t):
-                    for v in self._build(e):  # noqa
-                        yield v
+def stream_parse_values(i: ta.Iterable[str], **kwargs: ta.Any) -> ta.Iterator[ta.Any]:
+    return JsonStreamValueParser.parse_values(make_machinery(**kwargs), i)
 
 
-def stream_parse_values(
-        i: ta.Iterable[str],
-        **kwargs: ta.Any,
-) -> ta.Generator[ta.Any]:
-    with JsonStreamValueParser(**kwargs) as p:
-        yield from p.feed(i)
+def stream_parse_one_value(i: ta.Iterable[str], **kwargs: ta.Any) -> ta.Any:
+    return JsonStreamValueParser.parse_one_value(make_machinery(**kwargs), i)
 
 
-def stream_parse_one_value(
-        i: ta.Iterable[str],
-        **kwargs: ta.Any,
-) -> ta.Any:
-    with JsonStreamValueParser(**kwargs) as p:
-        return next(p.feed(i))
+def stream_parse_exactly_one_value(i: ta.Iterable[str], **kwargs: ta.Any) -> ta.Any:
+    return JsonStreamValueParser.parse_exactly_one_value(make_machinery(**kwargs), i)

omlish/http/all.py

@@ -1,53 +1,59 @@
-from . import consts  # noqa
-
-from .clients import (  # noqa
-    BaseHttpResponse,
-    HttpClient,
-    HttpClientError,
-    HttpRequest,
-    HttpResponse,
-    HttpxHttpClient,
-    StreamHttpResponse,
-    UrllibHttpClient,
-    client,
-    close_response,
-    closing_response,
-    read_response,
-    request,
-)
-
-from .cookies import (  # noqa
-    CookieTooBigError,
-    dump_cookie,
-    parse_cookie,
-)
-
-from .dates import (  # noqa
-    http_date,
-    parse_date,
-)
-
-from .encodings import (  # noqa
-    latin1_decode,
-    latin1_encode,
-)
-
-from .headers import (  # noqa
-    CanHttpHeaders,
-    HttpHeaders,
-    headers,
-)
-
-from .json import (  # noqa
-    JSON_TAGGER,
-    JsonTag,
-    JsonTagger,
-    json_dumps,
-    json_loads,
-)
-
-from .multipart import (  # noqa
-    MultipartData,
-    MultipartEncoder,
-    MultipartField,
-)
+from .. import lang as _lang
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from . import consts  # noqa
+
+    from .clients import (  # noqa
+        BaseHttpResponse,
+        HttpClient,
+        HttpClientError,
+        HttpRequest,
+        HttpResponse,
+        HttpxHttpClient,
+        StreamHttpResponse,
+        UrllibHttpClient,
+        client,
+        close_response,
+        closing_response,
+        read_response,
+        request,
+    )
+
+    from .cookies import (  # noqa
+        CookieTooBigError,
+        dump_cookie,
+        parse_cookie,
+    )
+
+    from .dates import (  # noqa
+        http_date,
+        parse_date,
+    )
+
+    from .encodings import (  # noqa
+        latin1_decode,
+        latin1_encode,
+    )
+
+    from .headers import (  # noqa
+        CanHttpHeaders,
+        HttpHeaders,
+        headers,
+    )
+
+    from .json import (  # noqa
+        JSON_TAGGER,
+        JsonTag,
+        JsonTagger,
+        json_dumps,
+        json_loads,
+    )
+
+    from .multipart import (  # noqa
+        MultipartData,
+        MultipartEncoder,
+        MultipartField,
+    )

omlish/inject/__init__.py

@@ -123,6 +123,7 @@ with _lang.auto_proxy_init(globals()):
     )
 
     from .providers import (  # noqa
+        AsyncFnProvider,
         ConstProvider,
         CtorProvider,
         FnProvider,

omlish/iterators/__init__.py

@@ -22,6 +22,8 @@ with _lang.auto_proxy_init(globals()):
         unzip,
     )
 
+    from . import transforms as tf  # noqa
+
     from .unique import (  # noqa
         UniqueItem,
         UniqueIterator,