aait 2.3.15.995__tar.gz → 2.3.15.997__tar.gz

aait-2.3.15.997/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: aait
+Version: 2.3.15.997
+Summary: Advanced Artificial Intelligence Tools is a package meant to develop and enable advanced AI functionalities in Orange
+Home-page: 
+Author: Orange community
+Author-email: 
+Keywords: orange3 add-on

aait-2.3.15.997/aait.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: aait
+Version: 2.3.15.997
+Summary: Advanced Artificial Intelligence Tools is a package meant to develop and enable advanced AI functionalities in Orange
+Home-page: 
+Author: Orange community
+Author-email: 
+Keywords: orange3 add-on

{aait-2.3.15.995 → aait-2.3.15.997}/aait.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ orangecontrib/AAIT/llm/lmstudio.py
 orangecontrib/AAIT/llm/process_documents.py
 orangecontrib/AAIT/llm/prompt_management.py
 orangecontrib/AAIT/llm/translations.py
+orangecontrib/AAIT/llm/wordchunker_deprecated.py
 orangecontrib/AAIT/llm/resources/__ini__.py
 orangecontrib/AAIT/llm/resources/markdown_recipe.json
 orangecontrib/AAIT/optimiser/__init__.py
@@ -40,6 +41,7 @@ orangecontrib/AAIT/utils/thread_management.py
 orangecontrib/AAIT/utils/unlink_table_domain.py
 orangecontrib/AAIT/utils/widget_positioning.py
 orangecontrib/AAIT/utils/windows_utils.py
+orangecontrib/AAIT/utils/tools/TigerODM_notepad.py
 orangecontrib/AAIT/utils/tools/__init__.py
 orangecontrib/AAIT/utils/tools/change_owcorpus.py
 orangecontrib/AAIT/utils/tools/concat_splitted_pypi.py
@@ -112,6 +114,7 @@ orangecontrib/AAIT/widgets/OWSelectColumnDynamique.py
 orangecontrib/AAIT/widgets/OWSelectRowsDynamic.py
 orangecontrib/AAIT/widgets/OWSortAndSelect.py
 orangecontrib/AAIT/widgets/OWSplitExcelSheets.py
+orangecontrib/AAIT/widgets/OWSplitPath.py
 orangecontrib/AAIT/widgets/OWStartLoop.py
 orangecontrib/AAIT/widgets/OWTable2Corpus.py
 orangecontrib/AAIT/widgets/OWTranslation.py
@@ -182,6 +185,7 @@ orangecontrib/AAIT/widgets/designer/owselect_column_dynamic.ui
 orangecontrib/AAIT/widgets/designer/owselect_row_dynamic.ui
 orangecontrib/AAIT/widgets/designer/owsortandselect.ui
 orangecontrib/AAIT/widgets/designer/owsplitexcelsheets.ui
+orangecontrib/AAIT/widgets/designer/owsplitpath.ui
 orangecontrib/AAIT/widgets/designer/owstartloop.ui
 orangecontrib/AAIT/widgets/designer/owtable2corpus.ui
 orangecontrib/AAIT/widgets/designer/owtranslation.ui
@@ -265,6 +269,7 @@ orangecontrib/AAIT/widgets/icons/processdocuments.svg
 orangecontrib/AAIT/widgets/icons/quadrantclicker.svg
 orangecontrib/AAIT/widgets/icons/qwen-color.png
 orangecontrib/AAIT/widgets/icons/select_dynamic_row.png
+orangecontrib/AAIT/widgets/icons/split_path.png
 orangecontrib/AAIT/widgets/icons/splitexcelsheets.png
 orangecontrib/AAIT/widgets/icons/startloop.png
 orangecontrib/AAIT/widgets/icons/tools.png

{aait-2.3.15.995 → aait-2.3.15.997}/orangecontrib/AAIT/__init__.py

@@ -42,11 +42,11 @@ if not check_executable_length():
     exit(0)
 
 
-target_version = version.parse("3.37")
+target_version = version.parse("3.40")
 current_version = version.parse(Orange.version.version)
 if current_version < target_version: # Skip the file
     print("Orange version not compatible with all of AAIT functions !")
-
+    SimpleDialogQt.BoxError("Orange version not compatible with all of AAIT functions !")
 
 else: # Execute the file
     import os
@@ -330,4 +330,41 @@ else: # Execute the file
     import_proprietary_categories()
     duplicate_widget_if_needed_exept_POW_file()
 
-    duplicate_POW_file()
+    duplicate_POW_file()
+
+
+
+from AnyQt import QtWidgets, QtGui, QtCore
+
+def force_native_light_mode():
+    # 1. Get the current application instance
+    app = QtWidgets.QApplication.instance()
+    if not app:
+        return
+
+    # 2. Force the style back to 'Windows' or 'WindowsVista'
+    # This prevents Orange from using any custom Dark-specific styles
+    app.setStyle(QtWidgets.QStyleFactory.create("WindowsVista"))
+
+    # 3. Explicitly tell Qt to use the Light Palette
+    # We fetch the 'Standard' palette which defaults to Light colors
+    light_palette = QtGui.QPalette()
+
+    # Manually re-assert the Light Mode colors to override OS injection
+    light_palette.setColor(QtGui.QPalette.Window, QtGui.QColor(240, 240, 240))
+    light_palette.setColor(QtGui.QPalette.WindowText, QtCore.Qt.black)
+    light_palette.setColor(QtGui.QPalette.Base, QtCore.Qt.white)
+    light_palette.setColor(QtGui.QPalette.AlternateBase, QtGui.QColor(233, 233, 233))
+    light_palette.setColor(QtGui.QPalette.ToolTipBase, QtCore.Qt.white)
+    light_palette.setColor(QtGui.QPalette.ToolTipText, QtCore.Qt.black)
+    light_palette.setColor(QtGui.QPalette.Text, QtCore.Qt.black)
+    light_palette.setColor(QtGui.QPalette.Button, QtGui.QColor(240, 240, 240))
+    light_palette.setColor(QtGui.QPalette.ButtonText, QtCore.Qt.black)
+    light_palette.setColor(QtGui.QPalette.BrightText, QtCore.Qt.red)
+    light_palette.setColor(QtGui.QPalette.Link, QtGui.QColor(0, 0, 255))
+    light_palette.setColor(QtGui.QPalette.Highlight, QtGui.QColor(0, 120, 215))
+    light_palette.setColor(QtGui.QPalette.HighlightedText, QtCore.Qt.white)
+
+    app.setPalette(light_palette)
+
+force_native_light_mode()

aait-2.3.15.997/orangecontrib/AAIT/llm/chunking.py

@@ -0,0 +1,113 @@
+import copy
+import re
+import os
+import pathlib
+import Orange
+from Orange.data import Domain, Table, StringVariable, ContinuousVariable
+from sentence_transformers import SentenceTransformer
+
+### Chonkie
+from chonkie import TokenChunker, SentenceChunker, RecursiveChunker, SemanticChunker, LateChunker, CodeChunker
+if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
+    from Orange.widgets.orangecontrib.AAIT.llm import wordchunker_deprecated
+    from Orange.widgets.orangecontrib.AAIT.utils.MetManagement import get_local_store_path
+else:
+    from orangecontrib.AAIT.llm import wordchunker_deprecated
+    from orangecontrib.AAIT.utils.MetManagement import get_local_store_path
+
+
+def create_chunks(table, column_name, tokenizer="character", chunk_size=300, chunk_overlap=100, mode="tokens",
+                  progress_callback=None, argself=None):
+    """
+    Chunk the text in `column_name` of an Orange Table using a specialized chunker.
+
+    Splits each row's text into chunks based on the selected mode (Token, Sentence,
+    Recursive, or Markdown). Adds the chunked text and its metadata as new meta
+    columns to the table.
+
+    Parameters:
+        table (Table): Input data table.
+        column_name (str): Name of the text column to chunk.
+        tokenizer (str): Tokenizer type (e.g., "character").
+        chunk_size (int): Target chunk size.
+        chunk_overlap (int): Overlap between chunks (not used in all modes).
+        mode (str): Chunking strategy ("Token", "Sentence", "Recursive", "Markdown").
+        progress_callback (callable): Optional progress reporter.
+        argself: Optional caller reference.
+
+    Returns:
+        Table: The table with added meta columns: "Chunks", "Chunks size", and "Metadata".
+    """
+    print("This widget is being updated : default tokenizer 'character' enabled for compatibility !!")
+    tokenizer = "character"
+
+    # Définir la fonction de chunking selon le mode
+    if mode == "tokens":
+        chunker = TokenChunker(tokenizer=tokenizer, chunk_size=chunk_size, chunk_overlap=chunk_overlap)
+    elif mode == "words":
+        path_ugly = os.path.join(get_local_store_path(), "Models", "NLP", "all-mpnet-base-v2")
+        tokenizer_word = SentenceTransformer(path_ugly, device="cpu")
+        chunker = wordchunker_deprecated.WordChunker(tokenizer=tokenizer_word, chunk_size=chunk_size, chunk_overlap=chunk_overlap)
+    elif mode == "sentence":
+        chunker = SentenceChunker(tokenizer=tokenizer, chunk_size=chunk_size, chunk_overlap=chunk_overlap,
+                                  min_sentences_per_chunk=1)
+    elif mode == "markdown":
+        markdown_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "resources/markdown_recipe.json")
+        chunker = RecursiveChunker.from_recipe(path=markdown_path,
+                                               tokenizer=tokenizer,
+                                               chunk_size=chunk_size,
+                                               min_characters_per_chunk=1)
+
+    # TODO : Ajouter la gestion des paramètres dans le .ui
+    # Nécessite des "rules" pour faire un chunking différent de Token ou Sentence
+    elif mode == "Recursive":
+        chunker = RecursiveChunker(tokenizer=tokenizer, chunk_size=chunk_size, min_characters_per_chunk=24)
+    # À tester avant d'ajouter la fonctionnalité dans l'UI
+    # Model d'embeddings REQUIS !
+    elif mode == "Semantic":
+        chunker = SemanticChunker(embedding_model=tokenizer, threshold=0.7, chunk_size=chunk_size, similarity_window=3)
+    # À tester avant d'ajouter la fonctionnalité dans l'UI
+    # Model d'embeddings REQUIS !
+    elif mode == "Late":
+        chunker = LateChunker(embedding_model=tokenizer, chunk_size=chunk_size, min_characters_per_chunk=24)
+    elif mode == "Code":
+        chunker = CodeChunker("blabla")
+    else:
+        raise ValueError(f"Invalid mode: {mode}. Valid modes are: Token, Sentence, Recursive, Markdown")
+
+    new_metas = list(table.domain.metas) + [StringVariable("Chunks"),
+                                            ContinuousVariable("Chunks size"),
+                                            ContinuousVariable("Chunks index"),
+                                            ContinuousVariable("Chunks start"),
+                                            ContinuousVariable("Chunks end"),
+                                            StringVariable("Metadata")]
+    new_domain = Domain(table.domain.attributes, table.domain.class_vars, new_metas)
+
+    new_rows = []
+    for i, row in enumerate(table):
+        content = row[column_name].value
+        chunks = chunker(content)
+        # For each chunk in the chunked data
+        for j, chunk in enumerate(chunks):
+            # Build new metas with previous data and the chunk
+            new_metas_values = list(row.metas) + [chunk.text,
+                                                  chunk.token_count,
+                                                  j, # Chunks index
+                                                  chunk.start_index,
+                                                  chunk.end_index,
+                                                  ""] # Metadata
+            # Create the new row instance
+            new_instance = Orange.data.Instance(new_domain,
+                                                [row[x] for x in table.domain.attributes] + [row[y] for y in
+                                                                                             table.domain.class_vars] + new_metas_values)
+            # Store the new row
+            new_rows.append(new_instance)
+
+        if progress_callback is not None:
+            progress_value = float(100 * (i + 1) / len(table))
+            progress_callback(progress_value)
+        if argself is not None:
+            if argself.stop:
+                break
+
+    return Table.from_list(domain=new_domain, rows=new_rows)

aait-2.3.15.997/orangecontrib/AAIT/llm/wordchunker_deprecated.py

@@ -0,0 +1,333 @@
+# wordchunker_deprecated.py
+# -----------------------------------------------------------------------------
+# Compatibility shim reproducing chonkie==0.4.1 WordChunker behavior (including
+# historical quirks/bugs), while being usable inside chonkie>=1.x pipelines.
+#
+# What you get:
+# - A local WordChunker class with the same logic as chonkie 0.4.1 word chunker.
+# - Preserves newlines: words are spans like r"(\s*\S+)" joined with "".
+# - chunk_size / chunk_overlap are TOKEN budgets (not "word" counts), measured
+#   via the provided tokenizer backend.
+# - Reproduces 0.4.1 overlap-loop quirk: iterates range(previous_chunk_length)
+#   where previous_chunk_length is a TOKEN count (not word count).
+# - Reproduces 0.4.1 final-chunk quirk: _create_chunk called without current_index
+#   (defaults to 0), which can yield start_index via .find from the start.
+#
+# Added for practicality in your AAIT / chonkie>=1.5.2 integration:
+# - WordChunker is callable: chunker(text) == chunker.chunk(text)
+# - Accepts tokenizer="character" (character-count pseudo tokenizer)
+# - Accepts a SentenceTransformer instance as tokenizer (uses .tokenizer underneath)
+#
+# NOTE (important bugfix vs earlier draft):
+# Many HuggingFace tokenizers are *callable* (tokenizer(text) -> BatchEncoding).
+# We must NOT mis-detect them as a generic callable token counter. We detect
+# transformers/tokenizers backends *first* by attributes, then fall back to callable.
+# -----------------------------------------------------------------------------
+
+from __future__ import annotations
+
+import importlib
+import inspect
+import re
+from dataclasses import dataclass
+from typing import Any, Callable, List, Union
+
+
+@dataclass(frozen=True)
+class Chunk:
+    text: str
+    start_index: int
+    end_index: int
+    token_count: int
+
+
+# -----------------------------
+# Helpers for robust tokenizers
+# -----------------------------
+
+def _unwrap_possible_sentence_transformer(obj: Any) -> Any:
+    """
+    If `obj` looks like a SentenceTransformer, return its underlying HF tokenizer
+    when available. SentenceTransformer usually has `.tokenizer`.
+    """
+    if obj is None:
+        return obj
+    try:
+        if hasattr(obj, "tokenizer") and "SentenceTransformer" in type(obj).__name__:
+            tok = getattr(obj, "tokenizer", None)
+            if tok is not None:
+                return tok
+    except Exception:
+        pass
+    return obj
+
+
+def _make_character_tokenizer() -> Any:
+    """
+    Special compatibility: when user passes tokenizer="character", count tokens
+    as characters, and support batch encoding.
+    """
+    class _CharTokenizer:
+        def encode(self, text: str):
+            return list(range(len(text)))
+
+        def encode_batch(self, texts: List[str]):
+            return [self.encode(t) for t in texts]
+
+    return _CharTokenizer()
+
+
+# -----------------------------
+# Minimal BaseChunker (0.4.1-ish)
+# -----------------------------
+
+class BaseChunker:
+    """
+    Minimal subset of chonkie.chunker.base.BaseChunker needed by WordChunker 0.4.1
+    """
+
+    def __init__(self, tokenizer_or_token_counter: Union[str, Any, Callable[[str], int]]):
+        tokenizer_or_token_counter = _unwrap_possible_sentence_transformer(tokenizer_or_token_counter)
+
+        if tokenizer_or_token_counter == "character":
+            tokenizer_or_token_counter = _make_character_tokenizer()
+
+        if isinstance(tokenizer_or_token_counter, str):
+            self.tokenizer = self._load_tokenizer(tokenizer_or_token_counter)
+        else:
+            self.tokenizer = tokenizer_or_token_counter
+
+        self._tokenizer_backend = self._get_tokenizer_backend()
+        self.token_counter = self._get_tokenizer_counter()
+
+    def _get_tokenizer_backend(self) -> str:
+        t = self.tokenizer
+        tname = type(t).__name__
+        ttype = str(type(t))
+
+        # 1) transformers-style tokenizer (callable, returns BatchEncoding, has encode, often batch_encode_plus)
+        if hasattr(t, "batch_encode_plus") or "transformers" in ttype or "PreTrainedTokenizer" in tname:
+            return "transformers"
+
+        # 2) tokenizers rust-style (has encode_batch with add_special_tokens)
+        if "tokenizers" in ttype:
+            return "tokenizers"
+
+        # 3) tiktoken encodings
+        if "tiktoken" in ttype:
+            return "tiktoken"
+
+        # 4) our custom / other encoders that implement encode_batch
+        if hasattr(t, "encode_batch"):
+            return "encode_batch"
+
+        # 5) basic encode-only objects
+        if hasattr(t, "encode"):
+            return "encode_only"
+
+        # 6) finally: a callable token *counter* function: f(text)->int
+        # (must be LAST so we don't mis-detect HF tokenizers as callable counters)
+        if callable(t) or inspect.isfunction(t) or inspect.ismethod(t):
+            return "callable_counter"
+
+        raise ValueError(f"Tokenizer backend {ttype} not supported")
+
+    def _load_tokenizer(self, tokenizer_name: str):
+        # Same overall strategy as 0.4.1: try tiktoken -> autotiktokenizer -> tokenizers -> transformers
+        try:
+            if importlib.util.find_spec("tiktoken") is not None:
+                from tiktoken import get_encoding
+                return get_encoding(tokenizer_name)
+            raise RuntimeError("tiktoken not available")
+        except Exception:
+            try:
+                if importlib.util.find_spec("autotiktokenizer") is not None:
+                    from autotiktokenizer import AutoTikTokenizer
+                    return AutoTikTokenizer.from_pretrained(tokenizer_name)
+                raise RuntimeError("autotiktokenizer not available")
+            except Exception:
+                try:
+                    if importlib.util.find_spec("tokenizers") is not None:
+                        from tokenizers import Tokenizer
+                        return Tokenizer.from_pretrained(tokenizer_name)
+                    raise RuntimeError("tokenizers not available")
+                except Exception:
+                    if importlib.util.find_spec("transformers") is not None:
+                        from transformers import AutoTokenizer
+                        return AutoTokenizer.from_pretrained(tokenizer_name)
+                    raise ValueError(
+                        "Tokenizer not found in: transformers, tokenizers, autotiktokenizer, tiktoken. "
+                        "Install one of these."
+                    )
+
+    def _get_tokenizer_counter(self) -> Callable[[str], int]:
+        t = self.tokenizer
+        if self._tokenizer_backend == "transformers":
+            return lambda text: len(t.encode(text, add_special_tokens=False))
+        if self._tokenizer_backend == "tokenizers":
+            return lambda text: len(t.encode(text, add_special_tokens=False).ids)
+        if self._tokenizer_backend == "tiktoken":
+            return lambda text: len(t.encode(text))
+        if self._tokenizer_backend == "encode_batch":
+            if hasattr(t, "encode"):
+                return lambda text: len(t.encode(text))
+            return lambda text: len(t.encode_batch([text])[0])
+        if self._tokenizer_backend == "encode_only":
+            return lambda text: len(t.encode(text))
+        if self._tokenizer_backend == "callable_counter":
+            return t  # type: ignore[return-value]
+        raise ValueError("Tokenizer backend not supported for token counting")
+
+    def _encode_batch(self, texts: List[str]) -> List[List[int]]:
+        """
+        Return list of token-id lists. Only lengths are used by WordChunker.
+        """
+        t = self.tokenizer
+        if self._tokenizer_backend == "transformers":
+            # batch_encode_plus exists on most HF tokenizers; if not, fall back to __call__
+            if hasattr(t, "batch_encode_plus"):
+                return t.batch_encode_plus(texts, add_special_tokens=False)["input_ids"]
+            # Fallback: tokenizer(texts, add_special_tokens=False) -> BatchEncoding with input_ids
+            enc = t(texts, add_special_tokens=False)
+            return enc["input_ids"]
+        if self._tokenizer_backend == "tokenizers":
+            return [e.ids for e in t.encode_batch(texts, add_special_tokens=False)]
+        if self._tokenizer_backend == "tiktoken":
+            return t.encode_batch(texts)
+        if self._tokenizer_backend == "encode_batch":
+            return t.encode_batch(texts)
+        if self._tokenizer_backend == "encode_only":
+            return [t.encode(x) for x in texts]
+        if self._tokenizer_backend == "callable_counter":
+            # emulate "ids" with dummy list of length == token_count
+            out: List[List[int]] = []
+            for x in texts:
+                n = int(t(x))
+                out.append(list(range(n)))
+            return out
+        raise ValueError(f"Tokenizer backend {self._tokenizer_backend} not supported.")
+
+
+# -----------------------------
+# WordChunker (exact 0.4.1 logic)
+# -----------------------------
+
+class WordChunker(BaseChunker):
+    """
+    Exact port of chonkie==0.4.1 WordChunker (chunker/word.py), with identical behavior/quirks.
+    """
+
+    def __init__(
+        self,
+        tokenizer: Union[str, Any] = "gpt2",
+        chunk_size: int = 512,
+        chunk_overlap: int = 128,
+    ):
+        super().__init__(tokenizer)
+
+        if chunk_size <= 0:
+            raise ValueError("chunk_size must be positive")
+        if chunk_overlap >= chunk_size:
+            raise ValueError("chunk_overlap must be less than chunk_size")
+
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+
+    def _split_into_words(self, text: str) -> List[str]:
+        split_points = [match.end() for match in re.finditer(r"(\s*\S+)", text)]
+        words: List[str] = []
+        prev = 0
+
+        for point in split_points:
+            words.append(text[prev:point])
+            prev = point
+
+        if prev < len(text):
+            words.append(text[prev:])
+
+        return words
+
+    def _create_chunk(
+        self,
+        words: List[str],
+        text: str,
+        token_count: int,
+        current_index: int = 0,
+    ) -> Chunk:
+        chunk_text = "".join(words)
+        start_index = text.find(chunk_text, current_index)
+        return Chunk(
+            text=chunk_text,
+            start_index=start_index,
+            end_index=start_index + len(chunk_text),
+            token_count=token_count,
+        )
+
+    def _get_word_list_token_counts(self, words: List[str]) -> List[int]:
+        words = [word for word in words if word != ""]
+        encodings = self._encode_batch(words)
+        return [len(encoding) for encoding in encodings]
+
+    def chunk(self, text: str) -> List[Chunk]:
+        if not text or not text.strip():
+            return []
+
+        words = self._split_into_words(text)
+        lengths = self._get_word_list_token_counts(words)
+        chunks: List[Chunk] = []
+
+        current_chunk: List[str] = []
+        current_chunk_length = 0
+        current_index = 0
+
+        for i, (word, length) in enumerate(zip(words, lengths)):
+            if current_chunk_length + length <= self.chunk_size:
+                current_chunk.append(word)
+                current_chunk_length += length
+            else:
+                chunk = self._create_chunk(current_chunk, text, current_chunk_length, current_index)
+                chunks.append(chunk)
+
+                previous_chunk_length = current_chunk_length
+                current_index = chunk.end_index
+
+                overlap: List[str] = []
+                overlap_length = 0
+
+                # Quirk/bug-compatible loop: previous_chunk_length is token count
+                for j in range(0, previous_chunk_length):
+                    cwi = i - 1 - j
+                    if cwi < 0:
+                        break
+                    oword = words[cwi]
+                    olength = lengths[cwi]
+                    if overlap_length + olength <= self.chunk_overlap:
+                        overlap.append(oword)
+                        overlap_length += olength
+                    else:
+                        break
+
+                current_chunk = [w for w in reversed(overlap)]
+                current_chunk_length = overlap_length
+
+                current_chunk.append(word)
+                current_chunk_length += length
+
+        if current_chunk:
+            # Quirk/bug-compatible: current_index not passed (defaults to 0)
+            chunk = self._create_chunk(current_chunk, text, current_chunk_length)
+            chunks.append(chunk)
+
+        return chunks
+
+    def __call__(self, text: str) -> List[Chunk]:
+        return self.chunk(text)
+
+    def __repr__(self) -> str:
+        return f"WordChunker(chunk_size={self.chunk_size}, chunk_overlap={self.chunk_overlap})"
+
+
+def chunk_words(content: str, tokenizer: Any, chunk_size: int = 300, chunk_overlap: int = 100):
+    chunker = WordChunker(tokenizer=tokenizer, chunk_size=chunk_size, chunk_overlap=chunk_overlap)
+    chunks = chunker.chunk(content)
+    return [c.text for c in chunks], []

{aait-2.3.15.995 → aait-2.3.15.997}/orangecontrib/AAIT/utils/MetManagement.py

@@ -1473,6 +1473,48 @@ def create_trigger_table():
     return table
 
 
+def ensure_file_exists_recursive(path_holder: list[str]) -> bool:
+    """
+    Vérifie l'existence d'un fichier.
+
+    - Si le chemin absolu existe → True
+    - Sinon, cherche récursivement le fichier dans le dossier parent
+      - Si trouvé → met à jour path_holder[0] avec le nouveau chemin absolu → True
+      - Sinon → False (sans modifier path_holder)
+
+    Args:
+        path_holder (list[str]): liste mutable contenant le chemin absolu du fichier
+
+    Returns:
+        bool
+    """
+    if not path_holder or not path_holder[0]:
+        return False
+
+    original_path = Path(path_holder[0])
+
+    # 1️⃣ Cas simple : le fichier existe déjà
+    if original_path.is_file():
+        return True
+
+    parent_dir = original_path.parent
+    filename = original_path.name
+
+    # 2️⃣ Sécurité minimale
+    if not parent_dir.is_dir():
+        return False
+
+    # 3️⃣ Recherche récursive dans les sous-dossiers
+    for found in parent_dir.rglob(filename):
+        if found.is_file():
+            path_holder[0] = str(found.resolve())
+            return True
+
+    # 4️⃣ Rien trouvé → ne pas modifier le chemin
+    return False
+
+
+
 if __name__ == "__main__":
     # avant faire un bouton
     # set_aait_store_remote_ressources_path(ressource_path)

{aait-2.3.15.995 → aait-2.3.15.997}/orangecontrib/AAIT/utils/base_widget.py

@@ -12,7 +12,7 @@ else:
     from orangecontrib.AAIT.utils.import_uic import uic
 
 
-class BaseListWidget(widget.OWWidget):
+class BaseListWidget(widget.OWWidget, openclass=True):
     """
     Base Orange widget providing a filterable list of variables from the input data domain.
 
@@ -54,6 +54,14 @@ class BaseListWidget(widget.OWWidget):
        self.var_selector.add_variables(self.data.domain)
        self.var_selector.select_variable_by_name(self.selected_column_name)
        ```
+    7. You can use
+        autorun = Setting(True)
+        and self.autorun = True / self.autorun = False
+        to control whether the process is triggered automatically when input data is received.
+
+    8.self.data is the input data stream. Make sure to create
+        new_data = self.data.copy()
+        to avoid issues when the process is triggered several time via a push button.
     """
     # Settings
     selected_column_name = Setting("Default")  # set the targeted column by default as "Default"
@@ -91,8 +99,8 @@ class BaseListWidget(widget.OWWidget):
 
         # Data management
         self.data = None
-        self.autorun = True
-
+        # If self.autorun exists, it is preserved. Otherwise, it is set to True.
+        self.autorun = getattr(self, "autorun", True)
 
     def on_variable_selected(self, var_name):
         """Update the selected column when the user clicks an item."""