AIEmailAutomationUtility 0.0.17__py3-none-any.whl → 0.0.19__py3-none-any.whl

AIEmailAutomationUtility/EmailReplyAssistant.py

@@ -7,36 +7,35 @@ import loggerutility as logger
 import ast, re
 
 class EmailReplyAssistant:
+    class EventHandler(AssistantEventHandler):
+        def __init__(self):
+            super().__init__()
+            self.delta_values = []
+
+        def on_text_created(self, text):
+            if isinstance(text, str):
+                logger.log(f"\nAssistant: {text}")
+
+        def on_text_delta(self, delta, snapshot):
+            self.delta_values.append(delta.value)
+
+        def on_tool_call_created(self, tool_call):
+            logger.log(f"\nAssistant: {tool_call.type}\n")
+
+        def on_tool_call_delta(self, delta, snapshot):
+            if delta.type == 'code_interpreter':
+                if delta.code_interpreter.input:
+                    logger.log(delta.code_interpreter.input)
+                if delta.code_interpreter.outputs:
+                    logger.log(f"\n\nOutput >", flush=True)
+                    for output in delta.code_interpreter.outputs:
+                        if output.type == "logs":
+                            logger.log(output.logs, flush=True)
     def __init__(self):
         pass
 
     def Reply_Email_Ai_Assistant(self, openAI_key, assistant_ID, email_content, subject):
         try:
-            class EventHandler(AssistantEventHandler):
-                def __init__(self):
-                    super().__init__()
-                    self.delta_values = []
-
-                def on_text_created(self, text):
-                    if isinstance(text, str):
-                        logger.log(f"\nAssistant: {text}")
-
-                def on_text_delta(self, delta, snapshot):
-                    self.delta_values.append(delta.value)
-
-                def on_tool_call_created(self, tool_call):
-                    logger.log(f"\nAssistant: {tool_call.type}\n")
-
-                def on_tool_call_delta(self, delta, snapshot):
-                    if delta.type == 'code_interpreter':
-                        if delta.code_interpreter.input:
-                            logger.log(delta.code_interpreter.input)
-                        if delta.code_interpreter.outputs:
-                            logger.log(f"\n\nOutput >", flush=True)
-                            for output in delta.code_interpreter.outputs:
-                                if output.type == "logs":
-                                    logger.log(output.logs, flush=True)
-
             openAI_response = ""
             client = OpenAI(api_key=openAI_key)
             thread = client.beta.threads.create()
@@ -47,7 +46,7 @@ class EmailReplyAssistant:
                 content=f"subject:{subject}\nemail body:{email_content}",
             )
 
-            event_handler = EventHandler()
+            event_handler = EmailReplyAssistant().EventHandler()
 
             with client.beta.threads.runs.stream(
                 thread_id=thread.id,
@@ -92,4 +91,66 @@ class EmailReplyAssistant:
             return email_response
 
         except Exception as e:
-            logger.log(f"Error in Read_Email: {str(e)}")
+            logger.log(f"Error in Read_Email: {str(e)}")
+
+    def identify_customer_product_reply_assitant(self, openAI_key, assistant_ID, email_content, subject, prompt):
+        try:
+            openAI_response = ""
+            client = OpenAI(api_key=openAI_key)
+            thread = client.beta.threads.create()
+
+            client.beta.threads.messages.create(
+                thread_id=thread.id,
+                role="user",
+                content=f"subject:{subject}\nemail body:{email_content}",
+            )
+
+            event_handler = EmailReplyAssistant().EventHandler()
+
+            with client.beta.threads.runs.stream(
+                thread_id=thread.id,
+                assistant_id=assistant_ID,
+                instructions=prompt,
+                event_handler=event_handler,
+            ) as stream:
+                stream.until_done()
+
+            delta_values = event_handler.delta_values
+            openAI_response = ''.join(delta_values)
+            logger.log(f"openAI_response ::: {openAI_response}")
+            formated_openAI_response = openAI_response.replace("\n```", "").replace("```", "").replace("json","").replace("JSON","").replace("csv","").replace("CSV","").replace("html","")
+            return {"status": "Success", "message": formated_openAI_response}
+
+        except Exception as error:
+            return {"status": "Failed", "message": error}
+        
+    def create_quotation_draft(self, openAI_key, assistant_ID, email_content, subject, prompt):
+        try:
+            openAI_response = ""
+            client = OpenAI(api_key=openAI_key)
+            thread = client.beta.threads.create()
+
+            client.beta.threads.messages.create(
+                thread_id=thread.id,
+                role="user",
+                content=f"subject:{subject}\nemail body:{email_content}",
+            )
+
+            event_handler = EmailReplyAssistant().EventHandler()
+
+            with client.beta.threads.runs.stream(
+                thread_id=thread.id,
+                assistant_id=assistant_ID,
+                instructions=prompt,
+                event_handler=event_handler,
+            ) as stream:
+                stream.until_done()
+
+            delta_values = event_handler.delta_values
+            openAI_response = ''.join(delta_values)
+            logger.log(f"openAI_response ::: {openAI_response}")
+            formated_openAI_response = openAI_response.replace("\n```", "").replace("```", "").replace("json","").replace("JSON","").replace("csv","").replace("CSV","").replace("html","")
+            return formated_openAI_response
+
+        except Exception as error:
+            return None

AIEmailAutomationUtility/Email_Classification.py

@@ -59,11 +59,12 @@ class Email_Classification:
             }
 
             genai.configure(api_key=gemini_api_key)
-            model = genai.GenerativeModel('gemini-1.0-pro')
+            # model = genai.GenerativeModel('gemini-1.0-pro')
+            model = genai.GenerativeModel('gemini-1.5-pro-latest')
             response = model.generate_content(message_list)
 
-            logger.log(f"Input Question ::: {email_body}\ngemini-1.0-pro Response::: {response} {type(response)}")
-            logger.log(f"\n\nResponse GeminiAI endpoint::::: {response} \n{type(response)}", "0")
+            # logger.log(f"Input Question ::: {email_body}\ngemini-1.0-pro Response::: {response} {type(response)}")
+            # logger.log(f"\n\nResponse GeminiAI endpoint::::: {response} \n{type(response)}", "0")
 
             final_result = ""
             for part in response:

AIEmailAutomationUtility/Email_DocumentUploader.py

@@ -4,15 +4,16 @@ import shutil
 import requests
 import loggerutility as logger
 from flask import Flask,request
+from datetime import datetime
+
 
 class Email_DocumentUploader:
     def upload_document(self, upload_config, file_data):
         # try:
         logger.log("inside function" )
         # Create temp directory if needed
-        temp_dir = "temp"
-        if not os.path.exists(temp_dir):
-            os.makedirs(temp_dir)
+        today_date = datetime.today().strftime('%Y-%m-%d')
+        temp_dir = os.path.join("ORDERS", today_date)
             
         # Save file temporarily
         file_path = os.path.join(temp_dir, file_data['filename'])
@@ -50,6 +51,7 @@ class Email_DocumentUploader:
         
         if response.status_code == 200:
             result = json.loads(response.text)
+            logger.log(f"file Upload Response ::: {result}")
             document_id = result["ID"]["Document_Id"]
             return str(response.status_code), document_id
         else:

AIEmailAutomationUtility/Email_Draft.py

@@ -6,6 +6,8 @@ import time
 import loggerutility as logger
 from flask import Flask,request
 import json
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
 
 class Email_Draft:
     def draft_email(self, email_config, email_details, response_content):
@@ -33,7 +35,63 @@ class Email_Draft:
                 return True, utf8_message.decode("utf-8")
                 
         except Exception as e:
-            logger.log(f"Error creating draft: {str(e)}")
+            return False, str(e)
+
+    def quotation_draft_email(self, email_config, email_details, response_content):
+        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'])
+
+                # Create the email object
+                message = MIMEMultipart("alternative")
+                message["From"] = email_config['email']
+                message["To"] = email_details['sender']
+                message["CC"] = email_details['cc']
+
+                # Set the subject with "Re:" prefix
+                subject = email_details['subject']
+                if not subject.startswith("Re:"):
+                    subject = f"Re: {subject}"
+                message["Subject"] = subject
+
+                # Email details for original message
+                mail_details = f'{datetime.datetime.now().strftime("On %a, %b %d, %Y at %I:%M %p")} {email_details["sender"]} wrote:'
+
+                # Extract response content
+                body = response_content.get('body', '')
+                table_html = response_content.get('table_', '')
+                signature = response_content.get('signature', '')
+                email_body = email_details['body']
+
+                # Replace new lines with <br> for proper HTML formatting
+                body_html = body.replace("\n", "<br>")
+                signature_html = signature.replace("\n", "<br>")
+                email_body_html = email_body.replace("\n", "<br>")
+
+                # Create HTML content
+                html_content = (
+                    "<html><body>"
+                    f"<p>{body_html}</p>"
+                    f"{table_html}"
+                    f"<p>{signature_html}</p>"
+                    "<hr>"
+                    f"<p>{mail_details}</p>"
+                    f"<p>{email_body_html}</p>"
+                    "</body></html>"
+                )
+
+                # Attach HTML content
+                message.attach(MIMEText(html_content, "html"))
+
+                utf8_message = message.as_string().encode("utf-8")
+
+                # Append the draft to Gmail
+                imap_ssl.append("[Gmail]/Drafts", '', imaplib.Time2Internaldate(time.time()), utf8_message)
+
+                return True, utf8_message.decode("utf-8")
+
+        except Exception as e:
+            return False, str(e)
 
     def draft_email_response(self, email_details):
         try:

AIEmailAutomationUtility/Email_Read.py

@@ -7,6 +7,11 @@ import loggerutility as logger
 from flask import request
 import traceback
 from fpdf import FPDF
+from openai import OpenAI
+import requests
+import openai
+import google.generativeai as genai
+from datetime import datetime
 
 from .Save_Transaction import Save_Transaction
 from .Email_Upload_Document import Email_Upload_Document
@@ -14,6 +19,7 @@ from .Email_Classification import Email_Classification
 from .EmailReplyAssistant import EmailReplyAssistant
 from .Email_Draft import Email_Draft
 from .Email_DocumentUploader import Email_DocumentUploader
+import sqlite3
 
 class Email_Read:
     def read_email(self, email_config):
@@ -92,8 +98,8 @@ class Email_Read:
         fileName                    = ""
 
         Model_Name =  email_config.get('model_type', 'OpenAI') 
-        reciever_email_addr =  email_config.get('email', '') 
-        receiver_email_pwd =  email_config.get('password', '') 
+        reciever_email_addr = email_config.get('email', '').replace("\xa0", "").strip()
+        receiver_email_pwd = email_config.get('password', '').replace("\xa0", "").strip()
         host =  email_config.get('host', '') 
         port =  email_config.get('port', '') 
 
@@ -135,7 +141,6 @@ class Email_Read:
                                     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')                              
                             
@@ -219,23 +224,32 @@ class Email_Read:
                                     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:
+                                    # Download the attachment
+                                    fileName = self.download_attachment(msg)
+
+                                    # Get today's date folder path
+                                    today_date = datetime.today().strftime('%Y-%m-%d')
+                                    order_folder = os.path.join("ORDERS", today_date)
+
+                                    if responseMethod == "Upload_Document":
+                                        if len(fileName) != 0:
+                                            email_upload_document = Email_DocumentUploader()
+                                            file_path = os.path.join(order_folder, fileName)  # Correct file path
+
+                                            with open(file_path, "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:
+                                            new_file_path = os.path.join(order_folder, new_fileName)
+
+                                            with open(new_file_path, "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}'.")
+                                        if response_status == "200":
+                                            logger.log(f"Attachment uploaded successfully against Document ID: '{restAPI_Result}'.")
                                         else:
                                             logger.log(restAPI_Result)
                                     
@@ -257,6 +271,443 @@ class Email_Read:
         #         logger.log(f"Error during mail close/logout: {str(close_error)}")
         #         return {"status": "Failed", "message": f"Error reading emails: {str(close_error)}"}
 
+    def read_email_quotation(self, email_config):
+        # try:
+        logger.log(f"inside read_email_automation")
+        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', '').replace("\xa0", "").strip()
+        receiver_email_pwd = email_config.get('password', '').replace("\xa0", "").strip()
+        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')
+                            else:
+                                email_body = msg.get_payload(decode=True).decode('utf-8', errors='replace')                              
+                            
+                            openai_Process_Input  = email_body 
+                            logger.log(f"\nEmail Subject::: {subject}")
+                            logger.log(f"\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', '') 
+                            logger.log(f"\ngeminiAI_APIKey::: {geminiAI_APIKey}")
+                            logger.log(f"\nlocalAIURL::: {localAIURL}")
+                            logger.log(f"\nsignature::: {signature}")
+                            
+                            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 == "Quotation":
+                                    responseMethod, parameters = self.get_JsonArray_values(emailCategory, file_JsonArray)
+                                    
+                                    logger.log(f"Inside Quotation")
+                                    # Step 4: Identify customer from email using AI
+                                    customer_data = self.identify_customer(email_body, subject, Model_Name, openai_api_key, geminiAI_APIKey, localAIURL, parameters["Customer_Assistant_Id"])
+                                    logger.log(f"Identified customer: {customer_data}")
+                                    
+                                    # Step 5: Identify product from email using AI
+                                    products = self.identify_products(email_body, subject, Model_Name, openai_api_key, geminiAI_APIKey, localAIURL, parameters["Product_Assistant_Id"])
+                                    
+                                    for product in products:
+                                        db_connection = sqlite3.connect('price_list.db')
+                                        cursor = db_connection.cursor()
+
+                                        # Get rate from SQLite database
+                                        query = f'SELECT Price FROM price_list_table WHERE "Item No." = "{product.get("item_no", "")}";'
+                                        cursor.execute(query)
+                                        result = cursor.fetchone()
+                                        
+                                        if result:
+                                            rate = result[0]  
+                                            product["rate"] = rate
+                                        else:
+                                            product["rate"] = None
+                                    
+                                    logger.log(f"Identified products: {products}")
+                                    logger.log(f"Identified products length: {len(products)}")
+                                    quotation_draft = self.generate_quotation_draft(
+                                        customer_data, 
+                                        products,
+                                        Model_Name, 
+                                        openai_api_key, 
+                                        geminiAI_APIKey, 
+                                        localAIURL,
+                                        parameters["Customer_Assistant_Id"],
+                                        email_body, 
+                                        subject,
+                                        signature
+                                    )
+                                    logger.log(f"quotation_draft ::: {quotation_draft}")
+                                    
+                                    # Step 8: Send draft quotation email
+                                    email_details = {"sender":sender_email_addr, "cc":cc_email_addr, "subject":subject, "body": email_body}
+                                    email_draft = Email_Draft()
+                                    status, response = email_draft.quotation_draft_email(email_config, email_details, quotation_draft)
+                                    logger.log(f"status ::: {status}")
+                                    
+                                    logger.log(f"Quotation email sent to {sender_email_addr}")
+                                    
+                                else:
+                                    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.")
+
+            time.sleep(10)
+
+    def identify_customer(self, email_body, subject, model_type, openai_api_key, gemini_api_key, local_ai_url, assistant_id):
+        logger.log("Inside identify_customer")        
+        
+        if model_type == "OpenAI":
+            prompt = f"""Identify the customer code, customer name in json format from the following email {email_body} and received from {subject}. Do not include any instruction as the output will be directly in a program."""
+            emailreplyassistant = EmailReplyAssistant()
+            ai_result = emailreplyassistant.identify_customer_product_reply_assitant(openai_api_key, assistant_id, email_body, subject, prompt)
+
+        elif model_type == "GeminiAI": 
+            prompt = f"""Identify the customer code, customer name in json format from the following email {email_body} and received from {subject}. Do not include any instruction as the output will be directly in a program."""
+            ai_result = self.identify_customer_product_GeminiAI(gemini_api_key, email_body, prompt)
+
+        elif model_type == "LocalAI":
+            prompt = f"""Identify the customer code and customer name in JSON format from the following email: {email_body}, received from {subject}. 
+            If no customer details are found, return:{{"customer_name": "","customer_code": ""}}Only return the JSON object. No explanations, no additional text."""
+            ai_result = self.identify_customer_product_LocalAI(openai_api_key, email_body, local_ai_url, prompt)
+
+        else:
+            ai_result = "{}"
+        
+        customer_data = {}
+        if ai_result["status"] == "Success":
+            customer_data = json.loads(ai_result["message"])
+        else:            
+            customer_data = {
+                "customer_name": "",
+                "customer_code": ""
+            }
+        return customer_data
+    
+    def identify_products(self, email_body, subject, model_type, openai_api_key, gemini_api_key, local_ai_url, assistant_id):
+        logger.log("Inside identify_products")    
+        
+        if model_type == "OpenAI":
+            prompt = f"""
+                Can you give me price information of all products in following format requested_description, item_no, make, description, price, price unit, inventory unit for following items in strictly in JSON String format {email_body}. 
+                If there is one product or multiple should return in list. 
+                Do not include any instruction as the output will be directly in a program.
+                """
+            emailreplyassistant = EmailReplyAssistant()
+            ai_result = emailreplyassistant.identify_customer_product_reply_assitant(openai_api_key, assistant_id, email_body, subject, prompt)
+
+        elif model_type == "GeminiAI":
+            prompt = f"""
+                Can you give me price information of all products in following format requested_description, item_no, make, description, price, price unit, inventory unit for following items in strictly in JSON String format {email_body}. 
+                If there is one product or multiple should return in list. 
+                Do not include any instruction as the output will be directly in a program.
+                """
+            ai_result = self.identify_customer_product_GeminiAI(gemini_api_key, email_body, prompt)
+
+        elif model_type == "LocalAI":
+            prompt = f"""Can you give me price information in following format requested_description, item_no, make, description, price, price unit, inventory unit for following items it strictly in json format which loads directly in json {email_body}. If there is one product or multiple should return in list. 
+            If no product details are found, return:[] Only return the JSON object. No explanations, no additional text."""
+            ai_result = self.identify_customer_product_LocalAI(openai_api_key, email_body, local_ai_url, prompt)
+
+        else:
+            ai_result = "{}"
+        
+        product_data = {}
+        if ai_result["status"] == "Success":
+            logger.log(f"ai_result ::: {ai_result}")   
+            product_data = json.loads(ai_result["message"])
+        else:            
+            product_data = []
+        return product_data
+    
+    def generate_quotation_draft(self, customer_data, products, model_type, openai_api_key, gemini_api_key, local_ai_url, assistant_id, email_body, subject, signature):
+        logger.log("Inside generate_quotation_draft")   
+        
+        customer = customer_data
+        
+        product_table = "Products:\n"
+        for product in products:
+            product_table += f'- {product.get("requested_description")} (Code: {product.get("item_no")}) = ${product.get("rate")}\n'
+        
+        if model_type == "OpenAI":
+            prompt = f"""
+                Generate product information in HTML tabular format with line separators for rows and columns in a draft reply based on the following information:
+
+                Customer: {customer.get('customer_name', '')}  
+                Customer Code: {customer.get('customer_code', '')}  
+
+                {product_table}  
+                product_table must contain only price column even if it is none(set it as -).
+                Original Email Subject: {subject}  
+
+                Return only the following JSON String format:
+                {{
+                    "email_body": {{
+                        "body": "Draft email body proper response, It should not be same like mail content and does not having any signature part like Best regards.",
+                        "table_html": "Table Details with Sr. No. in HTML",
+                        "signature": "{signature}"
+                    }}
+                }}
+
+                Do not include signature in body and any instructions, explanations, or additional text—only the JSON object.
+            """
+            logger.log(f"Quotation draft ::: {prompt}")
+            emailreplyassistant = EmailReplyAssistant()
+            ai_result = emailreplyassistant.create_quotation_draft(openai_api_key, assistant_id, email_body, subject, prompt)   
+
+        elif model_type == "GeminiAI":
+            prompt = f"""
+                Generate product information in HTML tabular format with line separators for rows and columns in a draft reply based on the following information:
+
+                Customer: {customer.get('customer_name', '')}  
+                Customer Code: {customer.get('customer_code', '')}  
+
+                {product_table}  
+                product_table must contain only price column even if it is none(set it as -).
+                Original Email Subject: {subject}  
+
+                Return only the following JSON String format:
+                {{
+                    "email_body": {{
+                        "body": "Draft email body proper response, It should not be same like mail content and does not having any signature part like Best regards.",
+                        "table_html": "Table Details with Sr. No. in HTML",
+                        "signature": "{signature}"
+                    }}
+                }}
+
+                Do not include signature in body and any instructions, explanations, or additional text—only the JSON object.
+            """
+            logger.log(f"Quotation draft ::: {prompt}")
+            ai_result = self.create_quotation_draft_GeminiAI(gemini_api_key, email_body, prompt)
+
+        elif model_type == "LocalAI":
+            prompt = f"""
+                Generate product information in HTML tabular format with line separators for rows and columns in a draft reply based on the following information:
+
+                Customer: {customer.get('customer_name', '')}  
+                Customer Code: {customer.get('customer_code', '')}  
+
+                {product_table}  
+                - The table must contain the **Price** column, even if it is empty (set it as `-` if None).  
+                - The table should include **Sr. No.** as the first column.  
+                - Format the table with `<table>`, `<tr>`, `<th>`, and `<td>` tags with some border to table.
+
+                Original Email Subject: {subject}  
+
+                Return **strictly** in the following JSON String format:
+                - All keys must be: `body`, `table_`, and `signature` inside the `email_body` JSON.  
+                - **Do not include** `\n`, `\`, `\\`, or any unnecessary escape characters.  
+                - Do not include instructions, explanations, or additional text—only the JSON object.  
+
+                Format:
+                {{
+                    "email_body": {{
+                        "body": "Draft email body proper response, It should not contain the table or signature.",
+                        "table_": "Table Details with Sr. No. in HTML only",
+                        "signature": "{signature}"
+                    }}
+                }}
+            """
+            logger.log(f"Quotation draft ::: {prompt}")
+            ai_result = self.create_quotation_draft_LocalAI(openai_api_key, email_body, local_ai_url, prompt)
+
+        else:
+            ai_result = "Error: Unable to generate quotation draft. Please check the configuration."
+        
+        logger.log(f"Quotation draft ai_result::: {ai_result}")
+        quotation_draft_data = None
+        if ai_result != None:
+            quotation_draft_data = json.loads(ai_result)["email_body"]
+        return quotation_draft_data
+
+    def identify_customer_product_LocalAI(self, openai_api_key, email_body, local_ai_url, prompt):
+        logger.log("Inside identify_customer_product_LocalAI")   
+        try:
+            message = [{
+                "role": "user",
+                "content": f"{prompt}"
+            }]
+
+            logger.log(f"Final Local AI message for detecting category::: {message}")
+            openai.api_key = openai_api_key
+            client = OpenAI(base_url=local_ai_url, api_key="lm-studio")
+            completion = client.chat.completions.create(
+                model="mistral",
+                messages=message,
+                temperature=0,
+                stream=False,
+                max_tokens=4096
+            )
+
+            final_result = str(completion.choices[0].message.content)
+            final_result = final_result.replace("\n```", "").replace("```", "").replace("json","").replace("JSON","").replace("csv","").replace("CSV","").replace("html","")
+            logger.log(f"finalResult:520  {final_result}")
+            return {"status": "Success", "message": final_result}
+
+        except Exception as e:
+            logger.log(f"Error with LocalAI detection/generation: {str(e)}")
+            return {"success": "Failed", "message": f"Error with LocalAI detection/generation: {str(e)}"}
+        
+    def create_quotation_draft_LocalAI(self, openai_api_key, email_body, local_ai_url, prompt):
+        logger.log("Inside create_quotation_draft_LocalAI")   
+        try:
+            message = [{
+                "role": "user",
+                "content": f"{prompt}"
+            }]
+
+            logger.log(f"Final Local AI message for detecting category::: {message}")
+            openai.api_key = openai_api_key
+            client = OpenAI(base_url=local_ai_url, api_key="lm-studio")
+            completion = client.chat.completions.create(
+                model="mistral",
+                messages=message,
+                temperature=0,
+                stream=False,
+                max_tokens=4096
+            )
+
+            final_result = str(completion.choices[0].message.content)
+            final_result = final_result.replace("\n```", "").replace("```", "").replace("json","").replace("JSON","").replace("csv","").replace("CSV","").replace("html","")
+            logger.log(f"finalResult:520  {final_result}")
+            return final_result
+
+        except Exception as e:
+            logger.log(f"Error with LocalAI detection/generation: {str(e)}")
+            return str(e)
+        
+    def identify_customer_product_GeminiAI(self, gemini_api_key, email_body, prompt):
+        logger.log("Inside identify_customer_product_GeminiAI")   
+        try:
+            message = [{
+                "role": "user",
+                "content": f"{prompt}"
+            }]
+
+            logger.log(f"Final Gemini AI message for detecting category::: {message}")
+            message_list = str(message)
+
+            genai.configure(api_key=gemini_api_key)
+            # model = genai.GenerativeModel('gemini-1.0-pro')
+            model = genai.GenerativeModel('gemini-1.5-pro-latest')
+            response = model.generate_content(message_list)
+            
+            final_result = ""
+            for part in response:
+                final_result = part.text
+                logger.log(f"response:::  {final_result}")
+                if final_result:
+                    try:
+                        final_result = final_result.replace("\\", "").replace('```', '').replace('json', '')
+                        if final_result.startswith("{{") and final_result.endswith("}}"):
+                            final_result = final_result[1:-1]
+                    except json.JSONDecodeError:
+                        logger.log(f"Exception : Invalid JSON Response GEMINI 1.5: {final_result} {type(final_result)}")
+
+            logger.log(f"finalResult:::  {final_result}")
+            return {"status": "Success", "message": final_result}
+
+        except Exception as e:
+            logger.log(f"Error with Gemini AI detection/generation: {str(e)}")
+            return {"success": "Failed", "message": f"Error with Gemini AI detection/generation: {str(e)}"}
+        
+    def create_quotation_draft_GeminiAI(self, gemini_api_key, email_body, prompt):
+        logger.log("Inside identify_customer_product_GeminiAI")   
+        try:
+            message = [{
+                "role": "user",
+                "content": f"{prompt}"
+            }]
+
+            logger.log(f"Final Gemini AI message for detecting category::: {message}")
+            message_list = str(message)
+
+            genai.configure(api_key=gemini_api_key)
+            # model = genai.GenerativeModel('gemini-1.0-pro')
+            model = genai.GenerativeModel('gemini-1.5-pro-latest')
+            response = model.generate_content(message_list)
+            
+            final_result = ""
+            for part in response:
+                final_result = part.text
+                logger.log(f"response:::  {final_result}")
+                if final_result:
+                    try:
+                        final_result = final_result.replace("\\", "").replace('```', '').replace('json', '')
+                        if final_result.startswith("{{") and final_result.endswith("}}"):
+                            final_result = final_result[1:-1]
+                    except json.JSONDecodeError:
+                        logger.log(f"Exception : Invalid JSON Response GEMINI 1.5: {final_result} {type(final_result)}")
+
+            logger.log(f"finalResult:::  {final_result}")
+            return final_result
+
+        except Exception as e:
+            logger.log(f"Error with Gemini AI detection/generation: {str(e)}")
+            return {"success": "Failed", "message": f"Error with Gemini AI detection/generation: {str(e)}"}
+        
     def save_attachment(self, part, download_dir):
         try:
             filename = part.get_filename()
@@ -310,9 +761,14 @@ class Email_Read:
             logger.log(f"Error in Read_Email: {str(e)}")
 
     def download_attachment(self, msg):
-        filepath                = ""
-        filename                = ""
-        ATTACHMENT_SAVE_PATH    = "temp"
+        base_folder = "ORDERS"  # Main folder for storing orders
+        today_date = datetime.today().strftime('%Y-%m-%d')  # Format: YYYY-MM-DD
+        date_folder = os.path.join(base_folder, today_date)  # Path: ORDERS/YYYY-MM-DD
+
+        # Ensure folders exist
+        os.makedirs(date_folder, exist_ok=True)
+
+        filename = ""
 
         for part in msg.walk():
             if part.get_content_maintype() == 'multipart':
@@ -321,11 +777,8 @@ class Email_Read:
                 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)
+                filepath = os.path.join(date_folder, filename)  # Save inside date-wise folder
+
                 with open(filepath, 'wb') as f:
                     f.write(part.get_payload(decode=True))
                 logger.log(f"\nAttachment saved: '{filepath}'")
@@ -371,15 +824,19 @@ class Email_Read:
         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)
+        base_folder = "ORDERS"
+        today_date = datetime.today().strftime('%Y-%m-%d')  # Format: YYYY-MM-DD
+        order_folder = os.path.join(base_folder, today_date)
+
+        # Ensure the date-wise folder exists
+        os.makedirs(order_folder, exist_ok=True)
+
+        # Generate filename from sender's email
         fileName = sender_email_addr[sender_email_addr.find("<")+1:sender_email_addr.find("@")].strip().replace(".","_")
         
         if parameters["FILE_TYPE"] == "pdf":
             fileName = fileName + ".pdf"
-            filePath = dir + fileName 
+            filePath = os.path.join(order_folder, fileName)
 
             pdf = FPDF()
             pdf.add_page()
@@ -390,13 +847,13 @@ class Email_Read:
 
         elif parameters["FILE_TYPE"] == "txt":
             fileName = fileName + ".txt"
-            filePath = dir + fileName 
+            filePath = os.path.join(order_folder, fileName)
 
-            with  open(filePath, "w") as file:
+            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. "
+            message = f"Invalid File Type received."
             self.send_response(200)
             self.send_header('Content-type', 'text/html')
             self.end_headers()

{AIEmailAutomationUtility-0.0.17.dist-info → AIEmailAutomationUtility-0.0.19.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: AIEmailAutomationUtility
-Version: 0.0.17
-Summary: Remove save_draft class from this package
+Version: 0.0.19
+Summary: Add a code for creating a draft for the quotation category email.
 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
 
-Remove save_draft class from this package
+Add a code for creating a draft for the quotation category email.

AIEmailAutomationUtility-0.0.19.dist-info/RECORD

@@ -0,0 +1,13 @@
+AIEmailAutomationUtility/EmailReplyAssistant.py,sha256=oRobM6C1AwiRA3lQ2Sh51m-FaH2PpbUEidbkOG7O9Ww,6339
+AIEmailAutomationUtility/Email_Classification.py,sha256=anqJ0_Iyr4xRSSJBI3KkavELSoz_EENdbofr07NjTB0,9416
+AIEmailAutomationUtility/Email_DocumentUploader.py,sha256=P5P36rgDzALZEpO09aJWM0HEA-6vl48HNwz7GO6SbXc,3159
+AIEmailAutomationUtility/Email_Draft.py,sha256=QUJUpNWO8wdLl2x3eoN92jXVii8mpK8G3uwJn8ycYSY,7677
+AIEmailAutomationUtility/Email_Read.py,sha256=81RIJT8q-HEuKF5WCgMiGXgxHRcPTl-tI9GG0mlq91c,45524
+AIEmailAutomationUtility/Email_Upload_Document.py,sha256=3bdkxfDlwoeRp-46KPw2Gs1dqBhEIoA1yE5GCudpdV8,1320
+AIEmailAutomationUtility/Save_Transaction.py,sha256=Gg1w6hhzHmEFjsuzYvkq-3-EsWReetjLHsYSv5YIGgM,3816
+AIEmailAutomationUtility/__init__.py,sha256=UzDkFSvLwwc0NLnvMiM0jNV5pIWUlM9p2zvpcrh9rkM,344
+AIEmailAutomationUtility-0.0.19.dist-info/LICENCE.txt,sha256=2qX9IkEUBx0VJp1Vh9O2dsRwE-IpYId0lXDyn7OVsJ8,1073
+AIEmailAutomationUtility-0.0.19.dist-info/METADATA,sha256=6Vg6SHzfV00Wx-pXhls1DZOMlqnu3r6h-U8DJmO8mAw,631
+AIEmailAutomationUtility-0.0.19.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+AIEmailAutomationUtility-0.0.19.dist-info/top_level.txt,sha256=3jTWrTUblVkaP7mpwY2UBSnrlfot5Ykpfsehyke-Uzw,25
+AIEmailAutomationUtility-0.0.19.dist-info/RECORD,,

AIEmailAutomationUtility-0.0.17.dist-info/RECORD

@@ -1,13 +0,0 @@
-AIEmailAutomationUtility/EmailReplyAssistant.py,sha256=AK2I1j2wa6NvR9ysKgtQsm-wkaeKQycQdzREXR0Ptb8,3886
-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=Wc8HzZfMkDZ6XjjfNOibrI6r5XsytPEoA1ilw4DPRuA,20792
-AIEmailAutomationUtility/Email_Upload_Document.py,sha256=3bdkxfDlwoeRp-46KPw2Gs1dqBhEIoA1yE5GCudpdV8,1320
-AIEmailAutomationUtility/Save_Transaction.py,sha256=Gg1w6hhzHmEFjsuzYvkq-3-EsWReetjLHsYSv5YIGgM,3816
-AIEmailAutomationUtility/__init__.py,sha256=UzDkFSvLwwc0NLnvMiM0jNV5pIWUlM9p2zvpcrh9rkM,344
-AIEmailAutomationUtility-0.0.17.dist-info/LICENCE.txt,sha256=2qX9IkEUBx0VJp1Vh9O2dsRwE-IpYId0lXDyn7OVsJ8,1073
-AIEmailAutomationUtility-0.0.17.dist-info/METADATA,sha256=CrzAQxzsUyms22Uaoe8QMRk4oM-MjwGVB-7UAFHH2xc,583
-AIEmailAutomationUtility-0.0.17.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-AIEmailAutomationUtility-0.0.17.dist-info/top_level.txt,sha256=3jTWrTUblVkaP7mpwY2UBSnrlfot5Ykpfsehyke-Uzw,25
-AIEmailAutomationUtility-0.0.17.dist-info/RECORD,,