Update main.py

main.py

@@ -26,7 +26,6 @@ from bs4 import BeautifulSoup, Comment
 
 try:
     from pptx import Presentation
-    from pptx.enum.shapes import MSO_SHAPE_TYPE
 except ImportError:
     pass
 
@@ -91,7 +90,7 @@ def get_job_status(job_id: str):
         status_data = json.load(f)
     return status_data
 
-async def process_file(job_id: str, input_file_path: str, ext: str, original_filename: str):
+def process_file(job_id: str, input_file_path: str, ext: str, original_filename: str):
     job_dir = os.path.join(JOBS_DIR, job_id)
     try:
         update_job_status(job_id, 'processing', 'Le fichier est en cours de traitement')
@@ -101,9 +100,16 @@ async def process_file(job_id: str, input_file_path: str, ext: str, original_fil
         base_filename = os.path.splitext(original_filename)[0]
         output_filename = os.path.join(job_dir, f"{base_filename}.html")
 
-        final_html = await convert_to_accessible_html(
-            input_file_path, ext, base_filename, image_counter, images_data
-        )
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            final_html = loop.run_until_complete(
+                convert_to_accessible_html(
+                    input_file_path, ext, base_filename, image_counter, images_data
+                )
+            )
+        finally:
+            loop.close()
 
         if not final_html:
             update_job_status(job_id, 'error', 'Erreur lors de la conversion.')
@@ -139,23 +145,35 @@ def delete_files_after_delay(file_paths: List[str], delay: int = 6000):
 async def convert_to_accessible_html(input_filename, ext, base_filename, image_counter, images_data):
     try:
         if ext == '.pdf':
-            # PDF -> HTML avec pages et marqueurs IMG_X
+            # PDF -> HTML avec pages
             html_content = pdf_to_html(input_filename)
-            # Pour le PDF, on a déjà des <!--PAGE_X--> par page
+            # Pour le PDF, on a déjà des <!--PAGE_X--> par page, pas besoin d'en ajouter toutes les 20 lignes
         elif ext in ['.ppt', '.pptx']:
             # PPT/PPTX -> texte -> HTML minimal
             text = convert_ppt_to_text(input_filename)
             html_content = text_to_html(text)
+            # Ajouter les <!--PAGE_X--> toutes les 20 lignes pour ce format
             html_content = insert_page_comments_every_20_paragraphs(html_content)
         elif ext == '.doc':
             # DOC -> texte (textract) -> HTML minimal
             text = convert_doc_to_text(input_filename)
             html_content = text_to_html(text)
             html_content = insert_page_comments_every_20_paragraphs(html_content)
+        elif ext in ['.html', '.htm']:
+            with open(input_filename, 'r', encoding='utf-8') as f:
+                html_content = f.read()
+            try:
+                doc = Document(html_content)
+                html_content = doc.summary()
+            except Exception as e:
+                logging.error(f"Erreur lors du nettoyage HTML avec readability-lxml : {str(e)}")
+            # Ajouter les <!--PAGE_X--> toutes les 20 lignes
+            html_content = insert_page_comments_every_20_paragraphs(html_content)
         else:
             # Formats gérés par Pandoc
             input_format = get_pandoc_format(ext)
             html_content = convert_with_pandoc(input_filename, input_format)
+            # Ajouter les <!--PAGE_X--> toutes les 20 lignes
             html_content = insert_page_comments_every_20_paragraphs(html_content)
 
         # Nettoyage
@@ -165,24 +183,10 @@ async def convert_to_accessible_html(input_filename, ext, base_filename, image_c
         html_rewrite_task = asyncio.create_task(rewrite_html_accessible(cleaned_html))
 
         # Traitement des images (description)
-        tasks = []
         for image_key in images_data:
             base64_image = images_data[image_key]['base64_image']
-            tasks.append((image_key, asyncio.create_task(
-                get_image_description(
-                    base64_image,
-                    prompt="Décris ce que l'on peut voir sur cette image, pour qu'un lecteur malvoyant puisse comprendre ce qu'elle représente."
-                )
-            )))
-
-        results = await asyncio.gather(*(t for _, t in tasks), return_exceptions=True)
-
-        for (image_key, _), description in zip(tasks, results):
-            if isinstance(description, Exception):
-                logging.error(f"Erreur lors de la description de l'image {image_key} : {str(description)}")
-                images_data[image_key]['description'] = "Description indisponible."
-            else:
-                images_data[image_key]['description'] = description
+            description = await get_image_description(base64_image)
+            images_data[image_key]['description'] = description
 
         await html_rewrite_task
         rewritten_html = html_rewrite_task.result()
@@ -211,11 +215,13 @@ async def convert_to_accessible_html(input_filename, ext, base_filename, image_c
         return None
 
 def insert_page_comments_every_20_paragraphs(html_content: str) -> str:
+    # Insère un commentaire <!--PAGE_X--> toutes les 20 balises <p>
     soup = BeautifulSoup(html_content, 'html.parser')
     paragraphs = soup.find_all('p')
     page_number = 1
+    count = 0
     for i, p in enumerate(paragraphs, start=1):
-        if i % 20 == 1:
+        if i % 20 == 1:  # Avant le premier <p> d'un "bloc"
             comment = soup.new_string(f"<!--PAGE_{page_number}-->")
             p.insert_before(comment)
             page_number += 1
@@ -223,7 +229,6 @@ def insert_page_comments_every_20_paragraphs(html_content: str) -> str:
 
 def insert_css_into_html(html_content: str) -> str:
     css_code = """
-    /* Votre code CSS ici */
     :root {
         --font-size-min: 1rem;
         --font-size-base: 1rem;
@@ -395,44 +400,38 @@ def markdown_to_html(markdown_text: str) -> str:
     html = re.sub(r'_(.*?)_', r'<i>\1</i>', html)
     return html
 
-# MODIFICATIONS START
-# On rend le prompt pour get_image_description paramétrable
-async def get_image_description(base64_image: str, prompt: str) -> str:
+async def get_image_description(base64_image: str) -> str:
     try:
-        # Préparer le contenu avec le prompt et l'image en markdown
-        content = f"{prompt}\n\n![Image](data:image/jpeg;base64,{base64_image})"
-        logging.debug(f"Contenu envoyé à l'API OpenAI : {content}")
-
         response = await client.chat.completions.create(
             model="gpt-4o-mini",
             messages=[
                 {
                     "role": "user",
-                    "content": content,
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "Décris ce que l'on peut voir sur cette image, pour qu'un lecteur malvoyant puisse comprendre ce qu'elle représente.",
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{base64_image}"
+                            },
+                        },
+                    ],
                 }
             ],
         )
-        logging.debug(f"Réponse de l'API OpenAI : {response}")
-
-        if not response.choices:
-            logging.error("Aucune réponse reçue de l'API OpenAI.")
-            return "Description indisponible."
-
         description = response.choices[0].message.content.strip()
-        logging.debug(f"Description obtenue : {description}")
         return description
     except Exception as e:
         logging.error(f"Erreur lors de l'appel à l'API OpenAI : {str(e)}")
         return "Description indisponible."
 
-
-
-# MODIFICATIONS END
-
 async def rewrite_html_accessible(html_content: str) -> str:
     prompt = (
         "Je vais te donner un fichier HTML, et je voudrais que tu le réécrives pour permettre l'accessibilité à toutes les formes de handicap, tout en **préservant strictement l'ordre du contenu original**.\n"
-        "Commence à analyser le plan du document. Il faut d'abord identifier les titres et comprendre leur logique :\n"
+		"Commence à analyser le plan du document. Il faut d'abord identifier les titres et comprendre leur logique :\n"
         "- A priori, les titres qui sont préfixés par une écriture romaine (I, II, III), "
         "par un nombre (1, 2, 3) ou par une lettre (a, b, c, ou bien A, B, C) doivent être de même niveau."
         "Idem pour les titres rédigés en majuscules.\n"
@@ -470,7 +469,7 @@ async def rewrite_html_accessible(html_content: str) -> str:
         response = await client.chat.completions.create(
             model="o1-mini",
             messages=[
-                {"role": "user", "content": prompt + html_content}
+                {"role": "user", "content": prompt}
             ],
         )
         rewritten_html = response.choices[0].message.content.strip()
@@ -553,7 +552,7 @@ def reinsert_images(html_content: str, images_data: Dict[str, Dict[str, str]]) -
             if image_key in images_data:
                 img_tag = soup.new_tag('img')
                 img_tag['src'] = f"data:image/jpeg;base64,{images_data[image_key]['base64_image']}"
-                img_tag['alt'] = images_data[image_key].get('description', 'Description indisponible.')
+                img_tag['alt'] = images_data[image_key]['description']
 
                 new_content = soup.new_tag('div')
                 new_content.append(img_tag)
@@ -564,19 +563,17 @@ def reinsert_images(html_content: str, images_data: Dict[str, Dict[str, str]]) -
                 p_tag.append(strong_tag)
                 p_tag.append(" : ")
 
-                y_markdown = images_data[image_key].get('description', '')
+                y_markdown = images_data[image_key]['description']
                 y_html = markdown_to_html(y_markdown)
                 y_soup = BeautifulSoup(y_html, 'html.parser')
                 p_tag.append(y_soup)
 
                 new_content.append(p_tag)
                 comment.replace_with(new_content)
-                logging.debug(f"Image {image_number} réinsérée avec description.")
             else:
                 logging.error(f"Données pour {image_key} non trouvées.")
-    return str(soup)
-
 
+    return str(soup)
 
 def pdf_to_html(input_filename: str) -> str:
     soup = BeautifulSoup("<html><head></head><body></body></html>", 'html.parser')
@@ -676,7 +673,6 @@ async def convert_file_to_html(
         with open(status_file, 'w') as f:
             json.dump(status, f)
 
-        # Ajoutez la tâche asynchrone
         background_tasks.add_task(process_file, job_id, input_file_path, ext, file.filename)
 
         return JSONResponse(content={'job_id': job_id})
@@ -717,110 +713,6 @@ def delete_temp_files(file_paths: list):
         except Exception as e:
             logging.error(f"Erreur lors de la suppression du fichier {file_path} : {str(e)}")
 
-# MODIFICATIONS START
-def extract_images_from_pdf(input_filename: str) -> List[bytes]:
-    images = []
-    with fitz.open(input_filename) as doc:
-        smask_xrefs = set()  # Servira à lister les xrefs d'images masques
-        main_images = []     # Servira à lister les infos des images principales
-
-        for page_num, page in enumerate(doc, start=1):
-            img_list = page.get_images(full=True)
-            logging.debug(f"Page {page_num} contient {len(img_list)} images.")
-            for img_index, img in enumerate(img_list, start=1):
-                if len(img) < 7:
-                    logging.warning(f"Image {img_index} sur la page {page_num} a moins de 7 éléments : {img}")
-                    continue  # Ignorer les images avec une structure inattendue
-
-                xref, smask, width, height, bpc, colorspace, filters = img[:7]
-                # Si smask != 0, c'est une image principale avec un masque
-                # On ajoute le xref du masque à la liste des images à ignorer
-                if smask != 0:
-                    smask_xrefs.add(smask)
-                    logging.debug(f"Image {img_index} sur la page {page_num} a un masque (smask={smask}).")
-                # On enregistre l'image principale
-                main_images.append((xref, smask))
-        
-        logging.debug(f"Nombre total d'images principales à extraire : {len(main_images)}")
-        # Maintenant on extrait uniquement les images qui ne sont pas des masques
-        for (xref, smask) in main_images:
-            # Si xref est dans smask_xrefs, c'est une image de masque à ignorer
-            if xref in smask_xrefs:
-                logging.debug(f"Image xref={xref} est un masque, elle sera ignorée.")
-                continue
-            try:
-                base_image = doc.extract_image(xref)
-                image_bytes = base_image["image"]
-                images.append(image_bytes)
-                logging.debug(f"Image xref={xref} extraite avec succès.")
-            except Exception as e:
-                logging.error(f"Erreur lors de l'extraction de l'image xref={xref} : {str(e)}")
-    logging.info(f"Extraction des images terminée. Nombre total d'images extraites : {len(images)}")
-    return images
-
-def extract_text_with_image_markers(input_filename: str) -> Tuple[str, List[Tuple[int, bytes]]]:
-    """
-    Extrait le texte d'un PDF en insérant des marqueurs pour les images.
-
-    Args:
-        input_filename (str): Chemin vers le fichier PDF.
-
-    Returns:
-        Tuple[str, List[Tuple[int, bytes]]]: Le texte extrait avec des marqueurs et une liste d'images extraites.
-    """
-    text = ""
-    images = []
-    with fitz.open(input_filename) as doc:
-        for page_num, page in enumerate(doc, start=1):
-            text += f"<!--PAGE_{page_num}-->\n"
-
-            # Extraction du texte
-            page_text = page.get_text("text")
-            text += page_text + '\n'
-
-            # Extraction des images
-            image_list = page.get_images(full=True)
-            for img in image_list:
-                xref = img[0]
-                try:
-                    base_image = doc.extract_image(xref)
-                    image_bytes = base_image["image"]
-
-                    img_num = len(images) + 1
-                    marker = f"[IMG_{img_num}]"
-                    text += marker + '\n'
-
-                    images.append((img_num, image_bytes))
-                    logging.debug(f"Image {img_num} extraite de la page {page_num}.")
-                except Exception as e:
-                    logging.error(f"Erreur lors de l'extraction de l'image xref={xref} sur la page {page_num} : {str(e)}")
-
-            logging.debug(f"Page {page_num}: {len(images)} images extraites jusqu'à présent.")
-
-    logging.debug(f"Total text length: {len(text)} caractères.")
-    logging.debug(f"Total images extraites: {len(images)}.")
-    return text, images
-
-
-
-def extract_images_from_ppt(input_filename: str) -> List[Tuple[int, bytes]]:
-    images = []
-    if 'Presentation' not in globals():
-        return images
-    prs = Presentation(input_filename)
-    img_num = 1  # Compteur pour numéroter les images
-    for slide in prs.slides:
-        for shape in slide.shapes:
-            if shape.shape_type == MSO_SHAPE_TYPE.PICTURE:
-                image = shape.image
-                image_bytes = image.blob
-                images.append((img_num, image_bytes))
-                img_num += 1
-    return images
-
-
-# MODIFICATIONS END
-
 @app.post("/convert_to_txt/")
 async def convert_file_to_txt(
     file: UploadFile = File(...),
@@ -857,14 +749,13 @@ async def convert_file_to_txt(
         unique_id = uuid.uuid4().hex
         output_filename = os.path.join(tempfile.gettempdir(), f"{base_filename}_{unique_id}.txt")
 
-        text = ""
-        images = []
-        image_descriptions = {}
-
-        # Extraction du texte et des images
         if ext == '.pdf':
-            text, images = extract_text_with_image_markers(input_filename)
-            logging.debug(f"Extraction PDF terminée. Texte extrait de {len(text)} caractères. {len(images)} images trouvées.")
+            text = ""
+            with fitz.open(input_filename) as doc:
+                for page in doc:
+                    text += page.get_text()
+            with open(output_filename, "w", encoding="utf-8") as f:
+                f.write(text)
         elif ext == '.pptx':
             if 'Presentation' not in globals():
                 raise HTTPException(status_code=500, detail="La librairie python-pptx n'est pas installée.")
@@ -875,74 +766,29 @@ async def convert_file_to_txt(
                     if hasattr(shape, "text"):
                         text_content.append(shape.text)
             text = "\n".join(text_content)
-            images = extract_images_from_ppt(input_filename)
-            logging.debug(f"Extraction PPTX terminée. Texte extrait de {len(text)} caractères. {len(images)} images trouvées.")
+            with open(output_filename, "w", encoding="utf-8") as f:
+                f.write(text)
         elif ext == '.ppt':
             if 'textract' not in globals():
                 raise HTTPException(status_code=500, detail="La librairie textract n'est pas installée.")
             text = textract.process(input_filename).decode('utf-8', errors='replace')
-            images = extract_images_from_ppt(input_filename)
-            logging.debug(f"Extraction PPT terminée. Texte extrait de {len(text)} caractères. {len(images)} images trouvées.")
+            with open(output_filename, "w", encoding="utf-8") as f:
+                f.write(text)
         elif ext == '.doc':
             if 'textract' not in globals():
                 raise HTTPException(status_code=500, detail="La librairie textract n'est pas installée.")
             text = textract.process(input_filename).decode('utf-8', errors='replace')
-            # Pas d'extraction d'images simple pour .doc ici
-            images = []
-            logging.debug(f"Extraction DOC terminée. Texte extrait de {len(text)} caractères. Aucune image trouvée.")
-        else:
-            # Autres formats pris en charge par pandoc (sans extraction d'image)
-            pypandoc.convert_file(input_filename, 'plain', outputfile=output_filename)
-            with open(output_filename, "r", encoding="utf-8") as f:
-                text = f.read()
-            images = []
-            logging.debug(f"Conversion avec Pandoc terminée. Texte extrait de {len(text)} caractères. Aucune image trouvée.")
-
-        # Analyse des images et récupération des descriptions
-        if images:
-            tasks = []
-            for img_num, img_bytes in images:
-                base64_image = base64.b64encode(img_bytes).decode('utf-8')
-                tasks.append(asyncio.create_task(
-                    get_image_description(
-                        base64_image,
-                        prompt="Cette image est incluse dans un cours. Je voudrais que tu me donnes toutes les informations pertinentes, pour qu'on puisse comprendre ce qu'elle contient sans la voir. Ne commente pas les couleurs, les formes et la disposition. Ne commente pas le fait que tu décris l'image : fais en sorte que l'image puisse être naturellement remplacée par ta description. Si l'image ne contient aucune information, ne renvoie rien du tout."
-                    )
-                ))
-            logging.debug(f"Lancement de {len(tasks)} tâches pour la description des images.")
-
-            descriptions = await asyncio.gather(*tasks, return_exceptions=True)
-
-            for (img_num, _), desc in zip(images, descriptions):
-                if isinstance(desc, Exception):
-                    logging.error(f"Erreur lors de la description de l'image {img_num} : {str(desc)}")
-                    image_descriptions[img_num] = "Description indisponible."
-                elif desc and desc != "Description indisponible.":
-                    image_descriptions[img_num] = desc
-                else:
-                    image_descriptions[img_num] = "Description indisponible."
-            logging.debug(f"Descriptions des images terminées. {len(image_descriptions)} descriptions générées.")
-
-            # Remplacer les marqueurs par les descriptions
-            for img_num, desc in image_descriptions.items():
-                marker = f"[IMG_{img_num}]"
-                description_text = f"Image {img_num}: {desc}"
-                text = text.replace(marker, description_text)
-            logging.debug("Remplacement des marqueurs d'images par les descriptions terminé.")
+            with open(output_filename, "w", encoding="utf-8") as f:
+                f.write(text)
         else:
-            logging.debug("Aucune image trouvée. Aucun remplacement de marqueur effectué.")
-
-        # Écriture du texte dans le fichier de sortie
-        with open(output_filename, "w", encoding="utf-8") as f:
-            f.write(text)
-        logging.debug(f"Écriture du fichier texte terminée : {output_filename}")
+            output = pypandoc.convert_file(input_filename, 'plain', outputfile=output_filename)
 
         if not os.path.exists(output_filename):
             logging.error(f"Le fichier {output_filename} n'a pas été généré.")
             raise HTTPException(status_code=500, detail="Erreur lors de la conversion.")
 
         temp_files_to_delete = [input_filename, output_filename]
-        if ext in ['.html', '.htm'] and 'cleaned_input_filename' in locals():
+        if ext in ['.html', '.htm']:
             temp_files_to_delete.append(cleaned_input_filename)
         background_tasks.add_task(delete_temp_files, temp_files_to_delete)
 
@@ -953,5 +799,4 @@ async def convert_file_to_txt(
         return JSONResponse(status_code=http_exc.status_code, content={"message": http_exc.detail})
     except Exception as e:
         logging.error(f"Erreur interne lors de la conversion : {str(e)}")
-        return JSONResponse(status_code=500, content={"message": f"Erreur interne : {str(e)}"})
-
+        return JSONResponse(status_code=500, content={"message": f"Erreur interne : {str(e)}"})