bare-script 4.0.3__tar.gz → 4.1.1__tar.gz

{bare_script-4.0.3/src/bare_script.egg-info → bare_script-4.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bare-script
-Version: 4.0.3
+Version: 4.1.1
 Summary: bare-script
 Home-page: https://github.com/craigahobbs/bare-script
 Author: Craig A. Hobbs
@@ -191,6 +191,14 @@ markdownPrint('Hello, Markdown!')
 ~~~
 
 
+## C Runtime
+
+The package ships with an optional CPython C extension (`runtime_c`) that mirrors the pure-Python
+runtime for faster script execution. When the compiled extension is available, it is used
+automatically; otherwise the pure-Python runtime is used as a fallback. Set the environment
+variable `BARESCRIPT_RUNTIME_PY=1` to force the pure-Python runtime.
+
+
 ## Development
 
 This package is developed using [python-build](https://github.com/craigahobbs/python-build#readme).

{bare_script-4.0.3 → bare_script-4.1.1}/README.md

@@ -166,6 +166,14 @@ markdownPrint('Hello, Markdown!')
 ~~~
 
 
+## C Runtime
+
+The package ships with an optional CPython C extension (`runtime_c`) that mirrors the pure-Python
+runtime for faster script execution. When the compiled extension is available, it is used
+automatically; otherwise the pure-Python runtime is used as a fallback. Set the environment
+variable `BARESCRIPT_RUNTIME_PY=1` to force the pure-Python runtime.
+
+
 ## Development
 
 This package is developed using [python-build](https://github.com/craigahobbs/python-build#readme).

{bare_script-4.0.3 → bare_script-4.1.1}/setup.cfg

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

bare_script-4.1.1/setup.py

@@ -0,0 +1,46 @@
+# Licensed under the MIT License
+# https://github.com/craigahobbs/bare-script-py/blob/main/LICENSE
+
+"""
+bare-script setup
+"""
+
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+
+
+class OptionalBuildExt(build_ext):
+    """
+    Build C extensions optionally - if compilation fails, the package still installs
+    and falls back to the pure-Python implementation.
+    """
+
+    def run(self):
+        try:
+            super().run()
+        except Exception: # pylint: disable=broad-except
+            self._unavailable()
+
+    def build_extension(self, ext):
+        try:
+            super().build_extension(ext)
+        except Exception: # pylint: disable=broad-except
+            self._unavailable()
+
+    @staticmethod
+    def _unavailable():
+        print('*' * 70)
+        print('WARNING: C extension could not be compiled.')
+        print('         Falling back to pure-Python implementation.')
+        print('*' * 70)
+
+
+setup(
+    ext_modules=[
+        Extension(
+            'bare_script.runtime_c',
+            sources=['src/bare_script/runtime_c.c']
+        )
+    ],
+    cmdclass={'build_ext': OptionalBuildExt}
+)

{bare_script-4.0.3 → bare_script-4.1.1}/src/bare_script/__init__.py

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

{bare_script-4.0.3 → bare_script-4.1.1}/src/bare_script/bare.py

@@ -7,14 +7,22 @@ bare-script command-line interface (CLI)
 
 import argparse
 from functools import partial
+import os as _os
 import sys
 import time
 
 from .model import lint_script
 from .options import FETCH_SYSTEM_PREFIX, fetch_read_write, fetch_system, log_stdout, url_file_relative
 from .parser import parse_expression, parse_script
-from .runtime import SYSTEM_GLOBAL_INCLUDES_NAME, evaluate_expression, execute_script
+from .runtime import SYSTEM_GLOBAL_INCLUDES_NAME
 from .value import value_boolean
+if not _os.environ.get('BARESCRIPT_RUNTIME_PY'): # pragma: no cover
+    try:
+        from .runtime_c import evaluate_expression, execute_script
+    except ImportError:
+        from .runtime import evaluate_expression, execute_script
+else:
+    from .runtime import evaluate_expression, execute_script
 
 
 def main(argv=None):

{bare_script-4.0.3 → bare_script-4.1.1}/src/bare_script/library.py

@@ -11,6 +11,7 @@ import functools
 import importlib
 import json
 import math
+import os as _os
 import random
 import re
 import urllib
@@ -27,16 +28,18 @@ 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:
-        _EVALUATE_EXPRESSION.append(importlib.import_module('bare_script.runtime').evaluate_expression)
+        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):
+                _EVALUATE_EXPRESSION.append(importlib.import_module('bare_script.runtime').evaluate_expression)
+        else:
+            _EVALUATE_EXPRESSION.append(importlib.import_module('bare_script.runtime').evaluate_expression)
     return _EVALUATE_EXPRESSION[0]
 
 _EVALUATE_EXPRESSION = []
 
 
-# The default maximum statements for executeScript
-DEFAULT_MAX_STATEMENTS = 1e9
-
-
 #
 # Array functions
 #

{bare_script-4.0.3 → bare_script-4.1.1}/src/bare_script/runtime.py

@@ -8,13 +8,17 @@ The BareScript runtime
 import datetime
 import functools
 
-from .library import DEFAULT_MAX_STATEMENTS, EXPRESSION_FUNCTIONS, SCRIPT_FUNCTIONS
+from .library import EXPRESSION_FUNCTIONS, SCRIPT_FUNCTIONS
 from .model import lint_script
 from .options import url_file_relative
 from .parser import parse_script
 from .value import ValueArgsError, value_boolean, value_compare, value_normalize_datetime, value_round_number, value_string
 
 
+# The default maximum statements for executeScript
+DEFAULT_MAX_STATEMENTS = 1e9
+
+
 # Coverage configuration object global variable name
 SYSTEM_GLOBAL_COVERAGE_NAME = '__barescriptCoverage'
 
@@ -54,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
@@ -61,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
@@ -87,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
@@ -114,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')
@@ -239,50 +250,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_:
@@ -300,7 +317,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
@@ -308,54 +328,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
@@ -366,90 +389,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 == '==':
+            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 == '<=':
+            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 == '>=':
+            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 int(left_value) == left_value and
+                (right_type is int or right_type is float) and int(right_value) == right_value):
                 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 int(left_value) == left_value and
+                (right_type is int or right_type is float) and int(right_value) == right_value):
                 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 int(left_value) == left_value and
+                (right_type is int or right_type is float) and int(right_value) == right_value):
                 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 int(left_value) == left_value and
+                (right_type is int or right_type is float) and int(right_value) == right_value):
                 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 int(left_value) == left_value and
+                (right_type is int or right_type is float) and int(right_value) == right_value):
                 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 int(value) == value:
                 return ~int(value)
 
         # Invalid operation value