fix: only attempt ollama pull if model is not already local

This also refactors the pip_install_if_needed() logic out of the run module and into the pull module.

Signed-off-by: Nick Mitchell <[email protected]>

Author: starpit

pdl-live-react/src-tauri/src/cli/run.rs

@@ -1,75 +1,10 @@
-use ::file_diff::diff;
-use ::std::fs::{copy, create_dir_all};
-use ::std::path::{Path, PathBuf};
+use ::std::path::Path;
 use duct::cmd;
 use futures::executor::block_on;
 use yaml_rust2::yaml::LoadError;
 
-use tauri::path::BaseDirectory;
-use tauri::Manager;
-
-use crate::interpreter::load;
-
-#[cfg(desktop)]
-async fn pip_install_if_needed(app_handle: tauri::AppHandle) -> Result<PathBuf, tauri::Error> {
-    let cache_path = app_handle.path().cache_dir()?.join("pdl");
-
-    create_dir_all(&cache_path)?;
-    let venv_path = cache_path.join("interpreter-python");
-    let activate_path = if cfg!(windows) {
-        venv_path.join("Scripts").join("Activate.ps1")
-    } else {
-        venv_path.join("bin/activate")
-    };
-    let cached_requirements_path = venv_path
-        .join("requirements.txt")
-        .into_os_string()
-        .into_string()
-        .unwrap();
-    /* println!(
-        "RUN PATHS activate={:?} cached_reqs={:?}",
-        activate_path, cached_requirements_path
-    ); */
-
-    if !venv_path.exists() {
-        println!("Creating virtual environment...");
-        let python = if cfg!(target_os = "macos") {
-            "python3.12"
-        } else {
-            "python3"
-        };
-        cmd!(python, "-mvenv", &venv_path).run()?;
-    }
-
-    let requirements_path = app_handle
-        .path()
-        .resolve("interpreter/requirements.txt", BaseDirectory::Resource)?
-        .into_os_string()
-        .into_string()
-        .unwrap();
-
-    if !diff(
-        requirements_path.as_str(),
-        cached_requirements_path.as_str(),
-    ) {
-        cmd!(
-            venv_path
-                .join(if cfg!(windows) { "Scripts" } else { "bin" })
-                .join("pip"),
-            "install",
-            "-r",
-            &requirements_path,
-        )
-        .run()?;
-
-        copy(requirements_path, cached_requirements_path)?;
-    }
-
-    match activate_path.parent() {
-        Some(parent) => Ok(parent.to_path_buf()),
-        _ => Err(tauri::Error::UnknownPath),
-    }
-}
+use crate::interpreter::pip::pip_install_if_needed;
+use crate::interpreter::pull::pull_if_needed;
 
 #[cfg(desktop)]
 pub fn run_pdl_program(
@@ -84,7 +19,7 @@ pub fn run_pdl_program(
         Path::new(&source_file_path).file_name().unwrap()
     );
 
-    let pull_future = load::pull_if_needed(&source_file_path);
+    let pull_future = pull_if_needed(&source_file_path);
     let bin_path_future = pip_install_if_needed(app_handle);
 
     let trace_arg = if let Some(arg) = trace_file {

pdl-live-react/src-tauri/src/interpreter/mod.rs

@@ -1 +1,2 @@
-pub mod load;
+pub mod pip;
+pub mod pull;

pdl-live-react/src-tauri/src/interpreter/pip.rs

@@ -0,0 +1,68 @@
+use ::std::fs::{copy, create_dir_all};
+use ::std::path::PathBuf;
+
+use duct::cmd;
+use file_diff::diff;
+use tauri::path::BaseDirectory;
+use tauri::Manager;
+
+#[cfg(desktop)]
+pub async fn pip_install_if_needed(app_handle: tauri::AppHandle) -> Result<PathBuf, tauri::Error> {
+    let cache_path = app_handle.path().cache_dir()?.join("pdl");
+
+    create_dir_all(&cache_path)?;
+    let venv_path = cache_path.join("interpreter-python");
+    let activate_path = if cfg!(windows) {
+        venv_path.join("Scripts").join("Activate.ps1")
+    } else {
+        venv_path.join("bin/activate")
+    };
+    let cached_requirements_path = venv_path
+        .join("requirements.txt")
+        .into_os_string()
+        .into_string()
+        .unwrap();
+    /* println!(
+        "RUN PATHS activate={:?} cached_reqs={:?}",
+        activate_path, cached_requirements_path
+    ); */
+
+    if !venv_path.exists() {
+        println!("Creating virtual environment...");
+        let python = if cfg!(target_os = "macos") {
+            "python3.12"
+        } else {
+            "python3"
+        };
+        cmd!(python, "-mvenv", &venv_path).run()?;
+    }
+
+    let requirements_path = app_handle
+        .path()
+        .resolve("interpreter/requirements.txt", BaseDirectory::Resource)?
+        .into_os_string()
+        .into_string()
+        .unwrap();
+
+    if !diff(
+        requirements_path.as_str(),
+        cached_requirements_path.as_str(),
+    ) {
+        cmd!(
+            venv_path
+                .join(if cfg!(windows) { "Scripts" } else { "bin" })
+                .join("pip"),
+            "install",
+            "-r",
+            &requirements_path,
+        )
+        .run()?;
+
+        copy(requirements_path, cached_requirements_path)?;
+    }
+
+    match activate_path.parent() {
+        Some(parent) => Ok(parent.to_path_buf()),
+        _ => Err(tauri::Error::UnknownPath),
+    }
+}

pdl-live-react/src-tauri/src/interpreter/load.rs renamed to pdl-live-react/src-tauri/src/interpreter/pull.rs

@@ -61,8 +61,8 @@ pub async fn pull_if_needed(path: &String) -> Result<(), LoadError> {
     models
         .into_par_iter()
         .try_for_each(|model| match model {
-            m if model.starts_with("ollama/") => ollama_pull(&m[7..]),
-            m if model.starts_with("ollama_chat/") => ollama_pull(&m[12..]),
+            m if model.starts_with("ollama/") => ollama_pull_if_needed(&m[7..]),
+            m if model.starts_with("ollama_chat/") => ollama_pull_if_needed(&m[12..]),
             _ => {
                 eprintln!("Skipping model pull for {}", model);
                 Ok(())
@@ -73,8 +73,21 @@ pub async fn pull_if_needed(path: &String) -> Result<(), LoadError> {
     Ok(())
 }
 
+fn ollama_exists(model: &str) -> bool {
+    match cmd!("ollama", "show", model)
+        .stdout_null()
+        .stderr_null()
+        .run()
+    {
+        Ok(_output) => true,
+        _ => false,
+    }
+}
+
 /// The Ollama implementation of a single model pull
-fn ollama_pull(model: &str) -> Result<(), LoadError> {
-    cmd!("ollama", "pull", model).run().map_err(LoadError::IO)?;
+fn ollama_pull_if_needed(model: &str) -> Result<(), LoadError> {
+    if !ollama_exists(model) {
+        cmd!("ollama", "pull", model).run().map_err(LoadError::IO)?;
+    }
     Ok(())
 }