move client code from IPython.kernel to jupyter_client

jupyter_client/adapter.py

@@ -12,7 +12,7 b' from IPython.utils.tokenutil import token_at_cursor'
 def code_to_line(code, cursor_pos):
     """Turn a multiline code block and cursor position into a single line
     and new cursor position.
-    
+
     For adapting ``complete_`` and ``object_info_request``.
     """
     if not code:
@@ -28,42 +28,42 b' def code_to_line(code, cursor_pos):'
 
 class Adapter(object):
     """Base class for adapting messages
-    
+
     Override message_type(msg) methods to create adapters.
     """
-    
+
     msg_type_map = {}
-    
+
     def update_header(self, msg):
         return msg
-    
+
     def update_metadata(self, msg):
         return msg
-    
+
     def update_msg_type(self, msg):
         header = msg['header']
         msg_type = header['msg_type']
         if msg_type in self.msg_type_map:
             msg['msg_type'] = header['msg_type'] = self.msg_type_map[msg_type]
         return msg
-    
+
     def handle_reply_status_error(self, msg):
         """This will be called *instead of* the regular handler
-        
+
         on any reply with status != ok
         """
         return msg
-    
+
     def __call__(self, msg):
         msg = self.update_header(msg)
         msg = self.update_metadata(msg)
         msg = self.update_msg_type(msg)
         header = msg['header']
-        
+
         handler = getattr(self, header['msg_type'], None)
         if handler is None:
             return msg
-        
+
         # handle status=error replies separately (no change, at present)
         if msg['content'].get('status', None) in {'error', 'aborted'}:
             return self.handle_reply_status_error(msg)
@@ -71,7 +71,7 b' class Adapter(object):'
 
 def _version_str_to_list(version):
     """convert a version string to a list of ints
-    
+
     non-int segments are excluded
     """
     v = []
@@ -84,9 +84,9 b' def _version_str_to_list(version):'
 
 class V5toV4(Adapter):
     """Adapt msg protocol v5 to v4"""
-    
+
     version = '4.1'
-    
+
     msg_type_map = {
         'execute_result' : 'pyout',
         'execute_input' : 'pyin',
@@ -94,13 +94,13 b' class V5toV4(Adapter):'
         'inspect_request' : 'object_info_request',
         'inspect_reply' : 'object_info_reply',
     }
-    
+
     def update_header(self, msg):
         msg['header'].pop('version', None)
         return msg
-    
+
     # shell channel
-    
+
     def kernel_info_reply(self, msg):
         v4c = {}
         content = msg['content']
@@ -117,31 +117,31 b' class V5toV4(Adapter):'
             v4c.setdefault('language_version', _version_str_to_list(language_info['version']))
         msg['content'] = v4c
         return msg
-    
+
     def execute_request(self, msg):
         content = msg['content']
         content.setdefault('user_variables', [])
         return msg
-    
+
     def execute_reply(self, msg):
         content = msg['content']
         content.setdefault('user_variables', {})
         # TODO: handle payloads
         return msg
-    
+
     def complete_request(self, msg):
         content = msg['content']
         code = content['code']
         cursor_pos = content['cursor_pos']
         line, cursor_pos = code_to_line(code, cursor_pos)
-        
+
         new_content = msg['content'] = {}
         new_content['text'] = ''
         new_content['line'] = line
         new_content['block'] = None
         new_content['cursor_pos'] = cursor_pos
         return msg
-    
+
     def complete_reply(self, msg):
         content = msg['content']
         cursor_start = content.pop('cursor_start')
@@ -150,25 +150,25 b' class V5toV4(Adapter):'
         content['matched_text'] = content['matches'][0][:match_len]
         content.pop('metadata', None)
         return msg
-    
+
     def object_info_request(self, msg):
         content = msg['content']
         code = content['code']
         cursor_pos = content['cursor_pos']
         line, _ = code_to_line(code, cursor_pos)
-        
+
         new_content = msg['content'] = {}
         new_content['oname'] = token_at_cursor(code, cursor_pos)
         new_content['detail_level'] = content['detail_level']
         return msg
-    
+
     def object_info_reply(self, msg):
         """inspect_reply can't be easily backward compatible"""
         msg['content'] = {'found' : False, 'oname' : 'unknown'}
         return msg
-    
+
     # iopub channel
-    
+
     def stream(self, msg):
         content = msg['content']
         content['data'] = content.pop('text')
@@ -185,9 +185,9 b' class V5toV4(Adapter):'
                 # warn?
                 pass
         return msg
-    
+
     # stdin channel
-    
+
     def input_request(self, msg):
         msg['content'].pop('password', None)
         return msg
@@ -196,38 +196,38 b' class V5toV4(Adapter):'
 class V4toV5(Adapter):
     """Convert msg spec V4 to V5"""
     version = '5.0'
-    
+
     # invert message renames above
     msg_type_map = {v:k for k,v in V5toV4.msg_type_map.items()}
-    
+
     def update_header(self, msg):
         msg['header']['version'] = self.version
         return msg
-    
+
     # shell channel
-    
+
     def kernel_info_reply(self, msg):
         content = msg['content']
         for key in ('protocol_version', 'ipython_version'):
             if key in content:
                 content[key] = '.'.join(map(str, content[key]))
-        
+
         content.setdefault('protocol_version', '4.1')
-        
+
         if content['language'].startswith('python') and 'ipython_version' in content:
             content['implementation'] = 'ipython'
             content['implementation_version'] = content.pop('ipython_version')
-        
+
         language = content.pop('language')
         language_info = content.setdefault('language_info', {})
         language_info.setdefault('name', language)
         if 'language_version' in content:
             language_version = '.'.join(map(str, content.pop('language_version')))
             language_info.setdefault('version', language_version)
-        
+
         content['banner'] = ''
         return msg
-    
+
     def execute_request(self, msg):
         content = msg['content']
         user_variables = content.pop('user_variables', [])
@@ -235,7 +235,7 b' class V4toV5(Adapter):'
         for v in user_variables:
             user_expressions[v] = v
         return msg
-    
+
     def execute_reply(self, msg):
         content = msg['content']
         user_expressions = content.setdefault('user_expressions', {})
@@ -251,15 +251,15 b' class V4toV5(Adapter):'
                 payload['data']['text/plain'] = payload.pop('text')
 
         return msg
-    
+
     def complete_request(self, msg):
         old_content = msg['content']
-        
+
         new_content = msg['content'] = {}
         new_content['code'] = old_content['line']
         new_content['cursor_pos'] = old_content['cursor_pos']
         return msg
-    
+
     def complete_reply(self, msg):
         # complete_reply needs more context than we have to get cursor_start and end.
         # use special end=null to indicate current cursor position and negative offset
@@ -276,17 +276,17 b' class V4toV5(Adapter):'
         new_content['cursor_end'] = None
         new_content['metadata'] = {}
         return msg
-    
+
     def inspect_request(self, msg):
         content = msg['content']
         name = content['oname']
-        
+
         new_content = msg['content'] = {}
         new_content['code'] = name
         new_content['cursor_pos'] = len(name)
         new_content['detail_level'] = content['detail_level']
         return msg
-    
+
     def inspect_reply(self, msg):
         """inspect_reply can't be easily backward compatible"""
         content = msg['content']
@@ -309,9 +309,9 b' class V4toV5(Adapter):'
                 lines.append("<empty docstring>")
             data['text/plain'] = '\n'.join(lines)
         return msg
-    
+
     # iopub channel
-    
+
     def stream(self, msg):
         content = msg['content']
         content['text'] = content.pop('data')
@@ -328,30 +328,30 b' class V4toV5(Adapter):'
                 # warn?
                 pass
         return msg
-    
+
     # stdin channel
-    
+
     def input_request(self, msg):
         msg['content'].setdefault('password', False)
         return msg
-    
+
 
 
 def adapt(msg, to_version=kernel_protocol_version_info[0]):
     """Adapt a single message to a target version
-    
+
     Parameters
     ----------
-    
+
     msg : dict
         An IPython message.
     to_version : int, optional
         The target major version.
         If unspecified, adapt to the current version for IPython.
-    
+
     Returns
     -------
-    
+
     msg : dict
         An IPython message appropriate in the new version.
     """

jupyter_client/blocking/channels.py

@@ -89,4 +89,3 b' class ZMQSocketChannel(object):'
 
     def start(self):
         pass
-

jupyter_client/connect.py

@@ -44,7 +44,7 b' def write_connection_file(fname=None, shell_port=0, iopub_port=0, stdin_port=0, '
                          signature_scheme='hmac-sha256',
                          ):
     """Generates a JSON config file, including the selection of random ports.
-    
+
     Parameters
     ----------
 
@@ -71,7 +71,7 b' def write_connection_file(fname=None, shell_port=0, iopub_port=0, stdin_port=0, '
 
     key : str, optional
         The Session key used for message authentication.
-    
+
     signature_scheme : str, optional
         The scheme used for message authentication.
         This has the form 'digest-hash', where 'digest'
@@ -87,9 +87,9 b' def write_connection_file(fname=None, shell_port=0, iopub_port=0, stdin_port=0, '
     if not fname:
         fd, fname = tempfile.mkstemp('.json')
         os.close(fd)
-    
+
     # Find open ports as necessary.
-    
+
     ports = []
     ports_needed = int(shell_port <= 0) + \
                    int(iopub_port <= 0) + \
@@ -124,7 +124,7 b' def write_connection_file(fname=None, shell_port=0, iopub_port=0, stdin_port=0, '
         control_port = ports.pop(0)
     if hb_port <= 0:
         hb_port = ports.pop(0)
-    
+
     cfg = dict( shell_port=shell_port,
                 iopub_port=iopub_port,
                 stdin_port=stdin_port,
@@ -135,16 +135,16 b' def write_connection_file(fname=None, shell_port=0, iopub_port=0, stdin_port=0, '
     cfg['key'] = bytes_to_str(key)
     cfg['transport'] = transport
     cfg['signature_scheme'] = signature_scheme
-    
+
     with open(fname, 'w') as f:
         f.write(json.dumps(cfg, indent=2))
-    
+
     return fname, cfg
 
 
 def get_connection_file(app=None):
     """Return the path to the connection file of an app
-    
+
     Parameters
     ----------
     app : IPKernelApp instance [optional]
@@ -161,18 +161,18 b' def get_connection_file(app=None):'
 
 def find_connection_file(filename='kernel-*.json', profile=None):
     """find a connection file, and return its absolute path.
-    
+
     The current working directory and the profile's security
     directory will be searched for the file if it is not given by
     absolute path.
-    
+
     If profile is unspecified, then the current running application's
     profile will be used, or 'default', if not run from IPython.
-    
+
     If the argument does not match an existing file, it will be interpreted as a
     fileglob, and the matching file in the profile's security dir with
     the latest access time will be used.
-    
+
     Parameters
     ----------
     filename : str
@@ -180,7 +180,7 b" def find_connection_file(filename='kernel-*.json', profile=None):"
     profile : str [optional]
         The name of the profile to use when searching for the connection file,
         if different from the current IPython session or 'default'.
-    
+
     Returns
     -------
     str : The absolute path of the connection file.
@@ -191,7 +191,7 b" def find_connection_file(filename='kernel-*.json', profile=None):"
         return filefind(filename)
     except IOError:
         pass
-    
+
     if profile is None:
         # profile unspecified, check if running from an IPython app
         if IPApp.initialized():
@@ -204,15 +204,15 b" def find_connection_file(filename='kernel-*.json', profile=None):"
         # find profiledir by profile name:
         profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile)
     security_dir = profile_dir.security_dir
-    
+
     try:
         # first, try explicit name
         return filefind(filename, ['.', security_dir])
     except IOError:
         pass
-    
+
     # not found by full name
-    
+
     if '*' in filename:
         # given as a glob already
         pat = filename
@@ -231,14 +231,14 b" def find_connection_file(filename='kernel-*.json', profile=None):"
 
 def get_connection_info(connection_file=None, unpack=False, profile=None):
     """Return the connection information for the current Kernel.
-    
+
     Parameters
     ----------
     connection_file : str [optional]
         The connection file to be used. Can be given by absolute path, or
         IPython will search in the security directory of a given profile.
-        If run from IPython, 
-        
+        If run from IPython,
+
         If unspecified, the connection file for the currently running
         IPython Kernel will be used, which is only allowed from inside a kernel.
     unpack : bool [default: False]
@@ -247,8 +247,8 b' def get_connection_info(connection_file=None, unpack=False, profile=None):'
     profile : str [optional]
         The name of the profile to use when searching for the connection file,
         if different from the current IPython session or 'default'.
-        
-    
+
+
     Returns
     -------
     The connection dictionary of the current kernel, as string or dict,
@@ -260,10 +260,10 b' def get_connection_info(connection_file=None, unpack=False, profile=None):'
     else:
         # connection file specified, allow shortnames:
         cf = find_connection_file(connection_file, profile=profile)
-    
+
     with open(cf) as f:
         info = f.read()
-    
+
     if unpack:
         info = json.loads(info)
         # ensure key is bytes:
@@ -273,17 +273,17 b' def get_connection_info(connection_file=None, unpack=False, profile=None):'
 
 def connect_qtconsole(connection_file=None, argv=None, profile=None):
     """Connect a qtconsole to the current kernel.
-    
+
     This is useful for connecting a second qtconsole to a kernel, or to a
     local notebook.
-    
+
     Parameters
     ----------
     connection_file : str [optional]
         The connection file to be used. Can be given by absolute path, or
         IPython will search in the security directory of a given profile.
-        If run from IPython, 
-        
+        If run from IPython,
+
         If unspecified, the connection file for the currently running
         IPython Kernel will be used, which is only allowed from inside a kernel.
     argv : list [optional]
@@ -291,25 +291,25 b' def connect_qtconsole(connection_file=None, argv=None, profile=None):'
     profile : str [optional]
         The name of the profile to use when searching for the connection file,
         if different from the current IPython session or 'default'.
-    
-    
+
+
     Returns
     -------
     :class:`subprocess.Popen` instance running the qtconsole frontend
     """
     argv = [] if argv is None else argv
-    
+
     if connection_file is None:
         # get connection file from current kernel
         cf = get_connection_file()
     else:
         cf = find_connection_file(connection_file, profile=profile)
-    
+
     cmd = ';'.join([
         "from IPython.qt.console import qtconsoleapp",
         "qtconsoleapp.main()"
     ])
-    
+
     return Popen([sys.executable, '-c', cmd, '--existing', cf] + argv,
         stdout=PIPE, stderr=PIPE, close_fds=(sys.platform != 'win32'),
     )
@@ -317,12 +317,12 b' def connect_qtconsole(connection_file=None, argv=None, profile=None):'
 
 def tunnel_to_kernel(connection_info, sshserver, sshkey=None):
     """tunnel connections to a kernel via ssh
-    
+
     This will open four SSH tunnels from localhost on this machine to the
     ports associated with the kernel.  They can be either direct
     localhost-localhost tunnels, or if an intermediate server is necessary,
     the kernel must be listening on a public IP.
-    
+
     Parameters
     ----------
     connection_info : dict or str (path)
@@ -334,10 +334,10 b' def tunnel_to_kernel(connection_info, sshserver, sshkey=None):'
         Path to file containing ssh key to use for authentication.
         Only necessary if your ssh config does not already associate
         a keyfile with the host.
-    
+
     Returns
     -------
-    
+
     (shell, iopub, stdin, hb) : ints
         The four ports on localhost that have been forwarded to the kernel.
     """
@@ -346,22 +346,22 b' def tunnel_to_kernel(connection_info, sshserver, sshkey=None):'
         # it's a path, unpack it
         with open(connection_info) as f:
             connection_info = json.loads(f.read())
-    
+
     cf = connection_info
-    
+
     lports = tunnel.select_random_ports(4)
     rports = cf['shell_port'], cf['iopub_port'], cf['stdin_port'], cf['hb_port']
-    
+
     remote_ip = cf['ip']
-    
+
     if tunnel.try_passwordless_ssh(sshserver, sshkey):
         password=False
     else:
         password = getpass("SSH Password for %s: " % cast_bytes_py2(sshserver))
-    
+
     for lp,rp in zip(lports, rports):
         tunnel.ssh_tunnel(lp, rp, sshserver, remote_ip, sshkey, password)
-    
+
     return tuple(lports)
 
 
@@ -383,9 +383,9 b' class ConnectionFileMixin(LoggingConfigurable):'
     """Mixin for configurable classes that work with connection files"""
 
     # The addresses for the communication channels
-    connection_file = Unicode('', config=True, 
+    connection_file = Unicode('', config=True,
     help="""JSON file in which to store connection info [default: kernel-<pid>.json]
-    
+
     This file will contain the IP, ports, and authentication key needed to connect
     clients to this kernel. By default, this file will be created in the security dir
     of the current profile, but can be specified by absolute path.
@@ -504,12 +504,12 b' class ConnectionFileMixin(LoggingConfigurable):'
             cfg = json.load(f)
         self.transport = cfg.get('transport', self.transport)
         self.ip = cfg.get('ip', self._ip_default())
-        
+
         for name in port_names:
             if getattr(self, name) == 0 and name in cfg:
                 # not overridden by config or cl_args
                 setattr(self, name, cfg[name])
-        
+
         if 'key' in cfg:
             self.session.key = str_to_bytes(cfg['key'])
         if 'signature_scheme' in cfg:

jupyter_client/ioloop/restarter.py

@@ -51,4 +51,3 b' class IOLoopKernelRestarter(KernelRestarter):'
         if self._pcallback is not None:
             self._pcallback.stop()
             self._pcallback = None
-

jupyter_client/kernelspec.py

@@ -22,7 +22,7 b' else:'
     SYSTEM_KERNEL_DIRS = ["/usr/share/jupyter/kernels",
                           "/usr/local/share/jupyter/kernels",
                          ]
-    
+
 NATIVE_KERNEL_NAME = 'python3' if PY3 else 'python2'
 
 def _pythonfirst(s):
@@ -40,18 +40,18 b' class KernelSpec(HasTraits):'
     language = Unicode()
     env = Dict()
     resource_dir = Unicode()
-    
+
     @classmethod
     def from_resource_dir(cls, resource_dir):
         """Create a KernelSpec object by reading kernel.json
-        
+
         Pass the path to the *directory* containing kernel.json.
         """
         kernel_file = pjoin(resource_dir, 'kernel.json')
         with io.open(kernel_file, 'r', encoding='utf-8') as f:
             kernel_dict = json.load(f)
         return cls(resource_dir=resource_dir, **kernel_dict)
-    
+
     def to_dict(self):
         d = dict(argv=self.argv,
                  env=self.env,
@@ -70,7 +70,7 b' def _is_kernel_dir(path):'
 
 def _list_kernels_in(dir):
     """Return a mapping of kernel names to resource directories from dir.
-    
+
     If dir is None or does not exist, returns an empty dict.
     """
     if dir is None or not os.path.isdir(dir):
@@ -94,15 +94,15 b' class KernelSpecManager(Configurable):'
     @property
     def env_kernel_dir(self):
         return pjoin(sys.prefix, 'share', 'jupyter', 'kernels')
-    
+
     whitelist = Set(config=True,
         help="""Whitelist of allowed kernel names.
-        
+
         By default, all installed kernels are allowed.
         """
     )
     kernel_dirs = List(
-        help="List of kernel directories to search. Later ones take priority over earlier."    
+        help="List of kernel directories to search. Later ones take priority over earlier."
     )
     def _kernel_dirs_default(self):
         dirs = SYSTEM_KERNEL_DIRS[:]
@@ -114,7 +114,7 b' class KernelSpecManager(Configurable):'
     @property
     def _native_kernel_dict(self):
         """Makes a kernel directory for the native kernel.
-        
+
         The native kernel is the kernel using the same Python runtime as this
         process. This will put its information in the user kernels directory.
         """
@@ -143,7 +143,7 b' class KernelSpecManager(Configurable):'
 
     def get_kernel_spec(self, kernel_name):
         """Returns a :class:`KernelSpec` instance for the given kernel_name.
-        
+
         Raises :exc:`NoSuchKernel` if the given kernel name is not found.
         """
         if kernel_name in {'python', NATIVE_KERNEL_NAME} and \
@@ -157,7 +157,7 b' class KernelSpecManager(Configurable):'
         except KeyError:
             raise NoSuchKernel(kernel_name)
         return KernelSpec.from_resource_dir(resource_dir)
-    
+
     def _get_destination_dir(self, kernel_name, user=False):
         if user:
             return os.path.join(self.user_kernel_dir, kernel_name)
@@ -171,14 +171,14 b' class KernelSpecManager(Configurable):'
     def install_kernel_spec(self, source_dir, kernel_name=None, user=False,
                             replace=False):
         """Install a kernel spec by copying its directory.
-        
+
         If ``kernel_name`` is not given, the basename of ``source_dir`` will
         be used.
-        
+
         If ``user`` is False, it will attempt to install into the systemwide
         kernel registry. If the process does not have appropriate permissions,
         an :exc:`OSError` will be raised.
-        
+
         If ``replace`` is True, this will replace an existing kernel of the same
         name. Otherwise, if the destination already exists, an :exc:`OSError`
         will be raised.
@@ -186,7 +186,7 b' class KernelSpecManager(Configurable):'
         if not kernel_name:
             kernel_name = os.path.basename(source_dir)
         kernel_name = kernel_name.lower()
-        
+
         destination = self._get_destination_dir(kernel_name, user=user)
 
         if replace and os.path.isdir(destination):
@@ -196,13 +196,13 b' class KernelSpecManager(Configurable):'
 
     def install_native_kernel_spec(self, user=False):
         """Install the native kernel spec to the filesystem
-        
+
         This allows a Python 3 frontend to use a Python 2 kernel, or vice versa.
         The kernelspec will be written pointing to the Python executable on
         which this is run.
-        
+
         If ``user`` is False, it will attempt to install into the systemwide
-        kernel registry. If the process does not have appropriate permissions, 
+        kernel registry. If the process does not have appropriate permissions,
         an :exc:`OSError` will be raised.
         """
         path = self._get_destination_dir(NATIVE_KERNEL_NAME, user=user)
@@ -220,7 +220,7 b' def find_kernel_specs():'
 
 def get_kernel_spec(kernel_name):
     """Returns a :class:`KernelSpec` instance for the given kernel_name.
-    
+
     Raises KeyError if the given kernel name is not found.
     """
     return KernelSpecManager().get_kernel_spec(kernel_name)

jupyter_client/launcher.py

@@ -14,35 +14,35 b' from IPython.utils.py3compat import cast_bytes_py2'
 
 def swallow_argv(argv, aliases=None, flags=None):
     """strip frontend-specific aliases and flags from an argument list
-    
+
     For use primarily in frontend apps that want to pass a subset of command-line
     arguments through to a subprocess, where frontend-specific flags and aliases
     should be removed from the list.
-    
+
     Parameters
     ----------
-    
+
     argv : list(str)
         The starting argv, to be filtered
     aliases : container of aliases (dict, list, set, etc.)
         The frontend-specific aliases to be removed
     flags : container of flags (dict, list, set, etc.)
         The frontend-specific flags to be removed
-    
+
     Returns
     -------
-    
+
     argv : list(str)
         The argv list, excluding flags and aliases that have been stripped
     """
-    
+
     if aliases is None:
         aliases = set()
     if flags is None:
         flags = set()
-    
+
     stripped = list(argv) # copy
-    
+
     swallow_next = False
     was_flag = False
     for a in argv:
@@ -73,7 +73,7 b' def swallow_argv(argv, aliases=None, flags=None):'
             elif len(split) == 1 and any(flag.startswith(name) for flag in flags):
                 # strip flag, but don't swallow next, as flags don't take args
                 stripped.remove(a)
-    
+
     # return shortened list
     return stripped
 
@@ -91,17 +91,17 b" def make_ipkernel_cmd(mod='IPython.kernel', executable=None, extra_arguments=[],"
 
     extra_arguments : list, optional
         A list of extra arguments to pass when executing the launch code.
-    
+
     Returns
     -------
-    
+
     A Popen command list
     """
     if executable is None:
         executable = sys.executable
     arguments = [ executable, '-m', mod, '-f', '{connection_file}' ]
     arguments.extend(extra_arguments)
-    
+
     return arguments
 
 
@@ -131,7 +131,7 b' def launch_kernel(cmd, stdin=None, stdout=None, stderr=None, env=None,'
 
     Returns
     -------
-    
+
     Popen instance for the kernel subprocess
     """
 
@@ -155,7 +155,7 b' def launch_kernel(cmd, stdin=None, stdout=None, stderr=None, env=None,'
         _stderr = blackhole if stderr is None else stderr
     else:
         _stdout, _stderr = stdout, stderr
-    
+
     env = env if (env is not None) else os.environ.copy()
 
     encoding = getdefaultencoding(prefer_stream=False)
@@ -166,7 +166,7 b' def launch_kernel(cmd, stdin=None, stdout=None, stderr=None, env=None,'
         cwd=cwd,
         env=env,
     )
-    
+
     # Spawn a kernel.
     if sys.platform == 'win32':
         # Popen on Python 2 on Windows cannot handle unicode args or cwd
@@ -174,7 +174,7 b' def launch_kernel(cmd, stdin=None, stdout=None, stderr=None, env=None,'
         if cwd:
             cwd = cast_bytes_py2(cwd, sys.getfilesystemencoding() or 'ascii')
             kwargs['cwd'] = cwd
-        
+
         from IPython.kernel.zmq.parentpoller import ParentPollerWindows
         # Create a Win32 event for interrupting the kernel
         # and store it in an environment variable.
@@ -198,7 +198,7 b' def launch_kernel(cmd, stdin=None, stdout=None, stderr=None, env=None,'
                                      True, # Inheritable by new processes.
                                      DUPLICATE_SAME_ACCESS)
             env['JPY_PARENT_PID'] = str(int(handle))
-        
+
         proc = Popen(cmd, **kwargs)
 
         # Attach the interrupt event to the Popen objet so it can be used later.
@@ -209,7 +209,7 b' def launch_kernel(cmd, stdin=None, stdout=None, stderr=None, env=None,'
             kwargs['preexec_fn'] = lambda: os.setsid()
         else:
             env['JPY_PARENT_PID'] = str(os.getpid())
-        
+
         proc = Popen(cmd, **kwargs)
 
     # Clean up pipes created to work around Popen bug.

jupyter_client/manager.py

@@ -56,19 +56,19 b' class KernelManager(ConnectionFileMixin):'
     # The kernel process with which the KernelManager is communicating.
     # generally a Popen instance
     kernel = Any()
-    
+
     kernel_spec_manager = Instance(kernelspec.KernelSpecManager)
-    
+
     def _kernel_spec_manager_default(self):
         return kernelspec.KernelSpecManager(ipython_dir=self.ipython_dir)
-    
+
     kernel_name = Unicode(kernelspec.NATIVE_KERNEL_NAME)
-    
+
     kernel_spec = Instance(kernelspec.KernelSpec)
-    
+
     def _kernel_spec_default(self):
         return self.kernel_spec_manager.get_kernel_spec(self.kernel_name)
-    
+
     def _kernel_name_changed(self, name, old, new):
         if new == 'python':
             self.kernel_name = kernelspec.NATIVE_KERNEL_NAME
@@ -79,12 +79,12 b' class KernelManager(ConnectionFileMixin):'
 
     kernel_cmd = List(Unicode, config=True,
         help="""DEPRECATED: Use kernel_name instead.
-        
+
         The Popen Command to launch the kernel.
         Override this if you have a custom kernel.
         If kernel_cmd is specified in a configuration file,
         IPython does not pass any arguments to the kernel,
-        because it cannot make any assumptions about the 
+        because it cannot make any assumptions about the
         arguments that the kernel understands. In particular,
         this means that the kernel does not receive the
         option --debug if it given on the IPython command line.
@@ -97,7 +97,7 b' class KernelManager(ConnectionFileMixin):'
         self.ipython_kernel = False
 
     ipython_kernel = Bool(True)
-    
+
     ipython_dir = Unicode()
     def _ipython_dir_default(self):
         return get_ipython_dir()
@@ -173,12 +173,12 b' class KernelManager(ConnectionFileMixin):'
 
         ns = dict(connection_file=self.connection_file)
         ns.update(self._launch_args)
-        
+
         pat = re.compile(r'\{([A-Za-z0-9_]+)\}')
         def from_ns(match):
             """Get the key out of ns if it's there, otherwise no change."""
             return ns.get(match.group(1), match.group())
-        
+
         return [ pat.sub(from_ns, arg) for arg in cmd ]
 
     def _launch_kernel(self, kernel_cmd, **kw):
@@ -243,7 +243,7 b' class KernelManager(ConnectionFileMixin):'
 
     def request_shutdown(self, restart=False):
         """Send a shutdown request via control channel
-        
+
         On Windows, this just kills kernels instead, because the shutdown
         messages don't work.
         """
@@ -253,7 +253,7 b' class KernelManager(ConnectionFileMixin):'
 
     def finish_shutdown(self, waittime=1, pollinterval=0.1):
         """Wait for kernel shutdown, then kill process if it doesn't shutdown.
-        
+
         This does not send shutdown requests - use :meth:`request_shutdown`
         first.
         """
@@ -427,9 +427,9 b" def start_new_kernel(startup_timeout=60, kernel_name='python', **kwargs):"
 @contextmanager
 def run_kernel(**kwargs):
     """Context manager to create a kernel in a subprocess.
-    
+
     The kernel is shut down when the context exits.
-    
+
     Returns
     -------
     kernel_client: connected KernelClient instance

jupyter_client/multikernelmanager.py

@@ -41,13 +41,13 b' def kernel_method(f):'
 
 class MultiKernelManager(LoggingConfigurable):
     """A class for managing multiple kernels."""
-    
+
     ipython_kernel_argv = List(Unicode)
 
     default_kernel_name = Unicode(NATIVE_KERNEL_NAME, config=True,
         help="The name of the default kernel to start"
     )
-    
+
     kernel_manager_class = DottedObjectName(
         "IPython.kernel.ioloop.IOLoopKernelManager", config=True,
         help="""The kernel manager class.  This is configurable to allow
@@ -56,11 +56,11 b' class MultiKernelManager(LoggingConfigurable):'
     )
     def _kernel_manager_class_changed(self, name, old, new):
         self.kernel_manager_factory = import_item(new)
-    
+
     kernel_manager_factory = Any(help="this is kernel_manager_class after import")
     def _kernel_manager_factory_default(self):
         return import_item(self.kernel_manager_class)
-    
+
     context = Instance('zmq.Context')
     def _context_default(self):
         return zmq.Context.instance()
@@ -96,7 +96,7 b' class MultiKernelManager(LoggingConfigurable):'
         kernel_id = kwargs.pop('kernel_id', unicode_type(uuid.uuid4()))
         if kernel_id in self:
             raise DuplicateKernelError('Kernel already exists: %s' % kernel_id)
-        
+
         if kernel_name is None:
             kernel_name = self.default_kernel_name
         # kernel_manager_factory is the constructor for the KernelManager

jupyter_client/restarter.py

@@ -19,14 +19,14 b' class KernelRestarter(LoggingConfigurable):'
     """Monitor and autorestart a kernel."""
 
     kernel_manager = Instance('IPython.kernel.KernelManager')
-    
+
     debug = Bool(False, config=True,
         help="""Whether to include every poll event in debugging output.
-        
+
         Has to be set explicitly, because there will be *a lot* of output.
         """
     )
-    
+
     time_to_dead = Float(3.0, config=True,
         help="""Kernel heartbeat interval in seconds."""
     )

jupyter_client/session.py

@@ -118,7 +118,7 b' session_flags = {'
 
 def default_secure(cfg):
     """Set the default behavior for a config environment to be secure.
-    
+
     If Session.key/keyfile have not been set, set Session.key to
     a new random UUID.
     """
@@ -310,20 +310,20 b' class Session(Configurable):'
 
     metadata = Dict({}, config=True,
         help="""Metadata dictionary, which serves as the default top-level metadata dict for each message.""")
-    
+
     # if 0, no adapting to do.
     adapt_version = Integer(0)
 
     # message signature related traits:
-    
+
     key = CBytes(config=True,
         help="""execution key, for signing messages.""")
     def _key_default(self):
         return str_to_bytes(str(uuid.uuid4()))
-    
+
     def _key_changed(self):
         self._new_auth()
-    
+
     signature_scheme = Unicode('hmac-sha256', config=True,
         help="""The digest scheme used to construct the message signatures.
         Must have the form 'hmac-HASH'.""")
@@ -336,7 +336,7 b' class Session(Configurable):'
         except AttributeError:
             raise TraitError("hashlib has no such attribute: %s" % hash_name)
         self._new_auth()
-    
+
     digest_mod = Any()
     def _digest_mod_default(self):
         return hashlib.sha256
@@ -348,11 +348,11 b' class Session(Configurable):'
             self.auth = hmac.HMAC(self.key, digestmod=self.digest_mod)
         else:
             self.auth = None
-    
+
     digest_history = Set()
     digest_history_size = Integer(2**16, config=True,
         help="""The maximum number of digests to remember.
-        
+
         The digest history will be culled when it exceeds this value.
         """
     )
@@ -365,9 +365,9 b' class Session(Configurable):'
 
     # for protecting against sends from forks
     pid = Integer()
-    
+
     # serialization traits:
-    
+
     pack = Any(default_packer) # the actual packer function
     def _pack_changed(self, name, old, new):
         if not callable(new):
@@ -378,7 +378,7 b' class Session(Configurable):'
         # unpacker is not checked - it is assumed to be
         if not callable(new):
             raise TypeError("unpacker must be callable, not %s"%type(new))
-    
+
     # thresholds:
     copy_threshold = Integer(2**16, config=True,
         help="Threshold (in bytes) beyond which a buffer should be sent without copying.")
@@ -390,7 +390,7 b' class Session(Configurable):'
         """
     )
 
-    
+
     def __init__(self, **kwargs):
         """create a Session object
 
@@ -625,7 +625,7 b' class Session(Configurable):'
         track : bool
             Whether to track.  Only for use with Sockets, because ZMQStream
             objects cannot track messages.
-            
+
 
         Returns
         -------
@@ -655,7 +655,7 b' class Session(Configurable):'
         to_send.extend(buffers)
         longest = max([ len(s) for s in to_send ])
         copy = (longest < self.copy_threshold)
-        
+
         if buffers and track and not copy:
             # only really track when we are doing zero-copy buffers
             tracker = stream.send_multipart(to_send, copy=False, track=True)
@@ -776,15 +776,15 b' class Session(Configurable):'
         if self.digest_history_size == 0:
             # no history, never add digests
             return
-        
+
         self.digest_history.add(signature)
         if len(self.digest_history) > self.digest_history_size:
             # threshold reached, cull 10%
             self._cull_digest_history()
-    
+
     def _cull_digest_history(self):
         """cull the digest history
-        
+
         Removes a randomly selected 10% of the digest history
         """
         current = len(self.digest_history)
@@ -794,7 +794,7 b' class Session(Configurable):'
             return
         to_cull = random.sample(self.digest_history, n_to_cull)
         self.digest_history.difference_update(to_cull)
-    
+
     def deserialize(self, msg_list, content=True, copy=True):
         """Unserialize a msg_list to a nested message dict.
 
@@ -855,7 +855,7 b' class Session(Configurable):'
         message['buffers'] = buffers
         # adapt to the current version
         return adapt(message)
-    
+
     def unserialize(self, *args, **kwargs):
         warnings.warn(
             "Session.unserialize is deprecated. Use Session.deserialize.",
@@ -879,4 +879,3 b' def test_msg2obj():'
     am2 = dict(ao)
     assert am['x'] == am2['x']
     assert am['y']['z'] == am2['y']['z']
-

jupyter_client/tests/test_adapter.py

@@ -26,15 +26,15 b' def test_code_to_line_no_code():'
     nt.assert_equal(pos, 0)
 
 class AdapterTest(TestCase):
-    
+
     def setUp(self):
         self.session = Session()
-    
+
     def adapt(self, msg, version=None):
         original = copy.deepcopy(msg)
         adapted = adapt(msg, version or self.to_version)
         return original, adapted
-    
+
     def check_header(self, msg):
         pass
 
@@ -42,28 +42,28 b' class AdapterTest(TestCase):'
 class V4toV5TestCase(AdapterTest):
     from_version = 4
     to_version = 5
-    
+
     def msg(self, msg_type, content):
         """Create a v4 msg (same as v5, minus version header)"""
         msg = self.session.msg(msg_type, content)
         msg['header'].pop('version')
         return msg
-    
+
     def test_same_version(self):
         msg = self.msg("execute_result",
             content={'status' : 'ok'}
         )
         original, adapted = self.adapt(msg, self.from_version)
-    
+
         self.assertEqual(original, adapted)
-    
+
     def test_no_adapt(self):
         msg = self.msg("input_reply", {'value' : 'some text'})
         v4, v5 = self.adapt(msg)
         self.assertEqual(v5['header']['version'], V4toV5.version)
         v5['header'].pop('version')
         self.assertEqual(v4, v5)
-    
+
     def test_rename_type(self):
         for v5_type, v4_type in [
                 ('execute_result', 'pyout'),
@@ -75,7 +75,7 b' class V4toV5TestCase(AdapterTest):'
             self.assertEqual(v5['header']['version'], V4toV5.version)
             self.assertEqual(v5['header']['msg_type'], v5_type)
             self.assertEqual(v4['content'], v5['content'])
-    
+
     def test_execute_request(self):
         msg = self.msg("execute_request", {
             'code' : 'a=5',
@@ -106,7 +106,7 b' class V4toV5TestCase(AdapterTest):'
         self.assertEqual(v5c['payload'], [{'source': 'page',
                                            'data': {'text/plain': 'blah'}}
                                          ])
-    
+
     def test_complete_request(self):
         msg = self.msg("complete_request", {
             'text' : 'a.is',
@@ -121,7 +121,7 b' class V4toV5TestCase(AdapterTest):'
             self.assertNotIn(key, v5c)
         self.assertEqual(v5c['cursor_pos'], v4c['cursor_pos'])
         self.assertEqual(v5c['code'], v4c['line'])
-    
+
     def test_complete_reply(self):
         msg = self.msg("complete_reply", {
             'matched_text' : 'a.is',
@@ -134,12 +134,12 b' class V4toV5TestCase(AdapterTest):'
         v4, v5 = self.adapt(msg)
         v4c = v4['content']
         v5c = v5['content']
-        
+
         self.assertEqual(v5c['matches'], v4c['matches'])
         self.assertEqual(v5c['metadata'], {})
         self.assertEqual(v5c['cursor_start'], -4)
         self.assertEqual(v5c['cursor_end'], None)
-    
+
     def test_object_info_request(self):
         msg = self.msg("object_info_request", {
             'oname' : 'foo',
@@ -152,7 +152,7 b' class V4toV5TestCase(AdapterTest):'
         self.assertEqual(v5c['code'], v4c['oname'])
         self.assertEqual(v5c['cursor_pos'], len(v4c['oname']))
         self.assertEqual(v5c['detail_level'], v4c['detail_level'])
-    
+
     def test_object_info_reply(self):
         msg = self.msg("object_info_reply", {
             'oname' : 'foo',
@@ -168,7 +168,7 b' class V4toV5TestCase(AdapterTest):'
         self.assertEqual(sorted(v5c), [ 'data', 'found', 'metadata', 'name', 'status'])
         text = v5c['data']['text/plain']
         self.assertEqual(text, '\n'.join([v4c['definition'], v4c['docstring']]))
-    
+
     def test_kernel_info_reply(self):
         msg = self.msg("kernel_info_reply", {
             'language': 'python',
@@ -188,9 +188,9 b' class V4toV5TestCase(AdapterTest):'
             },
             'banner' : '',
         })
-    
+
     # iopub channel
-    
+
     def test_display_data(self):
         jsondata = dict(a=5)
         msg = self.msg("display_data", {
@@ -206,9 +206,9 b' class V4toV5TestCase(AdapterTest):'
         self.assertEqual(v5c['metadata'], v4c['metadata'])
         self.assertEqual(v5c['data']['text/plain'], v4c['data']['text/plain'])
         self.assertEqual(v5c['data']['application/json'], jsondata)
-    
+
     # stdin channel
-    
+
     def test_input_request(self):
         msg = self.msg('input_request', {'prompt': "$>"})
         v4, v5 = self.adapt(msg)
@@ -219,25 +219,25 b' class V4toV5TestCase(AdapterTest):'
 class V5toV4TestCase(AdapterTest):
     from_version = 5
     to_version = 4
-    
+
     def msg(self, msg_type, content):
         return self.session.msg(msg_type, content)
-    
+
     def test_same_version(self):
         msg = self.msg("execute_result",
             content={'status' : 'ok'}
         )
         original, adapted = self.adapt(msg, self.from_version)
-    
+
         self.assertEqual(original, adapted)
-    
+
     def test_no_adapt(self):
         msg = self.msg("input_reply", {'value' : 'some text'})
         v5, v4 = self.adapt(msg)
         self.assertNotIn('version', v4['header'])
         v5['header'].pop('version')
         self.assertEqual(v4, v5)
-    
+
     def test_rename_type(self):
         for v5_type, v4_type in [
                 ('execute_result', 'pyout'),
@@ -249,7 +249,7 b' class V5toV4TestCase(AdapterTest):'
             self.assertEqual(v4['header']['msg_type'], v4_type)
             nt.assert_not_in('version', v4['header'])
             self.assertEqual(v4['content'], v5['content'])
-    
+
     def test_execute_request(self):
         msg = self.msg("execute_request", {
             'code' : 'a=5',
@@ -262,7 +262,7 b' class V5toV4TestCase(AdapterTest):'
         v5c = v5['content']
         self.assertEqual(v4c['user_variables'], [])
         self.assertEqual(v5c['code'], v4c['code'])
-    
+
     def test_complete_request(self):
         msg = self.msg("complete_request", {
             'code' : 'def foo():\n'
@@ -278,7 +278,7 b' class V5toV4TestCase(AdapterTest):'
         self.assertEqual(v4c['cursor_pos'], 8)
         self.assertEqual(v4c['text'], '')
         self.assertEqual(v4c['block'], None)
-    
+
     def test_complete_reply(self):
         msg = self.msg("complete_reply", {
             'cursor_start' : 10,
@@ -295,7 +295,7 b' class V5toV4TestCase(AdapterTest):'
         v5c = v5['content']
         self.assertEqual(v4c['matched_text'], 'a.is')
         self.assertEqual(v4c['matches'], v5c['matches'])
-    
+
     def test_inspect_request(self):
         msg = self.msg("inspect_request", {
             'code' : 'def foo():\n'
@@ -310,7 +310,7 b' class V5toV4TestCase(AdapterTest):'
         v5c = v5['content']
         self.assertEqual(v4c['oname'], 'apple')
         self.assertEqual(v5c['detail_level'], v4c['detail_level'])
-    
+
     def test_inspect_reply(self):
         msg = self.msg("inspect_reply", {
             'name' : 'foo',
@@ -324,7 +324,7 b' class V5toV4TestCase(AdapterTest):'
         v5c = v5['content']
         self.assertEqual(sorted(v4c), ['found', 'oname'])
         self.assertEqual(v4c['found'], False)
-    
+
     def test_kernel_info_reply(self):
         msg = self.msg("kernel_info_reply", {
             'protocol_version': '5.0',
@@ -347,9 +347,9 b' class V5toV4TestCase(AdapterTest):'
             'language_version': [2,8,0],
             'ipython_version': [1,2,3],
         })
-    
+
     # iopub channel
-    
+
     def test_display_data(self):
         jsondata = dict(a=5)
         msg = self.msg("display_data", {
@@ -365,13 +365,11 b' class V5toV4TestCase(AdapterTest):'
         self.assertEqual(v5c['metadata'], v4c['metadata'])
         self.assertEqual(v5c['data']['text/plain'], v4c['data']['text/plain'])
         self.assertEqual(v4c['data']['application/json'], json.dumps(jsondata))
-    
+
     # stdin channel
-    
+
     def test_input_request(self):
         msg = self.msg('input_request', {'prompt': "$>", 'password' : True})
         v5, v4 = self.adapt(msg)
         self.assertEqual(v5['content']['prompt'], v4['content']['prompt'])
         self.assertNotIn('password', v4['content'])
-    
-

jupyter_client/tests/test_connect.py

@@ -60,13 +60,13 b' def test_load_connection_file_session():'
     app = DummyConsoleApp(session=Session())
     app.initialize(argv=[])
     session = app.session
-    
+
     with TemporaryDirectory() as d:
         cf = os.path.join(d, 'kernel.json')
         connect.write_connection_file(cf, **sample_info)
         app.connection_file = cf
         app.load_connection_file()
-    
+
     nt.assert_equal(session.key, sample_info['key'])
     nt.assert_equal(session.signature_scheme, sample_info['signature_scheme'])
 
@@ -78,7 +78,7 b' def test_app_load_connection_file():'
         connect.write_connection_file(cf, **sample_info)
         app = DummyConsoleApp(connection_file=cf)
         app.initialize(argv=[])
-    
+
     for attr, expected in sample_info.items():
         if attr in ('key', 'signature_scheme'):
             continue
@@ -92,14 +92,14 b' def test_get_connection_file():'
         cf = 'kernel.json'
         app = DummyConsoleApp(config=cfg, connection_file=cf)
         app.initialize(argv=[])
-        
+
         profile_cf = os.path.join(app.profile_dir.location, 'security', cf)
         nt.assert_equal(profile_cf, app.connection_file)
         with open(profile_cf, 'w') as f:
             f.write("{}")
         nt.assert_true(os.path.exists(profile_cf))
         nt.assert_equal(connect.get_connection_file(app), profile_cf)
-        
+
         app.connection_file = cf
         nt.assert_equal(connect.get_connection_file(app), profile_cf)
 
@@ -111,11 +111,11 b' def test_find_connection_file():'
         app = DummyConsoleApp(config=cfg, connection_file=cf)
         app.initialize(argv=[])
         BaseIPythonApplication._instance = app
-        
+
         profile_cf = os.path.join(app.profile_dir.location, 'security', cf)
         with open(profile_cf, 'w') as f:
             f.write("{}")
-        
+
         for query in (
             'kernel.json',
             'kern*',
@@ -123,7 +123,7 b' def test_find_connection_file():'
             'k*',
             ):
             nt.assert_equal(connect.find_connection_file(query), profile_cf)
-        
+
         BaseIPythonApplication._instance = None
 
 def test_get_connection_info():
@@ -132,12 +132,10 b' def test_get_connection_info():'
         connect.write_connection_file(cf, **sample_info)
         json_info = connect.get_connection_info(cf)
         info = connect.get_connection_info(cf, unpack=True)
-    
+
     nt.assert_equal(type(json_info), type(""))
     nt.assert_equal(info, sample_info)
-    
+
     info2 = json.loads(json_info)
     info2['key'] = str_to_bytes(info2['key'])
     nt.assert_equal(info2, sample_info)
-    
-

jupyter_client/tests/test_kernelmanager.py

@@ -40,7 +40,7 b' class TestKernelManager(TestCase):'
     def test_ipc_lifecycle(self):
         km = self._get_ipc_km()
         self._run_lifecycle(km)
-    
+
     def test_get_connect_info(self):
         km = self._get_tcp_km()
         cinfo = km.get_connection_info()
@@ -51,4 +51,3 b' class TestKernelManager(TestCase):'
             'key', 'signature_scheme',
         ])
         self.assertEqual(keys, expected)
-

jupyter_client/tests/test_kernelspec.py

@@ -22,7 +22,7 b' class KernelSpecTests(unittest.TestCase):'
             json.dump(sample_kernel_json, f)
 
         self.ksm = kernelspec.KernelSpecManager(ipython_dir=td.name)
-        
+
         td2 = TemporaryDirectory()
         self.addCleanup(td2.cleanup)
         self.installable_kernel = td2.name
@@ -39,18 +39,18 b' class KernelSpecTests(unittest.TestCase):'
         self.assertEqual(ks.argv, sample_kernel_json['argv'])
         self.assertEqual(ks.display_name, sample_kernel_json['display_name'])
         self.assertEqual(ks.env, {})
-    
+
     def test_install_kernel_spec(self):
         self.ksm.install_kernel_spec(self.installable_kernel,
                                      kernel_name='tstinstalled',
                                      user=True)
         self.assertIn('tstinstalled', self.ksm.find_kernel_specs())
-        
+
         with self.assertRaises(OSError):
             self.ksm.install_kernel_spec(self.installable_kernel,
                                          kernel_name='tstinstalled',
                                          user=True)
-        
+
         # Smoketest that this succeeds
         self.ksm.install_kernel_spec(self.installable_kernel,
                                      kernel_name='tstinstalled',

jupyter_client/tests/test_launcher.py

@@ -55,4 +55,3 b' def test_swallow_argv():'
             "returned : %r" % stripped,
         ])
         nt.assert_equal(expected, stripped, message)
-

jupyter_client/tests/test_multikernelmanager.py

@@ -61,7 +61,7 b' class TestKernelManager(TestCase):'
     def test_tcp_lifecycle(self):
         km = self._get_tcp_km()
         self._run_lifecycle(km)
-    
+
     def test_shutdown_all(self):
         km = self._get_tcp_km()
         kid = km.start_kernel(stdout=PIPE, stderr=PIPE)
@@ -70,7 +70,7 b' class TestKernelManager(TestCase):'
         self.assertNotIn(kid, km)
         # shutdown again is okay, because we have no kernels
         km.shutdown_all()
-    
+
     def test_tcp_cinfo(self):
         km = self._get_tcp_km()
         self._run_cinfo(km, 'tcp', localhost())
@@ -79,9 +79,8 b' class TestKernelManager(TestCase):'
     def test_ipc_lifecycle(self):
         km = self._get_ipc_km()
         self._run_lifecycle(km)
-    
+
     @dec.skip_win32
     def test_ipc_cinfo(self):
         km = self._get_ipc_km()
         self._run_cinfo(km, 'ipc', 'test')
-

jupyter_client/tests/test_public_api.py

@@ -38,4 +38,3 b' def test_launcher():'
 def test_connect():
     for name in connect.__all__:
         nt.assert_in(name, dir(kernel))
-

jupyter_client/tests/test_session.py

@@ -77,7 +77,7 b' class TestSession(SessionTestCase):'
 
         msg = self.session.msg('execute', content=dict(a=10))
         self.session.send(A, msg, ident=b'foo', buffers=[b'bar'])
-        
+
         ident, msg_list = self.session.feed_identities(B.recv_multipart())
         new_msg = self.session.deserialize(msg_list)
         self.assertEqual(ident[0], b'foo')
@@ -88,7 +88,7 b' class TestSession(SessionTestCase):'
         self.assertEqual(new_msg['parent_header'],msg['parent_header'])
         self.assertEqual(new_msg['metadata'],msg['metadata'])
         self.assertEqual(new_msg['buffers'],[b'bar'])
-        
+
         content = msg['content']
         header = msg['header']
         header['msg_id'] = self.session.msg_id
@@ -107,9 +107,9 b' class TestSession(SessionTestCase):'
         self.assertEqual(new_msg['metadata'],msg['metadata'])
         self.assertEqual(new_msg['parent_header'],msg['parent_header'])
         self.assertEqual(new_msg['buffers'],[b'bar'])
-        
+
         header['msg_id'] = self.session.msg_id
-        
+
         self.session.send(A, msg, ident=b'foo', buffers=[b'bar'])
         ident, new_msg = self.session.recv(B)
         self.assertEqual(ident[0], b'foo')
@@ -216,7 +216,7 b' class TestSession(SessionTestCase):'
         self.assertTrue(len(session.digest_history) == 100)
         session._add_digest(uuid.uuid4().bytes)
         self.assertTrue(len(session.digest_history) == 91)
-    
+
     def test_bad_pack(self):
         try:
             session = ss.Session(pack=_bad_packer)
@@ -225,7 +225,7 b' class TestSession(SessionTestCase):'
             self.assertIn("don't work", str(e))
         else:
             self.fail("Should have raised ValueError")
-    
+
     def test_bad_unpack(self):
         try:
             session = ss.Session(unpack=_bad_unpacker)
@@ -234,7 +234,7 b' class TestSession(SessionTestCase):'
             self.assertIn("don't work either", str(e))
         else:
             self.fail("Should have raised ValueError")
-    
+
     def test_bad_packer(self):
         try:
             session = ss.Session(packer=__name__ + '._bad_packer')
@@ -243,7 +243,7 b' class TestSession(SessionTestCase):'
             self.assertIn("don't work", str(e))
         else:
             self.fail("Should have raised ValueError")
-    
+
     def test_bad_unpacker(self):
         try:
             session = ss.Session(unpacker=__name__ + '._bad_unpacker')
@@ -252,11 +252,11 b' class TestSession(SessionTestCase):'
             self.assertIn("don't work either", str(e))
         else:
             self.fail("Should have raised ValueError")
-    
+
     def test_bad_roundtrip(self):
         with self.assertRaises(ValueError):
             session = ss.Session(unpack=lambda b: 5)
-    
+
     def _datetime_test(self, session):
         content = dict(t=datetime.now())
         metadata = dict(t=datetime.now())
@@ -274,24 +274,24 b' class TestSession(SessionTestCase):'
         assert isinstance(msg2['metadata']['t'], string_types)
         self.assertEqual(msg['content'], jsonutil.extract_dates(msg2['content']))
         self.assertEqual(msg['content'], jsonutil.extract_dates(msg2['content']))
-    
+
     def test_datetimes(self):
         self._datetime_test(self.session)
-    
+
     def test_datetimes_pickle(self):
         session = ss.Session(packer='pickle')
         self._datetime_test(session)
-    
+
     @skipif(module_not_available('msgpack'))
     def test_datetimes_msgpack(self):
         import msgpack
-        
+
         session = ss.Session(
             pack=msgpack.packb,
             unpack=lambda buf: msgpack.unpackb(buf, encoding='utf8'),
         )
         self._datetime_test(session)
-    
+
     def test_send_raw(self):
         ctx = zmq.Context.instance()
         A = ctx.socket(zmq.PAIR)
@@ -300,10 +300,10 b' class TestSession(SessionTestCase):'
         B.connect("inproc://test")
 
         msg = self.session.msg('execute', content=dict(a=10))
-        msg_list = [self.session.pack(msg[part]) for part in 
+        msg_list = [self.session.pack(msg[part]) for part in
                     ['header', 'parent_header', 'metadata', 'content']]
         self.session.send_raw(A, msg_list, ident=b'foo')
-        
+
         ident, new_msg_list = self.session.feed_identities(B.recv_multipart())
         new_msg = self.session.deserialize(new_msg_list)
         self.assertEqual(ident[0], b'foo')