Rename kernel finders -> kernel providers

MetaKernelFinder -> KernelFinder

Author: takluyver

jupyter_client/discovery.py

@@ -8,8 +8,8 @@
 
 log = logging.getLogger(__name__)
 
-class KernelFinderBase(six.with_metaclass(ABCMeta, object)):
-    id = None  # Should be a short string identifying the finder class.
+class KernelProviderBase(six.with_metaclass(ABCMeta, object)):
+    id = None  # Should be a short string identifying the provider class.
 
     @abstractmethod
     def find_kernels(self):
@@ -24,7 +24,7 @@ def make_manager(self, name):
         """
         pass
 
-class KernelSpecFinder(KernelFinderBase):
+class KernelSpecProvider(KernelProviderBase):
     """Find kernels from installed kernelspec directories.
     """
     id = 'spec'
@@ -47,7 +47,7 @@ def make_manager(self, name):
         return KernelManager(kernel_cmd=spec.argv, extra_env=spec.env)
 
 
-class IPykernelFinder(KernelFinderBase):
+class IPykernelProvider(KernelProviderBase):
     """Find ipykernel on this Python version by trying to import it.
     """
     id = 'pyimport'
@@ -82,31 +82,46 @@ def make_manager(self, name):
         return KernelManager(kernel_cmd=info['spec']['argv'])
 
 
-class MetaKernelFinder(object):
-    def __init__(self, finders):
-        self.finders = finders
+class KernelFinder(object):
+    """Manages a collection of kernel providers to find available kernels
+    """
+    def __init__(self, providers):
+        self.providers = providers
 
     @classmethod
     def from_entrypoints(cls):
-        finders = []
-        for ep in entrypoints.get_group_all('jupyter_client.kernel_finders'):
+        """Load all kernel providers advertised by entry points.
+
+        Kernel providers should use the "jupyter_client.kernel_providers"
+        entry point group.
+
+        Returns an instance of KernelFinder.
+        """
+        providers = []
+        for ep in entrypoints.get_group_all('jupyter_client.kernel_providers'):
             try:
-                finder = ep.load()()  # Load and instantiate
+                provider = ep.load()()  # Load and instantiate
             except Exception:
-                log.error('Error loading kernel finder', exc_info=True)
+                log.error('Error loading kernel provider', exc_info=True)
             else:
-                finders.append(finder)
+                providers.append(provider)
 
-        return cls(finders)
+        return cls(providers)
 
     def find_kernels(self):
-        for finder in self.finders:
-            for kid, attributes in finder.find_kernels():
-                id = finder.id + '/' + kid
+        """Iterate over available kernels.
+
+        Yields 2-tuples of (id_str, attributes)
+        """
+        for provider in self.providers:
+            for kid, attributes in provider.find_kernels():
+                id = provider.id + '/' + kid
                 yield id, attributes
 
     def make_manager(self, id):
-        finder_id, kernel_id = id.split('/', 1)
-        for finder in self.finders:
-            if finder_id == finder.id:
-                return finder.make_manager(kernel_id)
+        """Make a KernelManager instance for a given kernel ID.
+        """
+        provider_id, kernel_id = id.split('/', 1)
+        for provider in self.providers:
+            if provider_id == provider.id:
+                return provider.make_manager(kernel_id)

jupyter_client/tests/test_discovery.py

@@ -3,18 +3,18 @@
 from jupyter_client import KernelManager
 from jupyter_client import discovery
 
-def test_ipykernel_finder():
+def test_ipykernel_provider():
     import ipykernel  # Fail clearly if ipykernel not installed
-    ikf = discovery.IPykernelFinder()
+    ikf = discovery.IPykernelProvider()
 
     res = list(ikf.find_kernels())
     assert len(res) == 1, res
     id, info = res[0]
     assert id == 'kernel'
     assert info['argv'][0] == sys.executable
 
-class DummyKernelFinder(discovery.KernelFinderBase):
-    """A dummy kernel finder for testing MetaKernelFinder"""
+class DummyKernelProvider(discovery.KernelProviderBase):
+    """A dummy kernel provider for testing KernelFinder"""
     id = 'dummy'
 
     def find_kernels(self):
@@ -24,9 +24,9 @@ def make_manager(self, name):
         return KernelManager(kernel_cmd=['dummy_kernel'])
 
 def test_meta_kernel_finder():
-    mkf = discovery.MetaKernelFinder(finders=[DummyKernelFinder()])
-    assert list(mkf.find_kernels()) == \
+    kf = discovery.KernelFinder(providers=[DummyKernelProvider()])
+    assert list(kf.find_kernels()) == \
         [('dummy/sample', {'argv': ['dummy_kernel']})]
 
-    manager = mkf.make_manager('dummy/sample')
+    manager = kf.make_manager('dummy/sample')
     assert manager.kernel_cmd == ['dummy_kernel']

setup.py

@@ -94,7 +94,7 @@ def run(self):
             'jupyter-kernelspec = jupyter_client.kernelspecapp:KernelSpecApp.launch_instance',
             'jupyter-run = jupyter_client.runapp:RunApp.launch_instance',
         ],
-        'jupyter_client.kernel_finders' : [
+        'jupyter_client.kernel_providers' : [
             'spec = jupyter_client.discovery:KernelSpecFinder',
             'pyimport = jupyter_client.discovery:IPykernelFinder',
         ]