Les projets !

1. Projet:

Projet : créer un programme Python faisant intervenir les classes.

Consignes :

• Vous pouvez vous mettre avec un camarade de votre demi-groupe.
• Le but est d'apprendre et donc de manipuler la programmation orienté objet. Votre code doit donc tourner autour de ce paradigme.

• On souhaite avoir un code avec de "bonnes pratiques" donc :

  • Le code doit être documenté.
  • Le code doit être commenté.
  • Les noms des variables doivent être explicites.
  • Des assertions doivent être présentes pour tester la validité des paramètres.
• Lors de la remise du devoir, le professeur peut interroger un élève pour tester sa compréhension du code donné.

2. Projet sur les arbres binaires et la génération d'images:

Nous avons créer la classeArbreBinaire. Toutefois, une fois un arbre créé, il était difficile de le visualiser.

Nous allons donc créer un outil pour visualiser les arbres binaires à l'aide de la bibliothèque PIL. Le but est de créer une image au format png représentant l'arbre implémenté.

Quelques indications :

• L'image aura 800 pixels de largeur et 900 pixels de hauteur.
• On se limitera à des arbres de hauteur 4 au maximum. Un arbre n'étant composé que de sa racine est de hauteur 1.
• Il est utile de se faire un schéma au brouillon pour réfléchir aux coordonnées des noeuds de l'arbre avant de commencer à coder.
• On affichera les valeurs des noeuds à l'aide du module ImageDraw.

Voici un morceau de code pour vous aider à démarrer.

#Nom prenom
from PIL import Image,ImageDraw, ImageFont
img=Image.new("RGB",(800,900))
draw=ImageDraw.Draw(img)


class ArbreBinaire:
    def __init__(self,valeur):
        self.valeur=valeur
        self.gauche=None
        self.droit=None

    def ajout_gauche(self,valeur):
        self.gauche=Arbre_binaire(valeur)

    def ajout_droit(self,valeur):
        self.droit=Arbre_binaire(valeur)

    def suppr_gauche(self):
        self.gauche=None

    def suppr_droit(self):
        self.droit=None

#fond blanc
# for x in range(800):
#     for y in range(900):
#         img.putpixel((x,y),(255,255,255))

#un texte en (20,20) écrit en rouge
#font = ImageFont.truetype("arial.ttf", 30) 
#draw.text((20,20),"coucou",(255,0,0), font=font)

#une ligne :
#draw.line([(30,40),(50,60)],fill="black",width=6)

#un point :
#img.putpixel((400,450),(0,0,255))

img.show()

3. Projet API :

Nous souhaitons avoir accès à un LLM (Large Language Model) dans notre projet.

Faire tourner un LLM sur sa machine requiert une machine assez puissante pour le faire fonctionner.

En effet, des LLM performants requièrent des cartes graphiques de plusieurs milliers d'euros et plus d'une centaine de Go de mémoire vive. Des modèles plus petits peuvent tourner sur des machines plus raisonnables mais cela reste au delà de la puissance des machines du lycée.

Nous allons donc utiliser un module nommé ia.py qui utilise une API vers le site de votre professeur qui fait lui aussi appel à une API vers un LLM.

Prérequis :

• Avoir installé le module requests
• Avoir placé dans un même dossier :
  • le fichier ia.py

  • un fichier nommé noms_des_eleves.py contenant au début les trois premières lignes suivantes:

    import os
    
    #se déplacer dans le répertoire où se situe ia.py
    #os.chdir(os.path.dirname(os.path.abspath(__file__))) # pour des logiciels comme VScode par Exemple
    os.chdir("u:\\NSI") # a modifier
    import ia
    
    
    '''
    Exemple d'utilisation du module ia  : 
    
    
    messages = [
        {"role": "system", "content": "Tu es un assistant pédagogique."},
        {"role": "user", "content": "Explique-moi les bases de Python."},
        {"role": "assistant", "content": "Python est un langage de programmation facile à apprendre..."},
        {"role": "user", "content": "Comment déclarer une liste ?"}
    ]
    
    
    ia.reponse(messages)
    
    print(messages)
    '''
                        

Vous pouvez bien entendu regarder ce que contient le module ia.py mais vous ne le modifierez pas.

Tout votre code sera dans le second fichier que vous avez créé.

Exemples non exhaustifs des projets possibles :

• Exercices de corrections orthographiques : on fait écrire à l'élève du texte et on compte les fautes, l'encourage etc.
• Jeu de rôle intéractif
• Générateur de quiz
• Créateurs de récits : un utilisateur commence une histoire, le LLM la continue un peu, puis l'élève reprend etc.
• Un outil pour faire réviser un étudiant sur un thème donné (générateur de quiz).
• Un outil pour aider à la révision un étudiant sur un thème donné (créateur de fiches de révisions).
• Simulateur de chatbot historique : Faire dialoguer les élèves avec des figures historiques célèbres.
• Générateur de dictionnaires bilingues : Traduire et expliquer des termes spécifiques à un domaine.
• Simulateur de chatbot philosophe : Répondre à des questions éthiques ou philosophiques.
• Simulateur de test psychologique : Offrir des tests simples pour mieux se connaître (ex. : personnalité).
• Créateur de blagues : Générer des blagues adaptées au contexte ou au public.
• Créateur de personnages pour RPG : Générer des profils complets pour des jeux de rôle.

Certains projets ci-dessus sont (trop?) simples. On attendra alors une interface graphique (tkinter, flask...).

• Aide pour l'interface de tkinter :

  import tkinter as tk
  
  # Fonction pour mettre à jour le texte du label avec le texte saisi par l'utilisateur
  def update_text():
      # Récupère le texte entré dans le champ de saisie
      new_text = entry.get()
      # Met à jour le texte affiché dans le label
      label.config(text=new_text)
  
  # Création de la fenêtre principale de l'application
  root = tk.Tk()
  # Définition du titre de la fenêtre
  root.title("Interface simple")
  
  # Création d'un label qui affiche un texte initial "coucou"
  label = tk.Label(root, text="coucou", font=("Arial", 16))
  # Ajout du label à la fenêtre principale avec un espacement vertical
  label.pack(pady=10)
  
  # Création d'un champ de saisie pour permettre à l'utilisateur d'entrer du texte
  entry = tk.Entry(root, width=30)
  # Ajout du champ de saisie à la fenêtre principale avec un espacement vertical
  entry.pack(pady=5)
  
  # Création d'un bouton qui, lorsqu'il est cliqué, appelle la fonction update_text
  button = tk.Button(root, text="Valider", command=update_text)
  # Ajout du bouton à la fenêtre principale avec un espacement vertical
  button.pack(pady=5)
  
  # Lancement de la boucle principale de l'application Tkinter
  # Cette boucle écoute les événements et met à jour l'interface utilisateur
  root.mainloop()

• Aide pour l'interface flask et flask-session

  from flask import Flask, session, redirect, url_for, request, render_template
  from flask_session import Session
  
  # Création de l'application Flask
  app = Flask(__name__)
  
  # Configuration de Flask-Session
  app.config["SESSION_TYPE"] = "filesystem"  # Les sessions sont stockées dans des fichiers locaux (utilisé pour conserver les données de session)
  app.config["SECRET_KEY"] = "45465145615614654654165454544"  # Clé secrète pour signer les données de session
  Session(app)  # Initialisation de l'extension Flask-Session pour gérer les sessions
  
  @app.route("/", methods=["GET","POST"])  # Route principale, accepte les méthodes GET et POST
  def index():
      # Vérifie si une liste "personnes" existe déjà dans la session
      if "personnes" not in session:
          # Si elle n'existe pas, initialise la session avec une liste contenant une personne par défaut
          session['personnes'] = [
              {"nom": "Duranton", "prenom": "Olivier"}
          ]
  
      # Récupère les données envoyées via le formulaire (si elles existent)
      nom = request.form.get("nom")  # Récupère le champ "nom" du formulaire
      prenom = request.form.get("prenom")  # Récupère le champ "prenom" du formulaire
  
      # Si le nom et le prénom ont été soumis via le formulaire
      if nom is not None and prenom is not None:
          # Ajoute une nouvelle personne (dictionnaire avec nom et prénom) à la liste dans la session
          session["personnes"].append({"nom": nom, "prenom": prenom})
  
      # Rend le template HTML "index.html" en passant la liste des personnes à afficher
      return render_template("index.html", personnes=session['personnes'])
  
  # Lancement de l'application
  if __name__ == "__main__":
      app.run(debug=False)  # Lance le serveur Flask en mode debug (désactivé sur les ordinateurs du lycée car debug=True n'y marche pas)
                  

  Et dans le même dossier, avoir un dossier nommé templates avec à l'intérieur le fichier index.html qui contient :

  <!DOCTYPE html>
  <html lang="fr">
  
  <head>
      <meta charset="UTF-8">
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      <title>Document</title>
  </head>
  
  {% for personne in personnes %}
  <div class="personnes">
      <strong>{{ personne.nom.capitalize() }}:</strong>
      {{ personne.prenom }}
  </div>
  {% endfor %}
  
      <form method="POST" action="/">
          <input type="text" name="nom" placeholder="Votre nom de famille..." required>
          <input type="text" name="prenom" placeholder="Votre prénom..." required>
          <button type="submit">Envoyer</button>
      </form>
  
  </body>
  
  </html>
              

4. Projet SQL:

Le but de ce projet est d'appréhender les bases de données de la conception jusqu'à l'implémentation.

Voici les exigences :

• Ce projet est à faire seul ou deux.
• Le sujet du projet SQL est libre mais doit rester convenable.
• Il y aura une présentation à l'oral, avec une note d'oral.
• Le schéma relationnel doit contenir au moins 5 entités.

• Il y a trois fichiers à fournir :

  • Un fichier .pdf comportant :

    • Une présentation du contexte du projet.
    • Le schéma entité-association.
    • Le schéma relationnel.
    • Chaque requète demandée plus loin et avec une explication de ce qu'elle fait.

  • Un fichier .db

    • Chaque entité comporte au moins 8 lignes.

  • Un fichier .sql comportant :

    • 3 commandes INSERT INTO;
    • 2 commandes UPDATE;
    • 1 commande DELETE FROM;
    • 2 commandes SELECT simples ;
    • 1 commande SELECT associée avec la commande ORDER BY;
    • 2 commandes SELECT associée avec la commande WHERE;
    • 1 commande SELECT associée avec les commandes WHERE et ORDER BY;
    • 2 commandes SELECT associée avec les commandes WHERE et JOIN;
    • 1 commande SELECT comportant 2 commandes JOIN;
    • 1 commande SELECT avec la fonction COUNT()
    • 1 commande SELECT avec la fonction MAX()
    • 1 commande SELECT avec la fonction MIN()
    • 1 commande SELECT avec la fonction SUM()
    • 1 commande SELECT avec la fonction AVG()

5. Projet Message codé

Voici une première image :

Voici une deuxième image :

Il y a une différence entre ces deux images. La voyez-vous?

Un message a été caché dans la deuxième image, mais invisible pour votre oeil.

Le principe pour masquer le message a été le suivant :

1. Un message est écrit en lettres noires ((0,0,0)) sur fond blanc ((255,255,255)) dans une image privée .
2. On possède une image publique plus grande en largeur et en hauteur par exemple: original.jpeg
3. On créé une nouvelle image (pour le moment vide) de mêmes dimensions que l'image publique.

4. Pour chaque pixel aux coordonnées (x,y) de la nouvelle image , on récupère le tuple (r,g,b) de l'image publique aux coordonnées (x,y) puis :

   1. les valeurs r et g de la nouvelle image sont identiques
   2. Pour la valeur du bleu b:

      1. D'abord, si b est impair, on lui enlève 1. Ainsi la valeur de b est paire à cette étape.

      2. On ajoute 1 à b s'il existe un pixel blanc à ces coordonnées de l'image privée ou si ce pixel est en dehors de l'image privée.

Quelques lignes de codes pour vous aider :

# importation des bibliothèques nécessaires :
from PIL import Image
from PIL import ImageDraw
import os

repertoire_actuel="U:\\" #à modifier
# Se déplacer dans le répertoire du fichier actuel
os.chdir(repertoire_actuel)

#Pour ouvrir une image : 
#nom_de_variable_image=Image.open(nom_du_fichier_de_type_str)

#Pour créer une nouvelle image : 
#nom_de_variable_image=Image.new("RGB",(largeur,hauteur))

#Pour connaitre la taille d'une image : 
#largeur,hauteur = nom_de_variable_image.size

'''
for x in range(largeur):
    for y in range(hauteur):
        r,g,b=nom_de_variable_image.getpixel((x,y))[:3] # connaitre les pixels r,g,b

        nom_de_variable_image.putpixel((x,y),(r,g,b)) #mettre un pixel d'une certaine couleur
'''

#pour faire apparaitre une image : 
#nom_de_variable_image.show()

#pour enregistrer une image :
#nom_de_variable_image.save(nom_du_fichier_de_type_str)    

Travail à faire :

1. Télécharger la deuxième image puis faire apparaitre l'image privée à l'aide d'une fonction separation(fichier_entree :str,fichier_sortie :str). fichier_entree correspond au nom du fichier qu'il faut ouvrir. fichier_sortie correspond au nom du fichier que vous allez créer. Il correspond à l'image privée.

   Vous pouvez aussi tester votre code sur l'image originale, pour voir la différence.

2. Creer une fonction cache(image_publique :str, image_privee :str, fichier_sortie :str) qui permet de cacher une image en noir et blanc dans une autre et la tester.

   Attention : le fichier de sortie doit être au format png pour ne pas avoir de compressions de l'image et modifier les valeurs des pixels.

3. Une fois fini, approfondissement au choix :

   • Cacher trois images dans une autre à l'aide des deux autres couleurs. (facile)
   • Cacher une image en couleur dans une autre image en couleur.
   • Avec cette méthode, au lieu de cacher une image, on peut cacher un code binaire et donc un nombre ou du texte...