33
44import { injectable , inject } from 'inversify' ;
55import { getArchitectureDisplayName } from '../../common/platform/registry' ;
6+ import { Resource } from '../../common/types' ;
67import { isParentPath } from '../../pythonEnvironments/common/externalDependencies' ;
7- import { EnvironmentType , PythonEnvironment } from '../../pythonEnvironments/info' ;
8+ import { EnvironmentType , PythonEnvironment , virtualEnvTypes } from '../../pythonEnvironments/info' ;
89import { PythonVersion } from '../../pythonEnvironments/info/pythonVersion' ;
910import { IInterpreterHelper } from '../contracts' ;
1011import { IInterpreterComparer } from './types' ;
1112
12- /*
13- * Enum description:
14- * - Local environments (.venv);
15- * - Global environments (pipenv, conda);
16- * - Globally-installed interpreters (/usr/bin/python3, Windows Store).
17- */
18- export enum EnvTypeHeuristic {
13+ export enum EnvLocationHeuristic {
14+ /**
15+ * Environments inside the workspace.
16+ */
1917 Local = 1 ,
18+ /**
19+ * Environments outside the workspace.
20+ */
2021 Global = 2 ,
21- GlobalInterpreters = 3 ,
2222}
2323
2424@injectable ( )
@@ -41,8 +41,14 @@ export class EnvironmentTypeComparer implements IInterpreterComparer {
4141 * Always sort with newest version of Python first within each subgroup.
4242 */
4343 public compare ( a : PythonEnvironment , b : PythonEnvironment ) : number {
44+ // Check environment location.
45+ const envLocationComparison = compareEnvironmentLocation ( a , b , this . workspaceFolderPath ) ;
46+ if ( envLocationComparison !== 0 ) {
47+ return envLocationComparison ;
48+ }
49+
4450 // Check environment type.
45- const envTypeComparison = compareEnvironmentType ( a , b , this . workspaceFolderPath ) ;
51+ const envTypeComparison = compareEnvironmentType ( a , b ) ;
4652 if ( envTypeComparison !== 0 ) {
4753 return envTypeComparison ;
4854 }
@@ -53,20 +59,15 @@ export class EnvironmentTypeComparer implements IInterpreterComparer {
5359 return versionComparison ;
5460 }
5561
56- // Prioritize non- Conda environments .
57- if ( isCondaEnvironment ( a ) && ! isCondaEnvironment ( b ) ) {
62+ // If we have the "base" Conda env, put it last in its Python version subgroup .
63+ if ( isBaseCondaEnvironment ( a ) ) {
5864 return 1 ;
5965 }
6066
61- if ( ! isCondaEnvironment ( a ) && isCondaEnvironment ( b ) ) {
67+ if ( isBaseCondaEnvironment ( b ) ) {
6268 return - 1 ;
6369 }
6470
65- // If we have the "base" Conda env, put it last in its Python version subgroup.
66- if ( isBaseCondaEnvironment ( a ) ) {
67- return 1 ;
68- }
69-
7071 // Check alphabetical order.
7172 const nameA = getSortName ( a , this . interpreterHelper ) ;
7273 const nameB = getSortName ( b , this . interpreterHelper ) ;
@@ -76,6 +77,25 @@ export class EnvironmentTypeComparer implements IInterpreterComparer {
7677
7778 return nameA > nameB ? 1 : - 1 ;
7879 }
80+
81+ public getRecommended ( interpreters : PythonEnvironment [ ] , resource : Resource ) : PythonEnvironment | undefined {
82+ // When recommending an intepreter for a workspace, we either want to return a local one
83+ // or fallback on a globally-installed interpreter, and we don't want want to suggest a global environment
84+ // because we would have to add a way to match environments to a workspace.
85+ const workspaceUri = this . interpreterHelper . getActiveWorkspaceUri ( resource ) ;
86+ const filteredInterpreters = interpreters . filter ( ( i ) => {
87+ if ( getEnvLocationHeuristic ( i , workspaceUri ?. folderUri . fsPath || '' ) === EnvLocationHeuristic . Local ) {
88+ return true ;
89+ }
90+ if ( virtualEnvTypes . includes ( i . envType ) ) {
91+ // We're not sure if these envs were created for the workspace, so do not recommend them.
92+ return false ;
93+ }
94+ return true ;
95+ } ) ;
96+ filteredInterpreters . sort ( this . compare . bind ( this ) ) ;
97+ return filteredInterpreters . length ? filteredInterpreters [ 0 ] : undefined ;
98+ }
7999}
80100
81101function getSortName ( info : PythonEnvironment , interpreterHelper : IInterpreterHelper ) : string {
@@ -113,12 +133,11 @@ function getSortName(info: PythonEnvironment, interpreterHelper: IInterpreterHel
113133 return `${ sortNameParts . join ( ' ' ) } ${ envSuffix } . trim ( ) ;
114134}
115135
116- function isCondaEnvironment ( environment : PythonEnvironment ) : boolean {
117- return environment . envType === EnvironmentType . Conda ;
118- }
119-
120136function isBaseCondaEnvironment ( environment : PythonEnvironment ) : boolean {
121- return isCondaEnvironment ( environment ) && ( environment . envName === 'base' || environment . envName === 'miniconda' ) ;
137+ return (
138+ environment . envType === EnvironmentType . Conda &&
139+ ( environment . envName === 'base' || environment . envName === 'miniconda' )
140+ ) ;
122141}
123142
124143/**
@@ -151,40 +170,50 @@ function comparePythonVersionDescending(a: PythonVersion | undefined, b: PythonV
151170}
152171
153172/**
154- * Compare 2 environment types : return 0 if they are the same, -1 if a comes before b, 1 otherwise.
173+ * Compare 2 environment locations : return 0 if they are the same, -1 if a comes before b, 1 otherwise.
155174 */
156- function compareEnvironmentType ( a : PythonEnvironment , b : PythonEnvironment , workspacePath : string ) : number {
157- const aHeuristic = getEnvTypeHeuristic ( a , workspacePath ) ;
158- const bHeuristic = getEnvTypeHeuristic ( b , workspacePath ) ;
175+ function compareEnvironmentLocation ( a : PythonEnvironment , b : PythonEnvironment , workspacePath : string ) : number {
176+ const aHeuristic = getEnvLocationHeuristic ( a , workspacePath ) ;
177+ const bHeuristic = getEnvLocationHeuristic ( b , workspacePath ) ;
159178
160179 return Math . sign ( aHeuristic - bHeuristic ) ;
161180}
162181
163182/**
164183 * Return a heuristic value depending on the environment type.
165184 */
166- export function getEnvTypeHeuristic ( environment : PythonEnvironment , workspacePath : string ) : EnvTypeHeuristic {
167- const { envType } = environment ;
168-
185+ export function getEnvLocationHeuristic ( environment : PythonEnvironment , workspacePath : string ) : EnvLocationHeuristic {
169186 if (
170187 workspacePath . length > 0 &&
171188 ( ( environment . envPath && isParentPath ( environment . envPath , workspacePath ) ) ||
172189 ( environment . path && isParentPath ( environment . path , workspacePath ) ) )
173190 ) {
174- return EnvTypeHeuristic . Local ;
191+ return EnvLocationHeuristic . Local ;
175192 }
193+ return EnvLocationHeuristic . Global ;
194+ }
176195
177- switch ( envType ) {
178- case EnvironmentType . Venv :
179- case EnvironmentType . Conda :
180- case EnvironmentType . VirtualEnv :
181- case EnvironmentType . VirtualEnvWrapper :
182- case EnvironmentType . Pipenv :
183- case EnvironmentType . Poetry :
184- return EnvTypeHeuristic . Global ;
185- // The default case covers global environments.
186- // For now this includes: pyenv, Windows Store, Global, System and Unknown environment types.
187- default :
188- return EnvTypeHeuristic . GlobalInterpreters ;
189- }
196+ /**
197+ * Compare 2 environment types: return 0 if they are the same, -1 if a comes before b, 1 otherwise.
198+ */
199+ function compareEnvironmentType ( a : PythonEnvironment , b : PythonEnvironment ) : number {
200+ const envTypeByPriority = getPrioritizedEnvironmentType ( ) ;
201+ return Math . sign ( envTypeByPriority . indexOf ( a . envType ) - envTypeByPriority . indexOf ( b . envType ) ) ;
202+ }
203+
204+ function getPrioritizedEnvironmentType ( ) : EnvironmentType [ ] {
205+ return [
206+ // Prioritize non-Conda environments.
207+ EnvironmentType . Poetry ,
208+ EnvironmentType . Pipenv ,
209+ EnvironmentType . VirtualEnvWrapper ,
210+ EnvironmentType . Venv ,
211+ EnvironmentType . VirtualEnv ,
212+ EnvironmentType . Conda ,
213+ EnvironmentType . Pyenv ,
214+ EnvironmentType . WindowsStore ,
215+ EnvironmentType . Global ,
216+ EnvironmentType . System ,
217+ EnvironmentType . Unknown ,
218+ ] ;
190219}
0 commit comments