rdkit2ase/utils.py (1)

226-256: Make Julia detection robust: support custom Julia path, handle not-found/timeout, and parse output safely

• Hardcodes "julia" and misses a way to pass a custom interpreter path (PR objective).
• Missing handling for FileNotFoundError/TimeoutExpired; current except only catches CalledProcessError.
• Parsing with split()[2] is brittle across Pkg.status formats; prefer a regex.
• Deduplicate/clarify the repeated long error message; include the interpreter path used.

Apply this diff within the function:

-def get_packmol_julia_version() -> str:
+def get_packmol_julia_version(julia: str | None = None, timeout: float = 30.0) -> str:
@@
-    try:
-        result = subprocess.run(
-            ["julia", "-e", 'import Pkg; Pkg.status("Packmol")'],
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        for line in result.stdout.splitlines():
-            if "Packmol" in line:
-                parts = line.split()
-                if len(parts) >= 3:
-                    return parts[2]
-        raise RuntimeError(
-            "Failed to get Packmol version via Julia. Please verify that you can"
-            ' import packmol via `julia -e "import Pkg; Pkg.status("Packmol")"`'
-        )
-
-    except subprocess.CalledProcessError as e:
-        raise RuntimeError(
-            "Failed to get Packmol version via Julia. Please verify that you can"
-            ' import packmol via `julia -e "import Pkg; Pkg.status("Packmol")"`'
-        ) from e
+    import os, re, shutil
+    cmd = julia or os.environ.get("JULIA", "julia")
+    resolved = shutil.which(cmd) or cmd  # allow absolute/custom paths
+    try:
+        result = subprocess.run(
+            [resolved, "-e", 'import Pkg; Pkg.status("Packmol")'],
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=timeout,
+        )
+    except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired) as e:
+        raise RuntimeError(
+            f"Failed to get Packmol version via Julia at '{cmd}'. "
+            "Ensure Julia is installed and Packmol.jl is available. "
+            "Try: julia -e 'import Pkg; Pkg.status(\"Packmol\")'."
+        ) from e
+    for line in result.stdout.splitlines():
+        m = re.search(r"\bPackmol\b[^\n]*\b(v?\d+\.\d+\.\d+(?:[+-].+)?)", line)
+        if m:
+            ver = m.group(1)
+            return ver if ver.startswith("v") else f"v{ver}"
+    raise RuntimeError(
+        "Could not parse Packmol version from Julia Pkg.status output. "
+        "Run locally: julia -e 'import Pkg; Pkg.status(\"Packmol\")'."
+    )

If needed outside this hunk, I can add imports/constants to the module.

rdkit2ase/pack.py (2)

63-88: Remove shell=True, pass stdin explicitly, and support custom Julia path

• shell=True with user-provided executables is avoidable; pass argv list + stdin for Packmol.
• Support a custom Julia path by threading it through to get_packmol_julia_version and the run command (PR objective).

Apply this diff:

-def _run_packmol(
-    packmol_executable: str,
-    input_file: pathlib.Path,
-    tmpdir: pathlib.Path,
-    verbose: bool,
-) -> None:
+def _run_packmol(
+    packmol_executable: str,
+    input_file: pathlib.Path,
+    tmpdir: pathlib.Path,
+    verbose: bool,
+    julia: str | None = None,
+) -> None:
@@
-    if packmol_executable == "packmol.jl":
-        version = get_packmol_julia_version()
+    if packmol_executable == "packmol.jl":
+        version = get_packmol_julia_version(julia=julia)
         if verbose:
             print(f"Using Packmol version {version} via Julia")
         with open(tmpdir / "pack.jl", "w") as f:
             f.write("using Packmol \n")
             f.write(f'run_packmol("{input_file.name}") \n')
-        command = f"julia {tmpdir / 'pack.jl'}"
+        command = [(julia or "julia"), str(tmpdir / "pack.jl")]
     else:
-        command = f"{packmol_executable} < {input_file.name}"
+        command = [packmol_executable]
 
-    subprocess.run(
-        command,
-        cwd=tmpdir,
-        shell=True,
-        check=True,
-        capture_output=not verbose,
-    )
+    if packmol_executable == "packmol.jl":
+        subprocess.run(
+            command,
+            cwd=tmpdir,
+            shell=False,
+            check=True,
+            capture_output=not verbose,
+        )
+    else:
+        with open(input_file, "rb") as fin:
+            subprocess.run(
+                command,
+                cwd=tmpdir,
+                shell=False,
+                check=True,
+                capture_output=not verbose,
+                stdin=fin,
+            )

---

152-162: Expose a julia parameter on pack() and thread it through

Allows callers to pass a custom Julia interpreter path (PR objective).

Apply this diff:

 def pack(
     data: list[list[ase.Atoms]],
     counts: list[int],
     density: float,
     seed: int = 42,
     tolerance: float = 2,
     verbose: bool = False,
     packmol: str = "packmol",
     pbc: bool = True,
-    output_format: FORMAT = "pdb",
+    output_format: FORMAT = "pdb",
+    julia: str | None = None,
 ) -> ase.Atoms:

And thread it to the runner:

-        _run_packmol(packmol, tmpdir / "pack.inp", tmpdir, verbose)
+        _run_packmol(packmol, tmpdir / "pack.inp", tmpdir, verbose, julia=julia)