io4it 2.1.2.1__tar.gz → 2.1.3__tar.gz

io4it-2.1.3/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.1
+Name: io4it
+Version: 2.1.3
+Home-page: 
+Author: 
+Author-email: 
+Keywords: orange3 add-on

io4it-2.1.3/io4it.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.1
+Name: io4it
+Version: 2.1.3
+Home-page: 
+Author: 
+Author-email: 
+Keywords: orange3 add-on

{io4it-2.1.2.1 → io4it-2.1.3}/io4it.egg-info/SOURCES.txt

@@ -34,7 +34,6 @@ orangecontrib/IO4IT/widgets/OWmailLoader.py
 orangecontrib/IO4IT/widgets/OWmailSender.py
 orangecontrib/IO4IT/widgets/OWwordpdf2docx.py
 orangecontrib/IO4IT/widgets/__init__.py
-orangecontrib/IO4IT/widgets/designer/OWmailSender.py
 orangecontrib/IO4IT/widgets/designer/__init__.py
 orangecontrib/IO4IT/widgets/designer/nogui.ui
 orangecontrib/IO4IT/widgets/designer/ow_file_ext_selector.ui

{io4it-2.1.2.1 → io4it-2.1.3}/orangecontrib/IO4IT/widgets/OWChatGpt.py

@@ -2,7 +2,7 @@ import os
 import sys
 import base64
 import ast
-from openai import OpenAI
+import openai
 import Orange
 from Orange.data import StringVariable
 from Orange.widgets.widget import OWWidget, Input, Output
@@ -98,53 +98,30 @@ class ChatGpt(OWWidget):
 
     def generate_answers(self):
         try:
-            client = OpenAI(api_key=self.api_keys)
-            system_content = []
-            if getattr(self, "system_prompt", None):
-                system_content = [{"type": "input_text", "text": str(self.system_prompt)}]
-
-            user_content = []
-            if isinstance(self.prompt, list):
-                user_content.extend(self.prompt)
-            else:
-                user_content.append({"type": "input_text", "text": str(self.prompt)})
-
-            if getattr(self, "image_paths", None):
-                # normalize image_paths to a list
-                if isinstance(self.image_paths, str):
-                    self.image_paths = ast.literal_eval(self.image_paths)
-
-                for img_path in self.image_paths:
-                    filename = os.path.basename(img_path)
-                    user_content.append({"type": "input_text", "text": f"Photo : {filename}"})
-
-                    with open(img_path, "rb") as f:
-                        b64_img = base64.b64encode(f.read()).decode("utf-8")
-
-                    mime = "image/png" if filename.lower().endswith(".png") else "image/jpeg"
-                    user_content.append({
-                        "type": "input_image",
-                        "image_url": f"data:{mime};base64,{b64_img}",
-                    })
-                response = client.responses.create(
-                    model=self.model,
-                    input=[
-                        {"role": "system", "content": system_content},
-                        {"role": "user", "content": user_content},
-                    ],
-                    max_output_tokens=self.max_tokens,
-                    # temperature=self.temperature,
-                )
-                self.text_response = response.output_text
-
-
-            if self.text_response is None:
-                self.error("No response from model.")
-
+            openai.api_key = self.api_keys
+            response = openai.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {
+                        "role": "system",
+                        "content": self.system_prompt
+                    },
+                    {
+                        "role": "user",
+                        "content": self.prompt
+                    }
+                ],
+                max_tokens=self.max_tokens,
+                temperature=self.temperature
+            )
+            self.text_response = response.choices[0].message.content
         except Exception as e:
             print(e)
             self.error(f"Error: {e}")
             return
+        if self.text_response is None:
+            self.error("No response from chatgpt.")
+
 
     def run(self):
         self.error("")
@@ -160,6 +137,30 @@ class ChatGpt(OWWidget):
             self.error("No api keys provided.")
             return
 
+        # si on relance la génération par le bouton le prompt est déjà rempli (déjà une liste)
+        # mais on peut changer le model, la temp ou le nombre max de token
+        if isinstance(self.prompt, list):
+            self.prompt = [{"type": "text", "text": self.prompt}]
+            if self.image_paths is not None and self.image_paths != []:
+                if type(self.image_paths) == str:
+                    self.image_paths = ast.literal_eval(self.image_paths)
+                for img_path in self.image_paths:
+                    filename = os.path.basename(img_path)
+
+                    # Ajoute une mention de l’image avant
+                    self.prompt.append({
+                        "type": "text",
+                        "text": f"Photo : {filename}"
+                    })
+
+                    with open(img_path, "rb") as f:
+                        b64_img = base64.b64encode(f.read()).decode("utf-8")
+                        self.prompt.append({
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{b64_img}"
+                            }
+                        })
         self.progressBarInit()
         self.thread = thread_management.Thread(self.generate_answers)
         self.thread.progress.connect(self.handle_progress)

{io4it-2.1.2.1 → io4it-2.1.3}/orangecontrib/IO4IT/widgets/OWMarkdownizer.py

@@ -16,6 +16,7 @@ import easyocr
 
 from AnyQt.QtCore import QThread, pyqtSignal
 from AnyQt.QtWidgets import QApplication, QLabel, QSpinBox, QTextEdit, QPushButton
+from AnyQt import uic
 
 from Orange.widgets import widget
 from Orange.widgets.utils.signals import Input, Output

{io4it-2.1.2.1 → io4it-2.1.3}/orangecontrib/IO4IT/widgets/OWOfficeNormalizer.py

@@ -2,18 +2,15 @@ import os
 import sys
 from pathlib import Path
 import shutil
-import comtypes
+
 from AnyQt.QtWidgets import QApplication
 from Orange.widgets import widget
 from Orange.widgets.utils.signals import Input, Output
 from Orange.data import Domain, StringVariable, Table, DiscreteVariable
+
+# --- Ajout pour l'écriture Excel ---
 from openpyxl import Workbook
-import docx
-import aspose.words as aw
-import multiprocessing
-import queue
 
-# Les imports sont adaptés pour correspondre au style de l'autre script
 if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
     from Orange.widgets.orangecontrib.IO4IT.utils import utils_md
     from Orange.widgets.orangecontrib.AAIT.utils.import_uic import uic
@@ -22,24 +19,6 @@ else:
     from orangecontrib.AAIT.utils.import_uic import uic
 
 
-def _convert_file_process(src_path: Path, dst_dir: Path, file_type: str, result_queue: multiprocessing.Queue):
-    """
-    Fonction de conversion exécutée dans un processus séparé.
-    Place le résultat (statut, chemin, détails) dans une file d'attente.
-    """
-    try:
-        if file_type == "doc":
-            dst = utils_md.convert_doc_to_docx(src_path, dst_dir)
-            result_queue.put(("ok", str(dst), "doc->docx"))
-        elif file_type == "ppt":
-            dst = utils_md.convert_ppt_to_pptx(src_path, dst_dir)
-            result_queue.put(("ok", str(dst), "ppt->pptx"))
-    except comtypes.COMError:
-        result_queue.put(("ko", "", "conversion failed: COM error"))
-    except Exception as e:
-        result_queue.put(("ko", "", f"conversion failed: {e}"))
-
-
 class OWOfficeNormalizer(widget.OWWidget):
     name = "Office Normalizer"
     description = "Convertit .doc→.docx et .ppt→.pptx via COM (Windows + Office)"
@@ -68,11 +47,6 @@ class OWOfficeNormalizer(widget.OWWidget):
         self.autorun = True
         self.result = None
         self.processed_statuses = []
-
-        # Connecter la case à cocher pour activer/désactiver le spinbox
-        self.checkBox_timeout.toggled.connect(self.spinBox_timeout.setEnabled)
-        self.spinBox_timeout.setEnabled(self.checkBox_timeout.isChecked())
-
         self.post_initialized()
 
     @Inputs.data
@@ -98,41 +72,13 @@ class OWOfficeNormalizer(widget.OWWidget):
         self.processed_statuses = []
         self.Outputs.status_data.send(None)
 
-        # Déterminer la valeur du timeout
-        self.timeout_value = None
-        if self.checkBox_timeout.isChecked():
-            self.timeout_value = self.spinBox_timeout.value()
-
+        # Process files directly without a separate thread
         result_table = self._normalize_files(self.data)
 
+        # Send the final results to the primary output
         self.Outputs.data.send(result_table)
         self.progressBarFinished()
 
-    def _check_file_status(self, file_path: Path):
-        """
-        Vérifie si un fichier est accessible, non corrompu et non protégé par un mot de passe.
-        Retourne un tuple : (statut_court, détails)
-        """
-        if not file_path.exists():
-            return "ko", "not found"
-        try:
-            with open(file_path, 'rb'):
-                pass
-        except IOError as e:
-            return "ko", f"locked or permission denied: {e}"
-        try:
-            file_info = aw.FileFormatUtil.detect_file_format(str(file_path))
-            if file_info.is_encrypted:
-                return "ko", "password protected"
-        except Exception:
-            pass
-        if file_path.suffix.lower() == ".docx":
-            try:
-                docx.Document(file_path)
-            except Exception:
-                return "ko", "corrupted"
-        return "ok", "ready"
-
     def _normalize_files(self, in_data: Table) -> Table:
         rows = []
         file_paths = [str(x) for x in in_data.get_column("file_path")]
@@ -147,6 +93,7 @@ class OWOfficeNormalizer(widget.OWWidget):
         output_base_dir = common_path / "office_normalisation"
         output_base_dir.mkdir(parents=True, exist_ok=True)
 
+        # Gère le nom du fichier Excel avec incrémentation
         base_name = "normalization_results"
         excel_path = output_base_dir / f"{base_name}.xlsx"
         counter = 1
@@ -154,6 +101,7 @@ class OWOfficeNormalizer(widget.OWWidget):
             excel_path = output_base_dir / f"{base_name}_{counter}.xlsx"
             counter += 1
 
+        # Initialise le classeur Excel
         wb = Workbook()
         ws = wb.active
         ws.title = "Normalization Results"
@@ -162,72 +110,67 @@ class OWOfficeNormalizer(widget.OWWidget):
 
         for i, path_str in enumerate(file_paths):
             self.progressBarSet(i / total_files * 100)
+
             src = Path(path_str)
             dst_path = ""
-            status_short, details = self._check_file_status(src)
-
-            if status_short == "ok":
+            status_text = ""
+            status_short = ""
+            details = ""
+
+            if not src.exists():
+                status_short = "ko"
+                details = "not found"
+                status_text = f"ko: {details}"
+            else:
                 try:
-                    if src.suffix.lower() == ".docx":
-                        dst_dir = output_base_dir / src.parent.relative_to(common_path)
-                        dst_dir.mkdir(parents=True, exist_ok=True)
-                        dst = dst_dir / src.name
-                        shutil.copy(src, dst)
-                        dst_path = str(dst)
-                        details = "docx - unchanged"
-
-                    elif src.suffix.lower() in [".doc", ".ppt"]:
-                        dst_dir = output_base_dir / src.parent.relative_to(common_path)
-                        dst_dir.mkdir(parents=True, exist_ok=True)
-
-                        result_queue = multiprocessing.Queue()
-                        p = multiprocessing.Process(
-                            target=_convert_file_process,
-                            args=(src, dst_dir, src.suffix.lower().lstrip("."), result_queue)
-                        )
-                        p.start()
-
-                        try:
-                            # Utilisation de la valeur de timeout sélectionnée
-                            p.join(timeout=self.timeout_value)
-
-                            if p.is_alive():
-                                p.terminate()
-                                status_short = "ko"
-                                details = "conversion timed out"
-                            else:
-                                status_short, dst_path, details = result_queue.get(timeout=1)
-                        except queue.Empty:
-                            status_short = "ko"
-                            details = "conversion process failed silently"
-                        except Exception as e:
-                            status_short = "ko"
-                            details = f"conversion failed: {e}"
+                    relative_path_from_common = src.parent.relative_to(common_path)
+                    dst_dir = output_base_dir / relative_path_from_common
+                    dst_dir.mkdir(parents=True, exist_ok=True)
 
+                    if src.suffix.lower() == ".doc":
+                        dst = utils_md.convert_doc_to_docx(src, dst_dir)
+                        dst_path = str(dst)
+                        status_short = "ok"
+                        details = "doc->docx"
+                        status_text = f"ok: {details}"
+                    elif src.suffix.lower() == ".ppt":
+                        dst = utils_md.convert_ppt_to_pptx(src, dst_dir)
+                        dst_path = str(dst)
+                        status_short = "ok"
+                        details = "ppt->pptx"
+                        status_text = f"ok: {details}"
                     else:
-                        dst_dir = output_base_dir / src.parent.relative_to(common_path)
-                        dst_dir.mkdir(parents=True, exist_ok=True)
                         dst = dst_dir / src.name
                         if not dst.exists():
                             shutil.copy(src, dst)
                         dst_path = str(dst)
+                        status_short = "ok"
                         details = "unchanged"
-
+                        status_text = f"ok: {details}"
                 except Exception as e:
+                    error_msg = str(e)
                     status_short = "ko"
-                    details = f"error: {e}"
+                    details = f"error: {error_msg}"
+                    status_text = f"ko: {details}"
 
+            # Ajoute la ligne de résultat à la table Excel et la sauvegarde
             result_row = [path_str, dst_path, status_short, details]
             ws.append(result_row)
             wb.save(excel_path)
-            rows.append([path_str, dst_path, status_short])
 
+            # Append to the final results list for Orange table
+            rows.append([path_str, dst_path, status_text])
+
+            # Append to the status update list and send the incremental table
             self.processed_statuses.append([path_str, status_short, details])
             self._send_status_table()
 
+            # This is crucial for UI updates, including the progress bar
             QApplication.processEvents()
 
         self.progressBarSet(100)
+
+        # Create and return the final output table
         domain = Domain([], metas=[
             StringVariable("src_path"),
             StringVariable("dst_path"),
@@ -236,6 +179,7 @@ class OWOfficeNormalizer(widget.OWWidget):
         return Table.from_list(domain, rows)
 
     def _send_status_table(self):
+        """Sends an incremental table to the status_data output."""
         domain = Domain([], metas=[
             StringVariable("src_path"),
             DiscreteVariable("status", values=["ok", "ko"]),
@@ -252,7 +196,6 @@ class OWOfficeNormalizer(widget.OWWidget):
 
 
 if __name__ == "__main__":
-    multiprocessing.freeze_support()
     app = QApplication(sys.argv)
     my_widget = OWOfficeNormalizer()
     my_widget.show()

{io4it-2.1.2.1 → io4it-2.1.3}/orangecontrib/IO4IT/widgets/OWPdfType.py

@@ -10,7 +10,6 @@ from Orange.widgets.utils.signals import Input, Output
 
 # --- Ajout pour l'écriture Excel ---
 from openpyxl import Workbook
-import pypdf
 
 # Les imports sont adaptés pour correspondre au style de l'autre script
 if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
@@ -57,7 +56,7 @@ class OWPdfType(widget.OWWidget):
         self.thread = None
         self.autorun = True
         self.result = None
-        self.processed_statuses = []
+        self.processed_statuses = []  # List to accumulate statuses
         self.post_initialized()
 
     @Inputs.data
@@ -74,7 +73,6 @@ class OWPdfType(widget.OWWidget):
             self.Outputs.text_data.send(None)
             self.Outputs.image_data.send(None)
             self.Outputs.status_data.send(None)
-            QApplication.quit()
             return
 
         self.error("")
@@ -82,17 +80,19 @@ class OWPdfType(widget.OWWidget):
             self.data.domain["file_path"]
         except KeyError:
             self.error("You need a 'file_path' column in input data.")
-            QApplication.quit()
             return
 
         if type(self.data.domain["file_path"]).__name__ != 'StringVariable':
             self.error("'file_path' column needs to be a Text.")
-            QApplication.quit()
             return
 
         self.progressBarInit()
-        self.processed_statuses = []
+        self.processed_statuses = []  # Reset status list for a new run
+
+        # Connect the internal status update signal to a new handler
         self.status_update_signal.connect(self.handle_status_update)
+
+        # Pass the status update signal's emit method to the thread
         self.thread = Thread(self._process_pdfs, self.data, status_callback=self.status_update_signal.emit)
         self.thread.progress.connect(self.handle_progress)
         self.thread.result.connect(self.handle_result)
@@ -102,8 +102,10 @@ class OWPdfType(widget.OWWidget):
     def _process_pdfs(self, in_data: Table, progress_callback: callable, status_callback: callable) -> tuple[
         Table | None, Table | None]:
 
+        # Extraction des chemins de fichiers avant de commencer le traitement
         paths = [str(x) for x in in_data.get_column("file_path")]
 
+        # --- Gérer le nom du fichier Excel avec incrémentation ---
         excel_output_dir = Path.cwd() / "pdf_check_results"
         if paths:
             first_file_path = Path(paths[0])
@@ -118,6 +120,7 @@ class OWPdfType(widget.OWWidget):
             excel_path = excel_output_dir / f"{base_name}_{counter}.xlsx"
             counter += 1
 
+        # --- Initialiser le classeur Excel ---
         wb = Workbook()
         ws = wb.active
         ws.title = "PDF Check Results"
@@ -130,8 +133,9 @@ class OWPdfType(widget.OWWidget):
         total_files = len(paths)
         for i, p in enumerate(paths):
             progress_callback(i / total_files * 100)
+
             fp = Path(p)
-            result_row = [p, "", ""]
+            result_row = [p, "", ""]  # Initialisation de la ligne de résultat
 
             if not fp.exists() or fp.suffix.lower() != ".pdf":
                 result_row[1] = "ko"
@@ -142,56 +146,64 @@ class OWPdfType(widget.OWWidget):
                 continue
 
             try:
-                # Vérification de l'attribut is_encrypted de PyPDF avant de traiter le fichier.
-                reader = pypdf.PdfReader(fp)
-                if reader.is_encrypted:
-                    result_row[1] = "ko"
-                    result_row[2] = "Error: PDF is password protected."
+                is_text = utils_md.is_pdf_text_based(fp)
+                if is_text:
+                    text_indices.append(i)
+                    result_row[1] = "ok"
+                    result_row[2] = "Text-based PDF"
                 else:
-                    is_text = utils_md.is_pdf_text_based(fp)
-                    if is_text:
-                        text_indices.append(i)
-                        result_row[1] = "ok"
-                        result_row[2] = "Text-based PDF"
-                    else:
-                        image_indices.append(i)
-                        result_row[1] = "ok"
-                        result_row[2] = "Image-based PDF"
+                    image_indices.append(i)
+                    result_row[1] = "ok"
+                    result_row[2] = "Image-based PDF"
+
+                status_callback(result_row)
+                ws.append(result_row)
+                wb.save(excel_path)
             except Exception as e:
                 result_row[1] = "ko"
                 result_row[2] = f"Error: {str(e)}"
-            finally:
                 status_callback(result_row)
                 ws.append(result_row)
                 wb.save(excel_path)
 
         progress_callback(100)
 
+        # Create table for text PDFs
         if not text_indices:
             text_table = None
         else:
             text_table = in_data[text_indices]
 
+        # Create table for image PDFs
         if not image_indices:
             image_table = None
         else:
             image_table = in_data[image_indices]
 
+        # The final result is still returned here
         return text_table, image_table
 
     def handle_progress(self, value: float) -> None:
         self.progressBarSet(value)
 
     def handle_status_update(self, new_status: list):
+        """
+        Receives a single status update from the thread, appends it to the list,
+        and sends a new, updated status table.
+        """
         self.processed_statuses.append(new_status)
+
+        # Correct Domain creation: move "file_path" to metas
         status_domain = Domain(
-            [],
+            [],  # The variables list should be empty
             metas=[
                 StringVariable("file_path"),
                 DiscreteVariable("status", values=["ok", "ko"]),
                 StringVariable("details")
             ]
         )
+
+        # Now, the data is correctly structured for the new domain
         status_table = Table.from_list(status_domain, self.processed_statuses)
         self.Outputs.status_data.send(status_table)