Fix bug with pip list parsing (#84)

Fixes #83

---------

Co-authored-by: Copilot <[email protected]>

Author: karthiknadig

src/extension.ts

@@ -23,7 +23,7 @@ import {
     runInDedicatedTerminalCommand,
 } from './features/envCommands';
 import { registerCondaFeatures } from './managers/conda/main';
-import { registerSystemPythonFeatures } from './managers/sysPython/main';
+import { registerSystemPythonFeatures } from './managers/builtin/main';
 import { PythonProjectManagerImpl } from './features/projectManager';
 import { EnvironmentManagers, ProjectCreators, PythonProjectManager } from './internal.api';
 import { getPythonApi, setPythonApi } from './features/pythonApi';

src/managers/builtin/cache.ts

@@ -0,0 +1,45 @@
+import { ENVS_EXTENSION_ID } from '../../common/constants';
+import { getWorkspacePersistentState } from '../../common/persistentState';
+
+export const SYSTEM_WORKSPACE_KEY = `${ENVS_EXTENSION_ID}:system:WORKSPACE_SELECTED`;
+export const SYSTEM_GLOBAL_KEY = `${ENVS_EXTENSION_ID}:system:GLOBAL_SELECTED`;
+
+export async function clearSystemEnvCache(): Promise<void> {
+    const keys = [SYSTEM_WORKSPACE_KEY, SYSTEM_GLOBAL_KEY];
+    const state = await getWorkspacePersistentState();
+    await state.clear(keys);
+}
+
+export async function getSystemEnvForWorkspace(fsPath: string): Promise<string | undefined> {
+    const state = await getWorkspacePersistentState();
+    const data: { [key: string]: string } | undefined = await state.get(SYSTEM_WORKSPACE_KEY);
+    if (data) {
+        try {
+            return data[fsPath];
+        } catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+
+export async function setSystemEnvForWorkspace(fsPath: string, envPath: string | undefined): Promise<void> {
+    const state = await getWorkspacePersistentState();
+    const data: { [key: string]: string } = (await state.get(SYSTEM_WORKSPACE_KEY)) ?? {};
+    if (envPath) {
+        data[fsPath] = envPath;
+    } else {
+        delete data[fsPath];
+    }
+    await state.set(SYSTEM_WORKSPACE_KEY, data);
+}
+
+export async function getSystemEnvForGlobal(): Promise<string | undefined> {
+    const state = await getWorkspacePersistentState();
+    return await state.get(SYSTEM_GLOBAL_KEY);
+}
+
+export async function setSystemEnvForGlobal(envPath: string | undefined): Promise<void> {
+    const state = await getWorkspacePersistentState();
+    await state.set(SYSTEM_GLOBAL_KEY, envPath);
+}

src/managers/builtin/helpers.ts

@@ -0,0 +1,95 @@
+import * as ch from 'child_process';
+import { CancellationError, CancellationToken, LogOutputChannel } from 'vscode';
+import { createDeferred } from '../../common/utils/deferred';
+import { sendTelemetryEvent } from '../../common/telemetry/sender';
+import { EventNames } from '../../common/telemetry/constants';
+
+const available = createDeferred<boolean>();
+export async function isUvInstalled(log?: LogOutputChannel): Promise<boolean> {
+    if (available.completed) {
+        return available.promise;
+    }
+
+    const proc = ch.spawn('uv', ['--version']);
+    proc.on('error', () => {
+        available.resolve(false);
+    });
+    proc.stdout.on('data', (d) => log?.info(d.toString()));
+    proc.on('exit', (code) => {
+        if (code === 0) {
+            sendTelemetryEvent(EventNames.VENV_USING_UV);
+        }
+        available.resolve(code === 0);
+    });
+    return available.promise;
+}
+
+export async function runUV(
+    args: string[],
+    cwd?: string,
+    log?: LogOutputChannel,
+    token?: CancellationToken,
+): Promise<string> {
+    log?.info(`Running: uv ${args.join(' ')}`);
+    return new Promise<string>((resolve, reject) => {
+        const proc = ch.spawn('uv', args, { cwd: cwd });
+        token?.onCancellationRequested(() => {
+            proc.kill();
+            reject(new CancellationError());
+        });
+
+        let builder = '';
+        proc.stdout?.on('data', (data) => {
+            const s = data.toString('utf-8');
+            builder += s;
+            log?.append(s);
+        });
+        proc.stderr?.on('data', (data) => {
+            log?.append(data.toString('utf-8'));
+        });
+        proc.on('close', () => {
+            resolve(builder);
+        });
+        proc.on('exit', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Failed to run uv ${args.join(' ')}`));
+            }
+        });
+    });
+}
+
+export async function runPython(
+    python: string,
+    args: string[],
+    cwd?: string,
+    log?: LogOutputChannel,
+    token?: CancellationToken,
+): Promise<string> {
+    log?.info(`Running: ${python} ${args.join(' ')}`);
+    return new Promise<string>((resolve, reject) => {
+        const proc = ch.spawn(python, args, { cwd: cwd });
+        token?.onCancellationRequested(() => {
+            proc.kill();
+            reject(new CancellationError());
+        });
+        let builder = '';
+        proc.stdout?.on('data', (data) => {
+            const s = data.toString('utf-8');
+            builder += s;
+            log?.append(`python: ${s}`);
+        });
+        proc.stderr?.on('data', (data) => {
+            const s = data.toString('utf-8');
+            builder += s;
+            log?.append(`python: ${s}`);
+        });
+        proc.on('close', () => {
+            resolve(builder);
+        });
+        proc.on('exit', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Failed to run python ${args.join(' ')}`));
+            }
+        });
+    });
+}

src/managers/sysPython/main.ts renamed to src/managers/builtin/main.ts

@@ -6,7 +6,7 @@ import { VenvManager } from './venvManager';
 import { getPythonApi } from '../../features/pythonApi';
 import { NativePythonFinder } from '../common/nativePythonFinder';
 import { UvProjectCreator } from './uvProjectCreator';
-import { isUvInstalled } from './utils';
+import { isUvInstalled } from './helpers';
 import { createFileSystemWatcher, onDidDeleteFiles } from '../../common/workspace.apis';
 import { createSimpleDebounce } from '../../common/utils/debounce';
 

src/managers/builtin/pipListUtils.ts

@@ -0,0 +1,29 @@
+export interface PipPackage {
+    name: string;
+    version: string;
+    displayName: string;
+    description: string;
+}
+export function parsePipList(data: string): PipPackage[] {
+    const collection: PipPackage[] = [];
+
+    const lines = data.split('\n').splice(2);
+    for (let line of lines) {
+        if (line.trim() === '' || line.startsWith('Package') || line.startsWith('----') || line.startsWith('[')) {
+            continue;
+        }
+        const parts = line.split(' ').filter((e) => e);
+        if (parts.length > 1) {
+            const name = parts[0].trim();
+            const version = parts[1].trim();
+            const pkg = {
+                name,
+                version,
+                displayName: name,
+                description: version,
+            };
+            collection.push(pkg);
+        }
+    }
+    return collection;
+}

src/managers/sysPython/pipManager.ts renamed to src/managers/builtin/pipManager.ts

@@ -14,19 +14,18 @@ import {
     ResolveEnvironmentContext,
     SetEnvironmentScope,
 } from '../../api';
-import {
-    clearSystemEnvCache,
-    getSystemEnvForGlobal,
-    getSystemEnvForWorkspace,
-    refreshPythons,
-    resolveSystemPythonEnvironmentPath,
-    setSystemEnvForGlobal,
-    setSystemEnvForWorkspace,
-} from './utils';
+import { refreshPythons, resolveSystemPythonEnvironmentPath } from './utils';
 import { NativePythonFinder } from '../common/nativePythonFinder';
 import { createDeferred, Deferred } from '../../common/utils/deferred';
 import { getLatest } from '../common/utils';
 import { SysManagerStrings } from '../../common/localize';
+import {
+    setSystemEnvForWorkspace,
+    setSystemEnvForGlobal,
+    clearSystemEnvCache,
+    getSystemEnvForGlobal,
+    getSystemEnvForWorkspace,
+} from './cache';
 
 export class SysPythonManager implements EnvironmentManager {
     private collection: PythonEnvironment[] = [];