Exemple #1
0
class Window(QtWidgets.QWidget):
    """
    zmiana nagłówka działa tylko dla stylu fusion, działa tylko dla stylu 'fusion"
    """
    def __init__(self):
        super(Window, self).__init__()

        self.table = QTableView()
        self.sti = QStandardItemModel()
        self.sti.setColumnCount(3)
        self.table.setModel(self.sti)

        self.sti.setRowCount(8)

        #piersza możliwośc przez QStandardItem
        # item1 = QStandardItem('Red')
        # item1.setBackground(QBrush(Qt.red))
        # self.sti.setHorizontalHeaderItem(1, item1)

        #Druga możliwosć przez odwołanie modelu:
        self.table.model().setHeaderData(0, Qt.Horizontal,
                                         QBrush(QColor(121, 166, 210)),
                                         Qt.BackgroundRole)
        self.table.model().setHeaderData(0, Qt.Horizontal, "One",
                                         Qt.DisplayRole)

        self.mlayout = QHBoxLayout()
        self.mlayout.addWidget(self.table)

        self.setLayout(self.mlayout)

    def contextMenuEvent(self, event):
        contextMenu = QMenu(self)

        newAction = contextMenu.addAction("New")
        openAction = contextMenu.addAction("Open")
        quitAction = contextMenu.addAction("Quit")

        action = contextMenu.exec_(self.mapToGlobal(event.pos()))

        if action == quitAction:
            self.close()

        if action == openAction:
            # model = self.sti
            # indices = self.table.selectionModel().selectedRows()
            # for index in sorted(indices):
            #     model.removeRow(index.row())
            index_list = []
            for model_index in self.table.selectionModel().selectedRows():
                index = QtCore.QPersistentModelIndex(model_index)
                index_list.append(index)

            for index in index_list:
                self.sti.removeRow(index.row())
Exemple #2
0
    def table_insert(self, TableModel: TableModel,
                     TableView: QtWidgets.QTableView):
        print('Inserting a row into table.')
        # get selected row index
        selected_indexes = TableView.selectionModel().selectedIndexes()
        selected_row_index = selected_indexes[-1].row()
        print(f'row index {selected_row_index}.')
        # insert
        TableModel.insertRow(selected_row_index)

        print(TableView == self.ui.tableView_emitters)
        TableView.model().layoutChanged.emit()
        TableView.resizeRowsToContents()
        self.repaint()
    def testReferenceCounting(self):
        '''Tests reference count of model object referred by view objects.'''
        model1 = TestModel()
        refcount1 = getrefcount(model1)
        view1 = QTableView()
        view1.setModel(model1)
        self.assertEqual(getrefcount(view1.model()), refcount1 + 1)

        view2 = QTableView()
        view2.setModel(model1)
        self.assertEqual(getrefcount(view2.model()), refcount1 + 2)

        model2 = TestModel()
        view2.setModel(model2)
        self.assertEqual(getrefcount(view1.model()), refcount1 + 1)
    def testReferenceCounting(self):
        '''Tests reference count of model object referred by view objects.'''
        model1 = TestModel()
        refcount1 = getrefcount(model1)
        view1 = QTableView()
        view1.setModel(model1)
        self.assertEqual(getrefcount(view1.model()), refcount1 + 1)

        view2 = QTableView()
        view2.setModel(model1)
        self.assertEqual(getrefcount(view2.model()), refcount1 + 2)

        model2 = TestModel()
        view2.setModel(model2)
        self.assertEqual(getrefcount(view1.model()), refcount1 + 1)
Exemple #5
0
    def table_remove(self, TableModel: TableModel,
                     TableView: QtWidgets.QTableView):
        if TableModel.rowCount(TableView) <= 1:
            raise ValueError('Not enough rows to delete.')

        # get selected row index
        selected_indexes = TableView.selectionModel().selectedIndexes()
        if len(selected_indexes) > 1:
            selected_row_index = selected_indexes[-1].row()
        else:
            selected_row_index = selected_indexes[0].row()
        # remove
        TableModel.removeRow(selected_row_index)
        TableView.model().layoutChanged.emit()
        TableView.resizeRowsToContents()
        self.repaint()
Exemple #6
0
class DataframeView(QWidget):
    def __init__(self, parent: QWidget = None):
        super().__init__(parent)
        layout = QVBoxLayout(self)
        self.inputCB = QComboBox(self)
        self.dataView = QTableView(self)
        layout.addWidget(self.inputCB)
        layout.addWidget(self.dataView)
        self._workbench: WorkbenchModel = None

    def setWorkbench(self, w: WorkbenchModel) -> None:
        self.inputCB.setModel(w)
        self._workbench = w
        self.inputCB.currentTextChanged.connect(self.setDataframe)

    @Slot(str)
    def setDataframe(self, name: str) -> None:
        if not self.dataView.model():
            self.dataView.setModel(IncrementalRenderFrameModel(parent=self))
            self.dataView.horizontalScrollBar().valueChanged.connect(self.onHorizontalScroll)
            self.dataView.verticalScrollBar().valueChanged.connect(self.onVerticalScroll)
        # Get frame model and set it in the table
        frameModel = self._workbench.getDataframeModelByName(name)
        self.dataView.model().setSourceModel(frameModel)

    @Slot(int)
    def onVerticalScroll(self, *_) -> None:
        self.dataView.model().setScrollMode('row')

    @Slot(int)
    def onHorizontalScroll(self, *_) -> None:
        self.dataView.model().setScrollMode('column')
 def testReferreedObjectSurvivalAfterContextEnd(self):
     '''Model object assigned to a view object must survive after getting out of context.'''
     def createModelAndSetToView(view):
         model = TestModel()
         model.setObjectName('created model')
         view.setModel(model)
     view = QTableView()
     createModelAndSetToView(view)
     model = view.model()
 def testReferreedObjectSurvivalAfterContextEnd(self):
     '''Model object assigned to a view object must survive after getting out of context.'''
     def createModelAndSetToView(view):
         model = TestModel()
         model.setObjectName('created model')
         view.setModel(model)
     view = QTableView()
     createModelAndSetToView(view)
     model = view.model()
Exemple #9
0
    def _saveTableAsCsv(self, table: QTableView, title: str):
        """
        Saves given table to csv.
        
        :param table: Table you want to save.
        :type table: QTableView
        :param title: Title for file selection window.
        :type title: str
        """

        #get model
        if table.model():
            #let user choose path
            file = QFileDialog.getSaveFileName(self._widget, title, ".csv",
                                               self.tr("Any files (*)"))
            file = file[0]
            if file:
                saveTableModelAsCsv(table.model(), file)
    def testReferenceCountingWhenDeletingReferrer(self):
        '''Tests reference count of model object referred by deceased view object.'''
        model = TestModel()
        refcount1 = getrefcount(model)
        view = QTableView()
        view.setModel(model)
        self.assertEqual(getrefcount(view.model()), refcount1 + 1)

        del view
        self.assertEqual(getrefcount(model), refcount1)
    def testReferenceCountingWhenDeletingReferrer(self):
        '''Tests reference count of model object referred by deceased view object.'''
        model = TestModel()
        refcount1 = getrefcount(model)
        view = QTableView()
        view.setModel(model)
        self.assertEqual(getrefcount(view.model()), refcount1 + 1)

        del view
        self.assertEqual(getrefcount(model), refcount1)
class ConfigureUsersDialog(QDialog):
    def __init__(self, users):
        super().__init__()
        self.setWindowTitle("Configure Users")
        self.model = TableModel(users)

        self.layout = QVBoxLayout()
        self.table_layout = QHBoxLayout()
        self.users_table = QTableView()
        self.users_table.setModel(self.model)
        self.users_table.horizontalHeader().setStretchLastSection(True)
        self.table_layout.addWidget(self.users_table)

        self.table_buttons_layout = QVBoxLayout()
        self.add_user_button = QPushButton()
        self.add_user_button.setText("Add User")
        self.add_user_button.clicked.connect(self._add_user_clicked)
        self.delete_user_button = QPushButton()
        self.delete_user_button.setText("Delete User")
        self.delete_user_button.clicked.connect(self._delete_user_clicked)
        self.table_buttons_layout.addSpacerItem(
            QSpacerItem(0, 0, vData=QSizePolicy.Expanding))
        self.table_buttons_layout.addWidget(self.add_user_button)
        self.table_buttons_layout.addWidget(self.delete_user_button)
        self.table_buttons_layout.addSpacerItem(
            QSpacerItem(0, 0, vData=QSizePolicy.Expanding))
        self.table_layout.addLayout(self.table_buttons_layout)

        self.layout.addLayout(self.table_layout)

        self.error_text = QLabel()
        self.error_text.setStyleSheet("color: red;")
        self.layout.addWidget(self.error_text)

        self.button_box = QDialogButtonBox(QDialogButtonBox.Ok
                                           | QDialogButtonBox.Cancel)
        self.button_box.accepted.connect(self._on_accepted_clicked)
        self.button_box.rejected.connect(self.reject)
        self.layout.addWidget(self.button_box)
        self.setLayout(self.layout)

        self.resize(600, 400)

    def _on_accepted_clicked(self):
        self._complete_table()
        if not self.model.are_users_unique():
            self.error_text.setText("Name must be unique for each user")
            return

        self.error_text.setText("")
        self.accept()

    def _complete_table(self):
        # The currently selected cell only updates the model when 'return' is
        # pressed or another cell is selected. If the user is updating a value
        # then clicks 'OK' without pressing 'return' then the change is lost.
        # This is a Qt thing - the workaround is to take focus from the table.
        self.button_box.button(self.button_box.Ok).setFocus()

    def _add_user_clicked(self):
        self.users_table.model().insertRow(self.model.num_rows)

    def _delete_user_clicked(self):
        rows_to_remove = set()
        for index in self.users_table.selectedIndexes():
            rows_to_remove.add(index.row())
        self.users_table.model().removeRows(list(rows_to_remove))

    def get_users(self):
        return self.model.users
 def testModelWithParent(self):
     view = QTableView()
     model = TestModel(None)
     view.setModel(model)
     samemodel = view.model()
     self.assertEqual(model, samemodel)
Exemple #14
0
class DiffDataframeWidget(QWidget):
    # NOTE: NOT USED FOR NOW
    def __init__(self, parent=None):
        super().__init__(parent)
        self._workbench: WorkbenchModel = None

        sideWidget = QWidget(self)
        sideLayout = QVBoxLayout()
        self.CBL = QComboBox(sideWidget)
        self.CBR = QComboBox(sideWidget)
        self.columnsL = SearchableAttributeTableWidget(sideWidget, True, showTypes=True)
        self.columnsR = SearchableAttributeTableWidget(sideWidget, True, showTypes=True)
        button = QPushButton('Compute diff', self)
        sideLayout.addWidget(self.CBL)
        sideLayout.addWidget(self.columnsL)
        sideLayout.addWidget(self.CBR)
        sideLayout.addWidget(self.columnsR)
        sideLayout.addWidget(button)
        sideWidget.setLayout(sideLayout)

        self.tableWidget = QTableView(self)

        splitter = QSplitter(self)
        splitter.addWidget(sideWidget)
        splitter.addWidget(self.tableWidget)

        layout = QHBoxLayout(self)
        layout.addWidget(splitter)

        self.CBL.currentTextChanged.connect(self.setAttributeModelL)
        self.CBR.currentTextChanged.connect(self.setAttributeModelR)
        button.clicked.connect(self.computeDiff)

    @Slot(str)
    def setAttributeModelL(self, name: str) -> None:
        frameModel = self._workbench.getDataframeModelByName(name)
        self.columnsL.setSourceFrameModel(frameModel)

    @Slot(str)
    def setAttributeModelR(self, name: str) -> None:
        frameModel = self._workbench.getDataframeModelByName(name)
        self.columnsR.setSourceFrameModel(frameModel)

    def setWorkbench(self, w: WorkbenchModel) -> None:
        self._workbench = w
        self.CBL.setModel(w)
        self.CBR.setModel(w)
        model = IncrementalRenderFrameModel(parent=self)
        frameModel = FrameModel(model)
        model.setSourceModel(frameModel)
        self.tableWidget.setModel(model)

    @Slot()
    def computeDiff(self) -> None:
        frame1 = self.columnsL.model().frameModel().frame.getRawFrame()
        frame2 = self.columnsR.model().frameModel().frame.getRawFrame()
        changedMask = frame1 != frame2
        diffRows = changedMask.any(1)
        diffColumns = changedMask.any(0)
        frame = frame1.loc[diffRows, diffColumns]
        self.tableWidget.model().sourceModel().setFrame(Frame(frame))
Exemple #15
0
class MainWindow(QMainWindow):
    def __init__(self,*args,**kwargs):
        super(MainWindow,self).__init__(*args,**kwargs)
        self.ventanaHelp = HelpContentWindow()
        self.ventana = AddProductWindow(self)
        self.menuBar = QMenuBar(self)
        self.setMenuBar(self.menuBar)
        help_menu = self.menuBar.addMenu('&Ayuda')
        help_content = QAction('&Contenido',self)
        help_acerca = QAction('&Acerca de',self)
        help_menu.addAction(help_content)
        help_menu.addAction(help_acerca)
        help_content.triggered.connect(self.help_content_triggered)
        focus_in_signal = Signal()
        self.majorLayout = QHBoxLayout()
        self.layout = QVBoxLayout()
        self.table = QTableView()
        self.marco = QFrame()
        self.marco.setFrameStyle(QFrame.Box)
        self.marco.setLayout(self.layout)
        self.inputCommands = LineEdit()
        self.inputCommands.setText('Ingrese un comando')
        self.inputCommands.focus_in_signal.connect(self.focus_in_command)
        self.layout.addWidget(self.inputCommands)
        self.inputCommands.returnPressed.connect(self.command_agrega_producto)
        self.inputCommands.hide()
        self.input = QLineEdit()
        self.layout.addWidget(self.table)
        self.layout.addWidget(self.input)
        self.majorLayout.addWidget(self.marco)
        self.total = QLabel()
        self.total.setText('Total: 0.00')
        self.total.setStyleSheet("{padding:0 50; margin:0 100;}")
        self.majorLayout.addWidget(self.total)
        widget = QWidget()
        widget.setLayout(self.majorLayout)
        self.datos =[
            ['ABCZ-1234', 'Paño esponja', 130.50],
            ['XYZC-2345', 'Escoba', 140.30],
            ]
        self.datosAnexos = [
            ['ABCZ-1234', 'Paño esponja', 130.50],
            ['XYZC-2345', 'Escoba', 140.30],
            ['WXYZ-1234', 'Limpiador de pisos', 150.00],
            ['ABCD-1234', 'Bote de basura grande', 1000.00]
            ]
        self.model = TableModel(self.datos, ['SKU', 'Artículo', 'Precio'])
        self.table.setModel(self.model)
        self.table.setColumnWidth(1,315)
        self.setCentralWidget(widget)
        self.input.returnPressed.connect(self.add_datos)
        self.calculate_total()

    def help_content_triggered(self):
        self.ventanaHelp.display_help()

    def add_datos(self):
        texto = self.input.text()
        valor = self.method_in(self.datosAnexos, texto)
        if(valor is None):
            self.marco.setStyleSheet("QFrame{border: 1px solid red;}")
            self.input.setStyleSheet("border: 1px solid red;")
            self.inputCommands.setText('Ingrese un comando')
            self.inputCommands.show()
        else:
            self.marco.setStyleSheet("QFrame{border: 1px solid black;}")
            self.input.setStyleSheet("border: 1px solid black;")
            self.datos.append(valor)
            self.table.model().layoutChanged.emit()
            self.calculate_total()
            self.inputCommands.hide()

    def calculate_total(self):
        agregado = 0.0
        for dato in self.datos:
            agregado += dato[2]
        self.total.setText('Total: ' + '{:.2f}'.format(agregado))

    def method_in(self, data, text):
        for element in data:
            if element[0].casefold() == text.casefold():
                return element
        return None
        
    def focus_in_command(self):
        self.inputCommands.setText('')

    def command_agrega_producto(self):
        valor = self.elige_comando(1)
        print(valor)
        if(valor == self.inputCommands.text()):
            self.ventana.display_info()
        else:
            print('Comando incorrecto')

    def comando_agregar(self):
        return 'A'

    def elige_comando(self, argument):
        return {
            1: lambda: self.comando_agregar(),
        }.get(argument, lambda: 'Opción inválida')()
Exemple #16
0
class MainWindow(QMainWindow):
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)

        self.setWindowTitle("VW Competitive")
        self.setWindowIcon(QIcon(':/images/vw.png'))
        """
        Test wstawienia wartosci do tabeli
        """
        self.table = QTableView()
        self.setCentralWidget(self.table)
        self.sti = QStandardItemModel()
        self.sti.setColumnCount(6)
        self.table.setModel(self.sti)
        self.table.verticalHeader().setDefaultSectionSize(10)
        self.table.horizontalHeader().setDefaultSectionSize(200)
        self.headers = [
            'Year', 'Month', 'Week', 'Sector', 'Category', 'Sub Category',
            'Produkt(4)', 'Branża(I)', 'Kategoria(II)', 'Dział(III)',
            'Producer', 'Brand', 'Sub Brand', 'Film Code', 'Film Code 2',
            'Media', 'Glowne Medium', 'Medium', 'Wydawca Nadawca',
            'Periodyczność', 'Duration', 'Typ reklamy', 'Forma Reklamy',
            'Typ Strony', 'L.emisji', 'Sum.Str', 'Cost', 'PT/OFF', 'TRP',
            'TRP30', 'Channel group', 'Channel type', 'Wyprz', 'Upus', 'Rabat',
            'Wyprze Upust Rabat', 'Model', 'Brand final',
            'Subbrand (brand+Model)', 'Brand Type', 'Segment_detailed',
            'Segment', 'Segment_combined', 'Campaign Type'
        ]
        """
        Forms
        """
        self.excel_form = ExcelForm(self.headers, self)
        self.connect_form = ConnectRaports(self)
        self.filechoser = FileChoser(self)
        self.for_find_duplicate = FindDuplicate(self)
        self.filters_manager = FiltersManager(self)

        self.sti.setHorizontalHeaderLabels(self.headers)
        self.sti.setColumnCount(len(self.headers))
        self.table.setSortingEnabled(True)
        #self.table.horizontalHeader().connect()
        self.connect(self.table.horizontalHeader(),
                     SIGNAL("sectionClicked(int)"), self.showfilterforms)

        self.createActions()
        self.createMenus()
        self.createStatusBar()
        self.readSettings()
        self.set_color_on_header()

    def closeEvent(self, event):
        self.close()

    def open(self):
        self.filechoser.show()
        self.filechoser.clead_data()

    def save(self):
        """
        save data to data base
        :return:
        """
        #deleta rows from data base for compative name
        session = Session()
        comat = session.query(Competitive).filter(
            Competitive.name.ilike(f'%{self.compative_name}%')).first()
        session.query(Data).filter_by(competitive_id=comat.id).delete()

        #read data from row and save to data base
        for row in range(self.sti.rowCount()):
            datas = []
            for col in range(self.sti.columnCount()):
                if col in (0, 1, 2, 20, 24):
                    try:
                        #tutaj poprawic nie chce wpisać
                        if self.sti.item(row, col) is not None:
                            datas.append(int(self.sti.item(row, col).text()))
                        else:
                            datas.append(None)
                    except ValueError:
                        datas.append(None)
                elif col in (25, 26, 28, 29):
                    try:
                        if self.sti.item(row, col) is not None:
                            datas.append(float(self.sti.item(row, col).text()))
                        else:
                            datas.append(None)
                    except ValueError:
                        datas.append(None)
                else:
                    if self.sti.item(row, col) is not None:
                        datas.append(self.sti.item(row, col).text())
                    else:
                        datas.append(None)

            comat.datas.append(Data(*datas))

        session.commit()
        session.close()
        QMessageBox.information(self, "Zapis",
                                "Zapis zakonczyl się powodzeniem.")

    def createActions(self):
        self.openAct = QAction(QIcon(':/images/open.png'),
                               "&Otwórz...",
                               self,
                               shortcut=QKeySequence.Open,
                               statusTip="Otwóż nowe pliki",
                               triggered=self.open)

        self.saveAct = QAction(QIcon(':/images/save.png'),
                               "&Zapisz...",
                               self,
                               shortcut=QKeySequence.Save,
                               statusTip="Zapisz plik",
                               triggered=self.save)

        self.exitAct = QAction("&Zamknij",
                               self,
                               shortcut="Ctrl+Q",
                               statusTip="Zamknij aplikacje",
                               triggered=self.close)

        self.runWordFilter = QAction("Filtry &Automatyczne",
                                     shortcut="Ctrl+A",
                                     statusTip="Urchom filtry automatyczne",
                                     triggered=self.run_filters)

        self.showExcelForm = QAction("Generuj plik excel",
                                     triggered=self.show_excel_form)

        self.ConnectRaports = QAction("Połącz raporty",
                                      triggered=self.show_connect_raports)

        self.FindDuplicate = QAction("Znajdz duplikaty",
                                     triggered=self.show_duplicate_form)

        self.FilterManager = QAction("Filtry Manualne",
                                     triggered=self.show_filter_manager)

    def createMenus(self):
        self.fileMenu = self.menuBar().addMenu("&Plik")
        self.fileMenu.addAction(self.openAct)
        self.fileMenu.addAction(self.saveAct)
        self.fileMenu.addSeparator()
        self.fileMenu.addAction(self.exitAct)

        self.filterMenu = self.menuBar().addMenu("&Filtry")
        self.filterMenu.addAction(self.runWordFilter)
        self.filterMenu.addAction(self.FilterManager)

        self.excelMenu = self.menuBar().addMenu("&Raporty")
        self.excelMenu.addAction(self.showExcelForm)
        self.excelMenu.addAction(self.ConnectRaports)
        self.excelMenu.addAction(self.FindDuplicate)

    def contextMenuEvent(self, event):
        contextMenu = QMenu(self)
        removeAction = contextMenu.addAction('Usuń')

        action = contextMenu.exec_(self.mapToGlobal(event.pos()))

        if action == removeAction:
            index_list = []
            for model_index in self.table.selectionModel().selectedRows():
                index = QPersistentModelIndex(model_index)
                index_list.append(index)

            for index in index_list:
                self.sti.removeRow(index.row())

    def createStatusBar(self):
        self.statusBar().showMessage("Ready")

    def readSettings(self):
        settings = QSettings("Trolltech", "Application Example")
        pos = settings.value("pos", QPoint(200, 200))
        size = settings.value("size", QSize(800, 800))
        self.resize(size)
        self.move(pos)

    def get_data(self, paths, compative_name):
        """
        receives data from the filechose form
        :param paths: dictionary with paht to techege, adexpert
        :param compative_name: name of raport
        :return:
        """
        self.compative_name = compative_name
        if len(paths[0]) > 0:
            self.techegedata = Excel.get_data(paths[0])
        else:
            self.techegedata = None
        if len(paths[1]) > 0:
            self.adxpert = Excel.get_data(paths[1], False)
        else:
            self.adxpert = None

        #wczytanie arkusza z bazy danych
        session = Session()
        self.compativedata = session.query(Competitive).filter_by(
            name=compative_name).first()

        self.populate_row()
        session.close()

    def populate_row(self):
        """
        read data from compatiedate, techegedata, adxpert and past to rows
        :return:
        """
        # without this section data in column one don't show
        self.sti.setRowCount(0)
        self.sti.setRowCount(1)

        font = QFont()
        font.setPointSize(8)

        #add data from data base
        if self.compativedata:
            for row in self.compativedata.datas:
                rownr = self.sti.rowCount()
                rowvalue = row.values()
                for nr, value in enumerate(rowvalue):
                    item = QStandardItem(f'{value}')
                    item.setFont(font)
                    self.sti.setItem(rownr - 1, nr, item)
                    self.sti.setRowCount(rownr + 1)

        #add data from techegedata
        if self.techegedata:
            for rownr in range(len(self.techegedata[0])):
                self.sti.setRowCount(self.sti.rowCount() + 1)
                for colnr in range(len(self.techegedata)):
                    if len(self.techegedata[colnr]) == 0:
                        continue
                    item = QStandardItem(f'{self.techegedata[colnr][rownr]}')
                    item.setFont(font)
                    self.sti.setItem(self.sti.rowCount() - 2, colnr, item)

        #add data from adexpert
        if self.adxpert:
            for rownr in range(len(self.adxpert[0])):
                self.sti.setRowCount(self.sti.rowCount() + 1)
                for colnr in range(len(self.adxpert)):
                    if len(self.adxpert[colnr]) == 0:
                        continue
                    item = QStandardItem(f'{self.adxpert[colnr][rownr]}')
                    item.setFont(font)
                    self.sti.setItem(self.sti.rowCount() - 2, colnr, item)

        self.sti.removeRow(self.sti.rowCount() - 1)
        self.table.horizontalHeader().setSectionResizeMode(
            QHeaderView.ResizeToContents)
        QMessageBox.information(self, "Dane", "Dane zostały wczytane")

    def showfilterforms(self, i):
        """
        Show filters for collumn nr"
        :param i:
        :return:
        """
        session = Session()
        filter_ = session.query(FilterF).filter_by(column_nr=i).one_or_none()
        if filter_ is not None and filter_.type == 'manual':
            columns = self.prapercolumns(filter_.columns)
            headersname = [self.headers[i] for i in filter_.columns]
            self.filter = FiltersForm(filter_.id, columns, headersname, self)
            self.filter.show()

        session.close()

    def show_excel_form(self):
        """
        Show excel form
        :return:
        """
        self.excel_form.set_compatives()
        self.excel_form.show()

    def show_connect_raports(self):
        """
        Show  connect rapot
        :return:
        """
        self.connect_form.set_raports()
        self.connect_form.show()

    def show_duplicate_form(self):
        """
        show duplicate form
        """
        self.for_find_duplicate.set_raports()
        self.for_find_duplicate.show()

    def show_filter_manager(self):
        """
        show filter manager form
        """
        self.filters_manager.show()

    def prapercolumns(self, columns):
        """
        get unic data from sending columns
        :param args:
        :return:
        """
        mainlist = []
        for col in columns:
            collist = []
            for row in range(self.sti.rowCount()):
                if self.sti.item(row, col) is not None:
                    collist.append(self.sti.item(row, col).text())
            mainlist.append(collist)

        return list(set(zip(*mainlist)))

    def replace_column(self, col_nr, assignded_column):
        """
        replace column with new data
        :param col_nr:
        :param assignded_column:
        :return:
        """
        self.sti.takeColumn(col_nr)
        self.sti.insertColumn(col_nr, assignded_column)
        self.sti.setHorizontalHeaderLabels(self.headers)
        self.set_color_on_header()

    """
    
    Filters
    
    """

    def assign_value_for_filter(self, filter_id, show=True):
        """
        preper list with value from main filter, send it to make_filter_list.
        Replace column for filter_id with column with assigned data
        :param filter_id:
        :return:
        """
        session = Session()
        filter_ = session.query(FilterF).get(filter_id)
        rows = []
        for row in range(self.sti.rowCount()):
            row_value = [
                self.sti.item(row, col).text() for col in filter_.columns
            ]
            rows.append(row_value)

        read_rows = self.make_filter_list(filter_id, rows)
        col_nr = filter_.column_nr
        self.sti.takeColumn(col_nr)
        self.sti.insertColumn(col_nr, read_rows)
        self.sti.setHorizontalHeaderLabels(self.headers)
        session.close()
        self.set_color_on_header()

        if show:
            QMessageBox.information(self, "Informacja", "Operacja zakończona.")

    @staticmethod
    def make_filter_list(filter_id, rows):
        """
        make list with assigned value
        :param filter_id:
        :param rows:
        :return:
        """
        session = Session()
        filter_ = session.query(FilterF).get(filter_id)

        ready_valus = []
        for row in rows:
            flag = False
            row = [i.strip().lower() for i in row]
            for category in filter_.categorys:
                items = [[b.strip().lower() for b in a]
                         for a in category.items]
                if row in items:
                    #make QStandardItem to make column in sti model
                    item = QStandardItem(str(category.name))
                    ready_valus.append(item)
                    flag = True
            if flag is False:
                item = QStandardItem('')
                ready_valus.append(item)

        session.close()
        return ready_valus

    """
    filters: words, cut
    """

    def run_filters(self):
        """
        make filters
        :return:
        """
        session = Session()
        # filters_ = session.query(FilterF).filter_by(type='words').all()
        filters_ = session.query(FilterF).all()
        for fil in filters_:

            if fil.type == 'words':
                rows = self.get_data_from_columns(fil.columns)
                assignded_column = self.make_words_list(fil.id, rows)
                self.replace_column(fil.column_nr, assignded_column)

            elif fil.type == 'cut':
                if fil.name == 'model':
                    rows = self.get_data_from_columns(fil.columns)
                    assignded_column = self.filter_cut_model(rows)
                    self.replace_column(fil.column_nr, assignded_column)

                elif fil.name == 'subbrand_brand_model':
                    rows = self.get_data_from_columns(fil.columns)
                    assignded_column = self.join_columns(rows)
                    self.replace_column(fil.column_nr, assignded_column)

        session.close()
        QMessageBox.information(self, "Informacja", "Operacja zakończona.")

    def get_data_from_columns(self, columns_nr):
        """
        get data for sending columns
        :param columns_nr:
        :return: return list of value from table
        """
        rows = []
        for row in range(self.sti.rowCount()):
            row_value = []
            for col in columns_nr:
                if self.sti.item(row, col) is not None:
                    row_value.append(self.sti.item(row, col).text())
                else:
                    row_value.append('')
            # row_value = [self.sti.item(row, col).text() for col in columns_nr]
            rows.append(row_value)
        return rows

    @staticmethod
    def make_words_list(filter_id, rows):
        """
        make words list for filters,
        if find word in list assigned name of category
        :param filter_id:
        :param rows:
        :return:
        """

        session = Session()
        filter_ = session.query(FilterF).get(filter_id)

        ready_valus = []
        for row in rows:
            flag = False
            row = [i.lower() for i in row]
            row = ' '.join(row)
            for category in filter_.categorys:
                words = [b.lower() for b in category.words]
                for word in words:
                    if word in row:
                        item = QStandardItem(str(category.name))
                        ready_valus.append(item)
                        flag = True
                        break
            if flag is False:
                item = QStandardItem('')
                ready_valus.append(item)

        session.close()
        return ready_valus

    def filter_cut_model(self, rows):
        """
        cut ferst word from string
        :param rows:
        :return:
        """
        ready_values = []
        for row in rows:
            item = QStandardItem((row[1].replace(row[0], '')).strip())
            ready_values.append(item)

        return ready_values

    def join_columns(self, rows):
        """
        join column in list rows
        """
        temp = [QStandardItem(' '.join(x)) for x in rows]
        return temp

    def set_color_on_header(self):
        """
        changes the color of the header
        :return:
        """

        session = Session()
        filtersf = session.query(FilterF).all()

        for filterf in filtersf:
            if filterf.type == 'manual':
                self.table.model().setHeaderData(filterf.column_nr,
                                                 Qt.Horizontal,
                                                 QBrush(QColor(121, 166, 210)),
                                                 Qt.BackgroundRole)
                self.table.model().setHeaderData(
                    filterf.column_nr, Qt.Horizontal,
                    self.headers[filterf.column_nr], Qt.DisplayRole)
            if filterf.type in ('words', 'cut'):
                self.table.model().setHeaderData(filterf.column_nr,
                                                 Qt.Horizontal,
                                                 QBrush(QColor(212, 214, 219)),
                                                 Qt.BackgroundRole)
                self.table.model().setHeaderData(
                    filterf.column_nr, Qt.Horizontal,
                    self.headers[filterf.column_nr], Qt.DisplayRole)
        session.close()
Exemple #17
0
class App(QWidget):
    def __init__(self):
        super().__init__()
        self.title = 'Thermodynamic data'

        qd = QDesktopWidget()
        screen = qd.screenGeometry(qd)
        width = 600
        height = 300

        x = screen.width() / 2 - width / 2
        y = screen.height() / 2 - height / 2

        self.width = width
        self.height = height
        self.left = x
        self.top = y
        self.ignore_events = False
        self.initUI()

    def initUI(self):
        self.setWindowTitle(self.title)
        self.setGeometry(self.left, self.top, self.width, self.height)

        self.tableView1 = QTableView()
        self.tableWidget1 = QTableWidget()
        self.model = thTableModel()
        self.cas_filter = QLineEdit()
        self.name_filter = QLineEdit()
        self.formula_filter = QLineEdit()
        self.phase_filter = QComboBox()
        self.delete_selected_button = QPushButton()
        self.copy_selected_button = QPushButton()
        self.phases_vol_button = QPushButton()
        self.temp_text = QLineEdit()
        self.plot_window = PlotWindow()
        self.cp_button = QPushButton()
        self.psat_button = QPushButton()

        self.tableView1.setModel(self.model)
        self.tableWidget1.setColumnCount(
            self.tableView1.model().columnCount() + 1 + 1 + 1 + 1 + 1)
        self.widget_col_names = ['z_i', 'h_ig', 's_ig', 'g_ig', 'cp_ig'
                                 ] + self.tableView1.model().column_names
        self.widget_col_units = ['-', 'J/mol', 'J/mol/K', 'J/mol', 'J/mol/K'
                                 ] + self.tableView1.model().column_units
        self.widget_col_names_units = [
            self.widget_col_names[i] + '\n' + self.widget_col_units[i]
            for i in range(len(self.widget_col_names))
        ]
        self.tableWidget1.setHorizontalHeaderLabels(
            self.widget_col_names_units)
        self.phase_filter.addItems(['', 'G', 'L', 'S', 'C'])
        self.tableWidget1.setEnabled(False)
        self.tableWidget1.setSelectionBehavior(QTableWidget.SelectRows)
        self.tableWidget1.installEventFilter(self)
        self.delete_selected_button.setText('delete selected')
        self.copy_selected_button.setText('copy selected')
        self.phases_vol_button.setText('ph, v')
        self.temp_text.setValidator(QDoubleValidator(0, 6000, 16))
        self.temp_text.setPlaceholderText('1000 K')

        # Add box layout, add table to box layout and add box layout to widget
        self.layout = QGridLayout()
        self.layout.addWidget(self.tableView1, 1, 1, 1, 4)
        self.layout.addWidget(self.cas_filter, 3, 1, 1, 1)
        self.layout.addWidget(self.name_filter, 3, 2, 1, 1)
        self.layout.addWidget(self.formula_filter, 3, 3, 1, 1)
        self.layout.addWidget(self.phase_filter, 3, 4, 1, 1)
        self.layout.addWidget(QLabel('find by: cas'), 2, 1, 1, 1)
        self.layout.addWidget(QLabel('name'), 2, 2, 1, 1)
        self.layout.addWidget(QLabel('formula'), 2, 3, 1, 1)
        self.layout.addWidget(QLabel('phase'), 2, 4, 1, 1)
        self.layout.addWidget(QLabel('selection'), 4, 1, 1, 4)
        self.layout.addWidget(self.tableWidget1, 5, 1, 1, 4)
        self.layout.addWidget(self.delete_selected_button, 6, 4, 1, 1)
        self.layout.addWidget(self.copy_selected_button, 6, 1, 1, 1)
        self.layout.addWidget(self.phases_vol_button, 6, 2, 1, 1)
        self.layout.addWidget(self.temp_text, 6, 3, 1, 1)

        self.setLayout(self.layout)

        for item in [self.cas_filter, self.name_filter, self.formula_filter]:
            item.textChanged.connect(self.apply_filters)
        self.phase_filter.currentTextChanged.connect(self.apply_filters)
        self.tableView1.selectionModel().selectionChanged.connect(
            partial(self.add_selection_to_widget))
        self.tableWidget1.cellChanged.connect(partial(self.update_props))
        self.delete_selected_button.clicked.connect(
            partial(self.delete_selected))
        self.copy_selected_button.clicked.connect(partial(self.copy_selection))
        self.phases_vol_button.clicked.connect(partial(self.phases_vol))
        self.temp_text.editingFinished.connect(partial(self.update_temp))
        #self.tableView1.horizontalHeader().setClickable(False)

        self.props_i = self.tableView1.model().df.iloc[[]]
        self.props_i['z_i'] = zeros(0)
        self.props_i['h_ig'] = zeros(0)
        self.props_i['s_ig'] = zeros(0)
        self.props_i['g_ig'] = zeros(0)
        self.props_i['cp_ig'] = zeros(0)

        # Show widget
        self.show()

    def apply_filters(self):
        cas_filter = self.cas_filter.text().upper().strip().replace(' ', '')
        name_filter = self.name_filter.text().upper().strip()
        formula_filter = self.formula_filter.text().upper().strip()
        phase_filter = self.phase_filter.currentText()
        self.model.apply_filter(cas_filter, name_filter, formula_filter,
                                phase_filter)

    def add_selection_to_widget(self, selected, deselected):
        # indexes = self.tableView1.selectedIndexes()
        indexes = selected.indexes()
        index = indexes[0]
        column_of_cas = self.tableView1.model().column_names.index('cas_no')
        column_of_phase = self.tableView1.model().column_names.index('phase')
        phase = self.tableView1.model().index(index.row(),
                                              column_of_phase).data()
        cas = self.tableView1.model().index(index.row(), column_of_cas).data()
        already_in_table = False
        for item in self.tableWidget1.findItems(cas, Qt.MatchExactly):
            if phase == self.tableWidget1.item(
                    item.row(), column_of_phase + 1 + 1 + 1 + 1 + 1).text():
                already_in_table = True
        if not already_in_table:
            row_index = int(self.tableView1.model().headerData(
                index.row(), Qt.Vertical))
            column_names = self.tableView1.model().column_names
            header_to_add = QTableWidgetItem(str(row_index))

            # save df with new props
            z_i_orig = self.props_i['z_i']
            h_ig_orig = self.props_i['h_ig']
            s_ig_orig = self.props_i['s_ig']
            g_ig_orig = self.props_i['g_ig']
            cp_ig_orig = self.props_i['cp_ig']
            index_orig = self.props_i.index
            self.props_i = self.tableView1.model().df.loc[[
                int(self.tableWidget1.verticalHeaderItem(i).text())
                for i in range(self.tableWidget1.rowCount())
            ] + [row_index], :]
            self.props_i['z_i'] = zeros(len(self.props_i))
            self.props_i['h_ig'] = zeros(len(self.props_i))
            self.props_i['s_ig'] = zeros(len(self.props_i))
            self.props_i['g_ig'] = zeros(len(self.props_i))
            self.props_i['cp_ig'] = zeros(len(self.props_i))
            self.props_i.loc[index_orig, 'z_i'] = z_i_orig
            self.props_i.loc[index_orig, 'h_ig'] = h_ig_orig
            self.props_i.loc[index_orig, 's_ig'] = s_ig_orig
            self.props_i.loc[index_orig, 'g_ig'] = g_ig_orig
            self.props_i.loc[index_orig, 'cp_ig'] = cp_ig_orig

            self.props_i.loc[row_index, 'z_i'] = float(0)

            # add item to widget
            self.tableWidget1.setRowCount(self.tableWidget1.rowCount() + 1)
            self.tableWidget1.setVerticalHeaderItem(
                self.tableWidget1.rowCount() - 1, header_to_add)
            for i in range(len(column_names)):
                # columns in TableWidget shifted by 1+1+1+1+1 vs. Tableview due to first columns z_i, h_ig, s_ig, g_ig, cp_ig
                data = self.tableView1.model().index(index.row(), i).data()
                if isinstance(data, str) or data is None:
                    item_to_add = QTableWidgetItem(data)
                else:
                    item_to_add = QTableWidgetItem(locale.str(data))
                item_to_add.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
                                     | Qt.ItemIsEditable)
                self.tableWidget1.setItem(self.tableWidget1.rowCount() - 1,
                                          i + 1 + 1 + 1 + 1 + 1, item_to_add)

            # additional column with z_i
            item_to_add = QTableWidgetItem(locale.str(0))
            item_to_add.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
                                 | Qt.ItemIsEditable)
            self.tableWidget1.setItem(self.tableWidget1.rowCount() - 1, 0,
                                      item_to_add)

        if len(indexes) > 0 or self.tableWidget1.rowCount() > 0:
            self.tableWidget1.setEnabled(True)

    def update_props(self, row, col):
        if col == 0:
            # change z_i
            df_index = int(self.tableWidget1.verticalHeaderItem(row).text())
            new_value = float(
                self.tableWidget1.item(row, col).text().replace(',', '.'))
            self.props_i.loc[df_index, 'z_i'] = new_value
        else:
            pass

    def update_temp(self):
        if self.temp_text.hasAcceptableInput():
            self.temp_text.setPlaceholderText(self.temp_text.text() + ' K')
            t = float(self.temp_text.text().replace(',', '.'))  # K
            self.temp_text.clear()
        else:
            t = 1000  # K
            self.temp_text.clear()
        mm_i = (self.props_i['poling_molwt'] / 1000).tolist()  # kg/mol
        tc_i = self.props_i['poling_tc'].tolist()  # K
        pc_i = (self.props_i['poling_pc'] * 1e5).tolist()  # Pa
        omega_i = self.props_i['poling_omega'].tolist()
        vc_i = (self.props_i['poling_vc'] * 10**-6).tolist()  # m^3/mol
        delhf0_poling = (self.props_i['poling_delhf0'] *
                         1000).tolist()  # J/mol
        delgf0_poling = (self.props_i['poling_delgf0'] *
                         1000).tolist()  # J/mol
        delsf0_poling = [(delhf0_poling[i] - delgf0_poling[i]) / 298.15
                         for i in range(len(self.props_i))]  # J/mol/K
        a_low = [
            self.props_i['a' + str(i) + '_low'].tolist()
            for i in range(1, 7 + 1)
        ]
        a_high = [
            self.props_i['a' + str(i) + '_high'].tolist()
            for i in range(1, 7 + 1)
        ]

        cp_r_low = [
            sum([a_low[j][i] * t**j for j in range(4 + 1)])
            for i in range(len(self.props_i))
        ]  # cp/R
        cp_r_high = [
            sum([a_high[j][i] * t**j for j in range(4 + 1)])
            for i in range(len(self.props_i))
        ]  # cp/R

        if t > 1000:  # poly a_low is for 200 - 1000 K; a_high is for 1000 - 6000 K
            a = a_high
            cp_ig = [8.3145 * cp_r_high[i]
                     for i in range(len(self.props_i))]  # J/mol/K
        else:
            a = a_low
            cp_ig = [8.3145 * cp_r_low[i]
                     for i in range(len(self.props_i))]  # J/mol/K

        s_cp_r_dt = [
            sum([1 / (j + 1) * a[j][i] * t**(j + 1)
                 for j in range(4 + 1)]) - sum([
                     1 / (j + 1) * a_low[j][i] * 298.15**(j + 1)
                     for j in range(4 + 1)
                 ]) for i in range(len(self.props_i))
        ]  # int(Cp/R*dT,298,15K,T)
        # int(Cp/R/T*dT,298.15K,T)
        s_cp_r_t_dt = [
            a[0][i] * log(t) + a[6][i] +
            sum([1 / (j) * a[j][i] * t**(j) for j in range(1, 3 + 1)])
            for i in range(len(self.props_i))
        ]  # int(Cp/(RT)*dT,0,T)

        h_ig = [
            delhf0_poling[i] + 8.3145 * s_cp_r_dt[i]
            for i in range(len(self.props_i))
        ]
        s_ig = [8.3145 * s_cp_r_t_dt[i] for i in range(len(self.props_i))]
        g_ig = [h_ig[i] - t * s_ig[i] for i in range(len(self.props_i))]

        for i in range(len(self.props_i)):
            for j, col in enumerate([h_ig, s_ig, g_ig, cp_ig]):
                #print(col)
                item_to_add = QTableWidgetItem(locale.str(col[i]))
                item_to_add.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
                                     | Qt.ItemIsEditable)
                self.tableWidget1.setItem(i, j + 1, item_to_add)

    def copy_selection(self):
        selection = self.tableWidget1.selectedIndexes()
        if selection:
            rows = sorted(index.row() for index in selection)
            columns = range(len(self.widget_col_names))
            rowcount = rows[-1] - rows[0] + 1
            colcount = columns[-1] - columns[0] + 1 + 1
            table = [[''] * colcount for _ in range(rowcount + 1)]
            table[0] = []
            for i in range(len(self.widget_col_names)):
                text_to_add = self.widget_col_names[
                    i] + '/(' + self.widget_col_units[i] + ')'
                table[0] += [text_to_add]
            for index in selection:
                row = index.row() - rows[0]
                column = index.column() - columns[0]
                table[row + 1][column] = index.data().replace(
                    chr(34), ''
                )  # ensure string can be read as csv by removing quotation mark (ascii character 34)
            table = table + [['T=' + self.temp_text.placeholderText()] +
                             ['' for _ in range(colcount - 1)]]
            stream = io.StringIO()
            csv.writer(stream, delimiter=';',
                       quoting=csv.QUOTE_NONE).writerows(table)
            QApplication.clipboard().setText(stream.getvalue())

    def eventFilter(self, source, event):
        if self.ignore_events:
            pass
        elif (event.type() == QEvent.KeyPress
              and event.matches(QKeySequence.Copy)):
            self.copy_selection()
            return True
        elif (event.type() == QEvent.KeyPress
              and event.matches(QKeySequence.Delete)):
            if len(self.tableWidget1.selectedIndexes()) > 1:
                self.delete_selected()
            return True
        return super(App, self).eventFilter(source, event)

    def delete_selected(self):
        if len(self.tableWidget1.selectedIndexes()) > 0:
            while len(self.tableWidget1.selectedIndexes()) > 0:
                current_row = self.tableWidget1.selectedIndexes()[0].row()
                row_index = int(
                    self.tableWidget1.verticalHeaderItem(current_row).text())
                self.tableWidget1.removeRow(current_row)
                self.props_i = self.props_i.drop([row_index])
            self.tableWidget1.selectRow(current_row)
            if self.tableWidget1.rowCount() == 0:
                self.tableWidget1.setEnabled(False)

    def phases_vol(self):
        self.plot_window.show()
        t = linspace(60, 220, 10)
        p = 1.01325  # bar
        phase_fraction = empty_like(t)
        v_l = empty_like(t)
        v_v = empty_like(t)
        z_i = self.props_i['z_i']
        # normalize z_i
        sum_z_i = sum(z_i)
        if sum_z_i <= 0:
            z_i = 1 / len(z_i) * ones(len(z_i))
            z_i = z_i.tolist()
        elif sum_z_i != 1.0:
            z_i = z_i / sum_z_i
            z_i = z_i.to_list()
        else:
            z_i = z_i.to_list()
        mm_i = (self.props_i['poling_molwt'] / 1000).tolist()  # kg/mol
        tc_i = self.props_i['poling_tc'].tolist()  # K
        pc_i = (self.props_i['poling_pc']).tolist()  # bar
        omega_i = self.props_i['poling_omega'].tolist()
        vc_i = (self.props_i['poling_vc'] * 10**-6).tolist()  # m^3/mol
        state = State(t[0], p, z_i, mm_i, tc_i, pc_i, omega_i, 'pr')

        for i in range(len(t)):
            state.set_t(t[i])
            phase_fraction[i] = state.v_f
            v_l[i] = state.v_l
            v_v[i] = state.v_v
        self.plot_window.ax[0].plot(t, phase_fraction)
        self.plot_window.ax[0].set_xlabel('T / K')
        self.plot_window.ax[0].set_xlabel('V / F')
        self.plot_window.ax[1].semilogy(t, v_l, label='v_l')
        self.plot_window.ax[1].semilogy(t, v_v, label='v_v')
        self.plot_window.ax[1].set_xlabel('T / K')
        self.plot_window.ax[1].set_xlabel(r'$\frac{V}{m^3 / mol}$')
        self.plot_window.ax[1].legend()
        self.plot_window.fig.tight_layout()
 def testModelWithParent(self):
     view = QTableView()
     model = TestModel(None)
     view.setModel(model)
     samemodel = view.model()
     self.assertEqual(model, samemodel)