AIEmailAutomationUtility 0.0.4__py3-none-any.whl

AIEmailAutomationUtility/EmailReplyAssistant.py

@@ -0,0 +1,96 @@
+import traceback
+from openai import OpenAI
+from openai import OpenAI, AssistantEventHandler
+from flask import Flask,request
+import json
+import loggerutility as logger 
+
+class EmailReplyAssistant:
+    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):
+                        print(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)
+
+                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)
+                        if delta.code_interpreter.outputs:
+                            print(f"\n\nOutput >", flush=True)
+                            for output in delta.code_interpreter.outputs:
+                                if output.type == "logs":
+                                    print(output.logs, flush=True)
+
+            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 = EventHandler()
+
+            with client.beta.threads.runs.stream(
+                thread_id=thread.id,
+                assistant_id=assistant_ID,
+                instructions=f"Create a reply for the email received from a customer.\nDo not include any instruction as the output will be directly in a program.",
+                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:: {type(openAI_response)}")
+            logger.log(f"openAI_response:: {openAI_response}")
+            return {"status": "Success", "message": openAI_response}
+
+        except Exception as error:
+            responseStr = "<br/><br/>" + str(error)
+            trace = traceback.format_exc()
+            print(f"Exception in process_Email: {responseStr} \n {trace} \n DataType ::: {type(responseStr)}")
+
+    def email_reply_assitant(self):
+        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")
+            subject = data.get("subject")
+
+            if not all([openAI_key, assistant_ID, email_content, subject]):
+                raise ValueError("Missing required email configuration fields.")
+
+            email_response = self.Reply_Email_Ai_Assistant(
+                openAI_key=openAI_key,
+                assistant_ID=assistant_ID,
+                email_content=email_content,
+                subject=subject
+            )
+
+            logger.log(f"Reply_Email_Ai_Assistant response: {email_response}")
+            return email_response
+
+        except Exception as e:
+            logger.log(f"Error in Read_Email: {str(e)}")

AIEmailAutomationUtility/Email_Classification.py

@@ -0,0 +1,191 @@
+import json
+from openai import OpenAI
+import google.generativeai as genai
+import openai
+import loggerutility as logger 
+from flask import Flask,request
+
+class Email_Classification:
+    def detect_category_openai(self, openai_api_key, categories, email_body):
+        logger.log("Inside detect_category_openai::")
+        try:
+            categories_str = ', '.join(categories)
+            message = [{
+                "role": "user",
+                "content": f"Classify the mail into one of the following categories: {categories_str} and Others. Based on the email content: {email_body}, provide ONLY the category in JSON format as {{\"category\": \"category\"}}."
+            }]
+            
+            logger.log(f"Final GPT message for detecting category::: {message}")
+            client = OpenAI(api_key=openai_api_key)
+            result = client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=message,
+                temperature=0,
+                max_tokens=1800,
+                top_p=1,
+                frequency_penalty=0,
+                presence_penalty=0,
+            )
+            category = json.loads(result.choices[0].message.content)['category']
+            logger.log(f"category:: {category}")
+            return {"status": "Success", "message": category}
+        except Exception as e:
+            logger.log(f"Error detecting category with OpenAI: {str(e)}")
+            return {"success": "Failed", "message": f"Error detecting category with OpenAI: {str(e)}"}
+
+    def detect_category_gemini(self, gemini_api_key, categories, email_body, detect_email_category=True, signature=None):
+        logger.log("Inside detect_category_gemini::")
+        try:
+            categories_str = ', '.join(categories) 
+            if detect_email_category:
+                message = [{
+                    "role": "user",
+                    "content": f"Classify the mail into one of the following categories: {categories_str} and Others. Based on the email content: {email_body}, provide ONLY the category in JSON format as {{\"category\": \"category\"}}."
+                }]
+            else:
+                message = [{
+                    "role": "user",
+                    "content": f"Create a reply for the email received from a customer. Include the email signature as {signature}\nDo not include any instruction as the output will be directly in a program."
+                }]
+
+            logger.log(f"Final Gemini AI message for detecting category::: {message}")
+            message_list = str(message)
+
+            generation_config = {
+                "temperature": 0,
+                "top_p": 1,
+                "top_k": 1,
+                "max_output_tokens": 2048,
+            }
+
+            genai.configure(api_key=gemini_api_key)
+            model = genai.GenerativeModel('gemini-1.0-pro')
+            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")
+
+            final_result = ""
+            for part in response:
+                final_result = part.text
+                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]
+                        final_result = json.loads(final_result)
+                        logger.log(f"finalResult:::  {final_result}")
+                    except json.JSONDecodeError:
+                        logger.log(f"Exception : Invalid JSON Response GEMINI 1.5: {final_result} {type(final_result)}")
+
+            if detect_email_category:
+                category = final_result.get('category', 'Others')
+                return {"status": "Success", "message": category}
+            else:
+                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 detect_category_local(self, openai_api_key, categories, email_body, detect_email_category=True, signature=None, local_ai_url=None):
+        logger.log("Inside detect_category_local::")
+        try:
+            categories_str = ', '.join(categories)
+            if detect_email_category:
+                message = [{
+                    "role": "user",
+                    "content": f"Classify the mail into one of the following categories: {categories_str} and Others. Based on the email content: {email_body}, provide ONLY the category in JSON format as {{\"category\": \"category\"}}."
+                }]
+            else:
+                message = [{
+                    "role": "user",
+                    "content": f"Create a reply for the email received from a customer. Include the email signature as {signature}\nDo not include any instruction as the output will be directly in a program."
+                }]
+
+            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)
+            logger.log(f"\n\nInput Question ::: {email_body}\nLocalAI endpoint finalResult ::::: {final_result} \n{type(final_result)}", "0")
+
+            if detect_email_category:
+                try:
+                    json_start = final_result.find("{")
+                    json_end = final_result.rfind("}") + 1
+                    if json_start != -1 and json_end != -1:
+                        json_str = final_result[json_start:json_end]
+                        final_result = json.loads(json_str)
+                        logger.log(f"finalResult:::  {final_result}")
+                        category = final_result.get('category', 'Others')
+                        logger.log(f"category::1037 {category}")
+                        return {"status": "Success", "message": category}
+                    else:
+                        raise ValueError("No valid JSON object found in the response")
+                except json.JSONDecodeError as e:
+                    logger.log(f"JSON decode error: {e}")
+                    raise
+            else:
+                logger.log(f"finalResult:1040  {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 detect_category(self):
+        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']
+            if model_type == 'OpenAI':
+                required_fields.append('openai_api_key')
+            elif model_type == 'GeminiAI':
+                required_fields.append('gemini_api_key')
+            elif model_type == 'LocalAI':
+                required_fields.extend(['openai_api_key', 'local_ai_url'])
+
+            if model_type == 'OpenAI':
+                response = self.detect_category_openai(
+                    openai_api_key=data['openai_api_key'],
+                    categories=data['categories'],
+                    email_body=data['email_body']
+                )
+            elif model_type == 'GeminiAI':
+                response = self.detect_category_gemini(
+                    gemini_api_key=data['gemini_api_key'],
+                    categories=data['categories'],
+                    email_body=data['email_body'],
+                    detect_email_category=data.get('Detect_Email_category', True),
+                    signature=data.get('signature', '')
+                )
+            elif model_type == 'LocalAI':
+                response = self.detect_category_local(
+                    openai_api_key=data['openai_api_key'],
+                    categories=data['categories'],
+                    email_body=data['email_body'],
+                    detect_email_category=data.get('Detect_Email_category', True),
+                    signature=data.get('signature', ''),
+                    local_ai_url=data['local_ai_url']
+                )
+            else:
+                return {"status": "Failed", "message": f"Invalid model_type: {model_type}"}
+            
+            logger.log(f"Detect_Category response: {response}")
+            return response
+
+        except Exception as e:
+            logger.log(f"Error in Detect_Category: {str(e)}")
+            return e

AIEmailAutomationUtility/Email_DocumentUploader.py

@@ -0,0 +1,101 @@
+import os
+import json
+import shutil
+import requests
+import loggerutility as logger
+from flask import Flask,request
+
+
+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)
+            
+        # Save file temporarily
+        file_path = os.path.join(temp_dir, file_data['filename'])
+        logger.log(f"file_path:: {file_path}")
+        with open(file_path, 'wb') as f:
+            f.write(file_data['content'])
+        
+        # Prepare headers and parameters
+        headers = {"TOKEN_ID": upload_config["token_id"]}
+        params = {}
+        
+        param_fields = {
+            "DOCUMENT_TYPE": "document_type",
+            "OBJ_NAME": "obj_name",
+            "FILE_TYPE": "file_type",
+            "APP_ID": "app_id"
+        }
+        logger.log(f"param_fields:: {param_fields}")
+        
+        for api_key, config_key in param_fields.items():
+            if config_key in upload_config and upload_config[config_key]:
+                params[api_key] = upload_config[config_key]
+        
+        # Upload file
+        with open(file_path, 'rb') as file:
+            files = {'file': file}
+            response = requests.request(
+                upload_config["method"],
+                upload_config["url"],
+                headers=headers,
+                files=files,
+                data=params
+            )
+        logger.log("file read")
+        
+        if response.status_code == 200:
+            result = json.loads(response.text)
+            document_id = result["ID"]["Document_Id"]
+            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')
+            }
+
+            # 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()
+            }
+
+            result = self.upload_document(upload_config, file_data)
+            
+            logger.log(f"Upload_Document response result: {result}")
+            return "success"
+
+        except Exception as e:
+            logger.log(f"Error in Upload_Document: {str(e)}")

AIEmailAutomationUtility/Email_Draft.py

@@ -0,0 +1,121 @@
+import imaplib
+import email
+from email.message import Message
+import datetime
+import time
+import loggerutility as logger
+from flask import Flask,request
+import json
+
+class Email_Draft:
+    def 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'])
+                logger.log(f"login successfully")
+                
+                message = Message()
+                message["From"] = email_config['email']
+                message["To"] = email_details['sender']
+                message["CC"] = email_details['cc']
+                
+                subject = email_details['subject']
+                if not subject.startswith("Re:"):
+                    subject = f"Re: {subject}"
+                message["Subject"] = subject
+                
+                mail_details = f'{datetime.datetime.now().strftime("On %a, %b %d, %Y at %I:%M %p")} {email_details["sender"]} wrote:'
+                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}")
+                imap_ssl.append("[Gmail]/Drafts", '', imaplib.Time2Internaldate(time.time()), utf8_message)
+                
+                return True, utf8_message.decode("utf-8")
+                
+        except Exception as e:
+            logger.log(f"Error creating draft: {str(e)}")
+
+    def draft_email_response(self, email_details):
+        try:
+            logger.log("Creating draft email with the following details:")
+            logger.log(f"From: {email_details.get('from')}")
+            logger.log(f"To: {email_details.get('to')}")
+            logger.log(f"CC: {email_details.get('cc')}")
+            logger.log(f"Subject: {email_details.get('subject')}")
+            logger.log(f"Body: {email_details.get('body')}")
+
+            return "Success", {
+                "from": email_details['from'],
+                "to": email_details['to'],
+                "cc": email_details.get('cc', ""),
+                "subject": email_details['subject'],
+                "body": email_details['body']
+            }
+
+        except Exception as e:
+            logger.log(f"Error creating draft: {str(e)}")
+            return "Failed", None
+
+    def draft_mail(self):
+        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"]
+                logger.log(f"\nInside reciever_email_addr value:::\t{reciever_email_addr} \t{type(reciever_email_addr)}","0")
+
+            if "receiver_email_pwd" in data and data["receiver_email_pwd"] != None:
+                receiver_email_pwd = data["receiver_email_pwd"]
+                logger.log(f"\nInside receiver_email_pwd value:::\t{receiver_email_pwd} \t{type(receiver_email_pwd)}","0")
+
+            if "host_name" in data and data["host_name"] != None:
+                host_name = data["host_name"]
+                logger.log(f"\nInside host_name value:::\t{host_name} \t{type(host_name)}","0")
+            
+            if "sender_email_addr" in data and data["sender_email_addr"] != None:
+                sender_email_addr = data["sender_email_addr"]
+                logger.log(f"\nInside sender_email_addr value:::\t{sender_email_addr} \t{type(sender_email_addr)}","0")
+
+            if "cc_email_addr" in data and data["cc_email_addr"] != None:
+                cc_email_addr = data["cc_email_addr"]
+                logger.log(f"\nInside cc_email_addr value:::\t{cc_email_addr} \t{type(cc_email_addr)}","0")
+
+            if "subject" in data and data["subject"] != None:
+                subject = data["subject"]
+                logger.log(f"\nInside subject value:::\t{subject} \t{type(subject)}","0")
+
+            if "email_body" in data and data["email_body"] != None:
+                email_body = data["email_body"]
+                logger.log(f"\nInside email_body value:::\t{email_body} \t{type(email_body)}","0")
+
+            if "signature" in data and data["signature"] != None:
+                signature = data["signature"]
+                logger.log(f"\nInside signature value:::\t{signature} \t{type(signature)}","0")
+            
+
+            email_config = {
+                "email": data["reciever_email_addr"],
+                "password": data["receiver_email_pwd"],
+                "host": data["host_name"]
+            }
+            logger.log(f"data::{data}")
+            email_details = {
+                "from": data["sender_email_addr"],
+                "to":data["reciever_email_addr"],
+                "cc": cc_email_addr,
+                "subject": data["subject"],
+                "body": data["email_body"],
+                "signature": data["signature"]
+            }
+
+            success, draft_message = self.draft_email_response(email_details)
+            
+            if success == "Success":
+                logger.log(f"draft_message  {draft_message}")
+                return draft_message
+
+        except Exception as e:
+            logger.log(f"Error in Draft_Save: {str(e)}")

AIEmailAutomationUtility/Email_Read.py

@@ -0,0 +1,145 @@
+import imaplib
+import email
+import os
+import json
+import time
+import loggerutility as logger
+from flask import Flask, request
+from .Save_Transaction import Save_Transaction
+from .Email_Upload_Document import Email_Upload_Document
+
+class Email_Read:
+    def read_email(self, email_config):
+        try:
+            logger.log("inside function")
+            mail = imaplib.IMAP4_SSL(email_config['host'], email_config['port'])
+            mail.login(email_config['email'], email_config['password'])
+            logger.log("login successfully")
+            mail.select('inbox')
+
+            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")
+                        print("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)
+                                
+                                sender_email = msg['From']
+                                cc_email = msg['CC']
+                                subject = msg['Subject']
+                                to = msg['To']
+
+                                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')                              
+
+                                email_data = {
+                                    "email_id": email_id,
+                                    "from": sender_email,
+                                    "to": to,
+                                    "cc": cc_email,
+                                    "subject": subject,
+                                    "body": email_body
+                                }
+                                emails.append(email_data)
+                                logger.log(f"emails:: {emails}")
+                                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:
+            return {"success": "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)}")
+
+    def save_attachment(self, part, download_dir):
+        try:
+            filename = part.get_filename()
+            if filename:
+                # Create the directory if it doesn't exist
+                if not os.path.exists(download_dir):
+                    os.makedirs(download_dir)
+
+                file_path = os.path.join(download_dir, filename)
+                with open(file_path, 'wb') as f:
+                    f.write(part.get_payload(decode=True))
+
+                logger.log(f"Attachment saved: {file_path}")
+                return file_path
+        except Exception as e:
+            return {"success": "Failed", "message": f"Error saving attachment: {str(e)}"}
+
+    def Read_Email(self):
+        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")
+            host = data.get("host")
+            port = data.get("port")
+
+            if not all([reciever_email_addr, receiver_email_pwd, host, port]):
+                raise ValueError("Missing required email configuration fields.")
+
+            logger.log(f"\nReceiver Email Address: {reciever_email_addr}\t{type(reciever_email_addr)}", "0")
+            logger.log(f"\nReceiver Email Password: {receiver_email_pwd}\t{type(receiver_email_pwd)}", "0")
+            logger.log(f"\nHost: {host}\t{type(host)}", "0")
+            logger.log(f"\nPort: {port}\t{type(port)}", "0")
+
+            email_config = {
+                'email': reciever_email_addr,
+                'password': receiver_email_pwd,
+                'host': host,
+                'port': int(port)
+            }
+
+            emails = self.read_email(email_config)            
+            logger.log(f"Read_Email response: {emails}")
+
+        except Exception as e:
+            logger.log(f"Error in Read_Email: {str(e)}")
+
+        
+

AIEmailAutomationUtility/Email_Upload_Document.py

@@ -0,0 +1,41 @@
+
+import requests
+import loggerutility as logger
+from flask import Flask, request
+import json
+
+class Email_Upload_Document:
+
+    def upload_files(self, file_path):
+        data = request.get_data('jsonData', None)
+        data = json.loads(data[9:])
+        logger.log(f"jsondata:: {data}")
+        base_url = data.get("base_url")
+        token_id = data.get("token_id")
+
+        url = f"{base_url}/ibase/rest/DocumentHandlerService/uploadDocument"
+
+        headers = {
+            "TOKEN_ID": token_id,
+            "Content-Type": "multipart/form-data" 
+        }
+
+        with open(file_path, 'rb') as file_to_upload:
+            files = {'file': file_to_upload}
+            logger.log(f"files:: {files}")
+            logger.log(f"file_to_upload:: {file_to_upload}")
+
+            response = requests.post(url, headers=headers, files=files)
+
+        if response.status_code == 200:
+            logger.log("File uploaded successfully!")
+            logger.log("Response:", response.json())  
+            return {"success": "Success", "message": "File uploaded"}
+        else:
+            logger.log("Failed to upload file.")
+            logger.log("Status Code:", response.status_code)
+            logger.log("Response:", response.text)
+            return {"success": "Failed", "message": "File not uploaded"}
+
+        
+

AIEmailAutomationUtility/Save_Transaction.py

@@ -0,0 +1,95 @@
+import requests
+from flask import Flask,request
+import json
+import loggerutility as logger 
+
+class Save_Transaction:
+    def generate_token(self, base_url, app_id, user_code, password, is_pwd_encrypt, data_format):
+        url = f"{base_url}/ibase/rest/E12ExtService/login"
+        headers = {'Content-Type': 'application/x-www-form-urlencoded'}
+        payload = {
+            "USER_CODE": user_code,
+            "PASSWORD": password,
+            "IS_PWD_ENCRYPT": str(is_pwd_encrypt).lower(),
+            "APP_ID": app_id,
+            "DATA_FORMAT": data_format
+        }
+        logger.log(f"url:; {url}")
+        logger.log(f"payload:; {payload}")
+
+        response = requests.post(url, data=payload, headers=headers)
+        logger.log(f"response:: {response}")
+        if response.status_code == 200:
+            logger.log(f"response:: {response.text}")
+            logger.log(f"response JSON:: {response.json()}")
+            response_data = response.json()  # Parse the response JSON
+            results = response_data.get("Response", {}).get("results", "")
+            results_dict = json.loads(results)  # Parse the JSON-encoded string
+            token_id = results_dict.get("TOKEN_ID")
+            # token_id = response.json().get("TOKEN_ID")
+            logger.log(f"token_id:; {token_id}")
+            return token_id
+        else:
+            print(f"Failed to generate token. Status Code: {response.status_code}, Response: {response.text}")
+            return None
+
+    def email_save_transaction(self, input_data):
+        logger.log(f"input_data:: {input_data}")
+        data = request.get_data('jsonData', None)
+        data = json.loads(data[9:])
+        logger.log(f"jsondata:: {data}")
+
+        base_url = data.get("base_url")
+        token_id = data.get("token_id")
+        obj_name = data.get("obj_name")
+        enterprise_name = data.get("enterprise_name")
+        app_id = data.get("app_id")
+
+        url = f"{base_url}/ibase/rest/EDIService/setData/{obj_name}/{enterprise_name}/{app_id}/writefilesavetrans"
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'TOKEN_ID': token_id
+        }
+        payload = {
+            "INPUT_DATA": input_data
+        }
+
+        response = requests.post(url, data=payload, headers=headers)
+        logger.log(f"response:: {response}")
+        logger.log(f"response.status_code:: {response.status_code}")
+        if response.status_code == 200:
+            json_response = response.json()
+            return {"status": "Success", "message": json_response}
+        else:
+            print(f"Failed to push transaction. Status Code: {response.status_code}, Response: {response.text}")
+            return {"success": "Failed", "message": "failed in transaction"}
+        
+    def save_trans(self):
+
+        data = request.get_data('jsonData', None)
+        data = json.loads(data[9:])
+        logger.log(f"jsondata:: {data}")
+
+        base_url = data.get("base_url")
+        app_id = data.get("app_id")
+        user_code = data.get("user_code")
+        password = data.get("password")
+        is_pwd_encrypt = data.get("is_pwd_encrypt")
+        data_format = data.get("data_format")
+        input_data = "What are the modules are available in Proteus Vision ERP ?\r\nCan you please highlight the specific feature of manufacturing module"
+
+        trans_details = self.generate_token(
+                base_url,
+                app_id,
+                user_code,
+                password,
+                is_pwd_encrypt,
+                data_format
+            )
+        logger.log(f"trans_details::  {trans_details}")
+        # return trans_details
+        
+
+        token_id = self.email_save_transaction(base_url,input_data,trans_details)
+        logger.log(f"token:::  {token_id}")
+        return token_id

AIEmailAutomationUtility/__init__.py

@@ -0,0 +1,8 @@
+from .Email_Read import Email_Read
+from .Email_Classification import Email_Classification
+from .Email_Draft import Email_Draft
+from .Email_DocumentUploader import Email_DocumentUploader
+from .EmailReplyAssistant import EmailReplyAssistant
+from .Save_Transaction import Save_Transaction
+from .Email_Upload_Document import Email_Upload_Document
+

AIEmailAutomationUtility-0.0.4.dist-info/LICENCE.txt

@@ -0,0 +1,7 @@
+Copyright 2022 Proteus Technology PVT. LTD.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

AIEmailAutomationUtility-0.0.4.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: AIEmailAutomationUtility
+Version: 0.0.4
+Summary: Changed all classes for new changes and added save transaction class
+Author: Proteus Technology PVT. LTD.
+Author-email: <apps@baseinformation.com>
+Keywords: python,first package
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+License-File: LICENCE.txt
+
+Changed all classes for new changes and added save transaction class

AIEmailAutomationUtility-0.0.4.dist-info/RECORD

@@ -0,0 +1,13 @@
+AIEmailAutomationUtility/EmailReplyAssistant.py,sha256=9X4osN7JDG_2sdyq0Sww5VapxPc_u7Nc9bEbODeE6YU,3852
+AIEmailAutomationUtility/Email_Classification.py,sha256=73lqzfXft0q6D9lRhW0gHiDNGyykSgEZ8fUlgBYK9Hw,9362
+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_Transaction.py,sha256=Gg1w6hhzHmEFjsuzYvkq-3-EsWReetjLHsYSv5YIGgM,3816
+AIEmailAutomationUtility/__init__.py,sha256=UzDkFSvLwwc0NLnvMiM0jNV5pIWUlM9p2zvpcrh9rkM,344
+AIEmailAutomationUtility-0.0.4.dist-info/LICENCE.txt,sha256=2qX9IkEUBx0VJp1Vh9O2dsRwE-IpYId0lXDyn7OVsJ8,1073
+AIEmailAutomationUtility-0.0.4.dist-info/METADATA,sha256=0nvJzPE0TMCF1bPLE2g18sOl2FHie0QZViXbm19_W7U,636
+AIEmailAutomationUtility-0.0.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+AIEmailAutomationUtility-0.0.4.dist-info/top_level.txt,sha256=3jTWrTUblVkaP7mpwY2UBSnrlfot5Ykpfsehyke-Uzw,25
+AIEmailAutomationUtility-0.0.4.dist-info/RECORD,,

AIEmailAutomationUtility-0.0.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

AIEmailAutomationUtility-0.0.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+AIEmailAutomationUtility