AIEmailAutomationUtility 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

AIEmailAutomationUtility/EmailReplyAssistant.py

@@ -1,12 +1,15 @@
 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, signature):
+    def Reply_Email_Ai_Assistant(self, openAI_key, assistant_ID, email_content, subject):
         try:
             class EventHandler(AssistantEventHandler):
                 def __init__(self):
@@ -48,20 +51,46 @@ class EmailReplyAssistant:
             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. Include the email signature as {signature}\nDo not include any instruction as the output will be directly in a program.",
+                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)
-            return openAI_response
+            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)}")
-            self.send_response(200)
-            self.send_header('Content-type', 'text/html')
-            self.end_headers()
-            self.wfile.write(responseStr.encode('utf-8'))
+
+    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_CategoryDetector.py → Email_Classification.py}

@@ -3,8 +3,9 @@ from openai import OpenAI
 import google.generativeai as genai
 import openai
 import loggerutility as logger 
+from flask import Flask,request
 
-class Email_CategoryDetector:
+class Email_Classification:
     def detect_category_openai(self, openai_api_key, categories, email_body):
         logger.log("Inside detect_category_openai::")
         try:
@@ -27,10 +28,10 @@ class Email_CategoryDetector:
             )
             category = json.loads(result.choices[0].message.content)['category']
             logger.log(f"category:: {category}")
-            return category
+            return {"status": "Success", "message": category}
         except Exception as e:
             logger.log(f"Error detecting category with OpenAI: {str(e)}")
-            raise
+            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::")
@@ -79,14 +80,14 @@ class Email_CategoryDetector:
 
             if detect_email_category:
                 category = final_result.get('category', 'Others')
-                return category
+                return {"status": "Success", "message": category}
             else:
                 logger.log(f"finalResult:::  {final_result}")
-                return final_result
+                return {"status": "Success", "message": final_result}
 
         except Exception as e:
             logger.log(f"Error with Gemini AI detection/generation: {str(e)}")
-            raise
+            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::")
@@ -127,7 +128,7 @@ class Email_CategoryDetector:
                         logger.log(f"finalResult:::  {final_result}")
                         category = final_result.get('category', 'Others')
                         logger.log(f"category::1037 {category}")
-                        return category
+                        return {"status": "Success", "message": category}
                     else:
                         raise ValueError("No valid JSON object found in the response")
                 except json.JSONDecodeError as e:
@@ -135,8 +136,56 @@ class Email_CategoryDetector:
                     raise
             else:
                 logger.log(f"finalResult:1040  {final_result}")
-                return final_result
+                return {"status": "Success", "message": final_result}
 
         except Exception as e:
             logger.log(f"Error with LocalAI detection/generation: {str(e)}")
-            raise
+            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

@@ -3,59 +3,99 @@ 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:
-            # Create temp directory if needed
-            temp_dir = "temp"
-            if not os.path.exists(temp_dir):
-                os.makedirs(temp_dir)
+            if 'file' not in request.files:
+                return "file not found"
                 
-            # Save file temporarily
-            file_path = os.path.join(temp_dir, file_data['filename'])
-            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"
+            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')
             }
-            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]
+
+            # Validate required fields
+            if not upload_config['token_id'] or not upload_config['url']:
+                return "Missing required fields: TOKEN_ID or RestAPI_Url"
             
-            # 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
-                )
+            file_data = {
+                'filename': file.filename,
+                'content': file.read()
+            }
+
+            result = self.upload_document(upload_config, file_data)
             
-            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}"
-                
+            logger.log(f"Upload_Document response result: {result}")
+            return "success"
+
         except Exception as e:
-            print(f"Error uploading document: {str(e)}")
-            raise
-        finally:
-            # Cleanup
-            if os.path.exists(temp_dir):
-                shutil.rmtree(temp_dir)
+            logger.log(f"Error in Upload_Document: {str(e)}")

AIEmailAutomationUtility/Email_Draft.py

@@ -4,7 +4,8 @@ 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):
@@ -34,3 +35,87 @@ class Email_Draft:
                 
         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

@@ -1,14 +1,17 @@
 import imaplib
 import email
-import loggerutility as logger 
-from flask import Flask,request
+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")
@@ -23,10 +26,12 @@ 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")
                     else:
                     
                         for email_id in email_ids:
                             email_body = ""
+                            attachments = []
                             status, data = mail.fetch(email_id, '(RFC822)')
                             
                             if status == 'OK':
@@ -35,40 +40,77 @@ class Email_Read:
                                 
                                 sender_email = msg['From']
                                 cc_email = msg['CC']
-                                bcc_email = msg['BCC']
                                 subject = msg['Subject']
-                                
+                                to = msg['To']
+
                                 if msg.is_multipart():
                                     for part in msg.walk():
-                                        if part.get_content_type() == "text/plain":
-                                            email_body += part.get_payload(decode=True).decode()
+                                        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()
-                                    
-                                emails.append({
-                                    'id': email_id,
-                                    'sender': sender_email,
-                                    'cc': cc_email,
-                                    'bcc': bcc_email,
-                                    'subject': subject,
-                                    'body': email_body
-                                })
+                                    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:
-            logger.log(f"Error reading emails: {str(e)}")
-            raise
+            return {"success": "Failed", "message": f"Error reading emails: {str(e)}"}
         finally:
             try:
                 mail.close()
                 mail.logout()
-            except:
-                pass
+            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:
-            # while True:
             data = request.get_data('jsonData', None)
             data = json.loads(data[9:])
             logger.log(f"jsondata:: {data}")
@@ -95,11 +137,9 @@ class Email_Read:
 
             emails = self.read_email(email_config)            
             logger.log(f"Read_Email response: {emails}")
-            # return "Successfully read email"
 
         except Exception as e:
             logger.log(f"Error in Read_Email: {str(e)}")
-            # return "Problem in reading email"
-        
 
+        
 

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

@@ -1,6 +1,8 @@
 from .Email_Read import Email_Read
-from .Email_CategoryDetector import Email_CategoryDetector
+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.3.dist-info → AIEmailAutomationUtility-0.0.5.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: AIEmailAutomationUtility
-Version: 0.0.3
-Summary: Changed Email_read function and kept all code in this function only
+Version: 0.0.5
+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
@@ -13,4 +13,4 @@ Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 License-File: LICENCE.txt
 
-Changed Email_read function and kept all code in this function only
+Changed all classes for new changes and added save transaction class

AIEmailAutomationUtility-0.0.5.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.5.dist-info/LICENCE.txt,sha256=2qX9IkEUBx0VJp1Vh9O2dsRwE-IpYId0lXDyn7OVsJ8,1073
+AIEmailAutomationUtility-0.0.5.dist-info/METADATA,sha256=1IogHOb2dCKGS0pMX8YgHRSSgOJSLIxku5W1mN61Fuw,636
+AIEmailAutomationUtility-0.0.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+AIEmailAutomationUtility-0.0.5.dist-info/top_level.txt,sha256=3jTWrTUblVkaP7mpwY2UBSnrlfot5Ykpfsehyke-Uzw,25
+AIEmailAutomationUtility-0.0.5.dist-info/RECORD,,

AIEmailAutomationUtility-0.0.3.dist-info/RECORD

@@ -1,11 +0,0 @@
-AIEmailAutomationUtility/EmailReplyAssistant.py,sha256=IGAf3FZh_f6qxqKnP7dq2FZFNb_0b_6an81SfPBddYE,2841
-AIEmailAutomationUtility/Email_CategoryDetector.py,sha256=E2BRB57etINb1FjP6hODj7pS1Jj4UCoaCKj3Ic-N8_Y,6779
-AIEmailAutomationUtility/Email_DocumentUploader.py,sha256=VAfpoH7JD6B2cYQDTatK0wzQhhjtNnoB5tpMI8h4BOU,2148
-AIEmailAutomationUtility/Email_Draft.py,sha256=XIvATGaikTzJ1KAcW7h3b4TEH3DInO9j3-WYCm6G26g,1572
-AIEmailAutomationUtility/Email_Read.py,sha256=H5poHx7Unv-tFl4BpUJRevIQKewdnxow38IdteOWcs4,4109
-AIEmailAutomationUtility/__init__.py,sha256=1wFg_DXxwGtz34XVpEB4WhBEWNwVYHM0LNWUh5Jiowc,244
-AIEmailAutomationUtility-0.0.3.dist-info/LICENCE.txt,sha256=2qX9IkEUBx0VJp1Vh9O2dsRwE-IpYId0lXDyn7OVsJ8,1073
-AIEmailAutomationUtility-0.0.3.dist-info/METADATA,sha256=5dWuj49u72GY05Gr78TmGKJ68qG_L9DPterEf8dUnP0,634
-AIEmailAutomationUtility-0.0.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-AIEmailAutomationUtility-0.0.3.dist-info/top_level.txt,sha256=3jTWrTUblVkaP7mpwY2UBSnrlfot5Ykpfsehyke-Uzw,25
-AIEmailAutomationUtility-0.0.3.dist-info/RECORD,,