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

omlish/specs/jmespath/ast.py

@@ -1,119 +1,258 @@
+import abc
+import dataclasses as dc
 import typing as ta
 
+from ... import lang
 
-class Node(ta.TypedDict):
-    type: str
-    children: list['Node']
-    value: ta.NotRequired[ta.Any]
 
+@dc.dataclass(frozen=True)
+class Node(lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def children(self) -> ta.Sequence['Node']:
+        raise NotImplementedError
 
-def arithmetic_unary(operator, expression) -> Node:
-    return {'type': 'arithmetic_unary', 'children': [expression], 'value': operator}
 
+@dc.dataclass(frozen=True)
+class LeafNode(Node, lang.Abstract):
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return []
 
-def arithmetic(operator, left, right) -> Node:
-    return {'type': 'arithmetic', 'children': [left, right], 'value': operator}
 
+@dc.dataclass(frozen=True)
+class ArithmeticUnary(Node, lang.Final):
+    operator: str
+    expression: Node
 
-def assign(name, expr) -> Node:
-    return {'type': 'assign', 'children': [expr], 'value': name}
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [self.expression]
 
 
-def comparator(name, first, second) -> Node:
-    return {'type': 'comparator', 'children': [first, second], 'value': name}
+@dc.dataclass(frozen=True)
+class Arithmetic(Node, lang.Final):
+    operator: str
+    left: Node
+    right: Node
 
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [self.left, self.right]
 
-def current_node() -> Node:
-    return {'type': 'current', 'children': []}
 
+@dc.dataclass(frozen=True)
+class Assign(Node, lang.Final):
+    name: str
+    expr: Node
 
-def root_node() -> Node:
-    return {'type': 'root', 'children': []}
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [self.expr]
 
 
-def expref(expression) -> Node:
-    return {'type': 'expref', 'children': [expression]}
+@dc.dataclass(frozen=True)
+class Comparator(Node, lang.Final):
+    name: str
+    first: Node
+    second: Node
 
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [self.first, self.second]
 
-def function_expression(name, args) -> Node:
-    return {'type': 'function_expression', 'children': args, 'value': name}
 
+@dc.dataclass(frozen=True)
+class CurrentNode(LeafNode, lang.Final):
+    pass
 
-def field(name) -> Node:
-    return {'type': 'field', 'children': [], 'value': name}
 
+@dc.dataclass(frozen=True)
+class RootNode(LeafNode, lang.Final):
+    pass
 
-def filter_projection(left, right, comparator) -> Node:
-    return {'type': 'filter_projection', 'children': [left, right, comparator]}
 
+@dc.dataclass(frozen=True)
+class Expref(Node, lang.Final):
+    expression: Node
 
-def flatten(node) -> Node:
-    return {'type': 'flatten', 'children': [node]}
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [self.expression]
 
 
-def identity() -> Node:
-    return {'type': 'identity', 'children': []}
+@dc.dataclass(frozen=True)
+class FunctionExpression(Node, lang.Final):
+    name: str
+    args: ta.Sequence[Node]
 
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return tuple(self.args)
 
-def index(index) -> Node:
-    return {'type': 'index', 'value': index, 'children': []}
 
+@dc.dataclass(frozen=True)
+class Field(LeafNode, lang.Final):
+    name: str
 
-def index_expression(children) -> Node:
-    return {'type': 'index_expression', 'children': children}
 
+@dc.dataclass(frozen=True)
+class FilterProjection(Node, lang.Final):
+    left: Node
+    right: Node
+    comparator: Node
 
-def key_val_pair(key_name, node) -> Node:
-    return {'type': 'key_val_pair', 'children': [node], 'value': key_name}
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [self.left, self.right, self.comparator]
 
 
-def let_expression(bindings, expr) -> Node:
-    return {'type': 'let_expression', 'children': [*bindings, expr]}
+@dc.dataclass(frozen=True)
+class Flatten(Node, lang.Final):
+    node: Node
 
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [self.node]
 
-def literal(literal_value) -> Node:
-    return {'type': 'literal', 'value': literal_value, 'children': []}
 
+@dc.dataclass(frozen=True)
+class Identity(LeafNode, lang.Final):
+    pass
 
-def multi_select_dict(nodes) -> Node:
-    return {'type': 'multi_select_dict', 'children': nodes}
 
+@dc.dataclass(frozen=True)
+class Index(LeafNode, lang.Final):
+    index: int
 
-def multi_select_list(nodes) -> Node:
-    return {'type': 'multi_select_list', 'children': nodes}
 
+@dc.dataclass(frozen=True)
+class IndexExpression(Node, lang.Final):
+    nodes: ta.Sequence[Node]
 
-def or_expression(left, right) -> Node:
-    return {'type': 'or_expression', 'children': [left, right]}
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return tuple(self.nodes)
 
 
-def and_expression(left, right) -> Node:
-    return {'type': 'and_expression', 'children': [left, right]}
+@dc.dataclass(frozen=True)
+class KeyValPair(Node, lang.Final):
+    key_name: str
+    node: Node
 
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [self.node]
 
-def not_expression(expr) -> Node:
-    return {'type': 'not_expression', 'children': [expr]}
 
+@dc.dataclass(frozen=True)
+class LetExpression(Node, lang.Final):
+    bindings: ta.Sequence[Node]
+    expr: Node
 
-def pipe(left: Node, right: Node) -> Node:
-    return {'type': 'pipe', 'children': [left, right]}
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [*self.bindings, self.expr]
 
 
-def projection(left: Node, right: Node) -> Node:
-    return {'type': 'projection', 'children': [left, right]}
+@dc.dataclass(frozen=True)
+class Literal(LeafNode, lang.Final):
+    literal_value: ta.Any
 
 
-def subexpression(children) -> Node:
-    return {'type': 'subexpression', 'children': children}
+@dc.dataclass(frozen=True)
+class MultiSelectDict(Node, lang.Final):
+    nodes: ta.Sequence[KeyValPair]
 
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return tuple(self.nodes)
 
-def slice(start, end, step) -> Node:  # noqa
-    return {'type': 'slice', 'children': [start, end, step]}
 
+@dc.dataclass(frozen=True)
+class MultiSelectList(Node, lang.Final):
+    nodes: ta.Sequence[Node]
 
-def value_projection(left: Node, right: Node) -> Node:
-    return {'type': 'value_projection', 'children': [left, right]}
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return tuple(self.nodes)
 
 
-def variable_ref(name: str) -> Node:
-    return {'type': 'variable_ref', 'children': [], 'value': name}
+@dc.dataclass(frozen=True)
+class OrExpression(Node, lang.Final):
+    left: Node
+    right: Node
+
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [self.left, self.right]
+
+
+@dc.dataclass(frozen=True)
+class AndExpression(Node, lang.Final):
+    left: Node
+    right: Node
+
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [self.left, self.right]
+
+
+@dc.dataclass(frozen=True)
+class NotExpression(Node, lang.Final):
+    expr: Node
+
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [self.expr]
+
+
+@dc.dataclass(frozen=True)
+class Pipe(Node, lang.Final):
+    left: Node
+    right: Node
+
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [self.left, self.right]
+
+
+@dc.dataclass(frozen=True)
+class Projection(Node, lang.Final):
+    left: Node
+    right: Node
+
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [self.left, self.right]
+
+
+@dc.dataclass(frozen=True)
+class Subexpression(Node, lang.Final):
+    children_nodes: ta.Sequence[Node]
+
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return tuple(self.children_nodes)
+
+
+@dc.dataclass(frozen=True)
+class Slice(LeafNode, lang.Final):
+    start: int | None
+    end: int | None
+    step: int | None
+
+
+@dc.dataclass(frozen=True)
+class ValueProjection(Node, lang.Final):
+    left: Node
+    right: Node
+
+    @property
+    def children(self) -> ta.Sequence[Node]:
+        return [self.left, self.right]
+
+
+@dc.dataclass(frozen=True)
+class VariableRef(LeafNode, lang.Final):
+    name: str

omlish/specs/jmespath/cli.py

@@ -1,35 +1,49 @@
 #!/usr/bin/env python3
 import argparse
-import json
-import pprint
+import dataclasses as dc
 import sys
+import typing as ta
 
-from . import exceptions
+from ...formats import json
+from .ast import Node
+from .exceptions import ArityError
+from .exceptions import JmespathTypeError
+from .exceptions import JmespathValueError
+from .exceptions import ParseError
+from .exceptions import UnknownFunctionError
 from .parser import compile
 from .parser import search
+from .visitor import node_type
 
 
-def _main():
+def _ast_to_json(o: ta.Any) -> ta.Any:
+    if isinstance(o, json.SCALAR_TYPES):
+        return o
+    elif isinstance(o, Node):
+        return {node_type(o): {f.name: _ast_to_json(getattr(o, f.name)) for f in dc.fields(o)}}
+    elif isinstance(o, (list, tuple)):
+        return [_ast_to_json(e) for e in o]
+    else:
+        raise TypeError(o)
+
+
+def _main() -> int:
     parser = argparse.ArgumentParser()
     parser.add_argument('expression')
-    parser.add_argument(
-        '-f',
-        '--filename',
-        help='The filename containing the input data.  If a filename is not given then data is read from stdin.',
-    )
-    parser.add_argument(
-        '--ast',
-        action='store_true',
-        help='Pretty print the AST, do not search the data.',
-    )
+    parser.add_argument('-f', '--filename')
+    parser.add_argument('-c', '--compact', action='store_true')
+    parser.add_argument('--ast', action='store_true')
     args = parser.parse_args()
 
+    if args.compact:
+        json_dumps = json.dumps_compact
+    else:
+        json_dumps = json.dumps_pretty
+
     expression = args.expression
     if args.ast:
-        # Only print the AST
         expression = compile(args.expression)
-        sys.stdout.write(pprint.pformat(expression.parsed))
-        sys.stdout.write('\n')
+        print(json_dumps(_ast_to_json(expression.parsed)))
         return 0
 
     if args.filename:
@@ -40,27 +54,27 @@ def _main():
         data = json.loads(data)
 
     try:
-        sys.stdout.write(json.dumps(search(expression, data), indent=4, ensure_ascii=False))
-        sys.stdout.write('\n')
+        print(json_dumps(search(expression, data), ensure_ascii=False))
+        return 0
 
-    except exceptions.ArityError as e:
-        sys.stderr.write(f'invalid-arity: {e}\n')
+    except ArityError as e:
+        print(f'invalid-arity: {e}', file=sys.stderr)
         return 1
 
-    except exceptions.JmespathTypeError as e:
-        sys.stderr.write(f'invalid-type: {e}\n')
+    except JmespathTypeError as e:
+        print(f'invalid-type: {e}', file=sys.stderr)
         return 1
 
-    except exceptions.JmespathValueError as e:
-        sys.stderr.write(f'invalid-value: {e}\n')
+    except JmespathValueError as e:
+        print(f'invalid-value: {e}', file=sys.stderr)
         return 1
 
-    except exceptions.UnknownFunctionError as e:
-        sys.stderr.write(f'unknown-function: {e}\n')
+    except UnknownFunctionError as e:
+        print(f'unknown-function: {e}', file=sys.stderr)
         return 1
 
-    except exceptions.ParseError as e:
-        sys.stderr.write(f'syntax-error: {e}\n')
+    except ParseError as e:
+        print(f'syntax-error: {e}', file=sys.stderr)
         return 1