Update app.py

app.py

@@ -1,7 +1,7 @@
-from fastapi import FastAPI, HTTPException, Response, Request
+from fastapi import FastAPI, HTTPException, Response
 from fastapi.middleware.cors import CORSMiddleware
 import aiosqlite
-from typing import List, AsyncGenerator
+from typing import List
 import random
 import orjson
 from fastapi.middleware.gzip import GZipMiddleware
@@ -11,8 +11,7 @@ from cryptography.hazmat.primitives import hashes, serialization
 from cryptography.hazmat.primitives.asymmetric import rsa
 from datetime import datetime, timedelta
 import os
-from fastapi.responses import StreamingResponse
-
+from fastapi import Request
 
 app = FastAPI(
     title="Quiz API",
@@ -39,6 +38,7 @@ async def add_cache_headers(request: Request, call_next):
       response.headers["Expires"] = expires.strftime("%a, %d %b %Y %H:%M:%S GMT")
     return response
 
+
 # Database Manager (Singleton)
 class DatabaseManager:
     _instance = None
@@ -52,13 +52,13 @@ class DatabaseManager:
 
     async def connect(self):
         if self.conn is None:
-            try:
-                self.conn = await aiosqlite.connect(self.db_path)
-                self.conn.row_factory = aiosqlite.Row
-                print("Database connection established.")
-            except Exception as e:
-                print(f"Error establishing database connection: {e}")
-                raise  # Re-raise exception to be handled by calling code
+          try:
+            self.conn = await aiosqlite.connect(self.db_path)
+            self.conn.row_factory = aiosqlite.Row
+            print("Database connection established.")
+          except Exception as e:
+              print(f"Error establishing database connection: {e}")
+              raise  # Re-raise exception to be handled by calling code
         
         return self.conn
 
@@ -71,7 +71,6 @@ class DatabaseManager:
             except Exception as e:
                 print(f"Error closing database connection: {e}")
 
-
 db_manager = DatabaseManager()
 
 # Cache for precomputed data
@@ -131,16 +130,6 @@ def get_image():
         "clickUrl": click_url
     }
 
-async def stream_questions(cursor):
-    yield b"["  # Start of JSON array
-    first = True
-    async for row in cursor:
-        if not first:
-            yield b","
-        yield orjson.dumps(dict(row))
-        first = False
-    yield b"]"  # End of JSON array
-
 @app.get("/questions", 
     summary="Filter questions", 
     tags=["Questions"],
@@ -184,20 +173,14 @@ async def filter_questions(
     db = await db_manager.connect()
     try:
         cursor = await db.execute(query, params)
-        
-        # Check if there's any data to stream before yielding
-        if not await cursor.fetchone():
-          raise HTTPException(
+        questions = await cursor.fetchall()
+
+        if not questions:
+            raise HTTPException(
                 status_code=404, detail="No questions found with the given filters."
             )
-        
-        await cursor.close()
-        cursor = await db.execute(query, params) # re-execute since fetchone consume it
-        return StreamingResponse(
-                stream_questions(cursor), media_type="application/json"
-            )
-    except HTTPException as e:
-       raise e
+
+        return [dict(question) for question in questions]
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
     # finally:
@@ -262,22 +245,6 @@ def list_topics(subject: str, chapter: str):
 
     return cache["subject_chapters"][key]
 
-async def stream_topic_questions(cursor, subject, chapter, topic):
-  yield b'{"subject": '
-  yield orjson.dumps(subject)
-  yield b', "chapter": '
-  yield orjson.dumps(chapter)
-  yield b', "topic": '
-  yield orjson.dumps(topic)
-  yield b', "questions": ['
-  first = True
-  async for row in cursor:
-      if not first:
-          yield b","
-      yield orjson.dumps(dict(row))
-      first = False
-  yield b"]}"
-
 
 @app.get("/{subject}/{chapter}/{topic}",
     summary="List questions for a topic",
@@ -294,53 +261,24 @@ async def list_questions(subject: str, chapter: str, topic: str):
     db = await db_manager.connect()
     try:
         cursor = await db.execute(query, params)
-        
-        # Check if there's any data to stream before yielding
-        if not await cursor.fetchone():
-          raise HTTPException(
-              status_code=404, detail="Topic not found or no questions available."
-          )
-        await cursor.close()
-        cursor = await db.execute(query, params)
-        
-        return StreamingResponse(
-                stream_topic_questions(cursor, subject, chapter, topic),
-                media_type="application/json",
+        questions = await cursor.fetchall()
+
+        if not questions:
+            raise HTTPException(
+                status_code=404, detail="Topic not found or no questions available."
             )
-    except HTTPException as e:
-       raise e
+
+        return {
+            "subject": subject,
+            "chapter": chapter,
+            "topic": topic,
+            "questions": [dict(question) for question in questions],
+        }
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
     # finally:
     #    await db_manager.close()
 
-async def stream_test_questions(cursor, num_questions, total_time):
-    questions_list = []
-    async for row in cursor:
-        questions_list.append(dict(row))
-
-    if len(questions_list) < num_questions:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Not enough questions available. Requested {num_questions}, but found {len(questions_list)}."
-        )
-    
-    selected_questions = random.sample(questions_list, num_questions)
-
-    yield b'{"total_questions": '
-    yield orjson.dumps(num_questions)
-    yield b', "total_time": '
-    yield orjson.dumps(total_time)
-    yield b', "questions": ['
-    first = True
-    for question in selected_questions:
-      if not first:
-          yield b","
-      yield orjson.dumps(question)
-      first = False
-    yield b"]}"
-    
-
 @app.post("/generate-test",
     summary="Generate a test",
     tags=["Test Generation"],
@@ -376,26 +314,35 @@ async def generate_test(
 
     db = await db_manager.connect()
     try:
-        cursor = await db.execute(query, params)
-        # Check if there's any data to stream before yielding
-        if not await cursor.fetchone():
+      cursor = await db.execute(query, params)
+      questions = await cursor.fetchall()
+
+      if not questions:
           raise HTTPException(
               status_code=404, detail="No questions found matching the criteria."
           )
-        await cursor.close()
-        cursor = await db.execute(query, params)
-        
-        return StreamingResponse(
-                stream_test_questions(cursor, num_questions, total_time), media_type="application/json"
-            )
 
-    except HTTPException as e:
-        raise e
+      if len(questions) < num_questions:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Not enough questions available. Requested {num_questions}, but found {len(questions)}."
+        )
+
+      selected_questions = random.sample(questions, num_questions)
+
+      test = {
+          "total_questions": num_questions,
+          "total_time": total_time,
+          "questions": [dict(q) for q in selected_questions],
+      }
+
+      return test
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
     # finally:
     #    await db_manager.close()
 
+
 @app.on_event("shutdown")
 async def shutdown_event():
     await db_manager.close()
@@ -465,4 +412,5 @@ if __name__ == "__main__":
         ssl_certfile="cert.pem",
         timeout_keep_alive=60,
         log_level="warning"
+
     )