Python QtKernelManager.start_channels方法代码示例

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]
def default_manager(kernel):
    connection_file = find_connection_file(kernel.connection_file)
    manager = QtKernelManager(connection_file=connection_file)
    manager.load_connection_file()
    manager.start_channels()
    atexit.register(manager.cleanup_connection_file)
    return manager

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]
 def _init_kernel_manager(self):
     connection_file = find_connection_file(self.app.connection_file)
     manager = QtKernelManager(connection_file=connection_file)
     manager.load_connection_file()
     manager.start_channels()
     atexit.register(manager.cleanup_connection_file)
     self.kernel_manager = manager

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]
 def _init_kernel_manager(self):
     """"""
     
     km = QtKernelManager(connection_file=self._connection_file,
                          config=self.config)
     km.load_connection_file()
     km.start_channels(hb=self._heartbeat)
     self.kernel_manager = km
     atexit.register(self.kernel_manager.cleanup_connection_file)

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]
def default_manager(kernel):
    """ Return a configured QtKernelManager

    :param kernel: An IPKernelApp instance
    """
    connection_file = find_connection_file(kernel.connection_file)
    manager = QtKernelManager(connection_file=connection_file)
    manager.load_connection_file()
    manager.start_channels()
    atexit.register(manager.cleanup_connection_file)
    return manager

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]
class MainWin(QMainWindow):
  def __init__(self):
    QMainWindow.__init__(self)
    self.resize(1000,1000)

    self.kernel = QtKernelManager()
    self.kernel.start_kernel()
    self.kernel.start_channels()

    self.console = IPythonWidget()
    self.console.kernel_manager = self.kernel
    self.setCentralWidget(self.console)

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]
    def connect_kernel(self, connection_file, heartbeat=False):
        """
        connection_file: str - is the connection file name, for example
        'kernel-16098.json'.
        heartbeat: bool - workaround, needed for right click/save as
                          ... errors ... i don't know how to
                          fix this issue. Anyone knows? Anyway it
                          needs more testing
            example1 (standalone):

                    app = QtGui.QApplication([])
                    widget = IPythonConsoleQtWidget()
                    widget.set_default_style(colors='linux')


                    widget.connect_kernel(
                        connection_file='some connection file name')

                    app.exec_()

            example2 (IPythonLocalKernelApp):

                    app = QtGui.QApplication([])

                    kernelapp = IPythonLocalKernelApp.instance()
                    kernelapp.initialize()

                    widget = IPythonConsoleQtWidget()

                    # Green text, black background ;)
                    widget.set_default_style(colors='linux')

                    widget.connect_kernel(
                        connection_file='kernelapp.get_connection_file())

                    app.exec_()

        """
        km = QtKernelManager(
            connection_file=find_connection_file(connection_file),
            config=self.config)
        km.load_connection_file()
        km.start_channels(hb=heartbeat)
        self.kernel_manager = km
        atexit.register(self.kernel_manager.cleanup_connection_file)

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]
        def get_widget(self, droplist_completion=True):
            if IPython.__version__ < '0.13':
                completion = droplist_completion
            else:
                completion = 'droplist' if droplist_completion else 'plain'
            widget = RichIPythonWidget(gui_completion=completion)

            cf = find_connection_file(self.kernel_app.connection_file)
            km = QtKernelManager(connection_file=cf, config=widget.config)
            km.load_connection_file()
            km.start_channels()
            widget.kernel_manager = km
            atexit.register(km.cleanup_connection_file)

            sys.stdout = self._stdout
            sys.stderr = self._stderr
            sys.displayhook = self._dishook

            return widget

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]
class IPythonConsole(QDockWidget):
    def __init__(self, parent=None):
        QDockWidget.__init__(self, parent)
        self.setObjectName("IPython Console")
        self.setWindowTitle(QCoreApplication.translate("IPython Console", "IPython Console"))
        self.setAllowedAreas(Qt.BottomDockWidgetArea)

        self.container = QWidget()
        self.layout = QVBoxLayout(self.container)

        self.kernel_manager = QtKernelManager()
        self.kernel_manager.start_kernel()
        self.kernel_manager.start_channels()

        self.console = IPythonWidget(local_kernel=LOCALHOST)
        self.console.kernel_manager = self.kernel_manager
        print dir(self.console)

        self.layout.addWidget(self.console)
        self.setWidget(self.container)

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]
class console(QWidget):

	"""A QWidget that serves as a debug window"""

	def __init__(self, parent=None):

		QDialog.__init__(self, parent)

		self.main_window = parent
		self.kernel_manager = QtKernelManager()
		self.kernel_manager.start_kernel()
		self.kernel_manager.start_channels()
		self.console = IPythonWidget(local_kernel=LOCALHOST)
		self.console.kernel_manager = self.kernel_manager
		self.verticalLayout = QVBoxLayout(self)
		self.verticalLayout.setContentsMargins(0,0,0,0)
		self.setLayout(self.verticalLayout)
		self.verticalLayout.addWidget(self.console)

	def setReadOnly(self, state):

		"""
		Dummy function

		Arguments:
		state -- dummy argument
		"""

		pass

	def clear(self):

		"""Clears the console"""

		self.console.reset()

	def show_prompt(self):

		"""Shows a new prompt"""

		self.console._show_interpreter_prompt()

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]
 def new_frontend_slave(self, current_widget):
     """Create and return a new frontend attached to an existing kernel.
     
     Parameters
     ----------
     current_widget : IPythonWidget
         The IPythonWidget whose kernel this frontend is to share
     """
     kernel_manager = QtKernelManager(
                             connection_file=current_widget.kernel_manager.connection_file,
                             config = self.config,
     )
     kernel_manager.load_connection_file()
     kernel_manager.start_channels()
     widget = self.widget_factory(config=self.config,
                             local_kernel=False)
     widget._existing = True
     widget._may_close = False
     widget._confirm_exit = False
     widget.kernel_manager = kernel_manager
     return widget

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]
 def new_frontend_master(self):
     """ Create and return new frontend attached to new kernel, launched on localhost.
     """
     ip = self.ip if self.ip in LOCAL_IPS else LOCALHOST
     kernel_manager = QtKernelManager(
                             ip=ip,
                             connection_file=self._new_connection_file(),
                             config=self.config,
     )
     # start the kernel
     kwargs = dict(ipython=not self.pure)
     kwargs['extra_arguments'] = self.kernel_argv
     kernel_manager.start_kernel(**kwargs)
     kernel_manager.start_channels()
     widget = self.widget_factory(config=self.config,
                                local_kernel=True)
     widget.kernel_manager = kernel_manager
     widget._existing = False
     widget._may_close = True
     widget._confirm_exit = self.confirm_exit
     return widget

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]
def init_kernel_manager():
    # Don't let Qt or ZMQ swallow KeyboardInterupts.
    signal.signal(signal.SIGINT, signal.SIG_DFL)

    ip = '127.0.0.1'

    # Create a KernelManager and start a kernel.
    kernel_manager = QtKernelManager(
                            shell_address=(ip, 0),
                            sub_address=(ip, 0),
                            stdin_address=(ip, 0),
                            hb_address=(ip, 0)
                            #,
                            #config=self.config
    )
    # start the kernel
    kwargs = dict(ip='127.0.0.1', ipython=True)
    #kwargs['extra_arguments'] = self.kernel_argv
    kernel_manager.start_kernel(**kwargs)
    kernel_manager.start_channels()
    return kernel_manager

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]
 def setupKernelManager(self):
     kernelManager = None
     try:
         from IPython.frontend.qt.kernelmanager import QtKernelManager
         kernelManager = QtKernelManager()
         kernelManager.start_kernel()
         kernelManager.start_channels()
         if hasattr(kernelManager, "connection_file"):
             ipconnection = kernelManager.connection_file
         else:
             shell_port = kernelManager.shell_address[1]
             iopub_port = kernelManager.sub_address[1]
             stdin_port = kernelManager.stdin_address[1]
             hb_port = kernelManager.hb_address[1]
             ipconnection = "--shell={0} --iopub={1} --stdin={2} --hb={3}".format(shell_port, iopub_port, stdin_port, hb_port)
         self.supportManager.updateEnvironment({ 
                 "PMX_IPYTHON_CONNECTION": ipconnection
         })
     except ImportError as e:
         self.logger.warn("Warning: %s" % e)
         kernelManager = None
     return kernelManager

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]

#.........这里部分代码省略.........

    def init_kernel_manager(self):
        # Don't let Qt or ZMQ swallow KeyboardInterupts.
        signal.signal(signal.SIGINT, signal.SIG_DFL)
        sec = self.profile_dir.security_dir
        try:
            cf = filefind(self.connection_file, ['.', sec])
        except IOError:
            # file might not exist
            if self.connection_file == os.path.basename(self.connection_file):
                # just shortname, put it in security dir
                cf = os.path.join(sec, self.connection_file)
            else:
                cf = self.connection_file

        # Create a KernelManager and start a kernel.
        self.kernel_manager = QtKernelManager(
                                ip=self.ip,
                                shell_port=self.shell_port,
                                iopub_port=self.iopub_port,
                                stdin_port=self.stdin_port,
                                hb_port=self.hb_port,
                                connection_file=cf,
                                config=self.config,
        )
        # start the kernel
        if not self.existing:
            kwargs = dict(ipython=not self.pure)
            kwargs['extra_arguments'] = self.kernel_argv
            self.kernel_manager.start_kernel(**kwargs)
        elif self.sshserver:
            # ssh, write new connection file
            self.kernel_manager.write_connection_file()
        self.kernel_manager.start_channels()

    def new_frontend_master(self):
        """ Create and return new frontend attached to new kernel, launched on localhost.
        """
        ip = self.ip if self.ip in LOCAL_IPS else LOCALHOST
        kernel_manager = QtKernelManager(
                                ip=ip,
                                connection_file=self._new_connection_file(),
                                config=self.config,
        )
        # start the kernel
        kwargs = dict(ipython=not self.pure)
        kwargs['extra_arguments'] = self.kernel_argv
        kernel_manager.start_kernel(**kwargs)
        kernel_manager.start_channels()
        widget = self.widget_factory(config=self.config,
                                   local_kernel=True)
        widget.kernel_manager = kernel_manager
        widget._existing = False
        widget._may_close = True
        widget._confirm_exit = self.confirm_exit
        return widget

    def new_frontend_slave(self, current_widget):
        """Create and return a new frontend attached to an existing kernel.
        
        Parameters
        ----------
        current_widget : IPythonWidget
            The IPythonWidget whose kernel this frontend is to share
        """
        kernel_manager = QtKernelManager(

# 需要导入模块: from IPython.frontend.qt.kernelmanager import QtKernelManager [as 别名]
# 或者: from IPython.frontend.qt.kernelmanager.QtKernelManager import start_channels [as 别名]
class IPythonQtConsoleApp(BaseIPythonApplication):
    name = 'ipython-qtconsole'
    default_config_file_name='ipython_config.py'
    
    description = """
        The IPython QtConsole.
        
        This launches a Console-style application using Qt.  It is not a full
        console, in that launched terminal subprocesses will not.
        
        The QtConsole supports various extra features beyond the
        
    """
    
    classes = [IPKernelApp, IPythonWidget, ZMQInteractiveShell, ProfileDir, Session]
    flags = Dict(flags)
    aliases = Dict(aliases)

    kernel_argv = List(Unicode)

    # connection info:
    ip = Unicode(LOCALHOST, config=True,
        help="""Set the kernel\'s IP address [default localhost].
        If the IP address is something other than localhost, then
        Consoles on other machines will be able to connect
        to the Kernel, so be careful!"""
    )
    hb_port = Int(0, config=True,
        help="set the heartbeat port [default: random]")
    shell_port = Int(0, config=True,
        help="set the shell (XREP) port [default: random]")
    iopub_port = Int(0, config=True,
        help="set the iopub (PUB) port [default: random]")
    stdin_port = Int(0, config=True,
        help="set the stdin (XREQ) port [default: random]")

    existing = CBool(False, config=True,
        help="Whether to connect to an already running Kernel.")

    stylesheet = Unicode('', config=True,
        help="path to a custom CSS stylesheet")

    pure = CBool(False, config=True,
        help="Use a pure Python kernel instead of an IPython kernel.")
    plain = CBool(False, config=True,
        help="Use a plaintext widget instead of rich text (plain can't print/save).")

    def _pure_changed(self, name, old, new):
        kind = 'plain' if self.plain else 'rich'
        self.config.ConsoleWidget.kind = kind
        if self.pure:
            self.widget_factory = FrontendWidget
        elif self.plain:
            self.widget_factory = IPythonWidget
        else:
            self.widget_factory = RichIPythonWidget

    _plain_changed = _pure_changed

    confirm_exit = CBool(True, config=True,
        help="""
        Set to display confirmation dialog on exit. You can always use 'exit' or 'quit',
        to force a direct exit without any confirmation.""",
    )
    
    # the factory for creating a widget
    widget_factory = Any(RichIPythonWidget)

    def parse_command_line(self, argv=None):
        super(IPythonQtConsoleApp, self).parse_command_line(argv)
        if argv is None:
            argv = sys.argv[1:]

        self.kernel_argv = list(argv) # copy

        # scrub frontend-specific flags
        for a in argv:
            if a.startswith('--') and a[2:] in qt_flags:
                self.kernel_argv.remove(a)

    def init_kernel_manager(self):
        # Don't let Qt or ZMQ swallow KeyboardInterupts.
        signal.signal(signal.SIGINT, signal.SIG_DFL)

        # Create a KernelManager and start a kernel.
        self.kernel_manager = QtKernelManager(
                                shell_address=(self.ip, self.shell_port),
                                sub_address=(self.ip, self.iopub_port),
                                stdin_address=(self.ip, self.stdin_port),
                                hb_address=(self.ip, self.hb_port),
                                config=self.config
        )
        # start the kernel
        if not self.existing:
            kwargs = dict(ip=self.ip, ipython=not self.pure)
            kwargs['extra_arguments'] = self.kernel_argv
            self.kernel_manager.start_kernel(**kwargs)
        self.kernel_manager.start_channels()


#.........这里部分代码省略.........