use anyhow::{Context as _, ensure};use anyhow::{Result, anyhow};use async_trait::async_trait;use collections::HashMap;use futures::AsyncBufReadExt;use gpui::{App, Task};use gpui::{AsyncApp, SharedString};use language::Toolchain;use language::ToolchainList;use language::ToolchainLister;use language::language_settings::language_settings;use language::{ContextLocation, LanguageToolchainStore};use language::{ContextProvider, LspAdapter, LspAdapterDelegate};use language::{LanguageName, ManifestName, ManifestProvider, ManifestQuery};use lsp::LanguageServerBinary;use lsp::LanguageServerName;use node_runtime::{NodeRuntime, VersionStrategy};use pet_core::Configuration;use pet_core::os_environment::Environment;use pet_core::python_environment::PythonEnvironmentKind;use project::Fs;use project::lsp_store::language_server_settings;use serde_json::{Value, json};use smol::lock::OnceCell;use std::cmp::Ordering; use parking_lot::Mutex;use std::str::FromStr;use std::{ any::Any, borrow::Cow, ffi::OsString, fmt::Write, path::{Path, PathBuf}, sync::Arc,};use task::{ShellKind, TaskTemplate, TaskTemplates, VariableName};use util::ResultExt; pub(crate) struct PyprojectTomlManifestProvider; impl ManifestProvider for PyprojectTomlManifestProvider { fn name(&self) -> ManifestName { SharedString::new_static("pyproject.toml").into() } fn search( &self, ManifestQuery { path, depth, delegate, }: ManifestQuery, ) -> Option<Arc<Path>> { for path in path.ancestors().take(depth) { let p = path.join("pyproject.toml"); if delegate.exists(&p, Some(false)) { return Some(path.into()); } } None }} const SERVER_PATH: &str = "node_modules/pyright/langserver.index.js";const NODE_MODULE_RELATIVE_SERVER_PATH: &str = "pyright/langserver.index.js"; enum TestRunner { UNITTEST, PYTEST,} impl FromStr for TestRunner { type Err = (); fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { match s { "unittest" => Ok(Self::UNITTEST), "pytest" => Ok(Self::PYTEST), _ => Err(()), } }} fn server_binary_arguments(server_path: &Path) -> Vec<OsString> { vec![server_path.into(), "--stdio".into()]} pub struct PythonLspAdapter { node: NodeRuntime,} impl PythonLspAdapter { const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("pyright"); pub fn new(node: NodeRuntime) -> Self { PythonLspAdapter { node } }} #[async_trait(?Send)]impl LspAdapter for PythonLspAdapter { fn name(&self) -> LanguageServerName { Self::SERVER_NAME } async fn initialization_options( self: Arc<Self>, _: &dyn Fs, _: &Arc<dyn LspAdapterDelegate>, ) -> Result<Option<Value>> { // Provide minimal initialization options // Virtual environment configuration will be handled through workspace configuration Ok(Some(json!({ "python": { "analysis": { "autoSearchPaths": true, "useLibraryCodeForTypes": true, "autoImportCompletions": true } } }))) } async fn check_if_user_installed( &self, delegate: &dyn LspAdapterDelegate, _: Option<Toolchain>, _: &AsyncApp, ) -> Option<LanguageServerBinary> { if let Some(pyright_bin) = delegate.which("pyright-langserver".as_ref()).await { let env = delegate.shell_env().await; Some(LanguageServerBinary { path: pyright_bin, env: Some(env), arguments: vec!["--stdio".into()], }) } else { let node = delegate.which("node".as_ref()).await?; let (node_modules_path, _) = delegate .npm_package_installed_version(Self::SERVER_NAME.as_ref()) .await .log_err()??; let path = node_modules_path.join(NODE_MODULE_RELATIVE_SERVER_PATH); let env = delegate.shell_env().await; Some(LanguageServerBinary { path: node, env: Some(env), arguments: server_binary_arguments(&path), }) } } async fn fetch_latest_server_version( &self, _: &dyn LspAdapterDelegate, ) -> Result<Box<dyn 'static + Any + Send>> { Ok(Box::new( self.node .npm_package_latest_version(Self::SERVER_NAME.as_ref()) .await?, ) as Box<_>) } async fn fetch_server_binary( &self, latest_version: Box<dyn 'static + Send + Any>, container_dir: PathBuf, delegate: &dyn LspAdapterDelegate, ) -> Result<LanguageServerBinary> { let latest_version = latest_version.downcast::<String>().unwrap(); let server_path = container_dir.join(SERVER_PATH); self.node .npm_install_packages( &container_dir, &[(Self::SERVER_NAME.as_ref(), latest_version.as_str())], ) .await?; let env = delegate.shell_env().await; Ok(LanguageServerBinary { path: self.node.binary_path().await?, env: Some(env), arguments: server_binary_arguments(&server_path), }) } async fn check_if_version_installed( &self, version: &(dyn 'static + Send + Any), container_dir: &PathBuf, delegate: &dyn LspAdapterDelegate, ) -> Option<LanguageServerBinary> { let version = version.downcast_ref::<String>().unwrap(); let server_path = container_dir.join(SERVER_PATH); let should_install_language_server = self .node .should_install_npm_package( Self::SERVER_NAME.as_ref(), &server_path, container_dir, VersionStrategy::Latest(version), ) .await; if should_install_language_server { None } else { let env = delegate.shell_env().await; Some(LanguageServerBinary { path: self.node.binary_path().await.ok()?, env: Some(env), arguments: server_binary_arguments(&server_path), }) } } async fn cached_server_binary( &self, container_dir: PathBuf, delegate: &dyn LspAdapterDelegate, ) -> Option<LanguageServerBinary> { let mut binary = get_cached_server_binary(container_dir, &self.node).await?; binary.env = Some(delegate.shell_env().await); Some(binary) } async fn process_completions(&self, items: &mut [lsp::CompletionItem]) { // Pyright assigns each completion item a `sortText` of the form `XX.YYYY.name`. // Where `XX` is the sorting category, `YYYY` is based on most recent usage, // and `name` is the symbol name itself. // // Because the symbol name is included, there generally are not ties when // sorting by the `sortText`, so the symbol's fuzzy match score is not taken // into account. Here, we remove the symbol name from the sortText in order // to allow our own fuzzy score to be used to break ties. // // see https://github.com/microsoft/pyright/blob/95ef4e103b9b2f129c9320427e51b73ea7cf78bd/packages/pyright-internal/src/languageService/completionProvider.ts#LL2873 for item in items { let Some(sort_text) = &mut item.sort_text else { continue; }; let mut parts = sort_text.split('.'); let Some(first) = parts.next() else { continue }; let Some(second) = parts.next() else { continue }; let Some(_) = parts.next() else { continue }; sort_text.replace_range(first.len() + second.len() + 1.., ""); } } async fn label_for_completion( &self, item: &lsp::CompletionItem, language: &Arc<language::Language>, ) -> Option<language::CodeLabel> { let label = &item.label; let grammar = language.grammar()?; let highlight_id = match item.kind? { lsp::CompletionItemKind::METHOD => grammar.highlight_id_for_name("function.method")?, lsp::CompletionItemKind::FUNCTION => grammar.highlight_id_for_name("function")?, lsp::CompletionItemKind::CLASS => grammar.highlight_id_for_name("type")?, lsp::CompletionItemKind::CONSTANT => grammar.highlight_id_for_name("constant")?, _ => return None, }; let filter_range = item .filter_text .as_deref() .and_then(|filter| label.find(filter).map(|ix| ix..ix + filter.len())) .unwrap_or(0..label.len()); Some(language::CodeLabel { text: label.clone(), runs: vec![(0..label.len(), highlight_id)], filter_range, }) } async fn label_for_symbol( &self, name: &str, kind: lsp::SymbolKind, language: &Arc<language::Language>, ) -> Option<language::CodeLabel> { let (text, filter_range, display_range) = match kind { lsp::SymbolKind::METHOD | lsp::SymbolKind::FUNCTION => { let text = format!("def {}():\n", name); let filter_range = 4..4 + name.len(); let display_range = 0..filter_range.end; (text, filter_range, display_range) } lsp::SymbolKind::CLASS => { let text = format!("class {}:", name); let filter_range = 6..6 + name.len(); let display_range = 0..filter_range.end; (text, filter_range, display_range) } lsp::SymbolKind::CONSTANT => { let text = format!("{} = 0", name); let filter_range = 0..name.len(); let display_range = 0..filter_range.end; (text, filter_range, display_range) } _ => return None, }; Some(language::CodeLabel { runs: language.highlight_text(&text.as_str().into(), display_range.clone()), text: text[display_range].to_string(), filter_range, }) } async fn workspace_configuration( self: Arc<Self>, _: &dyn Fs, adapter: &Arc<dyn LspAdapterDelegate>, toolchain: Option<Toolchain>, cx: &mut AsyncApp, ) -> Result<Value> { cx.update(move |cx| { let mut user_settings = language_server_settings(adapter.as_ref(), &Self::SERVER_NAME, cx) .and_then(|s| s.settings.clone()) .unwrap_or_default(); // If we have a detected toolchain, configure Pyright to use it if let Some(toolchain) = toolchain && let Ok(env) = serde_json::from_value::< pet_core::python_environment::PythonEnvironment, >(toolchain.as_json.clone()) { if user_settings.is_null() { user_settings = Value::Object(serde_json::Map::default()); } let object = user_settings.as_object_mut().unwrap(); let interpreter_path = toolchain.path.to_string(); if let Some(venv_dir) = env.prefix { // Set venvPath and venv at the root level // This matches the format of a pyrightconfig.json file if let Some(parent) = venv_dir.parent() { // Use relative path if the venv is inside the workspace let venv_path = if parent == adapter.worktree_root_path() { ".".to_string() } else { parent.to_string_lossy().into_owned() }; object.insert("venvPath".to_string(), Value::String(venv_path)); } if let Some(venv_name) = venv_dir.file_name() { object.insert( "venv".to_owned(), Value::String(venv_name.to_string_lossy().into_owned()), ); } } // Always set the python interpreter path // Get or create the python section let python = object .entry("python") .or_insert(Value::Object(serde_json::Map::default())) .as_object_mut() .unwrap(); // Set both pythonPath and defaultInterpreterPath for compatibility python.insert( "pythonPath".to_owned(), Value::String(interpreter_path.clone()), ); python.insert( "defaultInterpreterPath".to_owned(), Value::String(interpreter_path), ); } user_settings }) }} async fn get_cached_server_binary( container_dir: PathBuf, node: &NodeRuntime,) -> Option<LanguageServerBinary> { let server_path = container_dir.join(SERVER_PATH); if server_path.exists() { Some(LanguageServerBinary { path: node.binary_path().await.log_err()?, env: None, arguments: server_binary_arguments(&server_path), }) } else { log::error!("missing executable in directory {:?}", server_path); None }} pub(crate) struct PythonContextProvider; const PYTHON_TEST_TARGET_TASK_VARIABLE: VariableName = VariableName::Custom(Cow::Borrowed("PYTHON_TEST_TARGET")); const PYTHON_ACTIVE_TOOLCHAIN_PATH: VariableName = VariableName::Custom(Cow::Borrowed("PYTHON_ACTIVE_ZED_TOOLCHAIN")); const PYTHON_ACTIVE_TOOLCHAIN_PATH_RAW: VariableName = VariableName::Custom(Cow::Borrowed("PYTHON_ACTIVE_ZED_TOOLCHAIN_RAW")); const PYTHON_MODULE_NAME_TASK_VARIABLE: VariableName = VariableName::Custom(Cow::Borrowed("PYTHON_MODULE_NAME")); impl ContextProvider for PythonContextProvider { fn build_context( &self, variables: &task::TaskVariables, location: ContextLocation<'_>, _: Option<HashMap<String, String>>, toolchains: Arc<dyn LanguageToolchainStore>, cx: &mut gpui::App, ) -> Task<Result<task::TaskVariables>> { let test_target = match selected_test_runner(location.file_location.buffer.read(cx).file(), cx) { TestRunner::UNITTEST => self.build_unittest_target(variables), TestRunner::PYTEST => self.build_pytest_target(variables), }; let module_target = self.build_module_target(variables); let location_file = location.file_location.buffer.read(cx).file().cloned(); let worktree_id = location_file.as_ref().map(|f| f.worktree_id(cx)); cx.spawn(async move |cx| { let raw_toolchain = if let Some(worktree_id) = worktree_id { let file_path = location_file .as_ref() .and_then(|f| f.path().parent()) .map(Arc::from) .unwrap_or_else(|| Arc::from("".as_ref())); toolchains .active_toolchain(worktree_id, file_path, "Python".into(), cx) .await .map_or_else( || String::from("python3"), |toolchain| toolchain.path.to_string(), ) } else { String::from("python3") }; let active_toolchain = format!("\"{raw_toolchain}\""); let toolchain = (PYTHON_ACTIVE_TOOLCHAIN_PATH, active_toolchain); let raw_toolchain_var = (PYTHON_ACTIVE_TOOLCHAIN_PATH_RAW, raw_toolchain); Ok(task::TaskVariables::from_iter( test_target .into_iter() .chain(module_target.into_iter()) .chain([toolchain, raw_toolchain_var]), )) }) } fn associated_tasks( &self, _: Arc<dyn Fs>, file: Option<Arc<dyn language::File>>, cx: &App, ) -> Task<Option<TaskTemplates>> { let test_runner = selected_test_runner(file.as_ref(), cx); let mut tasks = vec![ // Execute a selection TaskTemplate { label: "execute selection".to_owned(), command: PYTHON_ACTIVE_TOOLCHAIN_PATH.template_value(), args: vec![ "-c".to_owned(), VariableName::SelectedText.template_value_with_whitespace(), ], cwd: Some("$ZED_WORKTREE_ROOT".into()), ..TaskTemplate::default() }, // Execute an entire file TaskTemplate { label: format!("run '{}'", VariableName::File.template_value()), command: PYTHON_ACTIVE_TOOLCHAIN_PATH.template_value(), args: vec![VariableName::File.template_value_with_whitespace()], cwd: Some("$ZED_WORKTREE_ROOT".into()), ..TaskTemplate::default() }, // Execute a file as module TaskTemplate { label: format!("run module '{}'", VariableName::File.template_value()), command: PYTHON_ACTIVE_TOOLCHAIN_PATH.template_value(),Lines 1–500 of 1745. Load more
use anyhow::{Context as _, ensure}; use anyhow::{Result, anyhow}; use async_trait::async_trait; use collections::HashMap; use futures::AsyncBufReadExt; use gpui::{App, Task}; use gpui::{AsyncApp, SharedString}; use language::Toolchain; use language::ToolchainList; use language::ToolchainLister; use language::language_settings::language_settings; use language::{ContextLocation, LanguageToolchainStore}; use language::{ContextProvider, LspAdapter, LspAdapterDelegate}; use language::{LanguageName, ManifestName, ManifestProvider, ManifestQuery}; use lsp::LanguageServerBinary; use lsp::LanguageServerName; use node_runtime::{NodeRuntime, VersionStrategy}; use pet_core::Configuration; use pet_core::os_environment::Environment; use pet_core::python_environment::PythonEnvironmentKind; use project::Fs; use project::lsp_store::language_server_settings; use serde_json::{Value, json}; use smol::lock::OnceCell; use std::cmp::Ordering; use parking_lot::Mutex; use std::str::FromStr; use std::{ any::Any, borrow::Cow, ffi::OsString, fmt::Write, path::{Path, PathBuf}, sync::Arc, }; use task::{ShellKind, TaskTemplate, TaskTemplates, VariableName}; use util::ResultExt; pub(crate) struct PyprojectTomlManifestProvider; impl ManifestProvider for PyprojectTomlManifestProvider { fn name(&self) -> ManifestName { SharedString::new_static("pyproject.toml").into() } fn search( &self, ManifestQuery { path, depth, delegate, }: ManifestQuery, ) -> Option<Arc<Path>> { for path in path.ancestors().take(depth) { let p = path.join("pyproject.toml"); if delegate.exists(&p, Some(false)) { return Some(path.into()); } } None } } const SERVER_PATH: &str = "node_modules/pyright/langserver.index.js"; const NODE_MODULE_RELATIVE_SERVER_PATH: &str = "pyright/langserver.index.js"; enum TestRunner { UNITTEST, PYTEST, } impl FromStr for TestRunner { type Err = (); fn from_str(s: &str) -> std::result::Result<Self, Self::Err> { match s { "unittest" => Ok(Self::UNITTEST), "pytest" => Ok(Self::PYTEST), _ => Err(()), } } } fn server_binary_arguments(server_path: &Path) -> Vec<OsString> { vec![server_path.into(), "--stdio".into()] } pub struct PythonLspAdapter { node: NodeRuntime, } impl PythonLspAdapter { const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("pyright"); pub fn new(node: NodeRuntime) -> Self { PythonLspAdapter { node } } } #[async_trait(?Send)] impl LspAdapter for PythonLspAdapter { fn name(&self) -> LanguageServerName { Self::SERVER_NAME } async fn initialization_options( self: Arc<Self>, _: &dyn Fs, _: &Arc<dyn LspAdapterDelegate>, ) -> Result<Option<Value>> { // Provide minimal initialization options // Virtual environment configuration will be handled through workspace configuration Ok(Some(json!({ "python": { "analysis": { "autoSearchPaths": true, "useLibraryCodeForTypes": true, "autoImportCompletions": true } } }))) } async fn check_if_user_installed( &self, delegate: &dyn LspAdapterDelegate, _: Option<Toolchain>, _: &AsyncApp, ) -> Option<LanguageServerBinary> { if let Some(pyright_bin) = delegate.which("pyright-langserver".as_ref()).await { let env = delegate.shell_env().await; Some(LanguageServerBinary { path: pyright_bin, env: Some(env), arguments: vec!["--stdio".into()], }) } else { let node = delegate.which("node".as_ref()).await?; let (node_modules_path, _) = delegate .npm_package_installed_version(Self::SERVER_NAME.as_ref()) .await .log_err()??; let path = node_modules_path.join(NODE_MODULE_RELATIVE_SERVER_PATH); let env = delegate.shell_env().await; Some(LanguageServerBinary { path: node, env: Some(env), arguments: server_binary_arguments(&path), }) } } async fn fetch_latest_server_version( &self, _: &dyn LspAdapterDelegate, ) -> Result<Box<dyn 'static + Any + Send>> { Ok(Box::new( self.node .npm_package_latest_version(Self::SERVER_NAME.as_ref()) .await?, ) as Box<_>) } async fn fetch_server_binary( &self, latest_version: Box<dyn 'static + Send + Any>, container_dir: PathBuf, delegate: &dyn LspAdapterDelegate, ) -> Result<LanguageServerBinary> { let latest_version = latest_version.downcast::<String>().unwrap(); let server_path = container_dir.join(SERVER_PATH); self.node .npm_install_packages( &container_dir, &[(Self::SERVER_NAME.as_ref(), latest_version.as_str())], ) .await?; let env = delegate.shell_env().await; Ok(LanguageServerBinary { path: self.node.binary_path().await?, env: Some(env), arguments: server_binary_arguments(&server_path), }) } async fn check_if_version_installed( &self, version: &(dyn 'static + Send + Any), container_dir: &PathBuf, delegate: &dyn LspAdapterDelegate, ) -> Option<LanguageServerBinary> { let version = version.downcast_ref::<String>().unwrap(); let server_path = container_dir.join(SERVER_PATH); let should_install_language_server = self .node .should_install_npm_package( Self::SERVER_NAME.as_ref(), &server_path, container_dir, VersionStrategy::Latest(version), ) .await; if should_install_language_server { None } else { let env = delegate.shell_env().await; Some(LanguageServerBinary { path: self.node.binary_path().await.ok()?, env: Some(env), arguments: server_binary_arguments(&server_path), }) } } async fn cached_server_binary( &self, container_dir: PathBuf, delegate: &dyn LspAdapterDelegate, ) -> Option<LanguageServerBinary> { let mut binary = get_cached_server_binary(container_dir, &self.node).await?; binary.env = Some(delegate.shell_env().await); Some(binary) } async fn process_completions(&self, items: &mut [lsp::CompletionItem]) { // Pyright assigns each completion item a `sortText` of the form `XX.YYYY.name`. // Where `XX` is the sorting category, `YYYY` is based on most recent usage, // and `name` is the symbol name itself. // // Because the symbol name is included, there generally are not ties when // sorting by the `sortText`, so the symbol's fuzzy match score is not taken // into account. Here, we remove the symbol name from the sortText in order // to allow our own fuzzy score to be used to break ties. // // see https://github.com/microsoft/pyright/blob/95ef4e103b9b2f129c9320427e51b73ea7cf78bd/packages/pyright-internal/src/languageService/completionProvider.ts#LL2873 for item in items { let Some(sort_text) = &mut item.sort_text else { continue; }; let mut parts = sort_text.split('.'); let Some(first) = parts.next() else { continue }; let Some(second) = parts.next() else { continue }; let Some(_) = parts.next() else { continue }; sort_text.replace_range(first.len() + second.len() + 1.., ""); } } async fn label_for_completion( &self, item: &lsp::CompletionItem, language: &Arc<language::Language>, ) -> Option<language::CodeLabel> { let label = &item.label; let grammar = language.grammar()?; let highlight_id = match item.kind? { lsp::CompletionItemKind::METHOD => grammar.highlight_id_for_name("function.method")?, lsp::CompletionItemKind::FUNCTION => grammar.highlight_id_for_name("function")?, lsp::CompletionItemKind::CLASS => grammar.highlight_id_for_name("type")?, lsp::CompletionItemKind::CONSTANT => grammar.highlight_id_for_name("constant")?, _ => return None, }; let filter_range = item .filter_text .as_deref() .and_then(|filter| label.find(filter).map(|ix| ix..ix + filter.len())) .unwrap_or(0..label.len()); Some(language::CodeLabel { text: label.clone(), runs: vec![(0..label.len(), highlight_id)], filter_range, }) } async fn label_for_symbol( &self, name: &str, kind: lsp::SymbolKind, language: &Arc<language::Language>, ) -> Option<language::CodeLabel> { let (text, filter_range, display_range) = match kind { lsp::SymbolKind::METHOD | lsp::SymbolKind::FUNCTION => { let text = format!("def {}():\n", name); let filter_range = 4..4 + name.len(); let display_range = 0..filter_range.end; (text, filter_range, display_range) } lsp::SymbolKind::CLASS => { let text = format!("class {}:", name); let filter_range = 6..6 + name.len(); let display_range = 0..filter_range.end; (text, filter_range, display_range) } lsp::SymbolKind::CONSTANT => { let text = format!("{} = 0", name); let filter_range = 0..name.len(); let display_range = 0..filter_range.end; (text, filter_range, display_range) } _ => return None, }; Some(language::CodeLabel { runs: language.highlight_text(&text.as_str().into(), display_range.clone()), text: text[display_range].to_string(), filter_range, }) } async fn workspace_configuration( self: Arc<Self>, _: &dyn Fs, adapter: &Arc<dyn LspAdapterDelegate>, toolchain: Option<Toolchain>, cx: &mut AsyncApp, ) -> Result<Value> { cx.update(move |cx| { let mut user_settings = language_server_settings(adapter.as_ref(), &Self::SERVER_NAME, cx) .and_then(|s| s.settings.clone()) .unwrap_or_default(); // If we have a detected toolchain, configure Pyright to use it if let Some(toolchain) = toolchain && let Ok(env) = serde_json::from_value::< pet_core::python_environment::PythonEnvironment, >(toolchain.as_json.clone()) { if user_settings.is_null() { user_settings = Value::Object(serde_json::Map::default()); } let object = user_settings.as_object_mut().unwrap(); let interpreter_path = toolchain.path.to_string(); if let Some(venv_dir) = env.prefix { // Set venvPath and venv at the root level // This matches the format of a pyrightconfig.json file if let Some(parent) = venv_dir.parent() { // Use relative path if the venv is inside the workspace let venv_path = if parent == adapter.worktree_root_path() { ".".to_string() } else { parent.to_string_lossy().into_owned() }; object.insert("venvPath".to_string(), Value::String(venv_path)); } if let Some(venv_name) = venv_dir.file_name() { object.insert( "venv".to_owned(), Value::String(venv_name.to_string_lossy().into_owned()), ); } } // Always set the python interpreter path // Get or create the python section let python = object .entry("python") .or_insert(Value::Object(serde_json::Map::default())) .as_object_mut() .unwrap(); // Set both pythonPath and defaultInterpreterPath for compatibility python.insert( "pythonPath".to_owned(), Value::String(interpreter_path.clone()), ); python.insert( "defaultInterpreterPath".to_owned(), Value::String(interpreter_path), ); } user_settings }) } } async fn get_cached_server_binary( container_dir: PathBuf, node: &NodeRuntime, ) -> Option<LanguageServerBinary> { let server_path = container_dir.join(SERVER_PATH); if server_path.exists() { Some(LanguageServerBinary { path: node.binary_path().await.log_err()?, env: None, arguments: server_binary_arguments(&server_path), }) } else { log::error!("missing executable in directory {:?}", server_path); None } } pub(crate) struct PythonContextProvider; const PYTHON_TEST_TARGET_TASK_VARIABLE: VariableName = VariableName::Custom(Cow::Borrowed("PYTHON_TEST_TARGET")); const PYTHON_ACTIVE_TOOLCHAIN_PATH: VariableName = VariableName::Custom(Cow::Borrowed("PYTHON_ACTIVE_ZED_TOOLCHAIN")); const PYTHON_ACTIVE_TOOLCHAIN_PATH_RAW: VariableName = VariableName::Custom(Cow::Borrowed("PYTHON_ACTIVE_ZED_TOOLCHAIN_RAW")); const PYTHON_MODULE_NAME_TASK_VARIABLE: VariableName = VariableName::Custom(Cow::Borrowed("PYTHON_MODULE_NAME")); impl ContextProvider for PythonContextProvider { fn build_context( &self, variables: &task::TaskVariables, location: ContextLocation<'_>, _: Option<HashMap<String, String>>, toolchains: Arc<dyn LanguageToolchainStore>, cx: &mut gpui::App, ) -> Task<Result<task::TaskVariables>> { let test_target = match selected_test_runner(location.file_location.buffer.read(cx).file(), cx) { TestRunner::UNITTEST => self.build_unittest_target(variables), TestRunner::PYTEST => self.build_pytest_target(variables), }; let module_target = self.build_module_target(variables); let location_file = location.file_location.buffer.read(cx).file().cloned(); let worktree_id = location_file.as_ref().map(|f| f.worktree_id(cx)); cx.spawn(async move |cx| { let raw_toolchain = if let Some(worktree_id) = worktree_id { let file_path = location_file .as_ref() .and_then(|f| f.path().parent()) .map(Arc::from) .unwrap_or_else(|| Arc::from("".as_ref())); toolchains .active_toolchain(worktree_id, file_path, "Python".into(), cx) .await .map_or_else( || String::from("python3"), |toolchain| toolchain.path.to_string(), ) } else { String::from("python3") }; let active_toolchain = format!("\"{raw_toolchain}\""); let toolchain = (PYTHON_ACTIVE_TOOLCHAIN_PATH, active_toolchain); let raw_toolchain_var = (PYTHON_ACTIVE_TOOLCHAIN_PATH_RAW, raw_toolchain); Ok(task::TaskVariables::from_iter( test_target .into_iter() .chain(module_target.into_iter()) .chain([toolchain, raw_toolchain_var]), )) }) } fn associated_tasks( &self, _: Arc<dyn Fs>, file: Option<Arc<dyn language::File>>, cx: &App, ) -> Task<Option<TaskTemplates>> { let test_runner = selected_test_runner(file.as_ref(), cx); let mut tasks = vec![ // Execute a selection TaskTemplate { label: "execute selection".to_owned(), command: PYTHON_ACTIVE_TOOLCHAIN_PATH.template_value(), args: vec![ "-c".to_owned(), VariableName::SelectedText.template_value_with_whitespace(), ], cwd: Some("$ZED_WORKTREE_ROOT".into()), ..TaskTemplate::default() }, // Execute an entire file TaskTemplate { label: format!("run '{}'", VariableName::File.template_value()), command: PYTHON_ACTIVE_TOOLCHAIN_PATH.template_value(), args: vec![VariableName::File.template_value_with_whitespace()], cwd: Some("$ZED_WORKTREE_ROOT".into()), ..TaskTemplate::default() }, // Execute a file as module TaskTemplate { label: format!("run module '{}'", VariableName::File.template_value()), command: PYTHON_ACTIVE_TOOLCHAIN_PATH.template_value(),