Merge pull request #425 from mbektas/conda_activate_using_root_env

activate conda env using base conda env

src/main/app.ts

@@ -36,6 +36,10 @@ export interface IApplication {
   saveState: (service: IStatefulService, data: JSONValue) => Promise<void>;
 
   getPythonEnvironment(): Promise<IPythonEnvironment>;
+
+  setCondaRootPath(condaRootPath: string): void;
+
+  getCondaRootPath(): Promise<string>;
 }
 
 /**
@@ -127,7 +131,8 @@ export class JupyterApplication implements IApplication, IStatefulService {
 
     this._applicationState = {
       checkForUpdatesAutomatically: true,
-      pythonPath: ''
+      pythonPath: '',
+      condaRootPath: ''
     };
 
     this.registerStatefulService(this).then(
@@ -168,6 +173,18 @@ export class JupyterApplication implements IApplication, IStatefulService {
     });
   }
 
+  setCondaRootPath(condaRootPath: string): void {
+    this._applicationState.condaRootPath = condaRootPath;
+  }
+
+  getCondaRootPath(): Promise<string> {
+    return new Promise<string>((resolve, _reject) => {
+      this._appState.then((state: JSONObject) => {
+        resolve(this._applicationState.condaRootPath);
+      });
+    });
+  }
+
   registerStatefulService(service: IStatefulService): Promise<JSONValue> {
     this._services.push(service);
 
@@ -630,6 +647,7 @@ export namespace JupyterApplication {
   export interface IState extends JSONObject {
     checkForUpdatesAutomatically?: boolean;
     pythonPath?: string;
+    condaRootPath?: string;
   }
 }
 

src/main/env_info.py

@@ -7,7 +7,8 @@
   env_type = 'venv'
 
 if env_type != 'venv' and os.path.exists(os.path.join(sys.prefix, "conda-meta")):
-  env_type = 'conda'
+  is_root = os.path.exists(os.path.join(sys.prefix, "condabin"))
+  env_type = 'conda-root' if is_root else 'conda-env'
 
 if env_type != 'system':
   env_name = os.path.basename(sys.prefix)

src/main/registry.ts

@@ -15,6 +15,7 @@ import { ArrayExt } from '@lumino/algorithm';
 import * as fs from 'fs';
 import log from 'electron-log';
 import {
+  EnvironmentTypeName,
   IEnvironmentType,
   IPythonEnvironment,
   IVersionContainer
@@ -38,6 +39,8 @@ export interface IRegistry {
 
   getEnvironmentList: () => Promise<IPythonEnvironment[]>;
 
+  getCondaEnvironments(): Promise<IPythonEnvironment[]>;
+
   addEnvironment: (path: string) => Promise<IPythonEnvironment>;
 
   getUserJupyterPath: () => Promise<IPythonEnvironment>;
@@ -46,6 +49,8 @@ export interface IRegistry {
 
   validatePythonEnvironmentAtPath: (path: string) => boolean;
 
+  validateCondaBaseEnvironmentAtPath: (envPath: string) => boolean;
+
   setDefaultPythonPath: (path: string) => void;
 
   getCurrentPythonEnvironment: () => IPythonEnvironment;
@@ -130,6 +135,7 @@ export class Registry implements IRegistry {
           this._setDefaultEnvironment(undefined);
         });
     } else {
+      this._condaEnvironments = this._loadCondaEnvironments();
       this._registryBuilt = Promise.resolve();
     }
   }
@@ -256,6 +262,14 @@ export class Registry implements IRegistry {
     });
   }
 
+  /**
+   * Retrieve the list of conda environments, once they have been resolved
+   * @returns a promise that resolves to a list of conda environments
+   */
+  getCondaEnvironments(): Promise<IPythonEnvironment[]> {
+    return this._condaEnvironments;
+  }
+
   /**
    * Create a new environment from a python executable, without waiting for the
    * entire registry to be resolved first.
@@ -317,6 +331,16 @@ export class Registry implements IRegistry {
     return true;
   }
 
+  validateCondaBaseEnvironmentAtPath(envPath: string): boolean {
+    const isWin = process.platform === 'win32';
+    const condaBinPath = path.join(
+      envPath,
+      'condabin',
+      isWin ? 'conda.bat' : 'conda'
+    );
+    return fs.existsSync(condaBinPath) && fs.lstatSync(condaBinPath).isFile();
+  }
+
   getEnvironmentInfo(pythonPath: string): IPythonEnvironment {
     const runOptions = {
       env: { PATH: this.getAdditionalPathIncludesForPythonPath(pythonPath) }
@@ -339,13 +363,16 @@ export class Registry implements IRegistry {
     );
     const envInfoOut = this._runCommandSync(pythonPath, ['-c', envInfoPyCode]);
     const envInfo = JSON.parse(envInfoOut.trim());
-    const envName = `${envInfo.type}: ${envInfo.name}`;
+    const envType =
+      envInfo.type === 'conda-root'
+        ? IEnvironmentType.CondaRoot
+        : envInfo.type === 'conda-env'
+        ? IEnvironmentType.CondaEnv
+        : IEnvironmentType.VirtualEnv;
+    const envName = `${EnvironmentTypeName[envType]}: ${envInfo.name}`;
 
     return {
-      type:
-        envInfo.type === 'conda'
-          ? IEnvironmentType.CondaEnv
-          : IEnvironmentType.VirtualEnv,
+      type: envType,
       name: envName,
       path: pythonPath,
       versions: { python: pythonVersion, jupyterlab: jlabVersion },
@@ -486,6 +513,13 @@ export class Registry implements IRegistry {
     );
 
     let allCondas = [pathCondas, commonCondas];
+
+    // add bundled conda env to the list of base conda envs
+    const bundledEnvPath = path.join(dirname(app.getAppPath()), 'jlab_server');
+    if (fs.existsSync(path.join(bundledEnvPath, 'condabin'))) {
+      allCondas.unshift(Promise.resolve([bundledEnvPath]));
+    }
+
     if (process.platform === 'win32') {
       allCondas.push(this._getWindowsRegistryCondas());
     }
@@ -1101,6 +1135,8 @@ export class Registry implements IRegistry {
 
   private _environments: IPythonEnvironment[] = [];
 
+  private _condaEnvironments: Promise<IPythonEnvironment[]>;
+
   private _default: IPythonEnvironment;
 
   private _registryBuilt: Promise<void>;