eric: comparison eric6/QScintilla/Shell.py

-:fb0ef164f536
+:698ae46f40a4
 Module implementing a graphical Python shell.
 """
 import sys
 import re
+import contextlib
-from enum import Enum
+import enum
 from PyQt5.QtCore import pyqtSignal, pyqtSlot, QFileInfo, Qt, QEvent
 from PyQt5.QtGui import QClipboard, QPalette, QFont
 from PyQt5.QtWidgets import (
 QDialog, QInputDialog, QApplication, QMenu, QWidget, QHBoxLayout,
 @param horizontal flag indicating a horizontal layout
 @type bool
 @param parent parent widget
 @type QWidget
 """
-super(ShellAssembly, self).__init__(parent)
+super().__init__(parent)
 self.__shell = Shell(dbs, vm, project, False, self)
 from UI.SearchWidget import SearchWidget
 self.__searchWidget = SearchWidget(self.__shell, self, horizontal)
 @return reference to the shell widget (Shell)
 """
 return self.__shell
-class ShellHistoryStyle(Enum):
+class ShellHistoryStyle(enum.Enum):
 """
 Class defining the shell history styles.
 """
-Disabled = 0
+DISABLED = 0
-LinuxStyle = 1
+LINUXSTYLE = 1
-WindowsStyle = 2
+WINDOWSSTYLE = 2
 class Shell(QsciScintillaCompat):
 """
 Class implementing a graphical Python shell.
 @param windowedVariant flag indicating the shell window variant
 @type bool
 @param parent parent widget
 @type QWidget
 """
-super(Shell, self).__init__(parent)
+super().__init__(parent)
 self.setUtf8(True)
 self.vm = vm
 self.__mainWindow = parent
 self.__lastSearch = ()
 dbs.clientSyntaxError.connect(self.__clientSyntaxError)
 dbs.clientSignal.connect(self.__clientSignal)
 dbs.mainClientExit.connect(self.__writePrompt)
 self.dbs = dbs
-self.__debugUI = None
+# will register a method to get the debugger ID to work with
+self.__getSelectedDebuggerId = None
 # Make sure we have prompts.
 if self.passive:
 sys.ps1 = self.tr("Passive >>> ")
 else:
 """
 self.setTabWidth(Preferences.getEditor("TabWidth"))
 if Preferences.getEditor("ShowWhitespace"):
 self.setWhitespaceVisibility(
 QsciScintilla.WhitespaceVisibility.WsVisible)
-try:
+with contextlib.suppress(AttributeError):
 self.setWhitespaceForegroundColor(
 Preferences.getEditorColour("WhitespaceForeground"))
 self.setWhitespaceBackgroundColor(
 Preferences.getEditorColour("WhitespaceBackground"))
 self.setWhitespaceSize(
 Preferences.getEditor("WhitespaceSize"))
-except AttributeError:
-# QScintilla before 2.5 doesn't support this
-pass
 else:
 self.setWhitespaceVisibility(
 QsciScintilla.WhitespaceVisibility.WsInvisible)
 self.setEolVisibility(Preferences.getEditor("ShowEOL"))
 if Preferences.getEditor("BraceHighlighting"):
 Public method to set the debugger UI.
 @param ui reference to the debugger UI object (DebugUI)
 """
 ui.exceptionInterrupt.connect(self.__writePrompt)
-self.__debugUI = ui
+self.registerDebuggerIdMethod(ui.getSelectedDebuggerId)
+def registerDebuggerIdMethod(self, method):
+"""
+Public method to register a method to get the debugger ID to send data
+to.
+@param method reference to the method
+@type function
+"""
+self.__getSelectedDebuggerId = method
 def __initialise(self):
 """
 Private method to get ready for a new remote interpreter.
 """
 """
 if index is None:
 # determine based on history style
 if (
 self.clientType and
-self.__historyStyle == ShellHistoryStyle.WindowsStyle
+self.__historyStyle == ShellHistoryStyle.WINDOWSSTYLE
 ):
 idx = int(Preferences.Prefs.settings.value(
 "Shell/HistoryIndexes/" + self.clientType, -1))
 if idx >= len(self.__history):
 idx = -1
 self.__histidx = index
 if self.__histidx >= len(self.__history):
 self.__histidx = -1
 if (
 self.clientType and
-self.__historyStyle == ShellHistoryStyle.WindowsStyle
+self.__historyStyle == ShellHistoryStyle.WINDOWSSTYLE
 ):
 Preferences.Prefs.settings.setValue(
 "Shell/HistoryIndexes/" + self.clientType, self.__histidx)
 def __isHistoryIndexValid(self):
 @param platform platform of the remote interpreter
 @type str
 @param venvName name of the virtual environment
 @type str
 """
-super(Shell, self).clear()
+super().clear()
 if self.passive and not self.dbs.isConnected():
 self.__write(self.tr('Passive Debug Mode'))
 self.__write(self.tr('\nNot connected'))
 else:
 self.__currentVenv = venvName
 """
 self .__clientError()
 if (
 not self.__windowed and
-Preferences.getDebugger("ShowExceptionInShell")
+Preferences.getDebugger("ShowExceptionInShell") and
+exceptionType
 ):
-if exceptionType:
+if stackTrace:
-if stackTrace:
+self.__write(
-self.__write(
+self.tr('Exception "{0}"\n{1}\nFile: {2}, Line: {3}\n')
-self.tr('Exception "{0}"\n{1}\nFile: {2}, Line: {3}\n')
+.format(
-.format(
+exceptionType,
-exceptionType,
+exceptionMessage,
-exceptionMessage,
+stackTrace[0][0],
-stackTrace[0][0],
+stackTrace[0][1]
-stackTrace[0][1]
-)
 )
-else:
+)
-self.__write(
+else:
-self.tr('Exception "{0}"\n{1}\n')
+self.__write(
-.format(
+self.tr('Exception "{0}"\n{1}\n')
-exceptionType,
+.format(
-exceptionMessage)
+exceptionType,
-)
+exceptionMessage)
+)
 def __clientSyntaxError(self, message, filename, lineNo, characterNo):
 """
 Private method to handle a syntax error in the debugged program.
 self.setFocus()
 if event.button() == Qt.MouseButton.MidButton:
 lines = QApplication.clipboard().text(QClipboard.Mode.Selection)
 self.paste(lines)
 else:
-super(Shell, self).mousePressEvent(event)
+super().mousePressEvent(event)
 def wheelEvent(self, evt):
 """
 Protected method to handle wheel events.
 elif delta > 0:
 self.zoomIn()
 evt.accept()
 return
-super(Shell, self).wheelEvent(evt)
+super().wheelEvent(evt)
 def event(self, evt):
 """
 Public method handling events.
 """
 if evt.type() == QEvent.Type.Gesture:
 self.gestureEvent(evt)
 return True
-return super(Shell, self).event(evt)
+return super().event(evt)
 def gestureEvent(self, evt):
 """
 Protected method handling gesture events.
 line, col = self.__getEndPos()
 self.setCursorPosition(line, col)
 self.prline, self.prcol = self.getCursorPosition()
 if self.__echoInput:
 ac = self.isListActive()
-super(Shell, self).keyPressEvent(ev)
+super().keyPressEvent(ev)
 self.incrementalSearchActive = True
 if ac and self.racEnabled:
 self.dbs.remoteCompletion(
-self.__debugUI.getSelectedDebuggerId(),
+self.__getSelectedDebuggerId(),
 self.completionText + txt
 )
 else:
 self.__insertTextNoEcho(txt)
 else:
 buf = buf.replace(sys.ps2, "")
 if self.inContinue and not buf[:index - len(sys.ps2)].strip():
 self.SendScintilla(cmd)
 elif self.racEnabled:
 self.dbs.remoteCompletion(
-self.__debugUI.getSelectedDebuggerId(),
+self.__getSelectedDebuggerId(),
 buf
 )
 def __QScintillaLeftDeleteCommand(self, method):
 """
 method()
 db = 1
 if db and ac and self.racEnabled and self.completionText:
 delta = len(self.text(line)) - oldLength
 self.dbs.remoteCompletion(
-self.__debugUI.getSelectedDebuggerId(),
+self.__getSelectedDebuggerId(),
 self.completionText[:delta]
 )
 def __QScintillaDeleteBack(self):
 """
 if cmd != "" and (
 len(self.__history) == 0 or self.__history[-1] != cmd):
 if len(self.__history) == self.__maxHistoryEntries:
 del self.__history[0]
 self.__history.append(cmd)
-if self.__historyStyle == ShellHistoryStyle.LinuxStyle:
+if self.__historyStyle == ShellHistoryStyle.LINUXSTYLE:
 self.__setHistoryIndex(index=-1)
-elif self.__historyStyle == ShellHistoryStyle.WindowsStyle:
+elif self.__historyStyle == ShellHistoryStyle.WINDOWSSTYLE:
 if historyIndex is None:
 if (
 self.__histidx - 1 > 0 and
 cmd != self.__history[self.__histidx - 1]
 ):
 # call main window quit()
 self.vm.quit()
 return
 else:
 self.dbs.remoteStatement(
-self.__debugUI.getSelectedDebuggerId(), cmd)
+self.__getSelectedDebuggerId(), cmd)
 while self.inCommandExecution:
-try:
+with contextlib.suppress(KeyboardInterrupt):
 QApplication.processEvents()
-except KeyboardInterrupt:
-pass
 else:
 if not self.__echoInput:
 cmd = self.buff
 self.buff = ""
 elif cmd:
 @type int
 @return tuple containing the index of found entry and a flag indicating
 that something was found
 @rtype tuple of (int, bool)
 """
-if startIdx == -1:
+idx = 0 if startIdx == -1 else startIdx + 1
-idx = 0
-else:
-idx = startIdx + 1
 while (
 idx < len(self.__history) and
 not self.__history[idx].startswith(txt)
 ):
 idx += 1
 @type int
 @return tuple containing the index of found entry and a flag indicating
 that something was found
 @rtype tuple of (int, bool)
 """
-if startIdx == -1:
+idx = len(self.__history) - 1 if startIdx == -1 else startIdx - 1
-idx = len(self.__history) - 1
-else:
-idx = startIdx - 1
 while (
 idx >= 0 and
 not self.__history[idx].startswith(txt)
 ):
 idx -= 1
 event.mimeData().hasText()
 )
 if self.inDragDrop:
 event.acceptProposedAction()
 else:
-super(Shell, self).dragEnterEvent(event)
+super().dragEnterEvent(event)
 def dragMoveEvent(self, event):
 """
 Protected method to handle the drag move event.
 @param event the drag move event (QDragMoveEvent)
 """
 if self.inDragDrop:
 event.accept()
 else:
-super(Shell, self).dragMoveEvent(event)
+super().dragMoveEvent(event)
 def dragLeaveEvent(self, event):
 """
 Protected method to handle the drag leave event.
 """
 if self.inDragDrop:
 self.inDragDrop = False
 event.accept()
 else:
-super(Shell, self).dragLeaveEvent(event)
+super().dragLeaveEvent(event)
 def dropEvent(self, event):
 """
 Protected method to handle the drop event.
 if s:
 event.acceptProposedAction()
 self.executeLines(s)
 del s
 else:
-super(Shell, self).dropEvent(event)
+super().dropEvent(event)
 self.inDragDrop = False
 def focusInEvent(self, event):
 """
 self.__searchNext, self.__searchNext)
 self.__searchPrevShortcut = QShortcut(
 self.vm.searchPrevAct.shortcut(), self,
 self.__searchPrev, self.__searchPrev)
-try:
+with contextlib.suppress(AttributeError):
 self.vm.editActGrp.setEnabled(False)
 self.vm.editorActGrp.setEnabled(True)
 self.vm.copyActGrp.setEnabled(True)
 self.vm.viewActGrp.setEnabled(True)
 self.vm.searchActGrp.setEnabled(False)
-except AttributeError:
-pass
 if not self.__windowed:
 self.__searchShortcut.setEnabled(True)
 self.__searchNextShortcut.setEnabled(True)
 self.__searchPrevShortcut.setEnabled(True)
 self.setCaretWidth(self.caretWidth)
 self.setCursorFlashTime(QApplication.cursorFlashTime())
-super(Shell, self).focusInEvent(event)
+super().focusInEvent(event)
 def focusOutEvent(self, event):
 """
 Protected method called when the shell loses focus.
 @param event the event object (QFocusEvent)
 """
-try:
+with contextlib.suppress(AttributeError):
 self.vm.editorActGrp.setEnabled(False)
-except AttributeError:
-pass
 if not self.__windowed:
 self.__searchShortcut.setEnabled(False)
 self.__searchNextShortcut.setEnabled(False)
 self.__searchPrevShortcut.setEnabled(False)
 self.setCaretWidth(0)
-super(Shell, self).focusOutEvent(event)
+super().focusOutEvent(event)
 def insert(self, txt):
 """
 Public slot to insert text at the current cursor position.
 Public method to check, if the history is enabled.
 @return flag indicating if history is enabled
 @rtype bool
 """
-return self.__historyStyle != ShellHistoryStyle.Disabled
+return self.__historyStyle != ShellHistoryStyle.DISABLED
 #################################################################
 ## Project Support
 #################################################################

Mercurial Repositories > eric / file comparison

comparison: eric6/QScintilla/Shell.py

eric6/QScintilla/Shell.py