bare-script 5.1.6__tar.gz → 5.1.7__tar.gz

{bare_script-5.1.6/src/bare_script.egg-info → bare_script-5.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bare-script
-Version: 5.1.6
+Version: 5.1.7
 Summary: BareScript; a lightweight scripting and expression language
 Author-email: "Craig A. Hobbs" <craigahobbs@gmail.com>
 License-Expression: MIT
@@ -296,6 +296,17 @@ builds. See the Performance section below for benchmark results comparing the C
 pure-Python runtime, and native Python.
 
 
+## Thread Safety
+
+Both runtimes may be used from multiple threads, including on the free-threaded (no-GIL) Python
+builds. Script models and a `globals` dict may be shared across threads once populated - for example,
+execute a script that defines functions once, then call those functions concurrently. Each
+concurrently executing thread must pass its own `options` dict to `execute_script`, since the runtime
+records the running `statementCount` there. The parser, linter, and include library stubs initialize
+lazily and are safe to call from any thread. As in Python, unsynchronized concurrent mutation of a
+shared array or object from several threads has unspecified results but never crashes the runtime.
+
+
 ## Performance
 
 The `make perf` target benchmarks the BareScript runtime with a suite of compute-intensive tests —

{bare_script-5.1.6 → bare_script-5.1.7}/README.md

@@ -270,6 +270,17 @@ builds. See the Performance section below for benchmark results comparing the C
 pure-Python runtime, and native Python.
 
 
+## Thread Safety
+
+Both runtimes may be used from multiple threads, including on the free-threaded (no-GIL) Python
+builds. Script models and a `globals` dict may be shared across threads once populated - for example,
+execute a script that defines functions once, then call those functions concurrently. Each
+concurrently executing thread must pass its own `options` dict to `execute_script`, since the runtime
+records the running `statementCount` there. The parser, linter, and include library stubs initialize
+lazily and are safe to call from any thread. As in Python, unsynchronized concurrent mutation of a
+shared array or object from several threads has unspecified results but never crashes the runtime.
+
+
 ## Performance
 
 The `make perf` target benchmarks the BareScript runtime with a suite of compute-intensive tests —

{bare_script-5.1.6 → bare_script-5.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bare-script"
-version = "5.1.6"
+version = "5.1.7"
 description = "BareScript; a lightweight scripting and expression language"
 readme = "README.md"
 license = "MIT"

{bare_script-5.1.6 → bare_script-5.1.7}/src/bare_script/runtime.py

@@ -10,6 +10,7 @@ import functools
 import json
 import math
 import sys
+import threading
 
 from .include_source import SYSTEM_INCLUDES
 from .library import EXPRESSION_FUNCTIONS, INTRINSICS, SCRIPT_FUNCTIONS
@@ -199,20 +200,25 @@ def _execute_script_helper(script, statements, options, locals_, label_indexes):
     return None
 
 
-# The barescriptParser.bare include library script globals (lazily initialized)
+# The barescriptParser.bare include library script globals (lazily initialized under a lock)
 _PARSER_GLOBALS = None
+_PARSER_GLOBALS_INIT_LOCK = threading.Lock()
 
 
 def _parser_globals_init():
-    # Execute the barescriptParser.bare include library script, if necessary
+    # Execute the barescriptParser.bare include library script, if necessary. The globals are built
+    # locally and published only once complete so a concurrent first-use caller never observes a
+    # partially-initialized parser; the lock serializes the one-time initialization.
     # pylint: disable-next=global-statement
     global _PARSER_GLOBALS
-    if _PARSER_GLOBALS is None:
-        _PARSER_GLOBALS = {}
-        execute_script(
-            {'statements': [{'include': {'includes': [{'url': 'barescriptParser.bare', 'system': True}]}}]},
-            {'globals': _PARSER_GLOBALS}
-        )
+    with _PARSER_GLOBALS_INIT_LOCK:
+        if _PARSER_GLOBALS is None:
+            parser_globals = {}
+            execute_script(
+                {'statements': [{'include': {'includes': [{'url': 'barescriptParser.bare', 'system': True}]}}]},
+                {'globals': parser_globals}
+            )
+            _PARSER_GLOBALS = parser_globals
 
 
 def _normalize_statements(statements):
@@ -281,8 +287,9 @@ def barescript_parse_expression(expr_text, line_number=None, script_name=None, a
     return result['result']
 
 
-# The barescriptLint.bare include library script globals (lazily initialized)
+# The barescriptLint.bare include library script globals (lazily initialized under a lock)
 _LINT_GLOBALS = None
+_LINT_GLOBALS_INIT_LOCK = threading.Lock()
 
 
 def barescript_lint_script(script, globals_=None):
@@ -297,15 +304,17 @@ def barescript_lint_script(script, globals_=None):
     :rtype: list[str]
     """
 
-    # Execute the barescriptLint.bare include library script, if necessary
+    # Execute the barescriptLint.bare include library script, if necessary (see _parser_globals_init)
     # pylint: disable-next=global-statement
     global _LINT_GLOBALS
-    if _LINT_GLOBALS is None:
-        _LINT_GLOBALS = {}
-        execute_script(
-            {'statements': [{'include': {'includes': [{'url': 'barescriptLint.bare', 'system': True}]}}]},
-            {'globals': _LINT_GLOBALS}
-        )
+    with _LINT_GLOBALS_INIT_LOCK:
+        if _LINT_GLOBALS is None:
+            lint_globals = {}
+            execute_script(
+                {'statements': [{'include': {'includes': [{'url': 'barescriptLint.bare', 'system': True}]}}]},
+                {'globals': lint_globals}
+            )
+            _LINT_GLOBALS = lint_globals
 
     # Call the barescriptLint.bare lint function. Async function detection is not possible in
     # Python (all functions execute synchronously), so the async lint checks are skipped.

{bare_script-5.1.6 → bare_script-5.1.7}/src/bare_script/runtime_c.c

@@ -187,6 +187,7 @@ typedef struct {
     PyObject *str_method_upper;
     PyObject *str_method_lower;
     PyObject *str_method_strip;
+    PyObject *str_method_pop;
 
     // Imported objects
     PyObject *script_functions;
@@ -783,7 +784,12 @@ static UnaryOp parse_unary_op(PyObject *op)
 // value.value_args_validate model exactly and raise errors by calling the Python ValueArgsError
 // class so messages and error return values match. Intrinsics never touch the options object, so
 // no statement-counter sync is required around them. The table is populated once at module exec
-// and immutable afterwards (free-threading safe).
+// and immutable afterwards (free-threading safe). A per-call args list is private to the calling
+// thread, but the arrays and objects it references may be shared with other threads, so handlers
+// touch those only through the bounds-checked, locking list/dict APIs (list_get_ref,
+// PyList_SetItem, list.pop, dict_get_ref, ...) under the free-threaded build, where an
+// unsynchronized concurrent mutation then raises instead of reading freed storage. The default
+// (GIL) build keeps the direct macro accessors - the GIL already serializes those operations.
 //
 
 
@@ -1083,7 +1089,17 @@ static PyObject *intrinsic_array_get(PyObject *args)
         intrinsic_index_bounds_error(args, 1, "index");
         return NULL;
     }
+#ifdef Py_GIL_DISABLED
+    // Bounds-checked under the list's lock - an unsynchronized concurrent shrink by another thread
+    // raises IndexError instead of reading freed storage
+    PyObject *value;
+    if (list_get_ref(array, index, &value) < 0) {
+        return NULL;
+    }
+    return value;
+#else
     return Py_NewRef(PyList_GET_ITEM(array, index));
+#endif
 }
 
 
@@ -1150,12 +1166,19 @@ static PyObject *intrinsic_array_pop(PyObject *args)
         intrinsic_args_error("array", array, NULL);
         return NULL;
     }
+#ifdef Py_GIL_DISABLED
+    // list.pop() is atomic under the list's lock, like the reference implementation's array.pop() -
+    // an unsynchronized concurrent pop by another thread then raises IndexError (empty list) rather
+    // than returning an element this call did not remove
+    return PyObject_CallMethodNoArgs(array, g.str_method_pop);
+#else
     PyObject *value = Py_NewRef(PyList_GET_ITEM(array, length - 1));
     if (PyList_SetSlice(array, length - 1, length, NULL) < 0) {
         Py_DECREF(value);
         return NULL;
     }
     return value;
+#endif
 }
 
 
@@ -5223,7 +5246,8 @@ static int runtime_c_exec(PyObject *module)
         intern_string(&g.str_copy, "copy") < 0 ||
         intern_string(&g.str_method_upper, "upper") < 0 ||
         intern_string(&g.str_method_lower, "lower") < 0 ||
-        intern_string(&g.str_method_strip, "strip") < 0) {
+        intern_string(&g.str_method_strip, "strip") < 0 ||
+        intern_string(&g.str_method_pop, "pop") < 0) {
         return -1;
     }
 

{bare_script-5.1.6 → bare_script-5.1.7/src/bare_script.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bare-script
-Version: 5.1.6
+Version: 5.1.7
 Summary: BareScript; a lightweight scripting and expression language
 Author-email: "Craig A. Hobbs" <craigahobbs@gmail.com>
 License-Expression: MIT
@@ -296,6 +296,17 @@ builds. See the Performance section below for benchmark results comparing the C
 pure-Python runtime, and native Python.
 
 
+## Thread Safety
+
+Both runtimes may be used from multiple threads, including on the free-threaded (no-GIL) Python
+builds. Script models and a `globals` dict may be shared across threads once populated - for example,
+execute a script that defines functions once, then call those functions concurrently. Each
+concurrently executing thread must pass its own `options` dict to `execute_script`, since the runtime
+records the running `statementCount` there. The parser, linter, and include library stubs initialize
+lazily and are safe to call from any thread. As in Python, unsynchronized concurrent mutation of a
+shared array or object from several threads has unspecified results but never crashes the runtime.
+
+
 ## Performance
 
 The `make perf` target benchmarks the BareScript runtime with a suite of compute-intensive tests —