Affiche les icones de nodes dans toutes les catégories
Avant-propos
Privilégiez le format png car il permet la transparence.
QListWidget
, notamment : setViewMode
, setResizeMode
, setGridSize
, setAcceptDrops
.QListWidgetItem
et QListWidgetItem.setIcon
, QPixmap
, QIcon
.Description
/nodes
dans le disque dur.afficheurs
generateurs
indicateurs
.py
pour en extraire les données de peuplement.
self.do_groups_nodes = { # Chaque onglet du dockable 'Noeuds' = Un groupes de modèles de nodes.
'Afficheurs': GroupNodes('afficheurs'),
'Générateurs': GroupNodes('generateurs'),
'Indicateurs': GroupNodes('indicateurs'),
'Oscillateurs': GroupNodes('oscillateurs'),
'Opérateurs': GroupNodes('operateurs'),
}
Un passage d'argument a été ajouté : nom du sous-dossier sur disque dur.
from PyQt5.QtWidgets import QListWidget
import os
# Compléter les imports en fonction des besoins ...
class GroupNodes(QListWidget):
def __init__(self, dir_name):
"""
:param dir_name: Nom du sous-dossier sur disque dur.
"""
super().__init__()
self.dir_name = dir_name
self.path_name = ''
self.setup()
ld_datas = self.get_datas()
self.populate_tab(ld_datas)
self.set_flags()
def setup(self):
self.path_name = f"..{os.sep}nodes{os.sep}{self.dir_name}{os.sep}"
os.makedirs(self.path_name, exist_ok=True) # Création dossier. Si ce dossier existe, pas d'erreur renvoyée.
def get_datas(self):
""" 1 - Liste de tous les fichiers .py du sous-dossier => py_files
2 - Seuls les fichiers qui possèdent un dictionnaire 'd_datas' sont candidats.
3 - Création d'une liste de ces dictionnaires => ld_datas
:return: Liste de dictionnaires de datas 'ld_datas'
"""
ld_datas = list() # ld_ = Liste de dictionnaires.
# à coder ...
return ld_datas
def populate_tab(self, ld_datas):
"""
Affichage des icones et de leur libellé à partir de la liste 'ld_datas'.
:param ld_datas: Liste de dictionnaires : un par node, contenant le nom de l'icone et de son libellé.
:return: NA
"""
# à coder ...
def set_flags(self):
""" Ces flags permettent :
- De placer la liste en mode 'icones'.
- D'adapter l'affichage à la largeur du dockable (retour à la ligne).
- Dans une grille de 64 x 64 px.
- De refuser les drops.
:return: NA
"""
# à coder ...
histos.png
→ icone qui sera affichée.histos.py
→ Classes spécifiques au modèle de node 'Historiques'..py
doit contenir un dictionnaire. Exemple → contenu initial de histos.py
:
d_datas = {
'name': 'Histos', # Label affiché sous l'icone.
'icon': 'histos.png', # Icone affichée.
}
Ce code doit être créé manuellement pour chaque modèle.
à coder ...
Vérification
test_populate_nodes()
. Remplacez tout le code de test_main.py
par celui-ci :
from PyQt5.QtWidgets import QApplication, QTabBar
from PyQt5.QtCore import QSettings, QRect, QTimer, Qt
from PyQt5.QtTest import QTest
from pc.main import UiMain, NewGraph
import pytest
import sys
import os
import random
class Main(UiMain):
""" Classe dérivée de la fenêtre à tester. """
def __init__(self, normal, dockable):
super().__init__()
self.premier_passage = normal is not None
self.dockable = dockable
self.sauvage = normal is False
self.settings_ante = QSettings(f"{os.getcwd()}{os.sep}ante.conf", QSettings.IniFormat)
def moveEvent(self, ev):
if not self.dockable:
super().moveEvent(ev)
def resizeEvent(self, ev):
if not self.dockable:
super().resizeEvent(ev)
def closeEvent(self, ev):
if self.premier_passage:
""" Premier passage : Mémorisation des états. """
self.settings_ante.setValue('Geometrie', self.geometry())
self.settings_ante.setValue('dockNodes visible', self.dockNodes.isVisible())
self.settings_ante.setValue('dockNodes détaché', self.dockNodes.isFloating())
self.settings_ante.setValue('dockNodes géométrie', self.dockNodes.geometry())
self.settings_ante.setValue('dockParams visible', self.dockParams.isVisible())
self.settings_ante.setValue('dockParams détaché', self.dockParams.isFloating())
self.settings_ante.setValue('dockParams géométrie', self.dockParams.geometry())
if not self.sauvage:
""" Non exécuté en mode 'sauvage'. """
super().closeEvent(ev)
# @pytest.mark.skip() # Commenter pour tester
class TestMain:
g_appli = QApplication(sys.argv)
tempo = QTimer()
tempo.setSingleShot(True)
@staticmethod
@pytest.fixture(scope="session", autouse=True)
def cleanup(request):
""" Appel final pour effacer les fichiers temporaires créés par les tests. """
def remove_files():
test_folder = os.getcwd() + os.sep
backups_folder = test_folder.replace('tests', 'backups')
files = [f"{test_folder}ante.conf", f"{test_folder}params.conf"]
folders = ['Test creation de graphe', 'test_graph_1', 'test_graph_2', 'test_graph_3']
for file in files:
if os.path.isfile(file):
os.remove(file)
for folder in folders:
if os.path.isdir(backups_folder + folder):
os.rmdir(backups_folder + folder)
request.addfinalizer(remove_files)
@staticmethod
def get_rect(t_x, t_y, t_w, t_h):
""" Retourne un QRect aléatoire. """
return QRect(random.randint(*t_x), random.randint(*t_y), random.randint(*t_w), random.randint(*t_h))
@staticmethod
def open_window(normal=None, dockable=False):
win = Main(normal, dockable)
if normal is not None:
win.settings_ante.clear()
win.show()
return win
def connect(self, function, delay):
try:
self.tempo.timeout.disconnect()
except TypeError:
pass
self.tempo.timeout.connect(function)
self.tempo.start(delay)
def fenetre_modif(self, normal):
win = self.open_window(normal)
win.setGeometry(self.get_rect((50, 800), (50, 800), (300, 800), (300, 800)))
self.connect(win.close, 300) # {x}ms : On laisse le temps à la fenêtre main de mémoriser ses états.
""" Boucle d'exécution. """
self.g_appli.exec()
def fenetre_assert(self):
def geometry(qrect):
return f"x = {qrect.x()}, y = {qrect.y()}, largeur = {qrect.width()}, hauteur = {qrect.height()}"
win = self.open_window()
self.connect(win.close, 50)
geometry_ante = win.settings_ante.value('Geometrie', QRect(200, 200, 800, 600))
geometry_now = win.geometry()
print(
"\n- La fenêtre doit apparaître avec la même géométrie (taille et position) "
"que lors de sa dernière fermeture."
f"\n- Géométrie à la dernière fermeture : {geometry(geometry_ante)}."
f"\n- Géométrie à l'ouverture actuelle : {geometry(geometry_now)}."
)
assert geometry_now == geometry_ante
""" Boucle d'exécution. """
self.g_appli.exec()
""" *************************************************************************************** """
""" LES TESTS """
""" *************************************************************************************** """
@pytest.mark.skip() # Commenter pour tester
def test_ferme_normal(self):
""" Phase 1 : Affichage de la fenêtre, plusieurs déplacements et changements de taille, aléatoires.
Fermeture de la fenêtre, mémorisation de sa géométrie. """
self.fenetre_modif(normal=True) # True = Fermeture normale.
""" Phase 2: Réouverture de la fenêtre, lecture de sa géométrie, comparaison. """
self.fenetre_assert()
@pytest.mark.skip() # Commenter pour tester
def test_ferme_sauvage(self):
self.fenetre_modif(normal=False) # False = Fermeture sauvage.
self.fenetre_assert()
@pytest.mark.skip() # Commenter pour tester
def test_dock_state(self):
def update_dock():
self.connect(win.close, 500) # {x} ms : On laisse le temps à la fenêtre main de mémoriser ses états.
""" Modification des états des dockables, de façon aléatoire. """
for o_dock in [win.dockNodes, win.dockParams]:
x, y = win.x() + win.width() // 2, win.y() + win.height() // 2
o_dock.setFloating(random.choice([False, True]))
if o_dock.isFloating():
o_dock.setGeometry(self.get_rect((x - 50, x + 50), (y - 50, y + 50), (50, 400), (50, 400)))
else:
o_dock.setFixedWidth(random.randint(82, 200))
def state_dock():
self.connect(win.close, 50) # Obligatoirement avant les asserts.
""" Vérification des résultats. """
msg = 'DockNodes : Flottant (détaché).'
assert win.dockNodes.isFloating() == win.settings_ante.value('dockNodes détaché'), msg
res, qrect_now, qrect_ante = 0, win.dockNodes.geometry().getRect(), win.settings_ante.value(
'dockNodes géométrie').getRect()
if win.dockNodes.isFloating():
msg = 'DockNodes : Géométrie (x, y, w, h).'
for i in range(4):
""" Tolérence : on accepte 3 bonnes valeurs sur 4. """
res += qrect_now[i] == qrect_ante[i]
assert res > 2, msg
else:
msg = 'DockNodes : Largeur.' # 0=x, 1=y, 2=width, 3=height
assert qrect_now[2] == qrect_ante[2], msg # [2]=width
msg = 'DockParams : Flottant (détaché).'
assert win.dockParams.isFloating() == win.settings_ante.value('dockParams détaché'), msg
res, qrect_now, qrect_ante = 0, win.dockParams.geometry().getRect(), win.settings_ante.value(
'dockParams géométrie').getRect()
if win.dockParams.isFloating():
msg = 'DockParams : Géométrie (x, y, w, h).'
for i in range(4):
res += qrect_now[i] == qrect_ante[i]
assert res > 2, msg
else:
msg = 'DockParams : Largeur.'
assert qrect_now[2] == qrect_ante[2], msg
""" Phase 1 : Modification aléatoire des dockables (détaché ou attaché, position, taille, visibilité). """
win = self.open_window(normal=True)
update_dock()
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.g_appli.exec()
""" Phase 2 : Ouverture fenêtre, lecture de l'état des dockables, assertions et fermeture. """
win = self.open_window()
state_dock()
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.g_appli.exec()
@pytest.mark.skip() # Commenter pour tester
def test_dock_visible(self):
def update_dock():
self.connect(win.close, 300) # {x} ms : On laisse le temps à la fenêtre main de mémoriser ses états.
""" Modification des visibilités, de façon aléatoire. """
for o_dock in [win.dockNodes, win.dockParams]:
o_dock.setVisible(random.choice([False, True]))
def state_dock():
self.connect(win.close, 50) # Obligatoirement avant les asserts.
""" Vérification des résultats. """
try:
msg = 'DockNodes : Visibilité.'
assert win.dockNodes.isVisible() == win.settings_ante.value('dockNodes visible'), msg
msg = 'DockParams : Visibilité.'
assert win.dockParams.isVisible() == win.settings_ante.value('dockParams visible'), msg
except (Exception,):
pass
for i in range(4):
""" Phase 1 : Modification aléatoire des dockables (détaché ou attaché, position, taille, visibilité). """
win = self.open_window(normal=True, dockable=True)
update_dock()
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.g_appli.exec()
""" Phase 2 : Ouverture fenêtre, lecture de l'état des dockables, assertions et fermeture. """
win = self.open_window()
state_dock()
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.g_appli.exec()
@pytest.mark.skip()
def test_new_graph(self):
def write():
""" Écriture animée. """
new_graph.graph_name.setText(graph_name[:indx[0]])
indx[0] += 1
if indx[0] <= len(graph_name):
""" Écriture +1 caractère chaque xxx ms. """
self.tempo.start(100)
else:
""" Simulation de clic sur le bouton 'Ok'. """
self.connect(new_graph.accept, 1000)
graph_name = 'Test creation de graphe'
bk_folder = f"{os.getcwd()}{os.sep}..{os.sep}backups"
created_folder = bk_folder + os.sep + graph_name
win = self.open_window()
new_graph = NewGraph(win) # Type QDialog
indx = [0]
self.connect(write, 10)
new_graph.exec()
self.connect(win.close, 50) # Obligatoirement avant les asserts.
self.g_appli.exec()
""" Le dossier 'D:/Robot/backups/Test creation de graphe' doit avoir été créé. Vérification : """
assert os.path.isdir(created_folder), f"Le dossier '{created_folder}' n'a pas été créé."
@pytest.mark.skip()
def test_open_graph(self):
""" - État initial : à la création, il n'y a aucun onglet. Plus tard, il pourrait y en avoir un ou plusieurs.
- Création de 3 dossiers supplémentaires dans /backups : /test_graph_1, /test_graph_2 et /test_graph_3.
- Pour chaque dossier, appel de la méthode open_graph() :
- On vérifie que le dernier ajouté est sélectionné.
- On vérifie que la fenêtre Main a 3 onglets de plus dans sa zône centrale.
- On vérifie qu'ils sont déplaçables à la souris par drag & drop.
- On vérifie également qu'ils possèdent la croix de fermeture.
- Tentative d'ajout de /test_graph_2, qui est déjà présent :
- On vérifie le rejet de doublons.
- On vérifie néanmoins qu'il est sélectionné.
- Fermeture des 3 onglets => Vérification.
- Suppression des 3 dossiers de /backups.
"""
""" Ouverture et géométrie de la fenêtre Main. """
win = self.open_window()
win.setGeometry(QRect(100, 100, 900, 400))
self.connect(win.close, 800) # Fermeture différée.
""" Fermeture éventuelle des onglets. """
for i in range(3):
win.close_graph(0)
""" Création et affichage des onglets de 3 graphes. """
for i, dir_name in enumerate(['test_graph_1', 'test_graph_2', 'test_graph_3']):
created_folder = os.path.abspath(f"{os.getcwd()}{os.sep}..{os.sep}backups{os.sep}{dir_name}")
os.makedirs(created_folder, exist_ok=True) # Création dossier. Si ce dossier existe, pas d'erreur renvoyée.
win.open_graph(dir_name)
assert win.tabGraphs.currentIndex() == i, "L'onglet sélectionné n'est pas le dernier ajouté."
""" Asserts. """
nb_now = win.tabGraphs.count() # Le nombre d'onglets a augmenté de 3.
vrai = True
assert nb_now == 3, "L'ajout d'onglets a échoué."
assert win.tabGraphs.isMovable() == vrai, "Les onglets ne sont pas déplaçables à la souris."
assert win.tabGraphs.tabsClosable() == vrai, "Les onglets ne possèdent pas la croix de fermeture."
""" Tentative d'ouverture d'un graphe déjà ouvert. """
win.open_graph("test_graph_2")
assert nb_now == win.tabGraphs.count(), "La gestion des doublons ne fonctionne pas."
assert win.tabGraphs.currentIndex() == 1, "L'onglet sélectionné n'est pas celui du graphe choisi."
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.g_appli.exec()
@pytest.mark.skip()
def test_close_graph(self):
""" - Ouverture de la fenêtre Main.
- Création de 3 dossiers dans /backups/ (qui contiendront les graphes).
- Pour chaque dossier, création d'un onglet dans la zône principale.
- Fermeture successive des 3 onglets.
- A chaque fois, on compte le nombre d'onglets restant.
- Les résultats à obtenir : 2, 1 puis 0.
"""
""" Ouverture et géométrie de la fenêtre Main. """
win = self.open_window()
win.setGeometry(QRect(200, 200, 900, 400))
self.connect(win.close, 800) # Fermeture différée.
""" Création et affichage des onglets de 3 graphes. """
for i, dir_name in enumerate(['test_graph_1', 'test_graph_2', 'test_graph_3']):
created_folder = os.path.abspath(f"{os.getcwd()}{os.sep}..{os.sep}backups{os.sep}{dir_name}")
os.makedirs(created_folder, exist_ok=True) # Création dossier. Si ce dossier existe, pas d'erreur renvoyée.
win.open_graph(dir_name)
nb_ante = win.tabGraphs.count()
""" Fermeture successive des 3 onglets. """
for i in range(1, 4):
close_button = win.tabGraphs.tabBar().tabButton(0, QTabBar.RightSide)
QTest.mouseClick(close_button, Qt.LeftButton, Qt.NoModifier)
nb_now = win.tabGraphs.count()
assert nb_now == nb_ante - i, "La fermeture des onglets a échoué."
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.g_appli.exec()
@pytest.mark.skip()
def test_memo_tabs(self):
""" - Phase 1 :
- Ouverture de la fenêtre Main.
- Fermeture éventuelle des onglets.
- Mélange de la liste ['test_graph_1', 'test_graph_2', 'test_graph_3']
- Création de 3 dossiers, selon la liste, dans /backups/ (qui contiendront les graphes).
- Pour chaque dossier, création d'un onglet dans la zône principale.
- Activation d'un aonglet au hasard.
- Mémorisation de l'état des onglets.
- Fermeture de la fenêtre Main.
- Phase 2 :
- Ouverture de la fenêtre Main.
- Assert : Comparaison de l'état des onglets avec celui mémorisé.
- Fermeture de la fenêtre Main, fin du test.
"""
""" Ouverture et géométrie de la fenêtre Main. """
win = self.open_window()
win.setGeometry(QRect(200, 200, 900, 400))
""" Fermeture éventuelle des onglets. """
for i in range(3):
win.close_graph(0)
""" Phase 1 : Création et affichage des onglets de 3 graphes. """
l_tabs_ante = ['test_graph_1', 'test_graph_2', 'test_graph_3']
random.shuffle(l_tabs_ante)
current_index_ante = random.randint(0, 2)
for i, dir_name in enumerate(l_tabs_ante):
created_folder = os.path.abspath(f"{os.getcwd()}{os.sep}..{os.sep}backups{os.sep}{dir_name}")
os.makedirs(created_folder, exist_ok=True) # Création dossier. Si ce dossier existe, pas d'erreur renvoyée.
win.open_graph(dir_name)
win.tabGraphs.setCurrentIndex(current_index_ante)
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.connect(win.close, 800) # Fermeture différée.
self.g_appli.exec()
""" Phase 2 : Ouverture de la fenêtre Main. """
win = self.open_window()
win.setGeometry(QRect(200, 200, 900, 400))
l_tabs_now = list()
for i in range(win.tabGraphs.count()):
l_tabs_now.append(win.tabGraphs.widget(i).graph_name)
current_index_now = win.tabGraphs.currentIndex()
""" Asserts. """
fo = 'Fermeture, puis ouverture : '
if current_index_now >= 0:
assert current_index_now == current_index_ante, fo + "L'onglet sélectionné n'est pas le même."
assert len(l_tabs_now) == len(l_tabs_ante), fo + "Le nombre d'onglets n'est pas le même."
assert l_tabs_now == l_tabs_ante, fo + "L'ordre des onglets n'est pas le même."
""" Boucle d'exécution. Sortie lorsque la fenêtre se ferme. """
self.connect(win.close, 800) # Fermeture différée.
self.g_appli.exec()
@pytest.mark.skip()
def test_dock_nodes_tabs(self):
""" - Ouverture de la fenêtre.
- Assert 1 : On devrait avoir autant d'onglets que de clés dans le dictionnaire.
- Tri aléatoire les onglets -> Mémorisation.
- Sélection d'un onglet au hasard -> Mémorisation.
- Fermeture de la fenêtre.
- Réouverture de la fenêtre.
- Assert 2 : L'ordre des onglets doit être celui précédemment mémorisé.
_ Assert 3 : L'onglet sélectionné doit être celui précédemment mémorisé.
"""
""" Ouverture de la fenêtre. """
win = self.open_window()
""" Consigne : Onglets qui devraient être affichés = d_friendly. """
l_nodes_tabs = list()
for friendly_name in win.do_groups_nodes.keys():
l_nodes_tabs.append(friendly_name)
""" Assert 1. """
nb_tabs = win.tabNodes.count()
msg = f"Le nombre d'onglets affichés ({nb_tabs}) est différent de celui calculé ({len(l_nodes_tabs)})."
assert len(l_nodes_tabs) == nb_tabs, msg
""" Mélange des onglets. """
for i in range(nb_tabs):
n_from = random.randint(0, nb_tabs-1)
n_to = random.randint(0, nb_tabs-1)
win.tabNodes.tabBar().moveTab(n_from, n_to)
""" Sélection d'un onglet (Pas le 0 qui est la valeur par défaut). """
n_selected_ante = random.randint(1, nb_tabs-1)
win.tabNodes.setCurrentIndex(n_selected_ante)
""" Mémorisation de l'ordre des onglets. """
l_nodes_ante = list()
for i in range(win.tabNodes.count()):
l_nodes_ante.append(win.tabNodes.tabText(i))
# """ Fermeture asynchrone de la fenêtre. """
self.connect(win.close, 1000)
self.g_appli.exec()
""" Réouverture de la fenêtre. """
win = self.open_window()
""" Assert 2. Réel : Onglets effectivement affichés. """
l_nodes_now = list()
for i in range(win.tabNodes.count()):
l_nodes_now.append(win.tabNodes.tabText(i))
msg = "L'ordre des onglets du dock_nodes n'a pas été mémorisé."
assert l_nodes_ante == l_nodes_now, msg
""" Assert 3. Réel : Onglet sélectionné. """
n_selected_now = win.tabNodes.currentIndex()
msg = f"L'onglet actif ({n_selected_now}) du dock_nodes n'a pas été mémorisé ({n_selected_ante}).'"
assert n_selected_now == n_selected_ante, msg
self.connect(win.close, 1000)
self.g_appli.exec()
# noinspection PyUnresolvedReferences
# @pytest.mark.skip() # Collapse all : Ctrl Shift - Expand all : Ctrl Shift +
def test_populate_nodes(self):
""" Ouverture de la fenêtre. """
win = self.open_window()
""" Liste nécessaire des sous-dossiers dans /nodes. """
l_nodes_dir_need = list()
do_groups = dict()
for friendly_name, o_group in win.do_groups_nodes.items():
dir_name = o_group.dir_name
o_group.friendly_name = friendly_name
do_groups[dir_name] = o_group
assert dir_name != '', "Le sous-dossier de nodes ne doit pas être une chaîne vide."
assert dir_name not in l_nodes_dir_need, "2 sous-dossiers de node ne peuvent porter le même nom."
l_nodes_dir_need.append(o_group.dir_name)
l_nodes_dir_need.sort()
""" Liste réelle des sous-dossiers dans /nodes. """
l_nodes_dir_real = os.listdir(f'..{os.sep}nodes')
for nodes_dir in l_nodes_dir_need:
msg = f"Le dossier '/nodes/{nodes_dir}' n'existe pas."
assert nodes_dir in l_nodes_dir_real, msg
""" Liste des modèles de nodes présents physiquement. """
nb_total = 0
for dir_nodes in l_nodes_dir_real:
l_files = next(os.walk(f'..{os.sep}nodes{os.sep}{dir_nodes}'))[2]
l_py_files = [py_file[:-3] for py_file in l_files if os.path.splitext(py_file)[-1].lower() == '.py']
nb_models = 0
for py_file in l_py_files:
code = f"from nodes.{dir_nodes}.{py_file} import d_datas"
try:
""" Compilation dynamique. """
eval(compile(code, '<string>', 'exec'), globals(), globals())
except (Exception,):
continue
nb_models += 1
path = f"..{os.sep}nodes{os.sep}{dir_nodes}{os.sep}"
msg = f"Le dictionnaire '{dir_nodes}/{py_file}/d_datas' ne contient pas la clé"
assert 'name' in d_datas, f"{msg} 'name'"
assert 'icon' in d_datas, f"{msg} 'icon'"
assert os.path.isfile(path + py_file + '.py'), f"Le fichier '{path + py_file}.py' est absent."
assert os.path.isfile(path + d_datas['icon']), f"Le fichier '{path + d_datas['icon']}' est absent."
nb_showed = do_groups[dir_nodes].count()
friendly_name = do_groups[dir_nodes].friendly_name
msg = f"{friendly_name} -> Nombre d'icones à afficher : {nb_models}, nombre d'icones affichées : {nb_showed}"
assert nb_models == nb_showed, msg
nb_total += nb_models
assert nb_total > 0, "Il n'y a aucun modèle de node à afficher."
@pytest.mark.skip()
), sauf le dernier.Bon courage et bon coding !
Snippets
Bonjour les codeurs !