Merge pull request #30 from janschulz/rkernel_improvements

Rkernel improvements

Author: Cadair

environment_kernels/core.py

@@ -33,7 +33,7 @@ class EnvironmentKernelSpecManager(KernelSpecManager):
 
     # Check for the CONDA_ENV_PATH variable and add it to the list if set.
     if os.environ.get('CONDA_ENV_PATH', False):
-         _default_conda_dirs.append(os.environ['CONDA_ENV_PATH'].split('envs')[0])
+        _default_conda_dirs.append(os.environ['CONDA_ENV_PATH'].split('envs')[0])
 
     # If we are running inside the root conda env can get all the env dirs:
     if HAVE_CONDA:
@@ -106,13 +106,15 @@ class EnvironmentKernelSpecManager(KernelSpecManager):
     def __init__(self, *args, **kwargs):
         super(EnvironmentKernelSpecManager, self).__init__(*args, **kwargs)
         self.log.info("Using EnvironmentKernelSpecManager...")
+        self._env_data_cache = {}
         if self.refresh_interval > 0:
             try:
                 from tornado.ioloop import PeriodicCallback, IOLoop
                 # Initial loading NOW
-                IOLoop.current().call_later(0, callback=self._update_env_data)
+                IOLoop.current().call_later(0, callback=self._update_env_data, initial=True)
                 # Later updates
-                updater = PeriodicCallback(callback=self._update_env_data, callback_time=1000 * 60 * self.refresh_interval)
+                updater = PeriodicCallback(callback=self._update_env_data,
+                                           callback_time=1000 * 60 * self.refresh_interval)
                 updater.start()
                 if not updater.is_running():
                     raise Exception()
@@ -141,10 +143,13 @@ def validate_env(self, envname):
         else:
             return True
 
-    def _update_env_data(self):
-        self.log.info("Starting periodic scan of virtual environments...")
+    def _update_env_data(self, initial=False):
+        if initial:
+            self.log.info("Starting initial scan of virtual environments...")
+        else:
+            self.log.debug("Starting periodic scan of virtual environments...")
         self._get_env_data(reload=True)
-        self.log.debug("done...")
+        self.log.debug("done.")
 
     def _get_env_data(self, reload=False):
         """Get the data about the available environments.
@@ -153,16 +158,17 @@ def _get_env_data(self, reload=False):
         """
 
         # This is called much too often and finding-process is really expensive :-(
-        if not reload and hasattr(self, "_env_data_cache"):
+        if not reload and getattr(self, "_env_data_cache", {}):
             return getattr(self, "_env_data_cache")
 
         env_data = {}
         for supplyer in ENV_SUPPLYER:
             env_data.update(supplyer(self))
 
         env_data = {name: env_data[name] for name in env_data if self.validate_env(name)}
-        self.log.info("Found the following kernels in environments: %s",
-                      ", ".join(list(env_data)))
+        new_kernels = env_data.keys() - self._env_data_cache.keys()
+        if new_kernels:
+            self.log.info("Found new kernels in environments: %s", ", ".join(new_kernels))
 
         self._env_data_cache = env_data
         return env_data

environment_kernels/envs_common.py

@@ -33,9 +33,9 @@ def convert_to_env_data(mgr, env_paths, validator_func, activate_func,
         kernel_name = name_template.format(name_prefix + venv_name)
         kernel_name = kernel_name.lower()
         if kernel_name in env_data:
-            mgr.log.error(
-                "Duplicate env kernels: %s would both point to %s and %s. Using the first!",
-                kernel_name, env_data[kernel_name], venv_dir)
+            mgr.log.debug(
+                "Found duplicate env kernel: %s, which would again point to %s. Using the first!",
+                kernel_name, venv_dir)
             continue
         argv, language, resource_dir = validator_func(venv_dir)
         if not argv:
@@ -52,7 +52,7 @@ def convert_to_env_data(mgr, env_paths, validator_func, activate_func,
         def loader(env_dir=venv_dir, activate_func=activate_func, mgr=mgr):
             mgr.log.debug("Loading env data for %s" % env_dir)
             res = activate_func(mgr, env_dir)
-            #mgr.log.info("PATH: %s" % res['PATH'])
+            # mgr.log.info("PATH: %s" % res['PATH'])
             return res
 
         kspec = EnvironmentLoadingKernelSpec(loader, **kspec_dict)
@@ -100,19 +100,24 @@ def validate_IRkernel(venv_dir):
     Returns: tuple
         (ARGV, language, resource_dir)
     """
-    r_exe_name = find_exe(venv_dir, "r")
+    r_exe_name = find_exe(venv_dir, "R")
     if r_exe_name is None:
         return [], None, None
 
-    # check if this is really an ipython **kernel**
+    # check if this is really an IRkernel **kernel**
     import subprocess
+    ressources_dir = None
     try:
-        subprocess.check_call([r_exe_name, '--slave', '-e', 'library(IRkernel)'])
+        print_resources = 'cat(as.character(system.file("kernelspec", package = "IRkernel")))'
+        resources_dir_bytes = subprocess.check_output([r_exe_name, '--slave', '-e', print_resources])
+        resources_dir = resources_dir_bytes.decode(errors='ignore')
     except:
         # not installed? -> not useable in any case...
         return [], None, None
     argv = [r_exe_name, "--slave", "-e", "IRkernel::main()", "--args", "{connection_file}"]
-    resources_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "logos", "r")
+    if not os.path.exists(resources_dir.strip()):
+        # Fallback to our own log, but don't get the nice js goodies...
+        resources_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "logos", "r")
     return argv, "r", resources_dir
 
 

environment_kernels/envs_conda.py

@@ -15,13 +15,14 @@ def get_conda_env_data(mgr):
     if not mgr.find_conda_envs:
         return {}
 
-    mgr.log.info("Looking for conda environments (python)...")
+    mgr.log.debug("Looking for conda environments in %s...", mgr.conda_env_dirs)
 
     # find all potential env paths
     env_paths = find_env_paths_in_basedirs(mgr.conda_env_dirs)
     env_paths.extend(_find_conda_env_paths_from_conda(mgr))
     env_paths = list(set(env_paths)) # remove duplicates
 
+    mgr.log.debug("Scanning conda environments for python kernels...")
     env_data = convert_to_env_data(mgr=mgr,
                                    env_paths=env_paths,
                                    validator_func=validate_IPykernel,
@@ -30,7 +31,7 @@ def get_conda_env_data(mgr):
                                    display_name_template=mgr.display_name_template,
                                    name_prefix="")  # lets keep the py kernels without a prefix...
     if mgr.find_r_envs:
-        mgr.log.info("Looking for conda environments (R)...")
+        mgr.log.debug("Scanning conda environments for R kernels...")
         env_data.update(convert_to_env_data(mgr=mgr,
                                             env_paths=env_paths,
                                             validator_func=validate_IRkernel,
@@ -66,7 +67,7 @@ def _find_conda_env_paths_from_conda(mgr):
     # this is expensive, so make it configureable...
     if not mgr.use_conda_directly:
         return []
-    mgr.log.info("Looking for conda environments by calling conda directly...")
+    mgr.log.debug("Looking for conda environments by calling conda directly...")
     import subprocess
     import json
     try:

environment_kernels/envs_virtualenv.py

@@ -8,6 +8,7 @@
 from .activate_helper import source_env_vars_from_command
 from .envs_common import find_env_paths_in_basedirs, convert_to_env_data, validate_IPykernel
 
+
 def get_virtualenv_env_data(mgr):
     """Finds kernel specs from virtualenv environments
 
@@ -17,19 +18,20 @@ def get_virtualenv_env_data(mgr):
     if not mgr.find_virtualenv_envs:
         return {}
 
-    mgr.log.info("Looking for virtualenv environments...")
+    mgr.log.debug("Looking for virtualenv environments in %s...", mgr.virtualenv_env_dirs)
 
     # find all potential env paths
     env_paths = find_env_paths_in_basedirs(mgr.virtualenv_env_dirs)
 
+    mgr.log.debug("Scanning virtualenv environments for python kernels...")
     env_data = convert_to_env_data(mgr=mgr,
                                    env_paths=env_paths,
                                    validator_func=validate_IPykernel,
                                    activate_func=_get_env_vars_for_virtualenv_env,
                                    name_template=mgr.conda_prefix_template,
                                    display_name_template=mgr.display_name_template,
                                    name_prefix="")  # virtualenv has only python, so no need for a
-                                                    # prefix
+    # prefix
     return env_data
 
 
@@ -40,7 +42,7 @@ def _get_env_vars_for_virtualenv_env(mgr, env_path):
         args = ['source', os.path.join(env_path, "bin", "activate")]
     try:
         envs = source_env_vars_from_command(args)
-        #mgr.log.debug("Environment variables: %s", envs)
+        # mgr.log.debug("Environment variables: %s", envs)
         return envs
     except:
         # as a fallback, don't activate...