Refractor: Mise en conformité avec PEP8 (#34)

- Mise en conformité du code avec PEP8
- Déplacement de la classe EntreeLogApache vers le fichier entree_log_apache.py
- Mise à jour de la documentation suite à ces modifications
- Mise à jour des tests unitaires suite à ces modifications
- Ajout d'une action pour tester si la qualité du code est noté correctement par PyLint (>= 9)

Author: AnthonyGuillauma

.github/workflows/documentation.yaml

@@ -1,4 +1,4 @@
-name: Construction et déploiement de la configuration
+name: Documentation - LogBuster
 
 on:
   push:

.github/workflows/qualite.yaml

@@ -0,0 +1,42 @@
+name: Qualité code - LogBuster
+
+on:
+  push:
+    branches:
+      - develop
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout du code
+        uses: actions/checkout@v4
+
+      - name: Configuration de Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.x'
+
+      - name: Installation des dépendances
+        run: |
+          python -m pip install --upgrade pip
+          pip install pylint
+          pip install colorama
+
+      - name: Analyse avec Pylint (note >= 9.0 requise)
+        run: |
+          pylint app > tests-resultats-qualite.txt || true
+          SCORE=$(grep "Your code has been rated at" tests-resultats-qualite.txt | awk '{print $7}' | cut -d"/" -f1)
+          echo "Le score du code dans le dossier app est de $SCORE"
+          SCORE_VALIDE=$(echo "$SCORE >= 9.0" | bc)
+          if [ "$SCORE_VALIDE" -ne 1 ]; then
+            echo "Erreur: La note du code est inférieur à 9."
+            exit 1
+          fi
+      
+      - name: Upload du rapport Pylint
+        uses: actions/upload-artifact@v4
+        with:
+          name: rapport-qualite-code
+          path: tests-resultats-qualite.txt

.github/workflows/tests.yaml

@@ -48,5 +48,5 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           if-no-files-found: error
-          name: tests-resultats-python-${{ matrix.python-version }} # Nom de l'artefact
+          name: rapport-tests-unitaires-python-${{ matrix.python-version }} # Nom de l'artefact
           path: tests/resultats_pytest # Eléments à sauvegarder

app/analyse/analyseur_log_apache.py

@@ -27,22 +27,27 @@ def __init__(self, fichier_log_apache: FichierLogApache, nombre_par_top: int = 3
                 les statistiques des classements (tops). Par défaut, sa valeur est égale à ``3``.
 
         Raises:
-            TypeError: Si l'argument ``fichier_log_apache`` n'est pas une instance de :class:`FichierLogApache`
+            TypeError: Si l'argument ``fichier_log_apache`` n'est pas une instance 
+                de :class:`FichierLogApache`
                 ou si l'argument ``nombre_par_top`` n'est pas un entier.
             ValueError: Si l'argument ``nombre_par_top`` est inférieur à ``0``.
         """
+        # Vérification du type des paramètres
         if not isinstance(fichier_log_apache, FichierLogApache):
             raise TypeError("La représentation du fichier doit être de type FichierLogApache.")
         if not isinstance(nombre_par_top, int) or isinstance(nombre_par_top, bool):
             raise TypeError("Le nombre par top doit être un entier.")
+        # Vérification de la valeur du paramètre
         if nombre_par_top < 0:
             raise ValueError("Le nombre par top doit être supérieur ou égale à 0.")
+
+        # Ajout des données
         self.fichier = fichier_log_apache
         self.nombre_par_top = nombre_par_top
 
     def _get_repartition_elements(self,
-                          liste_elements: list, 
-                          nom_elements: str, 
+                          liste_elements: list,
+                          nom_elements: str,
                           mode_top_classement: bool = False) -> list:
         """
         Retourne le top 'n' des éléments qui apparaissent le plus dans la liste.
@@ -64,21 +69,25 @@ def _get_repartition_elements(self,
                 :attr:`nombre_par_top` éléments, mais peut en contenir moins s'il y a moins 
                 de :attr:`nombre_par_top` éléments distincts.
         """
+        # Vérification du type des paramètres
         if not isinstance(liste_elements, list):
             raise TypeError("La liste des éléments doit être une instance du type list.")
         if not isinstance(nom_elements, str):
             raise TypeError("Le nom des éléments doit être une chaîne de caractères")
         if not isinstance(mode_top_classement, bool):
-            raise TypeError("L'indication de l'activation du mode 'top_classement' doi être un booléen.")
-        
+            raise TypeError("L'indication de l'activation du mode 'top_classement' "
+                "doit être un booléen.")
+
+        # Analyse de la liste
         total_elements = len(liste_elements)
         compteur_elements = Counter(liste_elements)
-        top_elements = compteur_elements.most_common(self.nombre_par_top if mode_top_classement else None)
+        top_elements = compteur_elements.most_common(self.nombre_par_top
+                                                     if mode_top_classement else None)
         return [
             {nom_elements: element, "total": total, "taux": total / total_elements * 100}
             for element, total in top_elements
         ]
-    
+
     def get_analyse_complete(self) -> dict:
         """
         Retourne l'analyse complète du fichier de log Apache.
@@ -88,7 +97,8 @@ def get_analyse_complete(self) -> dict:
             - statistiques:
                         - requetes:
                             - top_urls: voir :meth:`get_top_urls`
-                            - repartition_code_statut_http: voir :meth:`get_total_par_code_statut_http`
+                            - repartition_code_statut_http: 
+                                voir :meth:`get_total_par_code_statut_http`
 
         Returns:
             dict: L'analyse sous forme d'un dictionnaire.
@@ -112,7 +122,7 @@ def get_total_entrees(self) -> int:
             int: Le nombre total d'entrées.
         """
         return len(self.fichier.entrees)
-    
+
     def get_top_urls(self) -> list:
         """
         Retourne le top :attr:`nombre_par_top` des urls les plus demandées.
@@ -130,7 +140,7 @@ def get_top_urls(self) -> list:
             "url",
             True
         )
-    
+
     def get_total_par_code_statut_http(self) -> list:
         """
         Retourne la répartition des réponses par code de statut htpp retourné.
@@ -146,4 +156,4 @@ def get_total_par_code_statut_http(self) -> list:
         return self._get_repartition_elements(
             [entree.reponse.code_statut_http for entree in self.fichier.entrees],
             "code"
-        )
+        )

app/cli/afficheur_cli.py

@@ -7,8 +7,9 @@
 from json import load
 from time import sleep
 from random import choice
-import colorama
 import threading
+import colorama
+
 
 class AfficheurCLI:
     """
@@ -51,7 +52,7 @@ def __init__(self):
             "rayon_laser": elements_animations["rayons_laser"]
         }
 
-    def reecrire_ligne(self, message: str):
+    def reecrire_ligne(self, message: str) -> None:
         """
         Permet d'écrire des caractères par dessus la dernière ligne dans la
         ligne de commande.
@@ -68,11 +69,12 @@ def reecrire_ligne(self, message: str):
         # Validation du paramètre
         if not isinstance(message, str):
             raise TypeError("Le message pour la réécriture doit être une chaîne de caractères.")
+
         # Ecriture du message
         sys.stdout.write("\r" + self.COULEUR_MESSAGE_NORMAL + message)
         sys.stdout.flush()
 
-    def affiche_message(self, message: str):
+    def affiche_message(self, message: str) -> None:
         """
         Permet d'écrire un message commun dans la ligne de commande avec la bonne
         couleur.
@@ -89,10 +91,11 @@ def affiche_message(self, message: str):
         # Validation du paramètre
         if not isinstance(message, str):
             raise TypeError("Le message doit être une chaîne de caractères.")
+
         # Ecriture du message
         print(self.COULEUR_MESSAGE_NORMAL + message, flush=True)
 
-    def affiche_erreur(self, message: str, exception: Exception):
+    def affiche_erreur(self, message: str, exception: Exception) -> None:
         """
         Permet d'écrire un message d'erreur dans la ligne de commande avec la bonne
         couleur.
@@ -113,10 +116,11 @@ def affiche_erreur(self, message: str, exception: Exception):
             raise TypeError("Le message d'erreur doit être une chaîne de caractères.")
         if not isinstance(exception, Exception):
             raise TypeError("L'exception à afficher doit être une instance de Exception.")
+
         # Ecriture du message
         print(self.COULEUR_MESSAGE_ERREUR + f"{message}\n{exception}", flush=True)
 
-    def lance_animation_chargement(self):
+    def lance_animation_chargement(self) -> None:
         """
         Lance une animation de chargement dans la ligne de commande via un thread non bloquant.
         Si l'animation de chargement est déjà en cours, cette méthode ne fait rien.
@@ -130,11 +134,12 @@ def lance_animation_chargement(self):
             self._thread_chargement_termine.clear()
             self._thread_chargement_erreur.clear()
             # Initialisation du thread pour le chargement
-            self._thread_chargement = threading.Thread(target=self._animation_chargement, daemon=True)
+            self._thread_chargement = threading.Thread(target=self._animation_chargement,
+                                                       daemon=True)
             # Lancement du thread pour le chargement
             self._thread_chargement.start()
-        
-    def _animation_chargement(self):
+
+    def _animation_chargement(self) -> None:
         """
         Lance l'animation de chargement en boucle jusqu'à la demande d'arrêt via
         l'attribut :attr:`_thread_chargement_demande_arret`.
@@ -147,7 +152,7 @@ def _animation_chargement(self):
         fantome_chargement = self._animations_actuelles["fantome"][0]
         signes_rayon_laser = self._animations_actuelles["rayon_laser"]
         couleurs = ["\033[91m", "\033[93m", "\033[94m", "\033[95m"] # Rouge, Jaune, Bleu, Magenta
-        
+
         # Eléments de l'animation de fin de chargement en cas de succès
         chasseur_gagne = self._animations_actuelles["chasseur"][2]
         fantome_perd = self._animations_actuelles["fantome"][1]
@@ -164,30 +169,32 @@ def _animation_chargement(self):
         while not (self._thread_chargement_termine.is_set()
                    or self._thread_chargement_erreur.is_set()):
             # Arrête d'ajouter des caractères lorsque la chaîne est trop longue
-            if (index_boucle < 40):
+            if index_boucle < 40:
                 # Récupération de la prochaine couleur
                 couleur_courante = couleurs[(index_boucle % len(couleurs))]
                 # Récupération du prochain signe du rayon
                 signe_courant = signes_rayon_laser[(index_boucle % len(signes_rayon_laser))]
                 # Ajout du dernier signe avec la nouvelle couleur au rayon
                 rayon_laser += couleur_courante + signe_courant
                 # Réactualisation de l'animation de chargement
-                self.reecrire_ligne(f"{chasseur_chargement}{rayon_laser}\033[0m{fantome_chargement}")
+                self.reecrire_ligne(
+                    f"{chasseur_chargement}{rayon_laser}\033[0m{fantome_chargement}"
+                )
                 index_boucle += 1
             sleep(0.05)
 
         # Suppression de la ligne de chargement
         self.reecrire_ligne("\033[K")
         espace_rayon_laser = " " * index_boucle
-        if (self._thread_chargement_termine.is_set()):
+        if self._thread_chargement_termine.is_set():
             # Message d'animation terminée
             self.reecrire_ligne(f"{chasseur_gagne}{espace_rayon_laser}\033[0m{fantome_perd}\n")
-            self.affiche_message(f"Analyse terminée! We came, we saw, we logged it.")
+            self.affiche_message("Analyse terminée! We came, we saw, we logged it.")
         else:
             # Message d'animation erreur
             self.reecrire_ligne(f"{chasseur_perd}{espace_rayon_laser}\033[0m{fantome_gagne}\n")
 
-    def stop_animation_chargement(self, erreur: bool = False):
+    def stop_animation_chargement(self, erreur: bool = False) -> None:
         """
         Lance une demande d'arrêt au thread qui gère l'animation de chargement
         en cours. Si aucune animation n'est en cours, cette méthode ne fait rien.
@@ -198,6 +205,10 @@ def stop_animation_chargement(self, erreur: bool = False):
         Returns:
             None
         """
+        # Vérification du type du paramètre
+        if not isinstance(erreur, bool):
+            raise TypeError("L'indication d'une erreur doit être un booléan.")
+
         # Si le thread de chargement existe et est lancé
         if self._thread_chargement and self._thread_chargement.is_alive():
             # Lancement de la demade d'arrêt

app/cli/parseur_arguments_cli.py

@@ -2,8 +2,10 @@
 Module pour analyser les arguments passés en ligne de commande.
 """
 
-from argparse import ArgumentParser
+from argparse import ArgumentParser, Namespace
 from re import match
+from typing import Optional
+
 
 class ParseurArgumentsCLI(ArgumentParser):
     """
@@ -12,14 +14,20 @@ class ParseurArgumentsCLI(ArgumentParser):
     """
 
     def __init__(self):
+        """
+        Initialise uparseur pour analyser les arguments passés en ligne de commande.
+        """
         super().__init__(
             description="LogBuster, l'analyseur de log Apache.", allow_abbrev=False,
         )
         self.__set_arguments()
 
-    def __set_arguments(self):
+    def __set_arguments(self) -> None:
         """
         Définit les arguments attendus par l'application.
+
+        Returns:
+            None
         """
         # -- Argument obligatoire --
         self.add_argument(
@@ -37,10 +45,32 @@ def __set_arguments(self):
             "nom 'analyse-log-apache.json' dans le repertoire courant sera crée.",
         )
 
-    def parse_args(self, args=None, namespace=None):
+    def parse_args(self,
+                   args: Optional[list] = None,
+                   namespace: Optional[Namespace] = None) -> Namespace:
         """
-        Analyse, vérifie et retourne les arguments fournis en ligne de commande.
+        Récupère les arguments passés en ligne de commande puis vérifie
+        que leur format est conforme à ceux attendus.
+
+        Args:
+            args (Optional[list]): Liste des arguments passés en paramètre. 
+                Si ``None``, les arguments de la ligne de commande sont utilisés.
+            namespace (Optional[Namespace]): Un espace de noms (namespace) 
+                pour stocker les résultats. Si ``None``, un nouvel espace de noms est créé.
+
+        Returns:
+            Namespace: L'objet contenant les arguments analysés et leurs valeurs.
+        
+        Raises:
+            ArgumentCLIException: Si une erreur se produit lors du parsing des arguments 
+                (par exemple, si un argument inconnu est fourni ou si son format est invalide).
         """
+        # Vérification du type des paramètres
+        if args is not None and not isinstance(args, list):
+            raise TypeError("Les arguments doivent soit être None, soit être dans une liste.")
+        if namespace is not None and not isinstance(args, Namespace):
+            raise TypeError("L'espace de noms doit soit être None, soit être un objet Namespace.")
+
         # Analyse des arguments
         try:
             arguments_parses = super().parse_args(args, namespace)
@@ -49,29 +79,33 @@ def parse_args(self, args=None, namespace=None):
 
         # Vérification syntaxique des arguments
         regex_chemin = r"^[a-zA-Z0-9:_\\\-.\/]+$"
+
         if not match(regex_chemin, arguments_parses.chemin_log):
             raise ArgumentCLIException(
                 "Le chemin du fichier log doit uniquement contenir les caractères autorisés. "
                 "Les caractères autorisés sont les minuscules, majuscules, chiffres ou les "
                 "caractères spéciaux suivants: _, \\, -, /."
             )
+
         if not match(regex_chemin, arguments_parses.sortie):
             raise ArgumentCLIException(
                 "Le chemin du fichier de sortie doit uniquement contenir les caractères "
                 "autorisés. Les caractères autorisés sont les minuscules, majuscules, "
                 "chiffres ou les caractères spéciaux suivants: _, \\, -, /."
             )
+
         if not arguments_parses.sortie.endswith(".json"):
             raise ArgumentCLIException(
                 "Le fichier de sortie doit obligatoirement être un fichier au format json."
             )
-        
+
         return arguments_parses
 
 
 class ArgumentCLIException(Exception):
     """
-    Représente une erreur liée l'analyse d'un argument en ligne de commande.
+    Représente une erreur lorsque un argument passé en ligne de commande
+    est inconnu ou que son format est invalide.
     """
 
     def __init__(self, *args):