omlish 0.0.0.dev45__py3-none-any.whl → 0.0.0.dev47__py3-none-any.whl

omlish/.manifests.json

@@ -34,5 +34,17 @@
         "mod_name": "omlish.diag.pycharm"
       }
     }
+  },
+  {
+    "module": ".specs.jmespath.__main__",
+    "attr": "_CLI_MODULE",
+    "file": "omlish/specs/jmespath/__main__.py",
+    "line": 1,
+    "value": {
+      "$omdev.cli.types.CliModule": {
+        "cmd_name": "jp",
+        "mod_name": "omlish.specs.jmespath.__main__"
+      }
+    }
   }
 ]

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev45'
-__revision__ = 'db777c425b0d53ee128b96fca75e6c6f4cd43654'
+__version__ = '0.0.0.dev47'
+__revision__ = 'f28331ec54caff2de81847ec3e299466513a08f7'
 
 
 #

omlish/specs/__init__.py

@@ -2,7 +2,6 @@
 TODO:
  - avro
  - iceberg
- - jmespath
  - jsonnet
  - jsonpatch
  - jsonpointer.py

omlish/specs/jmespath/LICENSE

@@ -0,0 +1,16 @@
+MIT License
+
+Copyright (c) 2013 Amazon.com, Inc. or its affiliates.  All Rights Reserved
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

omlish/specs/jmespath/__init__.py

@@ -0,0 +1,20 @@
+"""
+TODO:
+ - @omlish-lite
+"""
+from . import exceptions  # noqa
+from . import functions  # noqa
+from . import lexer  # noqa
+from . import parser  # noqa
+
+from .parser import (  # noqa
+    compile,
+    search,
+)
+
+from .visitor import (  # noqa
+    Options,
+)
+
+
+__version__ = '1.0.1'

omlish/specs/jmespath/__main__.py

@@ -0,0 +1,11 @@
+# @omlish-manifest
+_CLI_MODULE = {'$omdev.cli.types.CliModule': {
+    'cmd_name': 'jp',
+    'mod_name': __name__,
+}}
+
+
+if __name__ == '__main__':
+    from .cli import _main
+
+    _main()

omlish/specs/jmespath/ast.py

@@ -0,0 +1,90 @@
+# AST nodes have this structure:
+# {'type': <node type>', children: [], 'value': ''}
+
+
+def comparator(name, first, second):
+    return {'type': 'comparator', 'children': [first, second], 'value': name}
+
+
+def current_node():
+    return {'type': 'current', 'children': []}
+
+
+def expref(expression):
+    return {'type': 'expref', 'children': [expression]}
+
+
+def function_expression(name, args):
+    return {'type': 'function_expression', 'children': args, 'value': name}
+
+
+def field(name):
+    return {'type': 'field', 'children': [], 'value': name}
+
+
+def filter_projection(left, right, comparator):
+    return {'type': 'filter_projection', 'children': [left, right, comparator]}
+
+
+def flatten(node):
+    return {'type': 'flatten', 'children': [node]}
+
+
+def identity():
+    return {'type': 'identity', 'children': []}
+
+
+def index(index):
+    return {'type': 'index', 'value': index, 'children': []}
+
+
+def index_expression(children):
+    return {'type': 'index_expression', 'children': children}
+
+
+def key_val_pair(key_name, node):
+    return {'type': 'key_val_pair', 'children': [node], 'value': key_name}
+
+
+def literal(literal_value):
+    return {'type': 'literal', 'value': literal_value, 'children': []}
+
+
+def multi_select_dict(nodes):
+    return {'type': 'multi_select_dict', 'children': nodes}
+
+
+def multi_select_list(nodes):
+    return {'type': 'multi_select_list', 'children': nodes}
+
+
+def or_expression(left, right):
+    return {'type': 'or_expression', 'children': [left, right]}
+
+
+def and_expression(left, right):
+    return {'type': 'and_expression', 'children': [left, right]}
+
+
+def not_expression(expr):
+    return {'type': 'not_expression', 'children': [expr]}
+
+
+def pipe(left, right):
+    return {'type': 'pipe', 'children': [left, right]}
+
+
+def projection(left, right):
+    return {'type': 'projection', 'children': [left, right]}
+
+
+def subexpression(children):
+    return {'type': 'subexpression', 'children': children}
+
+
+def slice(start, end, step):  # noqa
+    return {'type': 'slice', 'children': [start, end, step]}
+
+
+def value_projection(left, right):
+    return {'type': 'value_projection', 'children': [left, right]}

omlish/specs/jmespath/cli.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import pprint
+import sys
+
+from . import exceptions
+from .parser import compile
+from .parser import search
+
+
+def _main():
+    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.',
+    )
+    args = parser.parse_args()
+
+    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')
+        return 0
+
+    if args.filename:
+        with open(args.filename) as f:
+            data = json.load(f)
+    else:
+        data = sys.stdin.read()
+        data = json.loads(data)
+
+    try:
+        sys.stdout.write(json.dumps(search(expression, data), indent=4, ensure_ascii=False))
+        sys.stdout.write('\n')
+
+    except exceptions.ArityError as e:
+        sys.stderr.write(f'invalid-arity: {e}\n')
+        return 1
+
+    except exceptions.JmespathTypeError as e:
+        sys.stderr.write(f'invalid-type: {e}\n')
+        return 1
+
+    except exceptions.UnknownFunctionError as e:
+        sys.stderr.write(f'unknown-function: {e}\n')
+        return 1
+
+    except exceptions.ParseError as e:
+        sys.stderr.write(f'syntax-error: {e}\n')
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(_main())

omlish/specs/jmespath/exceptions.py

@@ -0,0 +1,116 @@
+class JmespathError(ValueError):
+    pass
+
+
+class ParseError(JmespathError):
+    _ERROR_MESSAGE = 'Invalid jmespath expression'
+
+    def __init__(
+            self,
+            lex_position,
+            token_value,
+            token_type,
+            msg=_ERROR_MESSAGE,
+    ):
+        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
+
+    def __str__(self):
+        # self.lex_position +1 to account for the starting double quote char.
+        underline = ' ' * (self.lex_position + 1) + '^'
+        return (
+            f'{self.msg}: Parse error at column {self.lex_position}, '
+            f'token "{self.token_value}" ({self.token_type}), for expression:\n"{self.expression}"\n{underline}'
+        )
+
+
+class IncompleteExpressionError(ParseError):
+    def set_expression(self, expression):
+        self.expression = expression
+        self.lex_position = len(expression)
+        self.token_type = None
+        self.token_value = None
+
+    def __str__(self):
+        # self.lex_position +1 to account for the starting double quote char.
+        underline = ' ' * (self.lex_position + 1) + '^'
+        return (
+            f'Invalid jmespath expression: Incomplete expression:\n'
+            f'"{self.expression}"\n{underline}'
+        )
+
+
+class LexerError(ParseError):
+    def __init__(self, lexer_position, lexer_value, message, expression=None):
+        self.lexer_position = lexer_position
+        self.lexer_value = lexer_value
+        self.message = message
+        super().__init__(lexer_position, lexer_value, message)
+        # Whatever catches LexerError can set this.
+        self.expression = expression
+
+    def __str__(self):
+        underline = ' ' * self.lexer_position + '^'
+        return f'Bad jmespath expression: {self.message}:\n{self.expression}\n{underline}'
+
+
+class ArityError(ParseError):
+    def __init__(self, expected, actual, name):
+        self.expected_arity = expected
+        self.actual_arity = actual
+        self.function_name = name
+        self.expression = None
+
+    def __str__(self):
+        return (
+            f"Expected {self.expected_arity} {self._pluralize('argument', self.expected_arity)} "
+            f'for function {self.function_name}(), received {self.actual_arity}'
+        )
+
+    def _pluralize(self, word, count):
+        if count == 1:
+            return word
+        else:
+            return word + 's'
+
+
+class VariadicArityError(ArityError):
+    def __str__(self):
+        return (
+            f"Expected at least {self.expected_arity} {self._pluralize('argument', self.expected_arity)} "
+            f'for function {self.function_name}(), received {self.actual_arity}'
+        )
+
+
+class JmespathTypeError(JmespathError):
+    def __init__(
+            self,
+            function_name,
+            current_value,
+            actual_type,
+            expected_types,
+    ):
+        self.function_name = function_name
+        self.current_value = current_value
+        self.actual_type = actual_type
+        self.expected_types = expected_types
+
+    def __str__(self):
+        return (
+            f'In function {self.function_name}(), invalid type for value: {self.current_value}, '
+            f'expected one of: {self.expected_types}, received: "{self.actual_type}"'
+        )
+
+
+class EmptyExpressionError(JmespathError):
+    def __init__(self):
+        super().__init__('Invalid Jmespath expression: cannot be empty.')
+
+
+class UnknownFunctionError(JmespathError):
+    pass