def refreshProteinsTableWidget(self) -> None:
search_text = self.proteinsSearchLineEdit.text().strip()
search_mode = self.proteinsSearchTypeComboBox.currentIndex()
if not search_text:
return
if search_mode == 0:
results = self._database.search_proteins_by_name(
search_text, limit=10000, callback=self._progressCallback)
elif search_mode == 1:
results = self._database.search_proteins_by_sequence(
search_text, limit=10000, callback=self._progressCallback)
elif search_mode == 2:
try:
digestion_settings = self._working_digestion_action_group.checkedAction(
).data()
except AttributeError:
results = []
else:
results = self._database.search_proteins_by_peptide_sequence(
search_text,
digestion_settings,
limit=10000,
callback=self._progressCallback)
else:
raise ValueError
self.proteinsTableWidget.setRowCount(0)
self.proteinsTableWidget.setSortingEnabled(False)
try:
for i, protein in enumerate(results):
self.proteinsTableWidget.insertRow(i)
index_item = QTableWidgetItem(str(i + 1).zfill(5))
index_item.setData(TableItemDataRole.ROW_OBJECT, protein)
name_item = QTableWidgetItem(protein.name)
self.proteinsTableWidget.setItem(i, 0, index_item)
self.proteinsTableWidget.setItem(i, 1, name_item)
except ResultsLimitExceededError:
commondialog.informationMessage(
self, 'Your search returns too much results.\n'
'Only the 10000 first results will be displayed.',
dismissable=True)
self.proteinsTableWidget.setSortingEnabled(True)
self.proteinsTableWidget.resizeColumnToContents(-1)
# Change search line edit text color to assure the user the search is done
palette = self.proteinsSearchLineEdit.palette()
if self.proteinsTableWidget.rowCount():
palette.setColor(QPalette.Text, QColor(0, 180, 0))
else:
palette.setColor(QPalette.Text, QColor(180, 0, 0))
self.proteinsSearchLineEdit.setPalette(palette)
def update_list(self):
self.table_widget.clear()
self.table_widget.setHorizontalHeaderLabels([
"Name", "Game", "Status", "Entrants", "Goal", "Info", "Opened At"
])
name_filter = self.filter_name_edit.text().strip()
displayed_status = set()
for (check, status) in self._status_checks:
if check.isChecked():
displayed_status.add(status)
displayed_games = set()
for (check, game) in self._game_checks:
if check.isChecked():
displayed_games.add(game)
visible_races = [
race for race in self.races
if (race.status in displayed_status and name_filter in race.name
and race.game in displayed_games)
]
self.table_widget.setRowCount(len(visible_races))
for i, session in enumerate(visible_races):
name = QTableWidgetItem(session.name)
status = QTableWidgetItem(session.verbose_status)
entrants = QTableWidgetItem(str(session.entrants))
goal = QTableWidgetItem(session.goal)
info = QTableWidgetItem(session.info)
opened_at = QTableWidgetItem(
session.opened_at.astimezone().strftime("%c"))
game_name = QTableWidgetItem(session.game.short_name)
name.setData(Qt.UserRole, session)
self.table_widget.setItem(i, 0, name)
self.table_widget.setItem(i, 1, game_name)
self.table_widget.setItem(i, 2, status)
self.table_widget.setItem(i, 3, entrants)
self.table_widget.setItem(i, 4, goal)
self.table_widget.setItem(i, 5, info)
self.table_widget.setItem(i, 6, opened_at)
self.status_label.setText(
f"{len(self.races)} races total, {len(visible_races)} displayed.")
def refreshPeptidesTableWidget(self) -> None:
selected_items = self.proteinsTableWidget.selectedItems()
selected_protein = selected_items[0].data(
TableItemDataRole.ROW_OBJECT) if selected_items else None
selected_protein_id = selected_protein.id if selected_protein else None
digestion_settings = self._working_digestion_action_group.checkedAction(
).data()
if selected_protein_id and digestion_settings:
results = self.database.search_peptides_by_protein_id(
selected_protein_id,
digestion_settings,
limit=10000,
callback=self._progressCallback)
else:
results = []
self.peptidesTableWidget.setRowCount(0)
self.peptidesTableWidget.setSortingEnabled(False)
try:
for i, peptide in enumerate(results):
self.peptidesTableWidget.insertRow(i)
index_item = QTableWidgetItem(str(i + 1).zfill(5))
index_item.setData(TableItemDataRole.ROW_OBJECT, peptide)
sequence_item = QTableWidgetItem(peptide.sequence)
missed_cleavages_item = QTableWidgetItem(
str(peptide.missed_cleavages))
digest_unique_item = QTableWidgetItem(
'Yes' if peptide.digest_unique else 'No')
sequence_unique_item = QTableWidgetItem(
'Yes' if peptide.sequence_unique else 'No')
self.peptidesTableWidget.setItem(i, 0, index_item)
self.peptidesTableWidget.setItem(i, 1, sequence_item)
self.peptidesTableWidget.setItem(i, 2, missed_cleavages_item)
self.peptidesTableWidget.setItem(i, 3, digest_unique_item)
self.peptidesTableWidget.setItem(i, 4, sequence_unique_item)
except ResultsLimitExceededError:
commondialog.informationMessage(
self, 'Your search returns too much results.\n'
'Only the 10000 first results will be displayed.',
dismissable=True)
self.peptidesTableWidget.setSortingEnabled(True)
self.proteinsTableWidget.resizeColumnToContents(-1)
def update_list(self):
self.table_widget.clear()
self.table_widget.setHorizontalHeaderLabels([
"Name", "State", "Players", "Password?", "Creator", "Creation Date"
])
name_filter = self.filter_name_edit.text().strip()
displayed_has_password = set()
if self.has_password_yes_check.isChecked():
displayed_has_password.add(True)
if self.has_password_no_check.isChecked():
displayed_has_password.add(False)
displayed_states = set()
for (check, state) in ((self.state_setup_check,
GameSessionState.SETUP),
(self.state_inprogress_check,
GameSessionState.IN_PROGRESS),
(self.state_finished_check,
GameSessionState.FINISHED)):
if check.isChecked():
displayed_states.add(state)
dont_filter_age = not self.filter_age_check.isChecked()
now = datetime.datetime.now(tz=datetime.timezone.utc)
max_session_age = datetime.timedelta(days=self.filter_age_spin.value())
visible_sessions = [
session for session in reversed(self.sessions)
if (session.has_password in displayed_has_password and session.
state in displayed_states and name_filter in session.name and (
dont_filter_age or
(now - session.creation_date) < max_session_age))
]
self.visible_sessions = visible_sessions
self.table_widget.setRowCount(len(visible_sessions))
for i, session in enumerate(visible_sessions):
name = QTableWidgetItem(session.name)
state = QTableWidgetItem(session.state.user_friendly_name)
players_item = QTableWidgetItem(str(session.num_players))
has_password = QTableWidgetItem(
"Yes" if session.has_password else "No")
creator = QTableWidgetItem(session.creator)
creation_date = QTableWidgetItem(
session.creation_date.astimezone().strftime("%Y-%m-%d %H:%M"))
name.setData(Qt.UserRole, session)
self.table_widget.setItem(i, 0, name)
self.table_widget.setItem(i, 1, state)
self.table_widget.setItem(i, 2, players_item)
self.table_widget.setItem(i, 3, has_password)
self.table_widget.setItem(i, 4, creator)
self.table_widget.setItem(i, 5, creation_date)
for i in range(6):
self.table_widget.resizeColumnToContents(i)
self.status_label.setText(
f"{len(self.sessions)} sessions total, {len(visible_sessions)} displayed."
)
def refreshSubProteinsTableWidget(self) -> None:
selected_items = self.peptidesTableWidget.selectedItems()
selected_peptide = selected_items[0].data(
TableItemDataRole.ROW_OBJECT) if selected_items else None
selected_peptide_id = selected_peptide.id if selected_peptide else None
selected_peptide_sequence = selected_peptide.sequence if selected_peptide else None
digestion_settings = self._working_digestion_action_group.checkedAction(
).data()
by_id_results_ids_set = set()
limit_reached = False
self.subProteinsTableWidget.setRowCount(0)
self.subProteinsTableWidget.setSortingEnabled(False)
if selected_peptide_id:
by_id_results = self.database.search_proteins_by_peptide_id(
selected_peptide_id,
digestion_settings,
limit=10000,
callback=self._progressCallback)
else:
by_id_results = []
try:
for i, protein in enumerate(by_id_results):
self.subProteinsTableWidget.insertRow(i)
index_item = QTableWidgetItem(str(i + 1).zfill(5))
index_item.setData(TableItemDataRole.ROW_OBJECT, protein)
name_item = QTableWidgetItem(protein.name)
origin_item = QTableWidgetItem('by digest')
self.subProteinsTableWidget.setItem(i, 0, index_item)
self.subProteinsTableWidget.setItem(i, 1, name_item)
self.subProteinsTableWidget.setItem(i, 2, origin_item)
by_id_results_ids_set.add(protein.id)
except ResultsLimitExceededError:
commondialog.informationMessage(
self, 'Your search returns too much results.\n'
'Only the 10000 first results will be displayed.',
dismissable=True)
limit_reached = True
if selected_peptide_sequence and not limit_reached:
by_sequence_results = self.database.search_proteins_by_sequence(
selected_peptide_sequence,
limit=10000,
callback=self._progressCallback)
else:
by_sequence_results = []
try:
for i, protein in enumerate(
(filtered_protein for filtered_protein in by_sequence_results
if filtered_protein.id not in by_id_results_ids_set),
start=len(by_id_results_ids_set)):
self.subProteinsTableWidget.insertRow(i)
index_item = QTableWidgetItem(str(i + 1).zfill(5))
index_item.setData(TableItemDataRole.ROW_OBJECT, protein)
name_item = QTableWidgetItem(protein.name)
origin_item = QTableWidgetItem('by sequence')
self.subProteinsTableWidget.setItem(i, 0, index_item)
self.subProteinsTableWidget.setItem(i, 1, name_item)
self.subProteinsTableWidget.setItem(i, 2, origin_item)
except ResultsLimitExceededError:
commondialog.informationMessage(
self, 'Your search returns too much by_id_results.\n'
'Only the 10000 first results will be displayed.',
dismissable=True)
self.subProteinsTableWidget.setSortingEnabled(True)
self.subProteinsTableWidget.resizeColumnToContents(-1)
app = QApplication(sys.argv)
# Create and populate the tableWidget
tableWidget = QTableWidget(4, 4)
tableWidget.setItemDelegate(StarDelegate())
tableWidget.setEditTriggers(QAbstractItemView.DoubleClicked
| QAbstractItemView.SelectedClicked)
tableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
tableWidget.setHorizontalHeaderLabels(
["Title", "Genre", "Artist", "Rating"])
data = [["Mass in B-Minor", "Baroque", "J.S. Bach", 5],
["Three More Foxes", "Jazz", "Maynard Ferguson", 4],
["Sex Bomb", "Pop", "Tom Jones", 3],
["Barbie Girl", "Pop", "Aqua", 5]]
for r in range(len(data)):
tableWidget.setItem(r, 0, QTableWidgetItem(data[r][0]))
tableWidget.setItem(r, 1, QTableWidgetItem(data[r][1]))
tableWidget.setItem(r, 2, QTableWidgetItem(data[r][2]))
item = QTableWidgetItem()
item.setData(0, StarRating(data[r][3]).starCount)
tableWidget.setItem(r, 3, item)
tableWidget.resizeColumnsToContents()
tableWidget.resize(500, 300)
tableWidget.show()
sys.exit(app.exec_())
async def validateUrl(self, url: str) -> bool:
self.download.setDisabled(True)
self.files.setDisabled(True)
self.files.clearSelection()
self.files.clearFocus()
self.files.clearContents()
self.files.setRowCount(0)
self.files.setSortingEnabled(False)
self.url.setStyleSheet('')
self.modId = 0
if not url:
self.urlInfo.setText('''
<font color="#888">Please enter a valid mod url.</font>
''')
return False
modId = getModId(url)
if not modId:
self.files.setDisabled(True)
self.url.setStyleSheet('''
*{
border: 1px solid #B22222;
padding: 1px 0px;
}
''')
self.urlInfo.setText('''
<font color="#888">Please enter a valid mod url.</font>
''')
return False
self.urlInfo.setText('🌐')
try:
filesResponse = await getModFiles(modId)
except (RequestError, ResponseError, Exception) as e:
self.url.setStyleSheet('''
*{
border: 1px solid #B22222;
padding: 1px 0px;
}
''')
self.urlInfo.setText(f'''
<font color="#888">Could not get mod files: {e}.</font>
''')
return False
try:
files = filesResponse['files']
if not len(files):
self.urlInfo.setText(f'''
<font color="#888">Mod "{modId}" has no files!</font>
''')
return False
self.files.setRowCount(len(files))
for i in range(len(files)):
file = files[i]
fileid = int(file['file_id'])
name = str(file['name'])
version = str(file['version'])
_uploadtime = dateparser.parse(file['uploaded_time'])
uploadtime = _uploadtime.astimezone(tz=None).strftime(
'%Y-%m-%d %H:%M:%S') if _uploadtime else '?'
description = html.unescape(str(file['description']))
nameItem = QTableWidgetItem(name)
nameItem.setToolTip(name)
nameItem.setData(Qt.UserRole, fileid)
self.files.setItem(i, 0, nameItem)
versionItem = QTableWidgetItem(version)
versionItem.setToolTip(version)
self.files.setItem(i, 1, versionItem)
uploadtimeItem = QTableWidgetItem(uploadtime)
uploadtimeItem.setToolTip(uploadtime)
self.files.setItem(i, 2, uploadtimeItem)
descriptionItem = QTableWidgetItem(description)
descriptionItem.setToolTip(description)
self.files.setItem(i, 3, descriptionItem)
except KeyError as e:
logger.exception(
f'Could not find key "{str(e)}" in mod files response')
self.urlInfo.setText(f'''
<font color="#888">Could not find key "{str(e)}" in mod files response.</font>
''')
return False
self.urlInfo.setText(f'''
<font color="#888">Found {len(files)} available files.</font>
''')
self.files.resizeColumnsToContents()
self.files.setDisabled(False)
self.files.setSortingEnabled(True)
self.modId = modId
return True