myokit 1.33.9__py3-none-any.whl → 1.35.0__py3-none-any.whl

myokit/gui/source.py

@@ -6,12 +6,11 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
-from __future__ import absolute_import, division
-from __future__ import print_function, unicode_literals
-
 import myokit
+
 from myokit.gui import Qt, QtCore, QtGui, QtWidgets
 
+
 # GUI components
 # Constants
 SPACE = ' '
@@ -54,7 +53,7 @@ COLOR_SELECTED_LINE = QtGui.QColor(238, 238, 238)
 
 def _check_for_dark_mode(palette):
     """
-    Checks the default editor background color, and adjusts the colour scheme
+    Checks the default editor background color, and adjusts the color scheme
     if it looks like dark-mode is enabled.
     """
     c = palette.base().color()
@@ -68,7 +67,7 @@ def _check_for_dark_mode(palette):
         STYLE_ANNOT_KEY.setForeground(QtGui.QColor(0, 31, 231))
         STYLE_ANNOT_VAL.setForeground(QtGui.QColor(57, 115, 214))
         STYLE_KEYWORD_1.setForeground(QtGui.QColor(0, 128, 0))
-        STYLE_KEYWORD_1.setFontWeight(QtGui.QFont.Bold)
+        STYLE_KEYWORD_1.setFontWeight(QtGui.QFont.Weight.Bold)
         STYLE_KEYWORD_2.setForeground(QtGui.QColor(0, 128, 128))
         STYLE_LITERAL.setForeground(QtGui.QColor(255, 20, 215))
         STYLE_INLINE_UNIT.setForeground(QtGui.QColor(128, 0, 128))
@@ -78,7 +77,7 @@ def _check_for_dark_mode(palette):
         STYLE_ANNOT_KEY.setForeground(QtGui.QColor(179, 179, 179))
         STYLE_ANNOT_VAL.setForeground(QtGui.QColor(171, 177, 205))
         STYLE_KEYWORD_1.setForeground(QtGui.QColor(10, 195, 87))
-        STYLE_KEYWORD_1.setFontWeight(QtGui.QFont.Bold)
+        STYLE_KEYWORD_1.setFontWeight(QtGui.QFont.Weight.Bold)
         STYLE_KEYWORD_2.setForeground(QtGui.QColor(10, 195, 87))
         STYLE_LITERAL.setForeground(QtGui.QColor(255, 223, 12))
         STYLE_INLINE_UNIT.setForeground(QtGui.QColor(168, 152, 33))
@@ -97,7 +96,7 @@ class Editor(QtWidgets.QPlainTextEdit):
     status bar.
     """
     def __init__(self, parent=None):
-        super(Editor, self).__init__(parent)
+        super().__init__(parent)
 
         # Current style
         self._palette = QtGui.QGuiApplication.palette()
@@ -115,7 +114,12 @@ class Editor(QtWidgets.QPlainTextEdit):
         self.cursor_changed()
 
         # Line position
-        self._line_offset = self.fontMetrics().width(' ' * 79)
+        try:
+            # https://doc.qt.io/qt-5/qfontmetrics.html#horizontalAdvance
+            # Qt 5.5.11 and onwards
+            self._line_offset = self.fontMetrics().horizontalAdvance(' ' * 79)
+        except AttributeError:
+            self._line_offset = self.fontMetrics().width(' ' * 79)
 
         # Number of blocks in page up/down
         self._blocks_per_page = 1
@@ -131,7 +135,7 @@ class Editor(QtWidgets.QPlainTextEdit):
         selection = QtWidgets.QTextEdit.ExtraSelection()
         selection.format.setBackground(COLOR_SELECTED_LINE)
         selection.format.setProperty(
-            QtGui.QTextFormat.FullWidthSelection, True)
+            QtGui.QTextFormat.Property.FullWidthSelection, True)
         selection.cursor = self.textCursor()
         selection.cursor.clearSelection()
         extra_selections.append(selection)
@@ -143,13 +147,14 @@ class Editor(QtWidgets.QPlainTextEdit):
             pos = cursor.position()
             bracket = None
             if not cursor.atEnd():
-                cursor.setPosition(pos + 1, QtGui.QTextCursor.KeepAnchor)
+                cursor.setPosition(
+                    pos + 1, QtGui.QTextCursor.MoveMode.KeepAnchor)
                 text = cursor.selectedText()
                 if text in BRACKETS:
                     bracket = cursor
             elif bracket is None and not cursor.atStart():
                 cursor.setPosition(pos - 1)
-                cursor.setPosition(pos, QtGui.QTextCursor.KeepAnchor)
+                cursor.setPosition(pos, QtGui.QTextCursor.MoveMode.KeepAnchor)
                 text = cursor.selectedText()
                 if text in BRACKETS:
                     bracket = cursor
@@ -163,10 +168,10 @@ class Editor(QtWidgets.QPlainTextEdit):
                     if text in BRACKETS_CLOSE:
                         other = doc.find(
                             text, start - 1,
-                            QtGui.QTextDocument.FindBackward)
+                            QtGui.QTextDocument.FindFlag.FindBackward)
                         match = doc.find(
                             BRACKETS[text], start - 1,
-                            QtGui.QTextDocument.FindBackward)
+                            QtGui.QTextDocument.FindFlag.FindBackward)
                     else:
                         other = doc.find(text, start)
                         match = doc.find(BRACKETS[text], start)
@@ -222,11 +227,20 @@ class Editor(QtWidgets.QPlainTextEdit):
         # Set font
         self.setFont(FONT)
         # Set frame
-        self.setFrameStyle(QtWidgets.QFrame.WinPanel | QtWidgets.QFrame.Sunken)
+        self.setFrameStyle(
+            QtWidgets.QFrame.Shape.WinPanel | QtWidgets.QFrame.Shadow.Sunken)
         # Disable wrapping
-        self.setLineWrapMode(self.NoWrap)
+        self.setLineWrapMode(QtWidgets.QPlainTextEdit.LineWrapMode.NoWrap)
         # Set tab width (if ever seen) to 4 spaces
-        self.setTabStopWidth(self.fontMetrics().width(' ' * 4))
+        try:
+            # https://doc.qt.io/qt-5/qtextedit-obsolete.html
+            # https://doc.qt.io/qt-5/qfontmetrics.html#horizontalAdvance
+            # Qt 5.10/5.11 and onwards
+            ts = self.fontMetrics().horizontalAdvance(' ' * 4)
+            self.setTabStopDistance(ts)
+        except AttributeError:
+            ts = self.fontMetrics().width(' ' * 4)
+            self.setTabStopWidth(ts)
 
     def get_text(self):
         """ Returns the text in this editor. """
@@ -242,6 +256,11 @@ class Editor(QtWidgets.QPlainTextEdit):
 
     def keyPressEvent(self, event):
         """ Qt event: A key was pressed. """
+        K = Qt.Key
+        KM = Qt.KeyboardModifier
+        MM = QtGui.QTextCursor.MoveMode
+        MO = QtGui.QTextCursor.MoveOperation
+
         # Get key and modifiers
         key = event.key()
         mod = event.modifiers()
@@ -251,11 +270,13 @@ class Editor(QtWidgets.QPlainTextEdit):
         #  MetaModifier (i.e. super key)
         #  KeyPadModifier (button is part of keypad)
         #  GroupSwitchModifier (x11 thing)
+
         # Ignore the keypad modifier, we don't care!
-        if mod & Qt.KeypadModifier:
-            mod = mod ^ Qt.KeypadModifier   # xor!
+        if mod & KM.KeypadModifier:
+            mod = mod ^ KM.KeypadModifier   # xor!
+
         # Actions per key/modifier combination
-        if key == Qt.Key_Tab and mod == Qt.NoModifier:
+        if key == K.Key_Tab and mod == KM.NoModifier:
             # Indent
             cursor = self.textCursor()
             start, end = cursor.selectionStart(), cursor.selectionEnd()
@@ -275,7 +296,7 @@ class Editor(QtWidgets.QPlainTextEdit):
                 pos = cursor.positionInBlock()
                 cursor.insertText((TABS - pos % TABS) * SPACE)
 
-        elif key == Qt.Key_Backtab and mod == Qt.ShiftModifier:
+        elif key == K.Key_Backtab and mod == KM.ShiftModifier:
             # Dedent all lines in selection (or single line if no selection)
             '''
             cursor = self.textCursor()
@@ -295,11 +316,11 @@ class Editor(QtWidgets.QPlainTextEdit):
                 p2 = p1 + min(4, len(t) - len(t.lstrip()))
                 c = self.textCursor()
                 c.setPosition(p1)
-                c.setPosition(p2, QtGui.QTextCursor.KeepAnchor)
+                c.setPosition(p2, MM.KeepAnchor)
                 c.removeSelectedText()
             cursor.endEditBlock()
             '''
-            # This silly method is required because of a bug in qt4/qt5
+            # This silly method is required because of a bug in qt5 (and 6?)
             cursor = self.textCursor()
             start, end = cursor.selectionStart(), cursor.selectionEnd()
             first = self.document().findBlock(start)
@@ -324,22 +345,21 @@ class Editor(QtWidgets.QPlainTextEdit):
                 cursor.beginEditBlock()
                 cursor.setPosition(first.position())
                 cursor.setPosition(
-                    last.position() + last.length() - 1,
-                    QtGui.QTextCursor.KeepAnchor)
+                    last.position() + last.length() - 1, MM.KeepAnchor)
                 cursor.removeSelectedText()
                 cursor.insertText('\n'.join(new_text))
                 cursor.endEditBlock()
                 # Set new cursor
                 cursor.setPosition(new_start)
-                cursor.setPosition(new_end, QtGui.QTextCursor.KeepAnchor)
+                cursor.setPosition(new_end, MM.KeepAnchor)
                 self.setTextCursor(cursor)
 
-        elif key == Qt.Key_Enter or key == Qt.Key_Return:
+        elif key == K.Key_Enter or key == K.Key_Return:
             # Enter/Return with modifier is overruled here to mean nothing
             # This is very important as the default for shift-enter is to
             # start a new line within the same block (this can't happen with
             # copy-pasting, so it's safe to just catch it here).
-            if mod == Qt.NoModifier:
+            if mod == KM.NoModifier:
                 # "Smart" enter:
                 #   - If selection, selection is deleted
                 #   - Else, autoindenting is performed
@@ -361,8 +381,8 @@ class Editor(QtWidgets.QPlainTextEdit):
                 # Scroll if necessary
                 self.ensureCursorVisible()
 
-        elif key == Qt.Key_Home and (
-                mod == Qt.NoModifier or mod == Qt.ShiftModifier):
+        elif key == K.Key_Home and (
+                mod == KM.NoModifier or mod == KM.ShiftModifier):
             # Plain home button: move to start of line
             # If Control is used: Jump to start of document
             # Ordinary home button: Jump to first column or first
@@ -385,25 +405,22 @@ class Editor(QtWidgets.QPlainTextEdit):
                 # Smart up/down:
                 self._last_column = indent
             # If Shift is used: only move position (keep anchor, i.e. select)
-            anchor = (
-                QtGui.QTextCursor.KeepAnchor if mod == Qt.ShiftModifier
-                else QtGui.QTextCursor.MoveAnchor)
-            cursor.setPosition(newpos, anchor)
+            cursor.setPosition(
+                newpos,
+                MM.KeepAnchor if mod == KM.ShiftModifier else MM.MoveAnchor)
             self.setTextCursor(cursor)
 
-        elif key == Qt.Key_Home and (
-                mod == Qt.ControlModifier
-                or mod == Qt.ControlModifier & Qt.ShiftModifier):
+        elif key == K.Key_Home and (
+                mod == KM.ControlModifier
+                or mod == KM.ControlModifier & KM.ShiftModifier):
             # Move to start of document
             # If Shift is used: only move position (keep anchor, i.e. select)
-            anchor = (
-                QtGui.QTextCursor.KeepAnchor if mod == Qt.ShiftModifier
-                else QtGui.QTextCursor.MoveAnchor)
             cursor = self.textCursor()
-            cursor.setPosition(0, anchor)
+            cursor.setPosition(
+                0, MM.KeepAnchor if mod == KM.ShiftModifier else MM.MoveAnchor)
             self.setTextCursor(cursor)
 
-        elif key in (Qt.Key_Up, Qt.Key_Down) and mod == Qt.AltModifier:
+        elif key in (K.Key_Up, K.Key_Down) and mod == KM.AltModifier:
             # Move selected lines up or down
             # Get current selection
             doc = self.document()
@@ -420,7 +437,7 @@ class Editor(QtWidgets.QPlainTextEdit):
                     block2 = block2.previous()  # always valid
             block2 = block1 if start == end else doc.findBlock(end)
             # Check if we can move
-            if key == Qt.Key_Up:
+            if key == K.Key_Up:
                 if not block1.previous().isValid():
                     return
             elif not block2.next().isValid():
@@ -429,30 +446,28 @@ class Editor(QtWidgets.QPlainTextEdit):
             b1pos = block1.position()
             cursor.beginEditBlock()
             cursor.setPosition(b1pos)
-            cursor.setPosition(end, QtGui.QTextCursor.KeepAnchor)
-            cursor.movePosition(
-                QtGui.QTextCursor.EndOfLine, QtGui.QTextCursor.KeepAnchor)
+            cursor.setPosition(end, MM.KeepAnchor)
+            cursor.movePosition(MO.EndOfLine, MM.KeepAnchor)
             line = cursor.selectedText()
             size = cursor.selectionEnd() - cursor.selectionStart()
             cursor.removeSelectedText()
-            if key == Qt.Key_Up:
+            if key == K.Key_Up:
                 cursor.deletePreviousChar()
-                cursor.movePosition(QtGui.QTextCursor.StartOfLine)
+                cursor.movePosition(MO.StartOfLine)
                 cursor.insertText(line + '\n')
-                cursor.movePosition(QtGui.QTextCursor.Left)
+                cursor.movePosition(MO.Left)
             else:
                 cursor.deleteChar()
-                cursor.movePosition(QtGui.QTextCursor.EndOfLine)
+                cursor.movePosition(MO.EndOfLine)
                 cursor.insertText('\n' + line)
             cursor.endEditBlock()
             # Cursor is at the end of the moved lines.
             # Set moved lines as selection
-            cursor.movePosition(
-                QtGui.QTextCursor.Left, QtGui.QTextCursor.KeepAnchor, size)
+            cursor.movePosition(MO.Left, MM.KeepAnchor, size)
             self.setTextCursor(cursor)
 
-        elif key in (Qt.Key_Up, Qt.Key_Down, Qt.Key_PageUp, Qt.Key_PageDown) \
-                and (mod == Qt.NoModifier or mod == Qt.ShiftModifier):
+        elif key in (K.Key_Up, K.Key_Down, K.Key_PageUp, K.Key_PageDown) \
+                and (mod == KM.NoModifier or mod == KM.ShiftModifier):
             # Move cursor up/down
             # Maintain the column position, even when the current row doesn't
             # have as many characters. Reset this behavior as soon as a
@@ -460,13 +475,12 @@ class Editor(QtWidgets.QPlainTextEdit):
             # changed.
             # Set up operation
             anchor = (
-                QtGui.QTextCursor.KeepAnchor if mod == Qt.ShiftModifier
-                else QtGui.QTextCursor.MoveAnchor)
-            operation = \
-                QtGui.QTextCursor.PreviousBlock if key in (
-                    Qt.Key_Up, Qt.Key_PageUp) else QtGui.QTextCursor.NextBlock
-            n = 1 if key in (Qt.Key_Up, Qt.Key_Down) else (
+                MM.KeepAnchor if mod == KM.ShiftModifier else MM.MoveAnchor)
+            operation = (MO.PreviousBlock if key in (K.Key_Up, K.Key_PageUp)
+                         else MO.NextBlock)
+            n = 1 if key in (K.Key_Up, K.Key_Down) else (
                 self._blocks_per_page - 3)
+
             # Move
             cursor = self.textCursor()
             if self._last_column is None:
@@ -478,22 +492,22 @@ class Editor(QtWidgets.QPlainTextEdit):
             else:
                 # Up/Down beyond document start/end? Move cursor to document
                 # start/end and update last column
-                if operation == QtGui.QTextCursor.NextBlock:
-                    cursor.movePosition(QtGui.QTextCursor.EndOfBlock, anchor)
+                if operation == MO.NextBlock:
+                    cursor.movePosition(MO.EndOfBlock, anchor)
                 else:
-                    cursor.movePosition(QtGui.QTextCursor.StartOfBlock, anchor)
+                    cursor.movePosition(MO.StartOfBlock, anchor)
                 self._last_column = cursor.positionInBlock()
             self.setTextCursor(cursor)
 
-        elif key in (Qt.Key_Left, Qt.Key_Right, Qt.Key_End) and not (
-                mod & Qt.AltModifier):
+        elif key in (K.Key_Left, K.Key_Right, K.Key_End) and not (
+                mod & KM.AltModifier):
             # Allow all modifiers except alt
             # Reset smart up/down behavior
             self._last_column = None
             # Pass to parent class
-            super(Editor, self).keyPressEvent(event)
+            super().keyPressEvent(event)
 
-        elif key == Qt.Key_Insert and mod == Qt.NoModifier:
+        elif key == K.Key_Insert and mod == KM.NoModifier:
             # Insert/replace
             self.setOverwriteMode(not self.overwriteMode())
 
@@ -530,20 +544,26 @@ class Editor(QtWidgets.QPlainTextEdit):
             # Shift-Enter           Starts new line within the same block!
             #                       Definitely removed
             # Ctrl-i                Undocumented, but inserts tab...
-            ctrl_ignore = (Qt.Key_K, Qt.Key_I)
-            if mod == Qt.ControlModifier and key in ctrl_ignore:
+            ctrl_ignore = (K.Key_K, K.Key_I)
+            if mod == KM.ControlModifier and key in ctrl_ignore:
                 # Control-K: ignore
                 pass
-            elif key == Qt.Key_Up or key == Qt.Key_Down:
+            elif key == K.Key_Up or key == K.Key_Down:
                 # Up/down with modifiers: ignore
                 pass
             else:
                 # Let parent class handle it
-                super(Editor, self).keyPressEvent(event)
+                super().keyPressEvent(event)
 
     def _line_number_area_width(self):
         """ Returns the required width for the number area. """
-        return 8 + self.fontMetrics().width(str(max(1, self.blockCount())))
+        text = str(max(1, self.blockCount()))
+        try:
+            # https://doc.qt.io/qt-5/qfontmetrics.html#horizontalAdvance
+            # Qt 5.5.11 and onwards
+            return 8 + self.fontMetrics().horizontalAdvance(text)
+        except AttributeError:
+            return 8 + self.fontMetrics().width(text)
 
     def _line_number_area_paint(self, area, event):
         """ Repaints the line number area. """
@@ -573,8 +593,8 @@ class Editor(QtWidgets.QPlainTextEdit):
         while block.isValid() and btop <= ebot:
             count += 1
             if block.isVisible() and bbot >= etop:
-                painter.drawText(
-                    0, btop, width - 4, height, Qt.AlignRight, str(count))
+                painter.drawText(0, btop, width - 4, height,
+                                 Qt.AlignmentFlag.AlignRight, str(count))
             block = block.next()
             btop = bbot
             bbot += int(self.blockBoundingRect(block).height())
@@ -583,7 +603,7 @@ class Editor(QtWidgets.QPlainTextEdit):
         """ Paints this editor. """
 
         # Paint the editor
-        super(Editor, self).paintEvent(e)
+        super().paintEvent(e)
 
         # Paint a line between the editor and the line number area
         x = int(
@@ -610,7 +630,7 @@ class Editor(QtWidgets.QPlainTextEdit):
 
     def resizeEvent(self, event):
         """ Qt event: Editor is resized. """
-        super(Editor, self).resizeEvent(event)
+        super().resizeEvent(event)
         # Update line number area
         rect = self.contentsRect()
         self._line_number_area.setGeometry(
@@ -677,7 +697,8 @@ class Editor(QtWidgets.QPlainTextEdit):
             for block in blocks:
                 p = block.position() + indent
                 cursor.setPosition(p)
-                cursor.setPosition(p + 1, QtGui.QTextCursor.KeepAnchor)
+                cursor.setPosition(
+                    p + 1, QtGui.QTextCursor.MoveMode.KeepAnchor)
                 cursor.removeSelectedText()
         else:
 
@@ -686,7 +707,8 @@ class Editor(QtWidgets.QPlainTextEdit):
                 n = len(block.text())
                 if len(block.text()) < indent:
                     cursor.setPosition(p)
-                    cursor.setPosition(p + n, QtGui.QTextCursor.KeepAnchor)
+                    cursor.setPosition(
+                        p + n, QtGui.QTextCursor.MoveMode.KeepAnchor)
                     cursor.removeSelectedText()
                     cursor.insertText(' ' * indent + '#')
                 else:
@@ -705,8 +727,8 @@ class Editor(QtWidgets.QPlainTextEdit):
             b = len(t.rstrip())
             if a > b:
                 cursor.setPosition(block.position() + b)
-                cursor.setPosition(
-                    block.position() + a, QtGui.QTextCursor.KeepAnchor)
+                cursor.setPosition(block.position() + a,
+                                   QtGui.QTextCursor.MoveMode.KeepAnchor)
                 cursor.removeSelectedText()
             block = block.next()
         cursor.endEditBlock()
@@ -722,7 +744,7 @@ class LineNumberArea(QtWidgets.QWidget):
     """
 
     def __init__(self, editor):
-        super(LineNumberArea, self).__init__(editor)
+        super().__init__(editor)
         self._editor = editor
         self._editor.blockCountChanged.connect(self.update_width)
         self._editor.updateRequest.connect(self.update_contents)
@@ -766,7 +788,7 @@ class FindReplaceWidget(QtWidgets.QWidget):
     find_action = QtCore.Signal(str)
 
     def __init__(self, parent, editor):
-        super(FindReplaceWidget, self).__init__(parent)
+        super().__init__(parent)
         self._editor = editor
 
         # Create widgets
@@ -789,7 +811,8 @@ class FindReplaceWidget(QtWidgets.QWidget):
         text_layout.addWidget(self._search_field, 0, 1)
         text_layout.addWidget(self._replace_label, 1, 0)
         text_layout.addWidget(self._replace_field, 1, 1)
-        check_layout = QtWidgets.QBoxLayout(QtWidgets.QBoxLayout.TopToBottom)
+        check_layout = QtWidgets.QBoxLayout(
+            QtWidgets.QBoxLayout.Direction.TopToBottom)
         check_layout.addWidget(self._case_check)
         check_layout.addWidget(self._whole_check)
         button_layout = QtWidgets.QGridLayout()
@@ -797,7 +820,8 @@ class FindReplaceWidget(QtWidgets.QWidget):
         button_layout.addWidget(self._replace_button, 0, 2)
         button_layout.addWidget(self._find_button, 0, 3)
 
-        layout = QtWidgets.QBoxLayout(QtWidgets.QBoxLayout.TopToBottom)
+        layout = QtWidgets.QBoxLayout(
+            QtWidgets.QBoxLayout.Direction.TopToBottom)
         layout.addLayout(text_layout)
         layout.addLayout(check_layout)
         layout.addLayout(button_layout)
@@ -814,11 +838,11 @@ class FindReplaceWidget(QtWidgets.QWidget):
         if query == '':
             self.find_action.emit('No query set')
             return
-        flags = 0x0
+        flags = QtGui.QTextDocument.FindFlag(0)
         if self._case_check.isChecked():
-            flags |= QtGui.QTextDocument.FindCaseSensitively
+            flags |= QtGui.QTextDocument.FindFlag.FindCaseSensitively
         if self._whole_check.isChecked():
-            flags |= QtGui.QTextDocument.FindWholeWords
+            flags |= QtGui.QTextDocument.FindFlag.FindWholeWords
         if flags:
             found = self._editor.find(query, flags)
         else:
@@ -867,11 +891,11 @@ class FindReplaceWidget(QtWidgets.QWidget):
         if query == '':
             self.find_action.emit('No query set')
             return
-        flags = 0x0
+        flags = QtGui.QTextDocument.FindFlag(0)
         if self._case_check.isChecked():
-            flags |= QtGui.QTextDocument.FindCaseSensitively
+            flags |= QtGui.QTextDocument.FindFlag.FindCaseSensitively
         if self._whole_check.isChecked():
-            flags |= QtGui.QTextDocument.FindWholeWords
+            flags |= QtGui.QTextDocument.FindFlag.FindWholeWords
         n = 0
         found = True
         scrollpos = self._editor.verticalScrollBar().value()
@@ -917,10 +941,10 @@ class FindReplaceWidget(QtWidgets.QWidget):
     def keyPressEvent(self, event):
         """ Qt event: A key-press reaches the widget. """
         key = event.key()
-        if key == Qt.Key_Enter or key == Qt.Key_Return:
+        if key == Qt.Key.Key_Enter or key == Qt.Key.Key_Return:
             self.action_find()
         else:
-            super(FindReplaceWidget, self).keyPressEvent(event)
+            super().keyPressEvent(event)
 
     def load_config(self, config, section):
         """
@@ -956,144 +980,153 @@ class ModelHighlighter(QtGui.QSyntaxHighlighter):
     ANNOT_KEYS = ['in', 'bind', 'label']
 
     def __init__(self, document):
-        super(ModelHighlighter, self).__init__(document)
+        super().__init__(document)
 
         # Expressions used to find strings & comments
-        self._string_start = QtCore.QRegExp(r'"""')
-        self._string_stop = QtCore.QRegExp(r'"""')
-        self._comment_start = QtCore.QRegExp(r'#[^\n]*')
+        R = QtCore.QRegularExpression
+        self._string = R(r'"""')
 
         # Headers
         name = r'[a-zA-Z]+[a-zA-Z0-9_]*'
-        self._rule_head = QtCore.QRegExp(r'^(\s*)\[{1,2}' + name + '\]{1,2}')
+        self._rule_head = R(r'^\s*(\[{1,2}' + name + '\]{1,2})')
 
         # Simple rules
         self._rules = []
 
         # Numbers
-        pattern = QtCore.QRegExp(r'\b[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?\b')
+        pattern = R(r'\b[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?\b')
         self._rules.append((pattern, STYLE_LITERAL))
-        unit = r'\[[a-zA-Z0-9/^]+\]'
-        self._rules.append((QtCore.QRegExp(unit), STYLE_INLINE_UNIT))
+        unit = r'\[([a-zA-Z0-9/^-]|\*)+\]'
+        self._rules.append((R(unit), STYLE_INLINE_UNIT))
 
         # Keywords
         for keyword in self.KEYWORD_1:
-            pattern = QtCore.QRegExp(r'\b' + keyword + r'\b')
-            self._rules.append((pattern, STYLE_KEYWORD_1))
+            self._rules.append((R(r'\b' + keyword + r'\b'), STYLE_KEYWORD_1))
         for keyword in self.KEYWORD_2:
-            pattern = QtCore.QRegExp(r'\b' + keyword + r'\b')
-            self._rules.append((pattern, STYLE_KEYWORD_2))
+            self._rules.append((R(r'\b' + keyword + r'\b'), STYLE_KEYWORD_2))
 
         # Meta-data coloring
         self._rules_labels = [
-            QtCore.QRegExp(r'(\s*)(bind)\s+(' + name + ')'),
-            QtCore.QRegExp(r'(\s*)(label)\s+(' + name + ')'),
+            R(r'(\s*)(bind)\s+(' + name + ')'),
+            R(r'(\s*)(label)\s+(' + name + ')'),
         ]
-        self._rule_meta_key = QtCore.QRegExp(name + r':')
-        self._rule_meta_val = QtCore.QRegExp(r':(\s*)(.+)')
-        self._rule_var_unit = QtCore.QRegExp(r'^(\s*)(in)(\s*)(' + unit + ')')
+        self._rule_meta = R(r'^\s*(' + name + r':)(\s*)(.+)')
+        self._rule_var_unit = R(r'^(\s*)(in)(\s*)(' + unit + ')')
 
-        # Comments
-        # Note: For some reason this can _not_ use self._comment_start
-        self._comments = QtCore.QRegExp(r'#[^\n]*')
+        # Comment
+        self._comment = R(r'#')
+
+    def _highlight_ok(self, strings, start, length):
+        """ Checks if the string ``start`` to ``length`` needs formatted. """
+        for lo, hi in strings:
+            if lo <= start < hi or lo <= start + length < hi:
+                return False
+        return True
 
     def highlightBlock(self, text):
         """ Qt: Called whenever a block should be highlighted. """
-        # Simple rules
-        for (pattern, style) in self._rules:
-            i = pattern.indexIn(text)
-            while i >= 0:
-                # Note: Can't use matchedLength() here because it does quirky
-                # things with the subgroup for the numbers regex.
-                n = len(pattern.cap(0))
-                self.setFormat(i, n, style)
-                i = pattern.indexIn(text, i + n)
-
-        # Model and component headers
-        i = self._rule_head.indexIn(text)
-        while i >= 0:
-            m = len(self._rule_head.cap(1))
-            n = len(self._rule_head.cap(0))
-            self.setFormat(i + m, n - m, STYLE_HEADER)
-            i = self._rule_head.indexIn(text, i + n)
-
-        # Annotations
-        # Labels
-        for pattern in self._rules_labels:
-            i = pattern.indexIn(text)
-            while i >= 0:
-                n0 = len(pattern.cap(0))
-                n1 = len(pattern.cap(1))
-                n2 = len(pattern.cap(2))
-                n3 = len(pattern.cap(3))
-                self.setFormat(i + n1, n2, STYLE_ANNOT_KEY)
-                self.setFormat(i + n0 - n3, n3, STYLE_ANNOT_VAL)
-                i = pattern.indexIn(text, i + n0)
-
-        # Units
-        i = self._rule_var_unit.indexIn(text)
-        if i == 0:
-            n1 = len(self._rule_var_unit.cap(1))
-            n2 = len(self._rule_var_unit.cap(2))
-            n3 = len(self._rule_var_unit.cap(3))
-            n4 = len(self._rule_var_unit.cap(4))
-            self.setFormat(n1, n2, STYLE_ANNOT_KEY)
-            self.setFormat(n1 + n2 + n3, n4, STYLE_ANNOT_VAL)
-
-        # Meta properties
-        i = self._rule_meta_key.indexIn(text)
-        if i >= 0:
-            n0 = len(self._rule_meta_key.cap(0))
-            self.setFormat(i, n0, STYLE_ANNOT_KEY)
-        i = self._rule_meta_val.indexIn(text)
-        if i >= 0:
-            n1 = len(self._rule_meta_val.cap(1))
-            n2 = len(self._rule_meta_val.cap(2))
-            self.setFormat(i, 1, STYLE_ANNOT_KEY)
-            self.setFormat(1 + i + n1, n2, STYLE_ANNOT_VAL)
-
-        # Comments (overrule all other formatting except multi-line strings)
-        i = self._comments.indexIn(text)
-        while i >= 0:
-            n = len(self._comments.cap(0))
-            self.setFormat(i, n, STYLE_COMMENT)
-            i = self._comments.indexIn(text, i + n)
-
-        # Multi-line strings
-        # Block states:
-        #  0 Normal
-        #  1 Multi-line string (meta)
+
+        # To avoid formatting within strings each is stored as a (start, end).
+        strings = []
+        # If the start has been handled, set the offset.
+        offset = 0
+        # If the end has been handled, chop it off the string
+
+        # Multi-line strings are done first, because they overrule a lot of
+        # things and we can skip formatting if we're inside one.
+        # Block states: 0=No string, 1=A """ string
         self.setCurrentBlockState(0)
 
-        # Check state of previous block
-        if self.previousBlockState() != 1:
-            # Normal block
-            next = start = self._string_start.indexIn(text)
-            comment = self._comment_start.indexIn(text)
-            if next >= 0 and (comment < 0 or comment > next):
-                next += self._string_start.matchedLength()
+        # Continuing a multi-line string?
+        if self.previousBlockState() == 1:
+            # Search for string stop
+            ms = self._string.match(text)
+            if ms.hasMatch():
+                # Terminate the multi-line string
+                offset = ms.capturedEnd(0)
+                self.setFormat(0, offset, STYLE_ANNOT_VAL)
             else:
-                start = next = -1
+                # Whole line in the string
+                self.setCurrentBlockState(1)
+                self.setFormat(0, len(text), STYLE_ANNOT_VAL)
+                return
         else:
-            start = next = 0
+            # Search for string start
+            ms = self._string.match(text)
+            if ms.hasMatch():
+                # Potential start, but check that it's not commented out
+                start = ms.capturedStart()
+                mc = self._comment.match(text)
+                if not (mc.hasMatch() and mc.capturedStart() < start):
+                    # Definitely a string start. See if it ends on this line
+                    me = self._string.match(text, offset=ms.capturedEnd())
+                    if me.hasMatch():
+                        # Terminate the single-line string
+                        end = me.capturedEnd()
+                        self.setFormat(start, end - start, STYLE_ANNOT_VAL)
+                        strings.append((start, end))
+                    else:
+                        # Multi-line string
+                        self.setCurrentBlockState(1)
+                        self.setFormat(start, len(text), STYLE_ANNOT_VAL)
+
+        # Comment
+        i = self._comment.globalMatch(text, offset=offset)
+        while i.hasNext():
+            m = i.next()
+            x = m.capturedStart()
+            if self._highlight_ok(strings, x, 1):
+                self.setFormat(x, len(text) - x, STYLE_COMMENT)
+                text = text[:x]
+                break
 
-        # Find any occurrences of string start / stop
-        while next >= 0:
-            stop = self._string_stop.indexIn(text, next)
-            if stop < 0:
-                # Continuing multi-line string
-                self.setCurrentBlockState(1)
-                self.setFormat(start, len(text) - start, STYLE_ANNOT_VAL)
-                next = -1
-            else:
-                # Ending single-line or multi-line string
-                # Format until stop token
-                next = stop = stop + self._string_stop.matchedLength()
-                self.setFormat(start, stop - start, STYLE_ANNOT_VAL)
-                # Find next string in block, if any
-                next = start = self._string_start.indexIn(text, next)
-                if next >= 0:
-                    next += self._string_start.matchedLength()
+        # Rule-based formatting
+        for (pattern, style) in self._rules:
+            i = pattern.globalMatch(text, offset=offset)
+            while i.hasNext():
+                m = i.next()
+                x, w = m.capturedStart(), m.capturedLength()
+                if self._highlight_ok(strings, x, w):
+                    self.setFormat(x, w, style)
+
+        # Model and component headers (must be at start of string)
+        if offset == 0:
+            m = self._rule_head.match(text)
+            if m.hasMatch():
+                x, w = m.capturedStart(1), m.capturedLength(1)
+                self.setFormat(x, w, STYLE_HEADER)
+
+        # Variable units (must be at start of string)
+        if offset == 0:
+            m = self._rule_var_unit.match(text)
+            if m.hasMatch():
+                self.setFormat(
+                    m.capturedStart(2), m.capturedLength(2), STYLE_ANNOT_KEY)
+                self.setFormat(
+                    m.capturedStart(4), m.capturedLength(4), STYLE_ANNOT_VAL)
+
+        # Binds and labels
+        for pattern in self._rules_labels:
+            i = pattern.globalMatch(text, offset=offset)
+            while i.hasNext():
+                m = i.next()
+                x, w = m.capturedStart(), m.capturedLength()
+                if self._highlight_ok(strings, x, w):
+                    self.setFormat(m.capturedStart(2), m.capturedLength(2),
+                                   STYLE_ANNOT_KEY)
+                    self.setFormat(m.capturedStart(3), m.capturedLength(3),
+                                   STYLE_ANNOT_VAL)
+
+        # Meta properties (must be at start of string)
+        if offset == 0:
+            m = self._rule_meta.match(text)
+            if m.hasMatch():
+                self.setFormat(
+                    m.capturedStart(1), m.capturedLength(1), STYLE_ANNOT_KEY)
+                # Don't reformat strings (or bits after string end!)
+                if m.captured(3)[:3] != '"""':
+                    self.setFormat(m.capturedStart(3), m.capturedLength(3),
+                                   STYLE_ANNOT_VAL)
 
 
 class ProtocolHighlighter(QtGui.QSyntaxHighlighter):
@@ -1101,43 +1134,40 @@ class ProtocolHighlighter(QtGui.QSyntaxHighlighter):
     Syntax highlighter for ``mmt`` protocol definitions.
     """
     def __init__(self, document):
-        super(ProtocolHighlighter, self).__init__(document)
+        super().__init__(document)
 
         # Headers and units
-        self._rule_head = QtCore.QRegExp(r'^(\s*)\[\[[a-zA-Z0-9_]+\]\]')
+        R = QtCore.QRegularExpression
+        self._rule_head = R(r'^\s*(\[\[[a-zA-Z0-9_]+\]\])')
 
         # Highlighting rules
         self._rules = []
 
         # Numbers
-        pattern = QtCore.QRegExp(r'\b[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?\b')
-        self._rules.append((pattern, STYLE_LITERAL))
+        self._rules.append(
+            (R(r'\b[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?\b'), STYLE_LITERAL))
 
         # Keyword "next"
-        pattern = QtCore.QRegExp(r'\bnext\b')
-        self._rules.append((pattern, STYLE_KEYWORD_1))
+        self._rules.append((R(r'\bnext\b'), STYLE_KEYWORD_1))
 
         # Comments
-        pattern = QtCore.QRegExp(r'#[^\n]*')
-        self._rules.append((pattern, STYLE_COMMENT))
+        self._rules.append((R(r'#[^\n]*'), STYLE_COMMENT))
 
     def highlightBlock(self, text):
         """ Qt: Called whenever a block should be highlighted. """
+
         # Rule based formatting
         for (pattern, style) in self._rules:
-            i = pattern.indexIn(text)
-            while i >= 0:
-                n = len(pattern.cap(0))
-                self.setFormat(i, n, style)
-                i = pattern.indexIn(text, i + n)
+            i = pattern.globalMatch(text)
+            while i.hasNext():
+                m = i.next()
+                self.setFormat(m.capturedStart(), m.capturedLength(), style)
 
-        # Protocol header
-        i = self._rule_head.indexIn(text)
-        while i >= 0:
-            m = len(self._rule_head.cap(1))
-            n = len(self._rule_head.cap(0))
-            self.setFormat(i + m, n - m, STYLE_HEADER)
-            i = self._rule_head.indexIn(text, i + n)
+        # Protocol header (must be at strart of string)
+        m = self._rule_head.match(text)
+        if m.hasMatch():
+            self.setFormat(
+                m.capturedStart(1), m.capturedLength(1), STYLE_HEADER)
 
 
 class ScriptHighlighter(QtGui.QSyntaxHighlighter):
@@ -1145,10 +1175,11 @@ class ScriptHighlighter(QtGui.QSyntaxHighlighter):
     Syntax highlighter for ``mmt`` script files.
     """
     def __init__(self, document):
-        super(ScriptHighlighter, self).__init__(document)
+        super().__init__(document)
 
-        # Headers and units
-        self._rule_head = QtCore.QRegExp(r'^(\s*)\[\[[a-zA-Z0-9_]+\]\]')
+        # Script header
+        R = QtCore.QRegularExpression
+        self._rule_head = R(r'^\s*(\[\[[a-zA-Z0-9_]+\]\])')
 
         # Highlighting rules
         self._rules = []
@@ -1156,197 +1187,197 @@ class ScriptHighlighter(QtGui.QSyntaxHighlighter):
         # Keywords
         import keyword
         for kw in keyword.kwlist:
-            pattern = QtCore.QRegExp(r'\b' + kw + r'\b')
-            self._rules.append((pattern, STYLE_KEYWORD_1))
+            self._rules.append((R(r'\b' + kw + r'\b'), STYLE_KEYWORD_1))
 
         # Built-in essential functions
         for func in _PYFUNC:
-            pattern = QtCore.QRegExp(r'\b' + str(func) + r'\b')
-            self._rules.append((pattern, STYLE_KEYWORD_2))
+            self._rules.append((R(r'\b' + str(func) + r'\b'), STYLE_KEYWORD_2))
 
         # Literals: numbers, True, False, None
         # Override some keywords
-        pattern = QtCore.QRegExp(r'\b[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?\b')
-        self._rules.append((pattern, STYLE_LITERAL))
-        pattern = QtCore.QRegExp(r'\bTrue\b')
-        self._rules.append((pattern, STYLE_LITERAL))
-        pattern = QtCore.QRegExp(r'\bFalse\b')
-        self._rules.append((pattern, STYLE_LITERAL))
-        pattern = QtCore.QRegExp(r'\bNone\b')
-        self._rules.append((pattern, STYLE_LITERAL))
+        self._rules.append((R(r'\b[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?\b'),
+                            STYLE_LITERAL))
+        self._rules.append((R(r'\bTrue\b'), STYLE_LITERAL))
+        self._rules.append((R(r'\bFalse\b'), STYLE_LITERAL))
+        self._rules.append((R(r'\bNone\b'), STYLE_LITERAL))
 
         # Strings
-        pattern = QtCore.QRegExp(r'"([^"\\]|\\")*"')
-        self._rules.append((pattern, STYLE_LITERAL))
-        pattern = QtCore.QRegExp(r"'([^'\\]|\\')*'")
-        self._rules.append((pattern, STYLE_LITERAL))
-
-        # Multi-line strings
-        self._string1 = QtCore.QRegExp(r"'''")
-        self._string2 = QtCore.QRegExp(r'"""')
+        self._s1 = R(r'"')
+        self._s2 = R(r"'")
+        self._ms1 = R(r'"""')
+        self._ms2 = R(r"'''")
+        self._s_start = R(r'"""|\'\'\'|"|\'')
+        self._s_end = {
+            '"': self._s1, "'": self._s2, '"""': self._ms1, "'''": self._ms2}
 
         # Comments
-        pattern = QtCore.QRegExp(r'#[^\n]*')
-        self._rules.append((pattern, STYLE_COMMENT))
+        self._comment = R(r'#')
+
+    def _highlight_ok(self, strings, start, length):
+        """ Checks if the string ``start`` to ``length`` needs formatted. """
+        for lo, hi in strings:
+            if lo <= start < hi or lo <= start + length < hi:
+                return False
+        return True
 
     def highlightBlock(self, text):
         """ Qt: Called whenever a block should be highlighted. """
-        # Rule based formatting
-        for (pattern, style) in self._rules:
-            i = pattern.indexIn(text)
-            while i >= 0:
-                # Note: Can't use matchedLength() here because it does quirky
-                # things with the subgroup for the numbers regex.
-                n = len(pattern.cap(0))
-                self.setFormat(i, n, style)
-                i = pattern.indexIn(text, i + n)
 
-        # Script header
-        i = self._rule_head.indexIn(text)
-        while i >= 0:
-            m = len(self._rule_head.cap(1))
-            n = len(self._rule_head.cap(0))
-            self.setFormat(i + m, n - m, STYLE_HEADER)
-            i = self._rule_head.indexIn(text, i + n)
-
-        # Block states:
-        #  0 Normal
-        #  1 Multi-line string 1
-        #  2 Multi-line string 2
+        # To avoid formatting within strings each is stored as a (start, end).
+        strings = []
+        # If the start has been handled, set the offset.
+        offset = 0
+        # If the end has been handled, chop it off the string
+
+        # Multi-line strings are done first, because they overrule a lot of
+        # things and we can skip formatting if we're inside one.
+        # Block states: 0=No string, 1=A " " " string, 2=A ' ' ' string
         self.setCurrentBlockState(0)
 
-        # Multi-line formats
-        def find_start(text, next):
-            s1 = self._string1.indexIn(text, next)
-            s2 = self._string2.indexIn(text, next)
-            if s1 < 0 and s2 < 0:
-                current = 0
-                start = -1
-                next = -1
-            else:
-                if s1 >= 0 and s2 >= 0:
-                    current = 1 if s1 < s2 else 2
-                    start = min(s1, s2)
-                elif s1 >= 0:
-                    current = 1
-                    start = s1
-                else:   # (s2 >= 0)
-                    current = 2
-                    start = s2
-                next = start + 3
-
-                # Check we're not in a comment
-                i = text.rfind('\n', start) + 1
-                if text[i:i + 1] == '#':
-                    current = 0
-                    start = next = -1
-
-            return current, start, next
-
-        # Check state of previous block
+        # Continuing a multi-line string?
         previous = self.previousBlockState()
         if previous == 1 or previous == 2:
-            current, start, next = previous, 0, 0
-        else:
-            current, start, next = find_start(text, 0)
-
-        # Find any occurrences of string start / stop
-        while next >= 0:
-            if current == 1:
-                stop = self._string1.indexIn(text, next)
+            # Search for string stop
+            r = self._ms1 if previous == 1 else self._ms2
+            ms = r.match(text)
+            if ms.hasMatch():
+                # Terminate the multi-line string, and increase global offset
+                offset = ms.capturedEnd(0)
+                self.setFormat(0, offset, STYLE_LITERAL)
             else:
-                stop = self._string2.indexIn(text, next)
-            if stop < 0:
-                # Continuing multi-line string
-                self.setCurrentBlockState(current)
-                self.setFormat(start, len(text) - start, STYLE_LITERAL)
-                next = -1
+                # Whole line in the string
+                self.setCurrentBlockState(previous)
+                self.setFormat(0, len(text), STYLE_LITERAL)
+                return
+
+        # Search for string starts (single or multi-line)
+        stroff = offset     # Offset for string start/end searching
+        m1 = self._s_start.match(text, offset=stroff)
+        while m1.hasMatch():
+            stroff = m1.capturedEnd()
+            start = m1.capturedStart()
+            # Are we in a comment?
+            mc = self._comment.match(text)
+            if (mc.hasMatch() and mc.capturedStart() < start):
+                # No point searching for further string starts
+                stroff = len(text)
             else:
-                # Ending single-line or multi-line string
-                # Format until stop token
-                stop += 3
-                self.setFormat(start, stop - start, STYLE_LITERAL)
-                # Find next string in block, if any
-                next = stop + 3
-                current, start, next = find_start(text, next)
+                # Find string end
+                m2 = self._s_end[m1.captured()].match(text, offset=stroff)
+                if m2.hasMatch():
+                    stroff = m2.capturedEnd()
+                    # Ignore if escaped
+                    if text[m2.capturedStart() - 1] != '\\':
+                        # Terminate the single line string and move on
+                        self.setFormat(start, stroff - start, STYLE_LITERAL)
+                        strings.append((start, stroff))
+                elif m1.capturedLength() > 1:
+                    # Multi-line string start. Block finished!
+                    self.setCurrentBlockState(
+                        1 if m1.captured() == '"""' else 2)
+                    self.setFormat(start, len(text) - start, STYLE_LITERAL)
+                    return
+                # No Match? Then not a string so ignore and continue
+            m1 = self._s_start.match(text, offset=stroff)
+
+        # Comment
+        i = self._comment.globalMatch(text, offset=offset)
+        while i.hasNext():
+            m = i.next()
+            x = m.capturedStart()
+            if self._highlight_ok(strings, x, 1):
+                self.setFormat(x, len(text) - x, STYLE_COMMENT)
+                text = text[:x]
+                break
+
+        # Script header (must be at start of string)
+        if offset == 0:
+            m = self._rule_head.match(text)
+            if m.hasMatch():
+                self.setFormat(
+                    m.capturedStart(1), m.capturedLength(1), STYLE_HEADER)
+
+        # Rule based formatting
+        for (pattern, style) in self._rules:
+            i = pattern.globalMatch(text, offset=offset)
+            while i.hasNext():
+                m = i.next()
+                x, w = m.capturedStart(), m.capturedLength()
+                if self._highlight_ok(strings, x, w):
+                    self.setFormat(x, w, style)
 
 
 # List of essential built-in python functions
 _PYFUNC = [
     'abs()',
-    'divmod()',
-    'input()',
-    'open()',
-    'staticmethod()',
+    'aiter()',
     'all()',
-    'enumerate()',
-    'int()',
-    'ord()',
-    'str()',
     'any()',
-    'eval()',
-    'isinstance()',
-    'pow()',
-    'sum()',
-    'basestring()',
-    'execfile()',
-    'issubclass()',
-    'print()',
-    'super()',
+    'anext()',
+    'ascii()',
     'bin()',
-    'file()',
-    'iter()',
-    'property()',
-    'tuple()',
     'bool()',
-    'filter()',
-    'len()',
-    'range()',
-    'type()',
+    'breakpoint()',
     'bytearray()',
-    'float()',
-    'list()',
-    'raw_input()',
-    'unichr()',
+    'bytes()',
     'callable()',
-    'format()',
-    'locals()',
-    'reduce()',
-    'unicode()',
     'chr()',
-    'frozenset()',
-    'long()',
-    'reload()',
-    'vars()',
     'classmethod()',
+    'compile()',
+    'complex()',
+    'delattr()',
+    'dict()',
+    'dir()',
+    'divmod()',
+    'enumerate()',
+    'eval()',
+    'exec()',
+    'filter()',
+    'float()',
+    'format()',
+    'frozenset()',
     'getattr()',
-    'map()',
-    'repr()',
-    'range()',
-    'cmp()',
     'globals()',
-    'max()',
-    'reversed()',
-    'zip()',
-    'compile()',
     'hasattr()',
-    'memoryview()',
-    'round()',
-    '__import__()',
-    'complex()',
     'hash()',
-    'min()',
-    'set()',
-    'delattr()',
     'help()',
-    'next()',
-    'setattr()',
-    'dict()',
     'hex()',
-    'object()',
-    'slice()',
-    'dir()',
     'id()',
+    'input()',
+    'int()',
+    'isinstance()',
+    'issubclass()',
+    'iter()',
+    'len()',
+    'list()',
+    'locals()',
+    'map()',
+    'max()',
+    'memoryview()',
+    'min()',
+    'next()',
+    'object()',
     'oct()',
+    'open()',
+    'ord()',
+    'pow()',
+    'print()',
+    'property()',
+    'range()',
+    'repr()',
+    'reversed()',
+    'round()',
+    'set()',
+    'setattr()',
+    'slice()',
     'sorted()',
+    'staticmethod()',
+    'str()',
+    'sum()',
+    'super()',
+    'tuple()',
+    'type()',
+    'vars()',
+    'zip()',
+    '__import__()',
 ]