IO4IT 4.0.7__tar.gz → 4.0.9__tar.gz

io4it-4.0.9/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: io4it
+Version: 4.0.9
+Summary: UNKNOWN
+Home-page: 
+Author: 
+Author-email: 
+License: UNKNOWN
+Keywords: orange3 add-on
+Platform: UNKNOWN
+
+UNKNOWN

io4it-4.0.9/io4it.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: io4it
+Version: 4.0.9
+Summary: UNKNOWN
+Home-page: 
+Author: 
+Author-email: 
+License: UNKNOWN
+Keywords: orange3 add-on
+Platform: UNKNOWN
+
+UNKNOWN

{io4it-4.0.7 → io4it-4.0.9}/orangecontrib/IO4IT/toolViews/key_manager_ui.py

@@ -155,7 +155,7 @@ class KeyManagerUI(QtWidgets.QDialog):
         if func_name=="Create / overwrite api key":
             self.textDetails.setText("{\n'service': 'service_name',\n'api_key': 'api_key',\n'description': 'this_is_a_description'\n}")
         elif func_name=="Create / overwrite imap4_ssl configuration":
-            self.textDetails.setText("{\n'agent': 'service_name',\n'alias': 'alias_name',\n'domain': '@domain.com',\n'interval_second': 1,\n'password': 'password'\n}")
+            self.textDetails.setText("{\n'agent': 'service_name',\n'alias': 'alias_name',\n'domain': '@domain.com',\n'interval_second': 1,\n'password': 'password',\n'server_imap': 'imap.gmail.com',\n'port_imap': 993,\n'server_smtp': 'smtp.gmail.com',\n'port_smtp': 587\n}")
         elif func_name=="Create / overwrite nxp configuration":
             self.textDetails.setText("{\n'dossier_node_id': 'bode_key',\n'serveur': 'servor_adress',\n'username': 'my_username',\n'password': 'password',\n'description': 'this is a description'\n}")
         elif func_name=="Create / overwrite owa configuration":

{io4it-4.0.7 → io4it-4.0.9}/orangecontrib/IO4IT/utils/keys_manager.py

@@ -35,7 +35,7 @@ def ask_secure():
         if resp in ("n", "no"):
             return False
         print("Please enter Y or N.")
-#  FONCTIOSN D'OBFUSCATION GÉNÉRALES & CHEMIN
+# FONCTIONS D'OBFUSCATION GÉNÉRALES & CHEMIN
 # Fonction pour générer une clé simple à partir du nom d'utilisateur
 def get_user_key():
     try:
@@ -115,7 +115,7 @@ def lire_list_email(chemin_fichier):
         return None
 
 
-def enregistrer_config_imap4_ssl(agent, my_domain, password, interval_second, alias=""):
+def enregistrer_config_imap4_ssl(agent, my_domain, password, interval_second, alias="", server_imap="imap.gmail.com", port_imap=993, server_smtp="smtp.gmail.com", port_smtp=587):
     try:
         dossier = get_keys_dir("IMAP4_SSL")
         # Crée le dossier s'il n'existe pas
@@ -137,7 +137,11 @@ def enregistrer_config_imap4_ssl(agent, my_domain, password, interval_second, al
             "domain": my_domain,
             "interval_second": interval_second,
             "password_encrypted": mdp_chiffre,
-            "alias": alias
+            "alias": alias,
+            "server_imap": server_imap,
+            "port_imap": port_imap,
+            "server_smtp": server_smtp,
+            "port_smtp": port_smtp
         }
 
         # Écriture du fichier
@@ -151,7 +155,7 @@ def enregistrer_config_imap4_ssl(agent, my_domain, password, interval_second, al
         print(f"❌ Erreur lors de l'enregistrement : {e}")
         return 1
 
-def enregistrer_config_imap4_ssl_secure(agent, my_domain, password, interval_second, alias=""):
+def enregistrer_config_imap4_ssl_secure(agent, my_domain, password, interval_second, alias="", server_imap="imap.gmail.com", port_imap=993, server_smtp="smtp.gmail.com", port_smtp=587):
     try:
         dossier = get_keys_dir("IMAP4_SSL")
         # Crée le dossier s'il n'existe pas
@@ -171,7 +175,11 @@ def enregistrer_config_imap4_ssl_secure(agent, my_domain, password, interval_sec
             "domain": my_domain,
             "interval_second": interval_second,
             "password": password,
-            "alias": alias
+            "alias": alias,
+            "server_imap": server_imap,
+            "port_imap": port_imap,
+            "server_smtp": server_smtp,
+            "port_smtp": port_smtp
         }
         sm = secret_manager.SecretManager(service_name)
         sm.store(contenu,overwrite=True)
@@ -326,7 +334,6 @@ def lire_config_imap4_ssl_dict_sec(chemin_fichier):
 
 # Fonction pour lire le fichier de configuration et déchiffrer le mot de passe
 def lire_config_imap4_ssl(chemin_fichier):
-    # renvoie une liste =["agent","domain",mdp,"interval_second"]
     if len(chemin_fichier)<5:
         print(f"❌ Error path not correct {chemin_fichier}")
         return None
@@ -341,7 +348,11 @@ def lire_config_imap4_ssl(chemin_fichier):
                 contenu["domain"],
                 contenu["password"],
                 int(contenu["interval_second"]),
-                contenu.get("alias", "")
+                contenu.get("alias", ""),
+                contenu.get("server_imap", "imap.gmail.com"),
+                contenu.get("port_imap", 993),
+                contenu.get("server_smtp", "smtp.gmail.com"),
+                contenu.get("port_smtp", 587)
             ]
 
         except Exception as e:
@@ -363,7 +374,11 @@ def lire_config_imap4_ssl(chemin_fichier):
             contenu["domain"],
             mdp_dechiffre,
             int(contenu["interval_second"]),
-            contenu.get("alias", "")
+            contenu.get("alias", ""),
+            contenu.get("server_imap", "imap.gmail.com"),
+            contenu.get("port_imap", 993),
+            contenu.get("server_smtp", "smtp.gmail.com"),
+            contenu.get("port_smtp", 587)
         ]
     except Exception as e:
         print(f"❌ Erreur lors de la lecture : {e}")
@@ -549,15 +564,19 @@ def enregistrer_config_cli_imap4_ssl():
     print("\n📝 Écriture d’un fichier de configuration :")
     agent = input("🤖 Nom de l’agent : ").strip()
     domaine = input("📨 @domain.com? : ").strip()
+    server_imap = input("📥 Serveur IMAP (ex: imap.nom.com) : ").strip()
+    port_imap = int(input("🔌 Port IMAP (ex: 993) : ").strip())
+    server_smtp = input("📤 Serveur SMTP (ex: smtp.nom.com) : ").strip()
+    port_smtp = int(input("🔌 Port SMTP (ex: 587) : ").strip())
     mdp = input("📨mot de passe? : ").strip()
     interval = int(input("⏱️ Intervalle en secondes : ").strip())
     alias = input("Nom de l'alias : ").strip()
     store = ask_secure()
     if not store:
-        if 0 != enregistrer_config_imap4_ssl(agent, domaine, mdp, interval, alias):
+        if 0 != enregistrer_config_imap4_ssl(agent, domaine, mdp, interval, alias, server_imap, port_imap, server_smtp, port_smtp):
             print("erreur!")
             return
-    if 0 != enregistrer_config_imap4_ssl_secure(agent, domaine, mdp, interval, alias):
+    if 0 != enregistrer_config_imap4_ssl_secure(agent, domaine, mdp, interval, alias, server_imap, port_imap, server_smtp, port_smtp):
         print("erreur!")
         return
 

{io4it-4.0.7 → io4it-4.0.9}/orangecontrib/IO4IT/utils/mail.py

@@ -29,7 +29,6 @@ else:
     from orangecontrib.AAIT.utils import MetManagement
     from orangecontrib.IO4IT.utils import keys_manager
 
-
 def clean_addresses(field,myemail):
     """Retourne une liste d'adresses nettoyées sans ton adresse"""
     if not field:
@@ -37,6 +36,13 @@ def clean_addresses(field,myemail):
     addresses = email.utils.getaddresses([field])
     return [addr for name, addr in addresses if addr.lower() != myemail.lower()]
 
+def get_addresses(field):
+    """Retourne une liste d'adresses nettoyées sans ton adresse"""
+    if not field:
+        return []
+    addresses = email.utils.getaddresses([field])
+    return [addr for name, addr in addresses]
+
 def mail_in_folder(agent_name, type="in"):
     if agent_name is None or agent_name == "":
         print("agent_name doit etre renseigné")
@@ -74,12 +80,15 @@ def mark_as_read(item):
         return False
 
 
-def check_new_emails(offusc_conf_agent,type_co, list_agent_email=[]):
+def check_new_emails(offusc_conf_agent,type_co,list_agent_email=[]):
     if type_co=="IMAP4_SSL":
         try:
-            agent,my_domain,password,interl_seconds,alias=keys_manager.lire_config_imap4_ssl(offusc_conf_agent)
-            myemail=agent + my_domain
-            imap = imaplib.IMAP4_SSL("imap.gmail.com")
+            agent,my_domain,password,interl_seconds,alias,server_imap,port_imap,_,_=keys_manager.lire_config_imap4_ssl(offusc_conf_agent)
+            if(alias and alias != ""):
+                myemail=alias + my_domain
+            else:
+                myemail=agent + my_domain
+            imap = imaplib.IMAP4_SSL(server_imap,port_imap)
             imap.login(myemail, password)
             imap.select("inbox")
             status, messages = imap.search(None, 'UNSEEN')
@@ -110,16 +119,29 @@ def check_new_emails(offusc_conf_agent,type_co, list_agent_email=[]):
 
                             # Expéditeur
                             from_ = msg.get("From")
+
                             # Destinataires
-                            to_emails = clean_addresses(msg.get("To", ""),myemail)
-                            cc_emails = clean_addresses(msg.get("Cc", ""),myemail)
-                            if (to_emails != [] or cc_emails != []) and alias == "":
-                                if myemail not in to_emails or myemail not in cc_emails:
-                                    print(f"l'adresse de reception est un alias : {to_emails}")
-                                    continue
-                            if (to_emails == [] and cc_emails == []) and alias != "":
-                                print(f"l'adresse de reception est un alias : {alias}")
+                            # Je n'ai pas compris la logique
+                            #to_emails = clean_addresses(msg.get("To", ""),myemail)
+                            #cc_emails = clean_addresses(msg.get("Cc", ""),myemail)
+
+                            #if (to_emails != [] or cc_emails != []) and alias == "":
+                            #    if myemail not in to_emails and myemail not in cc_emails:
+                            #        print(f"l'adresse de reception est un alias : {to_emails}")
+                            #        continue
+                            #if (to_emails == [] and cc_emails == []) and alias != "":
+                            #    print(f"l'adresse de reception est un alias : {alias}")
+                            #    continue
+                            to_emails = get_addresses(msg.get("To", ""))
+                            cc_emails = get_addresses(msg.get("Cc", ""))
+                            all_recipients = to_emails + cc_emails
+                            myemail = myemail.lower().strip()
+                            all_recipients = [x.lower().strip() for x in all_recipients]
+                            
+                            if myemail not in all_recipients:
+                                print(f"Le mail n'est pas destiné à {myemail}")
                                 continue
+
                             ## passe en lu si ce n'est pas un alias
                             imap.store(mail_id, '+FLAGS', '\\Seen')
                             # Corps
@@ -634,20 +656,25 @@ def lire_message(chemin_fichier):
     return donnees
 
 
-
-
-def send_mail(expediteur, offusc_conf_agent, destinataire, sujet, contenu_html, piece_jointe_paths=None, serveur="smtp.gmail.com", port=587):
+def send_mail(expediteur, offusc_conf_agent, destinataire, sujet, contenu_html, piece_jointe_paths=None, cc=None, serveur="smtp.gmail.com", port=587):
     msg = EmailMessage()
     msg['From'] = expediteur
     msg['To'] = destinataire
     msg['Subject'] = sujet
 
+    if cc:
+        # Si cc est une liste, on la transforme en chaîne séparée par des virgules
+        if isinstance(cc, list):
+            msg['Cc'] = ", ".join(cc)
+        else:
+            msg['Cc'] = cc
+
     # ✅ Définir le contenu HTML comme contenu alternatif
     msg.set_content("Votre client mail ne supporte pas le HTML.")  # fallback texte brut
     msg.add_alternative(contenu_html, subtype='html')
 
     # ✅ Ajout d'une ou plusieurs pièces jointes si fournie
-    if piece_jointe_paths:
+    if piece_jointe_paths and os.path.exists(piece_jointe_paths):
         piece_paths = [f for f in os.listdir(piece_jointe_paths) if os.path.isfile(os.path.join(piece_jointe_paths, f))]
         for piece_path in piece_paths:
             try:
@@ -660,7 +687,7 @@ def send_mail(expediteur, offusc_conf_agent, destinataire, sujet, contenu_html,
             except Exception as e:
                 print(f"Erreur lors de l'ajout de la pièce jointe '{piece_path}': {e}")
     try:
-        _, _, mot_de_passe, _, _ = keys_manager.lire_config_imap4_ssl(offusc_conf_agent)
+        _, _, mot_de_passe, _, _, _, _, _, _ = keys_manager.lire_config_imap4_ssl(offusc_conf_agent)
         with smtplib.SMTP(serveur, port) as smtp:
             smtp.starttls()
             smtp.login(expediteur, mot_de_passe)
@@ -705,8 +732,9 @@ def to_graph_recipients(champ):
 
 def check_send_new_emails(offusc_conf_agent, type_co):
     if type_co == "IMAP4_SSL":
-        agent, domain, _, _, alias = keys_manager.lire_config_imap4_ssl(offusc_conf_agent)
+        agent, domain, _, _, alias, _, _, server_smtp, port_smtp = keys_manager.lire_config_imap4_ssl(offusc_conf_agent)
         mail = agent + domain
+
         if alias != "":
             agent = alias
         chemin_dossier_in, chemin_dossier_out = mail_in_folder(agent, "out")
@@ -725,14 +753,19 @@ def check_send_new_emails(offusc_conf_agent, type_co):
                                 print("Aucun destinataire trouvé dans 'eme'")
                                 continue
 
+                            chemin_pj = chemin_dossier_out + "/" + contenu + "/pj"
+                            pj_argument = chemin_pj if os.path.exists(chemin_pj) else None
+
                             send_mail(
                                 mail,
                                 offusc_conf_agent,
                                 destinataires,
                                 infos["tit"],
                                 infos["txt"],
-                                #cc=copies,
-                                piece_jointe_paths=chemin_dossier_out + "/" + contenu + "/pj"
+                                cc=copies,
+                                piece_jointe_paths=pj_argument,
+                                serveur=server_smtp,
+                                port=port_smtp
                             )
                             MetManagement.reset_folder(chemin_dossier_in + contenu, recreate=False)
                             MetManagement.reset_folder(chemin_dossier_out + contenu, recreate=False)

io4it-4.0.9/orangecontrib/IO4IT/utils/pptx2jpg.py

@@ -0,0 +1,102 @@
+import sys
+import time
+import subprocess
+import shutil
+from pathlib import Path
+
+def get_conversion_method():
+    """Determines the best available conversion method."""
+    # 1. Check for MS Office
+    if sys.platform.startswith("win"):
+        try:
+            import win32com.client
+            # Try to see if the COM object is registered
+            win32com.client.GetActiveObject("PowerPoint.Application")
+            return "office"
+        except:
+            try:
+                # If not running, try to see if it's dispatchable
+                win32com.client.Dispatch("PowerPoint.Application")
+                return "office"
+            except: pass
+    elif sys.platform == "darwin":
+        # Check if PowerPoint app exists on Mac
+        if Path("/Applications/Microsoft PowerPoint.app").exists():
+            return "office"
+
+    # 2. Check for LibreOffice (soffice)
+    if shutil.which("soffice"):
+        return "libreoffice"
+
+    # 3. Fallback to Aspose
+    return "aspose"
+
+def convert_via_office(src: Path, pdf_path: Path):
+    if sys.platform.startswith("win"):
+        import win32com.client
+        powerpoint = win32com.client.Dispatch("PowerPoint.Application")
+        try:
+            presentation = powerpoint.Presentations.Open(str(src), WithWindow=False)
+            presentation.SaveAs(str(pdf_path), 32) # 32 = ppSaveAsPDF
+            presentation.Close()
+        finally:
+            # Note: We don't quit() powerpoint here to avoid killing other open docs
+            pass
+    elif sys.platform == "darwin":
+        script = f'tell application "Microsoft PowerPoint" to save (open POSIX file "{src}") in POSIX file "{pdf_path}" as PDF'
+        subprocess.run(["osascript", "-e", script], check=True)
+
+def convert_via_libreoffice(src: Path, out_dir: Path):
+    subprocess.run([
+        "soffice", "--headless", "--convert-to", "pdf", 
+        "--outdir", str(out_dir), str(src)
+    ], check=True, capture_output=True)
+    return src.with_suffix(".pdf")
+
+def process_one_pptx(file_path_str: str, unique_folder: bool = True):
+    try:
+        import fitz  # PyMuPDF
+    except ImportError:
+        return [file_path_str, "", "nok", "0.0", "Erreur: PyMuPDF non installé"]
+
+    t0 = time.time()
+    src = Path(file_path_str).resolve()
+    out_dir = src.parent / (f"images_{src.stem}" if unique_folder else "images")
+    out_dir.mkdir(parents=True, exist_ok=True)
+    
+    method = get_conversion_method()
+    img_list = []
+
+    try:
+        # --- PHASE 1: GENERATE IMAGES ---
+        if method == "aspose":
+        #    import aspose.slides as slides
+        #    with slides.Presentation(str(src)) as pres:
+        #        for i, slide in enumerate(pres.slides, start=1):
+        #            img_path = out_dir / f"{src.stem}_slide_{i:03d}.jpg"
+        #            slide.get_thumbnail(1.5, 1.5).save(str(img_path), slides.export.ImageFormat.JPEG)
+        #            img_list.append(str(img_path))
+            print("converting slides without having libre office or office isn't possible for the moment")
+        else:
+            # Office or LibreOffice both generate a PDF first
+            pdf_path = out_dir / f"{src.stem}.pdf"
+            if method == "office":
+                convert_via_office(src, pdf_path)
+            else: # libreoffice
+                convert_via_libreoffice(src, out_dir)
+            
+            # Convert PDF pages to JPG using PyMuPDF
+            doc = fitz.open(str(pdf_path))
+            for i, page in enumerate(doc, start=1):
+                pix = page.get_pixmap(dpi=150)
+                img_path = out_dir / f"{src.stem}_slide_{i:03d}.jpg"
+                pix.save(str(img_path))
+                img_list.append(str(img_path))
+            doc.close()
+            if pdf_path.exists(): pdf_path.unlink()
+
+        duration = time.time() - t0
+        return [str(src), "|".join(img_list), "ok", f"{duration:.2f}", f"{len(img_list)} slides ({method})"]
+
+    except Exception as e:
+        return [str(src), "", "nok", f"{time.time()-t0:.2f}", f"Method {method} failed: {str(e)}"]

{io4it-4.0.7 → io4it-4.0.9}/orangecontrib/IO4IT/widgets/OWInboxMailMonitoring.py

@@ -139,7 +139,7 @@ class OWInboxMailMonitoring(widget.OWWidget):
             try:
                 agent = ""
                 if self.type_co == "IMAP4_SSL":
-                    agent, _, _, _, alias = keys_manager.lire_config_imap4_ssl(self.your_email_conf)
+                    agent, _, _, _, alias, _, _, _, _ = keys_manager.lire_config_imap4_ssl(self.your_email_conf)
                     if alias != "":
                         agent = alias
                 if self.type_co == "MICROSOFT_EXCHANGE_OWA":

{io4it-4.0.7 → io4it-4.0.9}/orangecontrib/IO4IT/widgets/OWPipAuditor.py

@@ -5,9 +5,9 @@ from Orange.widgets import widget
 from Orange.data import Domain, StringVariable, Table
 from AnyQt.QtWidgets import QApplication
 from Orange.widgets.settings import Setting
-from Orange.widgets.utils.signals import Output
+from Orange.widgets.utils.signals import Output, Input
 from AnyQt.QtCore import QTimer
-
+from datetime import datetime
 
 # Importations conditionnelles selon l'architecture du projet
 if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
@@ -54,8 +54,6 @@ def run_audit(saved_packages: dict) -> tuple:
     all_keys = set(saved_packages.keys()) | set(current_packages.keys())
 
     diff_rows = []
-    current_rows = []
-    previous_rows = []
 
     for pkg in sorted(all_keys):
         saved_v = saved_packages.get(pkg, "(Absent)")
@@ -71,32 +69,21 @@ def run_audit(saved_packages: dict) -> tuple:
             status = "✅ OK"
 
         # Table différences : 4 colonnes complètes
-        #if status != "✅ OK":
         diff_rows.append([pkg, saved_v, current_v, status])
 
-        # Table courante : uniquement Package + Version courante
-        if current_v != "(Nouveau)":
-            current_rows.append([pkg, current_v])
-
-        # Table précédente : uniquement Package + Version sauvegardée
-        if saved_v != "(Absent)":
-            previous_rows.append([pkg, saved_v])
 
     diff_cols    = ["Package", "Saved Version", "Current Version", "Status"]
-    current_cols = ["Package", "Current Version"]
-    previous_cols = ["Package", "Saved Version"]
+    
 
     diff_table     = _make_table(diff_rows,     diff_cols)     if diff_rows     else None
-    current_table  = _make_table(current_rows,  current_cols)  if current_rows  else None
-    previous_table = _make_table(previous_rows, previous_cols) if previous_rows else None
-
-    return diff_table, current_table, previous_table
+    
+    return diff_table
  
  
 # ---------------------------------------------------------------------------
 # Widget
 # ---------------------------------------------------------------------------
- 
+
 @apply_modification_from_python_file(filepath_original_widget=__file__)
 class OWPipAuditor(widget.OWWidget):
     name = "Pip Auditor"
@@ -115,16 +102,23 @@ class OWPipAuditor(widget.OWWidget):
     # ------------------------------------------------------------------
     # Settings persistants
     # ------------------------------------------------------------------
-    saved_freeze: dict = Setting({})       # Snapshot sauvegardé (dict pkg→version)
+    saved_freeze = Setting(None, schema_only=True)       # Snapshot sauvegardé (dict pkg→version)
+    snapshot_time = Setting(None)
     autorun: bool = Setting(False)         # Checkbox "Lancer automatiquement au démarrage"
- 
+    trigger_on_signal = Setting(False)      # Checkbox "Run on signal"
+    # ------------------------------------------------------------------
+    # Entrées
+    # ------------------------------------------------------------------
+    class Inputs:
+        data = Input("Data", Orange.data.Table)
+
     # ------------------------------------------------------------------
     # Sorties
     # ------------------------------------------------------------------
     class Outputs:
-        diff_table = Output("Différences", Orange.data.Table)       # Packages avec écart
-        current_table = Output("Actuels", Orange.data.Table)        # Snapshot courant
-        previous_table = Output("Précédents", Orange.data.Table)    # Snapshot sauvegardé
+        diff_table = Output("Results", Orange.data.Table)       # Comparaison packages
+        info_table = Output("Infos", Orange.data.Table)     
+        data = Output("Data", Orange.data.Table) # Sortie "Passthrough"
  
     # ------------------------------------------------------------------
     # Initialisation
@@ -145,6 +139,9 @@ class OWPipAuditor(widget.OWWidget):
         # Checkbox autorun (doit être définie dans owpipauditor.ui avec le nom checkBox_autorun)
         self.checkBox_autorun.setChecked(self.autorun)
         self.checkBox_autorun.stateChanged.connect(self._on_autorun_changed)
+
+        self.checkBox_trigger.setChecked(self.trigger_on_signal)
+        self.checkBox_trigger.stateChanged.connect(self._on_trigger_changed)
  
         self.post_initialized()
         QTimer.singleShot(0, lambda: help_management.override_help_action(self))
@@ -152,6 +149,16 @@ class OWPipAuditor(widget.OWWidget):
         # Démarrage automatique si l'option est activée et qu'un snapshot existe
         if self.autorun and self.saved_freeze:
             QTimer.singleShot(100, self.run)
+    
+    @Inputs.data
+    def set_data(self, data):
+        # On renvoie immédiatement la donnée en sortie (Passthrough)
+        self.Outputs.data.send(data)
+    
+        # Si on reçoit une donnée non nulle et que l'option est activée
+        if data is not None and self.trigger_on_signal:
+            # On lance la comparaison
+            self.run()
  
     # ------------------------------------------------------------------
     # Slots
@@ -159,11 +166,17 @@ class OWPipAuditor(widget.OWWidget):
     def _on_autorun_changed(self, state: int):
         """Persistance de la checkbox autorun."""
         self.autorun = bool(state)
+
+    def _on_trigger_changed(self, state: int):
+        self.trigger_on_signal = bool(state)
  
     def take_snapshot(self):
         """Sauvegarde l'état pip courant dans le Setting."""
         try:
-            self.saved_freeze = get_pip_freeze_dict()
+            self.saved_freeze = dict(get_pip_freeze_dict())
+            self.snapshot_time = datetime.now()
+            self.error("")
+            self.warning("")
             self.information(
                 f"Snapshot réussi : {len(self.saved_freeze)} packages sauvegardés."
             )
@@ -175,8 +188,8 @@ class OWPipAuditor(widget.OWWidget):
         self.error("")
         self.warning("")
  
-        if not self.saved_freeze:
-            self.error("Aucun snapshot sauvegardé. Cliquez d'abord sur Snapshot.")
+        if self.saved_freeze is None:
+            self.error("Aucun snapshot sauvegardé.")
             return
  
         if self.thread is not None:
@@ -197,27 +210,41 @@ class OWPipAuditor(widget.OWWidget):
         self.progressBarSet(value)
  
     def handle_result(self, result):
-        """
-        result est un tuple (diff_table, current_table, previous_table).
-        """
         try:
-            diff_table, current_table, previous_table = result
-            self._last_results = result
- 
+            self.clear_messages()
+            diff_table = result
+            
+            if diff_table is None:
+                return
+            
+            ref_time = self.snapshot_time
+            now_time = datetime.now()
+
+            info_rows = [[
+                ref_time.strftime("%Y-%m-%d %H:%M:%S") if ref_time else "N/A",
+                now_time.strftime("%Y-%m-%d %H:%M:%S"),
+            ]]
+
+            info_table = _make_table(info_rows, ["Snapshot time", "Comparison time"])
+
             self.Outputs.diff_table.send(diff_table)
-            self.Outputs.current_table.send(current_table)
-            self.Outputs.previous_table.send(previous_table)
- 
-            n_diff = sum(1 for row in diff_table if str(row["Status"]) != "✅ OK")
-            self.information(f"Audit terminé : {n_diff} différence(s) détectée(s) sur {len(diff_table)} package(s).")
+            self.Outputs.info_table.send(info_table)
+
+            status_idx = diff_table.domain.metas.index(diff_table.domain["Status"])
+            n_diff = sum(1 for row in diff_table.metas if str(row[status_idx]) != "✅ OK")
+
+            self.information(
+                f"Audit terminé : {n_diff} différence(s)."
+            )
+
         except Exception as e:
+            self.clear_messages()
             self.error(f"Erreur lors de l'envoi des tables: {e}")
-            self.Outputs.diff_table.send(None)
-            self.Outputs.current_table.send(None)
-            self.Outputs.previous_table.send(None)
+
  
     def handle_finish(self):
         self.progressBarFinished()
+        self.thread = None
  
     # ------------------------------------------------------------------
     # Hook post-init (override si besoin dans une sous-classe)