bare-script 0.9.2__tar.gz → 0.9.3__tar.gz

{bare-script-0.9.2/src/bare_script.egg-info → bare-script-0.9.3}/PKG-INFO

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

{bare-script-0.9.2 → bare-script-0.9.3}/setup.cfg

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

{bare-script-0.9.2 → bare-script-0.9.3}/src/bare_script/__init__.py

@@ -5,6 +5,15 @@
 bare-script package
 """
 
+from .data import \
+    add_calculated_field, \
+    aggregate_data, \
+    filter_data, \
+    join_data, \
+    sort_data, \
+    top_data, \
+    validate_data
+
 from .library import \
     EXPRESSION_FUNCTIONS, \
     SCRIPT_FUNCTIONS

{bare-script-0.9.2 → bare-script-0.9.3}/src/bare_script/bare.py

@@ -23,8 +23,8 @@ def main(argv=None):
 
     # Command line arguments
     parser = argparse.ArgumentParser(prog='bare', description='The BareScript command-line interface')
-    parser.add_argument('file', nargs='*', action=_ScriptAction, help='files to process')
-    parser.add_argument('-c', '--code', nargs=1, action=_ScriptAction, help='execute the BareScript code')
+    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('-s', '--static', action='store_true', help='perform static analysis')
     parser.add_argument('-v', '--var', nargs=2, action='append', metavar=('VAR', 'EXPR'),
@@ -32,20 +32,27 @@ def main(argv=None):
     args = parser.parse_args(args=argv)
 
     status_code = 0
-    current_file = None
+    inline_count = 0
     try:
         # Parse and execute all source files in order
         globals_ = dict(args.var) if args.var is not None else {}
-        for file_, source in args.files:
-            current_file = file_
+        for script_type, script_value in args.scripts:
+            # Get the script source
+            if script_type == 'file':
+                script_name = script_value
+                script_source = fetch_read_write({'url': script_value})
+            else:
+                inline_count += 1
+                script_name = f'-c {inline_count}'
+                script_source = script_value
 
-            # Parse the source
-            script = parse_script(source if source is not None else fetch_read_write({'url': file_}))
+            # Parse the script source
+            script = parse_script(script_source)
 
             # Run the bare-script linter?
             if args.static or args.debug:
                 warnings = lint_script(script)
-                warning_prefix = f'BareScript: Static analysis "{file_}" ...'
+                warning_prefix = f'BareScript: Static analysis "{script_name}" ...'
                 if not warnings:
                     print(f'{warning_prefix} OK')
                 else:
@@ -53,8 +60,8 @@ def main(argv=None):
                     for warning in warnings:
                         print(f'BareScript:     {warning}')
                     if args.static:
-                        # pylint: disable=broad-exception-raised
-                        raise Exception('Static analysis failed')
+                        status_code = 1
+                        break
             if args.static:
                 continue
 
@@ -66,7 +73,7 @@ def main(argv=None):
                 'globals': globals_,
                 'logFn': log_print,
                 'systemPrefix': 'https://craigahobbs.github.io/markdown-up/include/',
-                'urlFn': partial(url_file_relative, file_)
+                '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)
@@ -83,27 +90,23 @@ def main(argv=None):
                 break
 
     except Exception as e: # pylint: disable=broad-exception-caught
-        if current_file is not None:
-            print(f'{current_file}:')
-        print(str(e))
+        print(f'{script_name}:')
+        print(str(e).strip())
         status_code = 1
 
     # Return the status code
     sys.exit(status_code)
 
 
-# Custom argparse action for script file arguments
-class _ScriptAction(argparse.Action):
+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):
-        files = getattr(namespace, 'files', [])
-        if option_string in ['-c', '--code']:
-            code_count = getattr(namespace, 'code_count', 0)
-            code_count += 1
-            setattr(namespace, 'code_count', code_count)
-            for value in values:
-                files.append((f'-c {code_count}', value))
-        elif option_string is None:
-            for value in values:
-                files.append((value, None))
-        setattr(namespace, 'files', files)
+        if 'scripts' not in namespace:
+            setattr(namespace, 'scripts', [])
+        namespace.scripts.extend(('file', value) for value in values)

{bare-script-0.9.2 → bare-script-0.9.3}/src/bare_script/baredoc.py

@@ -19,6 +19,7 @@ def main(argv=None):
     # Command line arguments
     parser = argparse.ArgumentParser(prog='bare', description='The BareScript library documentation tool')
     parser.add_argument('files', metavar='file', nargs='+', help='files to process')
+    parser.add_argument('-o', dest='output', metavar='file', help='write output to file')
     args = parser.parse_args(args=argv)
 
     # Parse each source file line-by-line
@@ -56,7 +57,7 @@ def main(argv=None):
 
                 elif key in ('doc', 'return'):
                     # Add the documentation line - don't add leading blank lines
-                    func_doc = func.get('key')
+                    func_doc = func.get(key)
                     if func_doc is not None or text_trim != '':
                         if func_doc is None:
                             func_doc = []
@@ -91,25 +92,25 @@ def main(argv=None):
                     continue
 
                 # Add the function arg documentation line - don't add leading blank lines
-                args = func.get('args')
-                arg = None
-                if args is not None:
-                    arg = next((arg_find for arg_find in args if arg_find['name'] == name), None)
-                if arg is not None or text_trim != '':
-                    if args is None:
-                        args = []
-                        func['args'] = args
-                    if arg is None:
-                        arg = {'name': name, 'doc': []}
-                        args.append(arg)
-                    arg['doc'].append(text)
+                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)
+                if func_arg is not None or text_trim != '':
+                    if func_args is None:
+                        func_args = []
+                        func['args'] = func_args
+                    if func_arg is None:
+                        func_arg = {'name': name, 'doc': []}
+                        func_args.append(func_arg)
+                    func_arg['doc'].append(text)
 
                 continue
 
             # Unknown documentation comment?
             match_unknown = R_UNKNOWN.match(line)
             if match_unknown is not None:
-                unknown = match_unknown.groups['unknown']
+                unknown = match_unknown.groups('unknown')
                 errors.append(f'{file_}:{ix_line + 1}: Invalid documentation comment "{unknown}"')
                 continue
 
@@ -122,18 +123,27 @@ def main(argv=None):
     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')
+            errors.append(f'error: Function "{func_name}" missing group')
         if 'doc' not in func:
-            errors.append(f'error: Function "{func.name}" missing documentation')
+            errors.append(f'error: Function "{func_name}" missing documentation')
 
     # Errors?
     if len(errors) != 0:
         print('\n'.join(errors))
-        sys.exit(len(errors))
+        sys.exit(1)
 
-    # Output the library JSON
-    print(json.dumps(library))
+    # JSON-serialize the library documentation model
+    library_json = json.dumps(library, separators=(',', ':'), sort_keys=True)
+
+    # Output to stdout?
+    if args.output is None or args.output == '-':
+        print(library_json)
+
+    # Output to file
+    with open(args.output, 'w', encoding='utf-8') as fh:
+        fh.write(library_json)
 
 
 # Library documentation regular expressions

bare-script-0.9.3/src/bare_script/data.py

@@ -0,0 +1,484 @@
+# Licensed under the MIT License
+# https://github.com/craigahobbs/bare-script-py/blob/main/LICENSE
+
+"""
+The BareScript data manipulation library
+"""
+
+import re
+
+from schema_markdown import parse_schema_markdown
+
+
+def validate_data(unused_data, unused_csv=False):
+    """
+    Determine data field types and parse/validate field values
+
+    :param data: The data array. Row objects are updated with parsed/validated values.
+    :type data: list[dict]
+    :param csv: If true, parse number and null strings
+    :type csv: bool
+    :return: The map of field name to field type ("datetime", "number", "string")
+    :rtype: dict
+    :raises TypeError: Data is invalid
+    """
+    return None
+
+    # # Determine field types
+    # types = {}
+    # for (row of data) {
+    #     for ([field, value] of Object.entries(row)) {
+    #         if !(field in types)) {
+    #             if typeof value == 'number') {
+    #                 types[field] = 'number'
+    #             elif value instanceof Date:
+    #                 types[field] = 'datetime'
+    #             elif typeof value == 'string' && (!csv || value != 'null'):
+    #                 if parseDatetime(value) != null:
+    #                     types[field] = 'datetime'
+    #                 elif csv && parseNumber(value) != null:
+    #                     types[field] = 'number'
+    #                 else:
+    #                     types[field] = 'string'
+    #                 }
+    #             }
+    #         }
+    #     }
+    # }
+
+    # # Validate field values
+    # throwFieldError = (field, fieldType, fieldValue) => {
+    #     throw new Error(`Invalid "${field}" field value ${JSON.stringify(fieldValue)}, expected type ${fieldType}`)
+    # }
+    # for (row of data) {
+    #     for ([field, value] of Object.entries(row)) {
+    #         fieldType = types[field]
+
+    #         # Null string?
+    #         if csv && value == 'null':
+    #             row[field] = null
+
+    #         # Number field
+    #         elif fieldType == 'number':
+    #             if csv && typeof value == 'string':
+    #                 numberValue = parseNumber(value)
+    #                 if numberValue == null:
+    #                     throwFieldError(field, fieldType, value)
+    #                 }
+    #                 row[field] = numberValue
+    #             elif value != null && typeof value != 'number':
+    #                 throwFieldError(field, fieldType, value)
+    #             }
+
+    #         # Datetime field
+    #         elif fieldType == 'datetime':
+    #             if typeof value == 'string':
+    #                 datetimeValue = parseDatetime(value)
+    #                 if datetimeValue == null:
+    #                     throwFieldError(field, fieldType, value)
+    #                 }
+    #                 row[field] = datetimeValue
+    #             elif value != null && !(value instanceof Date):
+    #                 throwFieldError(field, fieldType, value)
+    #             }
+
+    #         # String field
+    #         else:
+    #             if value != null && typeof value != 'string':
+    #                 throwFieldError(field, fieldType, value)
+    #             }
+    #         }
+    #     }
+    # }
+
+    # return types
+
+
+def _parse_number(unused_text):
+    return None
+
+    # value = Number.parseFloat(text)
+    # if Number.isNaN(value) || !Number.isFinite(value):
+    #     return null
+    # }
+    # return value
+
+
+def _parse_datetime(unused_text):
+    return None
+
+    # mDate = text.match(rDate)
+    # if mDate != null:
+    #     year = Number.parseInt(mDate.groups.year, 10)
+    #     month = Number.parseInt(mDate.groups.month, 10)
+    #     day = Number.parseInt(mDate.groups.day, 10)
+    #     return new Date(year, month - 1, day)
+    # elif rDatetime.test(text):
+    #     return new Date(text)
+    # }
+    # return null
+
+R_DATE = re.compile(r'^(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})$')
+R_DATETIME = re.compile(r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|[+-]\d{2}:\d{2})$')
+
+
+def join_data(unused_left_data, unused_right_data, unused_join_expr, unused_right_expr=None, unused_is_left_join=False,
+              unused_variables=None, unused_options=None):
+    """
+    Join two data arrays
+
+    :param leftData: The left data array
+    :type leftData: list[dict]
+    :param rightData: The left data array
+    :type rightData: list[dict]
+    :param joinExpr: The join `expression <https://craigahobbs.github.io/bare-script/language/#expressions>`__
+    :type joinExpr: str
+    :param rightExpr: The right join `expression <https://craigahobbs.github.io/bare-script/language/#expressions>`__
+    :type rightExpr: str
+    :param isLeftJoin: If true, perform a left join (always include left row)
+    :type isLeftJoin: bool
+    :param variables: Additional variables for expression evaluation
+    :type variables: dict
+    :param options: The :class:`script execution options <ExecuteScriptOptions>`
+    :type options: dict
+    :return: The joined data array
+    :rtype: list[dict]
+    """
+
+    return None
+
+    # # Compute the map of row field name to joined row field name
+    # leftNames = {}
+    # for (row of leftData) {
+    #     for (fieldName of Object.keys(row)) {
+    #         if !(fieldName in leftNames):
+    #             leftNames[fieldName] = fieldName
+    #         }
+    #     }
+    # }
+    # rightNames = {}
+    # for (row of rightData) {
+    #     for (fieldName of Object.keys(row)) {
+    #         if !(fieldName in rightNames):
+    #             if !(fieldName in leftNames):
+    #                 rightNames[fieldName] = fieldName
+    #             else:
+    #                 uniqueName = fieldName
+    #                 ixUnique = 2
+    #                 do {
+    #                     uniqueName = `${fieldName}${ixUnique}`
+    #                     ixUnique += 1
+    #                 } while (uniqueName in leftNames || uniqueName in rightNames)
+    #                 rightNames[fieldName] = uniqueName
+    #             }
+    #         }
+    #     }
+    # }
+
+    # # Create the evaluation options object
+    # evalOptions = options
+    # if variables != null:
+    #     evalOptions = (options != null ? {...options} : {})
+    #     if 'globals' in evalOptions:
+    #         evalOptions.globals = {...evalOptions.globals, ...variables}
+    #     else:
+    #         evalOptions.globals = variables
+    #     }
+    # }
+
+    # # Parse the left and right expressions
+    # leftExpression = parseExpression(joinExpr)
+    # rightExpression = (rightExpr != null ? parseExpression(rightExpr) : leftExpression)
+
+    # # Bucket the right rows by the right expression value
+    # rightCategoryRows = {}
+    # for (rightRow of rightData) {
+    #     categoryKey = jsonStringifySortKeys(evaluateExpression(rightExpression, evalOptions, rightRow))
+    #     if !(categoryKey in rightCategoryRows):
+    #         rightCategoryRows[categoryKey] = []
+    #     }
+    #     rightCategoryRows[categoryKey].push(rightRow)
+    # }
+
+    # # Join the left with the right
+    # data = []
+    # for (leftRow of leftData) {
+    #     categoryKey = jsonStringifySortKeys(evaluateExpression(leftExpression, evalOptions, leftRow))
+    #     if categoryKey in rightCategoryRows:
+    #         for (rightRow of rightCategoryRows[categoryKey]) {
+    #             joinRow = {...leftRow}
+    #             for ([rightName, rightValue] of Object.entries(rightRow)) {
+    #                 joinRow[rightNames[rightName]] = rightValue
+    #             }
+    #             data.push(joinRow)
+    #         }
+    #     elif !isLeftJoin:
+    #         data.push({...leftRow})
+    #     }
+    # }
+
+    # return data
+
+
+def add_calculated_field(unused_unused_data, unused_field_name, unused_expr, unused_variables=None, unused_options=None):
+    """
+    Add a calculated field to each row of a data array
+
+    @param {Object[]} data - The data array. Row objects are updated with the calculated field values.
+    @param {string} fieldName - The calculated field name
+    @param {string} expr - The calculated field expression
+    @param {?Object} [variables = null] -  Additional variables for expression evaluation
+    @param {?Object} [options = null] - The [script execution options]{@link module:lib/runtime~ExecuteScriptOptions}
+    @returns {Object[]} - The updated data array
+    """
+    return None
+
+    # # Parse the calculation expression
+    # calcExpr = parseExpression(expr)
+
+    # # Create the evaluation options object
+    # evalOptions = options
+    # if variables != null:
+    #     evalOptions = (options != null ? {...options} : {})
+    #     if 'globals' in evalOptions:
+    #         evalOptions.globals = {...evalOptions.globals, ...variables}
+    #     else:
+    #         evalOptions.globals = variables
+    #     }
+    # }
+
+    # # Compute the calculated field for each row
+    # for (row of data) {
+    #     row[fieldName] = evaluateExpression(calcExpr, evalOptions, row)
+    # }
+    # return data
+
+
+def filter_data(unused_data, unused_expr, unused_variables=None, unused_options=None):
+    """
+    Filter data rows
+
+    @param {Object[]} data - The data array
+    @param {string} expr - The boolean filter [expression]{@link https://craigahobbs.github.io/bare-script/language/#expressions}
+    @param {?Object} [variables = null] -  Additional variables for expression evaluation
+    @param {?Object} [options = null] - The [script execution options]{@link module:lib/runtime~ExecuteScriptOptions}
+    @returns {Object[]} - The filtered data array
+    """
+    return None
+
+    # result = []
+
+    # # Parse the filter expression
+    # filterExpr = parseExpression(expr)
+
+    # # Create the evaluation options object
+    # evalOptions = options
+    # if variables != null:
+    #     evalOptions = (options != null ? {...options} : {})
+    #     if 'globals' in evalOptions:
+    #         evalOptions.globals = {...evalOptions.globals, ...variables}
+    #     else:
+    #         evalOptions.globals = variables
+    #     }
+    # }
+
+    # # Filter the data
+    # for (row of data) {
+    #     if evaluateExpression(filterExpr, evalOptions, row):
+    #         result.push(row)
+    #     }
+    # }
+
+    # return result
+
+
+def aggregate_data(unused_data, unused_aggregation):
+    """
+    Aggregate data rows
+
+    @param {Object[]} data - The data array
+    @param {Object} aggregation - The
+        [aggregation model]{@link https://craigahobbs.github.io/bare-script/library/model.html#var.vName='Aggregation'}
+    @returns {Object[]} - The aggregated data array
+    """
+
+    return None
+
+    # Validate the aggregation model
+    # validate_type(AGGREGATION_TYPES, 'Aggregation', aggregation)
+
+    # categories = aggregation.categories ?? null
+
+    # # Create the aggregate rows
+    # categoryRows = {}
+    # for (row of data) {
+    #     # Compute the category values
+    #     categoryValues = (categories != null ? categories.map((categoryField) => row[categoryField]) : null)
+
+    #     # Get or create the aggregate row
+    #     aggregateRow
+    #     rowKey = (categoryValues != null ? jsonStringifySortKeys(categoryValues) : '')
+    #     if rowKey in categoryRows:
+    #         aggregateRow = categoryRows[rowKey]
+    #     else:
+    #         aggregateRow = {}
+    #         categoryRows[rowKey] = aggregateRow
+    #         if categories != null:
+    #             for (ixCategoryField = 0; ixCategoryField < categories.length; ixCategoryField++) {
+    #                 aggregateRow[categories[ixCategoryField]] = categoryValues[ixCategoryField]
+    #             }
+    #         }
+    #     }
+
+    #     # Add to the aggregate measure values
+    #     for (measure of aggregation.measures) {
+    #         field = measure.name ?? measure.field
+    #         value = row[measure.field] ?? null
+    #         if !(field in aggregateRow):
+    #             aggregateRow[field] = []
+    #         }
+    #         if value != null:
+    #             aggregateRow[field].push(value)
+    #         }
+    #     }
+    # }
+
+    # # Compute the measure values aggregate function value
+    # aggregateRows = Object.values(categoryRows)
+    # for (aggregateRow of aggregateRows) {
+    #     for (measure of aggregation.measures) {
+    #         field = measure.name ?? measure.field
+    #         func = measure.function
+    #         measureValues = aggregateRow[field]
+    #         if !measureValues.length:
+    #             aggregateRow[field] = null
+    #         elif func == 'count':
+    #             aggregateRow[field] = measureValues.length
+    #         elif func == 'max':
+    #             aggregateRow[field] = measureValues.reduce((max, val) => (val > max ? val : max))
+    #         elif func == 'min':
+    #             aggregateRow[field] = measureValues.reduce((min, val) => (val < min ? val : min))
+    #         elif func == 'sum':
+    #             aggregateRow[field] = measureValues.reduce((sum, val) => sum + val, 0)
+    #         elif func == 'stddev':
+    #             average = measureValues.reduce((sum, val) => sum + val, 0) / measureValues.length
+    #             aggregateRow[field] = Math.sqrt(measureValues.reduce((sum, val) => sum + (val - average) ** 2, 0) / measureValues.length)
+    #         else:
+    #             # func == 'average'
+    #             aggregateRow[field] = measureValues.reduce((sum, val) => sum + val, 0) / measureValues.length
+    #         }
+    #     }
+    # }
+
+    # return aggregateRows
+
+
+# The aggregation model
+AGGREGATION_TYPES = parse_schema_markdown('''\
+group "Aggregation"
+
+
+# A data aggregation specification
+struct Aggregation
+
+    # The aggregation category fields
+    optional string[len > 0] categories
+
+    # The aggregation measures
+    AggregationMeasure[len > 0] measures
+
+
+# An aggregation measure specification
+struct AggregationMeasure
+
+    # The aggregation measure field
+    string field
+
+    # The aggregation function
+    AggregationFunction function
+
+    # The aggregated-measure field name
+    optional string name
+
+
+# An aggregation function
+enum AggregationFunction
+
+    # The average of the measure's values
+    average
+
+    # The count of the measure's values
+    count
+
+    # The greatest of the measure's values
+    max
+
+    # The least of the measure's values
+    min
+
+    # The standard deviation of the measure's values
+    stddev
+
+    # The sum of the measure's values
+    sum
+''')
+
+
+def sort_data(unused_data, unused_sorts):
+    """
+    Sort data rows
+
+    @param {Object[]} data - The data array
+    @param {Object[]} sorts - The sort field-name/descending-sort tuples
+    @returns {Object[]} - The sorted data array
+    """
+
+    return None
+
+    # return data.sort((row1, row2) => sorts.reduce((result, sort) => {
+    #     if result != 0:
+    #         return result
+    #     }
+    #     [field, desc = false] = sort
+    #     value1 = row1[field] ?? null
+    #     value2 = row2[field] ?? null
+    #     compare = compareValues(value1, value2)
+    #     return desc ? -compare : compare
+    # }, 0))
+
+
+def top_data(unused_data, unused_count, unused_category_fields=None):
+    """
+    Top data rows
+
+    @param {Object[]} data - The data array
+    @param {number} count - The number of rows to keep
+    @param {?string[]} [categoryFields = null] - The category fields
+    @returns {Object[]} - The top data array
+    """
+
+    return None
+
+    # # Bucket rows by category
+    # categoryRows = {}
+    # categoryOrder = []
+    # for (row of data) {
+    #     categoryKey = categoryFields == null ? ''
+    #         : jsonStringifySortKeys(categoryFields.map((field) => (field in row ? row[field] : null)))
+    #     if !(categoryKey in categoryRows):
+    #         categoryRows[categoryKey] = []
+    #         categoryOrder.push(categoryKey)
+    #     }
+    #     categoryRows[categoryKey].push(row)
+    # }
+    # # Take only the top rows
+    # dataTop = []
+    # topCount = count
+    # for (categoryKey of categoryOrder) {
+    #     categoryKeyRows = categoryRows[categoryKey]
+    #     categoryKeyLength = categoryKeyRows.length
+    #     for (ixRow = 0; ixRow < topCount && ixRow < categoryKeyLength; ixRow++) {
+    #         dataTop.push(categoryKeyRows[ixRow])
+    #     }
+    # }
+    # return dataTop

{bare-script-0.9.2 → bare-script-0.9.3/src/bare_script.egg-info}/PKG-INFO

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

{bare-script-0.9.2 → bare-script-0.9.3}/src/bare_script.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/bare_script/__init__.py
 src/bare_script/__main__.py
 src/bare_script/bare.py
 src/bare_script/baredoc.py
+src/bare_script/data.py
 src/bare_script/library.py
 src/bare_script/model.py
 src/bare_script/options.py