AIEmailAutomationUtility 0.0.1__py3-none-any.whl

AIEmailAutomationUtility/Email_CategoryDetector.py

@@ -0,0 +1,142 @@
+import json
+from openai import OpenAI
+import google.generativeai as genai
+import openai
+import loggerutility as logger 
+
+class Email_CategoryDetector:
+    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 category
+        except Exception as e:
+            logger.log(f"Error detecting category with OpenAI: {str(e)}")
+            raise
+
+    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 category
+            else:
+                logger.log(f"finalResult:::  {final_result}")
+                return final_result
+
+        except Exception as e:
+            logger.log(f"Error with Gemini AI detection/generation: {str(e)}")
+            raise
+
+    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 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 final_result
+
+        except Exception as e:
+            logger.log(f"Error with LocalAI detection/generation: {str(e)}")
+            raise

AIEmailAutomationUtility/Email_DocumentUploader.py

@@ -0,0 +1,61 @@
+import os
+import json
+import shutil
+import requests
+import loggerutility as logger
+
+
+class Email_DocumentUploader:
+    def upload_document(self, upload_config, file_data):
+        try:
+            # 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'])
+            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
+                )
+            
+            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:
+            print(f"Error uploading document: {str(e)}")
+            raise
+        finally:
+            # Cleanup
+            if os.path.exists(temp_dir):
+                shutil.rmtree(temp_dir)

AIEmailAutomationUtility/Email_Drafter.py

@@ -0,0 +1,36 @@
+import imaplib
+import email
+from email.message import Message
+import datetime
+import time
+import loggerutility as logger
+
+
+class Email_Drafter:
+    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)}")

AIEmailAutomationUtility/Email_Read.py

@@ -0,0 +1,75 @@
+import imaplib
+import email
+import loggerutility as logger 
+
+
+
+class Email_Read:
+    def read_email(self, email_config):
+        """
+        Reads emails from the inbox and returns relevant details
+        
+        Args:
+            email_config (dict): Contains email configuration details
+                - host: IMAP host server
+                - port: IMAP port
+                - email: Email address
+                - password: Email password
+                
+        Returns:
+            list: List of dictionaries containing email details
+        """
+        try:
+            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')
+
+            
+            status, email_ids = mail.search(None, 'UNSEEN')
+            emails = []
+            
+            if status == 'OK':
+                email_ids = email_ids[0].split()
+                
+                for email_id in email_ids:
+                    email_body = ""
+                    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']
+                        bcc_email = msg['BCC']
+                        subject = msg['Subject']
+                        
+                        # Extract email body
+                        if msg.is_multipart():
+                            for part in msg.walk():
+                                if part.get_content_type() == "text/plain":
+                                    email_body += part.get_payload(decode=True).decode()
+                        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
+                        })
+                # logger.log(f"emails:: {emails}")
+            return emails
+            
+        except Exception as e:
+            logger.log(f"Error reading emails: {str(e)}")
+            raise
+        finally:
+            try:
+                mail.close()
+                mail.logout()
+            except:
+                pass

AIEmailAutomationUtility/__init__.py

@@ -0,0 +1,4 @@
+from .Email_Read import Email_Read
+from .Email_CategoryDetector import Email_CategoryDetector
+from .Email_Drafter import Email_Drafter
+from .Email_DocumentUploader import Email_DocumentUploader

AIEmailAutomationUtility-0.0.1.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.1.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: AIEmailAutomationUtility
+Version: 0.0.1
+Summary: Created class for read_email, draft_response,catrgory_detect and upload document
+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
+
+Created class for read_email, draft_response,catrgory_detect and upload document

AIEmailAutomationUtility-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+AIEmailAutomationUtility/Email_CategoryDetector.py,sha256=E2BRB57etINb1FjP6hODj7pS1Jj4UCoaCKj3Ic-N8_Y,6779
+AIEmailAutomationUtility/Email_DocumentUploader.py,sha256=VAfpoH7JD6B2cYQDTatK0wzQhhjtNnoB5tpMI8h4BOU,2148
+AIEmailAutomationUtility/Email_Drafter.py,sha256=YSD2tWPHyvJKqTjTuQyXbRJO_j6I7znnr5OPKG0nPGg,1574
+AIEmailAutomationUtility/Email_Read.py,sha256=OfqDmyBGRgLDWNbZbl2bxaTjSa9gydaIO8R6nAuByPw,2698
+AIEmailAutomationUtility/__init__.py,sha256=JpyFFoYlqLdoj9pe4AkoP_pXy5vbwAZKxEcHshuRHUg,194
+AIEmailAutomationUtility-0.0.1.dist-info/LICENCE.txt,sha256=2qX9IkEUBx0VJp1Vh9O2dsRwE-IpYId0lXDyn7OVsJ8,1073
+AIEmailAutomationUtility-0.0.1.dist-info/METADATA,sha256=gH3wC2s4h_Heek-D2FTPUaVEOwaHKFSOict-hFVxNVY,660
+AIEmailAutomationUtility-0.0.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+AIEmailAutomationUtility-0.0.1.dist-info/top_level.txt,sha256=3jTWrTUblVkaP7mpwY2UBSnrlfot5Ykpfsehyke-Uzw,25
+AIEmailAutomationUtility-0.0.1.dist-info/RECORD,,

AIEmailAutomationUtility-0.0.1.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.1.dist-info/top_level.txt

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