Chore dangling changes cleanup (#200)

* commonized and clean up logging in all places, not just most places

* one more that is out of place

* move to dynamical generating these - might be a better way

* more cleanup of envs

Author: wyattearp

api/api.py

@@ -10,17 +10,12 @@
 import google.generativeai as genai
 import asyncio
 
-# Get a logger for this module
-logger = logging.getLogger(__name__)
+# Configure logging
+from api.logging_config import setup_logging
 
-# Get API keys from environment variables
-google_api_key = os.environ.get('GOOGLE_API_KEY')
+setup_logging()
+logger = logging.getLogger(__name__)
 
-# Configure Google Generative AI
-if google_api_key:
-    genai.configure(api_key=google_api_key)
-else:
-    logger.warning("GOOGLE_API_KEY not found in environment variables")
 
 # Initialize FastAPI app
 app = FastAPI(
@@ -528,29 +523,29 @@ async def health_check():
 
 @app.get("/")
 async def root():
-    """Root endpoint to check if the API is running"""
+    """Root endpoint to check if the API is running and list available endpoints dynamically."""
+    # Collect routes dynamically from the FastAPI app
+    endpoints = {}
+    for route in app.routes:
+        if hasattr(route, "methods") and hasattr(route, "path"):
+            # Skip docs and static routes
+            if route.path in ["/openapi.json", "/docs", "/redoc", "/favicon.ico"]:
+                continue
+            # Group endpoints by first path segment
+            path_parts = route.path.strip("/").split("/")
+            group = path_parts[0].capitalize() if path_parts[0] else "Root"
+            method_list = list(route.methods - {"HEAD", "OPTIONS"})
+            for method in method_list:
+                endpoints.setdefault(group, []).append(f"{method} {route.path}")
+
+    # Optionally, sort endpoints for readability
+    for group in endpoints:
+        endpoints[group].sort()
+
     return {
         "message": "Welcome to Streaming API",
         "version": "1.0.0",
-        "endpoints": {
-            "Chat": [
-                "POST /chat/completions/stream - Streaming chat completion (HTTP)",
-                "WebSocket /ws/chat - WebSocket chat completion",
-            ],
-            "Wiki": [
-                "POST /export/wiki - Export wiki content as Markdown or JSON",
-                "GET /api/wiki_cache - Retrieve cached wiki data",
-                "POST /api/wiki_cache - Store wiki data to cache",
-                "GET /auth/status - Check if wiki authentication is enabled",
-                "POST /auth/validate - Check if wiki authentication is valid"
-            ],
-            "LocalRepo": [
-                "GET /local_repo/structure - Get structure of a local repository (with path parameter)",
-            ],
-            "Health": [
-                "GET /health - Health check endpoint"
-            ]
-        }
+        "endpoints": endpoints
     }
 
 # --- Processed Projects Endpoint --- (New Endpoint)

api/bedrock_client.py

@@ -11,6 +11,10 @@
 from adalflow.core.model_client import ModelClient
 from adalflow.core.types import ModelType, GeneratorOutput
 
+# Configure logging
+from api.logging_config import setup_logging
+
+setup_logging()
 log = logging.getLogger(__name__)
 
 class BedrockClient(ModelClient):
@@ -49,10 +53,12 @@ def __init__(
             aws_role_arn: AWS IAM role ARN for role-based authentication. If not provided, will use environment variable AWS_ROLE_ARN.
         """
         super().__init__(*args, **kwargs)
-        self.aws_access_key_id = aws_access_key_id or os.environ.get("AWS_ACCESS_KEY_ID")
-        self.aws_secret_access_key = aws_secret_access_key or os.environ.get("AWS_SECRET_ACCESS_KEY")
-        self.aws_region = aws_region or os.environ.get("AWS_REGION", "us-east-1")
-        self.aws_role_arn = aws_role_arn or os.environ.get("AWS_ROLE_ARN")
+        from api.config import AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION, AWS_ROLE_ARN
+
+        self.aws_access_key_id = aws_access_key_id or AWS_ACCESS_KEY_ID
+        self.aws_secret_access_key = aws_secret_access_key or AWS_SECRET_ACCESS_KEY
+        self.aws_region = aws_region or AWS_REGION or "us-east-1"
+        self.aws_role_arn = aws_role_arn or AWS_ROLE_ARN
 
         self.sync_client = self.init_sync_client()
         self.async_client = None  # Initialize async client only when needed

api/logging_config.py

@@ -34,7 +34,7 @@ def setup_logging(format: str = None):
     # Configure logging handlers and format
     logging.basicConfig(
         level=log_level,
-        format=format or "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        format = format or "%(asctime)s - %(levelname)s - %(name)s - %(filename)s:%(lineno)d - %(message)s",
         handlers=[
             logging.FileHandler(resolved_path),
             logging.StreamHandler()

api/main.py

@@ -9,8 +9,8 @@
 
 from api.logging_config import setup_logging
 
-# Setup logging with detailed format for main
-setup_logging(format="%(asctime)s - %(lineno)d %(filename)s:%(funcName)s - %(levelname)s - %(message)s")
+# Configure logging
+setup_logging()
 logger = logging.getLogger(__name__)
 
 # Add the current directory to the path so we can import the api package
@@ -23,6 +23,15 @@
     logger.warning(f"Missing environment variables: {', '.join(missing_vars)}")
     logger.warning("Some functionality may not work correctly without these variables.")
 
+# Configure Google Generative AI
+import google.generativeai as genai
+from api.config import GOOGLE_API_KEY
+
+if GOOGLE_API_KEY:
+    genai.configure(api_key=GOOGLE_API_KEY)
+else:
+    logger.warning("GOOGLE_API_KEY not configured")
+
 if __name__ == "__main__":
     # Get port from environment variable or use default
     port = int(os.environ.get("PORT", 8001))

api/ollama_patch.py

@@ -6,7 +6,7 @@
 from adalflow.core.types import Document
 from adalflow.core.component import DataComponent
 
-# Unified logging setup
+# Configure logging
 from api.logging_config import setup_logging
 
 setup_logging()

api/openrouter_client.py

@@ -1,6 +1,5 @@
 """OpenRouter ModelClient integration."""
 
-import os
 from typing import Dict, Sequence, Optional, Any, List
 import logging
 import json
@@ -45,9 +44,10 @@ def __init__(self, *args, **kwargs) -> None:
 
     def init_sync_client(self):
         """Initialize the synchronous OpenRouter client."""
-        api_key = os.environ.get("OPENROUTER_API_KEY")
+        from api.config import OPENROUTER_API_KEY
+        api_key = OPENROUTER_API_KEY
         if not api_key:
-            log.warning("OPENROUTER_API_KEY not found in environment variables")
+            log.warning("OPENROUTER_API_KEY not configured")
 
         # OpenRouter doesn't have a dedicated client library, so we'll use requests directly
         return {
@@ -57,9 +57,10 @@ def init_sync_client(self):
 
     def init_async_client(self):
         """Initialize the asynchronous OpenRouter client."""
-        api_key = os.environ.get("OPENROUTER_API_KEY")
+        from api.config import OPENROUTER_API_KEY
+        api_key = OPENROUTER_API_KEY
         if not api_key:
-            log.warning("OPENROUTER_API_KEY not found in environment variables")
+            log.warning("OPENROUTER_API_KEY not configured")
 
         # For async, we'll use aiohttp
         return {
@@ -115,7 +116,7 @@ async def acall(self, api_kwargs: Dict = None, model_type: ModelType = None) ->
 
         # Check if API key is set
         if not self.async_client.get("api_key"):
-            error_msg = "OPENROUTER_API_KEY not found in environment variables. Please set this environment variable to use OpenRouter."
+            error_msg = "OPENROUTER_API_KEY not configured. Please set this environment variable to use OpenRouter."
             log.error(error_msg)
             # Instead of raising an exception, return a generator that yields the error message
             # This allows the error to be displayed to the user in the streaming response

api/simple_chat.py

@@ -11,27 +11,19 @@
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel, Field
 
-from api.config import get_model_config, configs
+from api.config import get_model_config, configs, OPENROUTER_API_KEY, OPENAI_API_KEY, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY
 from api.data_pipeline import count_tokens, get_file_content
 from api.openai_client import OpenAIClient
 from api.openrouter_client import OpenRouterClient
 from api.bedrock_client import BedrockClient
 from api.rag import RAG
 
-# Unified logging setup
+# Configure logging
 from api.logging_config import setup_logging
 
 setup_logging()
 logger = logging.getLogger(__name__)
 
-# Get API keys from environment variables
-google_api_key = os.environ.get('GOOGLE_API_KEY')
-
-# Configure Google Generative AI
-if google_api_key:
-    genai.configure(api_key=google_api_key)
-else:
-    logger.warning("GOOGLE_API_KEY not found in environment variables")
 
 # Initialize FastAPI app
 app = FastAPI(
@@ -455,8 +447,8 @@ async def chat_completions_stream(request: ChatCompletionRequest):
             logger.info(f"Using OpenRouter with model: {request.model}")
 
             # Check if OpenRouter API key is set
-            if not os.environ.get("OPENROUTER_API_KEY"):
-                logger.warning("OPENROUTER_API_KEY environment variable is not set, but continuing with request")
+            if not OPENROUTER_API_KEY:
+                logger.warning("OPENROUTER_API_KEY not configured, but continuing with request")
                 # We'll let the OpenRouterClient handle this and return a friendly error message
 
             model = OpenRouterClient()
@@ -476,8 +468,8 @@ async def chat_completions_stream(request: ChatCompletionRequest):
             logger.info(f"Using Openai protocol with model: {request.model}")
 
             # Check if an API key is set for Openai
-            if not os.environ.get("OPENAI_API_KEY"):
-                logger.warning("OPENAI_API_KEY environment variable is not set, but continuing with request")
+            if not OPENAI_API_KEY:
+                logger.warning("OPENAI_API_KEY not configured, but continuing with request")
                 # We'll let the OpenAIClient handle this and return an error message
 
             # Initialize Openai client
@@ -498,8 +490,8 @@ async def chat_completions_stream(request: ChatCompletionRequest):
             logger.info(f"Using AWS Bedrock with model: {request.model}")
 
             # Check if AWS credentials are set
-            if not os.environ.get("AWS_ACCESS_KEY_ID") or not os.environ.get("AWS_SECRET_ACCESS_KEY"):
-                logger.warning("AWS_ACCESS_KEY_ID or AWS_SECRET_ACCESS_KEY environment variables are not set, but continuing with request")
+            if not AWS_ACCESS_KEY_ID or not AWS_SECRET_ACCESS_KEY:
+                logger.warning("AWS_ACCESS_KEY_ID or AWS_SECRET_ACCESS_KEY not configured, but continuing with request")
                 # We'll let the BedrockClient handle this and return an error message
 
             # Initialize Bedrock client

api/websocket_wiki.py

@@ -9,26 +9,18 @@
 from fastapi import WebSocket, WebSocketDisconnect, HTTPException
 from pydantic import BaseModel, Field
 
-from api.config import get_model_config, configs
+from api.config import get_model_config, configs, OPENROUTER_API_KEY, OPENAI_API_KEY
 from api.data_pipeline import count_tokens, get_file_content
 from api.openai_client import OpenAIClient
 from api.openrouter_client import OpenRouterClient
 from api.rag import RAG
 
-# Unified logging setup
+# Configure logging
 from api.logging_config import setup_logging
 
 setup_logging()
 logger = logging.getLogger(__name__)
 
-# Get API keys from environment variables
-google_api_key = os.environ.get('GOOGLE_API_KEY')
-
-# Configure Google Generative AI
-if google_api_key:
-    genai.configure(api_key=google_api_key)
-else:
-    logger.warning("GOOGLE_API_KEY not found in environment variables")
 
 # Models for the API
 class ChatMessage(BaseModel):
@@ -455,8 +447,8 @@ async def handle_websocket_chat(websocket: WebSocket):
             logger.info(f"Using OpenRouter with model: {request.model}")
 
             # Check if OpenRouter API key is set
-            if not os.environ.get("OPENROUTER_API_KEY"):
-                logger.warning("OPENROUTER_API_KEY environment variable is not set, but continuing with request")
+            if not OPENROUTER_API_KEY:
+                logger.warning("OPENROUTER_API_KEY not configured, but continuing with request")
                 # We'll let the OpenRouterClient handle this and return a friendly error message
 
             model = OpenRouterClient()
@@ -476,8 +468,8 @@ async def handle_websocket_chat(websocket: WebSocket):
             logger.info(f"Using Openai protocol with model: {request.model}")
 
             # Check if an API key is set for Openai
-            if not os.environ.get("OPENAI_API_KEY"):
-                logger.warning("OPENAI_API_KEY environment variable is not set, but continuing with request")
+            if not OPENAI_API_KEY:
+                logger.warning("OPENAI_API_KEY not configured, but continuing with request")
                 # We'll let the OpenAIClient handle this and return an error message
 
             # Initialize Openai client