# Python - Fonctions et modules

## Objectifs du TP

L'objectif de ce TP est de développer un générateur de mots de passe sécurisés qui fonctionne en mode console à l'aide d'un menu interactif. 

L'application a déjà été partiellement développée : le menu interactif a été créé, mais les actions du menu n'existent pas et ne font qu'afficher un message. 

Vous allez reprendre cette application et la compléter pour créer des mots de passe sécurisés.

### Apprendre

- **Fonctions** : Création de fonctions
- **Refactorisation** : réorganiser le code existant
- **Modules** : Import de modules externes
- **Modules** : Répartir le code dans différents fichiers

### Objectifs techniques

- Générer un mot de passe de taille fixe
- Réorganiser le code en créant un module pour générer les mots de passe
- Générer un mot de passe de taille personnalisable

## Étapes

### 0 - Analyse du code existant

Voici le code de l'application tel qu'il existe aujourd'hui.

```python
if __name__ == "__main__":
    choix = None
    while choix != 0:
        print("================================================")
        print("CIEL - Générateur de mots de passe")
        print("================================================")
        print("Quel type de mot de passe souhaitez-vous créer ?")
        print("1 - Mot de passe avec configuration par défaut")
        print("2 - Mot de passe avec configuration personnalisée")
        print("3 - Phrase de passe avec configuration par défaut")
        print("4 - Phrase de passe avec configuration personnalisée")
        print("0 - Quitter\n")
        

        choix = int(input("Saisissez votre choix : "))
        
        print("\n")
        match choix:
            case 1: 
                print("Mot de passe par défaut")
            case 2:
                print("Mot de passe personnalisé")
            case 3:
                print("Phrase de passe par défaut")
            case 4:
                print("Phrase de passe personnalisée")
            case 0:
                print("Vous quittez le programme")
            case _ as action:
                print(f"Erreur : l'option {action} n'existe pas")

        if choix != 0 :
            input("\n\nAppuyez sur Entrée")
```

**Objectif :** Analyser le code existant

```admonish travail
1. Copier le code précédent dans un nouveau fichier, que vous appellerez `main.py`
1. Exécuter le code et utiliser le programme en essayant toutes les options du menu
1. Essayer également un nombre ne correspondant à aucune option du menu
1. Essayer d'entrer une option qui n'est pas un nombre
```

```admonish note title="Dans le compte rendu"
1. Expliquer en quelques lignes ce que fait le programme
1. Dans votre compte rendu, copier le code et ajouter des commentaires pour expliquer en détail son fonctionnement. Une attention sera portée particulièrement sur :
    - l'instruction `match` ([documentation ici](https://docs.python.org/3/tutorial/controlflow.html#match-statements))
    - la première ligne (`if __name__ == "__main__":`) (Recherches en ligne autorisées)
    - Les deux dernières lignes :
        ```python
        if choix != 0 :
            input("\n\nAppuyez sur Entrée")
        ```
    - Le rôle de `int` dans `int(input("Saisissez votre choix : "))` ligne 15
```

### 1 - Fonction `afficher_menu`

**Objectif :** Créer une fonction `afficher_menu` qui affiche le menu. 

```admonish travail
- Créer une fonction `afficher_menu` qui ne prend aucun paramètre.
- Extraire dans cette fonction tout le code permettant d'**afficher** votre menu
- Remplacer le code d'affichage par un appel à votre nouvelle fonction
```

```admonish warning title="Attention"
On garde la variable `choix` et le `input` dans le corps du script. Cette ligne ne change pas de place.
```

```admonish note title="Dans le compte rendu"
1. Donner le code de la fonction
1. Où doit être déclarée la fonction ? 
1. Comment tester que la fonction marche ?
```

### 2 - Fonction `choix_generateur`

**Objectif :** Créer une fonction qui reçoit le choix de l'utilisateur et le traite 

```admonish travail
- Créer une fonction `choix_generateur` qui prend en paramètre le choix de l'utilisateur.
    ~~~python
    def choix_utilisateur(choix):
        # Ecrire le code ici
    ~~~
- Extraire dans cette fonction tout le code permettant de gérer vos choix d'options
- Remplacer votre ancien code par un appel à la nouvelle fonction. N'oubliez pas de passer votre variable en paramètre
```

```admonish note title="Dans le compte rendu"
1. Donner le code de la fonction
1. Donner le nouveau code de votre boucle principale
1. Pourquoi passer la variable `choix` en paramètre au lieu d'une variable globale ?
1. Si je modifie `choix` dans ma fonction, qu'en est-il de la variable `choix` originale (celle à l'extérieur de la fonction) ?
```


### 3 - Fonction `generer_mdp`

**Objectif :** Créer une fonction pour générer un mot de passe (fixe pour le moment)

```admonish travail
1. Créer une fonction `generer_mdp` qui retourne simplement la chaîne de caractères `P@ssw0rd!`. Penser à utiliser l'instruction `return`
1. Utiliser cette fonction dans le choix 1 pour afficher le mot de passe généré dans la console.
```

```admonish note title="Dans le compte rendu"
1. Donner le code de la nouvelle fonction créée
1. Donner le code de `choix_generateur` après l'avoir modifiée
1. Est-ce une bonne idée d'utiliser `P@ssw0rd!` comme vrai mot de passe pour un de vos comptes en ligne ? Pourquoi ?
```

### 4 - Création d'un module `mdp`

**Objectif :** Créer un module `mdp` pour y mettre tout ce qui concerne la génération de mots de passe, et l'importer dans le code principal

```admonish travail
1. Créer un nouveau fichier `mdp.py`
1. Déplacer la fonction `generer_mdp` dans ce nouveau fichier
1. Importer le module `mdp` dans le fichier principal
1. Modifier l'appel à la fonction `generer_mdp` pour tenir compte de son déplacement dans un module
1. Vérifier que tout fonctionne comme avant
```

```admonish help title="Aide"
- Pour importer le module `mdp` il faut utiliser l'instruction `import`
- Pour utiliser la fonction `generer_mdp` du module `mdp`, il faut préciser le nom du module : `mdp.generer_mdp()`
~~~python
import mdp

... #    Code du script

mdp.generer_mdp()

... # Encore du code
~~~
```

```admonish warning title="Attention"
Ne pas oublier de préciser le nom du module avec un point lorsqu'on appelle une fonction qui est dans un module externe (`mon_module.ma_fonction()`)
```

```admonish note title="Dans le compte rendu"
- Mettre le code du nouveau module
- Mettre la ligne modifiée pour appeler `generer_mdp` depuis le script principal
- Quel est l'intérêt de créer des modules séparés pour certaines portions de code ?
```


### 5 - Modification de `generer_mdp` pour générer un vrai mot de passe (attention : partie longue)

**Objectif :** Générer un mot de passe réellement aléatoire de taille fixe

```admonish travail
1. Dans le module `mdp`, tout en haut du fichier, importer les modules `secrets` et `string` qui sont livrés avec Python
1. En haut du fichier, après les imports, créer quatre **constantes** comme ci-dessous. Elles vont nous aider à définir l'ensemble des caractères autorisés dans les mots de passe
    ~~~python
    LETTRES = string.ascii_letters # Définit toutes les lettres autorisées
    CHIFFRES = string.digits # Définit tous les chiffres autorisés
    SPECIAL = string.punctuation # Définit les caractères spéciaux autorisés

    ALPHABET = LETTRES + CHIFFRES + SPECIAL # Ensemble complet des caractères autorisés
    ~~~
1. Modifier la fonction `generer_mdp` pour générer un mot de passe de 14 caractères. Pour cela :
    1. Ajouter une boucle qui bouclera 14 fois, grâce à la fonction `range` ([doc](https://docs.python.org/3/tutorial/controlflow.html#the-range-function))
    2. Dans cette boucle, nous allons ajouter un nouveau caractère à la variable `password`. Ce caractère sera tiré aléatoirement dans la constante `ALPHABET`. 
    
        Pour ça, nous allons utiliser la fonction `choice`. Cette fonction existe dans deux modules : [`random`](https://docs.python.org/3/library/random.html#module-random) et [`secrets`](https://docs.python.org/3/library/secrets.html#module-secrets). Choisir celle que vous allez utiliser.
        ~~~python
        password += secrets.choice(ALPHABET)
        ~~~
    3. A la fin, une fois sorti de la boucle, nous retournons la variable `password`
1. Vérifier que votre fonction marche en essayant de générer un mot de passe (via l'option 1)
```

```admonish tip title="Remarques"
1. Les constantes en Python sont comme des variables. La différence est qu'on ne voudra jamais changer leur valeur. Mais rien ne permet de l'empêcher. Alors pour savoir qu'il s'agit d'une constante et qu'elle ne devrait pas être modifiée, on lui donne un nom en majuscules. Il s'agit d'une convention courante en programmation.
1. Les constantes `string.ascii_letters`, `string.digits`, `string.punctuation` sont des chaînes de caractères avec l'ensemble des caractères de chaque catégorie. Elles sont définies dans le module string pour nous faire gagner du temps et éviter d'en oublier.
1. Pour ajouter un caractère à une chaîne, il suffit d'utiliser `+`
    ~~~python
    ma_chaine = ma_chaine + "c"
    ~~~
```

```admonish warning title="Attention"
- Ne pas oublier d'initialiser la variable `password` **avant la boucle** avec une chaîne de caractères vide : `""`
- Appeler l'instruction `return` **après être sorti de la boucle**
```

```admonish note title="Dans le compte rendu"
1. Donner le nouveau code du module `mdp` **complet**
1. A l'aide des docs des modules `random` et `secrets` :
    1. Expliquer en quelques mots le rôle des deux modules et leur principale différence
    1. Justifier votre choix d'utiliser l'un ou l'autre module pour générer un mot de passe **sécurisé**
```

### 6 - Réutiliser `generer_mdp` pour créer un mot de passe de taille personnalisable

**Objectif :** Rendre personnalisable la taille du mot de passe généré, et compléter l'option 2 du menu

```admonish travail
1. Modifier la fonction `generer_mdp` pour qu'elle puisse prendre un paramètre `password_length`. Ce paramètre aura une **valeur par défaut** : 14
1. Modifier la boucle pour qu'elle puisse faire autant d'itérations que `password_length` le nécessite.
1. Vérifier que le code fonctionne toujours normalement sans autre modification
1. Modifier le choix 2 du menu pour :
    1. Demander à l'utilisateurice de saisir une longueur de mot de passe personnalisée (avec `input`)
    1. Utiliser la fonction `generer_mdp` pour afficher un mot de passe aléatoire de la longueur demandée par l'utilisateurice
1. Vérifier que le choix 2 vous permette de générer des mots de passe de taille choisie.
```

```admonish note title="Dans le compte rendu"
1. Donner le code modifié de la fonction `generer_mdp`
2. Donner le code modifié du choix 2 du menu
3. Expliquer pourquoi votre choix 1 fonctionne toujours alors que vous ne passez aucun paramètre à la fonction `generer_mdp`
```

## Validation

Livrez le code final en plus du compte-rendu du TP (créez un répertoire)

### Checklist

- [ ] Le programme se lance sans erreur
- [ ] La fonction `generer_mdp` est créée avec les bons paramètres
- [ ] Le module `mdp` est créé et contient les bonnes fonctions
- [ ] Le code principal utilise les fonctions du module `mdp`
- [ ] Les mots de passe générés avec l'option 1 comportent 14 caractères et sont aléatoires
- [ ] Les mots de passe générés avec l'option 2 sont de la taille choisie et aléatoires
- [ ] Les fonctions ont des docstrings minimales (avec explication de leur fonctionnalité)
- [ ] Le code est propre, les variables et fonctions sont correctement nommées et avec des noms compréhensibles et adaptés

### Critères d'évaluation

- 40% - Le programme fonctionne correctement
- 30% - Réponse aux questions dans le compte-rendu
- 20% - Le code est propre : nommage des variables, lisibilité
- 10% - Documentation : commentaires pertinents

## Pour aller plus loin

### Bonus facile - Ajout de docstrings

**Objectif**: Documenter votre code à l'aide de docstrings complètes et formatées au format Numpy

```admonish travail
1. À l'aide de la section "Bonnes pratiques" du cours, ajoutez des docstrings aux fonctions de votre TP pour les documenter en respectant la syntaxe Numpy fournie
```

### Bonus difficile - Ajout de contraintes

**Objectif** : Créer une fonction `generer_mdp_avec_contraintes` pour ajouter des contraintes sur le nombre de caractères spéciaux et de chiffres

```admonish travail
1. Créer une nouvelle fonction `generer_mdp_avec_contraintes` dans le module `mdp`. Cette fonction appellera `generer_mdp` et retournera le mot de passe généré. Elle prendra trois paramètres :
    - `password_length` pour la longueur du mot de passe. Cette valeur sera passée à `generer_mdp` telle quelle et aura 14 en valeur par défaut.
    - `special` pour le nombre minimum de caractères spéciaux. Sa valeur par défaut sera de 1.
    - `digits` pour le nombre minimum de chiffres. Sa valeur par défaut sera de 1.
2. Ajouter une boucle qui permettra de re-générer le mot de passe tant qu'il ne comportera pas au moins `special` caractères spéciaux et `digits` chiffres. Il faudra pour cela : 
    - Compter les caractères spéciaux (et les chiffres) dans votre mot de passe
    - Vérifier ensuite que ce nombre soit supérieur au paramètre correspondant (`digits` ou `special`)
    - Arrêter la boucle si ces deux conditions sont réunies (donc la continuer tant que les deux conditions ne sont pas réunies)
3. Remplacer la fonction `generer_mdp` dans l'option 2 du menu pour utiliser votre nouvelle fonction. 
4. Vérfiez que les mots de passe générés respectent la contrainte par défaut
5. Sur le modèle de la longueur du mot de passe, demander à l'utilisateurice de choisir les contraintes voulues.
6. Documenter votre/vos nouvelles fonctions avec une docstring complète.
```

```admonish help title="Aide"
1. Pour compter les caractères spéciaux (ou les chiffres) dans votre mot de passe, vous pouvez 
    - faire une boucle 'for' sur votre mot de passe
    - vérifier si le caractère se trouve dans votre constante `SPECIAL` avec la syntaxe `caractere in SPECIAL`
    - et incrémenter une variable à chaque fois que la condition précédente est à `True`

2. Vous pouvez extraire le comptage et la validation de la contrainte dans une sous-fonction pour rendre votre code plus lisible.
```

```admonish note title="Dans le compte rendu"
1. Donner le code de la fonction `generer_mdp_avec_contraintes` et des éventuelles sous-fonctions créées.
2. Donner le code modifié du choix 2 du menu
```