如何在 PyQT 小部件中嵌入 Python 解释器

Question

我希望能够从我的 python 应用程序中调出交互式 python 终端。我的程序中的一些（但不是全部）变量需要暴露给解释器。

目前，我使用子类和修改的 QPlainTextEdit 并将所有“命令”路由到 eval 或 exec，并跟踪单独的命名空间在字典中。然而，必须有一种更优雅、更健壮的方式！如何？

这是一个执行我想要的操作的示例，但它是使用 IPython 和 pyGTK... http://ipython.scipy.org/moin/Cookbook/EmbeddingInGTK

下面是我的内容目前有。但有太多的极端情况，我可能错过了一些。它非常慢，尝试一个大的打印循环...它必须是一种更简单且不易出错的方法，...我希望！

def runCommand(self) 函数是理解我的问题的关键。理想情况下，我不想改进它，我宁愿用更简单、更智能的东西替换它的内容。

“main”中的 console.updateNamespace({'myVar1' : app, 'myVar2' : 1234}) 语句的功能也很重要。

import sys, os
import traceback
from PyQt4 import QtCore
from PyQt4 import QtGui

class Console(QtGui.QPlainTextEdit):
    def __init__(self, prompt='$> ', startup_message='', parent=None):
        QtGui.QPlainTextEdit.__init__(self, parent)
        self.prompt = prompt
        self.history = []
        self.namespace = {}
        self.construct = []

        self.setGeometry(50, 75, 600, 400)
        self.setWordWrapMode(QtGui.QTextOption.WrapAnywhere)
        self.setUndoRedoEnabled(False)
        self.document().setDefaultFont(QtGui.QFont("monospace", 10, QtGui.QFont.Normal))
        self.showMessage(startup_message)

    def updateNamespace(self, namespace):
        self.namespace.update(namespace)

    def showMessage(self, message):
        self.appendPlainText(message)
        self.newPrompt()

    def newPrompt(self):
        if self.construct:
            prompt = '.' * len(self.prompt)
        else:
            prompt = self.prompt
        self.appendPlainText(prompt)
        self.moveCursor(QtGui.QTextCursor.End)

    def getCommand(self):
        doc = self.document()
        curr_line = unicode(doc.findBlockByLineNumber(doc.lineCount() - 1).text())
        curr_line = curr_line.rstrip()
        curr_line = curr_line[len(self.prompt):]
        return curr_line

    def setCommand(self, command):
        if self.getCommand() == command:
            return
        self.moveCursor(QtGui.QTextCursor.End)
        self.moveCursor(QtGui.QTextCursor.StartOfLine, QtGui.QTextCursor.KeepAnchor)
        for i in range(len(self.prompt)):
            self.moveCursor(QtGui.QTextCursor.Right, QtGui.QTextCursor.KeepAnchor)
        self.textCursor().removeSelectedText()
        self.textCursor().insertText(command)
        self.moveCursor(QtGui.QTextCursor.End)

    def getConstruct(self, command):
        if self.construct:
            prev_command = self.construct[-1]
            self.construct.append(command)
            if not prev_command and not command:
                ret_val = '\n'.join(self.construct)
                self.construct = []
                return ret_val
            else:
                return ''
        else:
            if command and command[-1] == (':'):
                self.construct.append(command)
                return ''
            else:
                return command

    def getHistory(self):
        return self.history

    def setHisory(self, history):
        self.history = history

    def addToHistory(self, command):
        if command and (not self.history or self.history[-1] != command):
            self.history.append(command)
        self.history_index = len(self.history)

    def getPrevHistoryEntry(self):
        if self.history:
            self.history_index = max(0, self.history_index - 1)
            return self.history[self.history_index]
        return ''

    def getNextHistoryEntry(self):
        if self.history:
            hist_len = len(self.history)
            self.history_index = min(hist_len, self.history_index + 1)
            if self.history_index < hist_len:
                return self.history[self.history_index]
        return ''

    def getCursorPosition(self):
        return self.textCursor().columnNumber() - len(self.prompt)

    def setCursorPosition(self, position):
        self.moveCursor(QtGui.QTextCursor.StartOfLine)
        for i in range(len(self.prompt) + position):
            self.moveCursor(QtGui.QTextCursor.Right)

    def runCommand(self):
        command = self.getCommand()
        self.addToHistory(command)

        command = self.getConstruct(command)

        if command:
            tmp_stdout = sys.stdout

            class stdoutProxy():
                def __init__(self, write_func):
                    self.write_func = write_func
                    self.skip = False

                def write(self, text):
                    if not self.skip:
                        stripped_text = text.rstrip('\n')
                        self.write_func(stripped_text)
                        QtCore.QCoreApplication.processEvents()
                    self.skip = not self.skip

            sys.stdout = stdoutProxy(self.appendPlainText)
            try:
                try:
                    result = eval(command, self.namespace, self.namespace)
                    if result != None:
                        self.appendPlainText(repr(result))
                except SyntaxError:
                    exec command in self.namespace
            except SystemExit:
                self.close()
            except:
                traceback_lines = traceback.format_exc().split('\n')
                # Remove traceback mentioning this file, and a linebreak
                for i in (3,2,1,-1):
                    traceback_lines.pop(i)
                self.appendPlainText('\n'.join(traceback_lines))
            sys.stdout = tmp_stdout
        self.newPrompt()

    def keyPressEvent(self, event):
        if event.key() in (QtCore.Qt.Key_Enter, QtCore.Qt.Key_Return):
            self.runCommand()
            return
        if event.key() == QtCore.Qt.Key_Home:
            self.setCursorPosition(0)
            return
        if event.key() == QtCore.Qt.Key_PageUp:
            return
        elif event.key() in (QtCore.Qt.Key_Left, QtCore.Qt.Key_Backspace):
            if self.getCursorPosition() == 0:
                return
        elif event.key() == QtCore.Qt.Key_Up:
            self.setCommand(self.getPrevHistoryEntry())
            return
        elif event.key() == QtCore.Qt.Key_Down:
            self.setCommand(self.getNextHistoryEntry())
            return
        elif event.key() == QtCore.Qt.Key_D and event.modifiers() == QtCore.Qt.ControlModifier:
            self.close()
        super(Console, self).keyPressEvent(event)

welcome_message = '''
   ---------------------------------------------------------------
     Welcome to a primitive Python interpreter.
   ---------------------------------------------------------------
'''

if __name__ == '__main__':
    app = QtGui.QApplication(sys.argv)
    console = Console(startup_message=welcome_message)
    console.updateNamespace({'myVar1' : app, 'myVar2' : 1234})
    console.show();
    sys.exit(app.exec_())

Answer 1

我知道有点晚了，但我推荐 code.InteractiveConsole 类： http://docs.python.org/py3k/library/code.html#code.InteractiveConsole

Answer 2

您可能会考虑使用线程在打印大循环时保持 UI 响应。这也有助于保持你的回溯干净。

将变量保存在字典中是正确的方法——这就是 Python 本身在内部所做的事情。
至于揭露“其中一些，但不是全部”，请考虑全部揭露。容易多了。如果您担心安全性，请注意您无法可靠地隐藏 Python 中的任何内容。

至于丑陋的光标/文本操作：利用你有 GUI 的事实。
对于终端，您只有一个“文本框”，但在 Qt 中，拥有一个日志/结果视图和一个单独命令框可能更合适。

日志视图将在只读文本框中显示输入的命令和结果。

命令文本框将允许您干净地输入命令。

这种方法在某些 Web 框架中使用 - 例如通过 WebError:

< img src="https://i.sstatic.net/4IckU.png" alt="在此处输入图像描述">

Answer 3

支持 IPython 0.13 的代码更新版本初稿

'''
Created on 18-03-2012

@author: Paweł Jarosz
'''
import os, sys
import atexit

from PySide import QtCore, QtGui

from IPython.zmq.ipkernel import IPKernelApp
from IPython.lib.kernel import find_connection_file, connect_qtconsole
from IPython.frontend.qt.kernelmanager import QtKernelManager
from IPython.frontend.qt.console.rich_ipython_widget import RichIPythonWidget
from IPython.config.application import catch_config_error

class IPythonLocalKernelApp(IPKernelApp):
    """IPython kernel application with nonblocking loop, running in dedicated thread.
    example:
        app = QtGui.QApplication([])
        kernelapp = IPythonLocalKernelApp.instance()
        kernelapp.start()
        namespace = kernelapp.get_user_namespace()
        namespace["QtGui"]=QtGui
        namespace["QtCore"]=QtCore
        app.exec_()"""
    #DEFAULT_INSTANCE_ARGS starting commandline
    DEFAULT_INSTANCE_ARGS = ['qtconsole','--pylab=inline', '--colors=linux']

    @catch_config_error
    def initialize(self, argv=None):
        super(IPythonLocalKernelApp, self).initialize(argv)
        self.kernel.eventloop = self.loop_qt4_nonblocking

    def loop_qt4_nonblocking(self, kernel):
        """Non-blocking version of the ipython qt4 kernel loop"""
        kernel.timer = QtCore.QTimer()
        kernel.timer.timeout.connect(kernel.do_one_iteration)
        kernel.timer.start(1000*kernel._poll_interval)

    def start(self, argv=DEFAULT_INSTANCE_ARGS):
        """Starts IPython kernel app
            argv: arguments passed to kernel
        """
        self.initialize(argv)
        #self.heartbeat.start()
        #if self.poller is not None:
        #    self.poller.start()

        self.kernel.start()
        super(IPythonLocalKernelApp, self).start()


    def get_connection_file(self):
        """Returne current kernel connection file."""
        return self.connection_file

    def get_user_namespace(self):
        """Returns current kernel userspace dict"""
        return self.kernel.shell.user_ns

class IPythonConsoleQtWidget(RichIPythonWidget):
    """Ipython console Qt4+ widget
        Usage example:
            app = QtGui.QApplication([])
            kernelapp = IPythonLocalKernelApp.instance()
            kernelapp.start()
            namespace = kernelapp.get_user_namespace()
            widget = IPythonConsoleQtWidget()
            widget.set_default_style(colors='linux')
            widget.connect_kernel(connection_file=kernelapp.get_connection_file())
            # if you won't to connect to remote kernel:
            widget.connect_kernel(connection_file='kernel-16098.json')

            widget.show()

            namespace["widget"] = widget
            namespace["QtGui"]=QtGui
            namespace["QtCore"]=QtCore

            app.exec_()"""
    _connection_file = None

    def __init__(self, *args, **kw):
        RichIPythonWidget.__init__(self, *args, **kw)
        self._existing = True
        self._may_close = False
        self._confirm_exit = False

    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)

    def connect_kernel(self, connection_file, heartbeat=False):
        """Connect's to ipython kernel.
        connection_file    - connection file to use
        heartbeat          - should start heartbeat server? Workaround for problems with inproc embedded kernels
                             (right click save image as/save as html kills kernel heartbeat/pool(??) serwer """

        self._heartbeat = heartbeat
        if os.path.exists(connection_file):
            self._connection_file = connection_file
        else:
            self._connection_file = find_connection_file(connection_file)

        self._init_kernel_manager()



app = QtGui.QApplication([])
kernelapp = IPythonLocalKernelApp.instance()
kernelapp.start()
namespace = kernelapp.get_user_namespace()
widget = IPythonConsoleQtWidget()
widget.set_default_style(colors='linux')
widget.connect_kernel(connection_file=kernelapp.get_connection_file())
# if you won't to connect to remote kernel:
# widget.connect_kernel(connection_file='kernel-16098.json')

widget.show()

namespace["widget"] = widget
namespace["QtGui"]=QtGui
namespace["QtCore"]=QtCore

app.exec_()

Answer 4

不确定您到底想要什么，但尝试将小部件内容保存到临时文件中并使用 Popen 将其传递给标准 python 解释器？

文档在这里：http://docs.python。 org/release/2.6.5/library/subprocess.html#subprocess.Popen

示例：

import tempfile, os, sys, subprocess

# get the code
code = get_widget_content()

# save the code to a temporary file
file_handle, file_path = tempfile.mkstemp()
tmp_file = os.fdopen(file_handle, 'w')
tmp_file.write(code)
tmp_file.close()

#execute it
p = subprocess.Popen([sys.executable, file_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE)

# wait for the command to complete 
p.wait()

# retrieve the output:
pyerr = p.stderr.readlines()
pyout = p.stdout.readlines()

# do what ever you want with it
print(pyerr)
print(pyout)

Answer 5

听起来您所做的事情与我的 Veusz 应用程序 https://veusz.github.io/ 类似。我想您可能会发现查看更完整的实现很有用。我无法发布超链接，但请查看 windows/consolewindow.py 的小部件类。命令由 document/commandinterpreter.py 类执行。该接口在 document/commandinterface.py 中定义。然而，它主要是通过操纵字典来完成的。