Update flask_Character.py

flask_Character.py

@@ -35,12 +35,14 @@ from bson import ObjectId
 MONGO_URI = "mongodb+srv://precison9:P1LhtFknkT75yg5L@cluster0.isuwpef.mongodb.net"
 DB_NAME = "email_assistant_db"
 EXTRACTED_EMAILS_COLLECTION = "extracted_emails"
-GENERATED_REPLIES_COLLECTION = "generated_replies"
+GENERATED_REPLIES_COLLECTION = "generated_replies" # Still defined, but not used by generate-reply logic
 
 # Global variables for MongoDB client and collections
 client: Optional[MongoClient] = None
 db: Optional[Any] = None
 extracted_emails_collection: Optional[Any] = None
+# generated_replies_collection is no longer needed for /generate-reply logic,
+# but kept for /query-generated-replies endpoint if that's still desired.
 generated_replies_collection: Optional[Any] = None
 
 # --- Pydantic ObjectId Handling ---
@@ -158,7 +160,7 @@ class GenerateReplyRequest(BaseModel):
     emoji: str = Field("Auto", examples=["Auto", "None", "Occasional", "Frequent"])
 
 class GeneratedReplyData(BaseModel):
-    # Use PyObjectId for the _id field
+    # Use PyObjectId for the _id field (This model is now only used for the query endpoint)
     id: Optional[PyObjectId] = Field(alias="_id", default=None)
     original_email_text: str
     generated_reply_text: str
@@ -180,11 +182,11 @@ class GeneratedReplyData(BaseModel):
             data["_id"] = str(data["_id"])
         return data
 
-# NEW: Response Model for /generate-reply endpoint
+# Response Model for /generate-reply endpoint (simplified)
 class GenerateReplyResponse(BaseModel):
     reply: str = Field(..., description="The AI-generated reply text.")
-    stored_id: str = Field(..., description="The MongoDB ID of the stored reply.")
-    cached: bool = Field(..., description="True if the reply was retrieved from cache, False if newly generated.")
+    # 'stored_id' and 'cached' are removed as caching/storage is removed
+    # from the main generate-reply logic.
 
 # --- Query Models for GET Endpoints ---
 class ExtractedEmailQuery(BaseModel):
@@ -221,7 +223,7 @@ def extract_last_json_block(text: str) -> Optional[str]:
 
 def parse_date(date_str: Optional[str], current_date: date) -> Optional[date]:
     """
-    Parses a date string, handling 'today', 'tomorrow', and YYYY-MM-DD format.
+    Parses a date string, handling 'today', 'tomorrow', and APAC-MM-DD format.
     Returns None if input is None or cannot be parsed into a valid date.
     """
     if not date_str:
@@ -311,16 +313,16 @@ Here is the required JSON schema for each category:
   Each Appointment object must have:
     - `title` (string, short, meaningful title in Italian based on the meeting's purpose)
     - `description` (string, summary of the meeting's goal)
-    - `start_date` (string, YYYY-MM-DD. If not explicitly mentioned, use "{prompt_today_str}" for "today", or "{prompt_tomorrow_str}" for "tomorrow")
+    - `start_date` (string, APAC-MM-DD. If not explicitly mentioned, use "{prompt_today_str}" for "today", or "{prompt_tomorrow_str}" for "tomorrow")
     - `start_time` (string, optional, e.g., "10:30 AM", null if not present)
-    - `end_date` (string, YYYY-MM-DD, optional, null if unknown or not applicable)
+    - `end_date` (string, APAC-MM-DD, optional, null if unknown or not applicable)
     - `end_time` (string, optional, e.g., "11:00 AM", null if not present)
 
 - **tasks**: List of Task objects.
   Each Task object must have:
     - `task_title` (string, short summary of action item)
     - `task_description` (string, more detailed explanation)
-    - `due_date` (string, YYYY-MM-DD. Infer from context, e.g., "entro domani" becomes "{prompt_tomorrow_str}", "today" becomes "{prompt_today_str}")
+    - `due_date` (string, APAC-MM-DD. Infer from context, e.g., "entro domani" becomes "{prompt_tomorrow_str}", "today" becomes "{prompt_today_str}")
 
 ---
 
@@ -358,7 +360,7 @@ def _generate_response_internal(
     if not email_text:
         print(f"[{datetime.now()}] _generate_response_internal: Email text is empty.")
         return "Cannot generate reply for empty email text."
-    
+
     try:
         llm = ChatGroq(model="meta-llama/llama-4-scout-17b-16e-instruct", temperature=0.7, max_tokens=800, groq_api_key=api_key)
         prompt_template_str="""
@@ -390,7 +392,7 @@ def _generate_response_internal(
         traceback.print_exc() # Print full traceback to logs
         raise # Re-raise the exception so it can be caught by handle_single_reply_request
 
-# --- Batching and Caching Configuration ---
+# --- Batching Configuration (Caching/Storage logic removed) ---
 MAX_BATCH_SIZE = 20
 BATCH_TIMEOUT = 0.5 # seconds (Adjust based on expected LLM response time and desired latency)
 
@@ -400,45 +402,16 @@ reply_queue_condition = asyncio.Condition(lock=reply_queue_lock)
 batch_processor_task: Optional[asyncio.Task] = None
 
 
-# --- Batch Processor and Handler ---
+# --- Batch Processor and Handler (Simplified) ---
 async def handle_single_reply_request(request_data: GenerateReplyRequest, future: asyncio.Future):
-    """Handles a single request: checks cache, calls LLM, stores result, and sets future."""
+    """Handles a single request: calls LLM, and sets future with the reply."""
     print(f"[{datetime.now()}] Handle single reply: Starting for email_text_start='{request_data.email_text[:50]}'...")
     if future.cancelled():
         print(f"[{datetime.now()}] Handle single reply: Future cancelled. Aborting.")
         return
     try:
-        if generated_replies_collection is None:
-            print(f"[{datetime.now()}] Handle single reply: DB collection 'generated_replies_collection' is None.")
-            if not future.done():
-                future.set_exception(HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Database service not available for caching/storage."))
-            return
-
-        cache_query = {
-            "original_email_text": request_data.email_text,
-            "language": request_data.language,
-            "length": request_data.length,
-            "style": request_data.style,
-            "tone": request_data.tone,
-            "emoji": request_data.emoji,
-        }
-        print(f"[{datetime.now()}] Handle single reply: Checking cache for reply...")
-        # Use await asyncio.to_thread for blocking MongoDB operations
-        cached_reply_doc = await asyncio.to_thread(generated_replies_collection.find_one, cache_query)
-
-        if cached_reply_doc:
-            print(f"[{datetime.now()}] Handle single reply: Reply found in cache. ID: {str(cached_reply_doc['_id'])}")
-            response = {
-                "reply": cached_reply_doc["generated_reply_text"],
-                "stored_id": str(cached_reply_doc["_id"]),
-                "cached": True
-            }
-            if not future.done():
-                future.set_result(response)
-            print(f"[{datetime.now()}] Handle single reply: Cache result set on future.")
-            return
-
-        print(f"[{datetime.now()}] Handle single reply: Reply not in cache. Calling LLM...")
+        # Directly call LLM (no cache check or storage)
+        print(f"[{datetime.now()}] Handle single reply: Calling LLM for reply generation...")
         reply_content = await asyncio.to_thread(
             _generate_response_internal,
             request_data.email_text,
@@ -451,26 +424,10 @@ async def handle_single_reply_request(request_data: GenerateReplyRequest, future
         )
         print(f"[{datetime.now()}] Handle single reply: LLM call completed. Reply length: {len(reply_content)}.")
 
-        reply_data_to_store = GeneratedReplyData(
-            original_email_text=request_data.email_text,
-            generated_reply_text=reply_content,
-            language=request_data.language,
-            length=request_data.length,
-            style=request_data.style,
-            tone=request_data.tone,
-            emoji=request_data.emoji
-        )
-        print(f"[{datetime.now()}] Handle single reply: Storing reply in DB...")
-        # Use model_dump for Pydantic v2
-        reply_data_dict = reply_data_to_store.model_dump(by_alias=True, exclude_none=True, exclude={'id'})
-
-        insert_result = await asyncio.to_thread(generated_replies_collection.insert_one, reply_data_dict)
-        stored_id = str(insert_result.inserted_id)
-        print(f"[{datetime.now()}] Handle single reply: Reply stored in DB. ID: {stored_id}")
-
+        # Simplified response as no storage/cache ID
         final_response = {
             "reply": reply_content,
-            "stored_id": stored_id,
+            "stored_id": "N/A - Caching disabled", # Indicate that ID is not available
             "cached": False
         }
         if not future.done():
@@ -585,6 +542,7 @@ async def startup_event():
         client.admin.command('ping') # Test connection
         db = client[DB_NAME]
         extracted_emails_collection = db[EXTRACTED_EMAILS_COLLECTION]
+        # Keep generated_replies_collection definition if /query-generated-replies is still desired
         generated_replies_collection = db[GENERATED_REPLIES_COLLECTION]
         print(f"[{datetime.now()}] Successfully connected to MongoDB: {DB_NAME}")
 
@@ -739,16 +697,17 @@ async def extract_email_data_excel(request: ProcessEmailRequest):
     raise HTTPException(status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Excel functionality is currently disabled.")
 
 
-@app.post("/generate-reply", response_model=GenerateReplyResponse, summary="Generate a smart reply to an email (batched & cached)")
+@app.post("/generate-reply", response_model=GenerateReplyResponse, summary="Generate a smart reply to an email (batched)")
 async def generate_email_reply(request: GenerateReplyRequest):
     """
     Generates an intelligent email reply based on specified parameters (language, length, style, tone, emoji).
-    Uses a batch processing system with caching for efficiency.
+    Uses a batch processing system. Caching and database storage for replies are disabled.
     """
     print(f"[{datetime.now()}] /generate-reply: Received request.")
-    if generated_replies_collection is None or batch_processor_task is None or reply_queue_condition is None:
-        print(f"[{datetime.now()}] /generate-reply: Service not initialized. gen_replies_coll={generated_replies_collection is not None}, batch_task={batch_processor_task is not None}, queue_cond={reply_queue_condition is not None}")
-        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Reply generation service not fully initialized. Check server logs for database or batch processor issues.")
+    # generated_replies_collection check is no longer relevant for this endpoint's logic
+    if batch_processor_task is None or reply_queue_condition is None:
+        print(f"[{datetime.now()}] /generate-reply: Service not fully initialized. batch_task={batch_processor_task is not None}, queue_cond={reply_queue_condition is not None}")
+        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Reply generation service not fully initialized. Check server logs for batch processor issues.")
 
     future = asyncio.Future()
     current_time = asyncio.get_event_loop().time()
@@ -759,8 +718,8 @@ async def generate_email_reply(request: GenerateReplyRequest):
         print(f"[{datetime.now()}] /generate-reply: Request added to queue, notifying batch processor. Queue size: {len(reply_request_queue)}")
 
     try:
-        # Debugging: Increase timeout significantly to allow full tracing in logs
-        client_timeout = BATCH_TIMEOUT + 60.0 # Example: 0.5s batch + 60s LLM response buffer = 60.5s total timeout
+        # Debugging: Use a very long timeout for now to ensure server-side logs complete
+        client_timeout = BATCH_TIMEOUT + 300.0 # 5 minutes (0.5s batch + 300s buffer)
         print(f"[{datetime.now()}] /generate-reply: Waiting for future result with timeout {client_timeout}s.")
         result = await asyncio.wait_for(future, timeout=client_timeout)
         print(f"[{datetime.now()}] /generate-reply: Future result received. Returning data.")
@@ -832,6 +791,7 @@ async def query_extracted_emails_endpoint(query_params: ExtractedEmailQuery = De
 @app.get("/query-generated-replies", response_model=List[GeneratedReplyData], summary="Query generated replies from MongoDB")
 async def query_generated_replies_endpoint(query_params: GeneratedReplyQuery = Depends()):
     print(f"[{datetime.now()}] /query-generated-replies: Received request with params: {query_params.model_dump_json()}")
+    # This endpoint still relies on `generated_replies_collection`
     if generated_replies_collection is None:
         print(f"[{datetime.now()}] /query-generated-replies: MongoDB collection is None.")
         raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="MongoDB not available for querying generated replies.")