Remove old and unused API for Jupyter Ext

src/client/common/installer/condaInstaller.ts

@@ -88,18 +88,7 @@ export class CondaInstaller extends ModuleInstaller {
  // Found that using conda-forge is best at packages like tensorboard & ipykernel which seem to get updated first on conda-forge
  // https://github.com/microsoft/vscode-jupyter/issues/7787 & https://github.com/microsoft/vscode-python/issues/17628
  // Do this just for the datascience packages.
- if (
- [
- Product.tensorboard,
- Product.ipykernel,
- Product.pandas,
- Product.nbconvert,
- Product.jupyter,
- Product.notebook,
- ]
- .map(translateProductToModule)
- .includes(moduleName)
- ) {
+ if ([Product.tensorboard].map(translateProductToModule).includes(moduleName)) {
  args.push('-c', 'conda-forge');
  }
  if (info && info.name) {

src/client/common/installer/moduleInstaller.ts

@@ -264,18 +264,6 @@ export function translateProductToModule(product: Product): string {
  return 'unittest';
  case Product.bandit:
  return 'bandit';
- case Product.jupyter:
- return 'jupyter';
- case Product.notebook:
- return 'notebook';
- case Product.pandas:
- return 'pandas';
- case Product.ipykernel:
- return 'ipykernel';
- case Product.nbconvert:
- return 'nbconvert';
- case Product.kernelspec:
- return 'kernelspec';
  case Product.tensorboard:
  return 'tensorboard';
  case Product.torchProfilerInstallName:

src/client/common/installer/productNames.ts

@@ -19,11 +19,5 @@ ProductNames.set(Product.yapf, 'yapf');
 ProductNames.set(Product.tensorboard, 'tensorboard');
 ProductNames.set(Product.torchProfilerInstallName, 'torch-tb-profiler');
 ProductNames.set(Product.torchProfilerImportName, 'torch_tb_profiler');
-ProductNames.set(Product.jupyter, 'jupyter');
-ProductNames.set(Product.notebook, 'notebook');
-ProductNames.set(Product.ipykernel, 'ipykernel');
-ProductNames.set(Product.nbconvert, 'nbconvert');
-ProductNames.set(Product.kernelspec, 'kernelspec');
-ProductNames.set(Product.pandas, 'pandas');
 ProductNames.set(Product.pip, 'pip');
 ProductNames.set(Product.ensurepip, 'ensurepip');

src/client/common/installer/productService.ts

@@ -25,12 +25,6 @@ export class ProductService implements IProductService {
  this.ProductTypes.set(Product.autopep8, ProductType.Formatter);
  this.ProductTypes.set(Product.black, ProductType.Formatter);
  this.ProductTypes.set(Product.yapf, ProductType.Formatter);
- this.ProductTypes.set(Product.jupyter, ProductType.DataScience);
- this.ProductTypes.set(Product.notebook, ProductType.DataScience);
- this.ProductTypes.set(Product.ipykernel, ProductType.DataScience);
- this.ProductTypes.set(Product.nbconvert, ProductType.DataScience);
- this.ProductTypes.set(Product.kernelspec, ProductType.DataScience);
- this.ProductTypes.set(Product.pandas, ProductType.DataScience);
  this.ProductTypes.set(Product.tensorboard, ProductType.DataScience);
  this.ProductTypes.set(Product.torchProfilerInstallName, ProductType.DataScience);
  this.ProductTypes.set(Product.torchProfilerImportName, ProductType.DataScience);

src/client/common/types.ts

@@ -109,12 +109,6 @@ export enum Product {
  isort = 15,
  black = 16,
  bandit = 17,
- jupyter = 18,
- ipykernel = 19,
- notebook = 20,
- kernelspec = 21,
- nbconvert = 22,
- pandas = 23,
  tensorboard = 24,
  torchProfilerInstallName = 25,
  torchProfilerImportName = 26,

src/client/jupyter/jupyterIntegration.ts

@@ -6,90 +6,20 @@
 
 import { inject, injectable, named } from 'inversify';
 import { dirname } from 'path';
-import { CancellationToken, Event, Extension, Memento, Uri } from 'vscode';
+import { Extension, Memento, Uri } from 'vscode';
 import type { SemVer } from 'semver';
 import { IContextKeyManager, IWorkspaceService } from '../common/application/types';
 import { JUPYTER_EXTENSION_ID, PYLANCE_EXTENSION_ID } from '../common/constants';
-import { InterpreterUri, ModuleInstallFlags } from '../common/installer/types';
-import {
- GLOBAL_MEMENTO,
- IExtensions,
- IInstaller,
- IMemento,
- InstallerResponse,
- Product,
- ProductInstallStatus,
- Resource,
-} from '../common/types';
+import { GLOBAL_MEMENTO, IExtensions, IMemento, Resource } from '../common/types';
 import { getDebugpyPackagePath } from '../debugger/extension/adapter/remoteLaunchers';
 import { IEnvironmentActivationService } from '../interpreter/activation/types';
 import { IInterpreterQuickPickItem, IInterpreterSelector } from '../interpreter/configuration/types';
-import {
- IComponentAdapter,
- ICondaService,
- IInterpreterDisplay,
- IInterpreterService,
- IInterpreterStatusbarVisibilityFilter,
- PythonEnvironmentsChangedEvent,
-} from '../interpreter/contracts';
+import { ICondaService, IInterpreterDisplay, IInterpreterStatusbarVisibilityFilter } from '../interpreter/contracts';
 import { PythonEnvironment } from '../pythonEnvironments/info';
 import { PylanceApi } from '../activation/node/pylanceApi';
 import { ExtensionContextKey } from '../common/application/contextKeys';
-/**
- * This allows Python extension to update Product enum without breaking Jupyter.
- * I.e. we have a strict contract, else using numbers (in enums) is bound to break across products.
- */
-enum JupyterProductToInstall {
- jupyter = 'jupyter',
- ipykernel = 'ipykernel',
- notebook = 'notebook',
- kernelspec = 'kernelspec',
- nbconvert = 'nbconvert',
- pandas = 'pandas',
- pip = 'pip',
-}
-
-const ProductMapping: { [key in JupyterProductToInstall]: Product } = {
- [JupyterProductToInstall.ipykernel]: Product.ipykernel,
- [JupyterProductToInstall.jupyter]: Product.jupyter,
- [JupyterProductToInstall.kernelspec]: Product.kernelspec,
- [JupyterProductToInstall.nbconvert]: Product.nbconvert,
- [JupyterProductToInstall.notebook]: Product.notebook,
- [JupyterProductToInstall.pandas]: Product.pandas,
- [JupyterProductToInstall.pip]: Product.pip,
-};
 
 type PythonApiForJupyterExtension = {
- /**
- * IInterpreterService
- */
- onDidChangeInterpreter: Event<Uri | undefined>;
- /**
- * IInterpreterService
- */
- readonly refreshPromise: Promise<void> | undefined;
- /**
- * IInterpreterService
- */
- readonly onDidChangeInterpreters: Event<PythonEnvironmentsChangedEvent>;
- /**
- * Equivalent to getInterpreters() in IInterpreterService
- */
- getKnownInterpreters(resource?: Uri): PythonEnvironment[];
- /**
- * @deprecated Use `getKnownInterpreters`, `onDidChangeInterpreters`, and `refreshPromise` instead.
- * Equivalent to getAllInterpreters() in IInterpreterService
- */
- getInterpreters(resource?: Uri): Promise<PythonEnvironment[]>;
- /**
- * IInterpreterService
- */
- getActiveInterpreter(resource?: Uri): Promise<PythonEnvironment | undefined>;
- /**
- * IInterpreterService
- */
- getInterpreterDetails(pythonPath: string, resource?: Uri): Promise<undefined | PythonEnvironment>;
-
  /**
  * IEnvironmentActivationService
  */
@@ -98,31 +28,11 @@ type PythonApiForJupyterExtension = {
  interpreter?: PythonEnvironment,
  allowExceptions?: boolean,
  ): Promise<NodeJS.ProcessEnv | undefined>;
- isMicrosoftStoreInterpreter(pythonPath: string): Promise<boolean>;
- suggestionToQuickPickItem(suggestion: PythonEnvironment, workspaceUri?: Uri | undefined): IInterpreterQuickPickItem;
  getKnownSuggestions(resource: Resource): IInterpreterQuickPickItem[];
  /**
  * @deprecated Use `getKnownSuggestions` and `suggestionToQuickPickItem` instead.
  */
  getSuggestions(resource: Resource): Promise<IInterpreterQuickPickItem[]>;
- /**
- * IInstaller
- */
- install(
- product: JupyterProductToInstall,
- resource?: InterpreterUri,
- cancel?: CancellationToken,
- reInstallAndUpdate?: boolean,
- installPipIfRequired?: boolean,
- ): Promise<InstallerResponse>;
- /**
- * IInstaller
- */
- isProductVersionCompatible(
- product: Product,
- semVerRequirement: string,
- resource?: InterpreterUri,
- ): Promise<ProductInstallStatus>;
  /**
  * Returns path to where `debugpy` is. In python extension this is `/pythonFiles/lib/python`.
  */
@@ -140,10 +50,6 @@ type PythonApiForJupyterExtension = {
  * Returns the conda executable.
  */
  getCondaFile(): Promise<string | undefined>;
- getEnvironmentActivationShellCommands(
- resource: Resource,
- interpreter?: PythonEnvironment,
- ): Promise<string[] | undefined>;
 
  /**
  * Call to provide a function that the Python extension can call to request the Python
@@ -181,13 +87,10 @@ export class JupyterExtensionIntegration {
 
  constructor(
  @inject(IExtensions) private readonly extensions: IExtensions,
- @inject(IInterpreterService) private readonly interpreterService: IInterpreterService,
  @inject(IInterpreterSelector) private readonly interpreterSelector: IInterpreterSelector,
- @inject(IInstaller) private readonly installer: IInstaller,
  @inject(IEnvironmentActivationService) private readonly envActivation: IEnvironmentActivationService,
  @inject(IMemento) @named(GLOBAL_MEMENTO) private globalState: Memento,
  @inject(IInterpreterDisplay) private interpreterDisplay: IInterpreterDisplay,
- @inject(IComponentAdapter) private pyenvs: IComponentAdapter,
  @inject(IWorkspaceService) private workspaceService: IWorkspaceService,
  @inject(ICondaService) private readonly condaService: ICondaService,
  @inject(IContextKeyManager) private readonly contextManager: IContextKeyManager,
@@ -201,54 +104,15 @@ export class JupyterExtensionIntegration {
  }
  // Forward python parts
  jupyterExtensionApi.registerPythonApi({
- onDidChangeInterpreter: this.interpreterService.onDidChangeInterpreter,
- getActiveInterpreter: async (resource?: Uri) => this.interpreterService.getActiveInterpreter(resource),
- getInterpreterDetails: async (pythonPath: string) =>
- this.interpreterService.getInterpreterDetails(pythonPath),
- refreshPromise: this.interpreterService.refreshPromise,
- onDidChangeInterpreters: this.interpreterService.onDidChangeInterpreters,
- getKnownInterpreters: (resource: Uri | undefined) => this.pyenvs.getInterpreters(resource),
- getInterpreters: async (resource: Uri | undefined) => this.interpreterService.getAllInterpreters(resource),
  getActivatedEnvironmentVariables: async (
  resource: Resource,
  interpreter?: PythonEnvironment,
  allowExceptions?: boolean,
  ) => this.envActivation.getActivatedEnvironmentVariables(resource, interpreter, allowExceptions),
- isMicrosoftStoreInterpreter: async (pythonPath: string): Promise<boolean> =>
- this.pyenvs.isMicrosoftStoreInterpreter(pythonPath),
  getSuggestions: async (resource: Resource): Promise<IInterpreterQuickPickItem[]> =>
  this.interpreterSelector.getAllSuggestions(resource),
  getKnownSuggestions: (resource: Resource): IInterpreterQuickPickItem[] =>
  this.interpreterSelector.getSuggestions(resource),
- suggestionToQuickPickItem: (
- suggestion: PythonEnvironment,
- workspaceUri?: Uri | undefined,
- ): IInterpreterQuickPickItem =>
- this.interpreterSelector.suggestionToQuickPickItem(suggestion, workspaceUri),
- install: async (
- product: JupyterProductToInstall,
- resource?: InterpreterUri,
- cancel?: CancellationToken,
- reInstallAndUpdate?: boolean,
- installPipIfRequired?: boolean,
- ): Promise<InstallerResponse> => {
- let flags =
- reInstallAndUpdate === true
- ? ModuleInstallFlags.updateDependencies | ModuleInstallFlags.reInstall
- : undefined;
- if (installPipIfRequired === true) {
- flags = flags
- ? flags | ModuleInstallFlags.installPipIfRequired
- : ModuleInstallFlags.installPipIfRequired;
- }
- return this.installer.install(ProductMapping[product], resource, cancel, flags);
- },
- isProductVersionCompatible: async (
- product: Product,
- semVerRequirement: string,
- resource?: InterpreterUri,
- ): Promise<ProductInstallStatus> =>
- this.installer.isProductVersionCompatible(product, semVerRequirement, resource),
  getDebuggerPath: async () => dirname(getDebugpyPackagePath()),
  getInterpreterPathSelectedForJupyterServer: () =>
  this.globalState.get<string | undefined>('INTERPRETER_PATH_SELECTED_FOR_JUPYTER_SERVER'),
@@ -257,8 +121,6 @@ export class JupyterExtensionIntegration {
  ),
  getCondaFile: () => this.condaService.getCondaFile(),
  getCondaVersion: () => this.condaService.getCondaVersion(),
- getEnvironmentActivationShellCommands: (resource: Resource, interpreter?: PythonEnvironment) =>
- this.envActivation.getEnvironmentActivationShellCommands(resource, interpreter),
  registerJupyterPythonPathFunction: (func: (uri: Uri) => Promise<string | undefined>) =>
  this.registerJupyterPythonPathFunction(func),
  registerGetNotebookUriForTextDocumentUriFunction: (func: (textDocumentUri: Uri) => Uri | undefined) =>

src/test/activation/node/lspInteractiveWindowMiddlewareAddon.unit.test.ts

@@ -10,13 +10,8 @@ import { anything, capture, instance, mock, verify, when } from 'ts-mockito';
 import { LanguageClient } from 'vscode-languageclient/node';
 import { LspInteractiveWindowMiddlewareAddon } from '../../../client/activation/node/lspInteractiveWindowMiddlewareAddon';
 import { JupyterExtensionIntegration } from '../../../client/jupyter/jupyterIntegration';
-import { IExtensions, IInstaller } from '../../../client/common/types';
-import {
- IComponentAdapter,
- ICondaService,
- IInterpreterDisplay,
- IInterpreterService,
-} from '../../../client/interpreter/contracts';
+import { IExtensions } from '../../../client/common/types';
+import { ICondaService, IInterpreterDisplay } from '../../../client/interpreter/contracts';
 import { IInterpreterSelector } from '../../../client/interpreter/configuration/types';
 import { IEnvironmentActivationService } from '../../../client/interpreter/activation/types';
 import { IContextKeyManager, IWorkspaceService } from '../../../client/common/application/types';
@@ -32,13 +27,10 @@ suite('Pylance Language Server - Interactive Window LSP Notebooks', () => {
  languageClient = instance(languageClientMock);
  jupyterApi = new JupyterExtensionIntegration(
  mock<IExtensions>(),
- mock<IInterpreterService>(),
  mock<IInterpreterSelector>(),
- mock<IInstaller>(),
  mock<IEnvironmentActivationService>(),
  new MockMemento(),
  mock<IInterpreterDisplay>(),
- mock<IComponentAdapter>(),
  mock<IWorkspaceService>(),
  mock<ICondaService>(),
  mock<IContextKeyManager>(),