Spaces:

Rsnarsna
/

emaildockerdemo

Sleeping

App Files Files Community

Rsnarsna commited on Oct 19, 2024

Commit

0db913c

verified ·

1 Parent(s): 0fbd630

Update app.py

Browse files

Files changed (1) hide show

app.py +43 -114

app.py CHANGED Viewed

@@ -7,6 +7,7 @@ from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
 import email, imaplib, json, time
 import torch, logging
 import uvicorn
 app = FastAPI()
@@ -197,13 +198,6 @@ def read_email():
 running = False
 loop_thread = None
-def email_processing_loop():
-    global running
-    logger.info("Starting email processing loop...")
-    while running:
-        read_email()
-        time.sleep(10)  # Check for new emails every 10 seconds
 # HTML content for the web interface
 html_content = """
 <!DOCTYPE html>
@@ -228,124 +222,59 @@ html_content = """
 </head>
 <body>
     <h1>Email Processing Status: {{ status }}</h1>
-    <button onclick="window.location.href='/start'">Start Processing</button>
-    <button class="stop" onclick="window.location.href='/stop'">Stop Processing</button>
 </body>
 </html>
 """
-# Endpoint to display the home page with the email processor's status
 @app.get("/", response_class=HTMLResponse)
 async def home():
-    # service = authenticate_gmail()
-    # logger.info(service)
-    # print(service)
-    # if service:
-    #     get_latest_email(service)
     global running
     status = "Running" if running else "Stopped"
     return HTMLResponse(content=html_content.replace("{{ status }}", status), status_code=200)
-# Endpoint to start the email processing loop
-@app.get("/start", response_class=HTMLResponse)
-async def start_processing():
     global running, loop_thread
-    if not running:
-        running = True
-        loop_thread = threading.Thread(target=email_processing_loop, daemon=True)
-        loop_thread.start()
-    status = "Running"
-    return HTMLResponse(content=html_content.replace("{{ status }}", status), status_code=200)
-# Endpoint to stop the email processing loop
-@app.get("/stop", response_class=HTMLResponse)
-async def stop_processing():
-    global running
-    if running:
-        running = False
-    status = "Stopped"
-    return HTMLResponse(content=html_content.replace("{{ status }}", status), status_code=200)
-import os.path
-import base64
-import json
-import pickle
-from google.auth.transport.requests import Request
-from google.oauth2.credentials import Credentials
-from google_auth_oauthlib.flow import InstalledAppFlow
-from googleapiclient.discovery import build
-from googleapiclient.errors import HttpError
-# If modifying these SCOPES, delete the file token.json.
-SCOPES = ['https://www.googleapis.com/auth/gmail.readonly']
-def authenticate_gmail():
-    """Shows basic usage of the Gmail API.
-    Lists the user's Gmail labels.
-    """
-    creds = None
-    # The file token.json stores the user's access and refresh tokens, and is
-    # created automatically when the authorization flow completes for the first time.
-    if os.path.exists('token.json'):
-        creds = Credentials.from_authorized_user_file('token.json', SCOPES)
-    # If there are no (valid) credentials available, let the user log in.
-    if not creds or not creds.valid:
-        if creds and creds.expired and creds.refresh_token:
-            creds.refresh(Request())
         else:
-            flow = InstalledAppFlow.from_client_secrets_file(
-                'Credentials.json', SCOPES)
-            creds = flow.run_local_server(port=0)
-        # Save the credentials for the next run
-        with open('token.json', 'w') as token:
-            token.write(creds.to_json())
-    try:
-        # Call the Gmail API
-        service = build('gmail', 'v1', credentials=creds)
-        return service
-    except HttpError as error:
-        print(f'An error occurred: {error}')
-        return None
-def get_latest_email(service):
-    """Get the latest email from the inbox"""
-    try:
-        # Retrieve a list of messages
-        results = service.users().messages().list(userId='me', maxResults=1).execute()
-        messages = results.get('messages', [])
-        if not messages:
-            print('No messages found.')
-            return
-        # Get the message ID
-        message_id = messages[0]['id']
-        # Fetch the email content by message ID
-        message = service.users().messages().get(userId='me', id=message_id, format='full').execute()
-        # Get the email payload
-        payload = message['payload']
-        headers = payload.get('headers', [])
-        # Print the sender, subject, and body of the email
-        for header in headers:
-            if header['name'] == 'From':
-                print(f"From: {header['value']}")
-            if header['name'] == 'Subject':
-                print(f"Subject: {header['value']}")
-        # Extract the body
-        parts = payload.get('parts', [])
-        for part in parts:
-            if part.get('mimeType') == 'text/plain':
-                body = part.get('body', {}).get('data', '')
-                body_decoded = base64.urlsafe_b64decode(body).decode('utf-8')
-                print(f"Body: {body_decoded}")
-    except HttpError as error:
-        print(f'An error occurred: {error}')
 if __name__ == "__main__":

 import email, imaplib, json, time
 import torch, logging
 import uvicorn
+from pydantic import BaseModel
 app = FastAPI()
 running = False
 loop_thread = None
 # HTML content for the web interface
 html_content = """
 <!DOCTYPE html>
 </head>
 <body>
     <h1>Email Processing Status: {{ status }}</h1>
 </body>
 </html>
 """
+# Define a model for the incoming JSON data
+class ActionModel(BaseModel):
+    action: str  # The action can be 'start' or 'stop'
+class ModelData(BaseModel):
+    data: str
+# Function to process emails in a loop
+def email_processing_loop():
+    global running
+    logger.info("Starting email processing loop...")
+    while running:
+        # read_email()    # Assuming this is your email processing function
+        print("$"*100)
+        time.sleep(10)  # Check for new emails every 10 seconds
+# Endpoint to display the current email processor status
 @app.get("/", response_class=HTMLResponse)
 async def home():
     global running
     status = "Running" if running else "Stopped"
     return HTMLResponse(content=html_content.replace("{{ status }}", status), status_code=200)
+# Endpoint to receive JSON data to start/stop the email processing loop
+@app.post("/control", response_class=HTMLResponse)
+async def control_email_loop(action: ActionModel,data: ModelData):
     global running, loop_thread
+    logger.info(action.action)
+    if action.action == "start":
+        if not running:
+            running = True
+            email_data = data.data.dict()
+            logger.info(email_data)
+            loop_thread = threading.Thread(target=email_processing_loop, daemon=True)
+            loop_thread.start()
+            logger.info("Email processing loop started.")
         else:
+            logger.info("Email processing loop is already running.")
+    elif action.action == "stop":
+        if running:
+            running = False
+            logger.info("Email processing loop stopped.")
+        else:
+            logger.info("Email processing loop is not running.")
+    else:
+        raise HTTPException(status_code=400, detail="Invalid action. Use 'start' or 'stop'.")
+    status = "Running" if running else "Stopped"
+    return HTMLResponse(content=html_content.replace("{{ status }}", status), status_code=200)
 if __name__ == "__main__":