def edit_function_ok(self):
if self.function_dialog.lineEdit.text() == '':
self.msg.warning(self.msg, '提示', '没有函数', self.msg.Ok)
else:
val = self.function_dialog.lineEdit.text()
self.reload_vendor_info()
result_name = self.features.Features(self.df).run_function(
val) # ['平均人天']
for col in range(self.tableWidget.columnCount()):
for i in result_name:
if self.tableWidget.horizontalHeaderItem(col).text() == i:
for row in range(self.tableWidget.rowCount()):
item = self.df.at[row, i]
if pd.isnull(item):
item = ''
else:
item = round(item, 2)
item = str(item)
self.tableWidget.setItem(row, col,
QTableWidgetItem(item))
for col in range(self.tableWidget.columnCount()):
for i in self.splitter:
item = QTableWidgetItem('')
item.setBackground(QBrush(QColor(128, 128, 128)))
self.tableWidget.setItem(i - 1, col, item)
def updateTable(self): # Обновление таблицы
self.tableWidget.blockSignals(True)
self.tableWidget.setRowCount(0)
res = self.db.findTableRequest(self.lineEditForSearch.text())
for i, row in enumerate(res):
self.tableWidget.setRowCount(self.tableWidget.rowCount() + 1)
self.tableWidget.blockSignals(True)
for j, elem in enumerate(row):
s = QTableWidgetItem(str(elem))
self.clickedRow(i, j)
if j == 1:
brush = QtGui.QBrush(
QtGui.QPixmap(res[i][1]).scaled(200, 200))
self.tableWidget.setRowHeight(i, 200)
s.setText('')
s.setBackground(brush)
elif j == 6:
self.tableWidget.setItem(i, j, s)
self.checkCount(self.r, self.c)
continue
if self.id != '1':
if str(j) in '012345':
s.setFlags(QtCore.Qt.ItemIsEditable)
else:
if str(j) in '0':
s.setFlags(QtCore.Qt.ItemIsEditable)
self.tableWidget.setItem(i, j, s)
self.tableWidget.blockSignals(False)
self.checkError()
def insertRound(self, r):
closeType = r.getCloseType()
winner = r.getWinner()
background = self.bgcolors[closeType]
i = r.getNumRound() - 1
self.insertRow(i)
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)
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
if player == winner:
text = i18n(
"RemigioRoundTable", "Winner ({}x)").format(closeType)
font = item.font()
font.setBold(True)
item.setFont(font)
elif self.engine.wasPlayerOff(
player, r.getNumRound()) or r.getPlayerScore(player) < 0:
if r.getPlayerScore(player) < 0:
text = ""
else:
text = str(r.getPlayerScore(player))
item.setBackground(QtGui.QBrush(QtCore.Qt.gray))
else:
text = str(r.getPlayerScore(player))
item.setText(text)
self.setItem(i, j, item)
self.scrollToBottom()
def _set_module_auth_options_items(self,
row,
checked,
expire_date,
f_color,
b_color=None):
""" 设置模块管理的操作项目(选择开启或关闭,设置到期时间等) """
text = "开放" if checked else "关闭"
item2 = QTableWidgetItem(text)
item2.setCheckState(checked)
item2.setTextAlignment(Qt.AlignCenter)
item2.setBackground(
QBrush(b_color)) if b_color else item2.setForeground(
QBrush(f_color))
self.module_auth.module_auth_table.setItem(row, 2, item2)
item3 = QTableWidgetItem(expire_date)
item3.setBackground(
QBrush(b_color)) if b_color else item3.setForeground(
QBrush(f_color))
item3.setTextAlignment(Qt.AlignCenter)
self.module_auth.module_auth_table.setItem(row, 3, item3)
item4_widget = QPushButton("确定", self.module_auth.module_auth_table)
item4_widget.clicked.connect(self.edit_user_module_authority)
setattr(item4_widget, "row_index", row)
self.module_auth.module_auth_table.setCellWidget(row, 4, item4_widget)
def set_table_info(self):
self.table_items = my_sql.sql_select(self.query_table_select,
(self.other_value, ))
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(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])
if table_typle[2] >= 0:
color = QBrush(QColor(150, 255, 161, 255))
else:
color = QBrush(QColor(255, 255, 153, 255))
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 _create_row(self, idx, sentence):
"""Draws the row for the specified index and sentence.
Each row consists of a delete button on the left, a label stating
whether or not the test case was recognised correctly and the
test sentence as a line edit.
This method assumes that the table widget has already been set
to the correct size.
Arguments:
idx {int} -- the index of the test case
sentence {str} -- the test case
"""
delete_button = self._create_delete_button()
delete_button.pressed.connect(lambda idx=idx: self._on_deleted(idx))
self._ui.tabular.setCellWidget(idx, 0, delete_button)
self._ui.tabular.setCellWidget(idx, 1, self._create_space(10))
# check whether the test sentences are correctly analysed
correct, user_acts = self._analyse_sentence(sentence)
label = self._create_tick() if correct else self._create_cross()
analysis = ', '.join(
[self._get_user_act_string(act) for act in user_acts])
if len(user_acts) == 0:
analysis = 'no acts found'
label.setToolTip('Analysis: %s' % analysis)
self._ui.tabular.setCellWidget(idx, 2, label)
self._ui.tabular.setCellWidget(idx, 3, self._create_space(20))
item = QTableWidgetItem(sentence)
item.setBackground(QColor(96, 138, 255))
self._ui.tabular.setItem(idx, 4, item)
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)'])
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 update_users_from_mc(self, users):
table_user_count = self.users_table.rowCount()
for i in range(table_user_count):
current_table_user = self.users_table.item(i, 0).text()
if current_table_user in users:
tick = QTableWidgetItem("✓")
tick.setTextAlignment(QtCore.Qt.AlignCenter)
tick.setBackground(QColor(QtCore.Qt.green))
self.users_table.setItem(i, 1, tick)
users.remove(current_table_user)
else:
cross = QTableWidgetItem("✗")
cross.setTextAlignment(QtCore.Qt.AlignCenter)
cross.setBackground(QColor(QtCore.Qt.red))
self.users_table.setItem(i, 1, cross)
#handle users from server but not in table
self.users_table.setRowCount(table_user_count + len(users))
for i, user in enumerate(users):
self.users_table.setItem(i + table_user_count, 0,
QTableWidgetItem(user))
self.users_table.sortItems(0, QtCore.Qt.AscendingOrder)
self.users_table.sortItems(1, QtCore.Qt.DescendingOrder)
self.users_table.resizeRowsToContents()
def initUI(self):
self.setWindowTitle('代码改变单元格的大小')
self.resize(530, 300)
layout = QHBoxLayout()
tableWidget = QTableWidget()
tableWidget.setRowCount(4)
tableWidget.setColumnCount(3)
layout.addWidget(tableWidget)
tableWidget.setHorizontalHeaderLabels(['姓名', '性别', '体重(kg)'])
tableWidget.setRowHeight(0, 100) # 第0行的高度80
tableWidget.setColumnWidth(2, 150)
newItem = QTableWidgetItem('雷神')
newItem.setFont(QFont('Times', 20, 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', 60, QFont.Black))
newItem.setForeground(QBrush(QColor(0, 0, 255)))
tableWidget.setItem(0, 2, newItem)
self.setLayout(layout)
def chart_enlarge_clicked(self, chart_data):
self.chart_detail = DetailChartWidget(parent=self)
self.chart_detail.resize(self.width(), self.height())
self.chart_detail.close_button.clicked.connect(
self.delete_chart_detail) # 关闭删除控件
# 数据画图，将图和数据展示在相应的控件中
chart, table_df = self.data_to_chart(chart_data, tick_count=40)
table_df[0] = pd.to_datetime(table_df[0]) # 第一列转为时间类型
self.chart_detail.chart_view.setChart(chart)
# self.chart_detail.chart_view.setDateCategoryXaxis(chart.date_xaxis_category) # 根据x轴是否是时间轴设置鼠标动作
if chart_data['category'] == 'line':
self.chart_detail.chart_view.linesInstallHoverEvent()
elif chart_data['category'] == 'bar':
self.chart_detail.chart_view.barsInstallHoverEvent()
# 数据入表
header_data = chart_data['header_data'][1:]
self.chart_detail.table_view.clear()
self.chart_detail.table_view.setRowCount(table_df.shape[0]) # 行
self.chart_detail.table_view.setColumnCount(table_df.shape[1]) # 列
self.chart_detail.table_view.setHorizontalHeaderLabels(header_data)
for row, row_content in enumerate(table_df.to_numpy()):
# print(row_content)
for col in range(len(header_data)):
if col == 0:
item = QTableWidgetItem(
row_content[col].strftime('%Y-%m-%d'))
else:
item = QTableWidgetItem(str(row_content[col]))
item.setTextAlignment(Qt.AlignCenter)
if (row & 1) == 1: # 奇数行
item.setBackground(QBrush(QColor(218, 233, 231)))
self.chart_detail.table_view.setItem(row, col, item)
self.chart_detail.table_view.setRowHeight(row, 23) # 行高
self.chart_detail.show()
def load_pxmarker_table(self):
"""Load pixel marker table
"""
self.ui.pxmarker_table_widget.clearContents()
self.ui.pxmarker_table_widget.setRowCount(self.pxmarker_table_height)
row_position = 0
for classnum, color, feature in self.pxmarker_table_out:
class_item = QTableWidgetItem(str(classnum))
class_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
class_item.setTextAlignment(Qt.AlignCenter)
self.ui.pxmarker_table_widget.setItem(row_position, 0, class_item)
color_item = QTableWidgetItem()
color_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
color_item.setBackground(QColor(color[0], color[1], color[2]))
self.ui.pxmarker_table_widget.setItem(row_position, 1, color_item)
feature_item = QTableWidgetItem(feature)
if row_position == 0:
feature_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.ui.pxmarker_table_widget.setItem(row_position, 2,
feature_item)
row_position += 1
def initUI(self):
grid = QGridLayout()
self.setLayout(grid)
txt = QTableWidget()
txt.setRowCount(13)
txt.setColumnCount(13)
txt.setEditTriggers(QAbstractItemView.NoEditTriggers)
for r in range(13):
for c in range(13):
val = r * c / 169
item = QTableWidgetItem(f"{val:0.02f}")
rgba = cmap(val, bytes=True)
item.setBackground(
QColor(int(rgba[0]), int(rgba[1]), int(rgba[2])))
item.setForeground(QColor(255, 255, 255))
txt.setItem(r, c, item)
txt.resizeColumnsToContents()
txt.resizeRowsToContents()
grid.addWidget(txt)
self.move(300, 150)
self.setWindowTitle(f"Qt CS Grid")
self.show()
def show_tablewidget(self, dict_data):
'''在tableWidget显示dict_data'''
tableWidget = self.tableWidget
'''排序'''
df = DataFrame(dict_data).sort_values(by='count',ascending = False)
_temp = df.to_dict('index')
dict_data = list(_temp.values())
self.data = dict_data
'''tableWidget的初始化'''
list_col = ['key','count','ps','pron','pos','acceptation','sen']
len_col = len(list_col)
len_index = len(dict_data)
tableWidget.setRowCount(len_index)#设置行数
tableWidget.setColumnCount(len_col)#设置列数
tableWidget.setHorizontalHeaderLabels(['单词', '词频', '音标','发音','词性','释义','例句']) # 设置垂直方向上的名字
tableWidget.setVerticalHeaderLabels([str(i) for i in range(1, len_index + 1)]) # 设置水平方向上的名字
'''填充数据'''
for index in range(len_index):
for col in range(len_col):
name_col = list_col[col]
if name_col == 'pron':
item = QTableWidgetItem('播放')
item.setTextAlignment(Qt.AlignCenter)
font = QFont()
font.setBold(True)
font.setWeight(75)
item.setFont(font)
item.setBackground(QColor(218, 218, 218))
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
tableWidget.setItem(index, col, item)
else:
tableWidget.setItem(index,col,QTableWidgetItem(str(dict_data[index][name_col])))
tableWidget.resizeColumnsToContents()
tableWidget.setColumnWidth(5, 500)
def writeNewValueGUI(tableWidget, i, j, value, bounds=[None, None]):
newItem = Qitem(str(value))
if (float(value) <= bounds[1]) & (float(value) >= bounds[0]): #in bounds
newItem.setBackground(QColor(0, 255, 0)) #RGB ,green
else:
newItem.setBackground(QColor(255, 0, 0)) #RGB ,red
tableWidget.setItem(i, j, newItem)
def DomTableUI(self):
self.DomTable.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.DomTable.verticalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.DomTable.setHorizontalHeaderLabels(['買價', '成交價', '賣價'])
self.bestfive = pd.DataFrame(np.arange(27).reshape(27),
columns=['close'])
self.bestfive['bid'] = 0
self.bestfive['ask'] = 0
self.bestfive = self.bestfive[['close', 'bid', 'ask']].astype(int)
i = 0
# self.bestfive['close']=self.bestfive['close'].map(lambda x:self.Future.contractkpd.iloc[-1,4]+13-(self.bestfive['close'][self.bestfive['close']==x].index[0]))
self.lastclose = []
self.lastbidlist = []
self.lastasklist = []
# while i < self.bestfive.shape[0]:
while i < 27:
tmpitem = QTableWidgetItem(str(self.bestfive.iloc[i, 0]))
tmpitem.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
if i == 13:
tmpitem.setBackground(Qt.yellow)
self.DomTable.setItem(i, 1, tmpitem)
# self.DomTable.setItem(i,1,QTableWidgetItem(str(self.bestfive.iloc[i,0])))
i += 1
def update_feature_table(self):
self.feature_table.setRowCount(0)
# disconnect signal, else it would be called when adding a row
try:
self.feature_table.cellChanged.disconnect()
except:
pass
# available features
for row, feature_type in enumerate(FEATURES):
self.feature_table.insertRow(row)
feat_item = QTableWidgetItem(feature_type.label)
feat_item.setCheckState(False)
b_color = Qt.QColor(255, 255, 255)
if issubclass(feature_type, UnorderedFeature):
codebooks = self.store.list_codebooks(feature_type)
if len(codebooks) == 0:
dict_label = 'dictionary required, but none found'
b_color = Qt.QColor(255, 230, 230)
else:
dict_label = ' | '.join(codebooks)
b_color = Qt.QColor(230, 255, 230)
else:
dict_label = 'no dictionary needed'
dict_item = QTableWidgetItem(dict_label)
dict_item.setBackground(b_color)
self.feature_table.setItem(row, 0, feat_item)
self.feature_table.setItem(row, 1, dict_item)
self.feature_table.resizeColumnsToContents()
self.feature_table.cellChanged.connect(self.color_species_table)
def ModificaItem(self, valor, fila, col, backgroundColor=None):
"""
:param fila: la fila que se quiere modificar
:param valor: valor a modificar
:type col: entero en caso de indicar un numero de columna y string si quiero el nombre
"""
if isinstance(valor, (int, float, decimal.Decimal)):
item = QTableWidgetItem(str(valor))
else:
item = QTableWidgetItem(valor)
if not isinstance(col, int):
numCol = self.cabeceras.index(col)
else:
numCol = col
if numCol in self.columnasHabilitadas:
item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable)
else:
# item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
item.setFlags(QtCore.Qt.ItemIsSelectable)
if col in self.backgroundColorCol:
item.setBackground(self.backgroundColorCol[col])
self.setItem(fila, numCol, item)
self.resizeColumnsToContents()
def actualizarTablaMensualida(self, tabla: QTableWidget):
row = 0
cantidad = tabla.rowCount()
print(cantidad)
for i in range(cantidad + 1):
print(i)
tabla.removeRow(i)
header = tabla.horizontalHeader()
for m in self.listaMensualidades:
tabla.insertRow(row)
if m.estado == 0:
estado = QTableWidgetItem("Vencido")
estado.setBackground(QtGui.QColor(255, 0, 0))
else:
estado = QTableWidgetItem("Al Dia")
estado.setBackground(QtGui.QColor(42, 255, 39))
placa = QTableWidgetItem(str(m.vehiculo.placa))
tipo = QTableWidgetItem(str(m.vehiculo.tipo_vehiculo))
propietario = QTableWidgetItem(str(m.propietario))
telefono = QTableWidgetItem(str(m.telefono))
valor = QTableWidgetItem(str(m.valor))
fechaEntrada = QTableWidgetItem(str(m.fechaEntrada))
fechaSalida = QTableWidgetItem(str(m.fechaSalida))
tabla.setItem(row, 0, estado)
tabla.setItem(row, 1, placa)
tabla.setItem(row, 2, tipo)
tabla.setItem(row, 3, propietario)
tabla.setItem(row, 4, telefono)
tabla.setItem(row, 5, valor)
tabla.setItem(row, 6, fechaEntrada)
tabla.setItem(row, 7, fechaSalida)
header.setSectionResizeMode(3,
QtWidgets.QHeaderView.ResizeToContents)
row += 1
def __init__(self, app: dict, icon_cache: Cache, locale_keys: dict):
super(HistoryDialog, self).__init__()
self.setWindowTitle('{} - {} '.format(
locale_keys['popup.history.title'], app['model'].base_data.name))
layout = QVBoxLayout()
self.setLayout(layout)
table_history = QTableWidget()
table_history.setFocusPolicy(Qt.NoFocus)
table_history.setShowGrid(False)
table_history.verticalHeader().setVisible(False)
table_history.setAlternatingRowColors(True)
table_history.setColumnCount(len(app['history'][0]))
table_history.setRowCount(len(app['history']))
table_history.setHorizontalHeaderLabels([
locale_keys['flatpak.info.' + key].capitalize()
for key in sorted(app['history'][0].keys())
])
for row, commit in enumerate(app['history']):
current_app_commit = app['model'].commit == commit['commit']
for col, key in enumerate(sorted(commit.keys())):
item = QTableWidgetItem()
item.setText(commit[key])
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
if current_app_commit:
item.setBackground(
QColor('#ffbf00' if row != 0 else '#32CD32'))
tip = '{}. {}.'.format(
locale_keys['popup.history.selected.tooltip'],
locale_keys['version.{}'.format(
'updated' if row ==
0 else 'outdated')].capitalize())
item.setToolTip(tip)
table_history.setItem(row, col, item)
layout.addWidget(table_history)
header_horizontal = table_history.horizontalHeader()
for i in range(0, table_history.columnCount()):
header_horizontal.setSectionResizeMode(i, QHeaderView.Stretch)
new_width = reduce(operator.add, [
table_history.columnWidth(i)
for i in range(table_history.columnCount())
])
self.resize(new_width, table_history.height())
icon_data = icon_cache.get(app['model'].base_data.icon_url)
if icon_data and icon_data.get('icon'):
self.setWindowIcon(icon_data.get('icon'))
def initUI(self):
self.setWindowTitle("设置单元格字体和颜色")
self.resize(430, 230)
layout = QHBoxLayout()
tableWidget = QTableWidget()
tableWidget.setRowCount(4)
tableWidget.setColumnCount(3)
tableWidget.setHorizontalHeaderLabels(["姓名", "性别", "体重（kg）"])
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)
layout.addWidget(tableWidget)
self.setLayout(layout)
def __init__(self, editable=True, parent=None):
super(QTableWidgetMaterial, self).__init__(parent)
self.setColumnCount(2)
self.setRowCount(1)
item = QTableWidgetItem('')
item.setBackground(QColor(200, 200, 200))
self.setItem(0, 0, QTableWidgetItem(''))
self.setItem(0, 1, QTableWidgetItem(''))
item = QtWidgets.QTableWidgetItem()
item.setBackground(QColor(200, 200, 200))
self.setHorizontalHeaderItem(0, item)
item = QtWidgets.QTableWidgetItem()
self.setHorizontalHeaderItem(1, item)
self.horizontalHeader().setDefaultSectionSize(88)
self.horizontalHeader().setStretchLastSection(True)
self.verticalHeader().setVisible(False)
self.verticalHeader().setMinimumSectionSize(16)
self.verticalHeader().setStretchLastSection(False)
self.retranslate_ui()
self.cur_material = None
self.elemlist = []
self.elemlist.append('')
with open(BasicPath.element_list_file_name) as input_elemnt:
lines = [a for a in input_elemnt.readlines() if len(a) > 0]
for line in lines:
self.elemlist.append(line.strip('\r\n '))
self.connect_signal_slots()
self.editable = editable
def appendText(self, file):
local = re.findall(r"([a-zA-Z-_0-9]+)\.", str(file).strip('\n'))
extension = re.findall(r"\.([a-zA-Z-_0-9]+)", str(file).strip('\n'))
if (extension == []):
local = local[0]
else:
local = local[0] + "." + extension[0]
item1 = QTableWidgetItem(str(file))
item1.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item2 = QTableWidgetItem(local)
item2.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
# validate last item
table = self.ui.filesTable
curitem = table.item(table.rowCount() - 1, 0)
if (curitem != None):
# adding new row in table
table.insertRow(table.rowCount())
# if table is empty
if (table.rowCount() == 0):
table.setRowCount(1)
item1.setBackground(ACTIVE())
item2.setBackground(ACTIVE())
table.setItem(table.rowCount() - 1, 0, item1)
table.setItem(table.rowCount() - 1, 1, item2)
def _load_settings(self, filename='settings.json'):
try:
with open(filename) as f:
settings = json.load(f)
table: QTableWidget = self.colorTable
table.setRowCount(0)
for rgb_color in settings['colors']:
color = QColor.fromRgb(*rgb_color)
item = QTableWidgetItem()
item.setBackground(color)
table.insertRow(table.rowCount())
table.setItem(table.rowCount() - 1, 0, item)
self.delayInput.setTime(QTime(0, 0).addSecs(settings['delay']))
self.repeatInput.setTime(
QTime(0, 0).addSecs(settings['repeat_interval']))
self.errorLabel.setText(f'настройки загружены из {filename}')
except FileNotFoundError:
pass
except json.JSONDecodeError or KeyError or TypeError:
self.errorLabel.setText(f'в {filename} ошибка')
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 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 insertRound(self, r):
winner = r.getWinner()
i = r.getNumRound() - 1
self.insertRow(i)
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)
if player == winner:
text = i18n(
"Phase10RoundTable", "Winner")
font = item.font()
font.setBold(True)
item.setFont(font)
else:
text = str(r.getPlayerScore(player))
a_phase = r.getPlayerAimedPhase(player)
c_phase = r.getPlayerCompletedPhase(player)
text += i18n(
"Phase10PlayerWidget", " (Phase {})").format(a_phase)
if c_phase != 0:
background = 0xCCFF99 # green
else:
background = 0xFFCC99 # red
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
item.setText(text)
self.setItem(i, j, item)
self.scrollToBottom()
def add_result_to_display(self, item):
try:
if item["response"]["result"]["url"] is not None:
row_position = self.rowCount()
self.insertRow(row_position)
in_comingitem = QTableWidgetItem(
item["response"]["result"]["url"])
in_comingitem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
self.setItem(row_position, 0, in_comingitem)
in_comingitem = QTableWidgetItem(
str(item["response"]["result"]["code"]))
if item["response"]["result"]["code"] != 200:
in_comingitem.setBackground(QColor(205, 0, 0))
elif item["response"]["result"]["code"] == 200:
in_comingitem.setBackground(QColor(0, 229, 0))
in_comingitem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
self.setItem(row_position, 1, in_comingitem)
except Exception:
pass
def create_table(self):
h_headers = [sec.__class__.__name__ for sec in self.sections]
v_headers = [self.check_header] + self.phys_proc_names
self.ui.tableWidget.setColumnCount(len(h_headers))
self.ui.tableWidget.setRowCount(len(v_headers))
self.ui.tableWidget.setHorizontalHeaderLabels(h_headers)
self.ui.tableWidget.setVerticalHeaderLabels(v_headers)
#self.ui.tableWidget.setItem(row, 0, QTableWidgetItem(r_name))
for col, sec in enumerate(self.sections):
for row, r_name in enumerate(v_headers):
checkBoxItem = QTableWidgetItem()
checkBoxItem.setCheckState(QtCore.Qt.Checked)
#flags = checkBoxItem.flags()
#QtGui.QTableWidgetItem(str(pv))
checkBoxItem.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled
| QtCore.Qt.ItemIsUserCheckable)
self.ui.tableWidget.setItem(row, col, checkBoxItem)
if row == 0:
#self.ui.tableWidget.item(row, col + 1).setBackground(QtCore.Qt.red)
checkBoxItem.setBackground(QtGui.QColor(100, 100, 150))
sec_ui = SectionUI()
sec_ui.col = col
sec_ui.v_headers = v_headers
sec_ui.tableWidget = self.ui.tableWidget
sec.ui = sec_ui
#self.ui.tableWidget.horizontalHeader().setStretchLastSection(True)
self.ui.tableWidget.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
def solve_helper(self, board):
row, col = untested(board)
if row == -1 and col == -1:
return True
for num in range(1, 10):
num_str = str(num)
if is_valid(board, row, col, num_str):
board[row][col] = num_str
item = QTableWidgetItem(num_str)
item.setTextAlignment(QtCore.Qt.AlignCenter)
item.setBackground(QtGui.QBrush(QtGui.QColor("red")))
self.tableWidget.setItem(row, col, QTableWidgetItem(item))
self.tableWidget.item(row, col).setText(num_str)
#self.tableWidget.update()
if self.solve_helper(board):
return True
else:
board[row][col] = ''
item = QTableWidgetItem('')
self.tableWidget.setItem(row, col, QTableWidgetItem(item))
return False
def SetResultFail(self, line, n):
newItem = QTableWidgetItem("测试失败")
textFont = QFont("song", 18)
newItem.setFont(textFont)
newItem.setForeground(QBrush(Qt.red))
newItem.setBackground(QBrush(Qt.gray))
self.table.setItem(line, n, newItem)
def __init__(self, stream_type, path, parent=None):
super().__init__(parent=parent)
self.UI = Ui_StreamWindow()
self.UI.setupUi(self)
# self.setWindowFlags(Qt.WindowTitleHint)
self.stream_path = path
if stream_type == StreamerTypes.APPLEWATCH:
self.streamer = AppleWatchStreamer(path=self.stream_path, parent=self)
if self.streamer:
self.streamer.add_log.connect(self.add_to_log)
self.streamer.update_progress.connect(self.update_progress)
self.streamer.finished.connect(self.streaming_server_finished)
self.streamer.file_error_occured.connect(self.streaming_file_error)
# Initial UI state
self.UI.frameProgress.hide()
infos = self.streamer.get_streamer_infos()
row = 0
self.UI.tableInfos.setRowCount(len(infos))
for info_item, info_value in infos.items():
item = QTableWidgetItem(info_item)
item.setBackground(QBrush(Qt.lightGray))
self.UI.tableInfos.setItem(row, 0, item)
item = QTableWidgetItem(info_value)
item.setBackground(QBrush(Qt.white))
item.setForeground(QBrush(Qt.blue))
self.UI.tableInfos.setItem(row, 1, item)
row += 1
# Signals / slots connection
self.UI.btnClose.clicked.connect(self.close_requested)
def assign_mem(self, mem):
self.mem=mem
#UI headers
self.setColumnCount(self.mem.maxplayers+1)
for i, j in enumerate(self.mem.jugadores.arr):
self.setColumnWidth(i, 90)
item = QTableWidgetItem(j.name)
item.setTextAlignment(Qt.AlignHCenter|Qt.AlignVCenter|Qt.AlignCenter)
item.setIcon(j.color.qicon())
self.setHorizontalHeaderItem(i, item)
item = QTableWidgetItem(self.tr("Total"))
item.setTextAlignment(Qt.AlignHCenter|Qt.AlignVCenter|Qt.AlignCenter)
self.setHorizontalHeaderItem(self.mem.maxplayers, item)
#Crea items
for i in range(self.mem.maxplayers+1+1):
for j in range(17):
item=QTableWidgetItem()
item.setTextAlignment(Qt.AlignHCenter|Qt.AlignVCenter|Qt.AlignCenter)
self.setItem( j,i, item )
#Rallando la tabla
for i, j in ((11, self.mem.maxplayers), (12, self.mem.maxplayers), (14, self.mem.maxplayers), (16, self.mem.maxplayers)):
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignRight|Qt.AlignVCenter)
brush = QBrush(QColor(0, 0, 0))
brush.setStyle(Qt.BDiagPattern)
item.setBackground(brush)
self.setItem(i, j, item)
def update_possessions(self):
tiles = self.current_player.get_possessions()
if tiles:
sorted_tiles = sorted(tiles, key = lambda x: x.get_price())
self.possessions_info.setText("You have these properties:")
if sorted_tiles != []:
color2tiles = {}
for tile in sorted_tiles:
color2tiles.setdefault(tile.get_color(), []).append(tile)
self.possessions.setColumnCount(len(color2tiles))
self.possessions.setRowCount(max((len(v) for k, v in color2tiles.items())))
for column, (color, tiles) in enumerate(color2tiles.items()):
for row, tile in enumerate(tiles):
set_color = QColor()
set_color.setNamedColor(color)
cell = QTableWidgetItem()
cell.setBackground(QBrush(set_color, style = Qt.SolidPattern))
if color == "#000000":
cell.setForeground(QBrush(QColor(255, 255, 255)))
cell.setText(f"{tile.get_name()}")
self.possessions.setItem(row, column, cell)
else:
self.possessions.clearContents()
def populate_sudoku(self, table, color=Qt.black, table_init=None):
'''
populates SudokuWidget from the 2D table
color is Qt.Color instance e.g. Qt.Green or setForeground(QColor::fromRgb(255,0,0))
'''
for u in range(9):
for v in range(9):
if (table_init
is not None) and (table[u][v] - table_init[u][v]) == 0:
item = self.item(u, v)
if item is None:
item = QTableWidgetItem()
self.setItem(u, v, item)
else:
element = item.text()
item = QTableWidgetItem(element)
self.setItem(u, v, item)
else:
element = table[u][v]
if element == 0:
item = QTableWidgetItem('')
self.setItem(u, v, item)
else:
item = QTableWidgetItem(str(element))
item.setForeground(color)
self.setItem(u, v, item)
if self.in_quadrant(u, v) % 2 == 0:
item.setBackground(QColor.fromRgb(245, 245, 245))
def _set_twi(self, row, col, text, bg_color=None, fg_color=None):
twi = QTableWidgetItem(str(text))
if bg_color is not None:
bgb = QBrush(QColor(bg_color), Qt.SolidPattern)
twi.setBackground(bgb)
if fg_color is not None:
fgb = QBrush(QColor(fg_color), Qt.SolidPattern)
twi.setForeground(fgb)
self.ui.tw_flights.setItem(row, col, twi)
def fill_UI(self):
"""fills table with data
"""
self.get_data()
rows = len(self.data) + 1
self.setRowCount(rows)
self.check_dic = {}
all_checked = True
for (i, row) in enumerate(self.data):
cell_widget = QWidget()
mini_layout = QHBoxLayout(cell_widget)
cell_widget.setLayout(mini_layout)
self.check_dic[i] = QCheckBox(self)
self.check_dic[i].clicked.connect(self.count_chosen)
self.check_dic[i].clicked.connect(self.unselect_select_all)
mini_layout.addWidget(self.check_dic[i])
mini_layout.setAlignment(Qt.AlignCenter)
self.setCellWidget(i, 0, cell_widget)
for (k, item) in enumerate(row):
self.setItem(i, k + 1, QTableWidgetItem(str(item)))
if self.allele_status_column:
status = row[self.allele_status_column]
color = general.color_dic[general.allele_status_dic[status.lower()]]
status_item = QTableWidgetItem(status)
status_item.setBackground(QColor(color))
if self.instant_accept_status:
if status == self.instant_accept_status:
self.check_dic[i].setChecked(True)
status_item.setFont(general.font_bold)
else:
all_checked = False
self.setItem(i, self.allele_status_column + 1, status_item)
# add select-all row:
cell_widget = QWidget()
mini_layout = QHBoxLayout(cell_widget)
cell_widget.setLayout(mini_layout)
self.check_all = QCheckBox(self)
mini_layout.addWidget(self.check_all)
if all_checked:
self.check_all.setChecked(True)
mini_layout.setAlignment(Qt.AlignCenter)
self.check_all.clicked.connect(self.toggle_select_all)
self.setCellWidget(rows-1, 0, cell_widget)
self.setItem(rows-1, 1, QTableWidgetItem(""))
self.setItem(rows-1, 2, QTableWidgetItem("Select All"))
self.setItem(rows-1, 3, QTableWidgetItem(""))
self.setItem(rows-1, 4, QTableWidgetItem(""))
self.resizeColumnsToContents()
self.count_chosen()
def update_files_chosen(self, nr):
"""updates the "number of files chosen" field
"""
self.log.debug("Setting chosen_files to {}".format(nr))
try:
self.item(3,0).setText(str(nr))
except AttributeError:
myitem = QTableWidgetItem(str(nr))
if nr == 0:
myitem.setBackground(general.color_dic["todo"])
self.setItem(3,0, myitem)
self.updated.emit()
def _update_key(self):
"""
Updates the key. Run after the table has been (re)populated.
"""
i = 0
for key in self.color_map.keys():
item = QTableWidgetItem(key)
if self.color_map.get(key):
item.setForeground(QBrush(QColor(self.color_map[key][0])))
item.setBackground(QBrush(QColor(self.color_map[key][1])))
self.ui.keyTableWidget_2.setItem(0, i, item)
i += 1
def resetTotals(self):
self.totals.setHorizontalHeaderLabels(self.engine.getListPlayers())
self.totals.clearContents()
for row in range(len(self.engine.getEntryKinds())):
background = self.bgcolors[row]
for col in range(len(self.engine.getListPlayers())):
item = QTableWidgetItem()
item.setFlags(item.flags() ^ QtCore.Qt.ItemIsEditable)
item.setTextAlignment(
QtCore.Qt.AlignVCenter | QtCore.Qt.AlignCenter)
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
item.setText("0")
self.totals.setItem(row, col, item)
def set_row(self, row, model):
for col, spec in enumerate(self.columns):
value = spec.render(model)
color = None
if isinstance(value, tuple):
value, color = value
w = QTableWidgetItem(str(value))
if color is not None:
w.setBackground(color)
w.setTextAlignment(Qt.AlignVCenter | Qt.AlignLeft)
w.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.setItem(row, col, w)
self.setRowHidden(row, not self.apply_filter_to_row(row))
def set_table(self):
for row, operation in enumerate(self.work["operation_list"]):
self.tw_operation.insertRow(row)
new_table_item = QTableWidgetItem(str(operation[2]))
self.tw_operation.setItem(row, 0, new_table_item)
new_table_item = QTableWidgetItem(str(operation[5]))
self.tw_operation.setItem(row, 1, new_table_item)
new_table_item = QTableWidgetItem(str(operation[6]))
self.tw_operation.setItem(row, 2, new_table_item)
new_table_item = QTableWidgetItem(str(round(operation[1], 2)))
self.tw_operation.setItem(row, 3, new_table_item)
new_table_item = QTableWidgetItem(str(operation[3].strftime("%d.%m.%Y")))
self.tw_operation.setItem(row, 4, new_table_item)
new_table_item = QTableWidgetItem(str(operation[4].strftime("%d.%m.%Y %H:%M:%S")))
self.tw_operation.setItem(row, 5, new_table_item)
for row, p_m in enumerate(self.work["p_m_list"]):
self.tw_p_m.insertRow(row)
if p_m[2] > 0:
color = QBrush(QColor(152, 251, 152, 255))
else:
color = QBrush(QColor(240, 128, 128, 255))
new_table_item = QTableWidgetItem(str(p_m[1]))
new_table_item.setBackground(color)
self.tw_p_m.setItem(row, 0, new_table_item)
new_table_item = QTableWidgetItem(str(round(p_m[2], 2)))
new_table_item.setBackground(color)
self.tw_p_m.setItem(row, 1, new_table_item)
new_table_item = QTableWidgetItem(str(p_m[3].strftime("%d.%m.%Y")))
new_table_item.setBackground(color)
self.tw_p_m.setItem(row, 2, new_table_item)
new_table_item = QTableWidgetItem(str(p_m[4]))
new_table_item.setBackground(color)
self.tw_p_m.setItem(row, 3, new_table_item)
new_table_item = QTableWidgetItem(str(p_m[5]))
new_table_item.setBackground(color)
self.tw_p_m.setItem(row, 4, new_table_item)
def set_table_road(self):
date_old = self.de_road_date.date()
date_old = datetime.date(date_old.year(), date_old.month(), date_old.day())
query = """SELECT One_year, Many_year FROM program_settings_road"""
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получение цен оплаты проезда", sql_info.msg, QMessageBox.Ok)
return False
self.one_year_price = sql_info[0][0]
self.many_year_price = sql_info[0][1]
query = """SELECT Id, First_Name, Last_Name, Date_Recruitment
FROM staff_worker_info
WHERE Date_Recruitment < %s AND `Leave` = 0"""
sql_info = my_sql.sql_select(query, (date_old.replace(date_old.year-1), ))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получение сотрудников со стажем", sql_info.msg, QMessageBox.Ok)
return False
self.tw_road.clearContents()
self.tw_road.setRowCount(0)
for row, worker in enumerate(sql_info):
self.tw_road.insertRow(row)
delta_date = date_old - worker[3]
if delta_date.days < 730:
color = QBrush(QColor(252, 252, 139, 255))
price = self.one_year_price
else:
color = QBrush(QColor(252, 190, 139, 255))
price = self.many_year_price
new_table_item = QTableWidgetItem(str(worker[2]) + " " + str(worker[1]))
new_table_item.setData(-2, worker[0])
new_table_item.setBackground(color)
new_table_item.setFlags(Qt.ItemIsEnabled)
self.tw_road.setItem(row, 0, new_table_item)
new_table_item = QTableWidgetItem(worker[3].strftime("%d.%m.%Y"))
new_table_item.setData(-2, worker[0])
new_table_item.setBackground(color)
new_table_item.setFlags(Qt.ItemIsEnabled)
self.tw_road.setItem(row, 1, new_table_item)
new_table_item = QTableWidgetItem(str(delta_date.days))
new_table_item.setData(-2, worker[0])
new_table_item.setBackground(color)
new_table_item.setFlags(Qt.ItemIsEnabled)
self.tw_road.setItem(row, 2, new_table_item)
new_table_item = QTableWidgetItem(str(price))
new_table_item.setData(-2, worker[0])
new_table_item.setBackground(color)
self.tw_road.setItem(row, 3, new_table_item)
def refreshSamplesTable(self):
query="""
select sample,well,name,min(elapsed),max(elapsed)
from v_ops
where plate='%s' and program=%d
and cmd!='Detect_Liquid'
and cmd!='Initial'
group by sample,well,name
order by right(well,length(well)-1)+0,well
"""%(self.currentPlate, self.currentProgram)
print(query)
q=QtSql.QSqlQuery(query)
if q.lastError().isValid():
self.dbreopen()
q = QtSql.QSqlQuery(query)
self.sqlErrorCheck(q.lastError())
self.sampleTable.setColumnCount(7)
data=[]
while q.next():
sampInfo = self.getSampData(q.value(0),self.horizonHours.value())
data.append([q.value(0),q.value(1),q.value(2),"%.0f-%.0f"%(q.value(3)/60,q.value(4)/60) if q.value(4)>self.lastElapsed else "Done",sampInfo[0],sampInfo[1],sampInfo[2]])
self.sampleTable.setRowCount(len(data))
for r in range(len(data)):
for c in range(len(data[r])):
if c==0:
item = QTableWidgetItem("%d"%data[r][c])
elif c>=4:
item = QTableWidgetItem("%.1f"%data[r][c])
if data[r][c]<15:
item.setBackground(QColor("red"))
elif data[r][c] < 30:
item.setBackground(QColor("yellow"))
else:
item = QTableWidgetItem(data[r][c])
self.sampleTable.setItem(r,c,item)
#query = "select s.sample,s.well,s.name from samples s where s.plate='%s' and s.program=%d order by right(s.well,length(s.well)-1),s.well;" % (self.currentPlate, self.currentProgram)
self.sampleTable.setColumnHidden(0,True)
self.sampleTable.setHorizontalHeaderItem(1,QTableWidgetItem("Well"))
self.sampleTable.setHorizontalHeaderItem(2,QTableWidgetItem("Name"))
self.sampleTable.setHorizontalHeaderItem(3,QTableWidgetItem("Elapsed"))
self.sampleTable.setHorizontalHeaderItem(4,QTableWidgetItem("Cur Vol"))
self.sampleTable.setHorizontalHeaderItem(5,QTableWidgetItem("Vol in %.0f hrs"%self.horizonHours.value()))
self.sampleTable.setHorizontalHeaderItem(6,QTableWidgetItem("End Vol"))
self.sampleTable.resizeColumnsToContents()
def populate(self):
"""
Populates the table with given string groups
and sets the number of columns.
"""
columns = self.ui.tableWidget_2.width() // 140
logging.debug("columns on resize: " + str(columns))
self._items.clear()
self.ui.tableWidget_2.clear()
self.ui.tableWidget_2.columnWidth(140)
# We build a list of items and set the colors for item.
for key in self._item_dictionary:
for str_item in self._item_dictionary[key]:
item = QTableWidgetItem(str_item)
self._items.append(item)
item.setForeground(QBrush(QColor(self.color_map[key][0])))
item.setBackground(QBrush(QColor(self.color_map[key][1])))
if len(self._items) == 0:
return
self.ui.tableWidget_2.setRowCount(len(self._items)//columns+1)
self.ui.tableWidget_2.setColumnCount(columns)
i = 0
while i < columns:
self.ui.tableWidget_2.setColumnWidth(i, 140)
i += 1
# We set the items to the table.
row = 0
col = 0
for item in self._items:
self.ui.tableWidget_2.setItem(row, col, item)
if col+1 == columns:
col = 0
row += 1
else:
col += 1
self._update_key()
def ui_other(self):
query = """SELECT accessories_balance.Id, accessories_supply.Id, accessories_supply.Data, accessories_supplyposition.Price, accessories_supplyposition.Value,
accessories_balance.BalanceValue
FROM accessories_supplyposition LEFT JOIN accessories_balance ON accessories_supplyposition.Id = accessories_balance.accessories_SupplyPositionId
LEFT JOIN accessories_supply ON accessories_supplyposition.accessories_SupplyId = accessories_supply.Id
WHERE accessories_supplyposition.accessories_NameId = %s
ORDER BY accessories_supply.Data DESC"""
self.table_items = my_sql.sql_select(query, (self.other_value, ))
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(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])
if table_typle[4] == table_typle[5]:
color = QBrush(QColor(150, 255, 161, 255))
elif table_typle[5] == 0:
color = QBrush(QColor(252, 141, 141, 255))
else:
color = QBrush(QColor(255, 255, 153, 255))
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 ui_salary_p_m(self):
self.timer.start(900000)
query = """SELECT pay_reason.Name, pay_worker.Balance, pay_worker.Date_In_Pay, pay_worker.Note
FROM pay_worker LEFT JOIN pay_reason ON pay_worker.Reason_Id = pay_reason.Id
WHERE pay_worker.Worker_Id = %s AND pay_worker.Pay = 0"""
sql_info = my_sql.sql_select(query, (self.user["id"],))
if "mysql.connector.errors" in str(type(sql_info)):
return False
self.tw_salary_p_m.clearContents()
self.tw_salary_p_m.setRowCount(0)
p_m_plus = 0
p_m_minus = 0
p_m_all = 0
for row, p_m in enumerate(sql_info):
if p_m[1] >= 0:
color = QBrush(QColor(246, 250, 127, 255))
p_m_plus += p_m[1]
else:
color = QBrush(QColor(245, 113, 113, 255))
p_m_minus += -p_m[1]
self.tw_salary_p_m.insertRow(row)
new_table_item = QTableWidgetItem(str(p_m[0]))
new_table_item.setBackground(color)
self.tw_salary_p_m.setItem(row, 0, new_table_item)
new_table_item = QTableWidgetItem(str(round(p_m[1], 2)))
new_table_item.setBackground(color)
self.tw_salary_p_m.setItem(row, 1, new_table_item)
new_table_item = QTableWidgetItem(str(p_m[2].strftime("%d.%m.%Y")))
new_table_item.setBackground(color)
self.tw_salary_p_m.setItem(row, 2, new_table_item)
new_table_item = QTableWidgetItem(str(p_m[3]))
new_table_item.setBackground(color)
self.tw_salary_p_m.setItem(row, 3, new_table_item)
p_m_all = p_m_plus - p_m_minus
self.tw_salary_p_m_all.setText(re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(round(p_m_all, 2))))
self.tw_salary_p_m_minus.setText(re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(round(p_m_minus, 2))))
self.tw_salary_p_m_plus.setText(re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(round(p_m_plus, 2))))
self.sw_main.setCurrentIndex(7)
def insertRound(self, r):
winner = r.getWinner()
i = r.getNumRound() - 1
self.insertRow(i)
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(
"RatukiRoundTable", " (Winner)")
item.setText(text)
self.setItem(i, j, item)
self.scrollToBottom()
def insertRound(self, entry):
kind = entry.getKind()
kinds = self.engine.getEntryKinds()
background = self.bgcolors[kinds.index(kind)]
kind = i18n("CarcassonneInputWidget", kind)
i = entry.getNumRound() - 1
self.insertRow(i)
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)
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
if player == entry.getPlayer():
text = "{} ({})".format(entry.getPlayerScore(), kind)
font = item.font()
font.setBold(True)
item.setFont(font)
else:
text = ""
item.setText(text)
self.setItem(i, j, item)
self.scrollToBottom()
def set_start_info(self):
query = """SELECT Weight FROM rest_warehouse"""
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получения склада", sql_info.msg, QMessageBox.Ok)
return False
self.le_weight.setText(str(sql_info[0][0]))
query = """SELECT Id, Balance, Date, Note, Cut_Id FROM transaction_records_rest ORDER BY Date DESC, Id DESC LIMIT 30"""
sql_info = my_sql.sql_select(query)
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получения информации", sql_info.msg, QMessageBox.Ok)
return False
self.tw_info.clearContents()
self.tw_info.setRowCount(0)
for row, info in enumerate(sql_info):
self.tw_info.insertRow(row)
if info[1] >= 0:
color = QBrush(QColor(150, 255, 161, 255))
else:
color = QBrush(QColor(252, 141, 141, 255))
new_table_item = QTableWidgetItem(str(info[0]))
new_table_item.setData(-2, info[4])
new_table_item.setBackground(color)
self.tw_info.setItem(row, 0, new_table_item)
new_table_item = QTableWidgetItem(str(info[1]))
new_table_item.setData(-2, info[4])
new_table_item.setBackground(color)
self.tw_info.setItem(row, 1, new_table_item)
new_table_item = QTableWidgetItem(info[2].strftime("%d.%m.%Y"))
new_table_item.setData(-2, info[4])
new_table_item.setBackground(color)
self.tw_info.setItem(row, 2, new_table_item)
new_table_item = QTableWidgetItem(str(info[3]))
new_table_item.setData(-2, info[4])
new_table_item.setBackground(color)
self.tw_info.setItem(row, 3, new_table_item)
def ui_calc(self):
self.tw_pack.clearContents()
self.tw_pack.setRowCount(0)
# Получить пачки с нужной тканью
query = """SELECT pack.Article_Parametr_Id, pack.Id, cut.Id, pack.Number, pack.Value_Pieces,
pack.Weight, pack.Weight / 100 * cut.Rest_Percent
FROM cut LEFT JOIN pack ON cut.Id = pack.Cut_Id
WHERE cut.Date_Cut BETWEEN %s AND %s AND cut.Material_Id = %s"""
sql_info = my_sql.sql_select(query, (self.de_date_from.date().toPyDate(), self.de_date_to.date().toPyDate(), self.le_matrial.whatsThis()))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получения пачек", sql_info.msg, QMessageBox.Ok)
return False
# Получить пачки с доп тканью
query = """SELECT pack.Article_Parametr_Id, pack.Id, cut.Id, pack.Number, pack.Value_Pieces,
pack_add_material.Weight_Rest + pack_add_material.Weight
FROM cut LEFT JOIN pack ON cut.Id = pack.Cut_Id
LEFT JOIN pack_add_material ON pack.Id = pack_add_material.Pack_Id
WHERE cut.Date_Cut BETWEEN %s AND %s AND pack_add_material.Material_Name_Id = %s"""
sql_info_add = my_sql.sql_select(query, (self.de_date_from.date().toPyDate(), self.de_date_to.date().toPyDate(), self.le_matrial.whatsThis()))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получения пачек c доп тканью", sql_info.msg, QMessageBox.Ok)
return False
# Составить словать из полученых значений
# {Артикул: [[Id п, Id к, Номер пачк, кол-во, Вес, обрезь, Доп.тк], ...] , ...}
article = {}
for pack in sql_info:
if pack[1] is not None:
new = [pack[1], pack[2], pack[3], pack[4], pack[5]/pack[4], pack[6]/pack[4], None]
article.setdefault(pack[0], []).append(new)
for pack in sql_info_add:
if pack[1] is not None:
new = [pack[1], pack[2], pack[3], pack[4], None, None, pack[5]/pack[4]]
article.setdefault(pack[0], []).append(new)
color_g = QBrush(QColor(150, 255, 161, 255))
color_y = QBrush(QColor(255, 255, 153, 255))
color_w = QBrush(QColor(255, 255, 255, 255))
for key, values in article.items():
# Вставить шапку артикула
self.tw_pack.insertRow(self.tw_pack.rowCount())
self.tw_pack.setSpan(self.tw_pack.rowCount() - 1, 0, 1, 7)
item = QTableWidgetItem("Артикул %s" % key)
self.tw_pack.setItem(self.tw_pack.rowCount() - 1, 0, item)
# Найти средние значения и разлеты
mass = [i[4] for i in values if i[4] is not None]
if mass:
m = statistics.mean(mass)
w_ = m * Decimal(1.15)
_w = m * Decimal(0.75)
else:
w_ = 0
_w = 0
mass = [i[5] for i in values if i[5] is not None]
if mass:
m = statistics.mean(mass)
r_ = m * Decimal(1.15)
_r = m * Decimal(0.75)
else:
r_ = 0
_r = 0
mass = [i[6] for i in values if i[6] is not None]
if mass:
m = statistics.mean(mass)
a_ = m * Decimal(1.15)
_a = m * Decimal(0.75)
else:
a_ = 0
_a = 0
# print("Артикул %s w %s-%s r %s-%s a %s-%s " % (key, _w, w_, _r, r_, _a, a_,))
for value in values:
# Вставить значения
self.tw_pack.insertRow(self.tw_pack.rowCount())
item = QTableWidgetItem(str(value[0]))
item.setData(5, value[0])
self.tw_pack.setItem(self.tw_pack.rowCount() - 1, 0, item)
item = QTableWidgetItem(str(value[1]))
self.tw_pack.setItem(self.tw_pack.rowCount() - 1, 1, item)
item = QTableWidgetItem(str(value[2]))
self.tw_pack.setItem(self.tw_pack.rowCount() - 1, 2, item)
item = QTableWidgetItem(str(value[3]))
self.tw_pack.setItem(self.tw_pack.rowCount() - 1, 3, item)
if value[4] is None:
color = color_w
elif _w < value[4] < w_:
color = color_g
else:
color = color_y
try:
txt = str(round(value[4], 7))
except TypeError:
txt = "None"
item = QTableWidgetItem(txt)
item.setBackground(color)
self.tw_pack.setItem(self.tw_pack.rowCount() - 1, 4, item)
if value[5] is None:
color = color_w
elif _r < value[5] < r_:
color = color_g
else:
color = color_y
try:
txt = str(round(value[5], 7))
except TypeError:
txt = "None"
item = QTableWidgetItem(txt)
item.setBackground(color)
self.tw_pack.setItem(self.tw_pack.rowCount() - 1, 5, item)
if value[6] is None:
color = color_w
elif _a < value[6] < a_:
color = color_g
else:
color = color_y
try:
txt = str(round(value[6], 7))
except TypeError:
txt = "None"
item = QTableWidgetItem(txt)
item.setBackground(color)
self.tw_pack.setItem(self.tw_pack.rowCount() - 1, 6, item)
def ui_calc(self):
self.tableWidget.clearContents()
self.tableWidget.setRowCount(0)
query = """SELECT Last_Name, First_Name, Date_Recruitment, If(`Leave` = 0, NULL, Date_Leave)
FROM staff_worker_info
WHERE Date_Recruitment <= %s AND (Date_Leave >= %s OR `Leave` = 0 ) ORDER BY Last_Name, First_Name"""
sql_info = my_sql.sql_select(query, (self.de_date_to.date().toPyDate(), self.de_date_from.date().toPyDate()))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получения работников", sql_info.msg, QMessageBox.Ok)
return False
nal = int(self.le_nalog.text())
day_mon = calendar.monthrange(self.de_date_to.date().toPyDate().year, self.de_date_to.date().toPyDate().month)[1]
for work in sql_info:
# проверяем какую дату брать первой
if work[2] <= self.de_date_from.date().toPyDate():
date_from = self.de_date_from.date().toPyDate()
else:
date_from = work[2]
# проверяем какую дату брать второй
if work[3] is None:
date_to = self.de_date_to.date().toPyDate()
elif work[3] >= self.de_date_to.date().toPyDate():
date_to = self.de_date_to.date().toPyDate()
else:
date_to = work[3]
day = date_to - date_from
day = day.days + 1
if day == day_mon:
str_nal = str(nal)
else:
str_nal = str(round(nal - ((day_mon - day) * (nal / day_mon)), 2))
if str_nal != self.le_nalog.text() or day != day_mon:
color = QBrush(QColor(255, 255, 153, 255))
else:
color = QBrush(QColor(150, 255, 161, 255))
self.tableWidget.insertRow(self.tableWidget.rowCount())
item = QTableWidgetItem(work[0])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 0, item)
item = QTableWidgetItem(work[1])
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 1, item)
item = QTableWidgetItem(work[2].strftime("%d.%m.%Y"))
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 2, item)
if work[3] is None:
text = "Не уволен"
else:
text = work[3].strftime("%d.%m.%Y")
item = QTableWidgetItem(text)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 3, item)
item = QTableWidgetItem(str(day))
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 4, item)
item = QTableWidgetItem(str_nal)
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 5, item)
def ui_calc(self):
self.tableWidget.clearContents()
self.tableWidget.setRowCount(0)
article_list = {}
query = """SELECT product_article_parametrs.Id, CONCAT(product_article.Article, '(', product_article_size.Size, ')[', product_article_parametrs.Name, ']'),
order_position.Value, IF(clients.No_Nds, order_position.Price * (order_position.NDS / 100 + 1), order_position.Price)
FROM order_position LEFT JOIN `order` ON order_position.Order_Id = `order`.Id
LEFT JOIN clients ON `order`.Client_Id = clients.Id
LEFT JOIN product_article_parametrs ON order_position.Product_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 `order`.Date_Shipment >= %s AND `order`.Date_Shipment <= %s AND `order`.Shipped = 1"""
sql_info = my_sql.sql_select(query, (self.de_date_from.date().toPyDate(), self.de_date_to.date().toPyDate()))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получения проданых позиций", sql_info.msg, QMessageBox.Ok)
return False
for order_position in sql_info:
if article_list.get(order_position[0]) is None:
article_list.update({order_position[0]: {"value": 0, "sum": 0, "seb": None, "name": order_position[1]}})
article_list[order_position[0]]["value"] += order_position[2]
article_list[order_position[0]]["sum"] += order_position[2] * order_position[3]
# Получаем id разных пачек для подсчета
for key, value in article_list.items():
self.statusBar.showMessage("Расчет артикула %s" % article_list[key]["name"])
query = """SELECT pack.Id FROM pack LEFT JOIN cut ON pack.Cut_Id = cut.Id JOIN (SELECT @sum := 0) t
WHERE pack.Article_Parametr_Id = %s AND cut.Date_Cut <= %s AND (@sum := @sum + pack.Value_Pieces) <= %s"""
sql_pack_id_info = my_sql.sql_select(query, (key, self.de_date_to.date().toPyDate(), value["value"] + 200))
if "mysql.connector.errors" in str(type(sql_pack_id_info)):
QMessageBox.critical(self, "Ошибка sql получения id пачек для артикула", sql_pack_id_info.msg, QMessageBox.Ok)
return False
v = int(len(sql_pack_id_info)/5) + 1
sebest_pack_list = []
if sql_pack_id_info: # Если найдены предыдущие кроя! (Если нет то возьмем расчетную себестоимость из артикула)
for i in range(len(sql_pack_id_info)):
if i % v != 0:
continue
pack_id = sql_pack_id_info[i][0]
# Узнаем всю себестоимость
query = """SELECT(
SELECT AVG(DISTINCT material_supplyposition.Price) * (SELECT (pack.Weight * (1 + cut.Rest_Percent / 100)) / pack.Value_Pieces
FROM pack LEFT JOIN cut ON pack.Cut_Id = cut.Id
WHERE pack.Id = pm.Id)
FROM pack LEFT JOIN transaction_records_material ON transaction_records_material.Cut_Material_Id = pack.Cut_Id
LEFT JOIN material_balance ON transaction_records_material.Supply_Balance_Id = material_balance.Id
LEFT JOIN material_supplyposition ON material_balance.Material_SupplyPositionId = material_supplyposition.Id
WHERE pack.Id = pm.Id AND transaction_records_material.Note NOT LIKE '%доп. тк%'
),(
SELECT SUM(((pack_add_material.Weight + pack_add_material.Weight_Rest) / pack.Value_Pieces) * pack_add_material.Price)
FROM pack_add_material LEFT JOIN pack ON pack_add_material.Pack_Id = pack.Id
WHERE pack.Id = pm.Id
),(
SELECT SUM(avg) FROM (
SELECT AVG(accessories_supplyposition.Price) * pack_accessories.Value_Thing AS avg
FROM pack
LEFT JOIN pack_accessories ON pack.Id = pack_accessories.Pack_Id
LEFT JOIN transaction_records_accessories ON transaction_records_accessories.Pack_Accessories_Id = pack_accessories.Id
LEFT JOIN accessories_balance ON transaction_records_accessories.Supply_Balance_Id = accessories_balance.Id
LEFT JOIN accessories_supplyposition ON accessories_balance.Accessories_SupplyPositionId = accessories_supplyposition.Id
WHERE pack.Id = %s
GROUP BY pack_accessories.Id) t
),(
SELECT SUM(pack_operation.Price) FROM pack_operation WHERE pack_operation.Pack_Id = pm.Id
)
FROM pack as pm WHERE pm.Id = %s"""
sql_info = my_sql.sql_select(query, (pack_id, pack_id))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получения средней цены ткани для кроя", sql_info.msg, QMessageBox.Ok)
return False
sebest_pack_list.append(sum([0 if i is None else i for i in sql_info[0]]))
# Находим среднюю себестоимость на артикул
if sebest_pack_list:
article_list[key]["seb"] = sum(sebest_pack_list) / len(sebest_pack_list)
else:
article_list[key]["seb"] = None
else: # Если нет прошлых краев, то возьмем расчетную себестоимость
# Узнаем всю расчетную себестоимость
query = """SELECT (
SELECT SUM(operations.Price)
FROM product_article_operation LEFT JOIN operations ON product_article_operation.Operation_Id = operations.Id
WHERE product_article_operation.Product_Article_Parametrs_Id = pr.Id
),(
SELECT SUM(s)
FROM (SELECT material_supplyposition.Price * product_article_material.Value AS s
FROM product_article_material
LEFT JOIN material_supplyposition ON product_article_material.Material_Id = material_supplyposition.Material_NameId
LEFT JOIN material_supply ON material_supplyposition.Material_SupplyId = material_supply.Id
LEFT JOIN material_balance ON material_supplyposition.Id = material_balance.Material_SupplyPositionId
WHERE product_article_material.Product_Article_Parametrs_Id = %s AND product_article_material.Material_Id IS NOT NULL
AND material_balance.BalanceWeight > 0
GROUP BY product_article_material.Material_Id) t
),(
SELECT SUM(s)
FROM (SELECT accessories_supplyposition.Price * product_article_material.Value AS s
FROM product_article_material
LEFT JOIN accessories_supplyposition ON product_article_material.Accessories_Id = accessories_supplyposition.Accessories_NameId
LEFT JOIN accessories_supply ON accessories_supplyposition.Accessories_SupplyId = accessories_supply.Id
LEFT JOIN accessories_balance ON accessories_supplyposition.Id = accessories_balance.Accessories_SupplyPositionId
WHERE product_article_material.Product_Article_Parametrs_Id = %s AND product_article_material.Accessories_Id IS NOT NULL
AND accessories_balance.BalanceValue > 0
GROUP BY product_article_material.Accessories_Id) t
)
FROM product_article_parametrs AS pr WHERE pr.Id = %s"""
sql_info = my_sql.sql_select(query, (key, key, key))
if "mysql.connector.errors" in str(type(sql_info)):
QMessageBox.critical(self, "Ошибка sql получения расчетной себестоимости", sql_info.msg, QMessageBox.Ok)
return False
# Считаем себестоимость
if sql_info[0][0]:
article_list[key]["seb"] = sql_info[0][0] + sql_info[0][1] + sql_info[0][2]
article_list[key]["name"] = "Б/К " + article_list[key]["name"]
else:
article_list[key]["seb"] = 0
article_list[key]["name"] = "Б/К " + article_list[key]["name"]
self.tableWidget.insertRow(self.tableWidget.rowCount())
# Вставляем расчитаный артикул
# Цвет зависит от положительной или отрицательной прибыли
if article_list[key]["seb"]:
profit = (article_list[key]["sum"] - (article_list[key]["seb"] * article_list[key]["value"]))
if profit > 0:
color = QBrush(QColor(150, 255, 161, 255))
else:
color = QBrush(QColor(255, 255, 153, 255))
else:
color = QBrush(QColor(252, 141, 141, 255))
item = QTableWidgetItem(article_list[key]["name"])
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 0, item)
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(article_list[key]["value"]))
item = QTableWidgetItem(text)
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 1, item)
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(round(article_list[key]["sum"], 4)))
item = QTableWidgetItem(text)
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 2, item)
if article_list[key]["seb"]:
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(round(article_list[key]["seb"], 4)))
else:
text = "None"
item = QTableWidgetItem(text)
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 3, item)
if article_list[key]["seb"]:
text = re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(round(profit, 4)))
else:
text = "None"
item = QTableWidgetItem(text)
item.setBackground(color)
self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 4, item)
def createRow(self, param, name_editable=False, value_editable=True, comments_editable=True, index=-1):
"""
Create a row in the table for a param.
Input:
param: ParamNode
Return:
BaseRowItem derived object
"""
row = self.rowCount()
if index >= 0:
row = index
self.insertRow(row)
name_item = QTableWidgetItem(param.name)
name_item.setData(Qt.UserRole, param)
if not name_editable:
name_item.setFlags(Qt.ItemIsEnabled)
if param.required:
color = QColor(255, 204, 153)
brush = QBrush(color)
name_item.setBackground(brush)
elif param.user_added:
color = QColor("cyan")
brush = QBrush(color)
name_item.setBackground(brush)
name_item.setText(param.name)
self.setItem(row, 0, name_item)
if param.cpp_type == "bool":
checkbox = QCheckBox()
if param.value == "true":
checkbox.setCheckState(Qt.Checked)
else:
checkbox.setCheckState(Qt.Unchecked)
checkbox.pressed.connect(self.changed)
self.setCellWidget(row, 1, checkbox)
else:
value_item = QTableWidgetItem(param.value)
if not value_editable or param.name == "type":
value_item.setFlags(Qt.ItemIsEnabled)
else:
name_item.setToolTip(param.toolTip())
self.setItem(row, 1, value_item)
comments_item = QTableWidgetItem(param.comments)
if not comments_editable:
comments_item.setFlags(Qt.ItemIsEnabled)
self.setItem(row, 3, comments_item)
watch_blocks = self._getChildrenOfNodeOptions(param.cpp_type)
if param.cpp_type == "FileName" or param.cpp_type == "MeshFileName" or param.cpp_type == "FileNameNoExtension":
self._createFilenameOption(param)
elif watch_blocks:
self._createBlockWatcher(param, watch_blocks)
elif param.options:
self._createOptions(param)
elif param.user_added:
button = QPushButton("Remove")
button.clicked.connect(lambda checked: self._removeButtonClicked(name_item))
self.setCellWidget(row, 2, button)
else:
option_item = QTableWidgetItem()
option_item.setFlags(Qt.NoItemFlags)
self.setItem(row, 2, option_item)
def ui_salary_operation(self):
self.timer.start(900000)
query = """SELECT cut.Id, pack.Number, product_article.Article, product_article_size.Size, pack_operation.Name, pack_operation.Price,
pack.Value_Pieces - pack.Value_Damage, pack_operation.Price * (pack.Value_Pieces - pack.Value_Damage ),
pack_operation.Date_make, pack_operation.Date_Input,
CASE
WHEN pack.Date_Make IS NOT NULL AND pack.Date_Coplete IS NOT NULL THEN 1
ELSE 0
END
FROM pack_operation LEFT JOIN pack ON pack_operation.Pack_Id = pack.Id
LEFT JOIN cut ON pack.Cut_Id = cut.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_operation.Worker_Id = %s AND pack_operation.Pay = 0"""
sql_info = my_sql.sql_select(query, (self.user["id"], ))
if "mysql.connector.errors" in str(type(sql_info)):
return False
self.tw_salary_operation.clearContents()
self.tw_salary_operation.setRowCount(0)
operation_all = 0
operation_ok = 0
operation_waiting = 0
for row, operation in enumerate(sql_info):
if operation[10] == 0:
color = QBrush(QColor(246, 250, 127, 255))
operation_waiting += operation[7]
else:
color = QBrush(QColor(120, 240, 138, 255))
operation_ok += operation[7]
self.tw_salary_operation.insertRow(row)
new_table_item = QTableWidgetItem(str(operation[0]))
new_table_item.setBackground(color)
self.tw_salary_operation.setItem(row, 0, new_table_item)
new_table_item = QTableWidgetItem(str(operation[1]))
new_table_item.setBackground(color)
self.tw_salary_operation.setItem(row, 1, new_table_item)
new_table_item = QTableWidgetItem(str(operation[2]))
new_table_item.setBackground(color)
self.tw_salary_operation.setItem(row, 2, new_table_item)
new_table_item = QTableWidgetItem(str(operation[3]))
new_table_item.setBackground(color)
self.tw_salary_operation.setItem(row, 3, new_table_item)
new_table_item = QTableWidgetItem(str(operation[4]))
new_table_item.setBackground(color)
self.tw_salary_operation.setItem(row, 4, new_table_item)
new_table_item = QTableWidgetItem(str(round(operation[5], 2)))
new_table_item.setBackground(color)
self.tw_salary_operation.setItem(row, 5, new_table_item)
new_table_item = QTableWidgetItem(str(operation[6]))
new_table_item.setBackground(color)
self.tw_salary_operation.setItem(row, 6, new_table_item)
new_table_item = QTableWidgetItem(str(round(operation[7], 2)))
new_table_item.setBackground(color)
self.tw_salary_operation.setItem(row, 7, new_table_item)
new_table_item = QTableWidgetItem(operation[8].strftime("%d.%m.%Y"))
new_table_item.setBackground(color)
self.tw_salary_operation.setItem(row, 8, new_table_item)
new_table_item = QTableWidgetItem(operation[9].strftime("%d.%m.%Y %H:%M:%S"))
new_table_item.setBackground(color)
self.tw_salary_operation.setItem(row, 9, new_table_item)
operation_all = operation_waiting + operation_ok
self.le_salary_operation_all.setText(re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(round(operation_all, 2))))
self.le_salary_operation_waiting.setText(re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(round(operation_waiting, 2))))
self.le_salary_operation_ok.setText(re.sub(r'(?<=\d)(?=(\d\d\d)+\b.)', ' ', str(round(operation_ok, 2))))
self.sw_main.setCurrentIndex(6)
def set_operation_table(self):
query = """SELECT pack_operation.Id, pack_operation.Position, pack_operation.Name, sewing_machine.Name, staff_worker_info.Last_Name, staff_worker_info.First_Name,
DATE_FORMAT(pack_operation.Date_make, '%d.%m.%Y'), pack_operation.Price, staff_worker_info.Id
FROM pack LEFT JOIN pack_operation ON pack.Id = pack_operation.Pack_Id
LEFT JOIN operations ON pack_operation.Operation_id = operations.Id
LEFT JOIN sewing_machine ON operations.Sewing_Machine_Id = sewing_machine.Id
LEFT JOIN staff_worker_info ON pack_operation.Worker_Id = staff_worker_info.Id
WHERE pack.Id = %s
ORDER BY -pack_operation.Position DESC """
sql_info = my_sql.sql_select(query, (self.cut["pack_id"], ))
if "mysql.connector.errors" in str(type(sql_info)):
self.lb_pack_error.setText('<html><head/><body><p align="center"><span style=" color:#ff0000;">Не смог получить операции(Err BD)</span></p></body></html>')
return False
if sql_info:
self.operation_list = sql_info
else:
self.lb_pack_error.setText('<html><head/><body><p align="center"><span style=" color:#ff0000;">Пустой ответ операций (Err BD)</span></p></body></html>')
self.tw_operation.clearContents()
self.tw_operation.setRowCount(0)
for row, operation in enumerate(self.operation_list):
if operation[6] is None:
color = QBrush(QColor(120, 240, 138, 255))
open_operation = True
elif operation[8] == self.user["id"]:
color = QBrush(QColor(0, 221, 237, 255))
open_operation = False
else:
color = QBrush(QColor(240, 120, 172, 255))
open_operation = False
self.tw_operation.insertRow(row)
new_table_item = QTableWidgetItem(str(operation[1]))
new_table_item.setData(-1, open_operation)
new_table_item.setData(-2, operation[0])
if color is not None:
new_table_item.setBackground(color)
self.tw_operation.setItem(row, 0, new_table_item)
new_table_item = QTableWidgetItem(str(operation[2]))
new_table_item.setData(-1, open_operation)
new_table_item.setData(-2, operation[0])
if color is not None:
new_table_item.setBackground(color)
self.tw_operation.setItem(row, 1, new_table_item)
new_table_item = QTableWidgetItem(str(operation[3]))
new_table_item.setData(-1, open_operation)
new_table_item.setData(-2, operation[0])
if color is not None:
new_table_item.setBackground(color)
self.tw_operation.setItem(row, 2, new_table_item)
new_table_item = QTableWidgetItem(str(operation[4]) + " " + str(operation[5]))
new_table_item.setData(-1, open_operation)
new_table_item.setData(-2, operation[0])
if color is not None:
new_table_item.setBackground(color)
self.tw_operation.setItem(row, 3, new_table_item)
new_table_item = QTableWidgetItem(str(operation[6]))
new_table_item.setData(-1, open_operation)
new_table_item.setData(-2, operation[0])
if color is not None:
new_table_item.setBackground(color)
self.tw_operation.setItem(row, 4, new_table_item)
new_table_item = QTableWidgetItem(str(operation[7]))
new_table_item.setData(-1, open_operation)
new_table_item.setData(-2, operation[0])
if color is not None:
new_table_item.setBackground(color)
self.tw_operation.setItem(row, 5, new_table_item)
def __init__(self, named_importances, *args, **kwargs):
super(VariableImportanceDialog, self).__init__(*args, **kwargs)
self.setWindowTitle("Variable Importance Table")
self.setMinimumWidth(700)
self.setMinimumHeight(800)
layout = QGridLayout()
layout.setContentsMargins(10, 10, 10, 10)
if named_importances:
# Show variable importance table
rows = len(list(named_importances.items()))
columns = 5
table = QTableWidget(rows, columns)
table.setHorizontalHeaderLabels(['Variable Name', 'Class #0', 'Class #1', 'Overall', 'Gini'])
table.verticalHeader().setVisible(False)
importances_mins = list(map(min, list(zip(*list(named_importances.values())))))
importances_maxs = list(map(max, list(zip(*list(named_importances.values())))))
for i, (variable, importances) in enumerate(named_importances.items()):
# Remove non-ASCII characters to get rid of the sigma character in the variable names.
variable = re.sub(r'[^\x00-\x7F]+','s', variable)
item = QTableWidgetItem(variable)
item.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled )
table.setItem(i, 0, item)
for j, importance in enumerate(importances):
# Get color based on the importance value
val = importances[j]
imin = importances_mins[j]
imax = importances_maxs[j]
range = importances_maxs[j] - importances_mins[j]
color = int( 255 - old_div(( (val-imin) * 200), range) )
# Load items as strings
item = QTableWidgetItemWithFloatSorting(str("{: .05f}".format(importance)))
item.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled )
item.setBackground(QColor(color,255,color))
table.setItem(i, j+1, item)
table.resizeColumnsToContents()
table.setSortingEnabled(True)
table.sortByColumn(3, Qt.DescendingOrder) # Sort by overall importance
layout.addWidget(table, 1, 0, 3, 2)
else:
# Classifier is not trained. Show warning message.
msg = ('To enable this feature, you must choose the following classifier type via the menu Advanced > Classifier:\n\n'
'"Parallel Random Forest Classifier with Variable Importance (VIGRA)"\n\n'
'...and then RETRAIN your classifier (press "Live Update").')
warningLabel = QLabel(msg)
warningLabel.setAlignment(Qt.AlignCenter)
warningLabel.setWordWrap(True)
layout.addWidget(warningLabel, 3, 0, 1 ,2)
# Create and add close button
closeButton = QPushButton("Close")
closeButton.clicked.connect(self.close)
layout.addWidget(closeButton, 4, 1)
self.setLayout(layout)
