omlish 0.0.0.dev47__tar.gz → 0.0.0.dev49__tar.gz

{omlish-0.0.0.dev47/omlish.egg-info → omlish-0.0.0.dev49}/PKG-INFO

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

{omlish-0.0.0.dev47 → omlish-0.0.0.dev49}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev47'
-__revision__ = 'f28331ec54caff2de81847ec3e299466513a08f7'
+__version__ = '0.0.0.dev49'
+__revision__ = '1ce1fe5d1498c1f6bbf1e23e570be08c883fcd59'
 
 
 #

{omlish-0.0.0.dev47 → omlish-0.0.0.dev49}/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.dev47 → omlish-0.0.0.dev49}/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.dev49/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.dev47 → omlish-0.0.0.dev49}/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-0.0.0.dev47 → omlish-0.0.0.dev49}/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-0.0.0.dev47 → omlish-0.0.0.dev49}/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-0.0.0.dev47 → omlish-0.0.0.dev49}/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)