AIEmailAutomationUtility 0.0.9__py3-none-any.whl → 0.0.10__py3-none-any.whl

AIEmailAutomationUtility/EmailReplyAssistant.py

@@ -19,23 +19,23 @@ class EmailReplyAssistant:
 
                 def on_text_created(self, text):
                     if isinstance(text, str):
-                        print(f"\nAssistant: {text}", end="", flush=True)
+                        logger.log(f"\nAssistant: {text}", end="", flush=True)
 
                 def on_text_delta(self, delta, snapshot):
                     self.delta_values.append(delta.value)
 
                 def on_tool_call_created(self, tool_call):
-                    print(f"\nAssistant: {tool_call.type}\n", flush=True)
+                    logger.log(f"\nAssistant: {tool_call.type}\n", flush=True)
 
                 def on_tool_call_delta(self, delta, snapshot):
                     if delta.type == 'code_interpreter':
                         if delta.code_interpreter.input:
-                            print(delta.code_interpreter.input, end="", flush=True)
+                            logger.log(delta.code_interpreter.input, end="", flush=True)
                         if delta.code_interpreter.outputs:
-                            print(f"\n\nOutput >", flush=True)
+                            logger.log(f"\n\nOutput >", flush=True)
                             for output in delta.code_interpreter.outputs:
                                 if output.type == "logs":
-                                    print(output.logs, flush=True)
+                                    logger.log(output.logs, flush=True)
 
             openAI_response = ""
             client = OpenAI(api_key=openAI_key)
@@ -71,13 +71,8 @@ class EmailReplyAssistant:
             data = ast.literal_eval(m.group(1)).get('error') if m else {}  
             return {"status": "Failed", "message": data.get('message')}
 
-    def email_reply_assitant(self):
+    def email_reply_assitant(self, data):
         try:
-            # while True:
-            data = request.get_data('jsonData', None)
-            data = json.loads(data[9:])
-            logger.log(f"jsondata:: {data}")
-
             openAI_key = data.get("openAI_key")
             assistant_ID = data.get("assistant_ID")
             email_content = data.get("email_content")
@@ -93,7 +88,7 @@ class EmailReplyAssistant:
                 subject=subject
             )
 
-            logger.log(f"Reply_Email_Ai_Assistant response: {email_response}")
+            # logger.log(f"Reply_Email_Ai_Assistant response: {email_response}")
             return email_response
 
         except Exception as e:

AIEmailAutomationUtility/Email_Classification.py

@@ -142,11 +142,8 @@ class Email_Classification:
             logger.log(f"Error with LocalAI detection/generation: {str(e)}")
             return {"success": "Failed", "message": f"Error with LocalAI detection/generation: {str(e)}"}
 
-    def detect_category(self):
+    def detect_category(self, data):
         try:
-            data = request.get_data('jsonData', None)
-            data = json.loads(data[9:])
-            logger.log(f"jsondata:: {data}")
             model_type = data.get('model_type', 'OpenAI')  
             
             required_fields = ['email_body', 'categories']

AIEmailAutomationUtility/Email_DocumentUploader.py

@@ -5,7 +5,6 @@ import requests
 import loggerutility as logger
 from flask import Flask,request
 
-
 class Email_DocumentUploader:
     def upload_document(self, upload_config, file_data):
         # try:
@@ -55,47 +54,32 @@ class Email_DocumentUploader:
             return str(response.status_code), document_id
         else:
             return str(response.status_code), f"Upload failed: {response.text}"
-                
-        # except Exception as e:
-        #     logger.log(f"Error uploading document: {str(e)}")
-        #     raise
-        # finally:
-        #     # Cleanup
-        #     if os.path.exists(temp_dir):
-        #         shutil.rmtree(temp_dir)
-
-    def email_document_upload(self):
-        try:
-            if 'file' not in request.files:
-                return "file not found"
-                
-            file = request.files['file']
-            if file.filename == '':
-                return "No selected file"
 
-            upload_config = {
-                'token_id': request.form.get('TOKEN_ID'),
-                'document_type': request.form.get('DOCUMENT_TYPE', ''),
-                'obj_name': request.form.get('OBJ_NAME', ''),
-                'file_type': request.form.get('FILE_TYPE', ''),
-                'app_id': request.form.get('APP_ID', ''),
-                'method': request.form.get('Method_Type', 'POST'),
-                'url': request.form.get('RestAPI_Url')
-            }
+    def email_document_upload(self, file, parameters_details):
+        logger.log(f"file ::: {file}")
+        if not file:
+            return "file not found"
 
-            # Validate required fields
-            if not upload_config['token_id'] or not upload_config['url']:
-                return "Missing required fields: TOKEN_ID or RestAPI_Url"
-            
-            file_data = {
-                'filename': file.filename,
-                'content': file.read()
-            }
+        upload_config = {
+            'token_id': parameters_details.get('TOKEN_ID'),
+            'document_type': parameters_details.get('DOCUMENT_TYPE', ''),
+            'obj_name': parameters_details.get('OBJ_NAME', ''),
+            'file_type': parameters_details.get('FILE_TYPE', ''),
+            'app_id': parameters_details.get('APP_ID', ''),
+            'method': parameters_details.get('Method_Type', 'POST'),
+            'url': parameters_details.get('RestAPI_Url')
+        }
 
-            result = self.upload_document(upload_config, file_data)
-            
-            logger.log(f"Upload_Document response result: {result}")
-            return "success"
+        # Validate required fields
+        if not upload_config['token_id'] or not upload_config['url']:
+            return "Missing required fields: TOKEN_ID or RestAPI_Url"
+        
+        file_data = {
+            'filename': os.path.basename(file.name),
+            'content': file.read()
+        }
 
-        except Exception as e:
-            logger.log(f"Error in Upload_Document: {str(e)}")
+        response_status, restAPI_Result = self.upload_document(upload_config, file_data)
+        
+        logger.log(f"Upload_Document response result: {restAPI_Result}")
+        return response_status, restAPI_Result

AIEmailAutomationUtility/Email_Draft.py

@@ -12,7 +12,6 @@ class Email_Draft:
         try:
             with imaplib.IMAP4_SSL(host=email_config['host'], port=imaplib.IMAP4_SSL_PORT) as imap_ssl:
                 imap_ssl.login(email_config['email'], email_config['password'])
-                logger.log(f"login successfully")
                 
                 message = Message()
                 message["From"] = email_config['email']
@@ -28,7 +27,7 @@ class Email_Draft:
                 message.set_payload(f"{response_content}\n\n{mail_details}\n\n{email_details['body']}")
                 
                 utf8_message = str(message).encode("utf-8")
-                logger.log(f"utf8_message:: {utf8_message}")
+                # logger.log(f"utf8_message:: {utf8_message}")
                 imap_ssl.append("[Gmail]/Drafts", '', imaplib.Time2Internaldate(time.time()), utf8_message)
                 
                 return True, utf8_message.decode("utf-8")
@@ -57,11 +56,8 @@ class Email_Draft:
             logger.log(f"Error creating draft: {str(e)}")
             return "Failed", None
 
-    def draft_mail(self):
+    def draft_mail(self, data):
         try:
-            data =  request.get_data('jsonData', None)
-            data =  json.loads(data[9:])
-            logger.log(f"jsondata:: {data}")
 
             if "reciever_email_addr" in data and data["reciever_email_addr"] != None:
                 reciever_email_addr = data["reciever_email_addr"]

AIEmailAutomationUtility/Email_Read.py

@@ -4,14 +4,21 @@ import os
 import json
 import time
 import loggerutility as logger
-from flask import Flask, request
+from flask import request
+import traceback
+from fpdf import FPDF
+
 from .Save_Transaction import Save_Transaction
 from .Email_Upload_Document import Email_Upload_Document
+from .Email_Classification import Email_Classification
+from .EmailReplyAssistant import EmailReplyAssistant
+from .Email_Draft import Email_Draft
+from .Email_DocumentUploader import Email_DocumentUploader
 
 class Email_Read:
     def read_email(self, email_config):
         try:
-            logger.log("inside function")
+            logger.log("inside read_email")
             mail = imaplib.IMAP4_SSL(email_config['host'], email_config['port'])
             mail.login(email_config['email'], email_config['password'])
             logger.log("login successfully")
@@ -26,7 +33,7 @@ class Email_Read:
 
                     if not email_ids: 
                         logger.log("Email not found, going to check new mail")
-                        print("Email not found,\ngoing to check new mail \n")
+                        logger.log("Email not found,\ngoing to check new mail \n")
                     else:
                     
                         for email_id in email_ids:
@@ -64,23 +71,6 @@ class Email_Read:
                                 call_save_transaction = Save_Transaction()
                                 save_transaction_response = call_save_transaction.email_save_transaction(email_data)
                                 logger.log(f"save_transaction_response:: {save_transaction_response}")
-
-                                if save_transaction_response['status'] == "Success":
-                                    if msg.is_multipart():
-                                        for part in msg.walk():
-                                            content_disposition = str(part.get("Content-Disposition"))
-
-                                            if "attachment" in content_disposition: 
-                                                attachment_path = self.save_attachment(part, "attachments")
-                                                if attachment_path:
-                                                    logger.log(f"Attachment saved at: {attachment_path}")
-                                                    attachments.append(attachment_path)
-                                    for file_path in attachments:
-                                        logger.log(f"file_path:: {file_path}")
-                                        email_upload_doc = Email_Upload_Document()
-                                        email_file_upload = email_upload_doc.upload_files(file_path)
-                                        logger.log(f"file uploaded :: {email_file_upload}")
-                        logger.log(f"emails:: {emails}")
                 time.sleep(10)
         
         except Exception as e:
@@ -92,6 +82,181 @@ class Email_Read:
             except Exception as close_error:
                 logger.log(f"Error during mail close/logout: {str(close_error)}")
 
+    def read_email_automation(self, email_config):
+        # try:
+        logger.log(f"inside read_email_automation")
+        # logger.log(f"email_config ::: {email_config}")
+        LABEL                       = "Unprocessed_Email"
+        file_JsonArray              = []
+        templateName                = "ai_email_automation.json"
+        fileName                    = ""
+
+        Model_Name =  email_config.get('model_type', 'OpenAI') 
+        reciever_email_addr =  email_config.get('email', '') 
+        receiver_email_pwd =  email_config.get('password', '') 
+        host =  email_config.get('host', '') 
+        port =  email_config.get('port', '') 
+
+        mail = imaplib.IMAP4_SSL(host, port)
+        mail.login(reciever_email_addr, receiver_email_pwd)
+        logger.log("login successfully")
+        mail.select('inbox')
+                    
+        file_JsonArray, categories = self.read_JSON_File(templateName)
+
+        while True:
+            status, email_ids = mail.search(None, 'UNSEEN')
+            emails = []
+            
+            if status == 'OK':
+                email_ids = email_ids[0].split()
+
+                if not email_ids: 
+                    logger.log("Email not found, going to check new mail")
+                    logger.log("Email not found,\ngoing to check new mail \n")
+                else:
+                
+                    for email_id in email_ids:
+                        email_body = ""
+                        attachments = []
+                        status, data = mail.fetch(email_id, '(RFC822)')
+                        
+                        if status == 'OK':
+                            raw_email = data[0][1]
+                            msg = email.message_from_bytes(raw_email)
+
+                            subject = msg['Subject']
+                            sender_email_addr   = msg['From']
+                            cc_email_addr       = msg['CC']
+                            subject             = msg['Subject']
+
+                            if msg.is_multipart():
+                                for part in msg.walk():
+                                    content_type = part.get_content_type()
+                                    if content_type == "text/plain":
+                                        email_body += part.get_payload(decode=True).decode('utf-8', errors='replace')
+                                        fileName = self.download_attachment(msg)
+                            else:
+                                email_body = msg.get_payload(decode=True).decode('utf-8', errors='replace')                              
+                            
+                            openai_Process_Input  = email_body 
+                            logger.log("\nEmail Subject:::", subject)
+                            logger.log("\nEmail body:::", openai_Process_Input )
+
+                            openai_api_key = email_config.get('openai_api_key', '') 
+                            geminiAI_APIKey = email_config.get('gemini_api_key', '') 
+                            signature = email_config.get('signature', '') 
+                            localAIURL = email_config.get('local_ai_url', '') 
+                            
+                            if len(str(openai_Process_Input)) > 0 :
+                                email_cat_data = {
+                                    "model_type" : Model_Name,
+                                    "openai_api_key" : openai_api_key,
+                                    "categories" : categories,
+                                    "email_body" : email_body,
+                                    "gemini_api_key" : geminiAI_APIKey,
+                                    "signature" : signature,
+                                    "local_ai_url" : localAIURL,
+                                }
+                                # logger.log(f"\nemail_cat_data ::: {email_cat_data}")
+                                email_classification = Email_Classification()
+                                emailCategory = email_classification.detect_category(email_cat_data)
+                                emailCategory = emailCategory['message']
+                                logger.log(f"\nDetected Email category ::: {emailCategory}")
+                                
+                                if emailCategory == 'Others':
+                                    logger.log(f"Marking email as UNREAD. ")
+                                    mail.store(email_id, '-FLAGS', '\\Seen')
+
+                                    mail.create(LABEL)
+                                    mail.copy(email_id, LABEL)
+                                    mail.store(email_id, '+FLAGS', '\\Deleted')  # Mark for deletion
+                                    mail.expunge()                         
+                                    logger.log(f"Mail removed from inbox and added to '{LABEL}' label.")
+                                
+                                elif emailCategory == "Product Enquiry":
+                                    
+                                    if Model_Name == "OpenAI":
+                                        responseMethod, parameters = self.get_JsonArray_values(emailCategory, file_JsonArray)
+                                        if responseMethod == "Reply_Email_Ai_Assistant" :
+
+                                            emailreplyassistant = EmailReplyAssistant()
+                                            openai_Response = emailreplyassistant.Reply_Email_Ai_Assistant(openai_api_key, parameters["Assistant_Id"], openai_Process_Input, subject)
+                                            
+                                            logger.log(f"Process openai_Response ::: {openai_Response['message']}\n")
+                                            email_details = {"sender":sender_email_addr, "cc":cc_email_addr, "subject":subject, "body": email_body}
+
+                                            email_draft = Email_Draft()
+                                            status, response = email_draft.draft_email(email_config, email_details, openai_Response['message'])
+                                            logger.log(f"status ::: {status}")
+                                        else :
+                                            message = f"Invalid response method received '{responseMethod}' for category : '{emailCategory}'"
+                                            raise ValueError(message)
+                                    elif Model_Name == "LocalAI":
+                                        logger.log("localAI")
+                                        Detect_Email_category = False
+                                        LocalAI_Response = emailCategory
+                                        logger.log(f"Process LocalAI_Response ::: {LocalAI_Response}\n")
+                                        email_details = {"sender":sender_email_addr, "cc":cc_email_addr, "subject":subject, "body": email_body}
+
+                                        email_draft = Email_Draft()
+                                        status, response = email_draft.draft_email(email_config, email_details, LocalAI_Response)
+                                        logger.log(f"status ::: {status}")
+                                    elif Model_Name == "GeminiAI":
+                                        logger.log("GeminiAI")
+                                        Detect_Email_category = False
+                                        GeminiAI_Response = emailCategory
+                                        logger.log(f"Process GeminiAI_Response ::: {GeminiAI_Response}\n")
+                                        email_details = {"sender":sender_email_addr, "cc":cc_email_addr, "subject":subject, "body": email_body}
+
+                                        email_draft = Email_Draft()
+                                        status, response = email_draft.draft_email(email_config, email_details, GeminiAI_Response)
+                                        logger.log(f"status ::: {status}")
+                                    else:
+                                        raise ValueError(f"Invalid Model Name provided : '{Model_Name}'")
+
+                                elif emailCategory == "Purchase Order":
+                                    responseMethod, parameters = self.get_JsonArray_values(emailCategory, file_JsonArray)
+                                    logger.log(f"responseMethod ::: {responseMethod}")
+                                    logger.log(f"parameters ::: {parameters}")
+                                    if responseMethod == "Upload_Document" :
+                                        
+                                        if len(fileName) != 0 :   
+
+                                            email_upload_document = Email_DocumentUploader()               
+                                            with open(f"temp/{fileName}", "rb") as file:
+                                                response_status, restAPI_Result = email_upload_document.email_document_upload(file, parameters)
+                                                logger.log(f"email_upload_document_response ::: {restAPI_Result}")
+                                        else:
+                                            
+                                            new_fileName = self.create_file_from_emailBody(email_body, sender_email_addr, parameters)
+                                            with open(f"temp/{new_fileName}", "rb") as file:
+                                                response_status, restAPI_Result = email_upload_document.email_document_upload(file, parameters)
+                                                logger.log(f"email_upload_document_response ::: {restAPI_Result}")
+
+                                        if response_status == "200" :
+                                            logger.log(f"Attachment uploaded sucessfully against Document id: '{restAPI_Result}'.")
+                                        else:
+                                            logger.log(restAPI_Result)
+                                    
+                                    else :
+                                        message = f"Invalid response method received '{responseMethod}' for category : '{emailCategory}'"
+                                        raise ValueError(message)
+                                else:
+                                    message = f"Detected Email category not found : '{emailCategory}'"
+                                    raise ValueError(message)
+            time.sleep(10)
+        
+        # except Exception as e:
+        #     return {"status": "Failed", "message": f"Error reading emails: {str(e)}"}
+        # finally:
+        #     try:
+        #         mail.close()
+        #         mail.logout()
+        #     except Exception as close_error:
+        #         logger.log(f"Error during mail close/logout: {str(close_error)}")
+        #         return {"status": "Failed", "message": f"Error reading emails: {str(close_error)}"}
+
     def save_attachment(self, part, download_dir):
         try:
             filename = part.get_filename()
@@ -109,11 +274,8 @@ class Email_Read:
         except Exception as e:
             return {"success": "Failed", "message": f"Error saving attachment: {str(e)}"}
 
-    def Read_Email(self):
+    def Read_Email(self, data):
         try:
-            data = request.get_data('jsonData', None)
-            data = json.loads(data[9:])
-            logger.log(f"jsondata:: {data}")
 
             reciever_email_addr = data.get("reciever_email_addr")
             receiver_email_pwd = data.get("receiver_email_pwd")
@@ -141,5 +303,101 @@ class Email_Read:
         except Exception as e:
             logger.log(f"Error in Read_Email: {str(e)}")
 
+    def download_attachment(self, msg):
+        filepath                = ""
+        filename                = ""
+        ATTACHMENT_SAVE_PATH    = "temp"
+
+        for part in msg.walk():
+            if part.get_content_maintype() == 'multipart':
+                continue
+            if part.get('Content-Disposition') is None:
+                continue
+            filename = part.get_filename()
+            if filename:
+                if not os.path.exists(ATTACHMENT_SAVE_PATH):
+                    os.mkdir(ATTACHMENT_SAVE_PATH)
+                    filepath = os.path.join(ATTACHMENT_SAVE_PATH, filename)
+                else:
+                    filepath = os.path.join(ATTACHMENT_SAVE_PATH, filename)
+                with open(filepath, 'wb') as f:
+                    f.write(part.get_payload(decode=True))
+                logger.log(f"\nAttachment saved: '{filepath}'")
+            else:
+                logger.log("\nNo Attachment found.")
+        return filename
+    
+    def read_JSON_File(self, json_fileName):
+        category_list               = []
+        categories                  = ""
+        try:
+            if os.path.exists(json_fileName):
+                with open(json_fileName, "r") as fileObj:
+                    file_JsonArray = json.load(fileObj) 
+                    
+                    for eachJson in file_JsonArray :
+                        for key, value in eachJson.items():
+                            if key == "Category" and value:
+                                category_list.append(value)
+                        # categories = ", ".join(category_list)
+                        
+                return file_JsonArray, category_list
+
+            else:
+                message = f"{json_fileName} file not found."
+                raise Exception(message)
+        except Exception as e:
+            msg = f"'{json_fileName}' file is empty. Please provide JSON parameters in the filename."
+            trace = traceback.format_exc()
+            logger.log(f"Exception in writeJsonFile: {msg} \n {trace} \n DataType ::: {type(msg)}")
+            raise Exception(msg)
+        
+    def get_JsonArray_values(self, category, jsonArray):
+        responseMethod  = ""
+        parameters      = ""
+        
+        for eachJson in jsonArray :
+            for key, value in eachJson.items():
+                if value == category:
+                    responseMethod  = eachJson["Response_Method"]  
+                    parameters      = eachJson["Parameters"]
+        
+        return responseMethod, parameters
+    
+    def create_file_from_emailBody(self, text, sender_email_addr, parameters):
+        
+        dir      = "temp/"
+        if not os.path.exists(dir):
+            os.mkdir(dir)
+        fileName = sender_email_addr[sender_email_addr.find("<")+1:sender_email_addr.find("@")].strip().replace(".","_")
+        logger.log(f"{fileName = }")
+        
+        if parameters["FILE_TYPE"] == "pdf":
+            fileName = fileName + ".pdf"
+            filePath = dir + fileName 
+
+            pdf = FPDF()
+            pdf.add_page()
+            pdf.set_font("Arial", size=12)
+            pdf.multi_cell(0, 10, text)
+            pdf.output(filePath)
+            logger.log(f"New PDF file created from email body and stored in '{filePath}'")
+
+        elif parameters["FILE_TYPE"] == "txt":
+            fileName = fileName + ".txt"
+            filePath = dir + fileName 
+
+            with  open(filePath, "w") as file:
+                file.write(text)
+                logger.log(f"New TXT file created from email body and stored in '{filePath}'")
+        else:
+            message = f"Invalid File Type received. "
+            self.send_response(200)
+            self.send_header('Content-type', 'text/html')
+            self.end_headers()
+            self.wfile.write(message.encode('utf-8'))
+
+        return fileName
+
         
 

{AIEmailAutomationUtility-0.0.9.dist-info → AIEmailAutomationUtility-0.0.10.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: AIEmailAutomationUtility
-Version: 0.0.9
-Summary: Change the logic of return exception value
+Version: 0.0.10
+Summary: Create 2 different methods in read_email for different client
 Author: Proteus Technology PVT. LTD.
 Author-email: <apps@baseinformation.com>
 Keywords: python,first package
@@ -13,4 +13,4 @@ Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 License-File: LICENCE.txt
 
-Change the logic of return exception value
+Create 2 different methods in read_email for different client

AIEmailAutomationUtility-0.0.10.dist-info/RECORD

@@ -0,0 +1,14 @@
+AIEmailAutomationUtility/EmailReplyAssistant.py,sha256=NQlBPugGdEvNwGFOoaiJNb4JDQB_DYvCy_hWLgAVLns,3938
+AIEmailAutomationUtility/Email_Classification.py,sha256=eL52Td50zo7V0QTIqjN4Khhg-5HKvf2RUITIcKz5yZ0,9343
+AIEmailAutomationUtility/Email_DocumentUploader.py,sha256=ImTmMz_JeU6Xynt9kyu7lFv7vqrxzqAtBF-A7014fYc,3055
+AIEmailAutomationUtility/Email_Draft.py,sha256=BfseewnnlwNl1moodq3kZiUPXDUE9a_nQjuFQsUp3fY,5244
+AIEmailAutomationUtility/Email_Read.py,sha256=bmRS_jt_v0BxsOWQZcH12VKhcWUbc9dNuw3qkvbGCN4,20516
+AIEmailAutomationUtility/Email_Upload_Document.py,sha256=3bdkxfDlwoeRp-46KPw2Gs1dqBhEIoA1yE5GCudpdV8,1320
+AIEmailAutomationUtility/Save_Draft.py,sha256=yzLgFN14I_lXE6qL0I3tKNduvcnWdbsY9i2mKdTtio4,5348
+AIEmailAutomationUtility/Save_Transaction.py,sha256=Gg1w6hhzHmEFjsuzYvkq-3-EsWReetjLHsYSv5YIGgM,3816
+AIEmailAutomationUtility/__init__.py,sha256=bB7N-qQD85RdMaXHg_ZU5oPtHtx9zgeG6-ue4rhcfYI,379
+AIEmailAutomationUtility-0.0.10.dist-info/LICENCE.txt,sha256=2qX9IkEUBx0VJp1Vh9O2dsRwE-IpYId0lXDyn7OVsJ8,1073
+AIEmailAutomationUtility-0.0.10.dist-info/METADATA,sha256=iG4GkrRFAa5-1rXSU-nXQmnMbSqkIso7QKXPF7j4S78,623
+AIEmailAutomationUtility-0.0.10.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+AIEmailAutomationUtility-0.0.10.dist-info/top_level.txt,sha256=3jTWrTUblVkaP7mpwY2UBSnrlfot5Ykpfsehyke-Uzw,25
+AIEmailAutomationUtility-0.0.10.dist-info/RECORD,,

AIEmailAutomationUtility-0.0.9.dist-info/RECORD

@@ -1,14 +0,0 @@
-AIEmailAutomationUtility/EmailReplyAssistant.py,sha256=jFkOA0yfxRybICjeKsq4xDetTr6vPjkprkrXATsUpH8,4071
-AIEmailAutomationUtility/Email_Classification.py,sha256=NhJwKFGVjLd4BsIFPAWs9qKAUYTxRTYyWd-BvjONXF0,9476
-AIEmailAutomationUtility/Email_DocumentUploader.py,sha256=0AWcwAx7x4WiZwFBxHwdFpUfE9wjvLGcaxT_95bqRcY,3496
-AIEmailAutomationUtility/Email_Draft.py,sha256=WUdaSLk4xTwMs1wSOUXE2xiDUehsZQ2wGqvWtXbjeo0,5427
-AIEmailAutomationUtility/Email_Read.py,sha256=ScuF5zFimkiIUX91-WhgNL18RbhHrcWe7fbbRwDGB7w,6717
-AIEmailAutomationUtility/Email_Upload_Document.py,sha256=3bdkxfDlwoeRp-46KPw2Gs1dqBhEIoA1yE5GCudpdV8,1320
-AIEmailAutomationUtility/Save_Draft.py,sha256=yzLgFN14I_lXE6qL0I3tKNduvcnWdbsY9i2mKdTtio4,5348
-AIEmailAutomationUtility/Save_Transaction.py,sha256=Gg1w6hhzHmEFjsuzYvkq-3-EsWReetjLHsYSv5YIGgM,3816
-AIEmailAutomationUtility/__init__.py,sha256=bB7N-qQD85RdMaXHg_ZU5oPtHtx9zgeG6-ue4rhcfYI,379
-AIEmailAutomationUtility-0.0.9.dist-info/LICENCE.txt,sha256=2qX9IkEUBx0VJp1Vh9O2dsRwE-IpYId0lXDyn7OVsJ8,1073
-AIEmailAutomationUtility-0.0.9.dist-info/METADATA,sha256=mkiZRpGQHUuxEyDs1rK4af1Zte1vzUNdvUrH-wlPnLo,584
-AIEmailAutomationUtility-0.0.9.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-AIEmailAutomationUtility-0.0.9.dist-info/top_level.txt,sha256=3jTWrTUblVkaP7mpwY2UBSnrlfot5Ykpfsehyke-Uzw,25
-AIEmailAutomationUtility-0.0.9.dist-info/RECORD,,