snail-lang 0.5.0__tar.gz → 0.5.2__tar.gz

{snail_lang-0.5.0 → snail_lang-0.5.2}/Cargo.lock

@@ -485,11 +485,11 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "snail-ast"
-version = "0.5.0"
+version = "0.5.2"
 
 [[package]]
 name = "snail-core"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "pyo3",
  "snail-ast",
@@ -500,14 +500,14 @@ dependencies = [
 
 [[package]]
 name = "snail-error"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "snail-ast",
 ]
 
 [[package]]
 name = "snail-lower"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "pyo3",
  "snail-ast",
@@ -516,7 +516,7 @@ dependencies = [
 
 [[package]]
 name = "snail-parser"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "pest",
  "pest_derive",
@@ -526,7 +526,7 @@ dependencies = [
 
 [[package]]
 name = "snail-proptest"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "proptest",
  "pyo3",
@@ -540,7 +540,7 @@ dependencies = [
 
 [[package]]
 name = "snail-python"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "pyo3",
  "snail-core",

{snail_lang-0.5.0 → snail_lang-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snail-lang
-Version: 0.5.0
+Version: 0.5.2
 Requires-Dist: jmespath>=1.0.1
 Requires-Dist: maturin>=1.5 ; extra == 'dev'
 Requires-Dist: pytest ; extra == 'dev'

{snail_lang-0.5.0 → snail_lang-0.5.2}/crates/snail-ast/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-ast"
-version = "0.5.0"
+version = "0.5.2"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.5.0 → snail_lang-0.5.2}/crates/snail-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-core"
-version = "0.5.0"
+version = "0.5.2"
 edition.workspace = true
 readme = "README.md"
 

{snail_lang-0.5.0 → snail_lang-0.5.2}/crates/snail-error/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-error"
-version = "0.5.0"
+version = "0.5.2"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.5.0 → snail_lang-0.5.2}/crates/snail-lower/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-lower"
-version = "0.5.0"
+version = "0.5.2"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.5.0 → snail_lang-0.5.2}/crates/snail-parser/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-parser"
-version = "0.5.0"
+version = "0.5.2"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.5.0 → snail_lang-0.5.2}/crates/snail-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-python"
-version = "0.5.0"
+version = "0.5.2"
 edition.workspace = true
 build = "build.rs"
 

{snail_lang-0.5.0 → snail_lang-0.5.2}/crates/snail-python/src/lib.rs

@@ -8,9 +8,25 @@ use snail_core::{
     CompileMode, compile_snail_source_with_auto_print, format_snail_error, parse_awk_program,
     parse_program,
 };
+use std::sync::OnceLock;
+use std::time::Instant;
 
 const SNAIL_TRACE_PREFIX: &str = "snail:";
 
+fn profile_enabled() -> bool {
+    static ENABLED: OnceLock<bool> = OnceLock::new();
+    *ENABLED.get_or_init(|| std::env::var_os("SNAIL_PROFILE_NATIVE").is_some())
+}
+
+fn log_profile(label: &str, elapsed: std::time::Duration) {
+    if profile_enabled() {
+        eprintln!(
+            "[snail][native] {label}: {:.3} ms",
+            elapsed.as_secs_f64() * 1000.0
+        );
+    }
+}
+
 fn parse_mode(mode: &str) -> PyResult<CompileMode> {
     match mode {
         "snail" => Ok(CompileMode::Snail),
@@ -89,12 +105,23 @@ fn compile_source(
     auto_print: bool,
     filename: &str,
 ) -> Result<PyObject, PyErr> {
+    let profile = profile_enabled();
+    let total_start = Instant::now();
+    let compile_start = Instant::now();
     let module = compile_snail_source_with_auto_print(py, source, mode, auto_print)
         .map_err(|err| PySyntaxError::new_err(format_snail_error(&err, filename)))?;
+    if profile {
+        log_profile("compile_snail_source", compile_start.elapsed());
+    }
+    let ast_start = Instant::now();
     let ast = py.import_bound("ast")?;
     let fixed = ast
         .getattr("fix_missing_locations")?
         .call1((module.clone_ref(py),))?;
+    if profile {
+        log_profile("fix_missing_locations", ast_start.elapsed());
+        log_profile("compile_source_total", total_start.elapsed());
+    }
     Ok(fixed.into_py(py))
 }
 
@@ -135,14 +162,25 @@ fn compile_py(
     auto_print: bool,
     filename: &str,
 ) -> PyResult<PyObject> {
+    let profile = profile_enabled();
+    let total_start = Instant::now();
     let mode = parse_mode(mode)?;
     let python_ast = compile_source(py, source, mode, auto_print, filename)?;
     let display = display_filename(filename);
+    let linecache_start = Instant::now();
     register_linecache(py, &display, source)?;
+    if profile {
+        log_profile("register_linecache", linecache_start.elapsed());
+    }
+    let compile_start = Instant::now();
     let builtins = py.import_bound("builtins")?;
     let code = builtins
         .getattr("compile")?
         .call1((python_ast, display, "exec"))?;
+    if profile {
+        log_profile("py_compile", compile_start.elapsed());
+        log_profile("compile_py_total", total_start.elapsed());
+    }
     Ok(code.unbind())
 }
 
@@ -171,33 +209,56 @@ fn exec_py(
     auto_import: bool,
     filename: &str,
 ) -> PyResult<i32> {
+    let profile = profile_enabled();
+    let total_start = Instant::now();
     let mode = parse_mode(mode)?;
     let python_ast = compile_source(py, source, mode, auto_print, filename)?;
     let display = display_filename(filename);
+    let linecache_start = Instant::now();
     register_linecache(py, &display, source)?;
+    if profile {
+        log_profile("register_linecache", linecache_start.elapsed());
+    }
+    let compile_start = Instant::now();
     let builtins = py.import_bound("builtins")?;
     let code = builtins
         .getattr("compile")?
         .call1((python_ast, display, "exec"))?;
+    if profile {
+        log_profile("py_compile", compile_start.elapsed());
+    }
+    let globals_start = Instant::now();
     let globals = prepare_globals(py, strip_display_prefix(filename), &argv, auto_import)?;
+    if profile {
+        log_profile("prepare_globals", globals_start.elapsed());
+    }
 
-    match builtins.getattr("exec")?.call1((code.as_any(), &globals)) {
+    let exec_start = Instant::now();
+    let exec_result = builtins.getattr("exec")?.call1((code.as_any(), &globals));
+    if profile {
+        log_profile("py_exec", exec_start.elapsed());
+    }
+    let result = match exec_result {
         Ok(_) => Ok(0),
         Err(err) => {
             if err.is_instance_of::<PySystemExit>(py) {
                 let code = err.value_bound(py).getattr("code")?;
                 if code.is_none() {
-                    return Ok(0);
-                }
-                if let Ok(exit_code) = code.extract::<i32>() {
-                    return Ok(exit_code);
+                    Ok(0)
+                } else if let Ok(exit_code) = code.extract::<i32>() {
+                    Ok(exit_code)
+                } else {
+                    Ok(1)
                 }
-                Ok(1)
             } else {
                 Err(err)
             }
         }
+    };
+    if profile {
+        log_profile("exec_py_total", total_start.elapsed());
     }
+    result
 }
 
 #[pyfunction(name = "parse")]
@@ -214,15 +275,20 @@ fn parse_py(source: &str, mode: &str, filename: &str) -> PyResult<()> {
 }
 
 #[pymodule]
-fn _native(_py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> {
+fn _native(py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> {
+    let profile = profile_enabled();
+    let total_start = Instant::now();
     module.add_function(wrap_pyfunction!(compile_py, module)?)?;
     module.add_function(wrap_pyfunction!(compile_ast_py, module)?)?;
     module.add_function(wrap_pyfunction!(exec_py, module)?)?;
     module.add_function(wrap_pyfunction!(parse_py, module)?)?;
-    module.add("__build_info__", build_info_dict(_py)?)?;
+    module.add("__build_info__", build_info_dict(py)?)?;
     module.add(
         "__all__",
         vec!["compile", "compile_ast", "exec", "parse", "__build_info__"],
     )?;
+    if profile {
+        log_profile("module_init", total_start.elapsed());
+    }
     Ok(())
 }

{snail_lang-0.5.0 → snail_lang-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "snail-lang"
-version = "0.5.0"
+version = "0.5.2"
 description = "Snail programming language interpreter"
 readme = "README.md"
 requires-python = ">=3.10"

snail_lang-0.5.2/python/snail/__init__.py

@@ -0,0 +1,25 @@
+from ._native import __build_info__, compile, compile_ast, exec, parse
+
+
+def _resolve_version() -> str:
+    try:
+        from importlib.metadata import version
+
+        return version("snail-lang")
+    except Exception:  # pragma: no cover - during development
+        return "0.0.0"
+
+
+def __getattr__(name: str):
+    if name == "__version__":
+        value = _resolve_version()
+        globals()["__version__"] = value
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(list(globals().keys()) + ["__version__"])
+
+
+__all__ = ["compile", "compile_ast", "exec", "parse", "__version__", "__build_info__"]

{snail_lang-0.5.0 → snail_lang-0.5.2}/python/snail/cli.py

@@ -1,23 +1,15 @@
 from __future__ import annotations
 
-import argparse
-import ast
-import builtins
 import os
 import sys
-import traceback
-from pathlib import Path
 
-from . import __build_info__, __version__, compile_ast, exec
+from . import __build_info__, compile_ast, exec
 
-
-def _build_parser() -> argparse.ArgumentParser:
-    return argparse.ArgumentParser(
-        prog="snail",
-        description="Snail programming language interpreter",
-        usage="snail [options] -f <file> [args]...\n       snail [options] <code> [args]...",
-        add_help=True,
-    )
+_USAGE = (
+    "snail [options] -f <file> [args]...\n"
+    "       snail [options] <code> [args]..."
+)
+_DESCRIPTION = "Snail programming language interpreter"
 
 
 def _display_filename(filename: str) -> str:
@@ -26,10 +18,7 @@ def _display_filename(filename: str) -> str:
     return f"snail:{filename}"
 
 
-def _trim_internal_prefix(
-    stack: traceback.StackSummary,
-    internal_files: set[str],
-) -> None:
+def _trim_internal_prefix(stack, internal_files: set[str]) -> None:
     if not stack:
         return
     trim_count = 0
@@ -48,10 +37,7 @@ def _trim_internal_prefix(
         del stack[:trim_count]
 
 
-def _trim_traceback_exception(
-    tb_exc: traceback.TracebackException,
-    internal_files: set[str],
-) -> None:
+def _trim_traceback_exception(tb_exc, internal_files: set[str]) -> None:
     _trim_internal_prefix(tb_exc.stack, internal_files)
     cause = getattr(tb_exc, "__cause__", None)
     if cause is not None:
@@ -76,6 +62,8 @@ def _install_trimmed_excepthook() -> None:
     ) -> None:
         if exc_type is KeyboardInterrupt:
             return original_excepthook(exc_type, exc, tb)
+        import traceback
+
         tb_exc = traceback.TracebackException(
             exc_type,
             exc,
@@ -95,6 +83,77 @@ def _install_trimmed_excepthook() -> None:
     sys.excepthook = _snail_excepthook
 
 
+class _Args:
+    def __init__(self) -> None:
+        self.file: str | None = None
+        self.awk = False
+        self.no_print = False
+        self.no_auto_import = False
+        self.debug = False
+        self.version = False
+        self.help = False
+        self.args: list[str] = []
+
+
+def _print_help(file=sys.stdout) -> None:
+    print(f"usage: {_USAGE}", file=file)
+    print("", file=file)
+    print(_DESCRIPTION, file=file)
+    print("", file=file)
+    print("options:", file=file)
+    print("  -f <file>               read Snail source from file", file=file)
+    print("  -a, --awk               awk mode", file=file)
+    print("  -P, --no-print          disable auto-print of last expression", file=file)
+    print("  -I, --no-auto-import    disable auto-imports", file=file)
+    print("  --debug                 parse and compile, then print, do not run", file=file)
+    print("  -v, --version           show version and exit", file=file)
+    print("  -h, --help              show this help message and exit", file=file)
+
+
+def _parse_args(argv: list[str]) -> _Args:
+    args = _Args()
+    idx = 0
+    while idx < len(argv):
+        token = argv[idx]
+        if token == "--":
+            args.args = argv[idx + 1 :]
+            return args
+        if token == "-" or not token.startswith("-"):
+            args.args = argv[idx:]
+            return args
+        if token in ("-h", "--help"):
+            args.help = True
+            return args
+        if token in ("-v", "--version"):
+            args.version = True
+            idx += 1
+            continue
+        if token in ("-a", "--awk"):
+            args.awk = True
+            idx += 1
+            continue
+        if token in ("-P", "--no-print"):
+            args.no_print = True
+            idx += 1
+            continue
+        if token in ("-I", "--no-auto-import"):
+            args.no_auto_import = True
+            idx += 1
+            continue
+        if token == "--debug":
+            args.debug = True
+            idx += 1
+            continue
+        if token == "-f":
+            if idx + 1 >= len(argv):
+                raise ValueError("option -f requires an argument")
+            args.file = argv[idx + 1]
+            idx += 2
+            continue
+        raise ValueError(f"unknown option: {token}")
+    return args
+
+
 def _format_version(version: str, build_info: dict[str, object] | None) -> str:
     display_version = version if version.startswith("v") else f"v{version}"
     if not build_info:
@@ -114,28 +173,36 @@ def _format_version(version: str, build_info: dict[str, object] | None) -> str:
     return f"{display_version} ({git_rev})"
 
 
+def _get_version() -> str:
+    from . import __version__ as version
+
+    return version
+
+
 def main(argv: list[str] | None = None) -> int:
     if argv is None:
         _install_trimmed_excepthook()
+        argv = sys.argv[1:]
 
-    parser = _build_parser()
-    parser.add_argument("-f", dest="file", metavar="file")
-    parser.add_argument("-a", "--awk", action="store_true")
-    parser.add_argument("-P", "--no-print", action="store_true")
-    parser.add_argument("-I", "--no-auto-import", action="store_true")
-    parser.add_argument("--debug", action="store_true", help="Parse and compile, then print, do not run")
-    parser.add_argument("-v", "--version", action="store_true")
-    parser.add_argument("args", nargs=argparse.REMAINDER)
-
-    namespace = parser.parse_args(argv)
+    try:
+        namespace = _parse_args(argv)
+    except ValueError as exc:
+        _print_help(file=sys.stderr)
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
 
+    if namespace.help:
+        _print_help()
+        return 0
     if namespace.version:
-        print(_format_version(__version__, __build_info__))
+        print(_format_version(_get_version(), __build_info__))
         return 0
 
     mode = "awk" if namespace.awk else "snail"
 
     if namespace.file:
+        from pathlib import Path
+
         path = Path(namespace.file)
         try:
             source = path.read_text()
@@ -153,6 +220,9 @@ def main(argv: list[str] | None = None) -> int:
         args = ["--", *namespace.args[1:]]
 
     if namespace.debug:
+        import ast
+        import builtins
+
         python_ast = compile_ast(
             source,
             mode=mode,

snail_lang-0.5.2/python/snail/runtime/__init__.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import importlib
+
+__all__ = ["install_helpers", "AutoImportDict", "AUTO_IMPORT_NAMES"]
+
+# Names that can be auto-imported when first referenced.
+# Maps name -> (module, attribute) where attribute is None for whole-module imports.
+AUTO_IMPORT_NAMES: dict[str, tuple[str, str | None]] = {
+    # Whole module imports: import X
+    "sys": ("sys", None),
+    "os": ("os", None),
+    # Attribute imports: from X import Y
+    "Path": ("pathlib", "Path"),
+}
+
+
+class AutoImportDict(dict):
+    """A dict subclass that lazily imports allowed names on first access.
+
+    When a key lookup fails, if the key is in AUTO_IMPORT_NAMES,
+    the corresponding module/attribute is imported and stored in the dict.
+    Supports both whole-module imports (import sys) and attribute imports
+    (from pathlib import Path).
+    """
+
+    def __missing__(self, key: str) -> object:
+        if key in AUTO_IMPORT_NAMES:
+            module_name, attr_name = AUTO_IMPORT_NAMES[key]
+            module = importlib.import_module(module_name)
+            value = getattr(module, attr_name) if attr_name else module
+            self[key] = value
+            return value
+        raise KeyError(key)
+
+
+_compact_try = None
+_regex_search = None
+_regex_compile = None
+_subprocess_capture = None
+_subprocess_status = None
+_jmespath_query = None
+_js = None
+
+
+def _get_compact_try():
+    global _compact_try
+    if _compact_try is None:
+        from .compact_try import compact_try
+
+        _compact_try = compact_try
+    return _compact_try
+
+
+def _get_regex_search():
+    global _regex_search
+    if _regex_search is None:
+        from .regex import regex_search
+
+        _regex_search = regex_search
+    return _regex_search
+
+
+def _get_regex_compile():
+    global _regex_compile
+    if _regex_compile is None:
+        from .regex import regex_compile
+
+        _regex_compile = regex_compile
+    return _regex_compile
+
+
+def _get_subprocess_capture():
+    global _subprocess_capture
+    if _subprocess_capture is None:
+        from .subprocess import SubprocessCapture
+
+        _subprocess_capture = SubprocessCapture
+    return _subprocess_capture
+
+
+def _get_subprocess_status():
+    global _subprocess_status
+    if _subprocess_status is None:
+        from .subprocess import SubprocessStatus
+
+        _subprocess_status = SubprocessStatus
+    return _subprocess_status
+
+
+def _get_jmespath_query():
+    global _jmespath_query
+    if _jmespath_query is None:
+        from .structured_accessor import __snail_jmespath_query
+
+        _jmespath_query = __snail_jmespath_query
+    return _jmespath_query
+
+
+def _get_js():
+    global _js
+    if _js is None:
+        from .structured_accessor import js
+
+        _js = js
+    return _js
+
+
+def _lazy_compact_try(expr_fn, fallback_fn=None):
+    return _get_compact_try()(expr_fn, fallback_fn)
+
+
+def _lazy_regex_search(value, pattern):
+    return _get_regex_search()(value, pattern)
+
+
+def _lazy_regex_compile(pattern):
+    return _get_regex_compile()(pattern)
+
+
+def _lazy_subprocess_capture(cmd: str):
+    return _get_subprocess_capture()(cmd)
+
+
+def _lazy_subprocess_status(cmd: str):
+    return _get_subprocess_status()(cmd)
+
+
+def _lazy_jmespath_query(query: str):
+    return _get_jmespath_query()(query)
+
+
+def _lazy_js(input_data=None):
+    return _get_js()(input_data)
+
+
+def __snail_partial(func, /, *args, **kwargs):
+    import functools
+
+    return functools.partial(func, *args, **kwargs)
+
+
+def __snail_contains__(left, right):
+    method = getattr(right, "__snail_contains__", None)
+    if method is not None:
+        return method(left)
+    return left in right
+
+
+def __snail_contains_not__(left, right):
+    method = getattr(right, "__snail_contains__", None)
+    if method is not None:
+        return not bool(method(left))
+    return left not in right
+
+
+def install_helpers(globals_dict: dict) -> None:
+    globals_dict["__snail_compact_try"] = _lazy_compact_try
+    globals_dict["__snail_regex_search"] = _lazy_regex_search
+    globals_dict["__snail_regex_compile"] = _lazy_regex_compile
+    globals_dict["__SnailSubprocessCapture"] = _lazy_subprocess_capture
+    globals_dict["__SnailSubprocessStatus"] = _lazy_subprocess_status
+    globals_dict["__snail_jmespath_query"] = _lazy_jmespath_query
+    globals_dict["__snail_partial"] = __snail_partial
+    globals_dict["__snail_contains__"] = __snail_contains__
+    globals_dict["__snail_contains_not__"] = __snail_contains_not__
+    globals_dict["js"] = _lazy_js

{snail_lang-0.5.0 → snail_lang-0.5.2}/python/snail/runtime/structured_accessor.py

@@ -4,17 +4,16 @@ import json as _json
 import os as _os
 import sys as _sys
 
-import jmespath
-
-
 def __snail_jmespath_query(query: str):
     """Create a callable that applies JMESPath query.
 
     Used by the $[query] syntax which lowers to __snail_jmespath_query(query).
     """
 
+    import jmespath as _jmespath
+
     def apply(data):
-        return jmespath.search(query, data)
+        return _jmespath.search(query, data)
 
     return apply
 

snail_lang-0.5.0/python/snail/__init__.py

@@ -1,10 +0,0 @@
-from ._native import __build_info__, compile, compile_ast, exec, parse
-
-try:
-    from importlib.metadata import version
-
-    __version__ = version("snail-lang")
-except Exception:  # pragma: no cover - during development
-    __version__ = "0.0.0"
-
-__all__ = ["compile", "compile_ast", "exec", "parse", "__version__", "__build_info__"]

snail_lang-0.5.0/python/snail/runtime/__init__.py

@@ -1,75 +0,0 @@
-from __future__ import annotations
-
-import functools
-import importlib
-from typing import Any
-
-from .compact_try import compact_try
-from .regex import regex_compile, regex_search
-from .structured_accessor import (
-    __snail_jmespath_query,
-    js,
-)
-from .subprocess import SubprocessCapture, SubprocessStatus
-
-__all__ = ["install_helpers", "AutoImportDict", "AUTO_IMPORT_NAMES"]
-
-# Names that can be auto-imported when first referenced.
-# Maps name -> (module, attribute) where attribute is None for whole-module imports.
-AUTO_IMPORT_NAMES: dict[str, tuple[str, str | None]] = {
-    # Whole module imports: import X
-    "sys": ("sys", None),
-    "os": ("os", None),
-    # Attribute imports: from X import Y
-    "Path": ("pathlib", "Path"),
-}
-
-
-class AutoImportDict(dict):
-    """A dict subclass that lazily imports allowed names on first access.
-
-    When a key lookup fails, if the key is in AUTO_IMPORT_NAMES,
-    the corresponding module/attribute is imported and stored in the dict.
-    Supports both whole-module imports (import sys) and attribute imports
-    (from pathlib import Path).
-    """
-
-    def __missing__(self, key: str) -> Any:
-        if key in AUTO_IMPORT_NAMES:
-            module_name, attr_name = AUTO_IMPORT_NAMES[key]
-            module = importlib.import_module(module_name)
-            value = getattr(module, attr_name) if attr_name else module
-            self[key] = value
-            return value
-        raise KeyError(key)
-
-
-def __snail_partial(func, /, *args, **kwargs):
-    return functools.partial(func, *args, **kwargs)
-
-
-def __snail_contains__(left, right):
-    method = getattr(right, "__snail_contains__", None)
-    if method is not None:
-        return method(left)
-    return left in right
-
-
-def __snail_contains_not__(left, right):
-    method = getattr(right, "__snail_contains__", None)
-    if method is not None:
-        return not bool(method(left))
-    return left not in right
-
-
-def install_helpers(globals_dict: dict) -> None:
-    globals_dict["__snail_compact_try"] = compact_try
-    globals_dict["__snail_regex_search"] = regex_search
-    globals_dict["__snail_regex_compile"] = regex_compile
-    globals_dict["__SnailSubprocessCapture"] = SubprocessCapture
-    globals_dict["__SnailSubprocessStatus"] = SubprocessStatus
-    globals_dict["__snail_jmespath_query"] = __snail_jmespath_query
-    globals_dict["__snail_partial"] = __snail_partial
-    globals_dict["__snail_contains__"] = __snail_contains__
-    globals_dict["__snail_contains_not__"] = __snail_contains_not__
-    globals_dict["js"] = js