MetaKernelFinder -> KernelFinder

Prototype new kernel discovery machinery

Fix typo in documentation.

The old URL points to a "This page has moved"-page

Updated URL for Jupyter Kernels in other languages

- use IOLoop.current over IOLoop.instance
- drop removed `loop` arg from PeriodicCallback
- deprecate now-unused IOLoopKernelRestarter.loop

- interrupt_mode="signal" is the default and current behaviour
- With interrupt_mode="message", instead of a signal, a
  `interrupt_request` message on the control port will be sent

prepare for tornado 5

Additional to the actual signal, send a message on the control port

this should allow ipykernel's wheel-installed specs to specify `python3` or `python2` and prevent
python2 kernels from launching with sys.executable if the Python version is 3.

A simple lead in to the 'kernel nanny' work, this adds a command so you
can do:
jupyter kernel --kernel python

Add 'jupyter kernel' command

extend special handling of sys.executable to pythonX[.Y]

if killpg is available

this should cleanup process trees (e.g. multiprocessing subprocesses)
and make EADDRINUSE less likely during restart.

kill process group when killing kernel

…ance

Improve performance of get_kernel_spec

Tolerate invalid kernel specs in get_all_specs()

Start writing release notes for 5.2

require tornado

Du to a likely bug in wheel, the conditional dependency on pytest ends
up being unconditional. Seem like adding parenthesis fix that (as a work
around).

See pypa/setuptools#1242
Closes jupyter#324

Parenthesize conditional requirement in setup.py

This shrinks the sdist from 2MB to ~250KB... just realized that after
uploading 5.2.1 took way too long. Apparently 5.2.0 alsho shipped built
docs.

Exclude build docs from sdist.

to help inqiure on this jupyter#329

more complete error message

Use the ability to exclude branches as describe there:

 - https://docs.travis-ci.com/user/customizing-the-build/#Safelisting-or-blocklisting-branches

Relatively easy as MrMeeseeks push a known branch format.
This of course cannot be tested until merged and backported, and another
backport triggered.

Tell Travis not to test the push from MrMeeseeks

As this part of code is mainly used in IPython we
agreed to move it from pyzmq. It will be easier to
maintain here and some planned changes in this code
will be easier to apply and release.

we could probably avoid this if we registered/unregistered atexit callbacks for instances
instead of registering it once for classes at import time

handle classes having been torn down in atexit

on the result of a public overrideable method,
which breaks subclasses that don't override get_all_specs

…et_all_specs

avoid calling private method in subclasses of KernelSpecManager

changelog for 5.2.2

zmq.COPY_THRESHOLD is undefined prior to pyzmq 17,
so we need `create=True` to define it in that case

fix testing patch for pyzmq < 17

…neling_from_pyzmq

Migrate SSH tunneling from pyzmq

calling stop doesn’t wake the IOLoop with asyncio (tornado 5)

- avoid instantiating an IOLoop outside the thread in which it will be used,
  which sometimes causes problems.
- ensure asyncio eventloop is defined in the thread, if asyncio might be in use

tornado 5 fixes in ThreadedClient

…subclasses.

A recent requirement for Jupyter Enterprise Gateway is for clients to be able to
specify the kernel_id for new kernels.  Although `jupyter_client.start_kernel()` will
honor client-provided kernel_ids, Notebook's override of `start_kernel()` changes
the semantics of a non-null kernel_id in the argument list to mean an existing
(persisted) kernel should be _started_.  As a result, applications that derive
from the kernel management infrastructure beyond Notebook cannot influence the
derivation of the kernel's id via the existing argument list behavior.

By introducing the `determine_kernel_id()` method, subclasses are able to derive
the kernel's id however they wish.

With the ability to know the kernel's id prior to its invocation, a number of
things can be done that wouldn't be possible otherwise.  For example, this
provides the ability to setup a shared filesystem location possibly pre-populated
with data relative to what the request (i.e., kernel) is going to need.

Changelog for 5.2.3

Add setup() args for new pypi.org

After analyzing various leaked items when running either Notebook or
Jupyter Kernel Gateway, one item that recurred across each kernel
startup and shutdown sequence was the Popen object stored in the kernel
manager in `self.kernel`.

The issue is that in normal circumstances, when a kernel's termination
is successful via the ZMQ messaging, the process is never waited for
(which, in this case, is probably unnecessary but advised) nor is the
member variable set to None.  In the failing case, where the message-based
shutdown does not terminate the kernel process, the `_kill_kernel()`
method is used, which performs the `wait()` and _nullifies_ the kernel
member.  This change ensures that sequence occurs in normal situations
as well.

After analyzing various leaked items when running either Notebook or
Jupyter Kernel Gateway, one item that recurred across each kernel
startup and shutdown sequence was an instance of IOLoopKernelManager.
(Of course, when using JKG, this instance was KernelGatewayIOLoopKernelManager
since it derives from the former.)

The leak is caused by the circular references established in the `self._restarter`
and `self.session.parent` members. This change breaks the circular reference when
the restarter is stopped and during `cleanup()` of the kernel manager.  Once the
references are broken, the kernel manager instance can be garbage collected.

…manager

Fix leak of IOLoopKernelManager object

Fix memory leak of kernel Popen object

Per review comments, the name of the method to generate a kernel_id
was changed to `new_kernel_id()`.  In addition, the method is now
only called if `kernel_id` is not represented in the keyword arguments
(`**kwargs`).

…ernel-id

Wrap setting of kernel_id with method that can then be overridden in …

master is 6.0-dev

When running Jupyter via pythonw e.g. pythonw -m qtconsole, jupyter_client launches new kernel via python.exe which is a console application on Windows - a side-effect of that is a new empty console window created and shown as long as kernel is running.

This patch adds CREATE_NO_WINDOW 0x08000000 to Windows specific creationflags. This flag is not exported by subprocess module therefore has to be provides numerically.

Prevent creating new console on Windows

make KernelManager configurable for all who inherit JupyterConsoleApp

update python version testing