Upload 16 files

app/api/endpoints/plans.py

@@ -0,0 +1,53 @@
+# app/api/endpoints/plans.py
+from fastapi import APIRouter, HTTPException
+# Import the new RestartPlanBody model
+from app.core.models import GeneratePlanRequest, RevisePlanRequest, PlanResponse, RestartPlanBody
+from app.services.planner_service import planner_service
+
+router = APIRouter()
+
+# Updated endpoint to pass the new attribute
+@router.post("/generate", response_model=PlanResponse)
+async def generate_new_plan(request: GeneratePlanRequest):
+    """
+    Generates a new training plan based on athlete's profile and goal timeframe.
+    """
+    plan_object = await planner_service.create_plan(
+        profile=request.athlete_profile,
+        plan_type=request.plan_type,
+        focus=request.focus,
+        time_to_achieve=request.time_to_achieve # Pass the new value
+    )
+    if "error" in plan_object:
+        raise HTTPException(status_code=500, detail=plan_object["error"])
+    return plan_object
+
+# The revise endpoint remains unchanged
+@router.post("/revise", response_model=PlanResponse)
+async def revise_existing_plan(request: RevisePlanRequest):
+    """
+    Revises an existing training plan based on feedback.
+    """
+    revised_plan_object = await planner_service.update_plan(
+        original_plan=request.original_plan,
+        review=request.review
+    )
+    if "error" in revised_plan_object:
+        raise HTTPException(status_code=500, detail=revised_plan_object["error"])
+    return revised_plan_object
+
+# vvv THIS IS THE NEW ENDPOINT vvv
+@router.post("/athlete/{athlete_id}/restart", response_model=PlanResponse, tags=["Training Plans"])
+async def restart_athlete_plan(athlete_id: str, request: RestartPlanBody):
+    """
+    Archives the athlete's current plan and generates a new one.
+    This provides a 'Fresh Start' for the athlete.
+    """
+    new_plan_object = await planner_service.restart_plan(
+        athlete_id=athlete_id,
+        new_plan_details=request.model_dump()
+    )
+    if "error" in new_plan_object:
+        raise HTTPException(status_code=500, detail=new_plan_object["error"])
+    
+    return new_plan_object

app/core/config.py

@@ -0,0 +1,10 @@
+# app/core/config.py
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    GEMINI_API_KEY: str
+
+    class Config:
+        env_file = ".env"
+
+settings = Settings()

app/core/models.py

@@ -0,0 +1,41 @@
+# app/core/models.py
+from pydantic import BaseModel, Field
+from typing import Dict, List, Literal, Optional
+from datetime import date
+
+# The Task class remains deleted.
+
+class AthleteProfile(BaseModel):
+    # ... (this model is unchanged)
+    age: int = Field(..., gt=0, description="Athlete's age")
+    sport: str = Field(..., min_length=1, description="Athlete's primary sport")
+    goal: str = Field(..., min_length=1, description="Athlete's primary training goal")
+
+class GeneratePlanRequest(BaseModel):
+    # ... (this model is unchanged)
+    athlete_profile: AthleteProfile
+    plan_type: Literal["daily", "weekly"]
+    focus: str = Field("Overall fitness")
+    time_to_achieve: str
+
+# New request model for the restart endpoint's body
+class RestartPlanBody(BaseModel):
+    plan_type: Literal["daily", "weekly"] = Field(..., description="The plan type for the new plan")
+    focus: str = Field(..., description="The focus for the new plan")
+    time_to_achieve: str = Field(..., description="The timeframe for the new plan")
+
+
+class PlanObject(BaseModel):
+    # ADD a status field to track the plan's state. Default is "active".
+    status: str = Field("active", description="The current status of the plan (e.g., active, archived_by_user)")
+    type: Literal["daily", "weekly"]
+    weekStart: date
+    plan: Dict[str, List[str]]
+    no_of_days_req: Optional[int] = None
+    no_of_weeks_req: Optional[int] = None
+
+class RevisePlanRequest(BaseModel):
+    original_plan: PlanObject
+    review: str
+
+PlanResponse = PlanObject

app/services/planner_service.py

@@ -0,0 +1,163 @@
+# app/services/planner_service.py
+
+import json
+import google.generativeai as genai
+from datetime import date, timedelta
+from app.core.config import settings
+from app.core.models import AthleteProfile, PlanObject
+# In a real application, you would initialize your database client here
+# For example, with Firestore:
+# from google.cloud import firestore
+
+class PlannerService:
+    """
+    Handles the core logic of creating, revising, and restarting training plans
+    by interacting with the Gemini AI model and a database.
+    """
+    def __init__(self, api_key: str):
+        """
+        Initializes the Gemini model and database client.
+        """
+        genai.configure(api_key=api_key)
+        self.model = genai.GenerativeModel('gemini-1.5-flash-latest')
+        # self.db = firestore.Client() # Uncomment and configure for your database
+
+    async def _parse_llm_response(self, response_text: str) -> dict:
+        """
+        Cleans and parses the string response from the LLM into a dictionary.
+        """
+        try:
+            # The model sometimes wraps the JSON in markdown, so we strip it.
+            json_string = response_text.strip().replace('```json', '').replace('```', '')
+            return json.loads(json_string)
+        except json.JSONDecodeError:
+            # Return a standard error object if parsing fails
+            return {"error": "AI failed to generate a valid plan structure. Please try again."}
+
+    def _get_start_of_week(self) -> date:
+        """
+        Calculates the date of the most recent Monday.
+        """
+        today = date.today()
+        # today.weekday() returns Monday as 0 and Sunday as 6
+        start_of_week = today - timedelta(days=today.weekday())
+        return start_of_week
+
+    async def create_plan(self, profile: AthleteProfile, plan_type: str, focus: str, time_to_achieve: str) -> dict:
+        """
+        Generates the data for a new, repeatable training plan using the AI.
+        """
+        prompt = f"""
+        You are an expert sports trainer for KhelVerse creating a repeatable, template-based training plan.
+
+        **Athlete Profile:** {profile.model_dump_json()}
+        **Primary Goal:** {profile.goal}
+        **Desired Timeframe to Achieve Goal:** {time_to_achieve}
+        **Plan Type Requested:** {plan_type}
+        **Specific Focus:** {focus}
+
+        **Your Task & Rules:**
+        1.  Create a single, repeatable training template. **DO NOT** create a progressive plan.
+        2.  Estimate the total duration needed to achieve the goal.
+        3.  Return a single, valid JSON object with two top-level keys: "plan" and a duration key ("no_of_days_req" or "no_of_weeks_req").
+
+        **Output Format Rules:**
+        -   The "plan" dictionary keys depend on the plan type.
+        -   The value for each key **MUST BE A LIST OF STRINGS**. Each string should be a single, specific exercise.
+        -   **If `plan_type` is "daily"**: Keys are times (e.g., "6 AM"). Example value: ["10 min jogging", "Dynamic stretching"].
+        -   **If `plan_type` is "weekly"**: Keys are "D1" through "D7". Example value for "D1": ["Run 5km at moderate pace", "Core workout: 3 sets of planks"].
+        """
+        response = await self.model.generate_content_async(prompt)
+        llm_response = await self._parse_llm_response(response.text)
+
+        if "error" in llm_response:
+            return llm_response
+
+        # Assemble the full object to be returned by the API
+        full_plan_object = {
+            "type": plan_type,
+            "weekStart": self._get_start_of_week(),
+            "plan": llm_response.get('plan', {}),
+            "no_of_days_req": llm_response.get('no_of_days_req'),
+            "no_of_weeks_req": llm_response.get('no_of_weeks_req')
+        }
+        return full_plan_object
+
+    async def update_plan(self, original_plan: PlanObject, review: str) -> dict:
+        """
+        Revises an existing plan based on user feedback.
+        """
+        # Dump the model to a dict to get a clean JSON representation for the prompt
+        plan_to_revise_for_prompt = original_plan.model_dump()['plan']
+        
+        prompt = f"""
+        You are an expert sports trainer. Revise the tasks in the following repeatable training template based on the user's review.
+
+        **Original Plan Template (JSON format):**
+        {json.dumps(plan_to_revise_for_prompt, indent=2)}
+
+        **User's Review:**
+        "{review}"
+
+        **Your Task & Rules:**
+        1.  Modify the plan template based ONLY on the review.
+        2.  The value for each key MUST remain a LIST OF STRINGS.
+        3.  The output must be a single, valid JSON object of the tasks, maintaining the original key structure.
+        """
+        response = await self.model.generate_content_async(prompt)
+        revised_plan_dict = await self._parse_llm_response(response.text)
+        
+        if "error" in revised_plan_dict:
+            return revised_plan_dict
+
+        # Reconstruct the full object, carrying over metadata from the original plan
+        full_revised_object = {
+            "status": original_plan.status, # Keep original status
+            "type": original_plan.type,
+            "weekStart": original_plan.weekStart,
+            "plan": revised_plan_dict,
+            "no_of_days_req": original_plan.no_of_days_req,
+            "no_of_weeks_req": original_plan.no_of_weeks_req
+        }
+        return full_revised_object
+
+    async def restart_plan(self, athlete_id: str, new_plan_details: dict) -> dict:
+        """
+        Orchestrates the 'Fresh Start' feature: archives the old plan and creates a new one.
+        """
+        # --- Step 1: Archive the old plan (Database Interaction) ---
+        print(f"LOGIC: Searching for active plan for athlete {athlete_id} to archive.")
+        # This is where you would put your actual database code.
+        # Example for Firestore:
+        # plans_ref = self.db.collection('plans')
+        # query = plans_ref.where('athleteId', '==', athlete_id).where('status', '==', 'active').limit(1)
+        # for plan_doc in query.stream():
+        #     print(f"LOGIC: Found plan {plan_doc.id}. Setting status to 'archived_by_user'.")
+        #     plan_doc.reference.update({'status': 'archived_by_user'})
+
+        
+        # --- Step 2: Generate the new plan (Re-using existing logic) ---
+        print("LOGIC: Generating a new plan.")
+        
+        # Fetch the full athlete profile from your database using the athlete_id
+        # MOCKING athlete profile for this example. Replace with your DB call.
+        athlete_profile_data = {"age": 25, "sport": "Running", "goal": "Run a marathon"}
+        athlete_profile = AthleteProfile(**athlete_profile_data)
+        
+        # Call the existing create_plan method to get the new plan's data dictionary
+        new_plan_dict = await self.create_plan(
+            profile=athlete_profile,
+            plan_type=new_plan_details['plan_type'],
+            focus=new_plan_details['focus'],
+            time_to_achieve=new_plan_details['time_to_achieve']
+        )
+
+        # In a real app, you would save the new plan to the database here.
+        # new_plan_dict['athleteId'] = athlete_id # Add athlete ID before saving
+        # new_plan_ref = self.db.collection('plans').add(new_plan_dict)
+        # print(f"LOGIC: New plan created in DB with ID: {new_plan_ref[1].id}")
+
+        return new_plan_dict
+
+# A single instance of the service is created to be used across the application
+planner_service = PlannerService(api_key=settings.GEMINI_API_KEY)