Update app.py

app.py

@@ -1,24 +1,22 @@
 # app.py
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
-import os
-import re
-import json
-from datetime import datetime
+import os, re, json
+from datetime import datetime, timedelta
 from typing import Optional, Dict, Any
+from groq import Groq
 
-# Together client import (expects TOGETHER_API_KEY in env)
-try:
-    from together import Together
-except Exception:
-    Together = None
+# Initialize Groq client using environment variable
+GROQ_KEY = os.getenv("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")
+if not GROQ_KEY:
+    raise RuntimeError("Missing GROQ_API_KEY. Set it as an environment variable or in Hugging Face Secrets.")
 
-TOGETHER_KEY = os.getenv("TOGETHER_API_KEY")
+client = Groq(api_key=GROQ_KEY)
 
-app = FastAPI(title="Task Parsing API")
+app = FastAPI(title="Task Parsing API (Groq-powered)")
 
-# --- Configuration / Prompts (trimmed & adapted from your snippet) ---
-llm_task_create_agent_system_prompt = '''
+# -------------------- PROMPTS --------------------
+llm_task_create_agent_system_prompt = f"""
 You are a task creation agent. Extract the following from user input:
 
 - Task Name (Text)
@@ -28,14 +26,14 @@ You are a task creation agent. Extract the following from user input:
 - Task Type (Work, Health, Personal)
 - Date Created (If not given, use current time)
 
-⚠️ ALL datetime values must follow 'YYYY-MM-DD HH:MM:SS'. NO other format. NO natural language like 'tomorrow' or 'evening'.
+⚠️ ALL datetime values must follow 'YYYY-MM-DD HH:MM:SS'. NO natural language like 'tomorrow' or 'evening'.
 
 Output JUST a JSON object. Example:
-{"Task Name": "Submit report", "Task Priority": "High", "Task Deadline": "2025-07-17 18:00:00", "Task Status": "Pending", "Task Type": "Work", "Date Created": "2025-07-01 12:00:00"}
-'''
+{{"Task Name": "Submit report", "Task Priority": "High", "Task Deadline": "2025-07-17 18:00:00", "Task Status": "Pending", "Task Type": "Work", "Date Created": "2025-07-01 12:00:00"}}
+"""
 
-# Simple regex extractor helper
-def extract_json_from_response(text: str) -> Optional[Dict[str, Any]]:
+# -------------------- HELPERS --------------------
+def extract_json_from_response(text: str):
     match = re.search(r"\{[\s\S]*\}", text)
     if not match:
         return None
@@ -44,71 +42,56 @@ def extract_json_from_response(text: str) -> Optional[Dict[str, Any]]:
     except json.JSONDecodeError:
         return None
 
-# Datetime validation
 DATETIME_REGEX = r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}"
 
 def validate_datetime_format(dt_str: str) -> bool:
-    if not isinstance(dt_str, str):
-        return False
     if re.fullmatch(DATETIME_REGEX, dt_str):
         try:
             datetime.strptime(dt_str, "%Y-%m-%d %H:%M:%S")
             return True
-        except Exception:
+        except:
             return False
     return False
 
-# Small wrapper to call Together (or raise helpful error)
-def call_llm_system(system_prompt: str, user_message: str, model: str = "meta-llama/Llama-3-8b-chat-hf") -> str:
-    if Together is None:
-        raise RuntimeError("together package is not installed. Set TOGETHER_API_KEY and install dependency 'together'.")
-    if not TOGETHER_KEY:
-        raise RuntimeError("Environment variable TOGETHER_API_KEY is missing. Set it before running the container.")
-
-    client = Together(api_key="2aa48b9b987fa3f745dd1862a2063f5fce1ee508c3de1a01c3ec6969d47434e6")
-    response = client.chat.completions.create(
+# -------------------- GROQ CALLER --------------------
+def call_groq_system(system_prompt: str, user_message: str, model: str = "llama-3.3-70b-versatile"):
+    """Generic wrapper to call Groq chat API."""
+    chat_completion = client.chat.completions.create(
         model=model,
         messages=[
             {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_message}
-        ]
+            {"role": "user", "content": user_message},
+        ],
     )
-    return response.choices[0].message.content.strip()
-
-# --- Agent functions (lightweight, synchronous) ---
+    return chat_completion.choices[0].message.content.strip()
 
-def run_task_creation_agent(nl_task: str) -> Dict[str, Any]:
-    reply = call_llm_system(llm_task_create_agent_system_prompt, nl_task)
+# -------------------- AGENTS --------------------
+def run_task_creation_agent(nl_task: str):
+    reply = call_groq_system(llm_task_create_agent_system_prompt, nl_task)
     parsed = extract_json_from_response(reply)
     if not parsed:
-        # If LLM didn't return JSON, propagate error message for debugging
-        raise ValueError(f"LLM did not return valid JSON. Raw reply:\n{reply}")
-    # Fill defaults
-    if "Date Created" not in parsed or not validate_datetime_format(parsed["Date Created"]):
-        parsed["Date Created"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    # Validate deadline
+        raise ValueError(f"LLM did not return valid JSON. Raw:\n{reply}")
+
     if not validate_datetime_format(parsed.get("Task Deadline", "")):
-        raise ValueError(f"Invalid or missing 'Task Deadline' in parsed JSON: {parsed.get('Task Deadline')}")
-    # Normalize fields
+        raise ValueError(f"Invalid 'Task Deadline': {parsed.get('Task Deadline')}")
+
+    if not validate_datetime_format(parsed.get("Date Created", "")):
+        parsed["Date Created"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
     parsed.setdefault("Task Status", "Pending")
     parsed.setdefault("Task Priority", "Medium")
     parsed.setdefault("Task Type", "Work")
+
     return parsed
 
-# Scheduler agent (minimal — returns the original requested deadline as "scheduled" if valid)
-# In the original pipeline, you used other agents to suggest an optimal datetime. For this lightweight API
-# we'll do a simple rule: if deadline is valid, respond with the deadline; otherwise return an error.
 
 def scheduler_agent(task_json: Dict[str, Any]) -> str:
-    # For extensibility, you can replace this function to call your LLM scheduler prompt
+    """Simplified scheduler — returns the deadline as the scheduled time."""
     deadline = task_json.get("Task Deadline")
     if not validate_datetime_format(deadline):
         raise ValueError("Scheduler requires a valid Task Deadline.")
-    # Return the same deadline as scheduled time (placeholder for more advanced scheduling).
     return deadline
 
-# Reminder agent — produce 1-2 reminders before scheduled time (simple offsets)
-from datetime import timedelta
 
 def reminder_agent(task_json: Dict[str, Any], scheduled_time_str: str):
     scheduled = datetime.strptime(scheduled_time_str, "%Y-%m-%d %H:%M:%S")
@@ -118,7 +101,7 @@ def reminder_agent(task_json: Dict[str, Any], scheduled_time_str: str):
         offsets = [timedelta(hours=24), timedelta(hours=1)]
     elif priority == "low":
         offsets = [timedelta(days=1), timedelta(days=3)]
-    else:  # medium
+    else:
         offsets = [timedelta(hours=12), timedelta(hours=1)]
 
     reminders = []
@@ -128,35 +111,27 @@ def reminder_agent(task_json: Dict[str, Any], scheduled_time_str: str):
             reminders.append(r.strftime("%Y-%m-%d %H:%M:%S"))
     return reminders
 
-# --- API models ---
+# -------------------- MODELS --------------------
 class ParseRequest(BaseModel):
     text: str
-    # Optional flags to control behavior in future
-    return_full_pipeline: Optional[bool] = False
 
 class ParseResponse(BaseModel):
     task_json: Dict[str, Any]
     scheduled_time: str
     reminders: list
 
-# --- Endpoints ---
+# -------------------- ENDPOINTS --------------------
 @app.post("/parse-task", response_model=ParseResponse)
 def parse_task(req: ParseRequest):
     try:
-        # 1) Create structured task using the task creation agent
         task_json = run_task_creation_agent(req.text)
-
-        # 2) Run scheduler (lightweight)
         scheduled_time = scheduler_agent(task_json)
-
-        # 3) Create reminders
         reminders = reminder_agent(task_json, scheduled_time)
-
         return ParseResponse(task_json=task_json, scheduled_time=scheduled_time, reminders=reminders)
     except Exception as e:
         raise HTTPException(status_code=400, detail=str(e))
 
-# Healthcheck
+
 @app.get("/health")
 def health():
     return {"status": "ok"}