def insertRound(self, r):
winner = r.getWinner()
i = r.getNumRound() - 1
self.insertRow(i)
hands = self.engine.getHands(r.getNumRound())
direction = self.engine.getDirection(r.getNumRound())
hitem = QTableWidgetItem("{} {}".format(hands,
i18n("PochaWidget", direction)))
self.setVerticalHeaderItem(i, hitem)
for j, player in enumerate(self.engine.getListPlayers()):
item = QTableWidgetItem()
item.setFlags(item.flags() ^ QtCore.Qt.ItemIsEditable)
item.setTextAlignment(QtCore.Qt.AlignVCenter |
QtCore.Qt.AlignCenter)
score = r.getPlayerScore(player)
if score > 0:
background = self.bgcolors[0]
else:
background = self.bgcolors[1]
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
text = str(score)
if player == winner:
text += i18n("PochaRoundTable", " (Winner)")
item.setText(text)
self.setItem(i, j, item)
self.scrollToBottom()
def post_alert(self, id, msg, quiet=False):
if id in self.__hidden_uavs:
return #don't post alerts on UAVs I've said I don't care about
if id not in self.__alerts:
self.__alerts[id] = {}
self.__alerts[id]["time"] = time.time()
if "alerts" not in self.__alerts[id]:
self.__alerts[id]["alerts"] = []
if msg not in self.__alerts[id]["alerts"]:
self.__alerts[id]['alerts'].append(msg)
if quiet is False:
self.__speech.say(msg + " alert on " + str(id))
#already have alerts for this UAV?
if 'row' in self.__alerts[id]:
row = self.__alerts[id]['row']
else:
#put alert in alert table
self.__ui.tbl_alerts.insertRow(self.__ui.tbl_alerts.rowCount())
row = self.__ui.tbl_alerts.rowCount()-1
next_item = QTableWidgetItem()
next_item.setData(Qt.DisplayRole, id)
self.__ui.tbl_alerts.setItem(row, self.__ALRT_ID_COL, next_item)
self.__ui.tbl_alerts.setItem(row, self.__ALRT_MSGS_COL,
QTableWidgetItem())
self.__alerts[id]['row'] = row
self.__ui.tbl_alerts.item(row, self.__ALRT_MSGS_COL).setText(
",".join(self.__alerts[id]["alerts"]))
def drawDataTable(self,tab): # Called when user switches tabWidget to the Table Preview
if tab != 1 or self.needsRedraw == False: return
fields = self.fields
self.dataTable.clear()
self.repaint()
self.dataTable.setColumnCount(len(fields))
self.dataTable.setRowCount(self.provider.featureCount())
header = []
for i in fields.values():
header.append(i.name())
self.dataTable.setHorizontalHeaderLabels(header)
formatting = True
if formatting: # slower procedure, with formatting the table items
for i in range(len(self.data)):
for j in range(len(self.data[i])):
item = QTableWidgetItem(unicode(self.data[i][j] or 'NULL'))
item.setFlags(Qt.ItemIsSelectable)
if fields[i].type() == 6 or fields[i].type() == 2:
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.dataTable.setItem(j,i,item)
else: # about 25% faster procedure, without formatting
for i in range(len(self.data)):
for j in range(len(self.data[i])):
self.dataTable.setItem(j,i,QTableWidgetItem(unicode(self.data[i][j] or 'NULL')))
self.dataTable.resizeColumnsToContents()
self.needsRedraw = False
def addClicked(self, fileNames):
"""Fill the playlist with fileNames' info."""
if fileNames is None:
return
self.playlistTable.setSortingEnabled(False)
songsToAdd = len(fileNames)
for name, row in zip(fileNames, range(songsToAdd)):
currentRow = row + self.playlist.mediaCount() - songsToAdd
self.playlistTable.insertRow(currentRow)
artist = self.playerCore.getArtist(name)[0]
title = self.playerCore.getTitle(name)[0]
album = self.playerCore.getAlbum(name)[0]
seconds = self.playerCore.getDuration(name)
duration = QTime(0, seconds // 60, seconds % 60)
duration = duration.toString('mm:ss')
rowInfo = [artist, title, album, duration]
for info, index in zip(rowInfo, range(4)):
cell = QTableWidgetItem(info)
self.playlistTable.setItem(currentRow, index, cell)
font = QFont(info, weight=QFont.Normal)
cell.setFont(font)
cell.setTextAlignment(Qt.AlignCenter)
self.playlistTable.setSortingEnabled(True)
for index in range(4):
self.playlistTable.resizeColumnToContents(index)
def setmydata(self):
for row in range(0,16):
for col in range(0,4):
newitem = QTableWidgetItem(str("row %1, col %2")) #,row+1,col+1))
if row == 0 and col == 0:
newitem.setText("click me")
self.setItem(row, col, newitem)
def __init__(self, item, assets=None):
is_empty = (item is None or
assets is None or
"name" not in item)
if is_empty:
# empty slot
self.item = None
QTableWidgetItem.__init__(self)
return
self.assets = assets
self.item = item
QTableWidgetItem.__init__(self, self.item["name"])
self.setTextAlignment(QtCore.Qt.AlignCenter)
name = self.item["name"]
try:
asset_name = assets.items().get_item(name)[3]
if asset_name != "":
name = asset_name
except TypeError:
pass
self.setToolTip(name + " (" + str(self.item["count"]) + ")")
icon = inv_icon(self.item["name"], self.item["parameters"], assets)
try:
self.setIcon(QtGui.QIcon(icon))
except TypeError:
pass
if type(icon) is QPixmap:
self.setText("")
def __init__(self, hitem):
super().__init__()
assert isinstance(hitem, pewnet.HenItem)
self.item = hitem
url = self.item.gallery_url
self.profile_item = QTableWidgetItem(self.item.name)
self.profile_item.setToolTip(url)
def set_profile(item):
self.profile_item.setIcon(QIcon(item.thumb))
self.item.thumb_rdy.connect(set_profile)
# status
self.status_item = QTableWidgetItem('Downloading...')
self.status_item.setToolTip(url)
def set_finished(item):
self.status_item.setText('Finished downloading!')
self.d_item_ready.emit(self)
self.item.file_rdy.connect(set_finished)
# other
self.cost_item = QTableWidgetItem(self.item.cost)
self.cost_item.setToolTip(url)
self.size_item = QTableWidgetItem(self.item.size)
self.size_item.setToolTip(url)
type = 'Archive' if hitem.download_type == 0 else 'Torrent'
self.type_item = QTableWidgetItem(type)
self.type_item.setToolTip(url)
def _patchBinary(self):
"""
Exports the current function code, ascii hex encoded
This is useful to import into tools like miasm and alike
"""
self._console_output("Patching the original binary...")
pl = patch_binary()
if not pl:
self._console_output("[!] No bytes to patch", err = True)
return
self.table.setColumnCount(3)
self.table.setHorizontalHeaderLabels(
('File offset', 'Original', 'Patched'))
self.table_label.setText("Patched bytes exported to file")
self.table.clearContents()
self.table.setRowCount(0)
# Fill with contents
for idx, (fpos, o, p) in enumerate(pl):
self.table.insertRow(idx)
fpos_item = QTableWidgetItem("%x" % fpos)
fpos_item.setFlags(fpos_item.flags() ^ QtCore.Qt.ItemIsEditable)
orig_item = QTableWidgetItem("%x" % o)
patch_item = QTableWidgetItem("%x" % p)
self.table.setItem(idx, 0, fpos_item)
self.table.setItem(idx, 1, orig_item)
self.table.setItem(idx, 2, patch_item)
self._console_output("Done patching. Look in the same directory as the original for a .patched file")
def set_table_info(self):
self.table_widget.setSortingEnabled(False)
self.table_items = my_sql.sql_select(self.query_table_select)
if "mysql.connector.errors" in str(type(self.table_items)):
QMessageBox.critical(self, "Ошибка sql получение таблицы", self.table_items.msg, QMessageBox.Ok)
return False
self.table_widget.clearContents()
self.table_widget.setRowCount(0)
if not self.table_items:
return False
for table_typle in self.table_items:
self.table_widget.insertRow(self.table_widget.rowCount())
for column in range(2, len(table_typle)):
item = QTableWidgetItem(str(table_typle[column]))
item.setData(5, table_typle[0])
self.table_widget.setItem(self.table_widget.rowCount() - 1, column - 2, item)
self.table_widget.setSortingEnabled(True)
try:
item = self.tree_widget.currentItem()
if item.data(0, 5) >= 0: # Проверка не выбрано ли показать все!
self.ui_sorting(item)
except:
pass
if self.select_item:
self.open_id(self.select_item)
self.select_item = None
def updateZoneOccupationTableRow(self, zone, tableItems=None):
if (tableItems == None):
tableItems = []
for i in range(2):
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
tableItems.append(item)
self.zoTable.insertRow(0)
self.zoTable.setItem(0, 0, tableItems[0])
self.zoTable.setItem(0, 1, tableItems[1])
tableItems[0].setText(zone.name)
tableItems[0].setData(5, zone.xmlId)
wearablesPresent = ""
firstOneFlag = True
signalDataList = zone.wearablesInZone.items()
counter = 0
for wearbleId, signalData in signalDataList:
wearable = self.systemState.getHardwareObjectByHwId(TID_W, wearbleId)
if (not signalData.isInZone):
continue
counter += 1
if (firstOneFlag):
firstOneFlag = False
else:
wearablesPresent = wearablesPresent + ", "
wearablesPresent = wearablesPresent + wearable.name
if (counter == 0):
wearablesPresent = "[none]"
tableItems[1].setText(wearablesPresent)
def __init__(self, hitem):
super().__init__()
assert isinstance(hitem, pewnet.HenItem)
self.d_item_ready.connect(self.done)
self.item = hitem
url = self.item.gallery_url
self.profile_item = QTableWidgetItem(self.item.name)
self.profile_item.setData(Qt.UserRole+1, hitem)
self.profile_item.setToolTip(url)
def set_profile(item):
self.profile_item.setIcon(QIcon(item.thumb))
self.item.thumb_rdy.connect(set_profile)
# status
self.status_item = QTableWidgetItem('In queue...')
self.status_item.setToolTip(url)
def set_finished(item):
self.status_item.setText('Finished!')
self.d_item_ready.emit(self)
self.item.file_rdy.connect(set_finished)
# other
self.cost_item = QTableWidgetItem(self.item.cost)
self.cost_item.setToolTip(url)
self.size_item = QTableWidgetItem(self.item.size)
self.size_item.setToolTip(url)
type = 'Archive' if hitem.download_type == 0 else 'Torrent'
self.type_item = QTableWidgetItem(type)
self.type_item.setToolTip(url)
self.status_timer = QTimer()
self.status_timer.timeout.connect(self.check_progress)
self.status_timer.start(500)
def get_library(self):
self.clean_table()
r = server.getServer('musics/', {'token':session_lib.get_token()})
if len(r['payload']['musics']) == 0:
self.clean_table()
else:
self.tableWidget.setRowCount(len(r['payload']['musics']))
self.tableWidget.setColumnCount(1)
self.tableWidget.setHorizontalHeaderLabels(['Musica'])
self.tableWidget.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
self.tableWidget.horizontalHeader().setStretchLastSection(True)
self.tableWidget.cellDoubleClicked.connect(self.select_music)
i = 0
self.musics_in_current_playlist_by_index = {}
for music in r['payload']['musics']:
self.musics_in_current_playlist_by_index[i] = {
'id': music['id'], 'file_name': music['file_name'],
'name': music['name']
}
musica = QTableWidgetItem(music['name'])
file_path = QTableWidgetItem(music['file_name'])
musica.setFlags(musica.flags() & ~Qt.ItemIsEditable)
self.tableWidget.setItem(i, 0, musica)
self.tableWidget.setItem(i, 1, file_path)
i+=1
def ui_calc(self):
query = """SELECT pack.Cut_Id, pack.Number, CONCAT(product_article.Article, ' (', product_article_size.Size, ') [', product_article_parametrs.Name, ']'),
clients.Name, pack.Date_Make
FROM pack LEFT JOIN clients ON pack.Client_Id = clients.Id
LEFT JOIN product_article_parametrs ON pack.Article_Parametr_Id = product_article_parametrs.Id
LEFT JOIN product_article_size ON product_article_parametrs.Product_Article_Size_Id = product_article_size.Id
LEFT JOIN product_article ON product_article_size.Article_Id = product_article.Id
WHERE pack.Date_Make >= %s AND pack.Date_Make <= %s"""
sql_info = my_sql.sql_select(query, (self.de_date_from.date().toString(Qt.ISODate), self.de_date_to.date().toString(Qt.ISODate)))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получения принятых пачек", sql_info.msg, QMessageBox.Ok)
return False
self.tableWidget.clearContents()
self.tableWidget.setRowCount(0)
if not sql_info:
return False
for table_typle in sql_info:
self.tableWidget.insertRow(self.tableWidget.rowCount())
for column in range(len(table_typle)):
if isinstance(table_typle[column], datetime.date):
text = table_typle[column].strftime("%d.%m.%Y")
else:
text = str(table_typle[column])
item = QTableWidgetItem(text)
item.setData(5, table_typle[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, column , item)
def set_table_widget(self):
header_text_list = ['case_id', 'case名称', '设备id', '开始时间', '结束时间', '运行结果']
row_count = len(self.task_records) if self.task_records else 0
column_count = len(header_text_list)
self.report_table_widget.setColumnCount(column_count)
self.report_table_widget.setRowCount(row_count)
self.report_table_widget.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.report_table_widget.horizontalHeader().setStyleSheet("QHeaderView::section{background: #ECF5FF;}")
for column in range(0, self.report_table_widget.columnCount()):
table_header_item = QTableWidgetItem(header_text_list[column])
table_header_item.setFont(QFont("Roman times", 12, QFont.Bold))
self.report_table_widget.setHorizontalHeaderItem(column, table_header_item)
if self.task_records:
for i, report in enumerate(self.task_records):
case_id = str(report.case_id) if report.case_id else ''
case_name = report.case.name if report.case else ''
self.report_table_widget.setItem(i, 0, QTableWidgetItem(case_id))
self.report_table_widget.setItem(i, 1, QTableWidgetItem(case_name))
self.report_table_widget.setItem(i, 2, QTableWidgetItem(report.device_id))
self.report_table_widget.setItem(i, 3,
QTableWidgetItem(report.start_time.strftime("%Y-%m-%d %H:%M:%S")))
self.report_table_widget.setItem(i, 4,
QTableWidgetItem(report.end_time.strftime("%Y-%m-%d %H:%M:%S")))
status = '成功' if report.status == 0 else '失败'
self.report_table_widget.setItem(i, 5, QTableWidgetItem(status))
self.report_table_widget.cellClicked.connect(self.cell_clicked)
self.report_table_widget.resizeColumnsToContents() # Adjust the width according to the content
self.report_table_widget.horizontalHeader().setStretchLastSection(True)
def updateFormatsTable(self, mimeData=None):
self.formatsTable.setRowCount(0)
if mimeData is None:
return
for format in mimeData.formats():
formatItem = QTableWidgetItem(format)
formatItem.setFlags(Qt.ItemIsEnabled)
formatItem.setTextAlignment(Qt.AlignTop | Qt.AlignLeft)
if format == 'text/plain':
text = mimeData.text().strip()
elif format == 'text/html':
text = mimeData.html().strip()
elif format == 'text/uri-list':
text = " ".join([url.toString() for url in mimeData.urls()])
else:
text = " ".join(["%02X" % ord(datum) for datum in mimeData.data(format)])
row = self.formatsTable.rowCount()
self.formatsTable.insertRow(row)
self.formatsTable.setItem(row, 0, QTableWidgetItem(format))
self.formatsTable.setItem(row, 1, QTableWidgetItem(text))
self.formatsTable.resizeColumnToContents(0)
def __init__(self, item, assets=None):
if item is None or assets is None or "name" not in item:
# empty slot
self.item = None
QTableWidgetItem.__init__(self)
return
self.item = item
QTableWidgetItem.__init__(self, self.item["name"])
self.setTextAlignment(QtCore.Qt.AlignCenter)
name = self.item["name"]
if "shortdescription" in self.item["data"]:
name = self.item["data"]["shortdescription"]
else:
try:
asset_name = assets.items().get_item(name)[3]
if asset_name != "":
name = asset_name
except TypeError:
pass
self.setToolTip(name + " (" + str(self.item["count"]) + ")")
icon = inv_icon(self.item["name"])
try:
self.setIcon(QtGui.QIcon(icon))
except TypeError:
pass
if type(icon) is QPixmap:
self.setText("")
def fill_doc_table(self):
self.doc_table_widget.setRowCount(0)
self.doc_table_widget.setColumnCount(5)
header = ["Char", "Arity", "Starts", "Mnemonic", "Details"]
self.doc_table_widget.setHorizontalHeaderLabels(header)
filter_text = self.find_line_edit.text()
if not filter_text:
filtered = self.doc_items
if len(filter_text) == 1 or (len(filter_text) == 2 and filter_text[0] == "."):
filtered = [line for line in self.doc_items if line[0].lower() == filter_text.lower()]
else:
filtered = [line for line in self.doc_items if any(filter_text.lower() in item.lower() for item in line)]
self.doc_table_widget.setRowCount(len(filtered))
for row, items in enumerate(filtered):
for column, item in enumerate(items):
if len(item) > 40:
item = self.split_sentence(item, 40)
table_widget_item = QTableWidgetItem(item)
if column < 4:
table_widget_item.setTextAlignment(QtCore.Qt.AlignCenter)
self.doc_table_widget.setItem(row, column, table_widget_item)
self.doc_table_widget.resizeRowsToContents()
def _showConnectedIO(self):
"""
Shows a list of functions dealing with IO and
connected to the current function
"""
self._console_output("Calculating file & network IO...")
io_list = self.ba.input_to_function()
if not io_list:
self._console_output("[!] No (obvious) IO connecting to this function",
err = True)
return
self.table.setColumnCount(2)
self.table.setHorizontalHeaderLabels(("Caller", "Name"))
self.table_label.setText("Connected IO")
self.table.clearContents()
self.table.setRowCount(0)
for idx, caller in enumerate(io_list):
self.table.insertRow(idx)
addr_item = QTableWidgetItem("%08x" % caller)
addr_item.setFlags(addr_item.flags() ^ QtCore.Qt.ItemIsEditable)
name_item = QTableWidgetItem("%s" % misc.get_function_name(caller))
self.table.setItem(idx, 0, addr_item)
self.table.setItem(idx, 1, name_item)
def set_table_widget(self):
header_text_list = ['id', '开始时间', '结束时间', '总数', '通过数', '失败数']
self.task_record_statses = get_task_record_stats()
row_count = len(self.task_record_statses) if self.task_record_statses else 0
column_count = len(header_text_list)
self.event_table_widget.setColumnCount(column_count)
self.event_table_widget.setRowCount(row_count)
self.event_table_widget.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.event_table_widget.horizontalHeader().setStyleSheet("QHeaderView::section{background: #ECF5FF;}")
for column in range(0, self.event_table_widget.columnCount()):
table_header_item = QTableWidgetItem(header_text_list[column])
table_header_item.setFont(QFont("Roman times", 12, QFont.Bold))
self.event_table_widget.setHorizontalHeaderItem(column, table_header_item)
if self.task_record_statses:
for i, task_record_stats in enumerate(self.task_record_statses):
self.event_table_widget.setItem(i, 0, QTableWidgetItem(str(task_record_stats.id)))
self.event_table_widget.setItem(i, 1, QTableWidgetItem(
task_record_stats.start_time.strftime("%Y-%m-%d %H:%M:%S")))
self.event_table_widget.setItem(i, 2, QTableWidgetItem(
task_record_stats.end_time.strftime("%Y-%m-%d %H:%M:%S")))
self.event_table_widget.setItem(i, 3, QTableWidgetItem(str(task_record_stats.total_count)))
self.event_table_widget.setItem(i, 4, QTableWidgetItem(str(task_record_stats.pass_count)))
self.event_table_widget.setItem(i, 5, QTableWidgetItem(str(task_record_stats.fail_count)))
self.event_table_widget.cellClicked.connect(self.cell_clicked)
self.event_table_widget.resizeColumnsToContents() # Adjust the width according to the content
self.event_table_widget.horizontalHeader().setStretchLastSection(True)
def _showMostReferenced(self):
"""
Shows the most referenced functions.
"""
self._console_output("Calculating most referenced functions...")
self.table_label.setText("Most referenced functions")
most_referenced = self.ba.most_referenced_functions()
self.table.setColumnCount(3)
self.table.setHorizontalHeaderLabels(("Address", "References", "Name"))
self.table.clearContents()
self.table.setRowCount(0)
idx = 0
# Fill with contents
for f_ea, (ref_nr, ref_name) in most_referenced:
self.table.insertRow(idx)
addr_item = QTableWidgetItem("%x" % f_ea)
addr_item.setFlags(addr_item.flags() ^ QtCore.Qt.ItemIsEditable)
ref_item = cw.NumQTableWidgetItem("%d" % ref_nr)
name_item = QTableWidgetItem(ref_name)
self.table.setItem(idx, 0, addr_item)
self.table.setItem(idx, 1, ref_item)
self.table.setItem(idx, 2, name_item)
idx += 1
def _markImmCompares(self):
"""
Marks the immediate compares within the current function
"""
self.output_window.append("Marking all immediate compares...")
self.table_label.setText("Immediate compares within current function")
ins_color = 0x2020c0
self.table.setColumnCount(2)
self.table.setHorizontalHeaderLabels(("Address", "Disassembly"))
self.table.clearContents()
self.table.setRowCount(0)
idx = 0
for cmp_ea, dis in self.ba.find_imm_compares():
self.table.insertRow(idx)
addr_item = QTableWidgetItem("%x" % cmp_ea)
addr_item.setFlags(addr_item.flags() ^ QtCore.Qt.ItemIsEditable)
dis_item = cw.NumQTableWidgetItem("%s" % dis)
self.table.setItem(idx, 0, addr_item)
self.table.setItem(idx, 1, dis_item)
misc.set_ins_color(cmp_ea, ins_color)
idx += 1
def readPreferences(self):
self.qs.beginGroup("Preferences")
self.honeycomb_rows = self.qs.value("honeycomb_rows", slicestyles.HONEYCOMB_PART_MAXROWS)
self.honeycomb_cols = self.qs.value("honeycomb_cols", slicestyles.HONEYCOMB_PART_MAXCOLS)
self.honeycomb_steps = self.qs.value("honeycomb_steps", slicestyles.HONEYCOMB_PART_MAXSTEPS)
self.square_rows = self.qs.value("square_rows", slicestyles.SQUARE_PART_MAXROWS)
self.square_cols = self.qs.value("square_cols", slicestyles.SQUARE_PART_MAXCOLS)
self.square_steps = self.qs.value("square_steps", slicestyles.SQUARE_PART_MAXSTEPS)
self.auto_scaf_index = self.qs.value("autoScaf", styles.PREF_AUTOSCAF_INDEX)
self.startup_tool_index = self.qs.value("startup_tool", styles.PREF_STARTUP_TOOL_INDEX)
self.zoom_speed = self.qs.value("zoom_speed", styles.PREF_ZOOM_SPEED)
self.zoom_on_helix_add = self.qs.value("zoom_on_helix_add", styles.PREF_ZOOM_AFTER_HELIX_ADD)
self.qs.endGroup()
self.ui_prefs.honeycomb_rows_spin_box.setProperty("value", self.honeycomb_rows)
self.ui_prefs.honeycomb_cols_spin_box.setProperty("value", self.honeycomb_cols)
self.ui_prefs.honeycomb_steps_spin_box.setProperty("value", self.honeycomb_steps)
self.ui_prefs.square_rows_spin_box.setProperty("value", self.square_rows)
self.ui_prefs.square_cols_spin_box.setProperty("value", self.square_cols)
self.ui_prefs.square_steps_spin_box.setProperty("value", self.square_steps)
self.ui_prefs.auto_scaf_combo_box.setCurrentIndex(self.auto_scaf_index)
self.ui_prefs.default_tool_combo_box.setCurrentIndex(self.startup_tool_index)
self.ui_prefs.zoom_speed_slider.setProperty("value", self.zoom_speed)
ptw = self.ui_prefs.plugin_table_widget
loaded_plugin_paths = util.loadedPlugins.keys()
ptw.setRowCount(len(loaded_plugin_paths))
for i in range(len(loaded_plugin_paths)):
row = QTableWidgetItem(loaded_plugin_paths[i])
row.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
ptw.setItem(i, 0, row)
def refresh_table(self):
self._manual_change = True
self._custom_fields = list(
self._configuration.scheduler_info.data.keys())
labels = self._header + self._custom_fields
self.setRowCount(len(labels))
self.setVerticalHeaderLabels(labels)
self.horizontalHeader().setStretchLastSection(False)
header = self.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.Stretch)
header.setSectionResizeMode(1, QHeaderView.Interactive)
#header.setSectionResizeMode(2, QHeaderView.Interactive)
self.horizontalHeader().hide()
combo = QComboBox()
combo.addItems(['Custom scheduler...'] + list(get_schedulers()))
self.setCellWidget(0, 0, combo)
self.setSpan(0, 0, 1, 2)
name = self._configuration.scheduler_info.filename
scheduler_item = QTableWidgetItem(name and os.path.relpath(
name, self._configuration.cur_dir))
scheduler_item.setFlags(scheduler_item.flags() ^ (Qt.ItemIsEditable))
self.setItem(1, 0, scheduler_item)
self._btn_open = QPushButton(self)
self._btn_open.setText('Open')
self._btn_open.clicked.connect(self._open_scheduler)
self.setCellWidget(1, 1, self._btn_open)
combo.currentIndexChanged['QString'].connect(self._select_scheduler)
if self._configuration.scheduler_info.clas:
i = combo.findText(self._configuration.scheduler_info.clas)
if i <= 0:
i = 0
combo.setCurrentIndex(i)
self.setItem(
2, 0, QTableWidgetItem(str(
self._configuration.scheduler_info.overhead))
)
self.setSpan(2, 0, 1, 2)
self.setItem(
3, 0, QTableWidgetItem(str(
self._configuration.scheduler_info.overhead_activate))
)
self.setSpan(3, 0, 1, 2)
self.setItem(
4, 0, QTableWidgetItem(str(
self._configuration.scheduler_info.overhead_terminate))
)
self.setSpan(4, 0, 1, 2)
i = 5
for name, value in self._configuration.scheduler_info.data.items():
self.setItem(i, 0, QTableWidgetItem(str(value)))
self.setSpan(i, 0, 1, 2)
i += 1
def set_table_info(self):
self.table_items = my_sql.sql_select(self.query_table_select)
if "mysql.connector.errors" in str(type(self.table_items)):
QMessageBox.critical(self, "Ошибка sql получение таблицы", self.table_items.msg, QMessageBox.Ok)
return False
if not self.table_items:
self.table_widget.clearContents()
self.table_widget.setRowCount(0)
return False
self.table_widget.clearContents()
self.table_widget.setRowCount(0)
for table_typle in self.table_items:
self.table_widget.insertRow(self.table_widget.rowCount())
if table_typle[3] > 0:
color = QBrush(QColor(150, 255, 161, 255))
else:
color = QBrush(QColor(252, 141, 141, 255))
for column in range(1, len(table_typle)):
if isinstance(table_typle[column], Decimal):
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(table_typle[column]))
elif isinstance(table_typle[column], datetime.date):
text = table_typle[column].strftime("%d.%m.%Y")
else:
text = str(table_typle[column])
item = QTableWidgetItem(text)
item.setData(5, table_typle[0])
item.setBackground(color)
self.table_widget.setItem(self.table_widget.rowCount() - 1, column - 1, item)
def update(self, checked=False, labels=None, custom_labels=None):
"""Use this function when we make changes to the list of labels or when
we load a new dataset.
Parameters
----------
checked : bool
argument from clicked.connect
labels : list of str
list of labels in the dataset (default)
custom_labels : list of str
list of labels from a file
"""
if labels is not None:
self.setEnabled(True)
self.chan_name = labels
self.table.blockSignals(True)
self.table.clearContents()
self.table.setRowCount(len(self.chan_name))
for i, label in enumerate(self.chan_name):
old_label = QTableWidgetItem(label)
old_label.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
if custom_labels is not None and i < len(custom_labels) and custom_labels[i]: # it's not empty string or None
label_txt = custom_labels[i]
else:
label_txt = label
new_label = QTableWidgetItem(label_txt)
self.table.setItem(i, 0, old_label)
self.table.setItem(i, 1, new_label)
self.table.blockSignals(False)
def __init__(self, sigma):
QTableWidgetItem.__init__(self)
self.sigma = sigma
flags = self.flags()
flags |= Qt.ItemIsEditable
flags &= ~Qt.ItemIsSelectable
self.setFlags(flags)
def show_musics(self, playmid):
self.clean_table()
r = server.getServer('playlists/'+playmid, {'id':playmid})
#http://nullege.com/codes/show/src@p@y@pyqt5-HEAD@examples@[email protected]/193/PyQt5.QtWidgets.QTableWidget.setSelectionBehavior
if len(r['payload']['musics']) == 0:
self.clean_table()
else:
self.tableWidget.setRowCount(len(r['payload']['musics']))
self.tableWidget.setColumnCount(1)
self.tableWidget.setHorizontalHeaderLabels(['Musica'])
self.tableWidget.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
self.tableWidget.horizontalHeader().setStretchLastSection(True)
self.tableWidget.cellDoubleClicked.connect(self.select_music)
i = 0
self.musics_in_current_playlist_by_index = {}
for music in r['payload']['musics']:
self.musics_in_current_playlist_by_index[i] = {
'id': music['id'], 'file_name': music['file_name'],
'name': music['name']
}
musica = QTableWidgetItem(music['name'])
file_path = QTableWidgetItem(music['file_name'])
musica.setFlags(musica.flags() & ~Qt.ItemIsEditable)
self.tableWidget.setItem(i, 0, musica)
self.tableWidget.setItem(i, 1, file_path)
i+=1
def set_automated_stocks(self):
file_list = ["../data/sell_list.txt", "../data/buy_list.txt"]
automated_stocks = []
try:
for file in file_list:
# utf-8로 작성된 파일을
# cp949 환경에서 읽기위해서 encoding 지정
with open(file, 'rt', encoding='utf-8') as f:
stocks_list = f.readlines()
automated_stocks += stocks_list
except Exception as e:
print(e)
e.msg = "set_automated_stocks() 에러"
self.show_dialog('Critical', e)
return
# 테이블 행수 설정
cnt = len(automated_stocks)
self.automatedStocksTable.setRowCount(cnt)
# 테이블에 출력
for i in range(cnt):
stocks = automated_stocks[i].split(';')
for j in range(len(stocks)):
if j == 1:
name = self.kiwoom.get_master_code_name(stocks[j].rstrip())
item = QTableWidgetItem(name)
else:
item = QTableWidgetItem(stocks[j].rstrip())
item.setTextAlignment(Qt.AlignVCenter | Qt.AlignCenter)
self.automatedStocksTable.setItem(i, j, item)
self.automatedStocksTable.resizeRowsToContents()
def createGUI(self):
tableData = [
("Alice", QColor('aliceblue')),
("Neptun", QColor('aquamarine')),
("Ferdinand", QColor('springgreen'))
]
table = QTableWidget(3, 2)
table.setHorizontalHeaderLabels(["Name", "Hair Color"])
table.verticalHeader().setVisible(False)
table.resize(150, 50)
for i, (name, color) in enumerate(tableData):
nameItem = QTableWidgetItem(name)
colorItem = QTableWidgetItem()
colorItem.setData(Qt.DisplayRole, color)
table.setItem(i, 0, nameItem)
table.setItem(i, 1, colorItem)
table.resizeColumnToContents(0)
table.horizontalHeader().setStretchLastSection(True)
layout = QGridLayout()
layout.addWidget(table, 0, 0)
self.setLayout(layout)
self.setWindowTitle("Color Editor Factory")
def _new_setting(self):
"""
Add a new setting to the config
:return: None
"""
# get the number of rows in the table
_rows = self._table.rowCount()
# create a wizard to get the setting name and setting value from the user
_wizard = OptionWizard(self._tran.get_text('option_wizard_title'), self._tran)
# open the wizard
_wizard.exec_()
# only if the user has entered a setting name
if _wizard.setting_name():
# create a new item holding the entered data
self._table.insertRow(_rows)
_key = QTableWidgetItem(_wizard.setting_name())
# make the new item editable and selectable
_flags = _key.flags()
_flags |= Qt.ItemIsSelectable
_flags &= Qt.ItemIsEditable
_key.setFlags(_flags)
# add the new item to the table
self._table.setItem(_rows, 0, _key)
self._table.setItem(_rows, 1, QTableWidgetItem(_wizard.setting_value()))
# add the new setting to the config
self._config[_wizard.setting_name()] = _wizard.setting_value()
# make the default config visible in the ui, toggle tooltips, ...
self.init()
def createTable(self):
try:
email = self.t1.text()
query = "select * from result where email='%s'" % (email)
cursor.execute(query)
data = cursor.fetchone()
#code to create table at run time
self.tableWidget = QTableWidget()
self.tableWidget.setRowCount(2)
self.tableWidget.setColumnCount(7)
self.tableWidget.setItem(0, 0, QTableWidgetItem("Email"))
self.tableWidget.setItem(0, 1, QTableWidgetItem("Name"))
self.tableWidget.setItem(0, 2, QTableWidgetItem("Correct"))
self.tableWidget.setItem(0, 3, QTableWidgetItem("Wrong"))
self.tableWidget.setItem(0, 4, QTableWidgetItem("Score"))
self.tableWidget.setItem(0, 5, QTableWidgetItem("Status"))
self.tableWidget.setItem(0, 6, QTableWidgetItem("DateOfExam"))
for i in range(1, 2, 1):
for j in range(0, 7, 1):
self.tableWidget.setItem(i, j,
QTableWidgetItem(str(data[j])))
self.tableWidget.setGeometry(240, 90, 831, 131)
self.tableWidget.setWindowTitle("Your Result")
self.tableWidget.show()
#code for filling PyQt Designer Table
self.table1.setItem(0, 0, QTableWidgetItem("Email"))
self.table1.setItem(0, 1, QTableWidgetItem("Name"))
self.table1.setItem(0, 2, QTableWidgetItem("Correct"))
self.table1.setItem(0, 3, QTableWidgetItem("Wrong"))
self.table1.setItem(0, 4, QTableWidgetItem("Score"))
self.table1.setItem(0, 5, QTableWidgetItem("Status"))
self.table1.setItem(0, 6, QTableWidgetItem("DateOfExam"))
for i in range(1, 2, 1):
for j in range(0, 7, 1):
self.table1.setItem(i, j, QTableWidgetItem(str(data[j])))
except Exception as e:
print(e)
def setInformation(self):
# Presets
decoderEdit = False
self.ui.optionWidget.setCurrentIndex(0)
txt = ""
# Determine selected element
if self.ui.basefunctions.hasFocus():
element = self.ui.basefunctions.currentItem().text()
txt += element + ":\n"
elif self.ui.additionalfunctions.hasFocus():
element = self.ui.additionalfunctions.currentItem().text()
txt += element + ":\n"
elif self.ui.decoderchain.hasFocus():
decoderEdit = True
txt = "## DECODING PROCESS ##\n\n"
element = self.ui.decoderchain.currentItem().text()
if element[-1] == " ":
elementname = element[0:-1]
else:
elementname = element
txt += elementname + ":\n"
self.active_block = element
# Remove "[Disabled] " for further tasks
if constants.DECODING_DISABLED_PREFIX in element:
element = element[len(constants.DECODING_DISABLED_PREFIX):]
# Write info text and show options
if constants.DECODING_EDGE in element:
txt += "Trigger on signal edge, i.e. the transition between low and high.\n" \
"- Low to High (01) is 1\n" \
"- High to Low (10) is 0"
elif constants.DECODING_SUBSTITUTION in element:
txt += "A set of manual defined signal sequences FROM (e.g. 10, 01) is replaced by another set of " \
"sequences TO (e.g. 01, 10)."
self.ui.optionWidget.setCurrentIndex(3)
# Values can only be changed when editing decoder, otherwise default value
if not decoderEdit:
self.ui.substitution_rows.setValue(4)
self.ui.substitution.setRowCount(0)
self.ui.substitution.setRowCount(4)
else:
if element in self.chainoptions:
values = self.chainoptions[element]
if values == "":
self.ui.substitution_rows.setValue(4)
self.ui.substitution.setRowCount(0)
self.ui.substitution.setRowCount(4)
else:
arrs = self.e.get_subst_array(values)
if len(arrs[0]) == len(arrs[1]):
self.ui.substitution_rows.setValue(len(arrs[0]))
self.ui.substitution.setRowCount(len(arrs[0]))
for i in range(0, len(arrs[0])):
self.ui.substitution.setItem(i, 0, QTableWidgetItem(self.e.bit2str(arrs[0][i])))
self.ui.substitution.setItem(i, 1, QTableWidgetItem(self.e.bit2str(arrs[1][i])))
else:
self.ui.substitution_rows.setValue(4)
self.ui.substitution.setRowCount(0)
self.ui.substitution.setRowCount(4)
self.ui.substitution.setEnabled(decoderEdit)
self.ui.substitution_rows.setEnabled(decoderEdit)
elif constants.DECODING_EXTERNAL in element:
txt += "The decoding (and encoding) process is delegated to external programs or scripts via parameter.\n" \
"Example: Given the signal 10010110, your program is called as './decoder 10010110'. Your program " \
"computes and prints a corresponding set of 0s and 1s which is fed back into the decoding process. "
self.ui.optionWidget.setCurrentIndex(4)
# Values can only be changed when editing decoder, otherwise default value
if not decoderEdit:
self.ui.external_decoder.setText("")
self.ui.external_encoder.setText("")
else:
if element in self.chainoptions:
value = self.chainoptions[element]
if value == "":
self.ui.external_decoder.setText("")
self.ui.external_encoder.setText("")
else:
decstr, encstr = value.split(";")
self.ui.external_decoder.setText(decstr)
self.ui.external_encoder.setText(encstr)
else:
self.ui.external_decoder.setText("")
self.ui.external_encoder.setText("")
self.ui.external_decoder.setEnabled(decoderEdit)
self.ui.external_encoder.setEnabled(decoderEdit)
elif constants.DECODING_INVERT in element:
txt += "All bits are inverted, i.e. 0->1 and 1->0."
elif constants.DECODING_DIFFERENTIAL in element:
txt += "Every transition between low and high (0->1 or 1->0) becomes 1, no transition (0->0 or 1->1) remains 0.\n" \
"The first signal bit is regarded as start value and directly copied.\n" \
"Example: 0011 becomes 0010 [0|(0->0)|(0->1)|(1->1)]."
elif constants.DECODING_BITORDER in element:
txt += "Every byte (8 bit) is reversed, i.e. the order of the bits 01234567 (e.g. least significant bit first) " \
"is changed to 76543210 (e.g. most significant bit first)."
elif constants.DECODING_REDUNDANCY in element:
txt += "If the source signal always has multiple redundant bits for one bit (e.g. 1111=1, 0000=0), the " \
"redundancy is removed here. You have to define the number of redundant bits."
self.ui.optionWidget.setCurrentIndex(1)
# Values can only be changed when editing decoder, otherwise default value
if not decoderEdit:
self.ui.multiple.setValue(2)
else:
if element in self.chainoptions:
value = self.chainoptions[element]
if value == "":
self.ui.multiple.setValue(2)
else:
self.ui.multiple.setValue(int(value))
else:
self.ui.multiple.setValue(2)
self.ui.multiple.setEnabled(decoderEdit)
elif constants.DECODING_CARRIER in element:
txt += "A carrier is a fixed pattern like 1_1_1_1 where the actual data lies in between, e.g. 1a1a1b1. This " \
"function extracts the actual bit information (here: aab) from the signal.\n" \
"Examples:\n" \
"- Carrier = '1' means 1_1_1_1...\n" \
"- Carrier = '01' means 01_01_01_01..."
self.ui.optionWidget.setCurrentIndex(2)
# Values can only be changed when editing decoder, otherwise default value
if not decoderEdit:
self.ui.carrier.setText("1")
else:
if element in self.chainoptions:
value = self.chainoptions[element]
if value == "":
self.ui.carrier.setText("1")
else:
self.ui.carrier.setText(value)
else:
self.ui.carrier.setText("1")
self.ui.carrier.setEnabled(decoderEdit)
elif constants.DECODING_DATAWHITENING in element:
txt += "Texas Instruments CC110x chips allow a data whitening that is applied before sending the signals to HF. " \
"After a preamble (1010...) there is a fixed 16/32 bit sync word. The following data (incl. 16 bit CRC) " \
"is masked (XOR) with the output of a LFSR.\n" \
"This function removes the sync word, zeroes the crc (if valid) and unmasks the data."
self.ui.optionWidget.setCurrentIndex(5)
# Values can only be changed when editing decoder, otherwise default value
if not decoderEdit:
self.ui.datawhitening_sync.setText("0xe9cae9ca")
self.ui.datawhitening_polynomial.setText("0x21")
self.ui.datawhitening_applycrc.setChecked(True)
self.ui.datawhitening_preamble_rm.setChecked(True)
self.ui.datawhitening_sync_rm.setChecked(True)
self.ui.datawhitening_crc_rm.setChecked(False)
else:
if element in self.chainoptions:
value = self.chainoptions[element]
if value == "":
self.ui.datawhitening_sync.setText("0xe9cae9ca")
self.ui.datawhitening_polynomial.setText("0x21")
self.ui.datawhitening_applycrc.setChecked(True)
self.ui.datawhitening_preamble_rm.setChecked(True)
self.ui.datawhitening_sync_rm.setChecked(True)
self.ui.datawhitening_crc_rm.setChecked(False)
else:
try:
whitening_sync, whitening_polynomial, opt = value.split(";")
self.ui.datawhitening_sync.setText(whitening_sync)
self.ui.datawhitening_polynomial.setText(whitening_polynomial)
opt = self.e.hex2bit(opt)
if len(opt)>= 4:
self.ui.datawhitening_applycrc.setChecked(opt[0])
self.ui.datawhitening_preamble_rm.setChecked(opt[1])
self.ui.datawhitening_sync_rm.setChecked(opt[2])
self.ui.datawhitening_crc_rm.setChecked(opt[3])
except ValueError:
self.ui.datawhitening_sync.setText("0xe9cae9ca")
self.ui.datawhitening_polynomial.setText("0x21")
self.ui.datawhitening_applycrc.setChecked(True)
self.ui.datawhitening_preamble_rm.setChecked(True)
self.ui.datawhitening_sync_rm.setChecked(True)
self.ui.datawhitening_crc_rm.setChecked(False)
self.ui.datawhitening_sync.setEnabled(decoderEdit)
self.ui.datawhitening_polynomial.setEnabled(decoderEdit)
self.ui.datawhitening_applycrc.setEnabled(decoderEdit)
self.ui.datawhitening_preamble_rm.setEnabled(decoderEdit)
self.ui.datawhitening_sync_rm.setEnabled(decoderEdit)
self.ui.datawhitening_crc_rm.setEnabled(decoderEdit)
self.ui.info.setText(txt)
def __init__(self, text, color):
QTableWidgetItem.__init__(self, text)
self.setBackground(QBrush(color))
self.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
def Edit_reg_form_func(self, row):
root = ET.parse('Data\\filename2.xml').getroot()
login = root.find(root.find('Login_folder').text)
Users = login.find('Users')
curreant_User = Users.find('Users_{}'.format(str(row)))
for type_tag in Users.findall("Users_{}".format(str(row))):
self.gur_User_name.setText(type_tag.get('GUI_name'))
self.gur_Phone_num.setText(type_tag.get('gur_Phone_num'))
self.gur_Signaling.setText(type_tag.get('gur_Signaling'))
self.gur_IP_Address.setText(type_tag.get('GUI_IP_Address'))
self.gur_IP_port.setText(type_tag.get('gur_IP_port'))
self.gur_Email.setText(type_tag.get('gur_Email'))
self.gur_Pin_code.setText(type_tag.get('gur_Pin_code'))
self.gur_Web_password.setText(type_tag.get('gur_Web_password'))
self.gur_Login.setText(type_tag.get('gur_Login'))
self.gur_Password.setText(type_tag.get('gur_Password'))
self.gur_TTL.setText(type_tag.get('gur_TTL'))
self.gur_NAT.setText(type_tag.get('gur_NAT'))
self.gur_Fax.setText(type_tag.get('gur_Fax'))
self.gur_Convert.setText(type_tag.get('gur_Convert'))
self.gur_Repacketize.setText(type_tag.get('gur_Repacketize'))
self.gur_DTMF.setText(type_tag.get('gur_DTMF'))
self.gur_Connect.setText(type_tag.get('gur_Connect'))
self.gur_Tone.setText(type_tag.get('gur_Tone'))
self.gur_Sip.setText(type_tag.get('gur_Sip'))
self.gur_noproxy.setText(type_tag.get('gur_noproxy'))
self.gur_RBT.setText(type_tag.get('gur_RBT'))
index = self.comboBox.findText(type_tag.get('ODL_dis'))
if index >= 0:
self.comboBox.setCurrentIndex(index)
index = self.gur_Registration.findText(
type_tag.get('gur_Registration'))
if index >= 0:
self.gur_Registration.setCurrentIndex(index)
for i in range(int(type_tag.get('Num_codec'))):
self.add_row_for_codec()
for type_tag_2 in curreant_User.findall("codec_{}".format(
str(i))):
codec = self.Codec_Table.cellWidget(i, 0)
index = codec.findText(type_tag_2.get('codec_codec'))
if index >= 0:
codec.setCurrentIndex(index)
self.Codec_Table.setItem(
i, 1,
QTableWidgetItem(str(type_tag_2.get('codec_FFP'))))
for i in range(int(type_tag.get('Num_call'))):
self.add_row_for_call()
for type_tag_2 in curreant_User.findall("call_{}".format(
str(i))):
call = self.Call_Table.cellWidget(i, 1)
index = call.findText(type_tag_2.get('call_FwdC'))
if index >= 0:
call.setCurrentIndex(index)
self.Call_Table.setItem(
i, 2,
QTableWidgetItem(str(type_tag_2.get('call_Source'))))
self.Call_Table.setItem(
i, 3,
QTableWidgetItem(str(type_tag_2.get('call_Ashedule'))))
self.Call_Table.setItem(
i, 4,
QTableWidgetItem(str(type_tag_2.get('call_FwdN'))))
call_che = self.Call_Table.cellWidget(i, 0)
if int(type_tag_2.get('call_check')) == 2:
call_che.setChecked(True)
else:
call_che.setChecked(False)
def fill_pyqt_table(table,
col_names=None,
col=None,
df=None,
filter=None,
filter_col=0,
check=None):
"""Fill a PyQt table widget.
Parameters
----------
col_names : list | None
List of name of each columns.
col : list | None
List of columns values.
df : pandas.DataFrame or dict | None
Alternatively, a pandas DataFrame or a dictionary can also be used.
"""
from PyQt5.QtWidgets import (QTableWidgetItem, QTableWidget, QTableView)
from PyQt5 import QtGui, QtCore
# ________________________ Checking ________________________
# Dictionary / pandas.DataFrame :
if df is not None:
col_names = list(df.keys())
col = []
for k in col_names:
col.append(df[k])
assert len(col_names) == len(col)
assert all([isinstance(k, str) for k in col_names])
n_rows, n_cols = (len(col[0]), len(col_names))
# Switch between table view / widget :
if isinstance(table, QTableWidget): # Table widget
table.clear()
table.setColumnCount(n_cols)
table.setHorizontalHeaderLabels(col_names)
table.setRowCount(n_rows)
for i in range(table.rowCount()):
for k in range(table.columnCount()):
table.setItem(i, k, QTableWidgetItem(str(col[k][i])))
elif isinstance(table, QTableView): # Table view
table.reset()
# Fill the model :
model = QtGui.QStandardItemModel(n_rows, n_cols)
model.setHorizontalHeaderLabels(col_names)
for i in range(n_rows):
for k in range(n_cols):
item = QtGui.QStandardItem(str(col[k][i]))
item.setCheckable(check == k)
model.setItem(i, k, item)
table.setModel(model)
if filter is not None:
filt_model = QtCore.QSortFilterProxyModel()
filt_model.setSourceModel(model)
filt_model.setFilterKeyColumn(filter_col)
filt_model.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
filter.textChanged.connect(filt_model.setFilterRegExp)
table.setModel(filt_model)
return model
def out_frame_func(int_lng, prj_path, mesh_name_txt, pd_2, meshQC_visible):
meshQC_obj = None
#----------------Если файл meshQC.pkl существует, получаем данные из него для вывода в форму---------------#
if meshQC_visible == True:
meshQC_path_file = prj_path + '/' + mesh_name_txt + '_' + pd_2 + '/' + 'meshQC.pkl'
if os.path.exists(meshQC_path_file):
input = open(meshQC_path_file, 'rb')
meshQC_obj = pickle.load(input)
input.close()
#---------------Формируем внешний вид формы для файла meshQC.pkl на основе данных файла initial.pkl-------------#
main_lbl = QLabel()
if int_lng == 'Russian':
main_lbl.setText("Общие настройки качества сетки")
elif int_lng == 'English':
main_lbl.setText("Generic mesh quality settings")
initial_path_file = prj_path + '/' + mesh_name_txt + '_' + pd_2 + '/' + 'initial.pkl'
if os.path.exists(initial_path_file):
input = open(initial_path_file, 'rb')
obj_initial = pickle.load(input)
input.close()
prs_grid = QGridLayout()
##################################Дополнительные параметры#########################################
meshQC_prs_add_table = QTableWidget()
meshQC_prs_add_table.setFixedSize(685, 508)
meshQC_prs_add_table.setRowCount(16)
meshQC_prs_add_table.setColumnCount(4)
meshQC_prs_add_table.verticalHeader().hide()
meshQC_prs_add_table.horizontalHeader().resizeSection(0, 50)
meshQC_prs_add_table.horizontalHeader().setResizeMode(0, QtGui.QHeaderView.Fixed)
column_1 = QTableWidgetItem()
meshQC_prs_add_table.setHorizontalHeaderItem(0, column_1)
meshQC_prs_add_table.horizontalHeader().setStyleSheet("color: steelblue")
meshQC_prs_add_table.horizontalHeader().resizeSection(1, 150)
meshQC_prs_add_table.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Fixed)
column_2 = QTableWidgetItem()
meshQC_prs_add_table.setHorizontalHeaderItem(1, column_2)
meshQC_prs_add_table.horizontalHeader().setStyleSheet("color: steelblue")
meshQC_prs_add_table.horizontalHeader().resizeSection(2, 360)
meshQC_prs_add_table.horizontalHeader().setResizeMode(2, QtGui.QHeaderView.Fixed)
column_3 = QTableWidgetItem()
meshQC_prs_add_table.setHorizontalHeaderItem(2, column_3)
meshQC_prs_add_table.horizontalHeader().setStyleSheet("color: steelblue")
meshQC_prs_add_table.horizontalHeader().resizeSection(3, 110)
meshQC_prs_add_table.horizontalHeader().setResizeMode(3, QtGui.QHeaderView.Fixed)
column_4 = QTableWidgetItem()
meshQC_prs_add_table.setHorizontalHeaderItem(3, column_4)
meshQC_prs_add_table.horizontalHeader().setStyleSheet("color: steelblue")
if int_lng == 'Russian':
column_1.setText("Флаг")
column_2.setText("Параметр")
column_3.setText("Описание")
column_4.setText("Значение")
elif int_lng == 'English':
column_1.setText("Flag")
column_2.setText("Parameter")
column_3.setText("Definition")
column_4.setText("Value")
meshQC_chcks_list = []
meshQC_prs_list = []
meshQC_def_list = []
meshQC_val_list = []
#1)relaxedMaxNonOrtho
rMNO_chck = QCheckBox()
rMNO_chck_hbox = QHBoxLayout()
rMNO_chck_hbox.setContentsMargins(0, 0, 0, 0)
rMNO_chck_hbox.setAlignment(QtCore.Qt.AlignCenter)
rMNO_chck_hbox.addWidget(rMNO_chck)
rMNO_chck_cell_widget = QWidget()
rMNO_chck_cell_widget.setLayout(rMNO_chck_hbox)
meshQC_prs_add_table.setCellWidget(0, 0, rMNO_chck_cell_widget)
rMNO_val_pr = QLabel()
rMNO_val_pr.setEnabled(False)
rMNO_val_pr.setText('relaxed maxNonOrtho')
meshQC_prs_add_table.setCellWidget(0, 1, rMNO_val_pr)
rMNO_val_def = QLabel()
rMNO_val_def.setEnabled(False)
meshQC_prs_add_table.setCellWidget(0, 2, rMNO_val_def)
rMNO_val = QSpinBox()
rMNO_val.setEnabled(False)
rMNO_val.setFixedSize(70, 25)
rMNO_val_hbox = QHBoxLayout()
rMNO_val_hbox.setContentsMargins(0, 0, 0, 0)
rMNO_val_hbox.addWidget(rMNO_val)
rMNO_val_cell_widget = QWidget()
rMNO_val_cell_widget.setLayout(rMNO_val_hbox)
meshQC_prs_add_table.setCellWidget(0, 3, rMNO_val_cell_widget)
if int_lng == 'Russian':
rMNO_val_def.setText("Максимальная неортогональность для свойств relaxed")
rMNO_val.setToolTip("Введите целое число")
elif int_lng == 'English':
rMNO_val_def.setText("Maximum non-orthogonality for relaxed parameters")
rMNO_val.setToolTip("Enter the integer number")
meshQC_chcks_list.append(rMNO_chck)
meshQC_prs_list.append(rMNO_val_pr)
meshQC_def_list.append(rMNO_val_def)
meshQC_val_list.append(rMNO_val)
if meshQC_obj != None:
if 'relaxed_maxNonOrtho' in meshQC_obj['meshQC_add']:
rMNO_val.setValue(meshQC_obj['meshQC_add']['relaxed_maxNonOrtho'])
rMNO_chck.setChecked(True)
rMNO_val_pr.setEnabled(True)
rMNO_val_def.setEnabled(True)
rMNO_val.setEnabled(True)
#2)nSmoothScale
nSS_val_pr = QLabel()
nSS_val_pr.setText('nSmoothScale')
meshQC_prs_add_table.setCellWidget(1, 1, nSS_val_pr)
nSS_val_def = QLabel()
meshQC_prs_add_table.setCellWidget(1, 2, nSS_val_def)
nSS_val = QSpinBox()
nSS_val.setFixedSize(70, 25)
nSS_val_hbox = QHBoxLayout()
nSS_val_hbox.setContentsMargins(0, 0, 0, 0)
nSS_val_hbox.addWidget(nSS_val)
nSS_val_cell_widget = QWidget()
nSS_val_cell_widget.setLayout(nSS_val_hbox)
meshQC_prs_add_table.setCellWidget(1, 3, nSS_val_cell_widget)
if int_lng == 'Russian':
nSS_val_def.setText("Количество итераций распространения ошибок")
nSS_val.setToolTip("Введите целое число")
elif int_lng == 'English':
nSS_val_def.setText("Number of error distribution iterations")
nSS_val.setToolTip("Enter the integer number")
if meshQC_obj != None:
nSS_val.setValue(meshQC_obj['meshQC_add']['nSmoothScale'])
#3)errorReduction
eR_val_pr = QLabel()
eR_val_pr.setText('errorReduction')
meshQC_prs_add_table.setCellWidget(2, 1, eR_val_pr)
eR_val_def = QLabel()
meshQC_prs_add_table.setCellWidget(2, 2, eR_val_def)
eR_val = QDoubleSpinBox()
eR_val.setFixedSize(70, 25)
eR_val_hbox = QHBoxLayout()
eR_val_hbox.setContentsMargins(0, 0, 0, 0)
eR_val_hbox.addWidget(eR_val)
eR_val_cell_widget = QWidget()
eR_val_cell_widget.setLayout(eR_val_hbox)
meshQC_prs_add_table.setCellWidget(2, 3, eR_val_cell_widget)
if int_lng == 'Russian':
eR_val_def.setText("Величина уменьшения смещения в точке ошибки")
eR_val.setToolTip("Введите число двойной точности")
elif int_lng == 'English':
eR_val_def.setText("Amount to scale back displacement at error points")
eR_val.setToolTip("Enter the double-precision number")
if meshQC_obj != None:
eR_val.setValue(meshQC_obj['meshQC_add']['errorReduction'])
#4)maxNonOrtho
mNO_chck = QCheckBox()
mNO_chck_hbox = QHBoxLayout()
mNO_chck_hbox.setContentsMargins(0, 0, 0, 0)
mNO_chck_hbox.setAlignment(QtCore.Qt.AlignCenter)
mNO_chck_hbox.addWidget(mNO_chck)
mNO_chck_cell_widget = QWidget()
mNO_chck_cell_widget.setLayout(mNO_chck_hbox)
meshQC_prs_add_table.setCellWidget(3, 0, mNO_chck_cell_widget)
mNO_val_pr = QLabel()
mNO_val_pr.setEnabled(False)
mNO_val_pr.setText('maxNonOrtho')
meshQC_prs_add_table.setCellWidget(3, 1, mNO_val_pr)
mNO_val_def = QLabel()
mNO_val_def.setEnabled(False)
meshQC_prs_add_table.setCellWidget(3, 2, mNO_val_def)
mNO_val = QSpinBox()
mNO_val.setEnabled(False)
mNO_val.setFixedSize(70, 25)
mNO_val_hbox = QHBoxLayout()
mNO_val_hbox.setContentsMargins(0, 0, 0, 0)
mNO_val_hbox.addWidget(mNO_val)
mNO_val_cell_widget = QWidget()
mNO_val_cell_widget.setLayout(mNO_val_hbox)
meshQC_prs_add_table.setCellWidget(3, 3, mNO_val_cell_widget)
if int_lng == 'Russian':
mNO_val_def.setText("Максимальная ортогональность")
mNO_val.setToolTip("Введите целое число")
elif int_lng == 'English':
mNO_val_def.setText("Maximum orthogonality")
mNO_val.setToolTip("Enter the integer number")
meshQC_chcks_list.append(mNO_chck)
meshQC_prs_list.append(mNO_val_pr)
meshQC_def_list.append(mNO_val_def)
meshQC_val_list.append(mNO_val)
if meshQC_obj != None:
if 'maxNonOrtho' in meshQC_obj['meshQC_add']:
mNO_val.setValue(meshQC_obj['meshQC_add']['maxNonOrtho'])
mNO_chck.setChecked(True)
mNO_val_pr.setEnabled(True)
mNO_val_def.setEnabled(True)
mNO_val.setEnabled(True)
#5)maxBoundarySkewness
mBS_chck = QCheckBox()
mBS_chck_hbox = QHBoxLayout()
mBS_chck_hbox.setContentsMargins(0, 0, 0, 0)
mBS_chck_hbox.setAlignment(QtCore.Qt.AlignCenter)
mBS_chck_hbox.addWidget(mBS_chck)
mBS_chck_cell_widget = QWidget()
mBS_chck_cell_widget.setLayout(mBS_chck_hbox)
meshQC_prs_add_table.setCellWidget(4, 0, mBS_chck_cell_widget)
mBS_val_pr = QLabel()
mBS_val_pr.setEnabled(False)
mBS_val_pr.setText('maxBoundarySkewness')
meshQC_prs_add_table.setCellWidget(4, 1, mBS_val_pr)
mBS_val_def = QLabel()
mBS_val_def.setEnabled(False)
meshQC_prs_add_table.setCellWidget(4, 2, mBS_val_def)
mBS_val = QSpinBox()
mBS_val.setEnabled(False)
mBS_val.setFixedSize(70, 25)
mBS_val_hbox = QHBoxLayout()
mBS_val_hbox.setContentsMargins(0, 0, 0, 0)
mBS_val_hbox.addWidget(mBS_val)
mBS_val_cell_widget = QWidget()
mBS_val_cell_widget.setLayout(mBS_val_hbox)
meshQC_prs_add_table.setCellWidget(4, 3, mBS_val_cell_widget)
if int_lng == 'Russian':
mBS_val_def.setText("Максимальная асимметрия границы")
mBS_val.setToolTip("Введите целое число")
elif int_lng == 'English':
mBS_val_def.setText("Maximum boundary skewness")
mBS_val.setToolTip("Enter the integer number")
meshQC_chcks_list.append(mBS_chck)
meshQC_prs_list.append(mBS_val_pr)
meshQC_def_list.append(mBS_val_def)
meshQC_val_list.append(mBS_val)
if meshQC_obj != None:
if 'maxBoundarySkewness' in meshQC_obj['meshQC_add']:
mBS_val.setValue(meshQC_obj['meshQC_add']['maxBoundarySkewness'])
mBS_chck.setChecked(True)
mBS_val_pr.setEnabled(True)
mBS_val_def.setEnabled(True)
mBS_val.setEnabled(True)
#6)maxInternalSkewness
mIS_chck = QCheckBox()
mIS_chck = QCheckBox()
mIS_chck_hbox = QHBoxLayout()
mIS_chck_hbox.setContentsMargins(0, 0, 0, 0)
mIS_chck_hbox.setAlignment(QtCore.Qt.AlignCenter)
mIS_chck_hbox.addWidget(mIS_chck)
mIS_chck_cell_widget = QWidget()
mIS_chck_cell_widget.setLayout(mIS_chck_hbox)
meshQC_prs_add_table.setCellWidget(5, 0, mIS_chck_cell_widget)
mIS_val_pr = QLabel()
mIS_val_pr.setEnabled(False)
mIS_val_pr.setText('maxInternalSkewness')
meshQC_prs_add_table.setCellWidget(5, 1, mIS_val_pr)
mIS_val_def = QLabel()
mIS_val_def.setEnabled(False)
meshQC_prs_add_table.setCellWidget(5, 2, mIS_val_def)
mIS_val = QSpinBox()
mIS_val.setEnabled(False)
mIS_val.setFixedSize(70, 25)
mIS_val_hbox = QHBoxLayout()
mIS_val_hbox.setContentsMargins(0, 0, 0, 0)
mIS_val_hbox.addWidget(mIS_val)
mIS_val_cell_widget = QWidget()
mIS_val_cell_widget.setLayout(mIS_val_hbox)
meshQC_prs_add_table.setCellWidget(5, 3, mIS_val_cell_widget)
if int_lng == 'Russian':
mIS_val_def.setText("Максимальная внутренняя асимметрия")
mIS_val.setToolTip("Введите целое число")
elif int_lng == 'English':
mIS_val_def.setText("Maximum Internal Skewness")
mIS_val.setToolTip("Enter the integer number")
meshQC_chcks_list.append(mIS_chck)
meshQC_prs_list.append(mIS_val_pr)
meshQC_def_list.append(mIS_val_def)
meshQC_val_list.append(mIS_val)
if meshQC_obj != None:
if 'maxInternalSkewness' in meshQC_obj['meshQC_add']:
mIS_val.setValue(meshQC_obj['meshQC_add']['maxInternalSkewness'])
mIS_chck.setChecked(True)
mIS_val_pr.setEnabled(True)
mIS_val_def.setEnabled(True)
mIS_val.setEnabled(True)
#7)maxConcave
mC_chck = QCheckBox()
mC_chck_hbox = QHBoxLayout()
mC_chck_hbox.setContentsMargins(0, 0, 0, 0)
mC_chck_hbox.setAlignment(QtCore.Qt.AlignCenter)
mC_chck_hbox.addWidget(mC_chck)
mC_chck_cell_widget = QWidget()
mC_chck_cell_widget.setLayout(mC_chck_hbox)
meshQC_prs_add_table.setCellWidget(6, 0, mC_chck_cell_widget)
mC_val_pr = QLabel()
mC_val_pr.setEnabled(False)
mC_val_pr.setText('maxConcave')
meshQC_prs_add_table.setCellWidget(6, 1, mC_val_pr)
mC_val_def = QLabel()
mC_val_def.setEnabled(False)
meshQC_prs_add_table.setCellWidget(6, 2, mC_val_def)
mC_val = QSpinBox()
mC_val.setEnabled(False)
mC_val.setFixedSize(70, 25)
mC_val_hbox = QHBoxLayout()
mC_val_hbox.setContentsMargins(0, 0, 0, 0)
mC_val_hbox.addWidget(mC_val)
mC_val_cell_widget = QWidget()
mC_val_cell_widget.setLayout(mC_val_hbox)
meshQC_prs_add_table.setCellWidget(6, 3, mC_val_cell_widget)
if int_lng == 'Russian':
mC_val_def.setText("Максимальная вогнутость")
mC_val.setToolTip("Введите целое число")
elif int_lng == 'English':
mC_val_def.setText("Maximum concaveness")
mC_val.setToolTip("Enter the integer number")
meshQC_chcks_list.append(mC_chck)
meshQC_prs_list.append(mC_val_pr)
meshQC_def_list.append(mC_val_def)
meshQC_val_list.append(mC_val)
if meshQC_obj != None:
if 'maxConcave' in meshQC_obj['meshQC_add']:
mC_val.setValue(meshQC_obj['meshQC_add']['maxConcave'])
mC_chck.setChecked(True)
mC_val_pr.setEnabled(True)
mC_val_def.setEnabled(True)
mC_val.setEnabled(True)
#8)minVol
mV_chck = QCheckBox()
mV_chck_hbox = QHBoxLayout()
mV_chck_hbox.setContentsMargins(0, 0, 0, 0)
mV_chck_hbox.setAlignment(QtCore.Qt.AlignCenter)
mV_chck_hbox.addWidget(mV_chck)
mV_chck_cell_widget = QWidget()
mV_chck_cell_widget.setLayout(mV_chck_hbox)
meshQC_prs_add_table.setCellWidget(7, 0, mV_chck_cell_widget)
mV_val_pr = QLabel()
mV_val_pr.setEnabled(False)
mV_val_pr.setText('minVol')
meshQC_prs_add_table.setCellWidget(7, 1, mV_val_pr)
mV_val_def = QLabel()
mV_val_def.setEnabled(False)
meshQC_prs_add_table.setCellWidget(7, 2, mV_val_def)
mV_val = QLineEdit()
mV_val.setEnabled(False)
mV_val.setFixedSize(70, 25)
mV_val.setInputMask("9e-99;_")
mV_val_hbox = QHBoxLayout()
mV_val_hbox.setContentsMargins(0, 0, 0, 0)
mV_val_hbox.addWidget(mV_val)
mV_val_cell_widget = QWidget()
mV_val_cell_widget.setLayout(mV_val_hbox)
meshQC_prs_add_table.setCellWidget(7, 3, mV_val_cell_widget)
if int_lng == 'Russian':
mV_val_def.setText("Минимальный объем пирамиды")
mV_val.setToolTip("Введите число в экспоненциальном формате")
elif int_lng == 'English':
mV_val_def.setText("Minimum pyramid volume")
mV_val.setToolTip("Enter the number in exponential format")
meshQC_chcks_list.append(mV_chck)
meshQC_prs_list.append(mV_val_pr)
meshQC_def_list.append(mV_val_def)
meshQC_val_list.append(mV_val)
if meshQC_obj != None:
if 'minVol' in meshQC_obj['meshQC_add']:
mV_val.setText(meshQC_obj['meshQC_add']['minVol'])
mV_chck.setChecked(True)
mV_val_pr.setEnabled(True)
mV_val_def.setEnabled(True)
mV_val.setEnabled(True)
#9)minArea
mA_chck = QCheckBox()
mA_chck_hbox = QHBoxLayout()
mA_chck_hbox.setContentsMargins(0, 0, 0, 0)
mA_chck_hbox.setAlignment(QtCore.Qt.AlignCenter)
mA_chck_hbox.addWidget(mA_chck)
mA_chck_cell_widget = QWidget()
mA_chck_cell_widget.setLayout(mA_chck_hbox)
meshQC_prs_add_table.setCellWidget(8, 0, mA_chck_cell_widget)
mA_val_pr = QLabel()
mA_val_pr.setEnabled(False)
mA_val_pr.setText('minArea')
meshQC_prs_add_table.setCellWidget(8, 1, mA_val_pr)
mA_val_def = QLabel()
mA_val_def.setEnabled(False)
meshQC_prs_add_table.setCellWidget(8, 2, mA_val_def)
mA_val = QLineEdit()
mA_val.setEnabled(False)
mA_val.setFixedSize(70, 25)
regexp = QtCore.QRegExp('[А-яА-Яa-zA-Z0-9\_]+')
validator = QtGui.QRegExpValidator(regexp)
mA_val.setValidator(validator)
mA_val_hbox = QHBoxLayout()
mA_val_hbox.setContentsMargins(0, 0, 0, 0)
mA_val_hbox.addWidget(mA_val)
mA_val_cell_widget = QWidget()
mA_val_cell_widget.setLayout(mA_val_hbox)
meshQC_prs_add_table.setCellWidget(8, 3, mA_val_cell_widget)
if int_lng == 'Russian':
mA_val_def.setText("Минимальная площадь грани")
mA_val.setToolTip("Введите число в экспоненциальном формате")
elif int_lng == 'English':
mA_val_def.setText("Minimum face area")
mA_val.setToolTip("Enter the number in exponential format")
meshQC_chcks_list.append(mA_chck)
meshQC_prs_list.append(mA_val_pr)
meshQC_def_list.append(mA_val_def)
meshQC_val_list.append(mA_val)
if meshQC_obj != None:
if 'minVol' in meshQC_obj['meshQC_add']:
mA_val.setText(meshQC_obj['meshQC_add']['minVol'])
mA_chck.setChecked(True)
mA_val_pr.setEnabled(True)
mA_val_def.setEnabled(True)
mA_val.setEnabled(True)
#10)minTetQuality
mTQ_chck = QCheckBox()
mTQ_chck_hbox = QHBoxLayout()
mTQ_chck_hbox.setContentsMargins(0, 0, 0, 0)
mTQ_chck_hbox.setAlignment(QtCore.Qt.AlignCenter)
mTQ_chck_hbox.addWidget(mTQ_chck)
mTQ_chck_cell_widget = QWidget()
mTQ_chck_cell_widget.setLayout(mTQ_chck_hbox)
meshQC_prs_add_table.setCellWidget(9, 0, mTQ_chck_cell_widget)
mTQ_val_pr = QLabel()
mTQ_val_pr.setEnabled(False)
mTQ_val_pr.setText('minTetQuality')
meshQC_prs_add_table.setCellWidget(9, 1, mTQ_val_pr)
mTQ_val_def = QLabel()
mTQ_val_def.setEnabled(False)
meshQC_prs_add_table.setCellWidget(9, 2, mTQ_val_def)
mTQ_val = QLineEdit()
mTQ_val.setEnabled(False)
mTQ_val.setFixedSize(70, 25)
mTQ_val.setInputMask("9e-99;_")
mTQ_val_hbox = QHBoxLayout()
mTQ_val_hbox.setContentsMargins(0, 0, 0, 0)
mTQ_val_hbox.addWidget(mTQ_val)
mTQ_val_cell_widget = QWidget()
mTQ_val_cell_widget.setLayout(mTQ_val_hbox)
meshQC_prs_add_table.setCellWidget(9, 3, mTQ_val_cell_widget)
if int_lng == 'Russian':
mTQ_val_def.setText("Минимальное качество тетраэдра")
mTQ_val.setToolTip("Введите число в экспоненциальном формате")
elif int_lng == 'English':
mTQ_val_def.setText("Minimum quality of the tetrahedron")
mTQ_val.setToolTip("Enter the number in exponential format")
meshQC_chcks_list.append(mTQ_chck)
meshQC_prs_list.append(mTQ_val_pr)
meshQC_def_list.append(mTQ_val_def)
meshQC_val_list.append(mTQ_val)
if meshQC_obj != None:
if 'minTetQuality' in meshQC_obj['meshQC_add']:
mTQ_val.setText(meshQC_obj['meshQC_add']['minTetQuality'])
mTQ_chck.setChecked(True)
mTQ_val_pr.setEnabled(True)
mTQ_val_def.setEnabled(True)
mTQ_val.setEnabled(True)
#11)minTwist
mT_chck = QCheckBox()
mT_chck_hbox = QHBoxLayout()
mT_chck_hbox.setContentsMargins(0, 0, 0, 0)
mT_chck_hbox.setAlignment(QtCore.Qt.AlignCenter)
mT_chck_hbox.addWidget(mT_chck)
mT_chck_cell_widget = QWidget()
mT_chck_cell_widget.setLayout(mT_chck_hbox)
meshQC_prs_add_table.setCellWidget(10, 0, mT_chck_cell_widget)
mT_val_pr = QLabel()
mT_val_pr.setEnabled(False)
mT_val_pr.setText('minTwist')
meshQC_prs_add_table.setCellWidget(10, 1, mT_val_pr)
mT_val_def = QLabel()
mT_val_def.setEnabled(False)
meshQC_prs_add_table.setCellWidget(10, 2, mT_val_def)
mT_val = QDoubleSpinBox()
mT_val.setEnabled(False)
mT_val.setFixedSize(70, 25)
mT_val_hbox = QHBoxLayout()
mT_val_hbox.setContentsMargins(0, 0, 0, 0)
mT_val_hbox.addWidget(mT_val)
mT_val_cell_widget = QWidget()
mT_val_cell_widget.setLayout(mT_val_hbox)
meshQC_prs_add_table.setCellWidget(10, 3, mT_val_cell_widget)
if int_lng == 'Russian':
mT_val_def.setText("Минимальное скручивание грани")
mT_val.setToolTip("Введите число двойной точности")
elif int_lng == 'English':
mT_val_def.setText("Minimum face twist")
mT_val.setToolTip("Enter the double-precision number")
meshQC_chcks_list.append(mT_chck)
meshQC_prs_list.append(mT_val_pr)
meshQC_def_list.append(mT_val_def)
meshQC_val_list.append(mT_val)
if meshQC_obj != None:
if 'minTwist' in meshQC_obj['meshQC_add']:
mT_val.setValue(meshQC_obj['meshQC_add']['minTwist'])
mT_chck.setChecked(True)
mT_val_pr.setEnabled(True)
mT_val_def.setEnabled(True)
mT_val.setEnabled(True)
#12)minDeterminant
mD_chck = QCheckBox()
mD_chck_hbox = QHBoxLayout()
mD_chck_hbox.setContentsMargins(0, 0, 0, 0)
mD_chck_hbox.setAlignment(QtCore.Qt.AlignCenter)
mD_chck_hbox.addWidget(mD_chck)
mD_chck_cell_widget = QWidget()
mD_chck_cell_widget.setLayout(mD_chck_hbox)
meshQC_prs_add_table.setCellWidget(11, 0, mD_chck_cell_widget)
mD_val_pr = QLabel()
mD_val_pr.setEnabled(False)
mD_val_pr.setText('minDeterminant')
meshQC_prs_add_table.setCellWidget(11, 1, mD_val_pr)
mD_val_def = QLabel()
mD_val_def.setEnabled(False)
meshQC_prs_add_table.setCellWidget(11, 2, mD_val_def)
mD_val = QLineEdit()
mD_val.setEnabled(False)
mD_val.setValidator(QtGui.QDoubleValidator(0.0, 999.0, 3, mD_val))
mD_val.setFixedSize(70, 25)
mD_val_hbox = QHBoxLayout()
mD_val_hbox.setContentsMargins(0, 0, 0, 0)
mD_val_hbox.addWidget(mD_val)
mD_val_cell_widget = QWidget()
mD_val_cell_widget.setLayout(mD_val_hbox)
meshQC_prs_add_table.setCellWidget(11, 3, mD_val_cell_widget)
if int_lng == 'Russian':
mD_val_def.setText("Минимальная нормированная детерминанта ячейки")
mD_val.setToolTip("Введите число тройной точности")
elif int_lng == 'English':
mD_val_def.setText("Minimum normalised cell determinant")
mD_val.setToolTip("Enter the triple precision number")
meshQC_chcks_list.append(mD_chck)
meshQC_prs_list.append(mD_val_pr)
meshQC_def_list.append(mD_val_def)
meshQC_val_list.append(mD_val)
if meshQC_obj != None:
if 'minDeterminant' in meshQC_obj['meshQC_add']:
mD_val.setText(meshQC_obj['meshQC_add']['minDeterminant'])
mD_chck.setChecked(True)
mD_val_pr.setEnabled(True)
mD_val_def.setEnabled(True)
mD_val.setEnabled(True)
#13)minFaceWeight
mFW_chck = QCheckBox()
mFW_chck_hbox = QHBoxLayout()
mFW_chck_hbox.setContentsMargins(0, 0, 0, 0)
mFW_chck_hbox.setAlignment(QtCore.Qt.AlignCenter)
mFW_chck_hbox.addWidget(mFW_chck)
mFW_chck_cell_widget = QWidget()
mFW_chck_cell_widget.setLayout(mFW_chck_hbox)
meshQC_prs_add_table.setCellWidget(12, 0, mFW_chck_cell_widget)
mFW_val_pr = QLabel()
mFW_val_pr.setEnabled(False)
mFW_val_pr.setText('minFaceWeight')
meshQC_prs_add_table.setCellWidget(12, 1, mFW_val_pr)
mFW_val_def = QLabel()
mFW_val_def.setEnabled(False)
meshQC_prs_add_table.setCellWidget(12, 2, mFW_val_def)
mFW_val = QDoubleSpinBox()
mFW_val.setEnabled(False)
mFW_val.setFixedSize(70, 25)
mFW_val_hbox = QHBoxLayout()
mFW_val_hbox.setContentsMargins(0, 0, 0, 0)
mFW_val_hbox.addWidget(mFW_val)
mFW_val_cell_widget = QWidget()
mFW_val_cell_widget.setLayout(mFW_val_hbox)
meshQC_prs_add_table.setCellWidget(12, 3, mFW_val_cell_widget)
if int_lng == 'Russian':
mFW_val_def.setText("Минимальный вес грани")
mFW_val.setToolTip("Введите число двойной точности")
elif int_lng == 'English':
mFW_val_def.setText("Minimum face weight")
mFW_val.setToolTip("Enter the double-precision number")
meshQC_chcks_list.append(mFW_chck)
meshQC_prs_list.append(mFW_val_pr)
meshQC_def_list.append(mFW_val_def)
meshQC_val_list.append(mFW_val)
if meshQC_obj != None:
if 'minFaceWeight' in meshQC_obj['meshQC_add']:
mFW_val.setValue(meshQC_obj['meshQC_add']['minFaceWeight'])
mFW_chck.setChecked(True)
mFW_val_pr.setEnabled(True)
mFW_val_def.setEnabled(True)
mFW_val.setEnabled(True)
#14)minVolRatio
mVR_chck = QCheckBox()
mVR_chck_hbox = QHBoxLayout()
mVR_chck_hbox.setContentsMargins(0, 0, 0, 0)
mVR_chck_hbox.setAlignment(QtCore.Qt.AlignCenter)
mVR_chck_hbox.addWidget(mVR_chck)
mVR_chck_cell_widget = QWidget()
mVR_chck_cell_widget.setLayout(mVR_chck_hbox)
meshQC_prs_add_table.setCellWidget(13, 0, mVR_chck_cell_widget)
mVR_val_pr = QLabel()
mVR_val_pr.setEnabled(False)
mVR_val_pr.setText('minVolRatio')
meshQC_prs_add_table.setCellWidget(13, 1, mVR_val_pr)
mVR_val_def = QLabel()
mVR_val_def.setEnabled(False)
meshQC_prs_add_table.setCellWidget(13, 2, mVR_val_def)
mVR_val = QDoubleSpinBox()
mVR_val.setEnabled(False)
mVR_val.setFixedSize(70, 25)
mVR_val_hbox = QHBoxLayout()
mVR_val_hbox.setContentsMargins(0, 0, 0, 0)
mVR_val_hbox.addWidget(mVR_val)
mVR_val_cell_widget = QWidget()
mVR_val_cell_widget.setLayout(mVR_val_hbox)
meshQC_prs_add_table.setCellWidget(13, 3, mVR_val_cell_widget)
if int_lng == 'Russian':
mVR_val_def.setText("Минимальное объемное соотношение соседних ячеек")
mVR_val.setToolTip("Введите число двойной точности")
elif int_lng == 'English':
mVR_val_def.setText("Minimum volume ratio of neighbouring cells")
mVR_val.setToolTip("Enter the double-precision number")
meshQC_chcks_list.append(mVR_chck)
meshQC_prs_list.append(mVR_val_pr)
meshQC_def_list.append(mVR_val_def)
meshQC_val_list.append(mVR_val)
if meshQC_obj != None:
if 'minVolRatio' in meshQC_obj['meshQC_add']:
mVR_val.setValue(meshQC_obj['meshQC_add']['minVolRatio'])
mVR_chck.setChecked(True)
mVR_val_pr.setEnabled(True)
mVR_val_def.setEnabled(True)
mVR_val.setEnabled(True)
#15)minTriangleTwist
mTT_chck = QCheckBox()
mTT_chck_hbox = QHBoxLayout()
mTT_chck_hbox.setContentsMargins(0, 0, 0, 0)
mTT_chck_hbox.setAlignment(QtCore.Qt.AlignCenter)
mTT_chck_hbox.addWidget(mTT_chck)
mTT_chck_cell_widget = QWidget()
mTT_chck_cell_widget.setLayout(mTT_chck_hbox)
meshQC_prs_add_table.setCellWidget(14, 0, mTT_chck_cell_widget)
mTT_val_pr = QLabel()
mTT_val_pr.setEnabled(False)
mTT_val_pr.setText('minTriangleTwist')
meshQC_prs_add_table.setCellWidget(14, 1, mTT_val_pr)
mTT_val_def = QLabel()
mTT_val_def.setEnabled(False)
meshQC_prs_add_table.setCellWidget(14, 2, mTT_val_def)
mTT_val = QLineEdit()
mTT_val.setEnabled(False)
mTT_val.setValidator(QtGui.QDoubleValidator(-999.0, 999.0, 1, mTT_val))
mTT_val.setFixedSize(70, 25)
mTT_val.setEnabled(False)
mTT_val.setFixedSize(70, 25)
mTT_val_hbox = QHBoxLayout()
mTT_val_hbox.setContentsMargins(0, 0, 0, 0)
mTT_val_hbox.addWidget(mTT_val)
mTT_val_cell_widget = QWidget()
mTT_val_cell_widget.setLayout(mTT_val_hbox)
meshQC_prs_add_table.setCellWidget(14, 3, mTT_val_cell_widget)
if int_lng == 'Russian':
mTT_val_def.setText("Минимальное треугольное скручивание")
mTT_val.setToolTip("Введите целое число, отрицательное или положительное")
elif int_lng == 'English':
mTT_val_def.setText("Minimum triangle twist")
mTT_val.setToolTip("Enter an integer, negative or positive")
meshQC_chcks_list.append(mTT_chck)
meshQC_prs_list.append(mTT_val_pr)
meshQC_def_list.append(mTT_val_def)
meshQC_val_list.append(mTT_val)
if meshQC_obj != None:
if 'minTriangleTwist' in meshQC_obj['meshQC_add']:
mTT_val.setText(meshQC_obj['meshQC_add']['minTriangleTwist'])
mTT_chck.setChecked(True)
mTT_val_pr.setEnabled(True)
mTT_val_def.setEnabled(True)
mTT_val.setEnabled(True)
#16)minVolCollapseRatio
mVCR_chck = QCheckBox()
mVCR_chck_hbox = QHBoxLayout()
mVCR_chck_hbox.setContentsMargins(0, 0, 0, 0)
mVCR_chck_hbox.setAlignment(QtCore.Qt.AlignCenter)
mVCR_chck_hbox.addWidget(mVCR_chck)
mVCR_chck_cell_widget = QWidget()
mVCR_chck_cell_widget.setLayout(mVCR_chck_hbox)
meshQC_prs_add_table.setCellWidget(15, 0, mVCR_chck_cell_widget)
mVCR_val_pr = QLabel()
mVCR_val_pr.setEnabled(False)
mVCR_val_pr.setText('minVolCollapseRatio')
meshQC_prs_add_table.setCellWidget(15, 1, mVCR_val_pr)
mVCR_val_def = QLabel()
mVCR_val_def.setEnabled(False)
meshQC_prs_add_table.setCellWidget(15, 2, mVCR_val_def)
mVCR_val = QDoubleSpinBox()
mVCR_val.setEnabled(False)
mVCR_val.setFixedSize(70, 25)
mVCR_val_hbox = QHBoxLayout()
mVCR_val_hbox.setContentsMargins(0, 0, 0, 0)
mVCR_val_hbox.addWidget(mVCR_val)
mVCR_val_cell_widget = QWidget()
mVCR_val_cell_widget.setLayout(mVCR_val_hbox)
meshQC_prs_add_table.setCellWidget(15, 3, mVCR_val_cell_widget)
if int_lng == 'Russian':
mVCR_val_def.setText("Минимальный коэффициент сглаживания объема")
mVCR_val.setToolTip("Введите дробное или целое число")
elif int_lng == 'English':
mVCR_val_def.setText("Minimum volume smoothing ratio")
mVCR_val.setToolTip("Enter a fractional or an integer value")
meshQC_chcks_list.append(mVCR_chck)
meshQC_prs_list.append(mVCR_val_pr)
meshQC_def_list.append(mVCR_val_def)
meshQC_val_list.append(mVCR_val)
if meshQC_obj != None:
if 'minVolCollapseRatio' in meshQC_obj['meshQC_add']:
mVCR_val.setValue(meshQC_obj['meshQC_add']['minVolCollapseRatio'])
mVCR_chck.setChecked(True)
mVCR_val_pr.setEnabled(True)
mVCR_val_def.setEnabled(True)
mVCR_val.setEnabled(True)
prs_grid.addWidget(meshQC_prs_add_table, 0, 0, alignment=QtCore.Qt.AlignCenter)
prs_frame = QFrame()
prs_frame.setLayout(prs_grid)
# -------------------------Кнопка сохранения --------------------------#
meshQC_btnSave = QPushButton()
meshQC_btnSave.setFixedSize(80, 25)
buttons_hbox = QHBoxLayout()
buttons_hbox.addWidget(meshQC_btnSave)
if int_lng == 'Russian':
meshQC_btnSave.setText("Записать")
elif int_lng == 'English':
meshQC_btnSave.setText("Write")
# -----------------------Групповой элемент формы-----------------------#
meshQC_grid = QGridLayout()
meshQC_grid.addWidget(main_lbl, 0, 0, alignment=QtCore.Qt.AlignCenter)
meshQC_grid.addWidget(prs_frame, 1, 0, alignment=QtCore.Qt.AlignCenter)
meshQC_grid.addLayout(buttons_hbox, 2, 0, alignment=QtCore.Qt.AlignCenter)
meshQC_grid.setRowStretch(3, 6)
meshQC_group = QGroupBox()
meshQC_group.setLayout(meshQC_grid)
return meshQC_group, meshQC_btnSave, meshQC_prs_add_table, meshQC_chcks_list, meshQC_prs_list, meshQC_def_list, meshQC_val_list
def inserisci_elemento_in_tabella(self, elemento, row, index):
item = QTableWidgetItem()
item.setText(str(elemento))
item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.table_widget.setItem(row, index, item)
def show_doc_list(self, tbody):
selector = etree.HTML(tbody) # 转换为lxml解析的对象
contents = selector.xpath(
'//div/div[@data-type="file"]/div[@data-type="file"]/a/text()'
) # 这里返回的是一个列表
messages = selector.xpath(
'//div/div[@data-type="file"]/div/div[@class="commit-details"]/a/text()'
) # 这里返回的是一个列表
print(contents)
print(messages)
self.TableWidget = QTableWidget()
self.TableWidget.setColumnCount(3) # 表格共有四列
self.TableWidget.verticalHeader().setVisible(False) # 隐藏垂直表头
self.TableWidget.horizontalHeader().setVisible(True) # 显示水平表头
font = QFont('微软雅黑', 10)
font.setBold(True) #设置字体加粗
self.TableWidget.horizontalHeader().setFont(font) #设置表头字体
# self.TableWidget.setFrameShape(QFrame.NoFrame) ##设置无表格的外框
self.TableWidget.horizontalHeader().setFixedHeight(25) ##设置表头高度
self.TableWidget.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Stretch) #设置第一列宽度自动调整，充满屏幕
# self.TableWidget.horizontalHeader().setStretchLastSection(True) ##设置最后一列拉伸至最大
self.TableWidget.setHorizontalHeaderLabels(['文档名称', '文档介绍',
'操作']) #设置表头内容
self.TableWidget.horizontalHeader().setSectionsClickable(False)
self.TableWidget.horizontalHeader().setStyleSheet(
'QHeaderView::section{background:green}') #设置表头的背景色为绿色
self.TableWidget.setEditTriggers(
QAbstractItemView.NoEditTriggers) # 不可编辑
self.TableWidget.setSelectionBehavior(
QAbstractItemView.SelectRows) #只能选择整行
self.TableWidget.setColumnWidth(1, 230)
self.TableWidget.setColumnWidth(2, 80)
rows = self.TableWidget.rowCount()
rows_index = 0
if not messages:
for i in range(len(contents)):
messages.append("获取失败")
for content, message in zip(contents, messages):
content = content.strip() # 去掉字符左右的空格
message = message.strip()
self.TableWidget.setRowCount(rows_index + 1)
self.TableWidget.setItem(rows_index, 0, QTableWidgetItem(content))
self.TableWidget.setItem(rows_index, 1, QTableWidgetItem(message))
self.TableWidget.setCellWidget(rows_index, 2,
self.buttonForRow(rows_index))
rows_index += 1
self.TableWidget.setGeometry(15, 10, 300, 300)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.TableWidget)
return 0
def defaultsPushButtonPressed(self, button):
self.persepolis_setting.beginGroup('settings')
self.setting_dict = returnDefaultSettings()
self.tries_spinBox.setValue(int(self.setting_dict['max-tries']))
self.wait_spinBox.setValue(int(self.setting_dict['retry-wait']))
self.time_out_spinBox.setValue(int(self.setting_dict['timeout']))
self.connections_spinBox.setValue(int(
self.setting_dict['connections']))
self.rpc_port_spinbox.setValue(int(self.setting_dict['rpc-port']))
self.aria2_path_lineEdit.setText('')
self.aria2_path_checkBox.setChecked(False)
# wait-queue
wait_queue_list = self.setting_dict['wait-queue']
q_time = QTime(wait_queue_list[0], wait_queue_list[1])
self.wait_queue_time.setTime(q_time)
# save_as_tab
self.download_folder_lineEdit.setText(
str(self.setting_dict['download_path']))
self.temp_download_lineEdit.setText(
str(self.setting_dict['download_path_temp']))
self.subfolder_checkBox.setChecked(True)
# notifications_tab
self.volume_label.setText('Volume : ' +
str(self.setting_dict['sound-volume']))
self.volume_dial.setValue(int(self.setting_dict['sound-volume']))
# set style
current_style_index = self.style_comboBox.findText(
str(self.setting_dict['style']))
self.style_comboBox.setCurrentIndex(current_style_index)
# set language
current_locale = self.lang_comboBox.findData(
str(self.setting_dict['locale']))
self.lang_comboBox.setCurrentIndex(current_locale)
# set color_scheme
current_color_index = self.color_comboBox.findText(
str(self.setting_dict['color-scheme']))
self.color_comboBox.setCurrentIndex(current_color_index)
# set icons
current_icons_index = self.icon_comboBox.findText(
str(self.setting_dict['icons']))
self.icon_comboBox.setCurrentIndex(current_icons_index)
# set icons size
current_icons_size_index = self.icons_size_comboBox.findText(
str(self.setting_dict['toolbar_icon_size']))
self.icons_size_comboBox.setCurrentIndex(current_icons_size_index)
# set notification
current_notification_index = self.notification_comboBox.findText(
str(self.setting_dict['notification']))
self.notification_comboBox.setCurrentIndex(current_notification_index)
# set font
self.font_checkBox.setChecked(False)
font_setting = QFont()
font_setting.setFamily(str(self.setting_dict['font']))
self.fontComboBox.setCurrentFont(font_setting)
self.font_size_spinBox.setValue(int(self.setting_dict['font-size']))
# sound frame
self.enable_notifications_checkBox.setChecked(True)
# start_persepolis_if_browser_executed_checkBox
self.start_persepolis_if_browser_executed_checkBox.setChecked(True)
# hide window
self.hide_window_checkBox.setChecked(True)
# tray icon
self.enable_system_tray_checkBox.setChecked(True)
# after_download_checkBox
self.after_download_checkBox.setChecked(True)
# hide menubar for linux
if platform.system == 'Darwin':
self.show_menubar_checkbox.setChecked(True)
else:
self.show_menubar_checkbox.setChecked(False)
# show side panel
self.show_sidepanel_checkbox.setChecked(True)
# show progress window
self.show_progress_window_checkbox.setChecked(True)
# run persepolis at startup checkBox
self.startup_checkbox.setChecked(False)
# keep_awake_checkBox
self.keep_awake_checkBox.setChecked(False)
# columns_tab
self.column0_checkBox.setChecked(True)
self.column1_checkBox.setChecked(True)
self.column2_checkBox.setChecked(True)
self.column3_checkBox.setChecked(True)
self.column4_checkBox.setChecked(True)
self.column5_checkBox.setChecked(True)
self.column6_checkBox.setChecked(True)
self.column7_checkBox.setChecked(True)
self.column10_checkBox.setChecked(True)
self.column11_checkBox.setChecked(True)
self.column12_checkBox.setChecked(True)
# video finder
self.max_links_spinBox.setValue(3)
# shortcuts
self.shortcuts_list = [
self.setting_dict['shortcuts/quit_shortcut'],
self.setting_dict['shortcuts/hide_window_shortcut'],
self.setting_dict['shortcuts/remove_shortcut'],
self.setting_dict['shortcuts/delete_shortcut'],
self.setting_dict['shortcuts/move_up_selection_shortcut'],
self.setting_dict['shortcuts/move_down_selection_shortcut'],
self.setting_dict['shortcuts/add_new_download_shortcut'],
self.setting_dict['shortcuts/video_finder_shortcut'],
self.setting_dict['shortcuts/import_text_shortcut']
]
# add shortcuts to the shortcut_table
j = 0
for shortcut in self.shortcuts_list:
item = QTableWidgetItem(shortcut)
# align center
item.setTextAlignment(0x0004 | 0x0080)
# insert item in shortcut_table
self.shortcut_table.setItem(j, 1, item)
j = j + 1
self.persepolis_setting.endGroup()
def __init__(self, parent, persepolis_setting):
super().__init__(persepolis_setting)
self.persepolis_setting = persepolis_setting
self.parent = parent
self.grandparent = parent.persepolis_main
self.persepolis_setting.beginGroup('settings')
# initialization
self.tries_spinBox.setValue(
int(self.persepolis_setting.value('max-tries')))
self.wait_spinBox.setValue(
int(self.persepolis_setting.value('retry-wait')))
self.time_out_spinBox.setValue(
int(self.persepolis_setting.value('timeout')))
self.connections_spinBox.setValue(
int(self.persepolis_setting.value('connections')))
self.rpc_port_spinbox.setValue(
int(self.persepolis_setting.value('rpc-port')))
# add support for other languages
locale = str(self.persepolis_setting.value('settings/locale'))
QLocale.setDefault(QLocale(locale))
self.translator = QTranslator()
if self.translator.load(':/translations/locales/ui_' + locale, 'ts'):
QCoreApplication.installTranslator(self.translator)
# wait_queue
wait_queue_list = self.persepolis_setting.value('wait-queue')
q_time = QTime(int(wait_queue_list[0]), int(wait_queue_list[1]))
self.wait_queue_time.setTime(q_time)
# change aria2 path
self.aria2_path_pushButton.clicked.connect(self.changeAria2Path)
self.aria2_path_checkBox.toggled.connect(self.ariaCheckBoxToggled)
aria2_path = self.persepolis_setting.value('settings/aria2_path')
self.aria2_path_lineEdit.setEnabled(False)
if aria2_path != None:
self.aria2_path_checkBox.setChecked(True)
self.aria2_path_lineEdit.setText(str(aria2_path))
self.ariaCheckBoxToggled('aria2')
if os_type == 'Linux' or os_type == 'FreeBSD' or os_type == 'OpenBSD':
for widget in self.aria2_path_checkBox, self.aria2_path_lineEdit, self.aria2_path_pushButton:
widget.hide()
# save_as_tab
self.download_folder_lineEdit.setText(
str(self.persepolis_setting.value('download_path')))
self.temp_download_lineEdit.setText(
str(self.persepolis_setting.value('download_path_temp')))
# subfolder
if str(self.persepolis_setting.value('subfolder')) == 'yes':
self.subfolder_checkBox.setChecked(True)
else:
self.subfolder_checkBox.setChecked(False)
# notifications_tab
self.volume_label.setText(
'Volume : ' + str(self.persepolis_setting.value('sound-volume')))
self.volume_dial.setValue(
int(self.persepolis_setting.value('sound-volume')))
# set style
# find available styles(It's depends on operating system and desktop environments).
available_styles = QStyleFactory.keys()
for style in available_styles:
# 'GTK' or 'gtk' styles may cause to crashing! Eliminate them!
if 'gtk' not in str(style) and 'GTK' not in str(style):
self.style_comboBox.addItem(style)
# System >> for system default style
# when user select System for style section, the default system style is using.
self.style_comboBox.addItem('System')
current_style_index = self.style_comboBox.findText(
str(self.persepolis_setting.value('style')))
if current_style_index != -1:
self.style_comboBox.setCurrentIndex(current_style_index)
# available language
available_language = [
'en_US', 'fa_IR', 'ar', 'zh_CN', 'fr_FR', 'pl_PL', 'nl_NL',
'pt_BR', 'es_ES', 'hu', 'tr', 'tr_TR'
]
for lang in available_language:
self.lang_comboBox.addItem(str(QLocale(lang).nativeLanguageName()),
lang)
current_locale = self.lang_comboBox.findData(
str(self.persepolis_setting.value('locale')))
self.lang_comboBox.setCurrentIndex(current_locale)
self.current_icon = self.persepolis_setting.value('icons')
# icon size
size = ['128', '64', '48', '32', '24', '16']
self.icons_size_comboBox.addItems(size)
current_icons_size_index = self.icons_size_comboBox.findText(
str(self.persepolis_setting.value('toolbar_icon_size')))
self.icons_size_comboBox.setCurrentIndex(current_icons_size_index)
# call setDarkLightIcon if index is changed
self.icons_size_comboBox.currentIndexChanged.connect(
self.setDarkLightIcon)
# set notification
notifications = ['Native notification', 'QT notification']
self.notification_comboBox.addItems(notifications)
current_notification_index = self.notification_comboBox.findText(
str(self.persepolis_setting.value('notification')))
self.notification_comboBox.setCurrentIndex(current_notification_index)
# set font
font_setting = QFont()
font_setting.setFamily(str(self.persepolis_setting.value('font')))
self.fontComboBox.setCurrentFont(font_setting)
self.font_size_spinBox.setValue(
int(self.persepolis_setting.value('font-size')))
# sound frame
self.sound_frame.setEnabled(False)
self.enable_notifications_checkBox.toggled.connect(self.soundFrame)
if str(self.persepolis_setting.value('sound')) == 'yes':
self.enable_notifications_checkBox.setChecked(True)
else:
self.enable_notifications_checkBox.setChecked(False)
# connect folder buttons
self.download_folder_lineEdit.setEnabled(False)
self.download_folder_pushButton.clicked.connect(
self.downloadFolderPushButtonClicked)
self.temp_download_lineEdit.setEnabled(False)
self.temp_download_pushButton.clicked.connect(
self.tempDownloadPushButtonClicked)
# dial
self.volume_dial.setNotchesVisible(True)
self.volume_dial.valueChanged.connect(self.dialChanged)
# start_persepolis_if_browser_executed_checkBox
if str(self.persepolis_setting.value('browser-persepolis')) == 'yes':
self.start_persepolis_if_browser_executed_checkBox.setChecked(True)
else:
self.start_persepolis_if_browser_executed_checkBox.setChecked(
False)
# hide window
if str(self.persepolis_setting.value('hide-window')) == 'yes':
self.hide_window_checkBox.setChecked(True)
else:
self.hide_window_checkBox.setChecked(False)
# tray icon
if str(self.persepolis_setting.value('tray-icon')) == 'yes':
self.enable_system_tray_checkBox.setChecked(True)
else:
self.enable_notifications_checkBox.setChecked(False)
# show_menubar
if str(self.persepolis_setting.value('show-menubar')) == 'yes':
self.show_menubar_checkbox.setChecked(True)
else:
self.show_menubar_checkbox.setChecked(False)
if platform.system() == 'Darwin':
self.show_menubar_checkbox.setChecked(True)
self.show_menubar_checkbox.hide()
# show_sidepanel
if str(self.persepolis_setting.value('show-sidepanel')) == 'yes':
self.show_sidepanel_checkbox.setChecked(True)
else:
self.show_sidepanel_checkbox.setChecked(False)
# show ProgressWindow
if str(self.persepolis_setting.value('show-progress')) == 'yes':
self.show_progress_window_checkbox.setChecked(True)
else:
self.show_progress_window_checkbox.setChecked(False)
# after download dialog
if str(self.persepolis_setting.value('after-dialog')) == 'yes':
self.after_download_checkBox.setChecked(True)
else:
self.after_download_checkBox.setChecked(False)
# run persepolis at startup checkBox
if str(self.persepolis_setting.value('startup')) == 'yes':
self.startup_checkbox.setChecked(True)
else:
self.startup_checkbox.setChecked(False)
# font_checkBox
if str(self.persepolis_setting.value('custom-font')) == 'yes':
self.font_checkBox.setChecked(True)
else:
self.font_checkBox.setChecked(False)
self.fontCheckBoxState(self.font_checkBox)
# keep_awake_checkBox
if str(self.persepolis_setting.value('awake')) == 'yes':
self.keep_awake_checkBox.setChecked(True)
else:
self.keep_awake_checkBox.setChecked(False)
# columns_tab
if str(self.persepolis_setting.value('column0')) == 'yes':
self.column0_checkBox.setChecked(True)
else:
self.column0_checkBox.setChecked(False)
if str(self.persepolis_setting.value('column1')) == 'yes':
self.column1_checkBox.setChecked(True)
else:
self.column1_checkBox.setChecked(False)
if str(self.persepolis_setting.value('column2')) == 'yes':
self.column2_checkBox.setChecked(True)
else:
self.column2_checkBox.setChecked(False)
if str(self.persepolis_setting.value('column3')) == 'yes':
self.column3_checkBox.setChecked(True)
else:
self.column3_checkBox.setChecked(False)
if str(self.persepolis_setting.value('column4')) == 'yes':
self.column4_checkBox.setChecked(True)
else:
self.column4_checkBox.setChecked(False)
if str(self.persepolis_setting.value('column5')) == 'yes':
self.column5_checkBox.setChecked(True)
else:
self.column5_checkBox.setChecked(False)
if str(self.persepolis_setting.value('column6')) == 'yes':
self.column6_checkBox.setChecked(True)
else:
self.column6_checkBox.setChecked(False)
if str(self.persepolis_setting.value('column7')) == 'yes':
self.column7_checkBox.setChecked(True)
else:
self.column7_checkBox.setChecked(False)
if str(self.persepolis_setting.value('column10')) == 'yes':
self.column10_checkBox.setChecked(True)
else:
self.column10_checkBox.setChecked(False)
if str(self.persepolis_setting.value('column11')) == 'yes':
self.column11_checkBox.setChecked(True)
else:
self.column11_checkBox.setChecked(False)
if str(self.persepolis_setting.value('column12')) == 'yes':
self.column12_checkBox.setChecked(True)
else:
self.column12_checkBox.setChecked(False)
# video_finder
try: # Integer casting may raise exception.
self.max_links_spinBox.setValue(
int(persepolis_setting.value('video_finder/max_links', 3)))
except:
pass
# shortcuts
self.qshortcuts_list = [
self.parent.exitAction_shortcut,
self.parent.minimizeAction_shortcut,
self.parent.removeSelectedAction_shortcut,
self.parent.deleteSelectedAction_shortcut,
self.parent.moveUpSelectedAction_shortcut,
self.parent.moveDownSelectedAction_shortcut,
self.parent.addlinkAction_shortcut,
self.parent.videoFinderAddLinkAction_shortcut,
self.parent.addtextfileAction_shortcut
]
self.shortcuts_list = [
self.parent.exitAction_shortcut.key().toString(),
self.parent.minimizeAction_shortcut.key().toString(),
self.parent.removeSelectedAction_shortcut.key().toString(),
self.parent.deleteSelectedAction_shortcut.key().toString(),
self.parent.moveUpSelectedAction_shortcut.key().toString(),
self.parent.moveDownSelectedAction_shortcut.key().toString(),
self.parent.addlinkAction_shortcut.key().toString(),
self.parent.videoFinderAddLinkAction_shortcut.key().toString(),
self.parent.addtextfileAction_shortcut.key().toString()
]
# add shortcuts to the shortcut_table
j = 0
for shortcut in self.shortcuts_list:
item = QTableWidgetItem(shortcut)
# align center
item.setTextAlignment(0x0004 | 0x0080)
# insert item in shortcut_table
self.shortcut_table.setItem(j, 1, item)
j = j + 1
# If user doubleclicks on a row, then run showCaptureKeyboardWindow method
self.shortcut_table.itemDoubleClicked.connect(
self.showCaptureKeyboardWindow)
# ok cancel default button
self.cancel_pushButton.clicked.connect(self.close)
self.defaults_pushButton.clicked.connect(
self.defaultsPushButtonPressed)
self.ok_pushButton.clicked.connect(self.okPushButtonPressed)
# font_checkBox connect
self.font_checkBox.stateChanged.connect(self.fontCheckBoxState)
# saving initial value of self.persepolis_setting in self.first_key_value_dict
# at the end! in the okPushButtonPressed method, first_key_value_dict will compared with second_key_value_dict.
# if any thing changed , then a message box notify user about "some changes take effect after restarting persepolis".
self.first_key_value_dict = {}
for member in self.persepolis_setting.allKeys():
self.first_key_value_dict[member] = str(
self.persepolis_setting.value(member))
# if style_comboBox is changed, self.styleComboBoxChanged is called.
self.style_comboBox.currentIndexChanged.connect(
self.styleComboBoxChanged)
self.styleComboBoxChanged()
self.color_comboBox.currentIndexChanged.connect(self.setDarkLightIcon)
self.persepolis_setting.endGroup()
# setting window size and position
size = self.persepolis_setting.value('PreferencesWindow/size',
QSize(578, 565))
position = self.persepolis_setting.value('PreferencesWindow/position',
QPoint(300, 300))
self.resize(size)
self.move(position)
def __init__(self):
super().__init__()
self.tableWidget = QTableWidget()
self.tableWidget.setColumnCount(3)
self.tableWidget.setHorizontalHeaderItem(0,
QTableWidgetItem("process"))
self.tableWidget.setHorizontalHeaderItem(
1, QTableWidgetItem("Arrival Time"))
self.tableWidget.setHorizontalHeaderItem(
2, QTableWidgetItem("Burst Time"))
self.main_label = QLabel("SJF (Preemptive)")
self.main_label.setFont(QtGui.QFont("sanserif", 30))
self.main_label.setStyleSheet("color : #800000")
self.TA = QLabel("")
self.TA.setFont(QtGui.QFont("sanserif", 20))
self.TA.setStyleSheet("color : #800000")
self.WT = QLabel("")
self.WT.setFont(QtGui.QFont("sanserif", 20))
self.WT.setStyleSheet("color : #800000")
self.plot_graph = 0
self.colors_list = 0
self.process_name_label = QLabel("Enter process name : ")
self.Process_name_input = QLineEdit()
self.process_number_label = QLabel("Enter number of processes : ")
self.Process_number_input = QLineEdit()
self.burst_time_label = QLabel("Enter burst time : ")
self.burst_time_input = QLineEdit()
self.arrival_time_label = QLabel("Enter arrival time : ")
self.arrival_time_input = QLineEdit()
self.add_btn = QPushButton('Add Process')
self.plot_btn = QPushButton('Plot')
self.back_btn = QPushButton('Back')
self.process_number_added_btn = QPushButton('Next')
self.count = 0
self.sorted_list = process.processList()
self.h_box1 = QHBoxLayout()
self.h_box1.addStretch()
self.h_box1.addWidget(self.add_btn)
self.h_box1.addStretch()
self.h_box3 = QHBoxLayout()
self.main_init()
self.h_box4 = QHBoxLayout()
self.h_box4.addStretch()
self.h_box4.addWidget(self.plot_btn)
self.h_box4.addStretch()
self.h_box5 = QHBoxLayout()
self.h_box5.addStretch()
self.h_box5.addWidget(self.process_number_added_btn)
self.h_box5.addStretch()
self.h_box_back = QHBoxLayout()
self.h_box_back.addStretch()
self.h_box_back.addWidget(self.back_btn)
self.h_box_back.addStretch()
self.v_box1 = QVBoxLayout()
self.v_box1.addLayout(self.h_box3)
self.v_box1.addWidget(self.process_number_label)
self.v_box1.addWidget(self.Process_number_input)
self.v_box1.addWidget(self.process_name_label)
self.v_box1.addWidget(self.Process_name_input)
self.v_box1.addWidget(self.burst_time_label)
self.v_box1.addWidget(self.burst_time_input)
self.v_box1.addWidget(self.arrival_time_label)
self.v_box1.addWidget(self.arrival_time_input)
self.v_box1.addLayout(self.h_box1)
self.v_box1.addLayout(self.h_box4)
self.v_box1.addLayout(self.h_box5)
self.v_box1.addLayout(self.h_box_back)
self.v_box1.addWidget(self.tableWidget)
self.v_box1.addWidget(self.TA)
self.v_box1.addWidget(self.WT)
self.v_box1.addStretch()
self.setLayout(self.v_box1)
self.show_process_number_input()
self.add_btn.clicked.connect(self.add_btn_click)
self.plot_btn.clicked.connect(self.plot_btn_click)
self.back_btn.clicked.connect(self.back_btn_click)
self.process_number_added_btn.clicked.connect(
self.process_number_added_btn_click)
self.show()
def Actualizar(self):
nombre = " ".join(self.lineEditNombre.text().split()).title()
apellido = " ".join(self.lineEditApellido.text().split()).title()
sexo = self.comboBoxSexo.currentText()
fecNacimiento = self.dateEditFechaNacimiento.text()
pais = " ".join(self.lineEditPais.text().split()).title()
telCel = self.lineEditTelCel.text()
if not nombre:
self.lineEditNombre.setFocus()
elif not apellido:
self.lineEditApellido.setFocus()
elif not sexo:
self.comboBoxSexo.setFocus()
elif not pais:
self.lineEditPais.setFocus()
elif not telCel:
self.lineEditTelCel.setFocus()
else:
if QFile.exists("DB_SIACLE/DB_SIACLE.db"):
conexion = sqlite3.connect("DB_SIACLE/DB_SIACLE.db")
cursor = conexion.cursor()
try:
datos = [nombre, apellido, sexo, fecNacimiento, pais, telCel,
self.datos[0]]
cursor.execute("UPDATE CLIENTES SET NOMBRE = ?, APELLIDO = ?, SEXO = ?, "
"FECHA_NACIMIENTO = ?, PAIS = ?, TELEFONO_CELULAR = ? "
"WHERE ID = ?", datos)
conexion.commit()
conexion.close()
nuevos_datos = (str(self.datos[0]), nombre, apellido, sexo, fecNacimiento,
pais, telCel)
self.parent.tabla.removeRow(self.indice)
numFilas = self.parent.tabla.rowCount()
self.parent.tabla.insertRow(numFilas)
for indice, dato in enumerate(nuevos_datos):
dato = QTableWidgetItem(dato)
if indice == 0:
dato.setTextAlignment(Qt.AlignCenter)
self.parent.tabla.setItem(numFilas, indice, dato)
self.lineEditNombre.clear()
self.lineEditApellido.clear()
self.comboBoxSexo.setCurrentIndex(-1)
self.dateEditFechaNacimiento.setDate(QDate.currentDate())
self.lineEditPais.clear()
self.lineEditTelCel.clear()
QMessageBox.information(self, "Actualizar cliente", "Cliente actualizado."
" ", QMessageBox.Ok)
self.close()
except:
conexion.close()
QMessageBox.critical(self, "Actualizar cliente", "Error desconocido. ",
QMessageBox.Ok)
else:
QMessageBox.critical(self, "Actualizar cliente", "No se encontro la base de "
"datos. ", QMessageBox.Ok)
def initUI(self):
self.setWindowTitle("设置单元格尺寸")
self.resize(430, 230)
layout = QHBoxLayout()
tableWidget = QTableWidget()
tableWidget.setRowCount(4)
tableWidget.setColumnCount(3)
layout.addWidget(tableWidget)
tableWidget.setHorizontalHeaderLabels(['姓名', '性别', '体重（KG）'])
tableWidget.setRowHeight(0, 80)
tableWidget.setColumnWidth(2, 120)
tableWidget.setRowHeight(2, 100)
newItem = QTableWidgetItem('雷神')
newItem.setFont(QFont('Times', 14, QFont.Black))
newItem.setForeground(QBrush(QColor(255, 0, 0)))
tableWidget.setItem(0, 0, newItem)
newItem = QTableWidgetItem('女')
newItem.setForeground(QBrush(QColor(255, 255, 0)))
newItem.setBackground(QBrush(QColor(0, 0, 255)))
tableWidget.setItem(0, 1, newItem)
newItem = QTableWidgetItem('160')
newItem.setFont(QFont('Times', 20, QFont.Black))
newItem.setForeground(QBrush(QColor(0, 0, 255)))
tableWidget.setItem(0, 2, newItem)
self.setLayout(layout)
def make_item(value):
item = QTableWidgetItem(value)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
return item
def paste_table(self):
excel_document = openpyxl.load_workbook('form.xlsx')
sheet = excel_document["A샘플-주간"]
#sheet = excel_document["B샘플-야간"]
row_len = sheet.max_row # 길이가 인식 안됨
self.table.clearContents()
for idx in range(4,row_len+1):
print(idx)
teacher = sheet.cell(row=idx, column=3).value
item = QTableWidgetItem(str(teacher))
item.setTextAlignment(Qt.AlignVCenter | Qt.AlignCenter)
self.table.setItem(idx-4, 0, item)
start_ac = sheet.cell(row=idx, column=14).value
item = QTableWidgetItem(str(start_ac))
item.setTextAlignment(Qt.AlignVCenter | Qt.AlignRight)
self.table.setItem(idx - 4, 1, item)
end_ac = sheet.cell(row=idx, column=15).value
item = QTableWidgetItem(str(end_ac))
item.setTextAlignment(Qt.AlignVCenter | Qt.AlignRight)
self.table.setItem(idx - 4, 2, item)
client = sheet.cell(row=idx, column=7).value
item = QTableWidgetItem(str(client))
item.setTextAlignment(Qt.AlignVCenter | Qt.AlignCenter)
self.table.setItem(idx - 4, 3,item)
child = sheet.cell(row=idx, column=11).value
item = QTableWidgetItem(str(child))
item.setTextAlignment(Qt.AlignVCenter | Qt.AlignCenter)
self.table.setItem(idx - 4, 4, item)
day_of_week = sheet.cell(row=idx, column=16).value
item = QTableWidgetItem(str(day_of_week))
item.setTextAlignment(Qt.AlignVCenter | Qt.AlignCenter)
self.table.setItem(idx - 4, 5, item)
total_time = sheet.cell(row=idx, column=17).value
item = QTableWidgetItem(str(total_time)+" 시간")
item.setTextAlignment(Qt.AlignVCenter | Qt.AlignRight)
self.table.setItem(idx - 4, 6, item)
excel_document.close()
def fill_row(self, row, data):
for index, elem in enumerate(data):
item = QTableWidgetItem(str(elem))
item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEditable)
self.table.setItem(row, index, item)
l = QLabel("label", root) # output
l.move(40, 50)
table = QTableWidget(root) # table
table.setRowCount(2)
table.setColumnCount(3)
table.setGeometry(60, 70, 300, 300)
def c():
for b1 in table.selectedItems():
print(b1.row(), b1.column(), b1.text())
table.clicked.connect(c)
table.setItem(0, 0, QTableWidgetItem('1'))
table.setItem(0, 1, QTableWidgetItem('2'))
table.setItem(0, 2, QTableWidgetItem('3'))
table.setItem(1, 0, QTableWidgetItem('4'))
table.setItem(1, 1, QTableWidgetItem('5'))
table.setItem(1, 2, QTableWidgetItem('6'))
table.setHorizontalHeaderLabels(str("num1:num2:num3:").split(":"))
table.setVerticalHeaderLabels(str("a*b").split("*"))
i = QInputDialog.getInt(root, 'cal', 'enter number', 12, 0, 100,
2) # bahave as a list
x = QInputDialog.getText(root, '2021', 'enter name', QLineEdit.Normal)
v = ('yellow', 'black', 'white', 'blue')
c = QInputDialog.getItem(root, 'background', 'enter your color', v)
lab = QLabel(root) # picture
def build_aa_layout(self, pak):
trees_id = self.get_tree_tabs(pak)
trees_info = eq2s_func.get_db_content('aatree', 'id', trees_id)
self.aa_maxpoints = {}
self.aa_clickedpoints = {}
self.aa_points_display = {}
# store aa tabs
self.aa_tables = {}
tradeskilltabs = []
# adventure tabs
for each in sorted(trees_id):
name = trees_info[each]['name']
# store all tradeskill aa tab into a list, and make all of them next to adventure tabs.
if name in ['Tradeskill', 'General', 'Far Seas']:
tradeskilltabs.append(each)
continue
# jumping to tabs creating function
tab = self.create_tabs(each)
self.aa_maxpoints[each] = trees_info[each][
'maxpointsperlevelnode_list'][-1]['maxpoints']
self.aa_clickedpoints[each] = 0
self.aa_points_display[each].setText('{} / {}'.format(
self.aa_clickedpoints[each], self.aa_maxpoints[each]))
self.tab_widget.addTab(tab, name)
# tradeskill tabs
for each in tradeskilltabs:
tab = self.create_tabs(each)
self.aa_maxpoints[each] = trees_info[each][
'maxpointsperlevelnode_list'][-1]['maxpoints']
self.aa_clickedpoints[each] = 0
self.aa_points_display[each].setText('{} / {}'.format(
self.aa_clickedpoints[each], self.aa_maxpoints[each]))
self.tab_widget.addTab(tab, trees_info[each]['name'])
self.splnodes = {}
# construct the aa layout
try:
for e1 in trees_info:
grid_n = eq2s_func.get_aa_tree_grid_modifier(
trees_info[e1]['name'])
for e2 in trees_info[e1]['alternateadvancementnode_list']:
epicon = QTableWidgetItem()
epicon.setFont(QFont("Times", 15, QFont.Black))
# get the crc group spells from local databases, cuz only one target provide,
# so I just extract the only list from the returned dict.
crcs = eq2s_func.get_db_content(
'crcspl', 'crc', (e2['spellcrc'], ))[e2['spellcrc']]
# this dict intend to save ordered level(tier) crc spells, the keys means tier of this spell.
crcdict = {}
for each in crcs:
crcdict[each['tier']] = each
epicon.setData(1000, crcdict)
self.splnodes[e2['nodeid']] = epicon
epicon.setToolTip(eq2s_func.CookSpellText(crcs[0]))
icon = QIcon()
iconid = epicon.data(1000)[1]['icon']['id']
# backiconid = epicon.data(1000)[0]['icon']['backdrop']
icon.addPixmap(
eq2s_func.get_pixmap_in_db(iconid, 'spellicons'))
# epicon.setBackground(QBrush(eq2s_func.get_pixmap_in_db(backiconid, 'spellicons')))
epicon.setIcon(icon)
self.aa_tables[e1].setItem(
int(e2['ycoord'] * grid_n['y'] + 1),
int(e2['xcoord'] * grid_n['x'] + 1), epicon)
except BaseException as err:
QMessageBox().critical(self, 'Loading Error',
'Something Bad Happen:\n{}'.format(err))
print(err)
return
self.fresh_tables()
self.throw_aas(pak)
def show_final_result(self, col, row, value):
value = str(value)
self.tbl_rng.setItem(row, col, QTableWidgetItem(value))
row += 1
return row
def show_moves(self):
exchanges = sorted(self._CTMain._Crypto_Trader.
_map_exchange_code_to_currency_code.keys())
column_names = ['BaseCode', 'CurrencyCode'
] + exchanges + ['Average 24-Hour Move']
markets = self._CTMain._Crypto_Trader.load_24hour_moves()
moves = []
for code_base in markets:
for code_curr in markets[code_base]:
total_move = 0
exchange_counter = 0
entry = {'BaseCode': code_base, 'CurrencyCode': code_curr}
for exchange in markets[code_base][code_curr].keys():
entry[exchange] = markets[code_base][code_curr][
exchange].get('24HrPercentMove', 0)
total_move += entry[exchange]
exchange_counter += 1
if exchange_counter > 0:
entry[
'Avg_24HrPercentMove'] = total_move / exchange_counter
moves.append(entry)
ordered_market_moves = sorted(moves,
key=itemgetter('Avg_24HrPercentMove'),
reverse=True)
n_columns = len(column_names)
self._tableWidget.setRowCount(len(ordered_market_moves))
self._tableWidget.setColumnCount(n_columns)
self._tableWidget.verticalHeader().hide()
self._tableWidget.setHorizontalHeaderLabels(column_names)
cell_index = 0
for move in ordered_market_moves:
self._tableWidget.setItem(cell_index, 0,
QTableWidgetItem(move['BaseCode']))
self._tableWidget.setItem(cell_index, 1,
QTableWidgetItem(move['CurrencyCode']))
for exchange_i in range(len(exchanges)):
if exchanges[exchange_i] in move:
self._tableWidget.setItem(
cell_index, exchange_i + 2,
QTableWidgetItem('{:.2f}%'.format(
move[exchanges[exchange_i]])))
if move[exchanges[exchange_i]] > 0:
self._tableWidget.item(cell_index,
exchange_i + 2).setForeground(
CTColors.GREEN_BOLD)
else:
self._tableWidget.item(cell_index,
exchange_i + 2).setForeground(
CTColors.RED_BOLD)
self._tableWidget.setItem(
cell_index, n_columns - 1,
QTableWidgetItem('{:.2f}%'.format(
move['Avg_24HrPercentMove'])))
if move['Avg_24HrPercentMove'] > 0:
self._tableWidget.item(cell_index, n_columns -
1).setForeground(CTColors.GREEN_BOLD)
else:
self._tableWidget.item(cell_index, n_columns -
1).setForeground(CTColors.RED_BOLD)
cell_index += 1
def initUI(self):
self.setWindowTitle('TEST PROGRAM')
self.data_choose = QComboBox()
d = self.data.get_data()
for i in range(len(d)):
if d.index[i][0] != self.data_choose.itemText(i - 1):
self.data_choose.addItem(d.index[i][0])
self.data_choose.activated[str].connect(self.onActivated)
self.data_condition = QComboBox()
dc = d.loc[d.index[0][0]]
for i in range(len(dc)):
self.data_condition.addItem(dc.index.values[i])
self.data_condition.activated[str].connect(self.onActivated_condition)
self.fig, self.ax = plt.subplots(figsize=(50, 100))
self.vis = Visualize(self.ax, self.data)
self.canvas = FigureCanvas(self.fig)
self.cal_button = QPushButton('Calculate')
self.cal_button.clicked.connect(self.calculate)
self.clr_button = QPushButton('Clear')
self.clr_button.clicked.connect(self.clear)
tempx, tempy = self.data.get_listdata(d.index[0][0],
dc.index.values[0])
self.data_cell = QTableWidget()
self.data_cell.setColumnCount(7)
self.data_cell.setRowCount(2)
self.data_cell.setMaximumHeight(100)
self.data_cell.setHorizontalHeaderLabels([
'Point1', 'Point2', 'Point3', 'Point4', 'Point5', 'Point6',
'Point7'
])
self.data_cell.setVerticalHeaderLabels(['x', 'y'])
self.graph_print = QPushButton('Print')
self.graph_print.clicked.connect(self.print_graph)
for idx, item in enumerate(tempx):
self.data_cell.setItem(0, idx, QTableWidgetItem(str(item[0])))
for idx, item in enumerate(tempy):
self.data_cell.setItem(1, idx, QTableWidgetItem(str(item[0])))
self.data_cell.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.input_num = QSpinBox()
self.input_num.setMaximumWidth(100)
self.input_num.setValue(1)
self.input_num.valueChanged.connect(self.changeCellNum)
self.input_cell_x = [QDoubleSpinBox()]
self.input_cell_y = [QDoubleSpinBox()]
self.hbox = QHBoxLayout()
self.vbox = QVBoxLayout()
self.inputbox_x = QHBoxLayout()
self.inputbox_y = QHBoxLayout()
self.inputbox_xy = QVBoxLayout()
self.inputbox = QHBoxLayout()
self.btnbox = QHBoxLayout()
self.btnbox.addWidget(self.cal_button)
self.btnbox.addWidget(self.clr_button)
self.btnbox.addWidget(self.graph_print)
self.vbox.addWidget(self.data_choose)
self.vbox.addWidget(self.data_condition)
self.vbox.addWidget(self.data_cell)
self.inputbox.addWidget(self.input_num)
self.inputbox_x.addWidget(self.input_cell_x[0])
self.inputbox_y.addWidget(self.input_cell_y[0])
self.inputbox_xy.addLayout(self.inputbox_x)
self.inputbox_xy.addLayout(self.inputbox_y)
self.inputbox.addLayout(self.inputbox_xy)
self.vbox.addLayout(self.inputbox)
self.vbox.addLayout(self.btnbox)
self.vbox.addWidget(self.canvas)
self.hbox.addLayout(self.vbox)
self.ax = self.vis.draw_data()
self.canvas.draw()
self.setLayout(self.hbox)
self.showMaximized()
def run_rsamp(self): #execute rsamp
log = self.logger.getChild('run_rsamp')
log.info('user pressed \'pushButton_HSgenerate\'')
#=======================================================================
# assemble/prepare inputs
#=======================================================================
finv_raw = self.comboBox_vec.currentLayer()
rlay_l = list(self.ras_dict.values())
crs = self.qproj.crs()
cf_fp = self.get_cf_fp()
out_dir = self.lineEdit_wd.text()
#update some parameters
cid = self.mFieldComboBox_cid.currentField() #user selected field
psmp_stat = self.comboBox_HS_stat.currentText()
#inundation
as_inun = self.checkBox_HS_in.isChecked()
if as_inun:
dthresh = self.mQgsDoubleSpinBox_HS.value()
dtm_rlay = self.comboBox_dtm.currentLayer()
assert isinstance(dthresh, float)
assert isinstance(dtm_rlay, QgsRasterLayer)
else:
dthresh, dtm_rlay = None, None
#=======================================================================
# slice aoi
#=======================================================================
finv = self.slice_aoi(finv_raw)
#======================================================================
# precheck
#======================================================================
if finv is None:
raise Error('got nothing for finv')
if not isinstance(finv, QgsVectorLayer):
raise Error('did not get a vector layer for finv')
for rlay in rlay_l:
if not isinstance(rlay, QgsRasterLayer):
raise Error('unexpected type on raster layer')
if not os.path.exists(out_dir):
raise Error('working directory does not exist: %s' % out_dir)
if cid is None or cid == '':
raise Error('need to select a cid')
if not cid in [field.name() for field in finv.fields()]:
raise Error(
'requested cid field \'%s\' not found on the finv_raw' % cid)
assert os.path.exists(cf_fp), 'bad control file specified'
#======================================================================
# execute
#======================================================================
#build the sample
wrkr = Rsamp(
logger=self.logger,
tag=self.tag, #set by build_scenario()
feedback=self.
feedback, #let the instance build its own feedback worker
cid=cid,
crs=crs,
out_dir=out_dir)
"""try just passing the Dialog's feedback
#connect the status bar to the worker's feedback
wrkr.feedback.progressChanged.connect(self.upd_prog)"""
#execute the tool
res_vlay = wrkr.run(rlay_l,
finv,
psmp_stat=psmp_stat,
as_inun=as_inun,
dtm_rlay=dtm_rlay,
dthresh=dthresh)
#check it
wrkr.check()
#save csv results to file
wrkr.write_res(res_vlay, )
#update ocntrol file
wrkr.upd_cf(cf_fp)
#======================================================================
# post---------
#======================================================================
"""
the hazard sampler sets up a lot of the other tools
"""
#======================================================================
# add to map
#======================================================================
if self.checkBox_loadres.isChecked():
self.qproj.addMapLayer(res_vlay)
self.logger.info('added \'%s\' to canvas' % res_vlay.name())
#======================================================================
# update event names
#======================================================================
self.event_name_set = [lay.name() for lay in rlay_l]
log.info('set %i event names: \n %s' %
(len(self.event_name_set), self.event_name_set))
#======================================================================
# populate Event Likelihoods table
#======================================================================
l = self.event_name_set
for tbl in [self.fieldsTable_EL]:
tbl.setRowCount(len(l)) #add this many rows
for rindx, ename in enumerate(l):
tbl.setItem(rindx, 0, QTableWidgetItem(ename))
log.info('populated tables with event names')
#======================================================================
# populate lisamp
#======================================================================
#get the mlcb
try:
rlay_d = {indxr: rlay for indxr, rlay in enumerate(rlay_l)}
for indxr, (sname, (mlcb_h,
mlcb_v)) in enumerate(self.ls_cb_d.items()):
if indxr in rlay_d:
mlcb_h.setLayer(rlay_l[indxr])
else:
"""
todo: clear the remaining comboboxes
"""
break
except Exception as e:
log.error('failed to populate lisamp fields w/\n %s' % e)
#======================================================================
# wrap
#======================================================================
self.feedback.upd_prog(None) #set the progress bar back down to zero
log.push('Rsamp finished')
return
def LineChanged(self):
global s_dbname
global db_user
global db_user_password
global db_host
global db_port
with closing(
psycopg2.connect(dbname=s_dbname,
user=db_user,
password=db_user_password,
host=db_host,
port=db_port)) as conn:
with conn.cursor() as cursor:
self.ui.lblLineRecord.setText('Записей в строке: ')
self.ui.lblMediane.setText('Среднее: ')
self.ui.lblOutput.setText('Записей в выдаче: ')
self.ui.lblOutputMediane.setText('Среднее по выдаче: ')
self.ui.lblRegLines.setText('Строк по региону: ')
self.ui.lblPosLines.setText('Строк по статье: ')
global sys_user_id
self.ui.tbLine.clear()
self.ui.tbLine.setRowCount(0)
cursor.execute('SELECT COUNT (*) FROM record')
rccount = cursor.fetchone()
cursor.execute(
'SELECT region_id FROM region WHERE region_name = %s',
(self.ui.cbRegion.currentText(), ))
region_id = cursor.fetchone()
cursor.execute(
'SELECT position_id FROM position WHERE position_name = %s',
(self.ui.cbPosition.currentText(), ))
position_id = cursor.fetchone()
cursor.execute(
'SELECT COUNT (*) FROM line WHERE line_region = %s',
(region_id, ))
creglines = cursor.fetchone()
self.ui.lblRegLines.setText('Строк по региону: ' +
str(creglines[0]))
cursor.execute(
'SELECT COUNT (*) FROM line WHERE line_position = %s',
(position_id, ))
cposlines = cursor.fetchone()
self.ui.lblPosLines.setText('Строк по статье: ' +
str(cposlines[0]))
line_id = None
rules = 0
if (region_id and position_id):
cursor.execute(
'SELECT line_id FROM line WHERE line_position = %s and line_region = %s',
(position_id, region_id))
line_id = cursor.fetchone()
for role in sys_user_roles:
cursor.execute(
'SELECT COUNT(*) FROM role_rule WHERE line = %s and role = %s',
(line_id, role))
rule = cursor.fetchone()
rules += rule[0]
if line_id and (rules > 0):
self.ui.tbLine.setColumnCount(2)
cursor.execute(
'SELECT unit FROM position WHERE position_id = %s',
(position_id, ))
position_unit = cursor.fetchone()
self.ui.tbLine.setHorizontalHeaderLabels(
('Дата', position_unit[0]))
cursor.execute(
'SELECT date,value FROM record WHERE on_line = %s',
(line_id, ))
values = cursor.fetchall()
row = 0
mediane = 0
omediane = 0
dif = {
'Равно': '==',
'Не равно': '!=',
'Больше': '>',
'Не меньше': '>=',
'Не больше': '<=',
'Меньше': '<'
}
for val in values:
mediane += val[1]
tval = str(val[0])
tdate = datetime.strptime(tval, "%d.%m.%Y")
sub = tdate.date() - self.ui.dtDate.date().toPyDate()
if (not self.ui.cbDate.currentText() in dif):
if (not self.ui.cbValue.currentText() in dif):
self.ui.tbLine.setRowCount(row + 1)
dt = QTableWidgetItem(str(val[0]))
dt.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
vl = QTableWidgetItem(str(val[1]))
vl.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.ui.tbLine.setItem(row, 0, dt)
self.ui.tbLine.setItem(row, 1, vl)
row += 1
omediane += val[1]
elif (eval(
str(val[1]) +
dif[self.ui.cbValue.currentText()] +
str(self.ui.spValue.value()))):
self.ui.tbLine.setRowCount(row + 1)
dt = QTableWidgetItem(str(val[0]))
dt.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
vl = QTableWidgetItem(str(val[1]))
vl.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.ui.tbLine.setItem(row, 0, dt)
self.ui.tbLine.setItem(row, 1, vl)
row += 1
omediane += val[1]
elif (eval(
str(sub.days) +
dif[self.ui.cbDate.currentText()] + '0')):
if (not self.ui.cbValue.currentText() in dif):
self.ui.tbLine.setRowCount(row + 1)
dt = QTableWidgetItem(str(val[0]))
dt.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
vl = QTableWidgetItem(str(val[1]))
vl.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.ui.tbLine.setItem(row, 0, dt)
self.ui.tbLine.setItem(row, 1, vl)
row += 1
omediane += val[1]
elif (eval(
str(val[1]) +
dif[self.ui.cbValue.currentText()] +
str(self.ui.spValue.value()))):
self.ui.tbLine.setRowCount(row + 1)
dt = QTableWidgetItem(str(val[0]))
dt.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
vl = QTableWidgetItem(str(val[1]))
vl.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.ui.tbLine.setItem(row, 0, dt)
self.ui.tbLine.setItem(row, 1, vl)
row += 1
omediane += val[1]
cursor.execute(
'SELECT COUNT(*) FROM record WHERE on_line = %s',
(line_id, ))
lcount = cursor.fetchone()
self.ui.lblLineRecord.setText('Записей в строке: ' +
str(lcount[0]))
if lcount[0] != 0:
self.ui.lblMediane.setText('Среднее: ' +
str(mediane / lcount[0]))
else:
self.ui.lblMediane.setText('Среднее: 0')
self.ui.lblOutput.setText('Записей в выдаче: ' + str(row))
if row != 0:
self.ui.lblOutputMediane.setText(
'Среднее по выдаче: ' + str(omediane / row))
else:
self.ui.lblOutputMediane.setText(
'Среднее по выдаче: 0')
def __init__(self, parent, list_of_links, callback, persepolis_setting):
super().__init__(persepolis_setting)
self.persepolis_setting = persepolis_setting
self.callback = callback
self.parent = parent
self.list_of_links = list_of_links
global icons
icons = ':/' + \
str(self.persepolis_setting.value('settings/icons')) + '/'
self.list_of_links.reverse()
k = 1
for dict in self.list_of_links:
# add row to the links_table
self.links_table.insertRow(0)
# file_name
if 'out' in dict:
if dict['out']:
file_name = dict['out']
else:
file_name = '***'
else:
file_name = '***'
if file_name == '***':
# spider finds file name
new_spider = QueueSpiderThread(dict)
self.parent.threadPool.append(new_spider)
self.parent.threadPool[len(self.parent.threadPool) - 1].start()
self.parent.threadPool[len(self.parent.threadPool) - 1].QUEUESPIDERRETURNEDFILENAME.connect(
partial(self.parent.queueSpiderCallBack, child=self, row_number=len(self.list_of_links) - k))
k = k + 1
item = QTableWidgetItem(file_name)
# add checkbox to the item
item.setFlags(Qt.ItemIsUserCheckable |
Qt.ItemIsEnabled)
item.setCheckState(Qt.Checked)
# insert file_name
self.links_table.setItem(0, 0, item)
# find link
link = dict['link']
item = QTableWidgetItem(str(link))
# insert link
self.links_table.setItem(0, 1, item)
# get categories name and add them to add_queue_comboBox
categories_list = self.parent.persepolis_db.categoriesList()
for queue in categories_list:
if queue != 'All Downloads':
self.add_queue_comboBox.addItem(queue)
self.add_queue_comboBox.addItem(
QIcon(icons + 'add_queue'), 'Create new queue')
# entry initialization
global connections
connections = int(
self.persepolis_setting.value('settings/connections'))
global download_path
download_path = str(
self.persepolis_setting.value('settings/download_path'))
# initialization
self.connections_spinBox.setValue(connections)
self.download_folder_lineEdit.setText(download_path)
self.download_folder_lineEdit.setEnabled(False)
# ip_lineEdit initialization
settings_ip = self.persepolis_setting.value(
'add_link_initialization/ip', None)
if settings_ip:
self.ip_lineEdit.setText(str(settings_ip))
# proxy user lineEdit initialization
settings_proxy_user = self.persepolis_setting.value(
'add_link_initialization/proxy_user', None)
if settings_proxy_user:
self.proxy_user_lineEdit.setText(str(settings_proxy_user))
# port_spinBox initialization
settings_port = self.persepolis_setting.value(
'add_link_initialization/port', 0)
self.port_spinBox.setValue(int(int(settings_port)))
# download UserName initialization
settings_download_user = self.persepolis_setting.value(
'add_link_initialization/download_user', None)
if settings_download_user:
self.download_user_lineEdit.setText(str(settings_download_user))
# connect folder_pushButton
self.folder_pushButton.clicked.connect(self.changeFolder)
# connect OK and canel button
self.cancel_pushButton.clicked.connect(self.close)
self.ok_pushButton.clicked.connect(self.okButtonPressed)
# connect select_all_pushButton deselect_all_pushButton
self.select_all_pushButton.clicked.connect(self.selectAll)
self.deselect_all_pushButton.clicked.connect(self.deselectAll)
#frames and checkBoxes
self.proxy_frame.setEnabled(False)
self.proxy_checkBox.toggled.connect(self.proxyFrame)
self.download_frame.setEnabled(False)
self.download_checkBox.toggled.connect(self.downloadFrame)
self.limit_frame.setEnabled(False)
self.limit_checkBox.toggled.connect(self.limitFrame)
# set focus to ok button
self.ok_pushButton.setFocus()
# add_queue_comboBox event
self.add_queue_comboBox.currentIndexChanged.connect(self.queueChanged)
# set window size and position
size = self.persepolis_setting.value('TextQueue/size', QSize(700, 500))
position = self.persepolis_setting.value(
'TextQueue/position', QPoint(300, 300))
self.resize(size)
self.move(position)
def ToggleActiveRow(self, row, value="True"):
''' Toggle Active row manager video status '''
self.VManager.setItem(row, 2, QTableWidgetItem(value))
return
def createTable(self, ):
self.tableWidget = QTableWidget()
self.tableWidget.setRowCount(32)
self.tableWidget.setColumnCount(2)
header = self.loadedLASFile.header
headerformat = header.header_format
rowcounter = 0
for spec in headerformat:
self.tableWidget.setItem(rowcounter, 0,
QTableWidgetItem(spec.name))
if (spec.name == 'file_sig'):
print(spec.name)
self.tableWidget.setItem(
rowcounter, 1, QTableWidgetItem(header.file_signature))
if (spec.name == 'file_source_id'):
print(spec.name)
self.tableWidget.setItem(
rowcounter, 1, QTableWidgetItem(header.filesource_id))
if (spec.name == 'global_encoding'):
print(spec.name)
self.tableWidget.setItem(
rowcounter, 1, QTableWidgetItem(header.global_encoding))
if (spec.name == 'proj_id_1'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.project_id))
if (spec.name == 'proj_id_2'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.project_id))
if (spec.name == 'proj_id_3'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.project_id))
if (spec.name == 'proj_id_4'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.project_id))
if (spec.name == 'version_major'):
print(spec.name)
self.tableWidget.setItem(
rowcounter, 1, QTableWidgetItem(header.major_version))
if (spec.name == 'version_minor'):
print(spec.name)
self.tableWidget.setItem(
rowcounter, 1, QTableWidgetItem(header.minor_version))
if (spec.name == 'system_id'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.system_id))
if (spec.name == 'software_id'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.software_id))
if (spec.name == 'created_day'):
print(spec.name)
self.tableWidget.setItem(
rowcounter, 1,
QTableWidgetItem('{:%m/%d/%Y}'.format(header.date)))
if (spec.name == 'created_year'):
print(spec.name)
self.tableWidget.setItem(
rowcounter, 1,
QTableWidgetItem('{:%m/%d/%Y}'.format(header.date)))
if (spec.name == 'header_size'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.header_size))
if (spec.name == 'data_offset'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.data_offset))
if (spec.name == 'num_variable_len_recs'):
print(spec.name)
self.tableWidget.setItem(
rowcounter, 1, QTableWidgetItem(header.records_count))
if (spec.name == 'data_format_id'):
print(spec.name)
self.tableWidget.setItem(
rowcounter, 1, QTableWidgetItem(header.dataformat_id))
if (spec.name == 'data_record_length'):
print(spec.name)
self.tableWidget.setItem(
rowcounter, 1, QTableWidgetItem(header.data_record_length))
if (spec.name == 'point_records_count'):
print(spec.name)
self.tableWidget.setItem(
rowcounter, 1,
QTableWidgetItem(header.point_records_count))
if (spec.name == 'point_return_count'):
print(spec.name)
self.tableWidget.setItem(
rowcounter, 1,
QTableWidgetItem(header.point_return_count[0]))
if (spec.name == 'x_scale'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.scale[0]))
if (spec.name == 'y_scale'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.scale[1]))
if (spec.name == 'z_scale'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.scale[2]))
if (spec.name == 'x_offset'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.offset[0]))
if (spec.name == 'y_offset'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.offset[1]))
if (spec.name == 'z_offset'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.offset[2]))
if (spec.name == 'x_max'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.max[0]))
if (spec.name == 'x_min'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.min[0]))
if (spec.name == 'y_max'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.max[1]))
if (spec.name == 'y_min'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.min[1]))
if (spec.name == 'z_max'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.max[2]))
if (spec.name == 'z_min'):
print(spec.name)
self.tableWidget.setItem(rowcounter, 1,
QTableWidgetItem(header.min[2]))
rowcounter += 1
self.tableWidget.move(0, 0)
self.tableWidget.doubleClicked.connect(self.on_click)
def table_item(self, text, flag):
tablewidgetitem = QTableWidgetItem(text)
tablewidgetitem.setFlags(flag)
return tablewidgetitem
def whey(self):
# Let's fetch the soup for the page here!
my_url = 'https://www.amazon.in/Optimum-Nutrition-Standard-Protein-Powder/dp/B000GIQT2Y/ref=twister_B075ZYTP6Q?_encoding=UTF8&th=1'
uClient = ureq(my_url)
page_html = uClient.read()
uClient.close()
page_soup = Soup(page_html, "html.parser")
# A little bit of Regex here to fetch the list items with id's beginning with flavor_name_
containers = page_soup.findAll("li",
{"id": re.compile("^flavor_name_")})
total = len(containers)
# The solution set :)
dictionary = {}
i = 0
for container in containers:
print(container['title'][15:], '\t', container['data-dp-url'])
while True:
try:
if not container['data-dp-url']:
price = page_soup.find("span",
{"id": "priceblock_ourprice"})
try:
print(type(price.text))
dictionary[str(
container['title'][15:].strip())] = float(
price.text.replace(u'\xa0', u' ').replace(
',', '').strip())
except AttributeError as e:
print("Unavailable")
# dictionary[str(container['title'][15:].strip())] = 'Unavailable'
# now go to the link to fetch the price and store in the dictionary
else:
uCl = ureq(
'https://www.amazon.in/Optimum-Nutrition-Standard-Protein-Powder'
+ container['data-dp-url'])
html = uCl.read()
uCl.close()
soup = Soup(html, "html.parser")
price = soup.find("span",
{"id": "priceblock_ourprice"})
try:
print(type(price.text))
# if type(price) != 'text':
# price = page_soup.find("span", {"id": "a-color-price"})
dictionary[str(
container['title'][15:].strip())] = float(
price.text.replace(u'\xa0', u' ').replace(
',', '').strip())
except AttributeError as e:
print("Unavailable")
# dictionary[str(container['title'][15:].strip())] = 'Unavailable'
i += 1
completed = (i / total) * 100
self.progressBar.setValue(completed)
break
except urllib2.HTTPError as err:
print("TRYING AGAIN - NETWORK ERROR")
print("Flavors in non-descending order of price: \n")
# Sorting the dictionary items in non decreasing order!
sorted_x = sorted(dictionary.items(), key=operator.itemgetter(1))
print(sorted_x)
print(len(sorted_x))
i = 0
for flavor, price in sorted_x:
self.tableWidget.setItem(i, 0, QTableWidgetItem(flavor))
self.tableWidget.setItem(i, 1, QTableWidgetItem(str(price)))
print("{:<25} {:<7}".format(flavor, price))
i += 1
def initTable(self):
dbutil = DbUtil()
results = dbutil.get_unresolve_task()
obj = {}
for row in results:
TASK_ID = row[0]
ANALYSIS_TASK_ID = row[1]
SUBMIT_TIME = row[2]
USER_DATA = row[3]
oldrow = self.tableWidget.rowCount()
self.tableWidget.setRowCount(oldrow + 1)
item = QTableWidgetItem(str(TASK_ID))
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.tableWidget.setItem(oldrow, 0, item)
item = QTableWidgetItem(str(ANALYSIS_TASK_ID))
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.tableWidget.setItem(oldrow, 1, item)
item = QTableWidgetItem(str(SUBMIT_TIME))
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.tableWidget.setItem(oldrow, 2, item)
strbtn = 'btn' + str(oldrow)
obj[strbtn] = QtWidgets.QPushButton()
obj[strbtn].setText("详细信息")
obj[strbtn].setStyleSheet("text-decoration: underline")
self.one = partial(self.btnclicked, obj[strbtn])
#print(btn.objectName())
obj[strbtn].setCursor(QCursor(Qt.PointingHandCursor))
self.tableWidget.setCellWidget(oldrow, 3, obj[strbtn])
obj[strbtn].clicked.connect(self.one)
self.tableWidget.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
def showRowContents(self, row_list):
self.clear()
table_headers = ['序号', '创建日期', '标题', '']
self.setColumnCount(len(table_headers))
self.setRowCount(len(row_list))
self.setHorizontalHeaderLabels(table_headers)
self.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)
self.horizontalHeader().setSectionResizeMode(3, QHeaderView.ResizeToContents)
for row, row_item in enumerate(row_list):
item0 = QTableWidgetItem(str(row + 1))
item0.setTextAlignment(Qt.AlignCenter)
item0.id = row_item['id']
self.setItem(row, 0, item0)
item1 = QTableWidgetItem(row_item['create_time'])
item1.setTextAlignment(Qt.AlignCenter)
self.setItem(row, 1, item1)
item2 = QTableWidgetItem(row_item['title'])
item2.setTextAlignment(Qt.AlignCenter)
self.setItem(row, 2, item2)
item3 = QTableWidgetItem('阅读')
item3.setForeground(QBrush(QColor(50, 50, 220)))
item3.setTextAlignment(Qt.AlignCenter)
item3.file_url = row_item['file_url']
self.setItem(row, 3, item3)
