omlish 0.0.0.dev104__py3-none-any.whl → 0.0.0.dev106__py3-none-any.whl

omlish/formats/json/render.py

@@ -5,13 +5,18 @@ import json
 import typing as ta
 
 from ... import lang
+from . import consts
 
 
 I = ta.TypeVar('I')
+Scalar: ta.TypeAlias = bool | int | float | str | None
 
+SCALAR_TYPES: tuple[type, ...] = (bool, int, float, str, type(None))
 
-class JsonRendererOut(ta.Protocol):
-    def write(self, s: str) -> ta.Any: ...
+MULTILINE_SEPARATORS = consts.Separators(',', ': ')
+
+
+##
 
 
 class AbstractJsonRenderer(lang.Abstract, ta.Generic[I]):
@@ -21,33 +26,33 @@ class AbstractJsonRenderer(lang.Abstract, ta.Generic[I]):
 
     def __init__(
             self,
-            out: JsonRendererOut,
-            *,
             indent: int | str | None = None,
             separators: tuple[str, str] | None = None,
             sort_keys: bool = False,
             style: ta.Callable[[ta.Any, State], tuple[str, str]] | None = None,
+            ensure_ascii: bool = True,
     ) -> None:
         super().__init__()
 
-        self._out = out
         self._sort_keys = sort_keys
         self._style = style
+        self._ensure_ascii = ensure_ascii
 
         if isinstance(indent, (str, int)):
             self._indent = (' ' * indent) if isinstance(indent, int) else indent
             self._endl = '\n'
             if separators is None:
-                separators = (',', ': ')
+                separators = MULTILINE_SEPARATORS
         elif indent is None:
             self._indent = self._endl = ''
             if separators is None:
-                separators = (', ', ': ')
+                separators = consts.PRETTY_SEPARATORS
         else:
             raise TypeError(indent)
         self._comma, self._colon = separators
 
         self._level = 0
+        self._indent_cache: dict[int, str] = {}
 
     _literals: ta.ClassVar[ta.Mapping[ta.Any, str]] = {
         True: 'true',
@@ -55,28 +60,62 @@ class AbstractJsonRenderer(lang.Abstract, ta.Generic[I]):
         None: 'null',
     }
 
-    def _write(self, s: str) -> None:
-        if s:
-            self._out.write(s)
+    def _get_indent(self) -> str:
+        if not self._indent:
+            return ''
 
-    def _write_indent(self) -> None:
-        if self._indent:
-            self._write(self._endl)
-            if self._level:
-                self._write(self._indent * self._level)
+        if not self._level:
+            return self._endl
 
+        try:
+            return self._indent_cache[self._level]
+        except KeyError:
+            pass
+
+        ret = self._endl + (self._indent * self._level)
+        self._indent_cache[self._level] = ret
+        return ret
+
+    def _format_scalar(self, o: Scalar) -> str:
+        if o is None or isinstance(o, bool):
+            return self._literals[o]
+
+        elif isinstance(o, (str, int, float)):
+            return json.dumps(o, ensure_ascii=self._ensure_ascii)
+
+        else:
+            raise TypeError(o)
+
+    @classmethod
     @abc.abstractmethod
-    def render(self, i: I) -> None:
+    def render_str(cls, i: I, /, **kwargs: ta.Any) -> str:
         raise NotImplementedError
 
-    @classmethod
-    def render_str(cls, i: I, **kwargs: ta.Any) -> str:
-        out = io.StringIO()
-        cls(out, **kwargs).render(i)
-        return out.getvalue()
+
+##
+
+
+class JsonRendererOut(ta.Protocol):
+    def write(self, s: str) -> ta.Any: ...
 
 
 class JsonRenderer(AbstractJsonRenderer[ta.Any]):
+    def __init__(
+            self,
+            out: JsonRendererOut,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(**kwargs)
+
+        self._out = out
+
+    def _write(self, s: str) -> None:
+        if s:
+            self._out.write(s)
+
+    def _write_indent(self) -> None:
+        self._write(self._get_indent())
+
     def _render(
             self,
             o: ta.Any,
@@ -88,11 +127,8 @@ class JsonRenderer(AbstractJsonRenderer[ta.Any]):
         else:
             post = None
 
-        if o is None or isinstance(o, bool):
-            self._write(self._literals[o])
-
-        elif isinstance(o, (str, int, float)):
-            self._write(json.dumps(o))
+        if isinstance(o, SCALAR_TYPES):
+            self._write(self._format_scalar(o))  # type: ignore
 
         elif isinstance(o, ta.Mapping):
             self._write('{')
@@ -133,3 +169,9 @@ class JsonRenderer(AbstractJsonRenderer[ta.Any]):
 
     def render(self, o: ta.Any) -> None:
         self._render(o)
+
+    @classmethod
+    def render_str(cls, i: ta.Any, /, **kwargs: ta.Any) -> str:
+        out = io.StringIO()
+        cls(out, **kwargs).render(i)
+        return out.getvalue()

omlish/formats/json/stream/build.py

@@ -36,7 +36,7 @@ class JsonObjectBuilder:
         if self._stack:
             raise self.StateError
 
-    def _emit_value(self, v):
+    def _emit_value(self, v: ta.Any) -> ta.Iterable[ta.Any]:
         if not (stk := self._stack):
             return (v,)
 
@@ -60,7 +60,7 @@ class JsonObjectBuilder:
         else:
             raise self.StateError
 
-    def __call__(self, e: JsonStreamParserEvent) -> ta.Any:
+    def __call__(self, e: JsonStreamParserEvent) -> ta.Iterable[ta.Any]:
         stk = self._stack
 
         #

omlish/formats/json/stream/render.py

@@ -1,8 +1,8 @@
-import json
+import io
 import typing as ta
 
+from ..render import SCALAR_TYPES
 from ..render import AbstractJsonRenderer
-from ..render import JsonRendererOut
 from .parse import BeginArray
 from .parse import BeginObject
 from .parse import EndArray
@@ -17,7 +17,6 @@ from .parse import Key
 class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]]):
     def __init__(
             self,
-            out: JsonRendererOut,
             *,
             delimiter: str = '',
             sort_keys: bool = False,
@@ -28,7 +27,7 @@ class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]
 
         self._delimiter = delimiter
 
-        super().__init__(out, **kwargs)
+        super().__init__(**kwargs)
 
         self._stack: list[tuple[ta.Literal['OBJECT', 'ARRAY'], int]] = []
         self._need_delimit = False
@@ -37,41 +36,38 @@ class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]
             self,
             o: ta.Any,
             state: AbstractJsonRenderer.State = AbstractJsonRenderer.State.VALUE,
-    ) -> None:
+    ) -> ta.Generator[str, None, None]:
         if self._style is not None:
             pre, post = self._style(o, state)
-            self._write(pre)
+            yield pre
         else:
             post = None
 
-        if o is None or isinstance(o, bool):
-            self._write(self._literals[o])
-
-        elif isinstance(o, (str, int, float)):
-            self._write(json.dumps(o))
+        if isinstance(o, SCALAR_TYPES):
+            yield self._format_scalar(o)  # type: ignore
 
         else:
             raise TypeError(o)
 
         if post:
-            self._write(post)
+            yield post
 
-    def _render(self, e: JsonStreamParserEvent) -> None:
+    def _render(self, e: JsonStreamParserEvent) -> ta.Generator[str, None, None]:
         if self._need_delimit:
-            self._write(self._delimiter)
+            yield self._delimiter
             self._need_delimit = False
 
         if e != EndArray and self._stack and (tt := self._stack[-1])[0] == 'ARRAY':
             if tt[1]:
-                self._write(self._comma)
-            self._write_indent()
+                yield self._comma
+            yield self._get_indent()
 
             self._stack[-1] = ('ARRAY', tt[1] + 1)
 
         #
 
         if e is None or isinstance(e, (str, int, float, bool)):
-            self._render_value(e)
+            yield from self._render_value(e)
             if not self._stack:
                 self._need_delimit = True
 
@@ -79,7 +75,7 @@ class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]
 
         elif e is BeginObject:
             self._stack.append(('OBJECT', 0))
-            self._write('{')
+            yield '{'
             self._level += 1
 
         elif isinstance(e, Key):
@@ -87,10 +83,10 @@ class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]
                 raise Exception
 
             if tt[1]:
-                self._write(self._comma)
-            self._write_indent()
-            self._render_value(e.key, AbstractJsonRenderer.State.KEY)
-            self._write(self._colon)
+                yield self._comma
+            yield self._get_indent()
+            yield from self._render_value(e.key, AbstractJsonRenderer.State.KEY)
+            yield self._colon
 
             self._stack.append(('OBJECT', tt[1] + 1))
 
@@ -100,8 +96,8 @@ class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]
 
             self._level -= 1
             if tt[1]:
-                self._write_indent()
-            self._write('}')
+                yield self._get_indent()
+            yield '}'
             if not self._stack:
                 self._need_delimit = True
 
@@ -109,7 +105,7 @@ class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]
 
         elif e is BeginArray:
             self._stack.append(('ARRAY', 0))
-            self._write('[')
+            yield '['
             self._level += 1
 
         elif e is EndArray:
@@ -118,8 +114,8 @@ class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]
 
             self._level -= 1
             if tt[1]:
-                self._write_indent()
-            self._write(']')
+                yield self._get_indent()
+            yield ']'
             if not self._stack:
                 self._need_delimit = True
 
@@ -128,6 +124,13 @@ class StreamJsonRenderer(AbstractJsonRenderer[ta.Iterable[JsonStreamParserEvent]
         else:
             raise TypeError(e)
 
-    def render(self, events: ta.Iterable[JsonStreamParserEvent]) -> None:
+    def render(self, events: ta.Iterable[JsonStreamParserEvent]) -> ta.Generator[str, None, None]:
         for e in events:
-            self._render(e)
+            yield from self._render(e)
+
+    @classmethod
+    def render_str(cls, i: ta.Iterable[JsonStreamParserEvent], /, **kwargs: ta.Any) -> str:
+        out = io.StringIO()
+        for s in cls(**kwargs).render(i):
+            out.write(s)
+        return out.getvalue()

omlish/io/trampoline.py

@@ -1,7 +1,3 @@
-"""
-TODO:
- - https://docs.python.org/3/library/zlib.html#zlib.compressobj
-"""
 import abc
 import contextlib
 import io

omlish/specs/jmespath/ast.py

@@ -1,114 +1,119 @@
-# AST nodes have this structure:
-# {'type': <node type>', children: [], 'value': ''}
+import typing as ta
 
 
-def arithmetic_unary(operator, expression):
+class Node(ta.TypedDict):
+    type: str
+    children: list['Node']
+    value: ta.NotRequired[ta.Any]
+
+
+def arithmetic_unary(operator, expression) -> Node:
     return {'type': 'arithmetic_unary', 'children': [expression], 'value': operator}
 
 
-def arithmetic(operator, left, right):
+def arithmetic(operator, left, right) -> Node:
     return {'type': 'arithmetic', 'children': [left, right], 'value': operator}
 
 
-def assign(name, expr):
+def assign(name, expr) -> Node:
     return {'type': 'assign', 'children': [expr], 'value': name}
 
 
-def comparator(name, first, second):
+def comparator(name, first, second) -> Node:
     return {'type': 'comparator', 'children': [first, second], 'value': name}
 
 
-def current_node():
+def current_node() -> Node:
     return {'type': 'current', 'children': []}
 
 
-def root_node():
+def root_node() -> Node:
     return {'type': 'root', 'children': []}
 
 
-def expref(expression):
+def expref(expression) -> Node:
     return {'type': 'expref', 'children': [expression]}
 
 
-def function_expression(name, args):
+def function_expression(name, args) -> Node:
     return {'type': 'function_expression', 'children': args, 'value': name}
 
 
-def field(name):
+def field(name) -> Node:
     return {'type': 'field', 'children': [], 'value': name}
 
 
-def filter_projection(left, right, comparator):
+def filter_projection(left, right, comparator) -> Node:
     return {'type': 'filter_projection', 'children': [left, right, comparator]}
 
 
-def flatten(node):
+def flatten(node) -> Node:
     return {'type': 'flatten', 'children': [node]}
 
 
-def identity():
+def identity() -> Node:
     return {'type': 'identity', 'children': []}
 
 
-def index(index):
+def index(index) -> Node:
     return {'type': 'index', 'value': index, 'children': []}
 
 
-def index_expression(children):
+def index_expression(children) -> Node:
     return {'type': 'index_expression', 'children': children}
 
 
-def key_val_pair(key_name, node):
+def key_val_pair(key_name, node) -> Node:
     return {'type': 'key_val_pair', 'children': [node], 'value': key_name}
 
 
-def let_expression(bindings, expr):
+def let_expression(bindings, expr) -> Node:
     return {'type': 'let_expression', 'children': [*bindings, expr]}
 
 
-def literal(literal_value):
+def literal(literal_value) -> Node:
     return {'type': 'literal', 'value': literal_value, 'children': []}
 
 
-def multi_select_dict(nodes):
+def multi_select_dict(nodes) -> Node:
     return {'type': 'multi_select_dict', 'children': nodes}
 
 
-def multi_select_list(nodes):
+def multi_select_list(nodes) -> Node:
     return {'type': 'multi_select_list', 'children': nodes}
 
 
-def or_expression(left, right):
+def or_expression(left, right) -> Node:
     return {'type': 'or_expression', 'children': [left, right]}
 
 
-def and_expression(left, right):
+def and_expression(left, right) -> Node:
     return {'type': 'and_expression', 'children': [left, right]}
 
 
-def not_expression(expr):
+def not_expression(expr) -> Node:
     return {'type': 'not_expression', 'children': [expr]}
 
 
-def pipe(left, right):
+def pipe(left: Node, right: Node) -> Node:
     return {'type': 'pipe', 'children': [left, right]}
 
 
-def projection(left, right):
+def projection(left: Node, right: Node) -> Node:
     return {'type': 'projection', 'children': [left, right]}
 
 
-def subexpression(children):
+def subexpression(children) -> Node:
     return {'type': 'subexpression', 'children': children}
 
 
-def slice(start, end, step):  # noqa
+def slice(start, end, step) -> Node:  # noqa
     return {'type': 'slice', 'children': [start, end, step]}
 
 
-def value_projection(left, right):
+def value_projection(left: Node, right: Node) -> Node:
     return {'type': 'value_projection', 'children': [left, right]}
 
 
-def variable_ref(name):
+def variable_ref(name: str) -> Node:
     return {'type': 'variable_ref', 'children': [], 'value': name}

omlish/specs/jmespath/exceptions.py

@@ -1,3 +1,6 @@
+import typing as ta
+
+
 class JmespathError(ValueError):
     pass
 
@@ -10,15 +13,15 @@ class ParseError(JmespathError):
             lex_position,
             token_value,
             token_type,
-            msg=_ERROR_MESSAGE,
-    ):
+            msg: str = _ERROR_MESSAGE,
+    ) -> None:
         super().__init__(lex_position, token_value, token_type)
         self.lex_position = lex_position
         self.token_value = token_value
         self.token_type = token_type.upper()
         self.msg = msg
         # Whatever catches the ParseError can fill in the full expression
-        self.expression = None
+        self.expression: ta.Any = None
 
     def __str__(self):
         # self.lex_position +1 to account for the starting double quote char.
@@ -46,7 +49,7 @@ class IncompleteExpressionError(ParseError):
 
 
 class LexerError(ParseError):
-    def __init__(self, lexer_position, lexer_value, message, expression=None):
+    def __init__(self, lexer_position, lexer_value, message, expression: ta.Any | None = None):
         self.lexer_position = lexer_position
         self.lexer_value = lexer_value
         self.message = message

omlish/specs/jmespath/functions.py

@@ -44,6 +44,7 @@ def signature(*arguments):
 class FunctionRegistry(type):
     def __init__(cls, name, bases, attrs):
         cls._populate_function_table()
+
         super().__init__(name, bases, attrs)
 
     def _populate_function_table(cls):

omlish/specs/jmespath/lexer.py

@@ -3,8 +3,17 @@ import string
 import typing as ta
 import warnings
 
+from ... import check
 from .exceptions import EmptyExpressionError
 from .exceptions import LexerError
+from .visitor import Options
+
+
+class Token(ta.TypedDict):
+    type: str
+    value: ta.Any
+    start: int
+    end: int
 
 
 class Lexer:
@@ -33,10 +42,13 @@ class Lexer:
         '\u00f7': 'divide',
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
+        super().__init__()
+
         self._enable_legacy_literals = False
+        self._current: str | None = None
 
-    def tokenize(self, expression, options=None):
+    def tokenize(self, expression: str, options: Options | None = None) -> ta.Generator[Token, None, None]:
         if options is not None:
             self._enable_legacy_literals = options.enable_legacy_literals
 
@@ -205,18 +217,18 @@ class Lexer:
             'end': self._length,
         }
 
-    def _consume_number(self):
+    def _consume_number(self) -> str:
         start = self._position  # noqa
 
-        buff = self._current
+        buff = check.not_none(self._current)
         while self._next() in self.VALID_NUMBER:
-            buff += self._current
+            buff += check.not_none(self._current)
         return buff
 
-    def _consume_variable(self):
+    def _consume_variable(self) -> Token:
         start = self._position
 
-        buff = self._current
+        buff = check.not_none(self._current)
         self._next()
         if self._current not in self.START_IDENTIFIER:
             raise LexerError(
@@ -225,9 +237,9 @@ class Lexer:
                 message=f'Invalid variable starting character {self._current}',
             )
 
-        buff += self._current
+        buff += check.not_none(self._current)
         while self._next() in self.VALID_IDENTIFIER:
-            buff += self._current
+            buff += check.not_none(self._current)
 
         return {
             'type': 'variable',
@@ -236,21 +248,21 @@ class Lexer:
             'end': start + len(buff),
         }
 
-    def _peek_may_be_valid_unquoted_identifier(self):
+    def _peek_may_be_valid_unquoted_identifier(self) -> bool:
         if (self._position == self._length - 1):
             return False
         else:
             nxt = self._chars[self._position + 1]
             return nxt in self.START_IDENTIFIER
 
-    def _peek_is_next_digit(self):
+    def _peek_is_next_digit(self) -> bool:
         if (self._position == self._length - 1):
             return False
         else:
             nxt = self._chars[self._position + 1]
             return nxt in self.VALID_NUMBER
 
-    def _initialize_for_expression(self, expression):
+    def _initialize_for_expression(self, expression: str) -> None:
         if not expression:
             raise EmptyExpressionError
         self._position = 0
@@ -259,7 +271,7 @@ class Lexer:
         self._current = self._chars[self._position]
         self._length = len(self._expression)
 
-    def _next(self):
+    def _next(self) -> str | None:
         if self._position == self._length - 1:
             self._current = None
         else:
@@ -267,7 +279,7 @@ class Lexer:
             self._current = self._chars[self._position]
         return self._current
 
-    def _consume_until(self, delimiter):
+    def _consume_until(self, delimiter: str) -> str:
         # Consume until the delimiter is reached, allowing for the delimiter to be escaped with "\".
         start = self._position
 
@@ -293,12 +305,11 @@ class Lexer:
         self._next()
         return buff
 
-    def _consume_literal(self):
+    def _consume_literal(self) -> Token:
         start = self._position
 
         token = self._consume_until('`')
         lexeme = token.replace('\\`', '`')
-        parsed_json = None
         try:
             # Assume it is valid JSON and attempt to parse.
             parsed_json = json.loads(lexeme)
@@ -331,7 +342,7 @@ class Lexer:
             'end': token_len,
         }
 
-    def _consume_quoted_identifier(self):
+    def _consume_quoted_identifier(self) -> Token:
         start = self._position
 
         lexeme = '"' + self._consume_until('"') + '"'
@@ -352,7 +363,7 @@ class Lexer:
                 message=error_message,
             )
 
-    def _consume_raw_string_literal(self):
+    def _consume_raw_string_literal(self) -> Token:
         start = self._position
 
         lexeme = self._consume_until("'") \
@@ -367,10 +378,10 @@ class Lexer:
             'end': token_len,
         }
 
-    def _match_or_else(self, expected, match_type, else_type):
+    def _match_or_else(self, expected: str, match_type: str, else_type: str) -> Token:
         start = self._position
 
-        current = self._current
+        current = check.not_none(self._current)
         next_char = self._next()
         if next_char == expected:
             self._next()