IO4IT 2.0.0__tar.gz → 2.1.0__tar.gz

io4it-2.1.0/PKG-INFO

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

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

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

{io4it-2.0.0 → io4it-2.1.0}/io4it.egg-info/SOURCES.txt

@@ -1,4 +1,3 @@
-setup.cfg
 setup.py
 io4it.egg-info/PKG-INFO
 io4it.egg-info/SOURCES.txt
@@ -30,10 +29,12 @@ orangecontrib/IO4IT/widgets/designer/__init__.py
 orangecontrib/IO4IT/widgets/designer/chart.html
 orangecontrib/IO4IT/widgets/designer/nogui.ui
 orangecontrib/IO4IT/widgets/designer/ow_file_ext_selector.ui
+orangecontrib/IO4IT/widgets/designer/owchatgpt.ui
 orangecontrib/IO4IT/widgets/designer/owdeepsearch.ui
 orangecontrib/IO4IT/widgets/designer/owexportmarkdown.ui
 orangecontrib/IO4IT/widgets/designer/owmailloader.ui
 orangecontrib/IO4IT/widgets/designer/owmailsender.ui
+orangecontrib/IO4IT/widgets/designer/owmarkdownizer.ui
 orangecontrib/IO4IT/widgets/designer/owspeechtotext.ui
 orangecontrib/IO4IT/widgets/designer/owvisualizationer.ui
 orangecontrib/IO4IT/widgets/designer/wordpdf2docx.ui

io4it-2.1.0/io4it.egg-info/entry_points.txt

@@ -0,0 +1,7 @@
+[orange.widgets]
+AAIT - ALGORITHM = orangecontrib.ALGORITHM.widgets
+AAIT - API = orangecontrib.API.widgets
+AAIT - LLM INTEGRATION = orangecontrib.LLM_INTEGRATION.widgets
+AAIT - MODELS = orangecontrib.LLM_MODELS.widgets
+AAIT - TOOLBOX = orangecontrib.TOOLBOX.widgets
+IO4IT = orangecontrib.IO4IT.widgets

{io4it-2.0.0 → io4it-2.1.0}/io4it.egg-info/requires.txt

@@ -11,6 +11,11 @@ pyannote.audio
 pyannote-core
 pypandoc
 pypandoc-binary
-wave==0.0.2
 scikit-learn
 openai
+pip-system-certs==5.0
+docx2pdf
+doc2docx
+msal
+exchangelib
+CATEGORIT

io4it-2.1.0/orangecontrib/IO4IT/widgets/OWChatGpt.py

@@ -0,0 +1,201 @@
+import os
+import sys
+import base64
+import ast
+import openai
+import Orange
+from Orange.data import StringVariable
+from Orange.widgets.widget import OWWidget, Input, Output
+from Orange.widgets.settings import Setting
+from AnyQt.QtWidgets import QApplication, QLineEdit, QSpinBox, QDoubleSpinBox, QPushButton
+
+if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
+    from Orange.widgets.orangecontrib.AAIT.utils import thread_management
+    from Orange.widgets.orangecontrib.AAIT.utils.import_uic import uic
+    from Orange.widgets.orangecontrib.IO4IT.utils import offuscation_basique
+else:
+    from orangecontrib.AAIT.utils.import_uic import uic
+    from orangecontrib.AAIT.utils import thread_management
+    from orangecontrib.IO4IT.utils import offuscation_basique
+
+class ChatGpt(OWWidget):
+    name = "CallChatGptApi"
+    description = "Call to chatgpt API. You need to provide a prompt and an api_keys. You call also add an image_paths and a system_prompt if you want."
+    icon = "icons/chatgpt.png"
+    if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
+        icon = "icons_dev/chatgpt.png"
+    priority = 3000
+    max_tokens = Setting(4096)
+    temperature = Setting(0)
+    model = Setting("gpt-4o")
+    gui = os.path.join(os.path.dirname(os.path.abspath(__file__)), "designer/owchatgpt.ui")
+    want_control_area = False
+    category = "AAIT - LLM INTEGRATION"
+
+    class Inputs:
+        data = Input("Data", Orange.data.Table)
+
+    @Inputs.data
+    def set_data(self, in_data):
+        if in_data is None:
+            return
+        if "prompt" not in in_data.domain:
+            self.error("input table need a prompt column")
+            return
+        self.prompt = in_data.get_column("prompt")[0]
+        if "image_paths" in in_data.domain:
+            self.image_paths = in_data.get_column("image_paths")[0]
+        if "api_keys" not in in_data.domain:
+            self.api_keys = offuscation_basique.lire_config_cli_api("CHAT_GPT")
+            if offuscation_basique.lire_config_cli_api("CHAT_GPT") is None:
+                self.error("input table need a api_keys column or a folder API with you CHAT_GPT keys in aait store")
+        if self.api_keys is None:
+            self.api_keys = in_data.get_column("api_keys")[0]
+        if "system_prompt" in in_data.domain:
+            self.system_prompt = in_data.get_column("system_prompt")[0]
+        self.data = in_data
+        self.run()
+
+    class Outputs:
+        data = Output("Data", Orange.data.Table)
+
+    def __init__(self):
+        super().__init__()
+        # Qt Management
+        self.setFixedWidth(400)
+        self.setFixedHeight(300)
+        uic.loadUi(self.gui, self)
+        self.edit_model = self.findChild(QLineEdit, 'modelName')
+        self.edit_model.setPlaceholderText("Model name")
+        self.edit_model.setText(self.model)
+        self.edit_model.editingFinished.connect(self.update_parameters)
+
+        self.edit_max_tokens = self.bind_spinbox("boxMaxTokens", self.max_tokens)
+        self.edit_temperature = self.bind_spinbox("boxTemperature", self.temperature, is_double=True)
+        self.pushButton_call_api =self.findChild(QPushButton, 'callApi')
+        self.pushButton_call_api.clicked.connect(self.run)
+
+        self.data = None
+        self.prompt = None
+        self.image_paths = None
+        self.api_keys = None
+        self.system_prompt = ""
+        self.text_response = None
+        self.thread = None
+        self.run()
+
+    def bind_spinbox(self, name, value, is_double=False):
+        widget_type = QDoubleSpinBox if is_double else QSpinBox
+        box = self.findChild(widget_type, name)
+        box.setValue(value)
+        box.editingFinished.connect(self.update_parameters)
+        return box
+
+    def update_parameters(self):
+        self.max_tokens = self.edit_max_tokens.value()
+        self.temperature = self.edit_temperature.value()
+        self.model = self.edit_model.text()
+
+    def generate_answers(self):
+        try:
+            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("")
+        self.warning("")
+        if self.data is None:
+            return
+
+        if self.prompt == "" or self.prompt is None:
+            self.error("No prompt provided.")
+            return
+
+        if self.api_keys is None:
+            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)
+        self.thread.result.connect(self.handle_result)
+        self.thread.finish.connect(self.handle_finish)
+        self.thread.start()
+
+    def handle_progress(self, progress) -> None:
+        value = progress[0]
+        text = progress[1]
+        if value is not None:
+            self.progressBarSet(value)
+        if text is None:
+            self.textBrowser.setText("")
+        else:
+            self.textBrowser.insertPlainText(text)
+
+    def handle_result(self, result):
+        new_name_column = StringVariable("answer")
+        table = self.data.add_column(new_name_column, [self.text_response])
+        self.Outputs.data.send(table)
+
+    def handle_finish(self):
+        print("Generation finished")
+        self.progressBarFinished()
+
+    def post_initialized(self):
+        pass
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    my_widget = ChatGpt()
+    my_widget.show()
+
+    if hasattr(app, "exec"):
+        sys.exit(app.exec())
+    else:
+        sys.exit(app.exec_())

{io4it-2.0.0 → io4it-2.1.0}/orangecontrib/IO4IT/widgets/OWDeep_Search.py

@@ -26,7 +26,8 @@ else:
 @apply_modification_from_python_file(filepath_original_widget=__file__)
 class OWDeep_Search(widget.OWWidget):
     name = "Deep Search"
-    description = "Generate a response to a column 'prompt' with a LuuLM"
+    description = "Generate a response to a column 'prompt' with a LLM"
+    category = "AAIT - LLM INTEGRATION"
     icon = "icons/deepsearch.svg"
     if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
         icon = "icons_dev/owqueryllm.svg"

io4it-2.1.0/orangecontrib/IO4IT/widgets/OWExportMarkdown.py

@@ -0,0 +1,216 @@
+import os
+import sys
+import tempfile
+import traceback
+
+import Orange
+from Orange.data import StringVariable
+from Orange.widgets import widget
+from Orange.widgets.widget import Input, Output
+from AnyQt.QtWidgets import QMessageBox, QApplication
+
+from docx import Document
+from docx.shared import Pt as pt_docx
+from pptx import Presentation
+from pptx.util import Inches, Pt
+import pypandoc
+from docx2pdf import convert
+
+# Chargement UI
+if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
+    from Orange.widgets.orangecontrib.AAIT.utils.import_uic import uic
+else:
+    from orangecontrib.AAIT.utils.import_uic import uic
+
+
+class OWExportMarkdown(widget.OWWidget):
+    name = "OWExportMarkdown"
+    description = "Auto-exporte content→(docx,pptx,pdf) au même path (base + extensions)."
+    icon = "icons/export_md.png"
+    if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
+        icon = "icons_dev/export_md.png"
+    want_control_area = True
+    priority = 9999
+    category = "AAIT - TOOLBOX"
+
+    class Inputs:
+        data = Input("Data", Orange.data.Table)
+
+    class Outputs:
+        data = Output("Data", Orange.data.Table)
+
+    def __init__(self):
+        super().__init__()
+        self.data = None
+        ui_path = os.path.join(os.path.dirname(__file__), "designer", "owexportmarkdown.ui")
+        uic.loadUi(ui_path, baseinstance=self)
+
+    # -------- helpers headers/footers --------
+    def ajouter_en_tete_pied_docx(self, file_path, header_text, footer_text):
+        try:
+            doc = Document(file_path)
+            section = doc.sections[0]
+            header = section.header
+            p = header.paragraphs[0] if header.paragraphs else header.add_paragraph()
+            p.text = header_text
+            if p.runs:
+                p.runs[0].font.size = pt_docx(10)
+            footer = section.footer
+            p = footer.paragraphs[0] if footer.paragraphs else footer.add_paragraph()
+            p.text = footer_text
+            if p.runs:
+                p.runs[0].font.size = pt_docx(10)
+            doc.save(file_path)
+        except Exception:
+            # en-tête/pied non bloquants
+            pass
+
+    def ajouter_entete_pied_pptx(self, file_path, entete_text, pied_text):
+        try:
+            prs = Presentation(file_path)
+            for slide in prs.slides:
+                entete = slide.shapes.add_textbox(Inches(0.3), Inches(0.2), Inches(8), Inches(0.5))
+                tf_entete = entete.text_frame
+                tf_entete.text = entete_text
+                tf_entete.paragraphs[0].font.size = Pt(12)
+                tf_entete.paragraphs[0].font.bold = True
+
+                pied = slide.shapes.add_textbox(Inches(0.3), Inches(6.3), Inches(8), Inches(0.5))
+                tf_pied = pied.text_frame
+                tf_pied.text = pied_text
+                tf_pied.paragraphs[0].font.size = Pt(10)
+            prs.save(file_path)
+        except Exception:
+            pass
+
+    # -------------- input --------------
+    @Inputs.data
+    def set_data(self, in_data):
+        self.error("")
+        if in_data is None:
+            self.data = None
+            self.Outputs.data.send(None)
+            return
+
+        # On exige au moins 'path'
+        if "path" not in in_data.domain:
+            self.error("La table d'entrée doit contenir au moins la colonne 'path'.")
+            self.Outputs.data.send(None)
+            return
+
+        # Optionnellement 'content'
+        self.data = in_data
+        try:
+            table_out = self.export_all_rows()
+            self.Outputs.data.send(table_out)
+        except Exception as e:
+            tb = traceback.format_exc()
+            QMessageBox.critical(self, "Erreur d'export", f"{e}\n\n{tb}")
+            self.Outputs.data.send(None)
+
+    # -------------- core --------------
+    def export_all_rows(self):
+        base_paths = self.data.get_column("path")
+        has_content = "content" in self.data.domain
+        file_contents = self.data.get_column("content") if has_content else [None] * len(base_paths)
+
+        pdf_paths, docx_paths, pptx_paths = [], [], []
+
+        for i, (md_text, base_path) in enumerate(zip(file_contents, base_paths)):
+            base_path = str(base_path or "").strip()
+
+            # Lecture du contenu si 'content' absent et path en .md
+            if not has_content:
+                if base_path.lower().endswith(".md"):
+                    try:
+                        with open(base_path, "r", encoding="utf-8") as f:
+                            md_text = f.read()
+                        # on remplace base_path par le même (on garde la base pour sorties)
+                    except Exception as e:
+                        self.error(f"Impossible de lire le fichier : {base_path} ({e})")
+                        pdf_paths.append("")
+                        docx_paths.append("")
+                        pptx_paths.append("")
+                        continue
+                else:
+                    # pas de content et path non .md -> rien à faire pour cette ligne
+                    pdf_paths.append("")
+                    docx_paths.append("")
+                    pptx_paths.append("")
+                    continue
+
+            md_text = (str(md_text or "")).strip()
+
+            if not md_text or not base_path:
+                pdf_paths.append("")
+                docx_paths.append("")
+                pptx_paths.append("")
+                continue
+
+            # Normaliser la base: enlever extension si présente
+            base_no_ext, _ = os.path.splitext(base_path)
+            # Créer dossier si nécessaire
+            out_dir = os.path.dirname(base_no_ext)
+            if out_dir and not os.path.isdir(out_dir):
+                os.makedirs(out_dir, exist_ok=True)
+
+            docx_out = base_no_ext + ".docx"
+            pptx_out = base_no_ext + ".pptx"
+            pdf_out = base_no_ext + ".pdf"
+
+            # MD temporaire
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as tmp:
+                tmp.write(md_text)
+                tmp_md = tmp.name
+
+            try:
+                # DOCX
+                pypandoc.convert_file(tmp_md, to="docx", outputfile=docx_out)
+                self.ajouter_en_tete_pied_docx(
+                    docx_out,
+                    "Rapport - Orange AI",
+                    "Page générée automatiquement - Ne pas diffuser"
+                )
+
+                # PPTX
+                pypandoc.convert_file(tmp_md, to="pptx", outputfile=pptx_out)
+                self.ajouter_entete_pied_pptx(
+                    pptx_out,
+                    "Orange AI – Présentation",
+                    "Page générée automatiquement"
+                )
+
+                # PDF (docx -> pdf) avec chemin de sortie exact
+                try:
+                    convert(docx_out, pdf_out)
+                except Exception:
+                    # fallback pandoc->pdf (si LaTeX dispo)
+                    try:
+                        pypandoc.convert_file(tmp_md, to="pdf", outputfile=pdf_out)
+                    except Exception:
+                        self.error(f"Échec conversion PDF pour la ligne {i+1}.")
+                        pdf_out = ""
+            finally:
+                try:
+                    os.remove(tmp_md)
+                except Exception:
+                    pass
+
+            pdf_paths.append(pdf_out if os.path.isfile(pdf_out) else "")
+            docx_paths.append(docx_out if os.path.isfile(docx_out) else "")
+            pptx_paths.append(pptx_out if os.path.isfile(pptx_out) else "")
+
+        # Ajouter colonnes sortie
+        table = self.data
+        table = table.add_column(StringVariable("output_pdf_path"), pdf_paths)
+        table = table.add_column(StringVariable("output_docx_path"), docx_paths)
+        table = table.add_column(StringVariable("output_pptx_path"), pptx_paths)
+
+        return table
+
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    w = OWExportMarkdown()
+    w.show()
+    sys.exit(app.exec() if hasattr(app, "exec") else app.exec_())