Пример #1
0
def main():
    km = BlockingEmbeddedKernelManager()
    #km = BlockingKernelManager()
    km.start_kernel()
    km.start_channels()

    shell = ZMQTerminalInteractiveShell(kernel_manager=km)
    shell.mainloop()
Пример #2
0
 def init_shell(self):
     IPythonConsoleApp.initialize(self)
     # relay sigint to kernel
     signal.signal(signal.SIGINT, self.handle_sigint)
     self.shell = ZMQTerminalInteractiveShell.instance(config=self.config,
                     display_banner=False, profile_dir=self.profile_dir,
                     ipython_dir=self.ipython_dir, kernel_manager=self.kernel_manager)
Пример #3
0
def main():
    print_process_id()

    # Create an in-process kernel
    # >>> print_process_id()
    # will print the same process ID as the main process
    kernel_manager = InProcessKernelManager()
    kernel_manager.start_kernel()
    kernel = kernel_manager.kernel
    kernel.gui = 'qt4'
    kernel.shell.push({'foo': 43, 'print_process_id': print_process_id})
    client = kernel_manager.client()
    client.start_channels()

    shell = ZMQTerminalInteractiveShell(manager=kernel_manager, client=client)
    shell.mainloop()
Пример #4
0
 def setUp(self):
     client = KernelClient()
     self.shell = ZMQTerminalInteractiveShell(kernel_client=client)
     self.raw = b'dummy data'
     self.mime = 'image/png'
     self.data = {self.mime: base64.encodestring(self.raw).decode('ascii')}
Пример #5
0
class ZMQTerminalInteractiveShellTestCase(unittest.TestCase):

    def setUp(self):
        client = KernelClient()
        self.shell = ZMQTerminalInteractiveShell(kernel_client=client)
        self.raw = b'dummy data'
        self.mime = 'image/png'
        self.data = {self.mime: base64.encodestring(self.raw).decode('ascii')}

    def test_no_call_by_default(self):
        def raise_if_called(*args, **kwds):
            assert False

        shell = self.shell
        shell.handle_image_PIL = raise_if_called
        shell.handle_image_stream = raise_if_called
        shell.handle_image_tempfile = raise_if_called
        shell.handle_image_callable = raise_if_called

        shell.handle_image(None, None)  # arguments are dummy

    @skip_without('PIL')
    def test_handle_image_PIL(self):
        import PIL.Image

        open_called_with = []
        show_called_with = []

        def fake_open(arg):
            open_called_with.append(arg)
            return Struct(show=lambda: show_called_with.append(None))

        with monkeypatch(PIL.Image, 'open', fake_open):
            self.shell.handle_image_PIL(self.data, self.mime)

        self.assertEqual(len(open_called_with), 1)
        self.assertEqual(len(show_called_with), 1)
        self.assertEqual(open_called_with[0].getvalue(), self.raw)

    def check_handler_with_file(self, inpath, handler):
        shell = self.shell
        configname = '{0}_image_handler'.format(handler)
        funcname = 'handle_image_{0}'.format(handler)

        assert hasattr(shell, configname)
        assert hasattr(shell, funcname)

        with TemporaryDirectory() as tmpdir:
            outpath = os.path.join(tmpdir, 'data')
            cmd = [sys.executable, SCRIPT_PATH, inpath, outpath]
            setattr(shell, configname, cmd)
            getattr(shell, funcname)(self.data, self.mime)
            # cmd is called and file is closed.  So it's safe to open now.
            with open(outpath, 'rb') as file:
                transferred = file.read()

        self.assertEqual(transferred, self.raw)

    def test_handle_image_stream(self):
        self.check_handler_with_file('-', 'stream')

    def test_handle_image_tempfile(self):
        self.check_handler_with_file('{file}', 'tempfile')

    def test_handle_image_callable(self):
        called_with = []
        self.shell.callable_image_handler = called_with.append
        self.shell.handle_image_callable(self.data, self.mime)
        self.assertEqual(len(called_with), 1)
        assert called_with[0] is self.data
Пример #6
0
 def setUp(self):
     km = KernelManager()
     self.shell = ZMQTerminalInteractiveShell(kernel_manager=km)
     self.raw = b'dummy data'
     self.mime = 'image/png'
     self.data = {self.mime: base64.encodestring(self.raw).decode('ascii')}
Пример #7
0
 def setUp(self):
     km = KernelManager()
     self.shell = ZMQTerminalInteractiveShell(kernel_manager=km)
     self.raw = b'dummy data'
     self.mime = 'image/png'
     self.data = {self.mime: base64.encodestring(self.raw).decode('ascii')}