Discussion :

[Beginner.]

Salut,

J'ouvre ce fil pour ne pas embrouiller l'autre fil : organiser le code 1

J'aimerais savoir comment vous faites pour organiser votre code dans certaines situations :

Exemple 2 :

Une interface graphique dans laquelle il y a plein d'onglets (frames)...

Chacun d'eux contient des champs de saisi, des boutons...

Pour l'instant j'utilise une class pour chaque onglet...

Il y a par exemple des méthodes qui sont exécutées chaque fois qu'une donnée est saisie (par exemple pour mettre à jour les autres champs)...

Le problème c'est que les class (pour chaque onglet) peuvent dépendre les unes des autres mais que je voudrais quand même séparer le code dans différents fichiers...


Pour l'instant je fais du bricolage pareil que dans l'exemple de l'autre fil...

[wiztricks]

Le problème c'est que les class (pour chaque onglet) peuvent dépendre les unes des autres mais que je voudrais quand même séparer le code dans différents fichiers...

"peuvent dépendre" ne dit rien sur la relation de dépendance... mais effectivement, on ne pourra pas construire cela sans avoir travaillé la relation de dépendance entre classes(*) ou en utilisant des relations clés en main comme le propose Qt avec slots/signaux.
(*) et on est toujours dans de la POO... et l'existence de forums plus adaptés.

- W

[Beginner.]

Ah il y a une solution avec Qt... C'est donc que cela ne doit pas être aussi simple qu'on pourrait le croire...

Bon ben ça me rassure quelque part...

[wiztricks]

Techniquement cela réalise un pattern appelé observer comme mentionné dans cet article de wikipédia. Avec Tk, on peut réaliser la même chose en utilisant des Variables (si on veut faire çà côté Tk) où avec des class python.

- W

[Beginner.]

Il faudra que je regarde ça attentivement mais à première vue cela me fait penser aux Custom Events en JS...

[wiztricks]

Il faudra que je regarde ça attentivement mais à première vue cela me fait penser aux Custom Events en JS...

Il n'y a rien de très original la dedans... Et ce n'est pas difficile à réaliser avec Python voir par exemple le source d'events sur PyPI.
Mais cela reste une façon parmi d'autre pour relier des objets....
Suivant le cas d'autres méthodes seront plus pertinentes.

- W

[MPython Alaplancha]

Bonjour,

Ah il y a une solution avec Qt... C'est donc que cela ne doit pas être aussi simple qu'on pourrait le croire...

Bon ben ça me rassure quelque part...

...Avec Kivy, le pattern observer se fait avec classe EventDispatcher .
Perso, je ne l'utilise pas et n'en ai jamais encore éprouvé le besoin . De plus, j'us lu un avis qui mentionnait que l'usage pouvait rendre difficile à détecter et à suivre un bug ...
Est ce vraiment de bonne pratique?

Explicit is better than implicit.

[Sve@r]

Bonjour

Le problème c'est que les class (pour chaque onglet) peuvent dépendre les unes des autres mais que je voudrais quand même séparer le code dans différents fichiers...

Cela ne doit pas être. Chaque onglet a son propre objet et ça c'est bien. Ensuite on peut penser que la saisie/boutons de l'onglet est indépendant de tous les autres donc quand l'utilisateur fait sa saisie, la saisie est validée puis il passe à un autre onglet et idem. Et là ça marche.

Mais on a aussi le droit de dire que la saisie de l'onglet 2 dépend de ce qui a été saisi dans l'onglet 1 (imaginons une saisie un peu complexe donc découpée) et dans ce cas il faut passer par une espèce d'objet de contrôle.
Chaque onglet doit avoir un signal type "saisie terminée" qui est envoyé quand tous les champs qui le concernent sont bien remplis ; et l'objet "contrôle" associe ce signal à un slot chez-lui qui centralise la saisie de l'onglet.
Ensuite quand on passe à l'onglet suivant celui-ci récupère du contrôle les valeurs des autres onglets pour faire sa propre cuisine et etc. Il doit avoir une méthode "onShow()" dans un onglet qui permet de faire une action quand il est appelé. Et l'action c'est donc de récupérer de l'objet de contrôle les éléments dont il a besoin.

Et au final l'objet de contrôle, quand tout a été saisi, s'occupe alors de l'enregistrement de la saisie en bdd.

[Beginner.]

Il n'y a rien de très original la dedans... Et ce n'est pas difficile à réaliser avec Python voir par exemple le source d'events sur PyPI.

Ah oui cela correspond bien aux Custom Events en JS... Il y a aussi une class dans node.js et même PHP...

Mais on a aussi le droit de dire que la saisie de l'onglet 2 dépend de ce qui a été saisi dans l'onglet 1 (imaginons une saisie un peu complexe donc découpée) et dans ce cas il faut passer par une espèce d'objet de contrôle.

Oui c'est plus ce genre de situation et même plus compliqué : la dépendance pourrait aller dans les deux sens...

Chaque onglet doit avoir un signal type "saisie terminée" qui est envoyé quand tous les champs qui le concernent sont bien remplis ; et l'objet "contrôle" associe ce signal à un slot chez-lui qui centralise la saisie de l'onglet.
Ensuite quand on passe à l'onglet suivant celui-ci récupère du contrôle les valeurs des autres onglets pour faire sa propre cuisine et etc. Il doit avoir une méthode "onShow()" dans un onglet qui permet de faire une action quand il est appelé. Et l'action c'est donc de récupérer de l'objet de contrôle les éléments dont il a besoin.

Et au final l'objet de contrôle, quand tout a été saisi, s'occupe alors de l'enregistrement de la saisie en bdd.

Oui cela ressemble à ce que j'ai pu faire en JS, il faut que je réfléchisse à la question pour savoir jusqu'où on peut aller avec cette méthode...

Sinon je pense aussi à ce qu'on a vu dans l'autre fil...

[Beginner.]

Salut,

J'ai aussi vu une autre solution basée sur le principe mentionné par @fred1599 & @Sve@r (passage d'instance en argument) sauf que là la communication se fait dans les deux sens :

classA.py

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
from classB import ClassB
 
class ClassA:
    def __init__(self, class_b: ClassB):
        self.ref_to_class_b = class_b
        self.data_in_classA = "Data in classA"
 
    def communicate_to_b(self):
        print("from ClassA to ClassB:", self.ref_to_class_b.data_in_classB)
        self.ref_to_class_b.method_in_classB()
 
    def method_in_classA(self):
        print("Method in ClassA")

classB.py

Code python :

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
from typing import TYPE_CHECKING
 
if TYPE_CHECKING:
    from classA import ClassA
 
 
class ClassB:
    def __init__(self, class_a: "ClassA"):
        self.ref_to_class_a = class_a
        self.data_in_classB = "Data in classB"
 
    def communicate_to_a(self):
        print("from ClassB to ClassA:", self.ref_to_class_a.data_in_classA)
        self.ref_to_class_a.method_in_classA()
 
    def method_in_classB(self):
        print("Method in ClassB")

main.py

Code python :

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

1
2
3
4
5
6
7
8
9
from classA import ClassA
from classB import ClassB
 
a = ClassA(None)
b = ClassB(a)
a.ref_to_class_b = b  
 
a.communicate_to_b()  # Communication de ClassA à ClassB
b.communicate_to_a()  # Communication de ClassB à ClassA

---> L’inconvénient que je vois pour l'instant c'est qu'il me semble que cela deviendrait plus compliqué dans le cas où on aurait plus de deux class, plus il y a de class et plus cela devient compliqué...

Pour ce cas j'ai trouvé une autre solution...


PS : cette partie :

Code python :

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

1
2
3
4
from typing import TYPE_CHECKING
 
if TYPE_CHECKING:
    from classA import ClassA

C'est pour pouvoir indiquer le typage :"ClassA" (cf.ci-dessous) en évitant les imports circulaires...

Sous VS Code j'obtiens une bonne assistance : autocomplétion, re-factoring, go to definition...

Il faut mettre le type en string ("ClassA") :

Code python :

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

1
2
class ClassB:
    def __init__(self, class_a: "ClassA"):

[wiztricks]

L’inconvénient que je vois pour l'instant c'est qu'il me semble que cela deviendrait plus compliqué dans le cas où on aurait plus de deux class, plus il y a de class et plus cela devient compliqué...

C'est une généralisation/extension du pattern observer (dont on a déjà parlé) qui s'appelle publish-subscribe.
Ils donnent en référence la bibliothèque externe pypubsub avec un cas d'utilisation (dans la documentation) qui mérite d'être lue.


- W

[papajoker]

cela deviendrait plus compliqué

Il faudrait déjà savoir quelle est ta véritable demande !

Si tu désires une "super" architecture: il faut déjà vouloir tout jeter (sauf formules mathématiques)
Créer des architectures est un gros savoir : cela demande autant de temps que d'apprendre python (minimum: SOLID et design pattern). Donc vouloir le faire immédiatement sur ton projet en cours n'a pas de sens.
Entre architecture/étude, codage, tests-debug, on arrive souvent à des ordres de grandeur du type 30% / 30% / 30%. Es-tu prêt à grandement retarder (encore ton projet) ? À repartir de zéro ?

Utiliser une bonne architecture, avec les bons principes, c'est un code au départ bien plus compliqué (longuement pensé dès le départ). L'intérêt est surtout pour partager son code avec une équipe (pas ton cas) et pour avoir une maintenance plus simple à long terme (tu comptes encore retravailler sur ton projet dans 1..3 ans ?)

ps: ne pas confondre avec "bien ranger ces fichiers dans une arborescence fichier", cela n'est pas lié au code.

Note: on trouve énormément de documentation sur le web puisque ce sujet est plus lié à la poo que à python et parce que l'objet n'est plus tout jeune.

[Beginner.]

Salut,

Je pense que le pattern qui se rapproche de ce que tu souhaites est le pattern Observer.

C'est une généralisation/extension du pattern observer (dont on a déjà parlé) qui s'appelle publish-subscribe.
Ils donnent en référence la bibliothèque externe pypubsub avec un cas d'utilisation (dans la documentation) qui mérite d'être lue.

Merci à vous deux. J'ai commencé à regarder, il faut que j’approfondisse... Il me semble que cela ressemble aux slots/signaux déjà évoqués sauf que là ce n'est pas propre à Qt...

Il faudrait déjà savoir quelle est ta véritable demande !

Ben c'est simple, je pensais même que c'était un problème classique, répandu et auquel beaucoup ont déjà eu à faire...

Comme expliqué au premier message :

On a une interface graphique dans laquelle il y a plein d'onglets (frames) et même des fenêtres enfants...

Chacun d'eux contient des champs de saisi, des boutons...

Il y a par exemple des méthodes qui sont exécutées chaque fois qu'une donnée est saisie, par exemple pour mettre à jour les autres champs, pour tracer les courbes en fonction des nouveaux paramètres...

Le problème c'est que les class (pour chaque onglet) peuvent dépendre les unes des autres mais que je voudrais quand même séparer le code dans différents fichiers...

Alors par exemple on peut saisir des nouveaux paramètres dans l'onglet 1 et alors l'onglet 2 doit être mis à jour automatiquement (question de cohérence). Et cela peut aller dans les deux sens...

Voilà restons sur cet exemple simple alors ma question c'est comment ce problème est résolu en général ?

Parmi vous il doit y en avoir qui ont déjà eu à faire ça ou bien à répondre à quelqu'un qui eu à faire ça, non ? Ou bien ça n'arrive jamais ?

---> Pour l'instant il y a la solution du pattern observer et aussi la solution dont j'ai donné un exemple au message #9 (je ne sais pas ce qu'elle vaut mais j'ai une variante qui me semble meilleure...)

Si tu désires une "super" architecture: il faut déjà vouloir tout jeter (sauf formules mathématiques)
Créer des architectures est un gros savoir : cela demande autant de temps que d'apprendre python (minimum: SOLID et design pattern). Donc vouloir le faire immédiatement sur ton projet en cours n'a pas de sens.

Non effectivement je ne cherche pas à faire une "super" architecture mais juste à faire ce qui est souvent conseillé, à juste titre selon moi, à savoir organiser/structurer son code (fonctions/class, modules, packages...).

C'est plus facile de s'y retrouver, si j'ai un problème ou si je veux mettre à jour une fonctionnalité, c'est plus facile de trouver le bon module que de chercher la partie du code qui nous intéresse parmi des milliers de ligne contenus dans un seul fichier...

Et il y a aussi la réutilisation des modules dans d'autres projets...

ps: ne pas confondre avec "bien ranger ces fichiers dans une arborescence fichier", cela n'est pas lié au code.

Oui mais si les codes contenus dans ces fichiers dépendent les uns des autres, il faudra bien faire quelque chose, non ?

Utiliser une bonne architecture, avec les bons principes, c'est un code au départ bien plus compliqué (longuement pensé dès le départ). L'intérêt est surtout pour partager son code avec une équipe (pas ton cas) et pour avoir une maintenance plus simple à long terme (tu comptes encore retravailler sur ton projet dans 1..3 ans ?)

Oui c'est vrai, je pourrais me passer d'une bonne architecture d'ailleurs comme je disais pour l'instant je bricole comme je peux...

[Beginner.]

Pour l'instant il y a la solution du pattern observer que j’espère approfondir plus tard et il y a aussi la solution dont j'ai donné un exemple au message #9 , je ne sais pas ce qu'elle vaut mais j'ai une variante qui me semble meilleure et j'aimerais savoir ce que vous en pensez...

Cette "solution" me semble meilleure que l'autre (du message #9) surtout dans le cas où on a plus de deux class...

Une chose que j'apprécie c'est que sous VS Code j'obtiens une bonne assistance : autocomplétion, re-factoring, go to definition... Et la coloration syntaxique indique tout de suite si un attribut ou une méthode n'existe pas dans la class...

Voici un exemple avec trois class (la communication peut faire dans tous les sens) :

main.py

Code python :

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
from classA import ClassA
from classB import ClassB
from classC import ClassC
 
class ClassABC:
 
    def __init__(self):
        self.a = ClassA(self)
        self.b = ClassB(self)
        self.c = ClassC(self)
 
 
abc = ClassABC()
 
abc.a.communicate_to_b()
abc.a.communicate_to_c()
 
abc.b.communicate_to_a()
abc.b.communicate_to_c()
 
abc.c.communicate_to_a()
abc.c.communicate_to_b()

classA.py

Code python :

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
from typing import TYPE_CHECKING
 
if TYPE_CHECKING:
    from main import ClassABC
 
 
class ClassA:
    def __init__(self, class_abc: "ClassABC"):
        self.class_abc = class_abc
        self.data_in_classA = "Data in classA"
 
    def method_in_classA(self):
        print("Method in ClassA")
 
    def communicate_to_b(self):
        print("\nfrom ClassA to ClassB:", self.class_abc.b.data_in_classB)
        self.class_abc.b.method_in_classB()
 
    def communicate_to_c(self):
        print("\nfrom ClassA to ClassC:", self.class_abc.c.data_in_ClassC)
        self.class_abc.c.method_in_ClassC()

classB.py

Code python :

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
from typing import TYPE_CHECKING
 
if TYPE_CHECKING:
    from main import ClassABC
 
 
class ClassB:
    def __init__(self, class_abc: "ClassABC"):
        self.class_abc = class_abc
        self.data_in_classB = "Data in classB"
 
    def method_in_classB(self):
        print("Method in ClassB")
 
    def communicate_to_a(self):
        print("\nfrom ClassB to ClassA:", self.class_abc.a.data_in_classA)
        self.class_abc.a.method_in_classA()
 
    def communicate_to_c(self):
        print("\nfrom ClassB to ClassC:", self.class_abc.c.data_in_ClassC)
        self.class_abc.c.method_in_ClassC()

classC.py

Code python :

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
from typing import TYPE_CHECKING
 
if TYPE_CHECKING:
    from main import ClassABC
 
 
class ClassC:
    def __init__(self, class_abc: "ClassABC"):
        self.class_abc = class_abc
        self.data_in_ClassC = "Data in ClassC"
 
    def method_in_ClassC(self):
        print("Method in ClassC")
 
    def communicate_to_a(self):
        print("\nfrom ClassC to ClassA:", self.class_abc.a.data_in_classA)
        self.class_abc.a.method_in_classA()
 
    def communicate_to_b(self):
        print("\nfrom ClassC to ClassB:", self.class_abc.b.data_in_classB)
        self.class_abc.b.method_in_classB()

[fred1599]

Je pense que le pattern qui se rapproche de ce que tu souhaites est le pattern Observer.

[fred1599]

Hello,

@Beginner,

La manière dont tu as développé classA, B et C et ABC ne correspondent pas à un pattern Observer.

Pour modéliser un peu,

1. Tes onglets seront chacun composés d'un observateur (on pourrait même dire que chacun de tes onglets est un observateur). Perso je préfère la composition...
2. Ton interface composée de tes onglets sera également composée d'un notificateur (gestionnaire des observateurs).
3. L'observateur envoi des messages, signaux, ... lors de la mise à jour ou d'un mouvement quelconque de tes onglets (à mon sens, la création d'un observateur pourrait prendre comme paramètre un callback).
4. Le notificateur va notifier l'interface (application) en envoyant tous les messages, signaux, ... écoutés par tes observateurs.

Maintenant j'ai quelques questions,

1. Qu'est-ce qui justifie la création d'une classe par onglet ? (Y a-t-il tellement d'actions liées à un onglet ?)
2. Quels sont les signaux que peuvent bien envoyer un onglet ? (Si peu de complexité dans les messages, signaux, est-ce que ça nécessite un pattern Oberver ?)