io4it 1.0.1__tar.gz → 1.0.2__tar.gz

{io4it-1.0.1 → io4it-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: io4it
-Version: 1.0.1
+Version: 1.0.2
 Home-page: 
 Author: 
 Author-email: 
@@ -15,5 +15,7 @@ Requires-Dist: pyannote.audio
 Requires-Dist: pyannote-core
 Requires-Dist: wave
 Requires-Dist: scikit-learn
+Requires-Dist: pylatexenc
+Requires-Dist: docopt
 Dynamic: keywords
 Dynamic: requires-dist

{io4it-1.0.1 → io4it-1.0.2}/io4it.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: io4it
-Version: 1.0.1
+Version: 1.0.2
 Home-page: 
 Author: 
 Author-email: 
@@ -15,5 +15,7 @@ Requires-Dist: pyannote.audio
 Requires-Dist: pyannote-core
 Requires-Dist: wave
 Requires-Dist: scikit-learn
+Requires-Dist: pylatexenc
+Requires-Dist: docopt
 Dynamic: keywords
 Dynamic: requires-dist

{io4it-1.0.1 → io4it-1.0.2}/io4it.egg-info/SOURCES.txt

@@ -11,25 +11,38 @@ orangecontrib/__init__.py
 orangecontrib/IO4IT/__init__.py
 orangecontrib/IO4IT/ocr_function/__init__.py
 orangecontrib/IO4IT/ocr_function/word_converter.py
+orangecontrib/IO4IT/utils/__init__.py
+orangecontrib/IO4IT/utils/mail.py
+orangecontrib/IO4IT/utils/offuscation_basique.py
+orangecontrib/IO4IT/widgets/OWDeep_Search.py
+orangecontrib/IO4IT/widgets/OWExportMarkdown.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/OWmailLoader.py
+orangecontrib/IO4IT/widgets/OWmailSender.py
 orangecontrib/IO4IT/widgets/OWwordpdf2docx.py
 orangecontrib/IO4IT/widgets/__init__.py
 orangecontrib/IO4IT/widgets/designer/__init__.py
 orangecontrib/IO4IT/widgets/designer/chart.html
 orangecontrib/IO4IT/widgets/designer/nogui.ui
 orangecontrib/IO4IT/widgets/designer/ow_file_ext_selector.ui
+orangecontrib/IO4IT/widgets/designer/owexportmarkdown.ui
 orangecontrib/IO4IT/widgets/designer/owmailloader.ui
+orangecontrib/IO4IT/widgets/designer/owmailsender.ui
 orangecontrib/IO4IT/widgets/designer/owspeechtotext.ui
 orangecontrib/IO4IT/widgets/designer/owvisualizationer.ui
 orangecontrib/IO4IT/widgets/designer/wordpdf2docx.ui
 orangecontrib/IO4IT/widgets/icons/__init__.py
+orangecontrib/IO4IT/widgets/icons/deepsearch.svg
 orangecontrib/IO4IT/widgets/icons/download.png
+orangecontrib/IO4IT/widgets/icons/export_md.png
 orangecontrib/IO4IT/widgets/icons/file_extensor.png
 orangecontrib/IO4IT/widgets/icons/list_aws.png
+orangecontrib/IO4IT/widgets/icons/mail_loader.png
+orangecontrib/IO4IT/widgets/icons/mail_writer.png
 orangecontrib/IO4IT/widgets/icons/md.png
 orangecontrib/IO4IT/widgets/icons/speech_to_text.png
 orangecontrib/IO4IT/widgets/icons/upload.png

{io4it-1.0.1 → io4it-1.0.2}/io4it.egg-info/requires.txt

@@ -8,3 +8,5 @@ pyannote.audio
 pyannote-core
 wave
 scikit-learn
+pylatexenc
+docopt

io4it-1.0.2/orangecontrib/IO4IT/utils/mail.py

@@ -0,0 +1,241 @@
+import imaplib
+import smtplib
+import email
+from email.header import decode_header
+import time
+import os
+from email import policy
+from email.message import EmailMessage
+if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
+    from Orange.widgets.orangecontrib.AAIT.utils import MetManagement
+    from Orange.widgets.orangecontrib.IO4IT.utils import offuscation_basique
+else:
+    from orangecontrib.AAIT.utils import MetManagement
+    from orangecontrib.IO4IT.utils import offuscation_basique
+
+
+def clean_addresses(field,myemail):
+    """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 if addr.lower() != myemail.lower()]
+
+def mail_in_folder(agent_name, type="in"):
+    if agent_name is None or agent_name == "":
+        print("agent_name doit etre renseigné")
+        return None
+    chemin_dossier= MetManagement.get_path_mailFolder()
+    if type == "in":
+        if not os.path.exists(chemin_dossier):
+            os.makedirs(chemin_dossier)
+        real_time = MetManagement.get_second_from_1970()
+        folder_in = chemin_dossier + "/" + str(agent_name) + "/in/" + str(real_time)
+        folder_out = chemin_dossier + "/" + str(agent_name) + "/out/" + str(real_time)
+        if not os.path.exists(folder_in) and not os.path.exists(folder_out):
+            os.makedirs(folder_in)
+            os.makedirs(folder_out)
+        else:
+            time.sleep(1.5)
+            mail_in_folder(agent_name, "in")
+        return folder_in
+    if  type == "out":
+        return chemin_dossier + str(agent_name) + "/in/", chemin_dossier + "/" + str(agent_name) + "/out/"
+
+
+def check_new_emails(offusc_conf_agent):
+    try:
+        agent,my_domain,password,interl_seconds=offuscation_basique.lire_config(offusc_conf_agent)
+        myemail=agent + my_domain
+        imap = imaplib.IMAP4_SSL("imap.gmail.com")
+        imap.login(myemail, password)
+        imap.select("inbox")
+
+        status, messages = imap.search(None, 'UNSEEN')
+        mail_ids = messages[0].split()
+
+        if not mail_ids:
+            print("Aucun nouveau mail.")
+        else:
+            for mail_id in mail_ids:
+                time.sleep(1.5)
+                output_lines = []
+                _, msg_data = imap.fetch(mail_id, "(RFC822)")
+                for response_part in msg_data:
+                    if isinstance(response_part, tuple):
+                        from email.parser import BytesParser
+
+                        # Utilise :
+                        msg = BytesParser(policy=policy.default).parsebytes(response_part[1])
+
+                        # Sujet
+                        subject, encoding = decode_header(msg["Subject"])[0]
+                        if isinstance(subject, bytes):
+                            subject = subject.decode(encoding if encoding else "utf-8")
+
+                        # Expéditeur
+                        from_ = msg.get("From")
+
+                        # Destinataires
+                        to_emails = clean_addresses(msg.get("To", ""),myemail)
+                        cc_emails = clean_addresses(msg.get("Cc", ""),myemail)
+
+                        # Corps
+                        body = ""
+                        if msg.is_multipart():
+                            for part in msg.walk():
+                                content_type = part.get_content_type()
+                                content_disposition = str(part.get("Content-Disposition"))
+
+                                if content_type == "text/plain" and "attachment" not in content_disposition:
+                                    payload = part.get_payload(decode=True)
+                                    charset = part.get_content_charset()
+                                    body = payload.decode(charset if charset else "utf-8", errors="replace")
+                                    break
+                        else:
+                            body = msg.get_payload(decode=True).decode(errors="replace")
+
+                        # Format de sortie
+                        output_lines.append(f"#$who : {myemail}")
+                        output_lines.append(f"#$eme : {from_}")
+                        output_lines.append(f"#$des : {', '.join(to_emails)}")
+                        output_lines.append(f"#$cop : {', '.join(cc_emails)}")
+                        output_lines.append("#$pri : Normale")
+                        output_lines.append(f"#$tit : {subject}")
+                        output_lines.append(f"#$txt : {body.strip()}")
+                        output_lines.append("")
+                        print("----------------------------------------")
+                        print(f"mail recu de {from_}")
+                        print("----------------------------------------")
+
+                        if output_lines != []:
+                            folder = mail_in_folder(agent, "in")
+                            if folder is None:
+                                print("erreur dans le folder de mail")
+                                return
+
+                            with open(folder + "/" + "mail.txt", "w", encoding="utf-8") as f:
+                                f.write("\n".join(output_lines))
+                                f.close()
+
+                            with open(folder + "/" + "mail.ok", "w") as f:
+                                f.close()
+
+                            for part in msg.iter_attachments():
+                                filename = part.get_filename()
+                                if filename:
+                                    folder_pj = folder + "/" + "pj"
+                                    if not os.path.exists(folder_pj):
+                                        os.makedirs(folder_pj)
+                                    filepath = os.path.join(folder_pj, filename)
+                                    with open(filepath, "wb") as f:
+                                        f.write(part.get_payload(decode=True))
+                                    f.close()
+
+        imap.logout()
+    except Exception as e:
+        print(f"Erreur lors de la vérification des mails : {e}")
+
+
+def lire_message(chemin_fichier):
+    donnees = {}
+    cle_courante = None
+    texte_multi_ligne = []
+
+    with open(chemin_fichier, 'r', encoding='utf-8') as fichier:
+        for ligne in fichier:
+            if ligne.startswith('#$'):
+                if cle_courante == 'txt' and texte_multi_ligne:
+                    donnees['txt'] = '\n'.join(texte_multi_ligne).strip()
+                    texte_multi_ligne = []
+
+                cle_val = ligne[2:].split(':', 1)
+                cle_courante = cle_val[0].strip()
+
+                if cle_courante == 'txt':
+                    texte_multi_ligne.append(cle_val[1].strip())
+                else:
+                    donnees[cle_courante] = cle_val[1].strip()
+            else:
+                if cle_courante == 'txt':
+                    texte_multi_ligne.append(ligne.rstrip())
+
+    # En fin de fichier, enregistrer le texte si encore en cours
+    if cle_courante == 'txt' and texte_multi_ligne:
+        donnees['txt'] = '\n'.join(texte_multi_ligne).strip()
+
+    return donnees
+
+
+
+
+def send_mail(expediteur, offusc_conf_agent, destinataire, sujet, contenu,piece_jointe_path=None, serveur="smtp.gmail.com", port=587):
+    msg = EmailMessage()
+    msg['From'] = expediteur
+    msg['To'] = destinataire
+    msg['Subject'] = sujet
+    msg.set_content(contenu)
+    # Ajout d'une pièce jointe si fournie
+    if piece_jointe_path:
+        with open(piece_jointe_path, 'rb') as f:
+            data = f.read()
+            nom_fichier = piece_jointe_path.split('/')[-1]
+            msg.add_attachment(data, maintype='application', subtype='octet-stream', filename=nom_fichier)
+    try:
+        _, _, mot_de_passe, _ = offuscation_basique.lire_config(offusc_conf_agent)
+        with smtplib.SMTP(serveur, port) as smtp:
+            smtp.starttls()
+            smtp.login(expediteur, mot_de_passe)
+            smtp.send_message(msg)
+        return 0
+    except Exception as e:
+        print("❌ Une erreur s'est produite :", e)
+
+
+def check_send_new_emails(offusc_conf_agent):
+    agent, domain, _, _  = offuscation_basique.lire_config(offusc_conf_agent)
+    chemin_dossier_in, chemin_dossier_out = mail_in_folder(agent, "out")
+    if os.path.exists(chemin_dossier_out) and os.path.isdir(chemin_dossier_out):
+        contenus = os.listdir(chemin_dossier_out)
+        if contenus:
+            for contenu in contenus:
+                if os.path.exists(chemin_dossier_out + "/" + contenu + "/mail.ok"):
+                    chemin = chemin_dossier_out + "/" + contenu + "/mail.txt"
+                    infos = lire_message(chemin)
+                    # Affichage des informations extraites
+                    cles_requises = ["eme", "des", "cop", "pri", "tit", "txt"]
+                    if all(cle in infos for cle in cles_requises):
+                        send_mail(
+                            agent+domain,
+                            offusc_conf_agent,
+                            infos["eme"],
+                            infos["tit"],
+                            infos["txt"],
+                            piece_jointe_path=None  #à rajouter quand PJ ok chemin_dossier_out + "/" + contenu + "/pj"
+                        )
+                        MetManagement.reset_folder(chemin_dossier_in + contenu , recreate=False)
+                        MetManagement.reset_folder(chemin_dossier_out + contenu, recreate=False)
+                    else:
+                        print("il manque des clefs dans le contenu du mail")
+        else:
+            print("Le dossier est vide.")
+    else:
+        print("Le dossier n'existe pas ou le chemin n'est pas un dossier.")
+
+
+if __name__ == "__main__":
+    offusc_conf_agent="agent.ia_at_institut-ia.com.json"
+    while True:
+        check_new_emails(offusc_conf_agent)
+        time.sleep(1)
+        check_send_new_emails(offusc_conf_agent)
+        time.sleep(1)
+    # print(f"Surveillance des mails toutes les {INTERVAL_SECONDS} secondes. Ctrl+C pour arrêter.")
+    # send_mail(
+    #     expediteur=EMAIL,
+    #     mot_de_passe=PASSWORD,
+    #     destinataire="jc@institut-ia.com",
+    #     sujet="Test depuis Python",
+    #     contenu="Bonjour,\nVoici un test d'envoi de mail avec Python 2.",
+    #     piece_jointe_path=r""#C:\Users\max83\Desktop\Orange_4All_AAIT\Orange_4All_AAIT\Orange\Lib\site-packages\Orange\widgets\orangecontrib\HLIT_dev\widgets\icons\input_interface.png"  # ou "chemin/vers/fichier.pdf"
+    # )

io4it-1.0.2/orangecontrib/IO4IT/utils/offuscation_basique.py

@@ -0,0 +1,126 @@
+import os
+import json
+import hashlib
+import getpass
+
+if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
+    from Orange.widgets.orangecontrib.AAIT.utils import MetManagement
+else:
+    from orangecontrib.AAIT.utils import MetManagement
+
+# Fonction pour générer une clé simple à partir du nom d'utilisateur
+def get_user_key():
+    try:
+        try:
+            username = os.getlogin()
+        except OSError:
+            username = getpass.getuser()
+
+        if not username:
+            raise ValueError("Nom d'utilisateur introuvable")
+
+        # On dérive une clé simple (1 octet) depuis le hash du nom d'utilisateur
+        digest = hashlib.sha256(username.encode("utf-8")).digest()
+        key = digest[0]  # 1 octet pour XOR
+        return key
+
+    except Exception as e:
+        raise RuntimeError(f"Erreur de génération de clé : {e}")
+
+# Fonction simple de chiffrement/déchiffrement par XOR (non sécurisé mais obscurcissant)
+def xor_crypt(data: str, key: int) -> str:
+    return ''.join(chr(ord(c) ^ (key & 0xFF)) for c in data)
+
+# Fonction pour enregistrer les données dans un fichier JSON avec le mot de passe chiffré
+def enregistrer_config(agent, my_domain, password, interval_second):
+    try:
+        dossier=MetManagement.get_secret_content_dir()
+        # Crée le dossier s'il n'existe pas
+        if not os.path.exists(dossier):
+            os.makedirs(dossier)
+
+        # Récupère l'adresse MAC et chiffre le mot de passe
+        key = get_user_key()
+        mdp_chiffre = xor_crypt(password, key)
+
+        # Nom du fichier (remplace @ par _at_ pour éviter les problèmes)
+        nom_fichier = os.path.join(dossier, f"{agent}{my_domain.replace('@', '_at_')}.json")
+
+        # Contenu à écrire dans le fichier
+        contenu = {
+            "agent": agent,
+            "domain": my_domain,
+            "interval_second": interval_second,
+            "password_encrypted": mdp_chiffre
+        }
+
+        # Écriture du fichier
+        with open(nom_fichier, "w", encoding="utf-8") as f:
+            json.dump(contenu, f, indent=4)
+
+        print(f"✅ Fichier enregistré : {nom_fichier}")
+        return 0
+
+    except Exception as e:
+        print(f"❌ Erreur lors de l'enregistrement : {e}")
+        return 1
+
+# Fonction pour lire le fichier de configuration et déchiffrer le mot de passe
+def lire_config(chemin_fichier):
+    # renvoie une liste =["agent","domain",mdp,"interval_second"]
+    try:
+        chemin_fichier=MetManagement.get_secret_content_dir()+chemin_fichier
+        # Lecture du fichier JSON
+        with open(chemin_fichier, "r", encoding="utf-8") as f:
+            contenu = json.load(f)
+
+        # Récupère l'adresse MAC
+        key = get_user_key()
+
+        # Déchiffre le mot de passe
+        mdp_dechiffre = xor_crypt(contenu["password_encrypted"], key)
+
+
+        return [
+            contenu["agent"],
+            contenu["domain"],
+            mdp_dechiffre,
+            int(contenu["interval_second"]),
+        ]
+
+
+    except Exception as e:
+        print(f"❌ Erreur lors de la lecture : {e}")
+        return None
+def enregistrer_config_cli():
+    print("\n📝 Écriture d’un fichier de configuration :")
+    agent = input("🤖 Nom de l’agent : ").strip()
+    domaine = input("📨 @domain.com? : ").strip()
+    mdp = input("📨mot de passe? : ").strip()
+    interval = int(input("⏱️ Intervalle en secondes : ").strip())
+    if 0!= enregistrer_config(agent,domaine,mdp,interval):
+        print("erreur!")
+
+
+def lire_config_cli():
+    chemin_fichier = input("📄 non fichier json (pas le chemin!) JSON : ").strip()
+    config = lire_config(chemin_fichier)
+
+    if config==None:
+        print("erreur")
+    print(config)
+
+
+
+if __name__ == "__main__":
+    print("1) ecrire fichier")
+    print("2) dechiffer fichier")
+    choix = input("👉 que faire? [1/2] : ").strip()
+
+    if choix == "1":
+        enregistrer_config_cli()
+    elif choix == "2":
+        lire_config_cli()
+    else:
+        print("❌ Choix invalide. Réessayez.\n")
+

io4it-1.0.2/orangecontrib/IO4IT/widgets/OWDeep_Search.py

@@ -0,0 +1,208 @@
+import os
+import sys
+# import time
+import requests
+# import orangecanvas.application.canvasmain as canvasmain
+import Orange.data
+from AnyQt.QtWidgets import QApplication, QLabel
+from Orange.widgets import widget # , gui
+from Orange.widgets.utils.signals import Input, Output
+# from Orange.widgets.settings import Setting
+from AnyQt.QtWidgets import QLineEdit, QTextBrowser #, QTextEdit
+
+if "site-packages/Orange/widgets" in os.path.dirname(os.path.abspath(__file__)).replace("\\", "/"):
+    # from Orange.widgets.orangecontrib.AAIT.llm import answers
+    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.llm import answers
+    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 OWDeep_Search(widget.OWWidget):
+    name = "Deep Search"
+    description = "Generate a response to a column 'prompt' with a LLM"
+    icon = "icons/deepsearch.svg"
+    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/owdeepsearch.ui")
+    want_control_area = True
+    priority = 1089
+
+    class Inputs:
+        api_key = Input("API KEY", Orange.data.Table)
+        prompt = Input("Prompt", Orange.data.Table)
+
+    class Outputs:
+        response = Output("Response", Orange.data.Table)
+
+    @Inputs.api_key
+    def set_api_key(self, in_api_key: Orange.data.Table):
+        if in_api_key is not None:
+            if "api_key" not in in_api_key.domain:
+                self.error("You need a column api_key");
+                return
+            self.api_key = str(in_api_key[0]["api_key"])  # ← cast en str
+            self.line_api_key.setText(self.api_key)
+            self.error(None)
+            if self.autorun:
+                self.run()
+
+
+    @Inputs.prompt
+    def set_prompt(self, in_prompt: Orange.data.Table):
+        if in_prompt is None:
+            self.Outputs.response.send(None)
+            return
+        if in_prompt is not None:
+            if "prompt" not in in_prompt.domain:
+                self.error("You need a column prompt");
+                return
+            self.prompt = str(in_prompt[0]["prompt"])  # ← cast en str
+            self.error(None)
+            if self.autorun:
+                self.run()
+
+    def __init__(self):
+        super().__init__()
+        # Qt Managementt
+        self.setFixedWidth(700)
+        self.setFixedHeight(500)
+        uic.loadUi(self.gui, self)
+        self.label_description = self.findChild(QLabel, 'Description')
+        # print(self.label_description.text())
+        self.line_api_key: QLineEdit = self.findChild(QLineEdit, "line_api_key")
+        # Connexion du champ à la fonction de mise à jour
+        self.line_api_key.editingFinished.connect(self.update_api_key)
+        # Text browser
+        self.textBrowser = self.findChild(QTextBrowser, 'textBrowser')
+        # Data Management
+        self.api_key = None
+        self.prompt = None
+        self.thread = None
+        self.autorun = True
+        self.can_run = True
+        self.result = None  # sera ma table de sortie
+        # Custom updates
+        self.post_initialized()
+
+    def update_api_key(self):
+        self.api_key = self.line_api_key.text().strip()
+
+    def deepsearch(self, api_key: str, prompt: str):
+        """
+        Appelle Perplexity Sonar Deep-Research et renvoie la réponse complète
+        dans une Orange Table (métadonnée 'response').
+        """
+
+        url = "https://api.perplexity.ai/chat/completions"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}"
+        }
+        payload = {
+            "model": "sonar-pro",
+            "messages": [
+                {"role": "system",
+                 "content": ("You are a deep research assistant. "
+                             "Answer only in Markdown without exposing any chain-of-thought.")},
+                {"role": "user", "content": prompt}
+            ],
+            "temperature": 0.0,
+            "max_tokens": 20_000,
+            "format": "markdown"
+        }
+
+        try:
+            resp = requests.post(url, json=payload, headers=headers, timeout=600)
+            resp.raise_for_status()
+            answer_md = resp.json()["choices"][0]["message"]["content"]
+
+        except requests.HTTPError: #as e:
+            print("STATUS :", resp.status_code)  # affiche 400, 401, etc.
+            print("DETAIL :", resp.text)  # message JSON complet de Perplexity
+
+            answer_md = f"**Erreur Perplexity :** {resp.text}"
+
+        except Exception as e:
+            answer_md = f"**Erreur Perplexity :** {e}"
+
+        # Affiche la réponse complète dans la console
+        # print("Réponse Perplexity :\n", answer_md)
+
+        response_var = Orange.data.StringVariable("response")
+
+        domain = Orange.data.Domain([], metas=[response_var])
+        out_data = Orange.data.Table.from_list(domain, [[answer_md]])
+        return out_data
+
+    def run(self):
+        # print("I'm running...")
+        # print(self.prompt)
+        # print(self.api_key)
+        if not self.can_run:
+            return
+
+        if self.prompt == None:
+            return
+
+        if self.api_key == None:
+            # print("Je sors")
+            return
+
+        # If Thread is already running, interrupt it
+        if self.thread is not None:
+            if self.thread.isRunning():
+                self.thread.safe_quit()
+
+        # Start progress bar
+        self.progressBarInit()
+        #◙self.textBrowser.setText("")
+
+        # Connect and start thread : main function, progress, result and finish
+        # --> progress is used in the main function to track progress (with a callback)
+        # --> result is used to collect the result from main function
+        # --> finish is just an empty signal to indicate that the thread is finished
+        self.thread = thread_management.Thread(self.deepsearch, self.api_key, self.prompt)
+        self.thread.progress.connect(self.handle_progress)
+        self.thread.result.connect(self.handle_result)
+        self.thread.finish.connect(self.handle_finish)
+        self.thread.start()
+
+    def handle_progress(self, progress) -> None:
+        value = progress[0]
+        text = progress[1]
+        if value is not None:
+            self.progressBarSet(value)
+        if text is None:
+            self.textBrowser.setText("")
+        else:
+            self.textBrowser.insertPlainText(text)
+
+    def handle_result(self, result):
+        try:
+            self.result = result
+            self.Outputs.response.send(result)
+        except Exception as e:
+            print("An error occurred when sending out_data:", e)
+            self.Outputs.response.send(None)
+            return
+
+    def handle_finish(self):
+        print("Generation finished")
+        self.progressBarFinished()
+
+
+    def post_initialized(self):
+        pass
+
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    my_widget = OWDeep_Search()
+    my_widget.show()
+    app.exec_()
+