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

omlish/specs/jmespath/parser.py

@@ -32,6 +32,8 @@ from . import visitor
 class Parser:
     BINDING_POWER: ta.Mapping[str, int] = {
         'eof': 0,
+        'variable': 0,
+        'assign': 0,
         'unquoted_identifier': 0,
         'quoted_identifier': 0,
         'literal': 0,
@@ -41,6 +43,7 @@ class Parser:
         'rbrace': 0,
         'number': 0,
         'current': 0,
+        'root': 0,
         'expref': 0,
         'colon': 0,
         'pipe': 1,
@@ -52,6 +55,12 @@ class Parser:
         'gte': 5,
         'lte': 5,
         'ne': 5,
+        'minus': 6,
+        'plus': 6,
+        'div': 7,
+        'divide': 7,
+        'modulo': 7,
+        'multiply': 7,
         'flatten': 9,
         # Everything above stops a projection.
         'star': 20,
@@ -76,12 +85,12 @@ class Parser:
         self._buffer_size = lookahead
         self._index = 0
 
-    def parse(self, expression):
+    def parse(self, expression, options=None):
         cached = self._CACHE.get(expression)
         if cached is not None:
             return cached
 
-        parsed_result = self._do_parse(expression)
+        parsed_result = self._do_parse(expression, options)
 
         self._CACHE[expression] = parsed_result
         if len(self._CACHE) > self._MAX_SIZE:
@@ -89,9 +98,9 @@ class Parser:
 
         return parsed_result
 
-    def _do_parse(self, expression):
+    def _do_parse(self, expression, options=None):
         try:
-            return self._parse(expression)
+            return self._parse(expression, options)
 
         except exceptions.LexerError as e:
             e.expression = expression
@@ -105,8 +114,8 @@ class Parser:
             e.expression = expression
             raise
 
-    def _parse(self, expression):
-        self.tokenizer = lexer.Lexer().tokenize(expression)
+    def _parse(self, expression, options=None):
+        self.tokenizer = lexer.Lexer().tokenize(expression, options)
         self._tokens = list(self.tokenizer)
         self._index = 0
 
@@ -157,8 +166,38 @@ class Parser:
     def _token_nud_literal(self, token):
         return ast.literal(token['value'])
 
+    def _token_nud_variable(self, token):
+        return ast.variable_ref(token['value'][1:])
+
     def _token_nud_unquoted_identifier(self, token):
-        return ast.field(token['value'])
+        if token['value'] == 'let' and self._current_token() == 'variable':
+            return self._parse_let_expression()
+        else:
+            return ast.field(token['value'])
+
+    def _parse_let_expression(self):
+        bindings = []
+        while True:
+            var_token = self._lookahead_token(0)
+            # Strip off the '$'.
+            varname = var_token['value'][1:]
+            self._advance()
+            self._match('assign')
+            assign_expr = self._expression()
+            bindings.append(ast.assign(varname, assign_expr))
+            if self._is_in_keyword(self._lookahead_token(0)):
+                self._advance()
+                break
+            else:
+                self._match('comma')
+        expr = self._expression()
+        return ast.let_expression(bindings, expr)
+
+    def _is_in_keyword(self, token):
+        return (
+            token['type'] == 'unquoted_identifier' and
+            token['value'] == 'in'
+        )
 
     def _token_nud_quoted_identifier(self, token):
         field = ast.field(token['value'])
@@ -194,6 +233,12 @@ class Parser:
         self._match('rparen')
         return expression
 
+    def _token_nud_minus(self, token):
+        return self._parse_arithmetic_unary(token)
+
+    def _token_nud_plus(self, token):
+        return self._parse_arithmetic_unary(token)
+
     def _token_nud_flatten(self, token):
         left = ast.flatten(ast.identity())
         right = self._parse_projection_rhs(
@@ -263,6 +308,9 @@ class Parser:
     def _token_nud_current(self, token):
         return ast.current_node()
 
+    def _token_nud_root(self, token):
+        return ast.root_node()
+
     def _token_nud_expref(self, token):
         expression = self._expression(self.BINDING_POWER['expref'])
         return ast.expref(expression)
@@ -348,6 +396,27 @@ class Parser:
     def _token_led_lte(self, left):
         return self._parse_comparator(left, 'lte')
 
+    def _token_led_div(self, left):
+        return self._parse_arithmetic(left, 'div')
+
+    def _token_led_divide(self, left):
+        return self._parse_arithmetic(left, 'divide')
+
+    def _token_led_minus(self, left):
+        return self._parse_arithmetic(left, 'minus')
+
+    def _token_led_modulo(self, left):
+        return self._parse_arithmetic(left, 'modulo')
+
+    def _token_led_multiply(self, left):
+        return self._parse_arithmetic(left, 'multiply')
+
+    def _token_led_plus(self, left):
+        return self._parse_arithmetic(left, 'plus')
+
+    def _token_led_star(self, left):
+        return self._parse_arithmetic(left, 'multiply')
+
     def _token_led_flatten(self, left):
         left = ast.flatten(left)
         right = self._parse_projection_rhs(self.BINDING_POWER['flatten'])
@@ -387,6 +456,14 @@ class Parser:
         right = self._expression(self.BINDING_POWER[comparator])
         return ast.comparator(comparator, left, right)
 
+    def _parse_arithmetic_unary(self, token):
+        expression = self._expression(self.BINDING_POWER[token['type']])
+        return ast.arithmetic_unary(token['type'], expression)
+
+    def _parse_arithmetic(self, left, operator):
+        right = self._expression(self.BINDING_POWER[operator])
+        return ast.arithmetic(operator, left, right)
+
     def _parse_multi_select_list(self):
         expressions = []
         while True:
@@ -542,7 +619,8 @@ class Parser:
         )
 
     def _free_cache_entries(self):
-        for key in random.sample(list(self._CACHE.keys()), int(self._MAX_SIZE / 2)):
+        keys = list(self._CACHE.keys())
+        for key in random.sample(keys, min(len(keys), int(self._MAX_SIZE / 2))):
             self._CACHE.pop(key, None)
 
     @classmethod
@@ -558,9 +636,8 @@ class ParsedResult:
         self.parsed = parsed
 
     def search(self, value, options=None):
-        interpreter = visitor.TreeInterpreter(options)
-        result = interpreter.visit(self.parsed, value)
-        return result
+        evaluator = visitor.TreeInterpreter(options)
+        return evaluator.evaluate(self.parsed, value)
 
     def _render_dot_file(self):
         """
@@ -579,9 +656,9 @@ class ParsedResult:
         return repr(self.parsed)
 
 
-def compile(expression):  # noqa
-    return Parser().parse(expression)
+def compile(expression, options=None):  # noqa
+    return Parser().parse(expression, options=options)
 
 
 def search(expression, data, options=None):
-    return Parser().parse(expression).search(data, options=options)
+    return compile(expression, options).search(data, options=options)

omlish/specs/jmespath/scope.py

@@ -0,0 +1,35 @@
+import collections
+
+
+class ScopedChainDict:
+    """
+    Dictionary that can delegate lookups to multiple dicts. This provides a basic get/set dict interface that is backed
+    by multiple dicts.  Each dict is searched from the top most (most recently pushed) scope dict until a match is
+    found.
+    """
+
+    def __init__(self, *scopes):
+        # The scopes are evaluated starting at the top of the stack (the most recently pushed scope via .push_scope()).
+        # If we use a normal list() and push/pop scopes by adding/removing to the end of the list, we'd have to always
+        # call reversed(self._scopes) whenever we resolve a key, because the end of the list is the top of the stack.
+        # To avoid this, we're using a deque so we can append to the front of the list via .appendleft() in constant
+        # time, and iterate over scopes without having to do so with a reversed() call each time.
+        self._scopes = collections.deque(scopes)
+
+    def __getitem__(self, key):
+        for scope in self._scopes:
+            if key in scope:
+                return scope[key]
+        raise KeyError(key)
+
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def push_scope(self, scope):
+        self._scopes.appendleft(scope)
+
+    def pop_scope(self):
+        self._scopes.popleft()

omlish/specs/jmespath/visitor.py

@@ -2,7 +2,9 @@ import numbers
 import operator
 import typing as ta
 
+from . import exceptions
 from . import functions
+from .scope import ScopedChainDict
 
 
 def _equals(x, y):
@@ -58,7 +60,12 @@ def _is_actual_number(x):
 class Options:
     """Options to control how a Jmespath function is evaluated."""
 
-    def __init__(self, dict_cls=None, custom_functions=None):
+    def __init__(
+            self,
+            dict_cls=None,
+            custom_functions=None,
+            enable_legacy_literals=False,
+    ):
         #: The class to use when creating a dict.  The interpreter may create dictionaries during the evaluation of a
         #  Jmespath expression.  For example, a multi-select hash will create a dictionary.  By default we use a dict()
         #  type. You can set this value to change what dict type is used. The most common reason you would change this
@@ -66,6 +73,12 @@ class Options:
         self.dict_cls = dict_cls
         self.custom_functions = custom_functions
 
+        #: The flag to enable pre-JEP-12 literal compatibility.
+        #  JEP-12 deprecates `foo` -> "foo" syntax.
+        #  Valid expressions MUST use: `"foo"` -> "foo"
+        #  Setting this flag to `True` enables support for legacy syntax.
+        self.enable_legacy_literals = enable_legacy_literals
+
 
 class _Expression:
     def __init__(self, expression, interpreter):
@@ -104,6 +117,20 @@ class TreeInterpreter(Visitor):
 
     _EQUALITY_OPS: ta.Sequence[str] = ['eq', 'ne']
 
+    _ARITHMETIC_UNARY_FUNC: ta.Mapping[str, ta.Callable] = {
+        'minus': operator.neg,
+        'plus': lambda x: x,
+    }
+
+    _ARITHMETIC_FUNC: ta.Mapping[str, ta.Callable] = {
+        'div': operator.floordiv,
+        'divide': operator.truediv,
+        'minus': operator.sub,
+        'modulo': operator.mod,
+        'multiply': operator.mul,
+        'plus': operator.add,
+    }
+
     MAP_TYPE = dict
 
     def __init__(self, options=None):
@@ -123,13 +150,22 @@ class TreeInterpreter(Visitor):
         else:
             self._functions = functions.Functions()
 
+        self._root = None
+        self._scope = ScopedChainDict()
+
     def default_visit(self, node, *args, **kwargs):
         raise NotImplementedError(node['type'])
 
+    def evaluate(self, ast, root):
+        self._root = root
+        return self.visit(ast, root)
+
     def visit_subexpression(self, node, value):
         result = value
         for child in node['children']:
             result = self.visit(child, result)
+            if result is None:
+                return None
         return result
 
     def visit_field(self, node, value):
@@ -157,9 +193,25 @@ class TreeInterpreter(Visitor):
                 return None
             return comparator_func(left, right)
 
+    def visit_arithmetic_unary(self, node, value):
+        operation = self._ARITHMETIC_UNARY_FUNC[node['value']]
+        return operation(
+            self.visit(node['children'][0], value),
+        )
+
+    def visit_arithmetic(self, node, value):
+        operation = self._ARITHMETIC_FUNC[node['value']]
+        return operation(
+            self.visit(node['children'][0], value),
+            self.visit(node['children'][1], value),
+        )
+
     def visit_current(self, node, value):
         return value
 
+    def visit_root(self, node, value):
+        return self._root
+
     def visit_expref(self, node, value):
         return _Expression(node['children'][0], self)
 
@@ -222,8 +274,15 @@ class TreeInterpreter(Visitor):
         return result
 
     def visit_slice(self, node, value):
+        if isinstance(value, str):
+            start = node['children'][0]
+            end = node['children'][1]
+            step = node['children'][2]
+            return value[start:end:step]
+
         if not isinstance(value, list):
             return None
+
         s = slice(*node['children'])
         return value[s]
 
@@ -234,9 +293,6 @@ class TreeInterpreter(Visitor):
         return node['value']
 
     def visit_multi_select_dict(self, node, value):
-        if value is None:
-            return None
-
         collected = self._dict_cls()
         for child in node['children']:
             collected[child['value']] = self.visit(child, value)
@@ -244,9 +300,6 @@ class TreeInterpreter(Visitor):
         return collected
 
     def visit_multi_select_list(self, node, value):
-        if value is None:
-            return None
-
         collected = []
         for child in node['children']:
             collected.append(self.visit(child, value))
@@ -286,9 +339,20 @@ class TreeInterpreter(Visitor):
 
     def visit_projection(self, node, value):
         base = self.visit(node['children'][0], value)
+
+        allow_string = False
+        first_child = node['children'][0]
+        if first_child['type'] == 'index_expression':
+            nested_children = first_child['children']
+            if len(nested_children) > 1 and nested_children[1]['type'] == 'slice':
+                allow_string = True
+
+        if isinstance(base, str) and allow_string:
+            # projections are really sub-expressions in disguise evaluate the rhs when lhs is a sliced string
+            return self.visit(node['children'][1], base)
+
         if not isinstance(base, list):
             return None
-
         collected = []
         for element in base:
             current = self.visit(node['children'][1], element)
@@ -297,6 +361,27 @@ class TreeInterpreter(Visitor):
 
         return collected
 
+    def visit_let_expression(self, node, value):
+        *bindings, expr = node['children']
+        scope = {}
+        for assign in bindings:
+            scope.update(self.visit(assign, value))
+        self._scope.push_scope(scope)
+        result = self.visit(expr, value)
+        self._scope.pop_scope()
+        return result
+
+    def visit_assign(self, node, value):
+        name = node['value']
+        value = self.visit(node['children'][0], value)
+        return {name: value}
+
+    def visit_variable_ref(self, node, value):
+        try:
+            return self._scope[node['value']]
+        except KeyError:
+            raise exceptions.UndefinedVariableError(node['value'])  # noqa
+
     def visit_value_projection(self, node, value):
         base = self.visit(node['children'][0], value)
         try:

omlish/specs/jsonschema/keywords/__init__.py

@@ -17,6 +17,12 @@ from .metadata import (  # noqa
 )
 
 from .parse import (  # noqa
+    DEFAULT_KEYWORD_SUPERTYPES,
+    DEFAULT_KEYWORD_TYPES,
+    DEFAULT_KEYWORD_TYPES_BY_TAG,
+    DEFAULT_PARSER,
+    Parser,
+    build_keyword_types_by_tag,
     parse_keyword,
     parse_keywords,
 )

omlish/specs/jsonschema/keywords/base.py

@@ -14,7 +14,7 @@ KeywordT = ta.TypeVar('KeywordT', bound='Keyword')
 ##
 
 
-class Keyword(lang.Abstract, lang.PackageSealed):
+class Keyword(lang.Abstract):
     tag: ta.ClassVar[str]
 
     def __init_subclass__(cls, *, tag: str | None = None, **kwargs: ta.Any) -> None:

omlish/specs/jsonschema/keywords/core.py

@@ -6,7 +6,7 @@ from .base import StrKeyword
 ##
 
 
-class CoreKeyword(Keyword, lang.Abstract):
+class CoreKeyword(Keyword, lang.Abstract, lang.Sealed):
     pass
 
 

omlish/specs/jsonschema/keywords/metadata.py

@@ -6,7 +6,7 @@ from .base import StrKeyword
 ##
 
 
-class MetadataKeyword(Keyword, lang.Abstract):
+class MetadataKeyword(Keyword, lang.Abstract, lang.Sealed):
     pass
 
 

omlish/specs/jsonschema/keywords/parse.py

@@ -4,9 +4,6 @@ import typing as ta
 from .... import check
 from .... import collections as col
 from .... import lang
-from . import core  # noqa
-from . import metadata  # noqa
-from . import validation  # noqa
 from .base import BooleanKeyword
 from .base import Keyword
 from .base import Keywords
@@ -15,6 +12,9 @@ from .base import NumberKeyword
 from .base import StrKeyword
 from .base import StrOrStrsKeyword
 from .base import StrToKeywordsKeyword
+from .core import CoreKeyword
+from .metadata import MetadataKeyword
+from .validation import ValidationKeyword
 
 
 KeywordT = ta.TypeVar('KeywordT', bound=Keyword)
@@ -23,46 +23,79 @@ KeywordT = ta.TypeVar('KeywordT', bound=Keyword)
 ##
 
 
-KEYWORD_TYPES_BY_TAG: ta.Mapping[str, type[Keyword]] = col.make_map_by(  # noqa
-    operator.attrgetter('tag'),
-    (cls for cls in lang.deep_subclasses(Keyword) if not lang.is_abstract_class(cls)),
-    strict=True,
-)
+def build_keyword_types_by_tag(keyword_types: ta.Iterable[type[Keyword]]) -> ta.Mapping[str, type[Keyword]]:
+    return col.make_map_by(operator.attrgetter('tag'), keyword_types, strict=True)
 
 
-def parse_keyword(cls: type[KeywordT], v: ta.Any) -> KeywordT:
-    if issubclass(cls, BooleanKeyword):
-        return cls(check.isinstance(v, bool))  # type: ignore
+DEFAULT_KEYWORD_SUPERTYPES: ta.AbstractSet = frozenset([
+    CoreKeyword,
+    MetadataKeyword,
+    ValidationKeyword,
+])
 
-    elif issubclass(cls, NumberKeyword):
-        return cls(check.isinstance(v, (int, float)))  # type: ignore
+DEFAULT_KEYWORD_TYPES: ta.AbstractSet = frozenset(lang.flatten(
+    lang.deep_subclasses(st, concrete_only=True) for st in DEFAULT_KEYWORD_SUPERTYPES
+))
 
-    elif issubclass(cls, StrKeyword):
-        return cls(check.isinstance(v, str))  # type: ignore
+DEFAULT_KEYWORD_TYPES_BY_TAG: ta.Mapping[str, type[Keyword]] = build_keyword_types_by_tag(DEFAULT_KEYWORD_TYPES)
 
-    elif issubclass(cls, StrOrStrsKeyword):
-        ss: str | ta.Sequence[str]
-        if isinstance(v, str):
-            ss = v
-        elif isinstance(v, ta.Iterable):
-            ss = col.seq_of(check.of_isinstance(str))(v)
+
+##
+
+
+class Parser:
+    def __init__(
+            self,
+            keyword_types: ta.Iterable[type[Keyword]] | ta.Mapping[str, type[Keyword]] = DEFAULT_KEYWORD_TYPES_BY_TAG,
+    ) -> None:
+        super().__init__()
+
+        if isinstance(keyword_types, ta.Mapping):
+            self._keyword_types_by_tag = keyword_types
         else:
-            raise TypeError(v)
-        return cls(ss)  # type: ignore
+            self._keyword_types_by_tag = build_keyword_types_by_tag(keyword_types)
+
+    def parse_keyword(self, cls: type[KeywordT], v: ta.Any) -> KeywordT:
+        if issubclass(cls, BooleanKeyword):
+            return cls(check.isinstance(v, bool))  # type: ignore
+
+        elif issubclass(cls, NumberKeyword):
+            return cls(check.isinstance(v, (int, float)))  # type: ignore
+
+        elif issubclass(cls, StrKeyword):
+            return cls(check.isinstance(v, str))  # type: ignore
 
-    elif issubclass(cls, KeywordsKeyword):
-        return cls(parse_keywords(v))  # type: ignore
+        elif issubclass(cls, StrOrStrsKeyword):
+            ss: str | ta.Sequence[str]
+            if isinstance(v, str):
+                ss = v
+            elif isinstance(v, ta.Iterable):
+                ss = col.seq_of(check.of_isinstance(str))(v)
+            else:
+                raise TypeError(v)
+            return cls(ss)  # type: ignore
 
-    elif issubclass(cls, StrToKeywordsKeyword):
-        return cls({k: parse_keywords(mv) for k, mv in v.items()})  # type: ignore
+        elif issubclass(cls, KeywordsKeyword):
+            return cls(parse_keywords(v))  # type: ignore
+
+        elif issubclass(cls, StrToKeywordsKeyword):
+            return cls({k: parse_keywords(mv) for k, mv in v.items()})  # type: ignore
+
+        else:
+            raise TypeError(cls)
+
+    def parse_keywords(self, dct: ta.Mapping[str, ta.Any]) -> Keywords:
+        lst: list[Keyword] = []
+        for k, v in dct.items():
+            cls = self._keyword_types_by_tag[k]
+            lst.append(self.parse_keyword(cls, v))
+        return Keywords(lst)
+
+
+##
 
-    else:
-        raise TypeError(cls)
 
+DEFAULT_PARSER = Parser()
 
-def parse_keywords(dct: ta.Mapping[str, ta.Any]) -> Keywords:
-    lst: list[Keyword] = []
-    for k, v in dct.items():
-        cls = KEYWORD_TYPES_BY_TAG[k]
-        lst.append(parse_keyword(cls, v))
-    return Keywords(lst)
+parse_keyword = DEFAULT_PARSER.parse_keyword
+parse_keywords = DEFAULT_PARSER.parse_keywords

omlish/specs/jsonschema/keywords/validation.py

@@ -10,7 +10,7 @@ from .base import StrToKeywordsKeyword
 ##
 
 
-class ValidationKeyword(Keyword, lang.Abstract):
+class ValidationKeyword(Keyword, lang.Abstract, lang.Sealed):
     pass
 
 

{omlish-0.0.0.dev47.dist-info → omlish-0.0.0.dev49.dist-info}/METADATA

@@ -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