Removed App changes

app.py

@@ -1,13 +1,12 @@
 import logging
-from fastapi import FastAPI, HTTPException, BackgroundTasks, Request
+from fastapi import FastAPI, HTTPException, BackgroundTasks
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 from typing import Dict, Optional, List, Any
 import uuid
 from datetime import datetime
 from contextlib import asynccontextmanager
-import asyncio
+
 from models.embedding import EmbeddingModel
 from models.summarization import SummarizationModel
 from models.nlp import NLPModel
@@ -20,6 +19,7 @@ logging.basicConfig(
     format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
     handlers=[logging.StreamHandler()]
 )
+logger = logging.getLogger(__name__)
 
 # Initialize models
 embedding_model = None
@@ -32,27 +32,27 @@ async def lifespan(app: FastAPI):
     global embedding_model, summarization_model, nlp_model, db_service
     
     # Model initialization
-    logging.info("Initializing models...")
+    logger.info("Initializing models...")
     try:
         embedding_model = EmbeddingModel()
         summarization_model = SummarizationModel()
         nlp_model = NLPModel()
         db_service = DatabaseService()
-        logging.info("All models initialized successfully")
+        logger.info("All models initialized successfully")
     except Exception as e:
-        logging.error(f"Model initialization failed: {str(e)}")
+        logger.error(f"Model initialization failed: {str(e)}")
         raise
 
     yield
 
     # Cleanup
-    logging.info("Shutting down application...")
+    logger.info("Shutting down application...")
     if db_service:
         try:
             await db_service.close()
-            logging.info("Database connection closed successfully")
+            logger.info("Database connection closed successfully")
         except Exception as e:
-            logging.error(f"Error closing database connection: {str(e)}")
+            logger.error(f"Error closing database connection: {str(e)}")
 
 app = FastAPI(
     title="Kairos News API",
@@ -84,51 +84,11 @@ class JobStatus(BaseModel):
     request: PostRequest
     result: Optional[Dict[str, Any]] = None
 
-@app.get("/")
-async def root(request: Request):
-    """Root endpoint with API information"""
-    logging.info(f"Root access from {request.client.host}")
-    return {
-        "message": "Kairos News API is running",
-        "endpoints": {
-            "create_job": {"method": "POST", "path": "/index"},
-            "check_status": {"method": "GET", "path": "/loading"},
-            "get_logs": {"method": "GET", "path": "/logs"}
-        }
-    }
-
-@app.get("/logs")
-async def get_logs(log_type: str = None):
-    """Endpoint for log retrieval"""
-    if log_type == "container":
-        return {"message": "Container logs endpoint", "status": "Not implemented"}
-    return {
-        "message": "Available log types: container",
-        "usage": "/logs?log_type=container"
-    }
-
-@app.exception_handler(404)
-async def not_found_exception_handler(request: Request, exc: HTTPException):
-    """Custom 404 handler"""
-    logging.warning(f"404 Not Found: {request.url}")
-    return JSONResponse(
-        status_code=404,
-        content={
-            "message": "Endpoint not found",
-            "available_endpoints": [
-                {"path": "/", "method": "GET"},
-                {"path": "/index", "method": "POST"},
-                {"path": "/loading", "method": "GET"},
-                {"path": "/logs", "method": "GET"}
-            ]
-        },
-    )
-
 @app.post("/index", response_model=JobStatus)
 async def create_job(request: PostRequest, background_tasks: BackgroundTasks):
     job_id = str(uuid.uuid4())
-    logging.info(f"Creating new job {job_id} with request: {request.dict()}")
-    print(asyncio.get_running_loop())
+    logger.info(f"Creating new job {job_id} with request: {request.dict()}")
+
     jobs_db[job_id] = {
         "id": job_id,
         "status": "processing",
@@ -148,17 +108,17 @@ async def create_job(request: PostRequest, background_tasks: BackgroundTasks):
         db_service
     )
     
-    logging.info(f"Job {job_id} created and processing started")
+    logger.info(f"Job {job_id} created and processing started")
     return jobs_db[job_id]
 
 @app.get("/loading", response_model=JobStatus)
 async def get_job_status(id: str):
-    logging.info(f"Checking status for job {id}")
+    logger.info(f"Checking status for job {id}")
     if id not in jobs_db:
-        logging.warning(f"Job {id} not found")
+        logger.warning(f"Job {id} not found")
         raise HTTPException(status_code=404, detail="Job not found")
     
-    logging.info(f"Returning status for job {id}: {jobs_db[id]['status']}")
+    logger.info(f"Returning status for job {id}: {jobs_db[id]['status']}")
     return jobs_db[id]
 
 async def process_job(
@@ -170,7 +130,7 @@ async def process_job(
     db_service: DatabaseService
 ):
     try:
-        logging.info(f"Starting processing for job {job_id}")
+        logger.info(f"Starting processing for job {job_id}")
         
         processor = QueryProcessor(
             embedding_model=embedding_model,
@@ -179,7 +139,7 @@ async def process_job(
             db_service=db_service
         )
         
-        logging.debug(f"Processing query: {request.query}")
+        logger.debug(f"Processing query: {request.query}")
         result = await processor.process(
             query=request.query,
             topic=request.topic,
@@ -192,13 +152,13 @@ async def process_job(
             "completed_at": datetime.now(),
             "result": result if result else {"message": "No results found"}
         })
-        logging.info(f"Job {job_id} completed successfully")
+        logger.info(f"Job {job_id} completed successfully")
         
     except Exception as e:
-        logging.error(f"Error processing job {job_id}: {str(e)}", exc_info=True)
+        logger.error(f"Error processing job {job_id}: {str(e)}", exc_info=True)
         jobs_db[job_id].update({
             "status": "failed",
             "completed_at": datetime.now(),
             "result": {"error": str(e)}
         })
-        logging.info(f"Job {job_id} marked as failed")
+        logger.info(f"Job {job_id} marked as failed")