Python BlockingInProcessKernelClient.start_channels方法代码示例

# 需要导入模块: from IPython.kernel.inprocess.blocking import BlockingInProcessKernelClient [as 别名]
# 或者: from IPython.kernel.inprocess.blocking.BlockingInProcessKernelClient import start_channels [as 别名]
    def test_interface(self):
        """ Does the in-process kernel manager implement the basic KM interface?
        """
        km = InProcessKernelManager()
        self.assert_(not km.has_kernel)

        km.start_kernel()
        self.assert_(km.has_kernel)
        self.assert_(km.kernel is not None)

        kc = BlockingInProcessKernelClient(kernel=km.kernel)
        self.assert_(not kc.channels_running)

        kc.start_channels()
        self.assert_(kc.channels_running)

        old_kernel = km.kernel
        km.restart_kernel()
        self.assertIsNotNone(km.kernel)
        self.assertNotEquals(km.kernel, old_kernel)

        km.shutdown_kernel()
        self.assert_(not km.has_kernel)

        self.assertRaises(NotImplementedError, km.interrupt_kernel)
        self.assertRaises(NotImplementedError, km.signal_kernel, 9)

        kc.stop_channels()
        self.assert_(not kc.channels_running)

# 需要导入模块: from IPython.kernel.inprocess.blocking import BlockingInProcessKernelClient [as 别名]
# 或者: from IPython.kernel.inprocess.blocking.BlockingInProcessKernelClient import start_channels [as 别名]
 def test_execute(self):
     """ Does executing code in an in-process kernel work?
     """
     km = InProcessKernelManager()
     km.start_kernel()
     kc = BlockingInProcessKernelClient(kernel=km.kernel)
     kc.start_channels()
     kc.execute('foo = 1')
     self.assertEquals(km.kernel.shell.user_ns['foo'], 1)

# 需要导入模块: from IPython.kernel.inprocess.blocking import BlockingInProcessKernelClient [as 别名]
# 或者: from IPython.kernel.inprocess.blocking.BlockingInProcessKernelClient import start_channels [as 别名]
 def test_complete(self):
     """ Does requesting completion from an in-process kernel work?
     """
     km = InProcessKernelManager()
     km.start_kernel()
     kc = BlockingInProcessKernelClient(kernel=km.kernel)
     kc.start_channels()
     km.kernel.shell.push({"my_bar": 0, "my_baz": 1})
     kc.complete("my_ba", "my_ba", 5)
     msg = kc.get_shell_msg()
     self.assertEqual(msg["header"]["msg_type"], "complete_reply")
     self.assertEqual(sorted(msg["content"]["matches"]), ["my_bar", "my_baz"])

# 需要导入模块: from IPython.kernel.inprocess.blocking import BlockingInProcessKernelClient [as 别名]
# 或者: from IPython.kernel.inprocess.blocking.BlockingInProcessKernelClient import start_channels [as 别名]
 def test_object_info(self):
     """ Does requesting object information from an in-process kernel work?
     """
     km = InProcessKernelManager()
     km.start_kernel()
     kc = BlockingInProcessKernelClient(kernel=km.kernel)
     kc.start_channels()
     km.kernel.shell.user_ns['foo'] = 1
     kc.object_info('foo')
     msg = kc.get_shell_msg()
     self.assertEquals(msg['header']['msg_type'], 'object_info_reply')
     self.assertEquals(msg['content']['name'], 'foo')
     self.assertEquals(msg['content']['type_name'], 'int')

# 需要导入模块: from IPython.kernel.inprocess.blocking import BlockingInProcessKernelClient [as 别名]
# 或者: from IPython.kernel.inprocess.blocking.BlockingInProcessKernelClient import start_channels [as 别名]
 def test_complete(self):
     """ Does requesting completion from an in-process kernel work?
     """
     km = InProcessKernelManager()
     km.start_kernel()
     kc = BlockingInProcessKernelClient(kernel=km.kernel)
     kc.start_channels()
     km.kernel.shell.push({'my_bar': 0, 'my_baz': 1})
     kc.complete('my_ba', 'my_ba', 5)
     msg = kc.get_shell_msg()
     self.assertEqual(msg['header']['msg_type'], 'complete_reply')
     self.assertEqual(sorted(msg['content']['matches']),
                       ['my_bar', 'my_baz'])

# 需要导入模块: from IPython.kernel.inprocess.blocking import BlockingInProcessKernelClient [as 别名]
# 或者: from IPython.kernel.inprocess.blocking.BlockingInProcessKernelClient import start_channels [as 别名]
def get_kernel_pointer(buffer):
    lisp.message("getting kernel for " + buffer)
    if buffer not in kernels:
        lisp.message("creating new " + buffer)
        km = InProcessKernelManager()
        km.start_kernel()
        kc = BlockingInProcessKernelClient(kernel=km.kernel)
        kc.start_channels()
        kernel = InProcessKernel()
        kernels[buffer] = (kc,kernel,kernel.shell.get_ipython())
        # run this so that plt, np pointers are ready
        kc.shell_channel.execute('%pylab inline')
    return kernels[buffer]

# 需要导入模块: from IPython.kernel.inprocess.blocking import BlockingInProcessKernelClient [as 别名]
# 或者: from IPython.kernel.inprocess.blocking.BlockingInProcessKernelClient import start_channels [as 别名]
 def test_history(self):
     """ Does requesting history from an in-process kernel work?
     """
     km = InProcessKernelManager()
     km.start_kernel()
     kc = BlockingInProcessKernelClient(kernel=km.kernel)
     kc.start_channels()
     kc.execute('%who')
     kc.history(hist_access_type='tail', n=1)
     msg = kc.shell_channel.get_msgs()[-1]
     self.assertEquals(msg['header']['msg_type'], 'history_reply')
     history = msg['content']['history']
     self.assertEquals(len(history), 1)
     self.assertEquals(history[0][2], '%who')

# 需要导入模块: from IPython.kernel.inprocess.blocking import BlockingInProcessKernelClient [as 别名]
# 或者: from IPython.kernel.inprocess.blocking.BlockingInProcessKernelClient import start_channels [as 别名]
 def test_inspect(self):
     """ Does requesting object information from an in-process kernel work?
     """
     km = InProcessKernelManager()
     km.start_kernel()
     kc = BlockingInProcessKernelClient(kernel=km.kernel)
     kc.start_channels()
     km.kernel.shell.user_ns['foo'] = 1
     kc.inspect('foo')
     msg = kc.get_shell_msg()
     self.assertEqual(msg['header']['msg_type'], 'inspect_reply')
     content = msg['content']
     assert content['found']
     text = content['data']['text/plain']
     self.assertIn('int', text)

# 需要导入模块: from IPython.kernel.inprocess.blocking import BlockingInProcessKernelClient [as 别名]
# 或者: from IPython.kernel.inprocess.blocking.BlockingInProcessKernelClient import start_channels [as 别名]
class InProcessKernelTestCase(unittest.TestCase):

    def setUp(self):
        self.km = InProcessKernelManager()
        self.km.start_kernel()
        self.kc = BlockingInProcessKernelClient(kernel=self.km.kernel)
        self.kc.start_channels()

    @skipif_not_matplotlib
    def test_pylab(self):
        """ Does pylab work in the in-process kernel?
        """
        kc = self.kc
        kc.execute('%pylab')
        msg = get_stream_message(kc)
        self.assert_('Welcome to pylab' in msg['content']['data'])

    def test_raw_input(self):
        """ Does the in-process kernel handle raw_input correctly?
        """
        io = StringIO('foobar\n')
        sys_stdin = sys.stdin
        sys.stdin = io
        try:
            if py3compat.PY3:
                self.kc.execute('x = input()')
            else:
                self.kc.execute('x = raw_input()')
        finally:
            sys.stdin = sys_stdin
        self.assertEqual(self.km.kernel.shell.user_ns.get('x'), 'foobar')

    def test_stdout(self):
        """ Does the in-process kernel correctly capture IO?
        """
        kernel = InProcessKernel()

        with capture_output() as io:
            kernel.shell.run_cell('print("foo")')
        self.assertEqual(io.stdout, 'foo\n')

        kc = BlockingInProcessKernelClient(kernel=kernel)
        kernel.frontends.append(kc)
        kc.shell_channel.execute('print("bar")')
        msg = get_stream_message(kc)
        self.assertEqual(msg['content']['data'], 'bar\n')

# 需要导入模块: from IPython.kernel.inprocess.blocking import BlockingInProcessKernelClient [as 别名]
# 或者: from IPython.kernel.inprocess.blocking.BlockingInProcessKernelClient import start_channels [as 别名]
class InProcessKernelTestCase(unittest.TestCase):
    def setUp(self):
        self.km = InProcessKernelManager()
        self.km.start_kernel()
        self.kc = BlockingInProcessKernelClient(kernel=self.km.kernel)
        self.kc.start_channels()
        self.kc.wait_for_ready()

    @skipif_not_matplotlib
    def test_pylab(self):
        """Does %pylab work in the in-process kernel?"""
        kc = self.kc
        kc.execute("%pylab")
        out, err = assemble_output(kc.iopub_channel)
        self.assertIn("matplotlib", out)

    def test_raw_input(self):
        """ Does the in-process kernel handle raw_input correctly?
        """
        io = StringIO("foobar\n")
        sys_stdin = sys.stdin
        sys.stdin = io
        try:
            if py3compat.PY3:
                self.kc.execute("x = input()")
            else:
                self.kc.execute("x = raw_input()")
        finally:
            sys.stdin = sys_stdin
        self.assertEqual(self.km.kernel.shell.user_ns.get("x"), "foobar")

    def test_stdout(self):
        """ Does the in-process kernel correctly capture IO?
        """
        kernel = InProcessKernel()

        with capture_output() as io:
            kernel.shell.run_cell('print("foo")')
        self.assertEqual(io.stdout, "foo\n")

        kc = BlockingInProcessKernelClient(kernel=kernel)
        kernel.frontends.append(kc)
        kc.execute('print("bar")')
        out, err = assemble_output(kc.iopub_channel)
        self.assertEqual(out, "bar\n")