IO4IT 4.0.24__tar.gz → 4.0.26__tar.gz

{io4it-4.0.24 → io4it-4.0.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: io4it
-Version: 4.0.24
+Version: 4.0.26
 Home-page: 
 Author: 
 Author-email: 

{io4it-4.0.24 → io4it-4.0.26}/io4it.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: io4it
-Version: 4.0.24
+Version: 4.0.26
 Home-page: 
 Author: 
 Author-email: 

{io4it-4.0.24 → io4it-4.0.26}/orangecontrib/IO4IT/ocr_function/word_converter.py

@@ -16,6 +16,81 @@ def enable_long_path(path):
     """Simplifie la gestion des chemins longs sous Windows."""
     return pathlib.Path(r"\\?\\" + str(path))
 
+def get_word_application():
+    """
+    Retourne une instance Word DÉDIÉE au script, dans un processus séparé.
+
+    Point clé : on utilise DispatchEx et NON Dispatch.
+      - Dispatch("Word.Application")  -> se raccroche au Word déjà ouvert par
+        l'utilisateur (Running Object Table). Un Quit() fermerait alors TOUTE
+        l'application, donc le document de l'utilisateur.
+      - DispatchEx("Word.Application") -> force la création d'un NOUVEAU
+        processus WINWORD.EXE, isolé. Notre Quit() ne fermera que cette
+        instance ; le document ouvert par l'utilisateur n'est jamais touché.
+
+    L'instance est rendue invisible pour ne pas polluer l'écran de l'utilisateur.
+    """
+    word = win32com.client.DispatchEx("Word.Application")
+    try:
+        word.Visible = False       # mettre True uniquement pour débogage
+    except Exception:
+        pass
+    try:
+        word.DisplayAlerts = 0     # pas de pop-up (sur NOTRE instance uniquement)
+    except Exception:
+        pass
+    return word
+
+
+def safe_quit_word(word):
+    """
+    Ferme notre instance Word dédiée SANS jamais faire perdre de données.
+
+    Cas normal (DispatchEx a bien créé un processus séparé) : après nos
+    conversions, l'instance ne contient plus aucun document -> on quitte
+    proprement.
+
+    Cas anormal (DispatchEx est retombé sur le Word de l'utilisateur) :
+    il reste des documents ouverts que nous n'avons pas ouverts. On REFUSE
+    alors de forcer la fermeture :
+      - on tente de sauvegarder EN PLACE, sans dialogue bloquant, les
+        documents déjà associés à un fichier (doc.Save() est non destructif :
+        il réécrit le fichier existant, il ne crée pas de "Enregistrer sous") ;
+      - les documents jamais enregistrés (sans chemin) sont laissés tels
+        quels, en mémoire ;
+      - on NE quitte PAS : l'utilisateur reprend la main et sauvegarde
+        lui-même comme il l'entend.
+    """
+    if word is None:
+        return
+    try:
+        count = word.Documents.Count
+    except Exception:
+        count = 0
+
+    if count > 0:
+        # Instance non vide -> on ne force rien.
+        try:
+            for i in range(1, count + 1):
+                try:
+                    d = word.Documents.Item(i)
+                    # d.Saved == False  -> modifications non enregistrées
+                    # d.Path non vide   -> le document a déjà un fichier associé
+                    if (not d.Saved) and d.Path:
+                        d.Save()   # réécrit le fichier existant, aucune boîte de dialogue
+                except Exception:
+                    pass
+        except Exception:
+            pass
+        return  # surtout pas de Quit : on préserve le travail de l'utilisateur
+
+    # Instance vide : c'est bien la nôtre, on peut la fermer.
+    try:
+        word.Quit()
+    except Exception:
+        pass
+
+    
 def convert_pdf_structure(input_dir: str, output_dir: str,ignore_exsting_out_put=False,forceBasicConvertion=False,progress_callback=None):
     """
     return a string with log in  case of error
@@ -37,38 +112,52 @@ def convert_pdf_structure(input_dir: str, output_dir: str,ignore_exsting_out_put
         input_path = Path(str(input_dir[i]))
         for pdf_file in input_path.rglob("*.pdf"):
             nbre_file += 1
+    
+    pythoncom.CoInitialize()
+    word = None
+    try:
+        word = get_word_application()
+    except Exception as e:
+        pythoncom.CoUninitialize()
+        return f"Impossible de démarrer Microsoft Word : {e}"
 
     k = 1
-    for i, data in enumerate(input_dir):
-        input_path = Path(str(input_dir[i]))
-        output_path = Path(str(output_dir[i]))
+    try:
+        for i, data in enumerate(input_dir):
+            input_path = Path(str(input_dir[i]))
+            output_path = Path(str(output_dir[i]))
 
-        if not input_path.exists() or not input_path.is_dir():
-            print(f"Error: The input directory '{input_dir}' does not exist or is not a directory.")
-            return f"Error: The input directory '{input_dir}' does not exist or is not a directory. "
+            if not input_path.exists() or not input_path.is_dir():
+                print(f"Error: The input directory '{input_dir}' does not exist or is not a directory.")
+                return f"Error: The input directory '{input_dir}' does not exist or is not a directory. "
 
-        for pdf_file in input_path.rglob("*.pdf"):  # Recursively search for .pdf and .PDF files
-            print("traitement de ",str(pdf_file))
-            relative_path = pdf_file.relative_to(input_path)  # Get relative path from input root
-            new_file_path = output_path / relative_path.with_suffix(".docx")  # Change extension to .docx
+            for pdf_file in input_path.rglob("*.pdf"):  # Recursively search for .pdf and .PDF files
+                print("traitement de ",str(pdf_file))
+                relative_path = pdf_file.relative_to(input_path)  # Get relative path from input root
+                new_file_path = output_path / relative_path.with_suffix(".docx")  # Change extension to .docx
 
 
 
-            if ignore_exsting_out_put:
-                if os.path.exists(enable_long_path(str(new_file_path))):
-                    print("ignoring",enable_long_path(str(new_file_path)))
-                    continue
+                if ignore_exsting_out_put:
+                    if os.path.exists(enable_long_path(str(new_file_path))):
+                        print("ignoring",enable_long_path(str(new_file_path)))
+                        continue
 
 
-            if 0!= convert_pdf_with_temp(str(pdf_file),str(new_file_path),forceBasicConvertion):#convert_pdf_with_temp #convert_pdf_to_docx
-                if error_log!="":
-                    error_log+="\n"
-                error_log+="error -> "+str(pdf_file)
-                return error_log # a supprimer
-            if progress_callback is not None:
-                progress_value = float(100 * (k) / nbre_file)
-                k += 1
-                progress_callback(progress_value)
+                if 0!= convert_pdf_with_temp(str(pdf_file),str(new_file_path),forceBasicConvertion,word=word):#convert_pdf_with_temp #convert_pdf_to_docx
+                    if error_log!="":
+                        error_log+="\n"
+                    error_log+="error -> "+str(pdf_file)
+                    return error_log # a supprimer
+                if progress_callback is not None:
+                    progress_value = float(100 * (k) / nbre_file)
+                    k += 1
+                    progress_callback(progress_value)
+    finally:
+        # On ne ferme QUE notre instance dédiée (processus séparé), et jamais
+        # si elle contient encore des documents de l'utilisateur.
+        safe_quit_word(word)
+        pythoncom.CoUninitialize()
     # purge temp dir if everithing is ok
     if error_log=="":
         reset_folder(get_local_store_path() + "temp_word_conversion/", attempts=10, delay=0.05, recreate=False)
@@ -77,13 +166,22 @@ def convert_pdf_structure(input_dir: str, output_dir: str,ignore_exsting_out_put
 
 
 
-def convert_pdf_to_docx(pdf_path, docx_path):
+def convert_pdf_to_docx(pdf_path, docx_path, word=None):
     """
     Convertit un fichier PDF en DOCX en utilisant Microsoft Word.
 
     Args:
         pdf_path (str): Chemin du fichier PDF source.
         docx_path (str): Chemin du fichier DOCX de destination.
+        word: instance Word.Application à réutiliser. Si None, une instance
+              DÉDIÉE (processus séparé via DispatchEx) est créée puis fermée
+              à la fin de l'appel.
+
+    Cette fonction ne ferme JAMAIS un Word ouvert par l'utilisateur :
+      - si `word` est fourni, elle ne fait que fermer le document qu'elle a
+        ouvert (doc.Close), sans jamais appeler Quit ;
+      - si `word` est None, elle crée sa propre instance isolée et ne ferme
+        que celle-ci.
 
     Returns:
         int: 0 si la conversion a réussi, 1 en cas d'échec.
@@ -92,14 +190,14 @@ def convert_pdf_to_docx(pdf_path, docx_path):
         print(f"Erreur : Le fichier {pdf_path} n'existe pas.")
         return 1
 
+    own_instance = word is None
+    doc = None
     try:
-        # Initialiser COM
-        pythoncom.CoInitialize()
+        if own_instance:
+            # Initialiser COM et créer une instance dédiée isolée
+            pythoncom.CoInitialize()
+            word = get_word_application()
 
-        # Lancer Word
-        word = win32com.client.Dispatch("Word.Application")
-        word.DisplayAlerts = 0  # Désactiver les alertes
-        word.Visible = True  # Mettre à True pour voir Word en action
         print(f"Conversion de {pdf_path} en {docx_path}...")
 
         # Ouvrir le PDF en lecture seule
@@ -108,20 +206,26 @@ def convert_pdf_to_docx(pdf_path, docx_path):
         # Sauvegarder en DOCX
         doc.SaveAs(docx_path, FileFormat=16)  # 16 = wdFormatDocumentDefault
         doc.Close(False)
+        doc = None
 
         print(f"Conversion réussie : {docx_path}")
         return 0
 
     except Exception as e:
         print(f"Erreur lors de la conversion : {e}")
+        # Toujours refermer le document qu'on a ouvert, jamais l'application
+        if doc is not None:
+            try:
+                doc.Close(False)
+            except Exception:
+                pass
         return 1
 
     finally:
-        if 'word' in locals():
-            word.Quit()
-
-        # Libérer COM
-        pythoncom.CoUninitialize()
+        # On ne quitte Word QUE si c'est nous qui avons créé l'instance.
+        if own_instance and word is not None:
+            safe_quit_word(word)
+            pythoncom.CoUninitialize()
 
 
 def wait_for_file_access(file_path, timeout=10, interval=0.5):
@@ -259,11 +363,16 @@ def write_two_strings_to_file(file_path: str,string1: str, string2: str):
     return 0
 
 
-def convert_pdf_with_temp(temp_pdf, output_path,forceBasicConvertion=False):
+def convert_pdf_with_temp(temp_pdf, output_path,forceBasicConvertion=False, word=None):
     """
     Copie le PDF source dans un dossier temporaire, le convertit en DOCX,
     puis copie le fichier résultant vers le chemin de sortie spécifié,
     en gérant les chemins longs.
+
+    word : instance Word.Application à réutiliser pour toutes les tentatives.
+           Si None, une instance DÉDIÉE (processus séparé) est créée puis
+           fermée à la fin de l'appel. Dans tous les cas, un Word ouvert par
+           l'utilisateur n'est jamais fermé.
     """
     pdf_path = enable_long_path(os.path.abspath(temp_pdf))
     output_path = enable_long_path(os.path.abspath(output_path))
@@ -277,7 +386,11 @@ def convert_pdf_with_temp(temp_pdf, output_path,forceBasicConvertion=False):
     if not output_dir.exists():
         output_dir.mkdir(parents=True, exist_ok=True)
 
+    own_instance = word is None
     try:
+        if own_instance:
+            pythoncom.CoInitialize()
+            word = get_word_application()
         dest_dir = get_local_store_path() + "temp_word_conversion/"
         if 0 != reset_folder(dest_dir, attempts=10, delay=0.05):
             print("impossible to reset " + dest_dir)
@@ -304,10 +417,10 @@ def convert_pdf_with_temp(temp_pdf, output_path,forceBasicConvertion=False):
                 wait_for_file_access(temp_pdf)
                 time.sleep(1)
         result=0
-        # Conversion du PDF en DOCX
+        # Conversion du PDF en DOCX (on réutilise la même instance Word dédiée)
         for _ in range(4):
             time.sleep(1)
-            result = convert_pdf_to_docx(str(temp_pdf), str(temp_docx))
+            result = convert_pdf_to_docx(str(temp_pdf), str(temp_docx), word=word)
             if result==0:
                 break
         if result == 0:
@@ -329,5 +442,8 @@ def convert_pdf_with_temp(temp_pdf, output_path,forceBasicConvertion=False):
         print(f"Erreur : {e}")
         return 1
 
-
-
+    finally:
+        # On ne quitte Word QUE si c'est nous qui avons créé l'instance ici.
+        if own_instance and word is not None:
+            safe_quit_word(word)
+            pythoncom.CoUninitialize()

{io4it-4.0.24 → io4it-4.0.26}/orangecontrib/IO4IT/toolViews/linkHTLMWorkflow_manager_ui.py

@@ -7,11 +7,11 @@ import ast
 if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
     from Orange.widgets.orangecontrib.AAIT.utils import MetManagement
     from Orange.widgets.orangecontrib.AAIT.utils.import_uic import uic
-    from Orange.widgets.orangecontrib.HLIT_dev.remote_server_smb import convert, hlit_workflow_management
+    from Orange.widgets.orangecontrib.HLIT.remote_server_smb import convert, hlit_workflow_management
 else:
     from orangecontrib.AAIT.utils import MetManagement
     from orangecontrib.AAIT.utils.import_uic import uic
-    from orangecontrib.HLIT_dev.remote_server_smb import convert, hlit_workflow_management
+    from orangecontrib.HLIT.remote_server_smb import convert, hlit_workflow_management
 
 FUNCTION_NAMES = [
     "Create",

{io4it-4.0.24 → io4it-4.0.26}/orangecontrib/IO4IT/utils/custom_api.py

@@ -1,11 +1,18 @@
-import base64
-import mimetypes
 import os
+import re
+import json
+import copy
+import numpy as np
 
 import requests
 
-import Orange.data
-from Orange.data import StringVariable
+from Orange.data import StringVariable, Table
+
+
+if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
+    from Orange.widgets.orangecontrib.AAIT.llm.answers_llama import write_tokens_to_file, prompt_to_messages, conv_to_messages
+else:
+    from orangecontrib.AAIT.llm.answers_llama import write_tokens_to_file, prompt_to_messages, conv_to_messages
 
 
 def build_headers(header_name, auth_scheme, api_key):
@@ -15,37 +22,25 @@ def build_headers(header_name, auth_scheme, api_key):
     return {"Content-Type": "application/json", header_name: value}
 
 
-def image_to_data_uri(file_path):
-    """Encode a local image file as a base64 data URI."""
-    mime_type, _ = mimetypes.guess_type(file_path)
-    mime_type = mime_type or "application/octet-stream"
-    with open(file_path, "rb") as f:
-        encoded = base64.b64encode(f.read()).decode("utf-8")
-    return f"data:{mime_type};base64,{encoded}"
-
-
-def build_user_content(prompt, image_paths):
-    """Build the 'content' field of a user message, attaching images when provided."""
-    if not image_paths:
-        return str(prompt)
-
-    content = []
-    for image_path in image_paths:
-        image_path = image_path.strip().strip("'").strip('"')
-        if not image_path:
-            continue
-        if not os.path.exists(image_path):
-            content.append({"type": "text", "text": f"[ERROR] Image not found: {image_path}"})
-            continue
-        try:
-            content.append({"type": "image_url", "image_url": {"url": image_to_data_uri(image_path)}})
-        except Exception as e:
-            content.append({"type": "text", "text": f"[ERROR] Unable to read image {image_path}: {e}"})
-    content.append({"type": "text", "text": str(prompt)})
-    return content
+def search_for_streamed_token(decoded_line):
+    r"""
+    /!\ This function is meant to be updated whenever a new response format is identified /!\
 
-
-def call_chat_completion(prompt, system_prompt, config, image_paths=None):
+    Parse a decoded stream response "line" to find the token generated by a LLM.
+    """
+    known_keys = ["content", "reasoning"]
+    dict_regex = r"\{[\s\S]*\}"
+    match = re.search(dict_regex, decoded_line)
+    if not match:
+        return "Token not found"
+    
+    json_data = json.loads(match.group())
+    delta = json_data["choices"][0]["delta"]
+    token = next((delta[key] for key in known_keys if key in delta), "Token not found")
+    return token
+
+
+def call_chat_completion(messages, config, stream=False, workflow_id="Request_RAG"):
     """
     Call a /chat/completions endpoint using the widely adopted chat-completions
     message format. Vision-capable models can be reached by passing image_paths,
@@ -58,11 +53,6 @@ def call_chat_completion(prompt, system_prompt, config, image_paths=None):
     url = config["base_url"].rstrip("/") + config["route"]
     headers = build_headers(config["header_name"], config["auth_scheme"], config["api_key"])
 
-    messages = []
-    if system_prompt:
-        messages.append({"role": "system", "content": str(system_prompt)})
-    messages.append({"role": "user", "content": build_user_content(prompt, image_paths)})
-
     payload = {
         "model": config["model"],
         "messages": messages,
@@ -86,10 +76,25 @@ def call_chat_completion(prompt, system_prompt, config, image_paths=None):
         proxy_url = config.get("proxy_url") or ""
         kwargs["proxies"] = {"http": proxy_url, "https": proxy_url}
 
-    response = requests.post(url, headers=headers, json=payload, **kwargs)
+    response = requests.post(url, headers=headers, json=payload, stream=stream, **kwargs)
     response.raise_for_status()
-    data = response.json()
-    return data["choices"][0]["message"]["content"]
+
+    if not stream:
+        data = response.json()
+        return data["choices"][0]["message"]["content"]
+    else:
+        answer = ""
+        for line in response.iter_lines():
+            if line:
+                decoded_line = line.decode("utf-8")
+                try:
+                    token = search_for_streamed_token(decoded_line)
+                except Exception as e:
+                    token = "Error"
+                    print("An error occured when trying to get token from stream response:", e)
+                answer += token
+                write_tokens_to_file(token, workflow_id=workflow_id)
+        return answer
 
 
 def generate_answers(data, config, progress_callback=None):
@@ -116,8 +121,9 @@ def generate_answers(data, config, progress_callback=None):
         prompt = prompts[i]
         system_prompt = system_prompts[i] if system_prompts is not None else None
         image_paths = image_paths_column[i].split(";") if image_paths_column is not None else None
+        messages = prompt_to_messages(prompt, system_prompt, image_paths)
         try:
-            answer = call_chat_completion(prompt, system_prompt, config, image_paths)
+            answer = call_chat_completion(messages, config, stream=True)
         except requests.HTTPError as e:
             body = e.response.text if e.response is not None else str(e)
             answer = f"[ERROR] HTTP {e.response.status_code if e.response is not None else '?'}: {body}"
@@ -130,3 +136,38 @@ def generate_answers(data, config, progress_callback=None):
 
     answer_var = StringVariable("Answer")
     return data.add_column(answer_var, answers)
+
+
+
+def continue_conversation(table, config, progress_callback=None):
+    """
+    Runs call_chat_completion considering the table as a conversation (list of messages).
+    """
+    data = copy.deepcopy(table)
+    messages = conv_to_messages(data)
+    if not messages:
+        return data
+
+    try:
+        answer = call_chat_completion(messages, config, stream=True)
+    except requests.HTTPError as e:
+        body = e.response.text if e.response is not None else str(e)
+        answer = f"[ERROR] HTTP {e.response.status_code if e.response is not None else '?'}: {body}"
+    except Exception as e:
+        answer = f"[ERROR] {e}"
+
+    # Create output table
+    meta = data.metas[-1].copy()
+    meta_names = [m.name for m in data.domain.metas]
+    meta[meta_names.index("role")] = "assistant"
+    meta[meta_names.index("type")] = "text"
+    meta[meta_names.index("content")] = answer
+    empty_x = np.zeros((1, len(data.domain.attributes)))
+
+    new_row = Table.from_numpy(
+        data.domain,
+        X=empty_x,
+        metas=np.array([meta], dtype=object)
+    )
+    out_data = Table.concatenate([data, new_row])
+    return out_data

{io4it-4.0.24 → io4it-4.0.26}/orangecontrib/IO4IT/widgets/OWCustomLLMApi.py

@@ -13,11 +13,13 @@ from AnyQt.QtWidgets import (
 if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
     from Orange.widgets.orangecontrib.IO4IT.utils import custom_api
     from Orange.widgets.orangecontrib.AAIT.utils import thread_management
+    from Orange.widgets.orangecontrib.AAIT.llm.answers_llama import identify_table_type
     from Orange.widgets.orangecontrib.AAIT.utils.import_uic import uic
     from Orange.widgets.orangecontrib.AAIT.utils.initialize_from_ini import apply_modification_from_python_file
 else:
     from orangecontrib.IO4IT.utils import custom_api
     from orangecontrib.AAIT.utils import thread_management
+    from orangecontrib.AAIT.llm.answers_llama import identify_table_type
     from orangecontrib.AAIT.utils.import_uic import uic
     from orangecontrib.AAIT.utils.initialize_from_ini import apply_modification_from_python_file
 
@@ -192,8 +194,14 @@ class OWCustomLLMApi(widget.OWWidget):
         if self.data is None:
             self.Outputs.data.send(None)
             return
-        if "prompt" not in self.data.domain:
-            self.error("Input table needs a 'prompt' column.")
+
+        table_type = identify_table_type(self.data)
+        if table_type == "error":
+            self.error("The table must contain either (StringVariable):\n- role + type + content\nor:\n- prompt (image paths)")
+            self.Outputs.data.send(None)
+            return
+        elif table_type == "multiple":
+            self.error("Cannot have role/type/content and prompt simultaneously.")
             self.Outputs.data.send(None)
             return
 
@@ -213,7 +221,11 @@ class OWCustomLLMApi(widget.OWWidget):
         self.progressBarInit()
         self.textBrowser.setText("")
 
-        self.thread = thread_management.Thread(custom_api.generate_answers, self.data, self.build_config())
+
+        if table_type == "batch":
+            self.thread = thread_management.Thread(custom_api.generate_answers, self.data, self.build_config())
+        elif table_type == "conversation":
+            self.thread = thread_management.Thread(custom_api.continue_conversation, self.data, self.build_config())
         self.thread.progress.connect(self.handle_progress)
         self.thread.result.connect(self.handle_result)
         self.thread.finish.connect(self.handle_finish)

{io4it-4.0.24 → io4it-4.0.26}/orangecontrib/IO4IT/widgets/OWExportMarkdown.py

@@ -265,8 +265,8 @@ class OWExportMarkdown(widget.OWWidget):
                     )
                     self.ajouter_entete_pied_pptx(
                         pptx_out,
-                        "Orange AI – Présentation",
-                        "Page générée automatiquement"
+                        "TigerODM – Présentation",
+                        "Page générée automatiquement par IA"
                     )
                     produced_pptx = pptx_out if os.path.isfile(pptx_out) else ""
 

{io4it-4.0.24 → io4it-4.0.26}/orangecontrib/IO4IT/widgets/OWJsonToDataTable.py

@@ -8,10 +8,10 @@ from Orange.widgets.settings import Setting
 from AnyQt.QtWidgets import  QCheckBox
 from Orange.data import Table, Domain, StringVariable
 if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
-    from Orange.widgets.orangecontrib.HLIT_dev.remote_server_smb import convert
+    from Orange.widgets.orangecontrib.HLIT.remote_server_smb import convert
     from Orange.widgets.orangecontrib.AAIT.utils import base_widget
 else:
-    from orangecontrib.HLIT_dev.remote_server_smb import convert
+    from orangecontrib.HLIT.remote_server_smb import convert
     from orangecontrib.AAIT.utils import base_widget
 
 class OWJsonToDataTable(base_widget.BaseListWidget):