Update main.py

main.py

@@ -1,13 +1,236 @@
+# from fastapi import FastAPI, HTTPException
+# from pydantic import BaseModel
+# import json
+# import openai
+# from typing import List, Dict, Any, Optional
+# import os
+
+# app = FastAPI()
+
+# class RoadmapInput(BaseModel):
+#     overall_study_pattern: str
+#     memorization_study_pattern: str
+#     problem_solving_study_pattern: str
+#     visualization_study_pattern: str
+#     obstacle_study_pattern: str
+#     new_topic_approach: str
+#     old_topic_approach: str
+#     topic_ratio: str
+#     hours_of_study: str
+#     hours_of_study_weekends: str
+#     revision_days: str
+#     test_days: str
+#     completed_phy_chapters: List[str]
+#     completed_chem_chapters: List[str]
+#     completed_maths_chapters: List[str]
+#     startphyRoadmapFrom: str
+#     startchemRoadmapFrom: str
+#     startmathRoadmapFrom: str
+#     userleft_topic_phy: List[dict]
+#     userleft_topic_chem: List[dict]
+#     userleft_topic_maths: List[dict]
+
+# output_structure = """
+# {
+#   "schedule": [
+#           "days": [
+#             {
+#               "dayNumber": int,
+#               "subjects": [
+#                 {
+#                   "name": "string",
+#                   "tasks": [
+#                     {
+#                       "type": "string",
+#                       "topic": "string",
+#                       "time": "string"
+#                     }
+#                   ]
+#                 }
+#               ]
+#             }
+#           ]
+#   ]
+# }
+# """
+
+# # Function to remove completed chapters from each subject
+# def remove_completed_chapters(subject_data, completed_chapters):
+#     subject_data["chapters"] = [chapter for chapter in subject_data["chapters"]
+#                                 if chapter["chapter"] not in completed_chapters]
+#     return subject_data
+
+# # Function to get topics within timeframe
+# def get_topics_within_timeframe(subject, allowed_time, start_subtopic):
+#     collected_subtopics = []
+#     time_spent = 0
+#     start_collecting = False
+
+#     if 'chapters' not in subject:
+#         print(f"Error: 'chapters' key not found in the subject: {subject}")
+#         return collected_subtopics
+
+#     for chapter in subject["chapters"]:
+#         if 'subtopics' not in chapter:
+#             print(f"Error: 'subtopics' key not found in the chapter: {chapter}")
+#             continue
+
+#         for subtopic in chapter["subtopics"]:
+#             if (subtopic["subtopic"] == start_subtopic):
+#                 start_collecting = True
+#                 continue
+
+#             if start_collecting and subtopic["subtopic_hours"]:
+#                 time_spent += float(subtopic["subtopic_hours"])
+#                 if time_spent <= allowed_time:
+#                     collected_subtopics.append({
+#                         "chapter": chapter["chapter"],
+#                         "subtopic": subtopic["subtopic"],
+#                         "subtopic_hours": subtopic["subtopic_hours"]
+#                     })
+#                 else:
+#                     break
+#         if time_spent > allowed_time:
+#             break
+
+#     return collected_subtopics
+
+
+# @app.post("/generate_roadmap")
+# async def generate_roadmap(input_data: RoadmapInput):
+#     try:
+#         # Load JSON data for each subject
+#         with open('Physics.json', 'r', encoding='utf-8') as file:
+#             phy = json.load(file)
+
+#         with open('Chemistry.json', 'r', encoding='utf-8') as file:
+#             chem = json.load(file)
+
+#         with open('Maths.json', 'r', encoding='utf-8') as file:
+#             maths = json.load(file)
+
+       
+
+#         # Remove completed chapters
+#         phy = remove_completed_chapters(phy, input_data.completed_phy_chapters)
+#         chem = remove_completed_chapters(chem, input_data.completed_chem_chapters)
+#         maths = remove_completed_chapters(maths, input_data.completed_maths_chapters)
+#         total_time=10;
+#         # Get topics within timeframe
+#         physics_topics = get_topics_within_timeframe(phy, total_time, input_data.startphyRoadmapFrom)
+#         chemistry_topics = get_topics_within_timeframe(chem, total_time, input_data.startchemRoadmapFrom)
+#         mathematics_topics = get_topics_within_timeframe(maths, total_time, input_data.startmathRoadmapFrom)
+     
+#         for topic in reversed(input_data.userleft_topic_phy):  
+#             physics_topics.insert(0, topic)
+#         for topic in reversed(input_data.userleft_topic_chem): 
+#             chemistry_topics.insert(0, topic)
+#         for topic in reversed(input_data.userleft_topic_maths):  
+#             mathematics_topics.insert(0, topic)
+        
+#         print(physics_topics)
+#         print(chemistry_topics)
+#         print(mathematics_topics)
+
+#         # User persona string
+#         userPersona = f"""
+#         You are required to generate a highly personalized roadmap for a student studying Physics, Chemistry, and Mathematics for the JEE Main exam.
+#         The roadmap should be tailored based on the following student-specific details:
+
+#         1. *Study Preferences:*
+#            - Study Pattern: {input_data.overall_study_pattern}
+#            - Memorization Approach: {input_data.memorization_study_pattern}
+#            - Problem-Solving Approach: {input_data.problem_solving_study_pattern}
+#            - Visualization Approach: {input_data.visualization_study_pattern}
+
+#         2. *Handling Challenges:*
+#            - If unable to understand a topic: {input_data.obstacle_study_pattern}
+#            - Approach to New Topics: {input_data.new_topic_approach}
+#            - Approach to Previously Encountered Topics: {input_data.old_topic_approach}
+
+#         3. *Study Hours:*
+#            - Weekdays: {input_data.hours_of_study} hours/day
+#            - Weekends: {input_data.hours_of_study_weekends} hours/day
+#            - Time Allocation Ratio (Physics:Chemistry:Mathematics): {input_data.topic_ratio}
+#            - By weekdays I mean day 1, day 2 , day 3 , day 4 , day 5
+#            - By weekends I mean day 6 , day 7
+#         """
+
+#         # System prompt
+#         sys_prompt = f"""
+#         You are required to generate a highly personalized roadmap for a student studying Physics, Chemistry, and Mathematics for the JEE Main exam.
+#         The roadmap should be tailored based on the following student-specific details:
+
+#         The roadmap must be provided in the following format:
+#         {output_structure}
+
+#         Do not include anything other than the roadmap, and ensure the focus remains strictly on the subjects {physics_topics}, {chemistry_topics}, and {mathematics_topics} and associated chapters.
+#         MAKE SURE THAT YOU MAKE THE ROADMAP FOR ALL THE THREE CHAPTERS EACH OF PHYSICS , CHEMISTRY AND MATHS TO COMPLETE THOSE CHAPTERS WITH 4 ASPECTS i.e "CONCEPT UNDERSTANDING","QUESTION PRACTICE","REVISION","TEST". ALSO INCLUDE TIME FOR EACH TASK THAT YOU GENERATE
+#         MAKE SURE THAT WE FIRST COMPLETE 1) CONCEPT UNDERSTANDING , 2) QUESTION PRACTICE FOR EVERY SUBTOPIC AND THEN REVISION AND TEST FOR WHOLE CHAPTER TOGETHER.
+#         MAKE SURE THAT WE INCLUDE EACH SUBTOPIC OF EACH CHAPTER FROM {physics_topics},{chemistry_topics} and {mathematics_topics} IS FINISHED
+#         YOU ARE NOT CONSTRAINED TO CREATE A ROADMAP FOR ONLY 'X' NUMBER OF DAYS , YOU CAN EXTEND TILL THE TOPICS ARE FINISHED BUT ONLY STICK TO THE TIMEFRAME ALLOTED FOR EACH SUBJECT AND DO NOT GO ABOVE OR BELOW THAT TIME FRAME.
+#         """
+#         openai.api_key=os.getenv("KEY")
+#         # First LLM call
+#         response = openai.ChatCompletion.create(
+#             model="gpt-4o-mini",
+#             messages=[
+#                 {
+#                     "role": "system",
+#                     "content": sys_prompt + "MAKE SURE YOU VERY VERY STRICTLY FOLLOW THE JSON STRUCTURE BECAUSE I WILL PARSE YOUR OUTPUT TO JSON"
+#                 },
+#                 {
+#                     "role": "user",
+#                     "content": userPersona
+#                 }
+#             ]
+#         )
+
+#         answer = response['choices'][0]['message']['content'].strip()
+
+#         # Calculate provided subtopics
+#         provided_subtopics = physics_topics + chemistry_topics + mathematics_topics
+
+#         # Second LLM call
+#         response = openai.ChatCompletion.create(
+#             model="gpt-4o-mini",
+#             messages=[
+#                 {
+#                     "role": "system",
+#                     "content": f'''
+#                     you created a very good roadmap {answer} but you make sure that you dont forget any subtopics from  {provided_subtopics}. ensure that the style is same as the previous roadmap.
+#                     MAKE SURE YOU VERY VERY STRICTLY FOLLOW THE JSON STRUCTURE BECAUSE I WILL PARSE YOUR OUTPUT TO JSON.
+#                     DO not include json at the top of the answer
+#                     '''
+#                 },
+#                 {
+#                     "role": "user",
+#                     "content": "Generate"
+#                 }
+#             ]
+#         )
+
+#         answer = response['choices'][0]['message']['content'].strip()
+#         parsed_json = json.loads(answer)
+
+#         return parsed_json
+#     except Exception as e:
+#         raise HTTPException(status_code=500, detail=str(e))
+
+# if __name__ == "__main__":
+#     import uvicorn
+#     uvicorn.run(app, host="0.0.0.0", port=8000)
+import json
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
-import json
 import openai
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any
 import os
 
 app = FastAPI()
 
-class RoadmapInput(BaseModel):
+# Pydantic models for request body
+class StudyInput(BaseModel):
     overall_study_pattern: str
     memorization_study_pattern: str
     problem_solving_study_pattern: str
@@ -16,190 +239,140 @@ class RoadmapInput(BaseModel):
     new_topic_approach: str
     old_topic_approach: str
     topic_ratio: str
-    hours_of_study: str
-    hours_of_study_weekends: str
+    hours_of_study: int
+    hours_of_study_weekends: int
     revision_days: str
     test_days: str
+    physicsStartIndex: int
+    chemistryStartIndex: int
+    mathematicsStartIndex: int
     completed_phy_chapters: List[str]
     completed_chem_chapters: List[str]
     completed_maths_chapters: List[str]
-    startphyRoadmapFrom: str
-    startchemRoadmapFrom: str
-    startmathRoadmapFrom: str
-    userleft_topic_phy: List[dict]
-    userleft_topic_chem: List[dict]
-    userleft_topic_maths: List[dict]
-
-output_structure = """
-{
-  "schedule": [
-          "days": [
-            {
-              "dayNumber": int,
-              "subjects": [
-                {
-                  "name": "string",
-                  "tasks": [
-                    {
-                      "type": "string",
-                      "topic": "string",
-                      "time": "string"
-                    }
-                  ]
-                }
-              ]
-            }
-          ]
-  ]
-}
-"""
+    total_time: int
 
-# Function to remove completed chapters from each subject
+# Function to remove completed chapters
 def remove_completed_chapters(subject_data, completed_chapters):
     subject_data["chapters"] = [chapter for chapter in subject_data["chapters"]
                                 if chapter["chapter"] not in completed_chapters]
     return subject_data
 
-# Function to get topics within timeframe
-def get_topics_within_timeframe(subject, allowed_time, start_subtopic):
-    collected_subtopics = []
-    time_spent = 0
-    start_collecting = False
-
-    if 'chapters' not in subject:
-        print(f"Error: 'chapters' key not found in the subject: {subject}")
-        return collected_subtopics
-
-    for chapter in subject["chapters"]:
-        if 'subtopics' not in chapter:
-            print(f"Error: 'subtopics' key not found in the chapter: {chapter}")
-            continue
-
-        for subtopic in chapter["subtopics"]:
-            if (subtopic["subtopic"] == start_subtopic):
-                start_collecting = True
-                continue
-
-            if start_collecting and subtopic["subtopic_hours"]:
-                time_spent += float(subtopic["subtopic_hours"])
-                if time_spent <= allowed_time:
-                    collected_subtopics.append({
-                        "chapter": chapter["chapter"],
-                        "subtopic": subtopic["subtopic"],
-                        "subtopic_hours": subtopic["subtopic_hours"]
-                    })
-                else:
-                    break
-        if time_spent > allowed_time:
-            break
-
-    return collected_subtopics
-
+# Function to get data at index
+def get_data_at_index(json_data, index):
+    if 0 <= index < len(json_data['chapters']):
+        return json_data['chapters'][index]
+    else:
+        return {}
 
 @app.post("/generate_roadmap")
-async def generate_roadmap(input_data: RoadmapInput):
-    try:
-        # Load JSON data for each subject
-        with open('Physics.json', 'r', encoding='utf-8') as file:
-            phy = json.load(file)
+async def generate_roadmap(study_input: StudyInput):
+    # Load JSON data for each subject
+    # Note: You'll need to adjust the file paths or include these JSON files in your Docker image
+    with open('Physics.json', 'r', encoding='utf-8') as file:
+        phy = json.load(file)
+    with open('Chemistry.json', 'r', encoding='utf-8') as file:
+        chem = json.load(file)
+    with open('Maths.json', 'r', encoding='utf-8') as file:
+        maths = json.load(file)
 
-        with open('Chemistry.json', 'r', encoding='utf-8') as file:
-            chem = json.load(file)
+    # Remove completed chapters
+    phy = remove_completed_chapters(phy, study_input.completed_phy_chapters)
+    chem = remove_completed_chapters(chem, study_input.completed_chem_chapters)
+    maths = remove_completed_chapters(maths, study_input.completed_maths_chapters)
 
-        with open('Maths.json', 'r', encoding='utf-8') as file:
-            maths = json.load(file)
+    # Get data at specified indices
+    phy = get_data_at_index(phy, study_input.physicsStartIndex)
+    chem = get_data_at_index(chem, study_input.chemistryStartIndex)
+    maths = get_data_at_index(maths, study_input.mathematicsStartIndex)
 
-       
+    # Prepare user persona
+    user_persona = f"""
+    You are required to generate a highly personalized roadmap for a student studying Physics, Chemistry, and Mathematics for the JEE Main exam.
+    The roadmap should be tailored based on the following student-specific details:
 
-        # Remove completed chapters
-        phy = remove_completed_chapters(phy, input_data.completed_phy_chapters)
-        chem = remove_completed_chapters(chem, input_data.completed_chem_chapters)
-        maths = remove_completed_chapters(maths, input_data.completed_maths_chapters)
-        total_time=10;
-        # Get topics within timeframe
-        physics_topics = get_topics_within_timeframe(phy, total_time, input_data.startphyRoadmapFrom)
-        chemistry_topics = get_topics_within_timeframe(chem, total_time, input_data.startchemRoadmapFrom)
-        mathematics_topics = get_topics_within_timeframe(maths, total_time, input_data.startmathRoadmapFrom)
-     
-        for topic in reversed(input_data.userleft_topic_phy):  
-            physics_topics.insert(0, topic)
-        for topic in reversed(input_data.userleft_topic_chem): 
-            chemistry_topics.insert(0, topic)
-        for topic in reversed(input_data.userleft_topic_maths):  
-            mathematics_topics.insert(0, topic)
-        
-        print(physics_topics)
-        print(chemistry_topics)
-        print(mathematics_topics)
-
-        # User persona string
-        userPersona = f"""
-        You are required to generate a highly personalized roadmap for a student studying Physics, Chemistry, and Mathematics for the JEE Main exam.
-        The roadmap should be tailored based on the following student-specific details:
-
-        1. *Study Preferences:*
-           - Study Pattern: {input_data.overall_study_pattern}
-           - Memorization Approach: {input_data.memorization_study_pattern}
-           - Problem-Solving Approach: {input_data.problem_solving_study_pattern}
-           - Visualization Approach: {input_data.visualization_study_pattern}
-
-        2. *Handling Challenges:*
-           - If unable to understand a topic: {input_data.obstacle_study_pattern}
-           - Approach to New Topics: {input_data.new_topic_approach}
-           - Approach to Previously Encountered Topics: {input_data.old_topic_approach}
-
-        3. *Study Hours:*
-           - Weekdays: {input_data.hours_of_study} hours/day
-           - Weekends: {input_data.hours_of_study_weekends} hours/day
-           - Time Allocation Ratio (Physics:Chemistry:Mathematics): {input_data.topic_ratio}
-           - By weekdays I mean day 1, day 2 , day 3 , day 4 , day 5
-           - By weekends I mean day 6 , day 7
-        """
-
-        # System prompt
-        sys_prompt = f"""
-        You are required to generate a highly personalized roadmap for a student studying Physics, Chemistry, and Mathematics for the JEE Main exam.
-        The roadmap should be tailored based on the following student-specific details:
-
-        The roadmap must be provided in the following format:
-        {output_structure}
-
-        Do not include anything other than the roadmap, and ensure the focus remains strictly on the subjects {physics_topics}, {chemistry_topics}, and {mathematics_topics} and associated chapters.
-        MAKE SURE THAT YOU MAKE THE ROADMAP FOR ALL THE THREE CHAPTERS EACH OF PHYSICS , CHEMISTRY AND MATHS TO COMPLETE THOSE CHAPTERS WITH 4 ASPECTS i.e "CONCEPT UNDERSTANDING","QUESTION PRACTICE","REVISION","TEST". ALSO INCLUDE TIME FOR EACH TASK THAT YOU GENERATE
-        MAKE SURE THAT WE FIRST COMPLETE 1) CONCEPT UNDERSTANDING , 2) QUESTION PRACTICE FOR EVERY SUBTOPIC AND THEN REVISION AND TEST FOR WHOLE CHAPTER TOGETHER.
-        MAKE SURE THAT WE INCLUDE EACH SUBTOPIC OF EACH CHAPTER FROM {physics_topics},{chemistry_topics} and {mathematics_topics} IS FINISHED
-        YOU ARE NOT CONSTRAINED TO CREATE A ROADMAP FOR ONLY 'X' NUMBER OF DAYS , YOU CAN EXTEND TILL THE TOPICS ARE FINISHED BUT ONLY STICK TO THE TIMEFRAME ALLOTED FOR EACH SUBJECT AND DO NOT GO ABOVE OR BELOW THAT TIME FRAME.
-        """
-        openai.api_key=os.getenv("KEY")
-        # First LLM call
+    1. *Study Preferences:*
+       - Study Pattern: {study_input.overall_study_pattern}
+       - Memorization Approach: {study_input.memorization_study_pattern}
+       - Problem-Solving Approach: {study_input.problem_solving_study_pattern}
+       - Visualization Approach: {study_input.visualization_study_pattern}
+
+    2. *Handling Challenges:*
+       - If unable to understand a topic: {study_input.obstacle_study_pattern}
+       - Approach to New Topics: {study_input.new_topic_approach}
+       - Approach to Previously Encountered Topics: {study_input.old_topic_approach}
+
+    3. *Study Hours:*
+       - Weekdays: {study_input.hours_of_study} hours/day
+       - Weekends: {study_input.hours_of_study_weekends} hours/day
+       - Time Allocation Ratio (Physics:Chemistry:Mathematics): {study_input.topic_ratio}
+       - By weekdays I mean day 1, day 2 , day 3 , day 4 , day 5
+       - By weekends I mean day 6 , day 7
+    """
+
+    # Prepare system prompt
+    sys_prompt = f"""
+    You are required to generate a highly personalized roadmap for a student studying Physics, Chemistry, and Mathematics for the JEE Main exam.
+    The roadmap should be tailored based on the following student-specific details:
+
+    The roadmap must be provided in the following format:
+    {{
+      "schedule": [
+              "days": [
+                {{
+                  "dayNumber": int,
+                  "subjects": [
+                    {{
+                      "name": "string",
+                      "tasks": [
+                        {{
+                          "type": "string",
+                          "topic": "string",
+                          "time": "string"
+                        }}
+                      ]
+                    }}
+                  ]
+                }}
+              ]
+      ]
+    }}
+
+    Do not include anything other than the roadmap, and ensure the focus remains strictly on the subjects {phy}, {chem}, and {maths} and associated chapters.
+    MAKE SURE THAT YOU MAKE THE ROADMAP FOR ALL THE THREE CHAPTERS EACH OF PHYSICS , CHEMISTRY AND MATHS TO COMPLETE THOSE CHAPTERS WITH 4 ASPECTS i.e "CONCEPT UNDERSTANDING","QUESTION PRACTICE","REVISION","TEST". ALSO INCLUDE TIME FOR EACH TASK THAT YOU GENERATE
+    MAKE SURE THAT WE FIRST COMPLETE 1) CONCEPT UNDERSTANDING , 2) QUESTION PRACTICE FOR EVERY SUBTOPIC AND THEN REVISION AND TEST FOR WHOLE CHAPTER TOGETHER.
+    MAKE SURE THAT WE INCULDE EACH SUBTOPIC OF EACH CHAPTER FROM {phy},{chem} and {maths} IS FINISHED
+    YOU ARE NOT CONSTRAINED TO CREATE A ROADMAP FOR ONLY 'X' NUMBER OF DAYS , YOU CAN EXTEND TILL THE TOPICS ARE FINISHED BUT ONLY STICK TO THE TIMEFRAME ALLOTED FOR EACH SUBJECT AND DO NOT GO ABOVE OR BELOW THAT TIME FRAME.
+    """
+
+    # Make OpenAI API call
+    openai.api_key = os.getenv("KEY")  # Replace with your actual API key or use environment variables
+    try:
         response = openai.ChatCompletion.create(
-            model="gpt-4o-mini",
+            model="gpt-4-0613",
             messages=[
                 {
                     "role": "system",
-                    "content": sys_prompt + "MAKE SURE YOU VERY VERY STRICTLY FOLLOW THE JSON STRUCTURE BECAUSE I WILL PARSE YOUR OUTPUT TO JSON"
+                    "content": sys_prompt + "MAKE SURE YOU VERY VERY STRUCTLY FOLLOW THE JSON STRUCTURE BECAUSE I WILL PARSE YOUR OUTPUT TO JSON"
                 },
                 {
                     "role": "user",
-                    "content": userPersona
+                    "content": user_persona
                 }
             ]
         )
 
         answer = response['choices'][0]['message']['content'].strip()
 
-        # Calculate provided subtopics
-        provided_subtopics = physics_topics + chemistry_topics + mathematics_topics
-
-        # Second LLM call
+        # Second OpenAI API call
+        provided_subtopics = list(phy.keys()) + list(chem.keys()) + list(maths.keys())
         response = openai.ChatCompletion.create(
-            model="gpt-4o-mini",
+            model="gpt-4-0613",
             messages=[
                 {
                     "role": "system",
                     "content": f'''
                     you created a very good roadmap {answer} but you make sure that you dont forget any subtopics from  {provided_subtopics}. ensure that the style is same as the previous roadmap.
-                    MAKE SURE YOU VERY VERY STRICTLY FOLLOW THE JSON STRUCTURE BECAUSE I WILL PARSE YOUR OUTPUT TO JSON.
+                    MAKE SURE YOU VERY VERY STRUCTLY FOLLOW THE JSON STRUCTURE BECAUSE I WILL PARSE YOUR OUTPUT TO JSON.
                     DO not include json at the top of the answer
                     '''
                 },
@@ -210,8 +383,8 @@ async def generate_roadmap(input_data: RoadmapInput):
             ]
         )
 
-        answer = response['choices'][0]['message']['content'].strip()
-        parsed_json = json.loads(answer)
+        final_answer = response['choices'][0]['message']['content'].strip()
+        parsed_json = json.loads(final_answer)
 
         return parsed_json
     except Exception as e:
@@ -219,4 +392,4 @@ async def generate_roadmap(input_data: RoadmapInput):
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    uvicorn.run(app, host="0.0.0.0", port=8000)