diff --git a/crates/pet-core/src/python_environment.rs b/crates/pet-core/src/python_environment.rs index 095de101..eb144581 100644 --- a/crates/pet-core/src/python_environment.rs +++ b/crates/pet-core/src/python_environment.rs @@ -67,10 +67,6 @@ pub struct PythonEnvironment { // Some of the known symlinks for the environment. // E.g. in the case of Homebrew there are a number of symlinks that are created. pub symlinks: Option>, - /// The folder/path that was searched to find this environment. - /// Generally applies to workspace folder, and means that the environment was found in this folder or is related to this folder. - /// Similar in meaqning to `project` but is more of a search path. - pub search_path: Option, } impl Ord for PythonEnvironment { @@ -146,9 +142,6 @@ impl std::fmt::Display for PythonEnvironment { if let Some(project) = &self.project { writeln!(f, " Project : {}", project.to_str().unwrap()).unwrap_or_default(); } - if let Some(search_path) = &self.search_path { - writeln!(f, " Search Path : {}", search_path.to_str().unwrap()).unwrap_or_default(); - } if let Some(arch) = &self.arch { writeln!(f, " Architecture: {arch}").unwrap_or_default(); } @@ -198,7 +191,6 @@ pub struct PythonEnvironmentBuilder { project: Option, arch: Option, symlinks: Option>, - search_path: Option, } impl PythonEnvironmentBuilder { @@ -214,7 +206,6 @@ impl PythonEnvironmentBuilder { project: None, arch: None, symlinks: None, - search_path: None, } } @@ -277,11 +268,6 @@ impl PythonEnvironmentBuilder { self } - pub fn search_path(mut self, search_path: Option) -> Self { - self.search_path = search_path; - self - } - fn update_symlinks_and_exe(&mut self, symlinks: Option>) { let mut all = vec![]; if let Some(ref exe) = self.executable { @@ -336,7 +322,6 @@ impl PythonEnvironmentBuilder { manager: self.manager, project: self.project, arch: self.arch, - search_path: self.search_path, symlinks, } } diff --git a/crates/pet/src/find.rs b/crates/pet/src/find.rs index 8af41ff6..b998efe2 100644 --- a/crates/pet/src/find.rs +++ b/crates/pet/src/find.rs @@ -87,7 +87,6 @@ pub fn find_and_report_envs( locators, false, &global_env_search_paths, - None, ); summary.lock().unwrap().find_path_time = start.elapsed(); }); @@ -117,7 +116,6 @@ pub fn find_and_report_envs( locators, false, &global_env_search_paths, - None, ); summary.lock().unwrap().find_global_virtual_envs_time = start.elapsed(); }); @@ -173,7 +171,6 @@ fn find_python_environments_in_workspace_folders_recursive( reporter, true, &[], - Some(workspace_folder.clone()), ); // If this is a virtual env folder, no need to scan this. @@ -189,14 +186,7 @@ fn find_python_environments_in_workspace_folders_recursive( .filter(should_search_for_environments_in_path) .filter(|p| !paths_to_search_first.contains(p)) { - find_python_environments( - vec![folder], - reporter, - locators, - true, - &[], - Some(workspace_folder.clone()), - ); + find_python_environments(vec![folder], reporter, locators, true, &[]); } } } @@ -210,7 +200,6 @@ fn find_python_environments( locators: &Arc>>, is_workspace_folder: bool, global_env_search_paths: &[PathBuf], - search_path: Option, ) { if paths.is_empty() { return; @@ -218,7 +207,6 @@ fn find_python_environments( thread::scope(|s| { for item in paths { let locators = locators.clone(); - let search_path = search_path.clone(); s.spawn(move || { find_python_environments_in_paths_with_locators( vec![item], @@ -226,7 +214,6 @@ fn find_python_environments( reporter, is_workspace_folder, global_env_search_paths, - search_path, ); }); } @@ -239,7 +226,6 @@ fn find_python_environments_in_paths_with_locators( reporter: &dyn Reporter, is_workspace_folder: bool, global_env_search_paths: &[PathBuf], - search_path: Option, ) { for path in paths { let executables = if is_workspace_folder { @@ -275,7 +261,6 @@ fn find_python_environments_in_paths_with_locators( locators, reporter, global_env_search_paths, - search_path.clone(), ); } } @@ -285,17 +270,13 @@ fn identify_python_executables_using_locators( locators: &Arc>>, reporter: &dyn Reporter, global_env_search_paths: &[PathBuf], - search_path: Option, ) { for exe in executables.into_iter() { let executable = exe.clone(); let env = PythonEnv::new(exe.to_owned(), None, None); - if let Some(env) = identify_python_environment_using_locators( - &env, - locators, - global_env_search_paths, - search_path.clone(), - ) { + if let Some(env) = + identify_python_environment_using_locators(&env, locators, global_env_search_paths) + { reporter.report_environment(&env); if let Some(manager) = env.manager { reporter.report_manager(&manager); diff --git a/crates/pet/src/jsonrpc.rs b/crates/pet/src/jsonrpc.rs index 4c1ca541..2283e999 100644 --- a/crates/pet/src/jsonrpc.rs +++ b/crates/pet/src/jsonrpc.rs @@ -202,24 +202,14 @@ pub fn handle_resolve(context: Arc, id: u32, params: Value) { match serde_json::from_value::(params.clone()) { Ok(request_options) => { let executable = request_options.executable.clone(); - let search_paths = context - .configuration - .read() - .unwrap() - .clone() - .workspace_directories; - let search_paths = search_paths.unwrap_or_default(); // Start in a new thread, we can have multiple resolve requests. let environment = context.os_environment.clone(); thread::spawn(move || { let now = SystemTime::now(); trace!("Resolving env {:?}", executable); - if let Some(result) = resolve_environment( - &executable, - &context.locators, - search_paths, - environment.deref(), - ) { + if let Some(result) = + resolve_environment(&executable, &context.locators, environment.deref()) + { if let Some(resolved) = result.resolved { // Gather telemetry of this resolved env and see what we got wrong. let _ = report_inaccuracies_identified_after_resolving( diff --git a/crates/pet/src/locators.rs b/crates/pet/src/locators.rs index e683af0d..8b410847 100644 --- a/crates/pet/src/locators.rs +++ b/crates/pet/src/locators.rs @@ -89,21 +89,12 @@ pub fn identify_python_environment_using_locators( env: &PythonEnv, locators: &[Arc], global_env_search_paths: &[PathBuf], - search_path: Option, ) -> Option { let executable = env.executable.clone(); - let search_paths = if let Some(search_path) = search_path { - vec![search_path] - } else { - vec![] - }; - if let Some(mut env) = - locators.iter().fold( - None, - |e, loc| if e.is_some() { e } else { loc.try_from(env) }, - ) - { - identify_and_set_search_path(&mut env, &search_paths); + if let Some(env) = locators.iter().fold( + None, + |e, loc| if e.is_some() { e } else { loc.try_from(env) }, + ) { return Some(env); } @@ -112,14 +103,13 @@ pub fn identify_python_environment_using_locators( // We try to get the interpreter info, hoping that the real exe returned might be identifiable. if let Some(resolved_env) = ResolvedPythonEnv::from(&executable) { let env = resolved_env.to_python_env(); - if let Some(mut env) = + if let Some(env) = locators.iter().fold( None, |e, loc| if e.is_some() { e } else { loc.try_from(&env) }, ) { trace!("Env ({:?}) in Path resolved as {:?}", executable, env.kind); - identify_and_set_search_path(&mut env, &search_paths); // TODO: Telemetry point. // As we had to spawn earlier. return Some(env); @@ -147,42 +137,12 @@ pub fn identify_python_environment_using_locators( "Env ({:?}) in Path resolved as {:?} and reported as {:?}", executable, resolved_env, fallback_kind ); - let mut env = create_unknown_env(resolved_env, fallback_kind); - identify_and_set_search_path(&mut env, &search_paths); - return Some(env); + return Some(create_unknown_env(resolved_env, fallback_kind)); } } None } -/// Assume we found a .venv environment, generally these are specific to a workspace folder, i.e. they belong in a worksapce folder. -/// If thats the case then verify this by checking if the workspace folder is a parent of the prefix (.venv folder). -/// If it is, and there is not project set, then set the search_path to the workspace folder. -pub fn identify_and_set_search_path(env: &mut PythonEnvironment, search_path: &Vec) { - if search_path.is_empty() || env.project.is_some() { - return; - } - - // All other environments generally need to be found globally, - // If we end up with some env thats not found globally, but only found in a special folder for some reason, - // then thats a weird situation, either way, when we cache the result it will re-appear (however for all other workspaces as well) - // Thats fine for now (if users complain then we'll find out that there's a problem and we can fix it then). - // Else no need to try and identify/fix edge cases that may not exist. - if env.kind == Some(PythonEnvironmentKind::Conda) - || env.kind == Some(PythonEnvironmentKind::Venv) - || env.kind == Some(PythonEnvironmentKind::VirtualEnv) - { - if let Some(prefix) = &env.prefix { - for path in search_path { - if path.starts_with(prefix) { - env.search_path = Some(path.clone()); - break; - } - } - } - } -} - fn create_unknown_env( resolved_env: ResolvedPythonEnv, fallback_category: Option, diff --git a/crates/pet/src/resolve.rs b/crates/pet/src/resolve.rs index d3f0c477..93aefe4f 100644 --- a/crates/pet/src/resolve.rs +++ b/crates/pet/src/resolve.rs @@ -13,7 +13,7 @@ use pet_core::{ use pet_env_var_path::get_search_paths_from_env_variables; use pet_python_utils::env::{PythonEnv, ResolvedPythonEnv}; -use crate::locators::{identify_and_set_search_path, identify_python_environment_using_locators}; +use crate::locators::identify_python_environment_using_locators; #[derive(Debug)] pub struct ResolvedEnvironment { @@ -24,17 +24,15 @@ pub struct ResolvedEnvironment { pub fn resolve_environment( executable: &PathBuf, locators: &Arc>>, - search_paths: Vec, os_environment: &dyn Environment, ) -> Option { // First check if this is a known environment let env = PythonEnv::new(executable.to_owned(), None, None); let global_env_search_paths: Vec = get_search_paths_from_env_variables(os_environment); - if let Some(mut env) = - identify_python_environment_using_locators(&env, locators, &global_env_search_paths, None) + if let Some(env) = + identify_python_environment_using_locators(&env, locators, &global_env_search_paths) { - identify_and_set_search_path(&mut env, &search_paths); // Ok we got the environment. // Now try to resolve this fully, by spawning python. if let Some(ref executable) = env.executable { @@ -67,7 +65,6 @@ pub fn resolve_environment( .name(env.name) .prefix(prefix) .project(env.project) - .search_path(env.search_path) .symlinks(Some(symlinks)) .version(version) .build(); diff --git a/crates/pet/tests/ci_test.rs b/crates/pet/tests/ci_test.rs index 59952053..51c0a174 100644 --- a/crates/pet/tests/ci_test.rs +++ b/crates/pet/tests/ci_test.rs @@ -355,13 +355,12 @@ fn verify_we_can_get_same_env_info_using_from_with_exe( get_search_paths_from_env_variables(&os_environment); let env = PythonEnv::new(executable.clone(), None, None); - let resolved = identify_python_environment_using_locators( - &env, - &locators, - &global_env_search_paths, - Some(workspace_dir.clone()), - ) - .expect(format!("Failed to resolve environment using `resolve` for {environment:?}").as_str()); + let resolved = + identify_python_environment_using_locators(&env, &locators, &global_env_search_paths) + .expect( + format!("Failed to resolve environment using `resolve` for {environment:?}") + .as_str(), + ); trace!( "For exe {:?} we got Environment = {:?}, To compare against {:?}", executable, @@ -543,13 +542,9 @@ fn verify_we_can_get_same_env_info_using_resolve_with_exe( locator.configure(&config); } - let env = resolve_environment( - &executable, - &locators, - vec![workspace_dir.clone()], - &os_environment, - ) - .expect(format!("Failed to resolve environment using `resolve` for {environment:?}").as_str()); + let env = resolve_environment(&executable, &locators, &os_environment).expect( + format!("Failed to resolve environment using `resolve` for {environment:?}").as_str(), + ); trace!( "For exe {:?} we got Environment = {:?}, To compare against {:?}", executable,