aait 2.2.3__tar.gz → 2.2.5__tar.gz

aait-2.2.5/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.1
+Name: aait
+Version: 2.2.5
+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
+License-File: License.txt
+Requires-Dist: torch
+Requires-Dist: sentence-transformers==5.0.0
+Requires-Dist: gpt4all[all]==2.8.2
+Requires-Dist: sacremoses==0.1.1
+Requires-Dist: transformers==4.51.3
+Requires-Dist: sentencepiece==0.2.0
+Requires-Dist: optuna
+Requires-Dist: spacy==3.7.6
+Requires-Dist: markdown
+Requires-Dist: python-multipart
+Requires-Dist: PyMuPDF==1.24.14
+Requires-Dist: chonkie==0.4.1
+Requires-Dist: GPUtil==1.4.0
+Requires-Dist: unidecode==1.3.8
+Requires-Dist: python-docx==1.1.2
+Requires-Dist: psutil
+Requires-Dist: thefuzz==0.22.1
+Requires-Dist: beautifulsoup4==4.12.3
+Requires-Dist: CATEGORIT

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

@@ -0,0 +1,28 @@
+Metadata-Version: 2.1
+Name: aait
+Version: 2.2.5
+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
+License-File: License.txt
+Requires-Dist: torch
+Requires-Dist: sentence-transformers==5.0.0
+Requires-Dist: gpt4all[all]==2.8.2
+Requires-Dist: sacremoses==0.1.1
+Requires-Dist: transformers==4.51.3
+Requires-Dist: sentencepiece==0.2.0
+Requires-Dist: optuna
+Requires-Dist: spacy==3.7.6
+Requires-Dist: markdown
+Requires-Dist: python-multipart
+Requires-Dist: PyMuPDF==1.24.14
+Requires-Dist: chonkie==0.4.1
+Requires-Dist: GPUtil==1.4.0
+Requires-Dist: unidecode==1.3.8
+Requires-Dist: python-docx==1.1.2
+Requires-Dist: psutil
+Requires-Dist: thefuzz==0.22.1
+Requires-Dist: beautifulsoup4==4.12.3
+Requires-Dist: CATEGORIT

{aait-2.2.3 → aait-2.2.5}/aait.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 License.txt
+setup.cfg
 setup.py
 aait.egg-info/PKG-INFO
 aait.egg-info/SOURCES.txt
@@ -65,6 +66,7 @@ orangecontrib/AAIT/utils/MetManagement.py
 orangecontrib/AAIT/utils/SimpleDialogQt.py
 orangecontrib/AAIT/utils/__init__.py
 orangecontrib/AAIT/utils/aait_repo_file.py
+orangecontrib/AAIT/utils/base_widget.py
 orangecontrib/AAIT/utils/check_data_in.py
 orangecontrib/AAIT/utils/delta_local_shared_fodler.py
 orangecontrib/AAIT/utils/import_uic.py
@@ -105,10 +107,12 @@ orangecontrib/AAIT/widgets/OWGenerateQuestions.py
 orangecontrib/AAIT/widgets/OWGenerateSynthesis.py
 orangecontrib/AAIT/widgets/OWGenerateWord.py
 orangecontrib/AAIT/widgets/OWInputSelector.py
+orangecontrib/AAIT/widgets/OWKeywords.py
 orangecontrib/AAIT/widgets/OWKeywordsDetection.py
 orangecontrib/AAIT/widgets/OWLMStudio.py
 orangecontrib/AAIT/widgets/OWLanguageDetection.py
 orangecontrib/AAIT/widgets/OWLemmatizer.py
+orangecontrib/AAIT/widgets/OWLoadDocuments.py
 orangecontrib/AAIT/widgets/OWModel_CE_MiniLML6.py
 orangecontrib/AAIT/widgets/OWModel_Falcon.py
 orangecontrib/AAIT/widgets/OWModel_HelsinkiEnFr.py
@@ -135,6 +139,7 @@ orangecontrib/AAIT/widgets/OWReranking.py
 orangecontrib/AAIT/widgets/OWSaveFilepathEntry.py
 orangecontrib/AAIT/widgets/OWSelectColumnDynamique.py
 orangecontrib/AAIT/widgets/OWSelectRowsDynamic.py
+orangecontrib/AAIT/widgets/OWSortAndSelect.py
 orangecontrib/AAIT/widgets/OWStartLoop.py
 orangecontrib/AAIT/widgets/OWTable2Corpus.py
 orangecontrib/AAIT/widgets/OWTranslation.py
@@ -148,6 +153,7 @@ orangecontrib/AAIT/widgets/designer/ow_widget_random_data.ui
 orangecontrib/AAIT/widgets/designer/owaccumulator.ui
 orangecontrib/AAIT/widgets/designer/owaddcolumns.ui
 orangecontrib/AAIT/widgets/designer/owapplyrules.ui
+orangecontrib/AAIT/widgets/designer/owchunkanalysis.ui
 orangecontrib/AAIT/widgets/designer/owchunking.ui
 orangecontrib/AAIT/widgets/designer/owconcatrules.ui
 orangecontrib/AAIT/widgets/designer/owconversellm.ui
@@ -155,6 +161,7 @@ orangecontrib/AAIT/widgets/designer/owembeddings.ui
 orangecontrib/AAIT/widgets/designer/owemptyswitch.ui
 orangecontrib/AAIT/widgets/designer/owendloop.ui
 orangecontrib/AAIT/widgets/designer/owexecutescript.ui
+orangecontrib/AAIT/widgets/designer/owexecutescript_TEST.ui
 orangecontrib/AAIT/widgets/designer/owextrachunks.ui
 orangecontrib/AAIT/widgets/designer/owextracttokens.ui
 orangecontrib/AAIT/widgets/designer/owfilemetadata.ui
@@ -169,6 +176,8 @@ orangecontrib/AAIT/widgets/designer/owkeyword.ui
 orangecontrib/AAIT/widgets/designer/owkeywordsdetection.ui
 orangecontrib/AAIT/widgets/designer/owlangdetect.ui
 orangecontrib/AAIT/widgets/designer/owlemmatizer.ui
+orangecontrib/AAIT/widgets/designer/owllm4all.ui
+orangecontrib/AAIT/widgets/designer/owloaddocuments.ui
 orangecontrib/AAIT/widgets/designer/owloadworkflow.ui
 orangecontrib/AAIT/widgets/designer/owmodel_ce_minilml6.ui
 orangecontrib/AAIT/widgets/designer/owmodel_falcon.ui
@@ -204,10 +213,12 @@ orangecontrib/AAIT/widgets/icons/MDViewer.png
 orangecontrib/AAIT/widgets/icons/Mistral.png
 orangecontrib/AAIT/widgets/icons/apply_rules.svg
 orangecontrib/AAIT/widgets/icons/category.svg
+orangecontrib/AAIT/widgets/icons/chunking_analysis.png
 orangecontrib/AAIT/widgets/icons/dark_green.txt
 orangecontrib/AAIT/widgets/icons/de.png
 orangecontrib/AAIT/widgets/icons/document_generator.png
 orangecontrib/AAIT/widgets/icons/documents.png
+orangecontrib/AAIT/widgets/icons/edge_llm.svg
 orangecontrib/AAIT/widgets/icons/endloop.png
 orangecontrib/AAIT/widgets/icons/extra_chunks.png
 orangecontrib/AAIT/widgets/icons/in_or_out.png
@@ -243,8 +254,10 @@ orangecontrib/AAIT/widgets/icons/owfilewithpath.svg
 orangecontrib/AAIT/widgets/icons/owfusion_nm.png
 orangecontrib/AAIT/widgets/icons/owgeneratequestions.svg
 orangecontrib/AAIT/widgets/icons/owgeneratesynthesis.png
+orangecontrib/AAIT/widgets/icons/owkeywords.png
 orangecontrib/AAIT/widgets/icons/owkeywordsdetection.png
 orangecontrib/AAIT/widgets/icons/owlemmatizer.svg
+orangecontrib/AAIT/widgets/icons/owloaddocuments.svg
 orangecontrib/AAIT/widgets/icons/owmodel_ce_minilml6.svg
 orangecontrib/AAIT/widgets/icons/owmodel_falcon.png
 orangecontrib/AAIT/widgets/icons/owmodel_helsinki_en_fr.svg
@@ -258,6 +271,7 @@ orangecontrib/AAIT/widgets/icons/owqueryllm.svg
 orangecontrib/AAIT/widgets/icons/owreranking.svg
 orangecontrib/AAIT/widgets/icons/owsavefilepathentry.svg
 orangecontrib/AAIT/widgets/icons/owselectcolumndynamique.png
+orangecontrib/AAIT/widgets/icons/owsortandselect.svg
 orangecontrib/AAIT/widgets/icons/owtable2corpus.svg
 orangecontrib/AAIT/widgets/icons/owtranslation.svg
 orangecontrib/AAIT/widgets/icons/owtrigger.svg

{aait-2.2.3 → aait-2.2.5}/orangecontrib/AAIT/llm/answers.py

@@ -1,6 +1,9 @@
 import copy
 import os
-import GPUtil
+try:
+    import GPUtil #sometimes errors occurs on gpu testing
+except:
+    pass
 import psutil
 import ntpath
 import platform
@@ -44,50 +47,56 @@ def check_gpu(model_path, argself):
         argself.can_run = False
         argself.error("Model is not compatible. It must be a .gguf format.")
         return
-    # Calculate the model size in MB with a 1500 MB buffer
-    model_size = os.path.getsize(model_path) / (1024 ** 3) * 1000
-    model_size += token_weight * int(argself.n_ctx)
-    print(f"Required memory: {model_size/1000:.2f}GB")
-    # If there is no GPU, set use_gpu to False
-    if len(GPUtil.getGPUs()) == 0:
-        argself.use_gpu = False
-        argself.information("Running on CPU. No GPU detected.")
-        return
-    # Else
-    else:
-        # Get the available VRAM on the first GPU
-        gpu = GPUtil.getGPUs()[0]
-        free_vram = gpu.memoryFree
-    # If there is not enough VRAM on GPU
-    if free_vram < model_size:
-        # Set use_gpu to False
-        argself.use_gpu = False
-        # Check for available RAM
-        available_ram = psutil.virtual_memory().available / 1024 / 1024
-        if available_ram < model_size:
-            argself.can_run = False
-            argself.error(f"Cannot run. Both GPU and CPU are too small for this model (required: {model_size/1000:.2f}GB).")
+    #  sometimes errors occurs on gpu testing
+    try:
+        # Calculate the model size in MB with a 1500 MB buffer
+        model_size = os.path.getsize(model_path) / (1024 ** 3) * 1000
+        model_size += token_weight * int(argself.n_ctx)
+        print(f"Required memory: {model_size/1000:.2f}GB")
+        # If there is no GPU, set use_gpu to False
+        if len(GPUtil.getGPUs()) == 0:
+            argself.use_gpu = False
+            argself.information("Running on CPU. No GPU detected.")
             return
+        # Else
         else:
-            argself.warning(f"Running on CPU. GPU seems to be too small for this model (available: {free_vram/1000:.2f}GB || required: {model_size/1000:.2f}GB).")
-            return
-    # If there is enough space on GPU
-    else:
-        try:
-            # Load the model and test it
-            # model = GPT4All(model_name=model_path, model_path=model_path, n_ctx=int(argself.n_ctx),
-            #                 allow_download=False, device="cuda")
-            # answer = model.generate("What if ?", max_tokens=3)
-            # # If it works, set use_gpu to True
-            argself.use_gpu = True
-            argself.information("Running on GPU.")
-            return
-        # If importing Llama and reading the model doesn't work
-        except Exception as e:
+            # Get the available VRAM on the first GPU
+            gpu = GPUtil.getGPUs()[0]
+            free_vram = gpu.memoryFree
+        # If there is not enough VRAM on GPU
+        if free_vram < model_size:
             # Set use_gpu to False
             argself.use_gpu = False
-            argself.warning(f"GPU cannot be used. (detail: {e})")
-            return
+            # Check for available RAM
+            available_ram = psutil.virtual_memory().available / 1024 / 1024
+            if available_ram < model_size:
+                argself.can_run = False
+                argself.error(f"Cannot run. Both GPU and CPU are too small for this model (required: {model_size/1000:.2f}GB).")
+                return
+            else:
+                argself.warning(f"Running on CPU. GPU seems to be too small for this model (available: {free_vram/1000:.2f}GB || required: {model_size/1000:.2f}GB).")
+                return
+        # If there is enough space on GPU
+        else:
+            try:
+                # Load the model and test it
+                # model = GPT4All(model_name=model_path, model_path=model_path, n_ctx=int(argself.n_ctx),
+                #                 allow_download=False, device="cuda")
+                # answer = model.generate("What if ?", max_tokens=3)
+                # # If it works, set use_gpu to True
+                argself.use_gpu = True
+                argself.information("Running on GPU.")
+                return
+            # If importing Llama and reading the model doesn't work
+            except Exception as e:
+                # Set use_gpu to False
+                argself.use_gpu = False
+                argself.warning(f"GPU cannot be used. (detail: {e})")
+                return
+    except:
+        argself.use_gpu = False
+        argself.warning(f"GPU cannot be used.")
+        return
 
 
 def load_model(model_path, use_gpu, n_ctx=10000):

{aait-2.2.3 → aait-2.2.5}/orangecontrib/AAIT/llm/process_documents.py

@@ -9,37 +9,31 @@ import fitz
 import docx
 
 
+
 def process_documents(dirpath):
-    if dirpath is None or not Path(dirpath).exists():
+    if dirpath is None or not os.path.exists(dirpath):
         return None, None
 
-    # Normalize dirpath
-    dirpath = Path(dirpath).resolve()
-
     # get path from user selection
     embeddings = check_for_embeddings(dirpath)
+    dirpath = dirpath.replace("\\","/")
 
     # Set selected path in the saved embeddings
     if embeddings is not None:
-        common_path = Path(find_common_root(embeddings)).resolve()
+        common_path = find_common_root(embeddings).replace("\\","/")
         for row in embeddings:
-            row_path = Path(str(row["path"].value)).resolve()
-            # Replace common root with the current dirpath
-            try:
-                row["path"] = str(dirpath / row_path.relative_to(common_path))
-            except ValueError:
-                # If relative_to fails (paths not matching), just normalize
-                row["path"] = str(row_path)
+            row["path"] = row["path"].value.replace("\\","/").replace(common_path, dirpath)
 
     # Verify which files are already processed
     files_to_process = get_files_to_process(dirpath, embeddings)
 
     rows = []
     for file in files_to_process:
-        file = Path(file).resolve()
-        content = extract_text(str(file))   # extractor may expect string
-        filename = file.name
-        row = [str(file), filename, content]  # store strings in Orange table
+        # Get the text content from the file
+        content = extract_text(file)
+        filename = ntpath.basename(file)
+        # Build a row containing dirpath | filename | content
+        row = [file, filename, content]
         rows.append(row)
 
     # Build a table with the constructed rows
@@ -51,115 +45,136 @@ def process_documents(dirpath):
     return out_data, embeddings
 
 
-def check_for_embeddings(folder_path):
-    """
-    Check for an embeddings.pkl file in a given folder. Return its content if it exists.
-
-    Parameters:
-        folder_path (str | Path): The path to the folder where embeddings.pkl may exist.
-
-    Returns:
-        Table or None: The content of embeddings.pkl, or None if not found.
-    """
-    folder_path = Path(folder_path).resolve()
-
-    filepaths = [
-        folder_path / "embeddings_question.pkl",
-        folder_path / "embeddings.pkl"
-    ]
-
-    for filepath in filepaths:
-        if filepath.exists():
-            return Table.from_file(str(filepath))  # Table.from_file expects a str
-    return None
-
-
 def find_common_root(data_table, column_name="path"):
     """Finds the common root path from a column of file paths in an Orange Data Table."""
-    paths = [Path(str(row[column_name].value)).resolve()
-             for row in data_table if row[column_name] is not None]
+    paths = [str(row[column_name]) for row in data_table if row[column_name] is not None]
     if not paths:
         return ""
-    return str(Path(os.path.commonpath(paths)).resolve())
+    return os.path.commonpath(paths)
 
 
 def get_files_to_process(folder_path, table=None):
     """
-    Finds all PDF/DOCX files in a folder (including subfolders) that are not already in the table
-    or that have changed since last check (based on file size).
+    Finds all PDF files in a folder (including subfolders) that are not already in the table.
+    The comparison is based on "name" (relative path from the main folder) instead of full paths.
 
     :param folder_path: Path to the folder to scan for documents.
-    :param table: Orange Data Table with column "path".
-    :return: List of new/changed file paths.
+    :param table: Orange Data Table with columns "path", "name", and "content".
+    :return: List of paths to files not present in the table (by name, including subfolder structure).
     """
-    supported_extensions = {".pdf", ".docx"}
+    #TODO
+    # Supported file extensions
+    supported_extensions = [".pdf", ".docx"]
 
-    folder_path = Path(folder_path).resolve()
-    filepath_sizes = folder_path / "sizes.json"
-
-    print(filepath_sizes)
-    print(filepath_sizes.exists())
-
-    # Load previous file sizes
-    if filepath_sizes.exists():
+    # Read the json containing file sizes
+    filepath_sizes = os.path.join(folder_path, "sizes.json")
+    if os.path.exists(filepath_sizes):
         with open(filepath_sizes, "r") as json_file:
-            sizes = {Path(k): v for k, v in json.load(json_file).items()}
+            sizes = json.load(json_file)
     else:
-        sizes = {}
-
-    print(sizes)
+        sizes = dict()
 
-    # Extract the existing paths from the Orange Data Table
+    # Extract the existing file names from the Orange Data Table
     if table:
-        # Orange stores metas as strings → turn them into Paths
-        existing_paths = {Path(str(p)).resolve() for p in table[:, "path"].metas.flatten()}
+        existing_paths = set(table[:, "path"].metas.flatten())  # Extract names from the table
     else:
         existing_paths = set()
 
+
+    # Walk through the folder and its subfolders
     new_files = []
+    for root, _, files in os.walk(folder_path):
+        for file in files:
+            # Check if the file has a supported extension
+            if os.path.splitext(file)[1].lower() in supported_extensions:
+                # Add the file if it is not already in the table
+                filepath = os.path.join(root, file).replace("\\","/")
+                if filepath not in existing_paths:
+                    new_files.append(filepath)
+                    sizes[filepath] = os.path.getsize(filepath)
+                # If the file is in the table, verify if the file has been modified (comparing the size)
+                else:
+                    new_size = os.path.getsize(filepath)
+                    if filepath not in sizes.keys():
+                        sizes[filepath] = new_size
+                    else:
+                        old_size = sizes[filepath]
+                        if old_size != new_size:
+                            new_files.append(filepath)
+                            table = remove_from_table(filepath, table)
+                            sizes[filepath] = new_size
+    with open(filepath_sizes, "w") as json_file:
+        json.dump(sizes, json_file, indent=4)
+    return new_files
 
-    # Walk through the folder and subfolders
-    for file in folder_path.rglob("*"):
-        if file.suffix.lower() in supported_extensions:
-            file = file.resolve()
-            size = file.stat().st_size
 
-            if file not in existing_paths:
-                # New file
-                new_files.append(str(file))
-                sizes[Path(ntpath.basename(file))] = size
-            else:
-                # File already in table: check if size changed
-                print("File: ", Path(ntpath.basename(file)))
-                old_size = sizes.get(Path(ntpath.basename(file)))
-                print(old_size)
-                if old_size is None or old_size != size:
-                    new_files.append(str(file))
-                    table = remove_from_table(file, table)
-                    sizes[Path(ntpath.basename(file))] = size
+def remove_from_table(filepath, table):
+    filtered_table = Table.from_list(domain=table.domain,
+                                      rows=[row for row in table if row["path"].value != filepath])
+    return filtered_table
 
 
-    # Save updated sizes.json (keys must be strings for JSON)
-    with open(filepath_sizes, "w") as json_file:
-        json.dump({str(k): v for k, v in sizes.items()}, json_file, indent=4)
+def check_for_embeddings(folder_path):
+    """
+    Check for an embeddings.pkl file in a given folder. Return its content if it exists.
 
-    return new_files
+    Parameters:
+        folder_path (str): The path to the folder where embeddings.pkl may exist.
+
+    Returns:
+        Table or None: The content of embeddings.pkl.
+    """
+    filepaths = [os.path.join(folder_path, "embeddings_question.pkl"),
+                 os.path.join(folder_path, "embeddings.pkl")]
+    for filepath in filepaths:
+        if os.path.exists(filepath):
+            data = Table.from_file(filepath)
+            return data
+    else:
+        return None
 
 
-def remove_from_table(filepath, table):
+def load_documents_in_table(table, progress_callback=None, argself=None):
     """
-    Remove rows from the Orange table where 'path' matches the given filepath.
+    Load the text content of each document listed in a table and add it
+    as a new column "content".
+
+    :param table: Orange.data.Table containing file paths in a column named "path".
+    :return: Orange.data.Table with an added meta column "content" containing the extracted text.
     """
-    filepath = Path(filepath).resolve()
-
-    filtered_table = Table.from_list(
-        domain=table.domain,
-        rows=[
-            row for row in table
-            if Path(str(row["path"].value)).resolve() != filepath
-        ]
-    )
-    return filtered_table
+    # Make a copy of the table to avoid modifying the original
+    data = table.copy()
+
+    # List to store text from each document
+    texts = []
+    names = []
+    # Iterate over all rows in the table
+    for i, row in enumerate(data):
+        # Get file path from the "path" column
+        filepath = row["path"].value
+        # Get text and name
+        name = Path(filepath).name
+        text = extract_text(filepath)
+        # Store results
+        names.append(name)
+        texts.append(text)
+        # Update progress if a callback is provided
+        if progress_callback is not None:
+            progress_value = float(100 * (i + 1) / len(data))
+            progress_callback(progress_value)
+        # Check if processing should be stopped
+        if argself is not None and getattr(argself, "stop", False):
+            break
+
+    # Create a StringVariable for the new column
+    var_content = StringVariable("content")
+    var_name = StringVariable("name")
+
+    # Add the column as a meta-column in the table
+    data = data.add_column(variable=var_name, data=names, to_metas=True)
+    data = data.add_column(variable=var_content, data=texts, to_metas=True)
+    return data
+
 
 
 def extract_text(filepath):
@@ -177,11 +192,13 @@ def extract_text(filepath):
             return extract_text_from_pdf(filepath)
         elif file_extension == ".docx":
             return extract_text_from_docx(filepath)
+        elif file_extension in [".txt", ".md"]:
+            return extract_text_from_txt(filepath)
         else:
-            raise ValueError("Format de fichier non supporté. Utilisez un fichier PDF ou DOCX.")
+            return "ERROR: Unsupported file format. Please use a .pdf, .docx, .txt, or .md file."
     except Exception as e:
         print(f"Erreur lors de l'extraction de texte depuis {filepath}: {e}")
-        return "Extraction Error"
+        return f"ERROR: Extraction Error ({e})"
 
 
 def extract_text_from_pdf(pdf_path):
@@ -205,7 +222,7 @@ def extract_text_from_pdf(pdf_path):
         return extracted_text
     except Exception as e:
         print(f"Erreur lors de l'extraction de texte depuis {pdf_path}: {e}")
-        return "Extraction Error"
+        return f"ERROR: Extraction Error ({e})"
 
 
 def extract_text_from_docx(docx_path):
@@ -250,13 +267,20 @@ def extract_text_from_docx(docx_path):
                 row_text = [cell.text.strip() for cell in row.cells]  # Extrait le texte de chaque cellule
                 table_text.append("\t".join(row_text))  # Sépare les colonnes par des tabulations
             extracted_text.append("\n".join(table_text))  # Ajoute le tableau sous forme de texte
-
         return "\n".join(filter(None, extracted_text))  # Retourne le texte en filtrant les vides
 
     except Exception as e:
         print(f"Erreur lors de l'extraction de texte depuis {docx_path}: {e}")
-        return "Extraction Error"
+        return f"ERROR: Extraction Error ({e})"
+
 
+def extract_text_from_txt(filepath):
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return f.read()
+    except Exception as e:
+        print(f"Erreur lors de l'extraction de texte depuis {filepath}: {e}")
+        return f"ERROR: Extraction Error ({e})"
 
 
 def get_pages_of_extract(pdf_path, extract):

{aait-2.2.3 → aait-2.2.5}/orangecontrib/AAIT/utils/MetManagement.py

@@ -1368,6 +1368,19 @@ def write_file_time(path):
     except Exception as e:
         print(f"Error creating .ok file: {e}")
     return
+def write_file_arbitrary_time(path,time):
+    time= int(time)
+    time_ok=path[:-4]+".ok"
+    reset_files([time_ok])
+    with open(path, "w") as f:
+        f.write(str(time))
+        f.flush()
+    try:
+        with open(time_ok, "w"):
+            pass
+    except Exception as e:
+        print(f"Error creating .ok file: {e}")
+    return
 
 def read_file_time(path):
     time_ok = path[:-4] + ".ok"