def init_table(self):
QTableWidget.clear(self.table)
self.table.setRowCount(19)
self.table.setColumnCount(4)
self.mknum = self.table.rowCount() - 15
row = list(map(str, list(range(1, self.table.rowCount(), 1))))
for i in range(self.mknum):
row.insert(0, '')
self.table.setVerticalHeaderLabels(row)
col = ['', '', '', '']
self.table.setHorizontalHeaderLabels(col)
self.table.setSpan(0, 0, 2, 4)
self.table.setItem(0, 0, QTableWidgetItem("this is vocabulary"))
self.table.item(0, 0).setFont(QFont('Times', 24, QFont.Bold))
for i in range(4):
self.table.setColumnWidth(i, self.table.width() / 4 - 9)
for i in [0, 2]:
self.table.setItem(self.mknum - 1, i, QTableWidgetItem("영어"))
self.table.setItem(self.mknum - 1, i + 1, QTableWidgetItem("뜻"))
title = ['This is Voca', 'Day : ' + str(self.x), '애플영어', '이름 : ']
for k in range(4):
self.table.setItem(self.mknum - 2, k, QTableWidgetItem(title[k]))
def sig_to_stems_clicked(self, row):
signature = self.sig_to_stems_major_table.item(row, 0).text()
print(signature)
signature = tuple(signature.split(SEP_SIG))
stems = sorted(self.lexicon.signatures_to_stems()[signature])
number_of_stems_per_column = 5
# create a master list of sublists, where each sublist contains k stems
# k = number_of_stems_per_column
stem_rows = list()
stem_row = list()
for i, stem in enumerate(stems, 1):
stem_row.append(stem)
if not i % number_of_stems_per_column:
stem_rows.append(stem_row)
stem_row = list()
if stem_row:
stem_rows.append(stem_row)
# set up the minor table as table widget
sig_to_stems_minor_table = QTableWidget()
sig_to_stems_minor_table.horizontalHeader().hide()
sig_to_stems_minor_table.verticalHeader().hide()
sig_to_stems_minor_table.clear()
sig_to_stems_minor_table.setRowCount(len(stem_rows))
sig_to_stems_minor_table.setColumnCount(number_of_stems_per_column)
# fill in the minor table
for row, stem_row in enumerate(stem_rows):
for col, stem in enumerate(stem_row):
item = QTableWidgetItem(stem)
sig_to_stems_minor_table.setItem(row, col, item)
sig_to_stems_minor_table.resizeColumnsToContents()
minor_table_title = QLabel('{} (number of stems: {})'
.format(SEP_SIG.join(signature), len(stems))
)
minor_table_widget_with_title = QWidget()
layout = QVBoxLayout()
layout.addWidget(minor_table_title)
layout.addWidget(sig_to_stems_minor_table)
minor_table_widget_with_title.setLayout(layout)
new_display = QSplitter(Qt.Horizontal)
new_display.setHandleWidth(10)
new_display.setChildrenCollapsible(False)
new_display.addWidget(self.sig_to_stems_major_table)
new_display.addWidget(minor_table_widget_with_title)
new_display_width = self.majorDisplay.width() / 2
new_display.setSizes(
[new_display_width * 0.4, new_display_width * 0.6])
self.load_main_window(major_display=new_display)
self.status.clearMessage()
self.status.showMessage('{} selected'.format(signature))
def safe_clear_table(table: QtWidgets.QTableWidget, headers: list = None):
"""Clears the contents from the passed table while preserving its current headers.
:param table is a QTableWidget object
:param headers is a list of strings representing the new headers to fill the table with. This should be in
order from left to right."""
if headers is None:
headers = list()
_current_headers = [
table.horizontalHeaderItem(column).text()
for column in range(table.columnCount())
]
for header in headers:
if header not in _current_headers:
_current_headers.append(header)
table.clear()
table.setRowCount(0)
for index, header in enumerate(_current_headers):
table.setHorizontalHeaderItem(index,
QtWidgets.QTableWidgetItem(str(header)))
def cargarTabla(tabla: QtWidgets.QTableWidget, values, columnNames):
tabla.clear()
tabla.setRowCount(0)
tabla.setColumnCount(len(columnNames))
tabla.setHorizontalHeaderLabels(columnNames)
tabla.verticalHeader().hide()
for rowNumber, rowData in enumerate(values):
tabla.insertRow(rowNumber)
for columnNumber, columnName in enumerate(columnNames):
valor = rowData[columnName]
value = f'{valor:0.2f}' if isinstance(valor, float) else f'{valor}'
item = QtWidgets.QTableWidgetItem(value)
item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
if isinstance(valor, float) or isinstance(valor, int):
item.setTextAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignVCenter)
tabla.setItem(rowNumber, columnNumber, item)
tabla.resizeColumnsToContents()
currentWidth = 0
for columnNumber, columnName in enumerate(columnNames):
currentWidth += tabla.columnWidth(columnNumber)
widthToAdd = (tabla.width() - 1 - currentWidth) / len(columnNames)
for columnNumber, columnName in enumerate(columnNames):
tabla.setColumnWidth(columnNumber,
tabla.columnWidth(columnNumber) + widthToAdd)
class titledTable():
def __init__(self, title):
self.title = QLabel(title)
self.table = QTableWidget()
self.table.setShowGrid(True)
self.layout = QVBoxLayout()
self.layout.addWidget(self.title)
self.layout.addWidget(self.table)
def clear(self):
self.table.setRowCount(0)
self.table.setColumnCount(0)
self.table.clear()
def set_item(self, row, col, item):
if isinstance(item, str):
self.table.setItem(row, col, QTableWidgetItem(item))
else:
print("Type Error: Item must be a str")
def num_cols(self, values):
value_shape = np.shape(values)
numcols = 1
if len(value_shape) > 1:
numcols = value_shape[1]
return numcols
def sig_to_stems_clicked(self, row):
signature = self.sig_to_stems_major_table.item(row, 0).text()
print(signature)
signature = tuple(signature.split(SEP_SIG))
stems = sorted(self.lexicon.signatures_to_stems()[signature])
number_of_stems_per_column = 5
# create a master list of sublists, where each sublist contains k stems
# k = number_of_stems_per_column
stem_rows = list()
stem_row = list()
for i, stem in enumerate(stems, 1):
stem_row.append(stem)
if not i % number_of_stems_per_column:
stem_rows.append(stem_row)
stem_row = list()
if stem_row:
stem_rows.append(stem_row)
# set up the minor table as table widget
sig_to_stems_minor_table = QTableWidget()
sig_to_stems_minor_table.horizontalHeader().hide()
sig_to_stems_minor_table.verticalHeader().hide()
sig_to_stems_minor_table.clear()
sig_to_stems_minor_table.setRowCount(len(stem_rows))
sig_to_stems_minor_table.setColumnCount(number_of_stems_per_column)
# fill in the minor table
for row, stem_row in enumerate(stem_rows):
for col, stem in enumerate(stem_row):
item = QTableWidgetItem(stem)
sig_to_stems_minor_table.setItem(row, col, item)
sig_to_stems_minor_table.resizeColumnsToContents()
minor_table_title = QLabel('{} (number of stems: {})'
.format(SEP_SIG.join(signature), len(stems)))
minor_table_widget_with_title = QWidget()
layout = QVBoxLayout()
layout.addWidget(minor_table_title)
layout.addWidget(sig_to_stems_minor_table)
minor_table_widget_with_title.setLayout(layout)
new_display = QSplitter(Qt.Horizontal)
new_display.setHandleWidth(10)
new_display.setChildrenCollapsible(False)
new_display.addWidget(self.sig_to_stems_major_table)
new_display.addWidget(minor_table_widget_with_title)
new_display_width = self.majorDisplay.width() / 2
new_display.setSizes(
[new_display_width * 0.4, new_display_width * 0.6])
self.load_main_window(major_display=new_display)
self.status.clearMessage()
self.status.showMessage('{} selected'.format(signature))
class SelectActivities(QDialog, sweattrails.qt.imports.DownloadManager):
select = pyqtSignal()
def __init__(self, parent=None):
super(SelectActivities, self).__init__(None)
layout = QVBoxLayout(self)
self.table = QTableWidget(None)
self.table.setColumnCount(3)
self.table.setHorizontalHeaderLabels(["", "Date", "Size"])
self.table.setColumnWidth(0, 25)
self.table.setColumnWidth(1, 100)
self.table.setColumnWidth(3, 80)
layout.addWidget(self.table)
self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
self.select.connect(self._select)
layout.addWidget(self.buttonbox)
self.setMinimumSize(320, 200)
self.before_download.connect(parent.before_download)
self.after_download.connect(parent.after_download)
self.ant_files = None
def selectActivities(self, antfiles):
logger.debug("SelectActivities.selectActivities")
self.ant_files = antfiles
self.select.emit()
return self._selected
def _select(self):
logger.debug("SelectActivities._select")
self.table.clear()
self.table.setRowCount(len(self.ant_files))
for row in range(len(self.ant_files)):
f = self.ant_files[row]
self.table.setCellWidget(row, 0, QCheckBox(self))
self.table.setItem(
row, 1,
QTableWidgetItem(f.get_date().strftime("%d %b %Y %H:%M")))
self.table.setItem(row, 2,
QTableWidgetItem("{:d}".format(f.get_size())))
result = self.exec_()
self._selected = []
if result == QDialog.Accepted:
for i in range(len(self.ant_files)):
f = self.ant_files[i]
cb = self.table.cellWidget(i, 0)
if cb.isChecked():
self._selected.append(f)
def clear_table(table: QtWidgets.QTableWidget, headers: list = None):
"""Clears ALL data from the passed table, including headers.
:param table is a QTableWidget object
:param headers is a list of strings representing the new headers to fill the table with. This should be in
order from left to right."""
table.clear()
if headers:
set_table_headers(table, headers)
else:
set_table_headers(table, ["Key", "Value"])
def _setRulerTable(self, tableWidget: QtWidgets.QTableWidget,
ruler: Ruler):
"""
设置ruler的table。
"""
tableWidget.clear()
tableWidget.setRowCount(0)
tableWidget.verticalHeader().setVisible(False)
tableWidget.setColumnCount(7)
tableWidget.setHorizontalHeaderLabels(
["区间", "分", "秒", "起", "停", "距离", "旅速"])
tableWidget.setColumnWidth(0, 150)
tableWidget.setColumnWidth(1, 40)
tableWidget.setColumnWidth(2, 50)
tableWidget.setColumnWidth(3, 50)
tableWidget.setColumnWidth(4, 50)
tableWidget.setColumnWidth(5, 70)
tableWidget.setColumnWidth(6, 70)
# 方便起见，直接调用line对象
line = ruler.line()
station_dicts = line.stations
blocker = "->" if ruler.different() else "<->"
former_dict = None
for i, st_dict in enumerate(station_dicts):
if not ruler.isDownPassed(st_dict["zhanming"]):
if former_dict is not None:
mile = abs(st_dict["licheng"] - former_dict["licheng"])
self._addRulerRow(
former_dict["zhanming"], st_dict["zhanming"], blocker,
ruler.getInfo(former_dict["zhanming"],
st_dict["zhanming"]), tableWidget, mile)
former_dict = st_dict
former_dict = None
if ruler.different():
# 上下行不一致，增加上行部分
for st_dict in reversed(station_dicts):
if not ruler.isUpPassed(st_dict["zhanming"]):
if former_dict is not None:
mile = abs(st_dict["licheng"] - former_dict["licheng"])
self._addRulerRow(
former_dict["zhanming"], st_dict["zhanming"],
blocker,
ruler.getInfo(former_dict["zhanming"],
st_dict["zhanming"]), tableWidget,
mile)
former_dict = st_dict
def fill_table(table: QTableWidget, head=(), data=()):
"""Clear table and fill with title and data"""
table.clear()
table.setColumnCount(len(head))
table.setHorizontalHeaderLabels(head)
table.setRowCount(len(data))
for i, row in enumerate(data):
for j in range(len(row)):
elem = row[j]
item = QTableWidgetItem(str(elem))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
table.setItem(i, j, item)
table.resizeColumnsToContents()
for i in range(table.colorCount()):
table.setColumnWidth(i, table.columnWidth(i) + 50)
def activateParamCell(self, row, paramNum, text, value=None):
col_index = self.col_index
if paramNum == 1:
col = col_index['p1']
else: # assume param 2
col = col_index['p2']
self.activateCell(row, col)
# clear and activate
nameMask = ~Qt.ItemIsEnabled
pname = QTableWidgetItem(text)
pname.setBackground(Qt.white)
pname.setForeground(Qt.black)
flags = pname.flags()
pname.setFlags(flags & nameMask)
# add 2-cell table
cellTable = self.cellWidget(row, col)
if isinstance(cellTable, QComboBox): # combo from file selection
self.removeCellWidget(row, col)
cellTable = None
if cellTable is None:
cellTable = QTableWidget(self)
self.setCellWidget(row, col, cellTable)
cellTable.clear()
cellTable.setRowCount(1)
cellTable.setColumnCount(2)
cellTable.horizontalHeader().setVisible(False)
cellTable.verticalHeader().setVisible(False)
cellTable.setProperty('row', row)
cellTable.setProperty('col', col)
cellTable.setItem(0, 0, pname)
if value is not None:
pval = QTableWidgetItem(str(value))
cellTable.setItem(0, 1, pval)
if self.viewOnly:
flags = pval.flags()
pval.setFlags(flags & ~Qt.ItemIsEnabled)
pval.setForeground(Qt.black)
cellTable.setColumnWidth(0, self.labelWidth)
cellTable.setColumnWidth(1, self.paramWidth)
cellTable.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
cellTable.cellChanged.connect(self.paramChange)
cellTable.setEditTriggers(QAbstractItemView.AllEditTriggers) # Allow single click to edit
return cellTable
class jobs_view(QWidget):
def __init__(self):
QWidget.__init__(self)
self.main_vbox = QVBoxLayout()
self.tab = QTableWidget()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
# self.tab.cellChanged.connect(self.tab_changed)
self.main_vbox.addWidget(self.tab)
self.setLayout(self.main_vbox)
self.myserver = server_get()
self.myserver.jobs_update.connect(self.callback_cluster_get_jobs)
self.show()
def callback_cluster_get_jobs(self):
self.tab.clear()
self.tab.setColumnCount(7)
self.tab.setRowCount(0)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tab.setHorizontalHeaderLabels([
_("name"),
_("path"),
_("ip"),
_("start"),
_("stop"),
_("CPUs"),
_("status")
])
for job in self.myserver.jobs:
tab_add(self.tab, [
job.name, job.path, job.ip, job.start, job.stop,
str(job.cpus),
str(job.status)
])
class jobs_view(QWidget):
def __init__(self):
QWidget.__init__(self)
self.main_vbox=QVBoxLayout()
self.tab = QTableWidget()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.create_model()
# self.tab.cellChanged.connect(self.tab_changed)
self.main_vbox.addWidget(self.tab)
self.setLayout(self.main_vbox)
self.show()
def add_items(self):
self.store.clear()
actresses = [("n","name","done","status","target","ip","copystate","start","stop")]
for act in actresses:
self.store.store.append([act[0], act[1], act[2], act[3],act[4], act[5], act[6], act[7]])
def load_data(self,jobs_list):
self.create_model()
for i in range(len(jobs_list)):
tab_add(self.tab,jobs_list[i])
def create_model(self):
self.tab.clear()
self.tab.setColumnCount(7)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tab.setHorizontalHeaderLabels([_("n"), _("done"), _("status"), _("target"), _("ip"),_("copy state"),_("start"),_("stop")])
self.tab.setRowCount(0)
class Widget(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle('Table')
self.table_widget = QTableWidget()
self.table_widget.cellClicked.connect(self._on_cell_clicked)
self.setCentralWidget(self.table_widget)
def _on_cell_clicked(self, row, col):
selection_model = self.table_widget.selectionModel()
selection_model.clear()
for i in range(self.table_widget.rowCount()):
for j in range(self.table_widget.columnCount()):
if i == row or j == col:
item = self.table_widget.item(i, j)
index = self.table_widget.indexFromItem(item)
selection_model.select(index, QItemSelectionModel.Select)
def fill(self):
self.table_widget.clear()
labels = ['ID', 'NAME', 'PRICE']
self.table_widget.setColumnCount(len(labels))
self.table_widget.setHorizontalHeaderLabels(labels)
for id_, name, price in [
['1', 'name_1', 'price_1'],
['2', 'name_2', 'price_2'],
['3', 'name_3', 'price_3'],
]:
row = self.table_widget.rowCount()
self.table_widget.setRowCount(row + 1)
self.table_widget.setItem(row, 0, QTableWidgetItem(str(id_)))
self.table_widget.setItem(row, 1, QTableWidgetItem(name))
self.table_widget.setItem(row, 2, QTableWidgetItem(price))
class Window(QWidget):
def __init__(self):
super(Window, self).__init__()
self.resize(400,250)
self.setWindowTitle('pythonexplainedto.me speedtest-result')
self.table = QTableWidget()
self.table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.refresh = QPushButton()
self.refresh.setText("Refresh data")
self.refresh.clicked.connect(lambda: self.result())
hbox = QVBoxLayout(self)
hbox.addWidget(self.refresh)
hbox.addWidget(self.table)
self.result()
def result(self, values=None):
self.table.clear()
self.connection = sqlite3.connect("speed.db")
self.connection.commit()
cursor = self.connection.cursor()
if values is None:
cursor.execute("SELECT download,upload,ping,date FROM speedtest ORDER BY id DESC")
else:
cursor.execute("SELECT download,upload,ping,date FROM speedtest ORDER BY id DESC", values)
name_of_columns = [e[0] for e in cursor.description]
self.table.setColumnCount(len(name_of_columns))
self.table.setRowCount(0)
self.table.setHorizontalHeaderLabels(name_of_columns)
header = self.table.horizontalHeader()
header.setSectionResizeMode(QHeaderView.ResizeToContents)
for i, row_data in enumerate(cursor.fetchall()):
self.table.insertRow(self.table.rowCount())
for j, value in enumerate(row_data):
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, value)
self.table.setItem(i, j, item)
class PropertyWidget(QtWidgets.QWidget):
def __init__(self, parent=None):
super(PropertyWidget, self).__init__(parent)
HB_lay = QHBoxLayout(self)
self.tableWidget = QTableWidget()
self.tableWidget.setRowCount(0)
self.tableWidget.setColumnCount(3)
HB_lay.addWidget(self.tableWidget)
HB_lay.addStretch()
def display(self, n):
try:
print('NNNNNNN', n)
print('n: ', int(n))
self.tableWidget.setHorizontalHeaderLabels(
['Criteria', 'Weghit', 'min/max'])
self.tableWidget.setRowCount(int(n))
except ValueError:
self.tableWidget.clear()
self.tableWidget.setRowCount(0)
def clearTable(self):
data = []
model = self.tableWidget.model()
for row in range(self.tableWidget.rowCount()):
data.append([])
for column in range(model.columnCount()):
index = model.index(row, column)
# We suppose data are strings
data[row].append(str(model.data(index)))
self.tableWidget.setRowCount(0)
print(data)
print('clear Table')
class MainWindow(QWidget):
def __init__(self):
super().__init__();
self.setGeometry(200, 200, 800, 640);
self.initUi();
def initUi(self):
self.setWindowTitle("Toy Language")
self.grid = QGridLayout()
self.grid.setSpacing(10)
self.initCodeEditor()
self.initVariableTable()
self.initButtons()
self.setLayout(self.grid)
self.show()
def initCodeEditor(self):
self.codeEditor = CodeEditor(self)
self.grid.addWidget(self.codeEditor, 2, 1)
defaultCode = """
x = 1;
y = 1;
z = 2;
for i=0 to 100
{
for j=0 to 100
{
x = x + 1;
};
y = y * 2;
};
if x > 0
{
z = 100;
};
"""
self.codeEditor.setPlainText(defaultCode)
def initVariableTable(self):
self.variableTable = QTableWidget()
#self.variableTable.setRowCount(8)
self.variableTable.setColumnCount(2)
self.grid.addWidget(self.variableTable, 2, 2)
def initButtons(self):
self.btnHBox = QHBoxLayout();
self.btnRun = QPushButton("Run")
self.btnSave = QPushButton("Save")
self.btnRun.clicked.connect(self.run)
self.btnHBox.addWidget(self.btnRun)
self.btnHBox.addWidget(self.btnSave)
self.grid.addLayout(self.btnHBox, 1, 1)
def run(self):
content = self.codeEditor.toPlainText()
try:
astTree = Parser(content).ast
self.execAst = ExecuteAst(astTree)
self.updateVariableTable()
except Exception as e:
print(e)
def updateVariableTable(self):
currentVars = self.execAst.identifiers.dumpMap()
self.variableTable.clear()
self.variableTable.setRowCount(len(currentVars))
for iNum, iName in enumerate(currentVars):
iValue = currentVars[iName]
print("<<<" + str(iName) + " - " + str(iValue))
self.variableTable.setItem( iNum, 0, QTableWidgetItem(str(iName)))
self.variableTable.setItem( iNum, 1, QTableWidgetItem(str(iValue)))
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.timer = QTimer(self)
self.formatted_time = FormattedTime(0, 0, 0)
self.state = TimerState.INACTIVE
self.splits = []
self.init_menus()
self.init_UI()
def init_menus(self):
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
exitAct = QAction(QIcon('exit.png'), '&Exit', self)
exitAct.setShortcut('Ctrl+Q')
exitAct.setStatusTip('Exit application')
exitAct.triggered.connect(qApp.quit)
fileMenu.addAction(exitAct)
viewMenu = menubar.addMenu('View')
viewStatAct = QAction('View statusbar', self, checkable=True)
viewStatAct.setStatusTip('View statusbar')
viewStatAct.setChecked(True)
viewStatAct.triggered.connect(self.toggle_menu)
viewMenu.addAction(viewStatAct)
def init_UI(self):
wid = QWidget(self)
self.setCentralWidget(wid)
QToolTip.setFont(QFont('SansSerif', 10))
# ---
self.start_stop_button = QPushButton('Start')
self.start_stop_button.clicked.connect(self.start_stop)
# ---
self.pause_button = QPushButton('Pause')
self.pause_button.resize(self.pause_button.sizeHint())
self.pause_button.clicked.connect(self.pause_timer)
self.pause_button.setEnabled(False)
# ---
self.split_button = QPushButton("Split")
self.split_button.clicked.connect(self.split)
self.split_button.setEnabled(False)
# ---
self.lcd = QLCDNumber(self)
self.lcd.setMinimumSize(QSize(150, 150))
self.lcd.setSegmentStyle(QLCDNumber.Flat)
self.lcd.setDigitCount(len(str(self.formatted_time)))
self.lcd.display(str(self.formatted_time))
# ---
self.splits_table = QTableWidget()
self.splits_table.setMinimumSize(QSize(150, 200))
self.splits_table.setRowCount(len(self.splits))
self.splits_table.setColumnCount(1)
self.splits_table.setShowGrid(False)
self.splits_table.verticalHeader().setDefaultSectionSize(20)
self.splits_table.verticalHeader().setVisible(False)
self.splits_table.horizontalHeader().setVisible(False)
self.update_splits_table()
# ---
vbox = QVBoxLayout()
vbox.addStretch(1)
vbox.addWidget(self.lcd)
vbox.addWidget(self.splits_table)
vbox.addWidget(self.start_stop_button)
vbox.addWidget(self.pause_button)
vbox.addWidget(self.split_button)
wid.setLayout(vbox)
# ---
self.statusBar().showMessage("")
self.setGeometry(350, 300, 350, 150)
self.setWindowTitle('Timer')
self.setWindowIcon(QIcon('web.png'))
self.show()
def start_stop(self):
if self.state == TimerState.ACTIVE:
self.state = TimerState.INACTIVE
self.timer.stop()
self.sender().setText("Start")
self.split_button.setEnabled(False)
self.pause_button.setEnabled(False)
self.statusBar().showMessage("Timer stopped!")
elif self.state == TimerState.INACTIVE:
self.state = TimerState.ACTIVE
self.reset_timer()
self.begin_timer()
self.sender().setText("Stop")
self.split_button.setEnabled(True)
self.pause_button.setEnabled(True)
self.statusBar().showMessage("Timer started!")
elif self.state == TimerState.PAUSED:
self.sender().setText("Stop")
self.state = TimerState.ACTIVE
self.pause_button.setEnabled(True)
self.split_button.setEnabled(True)
self.begin_timer()
def pause_timer(self):
self.statusBar().showMessage("Paused!")
self.start_stop_button.setText("Start")
self.formatted_time.pause()
self.pause_button.setEnabled(False)
self.state = TimerState.PAUSED
self.timer.stop()
def split(self):
now = FormattedTime(self.formatted_time.minutes,
self.formatted_time.seconds,
self.formatted_time.centiseconds)
self.splits.append(now)
self.update_splits_table()
def update_current_time(self):
self.formatted_time.increment_time()
self.lcd.setDigitCount(len(self.formatted_time))
self.lcd.display(str(self.formatted_time))
def begin_timer(self):
self.timer.start(10)
self.timer.timeout.connect(self.update_current_time)
def update_splits_table(self):
row = 0
for split in self.splits:
self.item = QTableWidgetItem(str(split))
self.splits_table.setRowCount(len(self.splits))
self.splits_table.setItem(row, 0, self.item)
row = row + 1
pass
def reset_timer(self):
self.splits = []
self.splits_table.clear()
self.formatted_time = FormattedTime(0, 0, 0)
def quit_app(self):
sys.exit()
def center(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
self.statusBar().showMessage('Moved!')
def toggle_menu(self, state):
if state:
self.statusBar().show()
else:
self.statusBar().hide()
def closeEvent(self, event):
if self.state == TimerState.ACTIVE or self.state == TimerState.PAUSED:
reply = QMessageBox.question(
self, 'Message',
"Timer running. Are you sure you want to quit?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
event.accept() if reply == QMessageBox.Yes else event.ignore()
else:
event.accept()
def keyPressEvent(self, e):
if e.key() == Qt.Key_Space:
if self.state == TimerState.INACTIVE:
self.start_stop()
else:
self.pause_timer()
class equation_editor(QGroupBox):
changed = pyqtSignal()
def load(self):
lines=[]
self.tab.clear()
self.tab.setHorizontalHeaderLabels([_("Function"), _("Enabled"), _("a"), _("b"), _("c")])
inp_load_file(lines,self.file_name)
print(self.file_name,lines)
pos=0
while True:
if lines[pos]=="#end":
break
if lines[pos]=="#ver":
break
tag=lines[pos]
scan_item_add(self.file_name,tag,tag,1)
pos=pos+1 #skip hash tag
function=lines[pos] #read label
pos=pos+1
tag=lines[pos]
scan_item_add(self.file_name,tag,tag,1)
pos=pos+1 #skip hash tag
enabled=lines[pos] #read value
pos=pos+1
tag=lines[pos]
scan_item_add(self.file_name,tag,tag,1)
pos=pos+1 #skip hash tag
a=lines[pos] #read value
pos=pos+1
tag=lines[pos]
scan_item_add(self.file_name,tag,tag,1)
pos=pos+1 #skip hash tag
b=lines[pos] #read value
pos=pos+1
tag=lines[pos]
scan_item_add(self.file_name,tag,tag,1)
pos=pos+1 #skip hash tag
c=lines[pos] #read value
pos=pos+1
tab_add(self.tab,[ str(function), str(enabled), str(a), str(b), str(c)])
def __init__(self,file_name,name):
QGroupBox.__init__(self)
self.file_name=file_name
self.name=name
self.setTitle(name)
self.setStyleSheet("QGroupBox { border: 1px solid gray;}")
vbox=QVBoxLayout()
self.setLayout(vbox)
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
add = QAction(QIcon(os.path.join(get_image_file_path(),"16_add.png")), _("Add "+self.name+" mesh layer"), self)
add.triggered.connect(self.add_item_clicked)
toolbar.addAction(add)
remove = QAction(QIcon(os.path.join(get_image_file_path(),"16_minus.png")), _("Remove "+self.name+" mesh layer"), self)
remove.triggered.connect(self.on_remove_click)
toolbar.addAction(remove)
vbox.addWidget(toolbar)
self.tab = QTableWidget()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.tab.clear()
self.tab.setColumnCount(5)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.load()
self.tab.cellChanged.connect(self.tab_changed)
vbox.addWidget(self.tab)
def tab_changed(self):
self.save()
self.changed.emit()
def add_item_clicked(self):
tab_add(self.tab,[ "exp", "true", "a", "b", "c"])
self.save()
self.changed.emit()
def on_remove_click(self):
tab_remove(self.tab)
self.save()
self.changed.emit()
def save(self):
lines=[]
for i in range(0,self.tab.rowCount()):
lines.append("#function_"+str(i))
lines.append(tab_get_value(self.tab,i, 0))
lines.append("#function_enable_"+str(i))
lines.append(tab_get_value(self.tab,i, 1))
lines.append("#function_a_"+str(i))
lines.append(tab_get_value(self.tab,i, 2))
lines.append("#function_b_"+str(i))
lines.append(tab_get_value(self.tab,i, 3))
lines.append("#function_c_"+str(i))
lines.append(tab_get_value(self.tab,i, 4))
lines.append("#ver")
lines.append("#1.0")
lines.append("#end")
inp_write_lines_to_file(self.file_name,lines)
class doping_window(QWidget):
lines=[]
def save_data(self):
print("save")
for i in range(0,self.tab.rowCount()):
inp_update(self.tab.item(i, 0).text()+".inp", "#doping_start", self.tab.item(i, 2).text())
inp_update(self.tab.item(i, 0).text()+".inp", "#doping_stop", self.tab.item(i, 3).text())
def update(self):
self.build_mesh()
self.draw_graph()
self.fig.canvas.draw()
def draw_graph(self):
# n=0
self.fig.clf()
self.fig.subplots_adjust(bottom=0.2)
self.fig.subplots_adjust(left=0.1)
self.ax1 = self.fig.add_subplot(111)
self.ax1.ticklabel_format(useOffset=False)
#ax2 = ax1.twinx()
# x_pos=0.0
# layer=0
# color =['r','g','b','y','o','r','g','b','y','o']
self.ax1.set_ylabel(_("Doping (m^{-3})"))
x_plot=[]
for i in range(0,len(self.x_pos)):
x_plot.append(self.x_pos[i]*1e9)
frequency, = self.ax1.plot(x_plot,self.doping, 'ro-', linewidth=3 ,alpha=1.0)
self.ax1.set_xlabel(_("Position (nm)"))
def save_image(self,file_name):
self.fig.savefig(file_name)
def callback_save(self, widget, data=None):
file_name=save_as_gpvdm(self)
if file_name!=False:
if os.path.splitext(file_name)[1]:
self.save_image(file_name)
else:
filter=dialog.get_filter()
self.save_image(file_name+".png")
def callback_help(self):
webbrowser.open('http://www.gpvdm.com/man/index.html')
def load(self):
self.tab.blockSignals(True)
self.tab.clear()
self.tab.setHorizontalHeaderLabels([_("File Name"), _("Width"), _("Start"), _("Stop")])
layers=epitaxy_get_layers()
for i in range(0,layers):
dos_file=epitaxy_get_dos_file(i)
width=epitaxy_get_width(i)
if dos_file!="none":
lines=[]
print("loading",dos_file)
if inp_load_file(lines,dos_file+".inp")==True:
doping_start=float(inp_search_token_value(lines, "#doping_start"))
doping_stop=float(inp_search_token_value(lines, "#doping_stop"))
print("add",dos_file)
count=self.tab.rowCount()
self.tab.insertRow(count)
item1 = QTableWidgetItem(str(dos_file))
self.tab.setItem(count,0,item1)
item2 = QTableWidgetItem(str(width))
self.tab.setItem(count,1,item2)
item3 = QTableWidgetItem(str(doping_start))
self.tab.setItem(count,2,item3)
item3 = QTableWidgetItem(str(doping_stop))
self.tab.setItem(count,3,item3)
self.tab.blockSignals(False)
return
def build_mesh(self):
# lines=[]
self.doping=[]
self.x_pos=[]
pos=0.0
for i in range(0,self.tab.rowCount()):
print(i)
doping_start=float(self.tab.item(i, 2).text())
doping_stop=float(self.tab.item(i, 3).text())
width=float(self.tab.item(i, 1).text())
self.doping.append(doping_start)
self.x_pos.append(pos)
pos=pos+width
self.doping.append(doping_stop)
self.x_pos.append(pos)
return True
def callback_close(self, widget, data=None):
self.win_list.update(self,"doping")
self.hide()
return True
def tab_changed(self, x,y):
self.build_mesh()
self.draw_graph()
self.fig.canvas.draw()
self.save_data()
def __init__(self):
QWidget.__init__(self)
self.win_list=windows()
self.setFixedSize(900, 600)
self.setWindowIcon(QIcon(os.path.join(get_image_file_path(),"doping.png")))
self.setWindowTitle(_("Doping profile editor (www.gpvdm.com)"))
self.win_list.set_window(self,"doping")
self.main_vbox=QVBoxLayout()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
self.save = QAction(QIcon(os.path.join(get_image_file_path(),"save.png")), _("Save"), self)
self.save.triggered.connect(self.callback_save)
toolbar.addAction(self.save)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.help = QAction(QIcon(os.path.join(get_image_file_path(),"help.png")), _("Help"), self)
self.help.triggered.connect(self.callback_help)
toolbar.addAction(self.help)
self.main_vbox.addWidget(toolbar)
self.fig = Figure(figsize=(5,4), dpi=100)
self.ax1=None
self.show_key=True
canvas = FigureCanvas(self.fig)
#canvas.set_background('white')
#canvas.set_facecolor('white')
canvas.figure.patch.set_facecolor('white')
canvas.show()
self.main_vbox.addWidget(canvas)
self.tab = QTableWidget()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.tab.clear()
self.tab.setColumnCount(4)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.load()
self.build_mesh()
self.tab.cellChanged.connect(self.tab_changed)
self.main_vbox.addWidget(self.tab)
self.draw_graph()
self.setLayout(self.main_vbox)
return
class mainWin(QMainWindow):
def __init__(self) -> None:
super(mainWin, self).__init__()
self.setWindowTitle("Analysis Main")
self.setGeometry(100, 100, 1100, 750)
self.statusBar().showMessage("Statusbar - awaiting user control")
self.show()
self.container = QWidget()
self.setCentralWidget(self.container)
self.mainLayout = qtw.QHBoxLayout(self.container)
self.mainLayout.setSpacing(0)
self.mainLayout.setContentsMargins(5, 5, 5, 5)
self.splitter = QSplitter(Qt.Horizontal)
self.verticalwidgets()
self.splitter.addWidget(self.var_table)
self.splitter.addWidget(self.tabs_widget)
self.mainLayout.addWidget(self.splitter)
def verticalwidgets(self) -> None:
# left side with the variable explorer
self.var_table = QTableWidget()
self.var_table.setSelectionBehavior(QTableView.SelectRows)
self.var_table.doubleClicked.connect(self.var_table_lr)
self.box_layout1 = qtw.QVBoxLayout()
self.box_layout1.setContentsMargins(0, 0, 0, 0)
self.box_layout1.setSpacing(0)
Vheader = self.var_table.verticalHeader()
Vheader.setDefaultSectionSize(20)
Vheader.setVisible(False)
self.var_table.setUpdatesEnabled(True)
self.var_table.setColumnWidth(0, 50)
self.var_table.setColumnCount(3)
cts.update_varlist()
self.var_table.setRowCount(len(cts.varlist))
self.updateglobvar_fn()
# right side with the tabs
self.tabs_widget = QWidget()
self.layout = qtw.QHBoxLayout(self.tabs_widget)
self.layout.setContentsMargins(0, 0, 0, 0)
self.main_panel = QTabWidget()
self.calib_tab = calib_win.CalibWin(self)
self.rabbit_tab = Rabbit_win.RabbitWin(self)
self.main_panel.addTab(self.calib_tab, "Energy calibration")
self.main_panel.addTab(self.rabbit_tab, "RABBIT")
self.main_panel.currentChanged.connect(self.onTabChange)
self.layout.addWidget(self.main_panel)
''' This function updates the values of the variable displayed on the left of the window. The list of the variables
is in the glob_var.py file'''
def updateglobvar_fn(self) -> None:
self.var_table.clear()
self.var_table.setColumnCount(3)
self.var_table.setRowCount(len(cts.varlist))
self.var_table.setItem(0, 0, QTableWidgetItem("name"))
self.var_table.setItem(0, 1, QTableWidgetItem("dtype"))
self.var_table.setItem(0, 2, QTableWidgetItem("value"))
cts.update_varlist() # updating the content of the variable list
for i in range(len(cts.varlist)):
var = cts.varlist[i][1]
varname = cts.varlist[i][0]
self.var_table.setItem(i, 0, QTableWidgetItem(cts.varlist[i][0]))
type = self.custom_type_fn(var)
self.var_table.setItem(i, 1, QTableWidgetItem(type))
# these 'if's are here to make the variables easily readable
if type == "int" or type == "float":
if varname == "Ip" or varname == "Vp" or varname == "elow" or varname == "ehigh" or varname == "dE":
self.var_table.setItem(
i, 2, QTableWidgetItem("{:.2f}".format(var)))
elif varname == "L" or varname == "1st harm" or varname == "steps_nm" or varname == "steps_fs" \
or varname == "stepsnb" or varname == "bandsnb":
self.var_table.setItem(
i, 2, QTableWidgetItem("{}".format(int(var))))
else:
self.var_table.setItem(
i, 2, QTableWidgetItem("{:.2e}".format(var)))
if type == "np.array":
self.var_table.setItem(i, 2, QTableWidgetItem(str(var.shape)))
if type == "list":
self.var_table.setItem(i, 2, QTableWidgetItem(str(len(var))))
if type == "bool":
self.var_table.setItem(i, 2, QTableWidgetItem(str(var)))
if type == "string":
self.var_table.setItem(i, 2, QTableWidgetItem(var))
self.var_table.resizeColumnsToContents()
w = 0
for i in range(self.var_table.columnCount()):
w = w + self.var_table.columnWidth(i)
self.var_table.setFixedWidth(w + 5)
def custom_type_fn(self, o) -> str:
type = "other"
if isinstance(o, int):
type = "int"
if isinstance(o, float):
type = "float"
if isinstance(o, np.ndarray):
type = "np.array"
if isinstance(o, list):
type = "list"
if isinstance(o, bool):
type = "bool"
if isinstance(o, str):
type = "string"
return type
''' function called when double-clicking on a variable'''
def var_table_lr(self, doubleClickedIndex) -> None:
rowindex = doubleClickedIndex.row()
try:
vardiag = varDialog(rowindex, self) # new class created below
except Exception:
print(traceback.format_exception(*sys.exc_info()))
''' Updating elow, ehigh and dE when going from one tab to the other'''
def onTabChange(self) -> None:
self.calib_tab.elow_le.setText("{:.2f}".format(cts.elow))
self.calib_tab.ehigh_le.setText("{:.2f}".format(cts.ehigh))
self.calib_tab.dE_le.setText("{:.2f}".format(cts.dE))
self.rabbit_tab.elow_le.setText("{:.2f}".format(cts.elow))
self.rabbit_tab.ehigh_le.setText("{:.2f}".format(cts.ehigh))
self.rabbit_tab.dE_le.setText("{:.2f}".format(cts.dE))
class ProdDetail(QWidget):
def __init__(self):
super().__init__()
hbox=QHBoxLayout()
hbox2=QHBoxLayout()
hbox3=QHBoxLayout()
hbox4=QHBoxLayout()
self.prod_combo=QComboBox()
self.lineEditProdName=QLineEdit()
namelabel=QLabel("스토어팜주소")
self.farm_combo=QComboBox()
self.li=['https://smartstore.naver.com/heyhannah','https://smartstore.naver.com/monsclub']
self.farm_combo.addItems(self.li)
self.shop_title_label=QLabel()
self.show_farm_name()
self.btn_show_prod_detail=QPushButton('조회')
self.btn_show_prod_detail.setIcon(QtGui.QIcon('update.png'))
hbox.addWidget(namelabel)
hbox.addWidget(self.farm_combo)
hbox.addWidget(self.shop_title_label)
hbox2.addWidget(QLabel("상품명"))
hbox2.addWidget(self.prod_combo)
hbox2.addStretch()
hbox3.addWidget(QLabel("직접입력"))
hbox3.addWidget(self.lineEditProdName)
hbox3.addWidget(self.btn_show_prod_detail)
hbox3.addStretch()
self.init_prod_combo()
self.btn_show_prod_detail.clicked.connect(self.get_prod_detail)
self.farm_combo.currentTextChanged.connect(self.show_farm_name)
self.prod_combo.currentTextChanged.connect(self.input_prod_title)
vbox=QVBoxLayout()
self.linechart=QChart()
self.linechart2=QChart()
self.linechart3=QChart()
self.chartview = QChartView(self.linechart)
self.chartview2 = QChartView(self.linechart2)
self.chartview3 = QChartView(self.linechart3)
self.tablewidget=QTableWidget()
self.chartgroup=QGroupBox()
self.chartvbox=QVBoxLayout()
self.chartvbox.addWidget(self.chartview)
self.chartvbox.addWidget(self.chartview2)
self.chartvbox.addWidget(self.chartview3)
self.chartgroup.setLayout(self.chartvbox)
hbox4.addWidget(self.tablewidget)
# hbox4.addWidget(self.chartview)
hbox4.addWidget(self.chartgroup)
self.updateProdDetail()
self.groupbox=QGroupBox()
self.groupbox2=QGroupBox()
self.groupbox3=QGroupBox()
self.groupbox4=QGroupBox()
self.groupbox.setLayout(hbox)
self.groupbox2.setLayout(hbox2)
self.groupbox3.setLayout(hbox3)
self.groupbox4.setLayout(hbox4)
vbox.addWidget(self.groupbox)
vbox.addWidget(self.groupbox2)
vbox.addWidget(self.groupbox3)
vbox.addWidget(self.groupbox4)
self.setLayout(vbox)
def init_prod_combo(self):
mall_url=self.farm_combo.currentText()
conn=sqlite3.connect('emaildb.sqlite')
cur=conn.cursor()
sql=f"Select distinct title from PROD3 where link like '{mall_url}%'"
cur.execute(sql)
conn.commit()
rows=cur.fetchall()
li=[]
for row in rows:
li.append(row[0])
self.prod_combo.clear()
self.prod_combo.addItems(li)
cur.close()
conn.close()
self.lineEditProdName.setText(self.prod_combo.currentText())
def drawChart(self):
conn=sqlite3.connect('emaildb.sqlite')
cur=conn.cursor()
title=self.lineEditProdName.text()
mall_url=self.farm_combo.currentText()
sql=f"select dt, jjim, sold, review from PROD3 where title='{title}'"
cur.execute(sql)
conn.commit()
rows=cur.fetchall()
series=[]
# series = QLineSeries(self)
series.append(QLineSeries(self))
series.append(QLineSeries(self))
series.append(QLineSeries(self))
tod=datetime.today()
nextday=datetime.today()+timedelta(days=1)
d=QDate(2020,1,3)
dt=QDateTime(d)
d2=d.addDays(1)
dt2=dt.addDays(1)
for i,row in enumerate(rows):
for j, serie in enumerate(series):
# serie.append((dt.addDays(i)).toMSecsSinceEpoch(),int(row[j+1]))
serie.append(i,int(row[j+1]))
for serie in series:
serie.setPointsVisible(True)
self.linechart.removeAllSeries()
self.linechart2.removeAllSeries()
self.linechart3.removeAllSeries()
self.linechart.addSeries(series[0])
self.linechart2.addSeries(series[1])
self.linechart3.addSeries(series[2])
dateAxis=QDateTimeAxis()
dateAxis2=QDateTimeAxis()
dateAxis3=QDateTimeAxis()
self.linechart.addAxis(dateAxis, Qt.AlignBottom)
self.linechart2.addAxis(dateAxis2, Qt.AlignBottom)
self.linechart3.addAxis(dateAxis3, Qt.AlignBottom)
self.linechart.createDefaultAxes()
self.linechart2.createDefaultAxes()
self.linechart3.createDefaultAxes()
self.linechart.setAnimationOptions(QChart.SeriesAnimations)
self.linechart.setTitle("찜")
self.linechart.legend().setVisible(True)
self.linechart2.setAnimationOptions(QChart.SeriesAnimations)
self.linechart2.setTitle("구매")
self.linechart2.legend().setVisible(True)
self.linechart3.setAnimationOptions(QChart.SeriesAnimations)
self.linechart3.setTitle("리뷰")
self.linechart3.legend().setVisible(True)
self.chartview.setRenderHint(QPainter.Antialiasing)
self.chartview2.setRenderHint(QPainter.Antialiasing)
self.chartview3.setRenderHint(QPainter.Antialiasing)
cur.close()
conn.close()
def updateProdDetail(self):
self.tablewidget.clear()
self.tablewidget.setRowCount(300)
self.tablewidget.setColumnCount(6)
self.tablewidget.setItem(0,0,QTableWidgetItem("날짜"))
self.tablewidget.setItem(0,1,QTableWidgetItem("찜"))
self.tablewidget.setItem(0,2,QTableWidgetItem("구매"))
self.tablewidget.setItem(0,3,QTableWidgetItem("리뷰"))
conn=sqlite3.connect('emaildb.sqlite')
cur=conn.cursor()
title=self.lineEditProdName.text()
mall_url=self.farm_combo.currentText()
sql=f"Select dt, jjim, sold, review from PROD3 where title='{title}' order by dt desc"
cur.execute(sql)
conn.commit()
rows=cur.fetchall()
for i,row in enumerate(rows):
# print(i, row[0])
for j, elem in enumerate(row):
# print(i+1,j,elem)
# self.tablewidget.setItem(i+1,j,QTableWidgetItem(elem))
self.tablewidget.setItem(i+1,j,QTableWidgetItem(str(row[j])))
# print(row[1])
# self.tablewidget.setItem(i+1,1,QTableWidgetItem(str(row[1])))
self.tablewidget.resizeColumnToContents(0)
cur.close()
conn.close()
return len(rows)
def input_prod_title(self):
self.lineEditProdName.setText(self.prod_combo.currentText())
def get_prod_detail(self):
url=self.farm_combo.currentText()
prod_title=self.lineEditProdName.text()
self.tablewidget.clear()
self.updateProdDetail()
self.drawChart()
def setFarm(self,li):
self.farmlist=FarmList(self.li)
# print(self.li)
# self.farm_combo.addItems(self.li)
self.farmlist.show()
def show_farm_name(self):
'''스토어팜 주소를 콤보박스에서 변경시에 검색하여 스토어팜 이름 표시
prod_combo도 변경함
'''
# self.shop_title_label.setText("sssss")
url=self.farm_combo.currentText()
req=requests.get(url)
soup=BeautifulSoup(req.text, 'html.parser')
self.shop_title_label.setText(soup.find('title').text.strip())
self.init_prod_combo()
class ImageListWidget(QWidget):
def __init__(self, parent=None):
super(ImageListWidget, self).__init__(parent)
self.resize(110, 768)
self.setupUi()
self.row_last = 0
def setupUi(self):
self.icontable = QTableWidget()
self.icontable.setColumnCount(2)
self.icontable.setColumnWidth(0, 200)
self.icontable.setColumnWidth(1, 300)
self.icontable.horizontalHeader().setVisible(False)
hlayout = QHBoxLayout()
hlayout.addWidget(self.icontable)
self.setLayout(hlayout)
def clear(self):
self.row_last = 0
self.icontable.clear()
def get_item(self):
combox = QComboBox()
combox.addItems(['欧拉角', '四元数'])
# hlayout = QHBoxLayout()
# hlayout.addWidget(combox)
return combox
def addItem(self, file_name):
exif = piexif.load(file_name)
thumbnail = exif.pop('thumbnail')
if thumbnail is not None:
pix = QPixmap()
pix.loadFromData(thumbnail, "JPG")
else:
pix = QPixmap()
pix.load(file_name)
pix_scaled = pix.scaled(200, 200, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
label = QLabel("")
label.setPixmap(pix_scaled)
self.icontable.insertRow(self.row_last)
self.icontable.setCellWidget(self.row_last, 0, label)
# self.icontable.setItem(self.row_last, 1, QTableWidgetItem("123"))
pos = PosItemWidget(QSize(300, pix_scaled.size().height()))
self.icontable.setCellWidget(self.row_last, 1, pos)
self.icontable.setRowHeight(self.row_last, pix_scaled.size().height())
self.row_last = self.row_last + 1
self.icontable.scrollToBottom()
def get_pos(self):
quats = np.zeros((self.icontable.rowCount(), 4))
trans = np.zeros((self.icontable.rowCount(), 3))
for row in range(self.icontable.rowCount()):
trans[row, :] = np.array([
self.icontable.cellWidget(row, 1).spinbox_tx.value(),
self.icontable.cellWidget(row, 1).spinbox_ty.value(),
self.icontable.cellWidget(row, 1).spinbox_tz.value()
])
if self.icontable.cellWidget(row, 1).combox.currentText() == '欧拉角':
x = self.icontable.cellWidget(row, 1).spinbox_x.value()
y = self.icontable.cellWidget(row, 1).spinbox_y.value()
z = self.icontable.cellWidget(row, 1).spinbox_z.value()
rot_temp = Rotation.from_euler('ZYX',
np.array([z, y, x]),
degrees=True)
quats[row, :] = rot_temp.as_quat()
elif self.icontable.cellWidget(row,
1).combox.currentText() == '四元数':
x = self.icontable.cellWidget(row, 1).spinbox_x.value()
y = self.icontable.cellWidget(row, 1).spinbox_y.value()
z = self.icontable.cellWidget(row, 1).spinbox_z.value()
w = self.icontable.cellWidget(row, 1).spinbox_w.value()
q = np.array([x, y, z, w])
if np.linalg.norm(q) == 0:
w = 1
q = np.array([0, 0, 0, 1])
self.icontable.cellWidget(row, 1).spinbox_x.setValue(
x / np.linalg.norm(q))
self.icontable.cellWidget(row, 1).spinbox_y.setValue(
y / np.linalg.norm(q))
self.icontable.cellWidget(row, 1).spinbox_z.setValue(
z / np.linalg.norm(q))
self.icontable.cellWidget(row, 1).spinbox_w.setValue(
w / np.linalg.norm(q))
rot_temp = Rotation.from_quat(np.array([x, y, z, w]))
quats[row, :] = rot_temp.as_quat()
rot = Rotation.from_quat(quats)
return rot, trans
class Window(QWidget):
def __init__(self):
super().__init__()
self.title = "mzTabTableWidget"
self.top = 100
self.left = 100
self.width = 500
self.height = 500
self.tableRows = 5
self.fileLoaded = False
self.PRTFull = []
self.PSMFull = []
self.PRTFiltered = []
self.PSMFiltered = []
self.PRTColumn = [True]
self.PSMColumn = [True]
self.selectedPRT = ""
self.selectedPSM = ""
self.tablePRTFull = QTableWidget()
self.tablePSMFull = QTableWidget()
self.tablePRTFiltered = QTableWidget()
self.tablePSMFiltered = QTableWidget()
self.vBoxPRT = QVBoxLayout()
self.vBoxPSM = QVBoxLayout()
self.outerVBox = QVBoxLayout()
self.InitWindow()
def InitWindow(self):
self.setWindowIcon(QtGui.QIcon("icon.png"))
self.setWindowTitle(self.title)
self.setGeometry(self.top, self.left, self.width, self.height)
self.tablePRTFull.setHidden(True)
self.tablePSMFull.setHidden(True)
self.tablePRTFiltered.setHidden(True)
self.tablePSMFiltered.setHidden(True)
self.tablePRTFull.itemClicked.connect(self.PRTClicked)
self.tablePRTFiltered.itemClicked.connect(self.PRTClicked)
self.tablePSMFull.itemClicked.connect(self.PSMClicked)
self.tablePSMFiltered.itemClicked.connect(self.PSMClicked)
self.tablePRTFull.itemDoubleClicked.connect(self.browsePRT)
self.tablePRTFiltered.itemDoubleClicked.connect(self.browsePRT)
self.tablePSMFull.itemDoubleClicked.connect(self.browsePSM)
self.tablePSMFiltered.itemDoubleClicked.connect(self.browsePSM)
self.vBoxPRT.addWidget(self.tablePRTFull)
self.vBoxPRT.addWidget(self.tablePRTFiltered)
self.vBoxPSM.addWidget(self.tablePSMFull)
self.vBoxPSM.addWidget(self.tablePSMFiltered)
self.outerVBox.addLayout(self.vBoxPRT)
self.outerVBox.addLayout(self.vBoxPSM)
self.setLayout(self.outerVBox)
self.show()
def readFile(self, file):
if self.fileLoaded:
self.tablePRTFull.clear()
self.tablePSMFull.clear()
self.tablePSMFiltered.clear()
self.tablePRTFiltered.clear()
self.tablePRTFull.setRowCount(0)
self.tablePSMFull.setRowCount(0)
self.tablePSMFiltered.setRowCount(0)
self.tablePRTFiltered.setRowCount(0)
self.PRTFull.clear()
self.PSMFull.clear()
self.PRTFiltered.clear()
self.PSMFiltered.clear()
self.PRTColumn.clear()
self.PSMColumn.clear()
self.PRTColumn = [True]
self.PSMColumn = [True]
self.parser(file)
self.PRTColumn *= len(self.PRTFull[1])
self.PSMColumn *= len(self.PSMFull[1])
self.initTables()
self.createTable(self.tablePRTFull, self.PRTFull)
self.createTable(self.tablePSMFull, self.PSMFull)
self.hidePRTColumns()
self.hidePSMColumns()
self.tablePRTFull.setHidden(False)
self.tablePSMFull.setHidden(False)
self.fileLoaded = True
def parser(self, file):
"""parses the given mzTab file and saves PRT and PSM information
Parameters
----------
file : str
The file path of the mzTab file
"""
with open(file) as inp:
for line in inp:
if line.startswith("PRH"):
self.PRTFull.append(line.strip().split('\t'))
elif line.startswith(
"PRT") and not line.endswith("protein_details\n"):
self.PRTFull.append(line.strip().split('\t'))
elif line.startswith("PSH") or line.startswith("PSM"):
self.PSMFull.append(line.strip().split('\t'))
for item in self.PRTFull:
item.pop(0)
for item in self.PSMFull:
item.pop(0)
def initTables(self):
"""draws protein and psm tables with headers"""
self.tablePRTFull.setRowCount(len(self.PRTFull))
self.tablePRTFull.setColumnCount(len(self.PRTFull[0]))
self.tablePRTFull.setHorizontalHeaderLabels(self.PRTFull[0])
self.tablePSMFull.setRowCount(len(self.PSMFull))
self.tablePSMFull.setColumnCount(len(self.PSMFull[0]))
self.tablePSMFull.setHorizontalHeaderLabels(self.PSMFull[0])
self.tablePRTFiltered.setRowCount(0)
self.tablePRTFiltered.setColumnCount(len(self.PRTFull[0]))
self.tablePRTFiltered.setHorizontalHeaderLabels(self.PRTFull[0])
self.tablePSMFiltered.setRowCount(0)
self.tablePSMFiltered.setColumnCount(len(self.PSMFull[0]))
self.tablePSMFiltered.setHorizontalHeaderLabels(self.PSMFull[0])
"""removes now unnecessary header information from content lists """
self.PRTFull.pop(0)
self.PSMFull.pop(0)
def createTable(self, table, content):
"""parameters: tableWidget to draw content in. Content to be drawn in list form"""
"""Setting count to zero empties the table. Then table is (re-)filled with specified content"""
table.setRowCount(0)
table.setRowCount(len(content))
j = 0
k = 0
for item in content[0:]:
while k < (len(content)):
while j < (len(item)):
table.setItem(k, j, QTableWidgetItem(item[j]))
j += 1
else:
k += 1
j = 0
break
self.tablePRTFull.resizeColumnsToContents() # resize columns
self.tablePSMFull.resizeColumnsToContents() # resize columns
self.tablePRTFiltered.resizeColumnsToContents() # resize columns
self.tablePSMFiltered.resizeColumnsToContents() # resize columns
def hidePRTColumns(self):
"""hides constant columns in PRT table by default by checking if every value equals"""
i = 0
j = 0
k = 0
while i < len(self.PRTFull) - 1:
while j < len(self.PRTFull[i]):
if self.PRTColumn[j]:
if self.PRTFull[i][j] != self.PRTFull[i + 1][j]:
self.PRTColumn[j] = False
j += 1
i += 1
while k < len(self.PRTColumn):
if self.PRTColumn[k]:
self.tablePRTFull.setColumnHidden(k, True)
self.tablePRTFiltered.setColumnHidden(k, True)
k += 1
def hidePSMColumns(self):
"""hides constant columns in PSM table by default by checking if every value equals"""
i = 0
j = 0
k = 0
while i < len(self.PSMFull) - 1:
while j < len(self.PSMFull[i]):
if self.PSMColumn[j]:
if self.PSMFull[i][j] != self.PSMFull[i + 1][j]:
self.PSMColumn[j] = False
j += 1
i += 1
while k < len(self.PSMColumn):
if self.PSMColumn[k]:
self.tablePSMFull.setColumnHidden(k, True)
self.tablePSMFiltered.setColumnHidden(k, True)
k += 1
def PRTClicked(self, item):
if self.tablePRTFull.isHidden():
relevantContent = self.PRTFiltered
else:
relevantContent = self.PRTFull
accession = relevantContent[item.row()][0]
if self.selectedPSM == accession:
self.unfilterPSM()
else:
self.filterPSM(accession)
def PSMClicked(self, item):
if self.tablePSMFull.isHidden():
relevantContent = self.PSMFiltered
else:
relevantContent = self.PSMFull
accession = relevantContent[item.row()][2]
if self.selectedPRT == accession:
self.unfilterPRT()
else:
self.filterPRT(accession)
def filterPRT(self, accession):
self.tablePRTFiltered.setHidden(False)
self.tablePRTFull.setHidden(True)
self.selectedPRT = accession
self.PRTFiltered = [
p for p in self.PRTFull if p[0] == self.selectedPRT
]
self.createTable(self.tablePRTFiltered, self.PRTFiltered)
def filterPSM(self, accession):
self.tablePSMFiltered.setHidden(False)
self.tablePSMFull.setHidden(True)
self.selectedPSM = accession
self.PSMFiltered = [
p for p in self.PSMFull if p[2] == self.selectedPSM
]
self.createTable(self.tablePSMFiltered, self.PSMFiltered)
def unfilterPRT(self):
self.tablePRTFiltered.setHidden(True)
self.tablePRTFull.setHidden(False)
self.selectedPRT = ""
self.PRTFiltered = []
def unfilterPSM(self):
self.tablePSMFiltered.setHidden(True)
self.tablePSMFull.setHidden(False)
self.selectedPSM = ""
self.PSMFiltered = []
def browsePRT(self, item):
if self.tablePRTFull.isHidden():
accession = self.PRTFiltered[item.row()][0].split("|", 2)[1]
else:
accession = self.PRTFull[item.row()][0].split("|", 2)[1]
webbrowser.open("https://www.uniprot.org/uniprot/" + accession)
def browsePSM(self, item):
if self.tablePSMFull.isHidden():
accession = self.PSMFiltered[item.row()][2].split("|", 2)[1]
else:
accession = self.PSMFull[item.row()][2].split("|", 2)[1]
webbrowser.open("https://www.uniprot.org/uniprot/" + accession)
class rmPeaksDialog(QDialog):
''' created when clicking on the "remove peaks" button'''
def __init__(self, parent=CalibWin) -> None:
super(rmPeaksDialog, self).__init__(parent)
self.par = self.parent()
self.currentindex = 0
self.setGeometry(850, 500, 450, 300)
self.setWindowTitle("Remove peaks")
self.mainlayout = QHBoxLayout()
self.rightlayout = QVBoxLayout()
self.thirdlayout = QHBoxLayout()
self.peaksTable = QTableWidget()
self.peaksTable.setSelectionBehavior(QTableView.SelectRows)
self.peaksTable.clicked.connect(self.changeindex_lr)
self.peaksTable.verticalHeader().sectionClicked.connect(
self.changeindex2_lr)
self.refreshTable_fn()
self.rmpeak_btn = QPushButton("Remove", self)
self.ok_btn = QPushButton("Done", self)
self.cancel_btn = QPushButton("Cancel", self)
self.rmpeak_btn.clicked.connect(self.rmpeak_lr)
self.ok_btn.clicked.connect(self.ok_lr)
self.cancel_btn.clicked.connect(self.cancel_lr)
self.thirdlayout.addWidget(self.ok_btn)
self.thirdlayout.addWidget(self.cancel_btn)
self.rightlayout.addWidget(self.rmpeak_btn)
self.rightlayout.addLayout(self.thirdlayout)
self.mainlayout.addWidget(self.peaksTable)
self.mainlayout.addLayout(self.rightlayout)
self.setLayout(self.mainlayout)
self.show()
''' Updating the table'''
def refreshTable_fn(self) -> None:
self.peaksTable.clear()
self.peaksTable.setRowCount(len(self.par.maximaIndices) + 1)
self.peaksTable.setColumnCount(2)
self.peaksTable.setItem(0, 0, QTableWidgetItem("xcoord"))
self.peaksTable.setItem(0, 1, QTableWidgetItem("ycoord"))
for i in range(len(self.par.maximaIndices)):
self.peaksTable.setItem(
i + 1, 0,
QTableWidgetItem("{:.3e}".format(self.par.maximaIndices[i])))
self.peaksTable.setItem(
i + 1, 1,
QTableWidgetItem("{:.3e}".format(self.par.maximaIntensity[i])))
''' Updating the row index on clicking on the vertical header'''
def changeindex2_lr(self, logicalIndex) -> None:
self.currentindex = logicalIndex - 1
''' Updating the row index on clicking anywhere in the row'''
def changeindex_lr(self, clickedIndex) -> None:
self.currentindex = clickedIndex.row() - 1
''' "Remove peaks" button listener '''
def rmpeak_lr(self):
del self.par.maximaIndices[self.currentindex]
del self.par.maximaIntensity[self.currentindex]
self.par.refreshplot_fn()
self.refreshTable_fn()
if (self.currentindex > len(self.par.maximaIndices) - 1):
self.peaksTable.selectRow(self.currentindex)
self.currentindex -= 1
else:
self.peaksTable.selectRow(self.currentindex + 1)
''' "ok" button listener '''
def ok_lr(self) -> None:
self.destroy()
''' "cancel" button listener. Calling the parent function "findpeaks_lr" erases all the changes '''
def cancel_lr(self) -> None:
self.par.findpeaks_lr()
self.par.refreshplot_fn()
self.destroy()
class MetaDataViewer(QWidget):
"""This is the QT Gui that can be used to manipulate
the meta data in the Embedding Gui
Assumes layout of the meta-data csv has an id followed
by pairs of label + color columns
id label0 color0 label1 color1 --- labelN colorN
. ... ... ... ... --- ... ...
. ... ... ... ... --- ... ...
"""
def __init__(self):
"""View a composite image based
on a subselection of the data
"""
super(MetaDataViewer, self).__init__()
self.class_combo = QComboBox(self)
main_layout = QVBoxLayout()
form_layout = QFormLayout()
form_layout.addRow(QLabel('Class:'), self.class_combo)
self.meta_table = QTableWidget(self)
self.meta_table.itemSelectionChanged.connect(self.on_change_select)
main_layout.addLayout(form_layout)
main_layout.addWidget(self.meta_table, 6)
self.setLayout(main_layout)
self.headers = None
self.class_combo.currentIndexChanged[int].connect(self.on_class)
self.meta_path = None
self.label_series = None
self.color_series = None
self.labels = None
self.string_labels = None
self.on_color_change = None
self.on_select = None
self.dframe = None
def init_metadata(
self,
meta_path=None,
on_color_change=None,
on_select=None):
"""Load the meta data and register the meta selection callbacks"""
if meta_path is None:
return
self.on_color_change = on_color_change
self.on_select = on_select
self.meta_path = meta_path
self.headers = pd.read_csv(meta_path, nrows=0)
header_names = list(self.headers)
self.meta_pairs = []
if len(header_names) % 2 == 0:
raise RuntimeError(
"""Expecting meta data to comprise an id
column followed by pairs of label/color columns""")
for i in range(1, len(header_names), 2):
self.meta_pairs.append([header_names[i], header_names[i + 1]])
self.class_combo.addItem(header_names[i], i)
self.class_combo.setCurrentIndex(0)
def __fill_table(self):
"""The table allows the user to select labels"""
self.meta_table.clear()
# select by row and allow building up multiple selections
self.meta_table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.meta_table.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.meta_table.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.meta_table.setShowGrid(True)
self.meta_table.setRowCount(len(self.labels))
self.meta_table.setColumnCount(2)
self.meta_table.setHorizontalHeaderLabels(['Group', 'Color'])
self.meta_table.verticalHeader().hide()
for i, label in enumerate(self.labels):
# some label columns are not strings - whodathunkit!
self.meta_table.setItem(i, 0, QTableWidgetItem(str(label)))
color_item = QTableWidgetItem(' ')
lab_col = self.unique_dframe[self.unique_dframe.iloc[:, 0] == label]
color_item.setBackground(QColor(lab_col.iloc[0, 1]))
self.meta_table.setItem(i, 1, color_item)
@pyqtSlot(int)
def on_class(self, index):
"""A new meta data class has been selected. Load
and activate the pair of meta columns label + color"""
if self.meta_path is None:
return
cols = self.meta_pairs[index]
# load the columns corresponsing to the selected class
dframe = pd.read_csv(self.meta_path, usecols=cols)
self.label_series = dframe.iloc[:, 0]
self.color_series = dframe.iloc[:, 1]
self.unique_dframe = dframe.drop_duplicates()
self.labels = list(self.label_series.unique())
self.labels.sort()
self.__fill_table()
# Callback the currently loaded colors
self.on_color_change(self.color_series.to_numpy())
@pyqtSlot()
def on_change_select(self):
"""A meta data row has been selected in the table. Convert that
to data indexes and callback to the Analysis Controller"""
selection = self.meta_table.selectedIndexes()
all_indexes = []
for i in selection:
group = self.labels[i.row()]
group_indexes = list(
self.label_series[self.label_series == group].index)
all_indexes = all_indexes + group_indexes
self.on_select(all_indexes)
class cost(QWidget):
def callback_close(self, widget, data=None):
self.hide()
return True
def callback_help(self):
webbrowser.open('http://www.gpvdm.com/man/index.html')
def __init__(self):
QWidget.__init__(self)
self.setFixedSize(900, 600)
self.setWindowIcon(QIcon(os.path.join(get_image_file_path(),"jv.png")))
self.setWindowTitle(_("Cost and energy payback calculator (BETA - missing realistic data at the moment!!!)"))
self.main_vbox = QVBoxLayout()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
self.play = QAction(QIcon(os.path.join(get_image_file_path(),"play.png")), "Re-calcualte", self)
self.play.triggered.connect(self.update)
toolbar.addAction(self.play)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.help = QAction(QIcon(os.path.join(get_image_file_path(),"help.png")), "Help", self)
self.help.triggered.connect(self.callback_help)
toolbar.addAction(self.help)
self.main_vbox.addWidget(toolbar)
self.tab= QTableWidget()
self.main_vbox.addWidget(self.tab)
self.setLayout(self.main_vbox)
self.win_list=windows()
self.win_list.load()
self.win_list.set_window(self,"costs_window")
self.update()
def update(self):
self.tab.clear()
self.tab.setColumnCount(5)
self.tab.setRowCount(0)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tab.setHorizontalHeaderLabels([_("material"), _("Volume (m^-3)"), _("Mass (kg)"), _("Cost ($)"), _("Energy (J)")])
self.tab.setColumnWidth(1, 200)
self.tab.setColumnWidth(2, 200)
self.tab.setColumnWidth(3, 200)
self.tab.setColumnWidth(4, 200)
energy_tot=0.0
cost_tot=0.0
for i in range(0,epitaxy_get_layers()):
volume=epitaxy_get_width(i)*1.0*1.0
name=epitaxy_get_mat_file(i)
xls_file_name=os.path.join(get_materials_path(),epitaxy_get_mat_file(i),"cost.xlsx")
wb = load_workbook(xls_file_name)
ws= wb.get_sheet_by_name("results")
density = float(ws['B2'].value)
mass=density*volume
cost_per_kg = float(ws['B3'].value)
cost=mass*cost_per_kg
energy_per_kg = float(ws['B4'].value)
energy=energy_per_kg*mass
tab_add(self.tab,[name,str(volume),str(mass),str(cost),str(energy)])
energy_tot=energy_tot+energy
cost_tot=cost_tot+cost
pce=inp_get_token_value("sim_info.dat", "#pce")
payback_time=-1.0
if pce!=None:
pce=float(pce)
gen_energy=1366.0*pce/100.0
payback_time=energy_tot/gen_energy/60.0/60.0/24/365
tab_add(self.tab,["sum","","",str(cost_tot),str(energy_tot)])
tab_add(self.tab,["","","pay back time=",str(payback_time),"years"])
def closeEvent(self, event):
self.win_list.update(self,"costs_window")
self.hide()
event.accept()
class contacts_window(QWidget):
visible=1
changed = pyqtSignal()
def update_contact_db(self):
for i in range(0,self.tab.rowCount()):
try:
float(tab_get_value(self.tab,i, 0))
float(tab_get_value(self.tab,i, 2))
float(tab_get_value(self.tab,i, 3))
float(tab_get_value(self.tab,i, 1))
except:
return False
contacts_clear()
for i in range(0,self.tab.rowCount()):
contacts_append(float(tab_get_value(self.tab,i, 0)),float(tab_get_value(self.tab,i, 2)),float(tab_get_value(self.tab,i, 3)),float(tab_get_value(self.tab,i, 1)),str2bool(tab_get_value(self.tab,i, 4)))
return True
def add_row(self,pos,start,width,depth,voltage,active):
pos= tab_insert_row(self.tab)
self.tab.blockSignals(True)
self.tab.setItem(pos,0,QTableWidgetItem(start))
self.tab.setItem(pos,1,QTableWidgetItem(width))
self.tab.setItem(pos,2,QTableWidgetItem(depth))
self.tab.setItem(pos,3,QTableWidgetItem(voltage))
combobox = QComboBox()
combobox.addItem(_("true"))
combobox.addItem(_("false"))
self.tab.setCellWidget(pos,4, combobox)
combobox.setCurrentIndex(combobox.findText(active.lower()))
combobox.currentIndexChanged.connect(self.save)
self.tab.blockSignals(False)
def on_add_clicked(self, button):
index = self.tab.selectionModel().selectedRows()
if len(index)>0:
pos=index[0].row()+1
else:
pos = self.tab.rowCount()
self.add_row(pos,_("0.0"),_("0.0"),_("0.0"),_("0.0"),_("false"))
self.save()
def on_remove_clicked(self, button):
tab_remove(self.tab)
self.save()
def save(self):
if self.update_contact_db()==True:
contacts_save()
self.changed.emit()
else:
error_dlg(self,_("There are some non numberic values in the table"))
def callback_close(self, widget, data=None):
self.win_list.update(self,"contact")
self.hide()
return True
def callback_help(self):
webbrowser.open('http://www.gpvdm.com/man/index.html')
def tab_changed(self, x,y):
self.save()
def load(self):
self.tab.clear()
self.tab.setHorizontalHeaderLabels([_("Start"), _("Width"),_("Depth"),_("Voltage"),_("Active contact")])
contacts_load()
#contacts_print()
contacts=contacts_get_array()
i=0
for c in contacts_get_array():
self.add_row(i,str(c.start),str(c.width),str(c.depth),str(c.voltage),str(c.active))
i=i+1
def __init__(self):
QWidget.__init__(self)
self.setFixedSize(600, 400)
self.win_list=windows()
self.win_list.set_window(self,"contacts")
self.setWindowIcon(QIcon(os.path.join(get_image_file_path(),"contact.png")))
self.setWindowTitle(_("Edit contacts (www.gpvdm.com)"))
self.main_vbox = QVBoxLayout()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
add = QAction(QIcon(os.path.join(get_image_file_path(),"add.png")), _("Add contact"), self)
add.triggered.connect(self.on_add_clicked)
toolbar.addAction(add)
remove = QAction(QIcon(os.path.join(get_image_file_path(),"minus.png")), _("Remove contacts"), self)
remove.triggered.connect(self.on_remove_clicked)
toolbar.addAction(remove)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.help = QAction(QIcon(os.path.join(get_image_file_path(),"help.png")), 'Hide', self)
self.help.setStatusTip(_("Close"))
self.help.triggered.connect(self.callback_help)
toolbar.addAction(self.help)
self.main_vbox.addWidget(toolbar)
self.tab = QTableWidget()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.tab.clear()
self.tab.setColumnCount(5)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.load()
self.tab.cellChanged.connect(self.tab_changed)
self.main_vbox.addWidget(self.tab)
self.setLayout(self.main_vbox)
class ClassUI(QWidget):
def __init__(self):
super().__init__()
self.initUI()
self.re_1 = re.compile(r"^([A-Z]{2,4})(\d{4})")
self.re_2 = re.compile(r"^([A-Z]{2,4})-(\d{4})(\d{2})$")
def initUI(self):
self.layout = QSplitter()
self.in_layout = QVBoxLayout()
self.table = QTableWidget()
self.headers = ['Class', 'Title', 'Amazon', 'Bookstore', 'Edition', 'ISBN', 'Publisher', 'Author', 'Suggested Retail Price', 'Comments', 'Required']
self.table.setColumnCount(len(self.headers))
self.table.setHorizontalHeaderLabels(self.headers)
self.table.cellDoubleClicked.connect(self.tableClicked)
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
# self.table.verticalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.le = []
for i in range(5):
self.le.append(QLineEdit(self))
self.table.setRowCount(len(self.le))
#self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.submit_btn = QPushButton('Submit', self)
self.submit_btn.clicked.connect(self.submit)
self.add_btn = QPushButton('+', self)
self.add_btn.clicked.connect(self.add_le)
self.rm_btn = QPushButton('-', self)
self.rm_btn.clicked.connect(self.rm_le)
self.btn_layout = QHBoxLayout()
self.in_layout.addWidget(self.submit_btn)
self.btn_layout.addWidget(self.add_btn)
self.btn_layout.addWidget(self.rm_btn)
self.in_layout.addLayout(self.btn_layout)
for l in self.le:
l.textChanged.connect(self.textChanged)
self.in_layout.addWidget(l)
self.regex = re.compile("^[A-Z]{2,4}-\d{4}(?:-\d{2})?$")
lside = QWidget(self)
lside.setLayout(self.in_layout)
self.layout.addWidget(lside)
self.tab = QTabWidget(self)
self.tab.addTab(self.table, 'Books')
self.calendar = WeekView()
self.tab.addTab(self.calendar, 'Calendar')
self.layout.addWidget(self.tab)
l = QVBoxLayout()
l.addWidget(self.layout)
self.setLayout(l)
app_icon = QIcon()
app_icon.addFile('tulsa.jpg')
self.setWindowIcon(app_icon)
self.setGeometry(300, 300, 800, 600)
self.setWindowTitle('Tulsa class info')
self.show()
def add_le(self):
l = QLineEdit(self)
l.textChanged.connect(self.textChanged)
self.in_layout.addWidget(l)
self.le.append(l)
def rm_le(self):
l = self.le.pop()
self.in_layout.removeWidget(l)
l.deleteLater()
l = None
def textChanged(self):
for l in self.le:
t = l.text().upper().replace(' ', '-')
t = re.sub(self.re_1, r"\1-\2", t)
t = re.sub(self.re_2, r"\1-\2-\3", t)
l.setText(t)
if self.regex.match(l.text()):
l.setStyleSheet('color: black')
else:
l.setStyleSheet('color: red')
def tableClicked(self, r, c):
if c == 2 or c == 3:
cell = self.table.item(r, c)
if cell:
url = cell.text()
if url:
QDesktopServices.openUrl(QUrl(url))
def keyPressEvent(self, event):
if event.key() == Qt.Key_Escape:
self.close()
def set_table_item(self, x, y, s):
self.table.setItem(x, y, QTableWidgetItem(s))
def submit(self):
data = [l.text() for l in self.le if self.regex.match(l.text())]
schedule, times = classes.do_stuff(data)
self.calendar.refresh()
self.table.clear()
self.table.setHorizontalHeaderLabels(self.headers)
cur_row = 0
for item in times:
for tup in item['times']:
self.calendar.add_event(tup[0], tup[1], item['name'], item['building'] + ' ' + item['room'])
for key in schedule:
for book in schedule[key]:
self.table.setRowCount(cur_row + 1)
if book['Book Title'] != "No Books Required":
result = search.ddg_crawl(search.ddg_search(book['Book Title'] + ' ' + book['ISBN']))
bkstr = search.bookstore_get_url(book['Book Title'])
self.set_table_item(cur_row, 2, result)
self.set_table_item(cur_row, 3, bkstr)
self.set_table_item(cur_row, 0, key)
self.set_table_item(cur_row, 1, book['Book Title'])
self.set_table_item(cur_row, 4, book['Edition'])
self.set_table_item(cur_row, 5, book['ISBN'])
self.set_table_item(cur_row, 6, book['Publisher'])
self.set_table_item(cur_row, 7, book['Author'])
self.set_table_item(cur_row, 8, book['Publishers Suggested Retail Price'])
self.set_table_item(cur_row, 9, book['Comments'])
self.set_table_item(cur_row, 10, book['Required'])
cur_row += 1
class DeleteOrphansDirector(QMdiSubWindow):
def __init__(self, main):
"""
Class for delete directors who are orphan in database.
:param main: Reference for main windows.
"""
super(DeleteOrphansDirector, self).__init__()
self.session = DB.get_session()
self.director = self.session.query(Director)
self.main = main
window_title = texts.delete_orphans + ' ' + texts.director_p
self.setWindowTitle(window_title)
self.subwindow = QWidget()
p = self.palette()
p.setColor(self.backgroundRole(), QColor(230, 230, 250))
self.setPalette(p)
self.setWidget(self.subwindow)
font = QFont()
font.setPointSize(12)
# Vbox Main
self.vbox_main = QVBoxLayout(self.subwindow)
self.vbox_main.setContentsMargins(20, 20, 20, 20)
self.vbox_main.setSpacing(10)
# Table Cast
self.table = QTableWidget()
self.table.setColumnCount(2)
self.table.setContentsMargins(20, 0, 0, 0)
self.table.setHorizontalHeaderLabels([
texts.director_s,
'Del'
])
# table set column width
w = int(0.5 * main.frameSize().width())
col_1 = int(0.60 * (w - 50))
col_2 = int(0.20 * (w - 50))
col_width = col_1 + col_2 + 4
self.table.setColumnWidth(0, col_1)
self.table.setColumnWidth(1, col_2)
self.table.rowHeight(30)
self.table.setFixedWidth(col_width)
self.table.horizontalHeader().setFont(font)
self.table.horizontalHeader().setStyleSheet(
'background-color: rgb(230, 230, 230);')
self.table.verticalHeader().setVisible(False)
self.rows = 0
self.ch_del = []
self.vbox_main.addWidget(self.table)
# Buttons
self.pb_delete = pb_create(texts.pb_delete, 12, 40)
self.pb_delete.setMinimumHeight(40)
self.pb_delete.setShortcut('Ctrl+D')
self.pb_delete.clicked.connect(self.delete)
self.pb_leave = pb_create(texts.pb_leave, 12, 40)
self.pb_leave.setMinimumHeight(40)
self.pb_leave.setShortcut('Ctrl+Q')
self.pb_leave.clicked.connect(self.close)
self.pb_help = pb_create(texts.pb_help, height=40)
self.pb_help.setMinimumHeight(40)
self.pb_help.clicked.connect(self.help)
self.pb_help.setShortcut('Ctrl+H')
self.pb_select_all = pb_create(texts.pb_select_all, 12, 40)
self.pb_select_all.setMinimumHeight(40)
self.pb_select_all.setShortcut('Ctrl+A')
self.pb_select_all.clicked.connect(self.select_all)
self.hb_pb = QHBoxLayout()
self.hb_pb.setSpacing(10)
self.hb_pb.addWidget(self.pb_delete)
self.hb_pb.addWidget(self.pb_leave)
self.hb_pb.addWidget(self.pb_help)
self.hb_pb.addWidget(self.pb_select_all)
self.vbox_main.addLayout(self.hb_pb)
self.width = col_width + 44
self.height = int(0.8 * main.frameSize().height())
self.setGeometry(0, 0, self.width, self.height)
self.create_table()
def create_table(self):
"""
Create a table for show all orphan directors info and with a QCheckBox
that if is check the actor will be delete.
"""
sub = self.session.query(MovieDirector.director_id)
sub = sub.distinct()
director_result = self.director.filter(Director.id.notin_(sub)).all()
for director in director_result:
self.table.insertRow(self.rows)
self.table.setItem(self.rows, 0,
QTableWidgetItem(director.name))
ch_del = QCheckBox(str(director.id))
self.ch_del.append(ch_del)
hb_del = hbox_create([self.ch_del[self.rows]], 0)
hb_del.setAlignment(Qt.AlignCenter)
cell_del = QWidget()
cell_del.setLayout(hb_del)
self.table.setCellWidget(self.rows, 1, cell_del)
if self.rows % 2 != 0:
self.table.item(self.rows, 0).setBackground(
QColor(230, 230, 230)
)
self.table.cellWidget(self.rows, 1).setStyleSheet(
'background-color: #E6E6E6;'
'color: #E6E6E6;'
)
else:
self.table.cellWidget(self.rows, 1).setStyleSheet(
'color: #FFFFFF;'
)
self.table.item(self.rows, 0).setFlags(
Qt.ItemIsSelectable | Qt.ItemIsEnabled
)
self.rows += 1
height = self.rows * 30 + 20
self.table.setMinimumHeight(height)
self.height = height + 130
self.setGeometry(0, 0, self.width, self.height)
def delete(self):
"""
Delete director from database.
"""
delete_orphans(self.session, self.ch_del, Director, texts.director_s)
self.clear()
self.create_table()
def select_all(self):
"""
Mark all delete QCheckBox.
"""
for ch in self.ch_del:
ch.setChecked(True)
# Clear
def clear(self):
"""
Call for help.
:return: Show a help view.
"""
for row in range(self.rows):
self.table.removeRow(row)
self.table.clear()
self.table.setRowCount(0)
self.rows = 0
self.ch_del = []
self.session.expire_all()
# Help
def help(self):
# I have to perform help preview functions on the main because the bug
# "stack_trace posix.cc (699)" does not let the page find its directory.
dir = os.getcwd()
url = 'file:///' + dir + '/views_help/help_delete_orphans.html'
self.main.views_help(url, texts.help_edit_movie)
# Close Event
def closeEvent(self, event):
self.session.close()
class AccountDialog(QDialog):
selected = QtCore.pyqtSignal(int, bool)
aborted = QtCore.pyqtSignal()
def __init__(self, parent, accountman):
QDialog.__init__(self, parent)
self.accountman = accountman
layout = QVBoxLayout()
self.setWindowTitle('Select Account')
# Create list
self.table = QTableWidget()
self.table.horizontalHeader().setHighlightSections(False)
self.table.setSelectionMode(QAbstractItemView.SingleSelection)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table.verticalHeader().hide()
self.table.setGridStyle(QtCore.Qt.NoPen)
self.table.doubleClicked.connect(self.select)
bottom_layout = QHBoxLayout()
self.remember_chk = QCheckBox('Remember')
cancel_btn = QPushButton('Cancel')
cancel_btn.clicked.connect(self.cancel)
add_btn = QPushButton('Add')
add_btn.clicked.connect(self.add)
self.edit_btns = QComboBox()
self.edit_btns.blockSignals(True)
self.edit_btns.addItem('Edit...')
self.edit_btns.addItem('Update')
self.edit_btns.addItem('Delete')
self.edit_btns.addItem('Purge')
self.edit_btns.setItemData(1, 'Change the local password/PIN for this account', QtCore.Qt.ToolTipRole)
self.edit_btns.setItemData(2, 'Remove this account from Trackma', QtCore.Qt.ToolTipRole)
self.edit_btns.setItemData(3, 'Clear local DB for this account', QtCore.Qt.ToolTipRole)
self.edit_btns.setCurrentIndex(0)
self.edit_btns.blockSignals(False)
self.edit_btns.activated.connect(self.s_edit)
select_btn = QPushButton('Select')
select_btn.clicked.connect(self.select)
select_btn.setDefault(True)
bottom_layout.addWidget(self.remember_chk)
bottom_layout.addWidget(cancel_btn)
bottom_layout.addWidget(add_btn)
bottom_layout.addWidget(self.edit_btns)
bottom_layout.addWidget(select_btn)
# Get icons
self.icons = dict()
for libname, lib in utils.available_libs.items():
self.icons[libname] = QtGui.QIcon(lib[1])
# Populate list
self.update()
self.rebuild()
# Finish layout
layout.addWidget(self.table)
layout.addLayout(bottom_layout)
self.setLayout(layout)
def update(self):
self.remember_chk.setChecked(self.accountman.get_default() is not None)
def add(self):
result = AccountAddDialog.do(icons=self.icons)
if result:
(username, password, api) = result
self.accountman.add_account(username, password, api)
self.rebuild()
def edit(self):
self.edit_btns.blockSignals(True)
self.edit_btns.setCurrentIndex(0)
self.edit_btns.blockSignals(False)
try:
selected_account_num = self.table.selectedItems()[0].num
acct = self.accountman.get_account(selected_account_num)
result = AccountAddDialog.do(icons=self.icons,
edit=True,
username=acct['username'],
password=acct['password'],
api=acct['api'])
if result:
(username, password, api) = result
self.accountman.edit_account(selected_account_num, username, password, api)
self.rebuild()
except IndexError:
self._error("Please select an account.")
def delete(self):
try:
selected_account_num = self.table.selectedItems()[0].num
reply = QMessageBox.question(self, 'Confirmation', 'Do you want to delete the selected account?', QMessageBox.Yes, QMessageBox.No)
if reply == QMessageBox.Yes:
self.accountman.delete_account(selected_account_num)
self.rebuild()
except IndexError:
self._error("Please select an account.")
def purge(self):
try:
selected_account_num = self.table.selectedItems()[0].num
reply = QMessageBox.question(self, 'Confirmation', 'Do you want to purge the selected account\'s local data?', QMessageBox.Yes, QMessageBox.No)
if reply == QMessageBox.Yes:
self.accountman.purge_account(selected_account_num)
self.rebuild()
except IndexError:
self._error("Please select an account.")
def s_edit(self, index):
if index is 1:
self.edit()
elif index is 2:
self.delete()
elif index is 3:
self.purge()
def rebuild(self):
self.table.clear()
columns = ['Username', 'Site']
self.table.setColumnCount(len(columns))
self.table.setHorizontalHeaderLabels(columns)
self.table.setRowCount(len(self.accountman.accounts['accounts']))
accounts = self.accountman.get_accounts()
i = 0
for k, account in accounts:
self.table.setRowHeight(i, QtGui.QFontMetrics(self.table.font()).height() + 2)
self.table.setItem(i, 0, AccountItem(k, account['username']))
self.table.setItem(i, 1, AccountItem(k, account['api'], self.icons.get(account['api'])))
i += 1
if pyqt_version is 5:
self.table.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
else:
self.table.horizontalHeader().setResizeMode(0, QHeaderView.Stretch)
def select(self, checked):
try:
selected_account_num = self.table.selectedItems()[0].num
self.selected.emit(selected_account_num, self.remember_chk.isChecked())
self.close()
except IndexError:
self._error("Please select an account.")
def cancel(self, checked):
self.aborted.emit()
self.close()
def _error(self, msg):
QMessageBox.critical(self, 'Error', str(msg), QMessageBox.Ok)
class StatisticsWidget(QWidget):
def __init__(self, parent, game):
super().__init__(parent)
self.parent = parent
self.game = game
self.title = "Statistics"
self.left = 0
self.top = 0
self.width = 1000
self.height = 800
self.initUI()
def initUI(self):
"""
initialize the widget parameter
"""
self.setWindowTitle(self.title)
# print(self.parent.minimumSizeHint().height())
self.setGeometry(self.left, self.top, self.width, self.height)
self.table_widget = QTableWidget()
self.table_widget.setRowCount(32) # attributes
num_individuals = self.parent.parent_window.config.global_config[
'num_individuals'] * 2
self.table_widget.setColumnCount(num_individuals) # individuals
self.display_statistics()
self.layout = QVBoxLayout()
self.layout.addWidget(self.table_widget)
self.setLayout(self.layout)
# self.resize(self.sizeHint().width(), self.sizeHint().height())
self.show()
def reload(self, game):
"""
reloads all statistics with the given game instance
"""
self.game = game
self.table_widget.clear()
def update(self):
"""
redraw statistics
"""
self.display_statistics()
def display_statistics(self):
"""
create a table for statistics for all individuals
"""
populations = ["pop1", "pop2"]
header = []
for pop in populations:
for i in range(len(self.game.game_objects[pop])):
header.append(self.game.colors[pop][1] + " #" + str(i + 1))
# self.table_widget.setSpan(1,0,7,0)
# setItem(row, column, item)
self.table_widget.setHorizontalHeaderLabels(header)
v_header_labels = [
"Dead", "Frames Survived", "Food Perception", "Poison Perception",
"Heal Potion Perception", "Corpse Perception",
"Opponent Perception", "Predator Perception", "Seek Food Desire",
"Dodge Poison Desire", "Seek Heal Potion Desire",
"Seek Opponents Desire", "Seek Corpse Desire",
"Dodge Predators Desire", "Increased Armor", "Increased Speed",
"Increased Poison Resistance", "Strength", "Toxicity",
"Food Eaten", "Poison Eaten", "Consumed Heal Potions",
"Consumed Corpses", "Attacked Enemies", "Attacked by Opponents",
"Attacked by Predators", "Food Seen", "Poison Seen",
"Heal Potion Seen", "Opponent Seen", "Predator Seen", "Corpse Seen"
]
self.table_widget.setVerticalHeaderLabels(v_header_labels)
pop_offset = 0
for pop in populations:
index = 0
for individual in self.game.game_objects[pop]:
individual.statistic_to_table(self.table_widget,
pop_offset + index)
index += 1
pop_offset += len(self.game.game_objects[pop])
def create_major_display_table(input_iterable,
key=lambda x: x, reverse=False,
headers=None, row_cell_functions=None,
cutoff=0,
set_text_alignment=None):
"""
This is a general function for creating a tabular display for the
major display.
"""
if not input_iterable:
print('Warning: input is empty', flush=True)
return
if not hasattr(input_iterable, '__iter__'):
print('Warning: input is not an iterable', flush=True)
return
number_of_headers = len(headers)
number_of_columns = len(row_cell_functions)
if number_of_headers != number_of_columns:
print('headers and cell functions don\'t match', flush=True)
return
len_input = len(input_iterable)
table_widget = QTableWidget()
table_widget.clear()
table_widget.setSortingEnabled(False)
# set up row count
if cutoff and cutoff < len_input:
actual_cutoff = cutoff
else:
actual_cutoff = len_input
table_widget.setRowCount(actual_cutoff)
# set up column count and table headers
table_widget.setColumnCount(number_of_headers)
table_widget.setHorizontalHeaderLabels(headers)
# fill in the table
for row, x in enumerate(double_sorted(input_iterable, key=key,
reverse=reverse)):
for col, fn in enumerate(row_cell_functions):
cell = fn(x)
if isinstance(cell, (int, float)):
# cell is numeric
item = QTableWidgetItem()
item.setData(Qt.EditRole, cell)
else:
# cell is not numeric
item = QTableWidgetItem(cell)
if set_text_alignment:
for align_col, alignment in set_text_alignment:
if col == align_col:
item.setTextAlignment(alignment)
table_widget.setItem(row, col, item)
if not row < actual_cutoff:
break
table_widget.setSortingEnabled(True)
table_widget.resizeColumnsToContents()
return table_widget
class MyStorFarm(QWidget):
def __init__(self):
super().__init__()
hbox=QHBoxLayout()
hbox2=QHBoxLayout()
namelabel=QLabel("스토어팜주소")
self.farm_combo=QComboBox()
self.li=['https://smartstore.naver.com/heyhannah','https://smartstore.naver.com/monsclub']
self.farm_combo.addItems(self.li)
self.shop_title_label=QLabel()
self.show_farm_name()
self.btn_show_prod=QPushButton('조회')
self.btn_show_prod.setIcon(QtGui.QIcon('update.png'))
self.gear_btn=QPushButton()
self.gear_btn.setIcon(QtGui.QIcon('gear.png'))
hbox.addWidget(namelabel)
hbox.addWidget(self.farm_combo)
hbox.addWidget(self.shop_title_label)
hbox.addWidget(self.btn_show_prod)
# hbox.addWidget(self.gear_btn)
self.date_combo=QComboBox()
self.init_date_combo()
self.btn_download=QPushButton("금일 데이터 받기")
self.btn_download.setIcon(QtGui.QIcon("download.png"))
hbox2.addWidget(QLabel("조회일"))
hbox2.addWidget(self.date_combo)
hbox2.addWidget(self.btn_download)
hbox2.addStretch()
self.gear_btn.clicked.connect(partial(self.setFarm,self.li))
self.btn_show_prod.clicked.connect(self.get_prod)
self.farm_combo.currentTextChanged.connect(self.show_farm_name)
self.btn_download.clicked.connect(self.download_data)
vbox=QVBoxLayout()
self.tablewidget=QTableWidget()
self.updateProdList()
self.groupbox=QGroupBox()
self.groupbox2=QGroupBox()
self.groupbox.setLayout(hbox)
self.groupbox2.setLayout(hbox2)
vbox.addWidget(self.groupbox)
vbox.addWidget(self.groupbox2)
self.tablewidget.resizeColumnToContents(0)
vbox.addWidget(self.tablewidget)
self.setLayout(vbox)
def download_data(self):
# mall_name='헤이해나'
mall_name=self.shop_title_label.text()
url_home=self.farm_combo.currentText()
# req=requests.get(url)
# soup=BeautifulSoup(req.text, 'html.parser')
# self.shop_title_label.setText(soup.find('title').text.strip())
itemslist=all_items(mall_name, url_home)
# print(itemslist)
conn=sqlite3.connect('emaildb.sqlite')
cur=conn.cursor()
tod=datetime.today()+timedelta(days=0)
tod=tod.strftime('%Y-%m-%d')
url_home=self.farm_combo.currentText()
# print(tod)
for item in itemslist:
#update link
item['link']=url_home+'/products/'+item['pid']
# link=url_home="https://smartstore.naver.com/heyhannah/products/" +pid
# print(item['name'])
sql=f"REPLACE INTO PROD3 (dt,title, pid,jjim, sold,review,link) VALUES('{tod}','{item['name']}','{item['pid']}','{item['jjim']}','{item['sold']}','{item['review']}','{item['link']}')"
# print(sql)
cur.execute(sql)
# cur.execute('''
# REPLACE INTO PROD3 (dt,title, pid,jjim, sold,review,link) VALUES (?,?,?,?,?,?,?);''', (tod,item['name'],item['pid'],item['jjim'],item['sold'],item['review']))
conn.commit()
conn.commit()
cur.close()
conn.close()
self.init_date_combo()
self.updateProdList()
def init_date_combo(self):
mall_url=self.farm_combo.currentText()
conn=sqlite3.connect('emaildb.sqlite')
cur=conn.cursor()
# tod=datetime.today().strftime('%Y-%m-%d')
# for item in itemslist:
# cur.execute('''
# REPlACE INTO PROD (dt,title, pid, jjim, sold,review) VALUES (?,?,?,?,?,?);''', (tod,item['name'],item['pid'] ,item['jjim'],item['sold'],item['review']))
sql=f"Select distinct dt from PROD3 where link like '{mall_url}%'"
cur.execute(sql)
conn.commit()
rows=cur.fetchall()
li=[]
for row in rows:
li.append(row[0])
# tod=datetime.today().strftime('%Y-%m-%d')
# if tod not in li:
# li.append(tod)
li.sort(reverse=True)
self.date_combo.clear()
self.date_combo.addItems(li)
# rs=self.updateProdList()
# print(rs)
cur.close()
conn.close()
# print(li)
def updateProdList(self):
self.tablewidget.clear()
self.tablewidget.setRowCount(300)
self.tablewidget.setColumnCount(6)
self.tablewidget.setItem(0,0,QTableWidgetItem("상품명"))
self.tablewidget.setItem(0,1,QTableWidgetItem("찜"))
self.tablewidget.setItem(0,2,QTableWidgetItem("구매"))
self.tablewidget.setItem(0,3,QTableWidgetItem("리뷰"))
self.tablewidget.setItem(0,4,QTableWidgetItem("LINK"))
# itemslist=all_items()
conn=sqlite3.connect('emaildb.sqlite')
cur=conn.cursor()
# tod=datetime.today().strftime('%Y-%m-%d')
tod=self.date_combo.currentText()
mall_url=self.farm_combo.currentText()
# for item in itemslist:
# cur.execute('''
# REPlACE INTO PROD (dt,title, pid, jjim, sold,review) VALUES (?,?,?,?,?,?);''', (tod,item['name'],item['pid'] ,item['jjim'],item['sold'],item['review']))
# cur.execute('''
# Select title, jjim, sold, review from PROD3 where dt='2020-04-14' order by sold desc ''')
# sql=f"Select title, jjim, sold, review,link from PROD3 where dt='{tod}' and link like '{self.farm_combo.currentText()}%'order by sold desc"
sql=f"Select title, jjim, sold, review,link from PROD3 where dt='{tod}' and link like '{mall_url}%' order by sold desc"
# print(sql)
cur.execute(sql)
conn.commit()
rows=cur.fetchall()
# print(rows[0])
for i,row in enumerate(rows):
# print(i, row[0])
for j, elem in enumerate(row):
# print(i+1,j,elem)
# self.tablewidget.setItem(i+1,j,QTableWidgetItem(elem))
self.tablewidget.setItem(i+1,j,QTableWidgetItem(str(row[j])))
# print(row[1])
# self.tablewidget.setItem(i+1,1,QTableWidgetItem(str(row[1])))
self.tablewidget.resizeColumnToContents(0)
cur.close()
conn.close()
return len(rows)
def get_prod(self):
url=self.farm_combo.currentText()
dt=self.date_combo.currentText()
self.tablewidget.clear()
self.updateProdList()
# print(url)
def setFarm(self,li):
self.farmlist=FarmList(self.li)
# print(self.li)
# self.farm_combo.addItems(self.li)
self.farmlist.show()
def show_farm_name(self):
'''스토어팜 주소를 콤보박스에서 변경시에 검색하여 스토어팜 이름 표시
date_combo도 변경함
'''
# self.shop_title_label.setText("sssss")
url=self.farm_combo.currentText()
req=requests.get(url)
soup=BeautifulSoup(req.text, 'html.parser')
self.shop_title_label.setText(soup.find('title').text.strip())
class Example(QWidget):
def __init__(self):
super().__init__()
self.hightingColor = QColor(255, 202, 0)
self.blueColor = QColor(0, 186, 255)
self.greenColor = QColor(0, 147, 44)
self.redColor = QColor(255, 0, 0)
self.setGeometry(100, 100, 1250, 800)
self.setWindowTitle('宝大爷神器')
self.show()
self.mainUI()
self.getUserInfo()
# self.clearUI()
# self.loginUI()
def mainUI(self):
self.box = QVBoxLayout()
self.box.setSpacing(5)
self.setLayout(self.box)
def dataUI(self):
self.box1 = QHBoxLayout()
self.code = QLabel('股票代码')
self.box1.addWidget(self.code)
self.codeEdit = QLineEdit()
self.codeEdit.setText('600519')
self.box1.addWidget(self.codeEdit)
self.year = QLabel('回报年限')
self.yearEdit = QComboBox()
for i in yearArr:
self.yearEdit.addItem(str(i))
self.yearEdit.setCurrentIndex(5)
self.box1.addWidget(self.year)
self.box1.addWidget(self.yearEdit)
# 同行年限
self.peerYear = QLabel('同行年限')
self.peerYearEdit = QComboBox()
for i in yearArr:
self.peerYearEdit.addItem(str(i))
self.peerYearEdit.setCurrentIndex(2)
self.box1.addWidget(self.peerYear)
self.box1.addWidget(self.peerYearEdit)
#开始日期
self.date = QLabel('开始日期')
self.box1.addWidget(self.date)
self.dateEdit = QDateEdit(QDate.currentDate().addDays(-365 * 10), self)
self.dateEdit.setCalendarPopup(True)
self.dateEdit.setDisplayFormat("yyyy-MM-dd")
self.box1.addWidget(self.dateEdit)
#结束日期
self.dateEnd = QLabel('结束日期')
self.box1.addWidget(self.dateEnd)
self.dateEditEnd = QDateEdit(QDate.currentDate(), self)
self.dateEditEnd.setCalendarPopup(True)
self.dateEditEnd.setDisplayFormat("yyyy-MM-dd")
self.box1.addWidget(self.dateEditEnd)
self.searchButton = QPushButton("估值")
self.searchButton.clicked.connect(self.searchEvent)
self.box1.addWidget(self.searchButton)
self.peerButton = QPushButton("同行对比")
self.peerButton.clicked.connect(self.searchPeerEvent)
self.box1.addWidget(self.peerButton)
self.box.addLayout(self.box1)
self.box2 = QHBoxLayout()
self.tips = QLabel('例子：以逗号隔开（000123,000333,000345）')
self.box2.addWidget(self.tips)
self.stockInfo = QLabel('')
self.box2.addWidget(self.stockInfo)
self.box.addLayout(self.box2)
self.table = QTableWidget(30, 15)
self.table.setStyleSheet(
"QHeaderView::section {background-color:#f3f3f3;color: black;padding-left: 4px;border: 1px dotted #dddddd;}"
)
# 设置表头字体，颜色，模式
self.box.addWidget(self.table)
self.tipsUI()
def loginUI(self):
self.username = QLabel('账号')
self.usernameEdit = QLineEdit()
self.password = QLabel('密码')
self.passwordEidt = QLineEdit()
self.okButton = QPushButton("登录")
self.grid = QGridLayout()
self.grid.addWidget(self.username, 1, 0)
self.grid.addWidget(self.usernameEdit, 1, 1)
self.grid.addWidget(self.password, 2, 0)
self.grid.addWidget(self.passwordEidt, 2, 1)
self.grid.addWidget(self.okButton, 3, 1)
self.box.addLayout(self.grid)
self.okButton.clicked.connect(self.loginEvent)
def tipsUI(self):
self.boxTips = QVBoxLayout()
self.boxTips.setSpacing(3)
self.box.addLayout(self.boxTips)
tipsData = [
'估值方法：', '小熊基本值=5年自由现金流之和/5年资本开支之和',
'回本年限默认10年，N=10+护城河（-1/0/1/2）+成长性（-1/0/1/2）',
'十年EBIT增长=(2003年EBIT-2012年EBIT)/2012年EBIT',
'有形资本汇报率ROIC=(净利润+税+利息)/(流动资产+固定资产+在建工程)=税前息利润EBIT/有形资产合计----------- >15%',
'理杏仁中的ROTA对应长投的ROIC,有形资产比他更加详细',
'EV/EQ=(总市值+有息负债-多余现金)/(流动资产+固定资产)=(总市值+有息负债-多余现金)/有形资产合计, EV/EQ=回报年限*ROIC',
'EV=总市值+有息负债-多余现金', '总市值：红色为高估，绿色为低估'
]
for item in tipsData:
self.boxTips.addWidget(QLabel(item))
def tableUI(self, jsonData):
self.table.clear()
colData = [{
'label': '财务费用(累计)',
'value': 'profitStatement-fe'
}, {
'label': '利润总额(累计)',
'value': 'profitStatement-tp'
}, {
'label': '流动资产合计(累计)',
'value': 'balanceSheet-tca'
}, {
'label': '固定资产(累计)',
'value': 'balanceSheet-fa'
}, {
'label': '在建工程(累计)',
'value': 'balanceSheet-cip'
}, {
'label': 'EBIT',
}, {
'label': '有形资产合计',
}, {
'label': 'ROIC',
}, {
'label': 'EBIT同比增长率',
}, {
'label': '经营活动产生的现金流量净额(累计)',
'value': 'cashFlow-ncffoa'
}, {
'label': '自由现金流量(累计)',
'value': 'metrics-fcf'
}, {
'label': '资本开支',
}, {
'label': '货币资金(累计)',
'value': 'balanceSheet-cabb'
}, {
'label': '有息负债(累计)',
'value': 'balanceSheet-lwi'
}, {
'label': '小熊基本值',
}, {
'label': '十年EBIT增长',
}, {
'label': 'ROIC平均值',
}, {
'label': '回报年限',
}, {
'label': 'EQ=有形资产合计',
}, {
'label': 'EV=EQ*(回本年限*ROIC)',
}, {
'label': '估值总市值',
}, {
'label': '当前总市值',
}, {
'label': '当前每股股价',
}, {
'label': '总股本',
}, {
'label': '估值每股股价',
}]
stockData = []
print(222222, jsonData)
for item in jsonData['fsMetricsList']:
stockData.append(item)
tableHeader = [] # 表头名字数据
tableColData = [] # 表列名字
self.table.setColumnCount(len(stockData))
self.table.setRowCount(len(colData))
print('roic数据的长度', len(stockData))
for index, item in enumerate(stockData):
tableHeader.append(item['date'].split('T')[0])
self.table.setColumnWidth(index, 170)
data = item['y']
for jIndex, jItem in enumerate(colData):
if ('value' in jItem):
attr = jItem['value'].split('-')
newItem = QTableWidgetItem(
str(data[attr[0]].get(attr[1], {'t': 0})['t']))
self.table.setItem(jIndex, index, newItem)
item[attr[1]] = data[attr[0]].get(
attr[1], {'t': 0})['t'] # 赋值最简值到该元素，方便后续的计算
elif jItem['label'] == 'EBIT':
# EBIT = 财务费用+利润总额
newItem = QTableWidgetItem('{:.2f}'.format(item['fe'] +
item['tp']))
newItem.setBackground(self.hightingColor)
self.table.setItem(jIndex, index, newItem)
item['EBIT'] = item['fe'] + item['tp']
elif jItem['label'] == '有形资产合计':
# 有形资产合计 = 流动资产合计+固定资产+在建工程
newItem = QTableWidgetItem(
'{:.2f}'.format(item['tca'] + item['fa'] +
item['cip']))
newItem.setBackground(self.hightingColor)
self.table.setItem(jIndex, index, newItem)
item['EQ'] = item['tca'] + item['fa'] + item['cip']
elif jItem['label'] == 'ROIC':
# ROIC = EBIT/有形资产合计
newItem = QTableWidgetItem(
str('{:.2%}'.format(item['EBIT'] / item['EQ'])))
newItem.setBackground(self.hightingColor)
self.table.setItem(jIndex, index, newItem)
item['ROIC'] = item['EBIT'] / item['EQ']
elif jItem['label'] == 'EBIT同比增长率':
if index != 0:
ebit = (stockData[index - 1]['EBIT'] -
item['EBIT']) / item['EBIT']
newItem = QTableWidgetItem('{:.2%}'.format(ebit))
newItem.setBackground(self.hightingColor)
self.table.setItem(jIndex, index - 1, newItem)
elif jItem['label'] == '资本开支':
# 资本开支 = 经营活动产生的现金流量净额-自由现金流量
newItem = QTableWidgetItem(
str(item['ncffoa'] - item['fcf']))
newItem.setBackground(self.hightingColor)
self.table.setItem(jIndex, index, newItem)
item['CAPEX'] = item['ncffoa'] + item['fcf']
calData = self.getCalData(stockData)
for index, item in enumerate(colData):
tableColData.append(item['label'])
if item['label'] == '小熊基本值':
newItem = QTableWidgetItem(calData['BaseValue'])
newItem.setBackground(self.blueColor)
self.table.setItem(index, 0, newItem)
elif item['label'] == '十年EBIT增长':
stockLen = len(stockData)
EBITValue = (stockData[0]['EBIT'] - stockData[stockLen - 1]['EBIT']) / \
stockData[stockLen - 1]['EBIT']
newItem = QTableWidgetItem(
str('{:.2f}'.format(EBITValue)) + '倍')
newItem.setBackground(self.blueColor)
self.table.setItem(index, 0, newItem)
elif item['label'] == 'ROIC平均值':
newItem = QTableWidgetItem(calData['ROICAVG'])
newItem.setBackground(self.blueColor)
self.table.setItem(index, 0, newItem)
elif item['label'] == 'EQ=有形资产合计':
newItem = QTableWidgetItem(str(calData['EQ']))
newItem.setBackground(self.blueColor)
self.table.setItem(index, 0, newItem)
elif item['label'] == '回报年限':
newItem = QTableWidgetItem(self.yearEdit.currentText())
newItem.setForeground(QBrush(QColor(255, 0, 0)))
self.table.setItem(index, 0, newItem)
elif item['label'] == 'EV=EQ*(回本年限*ROIC)':
yearRoic = int(self.yearEdit.currentText()) * float(
calData['ROICAVG'].strip('%')) / 100
global EV
EV = calData['EQ'] * yearRoic
newItem = QTableWidgetItem('{:.0f}'.format(EV))
newItem.setBackground(self.blueColor)
self.table.setItem(index, 0, newItem)
elif item['label'] == '估值总市值':
price = EV - calData['lwi'] + calData['cabb']
self.price_pre = price
newItem = QTableWidgetItem('{:.0f}'.format(price))
if price < calData['mc']:
newItem.setBackground(self.redColor)
else:
newItem.setBackground(self.greenColor)
self.table.setItem(index, 0, newItem)
elif item['label'] == '当前总市值':
price = calData['mc']
newItem = QTableWidgetItem(str(price))
self.table.setItem(index, 0, newItem)
elif item['label'] == '当前每股股价':
price = self.price_sp
newItem = QTableWidgetItem(str(price))
self.table.setItem(index, 0, newItem)
elif item['label'] == '总股本':
price = self.price_num
newItem = QTableWidgetItem(str(price))
self.table.setItem(index, 0, newItem)
elif item['label'] == '估值每股股价':
price = self.price_pre / self.price_num
newItem = QTableWidgetItem(str(price))
self.table.setItem(index, 0, newItem)
print(tableColData)
print(tableHeader)
self.table.setHorizontalHeaderLabels(tableHeader) # 设置表头数据
self.table.setVerticalHeaderLabels(tableColData) # 设置表列数据
# 同行对比表格
def peerTable(self, jsonData, stockIdArr):
self.table.clear()
colData = []
stockData = {}
for item in jsonData['fsMetricsList']:
id = item['stockId']
if (id in stockData):
stockData[id].append(item)
else:
stockData[id] = []
stockData[id].append(item)
tableHeader = [] # 表头名字数据
tableColData = [] # 表列名字
# 遍历股票代码数组，同行对比
idStrArr = self.stockIdArr
#遍历行表头 start
colData.append({'label': '归属母公司加权ROE'})
for jItem in idStrArr:
colData.append({
'label': self.stockNameData[jItem],
'value': 'ROE',
'id': int(jItem)
})
colData.append({
'label': str(len(idStrArr)) + '家均值',
'value': 'avg',
'type': 'ROE'
})
colData.append({'label': '归属母公司扣非ROE'})
for jItem in idStrArr:
colData.append({
'label': self.stockNameData[jItem],
'value': 'ROE_A',
'id': int(jItem)
})
colData.append({
'label': str(len(idStrArr)) + '家均值',
'value': 'avg',
'type': 'ROE_A'
})
colData.append({'label': 'ROIC'})
for jItem in idStrArr:
colData.append({
'label': self.stockNameData[jItem],
'value': 'ROIC',
'id': int(jItem)
})
colData.append({
'label': str(len(idStrArr)) + '家均值',
'value': 'avg',
'type': 'ROIC'
})
colData.append({'label': '毛利率GM'})
for jItem in idStrArr:
colData.append({
'label': self.stockNameData[jItem],
'value': 'GM',
'id': int(jItem)
})
colData.append({
'label': str(len(idStrArr)) + '家均值',
'value': 'avg',
'type': 'GM'
})
colData.append({'label': '净营业周期'})
for jItem in idStrArr:
colData.append({
'label': self.stockNameData[jItem],
'value': 'ROUND',
'id': int(jItem)
})
colData.append({
'label': str(len(idStrArr)) + '家均值',
'value': 'avg',
'type': 'ROUND'
})
colData.append({'label': '三费占比'})
for jItem in idStrArr:
colData.append({
'label': self.stockNameData[jItem],
'value': 'FEE',
'id': int(jItem)
})
colData.append({
'label': str(len(idStrArr)) + '家均值',
'value': 'avg',
'type': 'FEE'
})
# 遍历行表头 end
# 遍历表列名
for index, item in enumerate(colData):
tableColData.append(item['label'])
#找出行业数据中长度最小的，以防下面遍历出错
stockDataLen = []
for key in stockData:
stockDataLen.append(len(stockData[key]))
stockDataLen.sort()
print('找出行业数据中长度最小的，以防下面遍历出错%s' % stockDataLen[0])
# 平均值对象
avgData = {
'ROE': [],
'ROE_A': [],
'ROIC': [],
'GM': [],
'ROUND': [],
'FEE': []
}
year = int(self.peerYearEdit.currentText())
tablePerDataLen = stockDataLen[0] - 1 > year and year or stockDataLen[
0] - 1 # 净营业周期需要计算期初和期末，len-1
print('同行对比年数：', tablePerDataLen)
self.table.setColumnCount(tablePerDataLen + 1)
self.table.setRowCount(len(colData))
# 遍历表头,遍历表格内容,
for index in range(tablePerDataLen):
tableHeader.append(
stockData[stockIdArr[0]][index]['date'].split('T')[0])
self.table.setColumnWidth(index, 100)
for jIndex, jItem in enumerate(colData):
color = self.blueColor
if 'value' in jItem:
dItem = 'id' in jItem and stockData[jItem['id']] or {}
d = ''
if jItem['value'] == 'ROE':
d = dItem[index]['y']['metrics'].get('wroe',
{'t': 0})['t']
d = '{:.2%}'.format(d)
dItem[index]['ROE'] = d
elif jItem['value'] == 'ROE_A':
d = dItem[index]['y']['metrics'].get(
'roe_adnrpatoshaopc', {'t': 0})['t']
d = '{:.2%}'.format(d)
dItem[index]['ROE_A'] = d
elif jItem['value'] == 'ROIC':
d = dItem[index]['y']['metrics'].get('rota',
{'t': 0})['t']
d = '{:.2%}'.format(d)
dItem[index]['ROIC'] = d
elif jItem['value'] == 'GM':
d = dItem[index]['y']['profitStatement']['gp_m']['t']
d = '{:.2%}'.format(d)
dItem[index]['GM'] = d
elif jItem['value'] == 'ROUND':
# 净营业周期=存货周转天数+应收账款周转天数-应付账款周转天数
# 应收账款周转天数
arAvg = (dItem[index]['y']['balanceSheet']['ar']['t'] +
dItem[index +
1]['y']['balanceSheet']['ar']['t']) / 2
ar = arAvg > 0 and 360 / (
stockData[jItem['id']][index]['y']
['profitStatement']['oi']['t'] / arAvg) or 0
# 应付账款周转天数
apAvg = (dItem[index]['y']['balanceSheet']['ap']['t'] +
dItem[index +
1]['y']['balanceSheet']['ap']['t']) / 2
ap = apAvg > 0 and 360 / (
stockData[jItem['id']][index]['y']
['profitStatement']['oc']['t'] / apAvg) or 0
i_ds = stockData[
jItem['id']][index]['y']['metrics']['i_ds']['t']
d = i_ds + ar - ap
d = '{:.2f}'.format(d)
dItem[index]['ROUND'] = d
print(i_ds, ar, ap)
elif jItem['value'] == 'FEE':
d = stockData[jItem['id']][index]['y'][
'profitStatement']['te_r']['t']
d = '{:.2%}'.format(d)
dItem[index]['FEE'] = d
elif jItem['value'] == 'avg': #平均值
count = 0
for key in stockData:
v = stockData[key][index][jItem['type']]
vfloat = float('%' in v and v.strip('%') or v)
count += vfloat
d = count / len(stockData)
d = '%' in v and '{:.2%}'.format(
d / 100) or '{:.2f}'.format(d)
avgData[jItem['type']].append(d)
color = self.hightingColor
newItem = QTableWidgetItem(str(d))
newItem.setBackground(color)
self.table.setItem(jIndex, index, newItem)
#每一行求平均值
tableHeader.append('平均值')
for jIndex, jItem in enumerate(colData):
if 'value' in jItem:
d = 0
color = self.greenColor
for index in range(tablePerDataLen):
if jItem['value'] == 'avg': # 平均值
v = avgData[jItem['type']][index]
else:
v = stockData[jItem['id']][index][jItem['value']]
vfloat = float('%' in v and v.strip('%') or v)
d += vfloat
d = d / tablePerDataLen
d = '%' in v and '{:.2%}'.format(d / 100) or '{:.2f}'.format(d)
newItem = QTableWidgetItem(str(d))
newItem.setBackground(color)
self.table.setItem(jIndex, tablePerDataLen, newItem)
self.table.setHorizontalHeaderLabels(tableHeader) # 设置表头数据
self.table.setVerticalHeaderLabels(tableColData) # 设置表列数据
# 获取统计数据
def getCalData(self, data):
CAPEXSum = 0 # 5年资本开支之和
FCFSum = 0 # 5年自由现金流之和
ROICAVG = 0 # roic平均值
EQ = data[0]['EQ'] # 有形资产合计
lwi = data[0]['lwi'] # 有息负债
cabb = data[0]['cabb'] # 货币资金--多余现金
mc = self.price_mc # 总市值
for jIndex, jItem in enumerate(data):
if (jIndex < 5):
CAPEXSum += jItem['CAPEX']
FCFSum += jItem['fcf']
ROICAVG += jItem['ROIC']
return {
'BaseValue': '{:.2}'.format(FCFSum / CAPEXSum),
'ROICAVG': '{:.2%}'.format(ROICAVG / len(data)),
'EQ': EQ,
'lwi': lwi,
'cabb': cabb,
'mc': mc
}
def clearUI(self):
for i in range(self.box.count()):
boxChild = self.box.itemAt(i)
for j in range(boxChild.count()):
boxChild.itemAt(j).widget().deleteLater()
def getUserInfo(self):
self.clearUI()
res = requests.get("https://www.lixinger.com/api/user/users/current",
headers=Headers)
if res.status_code == 200:
self.dataUI()
else:
self.loginUI()
def loginEvent(self):
data = {
'uniqueName': self.usernameEdit.text(),
'password': self.passwordEidt.text()
} # 用户信息
res = requests.post("https://www.lixinger.com/api/login/by-account",
data)
if res.status_code == 200:
m_cookie = res.headers["Set-Cookie"].split(';')[0]
Headers["Cookie"] = m_cookie
f = open(cookieFilename, 'w')
f.write(m_cookie)
print(Headers["Cookie"])
self.getUserInfo()
else:
print("登录连接不成功%s" % (res.status_code))
# 查询按钮事件
def searchEvent(self, type):
self.getStockInfo()
self.getROICData()
def searchPeerEvent(self, type):
self.getStockInfo()
self.getPeerData()
# 获取股票的详细信息
def getStockInfo(self):
arr = self.codeEdit.text().split(',')
self.stockIdArr = []
detailStr = ''
noSearchId = []
self.stockNameData = {}
for item in arr:
url = 'https://www.lixinger.com/api/stock/stocks/stock/'
if '60' == item[0:2]:
url += 'sh/' + item + '/' + item
else:
url += 'sz/' + item + '/' + item
res = requests.get(url, headers=Headers)
if res.status_code == 200:
data = json.loads(res.text)
self.stockIdArr.append(item)
detailStr += item + ': ' + data['name'] + ' '
self.stockNameData[item] = data['name']
self.price_mc = data['priceMetrics']['mc'] #当前总市值
self.price_sp = data['priceMetrics']['sp'] #每股股价
self.price_num = data['priceMetrics']['mc'] / data[
'priceMetrics']['sp'] #股本
elif res.status_code == 401:
self.loginEvent()
else:
print('没有' + item + '股票')
noSearchId.append(item)
print(noSearchId)
if len(noSearchId) > 0:
noSearchStr = ','.join(noSearchId)
detailStr += '(没有找到股票：' + noSearchStr + ')'
self.stockInfo.setText(detailStr)
print(self.stockNameData)
print(self.stockIdArr)
# 获取roic数据
def getROICData(self):
if len(self.stockIdArr) > 0:
print(self.dateEdit.text(), self.dateEditEnd.text())
p = {
"stockIds": [int(self.stockIdArr[0])],
"startDate":
self.dateEdit.text(),
"endDate":
self.dateEditEnd.text(),
"granularities": ["y"],
"metricNames": [
"profitStatement.fe", "profitStatement.tp",
"balanceSheet.tca", "balanceSheet.fa", "balanceSheet.cip",
"balanceSheet.cabb", "balanceSheet.lwi", "cashFlow.ncffoa",
"metrics.fcf"
],
"expressionCaculateTypes": [
"t", "t_o", "t_y2y", "t_c2c", "c", "c_o", "c_y2y", "c_c2c",
"c_2y", "ttm", "ttm_y2y", "ttm_c2c"
]
}
r = requests.post(
'https://www.lixinger.com/api/analyt/company/fs-metrics/list-info',
json=p,
headers=Headers)
if r.status_code == 200:
self.tableUI(json.loads(r.text))
elif r.status_code == 401:
self.loginEvent()
# 获取同行数据
def getPeerData(self):
idsArr = []
time = datetime.datetime.strptime(self.dateEdit.text(),
"%Y-%m-%d").date()
dateStart = time + datetime.timedelta(days=-365)
for val in self.stockIdArr:
idsArr.append(int(val))
p = {
"stockIds":
idsArr,
"startDate":
str(dateStart),
"endDate":
self.dateEditEnd.text(),
"granularities": ["y"],
"metricNames": [
"profitStatement.gp_m", "profitStatement.te_r",
"profitStatement.oi", "profitStatement.oc", "metrics.wroe",
"metrics.roe_adnrpatoshaopc", "metrics.rota", "metrics.i_ds",
"balanceSheet.ar", "balanceSheet.ap"
],
"expressionCaculateTypes": [
"t", "t_o", "t_y2y", "t_c2c", "c", "c_o", "c_y2y", "c_c2c",
"c_2y", "ttm", "ttm_y2y", "ttm_c2c"
]
}
r = requests.post(
'https://www.lixinger.com/api/analyt/company/fs-metrics/list-info',
json=p,
headers=Headers)
if r.status_code == 200:
self.peerTable(json.loads(r.text), idsArr)
elif r.status_code == 401:
self.loginEvent()
class OWdabam_height_profile(OWWidget):
name = "DABAM Height Profile"
id = "dabam_height_profile"
description = "Calculation of mirror surface error profile"
icon = "icons/dabam.png"
author = "Luca Rebuffi"
maintainer_email = "[email protected]; [email protected]"
priority = 2
category = ""
keywords = ["dabam_height_profile"]
outputs = [{
"name": "PreInput",
"type": WiserPreInputData,
"doc": "PreInput",
"id": "PreInput"
}]
want_main_area = 1
want_control_area = 1
MAX_WIDTH = 1320
MAX_HEIGHT = 700
IMAGE_WIDTH = 860
IMAGE_HEIGHT = 645
CONTROL_AREA_WIDTH = 405
TABS_AREA_HEIGHT = 618
xx = None
yy = None
entry_number = Setting(1)
shape = Setting(0)
slope_error_from = Setting(0.0)
slope_error_to = Setting(1.5)
dimension_y_from = Setting(0.0)
dimension_y_to = Setting(200.0)
use_undetrended = Setting(0)
center_y = Setting(1)
modify_y = Setting(0)
new_length = Setting(200.0)
filler_value = Setting(0.0)
renormalize_y = Setting(1)
error_type_y = Setting(0)
rms_y = Setting(0.9)
dabam_profile_index = Setting(1)
heigth_profile_file_name = Setting('mirror.dat')
tab = []
def __init__(self):
super().__init__()
self.runaction = widget.OWAction("Calculate Height Profile", self)
self.runaction.triggered.connect(self.calculate_heigth_profile_ni)
self.addAction(self.runaction)
self.runaction = widget.OWAction("Generate Height Profile File", self)
self.runaction.triggered.connect(self.generate_heigth_profile_file_ni)
self.addAction(self.runaction)
geom = QApplication.desktop().availableGeometry()
self.setGeometry(
QRect(round(geom.width() * 0.05), round(geom.height() * 0.05),
round(min(geom.width() * 0.98, self.MAX_WIDTH)),
round(min(geom.height() * 0.95, self.MAX_HEIGHT))))
self.setMaximumHeight(self.geometry().height())
self.setMaximumWidth(self.geometry().width())
# DABAM INITIALIZATION
self.server = dabam.dabam()
self.server.set_input_silent(True)
gui.separator(self.controlArea)
button_box = oasysgui.widgetBox(self.controlArea,
"",
addSpace=False,
orientation="horizontal")
button = gui.button(button_box,
self,
"Calculate Height\nProfile",
callback=self.calculate_heigth_profile)
button.setFixedHeight(45)
button = gui.button(button_box,
self,
"Generate Height\nProfile File",
callback=self.generate_heigth_profile_file)
font = QFont(button.font())
font.setBold(True)
button.setFont(font)
palette = QPalette(button.palette()) # make a copy of the palette
palette.setColor(QPalette.ButtonText, QColor('Dark Blue'))
button.setPalette(palette) # assign new palette
button.setFixedHeight(45)
button.setFixedWidth(150)
button = gui.button(button_box,
self,
"Reset Fields",
callback=self.call_reset_settings)
font = QFont(button.font())
font.setItalic(True)
button.setFont(font)
palette = QPalette(button.palette()) # make a copy of the palette
palette.setColor(QPalette.ButtonText, QColor('Dark Red'))
button.setPalette(palette) # assign new palette
button.setFixedHeight(45)
gui.separator(self.controlArea)
tabs_setting = oasysgui.tabWidget(self.controlArea)
tabs_setting.setFixedHeight(self.TABS_AREA_HEIGHT)
tabs_setting.setFixedWidth(self.CONTROL_AREA_WIDTH - 5)
tab_input = oasysgui.createTabPage(tabs_setting,
"DABAM Search Setting")
tab_gener = oasysgui.createTabPage(tabs_setting,
"DABAM Generation Setting")
tab_out = oasysgui.createTabPage(tabs_setting, "Output")
manual_box = oasysgui.widgetBox(tab_input,
"Manual Entry",
addSpace=True,
orientation="vertical")
oasysgui.lineEdit(manual_box,
self,
"entry_number",
"Entry Number",
labelWidth=300,
valueType=int,
orientation="horizontal")
gui.separator(manual_box)
button = gui.button(manual_box,
self,
"Retrieve Profile",
callback=self.retrieve_profile)
button.setFixedHeight(35)
button.setFixedWidth(self.CONTROL_AREA_WIDTH - 35)
input_box = oasysgui.widgetBox(tab_input,
"Search Parameters",
addSpace=True,
orientation="vertical")
gui.comboBox(input_box,
self,
"shape",
label="Mirror Shape",
labelWidth=300,
items=[
"All", "Plane", "Cylindrical", "Elliptical",
"Toroidal", "Spherical"
],
sendSelectedValue=False,
orientation="horizontal")
gui.separator(input_box)
input_box_1 = oasysgui.widgetBox(input_box,
"",
addSpace=True,
orientation="horizontal")
oasysgui.lineEdit(input_box_1,
self,
"slope_error_from",
"Slope Error From (" + u"\u03BC" + "rad)",
labelWidth=150,
valueType=float,
orientation="horizontal")
oasysgui.lineEdit(input_box_1,
self,
"slope_error_to",
"To (" + u"\u03BC" + "rad)",
labelWidth=60,
valueType=float,
orientation="horizontal")
input_box_2 = oasysgui.widgetBox(input_box,
"",
addSpace=True,
orientation="horizontal")
self.le_dimension_y_from = oasysgui.lineEdit(input_box_2,
self,
"dimension_y_from",
"Mirror Length From",
labelWidth=150,
valueType=float,
orientation="horizontal")
self.le_dimension_y_to = oasysgui.lineEdit(input_box_2,
self,
"dimension_y_to",
"To",
labelWidth=60,
valueType=float,
orientation="horizontal")
table_box = oasysgui.widgetBox(tab_input,
"Search Results",
addSpace=True,
orientation="vertical",
height=250)
self.overlay_search = Overlay(table_box, self.search_profiles)
self.overlay_search.hide()
button = gui.button(input_box,
self,
"Search",
callback=self.overlay_search.show)
button.setFixedHeight(35)
button.setFixedWidth(self.CONTROL_AREA_WIDTH - 35)
gui.comboBox(table_box,
self,
"use_undetrended",
label="Use Undetrended Profile",
labelWidth=300,
items=["No", "Yes"],
callback=self.table_item_clicked,
sendSelectedValue=False,
orientation="horizontal")
gui.separator(table_box)
self.scrollarea = QScrollArea()
self.scrollarea.setMinimumWidth(self.CONTROL_AREA_WIDTH - 35)
table_box.layout().addWidget(self.scrollarea,
alignment=Qt.AlignHCenter)
self.table = QTableWidget(1, 5)
self.table.setStyleSheet("background-color: #FBFBFB;")
self.table.setAlternatingRowColors(True)
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Fixed)
self.table.verticalHeader().setVisible(False)
self.table.setColumnWidth(0, 40)
self.table.setColumnWidth(1, 70)
self.table.setColumnWidth(2, 70)
self.table.setColumnWidth(3, 85)
self.table.setColumnWidth(4, 80)
self.table.resizeRowsToContents()
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.itemClicked.connect(self.table_item_clicked)
self.scrollarea.setWidget(self.table)
self.scrollarea.setWidgetResizable(1)
output_profile_box = oasysgui.widgetBox(
tab_gener,
"Surface Generation Parameters",
addSpace=True,
orientation="vertical",
height=370)
gui.comboBox(output_profile_box,
self,
"center_y",
label="Center Profile in the middle of O.E.",
labelWidth=300,
items=["No", "Yes"],
sendSelectedValue=False,
orientation="horizontal")
gui.separator(output_profile_box)
gui.comboBox(output_profile_box,
self,
"modify_y",
label="Modify Length?",
labelWidth=150,
items=[
"No", "Rescale to new length",
"Fit to new length (fill or cut)"
],
callback=self.set_ModifyY,
sendSelectedValue=False,
orientation="horizontal")
self.modify_box_1 = oasysgui.widgetBox(output_profile_box,
"",
addSpace=False,
orientation="vertical",
height=60)
self.modify_box_2 = oasysgui.widgetBox(output_profile_box,
"",
addSpace=False,
orientation="vertical",
height=60)
self.le_new_length_1 = oasysgui.lineEdit(self.modify_box_2,
self,
"new_length",
"New Length",
labelWidth=300,
valueType=float,
orientation="horizontal")
self.modify_box_3 = oasysgui.widgetBox(output_profile_box,
"",
addSpace=False,
orientation="vertical",
height=60)
self.le_new_length_2 = oasysgui.lineEdit(self.modify_box_3,
self,
"new_length",
"New Length",
labelWidth=300,
valueType=float,
orientation="horizontal")
oasysgui.lineEdit(self.modify_box_3,
self,
"filler_value",
"Filler Value (if new length > profile length) [nm]",
labelWidth=300,
valueType=float,
orientation="horizontal")
self.set_ModifyY()
gui.comboBox(output_profile_box,
self,
"renormalize_y",
label="Renormalize Length Profile to different RMS",
labelWidth=300,
items=["No", "Yes"],
callback=self.set_RenormalizeY,
sendSelectedValue=False,
orientation="horizontal")
self.output_profile_box_1 = oasysgui.widgetBox(output_profile_box,
"",
addSpace=False,
orientation="vertical",
height=60)
self.output_profile_box_2 = oasysgui.widgetBox(output_profile_box,
"",
addSpace=False,
orientation="vertical",
height=60)
gui.comboBox(
self.output_profile_box_1,
self,
"error_type_y",
label="Normalization to",
labelWidth=270,
items=["Figure Error (nm)", "Slope Error (" + u"\u03BC" + "rad)"],
sendSelectedValue=False,
orientation="horizontal")
oasysgui.lineEdit(self.output_profile_box_1,
self,
"rms_y",
"Rms Value",
labelWidth=300,
valueType=float,
orientation="horizontal")
self.set_RenormalizeY()
output_box = oasysgui.widgetBox(tab_gener,
"Outputs",
addSpace=True,
orientation="vertical")
select_file_box = oasysgui.widgetBox(output_box,
"",
addSpace=True,
orientation="horizontal")
self.le_heigth_profile_file_name = oasysgui.lineEdit(
select_file_box,
self,
"heigth_profile_file_name",
"Output File Name",
labelWidth=120,
valueType=str,
orientation="horizontal")
gui.button(select_file_box, self, "...", callback=self.selectFile)
self.shadow_output = oasysgui.textArea(height=400)
out_box = oasysgui.widgetBox(tab_out,
"System Output",
addSpace=True,
orientation="horizontal",
height=500)
out_box.layout().addWidget(self.shadow_output)
gui.rubber(self.controlArea)
self.initializeTabs()
gui.rubber(self.mainArea)
self.overlay_search.raise_()
def resizeEvent(self, event):
self.overlay_search.resize(self.CONTROL_AREA_WIDTH - 15, 290)
event.accept()
def after_change_workspace_units(self):
self.si_to_user_units = 1e2 / self.workspace_units_to_cm
self.horHeaders = [
"Entry", "Shape", "Length\n[" + self.workspace_units_label + "]",
"Heights St.Dev.\n[nm]", "Slopes St.Dev.\n[" + u"\u03BC" + "rad]"
]
self.table.setHorizontalHeaderLabels(self.horHeaders)
self.plot_canvas[0].setGraphXLabel("Y [" + self.workspace_units_label +
"]")
self.plot_canvas[1].setGraphXLabel("Y [" + self.workspace_units_label +
"]")
self.plot_canvas[5].setGraphXLabel("Y [" + self.workspace_units_label +
"]")
label = self.le_dimension_y_from.parent().layout().itemAt(0).widget()
label.setText(label.text() + " [" + self.workspace_units_label + "]")
label = self.le_dimension_y_to.parent().layout().itemAt(0).widget()
label.setText(label.text() + " [" + self.workspace_units_label + "]")
label = self.le_new_length_1.parent().layout().itemAt(0).widget()
label.setText(label.text() + " [" + self.workspace_units_label + "]")
label = self.le_new_length_2.parent().layout().itemAt(0).widget()
label.setText(label.text() + " [" + self.workspace_units_label + "]")
def initializeTabs(self):
self.tabs = oasysgui.tabWidget(self.mainArea)
self.tab = [
oasysgui.createTabPage(self.tabs, "Info"),
oasysgui.createTabPage(self.tabs, "Heights Profile"),
oasysgui.createTabPage(self.tabs, "Slopes Profile"),
oasysgui.createTabPage(self.tabs, "PSD Heights"),
oasysgui.createTabPage(self.tabs, "CSD Heights"),
oasysgui.createTabPage(self.tabs, "ACF"),
oasysgui.createTabPage(self.tabs, "Generated 1D Profile"),
]
for tab in self.tab:
tab.setFixedHeight(self.IMAGE_HEIGHT)
tab.setFixedWidth(self.IMAGE_WIDTH)
self.plot_canvas = [None, None, None, None, None, None]
self.plot_canvas[0] = oasysgui.plotWindow(roi=False,
control=False,
position=True)
self.plot_canvas[0].setDefaultPlotLines(True)
self.plot_canvas[0].setActiveCurveColor(color='blue')
self.plot_canvas[0].setGraphYLabel("Z [nm]")
self.plot_canvas[0].setGraphTitle("Heights Profile")
self.plot_canvas[0].setInteractiveMode(mode='zoom')
self.plot_canvas[1] = oasysgui.plotWindow(roi=False,
control=False,
position=True)
self.plot_canvas[1].setDefaultPlotLines(True)
self.plot_canvas[1].setActiveCurveColor(color='blue')
self.plot_canvas[1].setGraphYLabel("Zp [$\mu$rad]")
self.plot_canvas[1].setGraphTitle("Slopes Profile")
self.plot_canvas[1].setInteractiveMode(mode='zoom')
self.plot_canvas[2] = oasysgui.plotWindow(roi=False,
control=False,
position=True)
self.plot_canvas[2].setDefaultPlotLines(True)
self.plot_canvas[2].setActiveCurveColor(color='blue')
self.plot_canvas[2].setGraphXLabel("f [m^-1]")
self.plot_canvas[2].setGraphYLabel("PSD [m^3]")
self.plot_canvas[2].setGraphTitle(
"Power Spectral Density of Heights Profile")
self.plot_canvas[2].setInteractiveMode(mode='zoom')
self.plot_canvas[2].setXAxisLogarithmic(True)
self.plot_canvas[2].setYAxisLogarithmic(True)
self.plot_canvas[3] = oasysgui.plotWindow(roi=False,
control=False,
position=True)
self.plot_canvas[3].setDefaultPlotLines(True)
self.plot_canvas[3].setActiveCurveColor(color='blue')
self.plot_canvas[3].setGraphXLabel("f [m^-1]")
self.plot_canvas[3].setGraphYLabel("CSD [m^3]")
self.plot_canvas[3].setGraphTitle(
"Cumulative Spectral Density of Heights Profile")
self.plot_canvas[3].setInteractiveMode(mode='zoom')
self.plot_canvas[3].setXAxisLogarithmic(True)
self.plot_canvas[4] = oasysgui.plotWindow(roi=False,
control=False,
position=True)
self.plot_canvas[4].setDefaultPlotLines(True)
self.plot_canvas[4].setActiveCurveColor(color='blue')
self.plot_canvas[4].setGraphXLabel("Length [m]")
self.plot_canvas[4].setGraphYLabel("ACF")
self.plot_canvas[4].setGraphTitle(
"Autocovariance Function of Heights Profile")
self.plot_canvas[4].setInteractiveMode(mode='zoom')
self.plot_canvas[5] = oasysgui.plotWindow(roi=False,
control=False,
position=True)
self.plot_canvas[5].setDefaultPlotLines(True)
self.plot_canvas[5].setActiveCurveColor(color='blue')
self.plot_canvas[5].setGraphYLabel("Z [nm]")
self.plot_canvas[5].setGraphTitle("Heights Profile")
self.plot_canvas[5].setInteractiveMode(mode='zoom')
self.profileInfo = oasysgui.textArea(height=self.IMAGE_HEIGHT - 5,
width=400)
profile_box = oasysgui.widgetBox(self.tab[0],
"",
addSpace=True,
orientation="horizontal",
height=self.IMAGE_HEIGHT,
width=410)
profile_box.layout().addWidget(self.profileInfo)
for index in range(0, 6):
self.tab[index + 1].layout().addWidget(self.plot_canvas[index])
self.tabs.setCurrentIndex(1)
def plot_dabam_graph(self,
plot_canvas_index,
curve_name,
x_values,
y_values,
xtitle,
ytitle,
title="",
color='blue',
replace=True):
self.plot_canvas[plot_canvas_index].addCurve(
x_values,
y_values,
curve_name,
symbol='',
color=color,
replace=replace) #'+', '^', ','
self.plot_canvas[plot_canvas_index].setGraphTitle(title)
self.plot_canvas[plot_canvas_index].setGraphXLabel(xtitle)
self.plot_canvas[plot_canvas_index].setGraphYLabel(ytitle)
self.plot_canvas[plot_canvas_index].replot()
def set_ModifyY(self):
self.modify_box_1.setVisible(self.modify_y == 0)
self.modify_box_2.setVisible(self.modify_y == 1)
self.modify_box_3.setVisible(self.modify_y == 2)
def set_RenormalizeY(self):
self.output_profile_box_1.setVisible(self.renormalize_y == 1)
def table_item_clicked(self):
if self.table.selectionModel().hasSelection():
if not self.table.rowCount() == 0:
if not self.table.item(0, 0) is None:
row = self.table.selectionModel().selectedRows()[0].row()
self.entry_number = int(self.table.item(row, 0).text())
self.retrieve_profile()
def retrieve_profile(self):
try:
if self.entry_number is None or self.entry_number <= 0:
raise Exception(
"Entry number should be a strictly positive integer number"
)
self.server.load(self.entry_number)
self.profileInfo.setText(self.server.info_profiles())
title0 = "Heights Profile. St.Dev.=%.3f nm" % (
self.server.stdev_profile_heights() * 1e9)
title1 = "Slopes Profile. St.Dev.=%.3f $\mu$rad" % (
self.server.stdev_profile_slopes() * 1e6)
if self.use_undetrended == 0:
self.plot_dabam_graph(0,
"heights_profile",
self.si_to_user_units * self.server.y,
1e9 * self.server.zHeights,
"Y [" + self.workspace_units_label + "]",
"Z [nm]",
title=title0)
self.plot_dabam_graph(1,
"slopes_profile",
self.si_to_user_units * self.server.y,
1e6 * self.server.zSlopes,
"Y [" + self.workspace_units_label + "]",
"Zp [$\mu$rad]",
title=title1)
else:
self.plot_dabam_graph(0,
"heights_profile",
self.si_to_user_units * self.server.y,
1e9 * self.server.zHeightsUndetrended,
"Y [" + self.workspace_units_label + "]",
"Z [nm]",
title=title0)
self.plot_dabam_graph(1,
"slopes_profile",
self.si_to_user_units * self.server.y,
1e6 * self.server.zSlopesUndetrended,
"Y [" + self.workspace_units_label + "]",
"Zp [$\mu$rad]",
title=title1)
y = self.server.f**(self.server.powerlaw["hgt_pendent"]
) * 10**self.server.powerlaw["hgt_shift"]
i0 = self.server.powerlaw["index_from"]
i1 = self.server.powerlaw["index_to"]
beta = -self.server.powerlaw["hgt_pendent"]
self.plot_dabam_graph(
2,
"psd_heights_2",
self.server.f,
self.server.psdHeights,
"f [m^-1]",
"PSD [m^3]",
title=
"Power Spectral Density of Heights Profile (beta=%.2f,Df=%.2f)"
% (beta, (5 - beta) / 2))
self.plot_dabam_graph(2,
"psd_heights_1",
self.server.f,
y,
"f [m^-1]",
"PSD [m^3]",
color='green',
replace=False)
self.plot_dabam_graph(2,
"psd_heights_3",
self.server.f[i0:i1],
y[i0:i1],
"f [m^-1]",
"PSD [m^3]",
color='red',
replace=False)
self.plot_dabam_graph(3, "csd", self.server.f,
self.server.csd_heights(), "f [m^-1]",
"CSD [m^3]")
c1, c2, c3 = dabam.autocorrelationfunction(self.server.y,
self.server.zHeights)
self.plot_dabam_graph(
4,
"acf",
c1[0:-1],
c2,
"Length [m]",
"Heights Autocovariance",
title=
"Autocovariance Function of Heights Profile.\nAutocorrelation Length (ACF=0.5)=%.3f m"
% (c3))
# surface error removal
if not self.yy is None and not self.xx is None:
self.xx = None
self.yy = None
self.plot_dabam_graph(5, "heights_profile_generated",
numpy.zeros(1), numpy.zeros(1),
"Y [" + self.workspace_units_label + "]",
"Z [nm]")
if (self.tabs.currentIndex() == 6): self.tabs.setCurrentIndex(1)
except Exception as exception:
QMessageBox.critical(self, "Error", exception.args[0],
QMessageBox.Ok)
#raise exception
def search_profiles(self):
try:
self.table.itemClicked.disconnect(self.table_item_clicked)
self.table.clear()
row_count = self.table.rowCount()
for n in range(0, row_count):
self.table.removeRow(0)
self.table.setHorizontalHeaderLabels(self.horHeaders)
profiles = dabam.dabam_summary_dictionary(
surface=self.get_dabam_shape(),
slp_err_from=self.slope_error_from * 1e-6,
slp_err_to=self.slope_error_to * 1e-6,
length_from=self.dimension_y_from / self.si_to_user_units,
length_to=self.dimension_y_to / self.si_to_user_units)
for index in range(0, len(profiles)):
self.table.insertRow(0)
for index in range(0, len(profiles)):
table_item = QTableWidgetItem(str(profiles[index]["entry"]))
table_item.setTextAlignment(Qt.AlignCenter)
self.table.setItem(index, 0, table_item)
table_item = QTableWidgetItem(str(profiles[index]["surface"]))
table_item.setTextAlignment(Qt.AlignLeft)
self.table.setItem(index, 1, table_item)
table_item = QTableWidgetItem(
str(
numpy.round(
profiles[index]["length"] * self.si_to_user_units,
3)))
table_item.setTextAlignment(Qt.AlignRight)
self.table.setItem(index, 2, table_item)
table_item = QTableWidgetItem(
str(numpy.round(profiles[index]["hgt_err"] * 1e9, 3)))
table_item.setTextAlignment(Qt.AlignRight)
self.table.setItem(index, 3, table_item)
table_item = QTableWidgetItem(
str(numpy.round(profiles[index]["slp_err"] * 1e6, 3)))
table_item.setTextAlignment(Qt.AlignRight)
self.table.setItem(index, 4, table_item)
self.table.setHorizontalHeaderLabels(self.horHeaders)
self.table.resizeRowsToContents()
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.itemClicked.connect(self.table_item_clicked)
self.overlay_search.hide()
except Exception as exception:
self.overlay_search.hide()
QMessageBox.critical(self, "Error", exception.args[0],
QMessageBox.Ok)
def get_dabam_shape(self):
if self.shape == 0: return None
elif self.shape == 1: return "plane"
elif self.shape == 2: return "cylindrical"
elif self.shape == 3: return "elliptical"
elif self.shape == 4: return "toroidal"
elif self.shape == 5: return "spherical"
def calculate_heigth_profile_ni(self):
self.calculate_heigth_profile(not_interactive_mode=True)
def calculate_heigth_profile(self, not_interactive_mode=False):
import matplotlib
print(matplotlib.__version__)
try:
if self.server.y is None: raise Exception("No Profile Selected")
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
self.check_fields()
# PREVENTS CRASH WITH PYQT5
if not not_interactive_mode: self.tabs.setCurrentIndex(6)
if self.modify_y == 2:
profile_1D_y_x_temp = self.si_to_user_units * self.server.y
if self.use_undetrended == 0:
profile_1D_y_y_temp = self.si_to_user_units * self.server.zHeights
else:
profile_1D_y_y_temp = self.si_to_user_units * self.server.zHeightsUndetrended
first_coord = profile_1D_y_x_temp[0]
second_coord = profile_1D_y_x_temp[1]
last_coord = profile_1D_y_x_temp[-1]
step = numpy.abs(second_coord - first_coord)
length = numpy.abs(last_coord - first_coord)
n_points_old = len(profile_1D_y_x_temp)
if self.new_length > length:
difference = self.new_length - length
n_added_points = int(difference / step)
if difference % step == 0:
n_added_points += 1
if n_added_points % 2 != 0:
n_added_points += 1
profile_1D_y_x = numpy.arange(n_added_points +
n_points_old) * step
profile_1D_y_y = numpy.ones(
n_added_points + n_points_old
) * self.filler_value * 1e-9 * self.si_to_user_units
profile_1D_y_y[int(n_added_points / 2):n_points_old +
int(n_added_points /
2)] = profile_1D_y_y_temp
elif self.new_length < length:
difference = length - self.new_length
n_removed_points = int(difference / step)
if difference % step == 0:
n_removed_points -= 1
if n_removed_points % 2 != 0:
n_removed_points -= 1
if n_removed_points >= 2:
profile_1D_y_x = profile_1D_y_x_temp[0:(
n_points_old - n_removed_points)]
profile_1D_y_y = profile_1D_y_y_temp[(
int(n_removed_points / 2) -
1):(n_points_old - int(n_removed_points / 2) - 1)]
else:
profile_1D_y_x = profile_1D_y_x_temp
profile_1D_y_y = profile_1D_y_y_temp
else:
profile_1D_y_x = profile_1D_y_x_temp
profile_1D_y_y = profile_1D_y_y_temp
else:
if self.modify_y == 0:
profile_1D_y_x = self.si_to_user_units * self.server.y
elif self.modify_y == 1:
scale_factor_y = self.new_length / (
self.si_to_user_units *
(max(self.server.y) - min(self.server.y)))
profile_1D_y_x = self.si_to_user_units * self.server.y * scale_factor_y
if self.use_undetrended == 0:
profile_1D_y_y = self.si_to_user_units * self.server.zHeights
else:
profile_1D_y_y = self.si_to_user_units * self.server.zHeightsUndetrended
if self.center_y:
first_coord = profile_1D_y_x[0]
last_coord = profile_1D_y_x[-1]
length = numpy.abs(last_coord - first_coord)
profile_1D_y_x_temp = numpy.linspace(-length / 2, length / 2,
len(profile_1D_y_x))
profile_1D_y_x = profile_1D_y_x_temp
if self.renormalize_y == 0:
rms_y = None
else:
if self.error_type_y == profiles_simulation.FIGURE_ERROR:
rms_y = self.si_to_user_units * self.rms_y * 1e-9 # from nm to user units
profile_1D_y_y = profile_1D_y_y / profile_1D_y_y.std(
) * rms_y
else:
rms_y = self.rms_y * 1e-6 # from urad to rad
yslopes = numpy.gradient(
profile_1D_y_y, profile_1D_y_x[1] - profile_1D_y_x[0])
profile_1D_y_y = profile_1D_y_y / yslopes.std() * rms_y
self.xx = profile_1D_y_x
self.yy = profile_1D_y_y
x_to_plot = self.xx
y_to_plot = self.yy * 1e9 / self.si_to_user_units
ny = len(self.yy)
slope = numpy.zeros(ny)
for i in range(ny - 1):
step = self.xx[i + 1] - self.xx[i]
slope[i] = numpy.arctan((self.yy[i + 1] - self.yy[i]) / step)
slope[ny - 1] = slope[ny - 2]
title = ' Slope error rms : %f $\mu$rad' % (slope.std() * 1e6) + '\n' + \
' Figure error rms : %f nm' % (round(self.yy.std()* 1e9 / self.si_to_user_units, 6))
self.plot_dabam_graph(5,
"heights_profile_generated",
x_to_plot,
y_to_plot,
"Y [" + self.workspace_units_label + "]",
"Z [nm]",
title=title)
if not not_interactive_mode:
QMessageBox.information(
self, "QMessageBox.information()",
"Height Profile calculated: if the result is satisfactory,\nclick \'Generate Height Profile File\' to complete the operation ",
QMessageBox.Ok)
except Exception as exception:
QMessageBox.critical(self, "Error", exception.args[0],
QMessageBox.Ok)
#raise exception
def generate_heigth_profile_file_ni(self):
self.generate_heigth_profile_file(not_interactive_mode=True)
def generate_heigth_profile_file(self, not_interactive_mode=False):
if not self.yy is None and not self.xx is None:
try:
congruence.checkDir(self.heigth_profile_file_name)
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
numpy.savetxt(self.heigth_profile_file_name, self.yy)
QMessageBox.information(
self, "QMessageBox.information()", "Height Profile file " +
self.heigth_profile_file_name + " written on disk",
QMessageBox.Ok)
self.send(
"PreInput",
WiserPreInputData(
figure_error_file=self.heigth_profile_file_name,
figure_error_step=numpy.abs(self.xx[1] - self.xx[0]),
figure_user_units_to_m=self.workspace_units_to_m))
except Exception as exception:
QMessageBox.critical(self, "Error", exception.args[0],
QMessageBox.Ok)
def call_reset_settings(self):
if ConfirmDialog.confirmed(parent=self,
message="Confirm Reset of the Fields?"):
try:
self.resetSettings()
except:
pass
def check_fields(self):
if self.modify_y == 1 or self.modify_y == 2:
self.new_length = congruence.checkStrictlyPositiveNumber(
self.new_length, "New Length")
if self.renormalize_y == 1:
self.rms_y = congruence.checkPositiveNumber(self.rms_y, "Rms Y")
congruence.checkDir(self.heigth_profile_file_name)
def writeStdOut(self, text):
cursor = self.shadow_output.textCursor()
cursor.movePosition(QTextCursor.End)
cursor.insertText(text)
self.shadow_output.setTextCursor(cursor)
self.shadow_output.ensureCursorVisible()
def selectFile(self):
self.le_heigth_profile_file_name.setText(
oasysgui.selectFileFromDialog(
self,
self.heigth_profile_file_name,
"Select Output File",
file_extension_filter="Data Files (*.dat)"))
class electrical_mesh_editor(QGroupBox):
changed = pyqtSignal()
def on_add_mesh_clicked(self):
self.tab.blockSignals(True)
index = self.tab.selectionModel().selectedRows()
print(index)
if len(index)>0:
pos=index[0].row()+1
else:
pos = self.tab.rowCount()
self.tab.insertRow(pos)
self.tab.setItem(pos,0,QTableWidgetItem("100e-9"))
self.tab.setItem(pos,1,QTableWidgetItem("20"))
self.save()
self.tab.blockSignals(False)
self.changed.emit()
def on_remove_click(self, button, treeview):
self.tab.blockSignals(True)
index = self.tab.selectionModel().selectedRows()
print(index)
if len(index)>0:
pos=index[0].row()
self.tab.removeRow(pos)
self.save()
self.tab.blockSignals(False)
self.changed.emit()
def save(self):
if self.xyz=="y":
mesh_clear_ylist()
elif self.xyz=="x":
print("cleared")
mesh_clear_xlist()
elif self.xyz=="z":
mesh_clear_zlist()
for i in range(0,self.tab.rowCount()):
mesh_add(self.xyz,float(self.tab.item(i, 0).text()),float(self.tab.item(i, 1).text()))
mesh_save_all()
def refresh(self):
self.load()
def disable_dim(self):
self.tab.setItem(0,1,QTableWidgetItem("1"))
self.save()
def enable_dim(self):
if int(self.tab.rowCount())==1:
self.tab.setItem(0,1,QTableWidgetItem("10"))
self.save()
def load(self):
self.tab.clear()
self.tab.setHorizontalHeaderLabels([_("Thicknes"), _("Mesh points")])
lines=[]
pos=0
if self.xyz=="y":
mesh_layers=mesh_get_ylayers()
layer_list=mesh_get_ylist()
elif self.xyz=="x":
mesh_layers=mesh_get_xlayers()
layer_list=mesh_get_xlist()
elif self.xyz=="z":
mesh_layers=mesh_get_zlayers()
layer_list=mesh_get_zlist()
self.tab.setRowCount(mesh_layers)
for i in range(0, mesh_layers):
value = QTableWidgetItem(str(layer_list[i].thick))
self.tab.setItem(i,0,value)
value = QTableWidgetItem(str(int(layer_list[i].points)))
self.tab.setItem(i,1,value)
def tab_changed(self, x,y):
print(x,y)
self.save()
self.changed.emit()
def __init__(self,xyz):
self.xyz=xyz
QGroupBox.__init__(self)
self.setTitle(self.xyz)
self.setStyleSheet("QGroupBox { border: 1px solid gray;}")
vbox=QVBoxLayout()
self.setLayout(vbox)
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
add = QAction(QIcon(os.path.join(get_image_file_path(),"16_add.png")), _("Add "+self.xyz+" mesh layer"), self)
add.triggered.connect(self.on_add_mesh_clicked)
toolbar.addAction(add)
remove = QAction(QIcon(os.path.join(get_image_file_path(),"16_minus.png")), _("Remove "+self.xyz+" mesh layer"), self)
remove.triggered.connect(self.on_remove_click)
toolbar.addAction(remove)
vbox.addWidget(toolbar)
self.tab = QTableWidget()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.tab.clear()
self.tab.setColumnCount(2)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.load()
self.tab.cellChanged.connect(self.tab_changed)
vbox.addWidget(self.tab)
class DictGui(Param):
"""A GUI for Dictionary-Parameters"""
def __init__(self,
project,
param_name,
param_alias=None,
hint=None,
default=None):
super().__init__(project, param_name, param_alias, default)
self.param_name = param_name
self.param_value = dict()
self.param_widget = QTableWidget(0, 2)
self.param_widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
if hint:
self.param_widget.setToolTip(hint)
self.param_widget.itemChanged.connect(self.get_param)
self.param_widget.setHorizontalHeaderLabels(['key', 'value'])
self.read_param()
self.set_param()
self.save_param()
self.init_bt_layout()
def set_items(self, row, key, value):
key_item = QTableWidgetItem(key)
key_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEditable
| Qt.ItemIsEnabled)
value_item = QTableWidgetItem(value)
value_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEditable
| Qt.ItemIsEnabled)
self.param_widget.setItem(row, 0, key_item)
self.param_widget.setItem(row, 1, value_item)
self.param_widget.resizeColumnsToContents()
def set_param(self):
self.param_widget.clear()
if len(self.param_value) > 0:
self.param_widget.setRowCount(len(self.param_value))
for row, (key, value) in enumerate(self.param_value.items()):
self.set_items(row, str(key), str(value))
def get_param(self):
param_dict = dict()
for row in range(self.param_widget.rowCount()):
row_item = self.param_widget.item(row, 0)
value_item = self.param_widget.item(row, 1)
if row_item and value_item:
try:
key = literal_eval(row_item.text())
except (ValueError, SyntaxError):
key = row_item.text()
try:
value = literal_eval(value_item.text())
except (ValueError, SyntaxError):
value = value_item.text()
param_dict.update({key: value})
self.param_widget.resizeColumnsToContents()
self.param_value = param_dict
self.save_param()
return self.param_value
def add_item(self):
row = self.param_widget.rowCount()
self.param_widget.insertRow(row)
self.set_items(row, '_None_key_', '_None_value_')
self.param_widget.resizeColumnsToContents()
self.get_param()
def remove_item(self):
row = self.param_widget.currentRow()
if row is not None:
self.param_widget.removeRow(row)
self.get_param()
class Ui_MainWindow(object):
#tworzenie zmienncyh tymczasowych
current_unit = 0
names_list = []
Readed_registers = []
Responded_messages_list = []
#zakoncz dzialanie programu po zamknieciu okna
def quit(self):
sys.exit(app.exec())
#tworzenie obiektow okna admina
def setupUi(self, MainWindow):
serwervxi.Listen_connection.listen()
MainWindow.setObjectName("Kinco_Driver")
MainWindow.resize(800, 600)
MainWindow.setFixedSize(MainWindow.size())
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.pushButton = QtWidgets.QPushButton(self.centralwidget)
self.pushButton.setGeometry(QtCore.QRect(50, 475, 100, 60))
self.pushButton.setObjectName("pushButton")
self.pushButton_2 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_2.setGeometry(QtCore.QRect(180, 475, 100, 60))
self.pushButton_2.setObjectName("pushButton_2")
self.pushButton_3 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_3.setGeometry(QtCore.QRect(310, 475, 100, 60))
self.pushButton_3.setObjectName("pushButton_3")
self.pushButton_4 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_4.setGeometry(QtCore.QRect(440, 475, 100, 60))
self.pushButton_4.setObjectName("pushButton_4")
self.pushButton_5 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_5.setGeometry(QtCore.QRect(500, 55, 50, 25))
self.pushButton_5.setObjectName("pushButton_5")
self.pushButton_6 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_6.setGeometry(QtCore.QRect(725, 300, 50, 25))
self.pushButton_6.setObjectName("pushButton_5")
self.pushButton_7 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_7.setGeometry(QtCore.QRect(570, 475, 100, 60))
self.pushButton_7.setObjectName("pushButton_7")
self.pushButton_8 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_8.setGeometry(QtCore.QRect(650, 300, 50, 25))
self.pushButton_8.setObjectName("pushButton_7")
self.pushButton_9 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_9.setGeometry(QtCore.QRect(500, 5, 120, 25))
self.pushButton_9.setObjectName("pushButton_7")
self.pushButton_10 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_10.setGeometry(QtCore.QRect(630, 440, 130, 25))
self.pushButton_10.setObjectName("pushButton_7")
self.pushButton_11 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_11.setGeometry(QtCore.QRect(630, 40, 130, 25))
self.pushButton_11.setObjectName("pushButton_7")
self.pushButton_12 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_12.setGeometry(QtCore.QRect(630, 70, 130, 25))
self.pushButton_12.setObjectName("pushButton_7")
self.pushButton_13 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_13.setGeometry(QtCore.QRect(630, 100, 130, 25))
self.pushButton_13.setObjectName("pushButton_7")
self.pushButton_14 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_14.setGeometry(QtCore.QRect(630, 5, 130, 25))
self.pushButton_14.setObjectName("pushButton_7")
self.scrollArea = QtWidgets.QScrollArea(self.centralwidget)
self.scrollArea.setGeometry(QtCore.QRect(50, 140, 701, 100))
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setObjectName("scrollArea")
self.scrollAreaWidgetContents = QtWidgets.QWidget()
self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(
0, 100, 699, 99))
self.scrollAreaWidgetContents.setObjectName("scrollAreaWidgetContents")
self.scrollArea.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setWidget(self.scrollAreaWidgetContents)
self.scrollArea2 = QtWidgets.QScrollArea(self.centralwidget)
self.scrollArea2.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.scrollArea2.setGeometry(QtCore.QRect(50, 330, 701, 100))
self.scrollArea2.setWidgetResizable(True)
self.scrollArea2.setObjectName("scrollArea")
self.scrollArea2WidgetContents = QtWidgets.QWidget()
self.scrollArea2WidgetContents.setGeometry(QtCore.QRect(0, 0, 699, 99))
self.scrollArea2WidgetContents.setObjectName(
"scrollAreaWidgetContents")
self.scrollArea2.setWidget(self.scrollArea2WidgetContents)
self.scrollArea2.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.scrollArea2.setWidgetResizable(True)
self.scrollArea2.setWidget(self.scrollAreaWidgetContents)
self.label = QtWidgets.QLabel(self.centralwidget)
self.label.setGeometry(QtCore.QRect(50, 5, 331, 25))
self.label.setObjectName("label")
self.label_2 = QtWidgets.QLabel(self.centralwidget)
self.label_2.setGeometry(QtCore.QRect(125, 5, 361, 25))
self.label_2.setObjectName("label_2")
self.label_3 = QtWidgets.QLabel(self.centralwidget)
self.label_3.setGeometry(QtCore.QRect(570, 530, 211, 25))
self.label_3.setObjectName("label_3")
self.label_4 = QtWidgets.QLabel(self.centralwidget)
self.label_4.setGeometry(QtCore.QRect(30, 265, 100, 25))
self.label_4.setObjectName("label_3")
self.label_5 = QtWidgets.QLabel(self.centralwidget)
self.label_5.setGeometry(QtCore.QRect(30, 295, 100, 25))
self.label_5.setObjectName("label_3")
self.label_6 = QtWidgets.QLabel(self.centralwidget)
self.label_6.setGeometry(QtCore.QRect(375, 5, 70, 25))
self.label_6.setObjectName("label_3")
self.label_7 = QtWidgets.QLabel(self.centralwidget)
self.label_7.setGeometry(QtCore.QRect(250, 5, 100, 25))
self.label_7.setObjectName("label_3")
self.label_8 = QtWidgets.QLabel(self.centralwidget)
self.label_8.setFont(QFont('Arial', 12))
self.label_8.setGeometry(QtCore.QRect(40, 70, 500, 60))
self.label_8.setObjectName("label_3")
self.label_9 = QtWidgets.QLabel(self.scrollArea)
self.label_9.setGeometry(QtCore.QRect(0, 0, 500, 25))
self.label_9.setObjectName("label_3")
self.label_11 = QtWidgets.QLabel(self.centralwidget)
self.label_11.setGeometry(QtCore.QRect(120, 245, 110, 25))
self.label_12 = QtWidgets.QLabel(self.centralwidget)
self.label_12.setGeometry(QtCore.QRect(230, 245, 140, 25))
self.label_13 = QtWidgets.QLabel(self.centralwidget)
self.label_13.setGeometry(QtCore.QRect(380, 245, 140, 25))
self.label_14 = QtWidgets.QLabel(self.centralwidget)
self.label_14.setGeometry(QtCore.QRect(530, 245, 130, 25))
self.label_15 = QtWidgets.QLabel(self.centralwidget)
self.label_15.setGeometry(QtCore.QRect(680, 245, 80, 25))
self.label_16 = QtWidgets.QLabel(self.centralwidget)
self.label_16.setGeometry(QtCore.QRect(10, 245, 80, 25))
self.label_17 = QtWidgets.QLabel(self.centralwidget)
self.label_17.setGeometry(QtCore.QRect(50, 530, 300, 60))
self.deafult_checkbox = QtWidgets.QCheckBox(self.centralwidget)
self.deafult_checkbox.move(70, 250)
self.coordination_box_y = QtWidgets.QTextEdit(self.centralwidget)
self.coordination_box_y.setGeometry(QtCore.QRect(120, 295, 80, 25))
self.coordination_box_x = QtWidgets.QTextEdit(self.centralwidget)
self.coordination_box_x.setGeometry(QtCore.QRect(120, 265, 80, 25))
self.acceleration_box_x = QtWidgets.QTextEdit(self.centralwidget)
self.acceleration_box_x.setGeometry(QtCore.QRect(260, 265, 80, 25))
self.decceleration_box_x = QtWidgets.QTextEdit(self.centralwidget)
self.decceleration_box_x.setGeometry(QtCore.QRect(400, 265, 80, 25))
self.velocity_box_x = QtWidgets.QTextEdit(self.centralwidget)
self.velocity_box_x.setGeometry(QtCore.QRect(540, 265, 80, 25))
self.acceleration_box_y = QtWidgets.QTextEdit(self.centralwidget)
self.acceleration_box_y.setGeometry(QtCore.QRect(260, 295, 80, 25))
self.decceleration_box_y = QtWidgets.QTextEdit(self.centralwidget)
self.decceleration_box_y.setGeometry(QtCore.QRect(400, 295, 80, 25))
self.velocity_box_y = QtWidgets.QTextEdit(self.centralwidget)
self.velocity_box_y.setGeometry(QtCore.QRect(540, 295, 80, 25))
self.Message_edit = QtWidgets.QTextEdit(self.centralwidget)
self.Message_edit.setGeometry(QtCore.QRect(375, 55, 100, 25))
self.Message_edit2 = QtWidgets.QTextEdit(self.centralwidget)
self.Message_edit2.setGeometry(QtCore.QRect(125, 55, 100, 25))
self.Message_edit3 = QtWidgets.QTextEdit(self.centralwidget)
self.Message_edit3.setGeometry(QtCore.QRect(250, 55, 100, 25))
self.unit_choice = QtWidgets.QComboBox(self.centralwidget)
self.unit_choice.setGeometry(QtCore.QRect(50, 25, 50, 25))
self.positioning_choice = QtWidgets.QComboBox(self.centralwidget)
self.positioning_choice.setGeometry(QtCore.QRect(650, 265, 100, 25))
self.function_choice = QtWidgets.QComboBox(self.centralwidget)
self.function_choice.setGeometry(QtCore.QRect(125, 25, 100, 25))
self.register_choice = QtWidgets.QComboBox(self.centralwidget)
self.register_choice.setGeometry(QtCore.QRect(250, 25, 100, 25))
self.message_choice = QtWidgets.QComboBox(self.centralwidget)
self.message_choice.setGeometry(QtCore.QRect(375, 25, 100, 25))
self.responded_messages = QWidget()
self.vbox = QVBoxLayout()
self.responded_messages2 = QWidget()
self.vbox2 = QVBoxLayout()
self.table = QTableWidget(self.centralwidget)
self.table.setGeometry(QtCore.QRect(20, 330, 760, 100))
self.table.setColumnCount(3)
self.table.setRowCount(1000)
self.table.setColumnWidth(0, 235)
self.table.setColumnWidth(1, 235)
self.table.setColumnWidth(2, 235)
self.table.setHorizontalHeaderLabels(
['Position X', 'Position Y', 'name'])
self.table.resizeRowsToContents()
self.table.setMinimumWidth(720)
self.table.setMinimumHeight(100)
#podzielenie okna na czesc z menu i czesc z obiektami
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 21))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
#dodanie zegara na dole okna
self.DigitalClock = DigitalClock(self.centralwidget)
self.DigitalClock.setGeometry(QtCore.QRect(570, 553, 130, 21))
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def send_message(self):
#wczytaj wartosci nazwy rejestru, funkcji, jednostki, oraz
#wysylanej wiadomosci podanych przez uzytkownika.
function_choosed = self.function_choice.currentText()
Admin_backend.message_sending.Register = self.register_choice.currentText(
)
Admin_backend.message_sending.Unit = self.unit_choice.currentText()
Admin_backend.message_sending.message = self.Message_edit.toPlainText()
#jesli wybrane jest czytanie z rejestru
if (function_choosed == 'read'):
#wywolaj funkcje czytajaca z rejestr
result = Admin_backend.message_sending.read_register()
#zapisz do tabeli odebrana wiadomosc
if (result == 0):
self.Responded_messages_list.append(
Admin_backend.Register_respond[
len(Admin_backend.Register_respond) - 1])
object = QLabel(self.Responded_messages_list[
len(self.Responded_messages_list) - 1])
self.vbox.addWidget(object)
self.responded_messages.setLayout(self.vbox)
self.scrollArea.setWidget(self.responded_messages)
#wyczysc zmienna z wczytaneym rejestrem
else:
self.msgbox = QMessageBox()
self.msgbox.setIcon(QMessageBox.Critical)
self.msgbox.setText("check connection")
self.msgbox.setStandardButtons(QMessageBox.Ok
| QMessageBox.Cancel)
self.msgbox.show()
Admin_backend.Register_respond = []
elif (function_choosed == 'write'):
#jesli wybrana funkcja jest pisanie do rejestru wywolaj
#metode piszaca do rejestru
result = Admin_backend.message_sending.write_register()
#korzystajac z flagi podniesionej przez wywolana funkcje
#wyswietl informacji o bledzie podczas wysylania wiadomosci
if (result != 0):
self.msgbox = QMessageBox()
self.msgbox.setIcon(QMessageBox.Critical)
if (result == 1):
self.msgbox.setText("wrong type of message")
elif (result == 2):
self.msgbox.setText("value of message out of limit")
elif (result == 3):
self.msgbox.setText("value of message out of limit")
else:
self.msgbox.setText("Check connection")
self.msgbox.setStandardButtons(QMessageBox.Ok
| QMessageBox.Cancel)
self.msgbox.show()
#wyswietl wczytane informacje z nowo zapisanego rejsetru
self.Responded_messages_list.append(Admin_backend.Register_respond[
len(Admin_backend.Register_respond) - 1])
object = QLabel(
self.Responded_messages_list[len(self.Responded_messages_list)
- 1])
self.vbox.addWidget(object)
self.responded_messages.setLayout(self.vbox)
self.scrollArea.setWidget(self.responded_messages)
#wyzeroj zmienne kontrolne
Admin_backend.Register_respond = []
#funkcja pobiera aktualna date
def getDate(self):
date = QDate.currentDate()
return date.toString(Qt.DefaultLocaleLongDate)
#callback wybrania wartosci okienka unit zapisuje wybrana zmienna do
#odpowiedniego zmiennej w klasie admin_backend
def unit_selected(self, value):
if (int(value) == 1):
Admin_backend.unit_choice = 0
else:
Admin_backend.unit_choice = 1
print("to dziala")
#callback wybrania wartosci okienka function zapisuje wybrana zmienna
#do odpowiedniego zmiennej w klasie admin_backend i wczytuje mozliwe
#wartosci okienka nazw rejestrow
def Function_selected(self, value):
self.register_choice.clear()
Admin_backend.function_value = value
names_list = Admin_backend.comboboxes.registers_names()
self.register_choice.addItems(names_list)
Admin_backend.registers_names_list = []
self.Message_edit2.setText(value)
#callback wybrania wartosci okienka nazwy rejsestru zapisuje wybrana
#zmienna do odpowiedniego zmiennej w klasie admin_backend i wczytuje
#mozliwe wartosci okienka mozliwych wiadomosci
def name_selected(self, value):
self.message_choice.clear()
Admin_backend.register_name_value = value
messages_list = Admin_backend.comboboxes.messages_names()
self.message_choice.addItems(messages_list)
Admin_backend.message_names_list = []
if (Admin_backend.label_text != []):
self.label_8.setText(Admin_backend.label_text[0])
Admin_backend.label_text = []
self.Message_edit3.setText(value)
#callback wybrania wartosci okienka wiadomosci zapisuje wybrana
#zmienna do odpowiedniego zmiennej w klasie admin_backend i wyswietla
#podpwiedz do danej wiadomosci
def message_selected(self, value):
Admin_backend.message_name_value = value
print(Admin_backend.label_text)
Admin_backend.comboboxes.message_description()
if (Admin_backend.label_text != []):
self.label_8.setText(Admin_backend.label_text[0])
Admin_backend.label_text = []
value = self.message_choice.currentText()
print(value)
if value != 'inc' and value != 'RPM' and value != 'AMP' and value != 'number' and value != 'rp/s^2':
self.Message_edit.setText(value)
#callback przcisku home do zaimplementopwania
def Home_window(self):
self.window = QMainWindow()
self.Home_ui = Home_window.Ui_Home_Window()
self.Home_ui.setupUi(self.window)
self.window.show()
#callback przycisku register uruchamia okno rejsetru
def Register_window(self):
#odpytaj serwomechnizm o stan jego rejestrow
connection_result = Admin_backend.message_sending.check_connection()
if (connection_result == 0):
self.window = QMainWindow()
self.Register_ui = Register_window.Ui_Register_Window()
self.Register_ui.setupUi(self.window)
self.window.show()
else:
self.msgbox = QMessageBox()
self.msgbox.setIcon(QMessageBox.Critical)
self.msgbox.setText("Check connection")
self.msgbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
self.msgbox.show()
#callback przycisku test wykonuje test serwomechnizmow a w razie
#problemow wyswietla informacje o bledzie
def Test_clicked(self):
#wywolaj metode wykoujaca test
Admin_backend.stop_thread = 0
self.check_window()
self.testTask()
def check_window(self):
global check_window
check_window = Check_move_Window.Ui_Check_move_Window()
print(check_window)
self.ui = check_window
check_window.setupUi(self.ui)
check_window.show()
def moveTask(self):
# Step 2: Create a QThread object
self.thread = QThread()
# Step 3: Create a worker object
self.moving = Admin_backend.moving()
# Step 4: Move worker to the thread
self.moving.moveToThread(self.thread)
# Step 5: Connect signals and slots
self.thread.started.connect(self.moving.do_move)
self.moving.finished.connect(self.thread.quit)
self.moving.finished.connect(self.moving.deleteLater)
self.thread.finished.connect(self.thread.deleteLater)
self.moving.progress2.connect(self.update_move_window)
self.moving.progress.connect(self.show_messagebox)
self.moving.progress3.connect(self.update_unit)
self.moving.stop_current_thread.connect(self.thread.quit)
# Step 6: Start the thread
self.thread.start()
self.pushButton_5.setEnabled(False)
self.thread.finished.connect(
lambda: self.pushButton_5.setEnabled(True))
self.pushButton_6.setEnabled(False)
self.thread.finished.connect(
lambda: self.pushButton_6.setEnabled(True))
self.pushButton_8.setEnabled(False)
self.thread.finished.connect(
lambda: self.pushButton_8.setEnabled(True))
#funkcja odpowiedzialna za porusznie sie serwomechanizmow
def update_unit(self, unit):
self.current_unit = unit
def testTask(self):
# Step 2: Create a QThread object
self.thread = QThread()
# Step 3: Create a worker object
self.moving = Admin_backend.moving()
# Step 4: Move worker to the thread
self.moving.moveToThread(self.thread)
# Step 5: Connect signals and slots
self.thread.started.connect(self.moving.do_test)
self.moving.finished.connect(self.thread.quit)
self.moving.finished.connect(self.moving.deleteLater)
self.thread.finished.connect(self.thread.deleteLater)
self.moving.progress2.connect(self.update_move_window)
self.moving.progress3.connect(self.update_unit)
self.moving.progress.connect(self.show_messagebox2)
self.moving.stop_current_thread.connect(self.thread.quit)
# Step 6: Start the thread
self.thread.start()
self.pushButton_5.setEnabled(False)
self.thread.finished.connect(
lambda: self.pushButton_5.setEnabled(True))
self.pushButton_6.setEnabled(False)
self.thread.finished.connect(
lambda: self.pushButton_6.setEnabled(True))
self.pushButton_8.setEnabled(False)
self.thread.finished.connect(
lambda: self.pushButton_8.setEnabled(True))
#funkcja odpowiedzialna za porusznie sie serwomechanizmow
def apimoveTask(self):
# Step 2: Create a QThread object
self.thread = QThread()
# Step 3: Create a worker object
self.moving = Admin_backend.moving()
# Step 4: Move worker to the thread
self.moving.moveToThread(self.thread)
# Step 5: Connect signals and slots
self.thread.started.connect(self.moving.do_test)
self.moving.finished.connect(self.thread.quit)
self.moving.finished.connect(self.moving.deleteLater)
self.thread.finished.connect(self.thread.deleteLater)
# Step 6: Start the thread
self.thread.start()
def update_move_window(self, point):
global check_window
curr_text = ""
if self.current_unit == 1:
curr_text = "x"
else:
curr_text = "y"
uplabel = ("current position of axis " + curr_text + " : " +
str(point))
Check_move_Window.Ui_Check_move_Window.update_label(
check_window, uplabel)
def show_messagebox(self, result):
self.msgbox = QMessageBox()
self.msgbox.setIcon(QMessageBox.Critical)
global check_window
check_window.close()
if (result == 1):
self.msgbox.setText("wrong type of message")
elif (result == 2):
self.msgbox.setText("one of value out of limit")
elif (result == 3):
self.msgbox.setText("one of value out of limit")
elif (result == 4):
self.msgbox.setText("Check connection")
elif (result == 5):
self.msgbox.setText("Move Error")
elif (result == 6):
self.msgbox.setText("Invalid input data")
else:
self.msgbox = QMessageBox()
self.msgbox.setIcon(QMessageBox.Information)
self.msgbox.setText("Move completed succesful")
self.msgbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
self.msgbox.show()
def show_messagebox2(self, result):
if (result != 0):
self.msgbox = QMessageBox()
self.msgbox.setIcon(QMessageBox.Critical)
self.msgbox.setText("Test Error")
self.msgbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
self.msgbox.show()
else:
self.msgbox = QMessageBox()
self.msgbox.setIcon(QMessageBox.Information)
self.msgbox.setText("Test completed succesful")
self.msgbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
self.msgbox.show()
def api_move(self, x, y, x_vel, y_vel, X_acc, y_acc, x_dec, y_dec,
positioning, deafult):
result = 0
try:
#pobierz wartosci o ruchu podane przez uzytkownika i zapisz
#w odpowienich zmiennych klasy asmin_backend
Admin_backend.moving.position_x = x
Admin_backend.moving.position_y = y
Admin_backend.moving.zero = positioning
except Exception:
traceback.print_exc()
result = 6
self.msgbox = QMessageBox()
self.msgbox.setIcon(QMessageBox.Critical)
self.msgbox.setText("Invalid input data")
self.msgbox.show()
#jesli aktualnie program nie namesession_ui wykonuje ruchu
if (deafult == 0):
try:
#zapisz wczytane uzytkownika informacje o ruchu
#do odpowiednich zmienncyh klasy admin_backend
Admin_backend.moving.acceleration_x = round(
163.84 * int(self.acceleration_box_x.toPlainText()))
Admin_backend.moving.decceleration_x = round(
163.84 * int(self.decceleration_box_x.toPlainText()))
Admin_backend.moving.velocity_x = round(
2730 * int(self.velocity_box_x.toPlainText()))
Admin_backend.moving.acceleration_y = round(
163.84 * int(self.acceleration_box_y.toPlainText()))
Admin_backend.moving.decceleration_y = round(
163.84 * int(self.decceleration_box_y.toPlainText()))
Admin_backend.moving.velocity_y = round(
2730 * int(self.velocity_box_x.toPlainText()))
Admin_backend.moving.zero = self.positioning_choice.currentText(
)
except Exception:
traceback.print_exc()
result = 6
self.msgbox = QMessageBox()
self.msgbox.setIcon(QMessageBox.Critical)
self.msgbox.setText("Invalid input data")
self.msgbox.show()
else:
Admin_backend.move_deafult_flag[0] = 1
#wyswietl informacje o statusie ruchu
if (result != 6):
Admin_backend.stop_thread = 0
self.check_window()
self.apimoveTask()
def Move_clicked(self):
result = 0
try:
#pobierz wartosci o ruchu podane przez uzytkownika i zapisz
#w odpowienich zmiennych klasy asmin_backend
Admin_backend.moving.position_x = int(
self.coordination_box_x.toPlainText())
Admin_backend.moving.position_y = int(
self.coordination_box_y.toPlainText())
Admin_backend.moving.zero = self.positioning_choice.currentText()
except Exception:
traceback.print_exc()
result = 6
self.msgbox = QMessageBox()
self.msgbox.setIcon(QMessageBox.Critical)
self.msgbox.setText("resultInvalid input data")
self.msgbox.show()
#jesli aktualnie program nie namesession_ui wykonuje ruchu
if (Admin_backend.move_deafult_flag[0] == 0):
try:
#zapisz wczytane uzytkownika informacje o ruchu
#do odpowiednich zmienncyh klasy admin_backend
Admin_backend.moving.acceleration_x = round(
163.84 * int(self.acceleration_box_x.toPlainText()))
Admin_backend.moving.decceleration_x = round(
163.84 * int(self.decceleration_box_x.toPlainText()))
Admin_backend.moving.velocity_x = round(
2730 * int(self.velocity_box_x.toPlainText()))
Admin_backend.moving.acceleration_y = round(
163.84 * int(self.acceleration_box_y.toPlainText()))
Admin_backend.moving.decceleration_y = round(
163.84 * int(self.decceleration_box_y.toPlainText()))
Admin_backend.moving.velocity_y = round(
2730 * int(self.velocity_box_x.toPlainText()))
Admin_backend.moving.zero = self.positioning_choice.currentText(
)
except Exception:
traceback.print_exc()
result = 6
self.msgbox = QMessageBox()
self.msgbox.setIcon(QMessageBox.Critical)
self.msgbox.setText("Invalid input data")
self.msgbox.show()
#wyswietl informacje o statusie ruchu
if (result != 6):
Admin_backend.stop_thread = 0
self.check_window()
self.moveTask()
#Callback checkboxu wylacza mozliwosc dodawania swoich wartosci do
#ruchu oprocz wspolrzednych
def deafult_checkbox_clicked(self, state):
Admin_backend.move_deafult_flag = []
if str(state) == "True":
self.acceleration_box_x.setDisabled(True)
self.decceleration_box_x.setDisabled(True)
self.velocity_box_x.setDisabled(True)
self.acceleration_box_y.setDisabled(True)
self.decceleration_box_y.setDisabled(True)
self.velocity_box_y.setDisabled(True)
Admin_backend.move_deafult_flag.append(1)
else:
self.acceleration_box_x.setDisabled(False)
self.decceleration_box_x.setDisabled(False)
self.velocity_box_x.setDisabled(False)
self.acceleration_box_y.setDisabled(False)
self.decceleration_box_y.setDisabled(False)
self.velocity_box_y.setDisabled(False)
Admin_backend.move_deafult_flag.append(0)
def savepoint_callback(self):
global table_end
global Table
Admin_backend.button_callbacks.savepoint_button_callback()
item1 = QTableWidgetItem(str(Admin_backend.Position_save_info[0]))
item2 = QTableWidgetItem(str(Admin_backend.Position_save_info[1]))
item3 = QTableWidgetItem("Default name " + str(table_end))
self.table.setItem(table_end, 0, item1)
self.table.setItem(table_end, 1, item2)
self.table.setItem(table_end, 2, item3)
self.table.selectRow(table_end)
table_end = table_end + 1
def previous_callback(self):
saved_coor = Admin_backend.button_callbacks.previous_buttton_callback()
self.coordination_box_x.setText(str(saved_coor[0]))
self.coordination_box_y.setText(str(saved_coor[1]))
if (Admin_backend.current_point > -1):
self.table.selectRow(Admin_backend.current_point)
def next_callback(self):
saved_coor = Admin_backend.button_callbacks.next_buttton_callback()
self.coordination_box_x.setText(str(saved_coor[0]))
self.coordination_box_y.setText(str(saved_coor[1]))
if (Admin_backend.current_point < 1000):
self.table.selectRow(Admin_backend.current_point)
def savesession_callback(self):
global Table
global table_end
Table = [[0 for x in range(self.table.columnCount())]
for y in range(table_end)]
for i in range(self.table.columnCount()):
for k in range(table_end):
print([k, i])
print(self.table.item(k, i).text())
Table[k][i] = self.table.item(k, i).text()
Admin_backend.Points = Table
self.namesession_ui = Namesession.Ui_NameSession_Window()
self.namesession_ui.setupUi(self.namesession_ui)
self.namesession_ui.show()
def readsession_callback(self):
self.thread = QThread()
self.readsession_ui = Session_records.Ui_Session_records_Window()
self.readsession_ui.moveToThread(self.thread)
self.readsession_ui.setupUi(self.readsession_ui)
self.thread.started.connect(self.readsession_ui.show)
self.readsession_ui.finished.connect(self.update_table)
self.readsession_ui.finished.connect(self.thread.quit)
self.readsession_ui.finished.connect(self.readsession_ui.deleteLater)
self.thread.finished.connect(self.thread.deleteLater)
self.thread.start()
def update_table(self):
try:
global table_end
Points = Admin_backend.New_points
counter = 0
print(Points)
self.table.clear()
Admin_backend.Saved_points = []
for point in Points:
Admin_backend.Saved_points.append(
[str(point[1]), str(point[2])])
Admin_backend.current_point = (len(
Admin_backend.Saved_points)) - 1
item1 = QTableWidgetItem(str(point[1]))
item2 = QTableWidgetItem(str(point[2]))
item3 = QTableWidgetItem(str(point[3]))
self.table.setItem(counter, 0, item1)
self.table.setItem(counter, 1, item2)
self.table.setItem(counter, 2, item3)
counter = counter + 1
table_end = counter
Admin_backend.current_point = 0
except Exception:
traceback.print_exc()
def error_reset_callback(self):
result = Admin_backend.button_callbacks.error_reset()
if (result != 0):
self.msgbox = QMessageBox()
self.msgbox.setIcon(QMessageBox.Critical)
self.msgbox.setText("Reset error")
def session_movement_callback(self):
self.currentPosition_ui = Current_position.Ui_current_position_window()
self.currentPosition_ui.setupUi(self.currentPosition_ui)
self.currentPosition_ui.show()
def motors_off_callback(self):
Admin_backend.button_callbacks.motors_off()
def Zero_current_callback(self):
Admin_backend.button_callbacks.Zero_current()
#funkcja uruchamiana przy starcie okna przypsiujaca wartosci oknu
#gui oraz deklarujaca callbacki
def retranslateUi(self, MainWindow):
try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
ip_adress = s.getsockname()[0]
except Exception:
ip_adress = "Check connection to switch"
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "Kinco Driver"))
self.pushButton.setText(_translate("MainWindow", "Home"))
self.pushButton.clicked.connect(self.Home_window)
self.pushButton_2.setText(_translate("MainWindow", "Save point"))
self.pushButton_2.clicked.connect(self.savepoint_callback)
self.pushButton_3.setText(_translate("MainWindow", "Previous"))
self.pushButton_3.clicked.connect(self.previous_callback)
self.pushButton_4.setText(_translate("MainWindow", "Next"))
self.pushButton_4.clicked.connect(self.next_callback)
self.pushButton_5.setText(_translate("MainWindow", "Send"))
self.pushButton_5.clicked.connect(self.send_message)
self.pushButton_6.setText(_translate("MainWindow", "test"))
self.pushButton_6.clicked.connect(self.Test_clicked)
self.pushButton_7.setText(_translate("MainWindow", "Save session"))
self.pushButton_7.clicked.connect(self.savesession_callback)
self.pushButton_8.setText(_translate("MainWindow", "Move"))
self.pushButton_8.clicked.connect(self.Move_clicked)
self.pushButton_9.setText(_translate("MainWindow", "Registers_status"))
self.pushButton_9.clicked.connect(self.Register_window)
self.pushButton_10.setText(_translate("MainWindow", "Read Session"))
self.pushButton_10.clicked.connect(self.readsession_callback)
self.pushButton_11.setText(_translate("MainWindow", "Reset Error"))
self.pushButton_11.clicked.connect(self.error_reset_callback)
self.pushButton_12.setText(_translate("MainWindow",
"Session Movement"))
self.pushButton_12.clicked.connect(self.session_movement_callback)
self.pushButton_13.setText(_translate("MainWindow", "motors off"))
self.pushButton_13.clicked.connect(self.motors_off_callback)
self.pushButton_14.setText(
_translate("MainWindow", "Zero current point"))
self.pushButton_14.clicked.connect(self.Zero_current_callback)
self.positioning_choice.addItems(Admin_backend.Positioning_values)
self.deafult_checkbox.clicked.connect(self.deafult_checkbox_clicked)
self.unit_choice.addItems(Constants.units)
self.unit_choice.currentTextChanged.connect(self.unit_selected)
self.function_choice.currentTextChanged.connect(self.Function_selected)
self.function_choice.addItems(Constants.function_select)
self.register_choice.currentTextChanged.connect(self.name_selected)
self.message_choice.currentTextChanged.connect(self.message_selected)
self.label.setText(_translate("MainWindow", "Unit:"))
self.label_2.setText(_translate("MainWindow", "Function:"))
self.label_3.setText(_translate("MainWindow", self.getDate()))
self.label_4.setText(_translate("MainWindow", "Y Coordinate:"))
self.label_5.setText(_translate("MainWindow", "X Coordinate:"))
self.label_6.setText(_translate("MainWindow", "Message:"))
self.label_7.setText(_translate("MainWindow", "Register Name:"))
self.label_9.setText(_translate("MainWindow", " "))
self.label_11.setText(_translate("MainWindow", "Position(inc):"))
self.label_12.setText(_translate("MainWindow",
"Acceleration(rp/s^2):"))
self.label_13.setText(_translate("MainWindow",
"Deceleration(rp/s^2):"))
self.label_14.setText(_translate("MainWindow", "Velocity(rpm):"))
self.label_15.setText(_translate("MainWindow", "Zero:"))
self.label_16.setText(_translate("MainWindow", "Deafult:"))
self.label_17.setText(
_translate("MainWindow", "Current IP: %s" % (ip_adress)))
self.DigitalClock.setStyleSheet('background-color: black', )
self.Register_window()
class SessionViewer(QWidget):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setMinimumSize(1100, 400)
main_layout = QHBoxLayout()
main_layout.setSpacing(5)
self.setLayout(main_layout)
list_column = QVBoxLayout()
main_layout.addLayout(list_column, stretch=1)
refresh_button = QPushButton('🔄 Refresh')
refresh_button.setFont(cn.EMOJI_FONT)
refresh_button.clicked.connect(self.refresh_list)
list_column.addWidget(refresh_button)
self.session_list = QListWidget()
self.session_list.currentItemChanged.connect(self.show_session)
list_column.addWidget(self.session_list)
self.refresh_list()
self.info_column = QVBoxLayout()
main_layout.addLayout(self.info_column, stretch=1)
self.info_column.addWidget(QLabel('Selected session info:'))
self.session_info_table = QTableWidget()
self.session_info_table.setColumnCount(2)
self.session_info_table.horizontalHeader().setStretchLastSection(True)
self.info_column.addWidget(self.session_info_table)
self.info_column.addWidget(QLabel('Contained gestures:'))
self.gesture_list = QListWidget()
self.gesture_list.currentItemChanged.connect(self.show_gesture)
self.info_column.addWidget(self.gesture_list)
self.data_column = QVBoxLayout()
self.data_column.setContentsMargins(0, 0, 0, 0)
main_layout.addLayout(VerticalScrollableExtension(
self.data_column,
direction=QBoxLayout.TopToBottom,
scrolled_spacing=10),
stretch=3)
self.current_session_data = None
self.current_gesture_names = None
@staticmethod
def load_session_data(session_name):
file = f'data/gestures/{session_name}'
with open(file, 'rb') as f:
data = pickle.load(f)
gesture_keys = [
item for item in data if type(data[item]) == np.ndarray
]
return data, sorted(gesture_keys, key=lambda x: str(x).zfill(5))
@staticmethod
def load_session_list():
return sorted(
filter(
lambda x: x.startswith('s-') and x.count(cn.FILE_NAME_SEPARATOR
) == 2,
os.listdir(cn.DATA_FOLDER)))
def refresh_list(self):
self.session_list.clear()
self.session_list.addItems(SessionViewer.load_session_list())
def cleanup_shown_session(self):
self.session_info_table.clear()
self.gesture_list.clearSelection()
self.gesture_list.clear()
for i in range(self.data_column.count()):
self.data_column.itemAt(i).widget().plot_data(None)
def show_session(self, current_item):
if not current_item:
return
self.cleanup_shown_session()
session_name = current_item.text()
self.current_session_data, self.current_gesture_names = SessionViewer.load_session_data(
session_name)
self.session_info_table.setRowCount(2 +
len(self.current_session_data) -
len(self.current_gesture_names))
row = 0
for info in self.current_session_data:
if info in self.current_gesture_names:
continue
self.session_info_table.setItem(row, 0, QTableWidgetItem(info))
self.session_info_table.setItem(
row, 1, QTableWidgetItem(str(self.current_session_data[info])))
row += 1
self.session_info_table.setItem(row, 0, QTableWidgetItem('Gestures'))
self.session_info_table.setItem(
row, 1, QTableWidgetItem(str(len(self.current_gesture_names))))
self.session_info_table.setItem(row + 1, 0,
QTableWidgetItem('Instances'))
self.session_info_table.setItem(
row + 1, 1,
QTableWidgetItem(
str(
sum(
map(lambda name: len(self.current_session_data[name]),
self.current_gesture_names)))))
self.gesture_list.addItems(
map(
lambda name:
f'{name} ({len(self.current_session_data[name])} inst.)',
self.current_gesture_names))
def show_gesture(self):
current_gesture_data = self.current_session_data[
self.current_gesture_names[self.gesture_list.currentIndex().row()]]
new_count = len(current_gesture_data)
old_count = self.data_column.count()
for i in range(old_count, new_count):
self.data_column.addWidget(StaticSignalWidget())
for i in range(new_count, old_count):
self.data_column.itemAt(i).widget().plot_data(None)
for i, instance in enumerate(current_gesture_data):
# We use a function here, to create a temporary scope for index & data
w = self.data_column.itemAt(i).widget()
w.plot_data(instance)
class layer_widget(QWidget):
changed = pyqtSignal()
def combo_changed(self):
self.save_model()
self.emit_change()
def tab_changed(self, x,y):
self.save_model()
self.emit_change()
def emit_change(self):
if self.optics_window!=False:
if self.optics_window.isVisible()==True:
self.optics_window.update()
self.changed.emit()
def sync_to_electrical_mesh(self):
tot=0
for i in range(0,len(self.model)):
if yes_no(self.model[i][COLUMN_DEVICE])==True:
tot=tot+float(self.model[i][COLUMN_THICKNES])
lines=[]
if inp_load_file(lines,os.path.join(os.getcwd(),"mesh_y.inp"))==True:
mesh_layers=int(inp_search_token_value(lines, "#mesh_layers"))
if mesh_layers==1:
inp_update_token_value(os.path.join(os.getcwd(),"mesh_y.inp"), "#mesh_layer_length0", str(tot),1)
def layer_type_edit(self):
for i in range(0,self.tab.rowCount()):
if tab_get_value(self.tab,i,3).lower()=="active layer" and tab_get_value(self.tab,i,4).startswith("dos")==False:
tab_set_value(self.tab,i,4,epitay_get_next_dos())
tab_set_value(self.tab,i,5,epitay_get_next_pl())
mat_dir=os.path.join(get_materials_path(),tab_get_value(self.tab,i,2))
new_file=tab_get_value(self.tab,i,4)+".inp"
if inp_isfile(new_file)==False:
inp_copy_file(new_file,os.path.join(mat_dir,"dos.inp"))
new_file=tab_get_value(self.tab,i,5)+".inp"
if inp_isfile(new_file)==False:
inp_copy_file(new_file,os.path.join(mat_dir,"pl.inp"))
if tab_get_value(self.tab,i,3).lower()!="active layer" and tab_get_value(self.tab,i,4).startswith("dos")==True:
tab_set_value(self.tab,i,4,tab_get_value(self.tab,i,3))
tab_set_value(self.tab,i,5,"none")
self.save_model()
self.emit_change()
def rebuild_mat_list(self):
self.material_files=[]
mat=find_materials()
for i in range(0,len(mat)):
self.material_files.append(mat[i])
scan_remove_file(os.path.join(get_materials_path(),mat[i]))
scan_item_add(os.path.join("materials",mat[i],"fit.inp"),"#wavelength_shift_alpha","Absorption spectrum wavelength shift",1)
scan_item_add(os.path.join("materials",mat[i],"fit.inp"),"#n_mul","Refractive index spectrum multiplier",1)
scan_item_add(os.path.join("materials",mat[i],"fit.inp"),"#alpha_mul","Absorption spectrum multiplier",1)
def callback_view_materials(self):
dialog=gpvdm_open(get_materials_path())
dialog.show_inp_files=False
ret=dialog.window.exec_()
if ret==QDialog.Accepted:
if os.path.isfile(os.path.join(dialog.get_filename(),"mat.inp"))==True:
self.mat_window=materials_main(dialog.get_filename())
self.mat_window.show()
else:
plot_gen([dialog.get_filename()],[],"auto")
def on_move_down(self):
tab_move_down(self.tab)
self.save_model()
self.emit_change()
def callback_optics_sim(self, widget, data=None):
help_window().help_set_help(["optics.png",_("<big><b>The optical simulation window</b></big><br>Use this window to perform optical simulations. Click on the play button to run a simulation."),"play.png",_("Click on the play button to run an optical simulation. The results will be displayed in the tabs to the right.")])
if self.optics_window==False:
self.optics_window=class_optical()
if self.optics_window.isVisible()==True:
self.optics_window.hide()
else:
self.optics_window.show()
def __init__(self):
QWidget.__init__(self)
self.rebuild_mat_list()
self.doping_window=False
self.cost_window=False
self.optics_window=False
self.main_vbox=QVBoxLayout()
self.toolbar=QToolBar()
self.toolbar.setIconSize(QSize(32, 32))
self.tb_add = QAction(QIcon(os.path.join(get_image_file_path(),"add.png")), _("Add device layer"), self)
self.tb_add.triggered.connect(self.on_add_item_clicked)
self.toolbar.addAction(self.tb_add)
self.tb_remove = QAction(QIcon(os.path.join(get_image_file_path(),"minus.png")), _("Delete device layer"), self)
self.tb_remove.triggered.connect(self.on_remove_item_clicked)
self.toolbar.addAction(self.tb_remove)
self.tb_remove= QAction(QIcon(os.path.join(get_image_file_path(),"down.png")), _("Move device layer"), self)
self.tb_remove.triggered.connect(self.on_move_down)
self.toolbar.addAction(self.tb_remove)
self.tb_doping = QAction(QIcon(os.path.join(get_image_file_path(),"doping.png")), _("Doping"), self)
self.tb_doping.triggered.connect(self.callback_doping)
self.toolbar.addAction(self.tb_doping)
self.optics_button = QAction(QIcon(os.path.join(get_image_file_path(),"optics.png")), _("Optical simulation"), self)
self.optics_button.triggered.connect(self.callback_optics_sim)
self.toolbar.addAction(self.optics_button)
self.tb_open = QAction(QIcon(os.path.join(get_image_file_path(),"organic_material.png")), _("Look at the materials database"), self)
self.tb_open.triggered.connect(self.callback_view_materials)
self.toolbar.addAction(self.tb_open)
self.cost = QAction(QIcon(os.path.join(get_image_file_path(),"cost.png")), _("Calculate the cost of the solar cell"), self)
self.cost.triggered.connect(self.callback_cost)
self.toolbar.addAction(self.cost)
self.main_vbox.addWidget(self.toolbar)
self.tab = QTableWidget()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.create_model()
self.tab.cellChanged.connect(self.tab_changed)
self.main_vbox.addWidget(self.tab)
self.setLayout(self.main_vbox)
def create_model(self):
self.tab.clear()
self.tab.setColumnCount(6)
if enable_betafeatures()==False:
self.tab.setColumnHidden(5, True)
self.tab.setColumnHidden(4, True)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tab.setHorizontalHeaderLabels([_("Layer name"), _("Thicknes"), _("Optical material"), _("Layer type"), _("DoS Layer"),_("PL Layer")])
self.tab.setRowCount(epitaxy_get_layers())
for i in range(0,epitaxy_get_layers()):
thick=epitaxy_get_width(i)
material=epitaxy_get_mat_file(i)
dos_layer=epitaxy_get_electrical_layer(i)
pl_file=epitaxy_get_pl_file(i)
name=epitaxy_get_name(i)
self.add_row(i,thick,material,dos_layer,pl_file,name)
return
def add_row(self,i,thick,material,dos_layer,pl_file,name):
self.tab.blockSignals(True)
dos_file=""
if dos_layer.startswith("dos")==True:
dos_file="active layer"
else:
dos_file=dos_layer
item1 = QTableWidgetItem(str(name))
self.tab.setItem(i,0,item1)
item2 = QTableWidgetItem(str(thick))
self.tab.setItem(i,1,item2)
combobox = QComboBox()
#combobox.setEditable(True)
for a in self.material_files:
combobox.addItem(str(a))
self.tab.setCellWidget(i,2, combobox)
combobox.setCurrentIndex(combobox.findText(material))
p=combobox.palette()
p.setColor(QPalette.Active, QPalette.Button, Qt.white);
p.setColor(QPalette.Inactive, QPalette.Button, Qt.white);
combobox.setPalette(p)
#item3 = QTableWidgetItem(str(dos_file))
#self.tab.setItem(i,3,item3)
combobox_layer_type = QComboBox()
#combobox.setEditable(True)
combobox_layer_type.addItem("contact")
combobox_layer_type.addItem("active layer")
combobox_layer_type.addItem("other")
self.tab.setCellWidget(i,3, combobox_layer_type)
combobox_layer_type.setCurrentIndex(combobox_layer_type.findText(str(dos_file).lower()))
item3 = QTableWidgetItem(str(dos_layer))
self.tab.setItem(i,4,item3)
item3 = QTableWidgetItem(str(pl_file))
self.tab.setItem(i,5,item3)
scan_item_add("epitaxy.inp","#layer_material_file"+str(i),_("Material for ")+name,2)
scan_item_add("epitaxy.inp","#layer_width"+str(i),_("Layer width ")+name,1)
combobox.currentIndexChanged.connect(self.combo_changed)
combobox_layer_type.currentIndexChanged.connect(self.layer_type_edit)
self.tab.blockSignals(False)
def clean_dos_files(self):
files=inp_lsdir()
tab=[]
for i in range(0,self.tab.rowCount()):
tab.append(str(tab_get_value(self.tab,i, 4))+".inp")
for i in range(0,len(files)):
if files[i].startswith("dos") and files[i].endswith(".inp"):
disk_file=files[i]
if disk_file not in tab:
inp_remove_file(disk_file)
def on_remove_item_clicked(self):
tab_remove(self.tab)
self.save_model()
self.changed.emit()
def change_active_layer_thickness(self,obj):
thickness=obj.get_data("refresh")
count=0
for item in self.model:
if str2bool(item[COLUMN_DEVICE])==True:
count=count+1
if count==1:
for item in self.model:
if str2bool(item[COLUMN_DEVICE])==True:
item[COLUMN_THICKNES]=str(thickness)
self.save_model()
self.refresh(False)
return
def on_add_item_clicked(self):
row=tab_insert_row(self.tab)
self.add_row(row,"100e-9","pcbm","other","none","layer"+str(row))
self.save_model()
self.changed.emit()
def save_model(self):
thick=[]
mat_file=[]
dos_file=[]
pl_file=[]
name=[]
for i in range(0,self.tab.rowCount()):
name.append(str(tab_get_value(self.tab,i, 0)))
thick.append(str(tab_get_value(self.tab,i, 1)))
mat_file.append(str(tab_get_value(self.tab,i, 2)))
dos_file.append(str(tab_get_value(self.tab,i, 4)))
pl_file.append(str(tab_get_value(self.tab,i, 5)))
ret=epitaxy_load_from_arrays(name,thick,mat_file,dos_file,pl_file)
if ret==False:
error_dlg(self,_("Error in epitaxy, check the input values."))
epitaxy_save()
self.clean_dos_files()
#self.sync_to_electrical_mesh()
def callback_doping(self):
help_window().help_set_help(["doping.png",_("<big><b>Doping window</b></big>\nUse this window to add doping to the simulation")])
if self.doping_window==False:
self.doping_window=doping_window()
if self.doping_window.isVisible()==True:
self.doping_window.hide()
else:
self.doping_window.show()
def callback_cost(self):
help_window().help_set_help(["cost.png",_("<big><b>Costs window</b></big>\nUse this window to calculate the cost of the solar cell and the energy payback time.")])
if self.cost_window==False:
self.cost_window=cost()
if self.cost_window.isVisible()==True:
self.cost_window.hide()
else:
self.cost_window.show()
