calkit-python 0.34.1__tar.gz → 0.34.2__tar.gz

{calkit_python-0.34.1 → calkit_python-0.34.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calkit-python
-Version: 0.34.1
+Version: 0.34.2
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues

{calkit_python-0.34.1 → calkit_python-0.34.2}/calkit/cli/main.py

@@ -1835,9 +1835,9 @@ def execute_and_record(
         list[str],
         typer.Argument(
             help="Command to execute and record. "
-            "If the first argument is a script or notebook, "
-            "it will be treated as a stage with that script/notebook as "
-            "the target."
+            "If the first argument is a script, notebook or LaTeX file, "
+            "it will be treated as a stage with that file as "
+            "the target. Any command, including arguments, is supported."
         ),
     ],
     environment: Annotated[
@@ -1895,6 +1895,17 @@ def execute_and_record(
             ),
         ),
     ] = False,
+    force: Annotated[
+        bool,
+        typer.Option(
+            "--force",
+            "-f",
+            help="Force running stage even if it's up-to-date.",
+        ),
+    ] = False,
+    verbose: Annotated[
+        bool, typer.Option("--verbose", "-v", help="Print verbose output.")
+    ] = False,
 ):
     """Execute a command and if successful, record in the pipeline."""
     import io
@@ -2152,8 +2163,8 @@ def execute_and_record(
     # If we created an environment from dependencies, write the spec file
     if env_result.created_from_dependencies and not dry_run:
         typer.echo(
-            "No existing environment detected. "
-            "Attempting to create one based on detected dependencies..."
+            "No existing environment detected; "
+            "Attempting to create one based on detected dependencies"
         )
         if env_result.dependencies:
             typer.echo(
@@ -2302,7 +2313,7 @@ def execute_and_record(
             f"Adding stage to pipeline and attempting to execute:"
             f"\n{indented_yaml}"
         )
-        run(targets=[stage_name])
+        run(targets=[stage_name], force=force, verbose=verbose)
     except Exception as e:
         # If the stage failed, write the old ck_info back to calkit.yaml to
         # remove the stage that we added

{calkit_python-0.34.1 → calkit_python-0.34.2}/calkit/cli/notebooks.py

@@ -15,7 +15,7 @@ from typing_extensions import Annotated
 
 import calkit
 import calkit.notebooks
-from calkit.cli.core import raise_error
+from calkit.cli.core import raise_error, warn
 
 notebooks_app = typer.Typer(no_args_is_help=True)
 
@@ -115,7 +115,7 @@ def check_env_kernel(
     verbose: Annotated[
         bool, typer.Option("--verbose", "-v", help="Print verbose output.")
     ] = False,
-):
+) -> tuple[str, str]:
     """Check that an environment has a registered Jupyter kernel."""
     from calkit.cli.check import check_environment
     from calkit.cli.main import run_in_env
@@ -159,7 +159,7 @@ def check_env_kernel(
             verbose=verbose,
             relaxed_check=True,
         )
-        return kernel_name
+        return kernel_name, display_name
     elif language == "r":
         cmd = [
             "Rscript",
@@ -176,7 +176,7 @@ def check_env_kernel(
             verbose=verbose,
             relaxed_check=True,
         )
-        return kernel_name
+        return kernel_name, display_name
     elif language == "julia":
         if not no_check:
             check_environment(env_name=env_name, verbose=verbose)
@@ -214,9 +214,10 @@ def check_env_kernel(
         kernel_path = res.stdout.strip()
         typer.echo(f"Registered IJulia kernel at: {kernel_path}")
         kernel_name = os.path.basename(kernel_path)
-        return kernel_name
+        return kernel_name, display_name
     else:
         raise_error(f"{language} not supported")
+        return "", ""  # For typing analysis since raise_error exits
 
 
 @notebooks_app.command("exec", help="Alias for 'execute'.")
@@ -345,14 +346,10 @@ def execute_notebook(
             env = envs[env_name]
             language = language_from_env(env) or "python"
         typer.echo(f"Using {language} as notebook language")
-    if language.lower() not in ["python", "matlab", "julia", "r"]:
-        raise ValueError(
-            "Language must be one of 'python', 'matlab', 'julia', or 'r'"
-        )
     # First, ensure the specified environment has a kernel we can use
     # We need to check the environment type and create the kernel if needed
     if language.lower() in ["python", "julia", "r"]:
-        kernel_name = check_env_kernel(
+        kernel_name, display_name = check_env_kernel(
             env_name=env_name,
             no_check=no_check,
             verbose=verbose,
@@ -360,6 +357,25 @@ def execute_notebook(
         )
     elif language.lower() == "matlab":
         kernel_name = "jupyter_matlab_kernel"
+        display_name = "MATLAB"
+    else:
+        raise ValueError(
+            "Language must be one of 'python', 'matlab', 'julia', or 'r'"
+        )
+    # Try to set kernelspec metadata so execution uses the expected kernel
+    try:
+        with open(path, "r") as f:
+            nb_json = json.load(f)
+        metadata = nb_json.setdefault("metadata", {})
+        kernelspec = metadata.setdefault("kernelspec", {})
+        kernelspec["name"] = kernel_name
+        kernelspec["display_name"] = display_name
+        kernelspec.setdefault("language", language.lower())
+        with open(path, "w") as f:
+            json.dump(nb_json, f, indent=1)
+    except Exception as e:
+        if verbose:
+            warn(f"Warning: failed to set kernelspec metadata: {e}")
     # We can't handle parameters unless language is Python, Julia, or R
     if language.lower() not in ["python", "julia", "r"]:
         if params or params_json is not None or params_base64 is not None:

{calkit_python-0.34.1 → calkit_python-0.34.2}/calkit/detect.py

@@ -1214,7 +1214,6 @@ def generate_stage_name(cmd: list[str]) -> str:
             if remaining_args:
                 args_part = "-".join(remaining_args)
                 stage_name += "-" + args_part
-
     # Convert to kebab-case
     stage_name = stage_name.replace("_", "-").lower()
     # Replace dots with dashes (except file extensions which are
@@ -1229,6 +1228,9 @@ def generate_stage_name(cmd: list[str]) -> str:
     stage_name = re.sub(r"-+", "-", stage_name)
     # Remove leading/trailing dashes
     stage_name = stage_name.strip("-")
+    # If any args include the .ipynb extension, add a -notebook suffix
+    if any(arg.endswith(".ipynb") for arg in cmd):
+        stage_name += "-notebook"
     return stage_name
 
 

{calkit_python-0.34.1 → calkit_python-0.34.2}/calkit/environments.py

@@ -10,6 +10,8 @@ import tempfile
 from pathlib import Path
 from typing import cast
 
+import toml
+import yaml
 from pydantic import BaseModel
 from sqlitedict import SqliteDict
 
@@ -1055,6 +1057,214 @@ Title: Auto-generated R environment
     return content
 
 
+def extract_dependencies_from_spec_file(
+    spec_path: str, language: str | None = None
+) -> list[str]:
+    """Extract dependencies from an environment spec file.
+
+    Parameters
+    ----------
+    spec_path : str
+        Path to the spec file (requirements.txt, Project.toml, etc.).
+    language : str | None
+        Language hint to help identify the format. If None, will be inferred
+        from the file path.
+
+    Returns
+    -------
+    list[str]
+        List of package/dependency names.
+    """
+    if not os.path.exists(spec_path):
+        return []
+    try:
+        with open(spec_path, "r", encoding="utf-8") as f:
+            content = f.read()
+    except (IOError, UnicodeDecodeError):
+        return []
+    # Determine format from filename if not provided
+    if language is None:
+        if spec_path.endswith("requirements.txt"):
+            language = "python-requirements"
+        elif spec_path.endswith("pyproject.toml"):
+            language = "python-pyproject"
+        elif spec_path.endswith("Project.toml"):
+            language = "julia"
+        elif spec_path.endswith("DESCRIPTION"):
+            language = "r"
+        elif spec_path.endswith("environment.yml"):
+            language = "conda"
+    dependencies: list[str] = []
+    if language in ["python-requirements"]:
+        # Parse requirements.txt
+        for line in content.split("\n"):
+            line = line.strip()
+            if line and not line.startswith("#"):
+                # Extract package name (before any version specifiers)
+                pkg = line.split("[")[0].split("==")[0].split(">=")[0]
+                pkg = pkg.split("<=")[0].split(">")[0].split("<")[0]
+                pkg = pkg.split("~=")[0].strip()
+                if pkg:
+                    dependencies.append(pkg)
+    elif language == "python-pyproject":
+        # Parse pyproject.toml to extract dependencies
+        try:
+            data = toml.loads(content)
+            project_deps = data.get("project", {}).get("dependencies", [])
+            for dep in project_deps:
+                # Extract package name (before any version specifiers)
+                pkg = dep.split("[")[0].split("==")[0].split(">=")[0]
+                pkg = pkg.split("<=")[0].split(">")[0].split("<")[0]
+                pkg = pkg.split("~=")[0].strip()
+                if pkg:
+                    dependencies.append(pkg)
+        except Exception:
+            pass
+    elif language == "julia":
+        # Parse Julia Project.toml for [deps] section
+        try:
+            data = toml.loads(content)
+            # Package names are the keys in the [deps] section
+            deps_section = data.get("deps", {})
+            if isinstance(deps_section, dict):
+                dependencies = list(deps_section.keys())
+        except Exception:
+            pass
+    elif language == "r":
+        # Parse R DESCRIPTION file for Imports/Depends fields,
+        # correctly handling multi-line (continued) fields where
+        # continuation lines start with whitespace.
+        lines = content.splitlines()
+        i = 0
+        while i < len(lines):
+            raw_line = lines[i]
+            stripped = raw_line.lstrip()
+            if stripped.startswith(("Imports:", "Depends:")):
+                # Extract the text after the field name and colon
+                _, after_colon = stripped.split(":", 1)
+                pkg_chunks: list[str] = [after_colon.strip()]
+                # Collect continuation lines that start with whitespace
+                j = i + 1
+                while j < len(lines) and (
+                    lines[j].startswith(" ") or lines[j].startswith("\t")
+                ):
+                    pkg_chunks.append(lines[j].strip())
+                    j += 1
+                # Join all chunks into a single dependency string
+                pkg_str = " ".join(pkg_chunks)
+                # Split on commas to get individual package entries
+                pkgs = [p.strip() for p in pkg_str.split(",") if p.strip()]
+                for pkg in pkgs:
+                    # Remove version specifications if present
+                    pkg = pkg.split("(", 1)[0].strip()
+                    if pkg:
+                        dependencies.append(pkg)
+                # Continue parsing from the first non-continuation line
+                i = j
+                continue
+            i += 1
+    elif language == "conda":
+        # Parse conda environment.yml
+        try:
+            data = yaml.safe_load(content)
+            deps = data.get("dependencies", [])
+            for dep in deps:
+                if isinstance(dep, str):
+                    # Extract package name (before version spec)
+                    pkg = dep.split("==")[0].split(">=")[0].split("<=")[0]
+                    pkg = pkg.split("=")[0].strip()
+                    if "::" in pkg:
+                        pkg = pkg.split("::", 1)[1]
+                    if pkg:
+                        dependencies.append(pkg)
+                elif isinstance(dep, dict):
+                    # Handle pip dependencies nested as {pip: [...]}
+                    pip_deps = dep.get("pip", [])
+                    for pip_dep in pip_deps:
+                        if isinstance(pip_dep, str):
+                            pkg = (
+                                pip_dep.split("==")[0]
+                                .split(">=")[0]
+                                .split("<=")[0]
+                                .split("[")[0]
+                                .strip()
+                            )
+                            if "::" in pkg:
+                                pkg = pkg.split("::", 1)[1]
+                            if pkg:
+                                dependencies.append(pkg)
+        except Exception:
+            pass
+    # Remove duplicates and sort
+    return sorted(list(set(dependencies)))
+
+
+def env_has_superset_dependencies(
+    env: dict,
+    required_deps: list[str],
+    env_spec_path: str | None = None,
+    strict: bool = False,
+) -> bool:
+    """Check if an environment has a superset of required dependencies.
+
+    Parameters
+    ----------
+    env : dict
+        Environment dict from calkit.yaml with 'kind' and 'path' keys.
+    required_deps : list[str]
+        List of required dependencies to check for.
+    env_spec_path : str | None
+        Path to the environment spec file. If None, will use env.get("path").
+    strict : bool
+        If True, require the spec file to exist and have extractable
+        dependencies. If False, be optimistic when spec file doesn't exist.
+
+    Returns
+    -------
+    bool
+        True if the environment contains all required dependencies,
+        False otherwise.
+    """
+    if not required_deps:
+        # No dependencies to check, so any environment works
+        return True
+    if env_spec_path is None:
+        env_spec_path = env.get("path")
+    if not env_spec_path:
+        # No path to check
+        if strict:
+            return False
+        return True
+    if not os.path.exists(env_spec_path):
+        # Spec file doesn't exist
+        if strict:
+            # Strict mode: can't verify, so reject
+            return False
+        # Optimistic mode: assume it might work
+        return True
+    # Extract dependencies from the environment's spec file
+    env_deps = extract_dependencies_from_spec_file(env_spec_path)
+    if not env_deps:
+        # Couldn't extract dependencies (or file is empty)
+        if strict:
+            # Strict mode: can't verify, so reject
+            return False
+        # Optimistic mode: assume it might work
+        return True
+    # Check if env_deps is a superset of required_deps
+    # (case-insensitive comparison for package names)
+    env_deps_lower = {dep.lower() for dep in env_deps}
+    required_deps_lower = {dep.lower() for dep in required_deps}
+    transitive = {
+        "jupyter": {"ipykernel"},
+        "pandas": {"numpy"},
+    }
+    for base, provides in transitive.items():
+        if base in env_deps_lower:
+            env_deps_lower.update(provides)
+    return required_deps_lower.issubset(env_deps_lower)
+
+
 def detect_env_for_stage(
     stage: dict,
     environment: str | None = None,
@@ -1144,8 +1354,74 @@ def detect_env_for_stage(
     is_first_env_for_language = not any(
         env.get("kind") in preferred_kinds for env in envs.values()
     )
-    # 2) If there is already an environment for the stage language, use that
-    if stage_language:
+    # Stages with analyzable content where we should check dependencies before
+    # reusing existing environments
+    analyzable_stages = {
+        "jupyter-notebook",
+        "python-script",
+        "r-script",
+        "julia-script",
+        "shell-script",
+    }
+    # Initialize detected_dependencies so it's available throughout function
+    detected_dependencies: list[str] = []
+    # For analyzable stages, detect dependencies and check if existing
+    # environments satisfy them
+    if stage_language and stage_kind in analyzable_stages:
+        if stage_kind == "python-script":
+            detected_dependencies = detect_python_dependencies(
+                script_path=stage["script_path"]
+            )
+        elif stage_kind == "r-script":
+            detected_dependencies = detect_r_dependencies(
+                script_path=stage["script_path"]
+            )
+        elif stage_kind == "julia-script":
+            detected_dependencies = detect_julia_dependencies(
+                script_path=stage["script_path"]
+            )
+        elif stage_kind == "jupyter-notebook":
+            notebook_lang = language_from_notebook(stage["notebook_path"])
+            detected_dependencies = detect_dependencies_from_notebook(
+                stage["notebook_path"], language=notebook_lang
+            )
+        elif stage_kind == "matlab-script":
+            # MATLAB detection if needed
+            detected_dependencies = []
+        elif stage_kind == "shell-script":
+            # Shell script detection if needed
+            detected_dependencies = []
+
+        # Check if any existing environment has all these dependencies
+        matching_envs = [
+            (name, env)
+            for name, env in envs.items()
+            if env.get("kind") in preferred_kinds
+        ]
+        if matching_envs and detected_dependencies:
+            # Check if any matching environment has all required dependencies
+            # Use strict mode: only reuse if we can verify the deps are satisfied
+            for env_name, env in sorted(
+                matching_envs, key=lambda item: item[0]
+            ):
+                if env_has_superset_dependencies(
+                    env, detected_dependencies, strict=True
+                ):
+                    env_name = cast(str, env_name)
+                    return EnvForStageResult(
+                        name=env_name,
+                        env=env,
+                        exists=True,
+                        spec_path=env.get("path"),
+                        dependencies=detected_dependencies,
+                        created_from_dependencies=False,
+                    )
+            # No existing environment has verified dependencies, fall through to create
+        # If no matching environment found or no dependencies detected,
+        # fall through to create one from dependencies
+    # 2) If there is already an environment for the stage language (for
+    # non-analyzable stages or analyzable stages with no match), use that
+    if stage_language and stage_kind not in analyzable_stages:
         matching_envs = [
             (name, env)
             for name, env in envs.items()
@@ -1172,6 +1448,7 @@ def detect_env_for_stage(
                 created_from_dependencies=False,
             )
     # 3) If a typical env spec exists for the stage language, use that
+    # (fallback for analyzable stages if no existing environment matched)
     if stage_language:
         if stage_language == "latex":
             res = env_from_name_or_path(
@@ -1219,6 +1496,46 @@ def detect_env_for_stage(
                     ck_info=ck_info,
                     language=stage_language,
                 )
+                # For analyzable stages with detected dependencies, verify the
+                # spec file has all required packages before reusing
+                if stage_kind in analyzable_stages:
+                    # Detect dependencies for this stage if not already done
+                    if not detected_dependencies:
+                        if stage_kind == "python-script":
+                            detected_dependencies = detect_python_dependencies(
+                                script_path=stage["script_path"]
+                            )
+                        elif stage_kind == "r-script":
+                            detected_dependencies = detect_r_dependencies(
+                                script_path=stage["script_path"]
+                            )
+                        elif stage_kind == "julia-script":
+                            detected_dependencies = detect_julia_dependencies(
+                                script_path=stage["script_path"]
+                            )
+                        elif stage_kind == "jupyter-notebook":
+                            notebook_lang = language_from_notebook(
+                                stage["notebook_path"]
+                            )
+                            detected_dependencies = (
+                                detect_dependencies_from_notebook(
+                                    stage["notebook_path"],
+                                    language=notebook_lang,
+                                )
+                            )
+                    # Only reuse if it has all the dependencies (strict mode)
+                    if (
+                        detected_dependencies
+                        and not env_has_superset_dependencies(
+                            res.env,
+                            detected_dependencies,
+                            spec_path,
+                            strict=True,
+                        )
+                    ):
+                        # This spec file doesn't have all deps, try next
+                        # candidate
+                        continue
                 return EnvForStageResult(
                     name=res.name,
                     env=res.env,
@@ -1237,6 +1554,7 @@ def detect_env_for_stage(
         dependencies = detect_python_dependencies(
             script_path=stage["script_path"]
         )
+        project_name = calkit.detect_project_name(prepend_owner=False)
         # Generate unique environment name
         if is_first_env_for_language:
             temp_path = "pyproject.toml"
@@ -1248,15 +1566,16 @@ def detect_env_for_stage(
                 "path": spec_path,
             }
         else:
-            temp_path = ".calkit/envs/py/requirements.txt"
-            env_name = make_env_name(temp_path, all_env_names, kind="uv-venv")
-            spec_path = f".calkit/envs/{env_name}/requirements.txt"
-            spec_content = create_python_requirements_content(dependencies)
+            temp_path = ".calkit/envs/py/pyproject.toml"
+            env_name = make_env_name(temp_path, all_env_names, kind="uv")
+            spec_path = f".calkit/envs/{env_name}/pyproject.toml"
+            spec_content = create_uv_pyproject_content(
+                dependencies,
+                project_name=f"{project_name}-{env_name}",
+            )
             env_dict = {
-                "kind": "uv-venv",
+                "kind": "uv",
                 "path": spec_path,
-                "python": DEFAULT_PYTHON_VERSION,
-                "prefix": os.path.join(os.path.dirname(spec_path), ".venv"),
             }
     elif stage["kind"] == "r-script":
         dependencies = detect_r_dependencies(script_path=stage["script_path"])
@@ -1304,6 +1623,7 @@ def detect_env_for_stage(
             stage["notebook_path"], language=notebook_lang
         )
         if notebook_lang == "python" or notebook_lang is None:
+            project_name = calkit.detect_project_name(prepend_owner=False)
             # Add ipykernel for Jupyter notebook support
             if "ipykernel" not in dependencies:
                 dependencies.append("ipykernel")
@@ -1318,19 +1638,16 @@ def detect_env_for_stage(
                     "path": spec_path,
                 }
             else:
-                temp_path = ".calkit/envs/py/requirements.txt"
-                env_name = make_env_name(
-                    temp_path, all_env_names, kind="uv-venv"
+                temp_path = ".calkit/envs/py/pyproject.toml"
+                env_name = make_env_name(temp_path, all_env_names, kind="uv")
+                spec_path = f".calkit/envs/{env_name}/pyproject.toml"
+                spec_content = create_uv_pyproject_content(
+                    dependencies,
+                    project_name=f"{project_name}-{env_name}",
                 )
-                spec_path = f".calkit/envs/{env_name}/requirements.txt"
-                spec_content = create_python_requirements_content(dependencies)
                 env_dict = {
-                    "kind": "uv-venv",
+                    "kind": "uv",
                     "path": spec_path,
-                    "python": DEFAULT_PYTHON_VERSION,
-                    "prefix": os.path.join(
-                        os.path.dirname(spec_path), ".venv"
-                    ),
                 }
         elif notebook_lang == "r":
             # Add IRkernel for Jupyter notebook support
@@ -1354,6 +1671,7 @@ def detect_env_for_stage(
             # Add IJulia for Jupyter notebook support
             if "IJulia" not in dependencies:
                 dependencies.append("IJulia")
+            project_name = calkit.detect_project_name(prepend_owner=False)
             # Generate unique environment name
             if is_first_env_for_language:
                 temp_path = "Project.toml"
@@ -1361,16 +1679,21 @@ def detect_env_for_stage(
                     temp_path, all_env_names, kind="julia"
                 )
                 spec_path = "Project.toml"
+                julia_env_name = project_name
             else:
                 temp_path = ".calkit/envs/julia/Project.toml"
                 env_name = make_env_name(
                     temp_path, all_env_names, kind="julia"
                 )
                 spec_path = f".calkit/envs/{env_name}/Project.toml"
-            spec_content = create_julia_project_file_content(dependencies)
+                julia_env_name = f"{project_name}-{env_name}"
+            spec_content = create_julia_project_file_content(
+                dependencies, project_name=julia_env_name
+            )
             env_dict = {
                 "kind": "julia",
                 "path": spec_path,
+                "julia": _get_julia_version(),
             }
     if not spec_path or not env_name:
         raise ValueError(

{calkit_python-0.34.1 → calkit_python-0.34.2}/calkit/jupyterlab/routes.py

@@ -389,11 +389,13 @@ class NotebookKernelRouteHandler(APIHandler):
                 400, "Both 'path' and 'environment' are required"
             )
         try:
-            kernel_name = check_env_kernel(env_name=env_name)
+            kernel_name, display_name = check_env_kernel(env_name=env_name)
         except Exception as e:
             self.log.error(f"Failed to check env kernel for {env_name}: {e}")
             return self.error(500, f"Failed to check environment kernel: {e}")
-        self.finish(json.dumps({"name": kernel_name}))
+        self.finish(
+            json.dumps({"name": kernel_name, "display_name": display_name})
+        )
 
 
 class NotebookStageRouteHandler(APIHandler):
@@ -412,7 +414,11 @@ class NotebookStageRouteHandler(APIHandler):
         executed_ipynb_storage = body.get("executed_ipynb_storage", "git")
         if not notebook_path or not stage_name or not env_name:
             return self.error(
-                400, "Request body must include 'path' and 'stage_name'"
+                400,
+                (
+                    "Request body must include 'path', 'stage_name', and "
+                    "'environment'"
+                ),
             )
         ck_info = calkit.load_calkit_info()
         stages = ck_info.get("pipeline", {}).get("stages", {})

{calkit_python-0.34.1 → calkit_python-0.34.2}/calkit/models/pipeline.py

@@ -431,7 +431,7 @@ class MatlabScriptStage(Stage):
     def dvc_cmd(self) -> str:
         cmd = self.xenv_cmd
         if self.environment == "_system":
-            cmd += "matlab -batch"
+            cmd += "matlab -noFigureWindows -batch"
         matlab_cmd = ""
         if self.matlab_path is not None:
             matlab_cmd += f"addpath(genpath('{self.matlab_path}')); "
@@ -450,7 +450,7 @@ class MatlabCommandStage(Stage):
         matlab_cmd = self.command.replace('"', '\\"')
         cmd = self.xenv_cmd
         if self.environment == "_system":
-            cmd += "matlab -batch"
+            cmd += "matlab -noFigureWindows -batch"
         cmd += f' "{matlab_cmd}"'
         return cmd