Filtrer un PandasTableModel entre 2 dates

**Tiedien** · 08/04/2020, 12h15

Bonjour à tous.

Je réalise un logiciel Pyqt5 qui entre autre chose doit permettre d'afficher une base de donnée Sqlyte3 et l'analyser.

Pour cela, j'ai extrait la base de donnée avec un PandasTableModel, et je l'affiche ensuite dans un QTableView.

Mon problème vient du filtrage des dates de réception et de réponse aux messages.

J'arrive à faire en sorte de retrouver les messages d'une date précise, mais impossible d'effectuer la recherche pour une plage de dates.

Quelqu'un aurait il une idée sur la marche à suivre pour pouvoir faire la recherche par plage de date ?

Voici mon code, incluant ma tentative.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
 
 
# -*- coding: utf-8 -*-
"""
Created on Tue Mar  3 16:57:45 2020
 
 
"""
from PyQt5 import QtWidgets
from PyQt5 import QtCore
import pandas as pd
import datetime
 
 
class App_Direction(QtWidgets.QWidget):
 
    def __init__(self):
        super(App_Direction,self).__init__()
        self.initUI()
 
    def initUI(self):
        search_btn=QtWidgets.QPushButton( "Effectuer une recherche")
        search_btn.clicked.connect(self.search_win_launch) 
 
        vlayout=QtWidgets.QVBoxLayout()
        vlayout.addWidget(search_btn)
        self.setLayout(vlayout)
        self.show()
 
    def search_win_launch(self):
        """Lance la 2ème fenêtre en cas de clic sur le bouton
        """
        self.search_win = TableFilteringDialog()
        self.search_win.setWindowModality(QtCore.Qt.ApplicationModal)
        self.search_win.show()      
        self.close()    
 
class MainWindow(QtWidgets.QMainWindow):
    def __init__(self):
        super(MainWindow,self).__init__()
 
        self.main_frame=App_Direction()
        self.setCentralWidget(self.main_frame)
        self.setWindowTitle("Programme de test")
        self.resize(900,900)
        self.move(1500,100)
        self.show()
 
################################################################ SEARCH Win ########################################################
 
class PandasTableModel(QtCore.QAbstractTableModel):
 
    def __init__(self,  parent=None, *args):
        super(PandasTableModel,  self).__init__(parent,  *args)
        self._filters = {}
        self._sortBy = []
        self._sortDirection = []
        self._dfSource = pd.DataFrame()
        self._dfDisplay = pd.DataFrame()
 
    def rowCount(self,  parent=QtCore.QModelIndex()):
        if parent.isValid():
            return 0
        return self._dfDisplay.shape[0]
        print(self._dfDisplay.shape[0])
 
    def columnCount(self,  parent=QtCore.QModelIndex()):
        try:
            if parent.isValid():
                return 0
            return self._dfDisplay.shape[1]
        except TypeError:
            pass
 
    def data(self, index, role):
        if index.isValid() and role == QtCore.Qt.DisplayRole:
            return QtCore.QVariant(self._dfDisplay.values[index.row()][index.column()])
        return QtCore.QVariant()
 
    def headerData(self, col, orientation=QtCore.Qt.Horizontal, role=QtCore.Qt.DisplayRole):
        if orientation == QtCore.Qt.Horizontal and role == QtCore.Qt.DisplayRole:
            return QtCore.QVariant(str(self._dfDisplay.columns[col]))
        return QtCore.QVariant()
 
    def setupModel(self, header, data):
        self._dfSource = pd.DataFrame(data, columns=header)
        self._sortBy = []
        self._sortDirection = []
        self.setFilters({})
 
    def setFilters(self, filters):
        self.modelAboutToBeReset.emit()
        self._filters = filters
        self.updateDisplay()
        self.modelReset.emit()
 
    def sort(self, col, order=QtCore.Qt.AscendingOrder):
        column = self._dfDisplay.columns[col]
        ascending = (order == QtCore.Qt.AscendingOrder)
        if column in self._sortBy:
            i = self._sortBy.index(column)
            self._sortBy.pop(i)
            self._sortDirection.pop(i)
        self._sortBy.insert(0, column)
        self._sortDirection.insert(0, ascending)
        self.updateDisplay()
        self.dataChanged.emit(QtCore.QModelIndex(), QtCore.QModelIndex())
 
    def updateDisplay(self):
        dfDisplay = self._dfSource.copy()
        print(dfDisplay.index)
        # Filtering
        cond = pd.Series(True, index = dfDisplay.index)
 
        if list((self._filters.values()))!=[]:
            for column, value in self._filters.items():
                if column =='Jour de réception':
                    cond = pd.Series(True, index = ["Jour de réception"])
                    date_début=(list(self._filters.values())[0][0])
                    date_fin=list(self._filters.values())[0][1]
                    cond = cond & \
                            (cond.loc[date_début:date_fin])
 
                    dfDisplay = dfDisplay[cond]
                else: 
                    for column, value in self._filters.items():
                        cond = cond & \
                            (dfDisplay[column].str.lower().str.find(str(value).lower()) >= 0)
 
                    dfDisplay = dfDisplay[cond]
 
        # Sorting
        if len(self._sortBy) != 0:
            dfDisplay.sort_values(by=self._sortBy,
                                ascending=self._sortDirection,
                                inplace=True)
 
        # Updating
        self._dfDisplay = dfDisplay
 
class Ui_TableFilteringDialog(object):
    def setupUi(self, TableFilteringDialog):
        TableFilteringDialog.setObjectName("TableFilteringDialog")
        TableFilteringDialog.resize(1000, 900)
        self.verticalLayout = QtWidgets.QVBoxLayout(TableFilteringDialog)
        self.verticalLayout.setObjectName("verticalLayout")
        self.tableView = QtWidgets.QTableView(TableFilteringDialog)
        self.tableView.setObjectName("tableView")
        self.tableView.setSortingEnabled(True)
        self.tableView.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
        self.verticalLayout.addWidget(self.tableView)
        self.groupBox = QtWidgets.QGroupBox(TableFilteringDialog)
        self.groupBox.setObjectName("groupBox")
        self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.groupBox)
        self.verticalLayout_2.setObjectName("verticalLayout_2")
 
        self.formLayout = QtWidgets.QFormLayout()
        self.formLayout.setObjectName("formLayout")
 
        #titre recherche
        self.column1Label = QtWidgets.QLabel(self.groupBox)
        self.column1Label.setObjectName("column1Label")
        self.column1Label.setStyleSheet("font: bold;")
        self.formLayout.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.column1Label)
 
        #champ de recherche date début
        self.column1Label2 = QtWidgets.QLabel(self.groupBox)
        self.column1Label2.setObjectName("column1Label2")
        self.formLayout.setWidget(2, QtWidgets.QFormLayout.LabelRole, self.column1Label2)
        self.column1Field = QtWidgets.QLineEdit(self.groupBox)
        self.column1Field.setObjectName("column1Field")
        self.column1Field.setMaximumWidth(300)
        self.formLayout.setWidget(2, QtWidgets.QFormLayout.FieldRole, self.column1Field)
        #champ de recherche date de fin
        self.column1Label3 = QtWidgets.QLabel(self.groupBox)
        self.column1Label3.setObjectName("column1Label3")
        self.formLayout.setWidget(3, QtWidgets.QFormLayout.LabelRole, self.column1Label3)
        self.column1Field2 = QtWidgets.QLineEdit(self.groupBox)
        self.column1Field2.setObjectName("column1Field2")
        self.column1Field2.setMaximumWidth(300)
        self.formLayout.setWidget(3, QtWidgets.QFormLayout.FieldRole, self.column1Field2)
        #éléments recherchés en risque incident
        self.column5Label = QtWidgets.QLabel(self.groupBox)
        self.column5Label.setObjectName("column5Label")
        self.column5Label.setStyleSheet("font: bold;")
        self.formLayout.setWidget(10, QtWidgets.QFormLayout.LabelRole, self.column5Label)
        self.column5Field = QtWidgets.QLineEdit(self.groupBox)
        self.column5Field.setObjectName("column5Field")
        self.column5Field.setMaximumWidth(300)
        self.formLayout.setWidget(10, QtWidgets.QFormLayout.FieldRole, self.column5Field)
        # éléments recherchés sans action
        self.column6Label = QtWidgets.QLabel(self.groupBox)
        self.column6Label.setObjectName("column6Label")
        self.column6Label.setStyleSheet("font: bold;")
        self.formLayout.setWidget(11, QtWidgets.QFormLayout.LabelRole, self.column6Label)
        self.column6Field = QtWidgets.QLineEdit(self.groupBox)
        self.column6Field.setObjectName("column6Field")
        self.column6Field.setMaximumWidth(300)
        self.formLayout.setWidget(11, QtWidgets.QFormLayout.FieldRole, self.column6Field)
 
        self.verticalLayout_2.addLayout(self.formLayout)
        self.verticalLayout.addWidget(self.groupBox)
        self.retranslateUi(TableFilteringDialog)
        QtCore.QMetaObject.connectSlotsByName(TableFilteringDialog)
 
    def retranslateUi(self, TableFilteringDialog):
        _translate = QtCore.QCoreApplication.translate
        TableFilteringDialog.setWindowTitle(_translate("TableFilteringDialog", "Dialog"))
        self.groupBox.setTitle(_translate("TableFilteringDialog", "Filters"))
 
        self.column1Label.setText(_translate("TableFilteringDialog", "Jour de réception"))
        self.column1Label2.setText(_translate("TableFilteringDialog", "Du"))
        self.column1Label3.setText(_translate("TableFilteringDialog", "Au"))
 
 
        self.column5Label.setText(_translate("TableFilteringDialog", "Risque d'incident client"))
        self.column6Label.setText(_translate("TableFilteringDialog", "Transfert sans action du service"))
 
 
class TableFilteringDialog(QtWidgets.QDialog):
 
    def __init__(self, parent=None):
        super(TableFilteringDialog, self).__init__(parent)
 
        self.ui = Ui_TableFilteringDialog()
        self.ui.setupUi(self)
 
        self.tableModel = PandasTableModel()
        header = ["Jour de réception","Jour de Réponse","Thème","Motif","Risque d'incident client","Transfert sans action du service","Matricule de saisie","Origine"]
        data = short_main_search_mois()
        self.tableModel.setupModel(header, data)
        self.ui.tableView.setModel(self.tableModel)
 
        self.ui.column1Field.textEdited.connect(self.filtersEdited)
        self.ui.column1Field2.textEdited.connect(self.filtersEdited)
        self.ui.column5Field.textEdited.connect(self.filtersEdited)
        self.ui.column6Field.textEdited.connect(self.filtersEdited)
 
 
 
    def filtersEdited(self):
        filters = {}
        values = [
            self.ui.column1Field.text().lower(),
            self.ui.column5Field.text().lower(),
            self.ui.column6Field.text().lower(),
            self.ui.column7Field.text().lower(),
        ]
        for col, value in enumerate(values):
            if value == '':
                continue
            column = self.tableModel.headerData(col, QtCore.Qt.Horizontal, QtCore.Qt.DisplayRole).value()
            if column== 'Jour de réception':
                try:
                    filters[column]=(datetime.datetime.strptime(value,'%d/%m/%Y').timestamp()),(datetime.datetime.strptime(self.ui.column1Field2.text().lower(),'%d/%m/%Y').timestamp()) 
                except ValueError:
                    continue
            else: 
                filters[column]=value
 
 
        self.tableModel.setFilters(filters)
 
 
if __name__ == '__main__':
 
    QtWidgets.QApplication.setStyle("Fusion")   
    app=QtWidgets.QApplication ([])
 
    win= MainWindow()
    win.show()      
    app.exec_()

Si besoin, pour faciliter les tests, je vous joins un code rapide pour créer la BDD et la recherche qui alimente mon PandasTableModel.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
 
import sqlite3
from datetime import datetime, timedelta
import os
 
# Création de la BDD
profile_user=os.getenv("USERNAME")
BDD=(f"C:\\Users\\{profile_user}\\Desktop\\bdd_de_test")
 
def creation_table_messages(arg, kwarg):
 
    connexion=sqlite3.connect(BDD)
    c=connexion.cursor()
 
    c.execute(f""" CREATE TABLE IF NOT EXISTS {arg}(
        Id INTEGER PRIMARY KEY AUTOINCREMENT,
        Jour_Heure_Reception text, 
        Jour_Heure_Reponse text, 
        Theme text,
        Motif text,
        Risque_incident_client text, 
        Transfert_sans_action text,
        Matricule text, 
        Origine text)""")
 
    connexion.commit()
    connexion.close();
 
    connexion=sqlite3.connect(BDD)
    c=connexion.cursor()
 
 
    c.execute(f""" INSERT INTO {arg}(Jour_Heure_Reception,Jour_Heure_Reponse,Theme,Motif,Risque_incident_client,Transfert_sans_action,Matricule,Origine) Values(?,?,?,?,?,?,?,?)""",kwarg)
    connexion.commit()
    connexion.close()
 
 
Jour_Heure_Reception="08/04/2020"
Jour_Heure_Reponse ="08/04/2020" 
Theme ="NA"
Motif ="NA"
Risque_incident_client ="Oui" 
Transfert_sans_action ="Oui"
Matricule ="NA" 
Origine ="NA"
 
 
liste_mail_feed=[Jour_Heure_Reception,Jour_Heure_Reponse,Theme,Motif,Risque_incident_client,Transfert_sans_action,Matricule,Origine]
 
 
creation_table_messages("Message", liste_mail_feed)
 
 
# recherche 
 
def short_main_search_mois():
    connexion = sqlite3.connect(BDD)
    c=connexion.cursor()
 
    date_selection= str((datetime.now() - timedelta(30)).strftime('%d/%m/%Y'))
 
    date_selection_stamp=(datetime.strptime(date_selection, '%d/%m/%Y').timestamp())
 
    yesterday= str((datetime.now() - timedelta(0)).strftime('%d/%m/%Y'))
 
    hier_stamp=(datetime.strptime(yesterday, '%d/%m/%Y').timestamp())
 
 
 
    c.execute(f"""
select Jour_Heure_Reception ,
        Jour_Heure_Reponse , 
        Motif ,
        Theme ,
        Risque_incident_client , 
        Transfert_sans_action ,
        Matricule , 
    Origine      from Message WHERE Jour_Heure_Reception >= "{date_selection_stamp}" and Jour_Heure_Reponse<="{hier_stamp}" """  )                 
 
    msm=c.fetchall()  
 
 
    return msm

Merci d'avance !

**wiztricks** · 09/04/2020, 13h22

Salut,

Envoyé par Tiedien

J'arrive à faire en sorte de retrouver les messages d'une date précise, mais impossible d'effectuer la recherche pour une plage de dates.

Quelqu'un aurait il une idée sur la marche à suivre pour pouvoir faire la recherche par plage de date ?

Vous nous montrez tout sauf ce que vous avez essayé pour filtrer le dataframe entre 2 dates.
Essayez de partir de DataFrame.between_time ou expliquez pourquoi çà ne s'applique pas (après avoir cherché un peu sur Internet).

- W

**Tiedien** · 09/04/2020, 15h17

Tout d'abord, merci beaucoup d'avoir pris le temps de me répondre.

C'est peut etre pas très claire d'isoler mes tentatives, mais j'ai mis l'intégralité du code pour que vous ayez quelque chose qui se lance.

Plus particulièrement, j'ai tenté de dissocier le filtrage si les champs renseignés concernent le jours de réception par ce code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def filtersEdited(self):
        filters = {}
        values = [
            self.ui.column1Field.text().lower(),
            self.ui.column5Field.text().lower(),
            self.ui.column6Field.text().lower(),
            self.ui.column7Field.text().lower(),
        ]
        for col, value in enumerate(values):
            if value == '':
                continue
            column = self.tableModel.headerData(col, QtCore.Qt.Horizontal, QtCore.Qt.DisplayRole).value()
            if column== 'Jour de réception':
                try:
                    filters[column]=(datetime.datetime.strptime(value,'%d/%m/%Y').timestamp()),(datetime.datetime.strptime(self.ui.column1Field2.text().lower(),'%d/%m/%Y').timestamp()) 
                except ValueError:
                    continue
            else: 
                filters[column]=value
        
            
        self.tableModel.setFilters(filters)

Ensuite, j'ai tenté de définir les critères de recherches entre les 2 dates, comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def updateDisplay(self):
        dfDisplay = self._dfSource.copy()
        print(dfDisplay.index)
        # Filtering
        cond = pd.Series(True, index = dfDisplay.index)
        
        if list((self._filters.values()))!=[]:
            for column, value in self._filters.items():
                if column =='Jour de réception':
                    cond = pd.Series(True, index = ["Jour de réception"])
                    date_début=(list(self._filters.values())[0][0])
                    date_fin=list(self._filters.values())[0][1]
                    cond = cond & \
                            (cond.loc[date_début:date_fin])
                    
                    dfDisplay = dfDisplay[cond]
                else: 
                    for column, value in self._filters.items():
                        cond = cond & \
                            (dfDisplay[column].str.lower().str.find(str(value).lower()) >= 0)
                        
                    dfDisplay = dfDisplay[cond]

J'ai pourtant passé de nombreuses heures (jours ? ) a chercher une solution, sans tomber sur cette méthode.

Je me penche dessus dès maintenant.

Filtrer un PandasTableModel entre 2 dates

Bibliothèques tierces Python

Discussions similaires

Partager

Partager