bare-script 3.8.2__py3-none-any.whl

bare_script/__init__.py

@@ -0,0 +1,37 @@
+# Licensed under the MIT License
+# https://github.com/craigahobbs/bare-script-py/blob/main/LICENSE
+
+"""
+bare-script package
+"""
+
+from .data import \
+    add_calculated_field, \
+    aggregate_data, \
+    filter_data, \
+    join_data, \
+    sort_data, \
+    top_data, \
+    validate_data
+
+from .model import \
+    lint_script, \
+    validate_expression, \
+    validate_script
+
+from .options import \
+    fetch_http, \
+    fetch_read_only, \
+    fetch_read_write, \
+    log_stdout, \
+    url_file_relative
+
+from .parser import \
+    BareScriptParserError, \
+    parse_expression, \
+    parse_script
+
+from .runtime import \
+    BareScriptRuntimeError, \
+    evaluate_expression, \
+    execute_script

bare_script/__main__.py

@@ -0,0 +1,12 @@
+# Licensed under the MIT License
+# https://github.com/craigahobbs/bare-script-py/blob/main/LICENSE
+
+"""
+bare-script top-level script environment
+"""
+
+from .bare import main
+
+
+if __name__ == '__main__': # pragma: no cover
+    main()

bare_script/bare.py

@@ -0,0 +1,165 @@
+# Licensed under the MIT License
+# https://github.com/craigahobbs/bare-script-py/blob/main/LICENSE
+
+"""
+bare-script command-line interface (CLI)
+"""
+
+import argparse
+from functools import partial
+import importlib.resources
+import os
+import sys
+import time
+
+from .library import SYSTEM_GLOBAL_INCLUDES_NAME
+from .model import lint_script
+from .options import fetch_read_write, log_stdout, url_file_relative
+from .parser import parse_expression, parse_script
+from .runtime import evaluate_expression, execute_script
+from .value import value_boolean
+
+
+def main(argv=None):
+    """
+    BareScript command-line interface (CLI) main entry point
+    """
+
+    # Command line arguments
+    parser = argparse.ArgumentParser(prog='bare', description='The BareScript command-line interface')
+    parser.add_argument('file', nargs='*', action=_FileScriptAction, help='files to process')
+    parser.add_argument('-c', '--code', action=_InlineScriptAction, help='execute the BareScript code')
+    parser.add_argument('-d', '--debug', action='store_true', help='enable debug mode')
+    parser.add_argument('-m', '--markdown-up', action='store_true', help='run with MarkdownUp stubs')
+    parser.add_argument('-s', '--static', dest='static', action='store_const', const='s', help='perform static analysis')
+    parser.add_argument('-x', '--staticx', dest='static', action='store_const', const='x', help='perform static analysis with execution')
+    parser.add_argument('-v', '--var', nargs=2, action='append', metavar=('VAR', 'EXPR'), default = [],
+                        help='set a global variable to an expression value')
+    args = parser.parse_args(args=argv)
+    if not args.scripts:
+        parser.print_help()
+        parser.exit()
+
+    status_code = 0
+    inline_count = 0
+    try:
+        # Evaluate the global variable expression arguments
+        globals_ = {}
+        for var_name, var_expr in args.var:
+            globals_[var_name] = evaluate_expression(parse_expression(var_expr))
+
+        # Get the scripts to run
+        scripts = args.scripts
+        ix_user_script = 0
+        if args.markdown_up:
+            scripts = [('code', 'include <markdownUp.bare>'), *scripts]
+            ix_user_script = 1
+
+            # Add unittest.bare argument globals
+            globals_['vUnittestReport'] = True
+            if args.static:
+                globals_['vUnittestDisabled'] = True
+
+        # Parse and execute all source files in order
+        for ix_script, [script_type, script_value] in enumerate(scripts):
+            # Get the script source
+            if script_type == 'file':
+                script_name = script_value
+                script_source = None
+                try:
+                    script_source = fetch_read_write({'url': script_value})
+                except:
+                    pass
+                if script_source is None:
+                    raise ValueError(f'Failed to load "{script_value}"')
+            else:
+                inline_count += 1
+                inline_display = inline_count - ix_user_script
+                script_name = f'<string{inline_display if inline_display > 1 else ""}>'
+                script_source = script_value
+
+            # Parse the script source
+            script = parse_script(script_source, 1, script_name)
+
+            # Execute?
+            static_globals = None
+            if args.static != 's':
+                # Set the globals to use for static analysis (below)
+                if not args.static or ix_script < ix_user_script:
+                    static_globals = globals_
+                else:
+                    # Copy global to keep each script as isolated as possible
+                    static_globals = dict(globals_)
+                    global_includes = static_globals.get(SYSTEM_GLOBAL_INCLUDES_NAME)
+                    if global_includes is not None and isinstance(global_includes, dict):
+                        static_globals[SYSTEM_GLOBAL_INCLUDES_NAME] = dict(global_includes)
+
+                # Execute the script
+                time_begin = time.time()
+                result = execute_script(script, {
+                    'debug': args.debug or False,
+                    'fetchFn': _fetch_include,
+                    'globals': static_globals,
+                    'logFn': log_stdout,
+                    'systemPrefix': _FETCH_INCLUDE_PREFIX,
+                    'urlFn': partial(url_file_relative, script_value) if script_type == 'file' else None
+                })
+                if isinstance(result, (int, float)) and int(result) == result and 0 <= result <= 255:
+                    status_code = int(result) or status_code
+                else:
+                    status_code = (1 if value_boolean(result) else 0) or status_code
+
+                # Log script execution end with timing
+                if args.debug and ix_script >= ix_user_script:
+                    time_end = time.time()
+                    print(f'BareScript executed in {1000 * (time_end - time_begin):.1f} milliseconds')
+
+            # Run the bare-script linter?
+            if args.static and ix_script >= ix_user_script:
+                warnings = lint_script(script, static_globals)
+                if not warnings:
+                    print(f'BareScript static analysis "{script_name}" ... OK')
+                else:
+                    print(f'BareScript static analysis "{script_name}" ... {len(warnings)} warning{"s" if len(warnings) > 1 else ""}:')
+                    for warning in warnings:
+                        print(warning)
+                    status_code = 1
+
+            # Stop on error status code
+            if status_code != 0 and not args.static:
+                break
+
+    except Exception as exc:
+        print(str(exc).strip())
+        status_code = 1
+
+    # Return the status code
+    sys.exit(status_code)
+
+
+def _fetch_include(request):
+    # Is this a bare system include?
+    url = request['url']
+    if url.startswith(_FETCH_INCLUDE_PREFIX):
+        path = url[len(_FETCH_INCLUDE_PREFIX):]
+        with importlib.resources.files('bare_script.include').joinpath(path).open('rb') as cm_inc:
+            return cm_inc.read().decode(encoding='utf-8')
+
+    return fetch_read_write(request)
+
+
+_FETCH_INCLUDE_PREFIX = f':bare-include:{os.sep}'
+
+
+class _InlineScriptAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        if 'scripts' not in namespace:
+            setattr(namespace, 'scripts', [])
+        namespace.scripts.append(('code', values))
+
+
+class _FileScriptAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        if 'scripts' not in namespace:
+            setattr(namespace, 'scripts', [])
+        namespace.scripts.extend(('file', value) for value in values)

bare_script/baredoc.py

@@ -0,0 +1,177 @@
+# Licensed under the MIT License
+# https://github.com/craigahobbs/bare-script-py/blob/main/LICENSE
+
+"""
+bare-script documentation tool
+"""
+
+import argparse
+import json
+import re
+import sys
+
+
+def main(argv=None):
+    """
+    BareScript documentation tool main entry point
+    """
+
+    # Command line arguments
+    parser = argparse.ArgumentParser(prog='baredoc', description='The BareScript documentation tool')
+    parser.add_argument('files', metavar='file', nargs='+', help='files to process')
+    parser.add_argument('-o', dest='output', metavar='file', default='-', help='write output to file (default is "-")')
+    args = parser.parse_args(args=argv)
+
+    # Parse each source file line-by-line
+    errors = []
+    funcs = {}
+    func = None
+    for file_ in args.files:
+        # Read the source file
+        source = None
+        try:
+            with open(file_, 'r', encoding='utf-8') as fh:
+                source = fh.read()
+        except:
+            pass
+        if source is None:
+            errors.append(f'Failed to load "{file_}"')
+            continue
+
+        # Split the source lines and process documentation comments
+        lines = _R_SPLIT.split(source)
+        for ix_line, line in enumerate(lines):
+            # function/group/doc/return documentation keywords?
+            match_key = _R_KEY.match(line)
+            if match_key is not None:
+                key = match_key['key']
+                text = match_key['text']
+                text_trim = text.strip()
+
+                # Keyword used outside of function?
+                if key != 'function' and func is None:
+                    errors.append(f'{file_}:{ix_line + 1}: {key} keyword outside function')
+                    continue
+
+                # Process the keyword
+                if key == 'group':
+                    if text_trim == '':
+                        errors.append(f'{file_}:{ix_line + 1}: Invalid function group name "{text_trim}"')
+                        continue
+                    if 'group' in func:
+                        errors.append(f'{file_}:{ix_line + 1}: Function "{func["name"]}" group redefinition')
+                        continue
+
+                    # Set the function group
+                    func['group'] = text_trim
+
+                elif key in ('doc', 'return'):
+                    # Add the documentation line - don't add leading blank lines
+                    func_doc = func.get(key)
+                    if func_doc is not None or text_trim != '':
+                        if func_doc is None:
+                            func_doc = []
+                            func[key] = func_doc
+                        func_doc.append(text)
+
+                else:
+                    # key == 'function'
+                    if text_trim == '':
+                        errors.append(f'{file_}:{ix_line + 1}: Invalid function name "{text_trim}"')
+                        continue
+                    if text_trim in funcs:
+                        errors.append(f'{file_}:{ix_line + 1}: Function "{text_trim}" redefinition')
+                        continue
+
+                    # Add the function
+                    func = {'name': text_trim}
+                    funcs[text_trim] = func
+
+                continue
+
+            # arg keyword?
+            match_arg = _R_ARG.match(line)
+            if match_arg is not None:
+                name = match_arg['name']
+                text = match_arg['text']
+                text_trim = text.strip()
+
+                # Keyword used outside of function?
+                if func is None:
+                    errors.append(f'{file_}:{ix_line + 1}: Function argument "{name}" outside function')
+                    continue
+
+                # Get the function argument model, if it exists
+                func_args = func.get('args')
+                func_arg = None
+                if func_args is not None:
+                    func_arg = next((find_arg for find_arg in func_args if find_arg['name'] == name), None)
+
+                # Ignore leading argument documentation blank lines
+                if func_arg is None and text_trim == '':
+                    continue
+
+                # Add the fuction model arguments member, if necessary
+                if func_args is None:
+                    func_args = []
+                    func['args'] = func_args
+
+                # Add the function argument model, if necessary
+                if func_arg is None:
+                    func_arg = {'name': name, 'doc': []}
+                    func_args.append(func_arg)
+
+                # Add the function argument documentation line
+                func_arg['doc'].append(text)
+                continue
+
+            # Unknown documentation comment?
+            match_unknown = _R_UNKNOWN.match(line)
+            if match_unknown is not None:
+                unknown = match_unknown.group('unknown')
+                errors.append(f'{file_}:{ix_line + 1}: Invalid documentation comment "{unknown}"')
+                continue
+
+    # Create the library documentation model
+    library = {'functions': sorted(funcs.values(), key=lambda func: func['name'])}
+
+    # Validate the library documentation model
+    if len(library['functions']) == 0:
+        errors.append('error: No library functions')
+    for func in library['functions']:
+        func_name = func['name']
+        if 'group' not in func:
+            errors.append(f'error: Function "{func_name}" missing group')
+        if 'doc' not in func:
+            errors.append(f'error: Function "{func_name}" missing documentation')
+
+    # Errors?
+    if len(errors) != 0:
+        print('\n'.join(errors))
+        sys.exit(1)
+
+    # JSON-serialize the library documentation model
+    library_json = json.dumps(library, separators=(',', ':'), sort_keys=True)
+
+    # Output to stdout?
+    if args.output == '-':
+        print(library_json)
+    else:
+        # Output to file
+        success = False
+        try:
+            with open(args.output, 'w', encoding='utf-8') as fh:
+                fh.write(library_json)
+            success = True
+        except:
+            pass
+        if not success:
+            print(f'error: Failed to write "{args.output}"')
+            sys.exit(1)
+
+
+# Library documentation regular expressions
+_R_KEY = re.compile(r'^\s*(?:\/\/|#)\s*\$(?P<key>function|group|doc|return):\s?(?P<text>.*)$')
+_R_ARG = re.compile(r'^\s*(?:\/\/|#)\s*\$arg\s+(?P<name>[A-Za-z_][A-Za-z0-9_]*(?:\.\.\.)?):\s?(?P<text>.*)$')
+_R_UNKNOWN = re.compile(r'^\s*(?:\/\/|#)\s*\$(?P<unknown>[^:]+):')
+_R_SPLIT = re.compile(r'\r?\n')