GitHub/Anki
1
0
Fork 0
mirror of https://github.com/ankitects/anki.git synced 2025-09-19 06:22:22 -04:00
Code Issues Projects Releases Packages 1 Wiki Activity Actions

use qconnect everywhere, and fix some typing issues

Browse source 
a step towards check_untyped_defs in aqt, but there's still 100+
issues to resolve
This commit is contained in:
Damien Elmes 2020-05-04 13:23:08 +10:00
parent 164fdb37d5
commit eec3fcf87a
35 changed files with 282 additions and 266 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
qt/aqt/__init__.py
View file

@ -255,7 +255,7 @@ class AnkiApp(QApplication):
# previous instance died # previous instance died
QLocalServer.removeServer(self.KEY) QLocalServer.removeServer(self.KEY)
self._srv = QLocalServer(self) self._srv = QLocalServer(self)
self._srv.newConnection.connect(self.onRecv) qconnect(self._srv.newConnection, self.onRecv)
self._srv.listen(self.KEY) self._srv.listen(self.KEY)
return False return False

2
qt/aqt/about.py
View file

@ -86,7 +86,7 @@ def show(mw):
tooltip(_("Copied to clipboard"), parent=dialog) tooltip(_("Copied to clipboard"), parent=dialog)
btn = QPushButton(_("Copy Debug Info")) btn = QPushButton(_("Copy Debug Info"))
btn.clicked.connect(onCopy) qconnect(btn.clicked, onCopy)
abt.buttonBox.addButton(btn, QDialogButtonBox.ActionRole) abt.buttonBox.addButton(btn, QDialogButtonBox.ActionRole)
abt.buttonBox.button(QDialogButtonBox.Ok).setFocus() abt.buttonBox.button(QDialogButtonBox.Ok).setFocus()

4
qt/aqt/addcards.py
View file

@ -65,7 +65,7 @@ class AddCards(QDialog):
ar = QDialogButtonBox.ActionRole ar = QDialogButtonBox.ActionRole
# add # add
self.addButton = bb.addButton(_("Add"), ar) self.addButton = bb.addButton(_("Add"), ar)
self.addButton.clicked.connect(self.addCards) qconnect(self.addButton.clicked, self.addCards)
self.addButton.setShortcut(QKeySequence("Ctrl+Return")) self.addButton.setShortcut(QKeySequence("Ctrl+Return"))
self.addButton.setToolTip(shortcut(_("Add (shortcut: ctrl+enter)"))) self.addButton.setToolTip(shortcut(_("Add (shortcut: ctrl+enter)")))
# close # close
@ -84,7 +84,7 @@ class AddCards(QDialog):
sc = "Ctrl+H" sc = "Ctrl+H"
b.setShortcut(QKeySequence(sc)) b.setShortcut(QKeySequence(sc))
b.setToolTip(_("Shortcut: %s") % shortcut(sc)) b.setToolTip(_("Shortcut: %s") % shortcut(sc))
b.clicked.connect(self.onHistory) qconnect(b.clicked, self.onHistory)
b.setEnabled(False) b.setEnabled(False)
self.historyButton = b self.historyButton = b

28
qt/aqt/addons.py
View file

@ -175,7 +175,7 @@ class AddonManager:
self.mw = mw self.mw = mw
self.dirty = False self.dirty = False
f = self.mw.form f = self.mw.form
f.actionAdd_ons.triggered.connect(self.onAddonsDialog) qconnect(f.actionAdd_ons.triggered, self.onAddonsDialog)
sys.path.insert(0, self.addonsFolder()) sys.path.insert(0, self.addonsFolder())
# in new code, you may want all_addon_meta() instead # in new code, you may want all_addon_meta() instead
@ -699,16 +699,16 @@ class AddonsDialog(QDialog):
f = self.form = aqt.forms.addons.Ui_Dialog() f = self.form = aqt.forms.addons.Ui_Dialog()
f.setupUi(self) f.setupUi(self)
f.getAddons.clicked.connect(self.onGetAddons) qconnect(f.getAddons.clicked, self.onGetAddons)
f.installFromFile.clicked.connect(self.onInstallFiles) qconnect(f.installFromFile.clicked, self.onInstallFiles)
f.checkForUpdates.clicked.connect(self.check_for_updates) qconnect(f.checkForUpdates.clicked, self.check_for_updates)
f.toggleEnabled.clicked.connect(self.onToggleEnabled) qconnect(f.toggleEnabled.clicked, self.onToggleEnabled)
f.viewPage.clicked.connect(self.onViewPage) qconnect(f.viewPage.clicked, self.onViewPage)
f.viewFiles.clicked.connect(self.onViewFiles) qconnect(f.viewFiles.clicked, self.onViewFiles)
f.delete_2.clicked.connect(self.onDelete) qconnect(f.delete_2.clicked, self.onDelete)
f.config.clicked.connect(self.onConfig) qconnect(f.config.clicked, self.onConfig)
self.form.addonList.itemDoubleClicked.connect(self.onConfig) qconnect(self.form.addonList.itemDoubleClicked, self.onConfig)
self.form.addonList.currentRowChanged.connect(self._onAddonItemSelected) qconnect(self.form.addonList.currentRowChanged, self._onAddonItemSelected)
self.setAcceptDrops(True) self.setAcceptDrops(True)
self.redrawAddons() self.redrawAddons()
restoreGeom(self, "addons") restoreGeom(self, "addons")
@ -916,7 +916,7 @@ class GetAddons(QDialog):
b = self.form.buttonBox.addButton( b = self.form.buttonBox.addButton(
_("Browse Add-ons"), QDialogButtonBox.ActionRole _("Browse Add-ons"), QDialogButtonBox.ActionRole
) )
b.clicked.connect(self.onBrowse) qconnect(b.clicked, self.onBrowse)
restoreGeom(self, "getaddons", adjustSize=True) restoreGeom(self, "getaddons", adjustSize=True)
self.exec_() self.exec_()
saveGeom(self, "getaddons") saveGeom(self, "getaddons")
@ -1057,7 +1057,7 @@ class DownloaderInstaller(QObject):
QObject.__init__(self, parent) QObject.__init__(self, parent)
self.mgr = mgr self.mgr = mgr
self.client = client self.client = client
self.progressSignal.connect(self._progress_callback) # type: ignore qconnect(self.progressSignal, self._progress_callback)
def bg_thread_progress(up, down) -> None: def bg_thread_progress(up, down) -> None:
self.progressSignal.emit(up, down) # type: ignore self.progressSignal.emit(up, down) # type: ignore
@ -1283,7 +1283,7 @@ class ConfigEditor(QDialog):
self.form = aqt.forms.addonconf.Ui_Dialog() self.form = aqt.forms.addonconf.Ui_Dialog()
self.form.setupUi(self) self.form.setupUi(self)
restore = self.form.buttonBox.button(QDialogButtonBox.RestoreDefaults) restore = self.form.buttonBox.button(QDialogButtonBox.RestoreDefaults)
restore.clicked.connect(self.onRestoreDefaults) qconnect(restore.clicked, self.onRestoreDefaults)
self.setupFonts() self.setupFonts()
self.updateHelp() self.updateHelp()
self.updateText(self.conf) self.updateText(self.conf)

113
qt/aqt/browser.py
View file

@ -608,53 +608,53 @@ class Browser(QMainWindow):
# pylint: disable=unnecessary-lambda # pylint: disable=unnecessary-lambda
# actions # actions
f = self.form f = self.form
f.previewButton.clicked.connect(self.onTogglePreview) qconnect(f.previewButton.clicked, self.onTogglePreview)
f.previewButton.setToolTip( f.previewButton.setToolTip(
_("Preview Selected Card (%s)") % shortcut("Ctrl+Shift+P") _("Preview Selected Card (%s)") % shortcut("Ctrl+Shift+P")
) )
f.previewButton.setShortcut("Ctrl+Shift+P") f.previewButton.setShortcut("Ctrl+Shift+P")
f.filter.clicked.connect(self.onFilterButton) qconnect(f.filter.clicked, self.onFilterButton)
# edit # edit
f.actionUndo.triggered.connect(self.mw.onUndo) qconnect(f.actionUndo.triggered, self.mw.onUndo)
f.actionInvertSelection.triggered.connect(self.invertSelection) qconnect(f.actionInvertSelection.triggered, self.invertSelection)
f.actionSelectNotes.triggered.connect(self.selectNotes) qconnect(f.actionSelectNotes.triggered, self.selectNotes)
if not isMac: if not isMac:
f.actionClose.setVisible(False) f.actionClose.setVisible(False)
# notes # notes
f.actionAdd.triggered.connect(self.mw.onAddCard) qconnect(f.actionAdd.triggered, self.mw.onAddCard)
f.actionAdd_Tags.triggered.connect(lambda: self.addTags()) qconnect(f.actionAdd_Tags.triggered, lambda: self.addTags())
f.actionRemove_Tags.triggered.connect(lambda: self.deleteTags()) qconnect(f.actionRemove_Tags.triggered, lambda: self.deleteTags())
f.actionClear_Unused_Tags.triggered.connect(self.clearUnusedTags) qconnect(f.actionClear_Unused_Tags.triggered, self.clearUnusedTags)
f.actionToggle_Mark.triggered.connect(lambda: self.onMark()) qconnect(f.actionToggle_Mark.triggered, lambda: self.onMark())
f.actionChangeModel.triggered.connect(self.onChangeModel) qconnect(f.actionChangeModel.triggered, self.onChangeModel)
f.actionFindDuplicates.triggered.connect(self.onFindDupes) qconnect(f.actionFindDuplicates.triggered, self.onFindDupes)
f.actionFindReplace.triggered.connect(self.onFindReplace) qconnect(f.actionFindReplace.triggered, self.onFindReplace)
f.actionManage_Note_Types.triggered.connect(self.mw.onNoteTypes) qconnect(f.actionManage_Note_Types.triggered, self.mw.onNoteTypes)
f.actionDelete.triggered.connect(self.deleteNotes) qconnect(f.actionDelete.triggered, self.deleteNotes)
# cards # cards
f.actionChange_Deck.triggered.connect(self.setDeck) qconnect(f.actionChange_Deck.triggered, self.setDeck)
f.action_Info.triggered.connect(self.showCardInfo) qconnect(f.action_Info.triggered, self.showCardInfo)
f.actionReposition.triggered.connect(self.reposition) qconnect(f.actionReposition.triggered, self.reposition)
f.actionReschedule.triggered.connect(self.reschedule) qconnect(f.actionReschedule.triggered, self.reschedule)
f.actionToggle_Suspend.triggered.connect(self.onSuspend) qconnect(f.actionToggle_Suspend.triggered, self.onSuspend)
f.actionRed_Flag.triggered.connect(lambda: self.onSetFlag(1)) qconnect(f.actionRed_Flag.triggered, lambda: self.onSetFlag(1))
f.actionOrange_Flag.triggered.connect(lambda: self.onSetFlag(2)) qconnect(f.actionOrange_Flag.triggered, lambda: self.onSetFlag(2))
f.actionGreen_Flag.triggered.connect(lambda: self.onSetFlag(3)) qconnect(f.actionGreen_Flag.triggered, lambda: self.onSetFlag(3))
f.actionBlue_Flag.triggered.connect(lambda: self.onSetFlag(4)) qconnect(f.actionBlue_Flag.triggered, lambda: self.onSetFlag(4))
f.actionExport.triggered.connect(lambda: self._on_export_notes()) qconnect(f.actionExport.triggered, lambda: self._on_export_notes())
# jumps # jumps
f.actionPreviousCard.triggered.connect(self.onPreviousCard) qconnect(f.actionPreviousCard.triggered, self.onPreviousCard)
f.actionNextCard.triggered.connect(self.onNextCard) qconnect(f.actionNextCard.triggered, self.onNextCard)
f.actionFirstCard.triggered.connect(self.onFirstCard) qconnect(f.actionFirstCard.triggered, self.onFirstCard)
f.actionLastCard.triggered.connect(self.onLastCard) qconnect(f.actionLastCard.triggered, self.onLastCard)
f.actionFind.triggered.connect(self.onFind) qconnect(f.actionFind.triggered, self.onFind)
f.actionNote.triggered.connect(self.onNote) qconnect(f.actionNote.triggered, self.onNote)
f.actionTags.triggered.connect(self.onFilterButton) qconnect(f.actionTags.triggered, self.onFilterButton)
f.actionSidebar.triggered.connect(self.focusSidebar) qconnect(f.actionSidebar.triggered, self.focusSidebar)
f.actionCardList.triggered.connect(self.onCardList) qconnect(f.actionCardList.triggered, self.onCardList)
# help # help
f.actionGuide.triggered.connect(self.onHelp) qconnect(f.actionGuide.triggered, self.onHelp)
# keyboard shortcut for shift+home/end # keyboard shortcut for shift+home/end
self.pgUpCut = QShortcut(QKeySequence("Shift+Home"), self) self.pgUpCut = QShortcut(QKeySequence("Shift+Home"), self)
qconnect(self.pgUpCut.activated, self.onFirstCard) qconnect(self.pgUpCut.activated, self.onFirstCard)
@ -666,7 +666,7 @@ class Browser(QMainWindow):
# context menu # context menu
self.form.tableView.setContextMenuPolicy(Qt.CustomContextMenu) self.form.tableView.setContextMenuPolicy(Qt.CustomContextMenu)
self.form.tableView.customContextMenuRequested.connect(self.onContextMenu) qconnect(self.form.tableView.customContextMenuRequested, self.onContextMenu)
def onContextMenu(self, _point) -> None: def onContextMenu(self, _point) -> None:
m = QMenu() m = QMenu()
@ -750,8 +750,8 @@ class Browser(QMainWindow):
###################################################################### ######################################################################
def setupSearch(self): def setupSearch(self):
self.form.searchButton.clicked.connect(self.onSearchActivated) qconnect(self.form.searchButton.clicked, self.onSearchActivated)
self.form.searchEdit.lineEdit().returnPressed.connect(self.onSearchActivated) qconnect(self.form.searchEdit.lineEdit().returnPressed, self.onSearchActivated)
self.form.searchEdit.setCompleter(None) self.form.searchEdit.setCompleter(None)
self._searchPrompt = _("<type here to search; hit enter to show current deck>") self._searchPrompt = _("<type here to search; hit enter to show current deck>")
self.form.searchEdit.addItems( self.form.searchEdit.addItems(
@ -837,7 +837,9 @@ class Browser(QMainWindow):
self.form.tableView.setModel(self.model) self.form.tableView.setModel(self.model)
self.form.tableView.selectionModel() self.form.tableView.selectionModel()
self.form.tableView.setItemDelegate(StatusDelegate(self, self.model)) self.form.tableView.setItemDelegate(StatusDelegate(self, self.model))
self.form.tableView.selectionModel().selectionChanged.connect(self.onRowChanged) qconnect(
self.form.tableView.selectionModel().selectionChanged, self.onRowChanged
)
self.form.tableView.setWordWrap(False) self.form.tableView.setWordWrap(False)
if not theme_manager.night_mode: if not theme_manager.night_mode:
self.form.tableView.setStyleSheet( self.form.tableView.setStyleSheet(
@ -912,10 +914,10 @@ QTableView {{ gridline-color: {grid} }}
hh.setSectionsMovable(True) hh.setSectionsMovable(True)
self.setColumnSizes() self.setColumnSizes()
hh.setContextMenuPolicy(Qt.CustomContextMenu) hh.setContextMenuPolicy(Qt.CustomContextMenu)
hh.customContextMenuRequested.connect(self.onHeaderContext) qconnect(hh.customContextMenuRequested, self.onHeaderContext)
self.setSortIndicator() self.setSortIndicator()
hh.sortIndicatorChanged.connect(self.onSortChanged) qconnect(hh.sortIndicatorChanged, self.onSortChanged)
hh.sectionMoved.connect(self.onColumnMoved) qconnect(hh.sectionMoved, self.onColumnMoved)
def onSortChanged(self, idx, ord): def onSortChanged(self, idx, ord):
ord = bool(ord) ord = bool(ord)
@ -969,7 +971,7 @@ QTableView {{ gridline-color: {grid} }}
a = m.addAction(name) a = m.addAction(name)
a.setCheckable(True) a.setCheckable(True)
a.setChecked(type in self.model.activeCols) a.setChecked(type in self.model.activeCols)
a.toggled.connect(lambda b, t=type: self.toggleField(t)) qconnect(a.toggled, lambda b, t=type: self.toggleField(t))
gui_hooks.browser_header_will_show_context_menu(self, m) gui_hooks.browser_header_will_show_context_menu(self, m)
m.exec_(gpos) m.exec_(gpos)
@ -1015,8 +1017,8 @@ QTableView {{ gridline-color: {grid} }}
class SidebarTreeView(QTreeView): class SidebarTreeView(QTreeView):
def __init__(self): def __init__(self):
super().__init__() super().__init__()
self.expanded.connect(self.onExpansion) qconnect(self.expanded, self.onExpansion)
self.collapsed.connect(self.onCollapse) qconnect(self.collapsed, self.onCollapse)
def onClickCurrent(self) -> None: def onClickCurrent(self) -> None:
idx = self.currentIndex() idx = self.currentIndex()
@ -1058,13 +1060,13 @@ QTableView {{ gridline-color: {grid} }}
self.sidebarTree.setUniformRowHeights(True) self.sidebarTree.setUniformRowHeights(True)
self.sidebarTree.setHeaderHidden(True) self.sidebarTree.setHeaderHidden(True)
self.sidebarTree.setIndentation(15) self.sidebarTree.setIndentation(15)
self.sidebarTree.expanded.connect(self.onSidebarItemExpanded) # type: ignore qconnect(self.sidebarTree.expanded, self.onSidebarItemExpanded)
dw.setWidget(self.sidebarTree) dw.setWidget(self.sidebarTree)
# match window background color # match window background color
bgcolor = QPalette().window().color().name() bgcolor = QPalette().window().color().name()
self.sidebarTree.setStyleSheet("QTreeView { background: '%s'; }" % bgcolor) self.sidebarTree.setStyleSheet("QTreeView { background: '%s'; }" % bgcolor)
self.sidebarDockWidget.setFloating(False) self.sidebarDockWidget.setFloating(False)
self.sidebarDockWidget.visibilityChanged.connect(self.onSidebarVisChanged) # type: ignore qconnect(self.sidebarDockWidget.visibilityChanged, self.onSidebarVisChanged)
self.sidebarDockWidget.setTitleBarWidget(QWidget()) self.sidebarDockWidget.setTitleBarWidget(QWidget())
self.addDockWidget(Qt.LeftDockWidgetArea, dw) self.addDockWidget(Qt.LeftDockWidgetArea, dw)
@ -1428,7 +1430,7 @@ QTableView {{ gridline-color: {grid} }}
w.stdHtml(info + "<p>" + reps, context=card_info_dialog) w.stdHtml(info + "<p>" + reps, context=card_info_dialog)
bb = QDialogButtonBox(QDialogButtonBox.Close) bb = QDialogButtonBox(QDialogButtonBox.Close)
l.addWidget(bb) l.addWidget(bb)
bb.rejected.connect(card_info_dialog.reject) qconnect(bb.rejected, card_info_dialog.reject)
card_info_dialog.setLayout(l) card_info_dialog.setLayout(l)
card_info_dialog.setWindowModality(Qt.WindowModal) card_info_dialog.setWindowModality(Qt.WindowModal)
card_info_dialog.resize(500, 400) card_info_dialog.resize(500, 400)
@ -1932,7 +1934,7 @@ update cards set usn=?, mod=?, did=? where id in """
frm.setupUi(d) frm.setupUi(d)
d.setWindowModality(Qt.WindowModal) d.setWindowModality(Qt.WindowModal)
frm.field.addItems([_("All Fields")] + fields) frm.field.addItems([_("All Fields")] + fields)
frm.buttonBox.helpRequested.connect(self.onFindReplaceHelp) qconnect(frm.buttonBox.helpRequested, self.onFindReplaceHelp)
restoreGeom(d, "findreplace") restoreGeom(d, "findreplace")
r = d.exec_() r = d.exec_()
saveGeom(d, "findreplace") saveGeom(d, "findreplace")
@ -2000,7 +2002,7 @@ update cards set usn=?, mod=?, did=? where id in """
def onFin(code): def onFin(code):
saveGeom(d, "findDupes") saveGeom(d, "findDupes")
d.finished.connect(onFin) qconnect(d.finished, onFin)
def onClick(): def onClick():
field = fields[frm.fields.currentIndex()] field = fields[frm.fields.currentIndex()]
@ -2009,7 +2011,7 @@ update cards set usn=?, mod=?, did=? where id in """
) )
search = frm.buttonBox.addButton(_("Search"), QDialogButtonBox.ActionRole) search = frm.buttonBox.addButton(_("Search"), QDialogButtonBox.ActionRole)
search.clicked.connect(onClick) qconnect(search.clicked, onClick)
d.show() d.show()
def duplicatesReport(self, web, fname, search, frm, web_context): def duplicatesReport(self, web, fname, search, frm, web_context):
@ -2019,7 +2021,7 @@ update cards set usn=?, mod=?, did=? where id in """
self._dupesButton = b = frm.buttonBox.addButton( self._dupesButton = b = frm.buttonBox.addButton(
_("Tag Duplicates"), QDialogButtonBox.ActionRole _("Tag Duplicates"), QDialogButtonBox.ActionRole
) )
b.clicked.connect(lambda: self._onTagDupes(res)) qconnect(b.clicked, lambda: self._onTagDupes(res))
t = "" t = ""
groups = len(res) groups = len(res)
notes = sum(len(r[1]) for r in res) notes = sum(len(r[1]) for r in res)
@ -2179,7 +2181,7 @@ class ChangeModel(QDialog):
self.browser.mw, self.form.modelChooserWidget, label=False self.browser.mw, self.form.modelChooserWidget, label=False
) )
self.modelChooser.models.setFocus() self.modelChooser.models.setFocus()
self.form.buttonBox.helpRequested.connect(self.onHelp) qconnect(self.form.buttonBox.helpRequested, self.onHelp)
self.modelChanged(self.browser.mw.col.models.current()) self.modelChanged(self.browser.mw.col.models.current())
self.pauseUpdate = False self.pauseUpdate = False
@ -2215,8 +2217,9 @@ class ChangeModel(QDialog):
idx = min(i, len(targets) - 1) idx = min(i, len(targets) - 1)
cb.setCurrentIndex(idx) cb.setCurrentIndex(idx)
indices[cb] = idx indices[cb] = idx
cb.currentIndexChanged.connect( qconnect(
lambda i, cb=cb, key=key: self.onComboChanged(i, cb, key) cb.currentIndexChanged,
lambda i, cb=cb, key=key: self.onComboChanged(i, cb, key),
) )
combos.append(cb) combos.append(cb)
l.addWidget(cb, i, 1) l.addWidget(cb, i, 1)

37
qt/aqt/clayout.py
View file

@ -106,8 +106,8 @@ class CardLayout(QDialog):
self.topAreaForm = aqt.forms.clayout_top.Ui_Form() self.topAreaForm = aqt.forms.clayout_top.Ui_Form()
self.topAreaForm.setupUi(self.topArea) self.topAreaForm.setupUi(self.topArea)
self.topAreaForm.templateOptions.setText(_("Options") + " " + downArrow()) self.topAreaForm.templateOptions.setText(_("Options") + " " + downArrow())
self.topAreaForm.templateOptions.clicked.connect(self.onMore) qconnect(self.topAreaForm.templateOptions.clicked, self.onMore)
self.topAreaForm.templatesBox.currentIndexChanged.connect(self.onCardSelected) qconnect(self.topAreaForm.templatesBox.currentIndexChanged, self.onCardSelected)
def updateTopArea(self): def updateTopArea(self):
cnt = self.mw.col.models.useCount(self.model) cnt = self.mw.col.models.useCount(self.model)
@ -184,13 +184,14 @@ class CardLayout(QDialog):
tform.tlayout2.setContentsMargins(0, 11, 0, 0) tform.tlayout2.setContentsMargins(0, 11, 0, 0)
tform.tlayout3.setContentsMargins(0, 11, 0, 0) tform.tlayout3.setContentsMargins(0, 11, 0, 0)
tform.groupBox_3.setTitle(_("Styling (shared between cards)")) tform.groupBox_3.setTitle(_("Styling (shared between cards)"))
tform.front.textChanged.connect(self.saveCard) qconnect(tform.front.textChanged, self.saveCard)
tform.css.textChanged.connect(self.saveCard) qconnect(tform.css.textChanged, self.saveCard)
tform.back.textChanged.connect(self.saveCard) qconnect(tform.back.textChanged, self.saveCard)
l.addWidget(left, 5) l.addWidget(left, 5)
# preview area # preview area
right = QWidget() right = QWidget()
pform = self.pform = aqt.forms.preview.Ui_Form() self.pform: Any = aqt.forms.preview.Ui_Form()
pform = self.pform
pform.setupUi(right) pform.setupUi(right)
if self.style().objectName() == "gtk+": if self.style().objectName() == "gtk+":
# gtk+ requires margins in inner layout # gtk+ requires margins in inner layout
@ -269,22 +270,22 @@ Please create a new card type first."""
help = QPushButton(_("Help")) help = QPushButton(_("Help"))
help.setAutoDefault(False) help.setAutoDefault(False)
l.addWidget(help) l.addWidget(help)
help.clicked.connect(self.onHelp) qconnect(help.clicked, self.onHelp)
l.addStretch() l.addStretch()
addField = QPushButton(_("Add Field")) addField = QPushButton(_("Add Field"))
addField.setAutoDefault(False) addField.setAutoDefault(False)
l.addWidget(addField) l.addWidget(addField)
addField.clicked.connect(self.onAddField) qconnect(addField.clicked, self.onAddField)
if not self._isCloze(): if not self._isCloze():
flip = QPushButton(_("Flip")) flip = QPushButton(_("Flip"))
flip.setAutoDefault(False) flip.setAutoDefault(False)
l.addWidget(flip) l.addWidget(flip)
flip.clicked.connect(self.onFlip) qconnect(flip.clicked, self.onFlip)
l.addStretch() l.addStretch()
close = QPushButton(_("Close")) close = QPushButton(_("Close"))
close.setAutoDefault(False) close.setAutoDefault(False)
l.addWidget(close) l.addWidget(close)
close.clicked.connect(self.accept) qconnect(close.clicked, self.accept)
# Cards # Cards
########################################################################## ##########################################################################
@ -471,16 +472,16 @@ adjust the template manually to switch the question and answer."""
if not self._isCloze(): if not self._isCloze():
a = m.addAction(_("Add Card Type...")) a = m.addAction(_("Add Card Type..."))
a.triggered.connect(self.onAddCard) qconnect(a.triggered, self.onAddCard)
a = m.addAction(_("Remove Card Type...")) a = m.addAction(_("Remove Card Type..."))
a.triggered.connect(self.onRemove) qconnect(a.triggered, self.onRemove)
a = m.addAction(_("Rename Card Type...")) a = m.addAction(_("Rename Card Type..."))
a.triggered.connect(self.onRename) qconnect(a.triggered, self.onRename)
a = m.addAction(_("Reposition Card Type...")) a = m.addAction(_("Reposition Card Type..."))
a.triggered.connect(self.onReorder) qconnect(a.triggered, self.onReorder)
m.addSeparator() m.addSeparator()
@ -490,10 +491,10 @@ adjust the template manually to switch the question and answer."""
else: else:
s = _(" (off)") s = _(" (off)")
a = m.addAction(_("Deck Override...") + s) a = m.addAction(_("Deck Override...") + s)
a.triggered.connect(self.onTargetDeck) qconnect(a.triggered, self.onTargetDeck)
a = m.addAction(_("Browser Appearance...")) a = m.addAction(_("Browser Appearance..."))
a.triggered.connect(self.onBrowserDisplay) qconnect(a.triggered, self.onBrowserDisplay)
m.exec_(self.topAreaForm.templateOptions.mapToGlobal(QPoint(0, 0))) m.exec_(self.topAreaForm.templateOptions.mapToGlobal(QPoint(0, 0)))
@ -508,7 +509,7 @@ adjust the template manually to switch the question and answer."""
f.overrideFont.setChecked(True) f.overrideFont.setChecked(True)
f.font.setCurrentFont(QFont(t.get("bfont", "Arial"))) f.font.setCurrentFont(QFont(t.get("bfont", "Arial")))
f.fontSize.setValue(t.get("bsize", 12)) f.fontSize.setValue(t.get("bsize", 12))
f.buttonBox.accepted.connect(lambda: self.onBrowserDisplayOk(f)) qconnect(f.buttonBox.accepted, lambda: self.onBrowserDisplayOk(f))
d.exec_() d.exec_()
def onBrowserDisplayOk(self, f): def onBrowserDisplayOk(self, f):
@ -547,7 +548,7 @@ Enter deck to place new %s cards in, or leave blank:"""
te.setText(self.col.decks.get(t["did"])["name"]) te.setText(self.col.decks.get(t["did"])["name"])
te.selectAll() te.selectAll()
bb = QDialogButtonBox(QDialogButtonBox.Close) bb = QDialogButtonBox(QDialogButtonBox.Close)
bb.rejected.connect(d.close) qconnect(bb.rejected, d.close)
l.addWidget(bb) l.addWidget(bb)
d.setLayout(l) d.setLayout(l)
d.exec_() d.exec_()

12
qt/aqt/customstudy.py
View file

@ -37,12 +37,12 @@ class CustomStudy(QDialog):
def setupSignals(self): def setupSignals(self):
f = self.form f = self.form
f.radioNew.clicked.connect(lambda: self.onRadioChange(RADIO_NEW)) qconnect(f.radioNew.clicked, lambda: self.onRadioChange(RADIO_NEW))
f.radioRev.clicked.connect(lambda: self.onRadioChange(RADIO_REV)) qconnect(f.radioRev.clicked, lambda: self.onRadioChange(RADIO_REV))
f.radioForgot.clicked.connect(lambda: self.onRadioChange(RADIO_FORGOT)) qconnect(f.radioForgot.clicked, lambda: self.onRadioChange(RADIO_FORGOT))
f.radioAhead.clicked.connect(lambda: self.onRadioChange(RADIO_AHEAD)) qconnect(f.radioAhead.clicked, lambda: self.onRadioChange(RADIO_AHEAD))
f.radioPreview.clicked.connect(lambda: self.onRadioChange(RADIO_PREVIEW)) qconnect(f.radioPreview.clicked, lambda: self.onRadioChange(RADIO_PREVIEW))
f.radioCram.clicked.connect(lambda: self.onRadioChange(RADIO_CRAM)) qconnect(f.radioCram.clicked, lambda: self.onRadioChange(RADIO_CRAM))
def onRadioChange(self, idx): def onRadioChange(self, idx):
f = self.form f = self.form

21
qt/aqt/deckconf.py
View file

@ -36,10 +36,11 @@ class DeckConf(QDialog):
self.setupCombos() self.setupCombos()
self.setupConfs() self.setupConfs()
self.setWindowModality(Qt.WindowModal) self.setWindowModality(Qt.WindowModal)
self.form.buttonBox.helpRequested.connect(lambda: openHelp("deckoptions")) qconnect(self.form.buttonBox.helpRequested, lambda: openHelp("deckoptions"))
self.form.confOpts.clicked.connect(self.confOpts) qconnect(self.form.confOpts.clicked, self.confOpts)
self.form.buttonBox.button(QDialogButtonBox.RestoreDefaults).clicked.connect( qconnect(
self.onRestore self.form.buttonBox.button(QDialogButtonBox.RestoreDefaults).clicked,
self.onRestore,
) )
self.setWindowTitle(_("Options for %s") % self.deck["name"]) self.setWindowTitle(_("Options for %s") % self.deck["name"])
# qt doesn't size properly with altered fonts otherwise # qt doesn't size properly with altered fonts otherwise
@ -54,13 +55,13 @@ class DeckConf(QDialog):
f = self.form f = self.form
f.newOrder.addItems(list(cs.newCardOrderLabels().values())) f.newOrder.addItems(list(cs.newCardOrderLabels().values()))
f.newOrder.currentIndexChanged.connect(self.onNewOrderChanged) qconnect(f.newOrder.currentIndexChanged, self.onNewOrderChanged)
# Conf list # Conf list
###################################################################### ######################################################################
def setupConfs(self): def setupConfs(self):
self.form.dconf.currentIndexChanged.connect(self.onConfChange) qconnect(self.form.dconf.currentIndexChanged, self.onConfChange)
self.conf = None self.conf = None
self.loadConfs() self.loadConfs()
@ -84,13 +85,13 @@ class DeckConf(QDialog):
def confOpts(self): def confOpts(self):
m = QMenu(self.mw) m = QMenu(self.mw)
a = m.addAction(_("Add")) a = m.addAction(_("Add"))
a.triggered.connect(self.addGroup) qconnect(a.triggered, self.addGroup)
a = m.addAction(_("Delete")) a = m.addAction(_("Delete"))
a.triggered.connect(self.remGroup) qconnect(a.triggered, self.remGroup)
a = m.addAction(_("Rename")) a = m.addAction(_("Rename"))
a.triggered.connect(self.renameGroup) qconnect(a.triggered, self.renameGroup)
a = m.addAction(_("Set for all subdecks")) a = m.addAction(_("Set for all subdecks"))
a.triggered.connect(self.setChildren) qconnect(a.triggered, self.setChildren)
if not self.childDids: if not self.childDids:
a.setEnabled(False) a.setEnabled(False)
m.exec_(QCursor.pos()) m.exec_(QCursor.pos())

4
qt/aqt/dyndeckconf.py
View file

@ -23,7 +23,7 @@ class DeckConf(QDialog):
self.ok = self.form.buttonBox.addButton(label, QDialogButtonBox.AcceptRole) self.ok = self.form.buttonBox.addButton(label, QDialogButtonBox.AcceptRole)
self.mw.checkpoint(_("Options")) self.mw.checkpoint(_("Options"))
self.setWindowModality(Qt.WindowModal) self.setWindowModality(Qt.WindowModal)
self.form.buttonBox.helpRequested.connect(lambda: openHelp("filtered")) qconnect(self.form.buttonBox.helpRequested, lambda: openHelp("filtered"))
self.setWindowTitle(_("Options for %s") % self.deck["name"]) self.setWindowTitle(_("Options for %s") % self.deck["name"])
restoreGeom(self, "dyndeckconf") restoreGeom(self, "dyndeckconf")
self.initialSetup() self.initialSetup()
@ -46,7 +46,7 @@ class DeckConf(QDialog):
self.form.order.addItems(list(cs.dynOrderLabels().values())) self.form.order.addItems(list(cs.dynOrderLabels().values()))
self.form.order_2.addItems(list(cs.dynOrderLabels().values())) self.form.order_2.addItems(list(cs.dynOrderLabels().values()))
self.form.resched.stateChanged.connect(self._onReschedToggled) qconnect(self.form.resched.stateChanged, self._onReschedToggled)
def _onReschedToggled(self, _state): def _onReschedToggled(self, _state):
self.form.previewDelayWidget.setVisible( self.form.previewDelayWidget.setVisible(

8
qt/aqt/editor.py
View file

@ -521,7 +521,7 @@ class Editor:
d = QDialog(self.widget) d = QDialog(self.widget)
form = aqt.forms.edithtml.Ui_Dialog() form = aqt.forms.edithtml.Ui_Dialog()
form.setupUi(d) form.setupUi(d)
form.buttonBox.helpRequested.connect(lambda: openHelp("editor")) qconnect(form.buttonBox.helpRequested, lambda: openHelp("editor"))
form.textEdit.setPlainText(self.note.fields[field]) form.textEdit.setPlainText(self.note.fields[field])
d.show() d.show()
form.textEdit.moveCursor(QTextCursor.End) form.textEdit.moveCursor(QTextCursor.End)
@ -553,7 +553,7 @@ class Editor:
l = QLabel(_("Tags")) l = QLabel(_("Tags"))
tb.addWidget(l, 1, 0) tb.addWidget(l, 1, 0)
self.tags = aqt.tagedit.TagEdit(self.widget) self.tags = aqt.tagedit.TagEdit(self.widget)
self.tags.lostFocus.connect(self.saveTags) qconnect(self.tags.lostFocus, self.saveTags)
self.tags.setToolTip(shortcut(_("Jump to tags with Ctrl+Shift+T"))) self.tags.setToolTip(shortcut(_("Jump to tags with Ctrl+Shift+T")))
border = theme_manager.str_color("border") border = theme_manager.str_color("border")
self.tags.setStyleSheet(f"border: 1px solid {border}") self.tags.setStyleSheet(f"border: 1px solid {border}")
@ -921,7 +921,7 @@ to a cloze type first, via Edit>Change Note Type."""
(_("Edit HTML"), self.onHtmlEdit, "Ctrl+Shift+X"), (_("Edit HTML"), self.onHtmlEdit, "Ctrl+Shift+X"),
): ):
a = m.addAction(text) a = m.addAction(text)
a.triggered.connect(handler) qconnect(a.triggered, handler)
a.setShortcut(QKeySequence(shortcut)) a.setShortcut(QKeySequence(shortcut))
qtMenuShortcutWorkaround(m) qtMenuShortcutWorkaround(m)
@ -985,7 +985,7 @@ class EditorWebView(AnkiWebView):
self.setAcceptDrops(True) self.setAcceptDrops(True)
self._markInternal = False self._markInternal = False
clip = self.editor.mw.app.clipboard() clip = self.editor.mw.app.clipboard()
clip.dataChanged.connect(self._onClipboardChange) qconnect(clip.dataChanged, self._onClipboardChange)
gui_hooks.editor_web_view_did_init(self) gui_hooks.editor_web_view_did_init(self)
def _onClipboardChange(self): def _onClipboardChange(self):

4
qt/aqt/errors.py
View file

@ -34,7 +34,7 @@ class ErrorHandler(QObject):
QObject.__init__(self, mw) QObject.__init__(self, mw)
self.mw = mw self.mw = mw
self.timer = None self.timer = None
self.errorTimer.connect(self._setTimer) qconnect(self.errorTimer, self._setTimer)
self.pool = "" self.pool = ""
self._oldstderr = sys.stderr self._oldstderr = sys.stderr
sys.stderr = self sys.stderr = self
@ -59,7 +59,7 @@ class ErrorHandler(QObject):
def _setTimer(self): def _setTimer(self):
if not self.timer: if not self.timer:
self.timer = QTimer(self.mw) self.timer = QTimer(self.mw)
self.timer.timeout.connect(self.onTimeout) qconnect(self.timer.timeout, self.onTimeout)
self.timer.setInterval(self.ivl) self.timer.setInterval(self.ivl)
self.timer.setSingleShot(True) self.timer.setSingleShot(True)
self.timer.start() self.timer.start()

6
qt/aqt/exporting.py
View file

@ -11,7 +11,7 @@ from typing import List, Optional
import aqt import aqt
from anki import hooks from anki import hooks
from anki.exporting import exporters from anki.exporting import Exporter, exporters
from anki.lang import _, ngettext from anki.lang import _, ngettext
from aqt.qt import * from aqt.qt import *
from aqt.utils import checkInvalidFilename, getSaveFile, showWarning, tooltip from aqt.utils import checkInvalidFilename, getSaveFile, showWarning, tooltip
@ -29,7 +29,7 @@ class ExportDialog(QDialog):
self.col = mw.col.weakref() self.col = mw.col.weakref()
self.frm = aqt.forms.exporting.Ui_ExportDialog() self.frm = aqt.forms.exporting.Ui_ExportDialog()
self.frm.setupUi(self) self.frm.setupUi(self)
self.exporter = None self.exporter: Optional[Exporter] = None
self.cids = cids self.cids = cids
self.setup(did) self.setup(did)
self.exec_() self.exec_()
@ -45,7 +45,7 @@ class ExportDialog(QDialog):
break break
self.frm.format.insertItems(0, [e[0] for e in self.exporters]) self.frm.format.insertItems(0, [e[0] for e in self.exporters])
self.frm.format.setCurrentIndex(idx) self.frm.format.setCurrentIndex(idx)
self.frm.format.activated.connect(self.exporterChanged) qconnect(self.frm.format.activated, self.exporterChanged)
self.exporterChanged(idx) self.exporterChanged(idx)
# deck list # deck list
if self.cids is None: if self.cids is None:

14
qt/aqt/fields.py
View file

@ -42,13 +42,13 @@ class FieldDialog(QDialog):
def setupSignals(self): def setupSignals(self):
f = self.form f = self.form
f.fieldList.currentRowChanged.connect(self.onRowChange) qconnect(f.fieldList.currentRowChanged, self.onRowChange)
f.fieldAdd.clicked.connect(self.onAdd) qconnect(f.fieldAdd.clicked, self.onAdd)
f.fieldDelete.clicked.connect(self.onDelete) qconnect(f.fieldDelete.clicked, self.onDelete)
f.fieldRename.clicked.connect(self.onRename) qconnect(f.fieldRename.clicked, self.onRename)
f.fieldPosition.clicked.connect(self.onPosition) qconnect(f.fieldPosition.clicked, self.onPosition)
f.sortField.clicked.connect(self.onSortField) qconnect(f.sortField.clicked, self.onSortField)
f.buttonBox.helpRequested.connect(self.onHelp) qconnect(f.buttonBox.helpRequested, self.onHelp)
def onDrop(self, ev): def onDrop(self, ev):
fieldList = self.form.fieldList fieldList = self.form.fieldList

10
qt/aqt/importing.py
View file

@ -83,18 +83,18 @@ class ImportDialog(QDialog):
self.importer = importer self.importer = importer
self.frm = aqt.forms.importing.Ui_ImportDialog() self.frm = aqt.forms.importing.Ui_ImportDialog()
self.frm.setupUi(self) self.frm.setupUi(self)
self.frm.buttonBox.button(QDialogButtonBox.Help).clicked.connect( qconnect(
self.helpRequested self.frm.buttonBox.button(QDialogButtonBox.Help).clicked, self.helpRequested
) )
self.setupMappingFrame() self.setupMappingFrame()
self.setupOptions() self.setupOptions()
self.modelChanged() self.modelChanged()
self.frm.autoDetect.setVisible(self.importer.needDelimiter) self.frm.autoDetect.setVisible(self.importer.needDelimiter)
gui_hooks.current_note_type_did_change.append(self.modelChanged) gui_hooks.current_note_type_did_change.append(self.modelChanged)
self.frm.autoDetect.clicked.connect(self.onDelimiter) qconnect(self.frm.autoDetect.clicked, self.onDelimiter)
self.updateDelimiterButtonText() self.updateDelimiterButtonText()
self.frm.allowHTML.setChecked(self.mw.pm.profile.get("allowHTML", True)) self.frm.allowHTML.setChecked(self.mw.pm.profile.get("allowHTML", True))
self.frm.importMode.currentIndexChanged.connect(self.importModeChanged) qconnect(self.frm.importMode.currentIndexChanged, self.importModeChanged)
self.frm.importMode.setCurrentIndex(self.mw.pm.profile.get("importMode", 1)) self.frm.importMode.setCurrentIndex(self.mw.pm.profile.get("importMode", 1))
self.frm.tagModified.setText(self.mw.pm.profile.get("tagModified", "")) self.frm.tagModified.setText(self.mw.pm.profile.get("tagModified", ""))
self.frm.tagModified.setCol(self.mw.col) self.frm.tagModified.setCol(self.mw.col)
@ -266,7 +266,7 @@ you can enter it here. Use \\t to represent tab."""
self.grid.addWidget(QLabel(text), num, 1) self.grid.addWidget(QLabel(text), num, 1)
button = QPushButton(_("Change")) button = QPushButton(_("Change"))
self.grid.addWidget(button, num, 2) self.grid.addWidget(button, num, 2)
button.clicked.connect(lambda _, s=self, n=num: s.changeMappingNum(n)) qconnect(button.clicked, lambda _, s=self, n=num: s.changeMappingNum(n))
def changeMappingNum(self, n): def changeMappingNum(self, n):
f = ChangeMap(self.mw, self.importer.model, self.mapping[n]).getField() f = ChangeMap(self.mw, self.importer.model, self.mapping[n]).getField()

12
qt/aqt/legacy.py
View file

@ -38,9 +38,9 @@ def fmtTimeSpan(time, pad=0, point=0, short=False, inTime=False, unit=99):
return aqt.mw.col.backend.format_time_span(time) return aqt.mw.col.backend.format_time_span(time)
def install_pylib_legacy(): def install_pylib_legacy() -> None:
anki.utils.bodyClass = bodyClass anki.utils.bodyClass = bodyClass # type: ignore
anki.utils.fmtTimeSpan = fmtTimeSpan anki.utils.fmtTimeSpan = fmtTimeSpan # type: ignore
anki.sound._soundReg = r"\[sound:(.*?)\]" anki.sound._soundReg = r"\[sound:(.*?)\]" # type: ignore
anki.sound.allSounds = allSounds anki.sound.allSounds = allSounds # type: ignore
anki.sound.stripSounds = stripSounds anki.sound.stripSounds = stripSounds # type: ignore

74
qt/aqt/main.py
View file

@ -204,17 +204,17 @@ class AnkiQt(QMainWindow):
d = self.profileDiag = self.ProfileManager() d = self.profileDiag = self.ProfileManager()
f = self.profileForm = aqt.forms.profiles.Ui_MainWindow() f = self.profileForm = aqt.forms.profiles.Ui_MainWindow()
f.setupUi(d) f.setupUi(d)
f.login.clicked.connect(self.onOpenProfile) qconnect(f.login.clicked, self.onOpenProfile)
f.profiles.itemDoubleClicked.connect(self.onOpenProfile) qconnect(f.profiles.itemDoubleClicked, self.onOpenProfile)
f.openBackup.clicked.connect(self.onOpenBackup) qconnect(f.openBackup.clicked, self.onOpenBackup)
f.quit.clicked.connect(d.close) qconnect(f.quit.clicked, d.close)
d.onClose.connect(self.cleanupAndExit) qconnect(d.onClose, self.cleanupAndExit)
f.add.clicked.connect(self.onAddProfile) qconnect(f.add.clicked, self.onAddProfile)
f.rename.clicked.connect(self.onRenameProfile) qconnect(f.rename.clicked, self.onRenameProfile)
f.delete_2.clicked.connect(self.onRemProfile) qconnect(f.delete_2.clicked, self.onRemProfile)
f.profiles.currentRowChanged.connect(self.onProfileRowChange) qconnect(f.profiles.currentRowChanged, self.onProfileRowChange)
f.statusbar.setVisible(False) f.statusbar.setVisible(False)
f.downgrade_button.clicked.connect(self._on_downgrade) qconnect(f.downgrade_button.clicked, self._on_downgrade)
# enter key opens profile # enter key opens profile
QShortcut(QKeySequence("Return"), d, activated=self.onOpenProfile) # type: ignore QShortcut(QKeySequence("Return"), d, activated=self.onOpenProfile) # type: ignore
self.refreshProfilesList() self.refreshProfilesList()
@ -1128,23 +1128,25 @@ title="%s" %s>%s</button>""" % (
def setupMenus(self) -> None: def setupMenus(self) -> None:
m = self.form m = self.form
m.actionSwitchProfile.triggered.connect(self.unloadProfileAndShowProfileManager) qconnect(
m.actionImport.triggered.connect(self.onImport) m.actionSwitchProfile.triggered, self.unloadProfileAndShowProfileManager
m.actionExport.triggered.connect(self.onExport) )
m.actionExit.triggered.connect(self.close) qconnect(m.actionImport.triggered, self.onImport)
m.actionPreferences.triggered.connect(self.onPrefs) qconnect(m.actionExport.triggered, self.onExport)
m.actionAbout.triggered.connect(self.onAbout) qconnect(m.actionExit.triggered, self.close)
m.actionUndo.triggered.connect(self.onUndo) qconnect(m.actionPreferences.triggered, self.onPrefs)
qconnect(m.actionAbout.triggered, self.onAbout)
qconnect(m.actionUndo.triggered, self.onUndo)
if qtminor < 11: if qtminor < 11:
m.actionUndo.setShortcut(QKeySequence("Ctrl+Alt+Z")) m.actionUndo.setShortcut(QKeySequence("Ctrl+Alt+Z"))
m.actionFullDatabaseCheck.triggered.connect(self.onCheckDB) qconnect(m.actionFullDatabaseCheck.triggered, self.onCheckDB)
m.actionCheckMediaDatabase.triggered.connect(self.on_check_media_db) qconnect(m.actionCheckMediaDatabase.triggered, self.on_check_media_db)
m.actionDocumentation.triggered.connect(self.onDocumentation) qconnect(m.actionDocumentation.triggered, self.onDocumentation)
m.actionDonate.triggered.connect(self.onDonate) qconnect(m.actionDonate.triggered, self.onDonate)
m.actionStudyDeck.triggered.connect(self.onStudyDeck) qconnect(m.actionStudyDeck.triggered, self.onStudyDeck)
m.actionCreateFiltered.triggered.connect(self.onCram) qconnect(m.actionCreateFiltered.triggered, self.onCram)
m.actionEmptyCards.triggered.connect(self.onEmptyCards) qconnect(m.actionEmptyCards.triggered, self.onEmptyCards)
m.actionNoteTypes.triggered.connect(self.onNoteTypes) qconnect(m.actionNoteTypes.triggered, self.onNoteTypes)
def updateTitleBar(self) -> None: def updateTitleBar(self) -> None:
self.setWindowTitle("Anki") self.setWindowTitle("Anki")
@ -1156,9 +1158,9 @@ title="%s" %s>%s</button>""" % (
import aqt.update import aqt.update
self.autoUpdate = aqt.update.LatestVersionFinder(self) self.autoUpdate = aqt.update.LatestVersionFinder(self)
self.autoUpdate.newVerAvail.connect(self.newVerAvail) # type: ignore qconnect(self.autoUpdate.newVerAvail, self.newVerAvail)
self.autoUpdate.newMsg.connect(self.newMsg) # type: ignore qconnect(self.autoUpdate.newMsg, self.newMsg)
self.autoUpdate.clockIsOff.connect(self.clockIsOff) # type: ignore qconnect(self.autoUpdate.clockIsOff, self.clockIsOff)
self.autoUpdate.start() self.autoUpdate.start()
def newVerAvail(self, ver): def newVerAvail(self, ver):
@ -1360,7 +1362,7 @@ will be lost. Continue?"""
) )
self.reset() self.reset()
box.accepted.connect(onDelete) qconnect(box.accepted, onDelete)
diag.show() diag.show()
# Debugging # Debugging
@ -1376,13 +1378,13 @@ will be lost. Continue?"""
frm.text.setFont(font) frm.text.setFont(font)
frm.log.setFont(font) frm.log.setFont(font)
s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+return"), d) s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+return"), d)
s.activated.connect(lambda: self.onDebugRet(frm)) qconnect(s.activated, lambda: self.onDebugRet(frm))
s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+shift+return"), d) s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+shift+return"), d)
s.activated.connect(lambda: self.onDebugPrint(frm)) qconnect(s.activated, lambda: self.onDebugPrint(frm))
s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+l"), d) s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+l"), d)
s.activated.connect(frm.log.clear) qconnect(s.activated, frm.log.clear)
s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+shift+l"), d) s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+shift+l"), d)
s.activated.connect(frm.text.clear) qconnect(s.activated, frm.text.clear)
def addContextMenu(ev: QCloseEvent, name: str) -> None: def addContextMenu(ev: QCloseEvent, name: str) -> None:
ev.accept() ev.accept()
@ -1514,7 +1516,7 @@ will be lost. Continue?"""
if isMac: if isMac:
# mac users expect a minimize option # mac users expect a minimize option
self.minimizeShortcut = QShortcut("Ctrl+M", self) self.minimizeShortcut = QShortcut("Ctrl+M", self)
self.minimizeShortcut.activated.connect(self.onMacMinimize) # type: ignore qconnect(self.minimizeShortcut.activated, self.onMacMinimize)
self.hideMenuAccels = True self.hideMenuAccels = True
self.maybeHideAccelerators() self.maybeHideAccelerators()
self.hideStatusTips() self.hideStatusTips()
@ -1546,7 +1548,7 @@ will be lost. Continue?"""
########################################################################## ##########################################################################
def setupAppMsg(self) -> None: def setupAppMsg(self) -> None:
self.app.appMsg.connect(self.onAppMsg) qconnect(self.app.appMsg, self.onAppMsg)
def onAppMsg(self, buf: str) -> Optional[QTimer]: def onAppMsg(self, buf: str) -> Optional[QTimer]:
is_addon = self._isAddon(buf) is_addon = self._isAddon(buf)
@ -1606,7 +1608,7 @@ Please ensure a profile is open and Anki is not busy, then try again."""
# ensure gc runs in main thread # ensure gc runs in main thread
def setupDialogGC(self, obj: Any) -> None: def setupDialogGC(self, obj: Any) -> None:
obj.finished.connect(lambda: self.gcWindow(obj)) qconnect(obj.finished, lambda: self.gcWindow(obj))
def gcWindow(self, obj: Any) -> None: def gcWindow(self, obj: Any) -> None:
obj.deleteLater() obj.deleteLater()

14
qt/aqt/mediacheck.py
View file

@ -6,7 +6,7 @@ from __future__ import annotations
import itertools import itertools
import time import time
from concurrent.futures import Future from concurrent.futures import Future
from typing import Iterable, List, Optional, TypeVar from typing import Iterable, List, Optional, Sequence, TypeVar
import aqt import aqt
from anki import hooks from anki import hooks
@ -84,27 +84,27 @@ class MediaChecker:
b = QPushButton(tr(TR.MEDIA_CHECK_DELETE_UNUSED)) b = QPushButton(tr(TR.MEDIA_CHECK_DELETE_UNUSED))
b.setAutoDefault(False) b.setAutoDefault(False)
box.addButton(b, QDialogButtonBox.RejectRole) box.addButton(b, QDialogButtonBox.RejectRole)
b.clicked.connect(lambda c: self._on_trash_files(output.unused)) # type: ignore qconnect(b.clicked, lambda c: self._on_trash_files(output.unused))
if output.missing: if output.missing:
if any(map(lambda x: x.startswith("latex-"), output.missing)): if any(map(lambda x: x.startswith("latex-"), output.missing)):
b = QPushButton(tr(TR.MEDIA_CHECK_RENDER_LATEX)) b = QPushButton(tr(TR.MEDIA_CHECK_RENDER_LATEX))
b.setAutoDefault(False) b.setAutoDefault(False)
box.addButton(b, QDialogButtonBox.RejectRole) box.addButton(b, QDialogButtonBox.RejectRole)
b.clicked.connect(self._on_render_latex) # type: ignore qconnect(b.clicked, self._on_render_latex)
if output.have_trash: if output.have_trash:
b = QPushButton(tr(TR.MEDIA_CHECK_EMPTY_TRASH)) b = QPushButton(tr(TR.MEDIA_CHECK_EMPTY_TRASH))
b.setAutoDefault(False) b.setAutoDefault(False)
box.addButton(b, QDialogButtonBox.RejectRole) box.addButton(b, QDialogButtonBox.RejectRole)
b.clicked.connect(lambda c: self._on_empty_trash()) # type: ignore qconnect(b.clicked, lambda c: self._on_empty_trash())
b = QPushButton(tr(TR.MEDIA_CHECK_RESTORE_TRASH)) b = QPushButton(tr(TR.MEDIA_CHECK_RESTORE_TRASH))
b.setAutoDefault(False) b.setAutoDefault(False)
box.addButton(b, QDialogButtonBox.RejectRole) box.addButton(b, QDialogButtonBox.RejectRole)
b.clicked.connect(lambda c: self._on_restore_trash()) # type: ignore qconnect(b.clicked, lambda c: self._on_restore_trash())
box.rejected.connect(diag.reject) # type: ignore qconnect(box.rejected, diag.reject)
diag.setMinimumHeight(400) diag.setMinimumHeight(400)
diag.setMinimumWidth(500) diag.setMinimumWidth(500)
restoreGeom(diag, "checkmediadb") restoreGeom(diag, "checkmediadb")
@ -137,7 +137,7 @@ class MediaChecker:
self.mw.progress.update(tr(TR.MEDIA_CHECK_CHECKED, count=count)) self.mw.progress.update(tr(TR.MEDIA_CHECK_CHECKED, count=count))
return True return True
def _on_trash_files(self, fnames: List[str]): def _on_trash_files(self, fnames: Sequence[str]):
if not askUser(tr(TR.MEDIA_CHECK_DELETE_UNUSED_CONFIRM)): if not askUser(tr(TR.MEDIA_CHECK_DELETE_UNUSED_CONFIRM)):
return return

4
qt/aqt/mediasync.py
View file

@ -22,7 +22,7 @@ from anki.rsbackend import (
from anki.types import assert_impossible from anki.types import assert_impossible
from anki.utils import intTime from anki.utils import intTime
from aqt import gui_hooks from aqt import gui_hooks
from aqt.qt import QDialog, QDialogButtonBox, QPushButton from aqt.qt import QDialog, QDialogButtonBox, QPushButton, qconnect
from aqt.utils import showWarning, tr from aqt.utils import showWarning, tr
LogEntry = Union[MediaSyncProgress, str] LogEntry = Union[MediaSyncProgress, str]
@ -167,7 +167,7 @@ class MediaSyncDialog(QDialog):
self.form.setupUi(self) self.form.setupUi(self)
self.setWindowTitle(tr(TR.SYNC_MEDIA_LOG_TITLE)) self.setWindowTitle(tr(TR.SYNC_MEDIA_LOG_TITLE))
self.abort_button = QPushButton(tr(TR.SYNC_ABORT_BUTTON)) self.abort_button = QPushButton(tr(TR.SYNC_ABORT_BUTTON))
self.abort_button.clicked.connect(self._on_abort) # type: ignore qconnect(self.abort_button.clicked, self._on_abort)
self.abort_button.setAutoDefault(False) self.abort_button.setAutoDefault(False)
self.form.buttonBox.addButton(self.abort_button, QDialogButtonBox.ActionRole) self.form.buttonBox.addButton(self.abort_button, QDialogButtonBox.ActionRole)
self.abort_button.setHidden(not self._syncer.is_syncing()) self.abort_button.setHidden(not self._syncer.is_syncing())

2
qt/aqt/modelchooser.py
View file

@ -32,7 +32,7 @@ class ModelChooser(QHBoxLayout):
s = QShortcut(QKeySequence("Ctrl+N"), self.widget, activated=self.onModelChange) s = QShortcut(QKeySequence("Ctrl+N"), self.widget, activated=self.onModelChange)
self.models.setAutoDefault(False) self.models.setAutoDefault(False)
self.addWidget(self.models) self.addWidget(self.models)
self.models.clicked.connect(self.onModelChange) qconnect(self.models.clicked, self.onModelChange)
# layout # layout
sizePolicy = QSizePolicy(QSizePolicy.Policy(7), QSizePolicy.Policy(0)) sizePolicy = QSizePolicy(QSizePolicy.Policy(7), QSizePolicy.Policy(0))
self.models.setSizePolicy(sizePolicy) self.models.setSizePolicy(sizePolicy)

35
qt/aqt/models.py
View file

@ -3,6 +3,7 @@
import collections import collections
import re import re
from operator import itemgetter from operator import itemgetter
from typing import Optional
import aqt.clayout import aqt.clayout
from anki import stdmodels from anki import stdmodels
@ -32,7 +33,7 @@ class Models(QDialog):
self.mw.checkpoint(_("Note Types")) self.mw.checkpoint(_("Note Types"))
self.form = aqt.forms.models.Ui_Dialog() self.form = aqt.forms.models.Ui_Dialog()
self.form.setupUi(self) self.form.setupUi(self)
self.form.buttonBox.helpRequested.connect(lambda: openHelp("notetypes")) qconnect(self.form.buttonBox.helpRequested, lambda: openHelp("notetypes"))
self.setupModels() self.setupModels()
restoreGeom(self, "models") restoreGeom(self, "models")
self.exec_() self.exec_()
@ -46,20 +47,20 @@ class Models(QDialog):
box = f.buttonBox box = f.buttonBox
t = QDialogButtonBox.ActionRole t = QDialogButtonBox.ActionRole
b = box.addButton(_("Add"), t) b = box.addButton(_("Add"), t)
b.clicked.connect(self.onAdd) qconnect(b.clicked, self.onAdd)
b = box.addButton(_("Rename"), t) b = box.addButton(_("Rename"), t)
b.clicked.connect(self.onRename) qconnect(b.clicked, self.onRename)
b = box.addButton(_("Delete"), t) b = box.addButton(_("Delete"), t)
b.clicked.connect(self.onDelete) qconnect(b.clicked, self.onDelete)
if self.fromMain: if self.fromMain:
b = box.addButton(_("Fields..."), t) b = box.addButton(_("Fields..."), t)
b.clicked.connect(self.onFields) qconnect(b.clicked, self.onFields)
b = box.addButton(_("Cards..."), t) b = box.addButton(_("Cards..."), t)
b.clicked.connect(self.onCards) qconnect(b.clicked, self.onCards)
b = box.addButton(_("Options..."), t) b = box.addButton(_("Options..."), t)
b.clicked.connect(self.onAdvanced) qconnect(b.clicked, self.onAdvanced)
f.modelsList.currentRowChanged.connect(self.modelChanged) qconnect(f.modelsList.currentRowChanged, self.modelChanged)
f.modelsList.itemDoubleClicked.connect(self.onRename) qconnect(f.modelsList.itemDoubleClicked, self.onRename)
self.updateModelsList() self.updateModelsList()
f.modelsList.setCurrentRow(0) f.modelsList.setCurrentRow(0)
maybeHideClose(box) maybeHideClose(box)
@ -123,7 +124,7 @@ class Models(QDialog):
frm.latexHeader.setText(self.model["latexPre"]) frm.latexHeader.setText(self.model["latexPre"])
frm.latexFooter.setText(self.model["latexPost"]) frm.latexFooter.setText(self.model["latexPost"])
d.setWindowTitle(_("Options for %s") % self.model["name"]) d.setWindowTitle(_("Options for %s") % self.model["name"])
frm.buttonBox.helpRequested.connect(lambda: openHelp("latex")) qconnect(frm.buttonBox.helpRequested, lambda: openHelp("latex"))
restoreGeom(d, "modelopts") restoreGeom(d, "modelopts")
gui_hooks.models_advanced_will_show(d) gui_hooks.models_advanced_will_show(d)
d.exec_() d.exec_()
@ -180,19 +181,19 @@ class Models(QDialog):
class AddModel(QDialog): class AddModel(QDialog):
def __init__(self, mw, parent=None): def __init__(self, mw: AnkiQt, parent: Optional[QWidget] = None):
self.parent = parent or mw self.parent_ = parent or mw
self.mw = mw self.mw = mw
self.col = mw.col self.col = mw.col
QDialog.__init__(self, self.parent, Qt.Window) QDialog.__init__(self, self.parent_, Qt.Window)
self.model = None self.model = None
self.dialog = aqt.forms.addmodel.Ui_Dialog() self.dialog = aqt.forms.addmodel.Ui_Dialog()
self.dialog.setupUi(self) self.dialog.setupUi(self)
# standard models # standard models
self.models = [] self.models = []
for (name, func) in stdmodels.models: for (name, func) in stdmodels.models:
if isinstance(name, collections.Callable): if isinstance(name, collections.Callable): # type: ignore
name = name() name = name() # type: ignore
item = QListWidgetItem(_("Add: %s") % name) item = QListWidgetItem(_("Add: %s") % name)
self.dialog.models.addItem(item) self.dialog.models.addItem(item)
self.models.append((True, func)) self.models.append((True, func))
@ -204,9 +205,9 @@ class AddModel(QDialog):
self.dialog.models.setCurrentRow(0) self.dialog.models.setCurrentRow(0)
# the list widget will swallow the enter key # the list widget will swallow the enter key
s = QShortcut(QKeySequence("Return"), self) s = QShortcut(QKeySequence("Return"), self)
s.activated.connect(self.accept) qconnect(s.activated, self.accept)
# help # help
self.dialog.buttonBox.helpRequested.connect(self.onHelp) qconnect(self.dialog.buttonBox.helpRequested, self.onHelp)
def get(self): def get(self):
self.exec_() self.exec_()

3
qt/aqt/mpv.py
View file

@ -42,6 +42,7 @@ from queue import Empty, Full, Queue
from typing import Dict, Optional from typing import Dict, Optional
from anki.utils import isWin from anki.utils import isWin
from aqt import qconnect
class MPVError(Exception): class MPVError(Exception):
@ -180,7 +181,7 @@ class MPVBase:
# unix socket # unix socket
try: try:
self._sock = socket.socket(socket.AF_UNIX) self._sock = socket.socket(socket.AF_UNIX)
self._sock.connect(self._sock_filename) qconnect(self._sock, self._sock_filename)
except (FileNotFoundError, ConnectionRefusedError): except (FileNotFoundError, ConnectionRefusedError):
self._sock.close() self._sock.close()
continue continue

8
qt/aqt/preferences.py
View file

@ -22,7 +22,7 @@ class Preferences(QDialog):
self.form.setupUi(self) self.form.setupUi(self)
self.form.buttonBox.button(QDialogButtonBox.Help).setAutoDefault(False) self.form.buttonBox.button(QDialogButtonBox.Help).setAutoDefault(False)
self.form.buttonBox.button(QDialogButtonBox.Close).setAutoDefault(False) self.form.buttonBox.button(QDialogButtonBox.Close).setAutoDefault(False)
self.form.buttonBox.helpRequested.connect(lambda: openHelp("profileprefs")) qconnect(self.form.buttonBox.helpRequested, lambda: openHelp("profileprefs"))
self.silentlyClose = True self.silentlyClose = True
self.setupLang() self.setupLang()
self.setupCollection() self.setupCollection()
@ -54,7 +54,7 @@ class Preferences(QDialog):
f = self.form f = self.form
f.lang.addItems([x[0] for x in anki.lang.langs]) f.lang.addItems([x[0] for x in anki.lang.langs])
f.lang.setCurrentIndex(self.langIdx()) f.lang.setCurrentIndex(self.langIdx())
f.lang.currentIndexChanged.connect(self.onLangIdxChanged) qconnect(f.lang.currentIndexChanged, self.onLangIdxChanged)
def langIdx(self): def langIdx(self):
codes = [x[1] for x in anki.lang.langs] codes = [x[1] for x in anki.lang.langs]
@ -193,14 +193,14 @@ class Preferences(QDialog):
def setupNetwork(self): def setupNetwork(self):
self.form.media_log.setText(tr(TR.SYNC_MEDIA_LOG_BUTTON)) self.form.media_log.setText(tr(TR.SYNC_MEDIA_LOG_BUTTON))
self.form.media_log.clicked.connect(self.on_media_log) qconnect(self.form.media_log.clicked, self.on_media_log)
self.form.syncOnProgramOpen.setChecked(self.prof["autoSync"]) self.form.syncOnProgramOpen.setChecked(self.prof["autoSync"])
self.form.syncMedia.setChecked(self.prof["syncMedia"]) self.form.syncMedia.setChecked(self.prof["syncMedia"])
if not self.prof["syncKey"]: if not self.prof["syncKey"]:
self._hideAuth() self._hideAuth()
else: else:
self.form.syncUser.setText(self.prof.get("syncUser", "")) self.form.syncUser.setText(self.prof.get("syncUser", ""))
self.form.syncDeauth.clicked.connect(self.onSyncDeauth) qconnect(self.form.syncDeauth.clicked, self.onSyncDeauth)
def on_media_log(self): def on_media_log(self):
self.mw.media_syncer.show_sync_log() self.mw.media_syncer.show_sync_log()

4
qt/aqt/profiles.py
View file

@ -416,8 +416,8 @@ create table if not exists profiles
d = self.langDiag = NoCloseDiag() d = self.langDiag = NoCloseDiag()
f = self.langForm = aqt.forms.setlang.Ui_Dialog() f = self.langForm = aqt.forms.setlang.Ui_Dialog()
f.setupUi(d) f.setupUi(d)
d.accepted.connect(self._onLangSelected) qconnect(d.accepted, self._onLangSelected)
d.rejected.connect(lambda: True) qconnect(d.rejected, lambda: True)
# default to the system language # default to the system language
try: try:
(lang, enc) = locale.getdefaultlocale() (lang, enc) = locale.getdefaultlocale()

12
qt/aqt/progress.py
View file

@ -45,7 +45,7 @@ class ProgressManager:
t = QTimer(self.mw) t = QTimer(self.mw)
if not repeat: if not repeat:
t.setSingleShot(True) t.setSingleShot(True)
t.timeout.connect(handler) qconnect(t.timeout, handler)
t.start(ms) t.start(ms)
return t return t
@ -74,7 +74,7 @@ class ProgressManager:
self._win.setWindowModality(Qt.ApplicationModal) self._win.setWindowModality(Qt.ApplicationModal)
self._win.setMinimumWidth(300) self._win.setMinimumWidth(300)
self._setBusy() self._setBusy()
self._shown = False self._shown = 0
self._counter = min self._counter = min
self._min = min self._min = min
self._max = max self._max = max
@ -84,10 +84,10 @@ class ProgressManager:
self._show_timer = QTimer(self.mw) self._show_timer = QTimer(self.mw)
self._show_timer.setSingleShot(True) self._show_timer.setSingleShot(True)
self._show_timer.start(600) self._show_timer.start(600)
self._show_timer.timeout.connect(self._on_show_timer) # type: ignore qconnect(self._show_timer.timeout, self._on_show_timer)
return self._win return self._win
def update(self, label=None, value=None, process=True, maybeShow=True): def update(self, label=None, value=None, process=True, maybeShow=True) -> None:
# print self._min, self._counter, self._max, label, time.time() - self._lastTime # print self._min, self._counter, self._max, label, time.time() - self._lastTime
if not self.mw.inMainThread(): if not self.mw.inMainThread():
print("progress.update() called on wrong thread") print("progress.update() called on wrong thread")
@ -141,7 +141,7 @@ class ProgressManager:
self._shown = time.time() self._shown = time.time()
self._win.show() self._win.show()
def _closeWin(self): def _closeWin(self) -> None:
if self._shown: if self._shown:
while True: while True:
# give the window system a second to present # give the window system a second to present
@ -154,7 +154,7 @@ class ProgressManager:
self.app.processEvents(QEventLoop.ExcludeUserInputEvents) self.app.processEvents(QEventLoop.ExcludeUserInputEvents)
self._win.cancel() self._win.cancel()
self._win = None self._win = None
self._shown = False self._shown = 0
def _setBusy(self): def _setBusy(self):
self.mw.app.setOverrideCursor(QCursor(Qt.WaitCursor)) self.mw.app.setOverrideCursor(QCursor(Qt.WaitCursor))

4
qt/aqt/qt.py
View file

@ -7,7 +7,7 @@
import os import os
import sys import sys
import traceback import traceback
from typing import Callable from typing import Callable, Union
from PyQt5.Qt import * # type: ignore from PyQt5.Qt import * # type: ignore
from PyQt5.QtCore import * from PyQt5.QtCore import *
@ -55,6 +55,6 @@ if qtmajor != 5 or qtminor < 9 or qtminor == 10:
raise Exception("Anki does not support your Qt version.") raise Exception("Anki does not support your Qt version.")
def qconnect(signal: Callable, func: Callable) -> None: def qconnect(signal: Union[Callable, pyqtSignal], func: Callable) -> None:
"Helper to work around type checking not working with signal.connect(func)." "Helper to work around type checking not working with signal.connect(func)."
signal.connect(func) # type: ignore signal.connect(func) # type: ignore

2
qt/aqt/reviewer.py
View file

@ -757,7 +757,7 @@ time = %(time)d;
if opts.get("checked"): if opts.get("checked"):
a.setCheckable(True) a.setCheckable(True)
a.setChecked(True) a.setChecked(True)
a.triggered.connect(func) qconnect(a.triggered, func)
def onOptions(self) -> None: def onOptions(self) -> None:
self.mw.onDeckConf(self.mw.col.decks.get(self.card.odid or self.card.did)) self.mw.onDeckConf(self.mw.col.decks.get(self.card.odid or self.card.did))

12
qt/aqt/stats.py
View file

@ -38,14 +38,14 @@ class DeckStats(QDialog):
f.setupUi(self) f.setupUi(self)
restoreGeom(self, self.name) restoreGeom(self, self.name)
b = f.buttonBox.addButton(_("Save PDF"), QDialogButtonBox.ActionRole) b = f.buttonBox.addButton(_("Save PDF"), QDialogButtonBox.ActionRole)
b.clicked.connect(self.saveImage) qconnect(b.clicked, self.saveImage)
b.setAutoDefault(False) b.setAutoDefault(False)
f.groups.clicked.connect(lambda: self.changeScope("deck")) qconnect(f.groups.clicked, lambda: self.changeScope("deck"))
f.groups.setShortcut("g") f.groups.setShortcut("g")
f.all.clicked.connect(lambda: self.changeScope("collection")) qconnect(f.all.clicked, lambda: self.changeScope("collection"))
f.month.clicked.connect(lambda: self.changePeriod(0)) qconnect(f.month.clicked, lambda: self.changePeriod(0))
f.year.clicked.connect(lambda: self.changePeriod(1)) qconnect(f.year.clicked, lambda: self.changePeriod(1))
f.life.clicked.connect(lambda: self.changePeriod(2)) qconnect(f.life.clicked, lambda: self.changePeriod(2))
maybeHideClose(self.form.buttonBox) maybeHideClose(self.form.buttonBox)
addCloseShortcut(self) addCloseShortcut(self)
self.show() self.show()

8
qt/aqt/studydeck.py
View file

@ -48,7 +48,7 @@ class StudyDeck(QDialog):
b.setShortcut(QKeySequence("Ctrl+N")) b.setShortcut(QKeySequence("Ctrl+N"))
b.setToolTip(shortcut(_("Add New Deck (Ctrl+N)"))) b.setToolTip(shortcut(_("Add New Deck (Ctrl+N)")))
self.form.buttonBox.addButton(b, QDialogButtonBox.ActionRole) self.form.buttonBox.addButton(b, QDialogButtonBox.ActionRole)
b.clicked.connect(self.onAddDeck) qconnect(b.clicked, self.onAddDeck)
if title: if title:
self.setWindowTitle(title) self.setWindowTitle(title)
if not names: if not names:
@ -66,9 +66,9 @@ class StudyDeck(QDialog):
accept or _("Study"), QDialogButtonBox.AcceptRole accept or _("Study"), QDialogButtonBox.AcceptRole
) )
self.setWindowModality(Qt.WindowModal) self.setWindowModality(Qt.WindowModal)
self.form.buttonBox.helpRequested.connect(lambda: openHelp(help)) qconnect(self.form.buttonBox.helpRequested, lambda: openHelp(help))
self.form.filter.textEdited.connect(self.redraw) qconnect(self.form.filter.textEdited, self.redraw)
self.form.list.itemDoubleClicked.connect(self.accept) qconnect(self.form.list.itemDoubleClicked, self.accept)
self.show() self.show()
# redraw after show so position at center correct # redraw after show so position at center correct
self.redraw("", current) self.redraw("", current)

8
qt/aqt/sync.py
View file

@ -44,8 +44,8 @@ class SyncManager(QObject):
auth=auth, auth=auth,
hostNum=self.pm.profile.get("hostNum"), hostNum=self.pm.profile.get("hostNum"),
) )
t._event.connect(self.onEvent) qconnect(t._event, self.onEvent)
t.progress_event.connect(self.on_progress) qconnect(t.progress_event, self.on_progress)
self.label = _("Connecting...") self.label = _("Connecting...")
prog = self.mw.progress.start(immediate=True, label=self.label) prog = self.mw.progress.start(immediate=True, label=self.label)
self.sentBytes = self.recvBytes = 0 self.sentBytes = self.recvBytes = 0
@ -268,8 +268,8 @@ enter your details below."""
vbox.addLayout(g) vbox.addLayout(g)
bb = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) bb = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
bb.button(QDialogButtonBox.Ok).setAutoDefault(True) bb.button(QDialogButtonBox.Ok).setAutoDefault(True)
bb.accepted.connect(d.accept) qconnect(bb.accepted, d.accept)
bb.rejected.connect(d.reject) qconnect(bb.rejected, d.reject)
vbox.addWidget(bb) vbox.addWidget(bb)
d.setLayout(vbox) d.setLayout(vbox)
d.show() d.show()

44
qt/aqt/tagedit.py
View file

@ -18,12 +18,12 @@ class TagEdit(QLineEdit):
self.model = QStringListModel() self.model = QStringListModel()
self.type = type self.type = type
if type == 0: if type == 0:
self.completer = TagCompleter(self.model, parent, self) self.completer_ = TagCompleter(self.model, parent, self)
else: else:
self.completer = QCompleter(self.model, parent) self.completer_ = QCompleter(self.model, parent)
self.completer.setCompletionMode(QCompleter.PopupCompletion) self.completer_.setCompletionMode(QCompleter.PopupCompletion)
self.completer.setCaseSensitivity(Qt.CaseInsensitive) self.completer_.setCaseSensitivity(Qt.CaseInsensitive)
self.setCompleter(self.completer) self.setCompleter(self.completer_)
def setCol(self, col): def setCol(self, col):
"Set the current col, updating list of available tags." "Set the current col, updating list of available tags."
@ -40,26 +40,26 @@ class TagEdit(QLineEdit):
def keyPressEvent(self, evt): def keyPressEvent(self, evt):
if evt.key() in (Qt.Key_Up, Qt.Key_Down): if evt.key() in (Qt.Key_Up, Qt.Key_Down):
# show completer on arrow key up/down # show completer on arrow key up/down
if not self.completer.popup().isVisible(): if not self.completer_.popup().isVisible():
self.showCompleter() self.showCompleter()
return return
if evt.key() == Qt.Key_Tab and evt.modifiers() & Qt.ControlModifier: if evt.key() == Qt.Key_Tab and evt.modifiers() & Qt.ControlModifier:
# select next completion # select next completion
if not self.completer.popup().isVisible(): if not self.completer_.popup().isVisible():
self.showCompleter() self.showCompleter()
index = self.completer.currentIndex() index = self.completer_.currentIndex()
self.completer.popup().setCurrentIndex(index) self.completer_.popup().setCurrentIndex(index)
cur_row = index.row() cur_row = index.row()
if not self.completer.setCurrentRow(cur_row + 1): if not self.completer_.setCurrentRow(cur_row + 1):
self.completer.setCurrentRow(0) self.completer_.setCurrentRow(0)
return return
if evt.key() in (Qt.Key_Enter, Qt.Key_Return): if evt.key() in (Qt.Key_Enter, Qt.Key_Return):
# apply first completion if no suggestion selected # apply first completion if no suggestion selected
selected_row = self.completer.popup().currentIndex().row() selected_row = self.completer_.popup().currentIndex().row()
if selected_row == -1: if selected_row == -1:
self.completer.setCurrentRow(0) self.completer_.setCurrentRow(0)
index = self.completer.currentIndex() index = self.completer_.currentIndex()
self.completer.popup().setCurrentIndex(index) self.completer_.popup().setCurrentIndex(index)
self.hideCompleter() self.hideCompleter()
QWidget.keyPressEvent(self, evt) QWidget.keyPressEvent(self, evt)
return return
@ -80,18 +80,18 @@ class TagEdit(QLineEdit):
gui_hooks.tag_editor_did_process_key(self, evt) gui_hooks.tag_editor_did_process_key(self, evt)
def showCompleter(self): def showCompleter(self):
self.completer.setCompletionPrefix(self.text()) self.completer_.setCompletionPrefix(self.text())
self.completer.complete() self.completer_.complete()
def focusOutEvent(self, evt): def focusOutEvent(self, evt) -> None:
QLineEdit.focusOutEvent(self, evt) QLineEdit.focusOutEvent(self, evt)
self.lostFocus.emit() self.lostFocus.emit() # type: ignore
self.completer.popup().hide() self.completer_.popup().hide()
def hideCompleter(self): def hideCompleter(self):
if sip.isdeleted(self.completer): if sip.isdeleted(self.completer_):
return return
self.completer.popup().hide() self.completer_.popup().hide()
class TagCompleter(QCompleter): class TagCompleter(QCompleter):

4
qt/aqt/taglimit.py
View file

@ -17,11 +17,11 @@ class TagLimit(QDialog):
s = QShortcut( s = QShortcut(
QKeySequence("ctrl+d"), self.dialog.activeList, context=Qt.WidgetShortcut QKeySequence("ctrl+d"), self.dialog.activeList, context=Qt.WidgetShortcut
) )
s.activated.connect(self.dialog.activeList.clearSelection) qconnect(s.activated, self.dialog.activeList.clearSelection)
s = QShortcut( s = QShortcut(
QKeySequence("ctrl+d"), self.dialog.inactiveList, context=Qt.WidgetShortcut QKeySequence("ctrl+d"), self.dialog.inactiveList, context=Qt.WidgetShortcut
) )
s.activated.connect(self.dialog.inactiveList.clearSelection) qconnect(s.activated, self.dialog.inactiveList.clearSelection)
self.rebuildTagList() self.rebuildTagList()
restoreGeom(self, "tagLimit") restoreGeom(self, "tagLimit")
self.exec_() self.exec_()

4
qt/aqt/taskman.py
View file

@ -12,6 +12,8 @@ from typing import Any, Callable, Dict, List, Optional
from PyQt5.QtCore import QObject, pyqtSignal from PyQt5.QtCore import QObject, pyqtSignal
from aqt.qt import qconnect
Closure = Callable[[], None] Closure = Callable[[], None]
@ -23,7 +25,7 @@ class TaskManager(QObject):
self._executor = ThreadPoolExecutor() self._executor = ThreadPoolExecutor()
self._closures: List[Closure] = [] self._closures: List[Closure] = []
self._closures_lock = Lock() self._closures_lock = Lock()
self._closures_pending.connect(self._on_closures_pending) # type: ignore qconnect(self._closures_pending, self._on_closures_pending)
def run_on_main(self, closure: Closure): def run_on_main(self, closure: Closure):
"Run the provided closure on the main thread." "Run the provided closure on the main thread."

22
qt/aqt/utils.py
View file

@ -100,7 +100,7 @@ def showInfo(
b.setDefault(True) b.setDefault(True)
if help: if help:
b = mb.addButton(QMessageBox.Help) b = mb.addButton(QMessageBox.Help)
b.clicked.connect(lambda: openHelp(help)) qconnect(b.clicked, lambda: openHelp(help))
b.setAutoDefault(False) b.setAutoDefault(False)
return mb.exec_() return mb.exec_()
@ -137,7 +137,7 @@ def showText(
QApplication.clipboard().setText(text.toPlainText()) QApplication.clipboard().setText(text.toPlainText())
btn = QPushButton(_("Copy to Clipboard")) btn = QPushButton(_("Copy to Clipboard"))
btn.clicked.connect(onCopy) qconnect(btn.clicked, onCopy)
box.addButton(btn, QDialogButtonBox.ActionRole) box.addButton(btn, QDialogButtonBox.ActionRole)
def onReject(): def onReject():
@ -145,13 +145,13 @@ def showText(
saveGeom(diag, geomKey) saveGeom(diag, geomKey)
QDialog.reject(diag) QDialog.reject(diag)
box.rejected.connect(onReject) qconnect(box.rejected, onReject)
def onFinish(): def onFinish():
if geomKey: if geomKey:
saveGeom(diag, geomKey) saveGeom(diag, geomKey)
box.accepted.connect(onFinish) qconnect(box.accepted, onFinish)
diag.setMinimumHeight(minHeight) diag.setMinimumHeight(minHeight)
diag.setMinimumWidth(minWidth) diag.setMinimumWidth(minWidth)
if geomKey: if geomKey:
@ -257,10 +257,10 @@ class GetTextDialog(QDialog):
b = QDialogButtonBox(buts) b = QDialogButtonBox(buts)
v.addWidget(b) v.addWidget(b)
self.setLayout(v) self.setLayout(v)
b.button(QDialogButtonBox.Ok).clicked.connect(self.accept) qconnect(b.button(QDialogButtonBox.Ok).clicked, self.accept)
b.button(QDialogButtonBox.Cancel).clicked.connect(self.reject) qconnect(b.button(QDialogButtonBox.Cancel).clicked, self.reject)
if help: if help:
b.button(QDialogButtonBox.Help).clicked.connect(self.helpRequested) qconnect(b.button(QDialogButtonBox.Help).clicked, self.helpRequested)
def accept(self): def accept(self):
return QDialog.accept(self) return QDialog.accept(self)
@ -319,7 +319,7 @@ def chooseList(prompt, choices, startrow=0, parent=None):
c.setCurrentRow(startrow) c.setCurrentRow(startrow)
l.addWidget(c) l.addWidget(c)
bb = QDialogButtonBox(QDialogButtonBox.Ok) bb = QDialogButtonBox(QDialogButtonBox.Ok)
bb.accepted.connect(d.accept) qconnect(bb.accepted, d.accept)
l.addWidget(bb) l.addWidget(bb)
d.exec_() d.exec_()
return c.currentRow() return c.currentRow()
@ -366,7 +366,7 @@ def getFile(parent, title, cb, filter="*.*", dir=None, key=None, multi=False):
cb(result) cb(result)
ret.append(result) ret.append(result)
d.accepted.connect(accept) qconnect(d.accepted, accept)
if key: if key:
restoreState(d, key) restoreState(d, key)
d.exec_() d.exec_()
@ -520,7 +520,7 @@ def addCloseShortcut(widg):
if not isMac: if not isMac:
return return
widg._closeShortcut = QShortcut(QKeySequence("Ctrl+W"), widg) widg._closeShortcut = QShortcut(QKeySequence("Ctrl+W"), widg)
widg._closeShortcut.activated.connect(widg.reject) qconnect(widg._closeShortcut.activated, widg.reject)
def downArrow(): def downArrow():
@ -680,7 +680,7 @@ class MenuItem:
def renderTo(self, qmenu): def renderTo(self, qmenu):
a = qmenu.addAction(self.title) a = qmenu.addAction(self.title)
a.triggered.connect(self.func) qconnect(a.triggered, self.func)
def qtMenuShortcutWorkaround(qmenu): def qtMenuShortcutWorkaround(qmenu):

2
qt/aqt/webview.py
View file

@ -268,7 +268,7 @@ class AnkiWebView(QWebEngineView): # type: ignore
def contextMenuEvent(self, evt) -> None: def contextMenuEvent(self, evt) -> None:
m = QMenu(self) m = QMenu(self)
a = m.addAction(_("Copy")) a = m.addAction(_("Copy"))
a.triggered.connect(self.onCopy) # type: ignore qconnect(a.triggered, self.onCopy)
gui_hooks.webview_will_show_context_menu(self, m) gui_hooks.webview_will_show_context_menu(self, m)
m.popup(QCursor.pos()) m.popup(QCursor.pos())

5
qt/mypy.ini
View file

@ -6,7 +6,12 @@ show_error_codes = true
disallow_untyped_decorators = True disallow_untyped_decorators = True
warn_redundant_casts = True warn_redundant_casts = True
warn_unused_configs = True warn_unused_configs = True
#check_untyped_defs = true
[mypy-aqt.forms.*]
check_untyped_defs=false
[mypy-aqt.mpv]
ignore_errors=true
[mypy-win32file] [mypy-win32file]
ignore_missing_imports = True ignore_missing_imports = True
[mypy-win32pipe] [mypy-win32pipe]