def __init__(self, iris, chans, start, stop, parent=None):
QWidget.__init__(self, parent)
layout = QHBoxLayout(self)
self._iris = iris
self._chans = chans
self._start = start
self._stop = stop
self._editWidgets = dict()
for ch in chans:
if len(chans) == 1: title = ""
elif start == 0x011C: title = 'SX' + "RT"[ch]
else: title = "Ch" + "AB"[ch]
groupBox = QGroupBox(title, self)
layout.addWidget(groupBox)
hbox = QHBoxLayout(groupBox)
formLayout = QFormLayout()
hbox.addLayout(formLayout)
for i, addr in enumerate(range(start, stop + 1)):
for key, param_addr, bit_start, bit_stop, default, name, desc in PARAMS:
if addr != param_addr: continue
edit = LowLevelEditWidget(param_addr, bit_start, bit_stop,
default, name, desc, self)
edit.setToolTip(desc)
if formLayout.count() == 40:
formLayout = QFormLayout()
hbox.addLayout(formLayout)
formLayout.addRow(name, edit)
self._editWidgets[(key, ch)] = edit
edit.valueChanged.connect(
functools.partial(LowLevelControlTab.rmwSetting, iris,
ch, addr, bit_start, bit_stop))
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 Approval(QMainWindow):
def __init__(self):
super(Approval, self).__init__()
self.setWindowTitle("Expedited Approval Tool")
self.setWindowIcon(QIcon('icon/PS_Icon.png'))
self.frmMain = QFormLayout()
#test
mainLayout = QWidget()
mainLayout.setLayout(self.frmMain)
self.setCentralWidget(mainLayout)
self.formMain()
def formMain(self):
leProbSheet = QLineEdit()
leProbSheet.setMaximumWidth(50)
self.frmMain.addRow(QLabel("Enter Problem Sheet ID:"), leProbSheet)
hbShip = self.createRadioGroup("Ship")
rbtnShipYes = self.rb.get("ShipYes")
rbtnShipNo = self.rb.get("ShipNo")
rbtnShipNo.setChecked(True)
self.frmMain.addRow(
QLabel(
"Did you confirm the correct shipping was \n selected and the correct pricing was quoted?"
), hbShip)
hbYY = self.createRadioGroup("YY")
rbtnYYYes = self.rb.get("YYYes")
rbtnYYNo = self.rb.get("YYNo")
rbtnYYNo.setChecked(True)
self.frmMain.addRow(
QLabel("Is the order a YY or a non-suspicious NY/YN?"), hbYY)
hbOver = self.createRadioGroup("Over")
rbtnOverYes = self.rb.get("OverYes")
rbtnOverNo = self.rb.get("OverNo")
rbtnOverNo.setChecked(True)
self.frmMain.addRow(
QLabel(
"Did you override and upgrade the shipping \n in Stone Edge?"),
hbOver)
teNotes = QTextEdit()
teNotes.setMaximumHeight(125)
self.frmMain.addRow(QLabel("Additional Notes:"))
self.frmMain.addRow(teNotes)
btnApprove = QPushButton("Approved")
btnApprove.clicked.connect(lambda: self.btnApprove_Click(
leProbSheet.text(), rbtnShipYes.isChecked(), rbtnYYYes.isChecked(),
rbtnOverYes.isChecked(), teNotes.toPlainText()))
btnDeny = QPushButton("Not Approved")
btnDeny.clicked.connect(lambda: self.btnDeny_Click(
leProbSheet.text(), rbtnShipYes.isChecked(), rbtnYYYes.isChecked(),
rbtnOverYes.isChecked(), teNotes.toPlainText()))
btnQuit = QPushButton("Quit")
btnQuit.clicked.connect(self.btnCancel_Click)
hbBtnBox = QHBoxLayout()
hbBtnBox.addWidget(btnApprove)
hbBtnBox.addWidget(btnDeny)
hbBtnBox.addWidget(btnQuit)
self.frmMain.addRow(hbBtnBox)
def btnApprove_Click(self, probSheetID, correctShip, YYorder, Override,
notes):
ad = ApprovalData()
eid = ad.checkProbSheet(probSheetID)
if eid:
cnt = ad.checkApproved(eid)
else:
cnt = 0
if eid > 0 and cnt == 0:
try:
ad.insApproval(probSheetID, eid, 1, correctShip, YYorder,
Override, notes)
ad.updExpedited(eid, 1)
self.removeWidgets()
self.formMain()
except BaseException as e:
QMessageBox.warning(
self, "Database",
"There was an issue inserting into the database. \n" +
str(e), QMessageBox.Ok)
else:
if cnt:
QMessageBox.warning(
self, "Approved",
"This problem sheet has already been approved.",
QMessageBox.Ok)
else:
QMessageBox.warning(
self, "Missing",
"This problem sheet has not been entered into the system as expedited.",
QMessageBox.Ok)
def btnDeny_Click(self, probSheetID, correctShip, YYorder, Override,
notes):
ad = ApprovalData()
eid = ad.checkProbSheet(probSheetID)
if eid:
cnt = ad.checkApproved(eid)
else:
cnt = 0
if eid > 0 and cnt == 0:
try:
ad.insApproval(probSheetID, eid, 0, correctShip, YYorder,
Override, notes)
ad.updExpedited(eid, 0)
self.removeWidgets()
self.formMain()
except BaseException as e:
QMessageBox.warning(
self, "Database",
"There was an issue inserting into the database. \n" +
str(e), QMessageBox.Ok)
else:
if cnt:
QMessageBox.warning(
self, "Approved",
"This problem sheet has already been approved.",
QMessageBox.Ok)
else:
QMessageBox.warning(
self, "Missing",
"This problem sheet has not been entered into the system as expedited.",
QMessageBox.Ok)
def btnCancel_Click(self):
sys.exit()
def createRadioGroup(self, name):
#create dict items for all of the widgets, and to pull from after creation.
bg = {}
self.rb = {}
hb = {}
#create the group to hold the button.
bg[(name)] = QButtonGroup(self)
#create yes no buttons.
self.rb[name + "Yes"] = QRadioButton("Yes")
self.rb[name + "No"] = QRadioButton("No")
#add buttons to group
bg[(name)].addButton(self.rb[name + "Yes"])
bg[(name)].addButton(self.rb[name + "No"])
#add the whole thing to a Horz. Box layout.
hb[(name)] = QHBoxLayout()
hb[(name)].addWidget(self.rb[name + "Yes"])
hb[(name)].addWidget(self.rb[name + "No"])
hb[(name)].addStretch()
#print(self.rb[name+"Yes"].isChecked())
return hb[(name)]
def removeWidgets(self):
for cnt in reversed(range(self.frmMain.count())):
# takeAt does both the jobs of itemAt and removeWidget
# namely it removes an item and returns it
widget = self.frmMain.takeAt(cnt).widget()
if widget is not None:
# widget will be None if the item is a layout
widget.deleteLater()
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 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 IPWaveformSelectorWidget(QWidget):
sig_checkbox_clicked = pyqtSignal(list)
checkbox_list = []
name_list = []
value_list = []
def __init__(self, parent):
super().__init__(parent)
self.parent = parent
self.buildUI()
def buildUI(self):
self.button_group = QButtonGroup()
self.button_group.setExclusive(False)
self.button_group.buttonClicked.connect(self.update_what_is_displayed)
self.title_label = QLabel("Show/Hide")
self.form_layout = QFormLayout()
self.tooltip_label = QLabel()
tooltip_text = 'Note: This is for displaying/hiding plots only. When you run the beamformer, all traces loaded will be used in the calculation. If you need to delete a trace, do it using the tabs in the trace viewer.'
self.tooltip_label.setText(tooltip_text)
self.tooltip_label.setWordWrap(True)
self.main_layout = QVBoxLayout()
self.main_layout.addWidget(self.title_label)
self.main_layout.addLayout(self.form_layout)
self.main_layout.addStretch()
self.main_layout.addWidget(self.tooltip_label)
self.setLayout(self.main_layout)
def update_selections(self, new_stream):
# This is called when waveforms are added or removed
# It updates the items in the checkbox list
# before we clear everything, lets first record the current elements in the name dictionary
# so we can keep track of what is currently visible/not visible. That way we can preserve
# their settings
if new_stream is None:
return # nothing to do
previous_name_list = self.name_list.copy()
previous_value_list = self.value_list.copy()
# now clear everything
self.name_list.clear()
self.value_list.clear()
self.clear_form()
for trace in new_stream:
# All new traces are automatically set to display
val = True # default value for a checkbox is True
if trace.id in previous_name_list:
# if entry was previously loaded, keep that setting
idx = previous_name_list.index(trace.id)
val = previous_value_list[idx]
# append new info to the name and value lists
self.name_list.append(trace.id)
self.value_list.append(val)
# make a new checkbox and add it to the list
new_checkbox = QCheckBox()
self.button_group.addButton(new_checkbox)
new_checkbox.setChecked(val)
self.checkbox_list.append(new_checkbox)
self.form_layout.addRow(trace.id, new_checkbox)
def clear_form(self):
self.checkbox_list.clear()
for row in reversed(range(self.form_layout.count())):
item = self.form_layout.takeAt(row)
item.widget().deleteLater()
@pyqtSlot(QAbstractButton)
def update_what_is_displayed(self, button):
# the value list is used by pl_widget to keep track of what is clicked
for idx, checkbox in enumerate(self.checkbox_list):
if checkbox is button:
self.value_list[idx] = checkbox.isChecked()
# This tells the plotviewer to update which plots to show
self.parent.pl_widget.draw_plots()
def get_checkbox_list(self):
return self.checkbox_list
def get_value_list(self):
return self.value_list
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 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:
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 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 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 Approval(QMainWindow):
def __init__(self):
super(Approval, self).__init__()
self.setWindowTitle("Expedited Approval Tool")
self.setWindowIcon(QIcon('icon/PS_Icon.png'))
self.frmMain = QFormLayout()
#test
mainLayout = QWidget()
mainLayout.setLayout(self.frmMain)
self.setCentralWidget(mainLayout)
self.formMain()
def formMain(self):
leProbSheet = QLineEdit()
leProbSheet.setMaximumWidth(50)
self.frmMain.addRow(QLabel("Enter Problem Sheet ID:"), leProbSheet)
hbShip = self.createRadioGroup("Ship")
rbtnShipYes = self.rb.get("ShipYes")
rbtnShipNo = self.rb.get("ShipNo")
rbtnShipNo.setChecked(True)
self.frmMain.addRow(QLabel("Did you confirm the correct shipping was \n selected and the correct pricing was quoted?"), hbShip)
hbYY = self.createRadioGroup("YY")
rbtnYYYes = self.rb.get("YYYes")
rbtnYYNo = self.rb.get("YYNo")
rbtnYYNo.setChecked(True)
self.frmMain.addRow(QLabel("Is the order a YY or a non-suspicious NY/YN?"), hbYY)
hbOver = self.createRadioGroup("Over")
rbtnOverYes = self.rb.get("OverYes")
rbtnOverNo = self.rb.get("OverNo")
rbtnOverNo.setChecked(True)
self.frmMain.addRow(QLabel("Did you override and upgrade the shipping \n in Stone Edge?"), hbOver)
teNotes = QTextEdit()
teNotes.setMaximumHeight(125)
self.frmMain.addRow(QLabel("Additional Notes:"))
self.frmMain.addRow(teNotes)
btnApprove = QPushButton("Approved")
btnApprove.clicked.connect(lambda: self.btnApprove_Click(leProbSheet.text(), rbtnShipYes.isChecked(), rbtnYYYes.isChecked(), rbtnOverYes.isChecked(), teNotes.toPlainText()))
btnDeny = QPushButton("Not Approved")
btnDeny.clicked.connect(lambda: self.btnDeny_Click(leProbSheet.text(), rbtnShipYes.isChecked(), rbtnYYYes.isChecked(), rbtnOverYes.isChecked(), teNotes.toPlainText()))
btnQuit = QPushButton("Quit")
btnQuit.clicked.connect(self.btnCancel_Click)
hbBtnBox = QHBoxLayout()
hbBtnBox.addWidget(btnApprove)
hbBtnBox.addWidget(btnDeny)
hbBtnBox.addWidget(btnQuit)
self.frmMain.addRow(hbBtnBox)
def btnApprove_Click(self, probSheetID, correctShip, YYorder, Override, notes):
ad = ApprovalData()
eid = ad.checkProbSheet(probSheetID)
if eid:
cnt = ad.checkApproved(eid)
else: cnt = 0
if eid > 0 and cnt == 0:
try:
ad.insApproval(probSheetID, eid, 1, correctShip, YYorder, Override, notes)
ad.updExpedited(eid, 1)
self.removeWidgets()
self.formMain()
except BaseException as e:
QMessageBox.warning(self, "Database", "There was an issue inserting into the database. \n" + str(e), QMessageBox.Ok)
else:
if cnt:
QMessageBox.warning(self, "Approved", "This problem sheet has already been approved.", QMessageBox.Ok)
else:
QMessageBox.warning(self, "Missing", "This problem sheet has not been entered into the system as expedited.", QMessageBox.Ok)
def btnDeny_Click(self, probSheetID, correctShip, YYorder, Override, notes):
ad = ApprovalData()
eid = ad.checkProbSheet(probSheetID)
if eid:
cnt = ad.checkApproved(eid)
else: cnt = 0
if eid > 0 and cnt == 0:
try:
ad.insApproval(probSheetID, eid, 0, correctShip, YYorder, Override, notes)
ad.updExpedited(eid, 0)
self.removeWidgets()
self.formMain()
except BaseException as e:
QMessageBox.warning(self, "Database", "There was an issue inserting into the database. \n" + str(e), QMessageBox.Ok)
else:
if cnt:
QMessageBox.warning(self, "Approved", "This problem sheet has already been approved.", QMessageBox.Ok)
else:
QMessageBox.warning(self, "Missing", "This problem sheet has not been entered into the system as expedited.", QMessageBox.Ok)
def btnCancel_Click(self):
sys.exit()
def createRadioGroup(self, name):
#create dict items for all of the widgets, and to pull from after creation.
bg = {}
self.rb = {}
hb = {}
#create the group to hold the button.
bg[(name)] = QButtonGroup(self)
#create yes no buttons.
self.rb[name+"Yes"] = QRadioButton("Yes")
self.rb[name+"No"] = QRadioButton("No")
#add buttons to group
bg[(name)].addButton(self.rb[name+"Yes"])
bg[(name)].addButton(self.rb[name+"No"])
#add the whole thing to a Horz. Box layout.
hb[(name)] = QHBoxLayout()
hb[(name)].addWidget(self.rb[name+"Yes"])
hb[(name)].addWidget(self.rb[name+"No"])
hb[(name)].addStretch()
#print(self.rb[name+"Yes"].isChecked())
return hb[(name)]
def removeWidgets(self):
for cnt in reversed(range(self.frmMain.count())):
# takeAt does both the jobs of itemAt and removeWidget
# namely it removes an item and returns it
widget = self.frmMain.takeAt(cnt).widget()
if widget is not None:
# widget will be None if the item is a layout
widget.deleteLater()
class PropertiesWidget(QWidget):
"""
A widget for displaying & editing properties of objects etc.
Also see the properties this likes to display:
also see: supertux/property.py
"""
def __init__(self, parent):
super().__init__(parent)
self.items = []
self.vbox = QVBoxLayout()
self.layout = QFormLayout()
self.vbox.addLayout(self.layout)
self.setLayout(self.vbox)
self.setMinimumWidth(300)
# Called in many cases. This should have functions connected
# which cause the changes in the widget to be applied
# Called by hitting "Apply", "Ok" or "Finish"
self.call_signal = Signal()
self.call_signal.connect(self.call_callbacks)
def clear_properties(self):
# Clear Items
self.items = []
# Remove all widgets
for i in range(self.layout.count()):
self.layout.layout().takeAt(0).widget().setParent(None)
def set_properties(self, props):
# Clear previous properties
self.clear_properties()
# Add all properties
for prop in props:
prop.property_dialog(self)
def add_label(self, text):
label = QLabel(text)
self.layout.addRow(label)
self.items.append(Item(Item.KIND_LABEL, label, None, None))
def add_bool(self, name, value, callback):
label = QLabel(name)
checkbox = QCheckBox()
self.layout.addRow(label, checkbox)
if value:
checkbox.setCheckState(Qt.Checked)
self.items.append(Item(Item.KIND_BOOL, label, checkbox, callback=callback))
def add_int(self, name, value, callback=None):
label = QLabel(name)
inputbox = QSpinBox()
self.layout.addRow(label, inputbox)
inputbox.setValue(value)
self.items.append(Item(Item.KIND_INT, label, inputbox, callback=callback))
def add_float(self, name, value, callback=None):
label = QLabel(name)
inputbox = QLineEdit()
self.layout.addRow(label, inputbox)
inputbox.setText(str(value))
self.items.append(Item(Item.KIND_FLOAT, label, inputbox, callback=callback))
def add_string(self, name, value, callback=None, placeholder=None):
label = QLabel(name)
inputbox = QLineEdit()
self.layout.addRow(label, inputbox)
inputbox.setText(value)
if placeholder is not None:
inputbox.setPlaceholderText(placeholder)
self.items.append(Item(Item.KIND_STRING, label, inputbox, callback=callback))
def add_file(self, label, default, ret_rel_to=None, show_rel_to=None, open_in=None, filters=("All Files (*)",),
callback=None):
"""Open a FileDialog for the user to select a file
:param ret_rel_to: Path to which the param. of callback(value)
will be relative to
:param show_rel_to: Path to which the displayed text (in input box)
will be relative to
:param open_in: Where the open file dialog will begin
:param callback: Method/function to call upon file being chosen.
:param filters: A tuple containing filters for filenames. They should appear like this:
Name of Filter (*.txt)
^ Only show .txt files
All Files (*)
C++ Files (*.cpp *.h *.hpp *.cxx)
"""
label = QLabel(label)
inputbox = QLineEdit(default)
browse = QPushButton("Browse...")
def file_selected(path):
"""Called whenever file is selected"""
# actual_path = path
if show_rel_to and path[:len(show_rel_to)] == show_rel_to:
inputbox.setText(path[len(show_rel_to):])
else:
inputbox.setText(path)
def browse_files():
"""Called when Browse... button clicked"""
dialog = OpenFileDialog("Open File")
dialog.set_directory(open_in if open_in else Config.current.datadir)
dialog.run(file_selected)
browse.clicked.connect(browse_files) # Connect the above to click signal
self.layout.addRow(label, inputbox)
self.layout.addRow(browse)
self.items.append(Item(Item.KIND_STRING, label, inputbox, callback=callback))
def add_enum(self, name, values, current_value=0, callback=None):
label = QLabel(name)
drop_down = QComboBox()
for value in values:
drop_down.addItem(value)
drop_down.setCurrentIndex(current_value)
self.layout.addRow(label, drop_down)
self.items.append(Item(Item.KIND_ENUM, label, drop_down, callback=callback, group=None))
def add_radio(self, name, values, current_value=0, callback=None):
label = QLabel(name)
group = QButtonGroup()
for i, value in enumerate(values):
radio = QRadioButton(value)
radio.setChecked(current_value == i)
if i == 0:
self.layout.addRow(label, radio)
else:
self.layout.addRow(None, radio)
group.addButton(radio)
self.items.append(Item(Item.KIND_ENUM, label, None, callback=callback, group=group))
def add_color(self, name, color, callback=None):
"""Not fully implemented according to Item class at the top."""
label = QLabel(name)
pixmap = QPixmap(32, 32)
pixmap.fill(color.to_qt())
icon = QIcon(pixmap)
colorbutton = QPushButton(icon, color.to_hex())
def on_color(qcolor):
pixmap.fill(qcolor)
icon.addPixmap(pixmap)
colorbutton.setIcon(icon)
colorbutton.setText(qcolor.name())
self.layout.addRow(label, colorbutton)
self.items.append(Item(Item.KIND_COLOR, label, colorbutton, callback=callback))
def call_callbacks(self, *args):
for item in self.items:
if item.callback is not None:
item.callback(item.get_value())
def get_values(self):
result = []
for item in self.items:
value = item.get_value()
if value is not None:
result.append(value)
return result
def add_callback(self, callback):
"""Adds a callback to the callback signal"""
self.call_signal.connect(callback)
def call(self):
self.call_signal(*self.get_values())
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 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 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 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 EventEditor (QDialog):
applied = pyqtSignal(object) # will send an Event instance
def __init__(self, event, parent):
super().__init__(parent)
self.setWindowTitle('Event Editor')
self.vbox = QVBoxLayout(self)
# vbox.addWidget(QLabel(event.name))
event_type_dropdown = QComboBox(self)
custom_event_entries = []
for code, evtype_base in script.fighter_event_types.items():
if code in ['length', 'default']:
continue
for custom_code, evtype in evtype_base.items():
text = f'{evtype["name"]} ({hex(custom_code)})'
data = [code, custom_code]
if custom_code != code:
custom_event_entries.append((text, data))
else:
event_type_dropdown.addItem(text, data)
for text, data in custom_event_entries:
event_type_dropdown.addItem(text, data)
event_type_dropdown.setCurrentIndex(event_type_dropdown.findData(event.code))
event_type_dropdown.currentIndexChanged.connect(
lambda: self.change_type(*event_type_dropdown.currentData())
)
self.vbox.addWidget(event_type_dropdown)
form_widget = QWidget(self)
self.vbox.addWidget(form_widget)
self.form = QFormLayout(form_widget)
self.event = event.copy()
self.populate_form()
buttons_widget = QWidget(self)
buttons_hbox = QHBoxLayout(buttons_widget)
ok_button = QPushButton('OK')
ok_button.pressed.connect(lambda: self.apply(close=True))
buttons_hbox.addWidget(ok_button)
cancel_button = QPushButton('Cancel')
cancel_button.pressed.connect(self.close)
buttons_hbox.addWidget(cancel_button)
apply_button = QPushButton('Apply')
apply_button.pressed.connect(self.apply)
buttons_hbox.addWidget(apply_button)
self.vbox.addWidget(buttons_widget)
def populate_form(self):
self.field_entry = []
for i, fd in enumerate(self.event.fields):
entry = self.field_editor(fd['bits'], fd['type'])
entry.set_value(self.event[i])
entry.editingFinished.connect(
lambda i=i, entry=entry: self.field_edited(i, entry.value())
)
self.field_entry.append(entry)
self.form.addRow(fd['name'], entry)
self.raw_edit = self.field_editor([0, self.event.length*8 - 1], 'h')
self.raw_edit.set_value(int(self.event))
self.raw_edit.editingFinished.connect(self.raw_changed)
self.form.addRow('Raw', self.raw_edit)
def change_type(self, code, custom_code):
self.event = script.FighterEvent.blank(code, custom_code)
while self.form.count():
self.form.removeRow(0)
app.processEvents(QEventLoop.ExcludeUserInputEvents)
self.resize(self.sizeHint());
app.processEvents(QEventLoop.ExcludeUserInputEvents)
self.resize(self.sizeHint());
self.populate_form()
app.processEvents(QEventLoop.ExcludeUserInputEvents)
def raw_changed(self):
self.event._data = self.raw_edit.value()
self.update_fields()
def field_edited(self, field, value):
self.event[field] = value
self.raw_edit.set_value(int(self.event))
def update_fields(self):
for i, entry in enumerate(self.field_entry):
entry.set_value(self.event[i])
def apply(self, close=False):
if close:
self.close()
self.applied.emit(self.event)
def field_editor(self, bit_range, type_str):
if type_str == 'u':
return self.IntFieldEntry(bit_range[1]-bit_range[0]+1, False, self)
elif type_str == 's':
return self.IntFieldEntry(bit_range[1]-bit_range[0]+1, True, self)
elif type_str == 'h':
byte_length = (bit_range[1] - bit_range[0] + 1)/8
if not byte_length.is_integer():
raise ValueError('Hex field length is not a multiple of 8 bits')
return self.HexFieldEntry(byte_length, self)
elif type_str == 'f':
byte_length = (bit_range[1] - bit_range[0] + 1)/8
if not byte_length == 4:
raise ValueError('Float field length is not 32 bits')
return self.FloatFieldEntry(False, self)
elif type_str == 'f-upper':
byte_length = (bit_range[1] - bit_range[0] + 1)/8
if not byte_length == 2:
raise ValueError('Upper-Half Float field length is not 16 bits')
return self.FloatFieldEntry(True, self)
class HexFieldEntry (QLineEdit):
# Always an even number of bytes
# should change to using a spinbox that displays hex instead of decimal
value_changed = pyqtSignal(int)
def __init__(self, byte_length, parent=None):
super().__init__(parent)
self.length = int(byte_length)
case_char = '>' if hex_caps else '<'
self.setInputMask(case_char + ' '.join(['HH']*self.length) + '')
font = QFont('Hexedit-monospace')
font.setStyleHint(QFont.Monospace)
self.setFont(font)
self.sizeHint = lambda: QSize(
self.fontMetrics().width(self.text() + ' '),
self.fontMetrics().height()*1.2,
)
self.minimumSizeHint = self.sizeHint
self.sizePolicy().setVerticalPolicy(QSizePolicy.Fixed)
self.sizePolicy().setHorizontalPolicy(QSizePolicy.Minimum)
self.updateGeometry()
self.textChanged.connect(
lambda: self.value_changed.emit(self.value())
)
def keyPressEvent(self, ev):
if ev.key() in [Qt.Key_Shift, Qt.Key_Control, Qt.Key_Left,
Qt.Key_Right, Qt.Key_Up, Qt.Key_Down]:
return super().keyPressEvent(ev)
if self.selectedText():
self.setCursorPosition(self.selectionStart())
self.deselect()
if ev.key() not in [Qt.Key_Backspace, Qt.Key_Delete]:
super().keyPressEvent(ev)
def value(self):
return int(super().text().replace(' ', ''), base=16)
def set_value(self, int_value):
self.setText(format(int_value, '0' + str(2*self.length) + 'x'))
class IntFieldEntry (QSpinBox):
# May be any number of bits wide
def __init__(self, bit_width, signed, parent=None):
super().__init__(parent)
if signed:
self.setMaximum(2**(bit_width-1) - 1)
self.setMinimum(-2**(bit_width-1))
else:
self.setMaximum(2**bit_width - 1)
self.setMinimum(0)
def set_value(self, val):
super().setValue(val) # to match naming of other entry boxes
class FloatFieldEntry (QDoubleSpinBox):
# Always 32 bits
Float = struct.Struct('>f')
Int = struct.Struct('>I')
def __init__(self, upper_only=False, parent=None):
super().__init__(parent)
self.setSingleStep(0.1)
self.setDecimals(2)
if upper_only:
self.shift = 16
self.setMaximum(self.from_raw(0x7F7F))
self.setMinimum(self.from_raw(0xFF7F))
else:
self.shift = 0
self.setMaximum(self.from_raw(0x7F7FFFFF))
self.setMinimum(self.from_raw(0xFF7FFFFF))
def to_raw(self, float_val):
return self.Int.unpack(self.Float.pack(float_val))[0] >> self.shift
def from_raw(self, raw_val):
return self.Float.unpack(self.Int.pack(raw_val << self.shift))[0]
def set_value(self, val):
super().setValue(val)
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 DetailView(QSplitter):
openFileSignal = pyqtSignal()
openPDFSignal = pyqtSignal()
def __init__(self):
super(DetailView, self).__init__()
self.setOrientation(Qt.Vertical)
self.form = QFormLayout()
self.toc = QTreeWidget()
self.toc.setColumnCount(1)
self.toc.setHeaderLabels(["目录"])
self.toc.setFont(QFont("", 14))
self.scrollarea = QScrollArea()
self.scrollarea.setFont(QFont("", 14))
self.scrollarea.setFrameShape(QFrame.NoFrame)
self.addWidget(self.scrollarea)
self.addWidget(self.toc)
self.setSizes([450, 350])
def updateToC(self, toc):
self.toc.clear()
floorlist = [0]
nodelist = [self.toc]
for line in toc:
layer, title = line
while floorlist[-1] >= layer:
floorlist.pop()
nodelist.pop()
node = QTreeWidgetItem(nodelist[-1])
node.setText(0, title)
floorlist.append(layer)
nodelist.append(node)
def deleteForm(self):
while self.form.count():
item = self.form.takeAt(0)
def updateView(self, note: Note):
self.deleteForm()
namelabel = QLabel("文件名")
ctimelabel = QLabel("创建时间")
atimelabel = QLabel("访问时间")
mtimelabel = QLabel("修改时间")
filelabel = QLabel("文件")
pdflabel = QLabel("链接")
taglabel = QLabel("标签")
name = QLabel("未知")
ctime = QLabel("未知")
atime = QLabel("未知")
mtime = QLabel("未知")
file = MyLabel("无")
pdf = MyLabel("无")
tag = MyLabel("无")
if note.name:
name.setText(note.name)
self.form.addRow(namelabel, name)
if note.create_time:
ctime.setText(note.create_time)
self.form.addRow(ctimelabel, ctime)
if note.visit_time:
atime.setText(note.visit_time)
self.form.addRow(atimelabel, atime)
if note.mod_time:
mtime.setText(note.mod_time)
self.form.addRow(mtimelabel, mtime)
if note.file_path:
file.setText("<a style='color: blue'>{}</a>".format(
note.file_path))
self.form.addRow(filelabel, file)
file.clicked.connect(lambda: self.openFile(note.file_path))
if note.pdf_path:
base, hfile = os.path.split(note.pdf_path)
pdfname, sufix = os.path.splitext(hfile)
pdf.setText("<a style='color: blue'>{}</a>".format(pdfname))
self.form.addRow(pdflabel, pdf)
pdf.clicked.connect(lambda: self.openFile(note.pdf_path))
if note.tags:
tag.setText(strSetToString(note.tags))
self.form.addRow(taglabel, tag)
tempWidget = QWidget()
tempWidget.setLayout(self.form)
self.scrollarea.setWidget(tempWidget)
self.updateToC(note.getToC())
def openFile(self, file_path):
os.system('explorer /select, {}'.format(os.path.abspath(file_path)))
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 AddSystem(QDialog):
def __init__(self, parent=None, flags=QtCore.Qt.WindowFlags()):
super(AddSystem, self).__init__(parent=parent, flags=flags)
self.setWindowTitle(TEXT.DIALOG_TITLE)
self.setLayout(QVBoxLayout())
self.setupContent()
btnBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
btnBox.accepted.connect(self.accept)
btnBox.rejected.connect(self.reject)
btnBox.button(QDialogButtonBox.Ok).setText(TEXT.BTN_CREATE)
btnBox.button(QDialogButtonBox.Cancel).setText(TEXT.BTN_CANCEL)
self.layout().addWidget(btnBox)
def setupContent(self):
self.Content = QWidget(self)
self.layout().addWidget(self.Content)
self.FormLayout = QFormLayout()
self.Content.setLayout(self.FormLayout)
self.error = QtWidgets.QLabel(TEXT.LB_ERR_CORRECT_DATA,
objectName='error')
self.FormLayout.addWidget(self.error)
self.sys = QComboBox()
self.sys.addItem(TEXT.EXP)
# self.sys.addItem("Վեյբուլ")
# self.system.currentIndexChanged.connect(self.systemChanged)
self.sysType = [
(QRadioButton(TEXT.NOT_BACKUP, objectName='0'),
QRadioButton(TEXT.BACKUP, objectName='1')),
]
self.btnGroupOne = QButtonGroup(self)
self.btnGroupOne.addButton(self.sysType[0][0])
self.btnGroupOne.addButton(self.sysType[0][1])
self.sysType[0][0].setChecked(True)
self.groupOne = True
self.btnGroupOne.buttonClicked.connect(self.onClickedTypeOne)
self.FormLayout.addRow(QLabel(TEXT.LB_SYSTEM_TYPE), self.sys)
self.FormLayout.addRow(self.sysType[0][0], self.sysType[0][1])
def onClickedTypeOne(self, btn):
if btn.objectName() == '1' and self.groupOne:
self.groupOne = False
self.sysType.append((QRadioButton(TEXT.REPLACEMENT,
objectName='0'),
QRadioButton(TEXT.PERMANENT, objectName='1')))
self.btnGroupTwo = QButtonGroup(self)
self.btnGroupTwo.addButton(self.sysType[1][0])
self.btnGroupTwo.addButton(self.sysType[1][1])
self.sysType[1][1].setChecked(True)
self.FormLayout.addRow(self.sysType[1][0], self.sysType[1][1])
self.sysType.append((QRadioButton(TEXT.BY_ELEMENTS,
objectName='0'),
QRadioButton(TEXT.WHOLE, objectName='1')))
self.btnGroupThree = QButtonGroup(self)
self.btnGroupThree.addButton(self.sysType[2][0])
self.btnGroupThree.addButton(self.sysType[2][1])
self.sysType[2][0].setChecked(True)
self.groupThree = True
self.btnGroupThree.buttonClicked.connect(self.onClickedTypeThree)
self.FormLayout.addRow(self.sysType[2][0], self.sysType[2][1])
self.isSame = QCheckBox(TEXT.LB_THE_SAME_VALUE)
self.FormLayout.addWidget(self.isSame)
self.row = QLineEdit()
self.row.setPlaceholderText(TEXT.LEP_1_OR_MORE)
regexp = QtCore.QRegExp('^([1-9]\\d{0,1})$')
validator = QRegExpValidator(regexp) # QIntValidator(1, 15)
self.row.setValidator(validator)
self.row.textChanged.connect(self.check_state)
self.row.textChanged.emit(self.row.text())
self.FormLayout.addRow(QLabel(TEXT.LB_THE_BACKUP_ELM_COUNT),
self.row)
elif btn.objectName() == '0' and not self.groupOne:
self.groupOne = True
self.sysType = self.sysType[:1]
for i in range(5, self.FormLayout.count(), 2):
self.FormLayout.removeRow(3)
def onClickedTypeThree(self, btn):
if btn.objectName() == '1' and self.groupThree:
self.groupThree = False
self.col = QLineEdit()
self.col.setPlaceholderText(TEXT.LEP_2_OR_MORE)
regexp = QtCore.QRegExp('^([2-9]\\d{0,1})$')
validator = QRegExpValidator(regexp) # QIntValidator(1, 15)
self.col.setValidator(validator)
self.col.textChanged.connect(self.check_state)
self.col.textChanged.emit(self.row.text())
self.FormLayout.addRow(QLabel(TEXT.LB_THE_SYSTEM_ELM_COUNT),
self.col)
elif btn.objectName() == '0' and not self.groupThree:
self.groupThree = True
self.FormLayout.removeRow(7)
def CreateSystem(self):
switch = {0: self.exponential, 1: self.weibull}
return switch.get(self.System.SysConfig['system'])()
def exponential(self):
grid = QHBoxLayout()
wdg = QWidget()
wdg.setLayout(grid)
if self.System.SysConfig['isSame']:
rows = 0
else:
rows = self.System.SysConfig["row"]
self.System.lmds = []
for col in range(self.System.SysConfig["col"]):
f, w = QFormLayout(), QWidget()
w.setLayout(f)
grid.addWidget(w)
self.System.lmds.append([])
for row in range(rows + 1):
self.System.lmds[col].append(QLineEdit())
f.addRow(QLabel(f"λ[{row}][{col}]:"),
self.System.lmds[col][row])
self.System.layout().addWidget(wdg)
def weibull(self):
pass
@pyqtSlot()
def accept(self) -> None:
try:
isOne = int(self.btnGroupOne.checkedButton().objectName())
typeText = f'{self.sys.currentText()} համակարգ'
typeText += f'\n{self.btnGroupOne.checkedButton().text()}'
if isOne == 1:
row = int(self.row.text())
isTwo = self.btnGroupTwo.checkedButton().objectName()
isThree = self.btnGroupThree.checkedButton().objectName()
typeText += f'/{row}' \
f'\n{self.btnGroupThree.checkedButton().text()}'
if isThree == '1':
col = int(self.col.text())
typeText += f'/{col}'
typeText += f'\n{self.btnGroupTwo.checkedButton().text()}'
if self.isSame.isChecked():
typeText += f'\n{self.isSame.text()}'
except:
self.error.setText(TEXT.LB_ERR_WRONG_DATA)
self.error.show()
return
self.error.hide()
self.System = QWidget()
self.parent().Systems.layout().addWidget(self.System)
self.parent().SystemList.append(self.System)
form = QtWidgets.QFormLayout()
self.System.setLayout(form)
toolBar = QToolBar(self.System)
remove = QAction(TEXT.BTN_DELETE, self.System)
remove.triggered.connect(self.parent().RemoveCtrl)
toolBar.addAction(remove)
# edit = QAction('Խմբագրել', self.System)
# toolBar.addAction(edit)
form.addWidget(toolBar)
self.System.SysConfig = {
'system': self.sys.currentIndex(),
'row': row if isOne == 1 else 0,
'col': col if isOne == 1 and isThree == "1" else 1,
'typeOne': isOne,
'typeTwoAndThree': isTwo + isThree if isOne == 1 else None,
# 'typeThree': isThree if isOne else None,
'isSame': self.isSame.isChecked() if isOne == 1 else None,
}
# form.addWidget(QLabel(f'{self.System.SysConfig["system"][1]} համակարգ'))
# typeText = f'{self.System.SysConfig["typeOne"][1]}/{self.System.SysConfig["row"]}'
# if self.System.SysConfig["typeOne"][0]:
# typeText += f'\n{self.System.SysConfig["typeThree"][1]}/{self.System.SysConfig["col"]}' \
# f'\n{self.System.SysConfig["typeTwo"][1]}'
# if self.System.SysConfig["isSame"][0]:
# typeText += f'\n{self.System.SysConfig["isSame"][1]}'
form.addWidget(QLabel(typeText))
self.CreateSystem()
self.parent().calc.setEnabled(True)
self.close()
def check_state(self, *args, **kwargs):
sender = self.sender()
validator = sender.validator()
state = validator.validate(sender.text(), 0)[0]
if state == QValidator.Acceptable:
color = '#c4df9b' # green
elif state == QValidator.Intermediate:
color = '#fff79a' # yellow
else:
color = '#f6989d' # red
sender.setStyleSheet('QLineEdit { background-color: %s }' % color)
class HomeWidget(QtWidgets.QWidget):
def __init__(self):
super().__init__() #testing
self.liveTrades = {}
self.buyList = []
self.sellList = []
self.change = 0 #difference gained or loss from trades
self.high = 0
self.low = 10000000
self.price = 0
self.currentPrice = 0
self.tempPrice = 0 #to hold value every 19th iterations used to determine short term trend
self.counter = 0 # to count 19th iterations and reset
self.tradeCount = 0
#for temp highs and lows
self.tempHigh = 0
self.tempLow = 10000000
#self.rootPassword=""
#QtWidgets.QMainWindow.__init__(self)
#super(HomeWidget, self).__init__()
self.initUI()
self.scrollSize = 100 #should update to count of live datas
self.setWindowTitle("PyTradeBot")
#self.setGeometry(0, 0, 800, 650)
#self.setGeometry(0, 0, 1000, 750)
self.showMaximized(
) # maximizes screen without going into full screen mode
#for the minimized screen, to center it
#screen_center = lambda \
#widget: app.desktop().screen().rect().center() - widget.rect().center() # determines center of view
#self.move(screen_center(self)) # move to center
# sets background color
p = self.palette()
p.setColor(self.backgroundRole(),
Qt.lightGray) # set background color of widget to green
self.setPalette(p)
#title label
self.label1 = QLabel("PyTradeBot")
self.label1.setFont(QtGui.QFont("Courier", 72, QtGui.QFont.Bold))
self.label1.setAlignment(QtCore.Qt.AlignCenter)
#Right column labels
#1/2
self.priceLabel = QLabel("Price: ")
self.priceLabel.setFont(QtGui.QFont("Courier", 12, QtGui.QFont.Bold))
self.highPriceLabel = QLabel("High: " + str(self.high))
self.highPriceLabel.setFont(
QtGui.QFont("Courier", 12, QtGui.QFont.Bold))
self.lowPriceLabel = QLabel("Low: " + str(self.low))
self.lowPriceLabel.setFont(QtGui.QFont("Courier", 12,
QtGui.QFont.Bold))
#2/2
self.trendLabel = QLabel("Trend: ")
self.trendLabel.setFont(QtGui.QFont("Courier", 12, QtGui.QFont.Bold))
self.tradeCountLabel = QLabel("Buy Trades: ")
self.tradeCountLabel.setFont(
QtGui.QFont("Courier", 12, QtGui.QFont.Bold))
self.returnLabel = QLabel("Sell Trades: ")
self.returnLabel.setFont(QtGui.QFont("Courier", 12, QtGui.QFont.Bold))
self.accountValueSQL = "SELECT `wallet` FROM `account` WHERE `account_id`>0" # to retrieve wallet value, set to arbitrary 100,000 upon creation
self.walletReturn = self.connectDB(self.accountValueSQL)
#print(self.walletReturn)
#print(self.walletReturn[0]['wallet'])
self.nowPrice = self.walletReturn[0][
'wallet'] # price to update wallet upon trades
#Horizontal labels
self.labelH = QLabel(" Price Quantity Time")
self.labelH.setFont(QtGui.QFont("Courier", 12, QtGui.QFont.Bold))
self.labelH2 = QLabel("$" + str(self.walletReturn[0]['wallet']))
self.labelH2.setFont(QtGui.QFont("Courier", 36, QtGui.QFont.Bold))
self.emptyLabel = QLabel(" ") # to add an empty line
self.graphWidget = pg.PlotWidget()
self.x = []
self.xLow = []
self.xHigh = []
self.y = []
self.yLow = []
self.yHigh = []
#adjusting main plot view size
self.graphWidget.setMaximumHeight(492)
self.graphWidget.setBackground('w')
self.graphWidget.addLegend(
) #to add graph legend 'name="Ethereum/USDT"'
#self.pen = pg.mkPen(color=(100, 100, 0)) #ugly puke color
self.pen = pg.mkPen(color=(0, 100, 100), width=6)
self.graphWidget.plot(self.x,
self.y,
pen=self.pen,
name="Ethereum USD / Trade")
#vertical box for layout
self.vbox = QVBoxLayout()
self.vbox.addWidget(self.label1)
self.hbox3 = QHBoxLayout()
self.hbox3.addWidget(self.labelH)
self.hbox3.addWidget(self.labelH2)
self.vbox.addLayout(self.hbox3)
#vertical box 2 for layout
self.vbox2 = QVBoxLayout()
self.vbox3 = QVBoxLayout()
self.vbox3.addWidget(self.highPriceLabel)
self.vbox3.addWidget(self.priceLabel)
self.vbox3.addWidget(self.lowPriceLabel)
self.vbox4 = QVBoxLayout()
self.vbox4.addWidget(self.trendLabel)
self.vbox4.addWidget(self.tradeCountLabel)
self.vbox4.addWidget(self.returnLabel)
# new for testing
self.formLayout2 = QFormLayout()
self.groupBox2 = QGroupBox("Incoming Data Stream") #2
self.scrollBox2 = QScrollArea()
self.scrollBox2.setWidget(self.groupBox2)
self.scrollBox2.setWidgetResizable(True)
self.scrollBox2.setFixedHeight(492)
self.scrollBox2.setFixedWidth(300)
self.hbox = QHBoxLayout()
self.hbox.addWidget(self.scrollBox2)
self.hbox.addWidget(self.graphWidget)
self.hbox.addLayout(self.vbox3)
self.hbox.addLayout(self.vbox4)
self.hbox2 = QHBoxLayout()
self.cbuysbtn = QPushButton("Show buy trades")
self.cbuysbtn.setMaximumWidth(150)
self.cbuysbtn.setMinimumWidth(150)
self.cbuysbtn.clicked.connect(
self.buybtn_clicked) #function called when clicked
self.csellsbtn = QPushButton("Show sell trades")
self.csellsbtn.setMaximumWidth(150)
self.csellsbtn.setMinimumWidth(150)
self.csellsbtn.clicked.connect(self.sellbtn_clicked)
self.hbox2.addWidget(self.cbuysbtn)
self.hbox2.addWidget(self.csellsbtn)
#for bottom main live data
self.formLayout = QFormLayout()
self.groupBox = QGroupBox("Incoming Data Stream")
self.formLayout.addRow(QLabel("awaiting data..."))
#self.formLayout.addRow(QLabel(str(len(data))))
#move this to above
self.dataList = []
#self.vbox2.addWidget(self.formLayout)
self.groupBox.setLayout(self.formLayout)
self.groupBox2.setLayout(self.formLayout2)
#scroll box main bottom with live data
self.scrollBox = QScrollArea()
self.scrollBox.setWidget(self.groupBox)
self.scrollBox.setWidgetResizable(True)
self.scrollBox.setFixedHeight(120)
#self.scrollBox.setFixedWidth(350)
self.vbox.addLayout(self.hbox)
self.vbox.addLayout(self.hbox2)
self.vbox.addLayout(self.vbox2)
self.vbox.addWidget(self.scrollBox)
self.setLayout(self.vbox)
self.vbox.setAlignment(Qt.AlignTop | Qt.AlignCenter)
#the magic
self._update_timer = QtCore.QTimer()
self._update_timer.timeout.connect(self.updateLabel)
self._update_timer.start(10) #100
self.update()
#TESTING
def initUI(self):
self.thread = QThread()
self.worker = Worker()
self.worker.moveToThread(self.thread)
self.thread.started.connect(self.worker.do_work)
#self.formLayout.addRow(QLabel("noob"))
self.thread.finished.connect(self.thread.deleteLater)
self.thread.start()
def updateLabel(self):
try:
for item in newData:
pyObject = json.loads(item)
if item not in self.dataList and pyObject['type'] != "ping":
self.currentPrice = float(self.getPrice(item))
if len(self.buyList) > 0 and len(self.buyList) != len(
self.sellList):
if self.checkStopLoss(self.currentPrice) == True:
#sell
self.sellList.append(self.currentPrice)
self.returnLabel.setText("Sell Trades: " +
str(len(self.sellList)))
self.length = len(self.buyList)
self.change = self.change + self.buyList[
self.length - 1] - self.currentPrice
self.nowPrice = self.nowPrice + self.change
self.labelH2.setText(
"$" +
str(self.nowPrice)) # change main wallet label
self.sqlSellInsert = "INSERT INTO `sell_trades` (`price`,`quantity`,`time`) VALUES (%s, %s, %s)"
self.confirmDB(self.sqlSellInsert,
self.getPrice(item),
self.getQuantity(item),
self.getTime(item))
#print("currr: ", self.currentPrice)
#print(type(self.currentPrice))
if self.currentPrice > self.high:
print("new high")
self.high = self.currentPrice
self.highPriceLabel.setText("High: " +
str(self.currentPrice))
if self.currentPrice < self.low:
print("new low")
self.low = self.currentPrice
self.lowPriceLabel.setText("Low: " +
str(self.currentPrice))
if self.currentPrice < self.tempLow:
self.tempLow = self.currentPrice
self.xLow.append(self.currentPrice)
self.yLow.append(len(self.x) + 1) # is plus 1 correct?
if self.currentPrice > self.tempHigh:
self.tempHigh = self.currentPrice
self.xHigh.append(self.tempHigh)
#self.yHigh.append(len(self.yHigh)+1)
self.yHigh.append(len(self.x) +
1) # is plus 1 correct?
if self.formLayout2.count() > 19:
self.formLayout2.removeRow(0)
self.dataList.append(item)
#self.formLayout.addRow(QLabel(item))
self.formLayout2.addRow(
QLabel("$" + self.getPrice(item) + " | " +
self.getQuantity(item) + " | " +
self.getTime(item)))
self.counter += 1
if self.counter == 5 or self.counter > 5:
if self.tempPrice != 0:
if self.tempPrice > self.currentPrice:
self.trendLabel.setText("Trend: Decreasing")
print("DESCREASING")
if len(self.buyList) == len(self.sellList):
self.buyList.append(self.currentPrice)
self.tradeCountLabel.setText(
"Buy Trades: " +
str(len(self.buyList)))
self.sqlBuyInsert = "INSERT INTO `buy_trades` (`price`,`quantity`,`time`) VALUES (%s, %s, %s)"
self.confirmDB(self.sqlBuyInsert,
self.getPrice(item),
self.getQuantity(item),
self.getTime(item))
elif self.tempPrice < self.currentPrice:
self.trendLabel.setText("Trend: Increasing")
print("INCREASING")
if len(self.buyList) != len(self.sellList):
self.sellList.append(self.currentPrice)
self.tradeCount += 1
self.returnLabel.setText(
"Sell Trades: " +
str(len(self.sellList)))
self.length = len(self.buyList)
self.change = self.change + self.buyList[
self.length - 1] - self.currentPrice
self.nowPrice = self.nowPrice + self.change
#self.labelH2.setText("$"+str(float(self.walletReturn[0]['wallet'])+self.change)) #change main wallet label
self.labelH2.setText(
"$" + str(self.nowPrice)
) # change main wallet label
#insert into sell table
self.sqlSellInsert = "INSERT INTO `sell_trades` (`price`,`quantity`,`time`) VALUES (%s, %s, %s)"
self.confirmDB(self.sqlSellInsert,
self.getPrice(item),
self.getQuantity(item),
self.getTime(item))
self.tempPrice = self.currentPrice
#print("tempprice:", self.tempPrice)
self.counter = 0
print("Buys:", self.buyList)
print("Sells:", self.sellList)
self.y.append(pyObject['data'][0]['p'])
self.x.append(len(self.y))
#might be out of place 1 tab in
newData.pop(0) #delete item after iterating it
self.priceLabel.setText("Price: " + str(self.currentPrice))
self.graphWidget.clear()
self.graphWidget.plot(self.x, self.y, pen=self.pen)
#self.graphWidget.plot(self.x,)
# reset variables afterwards to continue
self.tempHigh = 0
self.tempLow = 10000000
#print("xxxxx",self.x)
#print("yyyyy",self.y)
#return self.formLayout
#to autoscroll to most recent
self.area = self.scrollBox2.verticalScrollBar()
self.area.setValue(self.area.maximum())
except Exception as e:
print("updateLabel error:", e)
#return "error"
def updateBuyTrades(self):
pass
def getPrice(self, data):
#print("get price called")
pyObject = json.loads(data)
return str(pyObject['data'][0]['p'])
def getQuantity(self, data):
#print("get quantity called")
pyObject = json.loads(data)
return str(pyObject['data'][0]['v'])
def getTime(self, data):
#print("get time called")
pyObject = json.loads(data)
timestamp = pyObject['data'][0]['t']
#print(type(timestamp))
return str(
datetime.fromtimestamp(timestamp / 1000)
)[11:
-2] #must divide by 1000 because timestamp is of milliseconds and remove last 2 character (trailing 0's)
def buybtn_clicked(self):
#print("buy clicked!")
self.deleteRows()
self.sql = "SELECT `buy_id`,`price`,`quantity`, `time` FROM `buy_trades` WHERE `buy_id`>0"
#testresult=self.connectDB(self.sql)
if len(self.connectDB(self.sql)) == 0:
print("No trades positions have been initiated yet")
self.formLayout.addRow(
QLabel("No trade positions have been initiated yet"))
else:
print("trades have been made")
#print(self.result)
#print(type(self.result))
testresult = self.connectDB(self.sql)
# will need a form loop here to iterate over results as trades are made
for item in testresult:
self.formLayout.addRow(QLabel(str(item)))
def sellbtn_clicked(self):
print("sell clicked!")
self.deleteRows()
self.sql = "SELECT `sell_id`,`price`,`quantity`, `time` FROM `sell_trades` WHERE `sell_id`>0"
temper = self.connectDB((self.sql))
if len(temper) == 0:
print("No trades positions have been exited yet")
self.formLayout.addRow(
QLabel("No trades positions have been exited yet"))
else:
print("trades have been made")
#print(temper)
# will need a form loop here to iterate over results as trades are made
for item in temper:
self.formLayout.addRow(QLabel(str(item)))
def deleteRows(self):
print("delete rows called")
count = self.formLayout.rowCount()
#print("count of rows:", count)
if count == 0:
pass
elif count == 1:
self.formLayout.removeRow(0)
else:
for item in range(self.formLayout.count()):
#print("item:", item)
self.formLayout.removeRow(item)
self.formLayout.update()
def estimate_coef(self, x, y):
# number of observations/points
n = np.size(x)
# mean of x and y vector
m_x, m_y = np.mean(x), np.mean(y)
# calculating cross-deviation and deviation about x
SS_xy = np.sum(y * x) - n * m_y * m_x
SS_xx = np.sum(x * x) - n * m_x * m_x
# calculating regression coefficients
b_1 = SS_xy / SS_xx
b_0 = m_y - b_1 * m_x
return (b_0, b_1)
def shortTrend(self):
if newData[0] < newData[len(newData) - 1]: #is increasing
return "Increasing"
elif newData[0] > newData[len(newData) - 1]: #is decreasing
return "Decreasing"
#return true if stop loss triggered ( more than 10 cents loss)
def checkStopLoss(self, currentPrice):
val = len(self.buyList) - 1
if currentPrice - self.buyList[val] <= -0.03:
print("Stop Loss Triggered")
return True
return False
def connectDB(self, sqlstatement):
self.result = ""
print("connectDB called")
self.rootPassword = ""
if path.exists("PyTradeBot.txt"):
with open("PyTradeBot.txt") as o:
self.rootPassword = o.readline()
# establish database connection
self.connection = pymysql.connect(
host='localhost',
user='******',
password=self.rootPassword,
database='PyTradeBot',
charset='utf8mb4',
cursorclass=pymysql.cursors.DictCursor)
# call for apiKey
try:
with self.connection.cursor() as self.cursor:
# get API KEY
self.cursor.execute(sqlstatement)
self.result = self.cursor.fetchall()
print("result", self.result)
self.connection.commit()
except Exception as e:
print(e)
finally:
self.connection.close()
return self.result
def confirmDB(self, sqlstatement, arga, argb, argc):
print("connfirmDB called")
self.rootPassword = ""
if path.exists("PyTradeBot.txt"):
with open("PyTradeBot.txt") as o:
self.rootPassword = o.readline()
# establish database connection
self.connection = pymysql.connect(
host='localhost',
user='******',
password=self.rootPassword,
database='PyTradeBot',
charset='utf8mb4',
cursorclass=pymysql.cursors.DictCursor)
# call for apiKey
try:
with self.connection.cursor() as self.cursor:
self.cursor.execute(sqlstatement, (arga, argb, argc))
self.connection.commit()
except Exception as e:
print(e)
finally:
self.connection.close()
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)
