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

omlish/specs/jmespath/parser.py

@@ -23,6 +23,7 @@ A few notes on the implementation.
 import random
 import typing as ta
 
+from ... import check
 from . import ast
 from . import exceptions
 from . import lexer
@@ -76,16 +77,18 @@ class Parser:
     _PROJECTION_STOP = 10
 
     # The _MAX_SIZE most recent expressions are cached in _CACHE dict.
-    _CACHE: dict = {}  # noqa
+    _CACHE: ta.ClassVar[dict[str, 'ParsedResult']] = {}  # noqa
     _MAX_SIZE = 128
 
-    def __init__(self, lookahead=2):
-        self.tokenizer = None
-        self._tokens = [None] * lookahead
+    def __init__(self, lookahead: int = 2) -> None:
+        super().__init__()
+
+        self._tokenizer: ta.Iterable[lexer.Token] | None = None
+        self._tokens: list[lexer.Token | None] = [None] * lookahead
         self._buffer_size = lookahead
         self._index = 0
 
-    def parse(self, expression, options=None):
+    def parse(self, expression: str, options: visitor.Options | None = None) -> 'ParsedResult':
         cached = self._CACHE.get(expression)
         if cached is not None:
             return cached
@@ -98,7 +101,7 @@ class Parser:
 
         return parsed_result
 
-    def _do_parse(self, expression, options=None):
+    def _do_parse(self, expression: str, options: visitor.Options | None = None) -> 'ParsedResult':
         try:
             return self._parse(expression, options)
 
@@ -114,15 +117,15 @@ class Parser:
             e.expression = expression
             raise
 
-    def _parse(self, expression, options=None):
-        self.tokenizer = lexer.Lexer().tokenize(expression, options)
-        self._tokens = list(self.tokenizer)
+    def _parse(self, expression: str, options: visitor.Options | None = None) -> 'ParsedResult':
+        self._tokenizer = lexer.Lexer().tokenize(expression, options)
+        self._tokens = list(self._tokenizer)
         self._index = 0
 
         parsed = self._expression(binding_power=0)
 
         if self._current_token() != 'eof':
-            t = self._lookahead_token(0)
+            t = check.not_none(self._lookahead_token(0))
             raise exceptions.ParseError(
                 t['start'],
                 t['value'],
@@ -132,8 +135,8 @@ class Parser:
 
         return ParsedResult(expression, parsed)
 
-    def _expression(self, binding_power=0):
-        left_token = self._lookahead_token(0)
+    def _expression(self, binding_power: int = 0) -> ast.Node:
+        left_token = check.not_none(self._lookahead_token(0))
 
         self._advance()
 
@@ -143,7 +146,7 @@ class Parser:
             self._error_nud_token,
         )
 
-        left = nud_function(left_token)
+        left = nud_function(left_token)  # noqa
 
         current_token = self._current_token()
         while binding_power < self.BINDING_POWER[current_token]:
@@ -153,7 +156,7 @@ class Parser:
                 None,
             )
             if led is None:
-                error_token = self._lookahead_token(0)
+                error_token = check.not_none(self._lookahead_token(0))
                 self._error_led_token(error_token)
 
             else:
@@ -163,29 +166,29 @@ class Parser:
 
         return left
 
-    def _token_nud_literal(self, token):
+    def _token_nud_literal(self, token: lexer.Token) -> ast.Node:
         return ast.literal(token['value'])
 
-    def _token_nud_variable(self, token):
+    def _token_nud_variable(self, token: lexer.Token) -> ast.Node:
         return ast.variable_ref(token['value'][1:])
 
-    def _token_nud_unquoted_identifier(self, token):
+    def _token_nud_unquoted_identifier(self, token: lexer.Token) -> ast.Node:
         if token['value'] == 'let' and self._current_token() == 'variable':
             return self._parse_let_expression()
         else:
             return ast.field(token['value'])
 
-    def _parse_let_expression(self):
+    def _parse_let_expression(self) -> ast.Node:
         bindings = []
         while True:
-            var_token = self._lookahead_token(0)
+            var_token = check.not_none(self._lookahead_token(0))
             # Strip off the '$'.
             varname = var_token['value'][1:]
             self._advance()
             self._match('assign')
             assign_expr = self._expression()
             bindings.append(ast.assign(varname, assign_expr))
-            if self._is_in_keyword(self._lookahead_token(0)):
+            if self._is_in_keyword(check.not_none(self._lookahead_token(0))):
                 self._advance()
                 break
             else:
@@ -193,18 +196,18 @@ class Parser:
         expr = self._expression()
         return ast.let_expression(bindings, expr)
 
-    def _is_in_keyword(self, token):
+    def _is_in_keyword(self, token: lexer.Token) -> bool:
         return (
             token['type'] == 'unquoted_identifier' and
             token['value'] == 'in'
         )
 
-    def _token_nud_quoted_identifier(self, token):
+    def _token_nud_quoted_identifier(self, token: lexer.Token) -> ast.Node:
         field = ast.field(token['value'])
 
         # You can't have a quoted identifier as a function name.
         if self._current_token() == 'lparen':
-            t = self._lookahead_token(0)
+            t = check.not_none(self._lookahead_token(0))
             raise exceptions.ParseError(
                 0,
                 t['value'],
@@ -214,7 +217,7 @@ class Parser:
 
         return field
 
-    def _token_nud_star(self, token):
+    def _token_nud_star(self, token: lexer.Token) -> ast.Node:
         left = ast.identity()
         if self._current_token() == 'rbracket':
             right = ast.identity()
@@ -222,34 +225,34 @@ class Parser:
             right = self._parse_projection_rhs(self.BINDING_POWER['star'])
         return ast.value_projection(left, right)
 
-    def _token_nud_filter(self, token):
+    def _token_nud_filter(self, token: lexer.Token) -> ast.Node:
         return self._token_led_filter(ast.identity())
 
-    def _token_nud_lbrace(self, token):
+    def _token_nud_lbrace(self, token: lexer.Token) -> ast.Node:
         return self._parse_multi_select_hash()
 
-    def _token_nud_lparen(self, token):
+    def _token_nud_lparen(self, token: lexer.Token) -> ast.Node:
         expression = self._expression()
         self._match('rparen')
         return expression
 
-    def _token_nud_minus(self, token):
+    def _token_nud_minus(self, token: lexer.Token) -> ast.Node:
         return self._parse_arithmetic_unary(token)
 
-    def _token_nud_plus(self, token):
+    def _token_nud_plus(self, token: lexer.Token) -> ast.Node:
         return self._parse_arithmetic_unary(token)
 
-    def _token_nud_flatten(self, token):
+    def _token_nud_flatten(self, token: lexer.Token) -> ast.Node:
         left = ast.flatten(ast.identity())
         right = self._parse_projection_rhs(
             self.BINDING_POWER['flatten'])
         return ast.projection(left, right)
 
-    def _token_nud_not(self, token):
+    def _token_nud_not(self, token: lexer.Token) -> ast.Node:
         expr = self._expression(self.BINDING_POWER['not'])
         return ast.not_expression(expr)
 
-    def _token_nud_lbracket(self, token):
+    def _token_nud_lbracket(self, token: lexer.Token) -> ast.Node:
         if self._current_token() in ['number', 'colon']:
             right = self._parse_index_expression()
             # We could optimize this and remove the identity() node. We don't really need an index_expression node, we
@@ -265,7 +268,7 @@ class Parser:
         else:
             return self._parse_multi_select_list()
 
-    def _parse_index_expression(self):
+    def _parse_index_expression(self) -> ast.Node:
         # We're here:
         # [<current>
         #  ^
@@ -275,12 +278,12 @@ class Parser:
 
         else:
             # Parse the syntax [number]
-            node = ast.index(self._lookahead_token(0)['value'])
+            node = ast.index(check.not_none(self._lookahead_token(0))['value'])
             self._advance()
             self._match('rbracket')
             return node
 
-    def _parse_slice_expression(self):
+    def _parse_slice_expression(self) -> ast.Node:
         # [start:end:step]
         # Where start, end, and step are optional. The last colon is optional as well.
         parts = [None, None, None]
@@ -290,32 +293,32 @@ class Parser:
             if current_token == 'colon':  # noqa
                 index += 1
                 if index == 3:
-                    self._raise_parse_error_for_token(self._lookahead_token(0), 'syntax error')
+                    self._raise_parse_error_for_token(check.not_none(self._lookahead_token(0)), 'syntax error')
                 self._advance()
 
             elif current_token == 'number':  # noqa
-                parts[index] = self._lookahead_token(0)['value']
+                parts[index] = check.not_none(self._lookahead_token(0))['value']
                 self._advance()
 
             else:
-                self._raise_parse_error_for_token(self._lookahead_token(0), 'syntax error')
+                self._raise_parse_error_for_token(check.not_none(self._lookahead_token(0)), 'syntax error')
 
             current_token = self._current_token()
 
         self._match('rbracket')
         return ast.slice(*parts)
 
-    def _token_nud_current(self, token):
+    def _token_nud_current(self, token: lexer.Token) -> ast.Node:
         return ast.current_node()
 
-    def _token_nud_root(self, token):
+    def _token_nud_root(self, token: lexer.Token) -> ast.Node:
         return ast.root_node()
 
-    def _token_nud_expref(self, token):
+    def _token_nud_expref(self, token: lexer.Token) -> ast.Node:
         expression = self._expression(self.BINDING_POWER['expref'])
         return ast.expref(expression)
 
-    def _token_led_dot(self, left):
+    def _token_led_dot(self, left: ast.Node) -> ast.Node:
         if self._current_token() != 'star':
             right = self._parse_dot_rhs(self.BINDING_POWER['dot'])
             if left['type'] == 'subexpression':
@@ -331,24 +334,24 @@ class Parser:
             right = self._parse_projection_rhs(self.BINDING_POWER['dot'])
             return ast.value_projection(left, right)
 
-    def _token_led_pipe(self, left):
+    def _token_led_pipe(self, left: ast.Node) -> ast.Node:
         right = self._expression(self.BINDING_POWER['pipe'])
         return ast.pipe(left, right)
 
-    def _token_led_or(self, left):
+    def _token_led_or(self, left: ast.Node) -> ast.Node:
         right = self._expression(self.BINDING_POWER['or'])
         return ast.or_expression(left, right)
 
-    def _token_led_and(self, left):
+    def _token_led_and(self, left: ast.Node) -> ast.Node:
         right = self._expression(self.BINDING_POWER['and'])
         return ast.and_expression(left, right)
 
-    def _token_led_lparen(self, left):
+    def _token_led_lparen(self, left: ast.Node) -> ast.Node:
         if left['type'] != 'field':
             #  0 - first func arg or closing paren.
             # -1 - '(' token
             # -2 - invalid function "name".
-            prev_t = self._lookahead_token(-2)
+            prev_t = check.not_none(self._lookahead_token(-2))
             raise exceptions.ParseError(
                 prev_t['start'],
                 prev_t['value'],
@@ -368,7 +371,7 @@ class Parser:
         function_node = ast.function_expression(name, args)
         return function_node
 
-    def _token_led_filter(self, left):
+    def _token_led_filter(self, left: ast.Node) -> ast.Node:
         # Filters are projections.
         condition = self._expression(0)
         self._match('rbracket')
@@ -378,52 +381,52 @@ class Parser:
             right = self._parse_projection_rhs(self.BINDING_POWER['filter'])
         return ast.filter_projection(left, right, condition)
 
-    def _token_led_eq(self, left):
+    def _token_led_eq(self, left: ast.Node) -> ast.Node:
         return self._parse_comparator(left, 'eq')
 
-    def _token_led_ne(self, left):
+    def _token_led_ne(self, left: ast.Node) -> ast.Node:
         return self._parse_comparator(left, 'ne')
 
-    def _token_led_gt(self, left):
+    def _token_led_gt(self, left: ast.Node) -> ast.Node:
         return self._parse_comparator(left, 'gt')
 
-    def _token_led_gte(self, left):
+    def _token_led_gte(self, left: ast.Node) -> ast.Node:
         return self._parse_comparator(left, 'gte')
 
-    def _token_led_lt(self, left):
+    def _token_led_lt(self, left: ast.Node) -> ast.Node:
         return self._parse_comparator(left, 'lt')
 
-    def _token_led_lte(self, left):
+    def _token_led_lte(self, left: ast.Node) -> ast.Node:
         return self._parse_comparator(left, 'lte')
 
-    def _token_led_div(self, left):
+    def _token_led_div(self, left: ast.Node) -> ast.Node:
         return self._parse_arithmetic(left, 'div')
 
-    def _token_led_divide(self, left):
+    def _token_led_divide(self, left: ast.Node) -> ast.Node:
         return self._parse_arithmetic(left, 'divide')
 
-    def _token_led_minus(self, left):
+    def _token_led_minus(self, left: ast.Node) -> ast.Node:
         return self._parse_arithmetic(left, 'minus')
 
-    def _token_led_modulo(self, left):
+    def _token_led_modulo(self, left: ast.Node) -> ast.Node:
         return self._parse_arithmetic(left, 'modulo')
 
-    def _token_led_multiply(self, left):
+    def _token_led_multiply(self, left: ast.Node) -> ast.Node:
         return self._parse_arithmetic(left, 'multiply')
 
-    def _token_led_plus(self, left):
+    def _token_led_plus(self, left: ast.Node) -> ast.Node:
         return self._parse_arithmetic(left, 'plus')
 
-    def _token_led_star(self, left):
+    def _token_led_star(self, left: ast.Node) -> ast.Node:
         return self._parse_arithmetic(left, 'multiply')
 
-    def _token_led_flatten(self, left):
+    def _token_led_flatten(self, left: ast.Node) -> ast.Node:
         left = ast.flatten(left)
         right = self._parse_projection_rhs(self.BINDING_POWER['flatten'])
         return ast.projection(left, right)
 
-    def _token_led_lbracket(self, left):
-        token = self._lookahead_token(0)
+    def _token_led_lbracket(self, left: ast.Node) -> ast.Node:
+        token = check.not_none(self._lookahead_token(0))
         if token['type'] in ['number', 'colon']:
             right = self._parse_index_expression()
             if left['type'] == 'index_expression':
@@ -442,7 +445,7 @@ class Parser:
             right = self._parse_projection_rhs(self.BINDING_POWER['star'])
             return ast.projection(left, right)
 
-    def _project_if_slice(self, left, right):
+    def _project_if_slice(self, left: ast.Node, right: ast.Node) -> ast.Node:
         index_expr = ast.index_expression([left, right])
         if right['type'] == 'slice':
             return ast.projection(
@@ -452,20 +455,20 @@ class Parser:
         else:
             return index_expr
 
-    def _parse_comparator(self, left, comparator):
+    def _parse_comparator(self, left: ast.Node, comparator: str) -> ast.Node:
         right = self._expression(self.BINDING_POWER[comparator])
         return ast.comparator(comparator, left, right)
 
-    def _parse_arithmetic_unary(self, token):
+    def _parse_arithmetic_unary(self, token: lexer.Token) -> ast.Node:
         expression = self._expression(self.BINDING_POWER[token['type']])
         return ast.arithmetic_unary(token['type'], expression)
 
-    def _parse_arithmetic(self, left, operator):
+    def _parse_arithmetic(self, left: ast.Node, operator: str) -> ast.Node:
         right = self._expression(self.BINDING_POWER[operator])
         return ast.arithmetic(operator, left, right)
 
-    def _parse_multi_select_list(self):
-        expressions = []
+    def _parse_multi_select_list(self) -> ast.Node:
+        expressions: list[ast.Node] = []
         while True:
             expression = self._expression()
             expressions.append(expression)
@@ -476,10 +479,10 @@ class Parser:
         self._match('rbracket')
         return ast.multi_select_list(expressions)
 
-    def _parse_multi_select_hash(self):
+    def _parse_multi_select_hash(self) -> ast.Node:
         pairs = []
         while True:
-            key_token = self._lookahead_token(0)
+            key_token = check.not_none(self._lookahead_token(0))
 
             # Before getting the token value, verify it's an identifier.
             self._match_multiple_tokens(token_types=['quoted_identifier', 'unquoted_identifier'])
@@ -500,7 +503,7 @@ class Parser:
 
         return ast.multi_select_dict(nodes=pairs)
 
-    def _parse_projection_rhs(self, binding_power):
+    def _parse_projection_rhs(self, binding_power: int) -> ast.Node:
         # Parse the right hand side of the projection.
         if self.BINDING_POWER[self._current_token()] < self._PROJECTION_STOP:
             # BP of 10 are all the tokens that stop a projection.
@@ -517,11 +520,11 @@ class Parser:
             right = self._parse_dot_rhs(binding_power)
 
         else:
-            self._raise_parse_error_for_token(self._lookahead_token(0), 'syntax error')
+            self._raise_parse_error_for_token(check.not_none(self._lookahead_token(0)), 'syntax error')
 
         return right
 
-    def _parse_dot_rhs(self, binding_power):
+    def _parse_dot_rhs(self, binding_power: int) -> ast.Node:
         # From the grammar:
         # expression '.' ( identifier /
         #                  multi-select-list /
@@ -544,13 +547,13 @@ class Parser:
             return self._parse_multi_select_hash()
 
         else:
-            t = self._lookahead_token(0)
+            t = check.not_none(self._lookahead_token(0))
             allowed = ['quoted_identifier', 'unquoted_identifier', 'lbracket', 'lbrace']
             msg = f'Expecting: {allowed}, got: {t["type"]}'
             self._raise_parse_error_for_token(t, msg)
             raise RuntimeError  # noqa
 
-    def _error_nud_token(self, token):
+    def _error_nud_token(self, token: lexer.Token) -> ta.NoReturn:
         if token['type'] == 'eof':
             raise exceptions.IncompleteExpressionError(
                 token['start'],
@@ -560,10 +563,10 @@ class Parser:
 
         self._raise_parse_error_for_token(token, 'invalid token')
 
-    def _error_led_token(self, token):
+    def _error_led_token(self, token: lexer.Token) -> ta.NoReturn:
         self._raise_parse_error_for_token(token, 'invalid token')
 
-    def _match(self, token_type=None):
+    def _match(self, token_type: str | None = None) -> None:
         # inline'd self._current_token()
         if self._current_token() == token_type:
             # inline'd self._advance()
@@ -571,24 +574,24 @@ class Parser:
         else:
             self._raise_parse_error_maybe_eof(token_type, self._lookahead_token(0))
 
-    def _match_multiple_tokens(self, token_types):
+    def _match_multiple_tokens(self, token_types: ta.Container[str]) -> None:
         if self._current_token() not in token_types:
             self._raise_parse_error_maybe_eof(token_types, self._lookahead_token(0))
         self._advance()
 
-    def _advance(self):
+    def _advance(self) -> None:
         self._index += 1
 
-    def _current_token(self):
-        return self._tokens[self._index]['type']  # type: ignore
+    def _current_token(self) -> str:
+        return check.not_none(self._tokens[self._index])['type']
 
-    def _lookahead(self, number):
-        return self._tokens[self._index + number]['type']  # noqa
+    def _lookahead(self, number: int) -> str:
+        return check.not_none(self._tokens[self._index + number])['type']
 
-    def _lookahead_token(self, number):
+    def _lookahead_token(self, number: int) -> lexer.Token | None:
         return self._tokens[self._index + number]
 
-    def _raise_parse_error_for_token(self, token, reason) -> ta.NoReturn:
+    def _raise_parse_error_for_token(self, token: lexer.Token, reason: str) -> ta.NoReturn:
         lex_position = token['start']
         actual_value = token['value']
         actual_type = token['type']
@@ -631,15 +634,17 @@ class Parser:
 
 
 class ParsedResult:
-    def __init__(self, expression, parsed):
+    def __init__(self, expression: str, parsed: ast.Node) -> None:
+        super().__init__()
+
         self.expression = expression
         self.parsed = parsed
 
-    def search(self, value, options=None):
+    def search(self, value: ta.Any, options: visitor.Options | None = None) -> ta.Any:
         evaluator = visitor.TreeInterpreter(options)
         return evaluator.evaluate(self.parsed, value)
 
-    def _render_dot_file(self):
+    def _render_dot_file(self) -> str:
         """
         Render the parsed AST as a dot file.
 
@@ -652,13 +657,13 @@ class ParsedResult:
         contents = renderer.visit(self.parsed)
         return contents
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return repr(self.parsed)
 
 
-def compile(expression, options=None):  # noqa
+def compile(expression: str, options: visitor.Options | None = None) -> ParsedResult:  # noqa
     return Parser().parse(expression, options=options)
 
 
-def search(expression, data, options=None):
+def search(expression: str, data: ta.Any, options: visitor.Options | None = None) -> ta.Any:
     return compile(expression, options).search(data, options=options)

omlish/specs/jmespath/scope.py

@@ -9,6 +9,8 @@ class ScopedChainDict:
     """
 
     def __init__(self, *scopes):
+        super().__init__()
+
         # The scopes are evaluated starting at the top of the stack (the most recently pushed scope via .push_scope()).
         # If we use a normal list() and push/pop scopes by adding/removing to the end of the list, we'd have to always
         # call reversed(self._scopes) whenever we resolve a key, because the end of the list is the top of the stack.

omlish/specs/jmespath/visitor.py

@@ -4,17 +4,18 @@ import typing as ta
 
 from . import exceptions
 from . import functions
+from .ast import Node
 from .scope import ScopedChainDict
 
 
-def _equals(x, y):
+def _equals(x: ta.Any, y: ta.Any) -> bool:
     if _is_special_number_case(x, y):
         return False
     else:
         return x == y
 
 
-def _is_special_number_case(x, y):
+def _is_special_number_case(x: ta.Any, y: ta.Any) -> bool | None:
     # We need to special case comparing 0 or 1 to True/False.  While normally comparing any integer other than 0/1 to
     # True/False will always return False.  However 0/1 have this:
     # >>> 0 == True
@@ -39,13 +40,13 @@ def _is_special_number_case(x, y):
         return None
 
 
-def _is_comparable(x):
+def _is_comparable(x: ta.Any) -> bool:
     # The spec doesn't officially support string types yet, but enough people are relying on this behavior that it's
     # been added back.  This should eventually become part of the official spec.
     return _is_actual_number(x) or isinstance(x, str)
 
 
-def _is_actual_number(x):
+def _is_actual_number(x: ta.Any) -> bool:
     # We need to handle python's quirkiness with booleans, specifically:
     #
     # >>> isinstance(False, int)
@@ -62,10 +63,12 @@ class Options:
 
     def __init__(
             self,
-            dict_cls=None,
+            dict_cls: type | None = None,
             custom_functions=None,
-            enable_legacy_literals=False,
-    ):
+            enable_legacy_literals: bool = False,
+    ) -> None:
+        super().__init__()
+
         #: The class to use when creating a dict.  The interpreter may create dictionaries during the evaluation of a
         #  Jmespath expression.  For example, a multi-select hash will create a dictionary.  By default we use a dict()
         #  type. You can set this value to change what dict type is used. The most common reason you would change this
@@ -82,6 +85,7 @@ class Options:
 
 class _Expression:
     def __init__(self, expression, interpreter):
+        super().__init__()
         self.expression = expression
         self.interpreter = interpreter
 
@@ -91,6 +95,7 @@ class _Expression:
 
 class Visitor:
     def __init__(self):
+        super().__init__()
         self._method_cache = {}
 
     def visit(self, node, *args, **kwargs):
@@ -156,7 +161,7 @@ class TreeInterpreter(Visitor):
     def default_visit(self, node, *args, **kwargs):
         raise NotImplementedError(node['type'])
 
-    def evaluate(self, ast, root):
+    def evaluate(self, ast, root: Node) -> ta.Any:
         self._root = root
         return self.visit(ast, root)
 

omlish/text/random.py

@@ -0,0 +1,7 @@
+import random
+import string
+
+
+def generate_random_text(size: int) -> str:
+    chars = string.ascii_letters + string.digits + string.punctuation
+    return ''.join(random.choices(chars, k=size))

{omlish-0.0.0.dev104.dist-info → omlish-0.0.0.dev106.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev104
+Version: 0.0.0.dev106
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause