omlish 0.0.0.dev46__tar.gz → 0.0.0.dev48__tar.gz

{omlish-0.0.0.dev46/omlish.egg-info → omlish-0.0.0.dev48}/PKG-INFO

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

{omlish-0.0.0.dev46 → omlish-0.0.0.dev48}/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-0.0.0.dev46 → omlish-0.0.0.dev48}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev46'
-__revision__ = '58e90594af37bae52bd283a1c7dc3591c4bdc471'
+__version__ = '0.0.0.dev48'
+__revision__ = 'f7465912309f3de0889d4c1fbf3df1abe229e4c1'
 
 
 #

{omlish-0.0.0.dev46 → omlish-0.0.0.dev48}/omlish/bootstrap/harness.py

@@ -38,8 +38,7 @@ from .base import SimpleBootstrap
 
 BOOTSTRAP_TYPES_BY_NAME: ta.Mapping[str, ta.Type[Bootstrap]] = {  # noqa
     lang.snake_case(cls.__name__[:-len('Bootstrap')]): cls
-    for cls in lang.deep_subclasses(Bootstrap)
-    if not lang.is_abstract_class(cls)
+    for cls in lang.deep_subclasses(Bootstrap, concrete_only=True)
 }
 
 BOOTSTRAP_TYPES_BY_CONFIG_TYPE: ta.Mapping[ta.Type[Bootstrap.Config], ta.Type[Bootstrap]] = {

{omlish-0.0.0.dev46 → omlish-0.0.0.dev48}/omlish/lang/objects.py

@@ -2,6 +2,8 @@ import types
 import typing as ta
 import weakref
 
+from .classes.abstract import is_abstract_class
+
 
 T = ta.TypeVar('T')
 
@@ -85,7 +87,7 @@ def super_meta(
 ##
 
 
-def deep_subclasses(cls: type) -> ta.Iterator[type]:
+def deep_subclasses(cls: type, *, concrete_only: bool = False) -> ta.Iterator[type]:
     seen = set()
     todo = list(reversed(cls.__subclasses__()))
     while todo:
@@ -93,7 +95,8 @@ def deep_subclasses(cls: type) -> ta.Iterator[type]:
         if cur in seen:
             continue
         seen.add(cur)
-        yield cur
+        if not (concrete_only and is_abstract_class(cur)):
+            yield cur
         todo.extend(reversed(cur.__subclasses__()))
 
 

{omlish-0.0.0.dev46 → omlish-0.0.0.dev48}/omlish/specs/__init__.py

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

omlish-0.0.0.dev48/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-0.0.0.dev48/omlish/specs/jmespath/__init__.py

@@ -0,0 +1,41 @@
+"""
+TODO:
+ - @omlish-lite
+
+Applied:
+ https://github.com/jmespath-community/python-jmespath/compare/bbe7300c60056f52413603cf3e2bcd0b6afeda3d...aef45e9d665de662eee31b06aeb8261e2bc8b90a
+
+From community:
+ - JEP-11 Lexical Scoping - https://github.com/jmespath-community/jmespath.spec/discussions/24#discussioncomment-3285710
+ - JEP-11a Lexical Scoping deprecates the let function.
+ - JEP-13 Object Manipulation functions - https://github.com/jmespath-community/jmespath.spec/discussions/47#discussioncomment-3308897
+ - JEP-14 String functions - https://github.com/jmespath-community/jmespath.spec/discussions/21#discussioncomment-3869583
+ - JEP-15 String Slices - https://github.com/jmespath-community/jmespath.spec/discussions/26#discussioncomment-3284127
+ - JEP-16 Arithmetic Expressions - https://github.com/jmespath-community/jmespath.spec/discussions/25#discussioncomment-3277652
+ - JEP-17 Root Reference - https://github.com/jmespath-community/jmespath.spec/discussions/18#discussion-3913993
+ - JEP-18 Grouping - https://github.com/jmespath-community/jmespath.spec/discussions/96#discussion-4282156
+ - JEP-19 Evaluation of Pipe Expressions - https://github.com/jmespath-community/jmespath.spec/discussions/113#discussioncomment-4000862
+ - JEP-20 Compact syntax for multi-select-hash - https://github.com/jmespath-community/jmespath.spec/discussions/19
+
+See:
+ - https://github.com/jmespath-community/jmespath.spec/tree/main
+ - https://github.com/jmespath-community/python-jmespath
+ - https://github.com/jmespath-community/jmespath.spec/discussions?discussions_q=label%3Ajep-candidate
+ - https://github.com/jmespath-community/jmespath.spec/discussions/97
+"""  # noqa
+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-0.0.0.dev48/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-0.0.0.dev48/omlish/specs/jmespath/ast.py

@@ -0,0 +1,114 @@
+# AST nodes have this structure:
+# {'type': <node type>', children: [], 'value': ''}
+
+
+def arithmetic_unary(operator, expression):
+    return {'type': 'arithmetic_unary', 'children': [expression], 'value': operator}
+
+
+def arithmetic(operator, left, right):
+    return {'type': 'arithmetic', 'children': [left, right], 'value': operator}
+
+
+def assign(name, expr):
+    return {'type': 'assign', 'children': [expr], 'value': name}
+
+
+def comparator(name, first, second):
+    return {'type': 'comparator', 'children': [first, second], 'value': name}
+
+
+def current_node():
+    return {'type': 'current', 'children': []}
+
+
+def root_node():
+    return {'type': 'root', '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 let_expression(bindings, expr):
+    return {'type': 'let_expression', 'children': [*bindings, expr]}
+
+
+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]}
+
+
+def variable_ref(name):
+    return {'type': 'variable_ref', 'children': [], 'value': name}

omlish-0.0.0.dev48/omlish/specs/jmespath/cli.py

@@ -0,0 +1,68 @@
+#!/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.JmespathValueError as e:
+        sys.stderr.write(f'invalid-value: {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-0.0.0.dev48/omlish/specs/jmespath/exceptions.py

@@ -0,0 +1,140 @@
+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 JmespathValueError(JmespathError):
+    def __init__(
+            self,
+            function_name,
+            current_value,
+            expected_types,
+    ):
+        self.function_name = function_name
+        self.current_value = current_value
+        self.expected_types = expected_types
+
+    def __str__(self):
+        return (
+            f'In function {self.function_name}(), invalid value: "{self.current_value}", '
+            f'expected: {self.expected_types}'
+        )
+
+
+class EmptyExpressionError(JmespathError):
+    def __init__(self):
+        super().__init__('Invalid Jmespath expression: cannot be empty.')
+
+
+class UnknownFunctionError(JmespathError):
+    pass
+
+
+class UndefinedVariableError(JmespathError):
+    def __init__(self, varname):
+        self.varname = varname
+        super().__init__(f'Reference to undefined variable: {self.varname}')