33568259456

Committed 01 Sep 2026 10:50PM UTC coverage: 50.074% (-27.3%) from 77.395%

Build # 33568259456

Build Type

Pull #25

github

Committed by

web-flow

Commit Message

Merge 4135ca1fe into 536e4371b

Pull Request Pull Request #25: Bump prettier from 3.9.5 to 3.9.6

Coverage Stats

50 of 71 branches covered (70.42%)

Branch coverage included in aggregate %.

630 of 1287 relevant lines covered (48.95%)

0.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

50.71

/src/common/python.ts

import { commands, Disposable, Event, EventEmitter, Uri } from 'vscode';
import { traceError, traceLog } from './log/logging';
import { PythonExtension, ResolvedEnvironment } from '@vscode/python-extension';
import { PythonEnvironmentApi, PythonEnvironments } from '@vscode/python-environments';

export interface IInterpreterDetails {
    path?: string[];
    resource?: Uri;
}

const onDidChangePythonInterpreterEvent = new EventEmitter<IInterpreterDetails>();
export const onDidChangePythonInterpreter: Event<IInterpreterDetails> = onDidChangePythonInterpreterEvent.event;

let _api: PythonExtension | undefined;
async function getPythonExtensionAPI(): Promise<PythonExtension | undefined> {
    if (_api) {
        return _api;
    }
    _api = await PythonExtension.api();
    return _api;
}

let _envsApi: PythonEnvironmentApi | undefined;
async function getEnvironmentsExtensionAPI(): Promise<PythonEnvironmentApi | undefined> {
    if (_envsApi) {
        return _envsApi;
    }
    try {
        _envsApi = await PythonEnvironments.api();
    } catch {
        return undefined;
    }
    return _envsApi;
}

export async function initializePython(disposables: Disposable[]): Promise<void> {
    try {
        // // Prefer the Python Environments extension if it's available, as it provides a more comprehensive view of the available environments.
        const envsApi = await getEnvironmentsExtensionAPI();

        if (envsApi) {
            disposables.push(
                envsApi.onDidChangeEnvironment((e) => {
                    onDidChangePythonInterpreterEvent.fire({
                        path: e.new ? [e.new.execInfo.run.executable] : undefined,
                        resource: e.uri,
                    });
                }),
            );

            traceLog('Waiting for interpreter from python environments extension.');
            onDidChangePythonInterpreterEvent.fire(await getInterpreterDetails());
            return;
        }

        // Fall back to legacy ms-python.python extension API
        const api = await getPythonExtensionAPI();

        if (api) {
            disposables.push(
                api.environments.onDidChangeActiveEnvironmentPath((e) => {
                    const resource = e.resource instanceof Uri ? e.resource : e.resource?.uri;
                    onDidChangePythonInterpreterEvent.fire({ path: [e.path], resource });
                }),
            );

            traceLog('Waiting for interpreter from python extension.');
            onDidChangePythonInterpreterEvent.fire(await getInterpreterDetails());
        }
    } catch (error) {
        traceError('Error initializing python: ', error);
    }
}

export async function resolveInterpreter(interpreter: string[]): Promise<ResolvedEnvironment | undefined> {
    const api = await getPythonExtensionAPI();
    return api?.environments.resolveEnvironment(interpreter[0]);
}

export async function getInterpreterDetails(resource?: Uri): Promise<IInterpreterDetails> {
    // Prefer the Python Environments extension if it's available, as it provides a more comprehensive view of the available environments.
    const envsApi = await getEnvironmentsExtensionAPI();
    if (envsApi) {
        const environment = await envsApi.getEnvironment(resource);
        if (environment) {
            return {
                path: [environment.execInfo.run.executable],
                resource,
            };
        }
        return { path: undefined, resource };
    }

    // Fall back to legacy ms-python.python extension API
    const api = await getPythonExtensionAPI();
    const environment = await api?.environments.resolveEnvironment(
        api?.environments.getActiveEnvironmentPath(resource),
    );
    if (environment?.executable.uri && checkVersion(environment)) {
        return { path: [environment?.executable.uri.fsPath], resource };
    }
    return { path: undefined, resource };
}

export async function getDebuggerPath(): Promise<string | undefined> {
    const api = await getPythonExtensionAPI();
    return api?.debug.getDebuggerPackagePath();
}

export async function runPythonExtensionCommand(command: string, ...rest: any[]) {
    await getPythonExtensionAPI();
    return await commands.executeCommand(command, ...rest);
}

export function checkVersion(resolved: ResolvedEnvironment | undefined): boolean {
    const version = resolved?.version;
    if (version?.major === 3 && version?.minor >= 10) {
        return true;
    }
    traceError(`Python version ${version?.major}.${version?.minor} is not supported.`);
    traceError(`Selected python path: ${resolved?.executable.uri?.fsPath}`);
    traceError('Supported versions are 3.10 and above.');
    return false;
}

1	import { commands, Disposable, Event, EventEmitter, Uri } from 'vscode';	1✔
2	import { traceError, traceLog } from './log/logging';	1✔
3	import { PythonExtension, ResolvedEnvironment } from '@vscode/python-extension';	1✔
4	import { PythonEnvironmentApi, PythonEnvironments } from '@vscode/python-environments';	1✔
5		1✔
6	export interface IInterpreterDetails {	1✔
7	path?: string[];	1✔
8	resource?: Uri;	1✔
9	}	1✔
10		1✔
11	const onDidChangePythonInterpreterEvent = new EventEmitter<IInterpreterDetails>();	1✔
12	export const onDidChangePythonInterpreter: Event<IInterpreterDetails> = onDidChangePythonInterpreterEvent.event;	1✔
13		1✔
14	let _api: PythonExtension \| undefined;	1✔
15	async function getPythonExtensionAPI(): Promise<PythonExtension \| undefined> {	×
16	if (_api) {	×
17	return _api;	×
18	}	×
19	_api = await PythonExtension.api();	×
20	return _api;	×
21	}	×
22		1✔
23	let _envsApi: PythonEnvironmentApi \| undefined;	1✔
24	async function getEnvironmentsExtensionAPI(): Promise<PythonEnvironmentApi \| undefined> {	3✔
25	if (_envsApi) {	3✔
26	return _envsApi;	2✔
27	}	2✔
28	try {	1✔
29	_envsApi = await PythonEnvironments.api();	1✔
30	} catch {	3!
31	return undefined;	×
32	}	×
33	return _envsApi;	1✔
34	}	1✔
35		1✔
36	export async function initializePython(disposables: Disposable[]): Promise<void> {	1✔
37	try {	1✔
38	// // Prefer the Python Environments extension if it's available, as it provides a more comprehensive view of the available environments.	1✔
39	const envsApi = await getEnvironmentsExtensionAPI();	1✔
40		1✔
41	if (envsApi) {	1✔
42	disposables.push(	1✔
43	envsApi.onDidChangeEnvironment((e) => {	1✔
44	onDidChangePythonInterpreterEvent.fire({	×
45	path: e.new ? [e.new.execInfo.run.executable] : undefined,	×
46	resource: e.uri,	×
47	});	×
48	}),	1✔
49	);	1✔
50		1✔
51	traceLog('Waiting for interpreter from python environments extension.');	1✔
52	onDidChangePythonInterpreterEvent.fire(await getInterpreterDetails());	1!
53	return;	×
54	}	×
55		×
56	// Fall back to legacy ms-python.python extension API	×
57	const api = await getPythonExtensionAPI();	×
58		×
59	if (api) {	×
60	disposables.push(	×
61	api.environments.onDidChangeActiveEnvironmentPath((e) => {	×
62	const resource = e.resource instanceof Uri ? e.resource : e.resource?.uri;	×
63	onDidChangePythonInterpreterEvent.fire({ path: [e.path], resource });	×
64	}),	×
65	);	×
66		×
67	traceLog('Waiting for interpreter from python extension.');	×
68	onDidChangePythonInterpreterEvent.fire(await getInterpreterDetails());	×
69	}	×
70	} catch (error) {	1✔
71	traceError('Error initializing python: ', error);	1✔
72	}	1✔
73	}	1✔
74		1✔
75	export async function resolveInterpreter(interpreter: string[]): Promise<ResolvedEnvironment \| undefined> {	1✔
76	const api = await getPythonExtensionAPI();	×
77	return api?.environments.resolveEnvironment(interpreter[0]);	×
78	}	×
79		1✔
80	export async function getInterpreterDetails(resource?: Uri): Promise<IInterpreterDetails> {	1✔
81	// Prefer the Python Environments extension if it's available, as it provides a more comprehensive view of the available environments.	2✔
82	const envsApi = await getEnvironmentsExtensionAPI();	2✔
83	if (envsApi) {	2✔
84	const environment = await envsApi.getEnvironment(resource);	2✔
85	if (environment) {	2!
86	return {	×
87	path: [environment.execInfo.run.executable],	×
88	resource,	×
89	};	×
90	}	×
91	return { path: undefined, resource };	1✔
92	}	1✔
93		×
94	// Fall back to legacy ms-python.python extension API	×
95	const api = await getPythonExtensionAPI();	×
96	const environment = await api?.environments.resolveEnvironment(	2✔
97	api?.environments.getActiveEnvironmentPath(resource),	2!
98	);	2✔
99	if (environment?.executable.uri && checkVersion(environment)) {	2!
100	return { path: [environment?.executable.uri.fsPath], resource };	×
101	}	×
102	return { path: undefined, resource };	×
103	}	×
104		1✔
105	export async function getDebuggerPath(): Promise<string \| undefined> {	1✔
106	const api = await getPythonExtensionAPI();	×
107	return api?.debug.getDebuggerPackagePath();	×
108	}	×
109		1✔
110	export async function runPythonExtensionCommand(command: string, ...rest: any[]) {	1✔
111	await getPythonExtensionAPI();	×
112	return await commands.executeCommand(command, ...rest);	×
113	}	×
114		1✔
115	export function checkVersion(resolved: ResolvedEnvironment \| undefined): boolean {	×
116	const version = resolved?.version;	×
117	if (version?.major === 3 && version?.minor >= 10) {	×
118	return true;	×
119	}	×
120	traceError(`Python version ${version?.major}.${version?.minor} is not supported.`);	×
121	traceError(`Selected python path: ${resolved?.executable.uri?.fsPath}`);	×
122	traceError('Supported versions are 3.10 and above.');	×
123	return false;	×
124	}	×

pyta-uoft / python-ta-vscode-extension / 33568259456

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous