Fix dependencies import conflict

- Remove backend/dependencies/ directory (conflicted with existing file)
- Add authentication functions to existing backend/dependencies.py
- Update import in app.py to use correct module
- Maintain all existing database dependencies (get_db_session, etc.)
- Should fix import error on startup

backend/app.py

@@ -15,7 +15,7 @@ from starlette.middleware.sessions import SessionMiddleware
 from fastapi.responses import RedirectResponse, HTMLResponse
 from backend.middleware.auth import ConditionalAuthMiddleware
 from backend.middleware.usage_tracker import UsageTrackingMiddleware
-from backend.dependencies.auth import require_auth_in_hf_spaces
+from backend.dependencies import require_auth_in_hf_spaces
 from utils.environment import should_enable_auth, debug_environment
 
 

backend/dependencies.py

@@ -3,8 +3,9 @@ Dependencies for FastAPI routes
 """
 
 import logging
-from typing import Generator, Optional, Any
-from fastapi import Depends, HTTPException, status
+from typing import Generator, Optional, Any, Dict
+from fastapi import Depends, HTTPException, status, Request
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 
 # Initialize global testers
 knowledge_graph_tester = None
@@ -90,4 +91,94 @@ def get_prompt_reconstructor() -> Any:
                 detail=f"Error initializing reconstructor: {str(e)}"
             )
 
-    return prompt_reconstructor 
+    return prompt_reconstructor
+
+
+# ===== AUTHENTICATION DEPENDENCIES =====
+
+# Optional security scheme for Bearer tokens
+security = HTTPBearer(auto_error=False)
+
+
+def get_current_user_optional(request: Request) -> Optional[Dict[str, Any]]:
+    """
+    Get current user from session, but don't raise error if not found.
+    Used for endpoints where authentication is optional.
+    """
+    from utils.environment import should_enable_auth
+    
+    if not should_enable_auth():
+        logger.debug("🏠 Auth disabled - no user required")
+        return None
+    
+    # Try to get user from session
+    try:
+        user = request.session.get("user")
+        if user:
+            logger.info(f"🔓 Found authenticated user: {user.get('username', 'unknown')}")
+            return user
+        else:
+            logger.debug("🔍 No user found in session")
+            return None
+    except Exception as e:
+        logger.error(f"Session access failed: {e}")
+        return None
+
+
+def get_current_user_required(request: Request) -> Dict[str, Any]:
+    """
+    Get current user from session, raise HTTPException if not authenticated.
+    Used for endpoints that require authentication.
+    """
+    from utils.environment import should_enable_auth
+    
+    if not should_enable_auth():
+        logger.debug("🏠 Auth disabled - returning mock user")
+        return {
+            "id": "local_dev",
+            "username": "local_user", 
+            "name": "Local Development User",
+            "auth_method": "local_dev"
+        }
+    
+    user = get_current_user_optional(request)
+    if not user:
+        logger.warning(f"🚫 Authentication required for {request.url.path}")
+        raise HTTPException(
+            status_code=401,
+            detail={
+                "error": "Authentication required",
+                "message": "Please log in with your Hugging Face account",
+                "login_url": "/auth/login"
+            }
+        )
+    
+    return user
+
+
+def require_auth_in_hf_spaces(request: Request) -> None:
+    """
+    Dependency that enforces authentication only in HF Spaces.
+    Raises 401 if in HF Spaces and user is not authenticated.
+    """
+    from utils.environment import should_enable_auth
+    
+    if should_enable_auth():
+        user = get_current_user_optional(request)
+        if not user:
+            logger.warning(f"🚫 HF Spaces requires authentication for {request.url.path}")
+            raise HTTPException(
+                status_code=401,
+                detail={
+                    "error": "Authentication required in Hugging Face Spaces",
+                    "message": "Please log in to access this service",
+                    "login_url": "/auth/login-page",
+                    "reason": "This prevents abuse of OpenAI resources"
+                }
+            )
+
+
+# Convenience aliases for common use cases
+CurrentUser = Depends(get_current_user_required)
+OptionalUser = Depends(get_current_user_optional)
+RequireHFAuth = Depends(require_auth_in_hf_spaces)

backend/dependencies/__init__.py

@@ -1,25 +0,0 @@
-"""
-Dependencies module for FastAPI dependency injection.
-"""
-
-from .auth import (
-    get_current_user_optional,
-    get_current_user_required, 
-    get_current_user_with_bearer,
-    require_auth_in_hf_spaces,
-    CurrentUser,
-    OptionalUser,
-    APIUser,
-    RequireHFAuth
-)
-
-__all__ = [
-    "get_current_user_optional",
-    "get_current_user_required",
-    "get_current_user_with_bearer", 
-    "require_auth_in_hf_spaces",
-    "CurrentUser",
-    "OptionalUser",
-    "APIUser", 
-    "RequireHFAuth"
-]

backend/dependencies/auth.py

@@ -1,128 +0,0 @@
-"""
-Authentication Dependencies for FastAPI
-
-This module provides authentication dependencies that can be used 
-with FastAPI's dependency injection system instead of middleware.
-"""
-
-import logging
-from typing import Optional, Dict, Any
-from fastapi import Request, HTTPException, Depends
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
-from utils.environment import should_enable_auth, get_oauth_config, is_huggingface_space
-
-logger = logging.getLogger(__name__)
-
-# Optional security scheme for Bearer tokens
-security = HTTPBearer(auto_error=False)
-
-
-def get_current_user_optional(request: Request) -> Optional[Dict[str, Any]]:
-    """
-    Get current user from session, but don't raise error if not found.
-    Used for endpoints where authentication is optional.
-    """
-    if not should_enable_auth():
-        logger.debug("🏠 Auth disabled - no user required")
-        return None
-    
-    # Try to get user from session
-    try:
-        user = request.session.get("user")
-        if user:
-            logger.info(f"🔓 Found authenticated user: {user.get('username', 'unknown')}")
-            return user
-        else:
-            logger.debug("🔍 No user found in session")
-            return None
-    except Exception as e:
-        logger.error(f"Session access failed: {e}")
-        return None
-
-
-def get_current_user_required(request: Request) -> Dict[str, Any]:
-    """
-    Get current user from session, raise HTTPException if not authenticated.
-    Used for endpoints that require authentication.
-    """
-    if not should_enable_auth():
-        logger.debug("🏠 Auth disabled - returning mock user")
-        return {
-            "id": "local_dev",
-            "username": "local_user", 
-            "name": "Local Development User",
-            "auth_method": "local_dev"
-        }
-    
-    user = get_current_user_optional(request)
-    if not user:
-        logger.warning(f"🚫 Authentication required for {request.url.path}")
-        raise HTTPException(
-            status_code=401,
-            detail={
-                "error": "Authentication required",
-                "message": "Please log in with your Hugging Face account",
-                "login_url": "/auth/login"
-            }
-        )
-    
-    return user
-
-
-def get_current_user_with_bearer(
-    request: Request,
-    credentials: Optional[HTTPAuthorizationCredentials] = Depends(security)
-) -> Optional[Dict[str, Any]]:
-    """
-    Get current user from session or Bearer token.
-    Used for API endpoints that might accept both session and token auth.
-    """
-    # First try session authentication
-    user = get_current_user_optional(request)
-    if user:
-        return user
-    
-    # If no session user, try Bearer token (for API access)
-    if credentials and is_huggingface_space():
-        # In a full implementation, validate this token with HF API
-        # For now, assume it's valid if present in HF environment
-        logger.info("🔑 User authenticated via Bearer token")
-        return {
-            "id": "bearer_auth",
-            "username": "api_user",
-            "name": "API User",
-            "auth_method": "bearer_token",
-            "token": credentials.credentials
-        }
-    
-    return None
-
-
-# Convenience aliases for common use cases
-CurrentUser = Depends(get_current_user_required)
-OptionalUser = Depends(get_current_user_optional)
-APIUser = Depends(get_current_user_with_bearer)
-
-
-def require_auth_in_hf_spaces(request: Request) -> None:
-    """
-    Dependency that enforces authentication only in HF Spaces.
-    Raises 401 if in HF Spaces and user is not authenticated.
-    """
-    if should_enable_auth():
-        user = get_current_user_optional(request)
-        if not user:
-            logger.warning(f"🚫 HF Spaces requires authentication for {request.url.path}")
-            raise HTTPException(
-                status_code=401,
-                detail={
-                    "error": "Authentication required in Hugging Face Spaces",
-                    "message": "Please log in to access this service",
-                    "login_url": "/auth/login-page",
-                    "reason": "This prevents abuse of OpenAI resources"
-                }
-            )
-
-
-# Dependency alias for route protection
-RequireHFAuth = Depends(require_auth_in_hf_spaces)