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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev47'
-__revision__ = 'f28331ec54caff2de81847ec3e299466513a08f7'
+__version__ = '0.0.0.dev48'
+__revision__ = 'f7465912309f3de0889d4c1fbf3df1abe229e4c1'
 
 
 #

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

@@ -1,7 +1,28 @@
 """
 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

omlish/specs/jmespath/ast.py

@@ -2,6 +2,18 @@
 # {'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}
 
@@ -10,6 +22,10 @@ def current_node():
     return {'type': 'current', 'children': []}
 
 
+def root_node():
+    return {'type': 'root', 'children': []}
+
+
 def expref(expression):
     return {'type': 'expref', 'children': [expression]}
 
@@ -46,6 +62,10 @@ 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': []}
 
@@ -88,3 +108,7 @@ def slice(start, end, step):  # noqa
 
 def value_projection(left, right):
     return {'type': 'value_projection', 'children': [left, right]}
+
+
+def variable_ref(name):
+    return {'type': 'variable_ref', 'children': [], 'value': name}

omlish/specs/jmespath/cli.py

@@ -51,6 +51,10 @@ def _main():
         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

omlish/specs/jmespath/exceptions.py

@@ -107,6 +107,24 @@ class JmespathTypeError(JmespathError):
         )
 
 
+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.')
@@ -114,3 +132,9 @@ class EmptyExpressionError(JmespathError):
 
 class UnknownFunctionError(JmespathError):
     pass
+
+
+class UndefinedVariableError(JmespathError):
+    def __init__(self, varname):
+        self.varname = varname
+        super().__init__(f'Reference to undefined variable: {self.varname}')

omlish/specs/jmespath/functions.py

@@ -83,18 +83,36 @@ class Functions(metaclass=FunctionRegistry):
         return function(self, *resolved_args)
 
     def _validate_arguments(self, args, signature, function_name):
-        if signature and signature[-1].get('variadic'):
+
+        if len(signature) == 0:
+            return self._type_check(args, signature, function_name)
+
+        required_arguments_count = len([
+            param for param in signature if param and (not param.get('optional') or not param['optional'])
+        ])
+        optional_arguments_count = len([
+            param for param in signature if param and param.get('optional') and param['optional']
+        ])
+        has_variadic = signature[-1].get('variadic') if signature is not None else False
+
+        if has_variadic:
             if len(args) < len(signature):
                 raise exceptions.VariadicArityError(len(signature), len(args), function_name)
 
-        elif len(args) != len(signature):
+        elif optional_arguments_count > 0:
+            if (
+                    len(args) < required_arguments_count or
+                    len(args) > (required_arguments_count + optional_arguments_count)
+            ):
+                raise exceptions.ArityError(len(signature), len(args), function_name)
+        elif len(args) != required_arguments_count:
             raise exceptions.ArityError(len(signature), len(args), function_name)
 
         return self._type_check(args, signature, function_name)
 
     def _type_check(self, actual, signature, function_name):
-        for i in range(len(signature)):
-            allowed_types = signature[i]['types']
+        for i in range(min(len(signature), len(actual))):
+            allowed_types = self._get_allowed_types_from_signature(signature[i])
             if allowed_types:
                 self._type_check_single(actual[i], allowed_types, function_name)
 
@@ -117,6 +135,12 @@ class Functions(metaclass=FunctionRegistry):
         if allowed_subtypes:
             self._subtype_check(current, allowed_subtypes, types, function_name)
 
+    def _get_allowed_types_from_signature(self, spec):
+        # signature supports monotype {'type': 'type-name'}## or multiple types {'types': ['type1-name', 'type2-name']}
+        if spec.get('type'):
+            spec.update({'types': [spec.get('type')]})
+        return spec.get('types')
+
     def _get_allowed_pytypes(self, types):
         allowed_types: list = []
         allowed_subtypes: list = []
@@ -161,6 +185,14 @@ class Functions(metaclass=FunctionRegistry):
     def _func_abs(self, arg):
         return abs(arg)
 
+    @signature({'types': ['string']})
+    def _func_lower(self, arg):
+        return arg.lower()
+
+    @signature({'types': ['string']})
+    def _func_upper(self, arg):
+        return arg.upper()
+
     @signature({'types': ['array-number']})
     def _func_avg(self, arg):
         if arg:
@@ -280,6 +312,14 @@ class Functions(metaclass=FunctionRegistry):
     def _func_sum(self, arg):
         return sum(arg)
 
+    @signature({'types': ['object']})
+    def _func_items(self, arg):
+        return [list(t) for t in arg.items()]
+
+    @signature({'types': ['array']})
+    def _func_from_items(self, items):
+        return dict(items)
+
     @signature({'types': ['object']})
     def _func_keys(self, arg):
         # To be consistent with .values() should we also return the indices of a list?
@@ -289,6 +329,169 @@ class Functions(metaclass=FunctionRegistry):
     def _func_values(self, arg):
         return list(arg.values())
 
+    @signature(
+        {'type': 'string'},
+        {'type': 'string'},
+        {'type': 'number', 'optional': True},
+        {'type': 'number', 'optional': True},
+    )
+    def _func_find_first(self, text, search, start=0, end=None):
+        self._ensure_integer('find_first', 'start', start)
+        self._ensure_integer('find_first', 'end', end)
+        return self._find_impl(
+            text,
+            search,
+            lambda t, s: t.find(s),
+            start,
+            end,
+        )
+
+    @signature(
+        {'type': 'string'},
+        {'type': 'string'},
+        {'type': 'number', 'optional': True},
+        {'type': 'number', 'optional': True})
+    def _func_find_last(self, text, search, start=0, end=None):
+        self._ensure_integer('find_last', 'start', start)
+        self._ensure_integer('find_last', 'end', end)
+        return self._find_impl(
+            text,
+            search,
+            lambda t, s: t.rfind(s),
+            start,
+            end,
+        )
+
+    def _find_impl(self, text, search, func, start, end):
+        if len(search) == 0:
+            return None
+        if end is None:
+            end = len(text)
+
+        pos = func(text[start:end], search)
+        if start < 0:
+            start = start + len(text)
+
+        # restrict resulting range to valid indices
+        start = min(max(start, 0), len(text))
+        return start + pos if pos != -1 else None
+
+    @signature(
+        {'type': 'string'},
+        {'type': 'number'},
+        {'type': 'string', 'optional': True},
+    )
+    def _func_pad_left(self, text, width, padding=' '):
+        self._ensure_non_negative_integer('pad_left', 'width', width)
+        return self._pad_impl(lambda: text.rjust(width, padding), padding)
+
+    @signature(
+        {'type': 'string'},
+        {'type': 'number'},
+        {'type': 'string', 'optional': True},
+    )
+    def _func_pad_right(self, text, width, padding=' '):
+        self._ensure_non_negative_integer('pad_right', 'width', width)
+        return self._pad_impl(lambda: text.ljust(width, padding), padding)
+
+    def _pad_impl(self, func, padding):
+        if len(padding) != 1:
+            raise exceptions.JmespathError(
+                f'syntax-error: pad_right() expects $padding to have a single character, but received '
+                f'`{padding}` instead.',
+            )
+        return func()
+
+    @signature(
+        {'type': 'string'},
+        {'type': 'string'},
+        {'type': 'string'},
+        {'type': 'number', 'optional': True},
+    )
+    def _func_replace(self, text, search, replacement, count=None):
+        self._ensure_non_negative_integer(
+            'replace',
+            'count',
+            count,
+        )
+
+        if count is not None:
+            return text.replace(search, replacement, int(count))
+
+        return text.replace(search, replacement)
+
+    @signature(
+        {'type': 'string'},
+        {'type': 'string'},
+        {'type': 'number', 'optional': True},
+    )
+    def _func_split(self, text, search, count=None):
+        self._ensure_non_negative_integer(
+            'split',
+            'count',
+            count,
+        )
+
+        if len(search) == 0:
+            chars = list(text)
+            if count is None:
+                return chars
+
+            head = list(chars[:count])
+            tail = [''.join(chars[count:])]
+            return head + tail
+
+        if count is not None:
+            return text.split(search, count)
+
+        return text.split(search)
+
+    def _ensure_integer(
+            self,
+            func_name,
+            param_name,
+            param_value,
+    ):
+        if param_value is not None:
+            if int(param_value) != param_value:
+                raise exceptions.JmespathValueError(
+                    func_name,
+                    param_value,
+                    'integer',
+                )
+
+    def _ensure_non_negative_integer(
+            self,
+            func_name,
+            param_name,
+            param_value,
+    ):
+        if param_value is not None:
+            if int(param_value) != param_value or int(param_value) < 0:
+                raise exceptions.JmespathValueError(
+                    func_name,
+                    param_name,
+                    'non-negative integer',
+                )
+
+    @signature({'type': 'string'}, {'type': 'string', 'optional': True})
+    def _func_trim(self, text, chars=None):
+        if chars is None or len(chars) == 0:
+            return text.strip()
+        return text.strip(chars)
+
+    @signature({'type': 'string'}, {'type': 'string', 'optional': True})
+    def _func_trim_left(self, text, chars=None):
+        if chars is None or len(chars) == 0:
+            return text.lstrip()
+        return text.lstrip(chars)
+
+    @signature({'type': 'string'}, {'type': 'string', 'optional': True})
+    def _func_trim_right(self, text, chars=None):
+        if chars is None or len(chars) == 0:
+            return text.rstrip()
+        return text.rstrip(chars)
+
     @signature({'types': []})
     def _func_type(self, arg):
         if isinstance(arg, str):
@@ -310,6 +513,7 @@ class Functions(metaclass=FunctionRegistry):
     def _func_sort_by(self, array, expref):
         if not array:
             return array
+
         # sort_by allows for the expref to be either a number of a string, so we have some special logic to handle this.
         # We evaluate the first array element and verify that it's either a string of a number.  We then create a key
         # function that validates that type, which requires that remaining array elements resolve to the same type as
@@ -324,7 +528,6 @@ class Functions(metaclass=FunctionRegistry):
             )
 
         keyfunc = self._create_key_func(expref, [required_type], 'sort_by')
-
         return sorted(array, key=keyfunc)
 
     @signature({'types': ['array']}, {'types': ['expref']})
@@ -353,13 +556,31 @@ class Functions(metaclass=FunctionRegistry):
         else:
             return None
 
+    @signature({'types': ['array'], 'variadic': True})
+    def _func_zip(self, *arguments):
+        return [list(t) for t in zip(*arguments)]
+
+    @signature({'types': ['array']}, {'types': ['expref']})
+    def _func_group_by(self, array, expref):
+        keyfunc = self._create_key_func(expref, ['null', 'string'], 'group_by')
+        if not array:
+            return None
+
+        result = {}
+        keys = list(dict.fromkeys([keyfunc(item) for item in array if keyfunc(item) is not None]))
+        for key in keys:
+            items = [item for item in array if keyfunc(item) == key]
+            result.update({key: items})
+
+        return result
+
     def _create_key_func(self, expref, allowed_types, function_name):
         def keyfunc(x):
             result = expref.visit(expref.expression, x)
             actual_typename = type(result).__name__
 
             jmespath_type = self._convert_to_jmespath_type(actual_typename)
-            # allowed_types is in term of jmespath types, not python types.
+            # allowed_types is in terms of jmespath types, not python types.
             if jmespath_type not in allowed_types:
                 raise exceptions.JmespathTypeError(
                     function_name, result, jmespath_type, allowed_types)

omlish/specs/jmespath/lexer.py

@@ -26,9 +26,20 @@ class Lexer:
         ')': 'rparen',
         '{': 'lbrace',
         '}': 'rbrace',
+        '+': 'plus',
+        '%': 'modulo',
+        '\u2212': 'minus',
+        '\u00d7': 'multiply',
+        '\u00f7': 'divide',
     }
 
-    def tokenize(self, expression):
+    def __init__(self):
+        self._enable_legacy_literals = False
+
+    def tokenize(self, expression, options=None):
+        if options is not None:
+            self._enable_legacy_literals = options.enable_legacy_literals
+
         self._initialize_for_expression(expression)
         while self._current is not None:
             if self._current in self.SIMPLE_TOKENS:
@@ -111,24 +122,48 @@ class Lexer:
                 }
 
             elif self._current == '-':
-                # Negative number.
-                start = self._position
-
-                buff = self._consume_number()
-                if len(buff) > 1:
+                if not self._peek_is_next_digit():
+                    self._next()
                     yield {
-                        'type': 'number',
-                        'value': int(buff),
-                        'start': start,
-                        'end': start + len(buff),
+                        'type': 'minus',
+                        'value': '-',
+                        'start': self._position - 1,
+                        'end': self._position,
                     }
+                else:
+                    # Negative number.
+                    start = self._position
+                    buff = self._consume_number()
+                    if len(buff) > 1:
+                        yield {
+                            'type': 'number',
+                            'value': int(buff),
+                            'start': start,
+                            'end': start + len(buff),
+                        }
+                    else:
+                        raise LexerError(
+                            lexer_position=start,
+                            lexer_value=buff,
+                            message=f"Unknown token '{buff}'")
 
+            elif self._current == '/':
+                self._next()
+                if self._current == '/':
+                    self._next()
+                    yield {
+                        'type': 'div',
+                        'value': '//',
+                        'start': self._position - 1,
+                        'end': self._position,
+                    }
                 else:
-                    raise LexerError(
-                        lexer_position=start,
-                        lexer_value=buff,
-                        message=f"Unknown token '{buff}'",
-                    )
+                    yield {
+                        'type': 'divide',
+                        'value': '/',
+                        'start': self._position,
+                        'end': self._position + 1,
+                    }
 
             elif self._current == '"':
                 yield self._consume_quoted_identifier()
@@ -143,33 +178,24 @@ class Lexer:
                 yield self._match_or_else('=', 'ne', 'not')
 
             elif self._current == '=':
-                if self._next() == '=':
+                yield self._match_or_else('=', 'eq', 'assign')
+
+            elif self._current == '$':
+                if self._peek_may_be_valid_unquoted_identifier():
+                    yield self._consume_variable()
+                else:
                     yield {
-                        'type': 'eq',
-                        'value': '==',
-                        'start': self._position - 1,
-                        'end': self._position,
+                        'type': 'root',
+                        'value': self._current,
+                        'start': self._position,
+                        'end': self._position + 1,
                     }
                     self._next()
-
-                else:
-                    if self._current is None:
-                        # If we're at the EOF, we never advanced the position so we don't need to rewind it back one
-                        # location.
-                        position = self._position
-                    else:
-                        position = self._position - 1
-                    raise LexerError(
-                        lexer_position=position,
-                        lexer_value='=',
-                        message="Unknown token '='",
-                    )
-
             else:
                 raise LexerError(
                     lexer_position=self._position,
                     lexer_value=self._current,
-                    message=f'Unknown token {self._current}',
+                    message=f'Unknown token {self._current})',
                 )
 
         yield {
@@ -187,6 +213,43 @@ class Lexer:
             buff += self._current
         return buff
 
+    def _consume_variable(self):
+        start = self._position
+
+        buff = self._current
+        self._next()
+        if self._current not in self.START_IDENTIFIER:
+            raise LexerError(
+                lexer_position=start,
+                lexer_value=self._current,
+                message=f'Invalid variable starting character {self._current}',
+            )
+
+        buff += self._current
+        while self._next() in self.VALID_IDENTIFIER:
+            buff += self._current
+
+        return {
+            'type': 'variable',
+            'value': buff,
+            'start': start,
+            'end': start + len(buff),
+        }
+
+    def _peek_may_be_valid_unquoted_identifier(self):
+        if (self._position == self._length - 1):
+            return False
+        else:
+            nxt = self._chars[self._position + 1]
+            return nxt in self.START_IDENTIFIER
+
+    def _peek_is_next_digit(self):
+        if (self._position == self._length - 1):
+            return False
+        else:
+            nxt = self._chars[self._position + 1]
+            return nxt in self.VALID_NUMBER
+
     def _initialize_for_expression(self, expression):
         if not expression:
             raise EmptyExpressionError
@@ -233,15 +296,26 @@ class Lexer:
     def _consume_literal(self):
         start = self._position
 
-        lexeme = self._consume_until('`').replace('\\`', '`')
+        token = self._consume_until('`')
+        lexeme = token.replace('\\`', '`')
+        parsed_json = None
         try:
             # Assume it is valid JSON and attempt to parse.
             parsed_json = json.loads(lexeme)
         except ValueError:
+            error = LexerError(
+                lexer_position=start,
+                lexer_value=self._expression[start:],
+                message=f'Bad token %s `{token}`',
+            )
+
+            if not self._enable_legacy_literals:
+                raise error  # noqa
+
             try:
                 # Invalid JSON values should be converted to quoted JSON strings during the JEP-12 deprecation period.
                 parsed_json = json.loads('"%s"' % lexeme.lstrip())  # noqa
-                warnings.warn('deprecated string literal syntax', PendingDeprecationWarning)
+                warnings.warn('deprecated string literal syntax', DeprecationWarning)
             except ValueError:
                 raise LexerError(  # noqa
                     lexer_position=start,
@@ -281,7 +355,10 @@ class Lexer:
     def _consume_raw_string_literal(self):
         start = self._position
 
-        lexeme = self._consume_until("'").replace("\\'", "'")
+        lexeme = self._consume_until("'") \
+            .replace("\\'", "'")  \
+            .replace('\\\\', '\\')
+
         token_len = self._position - start
         return {
             'type': 'literal',