io4it 1.0.0.1__tar.gz → 1.0.0.3__tar.gz

{io4it-1.0.0.1 → io4it-1.0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: io4it
-Version: 1.0.0.1
+Version: 1.0.0.3
 Home-page: 
 Author: 
 Author-email: 

{io4it-1.0.0.1 → io4it-1.0.0.3}/io4it.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: io4it
-Version: 1.0.0.1
+Version: 1.0.0.3
 Home-page: 
 Author: 
 Author-email: 

{io4it-1.0.0.1 → io4it-1.0.0.3}/io4it.egg-info/SOURCES.txt

@@ -9,14 +9,13 @@ io4it.egg-info/requires.txt
 io4it.egg-info/top_level.txt
 orangecontrib/__init__.py
 orangecontrib/IO4IT/__init__.py
-orangecontrib/IO4IT/widgets/OWFileExtSelector.py
+orangecontrib/IO4IT/ocr_function/__init__.py
+orangecontrib/IO4IT/ocr_function/word_converter.py
 orangecontrib/IO4IT/widgets/OWMarkdownizer.py
 orangecontrib/IO4IT/widgets/OWS3Uploader.py
 orangecontrib/IO4IT/widgets/OWS3downloader.py
 orangecontrib/IO4IT/widgets/OWS3list.py
 orangecontrib/IO4IT/widgets/OWSpeechToText.py
-orangecontrib/IO4IT/widgets/OWVisualizationer.py
-orangecontrib/IO4IT/widgets/OWmailLoader.py
 orangecontrib/IO4IT/widgets/OWwordpdf2docx.py
 orangecontrib/IO4IT/widgets/__init__.py
 orangecontrib/IO4IT/widgets/designer/__init__.py

io4it-1.0.0.3/orangecontrib/IO4IT/ocr_function/word_converter.py

@@ -0,0 +1,333 @@
+import os
+import win32com.client
+from pathlib import Path
+import pathlib
+import shutil
+import time
+import pythoncom
+import fitz
+
+if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
+    from Orange.widgets.orangecontrib.AAIT.utils.MetManagement import get_local_store_path,reset_folder
+else:
+    from orangecontrib.AAIT.utils.MetManagement import get_local_store_path,reset_folder
+
+def enable_long_path(path):
+    """Simplifie la gestion des chemins longs sous Windows."""
+    return pathlib.Path(r"\\?\\" + str(path))
+
+def convert_pdf_structure(input_dir: str, output_dir: str,ignore_exsting_out_put=False,progress_callback=None):
+    """
+    return a string with log in  case of error
+    Recursively lists all .pdf and .PDF files in the input directory,
+    replicates the folder structure in the output directory, and
+    creates empty .docx files with the same names.
+
+    Parameters:
+    input_dir (str): Path to the input directory containing PDF files.
+    output_dir (str): Path to the output directory where DOCX files will be created.
+    """
+    error_log=""
+    if os.name != 'nt':
+        error_log="version developped for windows computer "
+        return error_log
+
+    nbre_file = 0
+    for i, data in enumerate(input_dir):
+        input_path = Path(str(input_dir[i]))
+        for pdf_file in input_path.rglob("*.pdf"):
+            nbre_file += 1
+
+    k = 1
+    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. "
+
+        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 0!= convert_pdf_with_temp(str(pdf_file),str(new_file_path)):#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)
+    # 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)
+    return error_log
+
+
+
+
+def convert_pdf_to_docx(pdf_path, docx_path):
+    """
+    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.
+
+    Returns:
+        int: 0 si la conversion a réussi, 1 en cas d'échec.
+    """
+    if not os.path.exists(pdf_path):
+        print(f"Erreur : Le fichier {pdf_path} n'existe pas.")
+        return 1
+
+    try:
+        # Initialiser COM
+        pythoncom.CoInitialize()
+
+        # 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
+        doc = word.Documents.Open(pdf_path, ReadOnly=True, ConfirmConversions=False)
+
+        # Sauvegarder en DOCX
+        doc.SaveAs(docx_path, FileFormat=16)  # 16 = wdFormatDocumentDefault
+        doc.Close(False)
+
+        print(f"Conversion réussie : {docx_path}")
+        return 0
+
+    except Exception as e:
+        print(f"Erreur lors de la conversion : {e}")
+        return 1
+
+    finally:
+        if 'word' in locals():
+            word.Quit()
+
+        # Libérer COM
+        pythoncom.CoUninitialize()
+
+
+def wait_for_file_access(file_path, timeout=10, interval=0.5):
+    """
+    Attendre que le fichier soit accessible en lecture/écriture.
+
+    Args:
+        file_path (str): Chemin du fichier à vérifier.
+        timeout (int): Temps max en secondes avant d'abandonner.
+        interval (float): Temps d'attente entre chaque vérification.
+
+    Returns:
+        bool: True si le fichier est accessible, False sinon.
+    """
+    start_time = time.time()
+
+    while time.time() - start_time < timeout:
+        if os.path.exists(file_path) and os.access(file_path, os.R_OK | os.W_OK):
+            try:
+                with open(file_path, "a"):
+                    pass  # Test d'ouverture en écriture
+                return True
+            except IOError:
+                pass
+
+        time.sleep(interval)  # Attendre avant de réessayer
+
+    print(f"Erreur : Le fichier {file_path} est verrouillé ou inaccessible.")
+    return False
+
+
+
+
+def is_pdf_a4(pdf_path: str) -> bool:
+    """
+    Vérifie si toutes les pages du PDF sont au format A4.
+    Retourne True si toutes les pages sont en A4, False sinon.
+    """
+    A4_WIDTH_PTS = 595  # Largeur A4 en points (approx. 210mm)
+    A4_HEIGHT_PTS = 842  # Hauteur A4 en points (approx. 297mm)
+    TOLERANCE = 5  # Marge de tolérance en points
+
+    try:
+        doc = fitz.open(pdf_path)
+        if len(doc) == 0:
+            return False
+
+        for page in doc:
+            width, height = page.rect.width, page.rect.height
+            if not (
+                    (abs(width - A4_WIDTH_PTS) <= TOLERANCE and abs(height - A4_HEIGHT_PTS) <= TOLERANCE) or
+                    (abs(width - A4_HEIGHT_PTS) <= TOLERANCE and abs(height - A4_WIDTH_PTS) <= TOLERANCE)
+            ):
+                return False
+    except Exception as e:
+        print("is A4?",e)
+        return False
+    return True
+
+def convert_pdf_to_a4(input_pdf, output_pdf):
+    try:
+        # Dimensions A4 en points
+        a4_width, a4_height = fitz.paper_size("a4")
+        a3_width, a3_height = fitz.paper_size("a3")
+        doc = fitz.open(input_pdf)
+        new_doc = fitz.open()
+
+        for page in doc:
+            page_w, page_h = page.rect.width, page.rect.height
+
+            # Si la page est déjà en A4 (tolérance de 1 point)
+            if abs(page_w - a4_width) < 1 and abs(page_h - a4_height) < 1:
+                new_doc.insert_pdf(doc, from_page=page.number, to_page=page.number)
+                continue
+
+            # Si la page est déjà en A3 (tolérance de 1 point)
+            if abs(page_w - a3_width) < 1 and abs(page_h - a3_height) < 1:
+                new_doc.insert_pdf(doc, from_page=page.number, to_page=page.number)
+                continue
+
+            # Définition de la transformation selon l'orientation de la page
+            if page_w > page_h:  # Paysage
+                # Après rotation, les dimensions seront inversées (largeur <-> hauteur)
+                effective_scale = min(a4_width / page_h, a4_height / page_w)
+                matrix = fitz.Matrix(effective_scale, effective_scale)
+                # Rotation de 90° et translation pour repositionner le contenu
+                matrix = matrix.prerotate(90).pretranslate(page_h * effective_scale, 0)
+            else:  # Portrait
+                effective_scale = min(a4_width / page_w, a4_height / page_h)
+                matrix = fitz.Matrix(effective_scale, effective_scale)
+
+            # Générer le pixmap à la résolution finale souhaitée
+            pix = page.get_pixmap(matrix=matrix)
+
+            # Calcul du centrage sur la page A4
+            new_img_w, new_img_h = pix.width, pix.height
+            x_offset = (a4_width - new_img_w) / 2
+            y_offset = (a4_height - new_img_h) / 2
+
+            # Créer la nouvelle page et y insérer l'image
+            new_page = new_doc.new_page(width=a4_width, height=a4_height)
+            new_page.insert_image(
+                fitz.Rect(x_offset, y_offset, x_offset + new_img_w, y_offset + new_img_h),
+                pixmap=pix
+            )
+        new_doc.save(output_pdf)
+        new_doc.close()
+        doc.close()
+        return 0
+    except:
+        return 1
+
+
+def write_two_strings_to_file(file_path: str,string1: str, string2: str):
+    """
+    Writes two strings to a file, one per line, handling errors gracefully.
+
+    :param string1: The first string to write.
+    :param string2: The second string to write.
+    :param file_path: The path where the file should be saved.
+    """
+    try:
+        file = open(file_path, 'w', encoding='utf-8')
+        file.write(string1 + "\n")
+        file.write(string2 )
+        print(f"Successfully written to {file_path}")
+    except IOError as e:
+        print(f"Error writing to file: {e}")
+        return 1
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+        return 1
+    finally:
+        file.close()
+    return 0
+
+
+def convert_pdf_with_temp(temp_pdf, output_path):
+    """
+    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.
+    """
+    pdf_path = enable_long_path(os.path.abspath(temp_pdf))
+    output_path = enable_long_path(os.path.abspath(output_path))
+    output_dir = output_path.parent
+
+    if not pdf_path.exists():
+        print(f"Le fichier {pdf_path} n'existe pas.")
+        return 1
+
+    # Créer le dossier de sortie s'il n'existe pas
+    if not output_dir.exists():
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        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)
+            return 1
+        # Création du dossier temporaire
+        temp_pdf = os.path.join(dest_dir, "input_toto.pdf")
+        temp_docx = os.path.join(dest_dir, "input_toto.docx")
+
+        print(dest_dir+"conversion_en_cours.txt")
+        print("######################################")
+        if 0!=write_two_strings_to_file(dest_dir+"conversion_en_cours.txt",str(pdf_path),str(output_path)):
+            print("error writing ",dest_dir+"conversion_en_cours.txt")
+            return 1
+        # Copie du fichier source vers le dossier temporaire
+        shutil.copy2(pdf_path, temp_pdf)
+        wait_for_file_access(temp_pdf)
+
+        if is_pdf_a4(temp_pdf)==False:
+            temp_pdf2 = os.path.join(dest_dir, "input_totoA4.pdf")
+            if 0!=convert_pdf_to_a4(temp_pdf,temp_pdf2):
+                print("erreur au resize du pdf")
+                return 1
+            temp_pdf=temp_pdf2
+            wait_for_file_access(temp_pdf)
+            time.sleep(1)
+        result=0
+        # Conversion du PDF en DOCX
+        for _ in range(4):
+            time.sleep(1)
+            result = convert_pdf_to_docx(str(temp_pdf), str(temp_docx))
+            if result==0:
+                break
+        if result == 0:
+            # Copie du fichier converti vers la destination finale
+            shutil.copy2(temp_docx, output_path)
+            print(f"recopie réussie : {output_path}")
+
+            # Supprimer les fichiers temporaires après le déplacement
+            # if temp_docx.exists():
+            #     temp_docx.unlink()
+            # if temp_pdf.exists():
+            #     temp_pdf.unlink()
+            return 0
+        else:
+            print("Erreur lors de la conversion.")
+            return 1
+
+    except Exception as e:
+        print(f"Erreur : {e}")
+        return 1
+
+
+

{io4it-1.0.0.1 → io4it-1.0.0.3}/setup.py

@@ -36,7 +36,7 @@ class CustomInstall(install):
 
 # Configuration
 NAME = "io4it"
-VERSION = "1.0.0.1"
+VERSION = "1.0.0.3"
 
 INSTALL_REQUIRES = [
     "boto3",

io4it-1.0.0.1/orangecontrib/IO4IT/widgets/OWFileExtSelector.py

@@ -1,279 +0,0 @@
-import os
-import subprocess
-import tempfile
-
-from PyQt5.QtWidgets import QPushButton, QListWidget, QListWidgetItem, QApplication, QLabel, QWidget, QVBoxLayout
-from PyQt5.QtGui import QFont
-from PyQt5.QtCore import Qt, QThread, pyqtSignal, QObject
-from PyQt5 import uic
-from Orange.widgets.widget import OWWidget, Output, Input
-from Orange.data import Table, Domain, StringVariable
-from Orange.widgets.settings import Setting
-
-
-class FileDialogWorker(QObject):
-    finished = pyqtSignal(list)
-
-    def __init__(self, ps_filter):
-        super().__init__()
-        self.ps_filter = ps_filter
-
-    def run(self):
-        from PyQt5.QtWidgets import QApplication
-        screen = QApplication.primaryScreen().geometry()
-        x = screen.x() + (screen.width() // 2) - 400
-        y = screen.y() + (screen.height() // 2) - 200
-
-        ps_code = f"""
-            Add-Type -AssemblyName System.Windows.Forms
-            
-            # Créer une nouvelle fenêtre parent invisible
-            $parentForm = New-Object System.Windows.Forms.Form -Property @{{ 
-                Size = New-Object System.Drawing.Size(0,0) # Taille minimale
-                StartPosition = 'CenterScreen'
-                TopMost = $true
-                ShowInTaskbar = $false
-                FormBorderStyle = 'None'
-                Opacity = 0 # Rendre la fenêtre totalement transparente
-            }}
-            
-            # Créer la boîte de dialogue de sélection de fichiers
-            $openFileDialog = New-Object System.Windows.Forms.OpenFileDialog -Property @{{ 
-                Filter = "{self.ps_filter}"
-                Multiselect = $true
-            }}
-            
-            # Afficher la boîte de dialogue en tant que fenêtre enfant de $parentForm
-            $result = $openFileDialog.ShowDialog($parentForm)
-            
-            # Traiter les fichiers sélectionnés
-            if ($result -eq [System.Windows.Forms.DialogResult]::OK) {{
-                $selectedFiles = $openFileDialog.FileNames
-                foreach ($file in $selectedFiles) {{
-                    Write-Output $file
-                }}
-            }}
-            
-            # Fermer la fenêtre parent
-            $parentForm.Close()
-        """
-
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".ps1", mode="w", encoding="utf-8") as f:
-            f.write(ps_code)
-            ps_path = f.name
-
-        result = subprocess.run(
-            ["powershell", "-ExecutionPolicy", "Bypass", "-File", ps_path],
-            capture_output=True, text=True
-        )
-        os.unlink(ps_path)
-
-        file_paths = [line.strip() for line in result.stdout.strip().splitlines() if line.strip()]
-        self.finished.emit(file_paths)
-
-
-class OWFileExtSelector(OWWidget):
-    name = "File Extension Selector"
-    description = "Select multiple extensions and files"
-    icon = "icons/file_extensor.png"
-    if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
-        icon = "icons_dev/file_extensor.png"
-    category = "AAIT - Input"
-    gui_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "designer/ow_file_ext_selector.ui")
-    priority = 10
-
-    selected_extensions = Setting(["*.txt"])
-    selected_paths = Setting([])
-
-    class Inputs:
-        in_data = Input("Data", Table)
-
-    class Outputs:
-        data = Output("Data", Table)
-
-    def __init__(self):
-        super().__init__()
-        self.in_data = None
-        self.overlay = None
-
-        uic.loadUi(self.gui_path, self)
-
-        self.extension_list = self.findChild(QListWidget, "listExtensions")
-        self.file_button = self.findChild(QPushButton, "fileButton")
-
-        self.extension_list.setSelectionMode(QListWidget.MultiSelection)
-        self.populate_extensions()
-        self.restore_selected_extensions()
-
-        self.file_button.clicked.connect(self.select_files)
-        self.extension_list.itemSelectionChanged.connect(self.update_settings)
-
-    def loadSettings(self):
-        super().loadSettings()
-
-    def update_settings(self):
-        self.selected_extensions = self.get_selected_extensions()
-        self.saveSettings()
-
-    def restore_selected_extensions(self):
-        for i in range(self.extension_list.count()):
-            item = self.extension_list.item(i)
-            if item.flags() != Qt.NoItemFlags:
-                ext = item.data(Qt.UserRole)
-                if ext in self.selected_extensions:
-                    item.setSelected(True)
-        self.update_settings()
-
-    def restore_selected_paths(self):
-        if self.selected_paths:
-            self.commit_paths()
-
-    def populate_extensions(self):
-        def add_category(label):
-            item = QListWidgetItem(label)
-            item.setFlags(Qt.NoItemFlags)
-            font = QFont()
-            font.setBold(True)
-            item.setFont(font)
-            item.setForeground(Qt.gray)
-            self.extension_list.addItem(item)
-
-        def add_extension(label, ext):
-            item = QListWidgetItem(f"  {label}")
-            item.setData(Qt.UserRole, ext)
-            self.extension_list.addItem(item)
-
-        extensions = {
-            "Documents": [
-                ("Text files (*.txt)", "*.txt"),
-                ("Word documents (*.docx)", "*.docx"),
-                ("PDF files (*.pdf)", "*.pdf"),
-                ("Markdown (*.md)", "*.md"),
-            ],
-            "Tableurs": [
-                ("Excel files (*.xlsx)", "*.xlsx"),
-                ("CSV files (*.csv)", "*.csv"),
-            ],
-            "Images": [
-                ("JPEG images (*.jpg *.jpeg)", "*.jpg *.jpeg"),
-                ("PNG images (*.png)", "*.png"),
-                ("GIF images (*.gif)", "*.gif"),
-                ("SVG images (*.svg)", "*.svg"),
-            ],
-            "Audio": [
-                ("MP3 (*.mp3)", "*.mp3"),
-                ("WAV (*.wav)", "*.wav"),
-            ],
-            "Vidéo": [
-                ("MP4 (*.mp4)", "*.mp4"),
-                ("MKV (*.mkv)", "*.mkv"),
-            ],
-            "Archives": [
-                ("ZIP (*.zip)", "*.zip"),
-                ("RAR (*.rar)", "*.rar"),
-                ("7-Zip (*.7z)", "*.7z"),
-            ],
-            "Code": [
-                ("Python (*.py)", "*.py"),
-                ("JSON (*.json)", "*.json"),
-                ("HTML (*.html)", "*.html"),
-                ("XML (*.xml)", "*.xml"),
-                ("OWS (*.ows)", "*.ows"),
-            ],
-            "Autres": [
-                ("All files (*.*)", "*.*")
-            ]
-        }
-
-        for category, items in extensions.items():
-            add_category(category)
-            for label, ext in items:
-                add_extension(label, ext)
-
-    def get_selected_extensions(self):
-        selected = [
-            item.data(Qt.UserRole)
-            for item in self.extension_list.selectedItems()
-            if item.flags() != Qt.NoItemFlags
-        ]
-        return selected
-
-    def show_overlay(self):
-        if not self.overlay:
-            self.overlay = QWidget()
-            self.overlay.setWindowFlags(
-                Qt.FramelessWindowHint |
-                Qt.Tool  # ← PAS de WindowStaysOnTopHint
-            )
-            self.overlay.setAttribute(Qt.WA_TranslucentBackground)
-            self.overlay.setAttribute(Qt.WA_TransparentForMouseEvents)
-            self.overlay.setStyleSheet("background-color: rgba(0, 0, 0, 150);")
-
-            layout = QVBoxLayout(self.overlay)
-            message = QLabel("Veuillez sélectionner un fichier...")
-            message.setStyleSheet("color: white; font-size: 24px;")
-            message.setAlignment(Qt.AlignCenter)
-            layout.addWidget(message)
-            self.overlay.setLayout(layout)
-
-            screen_geometry = QApplication.primaryScreen().geometry()
-            self.overlay.setGeometry(screen_geometry)
-            self.overlay.show()
-
-            QApplication.processEvents()
-
-    def hide_overlay(self):
-        if self.overlay:
-            self.overlay.hide()
-            self.overlay = None
-
-    def select_files(self):
-        self.show_overlay()
-
-        selected_exts = self.get_selected_extensions()
-        if not selected_exts:
-            self.warning("Please select at least one extension.")
-            self.hide_overlay()
-            return
-
-        all_patterns = ";".join(selected_exts)
-        ps_filter = f"Supported files ({all_patterns})|{all_patterns}"
-
-        self.thread = QThread()
-        self.worker = FileDialogWorker(ps_filter)
-        self.worker.moveToThread(self.thread)
-
-        self.thread.started.connect(self.worker.run)
-        self.worker.finished.connect(self.on_files_selected)
-        self.worker.finished.connect(self.thread.quit)
-        self.worker.finished.connect(self.worker.deleteLater)
-        self.thread.finished.connect(self.thread.deleteLater)
-
-        self.thread.start()
-
-    def on_files_selected(self, file_paths):
-        self.hide_overlay()
-        if file_paths:
-            self.selected_paths = file_paths
-            self.commit_paths()
-
-    def commit_paths(self):
-        var = StringVariable("file_path")
-        domain = Domain([], metas=[var])
-        table = Table(domain, [[p] for p in self.selected_paths])
-        self.Outputs.data.send(table)
-
-    @Inputs.in_data
-    def set_input_data(self, data):
-        self.in_data = data
-
-    def handleNewSignals(self):
-        pass
-
-
-if __name__ == "__main__":
-    import sys
-    app = QApplication(sys.argv)
-    ow = OWFileExtSelector()
-    ow.show()
-    sys.exit(app.exec_())

io4it-1.0.0.1/orangecontrib/IO4IT/widgets/OWVisualizationer.py

@@ -1,73 +0,0 @@
-import os
-from PyQt5.QtWidgets import QPushButton, QListWidget, QListWidgetItem, QApplication, QWidget, QVBoxLayout, QSizePolicy
-from PyQt5.QtGui import QFont
-from PyQt5.QtCore import Qt
-from PyQt5 import uic
-from AnyQt.QtWidgets import QFileDialog
-from Orange.widgets.widget import OWWidget, Output, Input
-from Orange.data import Table, Domain, StringVariable
-from Orange.widgets.settings import Setting
-
-if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
-    from orangecontrib.AAIT.utils.import_uic import uic
-    from orangecontrib.AAIT.utils import SimpleDialogQt
-    from orangecontrib.AAIT.utils.MetManagement import get_local_store_path, GetFromRemote
-else:
-    from orangecontrib.AAIT.utils.import_uic import uic
-    from orangecontrib.AAIT.utils import SimpleDialogQt
-    from orangecontrib.AAIT.utils.MetManagement import get_local_store_path, GetFromRemote
-
-from PyQt5.QtWebEngineWidgets import QWebEngineView
-from PyQt5.QtCore import QUrl
-
-
-class OWFileExtSelector(OWWidget):
-    name = "Javascript visualization"
-    description = "Select multiple extensions and files"
-    icon = "icons/visualizationer.png"
-    if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
-        icon = "icons_dev/visualizationer.png"
-    category = "AAIT - Input"
-    gui_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "designer/owvisualizationer.ui")
-    priority = 10
-
-
-    class Inputs:
-        in_data = Input("Data", Table)
-
-    class Outputs:
-        data = Output("Data", Table)
-
-    def __init__(self):
-        super().__init__()
-        self.in_data = None
-
-        # Load UI
-        uic.loadUi(self.gui_path, self)
-
-        self.web_frame = self.findChild(QWidget, "webFrame")  # Doit exister dans le .ui
-        self.web_view = QWebEngineView(self.web_frame)
-        self.web_view.setMinimumSize(400, 300)
-        self.web_view.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-
-        # Crée un layout si nécessaire
-        layout = QVBoxLayout(self.web_frame)
-        layout.setContentsMargins(0, 0, 0, 0)
-        layout.addWidget(self.web_view)
-
-        # Charge ton fichier HTML local
-        html_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "designer/chart.html"))
-        self.web_view.load(QUrl.fromLocalFile(html_path))
-
-
-    @Inputs.in_data
-    def set_input_data(self, data):
-        self.in_data = data
-
-
-if __name__ == "__main__":
-    import sys
-    app = QApplication(sys.argv)
-    ow = OWFileExtSelector()
-    ow.show()
-    sys.exit(app.exec_())

io4it-1.0.0.1/orangecontrib/IO4IT/widgets/OWmailLoader.py

@@ -1,156 +0,0 @@
-import os
-import sys
-from Orange.data import Domain, StringVariable, Table
-import Orange.data
-from AnyQt.QtWidgets import QApplication
-from Orange.widgets import widget
-from Orange.widgets.utils.signals import Input, Output
-
-
-if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
-    from Orange.widgets.orangecontrib.AAIT.utils import thread_management
-    from Orange.widgets.orangecontrib.AAIT.utils.import_uic import uic
-    from Orange.widgets.orangecontrib.AAIT.utils.initialize_from_ini import apply_modification_from_python_file
-else:
-    from orangecontrib.AAIT.utils import thread_management
-    from orangecontrib.AAIT.utils.import_uic import uic
-    from orangecontrib.AAIT.utils.initialize_from_ini import apply_modification_from_python_file
-
-
-@apply_modification_from_python_file(filepath_original_widget=__file__)
-class OWMailLoader(widget.OWWidget):
-    name = "OWMailLoader"
-    description = "Load a mail from AAIT format"
-    icon = ""
-    #if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
-    #    icon = "icons_dev/owqueryllm.svg"
-    gui = os.path.join(os.path.dirname(os.path.abspath(__file__)), "designer/owmailloader.ui")
-    want_control_area = True
-    priority = 9999
-
-    class Inputs:
-        data = Input("Data", Orange.data.Table)
-
-    class Outputs:
-        data_out_all_dir = Output("Data Out All Dir", Orange.data.Table)
-        data_out_nothing_to_do=Output("Data Out Nothing to Do", Orange.data.Table)
-
-    @Inputs.data
-    def set_data(self, in_data):
-        self.valid_folders=[]
-        input_dir_path=""
-        self.error("")
-        if in_data is None:
-            return
-        if not "input_dir" in in_data.domain:
-            self.error("need input_dir in input data domain" )
-            return
-        if len(in_data)!=1:
-            self.error("in data need to be exactly 1 line" )
-            return
-        input_dir_path=str(in_data[0]["input_dir"].value)
-        input_dir_path.replace ("\\","/")
-
-        self.valid_folders=self.get_valid_folders(input_dir_path)
-        if len(self.valid_folders)==0:
-            self.send_nothing_to_do()
-            return
-        print( self.valid_folders)
-        self.run()
-
-
-    def __init__(self):
-        super().__init__()
-        # Qt Management
-        self.valid_folders=[]
-        self.can_run = True
-        self.setFixedWidth(700)
-        self.setFixedHeight(500)
-        uic.loadUi(self.gui, self)
-
-
-
-
-        # # Data Management
-        self.thread = None
-
-        # Custom updates
-        self.post_initialized()
-
-
-
-    def get_valid_folders(self,input_dir_path):
-        in_dir = os.path.join(input_dir_path, "in")
-
-        # Étape 1 : Vérifier si le dossier existe
-        if not os.path.isdir(in_dir):
-            print(f"Dossier introuvable : {in_dir}")
-            return []  # ou `return` selon ton besoin
-
-        # Étape 2 : Parcourir les sous-dossiers
-        valid_folders = []
-        for name in os.listdir(in_dir):
-            full_path = os.path.join(in_dir, name)
-            if os.path.isdir(full_path):
-                mail_ok_path = os.path.join(full_path, "mail.ok")
-                if os.path.isfile(mail_ok_path):
-                    valid_folders.append(full_path.replace("\\","/"))
-
-        return valid_folders
-    def send_nothing_to_do(self):
-
-        # Définir une variable texte comme méta-attribut
-        text_meta = StringVariable("nothing to do")
-
-        # Créer un domaine sans variables principales, avec une méta
-        domain = Domain([], metas=[text_meta])
-
-        # Créer la table avec Table.from_list
-        data_table = Table.from_list(domain, [["nothing"]])
-        self.Outputs.data_out_nothing_to_do.send(data_table)
-
-    def run(self):
-        # Définir les variables de texte
-        var_mail_txt = StringVariable("mail_path")
-        var_pj_list = StringVariable("pj_files")
-
-        # Définir le domaine avec deux colonnes texte
-        domain = Domain([], metas=[var_mail_txt, var_pj_list])
-
-        # Construire les lignes de données
-        rows = []
-        for folder in self.valid_folders:
-            # Chemin vers mail.txt
-            mail_path = os.path.join(folder, "mail.txt")
-
-            # Chemin vers le sous-dossier "pj"
-            pj_path = os.path.join(folder, "pj")
-
-            # Lister les fichiers dans pj (ou chaîne vide s'il n'existe pas)
-            if os.path.isdir(pj_path):
-                files = os.listdir(pj_path)
-            else:
-                files = []
-
-            # Convertir la liste de fichiers en chaîne (ex : "file1.pdf, file2.docx")
-            files_str = ", ".join(files)
-            files_str='['+files_str+']'
-            # Ajouter la ligne
-            rows.append([mail_path, files_str])
-
-        # Créer la table Orange
-        data_table = Table.from_list(domain, rows)
-
-        # Afficher la table
-        self.Outputs.data_out_all_dir.send(data_table)
-
-    def post_initialized(self):
-        pass
-
-if __name__ == "__main__":
-    app = QApplication(sys.argv)
-    data = Orange.data.Table("C:/toto_ta_ta_titi/input.tab")
-    my_widget = OWMailLoader()
-    my_widget.show()
-    my_widget.set_data(data)
-    app.exec_()