reimplement idf_tools.py install-python-env

Author: Hahihula

src-tauri/src/cli/wizard.rs

@@ -132,7 +132,7 @@ async fn download_tools(
             })
         };
 
-        match idf_im_lib::download_file(&download_link.url, destination_path, progress_tx).await {
+        match idf_im_lib::download_file(&download_link.url, destination_path, Some(progress_tx)).await {
             Ok(_) => {
                 downloaded_tools.push(filename.to_string());
                 progress_bar.finish();
@@ -577,29 +577,24 @@ pub async fn run_wizzard_run(mut config: Settings) -> Result<(), String> {
             &tool_install_directory,
         )
         .await?;
-        let parent_tools = tool_install_directory.parent().unwrap();
-        let env_vars =
-            idf_im_lib::setup_environment_variables(&parent_tools.to_path_buf(), &idf_path)?;
-        let real_env_vars = idf_im_lib::setup_environment_variables(
-            &tool_install_directory.to_path_buf(),
-            &idf_path,
-        )?;
-        let idf_tools_path = get_and_validate_idf_tools_path(&mut config, &idf_path)?;
-        if config.idf_features.is_some() {
-            let features = config.idf_features.clone().unwrap();
-            idf_im_lib::python_utils::run_idf_tools_py_with_features(
-                idf_tools_path.to_str().unwrap(),
-                &env_vars,
-                &real_env_vars,
-                &features,
-            )?;
-        } else {
-            idf_im_lib::python_utils::run_idf_tools_py(
-                idf_tools_path.to_str().unwrap(),
-                &env_vars,
-                &real_env_vars,
-            )?;
-        }
+        match idf_im_lib::python_utils::install_python_env(
+          &idf_version,
+          &tool_install_directory,
+          true, //TODO: actually read from config
+          &idf_path,
+          &config.idf_features.clone().unwrap_or_default(),
+        ).await {
+            Ok(_) => {
+                info!("Python environment installed");
+            }
+            Err(err) => {
+                error!("Failed to install Python environment: {}", err);
+                return Err(err.to_string());
+            }
+        };
+        let idf_python_env_path = tool_install_directory.join("python").join(&idf_version).join("venv"); //todo: move to config
+        ensure_path(idf_python_env_path.to_str().unwrap())
+            .map_err(|err| format!("Failed to create Python environment directory: {}", err))?;
 
         let export_paths = idf_im_lib::idf_tools::get_tools_export_paths(
             tools,
@@ -615,13 +610,13 @@ pub async fn run_wizzard_run(mut config: Settings) -> Result<(), String> {
             }
         })
         .collect();
-
         idf_im_lib::single_version_post_install(
             version_instalation_path.to_str().unwrap(),
             idf_path.to_str().unwrap(),
             &idf_version,
             tool_install_directory.to_str().unwrap(),
             export_paths,
+            idf_python_env_path.to_str(),
         )
     }
     save_config_if_desired(&config)?;

src-tauri/src/gui/commands/idf_tools.rs

@@ -95,6 +95,7 @@ pub async fn setup_tools(
   app_handle: &AppHandle,
   settings: &Settings,
   idf_path: &PathBuf,
+  idf_version: &str,
 ) -> Result<Vec<String>> {
   info!("Setting up tools...");
 
@@ -173,19 +174,31 @@ pub async fn setup_tools(
       return Err(anyhow!("Failed to setup environment variables: IDF tools path does not exist"));
   }
 
-  // Run IDF tools Python script
-  run_idf_tools_py(
-      idf_tools_path.to_str().unwrap(),
-      &env_vars_install,
-      &env_vars_python
-  ).map_err(|e| {
-      send_message(
+  match idf_im_lib::python_utils::install_python_env(
+    &idf_version,
+    &tools_install_folder,
+    true, //TODO: actually read from config
+    &idf_path,
+    &settings.idf_features.clone().unwrap_or_default(),
+  ).await {
+      Ok(_) => {
+        info!("Python environment installed");
+        send_message(
           app_handle,
-          format!("Failed to run IDF tools setup: {}", e),
-          "error".to_string(),
-      );
-      anyhow!("Failed to run IDF tools setup: {}", e)
-  })?;
+          "Python environment installed successfully".to_string(),
+          "info".to_string(),
+        );
+      }
+      Err(err) => {
+          error!("Failed to install Python environment: {}", err);
+          send_message(
+            app_handle,
+            "Failed to install Python environment".to_string(),
+            "error".to_string(),
+          );
+          return Err(anyhow!("Failed to install Python environment: {}", err));
+      }
+  };
 
   send_message(
       app_handle,
@@ -259,7 +272,7 @@ async fn process_tool_download(
 
   // Download file
   info!("Downloading {} to: {}", tool_name, full_path_str);
-  match download_file(&download.url, &tool_setup.download_dir, progress_tx).await {
+  match download_file(&download.url, &tool_setup.download_dir, Some(progress_tx)).await {
       Ok(_) => {
           send_tools_message(app_handle, filename.to_string(), "downloaded".to_string());
           send_message(

src-tauri/src/gui/commands/installation.rs

@@ -148,7 +148,7 @@ async fn install_single_version(
 
   download_idf(&app_handle, settings, &version, &idf_path).await?;
 
-  let export_vars = setup_tools(&app_handle, settings, &idf_path).await?;
+  let export_vars = setup_tools(&app_handle, settings, &idf_path, &version).await?;
 
   let tools_install_path = version_path.clone().join(
       settings
@@ -157,12 +157,14 @@ async fn install_single_version(
           .unwrap_or_default(),
   );
 
+  let idf_python_env_path = tools_install_path.clone().join("python").join(&version).join("venv");
   idf_im_lib::single_version_post_install(
       version_path.to_str().unwrap(),
       idf_path.to_str().unwrap(),
       &version,
       tools_install_path.to_str().unwrap(),
       export_vars,
+      Some(idf_python_env_path.to_str().unwrap()),
   );
 
   Ok(())

src-tauri/src/gui/mod.rs

@@ -211,19 +211,21 @@ async fn install_single_version(
     let version_path = prepare_installation_directories(app_handle.clone(), settings, &version)?;
     let idf_path = version_path.clone().join("esp-idf");
     download_idf(&app_handle, settings, &version, &idf_path).await?;
-    let export_vars = setup_tools(&app_handle, settings, &idf_path).await?;
+    let export_vars = setup_tools(&app_handle, settings, &idf_path, &version).await?;
     let tools_install_path = version_path.clone().join(
         settings
             .tool_install_folder_name
             .clone()
             .unwrap_or_default(),
     );
+    let idf_python_env_path = tools_install_path.clone().join("python").join(&version).join("venv");
     idf_im_lib::single_version_post_install(
         version_path.to_str().unwrap(),
         idf_path.to_str().unwrap(),
         &version,
         tools_install_path.to_str().unwrap(),
         export_vars,
+        Some(idf_python_env_path.to_str().unwrap()),
     );
 
     Ok(())