Fix wait_for_ready() dying early for slow-starting kernels

KernelClient.is_alive() checks heartbeat responsiveness,
so it be False early on if the kernel process is slow to start.
This can cause `wait_for_ready` to falsely claim the Kernel died before it has finished starting up.

The fix is two-fold:

1. Use KernelManager.is_alive when Manager is available (most of the time).
   This isn't sensitive to slow startup.
2. When Manager isn't available, wait for `is_alive()` to become True at least once before entering the wait for the ready-reply.

Author: minrk

jupyter_client/blocking/client.py

@@ -34,6 +34,15 @@ def wait_for_ready(self, timeout=None):
         else:
             abs_timeout = time.time() + timeout
 
+        from ..manager import KernelManager
+        if not isinstance(self.parent, KernelManager):
+            # We aren't connected to a manager,
+            # so first wait for kernel to become responsive to heartbeats
+            while not self.is_alive():
+                if time.time() > abs_timeout:
+                    raise RuntimeError("Kernel didn't respond to heartbeats in %d seconds" % timeout)
+                time.sleep(0.2)
+
         # Wait for kernel info reply on shell channel
         while True:
             try:

jupyter_client/client.py

@@ -181,9 +181,13 @@ def hb_channel(self):
 
     def is_alive(self):
         """Is the kernel process still running?"""
+        from .manager import KernelManager
+        if isinstance(self.parent, KernelManager):
+            # We were created by a KernelManager, we can ask them:
+            return self.parent.is_alive()
         if self._hb_channel is not None:
-            # We didn't start the kernel with this KernelManager so we
-            # use the heartbeat.
+            # We don't have access to the KernelManager,
+            # so we use the heartbeat.
             return self._hb_channel.is_beating()
         else:
             # no heartbeat and not local, we can't tell if it's running,