Discussion :

[papajoker]

Pour forcément à utiliser dans ton cas ...

Qt a son propre système (pas du mvc classique) et c'est dans la doc !

python ou C++ c'est la même doc
Note: pySide est la lib officielle python pour faire du Qt

Puisque tu utilises un formulaire, la solution pour ton besoin spécifique serait le QDataWidgetMapper ( et est dispo un exemple)

---------

Si on désire une classe particulière pour le controleur/présentateur, rien n'est fait mais c'est possible, voir cet exemple mais, surtout cet article (en)



=========
Re-note: pour moi, c'est une aberration d'écrite un outil en Qt pour un bureau gnome !!!!
https://github.com/Taiko2k/GTK4PythonTutorial
https://github.com/yucefsourani/pyth...-gtk4-examples
https://discourse.gnome.org/tag/python

[fred1599]

Je n'ai fais qu'un projet professionnel en PyQt, autant dire que je ne suis pas expérimenté avec... Je ne vais pas avoir une critique sur l'utilisation de Qt !
Une de mes erreurs (en ce qui me concerne, car l'entreprise ne voit pas le mal) avaient été de rendre ce projet totalement dépendant de PyQt.

Imaginons, que je veuille passer de PyQt à wxPython ou à Kivy ? Est-ce que tout mon code est bon à mettre à la poubelle ? Sur mon projet, oui !

C'est pour cela que maintenant dans tous mes projets je fais une fixette sur l'architecture du projet, c'est pour moi un temps que je ne négocie jamais avec mes chefs... L'objectif est de permettre d'ajouter du code, et de ne jamais en supprimer (évolution permanente).

Si ça vous intéresse, je vous propose de lire ce blog qui parle de la "clean architecture" d'Uncle Bob, tout est indépendant (si je veux passer de SQL à NoSQL par ex., ça doit être possible sans rien supprimer de l'existant SQL) !
J'ai bien évidemment le bouquin qui est je dois dire complexe à lire (pas parce-qu'il est en anglais, mais un peu vaste, on s'attend à plus de précision).

C'est très appréciable de se dire que ses projets persistent dans le temps, et à vrai dire aux nombres importants de projets que j'ai pu lire, très rarement je rencontre ce type d'architecture (rencontré 1x dans ma carrière).

Et perso, comme Sve@r, l'IHM n'est que Vue ! Mais cela implique de nombreux découpage de modules, une organisation plus complexe au départ, mais avec de nombreux avantages par la suite, comme par exemple la simplification des tests unitaires, une évolution rapide du projet, etc.

[Sve@r]

Une de mes erreurs (en ce qui me concerne, car l'entreprise ne voit pas le mal) avaient été de rendre ce projet totalement dépendant de PyQt.
Imaginons, que je veuille passer de PyQt à wxPython ou à Kivy ? Est-ce que tout mon code est bon à mettre à la poubelle ? Sur mon projet, oui !

Et perso, comme Sve@r, l'IHM n'est que Vue ! Mais cela implique de nombreux découpage de modules, une organisation plus complexe au départ, mais avec de nombreux avantages par la suite, comme par exemple la simplification des tests unitaires, une évolution rapide du projet, etc.

Et hélas c'est le cas de beaucoup. Parce qu'entre écrire directement son select truc from machin dans le widget Qt qui va afficher les datas ou créer la classe modele.select qui va se charger de récupérer les datas en cohérence avec le vrai MVC les sirènes de la tentation et de la facilité font malheureusement que...
Certes dans mes projets mes tables sont toutes gérées par un objet dédié qui contient les méthodes "update" et "delete" mais pour le select... Je pense que le vrai et pur MVC, celui qui permet de changer facilement et immédiatement X par Y est une utopie.
- est-ce que le côté obscur est le plus fort ?
- non ! seulement plus facile, plus rapide, plus séduisant le côté obscur est.

[fred1599]

Le "côté obscur" n'est pas plus fort, mais il requiert une discipline et une vision à long terme pour résister à ses tentations.
Les bénéfices d'une architecture propre et d'une conception réfléchie surpassent largement les facilités de développement à court terme.

Le "côté obscur" (opter pour la facilité et la rapidité à court terme) peut sembler attrayant, mais il conduit souvent à une dette technique accrue et à des difficultés lorsqu'il s'agit d'adapter ou d'étendre l'application.

[papajoker]

Note sur les model Qt : ce ne sont que des interfaces entre un widget et des datas ! Nous pouvons donc avoir des datas indépendantes de l'interface et suivre facilement le paradigme de fred1599 (à cette étape)

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
@dataclass
class Person:
    nom: str
    age: int
 
class Metier:
    def __init__(self):
        self._datas = {}
    def retourne(self, index):
        return self._datas[index]
    def change(self, index, person):
        if person.age < 18:
            raise Exception("règle métier")
        self._datas[index] = person
    def count(self):
        return len(self._datas)
 
class personnes_model(QtCore.QAbstractListModel, database_connecteur="'il vient de la gui ? non"):
    def __init__(self, parent=None):
        super().__init__(parent)
        self._datas = Metier(database_connecteur)
 
    def rowCount(self, parent=QtCore.QModelIndex()):
        return self._datas.count()
 
    def data(self, index, role):
        if role == QtCore.Qt.DisplayRole:
            return self._datas.retourne(index.row()).nom
        if role == QtCore.Qt.UserRole + 666:   # vouloir l'objet dans la GUI ? c'est le diable (si il est mutable)
            return self._datas.retourne(index.row())
 
    def addRow(self, name, age):
        self._datas.ajout(Person(name, age))
 
    def removeRow(self, index):
        pass

ps: ne pas chercher ici une logique métier ou pythonnesque à la classe Métier

[MPython Alaplancha]

Bonjour,
Pourquoi te limiter dans ta présentation à Ubuntu? Perso, j'aurai dit pour Debian et dérivés (ubuntu , mint, ...)

[Diablo76]

Salut,

Bonjour,
Pourquoi te limiter dans ta présentation à Ubuntu? Perso, j'aurai dit pour Debian et dérivés (ubuntu , mint, ...)

Oui, tu as raison, je dois être plus générique.

Re-note: pour moi, c'est une aberration d'écrite un outil en Qt pour un bureau gnome !!!!

En quoi c'est aberrant ?? Qt, je l'utilise également sur MacOS et Windows

Edit: Mon environnement n'est pas basé sur Gnone mais Kde :

Système d'exploitation*: Ubuntu Studio 22.04
Version de KDE Plasma*: 5.24.7
Version de KDE Frameworks*: 5.92.0
Version de Qt*: 5.15.3
Version de noyau*: 6.5.0-17-lowlatency (64-bit)
Plate-forme graphique*: X11

[papajoker]

Voici un code presque fonctionnel.

Model python <-> model QT <-> GUI (QDataWidgetMapper <-> formulaire)

Particularité : utilise un QDataWidgetMapper pour lier le formulaire à un modelQT. Si on utilise une table ou treeview alors ce composant intermédiaire n'a pas lieu d'exister.

Le modèle "classique" est quasiment dépourvu de QT, sauf, que ici on modifie d'autres champs en fonction de la saisie de l'utilisateur. Pas une chose classique mais cela entraine un petit code supplémentaire (qt) qui peut parfois être utile. Notre modèle reste autonome (fonctionne avec -t passé en paramètre à l'application).
Le modèle ne gère ici pour démo que "Exec" et "Icone"

Note: ici, il y a des conversions dans les 2 sens entre les noms des champs et les index des variables, il y a moyen d'optimiser. Mais avec ce code, on peut par conséquent voir que le format des modèles est beaucoup plus libre (on descend et remonte toujours le numéro de la colonne et la clé associée à ce numéro).

Le modèle QT est classique, avec 2 méthodes pour lire une cellule et une autre pour écrire. Ici, il ne sert que d'interface avec notre modèle et la vue. Une grosse partie du travail est faite avec la transmission de messages.

La "vue" (fenêtre principale) : plus aucun code lié au métier (sauf création des champs du formulaire), on peut donc se focaliser ici entièrement à la GUI. En fait ici, il n'y a que __init__()

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
#!/usr/bin/env python
from pathlib import PurePath
from textwrap import dedent
import sys
try:
    from PySide6.QtWidgets import (
        QApplication, QMainWindow, QDialogButtonBox,
        QGroupBox, QLineEdit, QFormLayout,
        QDataWidgetMapper, QVBoxLayout, QHBoxLayout,
        QWidget, QComboBox
    )
    from PySide6.QtGui import QStandardItemModel, QIcon
    from PySide6.QtCore import Qt, QObject, Signal, QModelIndex, QCoreApplication, QLibraryInfo, QTranslator
except ImportError:
    print("ERREUR: installez pyside 6 !")
    exit(13)
 
"""
https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#recognized-keys
"""
 
TEMPLATE = {
    "exec" : {
        "msg": "Le fichier à exécuter",
        "type": 1
    },
    "name" : {
        "msg": "",
        "type": 1
    },
    "icon": {
        "msg": "Fichier .png ou nom d'une icone dans notre thème",
        "type": 1
    },
    "comment": {
        "msg": "",
        "type": 1
    },
    "type" : {
        "msg": ("Application","Link","Directory"),
        "type": 2
    },
    "path" : {
        "msg": "",
        "type": 1
    },
    "categories" : {
        "msg": ["Development","System", "Utility"],
        "type": 3
    },
}
 
"""
voir la fonction test() pour l'écrire/mini test de cette classe (app -t)
"""
class Work(QObject):
 
    onchange = Signal(int, str)  # pour GUI refresh
 
    def __init__(self) -> None:
        super().__init__()
        self.error = ""
        self._exec = ""
        self.type = ""
        self.name = ""
        self.comment = ""
        self._icon = ""
        self.path = ""
        self.categories = []
        self.type = "Application"
 
    @property
    def exec(self):
        return self._exec
    @exec.setter
    def exec(self, value):
        self.error = ""
        self._exec = value
        path = None
        if not self.name:
            path = PurePath(self.exec)
            self.name = path.stem
            self.onchange.emit(self.key_to_int("name"), "name")
        if not self.icon and self.name:
            self.icon = self.name
 
    @property
    def icon(self):
        return self._icon
    @icon.setter
    def icon(self, value):
        self.error = ""
        if value:
            ico = QIcon.fromTheme(value)
            if ico.isNull():
                self.error = "icone non trouvée dans le theme courant"
                return
        self._icon = value
        self.onchange.emit(self.key_to_int("icon"), "icon")
 
    def __str__(self) -> str:
        return dedent(
            f"""
                [Desktop Entry]
                Type={self.type}
                Name={self.name}
                Comment={self.comment}
                Exec={self.exec}
                Icon={self.icon}
 
                # erreur: {self.error}
            """
        )
 
    @staticmethod
    def key_to_int(key):
        return list(TEMPLATE.keys()).index(key)
 
 
class FormModel(QStandardItemModel):
    """ interface QT liée a mon métier """
    cols = tuple(k for k in TEMPLATE)
    error = Signal(str)
 
    def __init__(self, parent):
        super().__init__(1, len(TEMPLATE), parent=parent)
        self._datas = Work()
        self._datas.onchange.connect(self.onUpdate)
 
    def data(self , index , role):
        if not index.isValid():
            return
        if role in (Qt.EditRole, Qt.DisplayRole):
            """ texte par défaut à l'édition """
            key = self.cols[index.column()]
            return getattr(self._datas, key)
        if role == Qt.UserRole:
            return self.cols[index.column()]
        return super().data(index, role)
 
    def setData(self, index, value, role) -> bool:
        if not index.isValid():
            return
        if role == Qt.EditRole:
            self._datas.error = "" #puisque un seul setter existe dans la classe Work
            key = self.cols[index.column()]
            setattr(self._datas, key, value)
            self.error.emit(self._datas.error if self._datas.error else "")
            return True
        return False
 
    def onUpdate(self, col, key):
        self.beginResetModel()
        index = self.index(0, col, QModelIndex())
        self.dataChanged.emit(index, index, Qt.DisplayRole)
        self.endResetModel()
 
 
class MainWin(QMainWindow):
    """ fenetre principale """
 
    def __init__(self):
        super().__init__()
        self.resize(790, 50)
        self.setWindowTitle("model Qt lié a model classique python")
        self.edits = {}
        for key in TEMPLATE.keys():
            if TEMPLATE[key]["type"] != 2:
                self.edits[key] = QLineEdit()
            else:
                self.edits[key] = QComboBox()
                self.edits[key].addItems(TEMPLATE[key]["msg"])
            self.edits[key].setPlaceholderText(str(TEMPLATE[key]["msg"]))
 
        btnWidget = QWidget()
        layout = QHBoxLayout()
        savetBtn = QDialogButtonBox(QDialogButtonBox.StandardButton.Save)
        exitBtn = QDialogButtonBox(QDialogButtonBox.StandardButton.Close)
        savetBtn.clicked.connect(self.save_file)
        exitBtn.clicked.connect(self.close)
        layout.addWidget(savetBtn, stretch=1, alignment=Qt.AlignmentFlag.AlignRight)
        layout.addWidget(exitBtn)
        btnWidget.setLayout(layout)
 
        self.formGroupBox = QGroupBox("Données")
        self.form = QFormLayout()
        for key in TEMPLATE.keys():
            self.form.addRow(
                f"{key.capitalize()} :",
                self.edits[key]
            )
        self.formGroupBox.setLayout(self.form)
 
        mainLayout = QVBoxLayout()
        mainLayout.addWidget(self.formGroupBox)
        mainLayout.addWidget(btnWidget)
 
        widget = QWidget()
        widget.setLayout(mainLayout)
        self.setCentralWidget(widget)
        self.statusBar()
 
        self._setupModel()
 
    def _setupModel(self):
        self.model = FormModel(self)
        self.model.error.connect(self.onError)
        self.model.dataChanged.connect(self.onDataChanged)
        self.mapper = QDataWidgetMapper()
        self.mapper.setModel(self.model)
        self.model.modelReset.connect(self.mapper.toFirst)
        for i, key in enumerate(TEMPLATE.keys()):
            self.mapper.addMapping(self.edits[key], i)
        self.mapper.toFirst()
 
    def onError(self, msg):
        self.statusBar().showMessage(msg)
 
    def onDataChanged(self, item, _):
        print("maj de", item.data(Qt.UserRole))
        if item.column() == 2:
            ico = item.data(Qt.DisplayRole)
            if ico:
                QApplication.setWindowIcon(QIcon.fromTheme(item.data(Qt.DisplayRole)))
 
    def save_file(self):
        print(self.model._datas)
 
app = None
def run():
    """gui"""
    app = QApplication(sys.argv)
    app.setWindowIcon(QIcon.fromTheme("desktop"))
    trans = QTranslator()
    trans.load('qt_fr', QLibraryInfo.path(QLibraryInfo.LibraryPath.TranslationsPath))
    QCoreApplication.installTranslator(trans)    # dialogues/btn en fr
 
    win = MainWin()
    win.show()
    sys.exit(app.exec())
 
 
def test():
    """ si on ne travaille que sur la classe métier """
    work = Work()
    work.exec = "pacman"
    print(work)
    work.exec = "/usr/bin/pacman.sh"
    print(work)
    exit(0)
 
if __name__ == "__main__":
    if "-t" in sys.argv:
        test()
    run()

Edit: Mon environnement n'est pas basé sur Gnone mais Kde :

Système d'exploitation*: Ubuntu Studio 22.04

Donc ce n'est pas la ubuntu (classique) et bien sûr existe quelques dérivées de ubuntu avec kde (la tienne, kunbutu et neon).
ps: Du coup, tu aurais pu utiliser le logo de ta distribution (bien différent de celui que tu utilises dans ton code)

[fred1599]

Salut !

@papajoker,

J'avoue ne pas avoir tout compris et savoir où tu voulais en venir avec ce code... est-ce que te concernant tu lies ce code a ce qui a été dit dans ma précédente conversation ?

Je l'ai testé avec PyQt6 n'ayant pas PySide6, cependant je ne vois pas concrètement ce que tu souhaites souligner, ni ce que techniquement on doit en retenir... Imaginons que tu expliques à un dev junior ce code, que doit-il en retenir et quelle expérience souhaite tu lui faire partager ? En plus, me concernant je suis une bille en Qt

[papajoker]

Ce code était uniquement la suite du message #25 : juste un code fonctionnel
ps: ne pas tenir compte que tout est dans le même fichier c'est uniquement par facilité pour ce forum

Je viens de voir ton code Arborescence…
Et je me rends compte que nous avons une vue sur QT complètement différente (Et donc ton bon exemple sur l'autre sujet ne me convient pas du tout).

Les models QT :

Pour moi, il est incompréhensible de s'en passer (sauf GUI extrêmement simple)

Exemple:
si j'utilise un modelQt, tout mes widgets attachés a lui vont être actualisés en temps réel
- si j'ai dans ma barre d'outil générale un filtre, l'autocomplétion va s'adapter dès que l'utilisateur ajoute un enregistrement (par exemple un filtre sur "ville"). Même chose si j'ai un combobox
Donc, avec un modèle, toutes les vues attachés sont mises à jour automatiquement au moindre changement.

Exemple:
Si j'utilise un modelQt, nous avons les proxy (datas aussi en temps réel). Un proxy peut servir pour un filtre, mais aussi pour fournir un "nouveau" modèle qui lui aussi est lié à notre modelQT de base

Exemple:
- Parfois, pour la gestion fine de l'affichage d'une cellule, nous avons QStyledItemDelegate qui reçoit un item(gui) lié à notre modèleQt
- avec un QItemDelegate (.setModelData exemples) particulier, je vais pouvoir lier notre modelQT à ce délégé pour un comboBox; exemple: delégé ne retourne qu'une seule colonne et affichée différemment pour ce combo: un combo (temps-réel) avec "ville+cp" tirés de notre modèle


Puisque je dois absolument utiliser les modelQT, si je veux avoir quand même un modèle python plus classique (utilisable en tests), j'ai donné une recette ici. Et ce modèle (classique*) python à la particularité d'envoyer des messages à la gui lors de modification (pas un refresh de la vue mais uniquement de la cellule)
*"classique" : pas vraiment dans ce cas car le cahier des charges du départ n'est pas classique (un seul enregistrement), j'ai juste voulu faire simple (minimum de lignes pour ce fichier) et relativement général (manque ajout et suppression)

Je l'ai testé avec PyQt6 n'ayant pas PySide6

Comme indiqué plus haut #21, pyside est la lib officielle de la société qui fournit QT. Je ne vois pas l'intérêt d'utiliser une lib non officielle
ps: ok, cela n'a que quelques années, mais en dev les choses évoluent, avant pyside était le vilain petit canard et pyqt la seule solution.

[fred1599]

Comme indiqué plus haut #21, pyside est la lib officielle de la société qui fournit QT. Je ne vois pas l'intérêt d'utiliser une lib non officielle

C'est juste parce-que j'ai un PyQt6 sous la main, et que je ne souhaitais pas créer un nouvel environnement juste pour installer PySide6.

Non officielle ou pas, si elle existe c'est pour être utilisée... tout autant que PySide dans le temps où c'était le vilain petit canard.

Pour moi, il est incompréhensible de s'en passer (sauf GUI extrêmement simple)

Tu as beaucoup de termes où on sent un manque d'ouverture sur ce qui peut se faire dans le monde informatique ... "je ne vois pas l'intérêt, incompréhensible, je dois absolument"... si je te comprend bien, je jette PyQt6, la clean architecture n'a pas d'intérêt et je dois absolument utiliser les models Qt ?

Mais je ne comprend pas en quoi cette architecture empêche l'utilisation des models Qt, j'ai dû manquer quelque chose ? Je ne l'ai peut-être pas utiliser dans mon exemple, mais ça ne veut pas dire que je fais le choix de m'en passer dans d'autres cas !

[papajoker]

Tu as beaucoup de termes où on sent un manque d'ouverture

N'importe quoi !
je te dis que mon besoin est très différent du tien ! C'est pourtant clair ! Perso, j'ai besoin des modelQt dans 80% des cas (avec gtk c'est un autre système, les xxStore).
Donc, je persiste, pour moi, c'est un impératif d'utiliser les modèles natifs qt ou gtk.

je dois absolument utiliser les models Qt ?

Pour moi, renier une technologie est un manque d'ouverture ! moi, je dis, que je désire utiliser à mon maximum une techno. (c'est comme dire, je ne veux pas utiliser le css pour du web)

la clean architecture n'a pas d'intérêt

Toi, dans ton exemple "clean architecture", tu zappes une technologie, je vais en déduire que tu as un manque d'ouverture ? (bien sûr que non) je peux juste te dire que ton exemple dans cet état ne me convient pas. L'architecture de ton exemple est très très bonne, j'ai dit le contraire ? c'est encore du n'importe quoi.

si je te comprend bien, je jette PyQt6

Les 2 sont extrêmement proches en code, je souligne uniquement celle qui est officielle : beaucoup de personnes utilisent pyQt car c'est l'historique (sans connaitre pyside). Puisque tu disais ne pas trop bien connaitre Qt, c'était peut-être une chose que tu ne connaissais pas. ici aussi c'est du n'importe quoi, tu déformes une information en une demande/règle. Je développe encore parfois avec pyQt !
J'ai parlé plusieurs fois de qml sur ce forum (en bien), tu en déduits que je cherche à l'imposer au détriment de pyqt et pyside ?