expression-py 0.1.0__py3-none-any.whl

expression/parser.py

@@ -0,0 +1,968 @@
+#!/usr/bin/env python3.8
+# @generated by pegen from expression/grammar.peg
+
+import ast
+import sys
+import tokenize
+
+from typing import Any, Optional
+
+from pegen.parser import memoize, memoize_left_rec, logger, Parser
+from expression.helpers import (
+    with_type, is_typed, is_number, is_string_type, is_array_type,
+    validate_number, validate_types, maybe_regex, do_check_equal,
+    do_match, do_power, loose_equal, to_array,
+)
+
+# Keywords and soft keywords are listed at the end of the parser definition.
+class ExpressionParser(Parser):
+
+    @memoize
+    def start(self) -> Optional[object]:
+        # start: start_rule $
+        mark = self._mark()
+        if (
+            (a := self.start_rule())
+            and
+            (self.expect('ENDMARKER'))
+        ):
+            return a;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def start_rule(self) -> Optional[object]:
+        # start_rule: function_assignment | variable_assignment | expr ';' | expr
+        mark = self._mark()
+        if (
+            (function_assignment := self.function_assignment())
+        ):
+            return function_assignment;
+        self._reset(mark)
+        if (
+            (variable_assignment := self.variable_assignment())
+        ):
+            return variable_assignment;
+        self._reset(mark)
+        if (
+            (a := self.expr())
+            and
+            (self.expect(';'))
+        ):
+            return a;
+        self._reset(mark)
+        if (
+            (expr := self.expr())
+        ):
+            return expr;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def function_assignment(self) -> Optional[object]:
+        # function_assignment: NAME '(' param_list_inner ')' '=' func_rest | NAME '(' ')' '=' func_rest
+        mark = self._mark()
+        if (
+            (name := self.name())
+            and
+            (self.expect('('))
+            and
+            (params := self.param_list_inner())
+            and
+            (self.expect(')'))
+            and
+            (self.expect('='))
+            and
+            (self.func_rest())
+        ):
+            return self . _func_assign ( name . string , params );
+        self._reset(mark)
+        if (
+            (name := self.name())
+            and
+            (self.expect('('))
+            and
+            (self.expect(')'))
+            and
+            (self.expect('='))
+            and
+            (self.func_rest())
+        ):
+            return self . _func_assign ( name . string , [] );
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def param_list_inner(self) -> Optional[list]:
+        # param_list_inner: NAME ',' param_list_inner | NAME
+        mark = self._mark()
+        if (
+            (a := self.name())
+            and
+            (self.expect(','))
+            and
+            (b := self.param_list_inner())
+        ):
+            return [a . string] + b;
+        self._reset(mark)
+        if (
+            (a := self.name())
+        ):
+            return [a . string];
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def func_rest(self) -> Optional[object]:
+        # func_rest: expr ';' | expr
+        mark = self._mark()
+        if (
+            (a := self.expr())
+            and
+            (self.expect(';'))
+        ):
+            return a;
+        self._reset(mark)
+        if (
+            (a := self.expr())
+        ):
+            return a;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def variable_assignment(self) -> Optional[object]:
+        # variable_assignment: NAME '=' !'=' !'~' expr ';' | NAME '=' !'=' !'~' expr
+        mark = self._mark()
+        if (
+            (name := self.name())
+            and
+            (self.expect('='))
+            and
+            (self.negative_lookahead(self.expect, '='))
+            and
+            (self.negative_lookahead(self.expect, '~'))
+            and
+            (value := self.expr())
+            and
+            (self.expect(';'))
+        ):
+            return self . _var_assign ( name . string , value );
+        self._reset(mark)
+        if (
+            (name := self.name())
+            and
+            (self.expect('='))
+            and
+            (self.negative_lookahead(self.expect, '='))
+            and
+            (self.negative_lookahead(self.expect, '~'))
+            and
+            (value := self.expr())
+        ):
+            return self . _var_assign ( name . string , value );
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def expr(self) -> Optional[object]:
+        # expr: ternary
+        mark = self._mark()
+        if (
+            (ternary := self.ternary())
+        ):
+            return ternary;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def ternary(self) -> Optional[object]:
+        # ternary: boolean '?' expr ':' ternary | boolean
+        mark = self._mark()
+        if (
+            (a := self.boolean())
+            and
+            (self.expect('?'))
+            and
+            (b := self.expr())
+            and
+            (self.expect(':'))
+            and
+            (c := self.ternary())
+        ):
+            return b if a ['value'] else c;
+        self._reset(mark)
+        if (
+            (boolean := self.boolean())
+        ):
+            return boolean;
+        self._reset(mark)
+        return None;
+
+    @memoize_left_rec
+    def boolean(self) -> Optional[object]:
+        # boolean: boolean '&&' compare | boolean '||' compare | compare
+        mark = self._mark()
+        if (
+            (a := self.boolean())
+            and
+            (self.expect('&&'))
+            and
+            (b := self.compare())
+        ):
+            return with_type ( b ['value'] if a ['value'] else a ['value'] );
+        self._reset(mark)
+        if (
+            (a := self.boolean())
+            and
+            (self.expect('||'))
+            and
+            (b := self.compare())
+        ):
+            return with_type ( a ['value'] if a ['value'] else b ['value'] );
+        self._reset(mark)
+        if (
+            (compare := self.compare())
+        ):
+            return compare;
+        self._reset(mark)
+        return None;
+
+    @memoize_left_rec
+    def compare(self) -> Optional[object]:
+        # compare: compare '===' bitshift | compare '!==' bitshift | compare '<=>' bitshift | compare '==' bitshift | compare '=~' bitshift | compare '!=' bitshift | compare '>=' bitshift | compare '<=' bitshift | compare '>' bitshift | compare '<' bitshift | compare 'in' bitshift | bitshift
+        mark = self._mark()
+        if (
+            (a := self.compare())
+            and
+            (self.expect('==='))
+            and
+            (b := self.bitshift())
+        ):
+            return with_type ( type ( a ['value'] ) == type ( b ['value'] ) and a ['value'] == b ['value'] );
+        self._reset(mark)
+        if (
+            (a := self.compare())
+            and
+            (self.expect('!=='))
+            and
+            (b := self.bitshift())
+        ):
+            return with_type ( not ( type ( a ['value'] ) == type ( b ['value'] ) and a ['value'] == b ['value'] ) );
+        self._reset(mark)
+        if (
+            (a := self.compare())
+            and
+            (self.expect('<=>'))
+            and
+            (b := self.bitshift())
+        ):
+            return self . _spaceship ( a , b );
+        self._reset(mark)
+        if (
+            (a := self.compare())
+            and
+            (self.expect('=='))
+            and
+            (b := self.bitshift())
+        ):
+            return do_check_equal ( a , b , lambda x , y : loose_equal ( x , y ) );
+        self._reset(mark)
+        if (
+            (a := self.compare())
+            and
+            (self.expect('=~'))
+            and
+            (b := self.bitshift())
+        ):
+            return do_match ( a , b , self . variables );
+        self._reset(mark)
+        if (
+            (a := self.compare())
+            and
+            (self.expect('!='))
+            and
+            (b := self.bitshift())
+        ):
+            return do_check_equal ( a , b , lambda x , y : not loose_equal ( x , y ) );
+        self._reset(mark)
+        if (
+            (a := self.compare())
+            and
+            (self.expect('>='))
+            and
+            (b := self.bitshift())
+        ):
+            return self . _compare_op ( '>=' , a , b , lambda x , y : x >= y );
+        self._reset(mark)
+        if (
+            (a := self.compare())
+            and
+            (self.expect('<='))
+            and
+            (b := self.bitshift())
+        ):
+            return self . _compare_op ( '<=' , a , b , lambda x , y : x <= y );
+        self._reset(mark)
+        if (
+            (a := self.compare())
+            and
+            (self.expect('>'))
+            and
+            (b := self.bitshift())
+        ):
+            return self . _compare_op ( '>' , a , b , lambda x , y : x > y );
+        self._reset(mark)
+        if (
+            (a := self.compare())
+            and
+            (self.expect('<'))
+            and
+            (b := self.bitshift())
+        ):
+            return self . _compare_op ( '<' , a , b , lambda x , y : x < y );
+        self._reset(mark)
+        if (
+            (a := self.compare())
+            and
+            (self.expect('in'))
+            and
+            (b := self.bitshift())
+        ):
+            return self . _in ( a , b );
+        self._reset(mark)
+        if (
+            (bitshift := self.bitshift())
+        ):
+            return bitshift;
+        self._reset(mark)
+        return None;
+
+    @memoize_left_rec
+    def bitshift(self) -> Optional[object]:
+        # bitshift: bitshift '<<' sum_expr | bitshift '>>' sum_expr | sum_expr
+        mark = self._mark()
+        if (
+            (a := self.bitshift())
+            and
+            (self.expect('<<'))
+            and
+            (b := self.sum_expr())
+        ):
+            return self . _lshift ( a , b );
+        self._reset(mark)
+        if (
+            (a := self.bitshift())
+            and
+            (self.expect('>>'))
+            and
+            (b := self.sum_expr())
+        ):
+            return self . _shift_op ( '>>' , a , b , lambda x , y : x >> y );
+        self._reset(mark)
+        if (
+            (sum_expr := self.sum_expr())
+        ):
+            return sum_expr;
+        self._reset(mark)
+        return None;
+
+    @memoize_left_rec
+    def sum_expr(self) -> Optional[object]:
+        # sum_expr: sum_expr '+' product | sum_expr '-' product | sum_expr '|' product | product
+        mark = self._mark()
+        if (
+            (a := self.sum_expr())
+            and
+            (self.expect('+'))
+            and
+            (b := self.product())
+        ):
+            return self . _plus ( a , b );
+        self._reset(mark)
+        if (
+            (a := self.sum_expr())
+            and
+            (self.expect('-'))
+            and
+            (b := self.product())
+        ):
+            return self . _minus ( a , b );
+        self._reset(mark)
+        if (
+            (a := self.sum_expr())
+            and
+            (self.expect('|'))
+            and
+            (b := self.product())
+        ):
+            return self . _union ( a , b );
+        self._reset(mark)
+        if (
+            (product := self.product())
+        ):
+            return product;
+        self._reset(mark)
+        return None;
+
+    @memoize_left_rec
+    def product(self) -> Optional[object]:
+        # product: product '*' !'*' unary | product '/' unary | product '%' unary | product '&' unary | product '[' expr ']' | product implicit_mul | unary
+        mark = self._mark()
+        if (
+            (a := self.product())
+            and
+            (self.expect('*'))
+            and
+            (self.negative_lookahead(self.expect, '*'))
+            and
+            (b := self.unary())
+        ):
+            return self . _mul ( a , b );
+        self._reset(mark)
+        if (
+            (a := self.product())
+            and
+            (self.expect('/'))
+            and
+            (b := self.unary())
+        ):
+            return self . _div ( a , b );
+        self._reset(mark)
+        if (
+            (a := self.product())
+            and
+            (self.expect('%'))
+            and
+            (b := self.unary())
+        ):
+            return self . _mod ( a , b );
+        self._reset(mark)
+        if (
+            (a := self.product())
+            and
+            (self.expect('&'))
+            and
+            (b := self.unary())
+        ):
+            return self . _intersect ( a , b );
+        self._reset(mark)
+        if (
+            (a := self.product())
+            and
+            (self.expect('['))
+            and
+            (b := self.expr())
+            and
+            (self.expect(']'))
+        ):
+            return self . _property_access ( a , b );
+        self._reset(mark)
+        if (
+            (a := self.product())
+            and
+            (b := self.implicit_mul())
+        ):
+            return self . _implicit_mul ( a , b );
+        self._reset(mark)
+        if (
+            (unary := self.unary())
+        ):
+            return unary;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def implicit_mul(self) -> Optional[object]:
+        # implicit_mul: paren_expr_pow | func_call_pow | var_ref_pow
+        mark = self._mark()
+        if (
+            (paren_expr_pow := self.paren_expr_pow())
+        ):
+            return paren_expr_pow;
+        self._reset(mark)
+        if (
+            (func_call_pow := self.func_call_pow())
+        ):
+            return func_call_pow;
+        self._reset(mark)
+        if (
+            (var_ref_pow := self.var_ref_pow())
+        ):
+            return var_ref_pow;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def paren_expr_pow(self) -> Optional[object]:
+        # paren_expr_pow: paren_expr '**' value | paren_expr '^' value | paren_expr
+        mark = self._mark()
+        if (
+            (a := self.paren_expr())
+            and
+            (self.expect('**'))
+            and
+            (b := self.value())
+        ):
+            return do_power ( a , b );
+        self._reset(mark)
+        if (
+            (a := self.paren_expr())
+            and
+            (self.expect('^'))
+            and
+            (b := self.value())
+        ):
+            return do_power ( a , b );
+        self._reset(mark)
+        if (
+            (paren_expr := self.paren_expr())
+        ):
+            return paren_expr;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def func_call_pow(self) -> Optional[object]:
+        # func_call_pow: function_call '**' value | function_call '^' value | function_call
+        mark = self._mark()
+        if (
+            (a := self.function_call())
+            and
+            (self.expect('**'))
+            and
+            (b := self.value())
+        ):
+            return do_power ( a , b );
+        self._reset(mark)
+        if (
+            (a := self.function_call())
+            and
+            (self.expect('^'))
+            and
+            (b := self.value())
+        ):
+            return do_power ( a , b );
+        self._reset(mark)
+        if (
+            (function_call := self.function_call())
+        ):
+            return function_call;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def var_ref_pow(self) -> Optional[object]:
+        # var_ref_pow: var_ref '**' value | var_ref '^' value | var_ref
+        mark = self._mark()
+        if (
+            (a := self.var_ref())
+            and
+            (self.expect('**'))
+            and
+            (b := self.value())
+        ):
+            return do_power ( a , b );
+        self._reset(mark)
+        if (
+            (a := self.var_ref())
+            and
+            (self.expect('^'))
+            and
+            (b := self.value())
+        ):
+            return do_power ( a , b );
+        self._reset(mark)
+        if (
+            (var_ref := self.var_ref())
+        ):
+            return var_ref;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def unary(self) -> Optional[object]:
+        # unary: '!' unary | '-' unary | '+' unary | power
+        mark = self._mark()
+        if (
+            (self.expect('!'))
+            and
+            (a := self.unary())
+        ):
+            return with_type ( not a ['value'] );
+        self._reset(mark)
+        if (
+            (self.expect('-'))
+            and
+            (a := self.unary())
+        ):
+            return self . _unary_minus ( a );
+        self._reset(mark)
+        if (
+            (self.expect('+'))
+            and
+            (a := self.unary())
+        ):
+            return self . _unary_plus ( a );
+        self._reset(mark)
+        if (
+            (power := self.power())
+        ):
+            return power;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def power(self) -> Optional[object]:
+        # power: value '**' power | value '^' power | value
+        mark = self._mark()
+        if (
+            (a := self.value())
+            and
+            (self.expect('**'))
+            and
+            (b := self.power())
+        ):
+            return do_power ( a , b );
+        self._reset(mark)
+        if (
+            (a := self.value())
+            and
+            (self.expect('^'))
+            and
+            (b := self.power())
+        ):
+            return do_power ( a , b );
+        self._reset(mark)
+        if (
+            (value := self.value())
+        ):
+            return value;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def value(self) -> Optional[object]:
+        # value: json_value | const_value | regex_value | string_value | number_value | function_call | var_ref | paren_expr
+        mark = self._mark()
+        if (
+            (json_value := self.json_value())
+        ):
+            return json_value;
+        self._reset(mark)
+        if (
+            (const_value := self.const_value())
+        ):
+            return const_value;
+        self._reset(mark)
+        if (
+            (regex_value := self.regex_value())
+        ):
+            return regex_value;
+        self._reset(mark)
+        if (
+            (string_value := self.string_value())
+        ):
+            return string_value;
+        self._reset(mark)
+        if (
+            (number_value := self.number_value())
+        ):
+            return number_value;
+        self._reset(mark)
+        if (
+            (function_call := self.function_call())
+        ):
+            return function_call;
+        self._reset(mark)
+        if (
+            (var_ref := self.var_ref())
+        ):
+            return var_ref;
+        self._reset(mark)
+        if (
+            (paren_expr := self.paren_expr())
+        ):
+            return paren_expr;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def paren_expr(self) -> Optional[object]:
+        # paren_expr: '(' expr ')'
+        mark = self._mark()
+        if (
+            (self.expect('('))
+            and
+            (a := self.expr())
+            and
+            (self.expect(')'))
+        ):
+            return a;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def json_value(self) -> Optional[object]:
+        # json_value: '{' json_obj_body '}' | '{' '}' | '[' json_arr_body ']' | '[' ']'
+        mark = self._mark()
+        if (
+            (self.expect('{'))
+            and
+            (a := self.json_obj_body())
+            and
+            (self.expect('}'))
+        ):
+            return with_type ( a , 'array' );
+        self._reset(mark)
+        if (
+            (self.expect('{'))
+            and
+            (self.expect('}'))
+        ):
+            return with_type ( {} , 'array' );
+        self._reset(mark)
+        if (
+            (self.expect('['))
+            and
+            (a := self.json_arr_body())
+            and
+            (self.expect(']'))
+        ):
+            return with_type ( a , 'array' );
+        self._reset(mark)
+        if (
+            (self.expect('['))
+            and
+            (self.expect(']'))
+        ):
+            return with_type ( [] , 'array' );
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def json_obj_body(self) -> Optional[dict]:
+        # json_obj_body: STRING ':' json_element ',' json_obj_body | STRING ':' json_element
+        mark = self._mark()
+        if (
+            (a := self.string())
+            and
+            (self.expect(':'))
+            and
+            (b := self.json_element())
+            and
+            (self.expect(','))
+            and
+            (c := self.json_obj_body())
+        ):
+            return self . _merge_obj ( a , b , c );
+        self._reset(mark)
+        if (
+            (a := self.string())
+            and
+            (self.expect(':'))
+            and
+            (b := self.json_element())
+        ):
+            return self . _make_obj ( a , b );
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def json_arr_body(self) -> Optional[list]:
+        # json_arr_body: json_element ',' json_arr_body | json_element
+        mark = self._mark()
+        if (
+            (a := self.json_element())
+            and
+            (self.expect(','))
+            and
+            (b := self.json_arr_body())
+        ):
+            return [a] + b;
+        self._reset(mark)
+        if (
+            (a := self.json_element())
+        ):
+            return [a];
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def json_element(self) -> Optional[object]:
+        # json_element: '{' json_obj_body '}' | '[' json_arr_body ']' | STRING | NUMBER | 'true' | 'false' | 'null'
+        mark = self._mark()
+        if (
+            (self.expect('{'))
+            and
+            (a := self.json_obj_body())
+            and
+            (self.expect('}'))
+        ):
+            return dict ( a );
+        self._reset(mark)
+        if (
+            (self.expect('['))
+            and
+            (a := self.json_arr_body())
+            and
+            (self.expect(']'))
+        ):
+            return list ( a );
+        self._reset(mark)
+        if (
+            (a := self.string())
+        ):
+            return self . _json_string_val ( a );
+        self._reset(mark)
+        if (
+            (a := self.number())
+        ):
+            return self . _json_number_val ( a );
+        self._reset(mark)
+        if (
+            (self.expect('true'))
+        ):
+            return True;
+        self._reset(mark)
+        if (
+            (self.expect('false'))
+        ):
+            return False;
+        self._reset(mark)
+        if (
+            (self.expect('null'))
+        ):
+            return None;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def const_value(self) -> Optional[object]:
+        # const_value: 'true' | 'false' | 'null'
+        mark = self._mark()
+        if (
+            (self.expect('true'))
+        ):
+            return with_type ( True );
+        self._reset(mark)
+        if (
+            (self.expect('false'))
+        ):
+            return with_type ( False );
+        self._reset(mark)
+        if (
+            (self.expect('null'))
+        ):
+            return with_type ( None );
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def regex_value(self) -> Optional[object]:
+        # regex_value: regex_literal
+        mark = self._mark()
+        if (
+            (a := self.regex_literal())
+        ):
+            return with_type ( a . string , 'regex' );
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def regex_literal(self) -> Optional[object]:
+        # regex_literal: OP
+        mark = self._mark()
+        if (
+            (a := self.op())
+        ):
+            return a;
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def string_value(self) -> Optional[object]:
+        # string_value: STRING
+        mark = self._mark()
+        if (
+            (a := self.string())
+        ):
+            return self . _parse_string ( a );
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def number_value(self) -> Optional[object]:
+        # number_value: NUMBER
+        mark = self._mark()
+        if (
+            (a := self.number())
+        ):
+            return self . _parse_number ( a );
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def function_call(self) -> Optional[object]:
+        # function_call: NAME '(' arg_list_inner ')' | NAME '(' ')'
+        mark = self._mark()
+        if (
+            (name := self.name())
+            and
+            (self.expect('('))
+            and
+            (args := self.arg_list_inner())
+            and
+            (self.expect(')'))
+        ):
+            return self . _call_function ( name . string , args );
+        self._reset(mark)
+        if (
+            (name := self.name())
+            and
+            (self.expect('('))
+            and
+            (self.expect(')'))
+        ):
+            return self . _call_function ( name . string , [] );
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def arg_list_inner(self) -> Optional[list]:
+        # arg_list_inner: expr ',' arg_list_inner | expr
+        mark = self._mark()
+        if (
+            (a := self.expr())
+            and
+            (self.expect(','))
+            and
+            (b := self.arg_list_inner())
+        ):
+            return [a] + b;
+        self._reset(mark)
+        if (
+            (a := self.expr())
+        ):
+            return [a];
+        self._reset(mark)
+        return None;
+
+    @memoize
+    def var_ref(self) -> Optional[object]:
+        # var_ref: NAME
+        mark = self._mark()
+        if (
+            (a := self.name())
+        ):
+            return self . _resolve_var ( a . string );
+        self._reset(mark)
+        return None;
+
+    KEYWORDS = ('false', 'in', 'null', 'true')
+    SOFT_KEYWORDS = ()
+
+
+if __name__ == '__main__':
+    from pegen.parser import simple_parser_main
+    simple_parser_main(ExpressionParser)