class SettingsDialog(QDialog):
def __init__(self, scripter, parent=None):
super(SettingsDialog, self).__init__(parent)
self.scripter = scripter
self.setWindowTitle('Settings')
self.mainLayout = QFormLayout(self)
self.mainLayout.addRow(
'Syntax Highlither',
syntaxstylescombobox.SyntaxStylesComboBox(
self.scripter.uicontroller.highlight))
self.mainLayout.addRow(
'Fonts',
fontscombobox.FontsComboBox(self.scripter.uicontroller.editor))
def readSettings(self, settings):
for index in range(self.mainLayout.rowCount()):
widget = self.mainLayout.itemAt(index,
QFormLayout.FieldRole).widget()
widget.readSettings(settings)
def writeSettings(self, settings):
for index in range(self.mainLayout.rowCount()):
widget = self.mainLayout.itemAt(index,
QFormLayout.FieldRole).widget()
widget.writeSettings(settings)
class MainWindow(QMainWindow, Ui_MainWindow):
def __init__(self):
super().__init__()
self.setupUi(self)
self.setWindowTitle("Latte")
self.scrollLayout = QFormLayout()
self.scrollWidget = QWidget()
self.scrollWidget.setLayout(self.scrollLayout)
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setWidget(self.scrollWidget)
self.con = sqlite3.connect("coffee")
self.cur = self.con.cursor()
self.add_btn.clicked.connect(self.add_part)
self.refresh()
def clean_list(self):
while self.scrollLayout.itemAt(0) is not None:
self.scrollLayout.itemAt(0).widget().update()
self.scrollLayout.removeRow(0)
def refresh(self):
self.clean_list()
for el in self.cur.execute("""SELECT * FROM Coffee""").fetchall():
st = self.cur.execute(
f"SELECT title FROM Degrees WHERE id='{el[2]}'").fetchone()[0]
tp = self.cur.execute(
f"SELECT title FROM Types WHERE id='{el[3]}'").fetchone()[0]
self.scrollLayout.addWidget(
Part(id=el[0],
name=el[1],
degree=st,
type=tp,
desc=el[4],
price=el[5],
size=el[6],
parent=self))
def add_part(self):
quest = editCoffee()
quest.show()
quest.exec()
self.refresh()
def mousePressEvent(self, event):
'''When we click on an empty space the window will update list of parts'''
self.refresh()
def _get_operation_parameter_widget(form: QFormLayout,
param_name: str) -> QWidget:
for i in range(form.rowCount()):
label_item = form.itemAt(i * 2)
widget_item = form.itemAt(i * 2 + 1)
if label_item is not None and widget_item is not None:
label = label_item.widget()
assert isinstance(label, QLabel)
if label.text() == param_name:
return widget_item.widget()
raise ValueError(f"Could not find '{param_name}' in form")
class ListWidget(QWidget):
'''Parrent class for all tabs'''
def __init__(self, database_type_of_parts=None):
super().__init__()
uic.loadUi('content_widget.ui', self)
self.add_btn.clicked.connect(self.add_part)
# scroll area widget contents - layout
self.scrollLayout = QFormLayout()
# scroll area widget contents
self.scrollWidget = QWidget()
self.scrollWidget.setLayout(self.scrollLayout)
# scroll area
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setWidget(self.scrollWidget)
self.con = sqlite3.connect('database.db')
self.cur = self.con.cursor()
self.set_self_types(database_type_of_parts)
def set_self_types(self, type):
self.types_of_parts = type
def get_today_date(self):
return strftime("%Y-%m-%d", gmtime())
def get_type(self):
return self.types_of_parts
def refresh(self):
# function for refresh scrollWidget
pass
def clean_list(self):
while self.scrollLayout.itemAt(0) is not None:
self.scrollLayout.itemAt(0).widget().update()
self.scrollLayout.removeRow(0)
def get_res(self, type):
return self.cur.execute(f"""SELECT * FROM Inbox WHERE type = '{self.get_type()}'""")
def mousePressEvent(self, event):
'''When we click on an empty space the window will update list of parts'''
self.refresh()
def add_part(self):
part = Part(parent=self)
self.scrollLayout.addRow(part)
part.text_edit_clicked()
class PhasePatternSet(QWidget):
value_changed = pyqtSignal()
def __init__(self):
super().__init__()
self.layout = QFormLayout()
self.setLayout(self.layout)
@pyqtSlot()
def add_new_phase_pattern(self):
controller = PhasePatternController()
controller.value_changed.connect(self.value_changed.emit)
new_phase_pattern = CloseWrapper(controller)
new_phase_pattern.close.connect(
lambda: self.remove_pattern(new_phase_pattern))
self.layout.addRow(new_phase_pattern)
self.value_changed.emit()
def get_values(self):
return [
self.layout.itemAt(i).widget().wrapped_widget.get_values()
for i in range(self.layout.count())
]
def remove_pattern(self, pattern):
self.layout.removeRow(pattern)
self.value_changed.emit()
class ModelDialog(QDialog):
"""ModelDialog is the basic structure behind model dialogs in CATScore.
# Arguments
param_path: String, path to default parameters .json file.
"""
def __init__(self, param_path={}, parent=None):
super(ModelDialog, self).__init__(parent)
self.default_params = self._getParams(param_path)
print("Default params:")
print(json.dumps(self.default_params, indent=2))
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.buttonBox.setObjectName("model_buttonbox")
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.model_groupbox = QGroupBox()
self.model_groupbox.setTitle("Model hyperparameters")
self.tfidf_groupbox = QGroupBox()
self.tfidf_groupbox.setTitle('TF-IDF hyperparameters')
self.main_layout = QVBoxLayout()
self.form_layout = QFormLayout()
def saveParams(self):
"""Saves the parameters entered by the user.
"""
print("Default params after save:")
print(json.dumps(self.default_params, indent=2))
if (self.exec_() == QDialog.Accepted):
input_widgets = (self.form_layout.itemAt(i).widget() for i in range(self.form_layout.count()))
for widget in input_widgets:
if isinstance(widget, QDoubleSpinBox):
print('"' + widget.objectName() + '": {},'.format(widget.value()))
if isinstance(widget, QComboBox):
print('"' + widget.objectName() + '": {},'.format(widget.currentData()))
else:
print("Denied!")
def _getParams(self, path):
print("Path: {}".format(path))
svc_params = {
"clf__C": 1,
"clf__class_weight": None,
"clf__kernel": "linear",
"clf__tol": 0.001,
"clf__cache_size": 200,
"tfidf__max_df": 0.5,
"tfidf__min_df": 2,
"tfidf__ngram_range": [
1,
2
],
"tfidf__stop_words": None,
"tfidf__strip_accents": "unicode",
"tfidf__use_idf": False
}
return svc_params
class ViewportObjectsPane(QWidget):
def __init__(self, parent):
super(ViewportObjectsPane, self).__init__(parent)
self.screen_capture = ScreenCapture()
self.screen_capture.fire_once(self.on_first_screen_capture)
self.viewport_objects = ViewportObjects()
self.viewport_objects.bind(self.on_viewport_object_update)
self.form_layout = None
self.dragging_slider = False
self.object_widgets = {}
self.init_ui()
def init_ui(self):
self.form_layout = QFormLayout()
self.refresh_objects()
self.setLayout(self.form_layout)
def on_first_screen_capture(self, _):
for _, vp_object in self.object_widgets.items():
vp_object.update_states()
def on_viewport_object_update(self, _):
if not self.dragging_slider:
self.refresh_objects()
def refresh_objects(self):
for i in range(self.form_layout.count()):
self.form_layout.itemAt(i).widget().deleteLater()
self.object_widgets = {}
index = 0
for vp_object in self.viewport_objects.get():
name = vp_object.name
self.object_widgets[name] = ViewportObject(self, vp_object, index, self.on_slider_drag)
self.form_layout.addRow(self.object_widgets[name])
index += 1
def on_slider_drag(self, value):
self.dragging_slider = value
class AddEdgeWidget(QWidget):
def __init__(self, nodes, parent=None):
super(QWidget, self).__init__(parent)
self.nodes = nodes
self.initUI()
def initUI(self):
main_layout = QVBoxLayout()
self.setLayout(main_layout)
self.l = QFormLayout()
buttons_layout = QHBoxLayout()
main_layout.addLayout(self.l)
main_layout.addLayout(buttons_layout)
source = QComboBox()
destination = QComboBox()
pbOK = QPushButton()
pbOK.clicked.connect(lambda: self.parent().accept())
pbCancel = QPushButton()
pbCancel.clicked.connect(lambda: self.parent().reject())
source.addItems(self.nodes)
destination.addItems(self.nodes)
pbOK.setText("&OK")
pbCancel.setText("&Cancel")
buttons_layout.addWidget(pbOK)
buttons_layout.addWidget(pbCancel)
self.l.setWidget(0, QFormLayout.LabelRole, QLabel("Source Node"))
self.l.setWidget(0, QFormLayout.FieldRole, source)
self.l.setWidget(1, QFormLayout.LabelRole, QLabel("Destination Node"))
self.l.setWidget(1, QFormLayout.FieldRole, destination)
def getResults(self):
source = self.l.itemAt(0, QFormLayout.FieldRole).widget().currentText()
destination = self.l.itemAt(
1, QFormLayout.FieldRole).widget().currentText()
return (source, destination)
class Win(QMainWindow):
def __init__(self):
super(Win, self).__init__()
self.ui = uic.loadUi('form.ui', self)
self.ui.show()
self.LE_mode = False #False -- coefficients, True -- qbits
self.rb_qbit.mode = True
self.rb_coef.mode = False
self.rb_qbit.toggled.connect(self.changeMode)
self.rb_coef.toggled.connect(self.changeMode)
self.sa_layout = QFormLayout()
self.scrollAreaWidgetContents.setLayout(self.sa_layout)
self.operator = ""
self.b1 = False
self.b_X.op = "X"
self.b_X.toggled.connect(self.onClicked)
self.b_Y.op = "Y"
self.b_Y.toggled.connect(self.onClicked)
self.b_Z.op = "Z"
self.b_Z.toggled.connect(self.onClicked)
self.b_H.op = "H"
self.b_H.toggled.connect(self.onClicked)
self.b_R.op = "R"
self.b_R.toggled.connect(self.onClicked)
self.b_CNOT.op = "CNOT"
self.b_CNOT.toggled.connect(self.onClicked)
self.b_Fourier.op = "Fourier"
self.b_Fourier.toggled.connect(self.onClicked)
#self.line_out.setReadOnly(True)
rx = QRegExp('[0-9|,|.|-|j|+]*')
validator = QRegExpValidator(rx, self)
self.line_in.setValidator(validator)
self.line_in.textChanged.connect(self.line_in_f)
self.but_ACT.clicked.connect(self.act_f)
#BLOCKING
self.b_X.setEnabled(False)
self.b_Y.setEnabled(False)
self.b_Z.setEnabled(False)
self.b_H.setEnabled(False)
self.b_CNOT.setEnabled(False)
self.b_R.setEnabled(False)
self.b_Fourier.setEnabled(False)
def onClicked(self):
rb = self.sender()
if rb.isChecked():
self.b1 = True
if self.line_in.text() != "":
self.but_ACT.setEnabled(True)
self.operator = rb.op
#cleaning scrollarea widgets
n = self.sa_layout.rowCount()
while self.sa_layout.count():
c = self.sa_layout.takeAt(0)
if c.widget():
c.widget().deleteLater()
if rb.op == "R":
rx = QRegExp('[0-9|.|-]*')
validator = QRegExpValidator(rx, self)
par = QLineEdit()
par.setValidator(validator)
self.sa_layout.addRow("Тета", par)
if rb.op == "CNOT":
rx = QRegExp('[0-9|,]*')
validator = QRegExpValidator(rx, self)
par = QLineEdit()
par.setPlaceholderText("Номера управляющих кубитов")
par2 = QLineEdit()
par2.setPlaceholderText("Номера изменяемых кубитов")
par.setValidator(validator)
par2.setValidator(validator)
self.sa_layout.addRow("C", par)
self.sa_layout.addRow("NOT", par2)
def act_f(self):
ins = self.line_in.text()
if not self.LE_mode:
c = [complex(i) for i in ins.split(',')]
q = np.array([c], dtype=complex)
n = int(log(len(q[0]), 2)) #length in qbits
q = qregister(q.transpose()) #input qregister
res = qregister(np.array([[1]], dtype=complex))
else:
arg = list()
for c in ins:
if c == '0':
arg.append(qbit_0)
elif c == '1':
arg.append(qbit_1)
elif c == '+':
arg.append(qbit_sp)
elif c == '-':
arg.append(qbit_sn)
q = qregister(*arg)
n = len(q)
res = qregister(np.array([[1]], dtype=complex))
if self.operator == "X":
op = op_X**n
res = op @ q
elif self.operator == "Y":
op = op_Y**n
res = op @ q
elif self.operator == "Z":
op = op_Z**n
res = op @ q
elif self.operator == "H":
op = op_H**n
res = op @ q
elif self.operator == "Fourier":
res = fourier(q)
elif self.operator == "R":
try:
angle = float(self.sa_layout.itemAt(0, 1).widget().text())
except:
self.line_out.setText(
"Неправильно установлен коэффициент Тета")
return
op_R = qoperator(matrix.genpshift(angle, 1))
op = op_R**n
res = op @ q
elif self.operator == "CNOT":
try:
s = self.sa_layout.itemAt(0, 1).widget().text()
Cs = [int(i) for i in s.split(',')]
except Exception as e:
print(e)
self.line_out.setText("Ошибка обработки параметров C")
return
try:
s = self.sa_layout.itemAt(1, 1).widget().text()
NOTs = [int(i) for i in s.split(',')]
except:
self.line_out.setText("Ошибка обработки параметров NOT")
return
z = Cs + NOTs
for i in z:
if i > n:
self.line_out.setText("Превышение размеров курегистра")
return
Cs = np.array(Cs) - 1
NOTs = np.array(NOTs) - 1
list_1 = list()
list_2 = list()
for i in range(n):
list_1.append(op_I)
list_2.append(op_I)
for i in Cs:
list_1[i] = (qbit_0 @ qbit_0)
list_2[i] = (qbit_1 @ qbit_1)
for i in NOTs:
list_2[i] = op_X
op_l = op_I**0 #1
op_r = op_I**0
for i in list_1:
op_l = op_l * i
for i in list_2:
op_r = op_r * i
op = op_l + op_r #operator is ready
res = op @ q
print(res)
answer = ', '.join([str(e) for e in (res.vector.transpose()[0])])
self.line_out.setText(answer)
def line_in_f(self):
le = self.sender()
t = self.line_in.text()
if t != "":
r = self.checkparse(t)
#print(r)
if r > 0:
if r >= 1 and r < 2:
self.unblock1()
self.block2()
if r >= 2:
self.unblock1()
self.unblock2()
else:
self.block1()
self.block2()
if self.b1:
self.but_ACT.setEnabled(True)
else:
self.block1()
self.block2()
self.but_ACT.setEnabled(False)
def block1(self):
self.b_X.setEnabled(False)
self.b_Y.setEnabled(False)
self.b_Z.setEnabled(False)
self.b_H.setEnabled(False)
self.b_R.setEnabled(False)
def block2(self):
self.b_CNOT.setEnabled(False)
self.b_Fourier.setEnabled(False)
def unblock1(self):
self.b_X.setEnabled(True)
self.b_Y.setEnabled(True)
self.b_Z.setEnabled(True)
self.b_H.setEnabled(True)
self.b_R.setEnabled(True)
def unblock2(self):
self.b_CNOT.setEnabled(True)
self.b_Fourier.setEnabled(True)
def checkparse(self, ins: str):
if self.LE_mode == True:
arg = list()
for c in ins:
if c == '0':
arg.append(qbit_0)
elif c == '1':
arg.append(qbit_1)
elif c == '+':
arg.append(qbit_sp)
elif c == '-':
arg.append(qbit_sn)
return len(arg)
#else
try:
c = [complex(i) for i in ins.split(',')]
except:
return 0 # impossible operand
#print(c)
values = np.array(c, dtype=complex)
x = math.log(len(values), 2)
#print(x)
if x > 0:
if x % 1 == 0:
return x
return 0
def changeMode(self):
rb = self.sender()
if rb.mode != self.LE_mode:
self.line_in.setText("")
self.line_out.setText("")
self.LE_mode = rb.mode
if rb.mode == False:
rx = QRegExp('[0-9|,|.|-|j|+]*')
validator = QRegExpValidator(rx, self)
self.line_in.setValidator(validator)
else:
rx = QRegExp('[0|1|-|+]*')
validator = QRegExpValidator(rx, self)
self.line_in.setValidator(validator)
class AppWindows(QWidget):
def __init__(self):
super().__init__()
# 设置窗口标题及图标
self.setWindowTitle('Amazon商品信息分析')
self.setWindowIcon(QIcon('icon.ico'))
self.current_page = 1
self.results = None
self.len = None
self.Q = Manager().Queue()
self.p = None
self.log_thread = LogThread(self)
# 设置窗口居中显示
fg = self.frameGeometry()
fg.moveCenter(QDesktopWidget().availableGeometry().center())
self.move(fg.topLeft())
# 固定窗口大小
self.setFixedSize(1200, 675)
# self.setBaseSize(1200, 675)
# 添加水平主布局
self.main_layout = QHBoxLayout(self)
# 设置四周margin
self.main_layout.setContentsMargins(0, 0, 0, 0)
# 设置控件间间距
self.main_layout.setSpacing(0)
# 初始化控制窗口
self.__init_control_widget()
# 初始化显示窗口
self.__init_show_widget()
self.show()
# 控制窗口控件
def __init_control_widget(self):
self.control_widget = QWidget()
control_layout = QFormLayout(self.control_widget)
control_layout.setFormAlignment(Qt.AlignCenter)
control_layout.setSpacing(30)
self.control_widget.setFixedWidth(400)
# self.control_widget.setStyleSheet('QWidget{background-color:blue}')
self.main_layout.addWidget(self.control_widget, alignment=Qt.AlignLeft)
search_widget = QWidget()
search_layout = QHBoxLayout(search_widget)
search_label = QLabel()
search_label.setText('搜索关键字')
self.search_editer = QLineEdit()
self.search_editer.setPlaceholderText('亚马逊搜索关键字')
# self.search_editer.setFixedHeight(0)
search_layout.addWidget(search_label)
search_layout.addWidget(self.search_editer)
keywords_widget = QWidget()
keywords_layout = QHBoxLayout(keywords_widget)
keywords_label = QLabel()
keywords_label.setText('筛选关键字')
self.keywords_editer = QLineEdit()
self.keywords_editer.setPlaceholderText('请用;分隔搜索关键字')
keywords_layout.addWidget(keywords_label)
keywords_layout.addWidget(self.keywords_editer)
select_widget = QWidget()
select_layout = QHBoxLayout(select_widget)
self.jp_amazon = QRadioButton('日本亚马逊')
self.us_amazon = QRadioButton('美国亚马逊')
self.jp_amazon.setChecked(True)
select_layout.addWidget(self.jp_amazon)
select_layout.addWidget(self.us_amazon)
button_widget = QWidget()
button_layout = QHBoxLayout(button_widget)
self.clean_btn = QPushButton('清除')
self.clean_btn.clicked.connect(self.__clean)
self.search_btn = QPushButton('搜索')
self.search_btn.clicked.connect(self.__search)
button_layout.addWidget(self.clean_btn)
button_layout.addWidget(self.search_btn)
control_layout.addWidget(search_widget)
control_layout.addWidget(keywords_widget)
control_layout.addWidget(select_widget)
control_layout.addWidget(button_widget)
# 显示窗口控件
def __init_show_widget(self):
self.show_widget = QTabWidget()
self.show_widget.setFixedWidth(800)
# self.show_widget.setStyleSheet('QWidget{background-color:red}')
self.main_layout.addWidget(self.show_widget, alignment=Qt.AlignLeft)
self.__init_log_widget()
self.__init_result_widget()
# 日志窗口控件
def __init_log_widget(self):
self.log_widget = QWidget()
self.log_text = QTextBrowser(self.log_widget)
self.log_text.resize(793, 650)
self.show_widget.addTab(self.log_widget, "日志")
# 结果窗口控件
def __init_result_widget(self):
self.tab = QWidget()
self.tab_layout = QVBoxLayout(self.tab)
self.result_widget = QWidget()
self.page_widget = QWidget()
self.page_layout = QHBoxLayout(self.page_widget)
self.pre_btn = QPushButton('上一页')
self.pre_btn.clicked.connect(lambda: self.__change_page('pre'))
self.current_page_label = QLabel('1')
self.next_btn = QPushButton('下一页')
self.next_btn.clicked.connect(lambda: self.__change_page('next'))
self.result_layout = QFormLayout(self.result_widget)
self.result_layout.setFormAlignment(Qt.AlignTop)
self.tab_layout.addWidget(self.result_widget, alignment=Qt.AlignTop)
self.tab_layout.addWidget(self.page_widget, alignment=Qt.AlignBottom)
# self.result_text = QTextBrowser(self.result_widget)
# self.result_text.resize(793, 650)
# setStyleSheet("QTextBrowser{border-width:0;border-style:outset}");
self.show_widget.addTab(self.tab, "结果")
self.page_layout.addWidget(self.pre_btn, alignment=Qt.AlignCenter)
self.page_layout.addWidget(self.current_page_label,
alignment=Qt.AlignCenter)
self.page_layout.addWidget(self.next_btn, alignment=Qt.AlignCenter)
# self.results = filter_results(iPhone SE;Qi充電;第2世代;米軍MIL規格取得
# ['iPhone SE', 'Qi充電', '第2世代', '米軍MIL規格取得'])
def closeEvent(self, event):
if self.p:
self.p.terminate()
if self.log_thread:
self.log_thread.terminate()
def show_result(self, show, count):
self.len = count
self.current_page_label.setText('{}/{}'.format(
str(self.current_page), str(ceil(self.len / 10))))
for item in show:
commodity = Commodity(item['name'], item['page_index'],
item['page_link'], item['commodity_link'])
self.result_layout.addWidget(commodity)
@pyqtSlot()
def __search(self):
# 获取所要搜索的商品名称
self.current_page = 1
self.current_page_label.setText('')
self.log_text.setText('')
for i in range(self.result_layout.count()):
self.result_layout.itemAt(i).widget().deleteLater()
search = self.search_editer.text()
self.keywords = self.keywords_editer.text().split(';')
# 判断选择的网址
website = 'jp' if self.jp_amazon.isChecked() == True else 'us'
self.Q.put('开始爬取：{}'.format(search))
self.p = Process(target=start_crawl, args=(search, website, self.Q))
self.p.start()
# https://blog.csdn.net/La_vie_est_belle/article/details/102539029
self.log_thread.signal.connect(self.show_result)
self.log_thread.log_text_signal.connect(
lambda text: self.log_text.append(text))
self.log_thread.start()
@pyqtSlot()
def __clean(self):
self.search_editer.setText('')
self.keywords_editer.setText('')
self.log_text.setText('')
if os.path.exists('crawl.items'):
os.remove('crawl.items')
self.current_page = 1
for i in range(self.result_layout.count()):
self.result_layout.itemAt(i).widget().deleteLater()
pass
@pyqtSlot()
def __change_page(self, action):
if action == 'pre' and self.current_page > 1:
self.current_page = self.current_page - 1
elif action == 'pre' and self.current_page <= 1:
return
elif action == 'next' and self.current_page < ceil(self.len / 10):
self.current_page = self.current_page + 1
else:
return
# self.current_page_label.setText(
# '{}/{}'.format(str(self.current_page), str(ceil(self.len/10))))
self.current_page_label.setText('{}/{}'.format(
str(self.current_page), str(ceil(self.len / 10))))
for i in range(self.result_layout.count()):
self.result_layout.itemAt(i).widget().deleteLater()
start = (self.current_page - 1) * 10
end = self.current_page * 10
show = filter_results(self.keywords, start, end)
for item in show:
commodity = Commodity(item['name'], item['page_index'],
item['page_link'], item['commodity_link'])
self.result_layout.addWidget(commodity)
class SwipableListWidget(QWidget):
onElementClicked = pyqtSignal(str)
def __init__(
self,
controller: TouchManagerController,
model: TouchManagerModel,
):
super(QWidget, self).__init__()
self.model = model
self.controller = controller
self.main_layout = QGridLayout()
self.scroller = QScrollArea()
self.widget = QWidget()
self.verticalLayout = QFormLayout()
self.elementsDict = {}
self.lastElementSelected = ""
self.setupUI()
self.setMinimumWidth(300)
def setupUI(self):
self.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.main_layout)
self.main_layout.setContentsMargins(0, 0, 0, 0)
self.widget.setLayout(self.verticalLayout)
self.widget.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setSpacing(0)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.scroller.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.scroller.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.scroller.setWidgetResizable(True)
self.scroller.setWidget(self.widget)
self.scroller.setContentsMargins(0, 0, 0, 0)
self.main_layout.addWidget(self.scroller)
def addElement(self, button_name):
button = QtWidgets.QPushButton(button_name)
button.clicked.connect(partial(self._element_clicked, button_name))
self.elementsDict[button_name] = button
self.verticalLayout.addRow(self.elementsDict[button_name])
def _element_clicked(self, name):
self.onElementClicked.emit(name)
def onSelectionChanged(self, btn_name):
if self.lastElementSelected != "":
self.elementsDict[self.lastElementSelected].setStyleSheet(
"QPushButton { background-color : (225,225,225); }")
self.elementsDict[btn_name].setStyleSheet(
"background-color: rgb({}, {}, {})".format(self.model.ui_color[0],
self.model.ui_color[1],
self.model.ui_color[2]))
self.lastElementSelected = btn_name
def onDictChanged(self, new_source: dict):
self.clearLayout()
self.lastElementSelected = ""
for button_pos in new_source.items():
# button = QtWidgets.QPushButton("%s, %dx%d" %(button_pos[0], button_pos[1][0],button_pos[1][1]))
self.addElement(button_pos[0])
def clearLayout(self):
self.elementsDict.clear()
self.elementsDict = {}
for i in reversed(range(self.verticalLayout.count())):
self.verticalLayout.itemAt(i).widget().setParent(None)
class DynamicParamsSelectorView(QWidget):
""" Properties """
_selected = set()
_path_param_lines = []
_check_boxes = []
""" Init """
def __init__(self, presenter: ContentPresenter):
super().__init__()
self.presenter = presenter
self.box_layout = QVBoxLayout()
self.info_label = QWidget()
self.info_layout = QVBoxLayout()
self.path_param_values_label = QLabel("Path parameters:")
self.form_widget = QWidget()
self.setLayout(self.box_layout)
""" Public """
def update(self, view_model: ViewModel):
self._check_boxes = []
self._path_param_lines = []
self._reset_layout()
self._reset_input_form()
self._setup_path_params_input_view(view_model)
self.info_layout.addWidget(QLabel("Which values are dynamic?"))
self._setup_path_params_checkboxes(view_model)
self._setup_query_params_checkboxes(view_model)
self._setup_header_checkboxes(view_model)
self._setup_body_params_checkboxes(view_model)
""" Private """
def _reset_layout(self):
self.box_layout.removeWidget(self.info_label)
self.box_layout.removeWidget(self.path_param_values_label)
self.box_layout.removeWidget(self.form_widget)
self.info_label = QWidget()
self.info_layout = QVBoxLayout()
self.info_label.setLayout(self.info_layout)
self.setLayout(self.box_layout)
def _reset_input_form(self):
self.form_widget = QWidget()
self.form_layout = QFormLayout()
self.form_layout.setFormAlignment(QtCore.Qt.AlignmentFlag.AlignLeft)
self.form_widget.setMinimumWidth(300)
self.form_widget.setLayout(self.form_layout)
self.box_layout.addWidget(self.path_param_values_label)
self.box_layout.addWidget(self.form_widget)
self.box_layout.addWidget(self.info_label)
def _setup_path_params_checkboxes(self, view_model):
if view_model.request_content.path_params:
for path_param in view_model.request_content.path_params:
is_checked = view_model.dynamic_values[ParameterType.PATH_PARAM]
self._add_check_box(ParameterType.PATH_PARAM, path_param, is_checked)
def _setup_query_params_checkboxes(self, view_model):
if view_model.request_content.query_params:
for query_param in view_model.request_content.query_params:
is_checked = (
query_param in view_model.dynamic_values[ParameterType.QUERY_PARAM]
)
self._add_check_box(ParameterType.QUERY_PARAM, query_param, is_checked)
def _setup_header_checkboxes(self, view_model):
for header in view_model.request_content.headers:
is_checked = header in view_model.dynamic_values[ParameterType.HEADER]
self._add_check_box(ParameterType.HEADER, header, is_checked)
def _setup_path_params_input_view(self, view_model):
if view_model.request_content.path_params:
self.path_param_values_label.setVisible(True)
for path_param in view_model.request_content.path_params:
self._add_path_param_row(path_param)
else:
self.path_param_values_label.setVisible(False)
def _setup_body_params_checkboxes(self, view_model):
if view_model.request_content.body_param_rows:
for param_name in view_model.request_content.param_names:
is_checked = (
param_name[0] in view_model.dynamic_values[ParameterType.BODY_PARAM]
)
self._add_check_box(ParameterType.BODY_PARAM, param_name[0], is_checked)
def _add_check_box(self, param_type, title, is_checked):
check_box = QCheckBox(param_type.value + " - " + title)
if is_checked:
check_box.setChecked(True)
self._check_boxes.append(check_box)
check_box.stateChanged.connect(self._on_dynamic_parameter_selection_change)
self.info_layout.addWidget(check_box)
def _add_path_param_row(self, param_name):
path_param_line_edit = QLineEdit()
self._path_param_lines.append(path_param_line_edit)
self.form_layout.addRow(param_name + " = ", path_param_line_edit)
if param_name in self.presenter.path_parameters_dictionary:
text = self.presenter.path_parameters_dictionary[param_name]
path_param_line_edit.setText(text)
path_param_line_edit.textChanged.connect(self._on_path_param_line_edit_change)
def _on_path_param_line_edit_change(self):
params = {}
for index, line in enumerate(self._path_param_lines):
param_name = (
self.form_layout.itemAt(index, 0).widget().text().replace(" = ", "")
)
param_value = line.text()
params[param_name] = param_value
self.presenter.on_path_param_line_edit_change(params)
def _on_dynamic_parameter_selection_change(self):
selected = set()
for box in self._check_boxes:
if box.isChecked():
selected.add(box.text())
self.presenter.on_dynamic_parameter_selection_change(selected)
class EjournalApp(QWidget):
"""
This app facilitates the markup of journal articles.
There are two options: Generate the markdown file and Push to Jekyll.
The first takes user input and formats a markdown file for the user to
then add additional markup to.
The second takes a directory and pushes that directory to Jekyll for
HTML generation.
"""
'''
=========Variables for journals==========
Title of Journal: journal_title
Title of Article: art_title
Journal Volume: j_vol
Journal Issue: j_issue
Season: j_ssn
Year: j_year
Filename: j_filename
Dictionary of Authors: author_dict
Article Content: content
Article References: references
'''
def __init__(self):
"""
General layout is established and the create_ui method is invoked
to initialize the app's UI
"""
super().__init__()
self.container = QVBoxLayout(self)
self.form_widget = QWidget(self)
self.form_layout = QFormLayout()
self.layout = QVBoxLayout(self.form_widget)
self.init_gui = 0
self.setWindowTitle("Ejournal Editor")
self.create_ui()
def clear_layout_except(self, opt_removal=""):
"""
Clears the UI of every object except for the object passed in as
a param.
If no object is passed in, it clears everything.
"""
# clear the widgets that may be on the form_layout and btn_container
if opt_removal == '':
for i in reversed(range(self.form_layout.count())):
self.form_layout.itemAt(i).widget().deleteLater()
for i in reversed(range(self.btn_container.count())):
if self.btn_container.itemAt(i).widget() is None:
continue
else:
self.btn_container.itemAt(i).widget().deleteLater()
else:
for i in reversed(range(self.form_layout.count())):
if self.form_layout.itemAt(i).widget().whatsThis() == \
opt_removal:
continue
else:
self.form_layout.itemAt(i).widget().deleteLater()
def generate_md(self):
"""
This method is invoked after the user has entered the references.
It creates a MDGenerator Class object and invokes its
generate_md_file method, which creates the Markdown
file.
"""
self.references = self.ref_tb.toPlainText()
j_file_generator = MdGenerator(self.journal_title, self.art_title,
self.j_vol, self.j_issue, self.j_ssn, self.j_year, self.j_filename,
self.author_dict, self.content, self.references)
j_file_generator.generate_md_file()
notice = QMessageBox.information(self,
'Notice', "{}.md was created".format(self.j_filename.lower()),
QMessageBox.Ok)
def add_ref(self):
"""
This method generates a text area in which the user will input the
article's references
"""
# Sets the content to a global variable
self.content = self.content_tb.toPlainText()
self.clear_layout_except("back_btn")
# instructions for the user on signifiers for the MDGenerator class
ref_lb = QLabel("""Copy and paste references below.\n\n
Formatting Key:\n\n
Reference:\t\tr[*]]
""")
self.ref_tb = QTextEdit()
self.ref_tb.setAcceptRichText(True)
self.ref_tb.setMinimumSize(400, 400)
submit_btn = QPushButton("Submit and Generate MD File")
submit_btn.clicked.connect(self.generate_md)
self.form_layout.addRow(ref_lb)
self.form_layout.addRow(self.ref_tb)
self.form_layout.addRow(submit_btn)
def add_content(self):
"""
This method generates a text area in which the user will input
the article content
"""
self.clear_layout_except("back_btn")
# instructions for the user on signifiers for the MDGenerator class
content_lb = QLabel()
if self.j_filename == "clip":
content_lb.setText("""Copy and paste content below.\n\n
Formatting Key:\n\n
Book title:\t\t=\n
By-line:\t\t==\n
Genres:\t\t-=\n
Publisher:\t\t===\n
ISBN:\t\t-==\n
Entire body:\t>>*<<\n\n
If the body contains multiple paragraphs, each paragraph after the
first gets this put before it:\n
\t\tp[\n\n
* Represents the content\n\n
Signature:\n
Name:\t\t;=\n
Location:\t\t;==
""")
else:
content_lb.setText("""Copy and paste content below.\n\n
Formatting Key:\n\n
Paragraph:\t\tp[\n
Paragraph with bigFirst:\tpb[\n
Section header:\t\th[*]\n
Blockquote:\t\tq[*]\n\n
* Represents the content
""")
self.content_tb = QTextEdit()
self.content_tb.setAcceptRichText(True)
self.content_tb.setMinimumSize(400, 400)
submit_btn = QPushButton("Submit")
submit_btn.clicked.connect(self.add_ref)
self.form_layout.addRow(content_lb)
self.form_layout.addRow(self.content_tb)
self.form_layout.addRow(submit_btn)
def author_validation(self):
"""
Validation check for author input.
Displays an appropriate error to the error_lb if not valid.
"""
valid = False
for i in range(int(self.author_cb.currentText())):
if eval('self.firstname_le{}.text().strip() == ""'.format(i)) \
or \
eval('self.lastname_le{}.text().strip() == ""'.format(i)):
self.error_lb.setText("First and last names cannot be blank")
break
elif self.journal_title == \
"JCTE" and eval('self.affil_le{}.text().strip() == ""'.format(i)):
self.error_lb.setText("Affiliation cannot be blank")
break
else:
if i == int(self.author_cb.currentText()) - 1:
valid = True
# when the form passes validation, the author's names and their
# affiliation, if JCTE, are added to dictionaries
if valid:
self.author_dict = dict()
if "Clip" in self.art_title:
# currently, ALAN's Clip&File
# has an author, but the filename is clip
self.j_filename = "clip"
else:
self.j_filename = self.lastname_le0.text().strip()
for i in range(int(self.author_cb.currentText())):
auth_name = eval('" ".join((self.prefix_le{}.text(), \
self.firstname_le{}.text(),'.format(i, i)
+ 'self.middle_le{}.text())).strip()'.format(i))
auth_name = eval('" ".join((auth_name, \
self.suffix_cb{}.currentText())).strip()'.format(i))
auth_name = eval('", ".join((self.lastname_le{}.text(),\
auth_name))'.format(i))
if self.journal_title == "JCTE":
self.author_dict[i] = \
(eval('self.affil_le{}.text().strip()'.format(i)),\
auth_name)
else:
self.author_dict[i] = auth_name
self.add_content()
def update_authors(self):
"""
This method does the heavy-lifting for the author building.
It's called every time the value in the author_cb changes.
"""
# sets tuple to hold acceptable suffixes
self.suffixes = (" ", "CPA", "D.C.", "D.D.", "D.D.S.", "D.M.D.",
"D.O.", "D.V.M.", "Ed.D.", "Esq.", "II", "III", "IV", "J.D.", "Jr.",
"LL.D.", "M.D.", "O.D.", "Ph.D.", "R.N.", "R.N.C.", "Sr.")
self.clear_layout_except("author_cb")
# iterates through based on the value of author_cb,
# creating i number of author input sections
for i in range(int(self.author_cb.currentText())):
self.prefix_lb = QLabel("Prefix: ")
# exec and eval functions are called to insert string
# formatting into variables b/c of iteration
exec('self.prefix_le{} = QLineEdit()'.format(i))
exec('self.prefix_le{}.setMinimumSize(300, 10)'.format(i))
self.firstname_lb = QLabel("First name: ")
exec('self.firstname_le{} = QLineEdit()'.format(i))
exec('self.firstname_le{}.setMinimumSize(300, 10)'.format(i))
self.middle_lb = QLabel("Middle name: ")
exec('self.middle_le{} = QLineEdit()'.format(i))
exec('self.middle_le{}.setMinimumSize(300, 10)'.format(i))
self.lastname_lb = QLabel("Last name: ")
exec('self.lastname_le{} = QLineEdit()'.format(i))
exec('self.lastname_le{}.setMinimumSize(300, 10)'.format(i))
self.suffix_lb = QLabel("Suffix: ")
exec('self.suffix_cb{} = QComboBox()'.format(i))
exec('self.suffix_cb{}.setMinimumSize(300, 10)'.format(i))
for suffix in self.suffixes:
eval('self.suffix_cb{}'.format(i)).addItem(suffix)
self.spacer_lb = QLabel("--------------------------")
# Creates Afiliations section if the journal is JCTE
if self.journal_title == "JCTE":
self.affil_lb = QLabel("Affiliations:")
exec('self.affil_le{} = QLineEdit()'.format(i))
exec('self.affil_le{}.setMinimumSize(300, 10)'.format(i))
self.spacer_lb.setMinimumSize(300, 10)
exec('self.form_layout.addRow(self.prefix_lb,\
self.prefix_le{})'.format(i))
exec('self.form_layout.addRow(self.firstname_lb,\
self.firstname_le{})'.format(i))
exec('self.form_layout.addRow(self.middle_lb,\
self.middle_le{})'.format(i))
exec('self.form_layout.addRow(self.lastname_lb,\
self.lastname_le{})'.format(i))
exec('self.form_layout.addRow(self.suffix_lb,\
self.suffix_cb{})'.format(i))
self.form_layout.addRow(self.spacer_lb)
# JCTE has special affiliations field for its authors
if self.journal_title == "JCTE":
exec('self.form_layout.addRow(self.affil_lb,\
self.affil_le{})'.format(i))
self.form_layout.addRow(self.spacer_lb)
content_btn = QPushButton("Add content")
content_btn.clicked.connect(self.author_validation)
self.error_lb = QLabel("")
self.error_lb.setMinimumSize(300, 10)
self.form_layout.addRow(self.error_lb)
self.form_layout.addRow(content_btn)
def add_authors(self):
"""
Method that builds the screen and dropdown combobox for the authors
"""
self.clear_layout_except("back_btn")
self.author_cb = QComboBox()
for i in range(1, 11):
i = str(i)
self.author_cb.addItem(i)
self.author_cb.setWhatsThis("author_cb")
self.form_layout.addRow(self.author_cb)
# initial call to update_authors sets the screen up for one author
self.update_authors()
# this line watches for the value to change in the dropdown combobox
# if it does change, update_authors is called again to
# build screen based on new number of authors
self.author_cb.activated[str].connect(self.update_authors)
def metadata_validate(self, has_authors=True):
"""
Method to validate article metadata
"""
valid = False
# Place variables in tuple for validation
data = (
self.title_le.text().strip(),
self.vol_cb.currentText(),
self.issue_cb.currentText(),
self.ssn_cb.currentText(),
self.year_cb.currentText()
)
for d in data:
if d == "": # Checks for blanks
self.error_lb.setText("No field can be left blank.")
break
# Each of the following checks for inputs that are not an option
elif data.index(d) == 1 and self.vol_cb.findText(d) == -1:
self.error_lb.setText("Please select a volume from the list.")
break
elif data.index(d) == 2 and self.issue_cb.findText(d) == -1:
self.error_lb.setText("Please select an issue from the list.")
break
elif data.index(d) == 3 and self.ssn_cb.findText(d) == -1:
self.error_lb.setText("Please select a season from the list.")
break
elif data.index(d) == 4 and self.year_cb.findText(d) == -1:
self.error_lb.setText("Please select a year from the list.")
break
else:
if data.index(d) == 4: # if all checks pass and it's the last
# item in the list, validate the data
valid = True
if valid: # if the data are valid
self.art_title = data[0]
self.j_vol = data[1]
self.j_issue = data[2]
self.j_ssn = data[3]
self.j_year = data[4]
if has_authors:
self.add_authors()
else:
self.author_dict = dict() # set the author var to empty
if "Clip" in self.art_title:
self.j_filename = "clip"
elif "Editor" in self.art_title:
self.j_filename = "editors"
elif "Manuscript" in self.art_title:
self.j_filename = "manuscript"
elif "Misc" in self.art_title:
self.j_filename = "miscellany"
elif "Instruction" in self.art_title:
self.j_filename = "authors"
elif "Guideline" in self.art_title:
self.j_filename = "guidelines"
elif "Stories" in self.art_title:
self.j_filename = "stories"
self.add_content()
def show_journal_metadata(self, journal_title):
"""
Second screen user is presented.
It takes the title of the Journal as a param to set it globally
after the corresponding btn was chosen on the previous
screen--in the show_journal_chooser method.
"""
self.clear_layout_except("back_btn")
self.journal_title = journal_title
issue_range = ("1", "2", "3", "4")
seasons = ("Fall", "Winter", "Spring", "Summer")
header_lb = QLabel(self.journal_title + " Issue Metadata")
title_lb = QLabel("Title: ")
self.title_le = QLineEdit()
self.title_le.setMinimumSize(300, 10)
vol_lb = QLabel("Volume: ")
self.vol_cb = QComboBox()
self.vol_cb.setEditable(True)
# set autocompleters
self.vol_cb.completer().setCompletionMode(QCompleter.PopupCompletion)
self.vol_cb.setMinimumSize(300, 10)
for i in range(1, 201):
i = str(i)
self.vol_cb.addItem(i)
issue_lb = QLabel("Issue: ")
self.issue_cb = QComboBox()
self.issue_cb.setEditable(True)
self.issue_cb.completer().setCompletionMode(QCompleter.PopupCompletion)
self.issue_cb.setMinimumSize(300, 10)
for i in issue_range:
self.issue_cb.addItem(i)
ssn_lb = QLabel("Season: ")
self.ssn_cb = QComboBox()
self.ssn_cb.setEditable(True)
self.ssn_cb.completer().setCompletionMode(QCompleter.PopupCompletion)
self.ssn_cb.setMinimumSize(300, 10)
for ssn in seasons:
self.ssn_cb.addItem(ssn)
year_lb = QLabel("Year: ")
self.year_cb = QComboBox()
self.year_cb.setEditable(True)
self.year_cb.completer().setCompletionMode(QCompleter.PopupCompletion)
self.year_cb.setMinimumSize(300, 10)
for i in range(1900, 2101):
i = str(i)
self.year_cb.addItem(i)
authors_btn = QPushButton("Add Authors", self)
no_authors_btn = QPushButton("No Authors", self)
self.error_lb = QLabel("") # error label
authors_btn.clicked.connect(partial(self.metadata_validate, True))
no_authors_btn.clicked.connect(partial(self.metadata_validate, False))
self.form_layout.addRow(header_lb)
self.form_layout.addRow(title_lb, self.title_le)
self.form_layout.addRow(vol_lb, self.vol_cb)
self.form_layout.addRow(issue_lb, self.issue_cb)
self.form_layout.addRow(ssn_lb, self.ssn_cb)
self.form_layout.addRow(year_lb, self.year_cb)
self.form_layout.addRow(authors_btn)
self.form_layout.addRow(no_authors_btn)
self.form_layout.addRow(self.error_lb)
def show_journal_chooser(self):
"""
First metadata option for user when generation MD file
"""
self.clear_layout_except("back_btn")
self.journalList = ('ALAN', 'JCTE', 'JOTS', 'JTE', 'VALib')
for journal in self.journalList:
btn = QPushButton(journal, self)
btn.setMinimumSize(300, 40)
btn.setMaximumSize(300, 40)
btn.setWhatsThis(journal)
btn.clicked.connect(partial(self.show_journal_metadata, journal))
self.form_layout.addRow(btn)
self.btn_container = QHBoxLayout()
self.btn_container.addStretch(1)
self.back_btn = QPushButton("Back to options", self)
self.back_btn.setWhatsThis("back_btn")
self.back_btn.setMinimumSize(150, 40)
self.back_btn.setMaximumSize(150, 40)
self.back_btn.clicked.connect(self.create_ui)
self.btn_container.addWidget(self.back_btn)
# Back button is added to the container
# it remains unless a complete reset of the UI is called
self.layout.addLayout(self.btn_container)
def show_directory_chooser(self):
"""
Opens a directory browser for the user to choose the dir containing
the MD files.
Once a directory is chosen, it is passed on to a Jekyll Class
Object, which generates the HTMl via the Ruby Jekyll Generator
(not to be confused with the Jekyll Class Object created by
this program).
"""
user = os.getlogin()
md_directory = QFileDialog.getExistingDirectory(None, 'Select folder:',
'/Users/' + user + '/Desktop', QFileDialog.ShowDirsOnly)
# Creates a Jekyll object and generates the HTML files
if md_directory:
jekyll = Jekyll(md_directory)
jekyll.serve_html_files()
notice = QMessageBox.information(self, 'Notice',
"HTML files were generated", QMessageBox.Ok)
del jekyll
def create_ui(self):
"""
Sets up the main UI screen for the App.
"""
# If first time, added everything to the layout
if self.init_gui == 0:
self.md_btn = QPushButton('Generate the Markdown file', self)
self.jekyll_btn = QPushButton('Push to Jekyll', self)
self.md_btn.setMinimumSize(300, 40)
self.md_btn.setMaximumSize(300, 40)
self.jekyll_btn.setMinimumSize(300, 40)
self.jekyll_btn.setMaximumSize(300, 40)
self.md_btn.clicked.connect(self.show_journal_chooser)
self.jekyll_btn.clicked.connect(self.show_directory_chooser)
self.form_layout.addRow(self.md_btn)
self.form_layout.addRow(self.jekyll_btn)
self.setMinimumSize(800, 700)
self.scroll_area = QScrollArea()
self.scroll_area.setWidgetResizable(True)
self.container.addWidget(self.scroll_area)
self.layout.addLayout(self.form_layout)
self.scroll_area.setWidget(self.form_widget)
self.init_gui = 1
# i.e., Back to Options button has been pressed, re-init the UI
else:
self.clear_layout_except()
self.md_btn = QPushButton('Generate the Markdown file', self)
self.jekyll_btn = QPushButton('Push to Jekyll', self)
self.md_btn.setMinimumSize(300, 40)
self.md_btn.setMaximumSize(300, 40)
self.jekyll_btn.setMinimumSize(300, 40)
self.jekyll_btn.setMaximumSize(300, 40)
self.md_btn.clicked.connect(self.show_journal_chooser)
self.jekyll_btn.clicked.connect(self.show_directory_chooser)
self.form_layout.addRow(self.md_btn)
self.form_layout.addRow(self.jekyll_btn)
self.setMinimumSize(800, 700)
self.show()
class LiftHistory(QScrollArea):
def __init__(self):
super().__init__()
self.db_wrapper = DatabaseWrapper()
self.table_name = "Compound Exercises"
self.setStyleSheet("""
QWidget{
background-color: #232120;
font-weight: bold;
color:#c7c7c7;
}
QPushButton{
background-color: rgba(0, 0, 0, 0);
border: 1px solid;
font-size: 18px;
font-weight: bold;
border-color: #808080;
min-height: 28px;
white-space:nowrap;
text-align: center;
padding-left: 5%;
font-family: Montserrat;
}
QPushButton:hover:!pressed{
border: 2px solid;
border-color: #747474;
}
QPushButton:pressed{
border: 2px solid;
background-color: #323232;
}
""")
self.setWindowFlags(Qt.FramelessWindowHint | Qt.Tool)
self.setWindowModality(Qt.ApplicationModal)
self.units = "kg" if self.db_wrapper.fetch_local_column("Users", "units") == "metric" else "lb"
self.setWindowTitle("Lift History")
widget = QWidget()
self.layout = QFormLayout(widget)
self.setWidget(widget)
self.setWidgetResizable(True)
self.create_history(True, True)
@pyqtSlot(bool)
def create_history(self, create, init_layout=False):
exercise_label = QLabel("Exercise")
exercise_label.setAlignment(Qt.AlignCenter)
delete_label = QLabel("Delete")
delete_label.setAlignment(Qt.AlignCenter)
helper_layout = QFormLayout()
helper_layout.addRow(exercise_label, delete_label)
self.lift_history = self.db_wrapper.fetch_local_column(self.table_name, "lift_history")
if create and not self.lift_history == None:
if not init_layout:
if not self.db_wrapper.connection_exists: return
self.delete_history()
lift_history = json.loads(self.lift_history)
self.labels = [None] * len(lift_history)
self.delete_buttons = [None] * len(lift_history)
for i in range(len(lift_history)):
self.labels[i] = QLabel(self)
self.delete_buttons[i] = QPushButton("X", self)
for j, exercise in enumerate(lift_history):
try:
self.labels[j].setText(": ".join([exercise[0], " ".join([exercise[1], self.units])]))
except TypeError: # joining lift for reps as 1RM lift
self.labels[j].setText(": ".join([exercise[0], " ".join(["x".join(exercise[1]), self.units])]))
self.delete_buttons[j].setProperty("entry_index", exercise[-1])
self.delete_buttons[j].clicked.connect(partial(self.delete_history_entry_from_layout, j, self.delete_buttons[j].property("entry_index")))
helper_layout.addRow(self.labels[j], self.delete_buttons[j])
scroll_area = QScrollArea()
scroll_area.setContentsMargins(3, 3, 3, 3)
scroll_area.setWidgetResizable(True)
helper_widget = QWidget()
helper_widget.setLayout(helper_layout)
scroll_area.setWidget(helper_widget)
self.layout.addRow(scroll_area)
close_button = QPushButton("Close")
close_button.clicked.connect(lambda:self.close())
self.layout.addRow(close_button)
def delete_history(self):
for i in reversed(range(self.layout.count())):
self.layout.itemAt(i).widget().setParent(None)
def delete_history_entry_from_layout(self, i, entry_index):
self.labels[i].setParent(None)
self.delete_buttons[i].setParent(None)
history = json.loads(self.db_wrapper.fetch_local_column(self.table_name, "lift_history"))
lift_history = [lift for lift in history if not lift[-1] == entry_index]
if len(lift_history) == 0: lift_history = None
else: lift_history = json.dumps(lift_history)
self.db_wrapper.update_table_column(self.table_name, "lift_history", lift_history, True)
class MainWindow(QMainWindow):
def __init__(self, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.setWindowTitle("Testing GUI")
self.weighted_freq_jump_ranges = {}
self.num_of_ranges = 0
self.times = []
self.water_percent = []
self.main_layout = QVBoxLayout()
self.waveform_layout = QHBoxLayout()
self.run_waveform = createButton("Run Waveform", False,
self.enableWaveform)
#Create all the widgets for wave type
self.wave_type_layout = QVBoxLayout()
self.wave_type_layout.setSpacing(5)
self.wave_type_layout.setContentsMargins(0, 0, 0, 0)
#Label for Wave Types
self.wave_label = createLabel("Primary Wave Type")
#Button for sinusoid
self.sinusoid_wave = createButton("Sinusoid", True, self.enableSine)
self.sinusoid_wave.clicked.connect(self.enableSine)
#Button for square wave
self.square_wave = createButton("Square Wave", False,
self.enableSquare)
#Adds all the wavetype widgets
self.wave_type_layout.addWidget(self.wave_label)
self.wave_type_layout.addWidget(self.sinusoid_wave)
self.wave_type_layout.addWidget(self.square_wave)
#Label specifying wave carrier
self.wave_modulation_label = createLabel("Type of Wave Modulation")
#Button for Trapezoid Modulation
self.sinusoid_modulation = createButton("Sinusoidal Modulation", False,
self.setSinsuoidMod)
#Button for Sinusoid Modulation
self.trapezoid_modulation = createButton("Trapezoidal Modulation",
False, self.setTrapezoidMod)
self.wave_type_layout.addWidget(self.wave_modulation_label)
self.wave_type_layout.addWidget(self.sinusoid_modulation)
self.wave_type_layout.addWidget(self.trapezoid_modulation)
#Creates all the widgets for primary waveform measurements
self.wave_measurement_layout = QVBoxLayout()
self.wave_measurement_layout.setContentsMargins(0, 0, 0, 0)
self.wave_measurement_layout.setSpacing(5)
self.wave_measurement_label = createButton(
"Measurements for Primary Waveform", True, self.keepOn)
#Used for setting Wave Amplitude
self.wave_amplitude_label = createLabel("Wave Amplitude: 0.46")
self.wave_amplitude_slider = createHorizontalSlider(
0, 91, 46, self.setAmplitude)
#Used for setting Wave Frequency
self.wave_frequency_label = createLabel("Wave Frequency: 500")
self.wave_frequency_slider = createHorizontalSlider(
0, 999, 500, self.setFrequency)
#Used for setting Wave Symmetry
self.wave_symmetry_label = createLabel("Wave Symmetry (%): 50")
self.wave_symmetry_slider = createHorizontalSlider(
0, 99, 50, self.setSymmetry)
self.wave_measurement_layout.addWidget(self.wave_measurement_label)
self.wave_measurement_layout.addWidget(self.wave_amplitude_label)
self.wave_measurement_layout.addWidget(self.wave_amplitude_slider)
self.wave_measurement_layout.addWidget(self.wave_frequency_label)
self.wave_measurement_layout.addWidget(self.wave_frequency_slider)
self.wave_measurement_layout.addWidget(self.wave_symmetry_label)
self.wave_measurement_layout.addWidget(self.wave_symmetry_slider)
##############################################################
##############################################################
#Creates all the widgets for carrier waveform measurements
self.pulse_mod_layout = QVBoxLayout()
self.pulse_mod_layout.setContentsMargins(0, 0, 0, 0)
self.pulse_mod_layout.setSpacing(5)
self.pulse_mod = createButton("Pulse Modulation", False,
self.enablePulseModulation)
self.pulse_mod_duty_cycle_label = createLabel("Duty Cycle (%): 50")
self.pulse_mod_duty_cycle_slider = createHorizontalSlider(
0, 99, 50, self.setModDutyCycle)
#Used for setting Wave Frequency
self.pulse_mod_frequency_label = createLabel("Frequency: 50")
self.pulse_mod_frequency_slider = createHorizontalSlider(
0, 99, 50, self.setModFrequency)
#Used for setting Wave Symmetry
self.pulse_mod_rise_time_label = createLabel("Rise Time (%): 50")
self.pulse_mod_rise_time_slider = createHorizontalSlider(
0, 99, 50, self.setModRiseTime)
self.pulse_mod_layout.addWidget(self.pulse_mod)
self.pulse_mod_layout.addWidget(self.pulse_mod_duty_cycle_label)
self.pulse_mod_layout.addWidget(self.pulse_mod_duty_cycle_slider)
self.pulse_mod_layout.addWidget(self.pulse_mod_frequency_label)
self.pulse_mod_layout.addWidget(self.pulse_mod_frequency_slider)
self.pulse_mod_layout.addWidget(self.pulse_mod_rise_time_label)
self.pulse_mod_layout.addWidget(self.pulse_mod_rise_time_slider)
##############################################################
##############################################################
#Creates all the widgets for carrier waveform measurements
self.sweep_layout = QVBoxLayout()
self.sweep_layout.setContentsMargins(0, 0, 0, 0)
self.sweep_layout.setSpacing(5)
self.sweep = createButton("Sweep Frequency", False,
self.enablePulseModulation)
self.sweep_min_freq_label = createLabel("Minimum Frequency: 500")
self.sweep_min_freq_slider = createHorizontalSlider(
0, 999, 500, self.setMinSweepFreq)
#Used for setting Wave Frequency
self.sweep_max_freq_label = createLabel("Maximum Frequency: 500")
self.sweep_max_freq_slider = createHorizontalSlider(
0, 999, 500, self.setMaxSweepFreq)
#Used for setting Wave Symmetry
self.sweep_time_label = createLabel("Sweep Time (s): 50")
self.sweep_time_slider = createHorizontalSlider(
0, 99, 50, self.setSweepTime)
self.sweep_layout.addWidget(self.sweep)
self.sweep_layout.addWidget(self.sweep_min_freq_label)
self.sweep_layout.addWidget(self.sweep_min_freq_slider)
self.sweep_layout.addWidget(self.sweep_max_freq_label)
self.sweep_layout.addWidget(self.sweep_max_freq_slider)
self.sweep_layout.addWidget(self.sweep_time_label)
self.sweep_layout.addWidget(self.sweep_time_slider)
##############################################################
##############################################################
#Make all the widgets for random jumping the waveforms
self.wave_jumping_layout = QVBoxLayout()
self.wave_jumping_layout.setContentsMargins(0, 0, 0, 0)
self.wave_jumping_layout.setSpacing(5)
self.freq_jumping = createButton("Random Frequency Jumping", False,
self.enableFreqJumping)
self.freq_jump_cycle_label = createLabel(
"Cycles Before Frequency Jump: 50", alignment=0)
self.freq_jump_cycle_slider = createHorizontalSlider(
0, 99, 50, self.setFreqJumpCycles)
self.freq_jump_diff_label = createLabel(
"Maximum Frequency Difference: 500", alignment=0)
self.freq_jump_difference = createHorizontalSlider(
0, 999, 500, self.setMaxFreqJump)
self.amp_jumping = createButton("Random Amplitude Jumping", False,
self.enableAmpJumping)
self.amp_jump_cycle_label = createLabel(
"Cycles Before Amplitude Jump: 50", alignment=0)
self.amp_jump_cycle_slider = createHorizontalSlider(
0, 99, 50, self.setAmpJumpCycles)
self.amp_jump_diff_label = createLabel(
"Maximum Amplitude Difference: 0.50", alignment=0)
self.amp_jump_difference = createHorizontalSlider(
0, 99, 50, self.setMaxAmpJump)
#Add all the waveform jumping widgets
self.wave_jumping_layout.addWidget(self.freq_jumping)
self.wave_jumping_layout.addWidget(self.freq_jump_cycle_label)
self.wave_jumping_layout.addWidget(self.freq_jump_cycle_slider)
self.wave_jumping_layout.addWidget(self.freq_jump_diff_label)
self.wave_jumping_layout.addWidget(self.freq_jump_difference)
self.wave_jumping_layout.addWidget(self.amp_jumping)
self.wave_jumping_layout.addWidget(self.amp_jump_cycle_label)
self.wave_jumping_layout.addWidget(self.amp_jump_cycle_slider)
self.wave_jumping_layout.addWidget(self.amp_jump_diff_label)
self.wave_jumping_layout.addWidget(self.amp_jump_difference)
##############################################################
##############################################################
#Make all the widgets for weighted jumping of the waveforms
self.weighted_freq_jump_layout = QVBoxLayout()
self.weighted_freq_jump_layout.setContentsMargins(0, 0, 0, 0)
self.weighted_freq_jump_layout.setSpacing(5)
self.weighted_freq_jump_button = createButton(
"Weighted Frequency Jumping", False, self.enableWeightedFreq)
self.weighted_freq_box = QGroupBox("Weighted Frequency Range")
self.weighted_freq_form_layout = QFormLayout()
self.weighted_freq_form_layout.addRow(QLabel("Lower Frequency Bound:"),
QLineEdit())
self.weighted_freq_form_layout.addRow(QLabel("Upper Frequency Bound:"),
QLineEdit())
self.weighted_freq_form_layout.addRow(QLabel("Weight (integer):"),
QLineEdit())
self.weighted_freq_box.setLayout(self.weighted_freq_form_layout)
self.single_form = QFormLayout()
self.single_form.addRow(QLabel("Cycles before Frequency Jump: "),
QLineEdit())
self.weighted_freq_range_button = createButton(
"Add Weighted Frequency Range", False, self.addWeightedFreqRange)
#Add all the waveform jumping widgets
self.weighted_freq_jump_layout.addWidget(
self.weighted_freq_jump_button)
self.weighted_freq_jump_layout.addWidget(self.weighted_freq_box)
self.weighted_freq_jump_layout.addLayout(self.single_form)
self.weighted_freq_jump_layout.addWidget(
self.weighted_freq_range_button)
##############################################################
##############################################################
#Add all the different layouts to the waveform layout
self.waveform_layout.addLayout(self.wave_type_layout, 1)
self.waveform_layout.addLayout(self.wave_measurement_layout, 2)
self.waveform_layout.addLayout(self.pulse_mod_layout, 2)
self.waveform_layout.addLayout(self.sweep_layout, 2)
self.waveform_layout.addLayout(self.wave_jumping_layout, 2)
self.waveform_layout.addLayout(self.weighted_freq_jump_layout, 2)
##############################################################
##############################################################
#Video widget with pause and play buttons
self.video_widget = QVideoWidget()
self.open_video_button = QPushButton("Open Video")
self.open_video_button.setToolTip("Open Video File")
self.open_video_button.setStatusTip("Open Video File")
self.open_video_button.setFixedHeight(24)
self.open_video_button.setIconSize(QSize(16, 16))
self.open_video_button.setIcon(
QIcon.fromTheme("document-open", QIcon("D:/_Qt/img/open.png")))
self.open_video_button.clicked.connect(self.open_video)
self.play_video = QPushButton()
self.play_video.setEnabled(False)
self.play_video.setFixedHeight(24)
self.play_video.setIconSize(QSize(16, 16))
self.play_video.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.play_video.clicked.connect(self.play)
self.video_slider = QSlider(Qt.Horizontal)
self.video_slider.setRange(0, 15)
self.video_slider.sliderMoved.connect(self.setPosition)
self.video_control_layout = QHBoxLayout()
self.video_control_layout.setContentsMargins(0, 0, 0, 0)
self.video_control_layout.addWidget(self.open_video_button)
self.video_control_layout.addWidget(self.play_video)
self.video_control_layout.addWidget(self.video_slider)
self.media_player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.media_player.setVideoOutput(self.video_widget)
self.media_player.positionChanged.connect(self.positionChanged)
self.media_player.durationChanged.connect(self.durationChanged)
self.video_layout = QVBoxLayout()
self.video_layout.addWidget(self.video_widget)
self.video_layout.addLayout(self.video_control_layout)
##############################################################
##############################################################
#Graph of water percent obscuration vs time
self.graph = pg.PlotWidget(self)
self.graph.plot(self.times, self.water_percent)
self.graph.setLabel('bottom', text='Time', units='s')
self.graph.setLabel('left', text='Percent Obscuration', units='%')
self.graph.setYRange(0, 105, padding=0)
##############################################################
##############################################################
#Adds all the layouts to the main layout/screen
self.upper_layout = QHBoxLayout()
self.upper_layout.addLayout(self.video_layout)
self.upper_layout.addWidget(self.graph)
self.main_layout.addLayout(self.upper_layout)
self.main_layout.addWidget(self.run_waveform)
self.main_layout.addLayout(self.waveform_layout)
main_screen = QWidget()
main_screen.setLayout(self.main_layout)
self.setCentralWidget(main_screen)
def enableWaveform(self):
if (self.run_waveform.isChecked()):
out = "1"
else:
out = "0"
#Append the carrier wave values
out += 'c'
if (self.square_wave.isChecked()):
out += "1"
else:
out += "0"
out += str(self.wave_frequency_slider.value()).zfill(3)
out += "0." + str(self.wave_amplitude_slider.value()).zfill(2)
out += "0." + str(self.wave_symmetry_slider.value()).zfill(2)
#Append the Pulse Modulation Values
out += 'p'
if (self.pulse_mod.isChecked()):
out += "1"
else:
out += "0"
if (self.sinusoid_modulation.isChecked()):
out += "2"
else:
out += "1"
out += "0." + str(self.pulse_mod_duty_cycle_slider.value()).zfill(2)
out += str(self.pulse_mod_frequency_slider.value()).zfill(2)
out += str(self.pulse_mod_rise_time_slider.value()).zfill(2)
#Append the Sweep Values
out += 's'
if (self.sweep.isChecked()):
out += "1"
else:
out += "0"
if (self.sweep_min_freq_slider.value() <=
self.sweep_max_freq_slider.value()):
out += str(self.sweep_min_freq_slider.value()).zfill(3)
out += str(self.sweep_max_freq_slider.value()).zfill(3)
else:
out += str(self.sweep_min_freq_slider.value()).zfill(3)
out += str(self.sweep_min_freq_slider.value()).zfill(3)
out += str(self.sweep_time_slider.value()).zfill(2)
#Append the Frequency Jumping Values
out += 'f'
if (self.freq_jumping.isChecked()):
out += "1"
else:
out += "0"
out += str(self.freq_jump_cycle_slider.value()).zfill(2)
out += str(self.freq_jump_difference.value()).zfill(3)
#Append the Amplitude Jumping Values
out += 'a'
if (self.amp_jumping.isChecked()):
out += "1"
else:
out += "0"
out += str(self.amp_jump_cycle_slider.value()).zfill(2)
out += "0." + str(self.amp_jump_difference.value()).zfill(2)
#Append the Weighted Frequency Jumping Values
out += 'w'
if (not self.weighted_freq_jump_button.isChecked()):
out += "0"
else:
out += str(self.num_of_ranges)
out += self.single_form.itemAt(0, 1).widget().text().zfill(2)
for key, value in self.weighted_freq_jump_ranges.items():
out += str(key[0]).zfill(3) + str(key[1]).zfill(3) + str(value)
print(out)
#ser.write(out.encode())
#ser.flush()
def keepOn(self):
if (not self.wave_measurement_label.isChecked()):
self.wave_measurement_label.toggle()
##############################################################
#Carrier Wave Buttons#
##############################################################
def setAmplitude(self, value):
if (value < 10):
self.wave_amplitude_label.setText("Amplitude: 0.0" + str(value))
else:
self.wave_amplitude_label.setText("Amplitude: 0." + str(value))
def setFrequency(self, value):
self.wave_frequency_label.setText("Frequency: " + str(value))
def setSymmetry(self, value):
self.wave_symmetry_label.setText("Symmetry (%): " + str(value))
def enableSine(self):
if (not self.sinusoid_wave.isChecked()):
self.sinusoid_wave.toggle()
else:
print("Waveform set to Sine Wave")
if (self.square_wave.isChecked()):
self.square_wave.toggle()
def enableSquare(self):
if (not self.square_wave.isChecked()):
self.square_wave.toggle()
else:
print("Waveform set to Square Wave")
if (self.sinusoid_wave.isChecked()):
self.sinusoid_wave.toggle()
##############################################################
#Pulse Modulation Buttons#
##############################################################
def enablePulseModulation(self, value):
if (self.pulse_mod.isChecked()):
print("Pulse Modulation Enabled")
else:
print("Pulse Modulation Disabled")
def setModDutyCycle(self, value):
self.pulse_mod_duty_cycle_label.setText("Duty Cycle (%): " +
str(value))
def setModFrequency(self, value):
self.pulse_mod_frequency_label.setText("Frequency: " + str(value))
def setModRiseTime(self, value):
self.pulse_mod_rise_time_label.setText("Rise Time (%): " + str(value))
def setSinsuoidMod(self):
if (not self.sinusoid_modulation.isChecked()):
self.sinusoid_modulation.toggle()
else:
print("Carrier Wave set to Sinusoid")
if (self.trapezoid_modulation.isChecked()):
self.trapezoid_modulation.toggle()
def setTrapezoidMod(self):
if (not self.trapezoid_modulation.isChecked()):
self.trapezoid_modulation.toggle()
else:
print("Carrier Wave set to Trapezoidal")
if (self.sinusoid_modulation.isChecked()):
self.sinusoid_modulation.toggle()
##############################################################
#Sweeping Frequency Buttons#
##############################################################
def enableSweeping(self, value):
if (self.sweep.isChecked()):
print("Sweeping Frequency Enabled")
else:
print("Sweeping Frequency Disabled")
def setMinSweepFreq(self, value):
self.sweep_min_freq_label.setText("Minimum Frequency: " + str(value))
def setMaxSweepFreq(self, value):
self.sweep_max_freq_label.setText("Maximum Frequency: " + str(value))
def setSweepTime(self, value):
self.sweep_time_label.setText("Sweep Time (s): " + str(value))
##############################################################
#Amplitude/Frequency Jumping Buttons#
##############################################################
def setFreqJumpCycles(self, value):
self.freq_jump_cycle_label.setText("Cycles Before Frequency Jump: " +
str(value))
def setMaxFreqJump(self, value):
self.freq_jump_diff_label.setText("Maximum Frequency Difference: " +
str(value))
def setAmpJumpCycles(self, value):
self.amp_jump_cycle_label.setText("Cycles Before Amplitude Jump: " +
str(value))
def setMaxAmpJump(self, value):
self.amp_jump_diff_label.setText("Maximum Amplitude Difference: 0." +
str(value).zfill(2))
def enableFreqJumping(self):
if (self.freq_jumping.isChecked()):
print("Frequency Jumping Enabled")
else:
print("Frequency Jumping Disabled")
def enableAmpJumping(self):
if (self.amp_jumping.isChecked()):
print("Amplitude Jumping Enabled")
else:
print("Amplitude Jumping Disabled")
def enableWeightedFreq(self):
if (self.weighted_freq_jump_button.isChecked()):
print("Weighted Frequency Jumping Enabled")
else:
print("Weighted Frequency Jumping Disabled")
def addWeightedFreqRange(self):
self.num_of_ranges += 1
self.weighted_freq_range_button.toggle()
bounds = (self.weighted_freq_form_layout.itemAt(
0, 1).widget().text().zfill(3),
self.weighted_freq_form_layout.itemAt(
1, 1).widget().text().zfill(3))
self.weighted_freq_jump_ranges[
bounds] = self.weighted_freq_form_layout.itemAt(2,
1).widget().text()
self.weighted_freq_form_layout.itemAt(0, 1).widget().setText("")
self.weighted_freq_form_layout.itemAt(1, 1).widget().setText("")
self.weighted_freq_form_layout.itemAt(2, 1).widget().setText("")
print("Weighted Frequency Range Added")
print(self.weighted_freq_jump_ranges)
print("Number of Ranges: " + str(self.num_of_ranges))
def open_video(self):
fileName, _ = QFileDialog.getOpenFileName(
self, "Selecciona los mediose", ".",
"Video Files (*.mp4 *.flv *.ts *.mts *.avi)")
if fileName != '':
self.media_player.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.play_video.setEnabled(True)
self.start_time = time.time()
self.play()
def play(self):
if self.media_player.state() == QMediaPlayer.PlayingState:
self.media_player.pause()
self.play_video.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
else:
self.media_player.play()
self.play_video.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
def positionChanged(self, position):
self.video_slider.setValue(position)
def durationChanged(self, duration):
self.video_slider.setRange(0, duration)
self.graph.setXRange(0, .00105 * duration)
def setPosition(self, position):
self.media_player.setPosition(position)
class Identification(QWidget):
def __init__(self):
super().__init__()
self.site = "reddit"
self.resize(500, 800)
self.initUI()
def initUI(self):
self.setFont(QFont('Arial', 14))
outerLayout = QVBoxLayout()
self.topLayout = QFormLayout()
self.users = []
for i in range(1, 3):
self.users.append(QLineEdit())
self.topLayout.addRow(f'User', self.users[i - 1])
textLayout = QFormLayout()
self.textInput = QTextEdit()
textLayout.addRow('Text', self.textInput)
self.textInput.textChanged.connect(self.count)
botLayout = QGridLayout()
spinLabel = QLabel("Number of Users")
botLayout.addWidget(spinLabel, 0, 0)
spinBox = QSpinBox()
spinBox.setValue(2)
spinBox.valueChanged.connect(self.set_users)
botLayout.addWidget(spinBox, 0, 1)
redditBtn = QRadioButton("Reddit")
redditBtn.setChecked(True)
redditBtn.toggled.connect(self.toggle)
botLayout.addWidget(redditBtn, 0, 2)
twitterBtn = QRadioButton("Twitter")
twitterBtn.toggled.connect(self.toggle)
botLayout.addWidget(twitterBtn, 0, 3)
self.charCount = QLabel("Character Count: 0")
botLayout.addWidget(self.charCount, 1, 0)
testBtn = QPushButton("Start Test")
testBtn.clicked.connect(self.start)
botLayout.addWidget(testBtn, 2, 0)
outerLayout.addLayout(self.topLayout)
outerLayout.addLayout(textLayout)
outerLayout.addLayout(botLayout)
self.setLayout(outerLayout)
def toggle(self):
self.site = self.sender().text().lower()
print(f'Set Site to {self.site}')
def start(self):
usernames = [
u.text().strip() for u in self.users if len(u.text().strip()) > 0
]
r = -1
if self.site == 'reddit':
r = start_identification_reddit(
usernames,
self.textInput.toPlainText().strip())
if self.site == 'twitter':
r = start_identification_twitter(
usernames,
self.textInput.toPlainText().strip())
if type(r) == int:
self._new_window = Results("Error downloading users")
self._new_window.show()
else:
self._new_window = Results(f"The Most Likely User is: {r}")
self._new_window.show()
def count(self):
sender = self.sender()
self.charCount.setText("Character Count " +
str(len(sender.toPlainText())))
def set_users(self):
sender = self.sender()
if sender.value() > len(self.users):
new_name = QLineEdit()
self.topLayout.addRow("User", new_name)
self.users.append(new_name)
else:
self.topLayout.itemAt(len(self.users) * 2 -
1).widget().deleteLater()
self.topLayout.itemAt(len(self.users) * 2 -
2).widget().deleteLater()
self.users.pop()
class ChoicesDialog(QDialog):
"""
Choices dialog allows the user to customize editable fields before generating the SW robot.
"""
def __init__(self, df: pandas.DataFrame):
"""
:param df: low level dataframe of decided trace or most frequent routine
"""
# flags = Qt.Window | Qt.WindowTitleHint | Qt.CustomizeWindowHint
super(ChoicesDialog, self).__init__()
self.setWindowTitle("Choices")
# self.setMaximumWidth(1000)
# self.setMaximumHeight(600)
if WINDOWS:
self.setFixedWidth(1000)
else:
self.setFixedWidth(750)
self.df = df
# remove empty clipboard items
for row_index, row in self.df.iterrows():
e = row['concept:name']
if (e in ['cut', 'copy', 'paste']) and utils.removeWhitespaces(row['clipboard_content']) == '':
self.df = self.df.drop(row_index)
# take selected event names
mask1 = self.df['concept:name'].isin(
['changeField',
'editCell', 'editCellSheet', 'editRange',
'created', 'moved', 'Unmount', 'hotkey', 'copy']
)
# exclude paste in browser, take only paste in OS, do not consider cut or copy
mask2 = ((self.df['concept:name'] == 'paste') & (self.df['category'] != 'Browser'))
self.filtered_df = self.df[mask1 | mask2]
if not self.filtered_df.empty:
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok)
buttonBox.accepted.connect(self.handleReturn)
if darkdetect.isDark():
buttonBox.setStyleSheet('QPushButton {background-color: #656565;}')
formGroupBox = QGroupBox()
self.layout = QFormLayout()
self.addRows()
formGroupBox.setLayout(self.layout)
scroll = QScrollArea()
scroll.setWidget(formGroupBox)
scroll.setMaximumHeight(600)
scroll.setMaximumWidth(1000)
mainLayout = QVBoxLayout()
mainLayout.addWidget(QLabel("Change input variables before generating RPA script"))
mainLayout.addWidget(scroll)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
else:
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok)
buttonBox.accepted.connect(self.accept)
layout = QVBoxLayout(self)
layout.addWidget(QLabel("Most frequent trace does not contain editable fields.\n"
"Press OK to generate RPA script."))
layout.addWidget(buttonBox)
self.setLayout(layout)
def addRows(self):
"""
Add editable rows to custom dialog, such as typing in a web page, renaming a file or pasting a text.
For each row there is a label, the description of the field, and a value, the element to be edited
"""
for row_index, row in self.filtered_df.iterrows():
e = row["concept:name"]
url = utils.getHostname(row['browser_url'])
app = row['application']
label = ""
value = ""
if e == "changeField":
tags = list({row['tag_type'], row['tag_category'].lower(), row['tag_name']})
label = f"[{app}] Write in {' '.join(tags)} on {url}:"
value = row['tag_value'].replace('\n', ', ')
elif e in ["editCell", "editCellSheet", "editRange"]:
label = f"[Excel] Edit cell {row['cell_range']} on {row['current_worksheet']} with value:"
value = row['cell_content']
elif e in ["moved", "Unmount", "created"]:
path = row['event_dest_path'] if e == "moved" else row['event_src_path']
_, extension = ntpath.splitext(path)
if extension:
if e == 'created':
label = f"[OS] Create new file:"
else:
label = f"[OS] Rename file as:"
else:
if e == 'created':
label = f"[OS] Create new folder:"
else:
label = f"[OS] Rename folder as:"
value = path
elif e in ["copy", "cut", "paste"]:
cb = utils.removeWhitespaces(row['clipboard_content'])
label = f"[{app}] Copy and Paste:"
value = cb
elif e == 'hotkey':
if 'hotkey' in self.df.columns:
hotkey = row['hotkey']
else:
hotkey = row['id']
label = f"[{app if app else 'Operating System'}] Hotkey:"
value = hotkey
if label != "" and value != "":
lineEdit = QLineEdit(value)
lineEdit.setMinimumWidth(270)
self.layout.addRow(QLabel(label), lineEdit)
else:
# remove rows with empty fields from filtered dataframe so it's equal to the dialog shown
self.filtered_df = self.filtered_df.drop(row_index)
def handleReturn(self):
"""
Called when choices dialog is closed (OK button is pressed)
Each row of the dataframe in input is updated with the values inserted by the user.
"""
# close dialog
self.accept()
# edit original dataframe with new values
# get list of values inserted in QLineEdit, like ['aspirapolvere', 'tavolo', 'sedie']
widgets = (self.layout.itemAt(i).widget() for i in range(self.layout.count()))
new_values = [widget.text() for widget in widgets if isinstance(widget, QLineEdit)]
# To know which lines I need to change in the dataframe, I loop in a subset of the current dataframe
# I take only the rows that may have been modified above, like the ones where changeField is, into filtered_df
# Then I iterate through these rows, taking note also of the current iteration
# 'i' is the current iteration (like 0,1,2) while row_index is the index of the row that I need to modify
# (like 0,3,6)
for i, (row_index, row) in enumerate(self.filtered_df.iterrows()):
try:
e = row["concept:name"]
if e == "changeField":
self.df.loc[row_index, 'tag_value'] = new_values[i]
elif e in ["editCell", "editCellSheet", "editRange"]:
self.df.loc[row_index, 'cell_content'] = new_values[i]
elif e in ["moved", "Unmount", "created"]:
path = 'event_dest_path' if e == "moved" else 'event_src_path'
self.df.loc[row_index, path] = new_values[i]
elif e in ["copy", "cut", "paste"]:
self.df.loc[row_index, 'clipboard_content'] = new_values[i]
elif e == "hotkey":
col = 'hotkey' if 'hotkey' in self.df.columns else 'id'
self.df.loc[row_index, col] = new_values[i]
except Exception:
pass
# self.df.to_csv('/Users/marco/Desktop/temp2.csv', encoding='utf-8-sig', index=False)
def getDF(self):
"""
Get edited dataframe
:return: dataframe of trace with user edits
"""
# self.df.to_csv('/Users/marco/Desktop/temp.csv', encoding='utf-8-sig', index=False)
return self.df
class IntegrateEditor(BaseEditor):
"""
Editor to integrate defined regions.
"""
Integrators_classes = Integrate.INTEGRALS
Integrators = [a.name for a in Integrators_classes]
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self._limits = []
self.setLayout(QVBoxLayout())
self.form_set = QFormLayout()
self.form_lim = QFormLayout()
self.layout().addLayout(self.form_set)
self.layout().addLayout(self.form_lim)
self.methodcb = QComboBox()
self.methodcb.addItems(self.Integrators)
self.form_set.addRow("Integration method:", self.methodcb)
self.methodcb.currentIndexChanged.connect(self.changed)
self.methodcb.activated.connect(self.edited)
self.focusIn = self.activateOptions
self.add_limit()
button = QPushButton("Add Region")
self.layout().addWidget(button)
button.clicked.connect(self.add_limit)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)
self.user_changed = False
def activateOptions(self):
self.parent_widget.curveplot.clear_markings()
for row in range(self.form_lim.count()):
limitbox = self.form_lim.itemAt(row, 1)
if limitbox:
self.parent_widget.curveplot.add_marking(limitbox.line1)
self.parent_widget.curveplot.add_marking(limitbox.line2)
def add_limit(self, *args, row=None):
if row is None:
row = len(self._limits)
try:
self._limits.append(self._limits[-1])
except IndexError:
self._limits.append([0., 1.])
label = "Region {0}".format(row+1)
limitbox = LimitsBox(limits=self._limits[row], label=label)
if self.form_lim.rowCount() < row+1:
# new row
self.form_lim.addRow(limitbox)
else:
# row already exists
self.form_lim.setLayout(row, 2, limitbox)
limitbox.focusIn = self.activateOptions
limitbox.valueChanged.connect(self.set_limits)
limitbox.editingFinished.connect(self.edited)
limitbox.deleted.connect(self.remove_limit)
self.edited.emit()
return limitbox
def remove_limit(self, limitbox):
row, role = self.form_lim.getLayoutPosition(limitbox)
for r in range(row, len(self._limits)):
limitbox = self.form_lim.itemAt(r, 1)
limitbox.removeLayout()
self._limits.pop(row)
self.set_all_limits(self._limits)
def set_limits(self, limits, limitbox, user=True):
if user:
self.user_changed = True
row, role = self.form_lim.getLayoutPosition(limitbox)
if self._limits[row] != limits:
self._limits[row] = limits
with blocked(self.form_lim):
limitbox.lowlime.setValue(limits[0])
limitbox.highlime.setValue(limits[1])
self.changed.emit()
def set_all_limits(self, limits, user=True):
if user:
self.user_changed = True
self._limits = limits
for row in range(len(limits)):
limitbox = self.form_lim.itemAt(row, 1)
if limitbox is None:
limitbox = self.add_limit(row=row)
with blocked(limitbox):
limitbox.lowlime.setValue(limits[row][0])
limitbox.highlime.setValue(limits[row][1])
self.changed.emit()
def setParameters(self, params):
if params: # parameters were manually set somewhere else
self.user_changed = True
self.methodcb.setCurrentIndex(
params.get("method", self.Integrators_classes.index(Integrate.Baseline)))
self.set_all_limits(params.get("limits", [[0., 1.]]), user=False)
def parameters(self):
return {"method": self.methodcb.currentIndex(),
"limits": self._limits}
@staticmethod
def createinstance(params):
methodindex = params.get("method",
IntegrateEditor.Integrators_classes.index(Integrate.Baseline))
method = IntegrateEditor.Integrators_classes[methodindex]
limits = params.get("limits", None)
return Integrate(methods=method, limits=limits)
def set_preview_data(self, data):
if not self.user_changed:
x = getx(data)
if len(x):
self.set_all_limits([[min(x), max(x)]])
self.edited.emit()
class GUI(QMainWindow):
# Set global variables here
story = ''
new_story = ''
# Set up attributes of GUI instances
def __init__(self):
super().__init__()
self.w_sel = QWidget() # Create a QWidget called w
self.sel_story_label = QLabel(
self.w_sel) # Create a QLabel called label1 in QWidget w
self.sel_story_text = QLineEdit(
self.w_sel) # Create a QLineEdit called edit1 in QWidget w
self.sel_enter_b = QPushButton(
self.w_sel) # Create a QPushButton called button in QWidget w
self.vbox_sel = QVBoxLayout() # Create a QVBoxLayout called vbox
self.window_sel() # Call function window()
self.w_matches = QWidget() # Create a QWidget called w
self.form_layout_matches = QFormLayout()
self.submit_b_matches = QPushButton()
# Set up the GUI window
def window_sel(self):
self.setCentralWidget(
self.w_sel
) # Set w to central widget (nothing will show without this step)
self.sel_story_label.setText(
'Enter a MadLib .txt file name') # Set label1 text to 'testing'
self.sel_story_text.setText(
'vacation_short.txt') # Set edit1 text to 'test'
self.sel_enter_b.setText('Enter') # Set button text to 'Enter'
self.vbox_sel.addWidget(
self.sel_story_label
) # Add label1 to the vbox layout (order of this matters)
self.vbox_sel.addWidget(
self.sel_story_text) # Add edit1 to the vbox layout
self.vbox_sel.addWidget(
self.sel_enter_b) # Add button to the vbox layout
self.w_sel.setLayout(self.vbox_sel) # Set the window layout to vbox
self.sel_enter_b.clicked.connect(
self.button_click
) # When the button is clicked, call function button_click
self.setWindowTitle('MatLibs') # Set window title
self.show() # Show the window
def window_matches(self, matches):
self.setCentralWidget(
self.w_matches
) # Set w to central widget (nothing will show without this step)
self.submit_b_matches.setText('Submit')
self.w_matches.setLayout(self.form_layout_matches)
for match in matches:
match_label = QLabel(match)
word_enter = QLineEdit(self.w_matches)
self.word(match_label, word_enter)
self.form_layout_matches.addWidget(self.submit_b_matches)
self.w_matches.setLayout(self.form_layout_matches)
self.submit_b_matches.clicked.connect(lambda: self.matches_click())
self.show()
def matches_click(self):
items = (self.form_layout_matches.itemAt(i).widget()
for i in range(self.form_layout_matches.count()))
labels = []
values = []
for i, item in enumerate(items):
if i % 2 == 0:
labels.append(item.text())
else:
values.append(item.text())
labels.pop() # remove submit button from list
self.new_story = sub_matches(labels, values, self.story)
print(self.new_story)
w_story = QWidget()
story_label = QLabel(w_story)
story_button = QPushButton(w_story)
story_label.setText(self.new_story)
story_button.setText('Close')
story_vbox = QVBoxLayout()
self.setCentralWidget(w_story)
story_vbox.addWidget(story_label)
story_vbox.addWidget(story_button)
w_story.setLayout(story_vbox)
story_button.clicked.connect(lambda: self.close())
self.show()
def word(self, label, line_edit):
self.form_layout_matches.addRow(label, line_edit)
return
# This function is run when the button is clicked
# In this example, the text from edit1 is printed in the terminal window and the window closes.
# Other options on a button click...
# When the button is clicked, the global variables are updated and printed,
# the gui interface is closed,
# and a function is called passing the updated global variables as the parameters.
def button_click(self):
print(self.sel_story_text.text())
# self.read_file(self.sel_story_text.text())
self.story = get_story(self.sel_story_text.text())
self.window_matches(get_matches(self.story))
class Window2(QDialog):
def __init__(self, model, parent=None):
super(Window2, self).__init__(parent)
self.model = model
self.mainLayout = QGridLayout()
self.mainLayout.setColumnStretch(0, 1)
self.mainLayout.setColumnStretch(1, 3)
self.mainLayout.setColumnStretch(2, 3)
self.flayout = QFormLayout()
self.flayout.addRow('title', QLineEdit())
self.flayout.addRow('author', QLineEdit())
self.flayout.addRow('abstract', QLineEdit())
self.comboBox = QComboBox()
self.comboBox.addItems(Scraper.scrapers)
self.flayout.addRow('source', self.comboBox)
self.table = TableWidget()
self.table.doubleClicked.connect(self.openDocument)
self.setFixedSize(1000, 600)
button1 = QPushButton()
button1.setText("Search")
button1.clicked.connect(self.search)
button2 = QPushButton()
button2.setText("Save")
button2.clicked.connect(self.save)
self.button3 = QPushButton()
self.button3.setText("Next")
self.button3.clicked.connect(self.next_results)
self.button3.setVisible(False)
self.button4 = QPushButton()
self.button4.setText("Previous")
self.button4.clicked.connect(self.previous_results)
self.button4.setVisible(False)
self.label = QLabel()
self.label.setVisible(False)
self.setWindowTitle('Search')
self.mainLayout.addLayout(self.flayout, 0, 0)
self.mainLayout.addWidget(self.table, 0, 1, 1, 2)
self.mainLayout.addWidget(self.label, 1, 0)
self.mainLayout.addWidget(self.button4, 1, 1)
self.mainLayout.addWidget(self.button3, 1, 2)
self.mainLayout.addWidget(button1, 2, 0)
self.mainLayout.addWidget(button2, 2, 1, 1, 2)
self.setLayout(self.mainLayout)
def getInputData(self):
inputData = {
self.flayout.itemAt(2 * i).widget().text():
self.flayout.itemAt(2 * i + 1).widget().text()
for i in range(int(self.flayout.count() / 2) - 1)
}
inputData['source'] = self.comboBox.currentText()
return inputData
def search(self):
inputData = self.getInputData()
source = inputData.pop('source')
self.scraper = Scraper(inputData, source)
logging.info('Scraper search' + str(inputData))
results = self.scraper.search()
self.table.fillTable(results)
if self.scraper.total > 10:
self.button3.setVisible(True)
self.update_label()
def update_label(self):
self.label.setText('Page {} of {}'.format(
self.scraper.page,
int(self.scraper.total / 10) + 1))
self.label.setVisible(True)
def next_results(self):
self.scraper.page += 1
results = self.scraper.search()
self.table.fillTable(results)
self.button4.setVisible(True)
if self.scraper.total <= 10 * self.scraper.page:
self.button3.setVisible(False)
self.update_label()
def previous_results(self):
self.scraper.page -= 1
results = self.scraper.search()
self.table.fillTable(results)
self.button3.setVisible(True)
if self.scraper.page <= 1:
self.button4.setVisible(False)
self.update_label()
def openDocument(self, y):
if 'http' in y.data():
webbrowser.open(y.data(), new=2)
def save(self):
index = self.table.selectionModel().selectedRows()
if len(index) > 0:
new_data = {
self.table.horizontalHeaderItem(i).text():
str(self.table.model().index(index[0].row(), i).data())
for i in range(self.table.columnCount())
}
if 'document' in new_data and 'pdf' in new_data['document']:
new_data = self.save_file(new_data)
row_index = self.model.rowCount(QModelIndex())
record = self.model.record()
record.setGenerated('id', False)
record.setValue('created', QDateTime.currentDateTime())
for column in new_data:
record.setValue(column, new_data[column])
self.model.insertRecord(-1, record)
def save_file(self, new_data):
if 'document' in new_data and len(new_data['document']) > 0:
author = ', '.join(
re.findall(r'(\w*)(?:$|,)', new_data.get('author'))[:-1])
title = re.sub(r"[^a-zA-Z0-9]+", ' ', new_data.get('title'))
date = new_data.get('date') if new_data.get('date') else ''
filename = date + ' ' + title + ' - ' + author + '.pdf'
path = os.path.join(cfg['temp'], filename)
logging.info('Trying to save file ' + filename)
if not os.path.exists(path):
response = requests.get(new_data['document'], headers=_HEADERS)
if response.ok:
try:
with open(path, 'wb') as f:
f.write(response.content)
try:
new_data['length'] = PdfFileReader(open(
path, 'rb')).getNumPages()
except:
display_text = 'Corrupted document ' + filename
new_data['document'] = filename
display_text = 'Saved document ' + filename
except:
display_text = 'Dowload document successful, but not possible to save.'
new_data['document'] = ''
else:
display_text = 'Dowload document not successful.'
new_data['document'] = ''
else:
display_text = 'File ' + filename + 'already exists.'
else:
display_text = 'There is no document to save.'
msgBox = QMessageBox()
msgBox.setText(display_text)
msgBox.exec_()
logging.info(display_text)
return new_data
class OptionsPanel(QWidget):
"""Supported API. OptionsPanel is a container for single-use (not savable) Options"""
def __init__(self,
parent=None,
*,
sorting=True,
scrolled=True,
contents_margins=None):
"""sorting:
False; options shown in order added
True: options sorted alphabetically by name
func: options sorted based on the provided key function
"""
QWidget.__init__(self, parent)
self._layout = QVBoxLayout()
if contents_margins is not None:
self._layout.setContentsMargins(*contents_margins)
if scrolled:
sublayout = QVBoxLayout()
sublayout.setContentsMargins(3, 0, 3, 2)
self.setLayout(sublayout)
scroller = QScrollArea()
scroller.setWidgetResizable(True)
sublayout.addWidget(scroller)
scrolled_area = QWidget()
scroller.setWidget(scrolled_area)
scrolled_area.setLayout(self._layout)
else:
self.setLayout(self._layout)
self._sorting = sorting
self._options = []
self._option_groups = []
self._layout.setSizeConstraint(self._layout.SetMinAndMaxSize)
self._form = QFormLayout()
self._form.setSizeConstraint(self._form.SetMinAndMaxSize)
self._form.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow)
self._form.setVerticalSpacing(1)
from PyQt5.QtCore import Qt
# None of the below seem to have an effect on the Mac...
#self._form.setLabelAlignment(Qt.AlignRight | Qt.AlignVCenter)
#self._form.setFormAlignment(Qt.AlignLeft | Qt.AlignVCenter)
# if we wanted to force the form contents to upper left...
#self._form.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
self._layout.addLayout(self._form)
def add_option(self, option):
"""Supported API. Add an option (instance of chimerax.ui.options.Option)."""
if self._sorting is False:
insert_row = len(self._options)
else:
if self._sorting is True:
test = lambda o1, o2: o1.name < o2.name
else:
test = lambda o1, o2: self._sorting(o1) < self._sorting(o2)
for insert_row in range(len(self._options)):
if test(option, self._options[insert_row]):
break
else:
insert_row = len(self._options)
self._form.insertRow(insert_row, option.name, option.widget)
self._options.insert(insert_row, option)
if option.balloon:
self._form.itemAt(insert_row,
QFormLayout.LabelRole).widget().setToolTip(
option.balloon)
def add_option_group(self,
group_label=None,
checked=None,
group_alignment=None,
**kw):
if group_label is None:
grouping_widget = QWidget()
else:
grouping_widget = QGroupBox(group_label)
grouping_widget.setContentsMargins(
1,
grouping_widget.contentsMargins().top() // 2, 1, 1)
if checked is not None:
grouping_widget.setCheckable(True)
grouping_widget.setChecked(checked)
add_kw = {} if group_alignment is None else {
'alignment': group_alignment
}
self._layout.addWidget(grouping_widget, **add_kw)
suboptions = OptionsPanel(scrolled=False, **kw)
self._option_groups.append(suboptions)
return grouping_widget, suboptions
def change_label_for_option(self, option, new_label):
self._form.labelForField(option.widget).setText(new_label)
def options(self):
all_options = self._options[:]
for grp in self._option_groups:
# an option group can have further subgroups, so call options()
all_options.extend(grp.options())
return all_options
def sizeHint(self):
from PyQt5.QtCore import QSize
form_size = self._form.minimumSize()
return QSize(min(form_size.width(), 800), min(form_size.height(), 800))
class MainWindow(QDialog):
def __init__(self):
super().__init__()
self.title = "Main window"
self.top = 55
self.left = 7
w = data.scale[0]
h = data.scale[1]
data.reso[0] = App.primaryScreen().size().width()
data.reso[1] = App.primaryScreen().size().height()
self.width = App.primaryScreen().size().width() / w
self.height = App.primaryScreen().size().height() / h
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
data.graphResolution = [
self.width / data.scale[2], self.height / data.scale[3]
]
self.setWindowIcon(QtGui.QIcon('icon1.ico'))
self.formLayout0 = QFormLayout()
self.groupBox0 = QGroupBox("Available Asks")
self.groupBox0.setLayout(self.formLayout0)
scroll0 = QScrollArea()
scroll0.setWidget(self.groupBox0)
scroll0.setWidgetResizable(True)
self.formLayout = QFormLayout()
self.groupBox = QGroupBox("Available Bids")
customTheme()
data.pref_prd = list(client.get_stars(data.username,
data.password)) # TODO UNCOMMENT
#print(client.get_stars(data.username, data.password))
self.groupBox.setLayout(self.formLayout)
scroll = QScrollArea()
scroll.setWidget(self.groupBox)
scroll.setWidgetResizable(True)
self.formLayout3 = QFormLayout()
self.groupBox3 = QGroupBox("Your orders")
self.groupBox3.setLayout(self.formLayout3)
scroll3 = QScrollArea()
scroll3.setWidget(self.groupBox3)
scroll3.setWidgetResizable(True)
self.formLayout1 = QFormLayout()
self.groupBox1 = QGroupBox("Orders' History")
history = client.get_history(data.username, data.password)
print("HERE WE GO AGAIN")
for r in history:
#print(r)
if len(r):
Order = QtWidgets.QPushButton()
if r[-1] == "sell":
sign = func.sellOrder(
r[0], r[1], r[2],
r[3]) # ordertype, product, amount, price
Order.setStyleSheet(styles.sellbutton)
else:
sign = func.buyOrder(r[0], r[1], r[2], r[3])
Order.setStyleSheet(styles.buybutton)
Order.setText(sign)
Order.setDisabled(True)
# formLayout1.addWidget(Order)
self.formLayout1.insertRow(0, Order)
self.groupBox1.setLayout(self.formLayout1)
scroll2 = QScrollArea()
scroll2.setWidget(self.groupBox1)
scroll2.setWidgetResizable(True)
rightArea = QVBoxLayout()
threeScrolls = QHBoxLayout()
threeScrolls.addWidget(scroll)
threeScrolls.addWidget(scroll0)
Column = QVBoxLayout()
Column.addWidget(scroll3)
Column.addWidget(scroll2)
threeScrolls.addLayout(Column)
rightArea.addLayout(threeScrolls)
leftArea = QVBoxLayout()
BuySell = QHBoxLayout()
buyButton = QtWidgets.QPushButton("BUY")
buyButton.setStyleSheet(
styles.buybuttonFus.replace("text-align: left;", ""))
BuySell.addWidget(buyButton)
sellButton = QtWidgets.QPushButton("SELL")
sellButton.setStyleSheet(
styles.sellbuttonFus.replace("text-align: left;", ""))
BuySell.addWidget(sellButton)
settingsButton = QtWidgets.QPushButton("configuring".upper())
BuySell.addWidget(settingsButton)
self.MainProduct = QComboBox()
self.MainProduct.currentIndexChanged.connect(
self.prdChanged, self.MainProduct.currentIndex())
self.MainProduct.addItem("No filter")
for prd in data.pref_prd:
self.MainProduct.addItem(prd)
BuySell.addWidget(self.MainProduct)
buy_shortcut = QShortcut(QtGui.QKeySequence("B"), self)
buy_shortcut.activated.connect(lambda: callOrderWindow("Buy"))
sell_shortcut = QShortcut(QtGui.QKeySequence("S"), self)
sell_shortcut.activated.connect(lambda: callOrderWindow("Sell"))
conf_shortcut = QShortcut(QtGui.QKeySequence("C"), self)
conf_shortcut.activated.connect(lambda: callConfigWindow())
my_assets = QShortcut(QtGui.QKeySequence("A"), self)
my_assets.activated.connect(lambda: call_my_assets())
buyButton.clicked.connect(lambda: callOrderWindow("Buy"))
sellButton.clicked.connect(lambda: callOrderWindow("Sell"))
settingsButton.clicked.connect(lambda: callConfigWindow())
shortcut1 = QShortcut(QtGui.QKeySequence("1"), self)
shortcut1.activated.connect(lambda: change_prd_keyboard(1))
shortcut2 = QShortcut(QtGui.QKeySequence("2"), self)
shortcut2.activated.connect(lambda: change_prd_keyboard(2))
shortcut3 = QShortcut(QtGui.QKeySequence("3"), self)
shortcut3.activated.connect(lambda: change_prd_keyboard(3))
shortcut4 = QShortcut(QtGui.QKeySequence("4"), self)
shortcut4.activated.connect(lambda: change_prd_keyboard(4))
shortcut5 = QShortcut(QtGui.QKeySequence("5"), self)
shortcut5.activated.connect(lambda: change_prd_keyboard(5))
shortcut6 = QShortcut(QtGui.QKeySequence("6"), self)
shortcut6.activated.connect(lambda: change_prd_keyboard(6))
shortcut7 = QShortcut(QtGui.QKeySequence("7"), self)
shortcut7.activated.connect(lambda: change_prd_keyboard(7))
shortcut8 = QShortcut(QtGui.QKeySequence("8"), self)
shortcut8.activated.connect(lambda: change_prd_keyboard(8))
shortcut9 = QShortcut(QtGui.QKeySequence("9"), self)
shortcut9.activated.connect(lambda: change_prd_keyboard(9))
shortcut0 = QShortcut(QtGui.QKeySequence("0"), self)
shortcut0.activated.connect(lambda: change_prd_keyboard(0))
shortcutR = QShortcut(QtGui.QKeySequence("F5"), self)
shortcutR.activated.connect(lambda: self.F5_EVENT())
leftArea.addLayout(BuySell)
graphsArea = QVBoxLayout()
self.graph1 = CanvasUp()
self.graph2 = CanvasLow()
self.sliderUP = QSlider(Qt.Horizontal)
self.sliderUP.setTickInterval(10)
self.sliderUP.setSingleStep(30)
self.sliderUP.valueChanged.connect(lambda: self.sliderChanged1())
self.sliderDOWN = QSlider(Qt.Horizontal)
self.sliderDOWN.setTickInterval(10)
self.sliderDOWN.setSingleStep(30)
self.sliderDOWN.valueChanged.connect(lambda: self.sliderChanged2())
self.load = QtWidgets.QLabel()
self.load1 = QtWidgets.QLabel()
self.tabs = QTabWidget()
self.graphUP = QWidget()
self.graphUP.layout = QVBoxLayout(self.graphUP)
self.graphUP.layout.addWidget(self.graph1)
self.graphUP.layout.addWidget(self.sliderUP)
self.tabs.setFixedHeight(data.graphResolution[0])
self.tabs.setFixedWidth(data.graphResolution[1])
self.tabs.addTab(self.graphUP, "Graph1")
graphsArea.addWidget(self.tabs)
self.tabs1 = QTabWidget()
self.graphLOW = QWidget()
self.graphLOW.layout = QVBoxLayout(self.graphLOW)
self.graphLOW.layout.addWidget(self.graph2)
self.graphLOW.layout.addWidget(self.sliderDOWN)
self.tabs1.setFixedHeight(data.graphResolution[0])
self.tabs1.setFixedWidth(data.graphResolution[1])
self.tabs1.addTab(self.graphLOW, "Graph2")
graphsArea.addWidget(self.tabs1)
leftArea.addLayout(graphsArea)
global bar
bar = QPushButton(func.barInfo())
bar.setStyleSheet(styles.barstyle1)
bar.clicked.connect(lambda: call_my_assets())
lowBar = QPushButton("NEWS: " +
data.news[randrange(0, len(data.news))])
lowBar.setStyleSheet(styles.news)
lowBar.setDisabled(True)
Mainlayout = QVBoxLayout(self)
ContentArea = QHBoxLayout()
ContentArea.addLayout(leftArea)
ContentArea.addLayout(rightArea)
Mainlayout.addWidget(bar)
Mainlayout.addLayout(ContentArea)
Mainlayout.addWidget(lowBar)
self.show()
self.thread = MyThread() #time
self.thread.timeToSleep = 0.3
self.thread.change_value.connect(lambda: setProgressVal())
self.thread.start()
self.thread1 = MyThread() # add possible orders
self.thread1.timeToSleep = 2.5
self.thread1.change_value.connect(lambda: self.getUpdate())
self.thread1.start()
self.thread2 = MyThread() # update graphs
self.thread2.timeToSleep = 4
self.thread2.change_value.connect(lambda: self.updateGraphs())
self.thread2.start()
self.thread3 = MyThread() # update news
self.thread3.timeToSleep = 7
self.thread3.change_value.connect(lambda: printNews())
self.thread3.start()
def setProgressVal():
bar.setText(func.barInfo())
def change_prd_keyboard(i):
try:
if i == 0:
self.MainProduct.setCurrentIndex(0)
elif len(data.pref_prd) > i - 1:
self.MainProduct.setCurrentIndex(i)
else:
self.MainProduct.setCurrentIndex(0)
except:
print("error in change_prd_keyboard")
def callConfigWindow():
data.orderResolution[0], data.orderResolution[
1] = self.width / 2.3, self.height / 1.7
Dialog = QtWidgets.QDialog()
ui = cfg.Ui_DialogConfig()
ui.setupUi(Dialog)
Dialog.exec_()
if data.mode == "Dark":
switchDark()
bar.setStyleSheet(styles.barstyle2)
else:
QtWidgets.QApplication.instance().setPalette(
self.style().standardPalette())
switchLight()
bar.setStyleSheet(styles.barstyle1)
if data.clearHis == True:
try:
for i in reversed(range(self.formLayout1.count())):
self.formLayout1.itemAt(i).widget().deleteLater()
except:
pass
data.clearHis = False
if data.addToBox[0]:
self.MainProduct.clear()
self.MainProduct.addItem("No filter")
for prd in data.pref_prd:
self.MainProduct.addItem(prd)
data.addToBox = [False, []]
if data.joinG[0] == True and data.joinG[1] == True:
self.updateGraphs()
self.graph1.upd()
self.graph2.upd()
if self.MainProduct.currentText() == "No filter":
self.graph1.clear()
self.graph1.no_data()
self.graph2.clear()
self.graph2.no_data()
if data.joinG[0] == True and data.joinG[1] == True:
data.zoom1 = data.zoom
tm = time.time()
step = 3600
tm_ = tm - 60 * 60 * 24
inp = [[x, x + step]
for x in range(int(tm_), int(tm), int(step))]
prd = self.MainProduct.currentText()
data.bx = client.box_graph(prd, inp)
#data.bx1 = client.box_graph(prd, inp)
data.bx_lab = inp
#print("Box", inp)
data.box_reload = 0
def call_my_assets():
data.orderResolution[0], data.orderResolution[
1] = self.width / data.scale_[0], self.height / data.scale_[1]
Dialog = QtWidgets.QDialog()
ui = assets.Ui_DialogAssets()
ui.setupUi(Dialog)
Dialog.exec_()
def callOrderWindow(type):
data.orderWinIsON = True
data.orderResolution[0], data.orderResolution[
1] = self.width / data.scale_[2], self.height / data.scale_[3]
data.orderType = str(type)
if self.MainProduct.currentText() != "No filter":
try:
amtN = 0 # для средневзвешенного
wcc = 0
# computing autocomplete prices
if str(type) == "Buy":
for i in reversed(range(self.formLayout0.count())):
try:
#print("=>",func.getPrice(self.formLayout0.itemAt(i).widget().text()))
amtN += float(
func.getAmt(
self.formLayout0.itemAt(
i).widget().text()))
wcc += float(
func.getAmt(
self.formLayout0.itemAt(
i).widget().text())) * float(
func.getPrice(
self.formLayout0.itemAt(
i).widget().text()))
except:
pass
data.acPrice = func.getPrice(
self.formLayout0.itemAt(0).widget().text())
#print("wcc1",wcc, amtN)
data.acPriceFOK = (wcc / (amtN))
else:
for i in reversed(range(self.formLayout.count())):
try:
amtN += float(
func.getAmt(
self.formLayout.itemAt(
i).widget().text()))
wcc += float(
func.getAmt(
self.formLayout.itemAt(
i).widget().text())) * float(
func.getPrice(
self.formLayout.itemAt(
i).widget().text()))
except:
pass
#print("wcc2", wcc, amtN)
data.acPrice = func.getPrice(
self.formLayout.itemAt(self.formLayout.count() -
1).widget().text())
data.acPriceFOK = wcc / (amtN)
except:
pass
data.autocomplete = self.MainProduct.currentText()
Dialog = QtWidgets.QDialog()
ui = ord.Ui_DialogOrder()
ui.setupUi(Dialog)
Dialog.exec_()
if data.addToHis[0]: ### ALSO CHECKS FOR SUCCESS
sign = func.Order(data.addToHis[1][0], data.addToHis[1][1],
data.addToHis[1][2], data.addToHis[1][3],
data.addToHis[1][4])
newOrder = QtWidgets.QPushButton()
newOrder.setStyleSheet(styles.buybutton)
if data.addToHis[1][0].lower() == "sell":
newOrder.setStyleSheet(styles.sellbutton)
newOrder.setDisabled(True)
newOrder.setText(sign)
self.formLayout1.insertRow(0, newOrder)
bar.setText(func.barInfo()) #CHEANGE BALANCE
#RELOADING AVALIABLE ORDERS
self.reloadData()
elif data.addToOrd[0]:
self.reloadData()
if len(data.system_ord) != 0:
self.reloadSystemOrders("")
data.addToHis = (False, [])
data.addToOrd = (False, "Buy", "")
data.acPrice = ""
bal = client.get_balance(data.username)
data.balance = (bal, "$")
func.putPersonalData()
bar.setText(func.barInfo())
data.orderWinIsON = False
def printNews():
i = randrange(0, len(data.news))
lowBar.setText("NEWS: " + data.news[i])
def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_B:
print("b pressed")
def sliderChanged1(self):
if self.MainProduct.currentText() != "No filter":
data.zoom = self.sliderUP.value()
self.graph1.clear()
self.graph1.reloading()
self.reloading()
if len(data.graphsData) == 0:
self.graph1.clear()
self.graph1.no_data()
def sliderChanged2(self):
if self.MainProduct.currentText() != "No filter":
data.zoom1 = self.sliderDOWN.value()
self.graph2.clear()
self.graph2.reloading()
self.reloading()
if len(data.graphsData_1) == 0:
self.graph2.clear()
self.graph2.no_data()
def F5_EVENT(self):
data.box_reload = 0
self.reloading()
self.updateGraphs()
def reloading(self):
print("__reloading__")
try:
if data.joinG[0] == True and data.joinG[1] == True:
data.zoom1 = data.zoom
tm = time.time()
step = 3600
tm_ = tm - 60 * 60 * 24
inp = [[x, x + step]
for x in range(int(tm_), int(tm), int(step))]
prd = self.MainProduct.currentText()
data.bx = client.box_graph(prd, inp)
# data.bx1 = client.box_graph(prd, inp)
data.bx_lab = inp
# print("Box", inp)
data.sleep += 1
if data.sleep == 60:
data.sleep = 0
if data.zoom != 0:
data.graphsData = client.stats(
self.MainProduct.currentText(),
time.time() - (1100 - data.zoom * 10),
time.time() + 15, "buy")
else:
data.graphsData = client.stats(self.MainProduct.currentText(),
0,
time.time() + 15, "buy")
if data.zoom1 != 0:
data.graphsData_1 = client.stats(
self.MainProduct.currentText(),
time.time() - (1100 - data.zoom1 * 10),
time.time() + 15, "sell")
else:
data.graphsData_1 = client.stats(
self.MainProduct.currentText(), 0,
time.time() + 15, "sell")
except:
print("Error in reloading")
def updateGraphs(self):
print("TIME: ", time.time() - data.working_time)
try:
if self.MainProduct.currentText() != "No filter":
self.graph1.clear()
if data.joinG[0] == True and data.joinG[1] == True:
self.sliderUP.setHidden(True)
self.graph1.plot_joint()
else:
self.sliderUP.setHidden(False)
self.reloading()
self.graph1.plot()
if data.joinG[0] == True and data.joinG[1] == True:
if data.box_reload < 1:
self.sliderDOWN.setHidden(True)
self.graph2.clear()
self.graph2.candels()
data.box_reload += 1
else:
self.graph2.clear()
self.graph2.plot()
self.sliderDOWN.setHidden(False)
else:
data.graphsData = []
data.graphsData_1 = []
except:
print("Error in update graphs")
def prdChanged(self):
data.chosen_prd = self.MainProduct.currentText()
data.box_reload = 0
self.sliderChanged1()
self.sliderChanged2()
if self.MainProduct.currentText() == "No filter":
if not data.FIRSTSTART:
self.graph1.clear()
self.graph1.no_data()
self.graph2.clear()
self.graph2.no_data()
data.FIRSTSTART = False
self.reloadData()
def reloadData(self):
if data.joinG[0] == True and data.joinG[1] == True:
data.sleep = 0
try:
text = self.MainProduct.currentText()
data.prd = text
res1 = []
res2 = []
if text == "No filter":
try:
if data.goLocal:
raise Exception
except:
print(
"EXCEPTION OCCURRED: Local database is used instead ")
else:
try:
if data.goLocal:
raise Exception
res1 = client.exe(
"SELECT * FROM orders WHERE product='{}' AND request='{}'ORDER BY price LIMIT 20"
.format(text, "sell"))
res2 = client.exe(
"SELECT * FROM orders WHERE product='{}' AND request='{}'ORDER BY price LIMIT 20"
.format(text, "buy"))
except:
print(
"EXCEPTION OCCURRED: Local database is used instead ")
res = func.findOrder(text)
res = client.exe(
f"SELECT * FROM orders WHERE uid={float(data.userid)}")
data.yourOrd = data.system_ord
data.system_ord = []
try:
for i in reversed(range(self.formLayout.count())):
self.formLayout.itemAt(i).widget().deleteLater()
except:
pass
j2 = 0
for order in res:
j2 += 1
if order[3] == "sell":
if order[-1] == float(data.userid):
sys_ord = [
order[2], order[3], order[4],
str(order[5]),
str(order[6]),
str(order[0])
]
if sys_ord not in data.system_ord:
data.system_ord.append(sys_ord)
data.ORDDIC[order[0]] = order
else:
if order not in data.Orders:
data.ORDDIC[order[0]] = order
try:
for i in reversed(range(self.formLayout0.count())):
self.formLayout0.itemAt(i).widget().deleteLater()
except:
pass
j3 = 0
for order in res:
j3 += 1
if order[3] == "buy":
if order[-1] == float(data.userid):
sys_ord = [
order[2], order[3], order[4],
str(order[5]),
str(order[6]),
str(order[0])
]
if sys_ord not in data.system_ord:
data.system_ord.append(sys_ord)
data.ORDDIC[order[0]] = order
else:
if order not in data.Orders:
data.ORDDIC[order[0]] = order
# add to history
try:
for el in data.yourOrd:
if el not in data.system_ord and not data.orderWinIsON:
msg = QMessageBox()
msg.setWindowTitle("An order's been executed")
msg.setIconPixmap(QPixmap("arrow.png").scaled(80, 80))
msg_text = "This order\n"
thisorder = QPushButton()
if el[1] == "buy":
thisorder.setStyleSheet(styles.buybutton)
thisorder.setText(
func.buyOrder("Limit", el[2], el[3], el[4]))
data.balance = (data.balance[0] -
float(el[3]) * float(el[4]),
data.balance[1])
#msg_text += func.buyOrder("Limit", el[2], el[3], el[4])
msg_text += "Limit Buy" + el[2]
else:
thisorder.setStyleSheet(styles.sellbutton)
thisorder.setText(
func.sellOrder("Limit", el[2], el[3], el[4]))
data.balance = (data.balance[0] +
float(el[3]) * float(el[4]),
data.balance[1])
#msg_text += func.sellOrder("Limit", el[2], el[3], el[4])
msg_text += "Limit Sell" + el[2]
thisorder.setDisabled(True)
self.formLayout1.insertRow(0, thisorder)
msg.setText(msg_text + "\nhas been executed.")
msg.setWindowIcon(QtGui.QIcon('bgicon.ico'))
msg.exec_()
except:
print("line 676")
res = res1 + res2
if self.MainProduct.currentText() != "No filter":
prices = func.merger(res)
for el in prices:
if prices[el][1][3] == "sell":
thisorder = QPushButton()
thisorder.setStyleSheet(styles.sellbutton)
sign = func.sellOrder(prices[el][1][2],
prices[el][1][4],
str(prices[el][0]),
prices[el][1][6])
thisorder.setText(sign)
self.formLayout0.addRow(thisorder)
else:
thisorder = QPushButton()
thisorder.setStyleSheet(styles.buybutton)
sign = func.buyOrder(prices[el][1][2],
prices[el][1][4],
str(prices[el][0]),
prices[el][1][6])
thisorder.setText(sign)
self.formLayout.insertRow(0, thisorder)
self.reloadSystemOrders("")
except:
print("Error in def reloadData")
if data.error == False:
data.error = True
connect()
def removeOrder(self, n):
oldstyle = self.formLayout3.itemAt(n - 1).widget().styleSheet()
self.formLayout3.itemAt(n - 1).widget().setStyleSheet(styles.buttonY)
data.orderResolution[0], data.orderResolution[
1] = self.width / 2.5, self.height / 1.3
Dialog = QtWidgets.QDialog()
ui = confirmwin.Ui_DialogCONFIRM()
ui.setupUi(Dialog)
Dialog.exec_()
try:
if data.toDelete:
client.delete(data.username, data.system_ord[n - 1][-1])
for i in reversed(range(self.formLayout3.count())):
self.formLayout3.itemAt(i).widget().deleteLater()
del data.system_ord[n - 1]
self.reloadSystemOrders("")
bal = client.get_balance(data.username)
data.balance = (bal, "$")
func.putPersonalData()
bar.setText(func.barInfo())
else:
self.formLayout3.itemAt(n - 1).widget().setStyleSheet(oldstyle)
data.toDelete = False
except:
print("Error in remove order")
def reloadSystemOrders(self, temp):
try:
for i in reversed(range(self.formLayout3.count())):
self.formLayout3.itemAt(i).widget().deleteLater()
j1 = 0
for el in data.system_ord:
j1 += 1
thisorder = QPushButton(
"", clicked=lambda _, n=j1: self.removeOrder(n))
if el[1] == "buy":
thisorder.setStyleSheet(styles.buybutton)
thisorder.setText(
func.buyOrder("Limit", el[2], el[3],
el[4] + "\n id: " + el[-1]))
else:
thisorder.setStyleSheet(styles.sellbutton)
thisorder.setText(
func.sellOrder("Limit", el[2], el[3],
el[4] + "\n id: " + el[-1]))
self.formLayout3.insertRow(0, thisorder)
except:
print("Error reloadSystemOrders")
def getUpdate(self):
self.reloadData()
def closeEvent(self, event):
print("Goodbye")
# TODO приложение работает в фоновом режиме даже после закрытия
self.thread.terminate()
self.thread1.terminate()
self.thread2.terminate()
self.thread3.terminate()
pid = os.getpid()
os.kill(pid, signal.SIGINT)
print(pid)
print("BYE")
class AppView(QMainWindow):
def __init__(self, products):
"""View initializer."""
super().__init__()
self.setWindowTitle('Calcul compatibilité produits')
self.setFixedSize(400, 400)
self.generalLayout = QVBoxLayout()
self._centralWidget = QWidget(self)
self.setCentralWidget(self._centralWidget)
self._centralWidget.setLayout(self.generalLayout)
self.products = products
self._create_form()
self._create_buttons()
self._create_display()
def _create_form(self):
combo = CheckableComboBox()
combo.addItems(self.products)
self.form = QFormLayout()
self.form.addRow('Produits:', combo)
self.generalLayout.addLayout(self.form)
def _create_buttons(self):
self.buttons = {}
buttonsLayout = QGridLayout()
buttons = {'Run': (0, 0), 'Cancel': (0, 1)}
for btnText, pos in buttons.items():
self.buttons[btnText] = QPushButton(btnText)
self.buttons[btnText].setFixedSize(80, 40)
buttonsLayout.addWidget(self.buttons[btnText], pos[0], pos[1])
self.generalLayout.addLayout(buttonsLayout)
def _create_display(self):
"""Create the display."""
# self.table = QTableWidget()
# self.table.setRowCount(1)
# self.table.setColumnCount(2)
# self.table.setItem(0, 0, QTableWidgetItem("Groupe"))
# self.table.setItem(0, 1, QTableWidgetItem("Produit"))
self.display = QLabel()
self.display.setAlignment(Qt.AlignCenter)
self.display.setFixedSize(400, 400)
self.generalLayout.addWidget(self.display)
def set_display(self, group_dict):
text = ""
for g, plist in group_dict.items():
text += f'Rétention {g}: '
first = True
for p in plist:
if first:
text += f'{p}\n'
first = False
else:
text += f' {p}\n'
text += " --------------------- \n"
self.display.setText(text)
# i = 1
# for g, plist in group_dict.items():
# for p in plist:
# self.table.insertRow(i)
# self.table.setItem(i, 0, QTableWidgetItem(str(g)))
# self.table.setItem(i, 1, QTableWidgetItem(str(p)))
# i += 1
def clear_display(self):
widget = self.form.itemAt(1)
combo = widget.widget()
combo.clear()
for i in range(1, self.table.rowCount() + 1):
self.table.removeRow(1)
class First(QtWidgets.QMainWindow):
def __init__(self, parent=None):
super(First, self).__init__(parent)
self.title = 'Comic to Text Illustration'
self.left = 10
self.top = 10
self.width = 500
self.height = 500
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
# Create textbox
self.textbox = QLineEdit(self)
self.textbox.move(20, 20)
self.textbox.resize(200, 40)
# add button
self.addButton = QPushButton('Analyze')
self.addButton.clicked.connect(self.on_click)
self.addButton.move(20, 80)
# del button
self.delButton = QPushButton('Delete')
self.delButton.clicked.connect(self.on_click_del)
self.delButton.move(20, 100)
# scroll area widget contents - layout
self.scrollLayout = QFormLayout()
# scroll area widget contents
self.scrollWidget = QWidget()
self.scrollWidget.setLayout(self.scrollLayout)
# scroll area
self.scrollArea = QScrollArea()
self.scrollArea.setWidgetResizable(True)
self.scrollArea.setWidget(self.scrollWidget)
# main layout
self.mainLayout = QVBoxLayout()
# add all main to the main vLayout
self.mainLayout.addWidget(self.textbox)
self.mainLayout.addWidget(self.addButton)
self.mainLayout.addWidget(self.scrollArea)
self.mainLayout.addWidget(self.delButton)
# central widget
self.centralWidget = QWidget()
self.centralWidget.setLayout(self.mainLayout)
# set central widget
self.setCentralWidget(self.centralWidget)
def on_click(self):
textObtained = self.textbox.text()
extraction(textObtained)
i = 0
while i < len(fin_list):
self.button = QPushButton(str(fin_list[i]))
self.scrollLayout.addRow(self.button)
i = i + 1
for j in reversed(range(self.scrollLayout.count())):
self.scrollLayout.itemAt(j).widget().clicked.connect(lambda: request())
def on_click_del(self):
global k
self.textbox.setText("")
for i in reversed(range(self.scrollLayout.count())):
self.scrollLayout.itemAt(i).widget().deleteLater()
fin_list[:] = []
k = 0
class RemoteWidgetEdit(QDialog):
"""
Creates a dialog to add and edit remote widgets of different types
"""
def __init__(self, editWidget=False, **kwargs):
parent = kwargs.get('parent', None)
super(RemoteWidgetEdit, self).__init__(parent)
self.widgetType = kwargs.get('widgetType', 'PushButton')
self.name = kwargs.get('name', 'New')
self.valueOn = str(kwargs.get('valueOn', 0.0))
self.valueOff = str(kwargs.get('valueOff', 0.0))
self.minSlider = str(kwargs.get('minSlider', 0))
self.maxSlider = str(kwargs.get('maxSlider', 1))
self.stepSlider = str(kwargs.get('stepSlider', 1))
self.shortcut = str(kwargs.get('shortcut', ""))
self.shortcutPlus = str(kwargs.get('shortcutPlus', ""))
self.shortcutMinus = str(kwargs.get('shortcutMinus', ""))
self.curModule = kwargs.get('module', None)
self.curParameter = kwargs.get('parameter', None)
self.editWidget = editWidget
self.minSliderText = None
self.maxSliderText = None
self.stepSliderText = None
self.valueOffText = None
self.valueOnText = None
self.valueText = None
self.shortcutField = None
self.shortcutFieldPlus = None
self.shortcutFieldMinus = None
mainLayout = QFormLayout()
self.nameText = QLineEdit(self.name)
mainLayout.addRow(QLabel("Name"), self.nameText)
self.nameText.mousePressEvent = lambda event: self.nameText.selectAll()
self.typeList = QComboBox()
self.typeList.addItems(["PushButton", "Switch", "Slider"])
self.typeList.setCurrentText(self.widgetType)
self.typeList.currentIndexChanged.connect(self.typeListChanged)
self.typeList.setEnabled(not self.editWidget)
mainLayout.addRow(QLabel("Widget type"), self.typeList)
self.moduleList = QComboBox()
self.paramList = QComboBox()
self.modules = dict()
exp = kwargs.get('exp', None)
for key, value in exp.items():
self.modules[key] = [k for k, v in value.items()]
self.moduleList.addItem(key)
self.moduleList.currentIndexChanged.connect(self.moduleChanged)
if self.curModule is None:
self.moduleList.setCurrentIndex(0)
self.moduleChanged()
else:
self.moduleList.setCurrentText(self.curModule)
self.moduleChanged()
if self.curParameter is not None:
self.paramList.setCurrentText(self.curParameter)
mainLayout.addRow(QLabel("Modules:"), self.moduleList)
mainLayout.addRow(QLabel("Parameter:"), self.paramList)
self.settingsWidget = QWidget()
self.settingsWidgetLayout = QFormLayout()
self.settingsWidget.setLayout(self.settingsWidgetLayout)
mainLayout.addRow(self.settingsWidget)
self.typeListChanged()
self.setLayout(mainLayout)
# OK and Cancel buttons
buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
mainLayout.addWidget(buttons)
self.setWindowTitle("Add Remote Widget ...")
resPath = getResource("icon.svg")
self.icon = QIcon(resPath)
self.setWindowIcon(self.icon)
self.setFixedSize(self.sizeHint())
def typeListChanged(self):
for i in reversed(range(self.settingsWidgetLayout.count())):
self.settingsWidgetLayout.itemAt(i).widget().deleteLater()
height = QLineEdit().sizeHint().height()
if self.typeList.currentText() == "PushButton":
self.valueText = QLineEdit(self.valueOn)
self.settingsWidgetLayout.addRow(QLabel("Value"), self.valueText)
self.valueText.setValidator(QDoubleValidator())
self.valueText.mousePressEvent = lambda event: self.valueText.selectAll(
)
self.shortcutField = ShortcutCreator()
self.shortcutField.setText(self.shortcut)
self.settingsWidgetLayout.addRow(QLabel("Shortcut:"),
self.shortcutField)
dummy = QLabel("")
dummy.setFixedHeight(height)
self.settingsWidgetLayout.addRow(None, dummy)
dummy2 = QLabel("")
dummy2.setFixedHeight(height)
self.settingsWidgetLayout.addRow(None, dummy2)
dummy3 = QLabel("")
dummy3.setFixedHeight(height)
self.settingsWidgetLayout.addRow(None, dummy3)
elif self.typeList.currentText() == "Switch":
self.valueOnText = QLineEdit(self.valueOn)
self.settingsWidgetLayout.addRow(QLabel("Value On"),
self.valueOnText)
self.valueOnText.setValidator(QDoubleValidator())
self.valueOnText.mousePressEvent = lambda event: self.valueOnText.selectAll(
)
self.valueOffText = QLineEdit(self.valueOff)
self.settingsWidgetLayout.addRow(QLabel("Value Off"),
self.valueOffText)
self.valueOffText.mousePressEvent = lambda event: self.valueOffText.selectAll(
)
self.valueOffText.setValidator(QDoubleValidator())
self.shortcutField = ShortcutCreator()
self.shortcutField.setText(self.shortcut)
self.settingsWidgetLayout.addRow(QLabel("Shortcut:"),
self.shortcutField)
dummy = QLabel("")
dummy.setFixedHeight(height)
self.settingsWidgetLayout.addRow(None, dummy)
dummy2 = QLabel("")
dummy2.setFixedHeight(height)
self.settingsWidgetLayout.addRow(None, dummy2)
elif self.typeList.currentText() == "Slider":
self.maxSliderText = QLineEdit(str(self.maxSlider))
self.settingsWidgetLayout.addRow(QLabel("Max"), self.maxSliderText)
self.maxSliderText.setValidator(QDoubleValidator())
self.maxSliderText.mousePressEvent = lambda event: self.maxSliderText.selectAll(
)
self.minSliderText = QLineEdit(str(self.minSlider))
self.settingsWidgetLayout.addRow(QLabel("Min"), self.minSliderText)
self.minSliderText.setValidator(QDoubleValidator())
self.minSliderText.mousePressEvent = lambda event: self.minSliderText.selectAll(
)
self.stepSliderText = QLineEdit(str(self.stepSlider))
self.settingsWidgetLayout.addRow(QLabel("Step Size"),
self.stepSliderText)
self.stepSliderText.setValidator(QDoubleValidator())
self.stepSliderText.mousePressEvent = lambda event: self.stepSliderText.selectAll(
)
self.shortcutFieldPlus = ShortcutCreator()
self.shortcutFieldPlus.setText(self.shortcutPlus)
self.settingsWidgetLayout.addRow(QLabel("Shortcut Plus:"),
self.shortcutFieldPlus)
self.shortcutFieldMinus = ShortcutCreator()
self.shortcutFieldMinus.setText(self.shortcutMinus)
self.settingsWidgetLayout.addRow(QLabel("Shortcut Minus:"),
self.shortcutFieldMinus)
def moduleChanged(self):
self.paramList.clear()
module = self.moduleList.currentText()
for p in self.modules[module]:
self.paramList.addItem(p)
def _getData(self):
msg = dict()
msg['name'] = self.nameText.text()
msg['widgetType'] = self.typeList.currentText()
msg['module'] = self.moduleList.currentText()
msg['parameter'] = self.paramList.currentText()
if self.typeList.currentText() == "PushButton":
msg['valueOn'] = self.valueText.text()
msg['shortcut'] = self.shortcutField.getKeySequence()
elif self.typeList.currentText() == "Switch":
msg['valueOn'] = self.valueOnText.text()
msg['valueOff'] = self.valueOffText.text()
msg['shortcut'] = self.shortcutField.getKeySequence()
elif self.typeList.currentText() == "Slider":
msg['minSlider'] = self.minSliderText.text()
msg['maxSlider'] = self.maxSliderText.text()
msg['stepSlider'] = self.stepSliderText.text()
msg['shortcutPlus'] = self.shortcutFieldPlus.getKeySequence()
msg['shortcutMinus'] = self.shortcutFieldMinus.getKeySequence()
return msg
@staticmethod
def getData(exp=None, editWidget=False, **kwargs):
dialog = RemoteWidgetEdit(exp=exp, editWidget=editWidget, **kwargs)
result = dialog.exec_()
msg = dialog._getData()
if msg['widgetType'] == "Slider":
if msg['parameter'] in exp[msg['module']]:
msg['startValue'] = exp[msg['module']][msg['parameter']]
else:
msg['startValue'] = 0
return msg, result == QDialog.Accepted
class Popup(QDialog):
def __init__(self, schedule: Schedule, parent=None, edit_data=None):
super(Popup, self).__init__(parent)
self.schedule = schedule
self.event_name, self.data = edit_data if edit_data is not None else (
None, None)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
self.setWindowTitle("Add New Scheduled Notes" if edit_data is None else
"Edit {} Details".format(self.event_name))
self.layout = QVBoxLayout()
self.layout.setSpacing(0)
self.form_layout = QFormLayout()
self.form_layout.setContentsMargins(0, 0, 0,
self.form_layout.verticalSpacing())
self.form_layout_widget = QWidget()
self.form_layout_widget.setLayout(self.form_layout)
#The amount of fields in the form that come before the block section (name, #blocks, start, end date, color)
self.rows_before_blocks = 3
self.event_type = QPushButton()
event_type_menu = QMenu()
event_type_menu.addAction("Class")
event_type_menu.addSection("Event")
event_type_menu.addAction("One Time Event")
event_type_menu.addAction("Recurring Event")
event_type_menu.addAction("One Time Class Event")
for action in event_type_menu.actions():
if not action.isSeparator():
action.triggered.connect(
lambda state, x=action.text(): self.set_type(x))
self.event_type.setMenu(event_type_menu)
self.form_layout.addRow("Type:", self.event_type)
#Class Title
self.name_edit = QLineEdit()
self.form_layout.addRow("Name:", self.name_edit)
#Color
self.color_picker = QColorDialog()
self.color_button = QPushButton("Pick Color")
self.color_button.clicked.connect(self.color_picker.open)
self.color_picker.currentColorChanged.connect(self.update_color)
self.form_layout.addRow("Color Code:", self.color_button)
# Initialize widgets to be added later
self.start_date_model = DateTimePickerSeriesModel(self)
self.class_start_date = DateTimePickerSeries(self.start_date_model,
"MMM d yyyy")
self.event_start_date = DateTimePickerSeries(self.start_date_model,
"MMM d yyyy")
self.end_date_model = DateTimePickerSeriesModel(self)
self.class_end_date = DateTimePickerSeries(self.end_date_model,
"MMM d yyyy")
self.event_end_date = DateTimePickerSeries(self.end_date_model,
"MMM d yyyy")
self.event_date_model = DateTimePickerSeriesModel(self)
self.class_event_date = DateTimePickerSeries(self.event_date_model,
"MMM d yyyy hh:mm:AP")
self.event_date = DateTimePickerSeries(self.event_date_model,
"MMM d yyyy hh:mm:AP")
# Blocks
self.blocks = 1
self.spin_box = QSpinBox()
self.spin_box.setValue(1)
self.spin_box.setMinimum(1)
self.spin_box.setMaximum(7)
self.spin_box.valueChanged.connect(self.update_blocks)
self.class_picker = QPushButton()
class_picker_menu = QMenu()
for class_name in self.schedule.schedule.keys():
if self.schedule.schedule[class_name]["type"] != "class":
continue
class_action = QAction(class_name, parent=class_picker_menu)
class_action.triggered.connect(lambda state, x=class_action.text():
self.class_picker.setText(x))
class_picker_menu.addAction(class_action)
class_picker_menu.aboutToShow.connect(
lambda: class_picker_menu.setMinimumWidth(self.class_picker.width(
)))
self.class_picker.setMenu(class_picker_menu)
self.stack = QStackedWidget()
self.stack.setContentsMargins(0, 0, 0, 0)
class_layout = QFormLayout()
class_layout.setContentsMargins(0, 0, 0,
class_layout.verticalSpacing())
class_layout.addRow("Start Date:", self.class_start_date)
class_layout.addRow("End Date:", self.class_end_date)
class_layout.addRow("Weekly Blocks:", self.spin_box)
class_layout.addRow("Block Time:", ClassTimePicker())
self.class_options = QWidget()
self.class_options.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.class_options.setLayout(class_layout)
recurring_event_layout = QFormLayout()
recurring_event_layout.setContentsMargins(
0, 0, 0, recurring_event_layout.verticalSpacing())
recurring_event_layout.addRow("Start Date:", self.event_start_date)
recurring_event_layout.addRow("End Date:", self.event_end_date)
self.recurring_event_time_picker = ClassTimePicker()
recurring_event_layout.addRow("Event Time:",
self.recurring_event_time_picker)
self.recurring_event_options = QWidget()
self.recurring_event_options.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.recurring_event_options.setLayout(recurring_event_layout)
one_time_event_layout = QFormLayout()
one_time_event_layout.setContentsMargins(
0, 0, 0, one_time_event_layout.verticalSpacing())
one_time_event_layout.addRow("Event Date:", self.event_date)
self.one_time_event_options = QWidget()
self.one_time_event_options.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.one_time_event_options.setLayout(one_time_event_layout)
class_event_layout = QFormLayout()
class_event_layout.setContentsMargins(
0, 0, 0, class_event_layout.verticalSpacing())
class_event_layout.addRow("Class:", self.class_picker)
class_event_layout.addRow("Event Date:", self.class_event_date)
self.class_event_options = QWidget()
self.class_event_options.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.class_event_options.setLayout(class_event_layout)
self.stack.addWidget(self.class_event_options)
self.stack.addWidget(self.one_time_event_options)
self.stack.addWidget(self.recurring_event_options)
self.stack.addWidget(self.class_options)
if self.data is None:
self.set_type("Class")
self.layout.addWidget(self.form_layout_widget)
self.layout.addWidget(self.stack)
self.setLayout(self.layout)
self.show_buttons()
#Update Values if self.data is defined
if self.data is not None:
event_type = self.data["type"]
self.set_type(camel_case(event_type))
# noinspection PyTypeChecker
class_layout: QFormLayout = self.stack.currentWidget().layout()
self.name_edit.setText(self.event_name)
self.name_edit.setDisabled(True)
self.color_picker.setCurrentColor(to_qcolor(self.data["color"]))
if event_type in ["class", "recurring event"]:
self.start_date_model.content = QDateTime(
to_qdate(self.data["start"]))
self.end_date_model.content = QDateTime(
to_qdate(self.data["end"]))
if event_type == "class":
blocks = self.data["blocks"]
self.update_blocks(len(blocks))
for i, row in enumerate(
range(self.rows_before_blocks,
class_layout.rowCount())):
block = blocks[i]
# noinspection PyTypeChecker
block_widget: ClassTimePicker = class_layout.itemAt(
row, QFormLayout.FieldRole).widget()
block_widget.set_time(to_qtime(block["time"]))
block_widget.set_day(block["day"])
if event_type == "recurring event":
self.recurring_event_time_picker.set_day(self.data["day"])
self.recurring_event_time_picker.set_time(
to_qtime(self.data["time"]))
if event_type in ["one time event", "one time class event"]:
date_time = QDateTime()
date_time.setDate(to_qdate(self.data["date"]))
date_time.setTime(to_qtime(self.data["time"]))
self.event_date_model.content = date_time
if event_type == "one time class event":
self.class_picker.setText(self.data["class_name"])
def show_buttons(self):
save_button = QDialogButtonBox.Save if self.data is None else QDialogButtonBox.Apply
cancel_button = QDialogButtonBox.Cancel
buttonBox = QDialogButtonBox(Qt.Horizontal)
buttonBox.addButton(save_button).clicked.connect(self.accept)
buttonBox.addButton(cancel_button).clicked.connect(self.reject)
if self.data is not None:
delete_button = buttonBox.addButton(QDialogButtonBox.Discard)
delete_button.setText("Delete")
delete_button.clicked.connect(self.delete_event)
self.layout.addWidget(buttonBox)
def set_type(self, event_type: str):
if self.event_type.text() == event_type:
return
self.event_type.setText(event_type)
self.stack.currentWidget().setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
if event_type == "Class":
self.class_options.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.class_options.adjustSize()
self.stack.setCurrentWidget(self.class_options)
elif event_type == "Recurring Event":
self.recurring_event_options.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.recurring_event_options.adjustSize()
self.stack.setCurrentWidget(self.recurring_event_options)
elif event_type == "One Time Event":
self.one_time_event_options.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.one_time_event_options.adjustSize()
self.stack.setCurrentWidget(self.one_time_event_options)
elif event_type == "One Time Class Event":
self.class_event_options.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.class_event_options.adjustSize()
self.stack.setCurrentWidget(self.class_event_options)
self.stack.adjustSize()
max_width = 0
for i in range(self.form_layout.rowCount()):
widget = self.form_layout.itemAt(i, QFormLayout.LabelRole).widget()
widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
widget.adjustSize()
max_width = max(widget.size().width(), max_width)
# noinspection PyTypeChecker
current_widget_layout: QFormLayout = self.stack.currentWidget().layout(
)
for i in range(current_widget_layout.rowCount()):
widget = current_widget_layout.itemAt(
i, QFormLayout.LabelRole).widget()
widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
widget.adjustSize()
max_width = max(widget.size().width(), max_width)
for i in range(self.form_layout.rowCount()):
self.form_layout.itemAt(
i, QFormLayout.LabelRole).widget().setMinimumWidth(max_width)
for i in range(current_widget_layout.rowCount()):
current_widget_layout.itemAt(
i, QFormLayout.LabelRole).widget().setMinimumWidth(max_width)
self.adjustSize()
def update_color(self):
self.color_button.setStyleSheet(
"background-color: rgb({},{},{})".format(
self.color_picker.currentColor().red(),
self.color_picker.currentColor().green(),
self.color_picker.currentColor().blue()))
def update_blocks(self, value):
if self.spin_box.value() != value:
self.spin_box.setValue(value)
return
if self.blocks == value:
return
old_blocks = self.blocks
self.blocks = value
class_options_layout: QFormLayout = self.class_options.layout()
if self.blocks > old_blocks:
#Change label of block 1
if old_blocks == 1:
class_options_layout.itemAt(
self.rows_before_blocks,
QFormLayout.LabelRole).widget().setText("Block 1 Time:")
for i in range(1, self.blocks - old_blocks + 1):
offset = self.rows_before_blocks + old_blocks + i - 1
widget = class_options_layout.itemAt(offset,
QFormLayout.FieldRole)
label = class_options_layout.itemAt(offset,
QFormLayout.LabelRole)
if widget is not None and label is not None:
widget = widget.widget()
label = label.widget()
widget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
label.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
widget.adjustSize()
label.adjustSize()
widget.show()
label.show()
else:
picker = ClassTimePicker()
picker.sizePolicy().setRetainSizeWhenHidden(False)
class_options_layout.addRow(
"Block {} Time:".format(old_blocks + i), picker)
elif self.blocks < old_blocks:
if self.blocks == 1:
class_options_layout.itemAt(
self.rows_before_blocks,
QFormLayout.LabelRole).widget().setText("Block Time:")
for i in range(old_blocks - self.blocks):
offset = self.rows_before_blocks + old_blocks + i - 1
widget = class_options_layout.itemAt(
offset, QFormLayout.FieldRole).widget()
label = class_options_layout.itemAt(
offset, QFormLayout.LabelRole).widget()
widget.hide()
label.hide()
widget.adjustSize()
label.adjustSize()
self.class_options.adjustSize()
self.stack.adjustSize()
self.adjustSize()
# self.class_options.adjustSize()
# self.stack.adjustSize()
# self.adjustSize()
def get_name(self):
return self.name_edit.text()
def get_data(self):
event_type = self.event_type.text()
data = {
"type": event_type.lower(),
"name": self.get_name(),
"color": {
"r": self.color_picker.currentColor().red(),
"g": self.color_picker.currentColor().green(),
"b": self.color_picker.currentColor().blue(),
}
}
if event_type == "Class":
block_data = []
# noinspection PyTypeChecker
class_layout: QFormLayout = self.stack.currentWidget().layout()
for row in range(self.rows_before_blocks, class_layout.rowCount()):
# noinspection PyTypeChecker
block_widget: ClassTimePicker = class_layout.itemAt(
row, QFormLayout.FieldRole).widget()
if block_widget.isHidden():
continue
time = block_widget.get_time()
block_data.append({
"day": block_widget.day_picker.get_day(),
"time": {
"hour": time.hour(),
"minute": time.minute()
}
})
data["blocks"] = block_data
if event_type in ["Class", "Recurring Event"]:
start_date = self.start_date_model.content.date()
data["start"] = {
"day": start_date.day(),
"month": start_date.month(),
"year": start_date.year()
}
end_date = self.end_date_model.content.date()
data["end"] = {
"day": end_date.day(),
"month": end_date.month(),
"year": end_date.year()
}
if event_type == "Recurring Event":
data["day"] = self.recurring_event_time_picker.day_picker.get_day()
time = self.recurring_event_time_picker.get_time()
data["time"] = {"hour": time.hour(), "minute": time.minute()}
if event_type == "One Time Class Event":
data["class_name"] = self.class_picker.text()
if event_type in ["One Time Event", "One Time Class Event"]:
date_time = self.event_date_model.content
date = date_time.date()
time = date_time.time()
data["date"] = {
"day": date.day(),
"month": date.month(),
"year": date.year(),
}
data["time"] = {"hour": time.hour(), "minute": time.minute()}
return data
def delete_event(self):
error = QMessageBox()
error.setText("Are you sure you would like to delete this event?")
error.setStandardButtons(QMessageBox.Yes | QMessageBox.Cancel)
result = error.exec_()
if result == QMessageBox.Yes:
self.schedule.delete_event(self.event_name)
self.reject()
def accept(self):
event_type = self.event_type.text()
if event_type == "":
error = QMessageBox()
error.setText("Please select a type for the event.")
error.exec_()
self.event_type.setFocus()
return
# Check Name
if len(self.get_name()) == 0:
error = QMessageBox()
error.setText("Please enter a name for the event.")
error.exec_()
self.name_edit.setFocus()
return
if event_type in ["Class", "Recurring Event"]:
# Check Start/End Date
start_date = self.start_date_model.content.date()
end_date = self.end_date_model.content.date()
if start_date >= end_date:
error = QMessageBox()
error.setText("End date cannot {} start date.".format(
"be equal to" if start_date ==
end_date else "come before"))
error.exec_()
if event_type == "Class":
self.class_end_date.setFocus()
else:
self.event_end_date.setFocus()
return
if event_type == "Class":
# Check Blocks
# noinspection PyTypeChecker
class_layout: QFormLayout = self.stack.currentWidget().layout()
for row in range(self.rows_before_blocks,
class_layout.rowCount()):
block_widget = class_layout.itemAt(
row, QFormLayout.FieldRole).widget()
if block_widget.isHidden():
continue
# Make sure a day is selected for each block
if not block_widget.is_valid():
block_name = "the class block" if self.blocks == 1 else str.lower(
class_layout.itemAt(row, QFormLayout.LabelRole).
widget().text()).replace(" time:", "")
error = QMessageBox()
error.setText(
"Please select a valid day for {}.".format(
block_name))
error.exec_()
return
# Check for duplicate blocks
for other in range(self.rows_before_blocks,
class_layout.rowCount() - 1):
if row == other:
continue
other_block_widget = class_layout.itemAt(
other, QFormLayout.FieldRole).widget()
same_time = block_widget.get_time(
) == other_block_widget.get_time()
same_day = block_widget.day_picker.get_day(
) == other_block_widget.day_picker.get_day()
if same_time and same_day:
error = QMessageBox()
error.setText(
"Block {} and {} cannot have the same day and time."
.format(row - self.rows_before_blocks + 1,
other - self.rows_before_blocks + 1))
error.exec_()
return
if event_type == "Recurring Event":
# Make sure a day is selected
if not self.recurring_event_time_picker.is_valid():
error = QMessageBox()
error.setText("Please select a valid day for this event.")
error.exec_()
self.recurring_event_time_picker.setFocus()
return
if event_type == "One Time Class Event":
# Check Class
if len(self.class_picker.text()) == 0:
error = QMessageBox()
error.setText("Please select a class for this event.")
error.exec_()
self.class_picker.setFocus()
return
# Valid name
if self.get_name() in self.schedule.schedule.keys():
if self.data is None:
error = QMessageBox()
error.setText(
"An event with this name already exists, would you like to overwrite it?"
)
error.setStandardButtons(error.Apply | error.Cancel)
result = error.exec_()
if result == error.Apply:
to_overwrite = self.schedule.schedule[self.get_name()]
if to_overwrite["type"] == "class":
if self.event_type.text() == "One Time Class Event":
if self.class_picker.text() == self.get_name():
error = QMessageBox()
error.setText(
"Cannot overwrite a class with a one time class event for that class.\n"
"Please select a different class.")
error.setStandardButtons(QMessageBox.Close)
error.exec_()
return
self.schedule.edit_event(self.get_data())
self.reject()
elif result == error.Cancel:
self.name_edit.setFocus()
return
self.schedule.edit_event(self.get_data())
self.reject()
super(Popup, self).accept()
def reject(self):
super(Popup, self).reject()
class AddNodeWidget(QWidget):
def __init__(self, parent=None):
super(QWidget, self).__init__(parent)
self.initUI()
def initUI(self):
main_layout = QVBoxLayout()
self.setLayout(main_layout)
self.l = QFormLayout()
buttons_layout = QHBoxLayout()
main_layout.addLayout(self.l)
main_layout.addLayout(buttons_layout)
leNodeName = QLineEdit()
leNodeLabel = QLineEdit()
cbxNodeType = QComboBox()
self.leImagePath = QLineEdit()
pbOK = QPushButton()
pbOK.clicked.connect(lambda: self.parent().accept())
pbCancel = QPushButton()
pbCancel.clicked.connect(lambda: self.parent().reject())
browse = QPushButton("Browse")
browse.clicked.connect(self.browse)
browse.setEnabled(False)
cbxNodeType.addItems(["None", "circle", "box", "image"])
cbxNodeType.currentIndexChanged.connect(
lambda: browse.setEnabled(True) if cbxNodeType.currentText(
) == "image" else browse.setEnabled(False))
pbOK.setText("&OK")
pbCancel.setText("&Cancel")
buttons_layout.addWidget(pbOK)
buttons_layout.addWidget(pbCancel)
self.l.setWidget(0, QFormLayout.LabelRole, QLabel("Node Name"))
self.l.setWidget(0, QFormLayout.FieldRole, leNodeName)
self.l.setWidget(1, QFormLayout.LabelRole, QLabel("Node Label"))
self.l.setWidget(1, QFormLayout.FieldRole, leNodeLabel)
self.l.setWidget(2, QFormLayout.LabelRole, QLabel("Node Type"))
self.l.setWidget(2, QFormLayout.FieldRole, cbxNodeType)
self.l.setWidget(3, QFormLayout.LabelRole, QLabel("Node Image"))
self.l.setWidget(3, QFormLayout.FieldRole, self.leImagePath)
self.l.setWidget(4, QFormLayout.SpanningRole, browse)
def getResults(self):
results = []
for i in range(self.l.rowCount()):
item = self.l.itemAt(i, QFormLayout.FieldRole)
try:
text = item.widget().text()
except Exception:
text = item.widget().currentText()
results.append(text)
return results
def browse(self):
from PyQt5.QtCore import QFileInfo
from PyQt5.QtWidgets import QFileDialog
imagepath = str(
QFileDialog.getOpenFileName(self,
"Select Image",
filter="Image files (*.png *.jpg)")[0])
print(imagepath)
if imagepath:
self.leImagePath.setText(imagepath)
def __init__(self, schedule: Schedule, parent=None, edit_data=None):
super(Popup, self).__init__(parent)
self.schedule = schedule
self.event_name, self.data = edit_data if edit_data is not None else (
None, None)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
self.setWindowTitle("Add New Scheduled Notes" if edit_data is None else
"Edit {} Details".format(self.event_name))
self.layout = QVBoxLayout()
self.layout.setSpacing(0)
self.form_layout = QFormLayout()
self.form_layout.setContentsMargins(0, 0, 0,
self.form_layout.verticalSpacing())
self.form_layout_widget = QWidget()
self.form_layout_widget.setLayout(self.form_layout)
#The amount of fields in the form that come before the block section (name, #blocks, start, end date, color)
self.rows_before_blocks = 3
self.event_type = QPushButton()
event_type_menu = QMenu()
event_type_menu.addAction("Class")
event_type_menu.addSection("Event")
event_type_menu.addAction("One Time Event")
event_type_menu.addAction("Recurring Event")
event_type_menu.addAction("One Time Class Event")
for action in event_type_menu.actions():
if not action.isSeparator():
action.triggered.connect(
lambda state, x=action.text(): self.set_type(x))
self.event_type.setMenu(event_type_menu)
self.form_layout.addRow("Type:", self.event_type)
#Class Title
self.name_edit = QLineEdit()
self.form_layout.addRow("Name:", self.name_edit)
#Color
self.color_picker = QColorDialog()
self.color_button = QPushButton("Pick Color")
self.color_button.clicked.connect(self.color_picker.open)
self.color_picker.currentColorChanged.connect(self.update_color)
self.form_layout.addRow("Color Code:", self.color_button)
# Initialize widgets to be added later
self.start_date_model = DateTimePickerSeriesModel(self)
self.class_start_date = DateTimePickerSeries(self.start_date_model,
"MMM d yyyy")
self.event_start_date = DateTimePickerSeries(self.start_date_model,
"MMM d yyyy")
self.end_date_model = DateTimePickerSeriesModel(self)
self.class_end_date = DateTimePickerSeries(self.end_date_model,
"MMM d yyyy")
self.event_end_date = DateTimePickerSeries(self.end_date_model,
"MMM d yyyy")
self.event_date_model = DateTimePickerSeriesModel(self)
self.class_event_date = DateTimePickerSeries(self.event_date_model,
"MMM d yyyy hh:mm:AP")
self.event_date = DateTimePickerSeries(self.event_date_model,
"MMM d yyyy hh:mm:AP")
# Blocks
self.blocks = 1
self.spin_box = QSpinBox()
self.spin_box.setValue(1)
self.spin_box.setMinimum(1)
self.spin_box.setMaximum(7)
self.spin_box.valueChanged.connect(self.update_blocks)
self.class_picker = QPushButton()
class_picker_menu = QMenu()
for class_name in self.schedule.schedule.keys():
if self.schedule.schedule[class_name]["type"] != "class":
continue
class_action = QAction(class_name, parent=class_picker_menu)
class_action.triggered.connect(lambda state, x=class_action.text():
self.class_picker.setText(x))
class_picker_menu.addAction(class_action)
class_picker_menu.aboutToShow.connect(
lambda: class_picker_menu.setMinimumWidth(self.class_picker.width(
)))
self.class_picker.setMenu(class_picker_menu)
self.stack = QStackedWidget()
self.stack.setContentsMargins(0, 0, 0, 0)
class_layout = QFormLayout()
class_layout.setContentsMargins(0, 0, 0,
class_layout.verticalSpacing())
class_layout.addRow("Start Date:", self.class_start_date)
class_layout.addRow("End Date:", self.class_end_date)
class_layout.addRow("Weekly Blocks:", self.spin_box)
class_layout.addRow("Block Time:", ClassTimePicker())
self.class_options = QWidget()
self.class_options.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.class_options.setLayout(class_layout)
recurring_event_layout = QFormLayout()
recurring_event_layout.setContentsMargins(
0, 0, 0, recurring_event_layout.verticalSpacing())
recurring_event_layout.addRow("Start Date:", self.event_start_date)
recurring_event_layout.addRow("End Date:", self.event_end_date)
self.recurring_event_time_picker = ClassTimePicker()
recurring_event_layout.addRow("Event Time:",
self.recurring_event_time_picker)
self.recurring_event_options = QWidget()
self.recurring_event_options.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.recurring_event_options.setLayout(recurring_event_layout)
one_time_event_layout = QFormLayout()
one_time_event_layout.setContentsMargins(
0, 0, 0, one_time_event_layout.verticalSpacing())
one_time_event_layout.addRow("Event Date:", self.event_date)
self.one_time_event_options = QWidget()
self.one_time_event_options.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.one_time_event_options.setLayout(one_time_event_layout)
class_event_layout = QFormLayout()
class_event_layout.setContentsMargins(
0, 0, 0, class_event_layout.verticalSpacing())
class_event_layout.addRow("Class:", self.class_picker)
class_event_layout.addRow("Event Date:", self.class_event_date)
self.class_event_options = QWidget()
self.class_event_options.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.class_event_options.setLayout(class_event_layout)
self.stack.addWidget(self.class_event_options)
self.stack.addWidget(self.one_time_event_options)
self.stack.addWidget(self.recurring_event_options)
self.stack.addWidget(self.class_options)
if self.data is None:
self.set_type("Class")
self.layout.addWidget(self.form_layout_widget)
self.layout.addWidget(self.stack)
self.setLayout(self.layout)
self.show_buttons()
#Update Values if self.data is defined
if self.data is not None:
event_type = self.data["type"]
self.set_type(camel_case(event_type))
# noinspection PyTypeChecker
class_layout: QFormLayout = self.stack.currentWidget().layout()
self.name_edit.setText(self.event_name)
self.name_edit.setDisabled(True)
self.color_picker.setCurrentColor(to_qcolor(self.data["color"]))
if event_type in ["class", "recurring event"]:
self.start_date_model.content = QDateTime(
to_qdate(self.data["start"]))
self.end_date_model.content = QDateTime(
to_qdate(self.data["end"]))
if event_type == "class":
blocks = self.data["blocks"]
self.update_blocks(len(blocks))
for i, row in enumerate(
range(self.rows_before_blocks,
class_layout.rowCount())):
block = blocks[i]
# noinspection PyTypeChecker
block_widget: ClassTimePicker = class_layout.itemAt(
row, QFormLayout.FieldRole).widget()
block_widget.set_time(to_qtime(block["time"]))
block_widget.set_day(block["day"])
if event_type == "recurring event":
self.recurring_event_time_picker.set_day(self.data["day"])
self.recurring_event_time_picker.set_time(
to_qtime(self.data["time"]))
if event_type in ["one time event", "one time class event"]:
date_time = QDateTime()
date_time.setDate(to_qdate(self.data["date"]))
date_time.setTime(to_qtime(self.data["time"]))
self.event_date_model.content = date_time
if event_type == "one time class event":
self.class_picker.setText(self.data["class_name"])
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowTitle("Select Color")
actions = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
actions.accepted.connect(self.accept)
actions.rejected.connect(self.reject)
self.color = QColor()
dialog_layout = QVBoxLayout()
main_layout = QHBoxLayout()
value_layout = QVBoxLayout()
eight_bit_form = QFormLayout()
fullcolor_form = QFormLayout()
self.preview = QLabel()
self.preview_pixmap = QPixmap(100, 50)
self.preview.setFrameShape(QFrame.Panel)
self.preview.setFrameShadow(QFrame.Sunken)
self.preview.setLineWidth(3)
self.preview.setScaledContents(True)
value_layout.addWidget(self.preview)
header = QFont()
header.setBold(True)
ebframe = QFrame()
ebframe.setFrameShape(QFrame.StyledPanel)
eight_bit_form.addRow(QLabel("8-bit color"))
eight_bit_form.itemAt(0).setAlignment(Qt.AlignCenter)
eight_bit_form.itemAt(0).widget().setFont(header)
self.r8 = QLineEdit()
self.r8.setFixedWidth(60)
self.r8.setValidator(ColorValidator(7))
self.r8.editingFinished.connect(self.set8BitColors)
self.g8 = QLineEdit()
self.g8.setFixedWidth(60)
self.g8.setValidator(ColorValidator(7))
self.g8.editingFinished.connect(self.set8BitColors)
self.b8 = QLineEdit()
self.b8.setFixedWidth(60)
self.b8.setValidator(ColorValidator(3))
self.b8.editingFinished.connect(self.set8BitColors)
self.hex8 = QLineEdit()
self.hex8.setValidator(
QRegExpValidator(QRegExp(r"#?(?:[0-9a-fA-F]{2})")))
self.hex8.setFixedWidth(60)
self.hex8.editingFinished.connect(self.set8BitHex)
self.hex8.installEventFilter(self)
eight_bit_form.addRow(QLabel("Red:"), self.r8)
eight_bit_form.addRow(QLabel("Green:"), self.g8)
eight_bit_form.addRow(QLabel("Blue:"), self.b8)
eight_bit_form.addRow(QLabel("Hex:"), self.hex8)
ebframe.setLayout(eight_bit_form)
value_layout.addWidget(ebframe)
fcframe = QFrame()
fcframe.setFrameShape(QFrame.StyledPanel)
fullcolor_form.addRow(QLabel("Full color"))
fullcolor_form.itemAt(0).setAlignment(Qt.AlignCenter)
fullcolor_form.itemAt(0).widget().setFont(header)
self.r24 = QLineEdit()
self.r24.setFixedWidth(60)
self.r24.setValidator(ColorValidator(255))
self.r24.editingFinished.connect(self.set24BitColors)
self.g24 = QLineEdit()
self.g24.setValidator(ColorValidator(255))
self.g24.setFixedWidth(60)
self.g24.editingFinished.connect(self.set24BitColors)
self.b24 = QLineEdit()
self.b24.setValidator(ColorValidator(255))
self.b24.setFixedWidth(60)
self.b24.editingFinished.connect(self.set24BitColors)
self.hex24 = QLineEdit()
self.hex24.setValidator(
QRegExpValidator(QRegExp(r"#?(?:[0-9a-fA-F]{6})")))
self.hex24.setFixedWidth(60)
self.hex24.installEventFilter(self)
fullcolor_form.addRow(QLabel("Red:"), self.r24)
fullcolor_form.addRow(QLabel("Green:"), self.g24)
fullcolor_form.addRow(QLabel("Blue:"), self.b24)
fullcolor_form.addRow(QLabel("Hex:"), self.hex24)
fcframe.setLayout(fullcolor_form)
value_layout.addWidget(fcframe)
self.color_palette = ColorPalette()
for swatch in self.color_palette.palette:
swatch.clicked.connect(self.setColor)
main_layout.addWidget(self.color_palette)
main_layout.addLayout(value_layout)
dialog_layout.setSizeConstraint(QLayout.SetFixedSize)
dialog_layout.addLayout(main_layout)
dialog_layout.addWidget(actions)
self.setLayout(dialog_layout)
class IntegrateEditor(BaseEditor):
"""
Editor to integrate defined regions.
"""
Integrators_classes = Integrate.INTEGRALS
Integrators = [a.name for a in Integrators_classes]
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self._limits = []
self.setLayout(QVBoxLayout())
self.form_set = QFormLayout()
self.form_lim = QFormLayout()
self.layout().addLayout(self.form_set)
self.layout().addLayout(self.form_lim)
self.methodcb = QComboBox()
self.methodcb.addItems(self.Integrators)
self.form_set.addRow("Integration method:", self.methodcb)
self.methodcb.currentIndexChanged.connect(self.changed)
self.methodcb.activated.connect(self.edited)
self.focusIn = self.activateOptions
self.add_limit()
button = QPushButton("Add Region")
self.layout().addWidget(button)
button.clicked.connect(self.add_limit)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)
self.user_changed = False
def activateOptions(self):
self.parent_widget.curveplot.clear_markings()
for row in range(self.form_lim.count()):
limitbox = self.form_lim.itemAt(row, 1)
if limitbox:
self.parent_widget.curveplot.add_marking(limitbox.line1)
self.parent_widget.curveplot.add_marking(limitbox.line2)
def add_limit(self, *args, row=None):
if row is None:
row = len(self._limits)
try:
self._limits.append(self._limits[-1])
except IndexError:
self._limits.append([0., 1.])
label = "Region {0}".format(row + 1)
limitbox = LimitsBox(limits=self._limits[row], label=label)
if self.form_lim.rowCount() < row + 1:
# new row
self.form_lim.addRow(limitbox)
else:
# row already exists
self.form_lim.setLayout(row, 2, limitbox)
limitbox.focusIn = self.activateOptions
limitbox.valueChanged.connect(self.set_limits)
limitbox.editingFinished.connect(self.edited)
limitbox.deleted.connect(self.remove_limit)
self.edited.emit()
return limitbox
def remove_limit(self, limitbox):
row, role = self.form_lim.getLayoutPosition(limitbox)
for r in range(row, len(self._limits)):
limitbox = self.form_lim.itemAt(r, 1)
limitbox.removeLayout()
self._limits.pop(row)
self.set_all_limits(self._limits)
def set_limits(self, limits, limitbox, user=True):
if user:
self.user_changed = True
row, role = self.form_lim.getLayoutPosition(limitbox)
if self._limits[row] != limits:
self._limits[row] = limits
with blocked(self.form_lim):
limitbox.lowlime.setValue(limits[0])
limitbox.highlime.setValue(limits[1])
self.changed.emit()
def set_all_limits(self, limits, user=True):
if user:
self.user_changed = True
self._limits = limits
for row in range(len(limits)):
limitbox = self.form_lim.itemAt(row, 1)
if limitbox is None:
limitbox = self.add_limit(row=row)
with blocked(limitbox):
limitbox.lowlime.setValue(limits[row][0])
limitbox.highlime.setValue(limits[row][1])
self.changed.emit()
def setParameters(self, params):
if params: # parameters were manually set somewhere else
self.user_changed = True
self.methodcb.setCurrentIndex(
params.get("method",
self.Integrators_classes.index(Integrate.Baseline)))
self.set_all_limits(params.get("limits", [[0., 1.]]), user=False)
def parameters(self):
return {"method": self.methodcb.currentIndex(), "limits": self._limits}
@staticmethod
def createinstance(params):
methodindex = params.get(
"method",
IntegrateEditor.Integrators_classes.index(Integrate.Baseline))
method = IntegrateEditor.Integrators_classes[methodindex]
limits = params.get("limits", None)
return Integrate(methods=method, limits=limits)
def set_preview_data(self, data):
if not self.user_changed:
x = getx(data)
if len(x):
self.set_all_limits([[min(x), max(x)]])
self.edited.emit()
class MainLayout:
def __init__(self):
self.parameters = {}
self.main = QVBoxLayout()
container = QHBoxLayout()
self.opf = QFormLayout()
title = QLabel("Set Operational Parameters")
title.setFont(QFont('Helvetica', 14))
title.setAlignment(Qt.AlignCenter)
self.opf.addRow(title)
self.opf.setVerticalSpacing(20)
ops = [('Nm', "Speed of Motor", '1450'), ('Nd', "Speed of Digester Shaft", '109'),
('Nc', "Speed of Cake Breaker Shaft", '109'), ('Na', "Speed of Auger Shaft", '218'),
('Nsp', "Speed of Screw Press Shaft", '60')]
self.defaults = QPushButton('Clear')
self.defaults.setToolTip('Toggle this button to use optimized values for Operational Parameters')
self.defaults.setCheckable(1)
self.defaults.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
self.defaults.toggled.connect(self._defaults)
dl = QLabel('Reset')
dl.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
for op in ops:
opp = QLineEdit()
opp.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
opp.setText(op[2])
lb = QLabel(op[1])
lb.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
opp.setPlaceholderText(op[1])
opp.setObjectName(op[1])
opp.setAccessibleName(op[0])
opp.setInputMask('>0000;_')
self.opf.addRow(lb, opp)
self.opf.addRow(dl, self.defaults)
frame = QFrame()
frame.setLayout(self.opf)
frame.setObjectName('opf')
# Layout for Throughput input
tpf = QVBoxLayout()
self.capacity = QLineEdit()
self.capacity.setAlignment(Qt.AlignLeft | Qt.AlignCenter)
self.capacity.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
dv = DV(280, 5650, 3, self.capacity)
dv.setNotation(DV.StandardNotation)
self.capacity.setValidator(dv)
self.capacity.setPlaceholderText('Enter value between 280 and 5650')
title = QLabel("Set Throughput Capacity")
title.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
title.setFont(QFont('Helvetica', 14))
title.setAlignment(Qt.AlignLeft | Qt.AlignCenter)
tpf.addWidget(title)
tpf.addSpacing(15)
tpf.addWidget(self.capacity)
tpf.setAlignment(Qt.AlignLeft | Qt.AlignCenter)
frame1 = QFrame()
frame1.setLayout(tpf)
frame1.setObjectName('tpf')
container.addWidget(frame1)
container.addSpacing(50)
container.addWidget(frame)
self.bs = QHBoxLayout()
self.compute = QPushButton('Compute')
self.compute.setCheckable(True)
self.compute.clicked.connect(self.run)
self.reset = QPushButton('Reset')
self.reset.setCheckable(True)
self.reset.clicked.connect(self._reset)
self.reset.setEnabled(False)
self.report = QPushButton('Generate Report')
self.report.setCheckable(True)
self.report.clicked.connect(self._generate)
self.report.setEnabled(False)
self.bs.addWidget(self.compute)
self.bs.setSpacing(15)
self.bs.addWidget(self.report)
self.bs.addWidget(self.reset)
self.bs.setAlignment(Qt.AlignCenter | Qt.AlignBottom)
self.main.addLayout(container)
self.main.addSpacing(20)
self.main.addLayout(self.bs)
mframe = QFrame()
mframe.setLayout(self.main)
mframe.setObjectName('main')
mframe.setFrameShape(QFrame.StyledPanel)
mframe.setFrameStyle(QFrame.Raised | QFrame.Panel)
mframe.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
ml = QVBoxLayout()
ml.addWidget(mframe)
ml.setAlignment(Qt.AlignCenter | Qt.AlignTop)
self.tabs = QTabWidget()
self.tabs.setTabPosition(QTabWidget.North)
self.tabs.setMovable(True)
self.widget = QWidget()
self.widget.setObjectName('mainf')
self.widget.setContentsMargins(0, 50, 0, 0)
self.widget.setLayout(ml)
self.tabs.insertTab(0, self.widget, 'Results')
def _defaults(self, s):
dp = {'Nm': '1450', 'Nd': '109', 'Nc': '109', 'Na': '218', 'Nsp': '60'}
num = self.opf.count()
if s:
self.defaults.setText('Defaults')
else:
self.defaults.setText('Clear')
for i in range(num):
child = self.opf.itemAt(i).widget()
if isinstance(child, QLineEdit):
if s:
child.setText('')
else:
child.setText(dp[child.accessibleName()])
def _generate(self):
path = homedir('m')
path = str(path / self.parameters['filename'])
file, _ = QFileDialog.getSaveFileName(self.report, 'Save Manual', path, "PDF Format (*.pdf)")
if file:
BuildDoc(self.parameters, file)
def run(self, s):
res = self.validate()
if res['status']:
tpd, op = res['results'][0], res['results'][1:]
output = model(tpd, op)
self.parameters = format_results(output, tpd)
self.buiildTables()
self.showImages()
self.compute.setDisabled(True)
self.reset.setEnabled(True)
self.report.setEnabled(True)
else:
self.msgBox(res['err'])
def _reset(self, r):
self.compute.setDisabled(False)
while self.tabs.count() > 1:
self.tabs.removeTab(1)
self.reset.setEnabled(False)
self.report.setEnabled(False)
def validate(self):
err = ''
inputs = []
try:
if (i := self.capacity.text()) and (280 <= int(i) <= 5650):
inputs.append(int(i))
else:
def add_file_name_form_layout(self, outer_layout: QVBoxLayout) -> None:
"""File Name for the new pdf will be create"""
form_layout = QFormLayout()
form_layout.addRow("Nombre del archivo: ", QLineEdit("combined_file"))
self.name = form_layout.itemAt(0, 1).widget().text()
outer_layout.addLayout(form_layout)
