Robot

Le poste de contrôle (PC) / Infrastructure /
Infrastructure

Base de travail pour les graphes et les calculs

Avant-propos

Révision et amélioration du code :

Chaque scène est affichée dans un onglet du panneau central.
Chaque scène est modélisée par son super-dictionnaire od_pkl : self.o_pkl.od_pkl.
Ce dictionnaire peut être affiché pour effectuer un debug : od_pkl.print().
Il contient les valeurs réelles des éléments du graphe dont les paramètres ont été modifiés :
- Ceux des nodes.
- Ceux de la scène.
- Ceux de la vue.
- Ainsi que la liste des edges.
Au démarrage de l'application et lors de l'ajout d'un graphe, ce super-dictionnaire est créé à la fin de la méthode Pkl.restore(), grace à la lecture du fichier params.pkl.
On peut optimiser ce dictionnaire en limitant le nombre de nodes dans le graphe, ce qui a pour conséquence :
- De trier le dictionnaire, en plaçant les clés modifiées en tête.
- De supprimer automatiquement les dernières clés, au delà du nombre maximum autorisé.
- Tri et suppression sont confiés à la méthode Dictionary._sort_cut().

Remplacer la dernière ligne de Pkl.restore() par celle-ci :

        self.od_pkl = Dictionary(d_pkl, max_keys=100)  # OrderedDict de tout le graphe (vue + nodes + edges)

Le nombre maximum de clés est 100, vous pouvez le modifier.

Oui mais ... il apparaît une erreur, car on ne peut pas modifier un dictionnaire (le tri) pendant une boucle de lecture.
Corrigeons ce bug, en retirant une ligne, placée là par erreur, dans utils.py > Dictionary.read() :
- Supprimer ou commenter la ligne : self._sort_cut(l_keys[0]).
- En effet, cet appel doit exister dans Dictionary.write() mais pas dans Dictionary.read().
Vérifier.

Description

Problème à résoudre :

Un node inactif devient grisé ⇒ tous ses edges se désactivent (grisés).

Le problème à résoudre est le suivant :
- Un node est inactif lorsque :
  - Sa checkbox est décochée (exemple RSI dans cette image).
  - Toutes ses cases 'Signal actif' sont décochées (MACD dans cette image).
  - Il possède des entrées mais qu'aucun edge n'y est connecté.
  - Il possède des sorties mais qu'aucun edge n'y est connecté.
  - Il y a des edges aux entrées mais ils sont tous inactifs.
  - Il y a des edges aux sorties mais ils sont tous inactifs.
- Un edge est inactif lorsque :
  - Au moins l'un des 2 nodes qu'il relie est inactif (exemple.: liaison MACD-2 → Plots-6).
Dans cet exemple :
- MACD est inactif car le seul signal en entrée est inactif (case décochée dans les paramètres).
- ⇒ Ses 2 edges deviennent inactifs.
- ⇒ MM-1 devient inactif.
- ⇒ Plot-3 devient inactif.
- RSI est inactif car sa checkbox est décochée.
- ⇒ Ses 2 edges deviennent inactifs.
- ⇒ FFT-10 devient inactif.
- ⇒ Son edge de sortie devient inactif.
- ⇒ Plot-4 devient inactif
- Aleatoire-8 reste actif car il a au moins un edge de sortie actif (vers Union-5).
- Signaux-0 reste actif car il a au moins un edge de sortie actif (vers Union-5).

A faire, dans l'ordre :

Copier-coller les codes ci-dessous.
Coder les indications à coder ... N°, dans l'ordre des numéros.

Couleur des états inactifs :
- Pour les nodes, la couleur de fond est déjà définie dans UiNode.state_brush().
- Pour les edges, il faut la définir dans la @property UiEdge.state_pen(), à coder ... 4 la couleur choisie ici est #888.
- Par conséquent, il faut ajouter l'attribut b_on à la classe CtrlEdge : à coder ... 3
Propagation :
- Lorsqu'un node devient inactif, il entraîne la désactivation de tous ses edges.
- Lorsqu'un edge devient inactif suite à la désactivation d'un de ses nodes, il peut provoquer la désactivation de l'autre node.
- Lorsqu'un edge est supprimé, cela peut désactiver un ou deux des nodes qui étaient reliés.
- ... et ainsi de suite.
Ce problème doit être résolu par itérations successives :
- On compare, à la fin de chaque itération, l'état du graphe à ce qu'il était au début.
- S'il y a égalité, l'infrastructure est à jour, on peut sortir de la boucle d'itérations.

La méthode chargée de cela est CtrlScene.infratructure() : à coder ... 2

    def infrastructure(self):
        """ Le but de cette méthode est de :
            - Positionner le flag b_on de chaque node.
            - Positionner le flag b_on de chaque edge.
            - Rafraîchir l'affichage pour griser les éléments inactifs (b_on == False).
        """
        l_status_ante = list()
        l_grnodes, l_gredges = self.get_grnodes(), self.get_gredges()   # Capture unique pour ne pas alourdir.
        """ On positionne le flag de chaque node, selon son état initial. """
        for o_grnode in l_grnodes:
            o_grnode.o_node.b_on = o_grnode.o_node.get_state()
            l_status_ante.append(o_grnode.o_node.b_on)

        """ On lève tous les flags des edges. """
        for o_gredge in l_gredges:
            o_gredge.o_edge.b_on = True
            l_status_ante.append(True)

        for nb_loops in range(10):
            """ Positionnement des flags b_on de tous les nodes et de tous les edges. """
            # à coder ...

        """ Rafraîchit l'affichage du graphe. """
        self.o_grscene.update()

Elle doit être appelée en plusieurs endroits. Ajoutez ces lignes :

A l'instanciation d'une scène, dans CtrlScene.setup(), à la fin :

        """ Infrastructure. """
        self.infrastructure()

Vérification : On a une erreur, la méthode CtrlNode.get_state() n'existe pas. Créons-la.
CtrlNode.get_state() :

    def get_state(self):
        """ Chaque node, selon ses spécificités, retourne un booléen de son état on/off (True/False).
        Attention ! Cette méthode est surchargée par les nodes n'ayant pas de sockets d'entrée (générateurs).
        """
        b_on = False
        if self.b_chk:
            for key in self.o_params.od_params.key_list():
                if key[-1] == 'Signal actif':
                    if self.o_params.od_params.read(key, False):
                        b_on = True
                        break
        return b_on

Je répète : cette méthode doit être surchargée par les nodes générateurs : 3 méthodes à coder ... 1

Lorsqu'on clique sur la case à cocher d'un node.
La méthode CtrlNode.set_checked() devient :

    def set_checked(self, val):
        self.b_chk = val

        """ Enregistrement. """
        self.od_pkl.write([self.s_id, 'b_chk'], val)
        self.o_scene.o_pkl.backup()

        """ Infrastructure. """
        self.o_scene.infrastructure()

Lorsqu'on clique sur la case à cocher Signal actif d'un des signaux, dans les paramètres d'un node.
CtrlNode.refresh() :

    def refresh(self, l_keys):
        """ Titre du node. """
        if l_keys[-1] == 'Titre du node':
            self.o_grnode.set_title()
        """ Couleur des sockets et des edges. """
        if l_keys[-2] == 'Couleurs':
            self.set_colors(l_keys[1:])

        """ Fin de refresh - Appel conditionnel à infrastructure(). """
        if self.b_chk and (l_keys[0] == 'infrastructure' or l_keys[-1] == 'Signal actif'):
            """ Les nodes de type générateur doivent insérer le mot 'infrastructure'
            en 1ère place dans la liste l_keys[], car ils n'ont pas 'Signal actif' dans leurs paramètres. """
            self.o_scene.infrastructure()

Ce code nous montre en dernière ligne que l'appel à infrastructure() est conditionné :
- Soit par la clé Signal actif modifiée,
- Soit par la présence du mot 'infrastructure' dans la liste l_keys[], à l'indice 0.
- Par conséquent, la méthode refresh() de certains nodes de type générateur doit être modifiée :
  - /nodes/generateurs/histos.py > Node.refresh() :
```
    def refresh(self, l_keys):
        """ Propagation en cascade : Seulement sur les noms de signaux (type valeur = bool). """
        if isinstance(self.get_param(l_keys[-1]), bool):
            self.lo_sockets_out[0].to_update()

            """ Infrastructure :Insertion de 'infrastructure' en 1ère place. """
            l_keys = ['infrastructure'] + l_keys

        super().refresh(l_keys)
```
  - /nodes/generateurs/signaux.py > Node.refresh() : Même code que ci-dessus.
Lorsqu'on supprime un item (node ou edge), ajoutez ces 2 lignes à la fin, juste après self.show_params() (même indentation).
dans CtrlScene.remove_items() :
```
            """ Infrastructure. """
            self.infrastructure()
```
Lorsqu'on crée un node, ajoutez ces 2 lignes à la fin, juste après self.show_params() (même indentation).
dans CtrlScene.new_node() :
```
            """ Infrastructure. """
            self.infrastructure()
```
Lorsqu'on termine la création d'un edge, ajoutez ces 2 lignes juste après l'enregistrement → self.o_scene.save_edges(backup=True) (même indentation).
dans UiView.stop_edge() :
```
                """ Infrastructure. """
                self.o_scene.infrastructure()
```
Il reste encore 2 endroits où recalculer l'infrastructure : à vous des les trouver.
- Lorsqu'on crée un court-circuit (secousse) : à coder ... 5.
- Lorsqu'on croise 2 edges (Sélection + touche Tab) :à coder ... 6.

Vérification

Procéder dans l'ordre :

Traiter chaque point après avoir validé le précédent.

Chacun des nodes est inactif lorsque sa checkbox est décochée.
Histos ou Signaux est inactif lorsque sa checkbox est cochée, mais aussi que toutes les cases des ses paramètres sont décochées.
Chacun des nodes (autre que générateur) est inactif lorsque sa checkbox est cochée, mais aussi que tous ses paramètres Signal actif sont décochés.
Un edge relié au moins à un node inactif est inactif.
Un node est inactif si chacune de ses entrées est vide ou connectée à un edge inactif (sauf les générateurs).
Un node est inactif si chacune de ses sorties est vide ou connectée à un edge inactif (sauf les afficheurs).
Lorsqu'on ajoute un node, il est nécessairement inactif.
Lorsqu'on supprime un node, l'infrastructure est recalculée.
Lorsqu'on ajoute un edge, l'infrastructure est recalculée : son état dépend de ceux des 2 nodes reliés.
Lorsqu'on supprime un edge, l'infrastructure est recalculée.
Lorsqu'on crée un court-circuit (secousse), l'infrastructure est recalculée.
Lorsqu'on croise 2 edges (Sélection + touche Tab), l'infrastructure est recalculée.

Snippets

Essayez de résoudre cette fonctionnalité par vous-même.
Consultez les réponses (snippets) seulement si vous n'avez pas trop de temps.

Infrastructure

Bonjour les codeurs !

Commentaires & questions

Laissez vos commentaires et vos questions sur Youtube !