def view(self):
self.viewWindow = QtGui.QMainWindow()
self.ui = Ui_MainWindow()
self.ui.setupUi(self.viewWindow)
self.ui.textEdit.setStyleSheet("background-color: #FFFFDD;")
self.ui.textEdit.setText(self.worker.html)
self.viewWindow.show()
def __init__(self):
super(MainApp, self).__init__()
self.ui = Ui_MainWindow()
self.method = None
self.methodNum = 0
self.mode = False
self.step = 0
self.all_method_order = 0 # hold which method to be selected
self.all_method = [
] # hold objects of all methods in case of this mode
self.ui.setupUi(self)
self.eps = 0.00001
self.max_iter = 50
self.x0 = 0
self.x1 = 0
self.function = ""
self.setWindowTitle("Root Finder")
self.ui.modeCombo.activated.connect(self.mode_changed)
self.ui.methodCombo.activated.connect(self.method_changed)
self.ui.solveBtn.clicked.connect(self.solve_btn_action)
self.ui.prevBtn.clicked.connect(self.prev_btn_action)
self.ui.nextBtn.clicked.connect(self.next_btn_action)
self.ui.tableButton.clicked.connect(self.show_table)
self.ui.fileSaveBtn.clicked.connect(self.save_into_file)
self.ui.fileReadBtn.clicked.connect(self.read_file)
self.table = SolutionTable()
def __init__(self):
super(MainApp, self).__init__()
self.ui = Ui_MainWindow()
self.method = None
self.methodNum = 0
self.mode = False
self.ui.setupUi(self)
self.setWindowTitle("Root Finder")
self.ui.modeCombo.activated.connect(self.mode_changed)
self.ui.methodCombo.activated.connect(self.method_changed)
self.ui.solveBtn.clicked.connect(self.solve_btn_action)
self.ui.prevBtn.clicked.connect(self.prev_btn_action)
self.ui.nextBtn.clicked.connect(self.next_btn_action)
def __init__(self, parent=None):
"""
Initializes Controller and connects the logic with the UI
:param parent: Parent window for UI
"""
super().__init__(parent)
self.myForm = Ui_MainWindow()
self.myForm.setupUi(self)
self.myForm.pushButton.clicked.connect(self.start_game)
self.myForm.b1.clicked.connect(self.restart_game)
self.logic = GameLogic(self)
class MainWindow(QtWidgets.QMainWindow):
def __init__(self, img_source):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Create video capture
self.cap = cv2.VideoCapture(img_source)
self.cam_img = self.cap.read()[1]
# Create a timer to update camera image in GUI
self.img_timer = QtCore.QTimer(self)
self.img_timer_control(delay=20)
# Set timer timeout callback function
self.img_timer.timeout.connect(self.update_cam_img)
def get_cam_img(self):
return self.cam_img
def update_cam_img(self):
# Read image in BGR format
self.cam_img = self.cap.read()[1]
# Convert image to RGB format
self.cam_img = cv2.cvtColor(self.cam_img, cv2.COLOR_BGR2RGB)
# Get image infos
height, width, channel = self.cam_img.shape
step = channel * width
# Create QImage from image
qImg = QtGui.QImage(self.cam_img.data, width, height, step,
QtGui.QImage.Format_RGB888)
# Show image in img_label
self.ui.cam_img.setPixmap(QtGui.QPixmap.fromImage(qImg))
def img_timer_control(self, delay):
if not self.img_timer.isActive():
# Start timer
self.img_timer.start(delay)
else:
# Stop timer
self.img_timer.stop()
# Release video capture
self.cap.release()
def __init__(self, img_source):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Create video capture
self.cap = cv2.VideoCapture(img_source)
self.cam_img = self.cap.read()[1]
# Create a timer to update camera image in GUI
self.img_timer = QtCore.QTimer(self)
self.img_timer_control(delay=20)
# Set timer timeout callback function
self.img_timer.timeout.connect(self.update_cam_img)
def __init__(self):
super(View, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
validator = QtGui.QIntValidator(0, 150)
self.ui.age_from.setValidator(validator)
self.ui.age_to.setValidator(validator)
self.db = None
self.model = None
self.open_database()
doc_query = QtSql.QSqlQuery()
doc_query.exec_(get_document_types_query())
self.document_type = {}
while doc_query.next():
qs = unicode(doc_query.value(0).toString())
self.document_type[qs] = doc_query.value(1).toString()
self.ui.document_type.addItem(qs)
self.ui.document_type.setCurrentIndex(-1)
self.ui.age_from.textChanged.connect(lambda: update_date_to(
self))
self.ui.age_to.textChanged.connect(lambda: update_date_from(
self))
self.connect(self.ui.query_button, QtCore.SIGNAL("clicked()"),
self.query_on_button_click)
self._filter_from = DateFromFilter()
self._filter_to = DateToFilter()
self.ui.birth_date_from.installEventFilter(self._filter_from)
self.ui.birth_date_to.installEventFilter(self._filter_to)
def main():
app = QtGui.QApplication(sys.argv)
# model ... fem data and other user data?
view = Ui_MainWindow()
controller = MainWindow(app, view)
sys.exit(app.exec_())
def __init__(self,parent=None):
super(Main, self).__init__(parent=parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.modeGroup = QButtonGroup()
self.modeGroup.addButton(self.ui.filterRecord)
self.modeGroup.addButton(self.ui.plotGraph)
self.ui.allRecordsCB.clicked.connect(self.allRecordsCBMode)
self.ui.filterRecord.clicked.connect(self.onClickedMode)
self.ui.plotGraph.clicked.connect(self.onClickedMode)
self.ui.submitBtn.clicked.connect(self.execute)
self.initialiseDefaultOptions()
# Default UI initialisation calls
self.setComboBoxes()
self.initialiseTable()
def __init__(self, parent=None):
super().__init__(parent)
self.undoStack = QUndoStack()
self.view = Ui_MainWindow()
self.view.setupUi(self)
self.view.tableView.setSortingEnabled(True)
self.view.tableView.setItemDelegate(ItemDelegate(self.undoStack, self.set_undo_redo_text))
self.filename = None
self.table_model = CSVTableModel(datalist=[], header=[], parent=self)
self.connect_elements()
try:
self.db = DBAccess(DBConfig.database, DBConfig.username, DBConfig.password, DBConfig.wahltermin)
except Exception as e:
print(e)
Message.error("Database Error", "Error while trying to establish a database connection.")
def __init__(self, parent=None):
super().__init__(parent)
self.undoStack = QUndoStack()
self.db = DBConnection("172.16.6.137", "root", "password", "wahl")
self.gui = Ui_MainWindow()
self.gui.setupUi(self)
self.gui.actionOpen.triggered.connect(self.open_file)
self.gui.actionSave.triggered.connect(self.save_file)
self.gui.actionSave_as.triggered.connect(self.save_file_as)
self.gui.actionNew.triggered.connect(self.new_file)
self.gui.actionCopy.triggered.connect(self.copy_cs)
self.gui.actionAdd_Row.triggered.connect(self.add_rows)
self.gui.actionSave_DB.triggered.connect(self.open_save_db)
self.gui.actionOpen_DB.triggered.connect(self.open_load_db)
self.gui.actionPaste.triggered.connect(self.paste)
self.gui.actionCut.triggered.connect(self.cut)
self.gui.actionDelete_Row.triggered.connect(self.remove_rows)
self.gui.actionDuplicate_Row.triggered.connect(self.duplicate)
self.gui.actionUndo.triggered.connect(self.undo)
self.gui.actionRedo.triggered.connect(self.redo)
self.gui.actionCreate_Prediction.triggered.connect(self.open_create_pred)
self.gui.actionShow_Prediction.triggered.connect(self.open_choose_pred)
self.gui.tableView.setSortingEnabled(True)
self.gui.tableView.setItemDelegate(ItemDelegate(self.undoStack, self.set_unrdo_text))
self.tbm = DictTableModel(data=[], header=[], parent=self)
self.sdb_dialog = SaveToDBDialog(self)
self.ldb_dialog = LoadFromDBDialog(self)
self.create_pred_dialog = CreatePredDialog(self)
self.choose_pred_dialog = ChoosePredDialog(self)
self.show_pred_dialog = ShowPredDialog(self)
self.file = "."
class MainApp(QtWidgets.QMainWindow):
# constructor
def __init__(self):
super(MainApp, self).__init__()
self.ui = Ui_MainWindow()
self.method = None
self.methodNum = 0
self.mode = False
self.ui.setupUi(self)
self.setWindowTitle("Root Finder")
self.ui.modeCombo.activated.connect(self.mode_changed)
self.ui.methodCombo.activated.connect(self.method_changed)
self.ui.solveBtn.clicked.connect(self.solve_btn_action)
self.ui.prevBtn.clicked.connect(self.prev_btn_action)
self.ui.nextBtn.clicked.connect(self.next_btn_action)
# handle the event of selection specific mode of solution(single mode , Direct Solution)
def mode_changed(self):
self.mode = bool(self.ui.modeCombo.currentIndex())
# print(self.mode)
if self.mode:
self.ui.nextBtn.setEnabled(True)
self.ui.prevBtn.setEnabled(True)
else:
self.ui.nextBtn.setEnabled(False)
self.ui.prevBtn.setEnabled(False)
# handle the event of selection specific method
def method_changed(self):
self.methodNum = self.ui.methodCombo.currentIndex()
# print(self.methodNum)
if self.methodNum == 0:
self.ui.solveBtn.setEnabled(False)
elif self.methodNum == 3 or self.methodNum == 4 or self.methodNum == 6:
self.ui.X1lineEdit.setEnabled(False)
self.ui.labelX1.setText(" ")
self.ui.solveBtn.setEnabled(True)
else:
self.ui.X1lineEdit.setEnabled(True)
self.ui.labelX1.setText("X(1)")
self.ui.solveBtn.setEnabled(True)
# handle the event of solve button
def solve_btn_action(self):
function = self.ui.functionLineEdit.text()
if function == "":
return
# take value of initial point if exist
print("function : ", function)
try:
x0 = float(self.ui.X0lineEdit.text())
# print(x0)
except:
x0 = 0
if x0 == 0:
return
print("x0 : ", x0)
# take value of second point if exict
try:
x1 = float(self.ui.X1lineEdit.text())
# print(x1)
except:
x1 = 0
if (self.methodNum == 1 or self.methodNum == 2
or self.methodNum == 5) and x1 == 0:
print(self.methodNum)
return
print("x1 : ", x1)
# take value of eps
try:
eps = float(self.ui.EpslineEdit.text())
except:
eps = 0.05
# take value of max iteration
try:
max_iter = float(self.ui.iterlineEdit.text())
except:
max_iter = 50
print("eps : ", eps)
if self.methodNum == 1:
self.method = Bisection(function, x0, x1, eps, max_iter)
print("bisection")
elif self.methodNum == 2:
print(self.methodNum)
elif self.methodNum == 3:
self.method = FP.FixedPoint(function, x0, eps, max_iter)
elif self.methodNum == 4:
print(self.methodNum)
elif self.methodNum == 5:
self.method = SC.Secant(function, x0, x1, eps, max_iter)
print("Secant")
elif self.methodNum == 6:
print("birge vieta")
self.method = BV.BirgeVieta(function, x0, eps, max_iter)
self.method.calculate()
print("calculated")
if self.mode:
self.single_mode()
else:
self.direct_solution_mode()
# actions performed in case of direct solution display
def direct_solution_mode(self):
print("before plotted")
self.method.plot(self.ui.mplGraph.canvas)
print("plotted")
text = "\t\tsolution\n\n" + " estimate Root = " + str(
self.method.get_root()) + "\n\n" + " Relative Error = "
text += str(
self.method.get_error()) + "\n\n" + " # Iterations = " + str(
self.method.get_taken_iteration()) + "\n\n"
self.ui.solutionText.setText(text)
# actions performed in case of direct solution display
def single_mode(self):
return
# handle the event of prev button
def prev_btn_action(self):
return
# handle the event of next button
def next_btn_action(self):
return
class Ui_Form(object):
def view(self):
self.viewWindow = QtGui.QMainWindow()
self.ui = Ui_MainWindow()
self.ui.setupUi(self.viewWindow)
self.ui.textEdit.setStyleSheet("background-color: #FFFFDD;")
self.ui.textEdit.setText(self.worker.html)
self.viewWindow.show()
def setupUi(self, Form):
Form.setObjectName(_fromUtf8("Form"))
Form.setFixedSize(423, 221)
Form.setStyleSheet(_fromUtf8("plastique"))
self.tabWidget = QtGui.QTabWidget(Form)
self.tabWidget.setGeometry(QtCore.QRect(10, 10, 401, 201))
self.tabWidget.setObjectName(_fromUtf8("tabWidget"))
self.tab = QtGui.QWidget()
self.tab.setObjectName(_fromUtf8("tab"))
self.groupBox = QtGui.QGroupBox(self.tab)
self.groupBox.setGeometry(QtCore.QRect(0, 20, 391, 51))
self.groupBox.setObjectName(_fromUtf8("groupBox"))
self.lineEdit = QtGui.QLineEdit(self.groupBox)
self.lineEdit.setGeometry(QtCore.QRect(10, 20, 141, 20))
self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
self.groupBox_2 = QtGui.QGroupBox(self.tab)
self.groupBox_2.setGeometry(QtCore.QRect(0, 70, 391, 51))
self.groupBox_2.setObjectName(_fromUtf8("groupBox_2"))
self.lineEdit_2 = QtGui.QLineEdit(self.groupBox_2)
self.lineEdit_2.setGeometry(QtCore.QRect(10, 20, 141, 20))
self.lineEdit_2.setObjectName(_fromUtf8("lineEdit_2"))
self.pushButton = QtGui.QPushButton(self.groupBox_2)
self.pushButton.setGeometry(QtCore.QRect(200, 20, 81, 23))
self.pushButton.setObjectName(_fromUtf8("pushButton"))
self.label = QtGui.QLabel(self.groupBox_2)
self.label.setGeometry(QtCore.QRect(300, 20, 91, 21))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.label.setFont(font)
self.label.setText(_fromUtf8(""))
self.label.setObjectName(_fromUtf8("label"))
self.radioButton = QtGui.QRadioButton(self.tab)
self.radioButton.setGeometry(QtCore.QRect(20, 180, 82, 17))
self.radioButton.setObjectName(_fromUtf8("radioButton"))
self.checkBox = QtGui.QCheckBox(self.tab)
self.checkBox.setGeometry(QtCore.QRect(330, 140, 70, 17))
self.checkBox.setObjectName(_fromUtf8("checkBox"))
self.groupBox_3 = QtGui.QGroupBox(self.tab)
self.groupBox_3.setGeometry(QtCore.QRect(0, 120, 161, 51))
self.groupBox_3.setObjectName(_fromUtf8("groupBox_3"))
self.lineEdit_3 = QtGui.QLineEdit(self.groupBox_3)
self.lineEdit_3.setGeometry(QtCore.QRect(10, 20, 141, 20))
self.lineEdit_3.setObjectName(_fromUtf8("lineEdit_3"))
self.groupBox_7 = QtGui.QGroupBox(self.tab)
self.groupBox_7.setGeometry(QtCore.QRect(160, 120, 161, 51))
self.groupBox_7.setObjectName(_fromUtf8("groupBox_7"))
self.lineEdit_4 = QtGui.QLineEdit(self.groupBox_7)
self.lineEdit_4.setGeometry(QtCore.QRect(10, 20, 141, 20))
self.lineEdit_4.setEchoMode(QtGui.QLineEdit.Password)
self.lineEdit_4.setObjectName(_fromUtf8("lineEdit_4"))
self.tabWidget.addTab(self.tab, _fromUtf8(""))
self.tab_2 = QtGui.QWidget()
self.tab_2.setObjectName(_fromUtf8("tab_2"))
self.groupBox_4 = QtGui.QGroupBox(self.tab_2)
self.groupBox_4.setGeometry(QtCore.QRect(0, 20, 391, 51))
self.groupBox_4.setObjectName(_fromUtf8("groupBox_4"))
self.lineEdit_5 = QtGui.QLineEdit(self.groupBox_4)
self.lineEdit_5.setGeometry(QtCore.QRect(10, 20, 141, 20))
self.lineEdit_5.setObjectName(_fromUtf8("lineEdit_5"))
self.groupBox_5 = QtGui.QGroupBox(self.tab_2)
self.groupBox_5.setGeometry(QtCore.QRect(0, 70, 391, 51))
self.groupBox_5.setObjectName(_fromUtf8("groupBox_5"))
self.lineEdit_6 = QtGui.QLineEdit(self.groupBox_5)
self.lineEdit_6.setGeometry(QtCore.QRect(10, 20, 141, 20))
self.lineEdit_6.setObjectName(_fromUtf8("lineEdit_6"))
self.groupBox_6 = QtGui.QGroupBox(self.tab_2)
self.groupBox_6.setGeometry(QtCore.QRect(0, 120, 391, 51))
self.groupBox_6.setObjectName(_fromUtf8("groupBox_6"))
self.lineEdit_7 = QtGui.QLineEdit(self.groupBox_6)
self.lineEdit_7.setGeometry(QtCore.QRect(10, 20, 141, 20))
self.lineEdit_7.setObjectName(_fromUtf8("lineEdit_7"))
self.tabWidget.addTab(self.tab_2, _fromUtf8(""))
self.tab_3 = QtGui.QWidget()
self.tab_3.setObjectName(_fromUtf8("tab_3"))
self.pushButton_2 = QtGui.QPushButton(self.tab_3)
self.pushButton_2.setEnabled(True)
self.pushButton_2.setGeometry(QtCore.QRect(50, 60, 81, 41))
self.pushButton_2.setObjectName(_fromUtf8("pushButton_2"))
self.pushButton_3 = QtGui.QPushButton(self.tab_3)
self.pushButton_3.setGeometry(QtCore.QRect(240, 60, 91, 41))
self.pushButton_3.setObjectName(_fromUtf8("pushButton_3"))
self.tabWidget.addTab(self.tab_3, _fromUtf8(""))
self.tab_4 = QtGui.QWidget()
self.tab_4.setObjectName(_fromUtf8("tab_4"))
self.pushButton_4 = QtGui.QPushButton(self.tab_4)
self.pushButton_4.setGeometry(QtCore.QRect(140, 40, 111, 51))
self.pushButton_4.setObjectName(_fromUtf8("pushButton_4"))
self.label_2 = QtGui.QLabel(self.tab_4)
self.label_2.setGeometry(QtCore.QRect(170, 110, 111, 21))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.label_2.setFont(font)
self.label_2.setText(_fromUtf8(""))
self.label_2.setObjectName(_fromUtf8("label_2"))
self.tabWidget.addTab(self.tab_4, _fromUtf8(""))
ui.lineEdit.setText("smtp.gmail.com") # change another services
ui.lineEdit_2.setText("587") # change another your service port
ui.lineEdit_3.setText("") # your mail
ui.lineEdit_4.setText("") # your password
ui.lineEdit_5.setText("") # sender
ui.lineEdit_6.setText("") # receiver
ui.lineEdit_7.setText("") # mail subject
self.worker = Worker()
self.retranslateUi(Form)
self.tabWidget.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(Form)
######################### Button Event ##############################
QtCore.QObject.connect(self.pushButton,
QtCore.SIGNAL(_fromUtf8("clicked()")),
self.worker.authenticate)
QtCore.QObject.connect(self.pushButton_2,
QtCore.SIGNAL(_fromUtf8("clicked()")),
self.worker.selectFile)
self.pushButton_3.clicked.connect(self.view)
QtCore.QObject.connect(self.pushButton_4,
QtCore.SIGNAL(_fromUtf8("clicked()")),
self.worker.send)
self.checkBox.setChecked(True)
#####################################################################
def retranslateUi(self, Form):
Form.setWindowTitle(_translate("Form", "Python Phisher", None))
self.groupBox.setTitle(_translate("Form", "Smtp Server", None))
self.groupBox_2.setTitle(_translate("Form", "Port", None))
self.pushButton.setText(_translate("Form", "Authenticate", None))
self.radioButton.setText(_translate("Form", "start-tls", None))
self.checkBox.setText(_translate("Form", "Start Tls", None))
self.groupBox_3.setTitle(_translate("Form", "Username", None))
self.groupBox_7.setTitle(_translate("Form", "Password", None))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab),
_translate("Form", "Sending Profiles", None))
self.groupBox_4.setTitle(_translate("Form", "Sender", None))
self.groupBox_5.setTitle(_translate("Form", "Receiver", None))
self.groupBox_6.setTitle(_translate("Form", "Subject", None))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2),
_translate("Form", "E-Mail Tampletes", None))
self.pushButton_2.setToolTip(
_translate("Form", "<html><head/><body><p><br/></p></body></html>",
None))
self.pushButton_2.setText(_translate("Form", "Select File", None))
self.pushButton_3.setText(_translate("Form", "View", None))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_3),
_translate("Form", "Html File Upload", None))
self.pushButton_4.setText(_translate("Form", "Start", None))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_4),
_translate("Form", "Start", None))
import model as md
from view import QtCore, QtWidgets, Ui_MainWindow
from controller import ViewController
import controller
import sys
app = QtCore.QCoreApplication.instance()
if app is None:
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
user_ML_model = md.MlModel()
view_controller = ViewController(ui, user_ML_model)
MainWindow.show()
sys.exit(app.exec_())
class View(QtGui.QMainWindow):
def __init__(self):
super(View, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
validator = QtGui.QIntValidator(0, 150)
self.ui.age_from.setValidator(validator)
self.ui.age_to.setValidator(validator)
self.db = None
self.model = None
self.open_database()
doc_query = QtSql.QSqlQuery()
doc_query.exec_(get_document_types_query())
self.document_type = {}
while doc_query.next():
qs = unicode(doc_query.value(0).toString())
self.document_type[qs] = doc_query.value(1).toString()
self.ui.document_type.addItem(qs)
self.ui.document_type.setCurrentIndex(-1)
self.ui.age_from.textChanged.connect(lambda: update_date_to(
self))
self.ui.age_to.textChanged.connect(lambda: update_date_from(
self))
self.connect(self.ui.query_button, QtCore.SIGNAL("clicked()"),
self.query_on_button_click)
self._filter_from = DateFromFilter()
self._filter_to = DateToFilter()
self.ui.birth_date_from.installEventFilter(self._filter_from)
self.ui.birth_date_to.installEventFilter(self._filter_to)
def _get_fields_values(self):
return (
self.ui.last_name.text(),
self.ui.first_name.text(),
self.ui.patr_name.text(),
self._get_document_type(self.ui.document_type),
self._prepare_serial(self.ui.document_serial.text()),
self.ui.document_number.text(),
self.ui.sex.currentText(),
self._get_date(self.ui.birth_date_from),
self._get_date(self.ui.birth_date_to),
self.ui.age_from.text(),
self.ui.age_to.text(),
self.ui.snils_number.text()
)
def _get_date(self, form_object):
if isinstance(form_object, QtGui.QDateEdit):
return form_object.date().toString('yyyy-MM-dd')
try:
return form_object.text()
except:
return ""
def _get_document_type(self, form_object):
if isinstance(form_object, QtGui.QComboBox):
try:
return self.document_type[unicode(form_object.currentText())]
except:
return ""
try:
return form_object.text()
except:
return ""
def _prepare_serial(self, serial):
without_spaces = unicode(serial).replace(" ", "")
if len(without_spaces) < 2:
return without_spaces
return without_spaces[:2] + " " + without_spaces[2:]
@QtCore.pyqtSlot()
def query_on_button_click(self):
query = generate_query(*list(unicode(value)
for value in self._get_fields_values()))
self.model.setQuery(query)
self.ui.response_table.resizeColumnsToContents()
# with open('queries.log', "a") as logfile:
# logfile.write(str(QtCore.QDate.currentDate().toString)+"\n")
# logfile.write(query+"\n")
def create_db_connection(self):
db = QtSql.QSqlDatabase.addDatabase(config.DATABASE_DRIVER)
db.setDatabaseName(config.DATABASE_NAME)
db.setHostName(config.DATABASE_HOST)
db.setPort(config.DATABASE_PORT)
db.setUserName(config.DATABASE_USER)
db.setPassword(config.DATABASE_PASSWORD)
if not db.open():
sys.stderr.write(
"Error connecting to database %s. Program is terminated\n" %
config.DATABASE_NAME)
sys.exit(1)
return db
def open_database(self):
if self.db:
self.close_database()
self.db = self.create_db_connection()
self.model = QtSql.QSqlQueryModel()
self.ui.response_table.setModel(self.model)
def close_database(self):
self.ui.response_table.setModel(None)
del self.model
self.db.close()
del self.db
QtSql.QSqlDatabase.removeDatabase(config.DATABASE_NAME)
def closeEvent(self, event):
self.close_database()
class Controller(QMainWindow):
"""
Controller for the program, adding events to the ui
"""
def __init__(self, parent=None):
"""
Initializes Controller and connects the logic with the UI
:param parent: Parent window for UI
"""
super().__init__(parent)
self.myForm = Ui_MainWindow()
self.myForm.setupUi(self)
self.myForm.pushButton.clicked.connect(self.start_game)
self.myForm.b1.clicked.connect(self.restart_game)
self.logic = GameLogic(self)
def start_game(self):
"""
Initializes the game window content and generates mines on the logic component
:return: none
"""
x, y = self.myForm.get_x_y()
self.myForm.teardown_menu()
self.myForm.setupMines(x, y)
for row in self.myForm.mines:
for item in row:
item.leftclick_handler = self.logic.leftclick_button
item.rightclick_handler = self.logic.rightclick_button
self.logic.generate_mines(x, y)
self.logic.generate_mine_numbers(x, y)
def restart_game(self):
"""
Restarts the game by tearing down the UI, show restart game window and resets the logic
:return: none
"""
self.myForm.teardown_game()
self.myForm.showStart()
self.logic.restart_game()
self.myForm.pushButton.clicked.connect(self.start_game)
self.myForm.d.close()
def has_won(self):
"""
Handles the has_won event, when triggered locks all fields and shows win window
:return: none
"""
x, y = self.myForm.get_x_y()
for y_pos in range(y):
for x_pos in range(x):
self.set_button_text(x_pos, y_pos)
self.myForm.disableButton(x_pos, y_pos)
self.myForm.showWinRestart()
def end_game(self, button):
"""
Triggered when a mine is hit. Locks all fields and sets mine to red
:param button: button from which the event is triggered
:return: none
"""
x, y = self.myForm.get_x_y()
for y_pos in range(y):
for x_pos in range(x):
self.set_button_text(x_pos, y_pos)
self.myForm.disableButton(x_pos, y_pos)
button.setStyleSheet("""
QPushButton { background-color: red }
""")
self.myForm.showRestart()
def set_button_text(self, x, y):
"""
Merges data from logic component into the UI component on coordinate
:param x: coordinate
:param y: coordinate
:return: none
"""
self.myForm.mines[y][x].setText(str(self.logic.get_field_text(x, y)))
def __init__(self):
QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
self.setupUi(self)
class Controller(QtGui.QMainWindow):
def __init__(self, parent=None):
super().__init__(parent)
self.undoStack = QUndoStack()
self.view = Ui_MainWindow()
self.view.setupUi(self)
self.view.tableView.setSortingEnabled(True)
self.view.tableView.setItemDelegate(ItemDelegate(self.undoStack, self.set_undo_redo_text))
self.filename = None
self.table_model = CSVTableModel(datalist=[], header=[], parent=self)
self.connect_elements()
try:
self.db = DBAccess(DBConfig.database, DBConfig.username, DBConfig.password, DBConfig.wahltermin)
except Exception as e:
print(e)
Message.error("Database Error", "Error while trying to establish a database connection.")
def show_window(self):
self.show()
self.raise_()
def connect_elements(self):
self.view.actionNew.triggered.connect(self.new)
self.view.actionOpen.triggered.connect(self.open)
self.view.actionSave.triggered.connect(self.save)
self.view.actionSave_As.triggered.connect(self.save_as)
self.view.actionAdd_Row.triggered.connect(self.add_rows)
self.view.actionRemove_Row_s.triggered.connect(self.remove_rows)
self.view.actionWrite.triggered.connect(self.write)
self.view.actionLoad.triggered.connect(self.load)
self.view.actionUndo.triggered.connect(self.undo)
self.view.actionRedo.triggered.connect(self.redo)
self.view.actionCopy.triggered.connect(self.copy)
self.view.actionPaste.triggered.connect(self.paste)
self.view.actionDuplicate_Row.triggered.connect(self.duplicate)
self.view.actionCut.triggered.connect(self.cut)
self.view.actionShow_Results.triggered.connect(self.show_results)
def set_undo_redo_text(self):
undo = "Undo"
redo = "Redo"
undo_text = self.undoStack.undoText()
redo_text = self.undoStack.redoText()
if undo_text:
undo += " \"" + undo_text + "\""
if redo_text:
redo += " \"" + redo_text + "\""
self.view.actionUndo.setText(undo)
self.view.actionRedo.setText(redo)
def show_results(self):
# try:
datalist, header = self.db.create_results()
ResultsController(datalist, header, "Hochrechnungsergebnis")
"""
except Exception as e:
print(e)
Message.error("Database Error", "Error while accessing the database. Perhaps the schema in the database "
"does not match the ddl-script.")
"""
def duplicate(self):
if len(self.view.tableView.selectionModel().selectedIndexes()) == 0:
Message.error("Error", "You must select the first column of the row you want to duplicate")
return
start, amount = self.get_selection()
self.undoStack.beginMacro("Duplicate Row")
self.undoStack.push(DuplicateRowCommand(self.table_model, start))
self.undoStack.endMacro()
self.set_undo_redo_text()
self.view.tableView.reset()
def cut(self):
self.copy()
index = self.view.tableView.selectionModel().selectedIndexes()[0]
command = EditCommand(self.table_model, index)
command.newValue("")
self.undoStack.beginMacro("Cut")
self.undoStack.push(command)
self.undoStack.endMacro()
self.set_undo_redo_text()
self.view.tableView.reset()
def copy(self):
if len(self.view.tableView.selectionModel().selectedIndexes()) == 0:
return
clipboard = QApplication.clipboard()
selected_index = self.view.tableView.selectionModel().selectedIndexes()[0]
selected_text = str(self.table_model.data(selected_index))
clipboard.setText(selected_text)
def paste(self):
if len(self.view.tableView.selectionModel().selectedIndexes()) == 0:
return
clipboard = QApplication.clipboard()
index = self.view.tableView.selectionModel().selectedIndexes()[0]
command = EditCommand(self.table_model, index)
command.newValue(str(clipboard.text()))
self.undoStack.beginMacro("Paste")
self.undoStack.push(command)
self.undoStack.endMacro()
self.set_undo_redo_text()
self.view.tableView.reset()
def undo(self):
self.undoStack.undo()
self.set_undo_redo_text()
self.view.tableView.reset()
def redo(self):
self.undoStack.redo()
self.set_undo_redo_text()
self.view.tableView.reset()
def update_table_model(self, data, header):
self.table_model.set_list(data, header)
self.view.tableView.reset()
self.view.tableView.setModel(self.table_model)
def write(self):
if self.filename is None or len(self.table_model.get_list()) == 0:
Message.error("Writing to database not possible", "The table needs to contain of the same column headers "
"as the original 'wahl.csv'.")
return
try:
current_list = self.table_model.get_list()
self.db.write_from_csv_list(current_list)
except Exception as e:
print(e)
Message.error("Database Error", "Error while accessing the database. Perhaps the schema in the database "
"does not match the ddl-script or the required table headers (see "
"original 'wahl.csv') are not existing.")
def load(self):
try:
datalist, header = self.db.load_into_csv_list()
self.update_table_model(datalist, header)
except Exception as e:
print(e)
Message.error("Database Error", "Error while accessing the database. Perhaps the schema in the database "
"does not match the ddl-script.")
def add_rows(self):
if len(self.table_model.get_header()) == 0:
Message.error("Error", "Adding rows to an empty table without a header is not possible.")
return
start, amount = self.get_selection()
self.undoStack.beginMacro("Add Row")
self.undoStack.push(InsertRowsCommand(self.table_model, start, 1))
self.undoStack.endMacro()
self.set_undo_redo_text()
def remove_rows(self):
if len(self.table_model.get_list()) == 0:
Message.error("Error", "Removing rows from an empty table is not possible.")
return
start, amount = self.get_selection()
if start != len(self.table_model.get_list()):
self.undoStack.beginMacro("Remove Row(s)")
self.undoStack.push(RemoveRowsCommand(self.table_model, start, amount))
self.undoStack.endMacro()
self.set_undo_redo_text()
else:
Message.error("Error", "You need to choose the rows you want to remove by selecting the cells in the "
"first column")
def get_zero_column_selected_indexes(self):
selected_indexes = self.view.tableView.selectedIndexes()
if not selected_indexes:
return
return [index for index in selected_indexes if not index.column()]
def get_selection(self):
zero_column_selected_indexes = self.get_zero_column_selected_indexes()
if not zero_column_selected_indexes:
return self.table_model.rowCount(self), 1
first_zero_column_selected_index = zero_column_selected_indexes[0]
zero_column_selected_indexes = self.get_zero_column_selected_indexes()
if not first_zero_column_selected_index or not first_zero_column_selected_index.isValid():
return False
startingrow = first_zero_column_selected_index.row()
return startingrow, len(zero_column_selected_indexes)
def new(self):
self.filename = None
self.table_model.set_list([], [])
def open(self):
filename = QFileDialog.getOpenFileName(self, caption="Open CSV-File", filter="CSV-File (*.csv)")[0]
if len(filename) > 0:
self.filename = filename
datalist, header = CSV.read(self.filename)
self.update_table_model(datalist, header)
def save(self):
if self.filename is not None:
CSV.write(self.filename, self.table_model.get_list())
else:
self.save_as()
def save_as(self):
filename = QFileDialog.getSaveFileName(self, caption="Save CSV-File", dir=self.filename,
filter="CSV-File (*.csv)")[0]
if len(filename) > 0:
self.filename = filename
self.save()
class MainApp(QtWidgets.QMainWindow):
# constructor
def __init__(self):
super(MainApp, self).__init__()
self.ui = Ui_MainWindow()
self.method = None
self.methodNum = 0
self.mode = False
self.step = 0
self.all_method_order = 0 # hold which method to be selected
self.all_method = [
] # hold objects of all methods in case of this mode
self.ui.setupUi(self)
self.eps = 0.00001
self.max_iter = 50
self.x0 = 0
self.x1 = 0
self.function = ""
self.setWindowTitle("Root Finder")
self.ui.modeCombo.activated.connect(self.mode_changed)
self.ui.methodCombo.activated.connect(self.method_changed)
self.ui.solveBtn.clicked.connect(self.solve_btn_action)
self.ui.prevBtn.clicked.connect(self.prev_btn_action)
self.ui.nextBtn.clicked.connect(self.next_btn_action)
self.ui.tableButton.clicked.connect(self.show_table)
self.ui.fileSaveBtn.clicked.connect(self.save_into_file)
self.ui.fileReadBtn.clicked.connect(self.read_file)
self.table = SolutionTable()
# handle the event of selection specific mode of solution(single mode , Direct Solution)
def mode_changed(self):
self.mode = bool(self.ui.modeCombo.currentIndex())
# print(self.mode)
if not self.mode:
self.ui.nextBtn.setEnabled(False)
self.ui.prevBtn.setEnabled(False)
# handle the event of selection specific method
def method_changed(self):
self.ui.fileSaveBtn.setEnabled(False)
self.ui.tableButton.setEnabled(False)
self.methodNum = self.ui.methodCombo.currentIndex()
self.ui.solveBtn.setText("Solve")
self.ui.X0lineEdit.setEnabled(True)
self.ui.labelX0.setText("X0")
if self.methodNum == 0:
self.ui.solveBtn.setEnabled(False)
self.ui.method_name_label.setText("Select Method to solve")
return
elif self.methodNum == 3 or self.methodNum == 4 or self.methodNum == 6:
self.ui.X1lineEdit.setEnabled(False)
self.ui.labelX1.setText(" ")
self.ui.solveBtn.setEnabled(True)
elif self.methodNum == 7:
self.ui.X1lineEdit.setEnabled(False)
self.ui.labelX1.setText(" ")
self.ui.X0lineEdit.setEnabled(False)
self.ui.labelX0.setText(" ")
self.ui.solveBtn.setEnabled(True)
elif self.methodNum == 8:
self.ui.solveBtn.setText("Next method")
self.all_method_order = 1
self.ui.X1lineEdit.setEnabled(True)
self.ui.labelX1.setText("X1")
self.ui.method_name_label.setText("Bisection method")
self.ui.solveBtn.setEnabled(True)
return
else:
self.ui.X1lineEdit.setEnabled(True)
self.ui.labelX1.setText("X(1)")
self.ui.solveBtn.setEnabled(True)
self.ui.mplGraph.n2.setVisible(False)
self.ui.mplGraph.canvas2.setVisible(False)
self.ui.method_name_label.setText("")
self.all_method_order = 0
def take_method_input(self):
if self.all_method_order == 1: # bisection
self.all_method_order += 1
self.ui.method_name_label.setText("False position method")
self.all_method.append(
Bisection(self.function, self.x0, self.x1, self.eps,
self.max_iter))
elif self.all_method_order == 2: # false position
self.all_method_order += 1
self.ui.method_name_label.setText("Fixed Point method")
self.all_method.append(
FalsePosition(self.function, self.x0, self.x1, self.eps,
self.max_iter))
self.ui.X1lineEdit.setEnabled(False)
self.ui.labelX1.setText(" ")
elif self.all_method_order == 3: # Fixed Point
self.all_method_order += 1
self.ui.method_name_label.setText("Newton method")
self.all_method.append(
FixedPoint(self.function, self.x0, self.eps, self.max_iter))
self.ui.X1lineEdit.setEnabled(False)
self.ui.labelX1.setText(" ")
elif self.all_method_order == 4: # Newton
self.all_method_order += 1
self.ui.method_name_label.setText("Secant method")
self.all_method.append(
newton(self.function, self.x0, self.eps, self.max_iter))
self.ui.X1lineEdit.setEnabled(True)
self.ui.labelX1.setText("X1")
elif self.all_method_order == 5: # Secant
self.all_method_order += 1
self.ui.method_name_label.setText("Birge Vieta method")
self.ui.solveBtn.setText("Solve")
self.all_method.append(
Secant(self.function, self.x0, self.x1, self.eps,
self.max_iter))
self.ui.X1lineEdit.setEnabled(False)
self.ui.labelX1.setText(" ")
elif self.all_method_order == 6: # Birge VIeta
self.all_method_order += 1
self.all_method.append(
BirgeVieta(self.function, self.x0, self.eps, self.max_iter))
self.ui.X0lineEdit.setText("")
self.ui.X1lineEdit.setText("")
def excute_all_method(self):
self.ui.mplGraph.canvas2.ax.clear()
self.ui.mplGraph.canvas.ax.clear()
print("enterd")
print(len(self.all_method))
self.ui.mplGraph.n2.setVisible(True)
self.ui.mplGraph.canvas2.setVisible(True)
for i in range(len(self.all_method)):
if i == 2 and not self.all_method[i].is_converge():
continue
print("before calculate")
self.all_method[i].calculate()
print("calculte :" + self.all_method[i].method_name())
x_axis = [
c
for c in range(1, self.all_method[i].get_taken_iteration() + 1)
]
print(self.all_method[i].get_taken_iteration())
print(len(self.all_method[i].get_all_roots()))
print(self.all_method[i].method_name())
self.ui.mplGraph.canvas.ax.plot(
x_axis,
self.all_method[i].get_all_roots(),
label=self.all_method[i].method_name())
self.ui.mplGraph.canvas2.ax.plot(
x_axis,
self.all_method[i].get_all_errors(),
label=self.all_method[i].method_name())
print("ploted :" + self.all_method[i].method_name())
print("exit")
self.ui.mplGraph.canvas2.ax.legend()
self.ui.mplGraph.canvas2.ax.figure.canvas.draw()
self.ui.mplGraph.canvas.ax.legend()
self.ui.mplGraph.canvas.ax.figure.canvas.draw()
return
def validate_input(self, method_num):
self.function = self.ui.functionLineEdit.text()
flagx1 = True
if self.function == "":
return False
# take value of initial point if exist
print("function : ", self.function)
flag_x0 = True
try:
self.x0 = float(self.ui.X0lineEdit.text())
# print(x0)
except:
flag_x0 = False
if not flag_x0 and method_num != 7:
return
print("x0 : ", self.x0)
# take value of second point if exict
try:
self.x1 = float(self.ui.X1lineEdit.text())
# print(x1)
except:
flagx1 = False
if (method_num == 1 or method_num == 2
or method_num == 5) and not flagx1:
print(self.methodNum)
return False
print("x1 : ", self.x1)
# take value of eps
try:
self.eps = float(self.ui.EpslineEdit.text())
except:
self.eps = 0.00001
# take value of max iteration
try:
self.max_iter = float(self.ui.iterlineEdit.text())
except:
self.max_iter = 50
print("eps : ", self.eps)
return True
# handle the event of solve button
def solve_btn_action(self):
if self.all_method_order == 6:
print("valid :", self.all_method_order)
if not self.validate_input(self.all_method_order):
return
self.take_method_input()
self.excute_all_method()
return
elif self.all_method_order > 0:
if not self.validate_input(self.all_method_order):
return
print("valid :", self.all_method_order)
self.take_method_input()
return
if not self.validate_input(self.methodNum):
return
self.ui.mplGraph.n2.setVisible(False)
self.ui.mplGraph.canvas2.setVisible(False)
if self.methodNum == 1: # Bisection
self.method = Bisection(self.function, self.x0, self.x1, self.eps,
self.max_iter)
flag = self.method.calculate()
if not flag:
self.ui.solutionText.setText(
"Bisection method fails \ninterval is invalid \n select interval that contains odd number of roots"
)
return
print("bisection")
elif self.methodNum == 2: # False Position
self.method = FalsePosition(self.function, self.x0, self.x1,
self.eps, self.max_iter)
flag = self.method.calculate()
if not flag:
self.ui.solutionText.setText(
"False Position method fails \ninterval is invalid \n select interval that contains odd number of roots"
)
return
print("FalsePosition")
elif self.methodNum == 3:
self.method = FixedPoint(self.function, self.x0, self.eps,
self.max_iter)
if not self.method.is_converge():
self.method.plot(self.ui.mplGraph.canvas)
self.ui.solutionText.setText(
"\n\n Fixed Point iteration wiil diverge for this function under this initial point "
+ "\n, you can try another point or another method")
return
self.method.calculate()
elif self.methodNum == 4:
self.method = newton(self.function, self.x0, self.eps,
self.max_iter)
flag = self.method.calculate()
if not flag:
self.ui.solutionText.setText(
"Newton method fails \n\n method will converge for this function and this initial point"
)
return
print("Newton")
elif self.methodNum == 5:
self.method = Secant(self.function, self.x0, self.x1, self.eps,
self.max_iter)
self.method.calculate()
elif self.methodNum == 6:
self.method = BirgeVieta(self.function, self.x0, self.eps,
self.max_iter)
self.method.calculate()
elif self.methodNum == 7:
self.method = General(self.function, self.eps, self.max_iter)
self.method.calculate()
print("calculated", self.method.get_taken_iteration())
self.ui.tableButton.setEnabled(True)
self.ui.fileSaveBtn.setEnabled(True)
if self.mode:
self.single_mode()
else:
self.direct_solution_mode()
# actions performed in case of direct solution display
def direct_solution_mode(self):
print("before plotted")
self.method.plot(self.ui.mplGraph.canvas)
print("plotted")
text = "\tSolution\n\n" + " estimate Root = " + str(
self.method.get_root()) + "\n\n" + " absolute Error = "
text += str(
self.method.get_error()) + "\n\n" + " # Iterations = " + str(
self.method.get_taken_iteration()) + "\n\n" + "Time : " + str(
self.method.get_time()) + "\n"
self.ui.solutionText.setText(text)
# actions performed in case of direct solution display
def single_mode(self):
self.ui.nextBtn.setEnabled(True)
self.one_iteration()
self.step += 1
self.ui.prevBtn.setEnabled(True)
# handle the event of next button
def next_btn_action(self):
self.one_iteration()
# print("iteration : " + self.method.get_taken_iteration())
self.step += 1
if self.step >= self.method.get_taken_iteration():
self.ui.nextBtn.setEnabled(False)
else:
self.ui.prevBtn.setEnabled(True)
# handle the event of prev button
def prev_btn_action(self):
self.step -= 1
self.one_iteration()
if self.step == 0:
self.ui.prevBtn.setEnabled(False)
else:
self.ui.nextBtn.setEnabled(True)
def one_iteration(self):
text = self.method.perform_iteration(self.ui.mplGraph.canvas,
self.step)
self.ui.solutionText.setText(text)
def show_table(self):
self.table.fill_table(self.method)
self.table.show()
# enable saving results into file
def save_into_file(self):
options = QtWidgets.QFileDialog.Options()
options |= QtWidgets.QFileDialog.DontUseNativeDialog
filename = QtWidgets.QFileDialog.getOpenFileName(
self,
'QFileDialog.getSaveFileName()',
'/home',
"text Files (*.txt)",
options=options)
print(filename)
if filename[0]:
print(filename[0])
self.method.write_into_file(filename[0])
# handle read input from file
def read_file(self):
options = QtWidgets.QFileDialog.Options()
options |= QtWidgets.QFileDialog.DontUseNativeDialog
filename = QtWidgets.QFileDialog.getOpenFileName(
self,
'QFileDialog.getOpenFileName',
'/home',
"text Files (*.txt)",
options=options)
print(filename)
if filename[0]:
print(filename[0])
f = open(filename[0], 'r')
print(f)
# first line --->equation
self.ui.functionLineEdit.setText(f.readline())
# ----------------------------------
# second line ---> method name
method_name = f.readline().lower().capitalize()
print(method_name)
index = self.ui.modeCombo.findText(method_name,
QtCore.Qt.MatchFixedString)
print(index)
if index > 0:
self.ui.modeCombo.setCurrentIndex(index)
self.method_changed()
else:
self.ui.modeCombo.setCurrentIndex(0)
self.method_changed()
# ----------------------------------
# third line ---> parameters
par = f.readline().split(" ")
if len(par) == 2:
self.ui.X0lineEdit.setText(par[0])
self.ui.X1lineEdit.setText(par[1])
elif len(par) == 1:
self.ui.X0lineEdit.setText(par[0])
# ---------------------------------
# forth line ---> eps or max iteration
num = f.readline()
try:
number = int(num)
self.ui.iterlineEdit.setText(num)
except:
self.ui.EpslineEdit.setText(num)
f.close()
class WahlAnalyse(QMainWindow):
def __init__(self, parent=None):
super().__init__(parent)
self.undoStack = QUndoStack()
self.db = DBConnection("172.16.6.137", "root", "password", "wahl")
self.gui = Ui_MainWindow()
self.gui.setupUi(self)
self.gui.actionOpen.triggered.connect(self.open_file)
self.gui.actionSave.triggered.connect(self.save_file)
self.gui.actionSave_as.triggered.connect(self.save_file_as)
self.gui.actionNew.triggered.connect(self.new_file)
self.gui.actionCopy.triggered.connect(self.copy_cs)
self.gui.actionAdd_Row.triggered.connect(self.add_rows)
self.gui.actionSave_DB.triggered.connect(self.open_save_db)
self.gui.actionOpen_DB.triggered.connect(self.open_load_db)
self.gui.actionPaste.triggered.connect(self.paste)
self.gui.actionCut.triggered.connect(self.cut)
self.gui.actionDelete_Row.triggered.connect(self.remove_rows)
self.gui.actionDuplicate_Row.triggered.connect(self.duplicate)
self.gui.actionUndo.triggered.connect(self.undo)
self.gui.actionRedo.triggered.connect(self.redo)
self.gui.actionCreate_Prediction.triggered.connect(self.open_create_pred)
self.gui.actionShow_Prediction.triggered.connect(self.open_choose_pred)
self.gui.tableView.setSortingEnabled(True)
self.gui.tableView.setItemDelegate(ItemDelegate(self.undoStack, self.set_unrdo_text))
self.tbm = DictTableModel(data=[], header=[], parent=self)
self.sdb_dialog = SaveToDBDialog(self)
self.ldb_dialog = LoadFromDBDialog(self)
self.create_pred_dialog = CreatePredDialog(self)
self.choose_pred_dialog = ChoosePredDialog(self)
self.show_pred_dialog = ShowPredDialog(self)
self.file = "."
def open_file(self):
self.file = QFileDialog.getOpenFileName(self, "Choose File", filter="CSV-File (*.csv)")[0]
if self.file != '':
data, header = CSVUtil.read(self.file)
self.tbm.set_data(data, header)
self.gui.tableView.reset()
self.gui.tableView.setModel(self.tbm)
def save_file(self):
if self.file != '' and self.file is not None:
CSVUtil.write(self.file, self.tbm.get_data())
def save_file_as(self):
self.file = QFileDialog.getSaveFileName(self, "CSV-Datei speichern", dir=self.file, filter="CSV-Datei (*.csv)")[
0]
if self.file != '':
self.save_file()
def new_file(self):
self.file = "."
self.tbm.set_data([], [])
self.gui.tableView.reset()
self.gui.tableView.setModel(self.tbm)
self.undoStack.clear()
self.set_unrdo_text()
def copy_cs(self):
if len(self.gui.tableView.selectionModel().selectedIndexes()) == 0:
return
clipboard = QApplication.clipboard()
selected_index = self.gui.tableView.selectionModel().selectedIndexes()[0]
selected_text = str(self.tbm.data(selected_index))
clipboard.setText(selected_text)
def save_data_db(self, date):
self.db.write_data(self.tbm.get_data(), date)
def load_data_db(self, date):
data, header = self.db.read_data(date)
self.tbm.set_data(data, header)
self.gui.tableView.reset()
self.gui.tableView.setModel(self.tbm)
self.undoStack.clear()
self.set_unrdo_text()
def create_prediction(self, termin, time):
self.db.create_prediction(termin, time)
def open_save_db(self):
self.setDisabled(True)
self.sdb_dialog.setEnabled(True)
self.sdb_dialog.show()
def open_load_db(self):
self.ldb_dialog.update_dates(self.db.get_termine())
self.setDisabled(True)
self.ldb_dialog.setEnabled(True)
self.ldb_dialog.show()
def open_create_pred(self):
self.create_pred_dialog.update_dates(self.db.get_termine())
self.setDisabled(True)
self.create_pred_dialog.setEnabled(True)
self.create_pred_dialog.show()
def open_choose_pred(self):
self.choose_pred_dialog.update_predictions(self.db.get_predictions())
self.setDisabled(True)
self.choose_pred_dialog.setEnabled(True)
self.choose_pred_dialog.show()
def show_prediction(self, date, time):
data, header = self.db.get_prediction_data(date, time)
self.show_pred_dialog.update_prediction(data, header, date, time)
self.setDisabled(True)
self.show_pred_dialog.setEnabled(True)
self.show_pred_dialog.show()
def set_unrdo_text(self):
undo = "Undo"
redo = "Redo"
undo_txt = self.undoStack.undoText()
redo_txt = self.undoStack.redoText()
if undo_txt:
undo += " \"" + undo_txt + "\""
if redo_txt:
redo += " \"" + redo_txt + "\""
self.gui.actionUndo.setText(undo)
self.gui.actionRedo.setText(redo)
def get_sel_indexes(self):
sel_indexes = self.gui.tableView.selectedIndexes()
if sel_indexes:
return [index for index in sel_indexes if not index.column()]
def get_sel(self):
sel_indexes = self.get_sel_indexes()
if not sel_indexes:
return self.tbm.rowCount(self), 1
first_sel_index = sel_indexes[0]
sel_indexes = self.get_sel_indexes()
if not first_sel_index or not first_sel_index.isValid():
return False
startingrow = first_sel_index.row()
return startingrow, len(sel_indexes)
def remove_rows(self):
if len(self.tbm.get_data()) == 0:
return
start, amount = self.get_sel()
if start != len(self.tbm.get_data()):
self.undoStack.beginMacro("Remove Rows")
self.undoStack.push(RemoveRowsCommand(self.tbm, start, amount))
self.undoStack.endMacro()
self.set_unrdo_text()
def add_rows(self):
if len(self.tbm.get_header()) == 0:
return
start, amount = self.get_sel()
self.undoStack.beginMacro("Add Row")
self.undoStack.push(InsertRowsCommand(self.tbm, start, 1))
self.undoStack.endMacro()
self.set_unrdo_text()
def paste(self):
if len(self.gui.tableView.selectionModel().selectedIndexes()) == 0:
return
clipboard = QApplication.clipboard()
index = self.gui.tableView.selectionModel().selectedIndexes()[0]
command = EditCommand(self.tbm, index)
command.newVal(str(clipboard.text()))
self.undoStack.beginMacro("Paste")
self.undoStack.push(command)
self.undoStack.endMacro()
self.set_unrdo_text()
self.gui.tableView.reset()
def cut(self):
self.copy()
index = self.gui.tableView.selectionModel().selectedIndexes()[0]
command = EditCommand(self.tbm, index)
command.newVal("")
self.undoStack.beginMacro("Cut")
self.undoStack.push(command)
self.undoStack.endMacro()
self.set_unrdo_text()
self.gui.tableView.reset()
def duplicate(self):
if len(self.gui.tableView.selectionModel().selectedIndexes()) == 0:
return
start, amount = self.get_sel()
self.undoStack.beginMacro("Duplicate Row")
self.undoStack.push(DuplicateRowCommand(self.tbm, start))
self.undoStack.endMacro()
self.set_unrdo_text()
self.gui.tableView.reset()
def undo(self):
self.undoStack.undo()
self.set_unrdo_text()
self.gui.tableView.reset()
def redo(self):
self.undoStack.redo()
self.set_unrdo_text()
self.gui.tableView.reset()
class Main(QtWidgets.QMainWindow):
def __init__(self,parent=None):
super(Main, self).__init__(parent=parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.modeGroup = QButtonGroup()
self.modeGroup.addButton(self.ui.filterRecord)
self.modeGroup.addButton(self.ui.plotGraph)
self.ui.allRecordsCB.clicked.connect(self.allRecordsCBMode)
self.ui.filterRecord.clicked.connect(self.onClickedMode)
self.ui.plotGraph.clicked.connect(self.onClickedMode)
self.ui.submitBtn.clicked.connect(self.execute)
self.initialiseDefaultOptions()
# Default UI initialisation calls
self.setComboBoxes()
self.initialiseTable()
def onClickedMode(self):
global choice
radioBtn = self.sender()
if radioBtn.isChecked():
if radioBtn.text() == "Filter Records":
choice = "filterRecord"
self.ui.analysisOverSpin.setEnabled(False)
self.ui.filterBySpin.setEnabled(True)
elif radioBtn.text() == "Plot a Graph":
choice = "plotGraph"
self.ui.filterBySpin.setEnabled(False)
self.ui.analysisOverSpin.setEnabled(True)
def initialiseDefaultOptions(self):
self.ui.allRecordsCB.setChecked(True)
self.ui.startDateEdit.setEnabled(False)
self.ui.endDateEdit.setEnabled(False)
self.ui.filterRecord.setChecked(True)
self.ui.analysisOverSpin.setEnabled(False)
def allRecordsCBMode(self):
global allRecords
if self.ui.allRecordsCB.isChecked():
allRecords = True
self.ui.startDateEdit.setEnabled(False)
self.ui.endDateEdit.setEnabled(False)
else:
allRecords = False
self.ui.startDateEdit.setEnabled(True)
self.ui.endDateEdit.setEnabled(True)
def setComboBoxes(self):
filter_by = ['All Penalty Cases','Camera or Radar Cases','Mobile Phone Cases']
analysis_over = ['Distribution of Cases per offence code','Mobile phone usage over time','Mobile phone usage over Offence code','Distribution of Cases per Speed Band']
# Initialise FilterBy Drop Down
for item in filter_by:
self.ui.filterBySpin.addItem(item)
# Initialise Analysys Over Drop Down
for item in analysis_over:
self.ui.analysisOverSpin.addItem(item)
def initialiseTable(self):
df = ds.getAllData()
model = ds.getModel(df)
self.ui.table.setModel(model)
def filterDateWiseRecords(self):
model = ds.dateFilter(start_date='1/3/2012',end_date='1/5/2012') #working
self.ui.table.setModel(model)
def execute(self):
global allRecords,filterBySpinOptions
df = ds.getAllData()
if self.ui.filterRecord.isChecked():
if self.ui.allRecordsCB.isChecked():
df = ds.getAllData()
pass
else:
start_date = datetime.datetime.strftime(self.ui.startDateEdit.date().toPyDate(),'%d/%m/%Y')
end_date = datetime.datetime.strftime(self.ui.endDateEdit.date().toPyDate(),'%d/%m/%Y')
df = ds.dateFilter(start_date,end_date,df)
df = ds.filterBy(filterBySpinOptions[self.ui.filterBySpin.currentIndex()],df)
self.ui.table.setModel(ds.getModel(df))
if self.ui.plotGraph.isChecked():
if self.ui.allRecordsCB.isChecked():
df = ds.getAllData()
pass
else:
start_date = datetime.datetime.strftime(self.ui.startDateEdit.date().toPyDate(),'%d/%m/%Y')
end_date = datetime.datetime.strftime(self.ui.endDateEdit.date().toPyDate(),'%d/%m/%Y')
df = ds.dateFilter(start_date,end_date,df)
anlSpinInd = self.ui.analysisOverSpin.currentIndex()
if anlSpinInd == 0:
self.piePlot(df['OFFENCE_CODE'].value_counts().to_dict())
elif anlSpinInd == 1:
df = ds.filterBy(['mobile'],df)
self.linePlot(df['OFFENCE_FINYEAR'].value_counts().to_dict())
elif anlSpinInd == 2:
df = ds.filterBy(['mobile'],df)
self.piePlot(df['OFFENCE_CODE'].value_counts().to_dict())
elif anlSpinInd == 3:
self.piePlot(df['SPEED_BAND'].value_counts().to_dict())
# print(df['OFFENCE_CODE'].value_counts().to_dict())
# print(sum(list(df['OFFENCE_CODE'].value_counts().to_dict())))
def piePlot(self,dict):
print(dict)
keys = list(dict.keys())
values = list(dict.values())
total = sum(values)
othersValue = sum(values[10:])
keys = keys[:11]
values = values[:11]
keys.append("Others")
values.append(othersValue)
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
# ax.set_title(self.ui.analysisOverSpin.currentText(),bbox={'facecolor':'0.8', 'pad':3})
ax.axis('equal')
ax.pie(values, labels = keys,autopct='%1.2f%%')
plt.title(self.ui.analysisOverSpin.currentText())
plt.legend(keys,loc="upper right")
# plt.get_current_fig_manager().
plt.show()
def linePlot(self,dict):
dict = collections.OrderedDict(sorted(dict.items()))
keys = list(dict.keys())
values = list(dict.values())
print(keys)
plt.scatter(keys, values, color= "green", marker= "*", s=30)
plt.xlabel('Financial Year')
plt.ylabel('Cases')
plt.title(self.ui.analysisOverSpin.currentText())
plt.legend()
plt.show()
