pheww again

app.py

@@ -2,42 +2,50 @@
 import os
 import sys
 from fastapi import FastAPI
+import logging
+import redis # For optional top-level Redis connectivity check
 
-# --- Crucial for finding your modules ---
-# Assuming app.py is at the project root level.
+# --- CRITICAL: Adjust sys.path to find your modules correctly ---
+# Assuming 'app.py' is at the project root level.
 # This ensures Python can find 'components' and 'routes' as packages.
 sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "components")))
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "routes"))) # Add the routes directory
-# Add routes/api to path if you are doing 'from routes.api import module' directly
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "routes"))) 
+# Add routes/api specifically, as you're importing directly from it
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "routes", "api")))
 
 # Import your routers
-# These imports expect routes/api/ingest.py, routes/api/query.py, routes/api/headlines.py to exist
+# These imports expect routes/api/ingest.py, routes/api/descriptive.py, routes/api/headlines.py to exist
 from routes.api import ingest as ingest_router_module
-from routes.api import query as query_router_module # Assuming this exists
-from routes.api import headlines as headlines_router_module
+from routes.api import descriptive as descriptive_router_module
+from routes.api import headlines as headlines_router_module 
+# query.py is ignored as per your instruction
 
+# Configure basic logging for the application
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# NOTE: Settings.llm = None
-# This line is problematic if LlamaIndex components in your pipeline (like query engine)
-# rely on a global LLM setting. If you intend to use an LLM with LlamaIndex features,
-# you would set it here, e.g., `Settings.llm = OpenAI()`
-# For this current pipeline, the OpenAI client is initialized explicitly within
-# daily_feed.py and detailed_explainer.py, so setting Settings.llm here is not strictly needed
-# but also not harmful if it's just meant as a placeholder for a different use case.
-# I will leave it commented out as per your original request, but be aware of its implications.
-# Settings.llm = None
+app = FastAPI(
+    title="Nuse AI News Aggregator",
+    description="API for fetching, summarizing, and providing detailed explanations of news articles.",
+    version="1.0.0",
+)
 
+# Optional: App-level Redis client check 
+REDIS_URL = os.environ.get("UPSTASH_REDIS_URL", "redis://localhost:6379")
+try:
+    _app_redis_client_test = redis.Redis.from_url(REDIS_URL, decode_responses=True)
+    _app_redis_client_test.ping()
+    logging.info("App-level Redis connection test successful.")
+except Exception as e:
+    logging.critical(f"❌ FATAL ERROR: App-level Redis connection failed: {e}. Some functionalities may be impaired.")
 
-app = FastAPI()
 
 @app.get("/")
 def greet():
+    """Root endpoint for the API."""
     return {"welcome": "nuse ai"}
 
-# Include your routers
-# Use .router to access the APIRouter instance from the imported modules
-app.include_router(ingest_router_module.router, prefix="/api/ingest")
-app.include_router(query_router_module.router, prefix="/api/query") # Assuming query.py exists
-app.include_router(headlines_router_module.router, prefix="/api/headlines")
+# Include your routers with specific prefixes and tags
+app.include_router(ingest_router_module.router, prefix="/api/ingest", tags=["Data Ingestion & Summaries"])
+app.include_router(descriptive_router_module.router, prefix="/api/descriptive", tags=["Detailed Explanations"])
+app.include_router(headlines_router_module.router, prefix="/api/headlines", tags=["Headlines (Placeholder)"])

routes/api/descriptive.py

@@ -1,14 +1,13 @@
-# routes/api/headlines.py
+# routes/api/descriptive.py
 from fastapi import APIRouter, HTTPException, status
 import logging
 from typing import Dict, Any
 
 # Import functions directly from the now standalone detailed_explainer
-# Ensure sys.path in app.py allows these imports to components/generators
 from components.generators.detailed_explainer import (
     generate_detailed_feed,
-    cache_detailed_feed,
-    get_cached_detailed_feed
+    cache_detailed_feed,       # Function to cache the detailed feed
+    get_cached_detailed_feed   # Function to retrieve the detailed feed
 )
 # We also need to get the initial summaries, which are managed by daily_feed.py
 from components.generators.daily_feed import get_cached_daily_feed
@@ -24,10 +23,10 @@ async def generate_detailed_headlines_endpoint() -> Dict[str, Any]:
     This step requires initial summaries to be present in Redis cache (from daily_feed.py).
     The final detailed feed is then cached by this endpoint using its dedicated key.
     """
-    logging.info("API Call: POST /api/headlines/generate-detailed initiated.")
+    logging.info("API Call: POST /api/descriptive/generate-detailed initiated.")
     try:
         # Step 1: Retrieve the cached initial summaries
-        initial_summaries = get_cached_daily_feed() # This gets data from "initial_news_summary_cache"
+        initial_summaries = get_cached_daily_feed() # From daily_feed.py
         
         if not initial_summaries:
             logging.warning("No initial summaries found in cache to generate detailed explanations from.")
@@ -49,16 +48,16 @@ async def generate_detailed_headlines_endpoint() -> Dict[str, Any]:
         # This function (cache_detailed_feed) internally uses its own Redis client and DETAILED_FEED_CACHE_KEY
         cache_detailed_feed(detailed_feed) 
 
-        logging.info("API Call: POST /api/headlines/generate-detailed completed successfully.")
+        logging.info("API Call: POST /api/descriptive/generate-detailed completed successfully.")
         
         total_items = sum(len(topic_summaries) for topic_summaries in detailed_feed.values())
         
         return {"status": "success", "message": "Detailed headlines generated and cached.", "items": total_items}
 
     except HTTPException as he:
-        raise he # Re-raise FastAPI's HTTPExceptions
+        raise he
     except Exception as e:
-        logging.error(f"Error in /api/headlines/generate-detailed: {e}", exc_info=True)
+        logging.error(f"Error in /api/descriptive/generate-detailed: {e}", exc_info=True)
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=f"An unexpected error occurred during detailed feed generation: {e}"
@@ -70,7 +69,7 @@ async def get_detailed_headlines_endpoint() -> Dict[str, Dict[int, Dict[str, Any
     Retrieves the most recently cached *fully detailed* news feed.
     Returns 404 if no detailed feed is found in cache.
     """
-    logging.info("API Call: GET /api/headlines/get-detailed initiated.")
+    logging.info("API Call: GET /api/descriptive/get-detailed initiated.")
     try:
         # Retrieve the cached detailed feed using the function from detailed_explainer
         cached_detailed_feed = get_cached_detailed_feed()
@@ -79,16 +78,16 @@ async def get_detailed_headlines_endpoint() -> Dict[str, Dict[int, Dict[str, Any
             logging.info("No full detailed news feed found in cache.")
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
-                detail="No detailed news feed found in cache. Please run /api/headlines/generate-detailed first."
+                detail="No detailed news feed found in cache. Please run /api/descriptive/generate-detailed first."
             )
         
-        logging.info("API Call: GET /api/headlines/get-detailed completed successfully.")
+        logging.info("API Call: GET /api/descriptive/get-detailed completed successfully.")
         return cached_detailed_feed
 
     except HTTPException as he:
         raise he
     except Exception as e:
-        logging.error(f"Error in /api/headlines/get-detailed: {e}", exc_info=True)
+        logging.error(f"Error in /api/descriptive/get-detailed: {e}", exc_info=True)
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=f"An unexpected error occurred while retrieving cached detailed feed: {e}"