Feat: Amélioration des classes de données et du parseur (#19)

- Utilisation de la bibliothèque typing et dataclasses
- Simplification de la classe en dataclass
- Ajout de vérification des types des attributs
- Modifiation du test unitaire test_parsage_entree_valide suite à une erreur due aux précédents commits qui ont
  modifié le nom de l'attribut code_statut_http
- Ajout de commentaires et de sauts de ligne aux méthodes de ParseurLogApache afin de rendre le fichier plus lisible
- Suppression de la méthode __fichier_existe dans ParseurLogApache qui était utilisée qu'une
  seule fois en déplacant son contenu directement dans le __init__
- Ajout d'un except pour les Exceptions qui affiche un message en
  indiquant qu'une erreur interne s'est produite

Author: AnthonyGuillauma

app/donnees/client_informations.py

@@ -2,16 +2,45 @@
 Module relatif aux informations d'un client dans un fichier de log Apache.
 """
 
+from dataclasses import dataclass
+from typing import Optional
 
+
+@dataclass
 class ClientInformations:
+    """
+    Représente les informations d'un client à partir d'une entrée d'un log Apache.
+
+    Cette classe regroupe les données extraites d'une entrée de log,
+    qui concernent le client ayant effectué la requête au serveur Apache.
+
+    Attributes:
+        adresse_ip (str): L'adresse IP du client.
+        identifiant_rfc (Optional[str]): L'identifiant RFC du client. 
+            Peut être None si non fournie.
+        nom_utilisateur (Optional[str]): Le nom de l'utilisateur authentifié. 
+            Peut être None si non fournie.
+        agent_utilisateur (Optional[str]): L'agent utilisateur (User-Agent). 
+            Peut être None si non fournie.
+
+    Raises:
+        TypeError: Si les attributs ne sont pas de type `str` ou `None`.
+    """
+    adresse_ip: str
+    identifiant_rfc: Optional[str]
+    nom_utilisateur: Optional[str]
+    agent_utilisateur: Optional[str]
 
-    def __init__(self,
-                 adresse_ip,
-                 identifiant_rfc,
-                 nom_utilisateur,
-                 agent_utilisateur
-                 ):
-        self.adresse_ip = adresse_ip
-        self.identifiant_rfc = identifiant_rfc
-        self.nom_utilisateur = nom_utilisateur
-        self.agent_utilisateur = agent_utilisateur
+    def __post_init__(self):
+        # Validation de l'adresse IP
+        if not isinstance(self.adresse_ip, str):
+            raise TypeError("L'adresse IP est obligatoire et doit être une chaîne de caractères.")
+        # Validation de l'identifiant RFC
+        if self.identifiant_rfc != None and not isinstance(self.identifiant_rfc, str):
+            raise TypeError("L'identifiant RFC doit être une chaîne de caractères ou None.")
+        # Validation du nom d'utilisateur
+        if self.nom_utilisateur != None and not isinstance(self.nom_utilisateur, str):
+            raise TypeError("Le nom d'utilisateur doit être une chaîne de caractères ou None.")
+        # Validation de l'agent utilisateur
+        if self.agent_utilisateur != None and not isinstance(self.agent_utilisateur, str):
+            raise TypeError("L'agent utilisateur doit être une chaîne de caractères ou None.")

app/donnees/reponse_informations.py

@@ -2,12 +2,35 @@
 Module relatif aux informations de la réponse dans un fichier de log Apache.
 """
 
+from dataclasses import dataclass
+from typing import Optional
 
+
+@dataclass
 class ReponseInformations:
+    """
+    Représente les informations de la réponse HTTP à partir d'une entrée d'un log Apache.
+
+    Cette classe regroupe les données extraites d'une entrée de log,
+    qui concernent les informations techniques sur la réponse émise par
+    le serveur Apache au client.
+
+    Attributes:
+        code_statut_http (int): Le code de statut HTTP.
+        taille_octets (Optional[int]): La taille de la réponse en octets.
+            Peut être None si non fournie.
+
+    Raises:
+        TypeError: Si les attributs ne sont pas du type int.
+    """
+
+    code_statut_http: int
+    taille_octets: Optional[int]
 
-    def __init__(self,
-                 code_status_http,
-                 taille_octets
-                 ):
-        self.code_status_http = code_status_http
-        self.taille_octets = taille_octets
+    def __post_init__(self):
+        # Vérification du code de statut HTTP
+        if not isinstance(self.code_statut_http, int):
+            raise TypeError("Le code de statut HTTP doit être un entier.")
+        # Vérification de la taille de la réponse (en octets)
+        if self.taille_octets != None and not isinstance(self.taille_octets, int):
+            raise TypeError("La taille en octets doit être un entier ou None.")

app/donnees/requete_informations.py

@@ -2,18 +2,52 @@
 Module relatif aux informations de la requete dans un fichier de log Apache.
 """
 
+from dataclasses import dataclass
+from typing import Optional
+from datetime import datetime
 
+@dataclass
 class RequeteInformations:
+    """
+    Représente les informations de la requête HTTP à partir d'une entrée d'un log Apache.
 
-    def __init__(self,
-                 horodatage,
-                 methode_http,
-                 url,
-                 protocole_http,
-                 ancienne_url
-                 ):
-        self.horodatage = horodatage
-        self.methode_http = methode_http
-        self.url = url
-        self.protocole_http = protocole_http
-        self.ancienne_url = ancienne_url
+    Cette classe regroupe les données extraites d'une entrée de log,
+    qui concernent les informations techniques sur la requête émise au
+    serveur Apache.
+
+    Attributes:
+        horodatage (datetime): L'horodatage de la requête.
+        methode_http (Optional[str]): La méthode HTTP utilisée.
+            Peut être None si non fournie.
+        url (Optional[str]): L'URL cible de la requête.
+            Peut être None si non fournie.
+        protocole_http (Optional[str]): Le protocole HTTP utilisé.
+            Peut être None si non fournie.
+        ancienne_url (Optional[str]): L'URL de provenance (referrer).
+            Peut être None si non fournie.
+
+    Raises:
+        TypeError: Si les attributs ne sont pas du type attendu ou None.
+    """
+    horodatage: datetime
+    methode_http: Optional[str]
+    url: Optional[str]
+    protocole_http: Optional[str]
+    ancienne_url: Optional[str]
+
+    def __post_init__(self):
+        # Vérification de l'horodatage
+        if not isinstance(self.horodatage, datetime):
+            raise TypeError("L'horodatage doit être de type datetime.")
+        # Vérification de la méthode HTTP
+        if self.methode_http != None and not isinstance(self.methode_http, str):
+            raise TypeError("La méthode HTTP doit être une chaine de caractère ou None.")
+        # Vérification de la ressource demandée
+        if self.url != None and not isinstance(self.url, str):
+            raise TypeError("L'URL doit être une chaine de caractère ou None.")
+        # Vérification du protocole HTTP
+        if self.protocole_http != None and not isinstance(self.protocole_http, str):
+            raise TypeError("Le protocole HTTP doit être une chaine de caractère ou None.")
+        # Vérification de l'ancienne URL
+        if self.ancienne_url != None and not isinstance(self.ancienne_url, str):
+            raise TypeError("L'ancienne URL doit être une chaine de caractère ou None.")

app/main.py

@@ -36,3 +36,5 @@
         print(f"Erreur dans la recherche du log Apache !\n{ex}")
     except FormatLogApacheInvalideException as ex:
         print(f"Erreur dans l'analyse du log Apache !\n{ex}")
+    except Exception as ex:
+        print(f"Erreur interne !\n{ex}")

app/parse/parseur_log_apache.py

@@ -36,19 +36,9 @@ def __init__(self, chemin_log):
         Raises:
             FileNotFoundError: Si le fichier à analyser est introuvable.
         """
-        if not self.__fichier_existe(chemin_log):
+        if not os.path.isfile(chemin_log):
             raise FileNotFoundError(f"Le fichier {chemin_log} est introuvable.")
         self.chemin_log = chemin_log
-
-    def __fichier_existe(self, chemin_fichier):
-        """
-        Vérifie que le chemin passé en paramètre correspond à une fichier existant.
-        Returns:
-            bool: True s'il existe, False sinon.
-        """
-        if not os.path.isfile(chemin_fichier):
-            return False
-        return True
 
     def parse_fichier(self):
         """
@@ -60,17 +50,17 @@ def parse_fichier(self):
             FormatLogApacheInvalideException: Format du fichier log invalide.
         """
         log_analyse = FichierLogApache(self.chemin_log)
-        numero_ligne = 1
         with open(self.chemin_log, "r") as log:
-            for ligne in log:
+            for numero_ligne, ligne in enumerate(log, start=1):
                 try:
-                    log_analyse.ajoute_entree(self.parse_entree(ligne))
-                    numero_ligne += 1
+                    entree = self.parse_entree(ligne)
+                    log_analyse.ajoute_entree(entree)
                 except FormatLogApacheInvalideException as ex:
                     raise FormatLogApacheInvalideException(
-                        f"Le format de l'entrée à la ligne {numero_ligne}"
-                        f"('{ligne}') est invalide."
+                        f"Le format de l'entrée à la ligne {numero_ligne} "
+                        f"('{ligne.strip()}') est invalide."
                     ) from ex
+
         return log_analyse
 
     def parse_entree(self, entree):
@@ -89,40 +79,61 @@ def parse_entree(self, entree):
         analyse = match(self.PATTERN_ENTREE_LOG_APACHE, entree)
         if not analyse:
             raise FormatLogApacheInvalideException()
+
+        # Extraction des résultats d'analyse
         resultat_analyse = analyse.groupdict()
+
         # Récupération des informations liées au client
         adresse_ip = self.get_information_entree(resultat_analyse, "ip")
+        if adresse_ip is None:
+            raise FormatLogApacheInvalideException("L'adresse IP est obligatoire.")
         identifiant_rfc = self.get_information_entree(resultat_analyse, "rfc")
         utilisateur = self.get_information_entree(resultat_analyse, "utilisateur")
         agent_utilisateur = self.get_information_entree(resultat_analyse, "agent_utilisateur")
+
         informations_client = ClientInformations(
             adresse_ip, identifiant_rfc, utilisateur, agent_utilisateur
         )
+
         # Récupération des informations liées à la requête
         horodatage = self.get_information_entree(resultat_analyse, "horodatage")
         if horodatage:
             horodatage = datetime.strptime(horodatage, "%d/%b/%Y:%H:%M:%S %z")
+
+        if horodatage is None:
+            raise FormatLogApacheInvalideException("L'horodatage est obligatoire.")
+
         methode_http = self.get_information_entree(resultat_analyse, "methode")
         url = self.get_information_entree(resultat_analyse, "url")
         protocole_http = self.get_information_entree(resultat_analyse, "protocole")
         ancienne_url = self.get_information_entree(resultat_analyse, "ancienne_url")
+
         informations_requete = RequeteInformations(
             horodatage, methode_http, url, protocole_http, ancienne_url
         )
+
         # Récupération des informations liées à la réponse
         code_statut = self.get_information_entree(resultat_analyse, "code_status")
         if code_statut:
             code_statut = int(code_statut)
+
+        if code_statut is None:
+            raise FormatLogApacheInvalideException("Le code de statut HTTP est obligatoire.")
+
         taille_octets = self.get_information_entree(resultat_analyse, "taille_octets")
         if taille_octets:
             taille_octets = int(taille_octets)
+
         informations_reponse = ReponseInformations(
             code_statut, taille_octets
         )
+
+        # Retour des informations regroupées dans l'objet EntreeLogApache
         return EntreeLogApache(
             informations_client, informations_requete, informations_reponse
         )
 
+
     def get_information_entree(self, analyse_regex, nom_information):
         """
         Retourne la valeur de l'information dans l'analyse si elle possède une valeur
@@ -134,11 +145,8 @@ def get_information_entree(self, analyse_regex, nom_information):
             Union[str, None]: La valeur sous forme de chaîne de caractère ou None si
                 aucune valeur n'a été trouvée.
         """
-        if nom_information in analyse_regex:
-            valeur = analyse_regex[nom_information]
-            if valeur != "-" and valeur != "":
-                return valeur
-        return None
+        valeur = analyse_regex.get(nom_information)
+        return valeur if valeur != "" and valeur != "-" else None
 
 class FormatLogApacheInvalideException(Exception):
 

tests/test_parseur_log_apache.py

@@ -171,5 +171,5 @@ def test_parsage_entree_valide(parseur_log_apache):
     assert entree.requete.url == "/index.html"
     assert entree.requete.protocole_http == "HTTP/1.1"
     assert entree.requete.ancienne_url == "/home"
-    assert entree.reponse.code_status_http == 200
+    assert entree.reponse.code_statut_http == 200
     assert entree.reponse.taille_octets == 532