refactor: remove legacy ensureInstalled method and clean up environment management

This commit removes the deprecated `ensureInstalled` method from the `DeepnoteToolkitInstaller` class, streamlining the installation process by encouraging the use of `ensureVenvAndToolkit`. Additionally, the `logs.txt` file has been deleted as it is no longer necessary for the current implementation.

Changes include:
- Removal of the legacy method to enhance code clarity and maintainability.
- Deletion of the logs file to reduce clutter in the repository.

These changes contribute to a cleaner codebase and improved user experience when managing Deepnote environments.

Signed-off-by: Tomas Kislan <tomas@kislan.sk>

Author: tkislan

src/kernels/deepnote/deepnoteToolkitInstaller.node.ts

@@ -184,19 +184,6 @@ export class DeepnoteToolkitInstaller implements IDeepnoteToolkitInstaller {
         }
     }
 
-    /**
-     * Legacy file-based method (for backward compatibility).
-     * @deprecated Use ensureVenvAndToolkit instead
-     */
-    public async ensureInstalled(
-        baseInterpreter: PythonEnvironment,
-        deepnoteFileUri: Uri,
-        token?: CancellationToken
-    ): Promise<PythonEnvironment | undefined> {
-        const venvPath = this.getVenvPath(deepnoteFileUri);
-        return this.ensureVenvAndToolkit(baseInterpreter, venvPath, token);
-    }
-
     /**
      * Install venv and toolkit at a specific path (environment-based).
      */

src/kernels/deepnote/environments/deepnoteEnvironment.ts

@@ -78,7 +78,7 @@ export interface DeepnoteEnvironmentState {
 /**
  * Options for creating a new kernel environment
  */
-export interface CreateEnvironmentOptions {
+export interface CreateDeepnoteEnvironmentOptions {
     name: string;
     pythonInterpreter: PythonEnvironment;
     packages?: string[];

src/kernels/deepnote/environments/deepnoteEnvironmentManager.ts renamed to src/kernels/deepnote/environments/deepnoteEnvironmentManager.node.ts

@@ -4,9 +4,9 @@ import { generateUuid as uuid } from '../../../platform/common/uuid';
 import { IExtensionContext } from '../../../platform/common/types';
 import { IExtensionSyncActivationService } from '../../../platform/activation/types';
 import { logger } from '../../../platform/logging';
-import { DeepnoteEnvironmentStorage } from './deepnoteEnvironmentStorage';
+import { DeepnoteEnvironmentStorage } from './deepnoteEnvironmentStorage.node';
 import {
-    CreateEnvironmentOptions,
+    CreateDeepnoteEnvironmentOptions,
     DeepnoteEnvironment,
     DeepnoteEnvironmentWithStatus,
     EnvironmentStatus
@@ -74,7 +74,7 @@ export class DeepnoteEnvironmentManager implements IExtensionSyncActivationServi
     /**
      * Create a new kernel environment
      */
-    public async createEnvironment(options: CreateEnvironmentOptions): Promise<DeepnoteEnvironment> {
+    public async createEnvironment(options: CreateDeepnoteEnvironmentOptions): Promise<DeepnoteEnvironment> {
         const id = uuid();
         const venvPath = Uri.joinPath(this.context.globalStorageUri, 'deepnote-venvs', id);
 

src/kernels/deepnote/environments/deepnoteEnvironmentManager.unit.test.ts

@@ -1,8 +1,8 @@
 import { assert } from 'chai';
 import { anything, instance, mock, when, verify, deepEqual } from 'ts-mockito';
 import { Uri } from 'vscode';
-import { DeepnoteEnvironmentManager } from './deepnoteEnvironmentManager';
-import { DeepnoteEnvironmentStorage } from './deepnoteEnvironmentStorage';
+import { DeepnoteEnvironmentManager } from './deepnoteEnvironmentManager.node';
+import { DeepnoteEnvironmentStorage } from './deepnoteEnvironmentStorage.node';
 import { IExtensionContext } from '../../../platform/common/types';
 import { IDeepnoteServerStarter, IDeepnoteToolkitInstaller, DeepnoteServerInfo } from '../types';
 import { PythonEnvironment } from '../../../platform/pythonEnvironments/info';

src/kernels/deepnote/environments/deepnoteEnvironmentPicker.ts

@@ -2,12 +2,58 @@
 // Licensed under the MIT License.
 
 import { inject, injectable } from 'inversify';
-import { QuickPickItem, window, Uri, commands } from 'vscode';
+import { QuickPickItem, window, Uri, commands, ThemeColor } from 'vscode';
 import { logger } from '../../../platform/logging';
 import { IDeepnoteEnvironmentManager } from '../types';
-import { DeepnoteEnvironment } from './deepnoteEnvironment';
+import { DeepnoteEnvironment, EnvironmentStatus } from './deepnoteEnvironment';
 import { getDisplayPath } from '../../../platform/common/platform/fs-paths';
 
+export function getDeepnoteEnvironmentStatusVisual(status: EnvironmentStatus): {
+    icon: string;
+    text: string;
+    themeColor: ThemeColor;
+    contextValue: string;
+} {
+    switch (status) {
+        case EnvironmentStatus.Running:
+            return {
+                icon: 'vm-running',
+                text: 'Running',
+                contextValue: 'deepnoteEnvironment.running',
+                themeColor: { id: 'charts.green' }
+            };
+        case EnvironmentStatus.Starting:
+            return {
+                icon: 'vm-outline',
+                text: 'Starting',
+                contextValue: 'deepnoteEnvironment.starting',
+                themeColor: { id: 'charts.yellow' }
+            };
+        case EnvironmentStatus.Stopped:
+            return {
+                icon: 'vm-outline',
+                text: 'Stopped',
+                contextValue: 'deepnoteEnvironment.stopped',
+                themeColor: { id: 'charts.gray' }
+            };
+        case EnvironmentStatus.Error:
+            return {
+                icon: 'vm-outline',
+                text: 'Error',
+                contextValue: 'deepnoteEnvironment.stopped',
+                themeColor: { id: 'charts.gray' }
+            };
+        default:
+            status satisfies never;
+            return {
+                icon: 'vm-outline',
+                text: 'Unknown',
+                contextValue: 'deepnoteEnvironment.stopped',
+                themeColor: { id: 'charts.gray' }
+            };
+    }
+}
+
 /**
  * Handles showing environment picker UI for notebook selection
  */
@@ -56,11 +102,12 @@ export class DeepnoteEnvironmentPicker {
         // Build quick pick items
         const items: (QuickPickItem & { environment?: DeepnoteEnvironment })[] = environments.map((env) => {
             const envWithStatus = this.environmentManager.getEnvironmentWithStatus(env.id);
-            const statusIcon = envWithStatus?.status === 'running' ? '$(vm-running)' : '$(vm-outline)';
-            const statusText = envWithStatus?.status === 'running' ? '[Running]' : '[Stopped]';
+            const { icon, text } = getDeepnoteEnvironmentStatusVisual(
+                envWithStatus?.status || EnvironmentStatus.Stopped
+            );
 
             return {
-                label: `${statusIcon} ${env.name} ${statusText}`,
+                label: `$(${icon}) ${env.name} [${text}]`,
                 description: getDisplayPath(env.pythonInterpreter.uri),
                 detail: env.packages?.length ? `Packages: ${env.packages.join(', ')}` : 'No additional packages',
                 environment: env

src/kernels/deepnote/environments/deepnoteEnvironmentStorage.ts renamed to src/kernels/deepnote/environments/deepnoteEnvironmentStorage.node.ts

@@ -1,7 +1,7 @@
 import { assert } from 'chai';
 import { anything, instance, mock, when, verify, deepEqual } from 'ts-mockito';
 import { Memento, Uri } from 'vscode';
-import { DeepnoteEnvironmentStorage } from './deepnoteEnvironmentStorage';
+import { DeepnoteEnvironmentStorage } from './deepnoteEnvironmentStorage.node';
 import { IExtensionContext } from '../../../platform/common/types';
 import { IInterpreterService } from '../../../platform/interpreter/contracts';
 import { PythonEnvironment } from '../../../platform/pythonEnvironments/info';

src/kernels/deepnote/environments/deepnoteEnvironmentStorage.unit.test.ts

@@ -3,7 +3,7 @@
 
 import { Event, EventEmitter, TreeDataProvider, TreeItem } from 'vscode';
 import { IDeepnoteEnvironmentManager } from '../types';
-import { EnvironmentTreeItemType, DeepnoteEnvironmentTreeItem } from './deepnoteEnvironmentTreeItem';
+import { EnvironmentTreeItemType, DeepnoteEnvironmentTreeItem } from './deepnoteEnvironmentTreeItem.node';
 import { EnvironmentStatus } from './deepnoteEnvironment';
 
 /**
@@ -52,7 +52,12 @@ export class DeepnoteEnvironmentTreeDataProvider implements TreeDataProvider<Dee
             const statusInfo = this.environmentManager.getEnvironmentWithStatus(config.id);
             const status = statusInfo?.status || EnvironmentStatus.Stopped;
 
-            const item = new DeepnoteEnvironmentTreeItem(EnvironmentTreeItemType.Environment, config, status);
+            const item = new DeepnoteEnvironmentTreeItem(
+                EnvironmentTreeItemType.Environment,
+                // deepnoteEnvironmentToView(config),
+                config,
+                status
+            );
 
             items.push(item);
         }

src/kernels/deepnote/environments/deepnoteEnvironmentTreeDataProvider.ts renamed to src/kernels/deepnote/environments/deepnoteEnvironmentTreeDataProvider.node.ts

@@ -1,11 +1,11 @@
 import { assert } from 'chai';
 import { instance, mock, when } from 'ts-mockito';
 import { Uri, EventEmitter } from 'vscode';
-import { DeepnoteEnvironmentTreeDataProvider } from './deepnoteEnvironmentTreeDataProvider';
+import { DeepnoteEnvironmentTreeDataProvider } from './deepnoteEnvironmentTreeDataProvider.node';
 import { IDeepnoteEnvironmentManager } from '../types';
 import { DeepnoteEnvironment, DeepnoteEnvironmentWithStatus, EnvironmentStatus } from './deepnoteEnvironment';
 import { PythonEnvironment } from '../../../platform/pythonEnvironments/info';
-import { EnvironmentTreeItemType } from './deepnoteEnvironmentTreeItem';
+import { EnvironmentTreeItemType } from './deepnoteEnvironmentTreeItem.node';
 
 suite('DeepnoteEnvironmentTreeDataProvider', () => {
     let provider: DeepnoteEnvironmentTreeDataProvider;

src/kernels/deepnote/environments/deepnoteEnvironmentTreeDataProvider.unit.test.ts

@@ -1,5 +1,6 @@
 import { ThemeIcon, TreeItem, TreeItemCollapsibleState } from 'vscode';
 import { DeepnoteEnvironment, EnvironmentStatus } from './deepnoteEnvironment';
+import { getDeepnoteEnvironmentStatusVisual } from './deepnoteEnvironmentPicker';
 
 /**
  * Type of tree item in the environments view
@@ -37,28 +38,11 @@ export class DeepnoteEnvironmentTreeItem extends TreeItem {
             return;
         }
 
-        const isRunning = this.status === EnvironmentStatus.Running;
-        const isStarting = this.status === EnvironmentStatus.Starting;
+        const statusVisual = getDeepnoteEnvironmentStatusVisual(this.status);
 
-        // Set label with status indicator
-        const statusText = isRunning ? '[Running]' : isStarting ? '[Starting...]' : '[Stopped]';
-        this.label = `${this.environment.name} ${statusText}`;
-
-        // Set icon based on status
-        if (isRunning) {
-            this.iconPath = new ThemeIcon('vm-running', { id: 'charts.green' });
-        } else if (isStarting) {
-            this.iconPath = new ThemeIcon('loading~spin', { id: 'charts.yellow' });
-        } else {
-            this.iconPath = new ThemeIcon('vm-outline', { id: 'charts.gray' });
-        }
-
-        // Set context value for command filtering
-        this.contextValue = isRunning
-            ? 'deepnoteEnvironment.running'
-            : isStarting
-            ? 'deepnoteEnvironment.starting'
-            : 'deepnoteEnvironment.stopped';
+        this.label = `${this.environment.name} [${statusVisual.text}]`;
+        this.iconPath = new ThemeIcon(statusVisual.icon, { id: statusVisual.themeColor.id });
+        this.contextValue = statusVisual.contextValue;
 
         // Make it collapsible to show info items
         this.collapsibleState = TreeItemCollapsibleState.Collapsed;
@@ -99,6 +83,8 @@ export class DeepnoteEnvironmentTreeItem extends TreeItem {
         lines.push(`Status: ${this.status}`);
         lines.push(`Python: ${this.environment.pythonInterpreter.uri.fsPath}`);
         lines.push(`Venv: ${this.environment.venvPath.fsPath}`);
+        // lines.push(`Python: ${this.environment.pythonInterpreter.uriFsPath}`);
+        // lines.push(`Venv: ${this.environment.venvPathFsPath}`);
 
         if (this.environment.packages && this.environment.packages.length > 0) {
             lines.push(`Packages: ${this.environment.packages.join(', ')}`);