class ProgressBar(QtWidgets.QWidget):
def __init__(self):
QtWidgets.QWidget.__init__(self)
self.widget = QWidget(self)
self.widget.setObjectName("main")
self.widget.setStyleSheet("""
QWidget#main{
border:1px solid #148CD2;
border-radius:10px;
}
""")
self.progressBar = []
self.line = QFormLayout(self)
self.line.setContentsMargins(20,20,20,20)
self.line.setSpacing(30)
today = datetime.date.today()
Day = selectday(today)
totalTime = max(Day['totalTime'],1)
programs = Day['allPrograms']
sorteddata = sorted(programs.items(),key=lambda x: -x[1])[:6]
count = 0
for prog in sorteddata:
self.progressBar.append(QProgressBar())
self.progressBar[count].setValue(prog[1]/totalTime *100)
self.line.addRow(QLabel(prog[0]),self.progressBar[count])
count += 1
timer = QTimer(self)
timer.timeout.connect(self.updateOnTime)
timer.start(60*1000) # update every minute
self.widget.setLayout(self.line)
self.widget.setFixedSize(400,300)
def updateOnTime(self):
today = datetime.date.today()
Day = selectday(today)
totalTime = max(Day['totalTime'],1)
programs = Day['allPrograms']
sorteddata = sorted(programs.items(),key=lambda x: -x[1])[:6]
count = self.line.rowCount()
for i in range(0,count):
self.line.removeRow(0)
self.progressBar = []
count = 0
for prog in sorteddata:
self.progressBar.append(QProgressBar())
self.progressBar[count].setValue(prog[1]/totalTime * 100)
self.line.insertRow(count,QLabel(prog[0]),self.progressBar[count])
count += 1
def setFormLayoutRowVisibility(formLayout: QFormLayout, rowNumber: int, labelWidget: QWidget,
valueWidget: QWidget, visible: bool) -> None:
""" Sets the visibility of a QFormLayout row, without leaving empty space when hiding it. """
if visible:
if valueWidget.isHidden():
formLayout.insertRow(rowNumber, labelWidget, valueWidget)
labelWidget.show()
valueWidget.show()
else:
if not valueWidget.isHidden():
labelWidget.hide()
valueWidget.hide()
formLayout.removeWidget(labelWidget)
formLayout.removeWidget(valueWidget)
class Sidebar(QWidget):
def __init__(self, parent):
super().__init__(parent)
self.parent = parent
self._init_ui()
self.show()
def _init_ui(self):
self.layout = QFormLayout()
self._add_select()
self._add_reset()
self.form = QGroupBox()
self.figures_list = QGroupBox()
self.layout.addRow(QLabel(''))
self._render_fields()
self._render_figures()
self.setLayout(self.layout)
def _add_select(self):
self.select = QComboBox()
self.select.addItems(Figure.get_all())
self.select.activated[str].connect(self._handle_select)
self.layout.addRow(QLabel('Figure:'), self.select)
def _add_reset(self):
self.reset_btn = QPushButton('Reset')
self.reset_btn.setDefault(True)
self.reset_btn.clicked.connect(self.parent.reset_data)
self.layout.addRow(self.reset_btn)
def _render_fields(self):
FigureClass = self.parent.get_figure_class()
fields = FigureClass.get_fields()
if not fields:
self.form.hide()
return
self.form.hide()
self.layout.removeWidget(self.form)
self.form = QGroupBox()
self.form_layout = QFormLayout()
self.form.setLayout(self.form_layout)
self.layout.insertRow(3, self.form)
self.form.setTitle(f'{FigureClass.__name__} props:')
for i, field in enumerate(fields):
input_f = QSpinBox()
input_f.setRange(field.min_value, field.max_value)
input_f.setSingleStep(field.step)
input_f.setValue(field.default)
input_f.valueChanged.connect(
partial(self.parent.handle_data_change, i))
self.form_layout.addRow(QLabel(f'{field.name}:'), input_f)
self.form.show()
def _render_figures(self):
self.figures_list.hide()
self.layout.removeWidget(self.figures_list)
if not self.parent.figures:
return
self.figures_list = QGroupBox('Figures list:')
self.figures_layout = QFormLayout()
self.figures_list.setLayout(self.figures_layout)
self.layout.addRow(self.figures_list)
for index, fig in enumerate(self.parent.figures):
button = QPushButton('x')
button.setToolTip('Remove')
button.clicked.connect(
partial(self.parent.handle_figure_remove, index))
self.figures_layout.addRow(
QLabel(f'{index + 1}. {fig.__class__.__name__}'), button)
self.figures_list.show()
def _handle_select(self, item):
self.parent.set_figure(item)
self._render_fields()
def update_ui(self):
self.update()
self._render_figures()
class SearchPage(QWidget):
def __init__(self, parent):
super(QWidget, self).__init__(parent)
self.searchMode = 0
self.initDBConnection()
self.initUI()
def initUI(self):
layout = QVBoxLayout(self)
functionLayout = QHBoxLayout()
functionLayout.setAlignment(Qt.AlignLeft)
functionLayout.setSpacing(2)
self.searchButton = QPushButton()
self.searchButton.setText("Search")
self.searchButton.setStyleSheet("QPushButton {max-width: 80px;}")
functionLayout.addWidget(self.searchButton)
functionLayout.addSpacing(10)
matchExpressionLabel = QLabel("Match Expression: ")
functionLayout.addWidget(matchExpressionLabel)
matchExpressionEdit = QLineEdit()
matchExpressionEdit.setStyleSheet(
"QLineEdit {max-width: 450px;min-width: 300px;}")
matchExpressionEdit.setPlaceholderText(
"Eg: (1 & (2 | 3)), Default: (1) or (1 & 2) or ... ")
functionLayout.addWidget(matchExpressionEdit)
functionLayout.addSpacing(10)
caseMatchCheckBox = QCheckBox()
caseMatchLabel = QLabel("Match Case")
functionLayout.addWidget(caseMatchCheckBox)
functionLayout.addSpacing(6)
functionLayout.addWidget(caseMatchLabel)
functionLayout.addStretch()
layout.addLayout(functionLayout)
self.mygroupbox = QGroupBox()
self.myform = QFormLayout()
self.myform.setVerticalSpacing(0)
self.myform.setHorizontalSpacing(2)
self.labelList = []
self.fieldComboList = []
self.filterComboList = []
self.inputboxList = []
self.plusbuttonlist = []
self.minusbuttonlist = []
relationComboList = []
self.sublayoutList = []
for i in range(3):
self.createSearchFilter(i)
# self.myform.addRow(self.sublayoutList[i])
#self.mygroupbox.setLayout(self.myform)
self.updateSearchFilterForm()
scroll = QScrollArea()
scroll.setWidget(self.mygroupbox)
scroll.setWidgetResizable(True)
scroll.setFixedHeight(140)
layout.addWidget(scroll)
self.mainTable = QTableWidget(
100, 8, self) # create 100x8 table rowNum, colNum
self.mainTable.setHorizontalHeaderLabels(
('Year', 'Title', 'Published In', 'Authors', 'Type', 'Added',
'Labels', 'RefID'))
self.mainTable.setColumnWidth(0, 60) # Year
self.mainTable.setColumnWidth(1, 240) # Title
self.mainTable.setColumnWidth(2, 240) # Published In
self.mainTable.setColumnWidth(3, 240) # Authors
self.mainTable.setColumnWidth(4, 120) # Type
self.mainTable.setColumnWidth(5, 120) # Added Date
self.mainTable.setColumnWidth(6, 240) # Labels
self.mainTable.setColumnWidth(7, 120) # RefAbsID
# Table settings
self.mainTable.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.mainTable.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
self.mainTable.setHorizontalScrollMode(
QAbstractItemView.ScrollPerPixel)
self.mainTable.setSelectionBehavior(QAbstractItemView.SelectRows)
# Connect sorting signal
self.mainTable.setSortingEnabled(True)
self.mainTable.horizontalHeader().sortIndicatorChanged.connect(
self.sortingTable)
layout.addWidget(self.mainTable)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
# Add tabs to widget
#self.layout.addWidget(self.scrollArea)
#self.setLayout(self.layout)
self.appearance = True
# Initialize internal signal and slot
self.initSignalsSlots()
def createSearchFilter(self, ind):
self.labelList.insert(ind, QLabel('Key: ' + str(ind + 1)))
fieldCombo = QComboBox()
fieldChoiceList = [
'Title', 'Year', 'Published In', 'Author', 'Keywords'
]
fieldCombo.addItems(fieldChoiceList)
if ind < 3:
fieldCombo.setCurrentIndex(ind)
else:
fieldCombo.setCurrentIndex(0)
self.fieldComboList.insert(ind, fieldCombo)
filterCombo = QComboBox()
filterChoiceList = ['Contains', 'Is']
filterCombo.addItems(filterChoiceList)
self.filterComboList.insert(ind, filterCombo)
self.inputboxList.insert(ind, QLineEdit())
tempPlusButton = QPushButton()
tempPlusButton.setText("+")
tempPlusButton.setStyleSheet("QPushButton {background-color: gray; border-color: beige; border-width: 1px;" \
"border-radius: 1px; font: bold 14px; padding: 6px;}")
self.plusbuttonlist.insert(ind, tempPlusButton)
tempMinusButton = QPushButton()
tempMinusButton.setText("-")
tempMinusButton.setStyleSheet("QPushButton {background-color: gray; border-color: beige; border-width: 1px;" \
"border-radius: 1px; font: bold 14px; padding: 6px;}")
self.minusbuttonlist.insert(ind, tempMinusButton)
# Signal and Slot
self.plusbuttonlist[ind].clicked.connect(
partial(self.onPlusButtonClicked, ind))
self.minusbuttonlist[ind].clicked.connect(
partial(self.onMinusButtonClicked, ind))
tempSubLayput = QHBoxLayout()
tempSubLayput.addWidget(self.labelList[ind])
tempSubLayput.addWidget(self.fieldComboList[ind])
tempSubLayput.addWidget(self.filterComboList[ind])
tempSubLayput.addWidget(self.inputboxList[ind])
tempSubLayput.addWidget(self.plusbuttonlist[ind])
tempSubLayput.addWidget(self.minusbuttonlist[ind])
self.sublayoutList.insert(ind, tempSubLayput)
self.myform.insertRow(ind, self.sublayoutList[ind])
def removeSearchFilter(self, ind):
self.labelList.pop(ind)
self.fieldComboList.pop(ind)
self.filterComboList.pop(ind)
self.inputboxList.pop(ind)
self.plusbuttonlist.pop(ind)
self.minusbuttonlist.pop(ind)
self.sublayoutList.pop(ind)
self.myform.removeRow(ind)
def initSignalsSlots(self):
self.searchButton.clicked.connect(self.onSearchButtonClicked)
def sortingTable(self, colIndex, order):
#print("Column:" + str(colIndex))
if order == Qt.AscendingOrder:
pass
elif order == Qt.DescendingOrder:
pass
def initDBConnection(self):
database = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"Data.db")
refs = []
try:
self.conn = createConnectionToDB(database)
except:
buttonReply = QMessageBox.critical(
self, 'Alert', "Initialize Info Tab: Database is missing.",
QMessageBox.Ok, QMessageBox.Ok)
def onPlusButtonClicked(self, buttonId):
self.createSearchFilter(buttonId + 1)
self.updateSearchFilterForm()
def onMinusButtonClicked(self, buttonId):
if (buttonId == 0) and (len(self.sublayoutList) == 1):
buttonReply = QMessageBox.critical(self, 'Alert', "You need me.",
QMessageBox.Ok, QMessageBox.Ok)
else:
self.removeSearchFilter(buttonId)
self.updateSearchFilterForm()
def updateSearchFilterForm(self):
for i in range(len(self.sublayoutList)):
self.labelList[i].setText('Key: ' + str(i + 1))
self.plusbuttonlist[i].clicked.disconnect()
self.minusbuttonlist[i].clicked.disconnect()
self.plusbuttonlist[i].clicked.connect(
partial(self.onPlusButtonClicked, i))
self.minusbuttonlist[i].clicked.connect(
partial(self.onMinusButtonClicked, i))
self.mygroupbox.setLayout(self.myform)
def onSearchButtonClicked(self):
searchTarget = []
for i in range(len(self.inputboxList)):
tempStr = self.inputboxList[i].text()
if len(tempStr) > 0:
searchTarget.append(
[self.fieldComboList[i].currentText(), tempStr])
if len(searchTarget) > 0:
formattedSearchTarget = self.parseSearchTarget(searchTarget)
self.switchSearchMode(formattedSearchTarget)
def parseSearchTarget(self, searchTarget):
# fieldChoiceList = ['Title', 'Year', 'Published In', 'Author', 'Keywords']
formattedSearchTarget = []
if len(searchTarget) > 0:
for tarItem in searchTarget:
if tarItem[0] == 'Published In':
formattedSearchTarget.append(['PubIn', tarItem[1]])
else:
formattedSearchTarget.append(tarItem)
return formattedSearchTarget
def switchSearchMode(self, searchTarget):
# Local search, online search, mix search
if self.searchMode == 0:
self.databaseSearch(searchTarget)
elif self.searchMode == 1:
self.mixSearch(searchTarget)
else:
self.onlineSearch(searchTarget)
def databaseSearch(self, searchTarget):
foundRefItems = []
foundRefItems = searchRefInDB(self.conn, searchTarget)
self.setRefsTable(foundRefItems)
def onlineSearch(self, searchTarget):
''' 0: Local Database
1: "Mixed Search",
2: "Google Scholar",
3: "PubMed",
4: "IEEE Xplore",
5: "Science Direct",
6: "arXiv",
7: "Sci-Hub",
8: "More..."
'''
foundRefItems = []
if self.searchMode == 2:
pass
elif self.searchMode == 3:
pass
elif self.searchMode == 4:
pass
elif self.searchMode == 5:
pass
elif self.searchMode == 6:
pass
elif self.searchMode == 7:
pass
else:
pass
self.setRefsTable(foundRefItems)
def mixSearch(self, searchTarget):
foundRefItems = []
self.setRefsTable(foundRefItems)
def setRefsTable(self, refs):
# Clean old contents
self.mainTable.clearContents()
# Must disable sorting table first, otherwise error will occur
self.mainTable.setSortingEnabled(False)
for rowInd in range(len(refs)):
self.mainTable.setItem(rowInd, 0,
QTableWidgetItem(str(
refs[rowInd]['Year']))) # Year
self.mainTable.setItem(rowInd, 1,
QTableWidgetItem(
refs[rowInd]['Title'])) # Title
self.mainTable.setItem(rowInd, 2,
QTableWidgetItem(
refs[rowInd]['PubIn'])) # PubIn
self.mainTable.setItem(rowInd, 3,
QTableWidgetItem(
refs[rowInd]['Author'])) # Authors
self.mainTable.setItem(rowInd, 4,
QTableWidgetItem(
refs[rowInd]['MType'])) # Type
self.mainTable.setItem(rowInd, 5,
QTableWidgetItem(refs[rowInd]['AddedTime'])
) # Add Date, change to real field later
self.mainTable.setItem(rowInd, 6,
QTableWidgetItem(
refs[rowInd]['Labels'])) # Labels
self.mainTable.setItem(
rowInd, 7,
QTableWidgetItem(str(
refs[rowInd]['RefAbsID']).zfill(10))) # RefAbsID
# Enable sorting again.
self.mainTable.setSortingEnabled(True)
class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'Personality Grapher'
self.left = 100
self.right = 100
self.top = 10
self.width = 500
self.height = 500
self.init_ui()
def init_ui(self):
# set window title, size and position
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.right, self.width, self.height)
# create the main layout
self.main_layout = QVBoxLayout()
self.error_message = QErrorMessage()
# add a form with spin boxes
self.create_formbox()
self.main_layout.addWidget(self.form_groupbox)
# add an options box for the graph
self.create_optionsbox()
self.main_layout.addWidget(self.options_groupbox)
# add render button
render_button = QPushButton('Render Graph', self)
render_button.setToolTip('Render the personality graph and display it')
render_button.clicked.connect(self.render_click)
self.main_layout.addWidget(render_button)
# finally, display the window
self.setLayout(self.main_layout)
self.show()
def create_formbox(self):
self.form_groupbox = QGroupBox('Personality Traits')
self.form_layout = QFormLayout()
addrow_button = QPushButton('Add Trait', self)
addrow_button.setToolTip('Add a new section to the graph')
addrow_button.clicked.connect(self.addrow_click)
self.form_layout.addRow(QLabel('Trait'), QLabel('Value'))
self.form_layout.addRow(QLineEdit(),
QDoubleSpinBox(decimals=5, maximum=10))
self.form_layout.addRow(addrow_button)
self.form_groupbox.setLayout(self.form_layout)
def create_optionsbox(self):
self.options_groupbox = QGroupBox('Graph Options')
self.options_layout = QFormLayout()
self.ceiling_text = QDoubleSpinBox(decimals=5, value=10.00)
self.ceiling_text.valueChanged.connect(self.ceiling_changed)
self.options_layout.addRow(QLabel('Graph Name'), QLineEdit())
self.options_layout.addRow(QLabel('Max Value'), self.ceiling_text)
self.options_layout.addRow(QLabel('Height/Width'),
QSpinBox(value=6, minimum=1))
self.options_layout.addRow(QLabel('Padding'), QSpinBox(value=4))
self.options_layout.addRow(QLabel('Font Size'),
QSpinBox(value=12, minimum=1))
self.options_groupbox.setLayout(self.options_layout)
# calls the render_graph function to render and then display the graph
@pyqtSlot()
def render_click(self):
input_values = []
input_names = []
name = self.options_groupbox.children()[2].text().strip()
padding = self.options_groupbox.children()[8].value()
size = self.options_groupbox.children()[6].value()
font = self.options_groupbox.children()[10].value()
max = self.options_groupbox.children()[4].value()
if len(self.form_groupbox.children()) == 3:
# if the user has not added any sections, warn them
self.error_message.showMessage('Cannot graph with no sections!')
elif size < 1:
self.error_message.showMessage(
'Height/Width must be greater than 0!')
else:
# get values from input boxes and pass them into graphing function
children = self.form_groupbox.findChildren(QLineEdit)
count = 0
while count < len(children):
input_names.append(children[count].text())
count += 1
input_values.append(float(children[count].text()))
count += 1
result = polar_bar.render_graph(name=name,
section_names=input_names,
value_list=input_values,
padding=padding,
max=max,
size=size,
font=font)
if result is False:
self.error_message.showMessage(
'Padding too big for Height/Width!')
@pyqtSlot()
def addrow_click(self):
self.form_layout.insertRow(
self.form_layout.rowCount() - 1, QLineEdit(),
QDoubleSpinBox(decimals=5,
maximum=float(self.ceiling_text.value())))
@pyqtSlot()
def ceiling_changed(self):
for i in self.form_groupbox.findChildren(QDoubleSpinBox):
i.setMaximum(float(self.ceiling_text.value()))
def setupUi(self, Dialog):
Dialog.setObjectName("Dialog")
Dialog.resize(data.orderResolution[0], data.orderResolution[1])
addingToBox = []
mainWin = QVBoxLayout(Dialog)
tabs = QTabWidget()
mainWin.addWidget(tabs)
apply = QPushButton("Apply and Close")
apply.clicked.connect(lambda: applyClose())
mainWin.addWidget(apply)
apply.setFixedWidth(data.orderResolution[0] / 5)
Dialog.setWindowIcon(QtGui.QIcon('gear.ico'))
tabs.resize(data.orderResolution[0], data.orderResolution[1])
tab1 = QWidget()
tab1.layout = QGridLayout(tab1)
deleteHisButton = QPushButton("DELETE HIST.")
deleteHisButton.clicked.connect(lambda: deleteHis())
deleteHisButton.setFixedWidth(data.orderResolution[0] / 5)
darkModeBut = QPushButton()
if data.mode == "Light":
darkModeBut.setText("DARK MODE")
else:
darkModeBut.setText("Light MODE")
darkModeBut.clicked.connect(lambda: switchToDark())
tab1.layout.addWidget(deleteHisButton)
tab1.layout.addWidget(darkModeBut)
darkModeBut.setFixedWidth(data.orderResolution[0] / 5)
tab1.layout.addWidget(QLabel("Find bag? Say about it:"), 2, 0)
space = QtWidgets.QTextEdit()
tab1.layout.addWidget(space, 3, 0)
sendBag = QPushButton("Send")
sendBag.clicked.connect(lambda: send_bug())
tab1.layout.addWidget(sendBag, 3, 1)
tabs.addTab(tab1, "General")
#tab2 = QWidget()
#tab2.layout = QVBoxLayout(tab2)
#tabs.addTab(tab2, "Graph Settings")
# searchLine = QHBoxLayout()
# sLine = QtWidgets.QLineEdit()
# sBut = QPushButton("Search")
# sBut.clicked.connect(lambda: search())
# searchLine.addWidget(sLine)
# searchLine.addWidget(sBut)
joinGraphs = QCheckBox("Join Buy and Sell Graphs?")
if data.joinG[1] == True:
joinGraphs.setChecked(True)
joinGraphs.stateChanged.connect(self.joinGraphs)
tab1.layout.addWidget(joinGraphs, 0, 1)
tab4 = QWidget()
tab4.layout = QVBoxLayout(tab4)
tabs.addTab(tab4, "Products")
tab4.layout.addWidget(QLabel("Find products you want to add."))
searchLine1 = QHBoxLayout()
sLine1 = QtWidgets.QLineEdit()
sBut1 = QPushButton("Add")
sBut1.clicked.connect(lambda: addPrd())
searchLine1.addWidget(sLine1)
searchLine1.addWidget(sBut1)
tab4.layout.addLayout(searchLine1)
formLayout1 = QFormLayout()
groupBox1 = QGroupBox()
i = 0
for prod in data.pref_prd:
i += 1
t = QPushButton(" " + prod,
clicked=lambda _, n=i: remove_prd(n - 1))
t.setFixedWidth(data.orderResolution[0] / 5)
t.setStyleSheet("text-align: left;")
formLayout1.insertRow(0, t)
groupBox1.setLayout(formLayout1)
groupBox1.setTitle(
"Your products: Click to delete from Your Products.")
scroll1 = QScrollArea()
scroll1.setWidget(groupBox1)
scroll1.setWidgetResizable(True)
tab4.layout.addWidget(scroll1)
self.retranslateUi(Dialog)
QtCore.QMetaObject.connectSlotsByName(Dialog)
def addPrd():
prd = sLine1.text()
data.pref_prd.append(prd)
t = QPushButton(" " + str(prd))
t.setFixedWidth(data.orderResolution[0] / 5)
t.setStyleSheet("text-align: left;")
formLayout1.addRow(t)
addingToBox.append(prd)
data.addToBox = [True, addingToBox]
def send_bug():
text = space.toPlainText()
sendBag.setText("DONE")
sendBag.setDisabled(True)
bug_log(func.log_text_format(text))
def applyClose():
if data.joinG[0] == True:
data.joinG = [True, True]
if len(addingToBox) != 0:
client.add_star(addingToBox, data.username, data.password)
Dialog.close()
def switchToDark():
darkModeBut.setText("Click 'Apply and Close'")
darkModeBut.setDisabled(True)
if data.mode == "Light":
data.mode = "Dark"
else:
data.mode = "Light"
def deleteHis():
data.clearHis = True
func.clearHis()
client.delete_history(data.username, data.password)
deleteHisButton.setText("DONE")
deleteHisButton.setDisabled(True)
def remove_prd(index):
print("DLETE THIS NIBO", data.pref_prd[index])
client.remove_star([data.pref_prd[index]], data.username,
data.password)
del data.pref_prd[index]
for i in reversed(range(formLayout1.count())):
formLayout1.itemAt(i).widget().deleteLater()
i = 0
for prod in data.pref_prd:
i += 1
t = QPushButton(" " + prod,
clicked=lambda _, n=i: remove_prd(n - 1))
t.setFixedWidth(data.orderResolution[0] / 5)
t.setStyleSheet("text-align: left;")
formLayout1.insertRow(0, t)
print(data.pref_prd)
data.addToBox = [True, ""]
class CreateVersionWidget(QDialog):
"""
Create version dialog used when generating a new CAT version.
Allows user to input the expected question labels which will
become the directory structure for storing models and parameters.
"""
version_created = pyqtSignal(str)
def __init__(self, parent=None):
super(CreateVersionWidget, self).__init__(parent)
self.logger = logging.getLogger(__name__)
self.parent = parent
self.setWindowTitle("New CAT Version")
self.version_name = None
self.question_labels = {}
self.input_widgets = {}
self.main_layout = QVBoxLayout()
self.version_groupbox = QGroupBox("Create new version")
self.version_form = QFormLayout()
self.version_groupbox.setLayout(self.version_form)
self.main_layout.addWidget(self.version_groupbox)
self.setupUI()
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.buttonBox.setObjectName("version_warning")
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
self.buttonBox.setWindowTitle("Version Warning")
self.buttonBox.rejected.connect(self.reject)
self.main_layout.addWidget(self.buttonBox)
self.setLayout(self.main_layout)
def _verify_params(self):
"""
Checks that each input field has some value and that the version name
has been specified.
# Returns: None
"""
for label, widget in self.input_widgets.items():
if widget.text() == '':
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
return False
if self.version_name:
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(True)
return True
def _update_version_name(self, value):
self.version_name = value
def _verify_unique_params(self, key, value):
"""
Checks that field name is unique. This is necessary as field values
are used for version directory and data structure.
# Arguments
key(String): dict key for appropriate input widget
value(String): field name. Must be unique per version.
"""
if value.lower() in [x.lower() for x in self.question_labels.values()]:
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
exceptionWarning('Field names must be unique!')
return
try:
self._verify_params()
except Exception as e:
exceptionWarning('Error updating version params.', e, title="Update version warning")
def _version_check(self, version):
"""
Checks that user has both supplied a version name and that, if supplied,
the name is unique.
# Arguments
version(String): version name supplied by user
# Returns
bool: True if version is supplied and unique, else False
"""
if version == '':
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
return False
v = os.path.join(VERSION_BASE_DIR, version)
if os.path.exists(v):
msg_box = QMessageBox()
msg_box.setIcon(QMessageBox.Warning)
msg_box.setText("Version {} already exists!".format(version))
msg_box.setWindowTitle('Version Warning')
msg_box.exec_()
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
return False
self._verify_params()
return True
def _update_fields(self, state):
"""
Appends or removes an input widget for version field labels.
# Arguments
state(bool): If True, add a field, else remove the last field
# Returns
None
"""
current_row_idx = self.version_form.rowCount()
if state:
label = QLabel('Field ' + str(current_row_idx) + ':')
q_input = QLineEdit(objectName=str(current_row_idx - 1))
q_input.textChanged.connect(
lambda state, x=current_row_idx-1, y=q_input:
self._verify_unique_params(
x,
(None if y.text() == '' else y.text())
)
)
self.version_form.insertRow(current_row_idx, label, q_input)
self.input_widgets[str(current_row_idx - 1)] = q_input
q_input.setFocus()
else:
if current_row_idx == 1:
return
item = self.input_widgets[str(current_row_idx - 2)]
try:
del self.input_widgets[item.objectName()]
self.version_form.removeRow(current_row_idx - 1)
self.version_form.update()
except Exception as e:
exceptionWarning('Error updating version params.', e, title="Update version warning")
self._verify_params()
def _generate_fields(self):
"""
Generate fields based on default version scheme.
"""
for idx, q_label in enumerate(DEFAULT_QUESTION_LABELS):
self.question_labels[idx] = q_label
label = QLabel('Field ' + str(idx+ 1) + ':')
q_input = QLineEdit(objectName=str(idx))
q_input.setText(q_label)
q_input.textChanged.connect(
lambda state, x=idx, y=self.version_name_input:
self._verify_unique_params(
x,
(None if y.text() == '' else y.text())
)
)
self.version_form.addRow(label, q_input)
self.input_widgets[str(idx)] = q_input
self._verify_params()
def setupUI(self):
self.version_name_label = QLabel("Version name: ")
self.version_name_input = QLineEdit(objectName='version_name')
self.version_name_input.textChanged.connect(
lambda state, y=self.version_name_input:
self._update_version_name(
(y.text() if self._version_check(y.text()) else None)
)
)
self.version_form.addRow(self.version_name_label, self.version_name_input)
self._generate_fields()
self.new_question_row_btn = QPushButton('Add field', self)
self.new_question_row_btn.clicked.connect(lambda: self._update_fields(True))
self.remove_question_row_btn = QPushButton('Remove field', self)
self.remove_question_row_btn.clicked.connect(lambda: self._update_fields(False))
self.button_hbox = QHBoxLayout()
self.button_hbox.addWidget(self.new_question_row_btn)
self.button_hbox.addWidget(self.remove_question_row_btn)
self.main_layout.addLayout(self.button_hbox)
def create_version(self):
"""
Create the new version specified by the user.
"""
if(self.exec_() == QDialog.Accepted):
v_dir = os.path.join(VERSION_BASE_DIR, self.version_name)
try:
if not os.path.exists(v_dir):
os.makedirs(v_dir)
for k,v in self.input_widgets.items():
sub_dir = os.path.join(v_dir, v.text())
if not os.path.exists(sub_dir):
os.makedirs(sub_dir)
self.version_created.emit(v_dir)
except Exception as e:
exceptionWarning('Error occured when creating new version.', e, title='Create version exception')
finally:
self.question_labels = {}
self.version_name = None
self.version_name_input.setText('')
for k,v in self.input_widgets.items():
self.version_form.removeRow(v)
self.input_widgets = {}
self.version_form.update()
self._generate_fields()
class OptionsPanel(QWidget):
"""Supported API. OptionsPanel is a container for single-use (not savable) Options"""
def __init__(self,
parent=None,
*,
sorting=True,
scrolled=True,
contents_margins=None):
"""sorting:
False; options shown in order added
True: options sorted alphabetically by name
func: options sorted based on the provided key function
"""
QWidget.__init__(self, parent)
self._layout = QVBoxLayout()
if contents_margins is not None:
self._layout.setContentsMargins(*contents_margins)
if scrolled:
sublayout = QVBoxLayout()
sublayout.setContentsMargins(3, 0, 3, 2)
self.setLayout(sublayout)
scroller = QScrollArea()
scroller.setWidgetResizable(True)
sublayout.addWidget(scroller)
scrolled_area = QWidget()
scroller.setWidget(scrolled_area)
scrolled_area.setLayout(self._layout)
else:
self.setLayout(self._layout)
self._sorting = sorting
self._options = []
self._option_groups = []
self._layout.setSizeConstraint(self._layout.SetMinAndMaxSize)
self._form = QFormLayout()
self._form.setSizeConstraint(self._form.SetMinAndMaxSize)
self._form.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow)
self._form.setVerticalSpacing(1)
from PyQt5.QtCore import Qt
# None of the below seem to have an effect on the Mac...
#self._form.setLabelAlignment(Qt.AlignRight | Qt.AlignVCenter)
#self._form.setFormAlignment(Qt.AlignLeft | Qt.AlignVCenter)
# if we wanted to force the form contents to upper left...
#self._form.setFormAlignment(Qt.AlignLeft | Qt.AlignTop)
self._layout.addLayout(self._form)
def add_option(self, option):
"""Supported API. Add an option (instance of chimerax.ui.options.Option)."""
if self._sorting is False:
insert_row = len(self._options)
else:
if self._sorting is True:
test = lambda o1, o2: o1.name < o2.name
else:
test = lambda o1, o2: self._sorting(o1) < self._sorting(o2)
for insert_row in range(len(self._options)):
if test(option, self._options[insert_row]):
break
else:
insert_row = len(self._options)
self._form.insertRow(insert_row, option.name, option.widget)
self._options.insert(insert_row, option)
if option.balloon:
self._form.itemAt(insert_row,
QFormLayout.LabelRole).widget().setToolTip(
option.balloon)
def add_option_group(self,
group_label=None,
checked=None,
group_alignment=None,
**kw):
if group_label is None:
grouping_widget = QWidget()
else:
grouping_widget = QGroupBox(group_label)
grouping_widget.setContentsMargins(
1,
grouping_widget.contentsMargins().top() // 2, 1, 1)
if checked is not None:
grouping_widget.setCheckable(True)
grouping_widget.setChecked(checked)
add_kw = {} if group_alignment is None else {
'alignment': group_alignment
}
self._layout.addWidget(grouping_widget, **add_kw)
suboptions = OptionsPanel(scrolled=False, **kw)
self._option_groups.append(suboptions)
return grouping_widget, suboptions
def change_label_for_option(self, option, new_label):
self._form.labelForField(option.widget).setText(new_label)
def options(self):
all_options = self._options[:]
for grp in self._option_groups:
# an option group can have further subgroups, so call options()
all_options.extend(grp.options())
return all_options
def sizeHint(self):
from PyQt5.QtCore import QSize
form_size = self._form.minimumSize()
return QSize(min(form_size.width(), 800), min(form_size.height(), 800))
class ProfileWidget(QTabWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.parent = parent
self.buttons = []
self.levelTab = QWidget()
self.posTab = QWidget()
self.initLevelTab()
self.initPosTab()
self.addTab(self.levelTab, "LEVEL")
self.addTab(self.posTab, "POS")
def initLevelTab(self):
# Adding button
button = QPushButton()
button.setFlat(True)
button.setIconSize(QSize(30, 30))
button.setIcon(QIcon('files/add.png'))
button.clicked.connect(partial(self.addNewFormat, 'level'))
# Titles
hbox = QHBoxLayout()
hbox.addWidget(QLabel('Name'), 3)
hbox.addWidget(QLabel('Color'), 3)
hbox.addWidget(QLabel('List'), 3)
hbox.addWidget(QLabel('Rule'), 3)
hbox.addWidget(QLabel(), 1)
hbox2 = QHBoxLayout()
hbox2.addWidget(button, alignment=Qt.AlignCenter)
hbox2.addStretch()
self.levelFormLayout = QFormLayout()
self.levelFormLayout.addRow(hbox)
self.levelFormLayout.addRow(hbox2)
self.levelTab.setLayout(self.levelFormLayout)
def initPosTab(self):
# Adding button
button = QPushButton()
button.setFlat(True)
button.setIconSize(QSize(30, 30))
button.setIcon(QIcon('files/add.png'))
button.clicked.connect(partial(self.addNewFormat, 'pos'))
# Titles
hbox = QHBoxLayout()
hbox.addWidget(QLabel('Name'), 3)
hbox.addWidget(QLabel('Color'), 3)
hbox.addWidget(QLabel('Rule'), 3)
hbox.addWidget(QLabel(), 1)
hbox2 = QHBoxLayout()
hbox2.addWidget(button)
hbox2.addStretch()
self.posFormLayout = QFormLayout()
self.posFormLayout.addRow(hbox)
self.posFormLayout.addRow(hbox2)
self.posTab.setLayout(self.posFormLayout)
def addTextFormat(self, textFormat):
hbox = QHBoxLayout()
# Name
self.buttons.append(QPushButton())
textFormat.editButton = self.buttons[-1]
textFormat.editButton.setText(textFormat.name)
textFormat.editButton.setFlat(True)
textFormat.editButton.clicked.connect(
partial(self.changeName, textFormat))
hbox.addWidget(textFormat.editButton, 3)
# ColorButton
self.buttons.append(QPushButton())
textFormat.colorButton = self.buttons[-1]
textFormat.colorButton.setText('Edit')
textFormat.colorButton.setStyleSheet('background-color: ' +
textFormat.getColorRgbaCss())
textFormat.colorButton.clicked.connect(
partial(self.changeColor, textFormat))
hbox.addWidget(textFormat.colorButton, 3)
# ListButton
if textFormat.type == 'level':
self.buttons.append(QPushButton())
textFormat.listButton = self.buttons[-1]
textFormat.listButton.clicked.connect(
partial(self.openFile, textFormat, type='list'))
hbox.addWidget(textFormat.listButton, 3)
# RuleButton
self.buttons.append(QPushButton())
textFormat.ruleButton = self.buttons[-1]
textFormat.ruleButton.clicked.connect(
partial(self.openFile, textFormat, type='rule'))
hbox.addWidget(textFormat.ruleButton, 3)
# DeleteButton
self.buttons.append(QPushButton())
textFormat.removeButton = self.buttons[-1]
textFormat.removeButton.setFlat(True)
textFormat.removeButton.setIconSize(QSize(25, 25))
textFormat.removeButton.clicked.connect(
partial(self.parent.textFormatManager.remove, textFormat))
textFormat.removeButton.setIcon(QIcon('files/delete.png'))
hbox.addWidget(textFormat.removeButton, 1)
textFormat.tabHBox = hbox
if textFormat.type == 'level':
row = self.levelFormLayout.rowCount() - 1
self.levelFormLayout.insertRow(row, hbox)
else:
row = self.posFormLayout.rowCount() - 1
self.posFormLayout.insertRow(row, hbox)
def addNewFormat(self, type):
def getLatestNumber(formats, matchString):
i = 1
while True:
if '{}{}'.format(matchString, i) in [f.name for f in formats]:
i += 1
else:
break
return i
if type == 'level':
textFormat = TextFormat(
'Level' + str(
getLatestNumber(
self.parent.textFormatManager.getFormats(type='level'),
'Level')), type)
else:
textFormat = TextFormat(
'POS' + str(
getLatestNumber(
self.parent.textFormatManager.getFormats(type='pos'),
'POS')), type)
self.parent.textFormatManager.insert(textFormat)
def removeTextFormat(self, textFormat):
for i in reversed(range(textFormat.tabHBox.count())):
textFormat.tabHBox.itemAt(i).widget().setParent(None)
if textFormat.type == 'level':
self.levelFormLayout.removeItem(textFormat.tabHBox)
else:
self.posFormLayout.removeItem(textFormat.tabHBox)
def changeColor(self, textFormat):
color = QColorDialog.getColor(initial=textFormat.getColor())
if color.isValid():
textFormat.setColor(color)
textFormat.colorButton.setStyleSheet('background-color: ' +
textFormat.getColorRgbaCss())
self.parent.highlightViewpoint()
def changeName(self, textFormat):
textFormat.editButton.setParent(None)
self.nameLineEdit = QLineEdit()
textFormat.tabHBox.insertWidget(0, self.nameLineEdit, stretch=3)
self.nameLineEdit.setFocus()
self.nameLineEdit.returnPressed.connect(self.getChangedName)
self.nameLineEdit.focusOutEvent = self.nameLineEditFocusOut
self.textFormat = textFormat
def nameLineEditFocusOut(self, event):
QLineEdit.focusOutEvent(self.nameLineEdit, event)
self.getChangedName()
def getChangedName(self):
name = self.nameLineEdit.text()
if name:
self.textFormat.editButton.setText(name)
self.textFormat.counterNameLabel.setText(name)
self.nameLineEdit.setParent(None)
self.textFormat.tabHBox.insertWidget(0,
self.textFormat.editButton,
stretch=3)
def openFile(self, textFormat, type):
filePath, _ = QFileDialog.getOpenFileName(self)
if filePath:
if type == 'list':
textFormat.setupWordList(filePath)
listName = filePath.split('/')[-1]
textFormat.listButton.setText(
listName[:10] + '..' if len(listName) > 10 else listName)
elif type == 'rule':
ok = textFormat.setupRegexList(filePath)
if ok:
ruleName = filePath.split('/')[-1]
textFormat.ruleButton.setText(
ruleName[:10] +
'..' if len(ruleName) > 10 else ruleName)
else:
textFormat.ruleButton.setText('')
self.parent.highlightViewpoint()
self.parent.counterWidget.refresh()
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 EditableAssessment(BaseAssessment):
form = None
info_list = None
def __init__(self, course):
super().__init__()
self.setTitle('Assessment')
self.form = QFormLayout()
self.info_list = []
for x in db.get_course_assessment(course):
self.info_list.append((EditableWidget(x), QCheckBox()))
self.form.addRow(*self.info_list[len(self.info_list) - 1])
new_assessment = QLineEdit()
add_button = QPushButton()
add_button.setFixedSize(new_assessment.sizeHint().height(),
new_assessment.sizeHint().height())
add_button.setIcon(QIcon('./images/add.png'))
add_button.clicked.connect(
lambda: self.insert_new(new_assessment, course))
self.form.addRow(new_assessment, add_button)
del_button = QPushButton()
del_button.setIcon(QIcon('./images/del.png'))
del_button.clicked.connect(lambda: self.remove(course))
button_block = ButtonBlock(True)
button_block.block_layout.insertWidget(3, del_button)
button_block.edit_button.clicked.connect(
lambda: edit([f[0] for f in self.info_list]))
button_block.save_button.clicked.connect(lambda: self.__save(course))
v_layout = QVBoxLayout()
v_layout.addLayout(button_block.block_layout)
v_layout.addLayout(self.form)
self.setLayout(v_layout)
def remove(self, course):
to_remove = []
for x in self.info_list:
if x[1].isChecked():
db.remove_assessment(course, x[0].text())
self.form.removeRow(x[1])
to_remove.append(x)
for x in to_remove:
self.info_list.remove(x)
def __save(self, course):
for x in self.info_list:
x[0].push_to_db(x[0].text(), db.update_assessment,
[course, x[0].old])
def insert_new(self, line, course):
db.add_assessment(course, line.text())
to_info_list = (EditableWidget(line.text()), QCheckBox())
self.form.insertRow(0, *to_info_list)
self.info_list.append(to_info_list)
line.setText('')
