bare-script 4.1.0__tar.gz → 4.1.2__tar.gz

{bare_script-4.1.0/src/bare_script.egg-info → bare_script-4.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bare-script
-Version: 4.1.0
+Version: 4.1.2
 Summary: bare-script
 Home-page: https://github.com/craigahobbs/bare-script
 Author: Craig A. Hobbs

{bare_script-4.1.0 → bare_script-4.1.2}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = bare-script
-version = 4.1.0
+version = 4.1.2
 url = https://github.com/craigahobbs/bare-script
 author = Craig A. Hobbs
 author_email = craigahobbs@gmail.com

{bare_script-4.1.0 → bare_script-4.1.2}/src/bare_script/__init__.py

@@ -5,7 +5,7 @@
 bare-script package
 """
 
-import os as _os
+import os
 
 from .model import \
     lint_script, \
@@ -28,7 +28,8 @@ from .parser import \
 
 from .runtime import \
     BareScriptRuntimeError
-if not _os.environ.get('BARESCRIPT_RUNTIME_PY'): # pragma: no cover
+
+if not os.environ.get('BARESCRIPT_RUNTIME_PY'): # pragma: no cover
     try:
         from .runtime_c import evaluate_expression, execute_script
     except ImportError:

{bare_script-4.1.0 → bare_script-4.1.2}/src/bare_script/bare.py

@@ -7,7 +7,7 @@ bare-script command-line interface (CLI)
 
 import argparse
 from functools import partial
-import os as _os
+import os
 import sys
 import time
 
@@ -16,7 +16,7 @@ from .options import FETCH_SYSTEM_PREFIX, fetch_read_write, fetch_system, log_st
 from .parser import parse_expression, parse_script
 from .runtime import SYSTEM_GLOBAL_INCLUDES_NAME
 from .value import value_boolean
-if not _os.environ.get('BARESCRIPT_RUNTIME_PY'): # pragma: no cover
+if not os.environ.get('BARESCRIPT_RUNTIME_PY'): # pragma: no cover
     try:
         from .runtime_c import evaluate_expression, execute_script
     except ImportError:

{bare_script-4.1.0 → bare_script-4.1.2}/src/bare_script/library.py

@@ -11,7 +11,7 @@ import functools
 import importlib
 import json
 import math
-import os as _os
+import os
 import random
 import re
 import urllib
@@ -28,7 +28,7 @@ from .value import R_NUMBER_CLEANUP, ValueArgsError, value_args_model, value_arg
 # Helper to dynamically import evaluate_expression to avoid the circular dependency
 def _import_evaluate_expression():
     if not _EVALUATE_EXPRESSION:
-        if not _os.environ.get('BARESCRIPT_RUNTIME_PY'): # pragma: no cover
+        if not os.environ.get('BARESCRIPT_RUNTIME_PY'): # pragma: no cover
             try:
                 _EVALUATE_EXPRESSION.append(importlib.import_module('bare_script.runtime_c').evaluate_expression)
             except (ImportError, AttributeError):

{bare_script-4.1.0 → bare_script-4.1.2}/src/bare_script/runtime.py

@@ -58,6 +58,13 @@ def execute_script(script, options=None):
 
 def _execute_script_helper(script, statements, options, locals_):
     globals_ = options['globals']
+    max_statements = options.get('maxStatements', DEFAULT_MAX_STATEMENTS)
+    options.setdefault('statementCount', 0)
+
+    # Coverage configuration is invariant across this helper invocation
+    coverage_global = globals_.get(SYSTEM_GLOBAL_COVERAGE_NAME)
+    has_coverage = coverage_global is not None and isinstance(coverage_global, dict) and \
+        coverage_global.get('enabled') and not script.get('system')
 
     # Iterate each script statement
     label_indexes = None
@@ -65,25 +72,22 @@ def _execute_script_helper(script, statements, options, locals_):
     ix_statement = 0
     while ix_statement < statements_length:
         statement = statements[ix_statement]
-        statement_key = next(iter(statement.keys()))
 
         # Increment the statement counter
-        options['statementCount'] = options.get('statementCount', 0) + 1
-        max_statements = options.get('maxStatements', DEFAULT_MAX_STATEMENTS)
+        options['statementCount'] += 1
         if max_statements > 0 and options['statementCount'] > max_statements:
             raise BareScriptRuntimeError(script, statement, f'Exceeded maximum script statements ({max_statements})')
 
         # Record the statement coverage
-        coverage_global = globals_.get(SYSTEM_GLOBAL_COVERAGE_NAME)
-        has_coverage = coverage_global is not None and isinstance(coverage_global, dict) and \
-            coverage_global.get('enabled') and not script.get('system')
         if has_coverage:
+            statement_key = next(iter(statement.keys()))
             _record_statement_coverage(script, statement, statement_key, coverage_global)
 
         # Expression?
-        if statement_key == 'expr':
-            expr_value = evaluate_expression(statement['expr']['expr'], options, locals_, False, script, statement)
-            expr_name = statement['expr'].get('name')
+        if 'expr' in statement:
+            stmt_expr = statement['expr']
+            expr_value = evaluate_expression(stmt_expr['expr'], options, locals_, False, script, statement)
+            expr_name = stmt_expr.get('name')
             if expr_name is not None:
                 if locals_ is not None:
                     locals_[expr_name] = expr_value
@@ -91,24 +95,25 @@ def _execute_script_helper(script, statements, options, locals_):
                     globals_[expr_name] = expr_value
 
         # Jump?
-        elif statement_key == 'jump':
+        elif 'jump' in statement:
+            stmt_jump = statement['jump']
             # Evaluate the expression (if any)
-            if 'expr' not in statement['jump'] or \
-               value_boolean(evaluate_expression(statement['jump']['expr'], options, locals_, False, script, statement)):
+            if 'expr' not in stmt_jump or \
+               value_boolean(evaluate_expression(stmt_jump['expr'], options, locals_, False, script, statement)):
                 # Find the label
-                if label_indexes is not None and statement['jump']['label'] in label_indexes:
-                    ix_statement = label_indexes[statement['jump']['label']]
+                jump_label = stmt_jump['label']
+                if label_indexes is not None and jump_label in label_indexes:
+                    ix_statement = label_indexes[jump_label]
                 else:
-                    jump_label = statement['jump']['label']
                     ix_label = next(
                         (ix_stmt for ix_stmt, stmt in enumerate(statements) if 'label' in stmt and stmt['label']['name'] == jump_label),
                         -1
                     )
                     if ix_label == -1:
-                        raise BareScriptRuntimeError(script, statement, f"Unknown jump label \"{statement['jump']['label']}\"")
+                        raise BareScriptRuntimeError(script, statement, f"Unknown jump label \"{jump_label}\"")
                     if label_indexes is None:
                         label_indexes = {}
-                    label_indexes[statement['jump']['label']] = ix_label
+                    label_indexes[jump_label] = ix_label
                     ix_statement = ix_label
 
                 # Record the label statement coverage
@@ -118,17 +123,19 @@ def _execute_script_helper(script, statements, options, locals_):
                     _record_statement_coverage(script, label_statement, label_statement_key, coverage_global)
 
         # Return?
-        elif statement_key == 'return':
-            if 'expr' in statement['return']:
-                return evaluate_expression(statement['return']['expr'], options, locals_, False, script, statement)
+        elif 'return' in statement:
+            stmt_return = statement['return']
+            if 'expr' in stmt_return:
+                return evaluate_expression(stmt_return['expr'], options, locals_, False, script, statement)
             return None
 
         # Function?
-        elif statement_key == 'function':
-            globals_[statement['function']['name']] = functools.partial(_script_function, script, statement['function'])
+        elif 'function' in statement:
+            stmt_function = statement['function']
+            globals_[stmt_function['name']] = functools.partial(_script_function, script, stmt_function)
 
         # Include?
-        elif statement_key == 'include':
+        elif 'include' in statement:
             system_prefix = options.get('systemPrefix')
             fetch_fn = options.get('fetchFn')
             log_fn = options.get('logFn')
@@ -217,13 +224,17 @@ def _script_function(script, function, args, options):
     if func_args is not None:
         args_length = len(args)
         func_args_length = len(func_args)
-        ix_arg_last = function.get('lastArgArray', None) and (func_args_length - 1)
-        for ix_arg in range(func_args_length):
-            arg_name = func_args[ix_arg]
-            if ix_arg < args_length:
-                func_locals[arg_name] = args[ix_arg] if ix_arg != ix_arg_last else args[ix_arg:]
-            else:
-                func_locals[arg_name] = [] if ix_arg == ix_arg_last else None
+        if function.get('lastArgArray'):
+            ix_arg_last = func_args_length - 1
+            for ix_arg in range(func_args_length):
+                arg_name = func_args[ix_arg]
+                if ix_arg < args_length:
+                    func_locals[arg_name] = args[ix_arg] if ix_arg != ix_arg_last else args[ix_arg:]
+                else:
+                    func_locals[arg_name] = [] if ix_arg == ix_arg_last else None
+        else:
+            for ix_arg in range(func_args_length):
+                func_locals[func_args[ix_arg]] = args[ix_arg] if ix_arg < args_length else None
     return _execute_script_helper(script, function['statements'], options, func_locals)
 
 
@@ -243,50 +254,56 @@ def evaluate_expression(expr, options=None, locals_=None, builtins=True, script=
     :raises BareScriptRuntimeError: A script runtime error occurred
     """
 
-    expr_key, = expr.keys()
     globals_ = options.get('globals') if options is not None else None
 
     # Number
-    if expr_key == 'number':
+    if 'number' in expr:
         return expr['number']
 
     # String
-    if expr_key == 'string':
+    if 'string' in expr:
         return expr['string']
 
     # Variable
-    if expr_key == 'variable':
+    if 'variable' in expr:
+        variable = expr['variable']
+
         # Keywords
-        if expr['variable'] == 'null':
+        if variable == 'null':
             return None
-        if expr['variable'] == 'false':
+        if variable == 'false':
             return False
-        if expr['variable'] == 'true':
+        if variable == 'true':
             return True
 
         # Get the local or global variable value or None if undefined
-        if locals_ is not None and expr['variable'] in locals_:
-            return locals_[expr['variable']]
+        if locals_ is not None and variable in locals_:
+            return locals_[variable]
         else:
-            return globals_.get(expr['variable']) if globals_ is not None else None
+            return globals_.get(variable) if globals_ is not None else None
 
     # Function
-    if expr_key == 'function':
+    if 'function' in expr:
+        func = expr['function']
+
         # "if" built-in function?
-        func_name = expr['function']['name']
+        func_name = func['name']
         if func_name == 'if':
-            args_expr = expr['function'].get('args', ())
+            args_expr = func.get('args', ())
             args_expr_length = len(args_expr)
             value_expr = args_expr[0] if args_expr_length >= 1 else None
             true_expr = args_expr[1] if args_expr_length >= 2 else None
             false_expr = args_expr[2] if args_expr_length >= 3 else None
-            value = evaluate_expression(value_expr, options, locals_, builtins, script, statement) if value_expr else False
+            value = evaluate_expression(value_expr, options, locals_, builtins, script, statement) \
+                if value_expr is not None else False
             result_expr = true_expr if value_boolean(value) else false_expr
-            return evaluate_expression(result_expr, options, locals_, builtins, script, statement) if result_expr else None
+            return evaluate_expression(result_expr, options, locals_, builtins, script, statement) \
+                if result_expr is not None else None
 
         # Compute the function arguments
-        func_args = [evaluate_expression(arg, options, locals_, builtins, script, statement) for arg in expr['function']['args']] \
-            if 'args' in expr['function'] else None
+        args_expr = func.get('args')
+        func_args = [evaluate_expression(arg, options, locals_, builtins, script, statement) for arg in args_expr] \
+            if args_expr is not None else None
 
         # Global/local function?
         if locals_ is not None and func_name in locals_:
@@ -304,7 +321,10 @@ def evaluate_expression(expr, options=None, locals_=None, builtins=True, script=
             except Exception as error:
                 # Log and return null
                 if options is not None and 'logFn' in options and options.get('debug'):
-                    options['logFn'](f'BareScript: Function "{func_name}" failed with error: {error}')
+                    error_message = BareScriptRuntimeError(
+                        script, statement, f'BareScript: Function "{func_name}" failed with error: {error}'
+                    )
+                    options['logFn'](str(error_message))
                 if isinstance(error, ValueArgsError):
                     return error.return_value
                 return None
@@ -312,54 +332,57 @@ def evaluate_expression(expr, options=None, locals_=None, builtins=True, script=
         raise BareScriptRuntimeError(script, statement, f'Undefined function "{func_name}"')
 
     # Binary expression
-    if expr_key == 'binary':
-        bin_op = expr['binary']['op']
-        left_value = evaluate_expression(expr['binary']['left'], options, locals_, builtins, script, statement)
+    if 'binary' in expr:
+        binary = expr['binary']
+        bin_op = binary['op']
+        left_value = evaluate_expression(binary['left'], options, locals_, builtins, script, statement)
 
         # Short-circuiting "and" binary operator
         if bin_op == '&&':
             if not value_boolean(left_value):
                 return left_value
-            return evaluate_expression(expr['binary']['right'], options, locals_, builtins, script, statement)
+            return evaluate_expression(binary['right'], options, locals_, builtins, script, statement)
 
         # Short-circuiting "or" binary operator
         elif bin_op == '||':
             if value_boolean(left_value):
                 return left_value
-            return evaluate_expression(expr['binary']['right'], options, locals_, builtins, script, statement)
+            return evaluate_expression(binary['right'], options, locals_, builtins, script, statement)
 
         # Non-short-circuiting binary operators
-        right_value = evaluate_expression(expr['binary']['right'], options, locals_, builtins, script, statement)
+        right_value = evaluate_expression(binary['right'], options, locals_, builtins, script, statement)
+        left_type = type(left_value)
+        right_type = type(right_value)
         if bin_op == '+':
             # number + number
-            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and
-                isinstance(right_value, (int, float)) and not isinstance(right_value, bool)):
+            if ((left_type is int or left_type is float) and
+                (right_type is int or right_type is float)):
                 return left_value + right_value
 
             # string + string
-            elif isinstance(left_value, str) and isinstance(right_value, str):
+            elif left_type is str and right_type is str:
                 return left_value + right_value
 
             # string + <any>
-            elif isinstance(left_value, str):
+            elif left_type is str:
                 return left_value + value_string(right_value)
-            elif isinstance(right_value, str):
+            elif right_type is str:
                 return value_string(left_value) + right_value
 
             # datetime + number
             elif (isinstance(left_value, datetime.date) and
-                  isinstance(right_value, (int, float)) and not isinstance(right_value, bool)):
+                  (right_type is int or right_type is float)):
                 left_dt = value_normalize_datetime(left_value)
                 return left_dt + datetime.timedelta(milliseconds=right_value)
-            elif (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and
+            elif ((left_type is int or left_type is float) and
                   isinstance(right_value, datetime.date)):
                 right_dt = value_normalize_datetime(right_value)
                 return right_dt + datetime.timedelta(milliseconds=left_value)
 
         elif bin_op == '-':
             # number - number
-            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and
-                isinstance(right_value, (int, float)) and not isinstance(right_value, bool)):
+            if ((left_type is int or left_type is float) and
+                (right_type is int or right_type is float)):
                 return left_value - right_value
 
             # datetime - datetime
@@ -370,90 +393,104 @@ def evaluate_expression(expr, options=None, locals_=None, builtins=True, script=
 
         elif bin_op == '*':
             # number * number
-            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and
-                isinstance(right_value, (int, float)) and not isinstance(right_value, bool)):
+            if ((left_type is int or left_type is float) and
+                (right_type is int or right_type is float)):
                 return left_value * right_value
 
         elif bin_op == '/':
             # number / number
-            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and
-                isinstance(right_value, (int, float)) and not isinstance(right_value, bool)):
+            if ((left_type is int or left_type is float) and
+                (right_type is int or right_type is float)):
                 return left_value / right_value
 
-        elif bin_op == '==':
-            return value_compare(left_value, right_value) == 0
-
-        elif bin_op == '!=':
-            return value_compare(left_value, right_value) != 0
+        elif bin_op == '<':
+            if (left_type is int or left_type is float) and (right_type is int or right_type is float):
+                return left_value < right_value
+            return value_compare(left_value, right_value) < 0
 
         elif bin_op == '<=':
+            if (left_type is int or left_type is float) and (right_type is int or right_type is float):
+                return left_value <= right_value
             return value_compare(left_value, right_value) <= 0
 
-        elif bin_op == '<':
-            return value_compare(left_value, right_value) < 0
+        elif bin_op == '>':
+            if (left_type is int or left_type is float) and (right_type is int or right_type is float):
+                return left_value > right_value
+            return value_compare(left_value, right_value) > 0
 
         elif bin_op == '>=':
+            if (left_type is int or left_type is float) and (right_type is int or right_type is float):
+                return left_value >= right_value
             return value_compare(left_value, right_value) >= 0
 
-        elif bin_op == '>':
-            return value_compare(left_value, right_value) > 0
+        elif bin_op == '==':
+            if (left_type is int or left_type is float) and (right_type is int or right_type is float):
+                return left_value == right_value
+            return value_compare(left_value, right_value) == 0
+
+        elif bin_op == '!=':
+            if (left_type is int or left_type is float) and (right_type is int or right_type is float):
+                return left_value != right_value
+            return value_compare(left_value, right_value) != 0
 
         elif bin_op == '%':
             # number % number
-            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and
-                isinstance(right_value, (int, float)) and not isinstance(right_value, bool)):
+            if ((left_type is int or left_type is float) and
+                (right_type is int or right_type is float)):
                 return left_value % right_value
 
         elif bin_op == '**':
             # number ** number
-            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and
-                isinstance(right_value, (int, float)) and not isinstance(right_value, bool)):
+            if ((left_type is int or left_type is float) and
+                (right_type is int or right_type is float)):
                 return left_value ** right_value
 
         elif bin_op == '&':
             # int & int
-            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and int(left_value) == left_value and
-                isinstance(right_value, (int, float)) and not isinstance(right_value, bool) and int(right_value) == right_value):
+            if ((left_type is int or (left_type is float and left_value.is_integer())) and
+                (right_type is int or (right_type is float and right_value.is_integer()))):
                 return int(left_value) & int(right_value)
 
         elif bin_op == '|':
             # int & int
-            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and int(left_value) == left_value and
-                isinstance(right_value, (int, float)) and not isinstance(right_value, bool) and int(right_value) == right_value):
+            if ((left_type is int or (left_type is float and left_value.is_integer())) and
+                (right_type is int or (right_type is float and right_value.is_integer()))):
                 return int(left_value) | int(right_value)
 
         elif bin_op == '^':
             # int & int
-            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and int(left_value) == left_value and
-                isinstance(right_value, (int, float)) and not isinstance(right_value, bool) and int(right_value) == right_value):
+            if ((left_type is int or (left_type is float and left_value.is_integer())) and
+                (right_type is int or (right_type is float and right_value.is_integer()))):
                 return int(left_value) ^ int(right_value)
 
         elif bin_op == '<<':
             # int & int
-            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and int(left_value) == left_value and
-                isinstance(right_value, (int, float)) and not isinstance(right_value, bool) and int(right_value) == right_value):
+            if ((left_type is int or (left_type is float and left_value.is_integer())) and
+                (right_type is int or (right_type is float and right_value.is_integer()))):
                 return int(left_value) << int(right_value)
 
         else: # bin_op == '>>':
             # int & int
-            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and int(left_value) == left_value and
-                isinstance(right_value, (int, float)) and not isinstance(right_value, bool) and int(right_value) == right_value):
+            if ((left_type is int or (left_type is float and left_value.is_integer())) and
+                (right_type is int or (right_type is float and right_value.is_integer()))):
                 return int(left_value) >> int(right_value)
 
         # Invalid operation values
         return None
 
     # Unary expression
-    if expr_key == 'unary':
-        unary_op = expr['unary']['op']
-        value = evaluate_expression(expr['unary']['expr'], options, locals_, builtins, script, statement)
+    if 'unary' in expr:
+        unary = expr['unary']
+        unary_op = unary['op']
+        value = evaluate_expression(unary['expr'], options, locals_, builtins, script, statement)
         if unary_op == '!':
             return not value_boolean(value)
-        elif unary_op == '-':
-            if isinstance(value, (int, float)) and not isinstance(value, bool):
+        val_type = type(value)
+        if unary_op == '-':
+            if val_type is int or val_type is float:
                 return -value
         else: # unary_op == '~':
-            if isinstance(value, (int, float)) and not isinstance(value, bool) and int(value) == value:
+            if val_type is int or (val_type is float and value.is_integer()):
                 return ~int(value)
 
         # Invalid operation value