Upload 4 files

code.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:763a8e11dffaafff83b8e0bfd22707c0e3042b56c27988259186e6ecca00fcdf
+size 126976

code.txt

@@ -0,0 +1,258 @@
+1_16
+;;;
+On désire programmer une fonction qui prend en paramètre le rayon d'un cercle et renvoie son aire
+
+Exemple :
+```
+>>> aire_cercle(2)
+28.274
+```
+Complétez la fonction aire_cercle dans l'éditeur de code (remplacez les ...)
+;;;
+import math
+
+def aire_cercle(...):
+    aire = math.pi*rayon**2
+    return ...
+;;;
+c=""
+if round(aire_cercle(3)) == 28:
+    c+="1"
+else  :
+    c+="0"
+;;;
+1_17
+;;;
+On désire programmer une fonction qui prend en paramètre un nombre et qui renvoie la chaîne de caractères "pair" si le nombre est pair et "impair" dans le cas contraire
+
+Exemples :
+```
+>>> pair_impair(4)
+"pair"
+>>> pair_impair(3)
+"impair"
+```
+Complétez la fonction `pair_impair` dans l'éditeur de code (remplacez les ...)
+;;;
+import math
+
+def pair_impair(n):
+    if ... % 2 == 0:
+        return ...
+    else :
+        return "impair"
+;;;
+c=""
+if pair_impair(4) == "pair":
+    c+="1"
+else  :
+    c+="0"
+if pair_impair(3) == "impair":
+    c+="1"
+else  :
+    c+="0"
+;;;
+1_19
+;;;
+Vous êtes gérant d'un magasin et vous désirez écrire un programme Python qui calculera automatiquement le montant de la facture des clients.
+
+Tout client qui achète au moins 5 fois le même article se voit octroyer une remise de 5 % (uniquement sur le montant de l'achat de cet article).
+
+Afin de simplifier le problème, on considère qu'un client n'achète qu'un seul type d'article.
+
+Écrivez une fonction `facture` qui prend en paramètre le prix unitaire de l'article `p` et le nombre d'articles achetés `n`. Cette fonction doit renvoyer le montant de la facture.
+
+Exemples :
+```
+>>> facture(3,4)
+12
+>>> facture(3,5)
+14.25
+;;;
+;;;
+c=""
+if facture(3,4) == 12:
+    c+="1"
+else  :
+    c+="0"
+if facture(3,5) == 14.25:
+    c+="1"
+else  :
+    c+="0"
+;;;
+2_12
+;;;
+La fonction recherche_max prend en paramètre un tableau et renvoie la plus grande valeur présente dans le tableau (le tableau est constitué d'entiers positifs ou nuls).
+
+Exemples :
+```
+>>> recherche_max([4, 3, 0, 5])
+5
+>>> recherche_max([-3, -2, -12, -22])
+-2
+```
+Compétez la fonction dans l'éditeur de code.
+;;;
+def recherche_max(tab):
+    maxi = ...
+    for t in tab :
+        if ... > maxi :
+            maxi = ...
+    return ...
+;;;
+c=""
+if recherche_max([4, 3, 0, 5]) == 5:
+    c+="1"
+else  :
+    c+="0"
+if recherche_max([-3, -2, -12, -22]) == -2:
+    c+="1"
+else  :
+    c+="0"
+;;;
+2_13
+;;;
+La fonction somme prend en paramètres un tableau tab contenant des entiers. Cette fonction renvoie la somme des entiers présents dans le tableau tab.
+
+Exemple :
+```
+>>> somme([3,5,8,4])
+20
+```
+Complétez la fonction `somme` dans l'éditeur de code.
+;;;
+def somme(tab):
+    s = ...
+    for t in ... :
+        s = s + ...
+    return ...
+;;;
+c=""
+if somme([3,5,8,4]) == 20:
+    c+="1"
+else  :
+    c+="0"
+;;;
+2_14
+;;;
+La fonction recherche prend en paramètres un tableau tab contenant des entiers et un entier n. Cette fonction renvoie l'indice de position de l'entier n s'il est présent dans le tableau tab ou -1 dans le cas contraire (on partira du principe que le tableau ne peut pas contenir 2 fois le même entier).
+
+Exemples : 
+```
+>>> recherche([3,5,8,34], 8)
+2
+>>> recherche([3,5,8,34], 42)
+-1
+```
+Complétez la fonction `recherche` dans l'éditeur de code
+;;;
+def recherche(tab, n):
+    for i in ... :
+        if n == ... :
+            return ...
+    return ...
+;;;
+c=""
+if recherche([3,5,8,34], 8) == 2:
+    c+="1"
+else  :
+    c+="0"
+if recherche([3,5,8,34],42) == -1:
+    c+="1"
+else  :
+    c+="0"
+;;;
+2_15
+;;;
+Écrire une fonction moyenne qui prend en paramètre un tableau d'entiers non vide `tab` et qui renvoie la moyenne de ces entiers.
+
+Exemple :
+```
+>>> moyenne([12,15,17,0])
+11
+```
+;;;
+;;;
+c=""
+if moyenne([12,15,17,0]) == 11:
+    c+="1"
+else  :
+    c+="0"
+;;;
+3_6
+;;;
+On utilise un tableau contenant des dictionnaires afin de stocker les notes des élèves Titi, Toto et Tutu :
+```
+[{'nom':'Titi', 'note':12}, {'nom':'Tutu', 'note':11}, {'nom':'Toto', 'note':17}]
+```
+La fonction `plusHaute` prend en paramètre un tableau contenant des dictionnaires (comme celui ci-dessus) et renvoie le nom de l'élève ayant obtenu la meilleure note (on partira du principe que les élèves ont tous des notes différentes).
+
+Complétez la fonction `plusHaute` dans l'éditeur de code.
+;;;
+def plusHaute(tab):
+    nom = ""
+    max_note = ...
+    for t in ...:
+        if t['note'] > ...:
+            max_note = t[...]
+            nom = t[...]
+    return ...
+;;;
+c=""
+if plusHaute([{'nom':'Titi', 'note':12}, {'nom':'Tutu', 'note':11}, {'nom':'Toto', 'note':17}]) == "Toto":
+    c+="1"
+else  :
+    c+="0"
+;;;
+3_7
+;;;
+On utilise un tableau et des dictionnaires pour stocker des noms et des numéros de téléphone :
+```
+[{'nom':'Titi', 'num':987675643}, {'nom':'Tutu', 'num':424224}, {'nom':'Toto', 'num':343235365}]
+```
+La fonction numTel prend 2 paramètres : un tableau de dictionnaires `tab_tel` contenant les noms et les numéros de téléphone (comme celui ci-dessus) et un nom `n`
+
+La fonction `numTel` doit renvoyer le numéro de téléphone de `n` si ce dernier existe. Dans le cas où `n` n'existe pas, la fonction `numTel` doit renvoyer -1
+
+Exemples :
+```
+>>> numTel([{'nom':'Titi', 'num':987675643}, {'nom':'Tutu', 'num':424224}, {'nom':'Toto', 'num':343235365}], 'Tutu')
+424224
+>>> numTel([{'nom':'Titi', 'num':987675643}, {'nom':'Tutu', 'num':424224}, {'nom':'Toto', 'num':343235365}], 'Tata')
+-1
+```
+Complétez la fonction `numTel` dans l'éditeur de code.
+;;;
+def numTel(..., n):
+    for ... in tab_tel:
+        if ...  == t['nom']:
+            return ...
+    return ...
+;;;
+c=""
+if numTel([{'nom':'Titi', 'num':987675643}, {'nom':'Tutu', 'num':424224}, {'nom':'Toto', 'num':343235365}], 'Tutu') == 424224:
+    c+="1"
+else  :
+    c+="0"
+if  numTel([{'nom':'Titi', 'num':987675643}, {'nom':'Tutu', 'num':424224}, {'nom':'Toto', 'num':343235365}], 'Tata') == -1:
+    c+="1"
+else  :
+    c+="0"
+;;;
+3_8
+;;;
+On utilise un tableau contenant des dictionnaires afin de stocker les notes des élèves Titi, Toto et Tutu :
+```
+[{'nom':'Titi', 'note':12}, {'nom':'Tutu', 'note':11}, {'nom':'Toto', 'note':17}]
+```
+La fonction `moyenne` prend en paramètre un tableau contenant des dictionnaires (comme celui ci-dessus) et renvoie la moyenne des notes.
+
+Écrivez la fonction `moyenne`
+;;;
+;;;
+c=""
+if moyenne([{'nom':'Titi', 'note':13}, {'nom':'Tutu', 'note':14}, {'nom':'Toto', 'note':18}]) == 15:
+    c+="1"
+else  :
+    c+="0"
+;;;

database.py

@@ -0,0 +1,36 @@
+import sqlite3
+
+def create_table():
+    conn = sqlite3.connect("code.db")
+    cursor = conn.cursor()
+    cursor.execute("DELETE FROM code;")
+    with open('code.txt', 'r') as f:
+        c = 0
+        txt = ""
+        id = 1
+        for l in f :
+            txt += l
+            if l == ";;;\n":
+                c += 1
+            if c == 4 :
+                tab = txt.split(";;;\n")
+                txt = ""
+                c = 0
+                cursor.execute("INSERT INTO code (id, titre, enonce, code_trous, test) VALUES (?, ?, ?, ?, ?)", (id, tab[0].replace("\n",""), tab[1], tab[2], tab[3]))
+                id += 1
+        conn.commit()
+        conn.close()
+
+def return_exercise(titre):
+    conn = sqlite3.connect("code.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT * FROM code WHERE titre = ?", (titre,))
+    rows = cursor.fetchall()
+    conn.close()
+    return rows[0]
+
+
+
+
+
+

main.py

@@ -0,0 +1,104 @@
+import os
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import PromptTemplate
+from langgraph.checkpoint.memory import MemorySaver
+from typing import List
+from typing_extensions import TypedDict
+from typing import Annotated
+from langgraph.graph.message import AnyMessage, add_messages
+from langchain_core.messages import HumanMessage, AIMessage
+from langgraph.graph import END, StateGraph, START
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from database import create_table, return_exercise
+import logging
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+create_table()
+
+GOOGLE_API_KEY = 'AIzaSyDUtmNWKzd93_yLs2Ihi7K0nYwclZESmbE'
+
+llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0.7, api_key=GOOGLE_API_KEY)
+
+
+prompt_aide = PromptTemplate.from_template(
+"""
+Tu es un expert en pédagogie de l'apprentissage de la programmation
+Le langage utilisé pour l'apprentissage de la programmation est Python.
+Tu dois aider un élève à résoudre une activité de programmation Python.
+Il existe 2 types d'activités :
+- les activités qui demandent à l'élève d'écrire un programme Python complet
+- les activités qui demandent à l'élève de compléter un programme Python à trous (les trous sont indiqués par 3 points : ...)
+Si l'activité est de type "à trous" et que l'élève à laissé des trous, tu dois lui proposer de compléter les trous.
+Tu ne dois jamais donner la solution de l'activité (même partiellement) à l'élève, juste lui donner des inddications lui permettant de résoudre lui même l'activité
+Tu dois t'adresser directement à l'élève.
+L'élève ne peut pas te poser des questions, il peut juste te proposer son code.
+Tu ne dois pas proposer à l'élève de te poser des questions
+Il est inutile de proposer à l'élève de tester son code avec les exemples proposés.
+Tu ne dois pas proposer aux élèves des modifications du programme qui sorte du cadre de l'activité. Par exemple, pour l'activité qui demande d'écrire une fonction moyenne, si dans l'énoncé il est précisé que l'on a un tableau non vide d'entier en paramètre, il est inutile de dire à l'élève que son programme doit gérer les tableaux vides.
+Tu dois t'exprimer en français
+Voici l'énoncé de l'activité :
+{enonce}
+Voici le programme proposé par l'élève pour résoudre l'activité :
+{code}
+Pour améliorer ta réponse, tu as aussi à ta disposition l'historique des différents programme proposés par l'élève et les différents conseils que tu lui a déjà donné :
+{historique} 
+""")
+
+def history(hist):
+    historical = ""
+    for i in range(len(hist)):
+        if i%2 == 0:
+            historical += "code de l'éléve : \n"+hist[i].content+"\n"
+        else :
+            historical += "aide de l'expert : \n"+hist[i].content+"\n"
+    return historical
+
+memory = MemorySaver()
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class Request(BaseModel):
+    id : str
+    enonce : str
+    code : str
+    res_test : str
+
+class AgentState(TypedDict):
+    enonce : str
+    messages: Annotated[list[AnyMessage], add_messages]
+    res_test : str
+
+def aide(state : AgentState):
+    llm_aide = prompt_aide | llm | StrOutputParser()
+    response = llm_aide.invoke({'enonce': state['enonce'], 'code' : state['messages'][-1].content, 'historique' : history(state['messages'])})
+    return {"messages": [AIMessage(content=response)]}
+
+workflow = StateGraph(AgentState)
+
+workflow.add_node("aide", aide)
+
+workflow.add_edge(START, "aide")
+workflow.add_edge( "aide", END)
+
+graph = workflow.compile(checkpointer=memory)
+
+@app.post('/request')
+def request(req: Request):
+    config = {"configurable": {"thread_id": req.id}}
+    rep = graph.invoke({"enonce" : req.enonce,"messages": req.code, "res_test" : req.res_test},config , stream_mode="values")
+    return {"response":rep['messages'][-1].content}
+
+
+@app.get('/exercise/{titre}')
+def get_exercise(titre : str):
+    ex = return_exercise(titre)
+    return {"title" : ex[1], "enonce" : ex[2], "code_trous":ex[3], "test": ex[4]}