multipage et ux ++

agents_page/recommended_agent.py

@@ -1,5 +1,71 @@
 import streamlit as st
-
+from utils.audit.response_llm import generate_response_via_langchain
+from textwrap import dedent
 #st.set_page_config(page_title="Agents recommandés", page_icon="", layout="wide")
+def remove_images_from_content(content):
+    filtered_content = {}
+    
+    for page, data in content.items():
+        # Create a new dictionary excluding the "images" key
+        filtered_data = {key: value for key, value in data.items() if key != "images"}
+        filtered_content[page] = filtered_data
+    
+    return filtered_content
+
+def recommended_agent_main():
+    st.title("Agents recommandés")
+
+    if "audit" not in st.session_state or "audit" is None:
+        st.error("Veuillez d'abord effectuer un audit pour obtenir des recommandations d'agents.")
+        return
+    
+    audit = st.session_state.audit_simplified
+    content = st.session_state.audit["content"]
+
+    if "response_llm" not in st.session_state:
+        st.session_state.response_llm = ""
+
+
+    #filter content, delete images if type is pdf
+    if audit["type de fichier"] == "pdf":
+        content = remove_images_from_content(content)
+    #delete audio if type is audio and keep transcript
+    elif audit["type de fichier"] == "audio":
+        content = content["transcription"]
+
+    ressources = content
+
+    prompt = '''Tu es designer en intelligence artificielle (IA) spécialisé dans la création d'agents IA autonomes et performants.
+        A partir de ressources fournies par l'utilisateur (texte, documents, images, audio), tu es chargé de suggérer la création d'agents autonomes pour mettre en pratique les informations contenues dans les ressources fournies.
+
+        Tu proposes deux solutions :
+
+        Sol. A : 1 seul agent IA dont tu suggéreras :
+        * Nom
+        * Rôle
+        * Objectifs
+        * Outils utilisés par l'agent
+        * Tâches réalisées par l'agents
+        * Compétences de l'agent (backstory)
+
+        Sol. B : 1 équipe d'agents tu suggéreras :
+        * Le nombre d'agents
+        * Pour chacune d'eux [Nom, Rôle, Objectifs, Outils utilisés par l'agent, Tâches réalisées par l'agents, Compétences de l'agent (backstory)]
+
+        Une fois ce travail réalisé, tu proposes une série de 3 missions avec objectifs SMART pour chacun des agents  Sol. A et Sol. B en présentation les résultats dans un tableau contenant :
+        Nom de l’agent
+        Objectifs à atteindre
+        '''
+    
+    #display prompt and modify it 
+    prompt_modified = st.text_area("Prompt", prompt, height=300)
+    prompt_modified = dedent(prompt_modified)
+    if st.button("Générer les recommandations"):
+        resource_prompt = f'''Ressources fournies par l'utilisateur :{ressources}'''
+        prompt_modified = f"{prompt_modified}\n{resource_prompt}"
+        st.session_state.response_llm = st.write_stream(generate_response_via_langchain(query=prompt_modified,stream=True))
+    elif st.session_state.response_llm:
+        st.info("la dernière réponse générée est affichée ci-dessous")
+        st.write(st.session_state.response_llm)
 
-st.title("Agents recommandés")
+recommended_agent_main()

audit_page/audit.py

@@ -1,7 +1,7 @@
 import streamlit as st
 import pymupdf as fitz
 import pyperclip
-from utils.audit.audit_doc import audit_descriptif_pdf,audit_text,audit_descriptif_word
+from utils.audit.audit_doc import audit_descriptif_pdf,audit_text
 import dotenv
 from utils.audit.audit_audio import evaluate_audio_quality
 from PIL import Image
@@ -26,15 +26,16 @@ def classify_file(file):
     
 #display content
 def display_content_doc(content:dict,col:st):
-
     number_of_pages = len(content)
-    col.info("si vous choisissez 0, vous verrez le contenu de toutes les pages")
+    col.info("Note : Si vous choisissez 0, vous verrez le contenu de toutes les pages")
     
     number = col.number_input("Numéro de page", min_value=0, max_value=number_of_pages, value=0,key="number_page_content")
     #0 means all pages
     if number > 0:
         page : dict = content[f"page_{number-1}"]
+
     option = col.radio("Type de contenu",list(content[f"page_0"].keys()), index=0,horizontal=True)
+
     if option == "images":
         if number == 0:
             images = [img for page in content.values() for img in page["images"]]
@@ -62,55 +63,132 @@ def display_content_doc(content:dict,col:st):
             links = [link for page in content.values() for link in page["liens"]]
         else:
             links = page["liens"]
+        
         for i, link in enumerate(links):
-            col.markdown(f"- {i+1}: {link['uri']} (page {link['page']})")
+            col.markdown(f"- {i+1}: [{link['uri']}]({link["uri"]}) (page {link['page']})")
+    
+    elif option == "tableaux":
+        if number == 0:
+            tables = [table for page in content.values() for table in page["tableaux"]]
+        else:
+            tables = page["tableaux"]
         
+        for i, table in enumerate(tables):
+            col.write(f"Tableau {i+1}")
+            col.write(table)
+
+def display_content_audio(content:dict,col:st):
+    st.write("##### Transcription")
+    st.write(content["transcription"])
+    if st.button("📋",key="copy_transcription"):
+        pyperclip.copy(content["transcription"])
+        st.success("Transcription copiée dans le presse-papier")
+    
+    st.audio(content["audio_data"],sample_rate=content["frame_rate"]*2)
 
+def display_content_text(content,col:st):
+    st.text_area("Texte",content,height=200)
+        
+def handle_display_content(col:st):
+    audit = st.session_state.audit
+    type = st.session_state.audit_simplified["type de fichier"]
+    if type == "pdf":
+        with col.expander("Contenu"):
+            display_content_doc(audit["content"],st)
+    elif type == "audio":
+        with col.expander("Contenu"):
+            display_content_audio(audit["content"],col)
+    elif type == "text":
+        with col.expander("Contenu"):
+            display_content_text(audit["content"],col)
+
+
+
+def handle_audit(uploaded_file,type:str):
+    if type == "pdf":
+        if st.session_state.name_file != uploaded_file.name:
+            st.session_state.name_file = uploaded_file.name
+            with st.spinner("Analyse du document..."):
+                st.session_state.audit = audit_descriptif_pdf(uploaded_file,100)
+        audit = st.session_state.audit["audit"]
+        #global audit
+        audit_simplified = {
+            "type de fichier": type,
+            "Nombre de pages": audit["number_of_pages"],
+            "Nombre d'images": audit["number_of_images"],
+            "Nombre de liens": audit["number_of_links"],
+            "Nombre de tableaux": audit["number_of_tables"],
+            "Nombre de tokens": audit["number_of_tokens"],
+            "Nombre de mots": audit["number_of_words"],
+            "Mots clés": audit["key_words"]
+        }
+        st.session_state.audit_simplified = audit_simplified
     
+    elif type == "audio":
+        if st.session_state.name_file != uploaded_file.name:
+            st.session_state.name_file = uploaded_file.name
+            with st.spinner("Analyse de l'audio..."):
+                st.session_state.audit = evaluate_audio_quality(uploaded_file)
+        audit = st.session_state.audit["audit"]
+        #audit global simplifié
+        audit_simplified = {
+            "type de fichier": type,
+            "Durée": f"{audit['duration']:0.2f} minutes",
+            "Nombre de mots": audit["number_of_words"],
+            "Nombre de tokens": audit["number_of_tokens"],
+            "Volume": f"{audit['volume']:0.2f} dBFS (déciBels Full Scale)",
+            "SNR": f"{max(audit['SNR'],0):0.2f} dB (Ratio Signal / Bruit)", 
+        }
+        st.session_state.audit_simplified = audit_simplified
+    
+    elif type == "text":
+        text = uploaded_file.read().decode("utf-8")
+        if st.session_state.name_file != uploaded_file.name:
+            st.session_state.name_file = uploaded_file.name
+            with st.spinner("Analyse du texte..."):
+                st.session_state.audit = audit_text(text)
+        audit = st.session_state.audit["audit"]
+        #audit global simplifié
+        audit_simplified = {
+            "type de fichier": type,
+            "Nombre de tokens": audit["number_of_tokens"],
+            "Nombre de mots": audit["number_of_words"]
+        }
+        st.session_state.audit_simplified = audit_simplified
+    
+
     
-def display_audit_pdf(uploaded_file,col:st):
-    if st.session_state.name_file != uploaded_file.name:
-        st.session_state.name_file = uploaded_file.name
-        with st.spinner("Analyse du document..."):
-            st.session_state.audit = audit_descriptif_pdf(uploaded_file,200)
+    
+def display_audit(col:st):
+    #audit global simplifié
+    audit_simplified = st.session_state.audit_simplified
     audit = st.session_state.audit["audit"]
-    content = st.session_state.audit["content"]
-    #global audit
-    audit_simplified = {
-        "Nombre de pages": audit["number_of_pages"],
-        "Nombre d'images": audit["number_of_images"],
-        "Nombre de liens": audit["number_of_links"],
-        "Nombre de tableaux": audit["number_of_tables"],
-        "Nombre de tokens": audit["number_of_tokens"],
-        "Nombre de mots": audit["number_of_words"],
-        "Mots clés": audit["key_words"]
-    }
 
     well_formatted_audit = "Contenus audités\n"
     for key, value in audit_simplified.items():
         well_formatted_audit += f"- {key}: {value}\n"
 
-
     col.code(well_formatted_audit)
 
-    #audit par page
-    with col.expander("Audit par page"):
-        number = st.number_input("Numéro de page", min_value=1, max_value=audit["number_of_pages"], value=1,key="number_page_audit")
-        audit_page = audit[f"page_{number-1}"]
-        audit_page = {
-            "Nombre d'images": audit_page["number_of_images"],
-            "Nombre de liens": audit_page["number_of_links"],
-            "Nombre de tableaux": audit_page["number_of_tables"],
-            "Nombre de tokens": audit_page["number_of_tokens"],
-            "Nombre de mots": audit_page["number_of_words"],
-        }
-        well_formatted_audit_page = "Audit descriptif\n"
-        for key, value in audit_page.items():
-            well_formatted_audit_page += f"- {key}: {value}\n"
-        
-        st.code(well_formatted_audit_page)
+    if audit_simplified["type de fichier"] == "pdf": #cad un type qui contient des pages
+        #audit par page
+        with col.expander("Audit par page"):
+            number = st.number_input("Numéro de page", min_value=1, max_value=audit["number_of_pages"], value=1,key="number_page_audit")
+            audit_page = audit[f"page_{number-1}"]
+            audit_page = {
+                
+                "Nombre d'images": audit_page["number_of_images"],
+                "Nombre de liens": audit_page["number_of_links"],
+                "Nombre de tableaux": audit_page["number_of_tables"],
+                "Nombre de tokens": audit_page["number_of_tokens"],
+                "Nombre de mots": audit_page["number_of_words"],
+            }
+            well_formatted_audit_page = "Audit descriptif\n"
+            for key, value in audit_page.items():
+                well_formatted_audit_page += f"- {key}: {value}\n"
+            
+            st.code(well_formatted_audit_page)
     
-    return content
 
 
 def audit_main():
@@ -128,97 +206,22 @@ def audit_main():
         st.session_state.audit = {}
     if "name_file" not in st.session_state:
         st.session_state.name_file = ""
+    if "audit_simplified" not in st.session_state:
+        st.session_state.audit_simplified = {}
 
     # File uploader
     uploaded_file = col1.file_uploader("Télécharger un ou plusieurs documents")
 
     if uploaded_file is not None:
         type = classify_file(uploaded_file)
+        handle_audit(uploaded_file,type)
 
         col1.write(f"Type de fichier: {type}")
 
-        col1.write("### Synthèse audit du ou des document(s) téléchargé(s)")
-
-        
-        
-        if type == "pdf":
-            content = display_audit_pdf(uploaded_file,col1)
-            with col2.expander("Contenu"):
-                display_content_doc(content,st)
-
-        elif type == "audio":
-            if st.session_state.name_file != uploaded_file.name:
-                st.session_state.name_file = uploaded_file.name
-                with st.spinner("Analyse de l'audio..."):
-                    st.session_state.audit = evaluate_audio_quality(uploaded_file)
-            audit = st.session_state.audit
-
-            #audit global simplifié
-            audit_simplified = {
-                "Durée": f"{audit['duration']:0.2f} minutes",
-                "Nombre de mots": audit["number_of_words"],
-                "Nombre de tokens": audit["number_of_tokens"],
-                "Volume": f"{audit['volume']:0.2f} dBFS (déciBels Full Scale)",
-                "SNR": f"{max(audit['SNR'],0):0.2f} dB (Ratio Signal / Bruit)", 
-            }
-
-            well_formatted_audit = "Contenus audités\n"
-            for key, value in audit_simplified.items():
-                well_formatted_audit += f"- {key}: {value}\n"
-            
-            col1.code(well_formatted_audit)
-            
-            with col2.expander("Transcription"):
-                st.write(audit["transcription"])
-                if st.button("📋",key="copy_transcription"):
-                    pyperclip.copy(audit["transcription"])
-                    st.success("Transcription copiée dans le presse-papier")
-        
-        elif type == "text":
-            text = uploaded_file.read().decode("utf-8")
-            if st.session_state.name_file != uploaded_file.name:
-                st.session_state.name_file = uploaded_file.name
-                with st.spinner("Analyse du texte..."):
-                    st.session_state.audit = audit_text(text)
-            audit = st.session_state.audit
-
-            #audit global simplifié
-            audit_simplified = {
-                "Nombre de tokens": audit["number_of_tokens"],
-                "Nombre de mots": audit["number_of_words"]
-            }
-
-            well_formatted_audit = "Audit descriptif\n"
-            for key, value in audit_simplified.items():
-                well_formatted_audit += f"- {key}: {value}\n"
-
-            col1.code(well_formatted_audit)
-
-            with col2.expander("Texte"):
-                st.text_area("Texte",text,height=200)
-        
-        elif type == "word":
-            if st.session_state.name_file != uploaded_file.name:
-                st.session_state.name_file = uploaded_file.name
-                with st.spinner("Analyse du document..."):
-                    st.session_state.audit = audit_descriptif_word(uploaded_file)
-            audit = st.session_state.audit
-
-            #global audit
-            audit_simplified = {
-                "Nombre de pages": audit["number_of_paragraphs"],
-                "Nombre d'images": audit["number_of_images"],
-                "Nombre de liens": audit["number_of_links"],
-                "Nombre de tableaux": audit["number_of_tables"],
-                "Nombre de tokens": audit["number_of_tokens"],
-                "Nombre de mots": audit["number_of_words"]
-            }
-
-            well_formatted_audit = "Contenus audités\n"
-            for key, value in audit_simplified.items():
-                well_formatted_audit += f"- {key}: {value}\n"
-
-            st.code(well_formatted_audit)
+        col1.write("### Synthèse audit de(s) document(s) téléchargé(s)")
 
+    if "audit" in st.session_state and st.session_state.audit != {}:
+        display_audit(col1)
+        handle_display_content(col2)
 
 audit_main()

requirements.txt

@@ -11,3 +11,4 @@ nltk
 rake_nltk
 python-docx
 pillow
+pandas

utils/audit/audit_audio.py

@@ -39,7 +39,7 @@ def evaluate_audio_quality(file) -> dict:
     audio_data = np.array(audio.get_array_of_samples())
 
     #number of minutes
-    duration = len(audio_data) / audio.frame_rate / 60
+    duration = len(audio_data) / audio.frame_rate*2 / 60
 
     # Calculate volume
     volume = audio.dBFS
@@ -49,6 +49,24 @@ def evaluate_audio_quality(file) -> dict:
 
     #get the transcription of the audio
     transcription = transcript_audio_func(file)
-    
-    return {"volume": volume, "SNR": snr,"transcription": transcription,"number_of_tokens": count_tokens(transcription),"duration": duration, "number_of_words": len(transcription.split())}
 
+    audit = {
+        "volume": volume,
+        "SNR": snr,
+        "duration": duration,
+        "number_of_tokens": count_tokens(transcription),
+        "number_of_words": len(transcription.split())
+    }
+
+    content = {
+        "transcription": transcription,
+        "audio_data": audio_data,
+        "frame_rate": audio.frame_rate
+    }
+
+    audit_global = {
+        "audit": audit,
+        "content": content
+    }
+    
+    return audit_global

utils/audit/audit_doc.py

@@ -98,7 +98,8 @@ def audit_descriptif_pdf(file,max_img_width) -> dict:
         page_content = {
             "images": [],
             "texte": "",
-            "liens": []
+            "liens": [],
+            "tableaux": []
         }
 
         #number of images
@@ -140,7 +141,10 @@ def audit_descriptif_pdf(file,max_img_width) -> dict:
         audit_dict_doc["number_of_links"] += number_links
 
         #number of tables
-        number_tables = len(page.find_tables().tables)
+        tables = page.find_tables().tables
+        number_tables = len(tables)
+        for tab in tables:
+            page_content["tableaux"].append(tab.to_pandas())
         audit_dict_page["number_of_tables"] = number_tables
         audit_dict_doc["number_of_tables"] += number_tables
 
@@ -170,7 +174,8 @@ def audit_descriptif_pdf(file,max_img_width) -> dict:
         - {list_key_words_text}
         Veuillez extraire les cinq mots clés les plus pertinents de cette liste. Chaque mot clé doit contenir au maximum deux mots.
 
-        REPONSE:
+        TA REPONSE DOIT RESPECTER LE FORMAT SUIVANT :
+        key_word1, key_word2, key_word3, key_word4, key_word5
     '''
     key_words_extracted = extract_relevant_keywords(prompt)
     audit_dict_doc["key_words"] = "\n" + key_words_extracted
@@ -186,45 +191,14 @@ def audit_descriptif_pdf(file,max_img_width) -> dict:
 def audit_text(text: str) -> dict:
     audit_dict = {
         "number_of_tokens": count_tokens(text),
-        "number_of_words": len(text.split())
+        "number_of_words": len(text.split()),
     }
 
-    return audit_dict
-
-def audit_descriptif_word(file) -> dict:
-    document = Document(io.BytesIO(file.read()))
-
-    audit_dict_doc = {
-        "number_of_paragraphs": 0,
-        "number_of_images": 0,
-        "number_of_links": 0,
-        "number_of_tables": 0,
-        "number_of_tokens": 0,
-        "number_of_words": 0
+    global_audit = {
+        "audit": audit_dict,
+        "content": text
     }
 
-    for para in document.paragraphs:
-        audit_dict_doc["number_of_paragraphs"] += 1
-        text = para.text
-
-        # Count tokens and words in the paragraph
-        number_tokens = count_tokens(text)
-        number_words = len(text.split())
-
-        audit_dict_doc["number_of_tokens"] += number_tokens
-        audit_dict_doc["number_of_words"] += number_words
-
-        # Count links (assuming they are hyperlinks)
-        for run in para.runs:
-            if run.link:
-                audit_dict_doc["number_of_links"] += 1
-
-    for table in document.tables:
-        audit_dict_doc["number_of_tables"] += 1
-
-    # Counting images (inline shapes and pictures)
-    for shape in document.inline_shapes:
-        audit_dict_doc["number_of_images"] += 1
+    return global_audit
 
-    return audit_dict_doc
 

utils/audit/response_llm.py

@@ -0,0 +1,35 @@
+from openai import OpenAI
+from langchain_openai import ChatOpenAI
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import PromptTemplate
+
+def generate_response_openai(prompt: str,stream:bool = False) -> str:
+    client = OpenAI()
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
+            {"role": "user", "content": prompt}
+        ],
+        stream=stream
+    )
+    
+    return response.choices[0].message.content
+
+
+def generate_response_via_langchain(query: str, stream: bool = False, model: str = "gpt-4o-mini") :
+    # Define the prompt template
+    template = "You are an agent designer expert: {query}"
+    prompt = PromptTemplate.from_template(template)
+    
+    # Initialize the OpenAI LLM with the specified model
+    llm = ChatOpenAI(model=model)
+    
+    # Create an LLM chain with the prompt and the LLM
+    llm_chain = prompt | llm | StrOutputParser()
+
+    if stream:
+        # Return a generator that yields streamed responses
+        return llm_chain.stream({"query": query})
+    
+    # Invoke the LLM chain and return the result
+    return llm_chain.invoke({"query": query})