IO4IT 4.0.26__tar.gz → 4.0.28__tar.gz

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

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

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

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

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

@@ -22,22 +22,97 @@ def build_headers(header_name, auth_scheme, api_key):
     return {"Content-Type": "application/json", header_name: value}
 
 
+def list_models(config):
+    """
+    GET Base URL + /models and return the list of model ids exposed by an
+    OpenAI-compatible endpoint (llama-server, vLLM, OpenAI, ...).
+
+    Expects Base URL to already include the API version prefix if the
+    server uses one, e.g. "http://127.0.0.1:8080/v1".
+
+    config keys: base_url, header_name, auth_scheme, api_key, cert_path,
+                 cert_is_ca, use_proxy, proxy_url
+    """
+    url = config["base_url"].rstrip("/") + "/models"
+    api_key = config.get("api_key")
+    if api_key:
+        headers = build_headers(config["header_name"], config["auth_scheme"], api_key)
+    else:
+        headers = {"Content-Type": "application/json"}
+
+    kwargs = {"timeout": 30}
+    cert_path = config.get("cert_path")
+    if cert_path:
+        if config.get("cert_is_ca"):
+            kwargs["verify"] = cert_path
+        else:
+            kwargs["cert"] = cert_path
+
+    if config.get("use_proxy"):
+        proxy_url = config.get("proxy_url") or ""
+        kwargs["proxies"] = {"http": proxy_url, "https": proxy_url}
+
+    response = requests.get(url, headers=headers, **kwargs)
+    response.raise_for_status()
+    data = response.json()
+    return [m.get("id", "?") for m in data.get("data", [])]
+
+
 def search_for_streamed_token(decoded_line):
     r"""
     /!\ This function is meant to be updated whenever a new response format is identified /!\
 
-    Parse a decoded stream response "line" to find the token generated by a LLM.
+    Parse a decoded stream response "line" and return (kind, token), where
+    kind is "content" for actual answer text, "reasoning" for a model's
+    internal thinking trace (some reasoning models, e.g. Qwen3 through
+    llama-server, stream it in a separate delta field: "reasoning" or
+    "reasoning_content" depending on server version), or None if the line
+    carries no usable token.
     """
-    known_keys = ["content", "reasoning"]
+    reasoning_keys = ("reasoning", "reasoning_content")
     dict_regex = r"\{[\s\S]*\}"
     match = re.search(dict_regex, decoded_line)
     if not match:
-        return "Token not found"
-    
+        return None, ""
+
     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
+    # "choices" can be an empty list on the last chunk of a stream, e.g.
+    # llama-server sends {"choices": [], "usage": {...}, ...} right before
+    # [DONE] once "usage" reporting is involved.
+    choices = json_data.get("choices") or []
+    if not choices:
+        return None, ""
+    delta = choices[0].get("delta", {})
+    # .get(key) (not "key in delta") also skips a key whose value is
+    # JSON null, e.g. {"delta": {"role": "assistant", "content": null}},
+    # which some OpenAI-compatible servers (llama-server included) send.
+    if delta.get("content"):
+        return "content", delta["content"]
+    for key in reasoning_keys:
+        if delta.get(key):
+            return "reasoning", delta[key]
+    # Diagnostic: if the delta carries something we don't recognize (e.g. a
+    # model's thinking trace under a key that isn't "reasoning" or
+    # "reasoning_content" on this particular server), log it so the actual
+    # key name shows up in the console instead of silently dropping it.
+    ignored_keys = {"role", "tool_calls", "function_call", "refusal"}
+    unknown = {k: v for k, v in delta.items() if k not in ignored_keys and v}
+    if unknown:
+        print("search_for_streamed_token: unrecognized delta keys, please report ->", unknown)
+    return None, ""
+
+
+_THINK_BLOCK_RE = re.compile(r"<think>[\s\S]*?</think>", re.IGNORECASE)
+
+
+def strip_thinking(text):
+    """
+    Some reasoning models (e.g. Qwen3 served through llama-server) emit
+    their internal <think>...</think> trace as regular streamed content,
+    since it isn't split into a separate delta field. Strip it out so it
+    doesn't end up in the final answer.
+    """
+    return _THINK_BLOCK_RE.sub("", text).strip()
 
 
 def call_chat_completion(messages, config, stream=False, workflow_id="Request_RAG"):
@@ -58,6 +133,7 @@ def call_chat_completion(messages, config, stream=False, workflow_id="Request_RA
         "messages": messages,
         "temperature": config["temperature"],
         "max_tokens": config["max_tokens"],
+        "stream": stream,
     }
 
     kwargs = {"timeout": 600}
@@ -81,20 +157,23 @@ def call_chat_completion(messages, config, stream=False, workflow_id="Request_RA
 
     if not stream:
         data = response.json()
-        return data["choices"][0]["message"]["content"]
+        return strip_thinking(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)
+                    kind, token = search_for_streamed_token(decoded_line)
                 except Exception as e:
-                    token = "Error"
+                    kind, token = None, ""
                     print("An error occured when trying to get token from stream response:", e)
-                answer += token
+                # Only actual answer content goes into the final answer;
+                # a model's reasoning/thinking trace is deliberately dropped.
+                if kind == "content":
+                    answer += token
                 write_tokens_to_file(token, workflow_id=workflow_id)
-        return answer
+        return strip_thinking(answer)
 
 
 def generate_answers(data, config, progress_callback=None):
@@ -123,7 +202,7 @@ def generate_answers(data, config, progress_callback=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(messages, config, stream=True)
+            answer = call_chat_completion(messages, config, stream=True, workflow_id=config.get("workflow_id") or "")
         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}"
@@ -149,7 +228,7 @@ def continue_conversation(table, config, progress_callback=None):
         return data
 
     try:
-        answer = call_chat_completion(messages, config, stream=True)
+        answer = call_chat_completion(messages, config, stream=True, workflow_id=config.get("workflow_id") or "")
     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}"

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

@@ -12,13 +12,15 @@ 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.IO4IT.utils import keys_manager
+    from Orange.widgets.orangecontrib.AAIT.utils import thread_management, MetManagement
     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.IO4IT.utils import keys_manager
+    from orangecontrib.AAIT.utils import thread_management, MetManagement
     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
@@ -47,10 +49,11 @@ class OWCustomLLMApi(widget.OWWidget):
         data = Output("Data", Orange.data.Table)
 
     base_url = Setting("")
-    route = Setting("/v1/chat/completions")
+    route = Setting("/chat/completions")
     header_name = Setting("Authorization")
     auth_scheme = Setting("Bearer")
     api_key = Setting("")
+    key_service = Setting("")
     cert_path = Setting("")
     cert_is_ca = Setting(False)
     use_proxy = Setting(False)
@@ -58,6 +61,7 @@ class OWCustomLLMApi(widget.OWWidget):
     model = Setting("")
     max_tokens = Setting(4096)
     temperature = Setting(0.4)
+    workflow_id = Setting("")
 
     @Inputs.data
     def set_data(self, in_data):
@@ -79,7 +83,7 @@ class OWCustomLLMApi(widget.OWWidget):
     def __init__(self):
         super().__init__()
         self.setFixedWidth(700)
-        self.setFixedHeight(695)
+        self.setFixedHeight(809)
         uic.loadUi(self.gui, self)
 
         self.label_description = self.findChild(QLabel, 'Description')
@@ -104,6 +108,10 @@ class OWCustomLLMApi(widget.OWWidget):
         self.line_api_key.setText(self.api_key)
         self.line_api_key.editingFinished.connect(self.update_parameters)
 
+        self.line_key_service = self.findChild(QLineEdit, 'lineKeyService')
+        self.line_key_service.setText(self.key_service)
+        self.line_key_service.editingFinished.connect(self.update_parameters)
+
         self.line_cert_path = self.findChild(QLineEdit, 'lineCertPath')
         self.line_cert_path.setText(self.cert_path)
         self.line_cert_path.editingFinished.connect(self.update_parameters)
@@ -135,24 +143,33 @@ class OWCustomLLMApi(widget.OWWidget):
         self.box_temperature.setValue(self.temperature)
         self.box_temperature.editingFinished.connect(self.update_parameters)
 
+        self.line_workflow_id = self.findChild(QLineEdit, 'lineWorkflowId')
+        self.line_workflow_id.setText(self.workflow_id)
+        self.line_workflow_id.editingFinished.connect(self.update_parameters)
+
         self.push_button_run = self.findChild(QPushButton, 'pushButtonRun')
         self.push_button_run.clicked.connect(self.run)
 
+        self.button_list_models = self.findChild(QPushButton, 'buttonListModels')
+        self.button_list_models.clicked.connect(self.list_models)
+
         self.textBrowser = self.findChild(QTextBrowser, 'textBrowser')
 
         self.data = None
         self.thread = None
         self.can_run = True
         self.result = None
+        self._resolved_api_key = None
 
         self.post_initialized()
 
     def update_parameters(self):
         self.base_url = self.line_base_url.text().strip()
-        self.route = self.line_route.text().strip() or "/v1/chat/completions"
+        self.route = self.line_route.text().strip() or "/chat/completions"
         self.header_name = self.line_header_name.text().strip() or "Authorization"
         self.auth_scheme = self.line_auth_scheme.text().strip()
         self.api_key = self.line_api_key.text()
+        self.key_service = self.line_key_service.text().strip()
         self.cert_path = self.line_cert_path.text().strip()
         self.cert_is_ca = self.check_cert_is_ca.isChecked()
         self.use_proxy = self.check_use_proxy.isChecked()
@@ -160,6 +177,7 @@ class OWCustomLLMApi(widget.OWWidget):
         self.model = self.line_model.text().strip()
         self.max_tokens = self.box_max_tokens.value()
         self.temperature = self.box_temperature.value()
+        self.workflow_id = self.line_workflow_id.text().strip()
 
     def browse_cert(self):
         path, _ = QFileDialog.getOpenFileName(self, "Select a .pem file", "", "PEM files (*.pem);;All files (*)")
@@ -167,13 +185,53 @@ class OWCustomLLMApi(widget.OWWidget):
             self.line_cert_path.setText(path)
             self.update_parameters()
 
-    def build_config(self):
+    def resolve_api_key(self):
+        """
+        Resolve the API key to actually use. A "Key manager service" name
+        takes priority: the real key is fetched from the secure key store
+        (Key Manager tool) and never persisted in the workflow file. Falls
+        back to the plain-text "API key" field (stored in the .ows file)
+        for legacy workflows that don't use the key store.
+        """
+        if self.key_service:
+            cfg = keys_manager.lire_config_api(self.key_service)
+            if not cfg or not cfg.get("api_key"):
+                self.error(
+                    f"No API key found for service '{self.key_service}' in the Key Manager. "
+                    f"Register it there (Create / overwrite api key), or clear this field to "
+                    f"use the 'API key' field instead."
+                )
+                return None
+            return cfg["api_key"]
+        if not self.api_key:
+            self.error("API key is required (either via 'Key manager service' or the 'API key' field).")
+            return None
+        return self.api_key
+
+    def get_optional_api_key(self):
+        """
+        Best-effort API key resolution for diagnostic calls (e.g. List models):
+        unlike resolve_api_key(), does not fail when no key is configured at
+        all, since some local servers (llama-server without --api-key) don't
+        require one. Returns (api_key_or_None, error_message_or_None).
+        """
+        if self.key_service:
+            cfg = keys_manager.lire_config_api(self.key_service)
+            if not cfg or not cfg.get("api_key"):
+                return None, (
+                    f"No API key found for service '{self.key_service}' in the Key Manager. "
+                    f"Register it there, or clear this field."
+                )
+            return cfg["api_key"], None
+        return (self.api_key or None), None
+
+    def build_config(self, api_key=None):
         return {
             "base_url": self.base_url,
             "route": self.route,
             "header_name": self.header_name,
             "auth_scheme": self.auth_scheme,
-            "api_key": self.api_key,
+            "api_key": api_key if api_key is not None else self._resolved_api_key,
             "cert_path": self.cert_path,
             "cert_is_ca": self.cert_is_ca,
             "use_proxy": self.use_proxy,
@@ -181,8 +239,30 @@ class OWCustomLLMApi(widget.OWWidget):
             "model": self.model,
             "max_tokens": self.max_tokens,
             "temperature": self.temperature,
+            "workflow_id": self.workflow_id,
         }
 
+    def list_models(self):
+        self.error("")
+        self.warning("")
+
+        if not self.base_url:
+            self.error("Base URL is required.")
+            return
+
+        api_key, err = self.get_optional_api_key()
+        if err:
+            self.error(err)
+            return
+
+        try:
+            models = custom_api.list_models(self.build_config(api_key=api_key))
+        except Exception as e:
+            self.error(f"Unable to list models: {e}")
+            return
+
+        self.textBrowser.setText("\n".join(models) if models else "No model returned by the server.")
+
     def run(self):
         self.error("")
         self.warning("")
@@ -210,8 +290,8 @@ class OWCustomLLMApi(widget.OWWidget):
             self.Outputs.data.send(None)
             return
 
-        if not self.api_key:
-            self.error("API key is required.")
+        self._resolved_api_key = self.resolve_api_key()
+        if self._resolved_api_key is None:
             self.Outputs.data.send(None)
             return
 
@@ -221,6 +301,10 @@ class OWCustomLLMApi(widget.OWWidget):
         self.progressBarInit()
         self.textBrowser.setText("")
 
+        if self.workflow_id:
+            chemin_dossier = MetManagement.get_api_local_folder(workflow_id=self.workflow_id)
+            if os.path.exists(chemin_dossier):
+                MetManagement.write_file_time(chemin_dossier + "time.txt")
 
         if table_type == "batch":
             self.thread = thread_management.Thread(custom_api.generate_answers, self.data, self.build_config())

{io4it-4.0.26 → io4it-4.0.28}/orangecontrib/IO4IT/widgets/OWDoclingToMarkdown.py

@@ -1,4 +1,4 @@
-import os, time, sys
+import os, time, sys, re
 from pathlib import Path
 from concurrent.futures import as_completed
 
@@ -14,6 +14,7 @@ from openpyxl import Workbook
 # --- Docling (unique lib utilisée pour la conversion) ---
 from docling.backend.pypdfium2_backend import PyPdfiumDocumentBackend
 from docling.datamodel.base_models import InputFormat
+from docling.datamodel.pipeline_options import PdfPipelineOptions, RapidOcrOptions
 from docling.document_converter import (
     DocumentConverter,
     PdfFormatOption,
@@ -31,6 +32,45 @@ else:
     from orangecontrib.AAIT.utils.import_uic import uic
 
 
+# --------- helpers Docling ----------
+def _build_converter(force_ocr: bool = False):
+    """Construit le DocumentConverter.
+    force_ocr=False : configuration d'origine (options PDF par défaut).
+    force_ocr=True  : OCR RapidOCR forcé sur toute la page (PDF image).
+    """
+    pdf_format = PdfFormatOption(
+        pipeline_cls=StandardPdfPipeline,
+        backend=PyPdfiumDocumentBackend
+    )
+    if force_ocr:
+        pdf_options = PdfPipelineOptions()
+        pdf_options.do_ocr = True
+        pdf_options.ocr_options = RapidOcrOptions(force_full_page_ocr=True)
+        pdf_format = PdfFormatOption(
+            pipeline_cls=StandardPdfPipeline,
+            backend=PyPdfiumDocumentBackend,
+            pipeline_options=pdf_options,
+        )
+
+    # Docling minimal config (inspiré du snippet)
+    return DocumentConverter(
+        allowed_formats=[InputFormat.PDF, InputFormat.DOCX, InputFormat.PPTX],
+        format_options={
+            InputFormat.PDF: pdf_format,
+            InputFormat.DOCX: WordFormatOption(
+                pipeline_cls=SimplePipeline
+            ),
+            # PPTX: pas d'option spécifique; géré par défaut
+        },
+    )
+
+
+def _has_text(md: str, min_chars: int = 20) -> bool:
+    """True si le Markdown contient du vrai texte (hors commentaires <!-- image -->)."""
+    cleaned = re.sub(r"<!--.*?-->", "", md, flags=re.DOTALL)
+    return sum(c.isalnum() for c in cleaned) >= min_chars
+
+
 # --------- worker stateless : convertit 1 fichier avec Docling ----------
 def _convert_one_file(file_path_str: str):
     """Convertit un fichier (PDF/DOCX/PPTX) en Markdown via Docling.
@@ -67,7 +107,18 @@ def _convert_one_file(file_path_str: str):
             },
         )
         doc = doc_converter.convert(str(src)).document
+        md = doc.export_to_markdown(page_break_placeholder="<-!-- page-break --!->")
+        # 1er passage : comportement d'origine
+        doc = _build_converter().convert(str(src)).document
         md = doc.export_to_markdown()
+        message = ""
+
+        # Repli : PDF sans texte exploitable (PDF image) -> OCR pleine page
+        if src.suffix.lower() == ".pdf" and not _has_text(md):
+            doc = _build_converter(force_ocr=True).convert(str(src)).document
+            md = doc.export_to_markdown()
+            message = "ocr pleine page (pdf sans texte natif)"
+
         out_md.write_text(md, encoding="utf-8")
         status, message = "ok", ""
     except Exception as e: