omlish 0.0.0.dev117__py3-none-any.whl → 0.0.0.dev118__py3-none-any.whl

omlish/specs/jmespath/scope.py

@@ -1,14 +1,18 @@
-import collections
+import typing as ta
 
 
-class ScopedChainDict:
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+class ScopedChainDict(ta.Generic[K, V]):
     """
     Dictionary that can delegate lookups to multiple dicts. This provides a basic get/set dict interface that is backed
     by multiple dicts.  Each dict is searched from the top most (most recently pushed) scope dict until a match is
     found.
     """
 
-    def __init__(self, *scopes):
+    def __init__(self, *scopes: ta.Mapping[K, V]) -> None:
         super().__init__()
 
         # The scopes are evaluated starting at the top of the stack (the most recently pushed scope via .push_scope()).
@@ -16,22 +20,22 @@ class ScopedChainDict:
         # call reversed(self._scopes) whenever we resolve a key, because the end of the list is the top of the stack.
         # To avoid this, we're using a deque so we can append to the front of the list via .appendleft() in constant
         # time, and iterate over scopes without having to do so with a reversed() call each time.
-        self._scopes = collections.deque(scopes)
+        self._scopes: list[ta.Mapping[K, V]] = list(reversed(scopes))
 
-    def __getitem__(self, key):
-        for scope in self._scopes:
+    def __getitem__(self, key: K) -> V:
+        for scope in reversed(self._scopes):
             if key in scope:
                 return scope[key]
         raise KeyError(key)
 
-    def get(self, key, default=None):
+    def get(self, key: K, default: V | None = None) -> V | None:
         try:
             return self[key]
         except KeyError:
             return default
 
-    def push_scope(self, scope):
-        self._scopes.appendleft(scope)
+    def push_scope(self, scope: ta.Mapping[K, V]) -> None:
+        self._scopes.append(scope)
 
-    def pop_scope(self):
-        self._scopes.popleft()
+    def pop_scope(self) -> None:
+        self._scopes.pop()

omlish/specs/jmespath/visitor.py

@@ -2,12 +2,54 @@ import numbers
 import operator
 import typing as ta
 
-from . import exceptions
-from . import functions
+from ... import check
+from ... import lang
+from .ast import AndExpression
+from .ast import Arithmetic
+from .ast import ArithmeticUnary
+from .ast import Assign
+from .ast import Comparator
+from .ast import CurrentNode
+from .ast import Expref
+from .ast import Field
+from .ast import FilterProjection
+from .ast import Flatten
+from .ast import FunctionExpression
+from .ast import Identity
+from .ast import Index
+from .ast import IndexExpression
+from .ast import KeyValPair
+from .ast import LetExpression
+from .ast import Literal
+from .ast import MultiSelectDict
+from .ast import MultiSelectList
 from .ast import Node
+from .ast import NotExpression
+from .ast import OrExpression
+from .ast import Pipe
+from .ast import Projection
+from .ast import RootNode
+from .ast import Slice
+from .ast import Subexpression
+from .ast import ValueProjection
+from .ast import VariableRef
+from .exceptions import UndefinedVariableError
+from .functions import DefaultFunctions
+from .functions import Functions
 from .scope import ScopedChainDict
 
 
+if ta.TYPE_CHECKING:
+    import html
+    import json
+else:
+    html = lang.proxy_import('html')
+    json = lang.proxy_import('json')
+
+
+##
+
+
 def _equals(x: ta.Any, y: ta.Any) -> bool:
     if _is_special_number_case(x, y):
         return False
@@ -58,58 +100,69 @@ def _is_actual_number(x: ta.Any) -> bool:
     return isinstance(x, numbers.Number)
 
 
+def node_type(n: Node) -> str:
+    return lang.snake_case(type(n).__name__)
+
+
+##
+
+
+class Visitor:
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._method_cache: dict[str, ta.Callable] = {}
+
+    def visit(self, node: Node, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
+        nty = node_type(node)
+        method = self._method_cache.get(nty)
+        if method is None:
+            method = check.not_none(getattr(self, f'visit_{nty}', self.default_visit))
+            self._method_cache[nty] = method
+        return method(node, *args, **kwargs)
+
+    def default_visit(self, node, *args, **kwargs):
+        raise NotImplementedError('default_visit')
+
+
+##
+
+
 class Options:
     """Options to control how a Jmespath function is evaluated."""
 
     def __init__(
             self,
             dict_cls: type | None = None,
-            custom_functions=None,
+            custom_functions: Functions | None = None,
             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
-        #  is if you want to set a collections.OrderedDict so that you can have predictable key ordering.
+        # 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 is
+        # if you want to set a collections.OrderedDict so that you can have predictable key ordering.
         self.dict_cls = dict_cls
         self.custom_functions = custom_functions
 
-        #: The flag to enable pre-JEP-12 literal compatibility.
-        #  JEP-12 deprecates `foo` -> "foo" syntax.
-        #  Valid expressions MUST use: `"foo"` -> "foo"
-        #  Setting this flag to `True` enables support for legacy syntax.
+        # The flag to enable pre-JEP-12 literal compatibility.
+        # JEP-12 deprecates `foo` -> "foo" syntax.
+        # Valid expressions MUST use: `"foo"` -> "foo"
+        # Setting this flag to `True` enables support for legacy syntax.
         self.enable_legacy_literals = enable_legacy_literals
 
 
 class _Expression:
-    def __init__(self, expression, interpreter):
+    def __init__(self, expression: Node, interpreter: 'TreeInterpreter') -> None:
         super().__init__()
         self.expression = expression
         self.interpreter = interpreter
 
-    def visit(self, node, *args, **kwargs):
+    def visit(self, node: Node, *args: ta.Any, **kwargs: ta.Any) -> ta.Any:
         return self.interpreter.visit(node, *args, **kwargs)
 
 
-class Visitor:
-    def __init__(self):
-        super().__init__()
-        self._method_cache = {}
-
-    def visit(self, node, *args, **kwargs):
-        node_type = node['type']
-        method = self._method_cache.get(node_type)
-        if method is None:
-            method = getattr(self, f'visit_{node["type"]}', self.default_visit)
-            self._method_cache[node_type] = method
-        return method(node, *args, **kwargs)  # type: ignore
-
-    def default_visit(self, node, *args, **kwargs):
-        raise NotImplementedError('default_visit')
-
-
 class TreeInterpreter(Visitor):
     COMPARATOR_FUNC: ta.Mapping[str, ta.Callable] = {
         'eq': _equals,
@@ -120,7 +173,10 @@ class TreeInterpreter(Visitor):
         'gte': operator.ge,
     }
 
-    _EQUALITY_OPS: ta.Sequence[str] = ['eq', 'ne']
+    _EQUALITY_OPS: ta.AbstractSet[str] = {
+        'eq',
+        'ne',
+    }
 
     _ARITHMETIC_UNARY_FUNC: ta.Mapping[str, ta.Callable] = {
         'minus': operator.neg,
@@ -136,115 +192,113 @@ class TreeInterpreter(Visitor):
         'plus': operator.add,
     }
 
-    MAP_TYPE = dict
-
-    def __init__(self, options=None):
+    def __init__(self, options: Options | None = None) -> None:
         super().__init__()
 
-        self._dict_cls = self.MAP_TYPE
+        self._dict_cls: type = dict
 
         if options is None:
             options = Options()
         self._options = options
 
         if options.dict_cls is not None:
-            self._dict_cls = self._options.dict_cls
+            self._dict_cls = options.dict_cls
 
         if options.custom_functions is not None:
-            self._functions = self._options.custom_functions
+            self._functions: Functions = options.custom_functions
         else:
-            self._functions = functions.Functions()
+            self._functions = DefaultFunctions()
 
-        self._root = None
-        self._scope = ScopedChainDict()
+        self._root: Node | None = None
+        self._scope: ScopedChainDict = ScopedChainDict()
 
-    def default_visit(self, node, *args, **kwargs):
-        raise NotImplementedError(node['type'])
+    def default_visit(self, node: Node, *args: ta.Any, **kwargs: ta.Any) -> ta.NoReturn:
+        raise NotImplementedError(node_type(node))
 
-    def evaluate(self, ast, root: Node) -> ta.Any:
+    def evaluate(self, ast: Node, root: Node) -> ta.Any:
         self._root = root
         return self.visit(ast, root)
 
-    def visit_subexpression(self, node, value):
+    def visit_subexpression(self, node: Subexpression, value: ta.Any) -> ta.Any:
         result = value
-        for child in node['children']:
+        for child in node.children_nodes:
             result = self.visit(child, result)
             if result is None:
                 return None
         return result
 
-    def visit_field(self, node, value):
+    def visit_field(self, node: Field, value: ta.Any) -> ta.Any:
         try:
-            return value.get(node['value'])
+            return value.get(node.name)
         except AttributeError:
             return None
 
-    def visit_comparator(self, node, value):
+    def visit_comparator(self, node: Comparator, value: ta.Any) -> ta.Any:
         # Common case: comparator is == or !=
-        comparator_func = self.COMPARATOR_FUNC[node['value']]
-        if node['value'] in self._EQUALITY_OPS:
+        comparator_func = self.COMPARATOR_FUNC[node.name]
+        if node.name in self._EQUALITY_OPS:
             return comparator_func(
-                self.visit(node['children'][0], value),
-                self.visit(node['children'][1], value),
+                self.visit(node.first, value),
+                self.visit(node.second, value),
             )
 
         else:
             # Ordering operators are only valid for numbers. Evaluating any other type with a comparison operator will
             # yield a None value.
-            left = self.visit(node['children'][0], value)
-            right = self.visit(node['children'][1], value)
+            left = self.visit(node.first, value)
+            right = self.visit(node.second, value)
             # num_types = (int, float)
             if not (_is_comparable(left) and _is_comparable(right)):
                 return None
             return comparator_func(left, right)
 
-    def visit_arithmetic_unary(self, node, value):
-        operation = self._ARITHMETIC_UNARY_FUNC[node['value']]
+    def visit_arithmetic_unary(self, node: ArithmeticUnary, value: ta.Any) -> ta.Any:
+        operation = self._ARITHMETIC_UNARY_FUNC[node.operator]
         return operation(
-            self.visit(node['children'][0], value),
+            self.visit(node.expression, value),
         )
 
-    def visit_arithmetic(self, node, value):
-        operation = self._ARITHMETIC_FUNC[node['value']]
+    def visit_arithmetic(self, node: Arithmetic, value: ta.Any) -> ta.Any:
+        operation = self._ARITHMETIC_FUNC[node.operator]
         return operation(
-            self.visit(node['children'][0], value),
-            self.visit(node['children'][1], value),
+            self.visit(node.left, value),
+            self.visit(node.right, value),
         )
 
-    def visit_current(self, node, value):
+    def visit_current_node(self, node: CurrentNode, value: ta.Any) -> ta.Any:
         return value
 
-    def visit_root(self, node, value):
+    def visit_root_node(self, node: RootNode, value: ta.Any) -> ta.Any:
         return self._root
 
-    def visit_expref(self, node, value):
-        return _Expression(node['children'][0], self)
+    def visit_expref(self, node: Expref, value: ta.Any) -> ta.Any:
+        return _Expression(node.expression, self)
 
-    def visit_function_expression(self, node, value):
+    def visit_function_expression(self, node: FunctionExpression, value: ta.Any) -> ta.Any:
         resolved_args = []
-        for child in node['children']:
+        for child in node.args:
             current = self.visit(child, value)
             resolved_args.append(current)
 
-        return self._functions.call_function(node['value'], resolved_args)
+        return self._functions.call_function(node.name, resolved_args)
 
-    def visit_filter_projection(self, node, value):
-        base = self.visit(node['children'][0], value)
+    def visit_filter_projection(self, node: FilterProjection, value: ta.Any) -> ta.Any:
+        base = self.visit(node.left, value)
         if not isinstance(base, list):
             return None
 
-        comparator_node = node['children'][2]
+        comparator_node = node.comparator
         collected = []
         for element in base:
             if self._is_true(self.visit(comparator_node, element)):
-                current = self.visit(node['children'][1], element)
+                current = self.visit(node.right, element)
                 if current is not None:
                     collected.append(current)
 
         return collected
 
-    def visit_flatten(self, node, value):
-        base = self.visit(node['children'][0], value)
+    def visit_flatten(self, node: Flatten, value: ta.Any) -> ta.Any:
+        base = self.visit(node.node, value)
         if not isinstance(base, list):
             # Can't flatten the object if it's not a list.
             return None
@@ -258,77 +312,74 @@ class TreeInterpreter(Visitor):
 
         return merged_list
 
-    def visit_identity(self, node, value):
+    def visit_identity(self, node: Identity, value: ta.Any) -> ta.Any:
         return value
 
-    def visit_index(self, node, value):
+    def visit_index(self, node: Index, value: ta.Any) -> ta.Any:
         # Even though we can index strings, we don't want to support that.
         if not isinstance(value, list):
             return None
 
         try:
-            return value[node['value']]
+            return value[node.index]
         except IndexError:
             return None
 
-    def visit_index_expression(self, node, value):
+    def visit_index_expression(self, node: IndexExpression, value: ta.Any) -> ta.Any:
         result = value
-        for child in node['children']:
+        for child in node.nodes:
             result = self.visit(child, result)
 
         return result
 
-    def visit_slice(self, node, value):
+    def visit_slice(self, node: Slice, value: ta.Any) -> ta.Any:
         if isinstance(value, str):
-            start = node['children'][0]
-            end = node['children'][1]
-            step = node['children'][2]
-            return value[start:end:step]
+            return value[node.start:node.end:node.step]
 
         if not isinstance(value, list):
             return None
 
-        s = slice(*node['children'])
+        s = slice(node.start, node.end, node.step)
         return value[s]
 
-    def visit_key_val_pair(self, node, value):
-        return self.visit(node['children'][0], value)
+    def visit_key_val_pair(self, node: KeyValPair, value: ta.Any) -> ta.Any:
+        return self.visit(node.node, value)
 
-    def visit_literal(self, node, value):
-        return node['value']
+    def visit_literal(self, node: Literal, value: ta.Any):
+        return node.literal_value
 
-    def visit_multi_select_dict(self, node, value):
+    def visit_multi_select_dict(self, node: MultiSelectDict, value: ta.Any) -> ta.Any:
         collected = self._dict_cls()
-        for child in node['children']:
-            collected[child['value']] = self.visit(child, value)
+        for child in node.nodes:
+            collected[child.key_name] = self.visit(child, value)
 
         return collected
 
-    def visit_multi_select_list(self, node, value):
+    def visit_multi_select_list(self, node: MultiSelectList, value: ta.Any) -> ta.Any:
         collected = []
-        for child in node['children']:
+        for child in node.nodes:
             collected.append(self.visit(child, value))
 
         return collected
 
-    def visit_or_expression(self, node, value):
-        matched = self.visit(node['children'][0], value)
+    def visit_or_expression(self, node: OrExpression, value: ta.Any) -> ta.Any:
+        matched = self.visit(node.left, value)
 
         if self._is_false(matched):
-            matched = self.visit(node['children'][1], value)
+            matched = self.visit(node.right, value)
 
         return matched
 
-    def visit_and_expression(self, node, value):
-        matched = self.visit(node['children'][0], value)
+    def visit_and_expression(self, node: AndExpression, value: ta.Any) -> ta.Any:
+        matched = self.visit(node.left, value)
 
         if self._is_false(matched):
             return matched
 
-        return self.visit(node['children'][1], value)
+        return self.visit(node.right, value)
 
-    def visit_not_expression(self, node, value):
-        original_result = self.visit(node['children'][0], value)
+    def visit_not_expression(self, node: NotExpression, value: ta.Any) -> ta.Any:
+        original_result = self.visit(node.expr, value)
 
         if _is_actual_number(original_result) and original_result == 0:
             # Special case for 0, !0 should be false, not true. 0 is not a special cased integer in jmespath.
@@ -336,59 +387,59 @@ class TreeInterpreter(Visitor):
 
         return not original_result
 
-    def visit_pipe(self, node, value):
+    def visit_pipe(self, node: Pipe, value: ta.Any) -> ta.Any:
         result = value
-        for child in node['children']:
+        for child in [node.left, node.right]:
             result = self.visit(child, result)
         return result
 
-    def visit_projection(self, node, value):
-        base = self.visit(node['children'][0], value)
+    def visit_projection(self, node: Projection, value: ta.Any) -> ta.Any:
+        base = self.visit(node.left, value)
 
         allow_string = False
-        first_child = node['children'][0]
-        if first_child['type'] == 'index_expression':
-            nested_children = first_child['children']
-            if len(nested_children) > 1 and nested_children[1]['type'] == 'slice':
+        first_child = node.left
+        if isinstance(first_child, IndexExpression):
+            nested_children = first_child.nodes
+            if len(nested_children) > 1 and isinstance(nested_children[1], Slice):
                 allow_string = True
 
         if isinstance(base, str) and allow_string:
             # projections are really sub-expressions in disguise evaluate the rhs when lhs is a sliced string
-            return self.visit(node['children'][1], base)
+            return self.visit(node.right, base)
 
         if not isinstance(base, list):
             return None
+
         collected = []
         for element in base:
-            current = self.visit(node['children'][1], element)
+            current = self.visit(node.right, element)
             if current is not None:
                 collected.append(current)
 
         return collected
 
-    def visit_let_expression(self, node, value):
-        *bindings, expr = node['children']
+    def visit_let_expression(self, node: LetExpression, value: ta.Any) -> ta.Any:
         scope = {}
-        for assign in bindings:
+        for assign in node.bindings:
             scope.update(self.visit(assign, value))
         self._scope.push_scope(scope)
-        result = self.visit(expr, value)
+        result = self.visit(node.expr, value)
         self._scope.pop_scope()
         return result
 
-    def visit_assign(self, node, value):
-        name = node['value']
-        value = self.visit(node['children'][0], value)
+    def visit_assign(self, node: Assign, value: ta.Any) -> ta.Any:
+        name = node.name
+        value = self.visit(node.expr, value)
         return {name: value}
 
-    def visit_variable_ref(self, node, value):
+    def visit_variable_ref(self, node: VariableRef, value: ta.Any) -> ta.Any:
         try:
-            return self._scope[node['value']]
+            return self._scope[node.name]
         except KeyError:
-            raise exceptions.UndefinedVariableError(node['value'])  # noqa
+            raise UndefinedVariableError(node.name)  # noqa
 
-    def visit_value_projection(self, node, value):
-        base = self.visit(node['children'][0], value)
+    def visit_value_projection(self, node: ValueProjection, value: ta.Any) -> ta.Any:
+        base = self.visit(node.left, value)
         try:
             base = base.values()
         except AttributeError:
@@ -396,39 +447,62 @@ class TreeInterpreter(Visitor):
 
         collected = []
         for element in base:
-            current = self.visit(node['children'][1], element)
+            current = self.visit(node.right, element)
             if current is not None:
                 collected.append(current)
 
         return collected
 
-    def _is_false(self, value):
+    def _is_false(self, value: ta.Any) -> bool:
         # This looks weird, but we're explicitly using equality checks because the truth/false values are different
         # between python and jmespath.
-        return (value == '' or value == [] or value == {} or value is None or value is False)  # noqa
+        return (
+            value == '' or  # noqa
+            value == [] or
+            value == {} or
+            value is None or
+            value is False
+        )
 
-    def _is_true(self, value):
+    def _is_true(self, value: ta.Any) -> bool:
         return not self._is_false(value)
 
 
-class GraphvizVisitor(Visitor):
-    def __init__(self):
+class GraphvizVisitor:
+    def __init__(self) -> None:
         super().__init__()
-        self._lines = []
+        self._lines: list[str] = []
         self._count = 1
 
-    def visit(self, node, *args, **kwargs):
+    def visit(self, node: Node) -> str:
         self._lines.append('digraph AST {')
-        current = f"{node['type']}{self._count}"
+        current = f'{node_type(node)}{self._count}'
         self._count += 1
         self._visit(node, current)
         self._lines.append('}')
         return '\n'.join(self._lines)
 
-    def _visit(self, node, current):
-        self._lines.append('%s [label="%s(%s)"]' % (current, node['type'], node.get('value', '')))  # noqa
-        for child in node.get('children', []):
-            child_name = f"{child['type']}{self._count}"
+    def _node_value(self, node: Node) -> lang.Maybe[ta.Any]:
+        if isinstance(node, (ArithmeticUnary, Arithmetic)):
+            return lang.just(node.operator)
+        elif isinstance(node, (Assign, Comparator, FunctionExpression, Field, VariableRef)):
+            return lang.just(node.name)
+        elif isinstance(node, Index):
+            return lang.just(node.index)
+        elif isinstance(node, KeyValPair):
+            return lang.just(node.key_name)
+        elif isinstance(node, Literal):
+            return lang.just(node.literal_value)
+        else:
+            return lang.empty()
+
+    def _visit(self, node: Node, current: str) -> None:
+        self._lines.append(
+            f'{current} '
+            f'[label="{node_type(node)}({self._node_value(node).map(json.dumps).map(html.escape).or_else("")})"]',
+        )
+        for child in node.children:
+            child_name = f'{node_type(child)}{self._count}'
             self._count += 1
             self._lines.append(f'  {current} -> {child_name}')
             self._visit(child, child_name)

{omlish-0.0.0.dev117.dist-info → omlish-0.0.0.dev118.dist-info}/METADATA

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