open-swarm 0.1.1743070217__py3-none-any.whl → 0.1.1743364176__py3-none-any.whl

swarm/views/api_views.py

@@ -1,46 +1,55 @@
-"""
-API-specific views and viewsets for Open Swarm MCP Core.
-"""
-from rest_framework.viewsets import ModelViewSet
+import time
+import logging
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
 from rest_framework.permissions import AllowAny
-from drf_spectacular.views import SpectacularAPIView as BaseSpectacularAPIView
-from drf_spectacular.utils import extend_schema
-from swarm.utils.logger_setup import setup_logger
-from swarm.models import ChatMessage
-from swarm.serializers import ChatMessageSerializer
+# *** Import async_to_sync ***
+from asgiref.sync import async_to_sync
 
-logger = setup_logger(__name__)
+from swarm.views.utils import get_available_blueprints
 
-class HiddenSpectacularAPIView(BaseSpectacularAPIView):
-    exclude_from_schema = True
+logger = logging.getLogger(__name__)
 
-class ChatMessageViewSet(ModelViewSet):
-    """API viewset for managing chat messages."""
-    authentication_classes = []
+class ModelsListView(APIView):
+    """
+    API view to list available models (blueprints) compatible with OpenAI's /v1/models format.
+    """
     permission_classes = [AllowAny]
-    queryset = ChatMessage.objects.all()
-    serializer_class = ChatMessageSerializer
 
-    @extend_schema(summary="List all chat messages")
-    def list(self, request, *args, **kwargs):
-        return super().list(request, *args, **kwargs)
+    def get(self, request, *args, **kwargs):
+        try:
+            # *** Use async_to_sync to call the async function ***
+            available_blueprints = async_to_sync(get_available_blueprints)()
+
+            models_data = []
+            current_time = int(time.time())
+            if isinstance(available_blueprints, dict):
+                blueprint_ids = available_blueprints.keys()
+            elif isinstance(available_blueprints, list):
+                 blueprint_ids = available_blueprints
+            else:
+                 logger.error(f"Unexpected type from get_available_blueprints: {type(available_blueprints)}")
+                 blueprint_ids = []
+
+            for blueprint_id in blueprint_ids:
+                models_data.append({
+                    "id": blueprint_id,
+                    "object": "model",
+                    "created": current_time,
+                    "owned_by": "open-swarm",
+                })
+
+            response_payload = {
+                "object": "list",
+                "data": models_data,
+            }
+            return Response(response_payload, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            logger.exception("Error retrieving available models.")
+            return Response(
+                {"error": "Failed to retrieve models list."},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
 
-    @extend_schema(summary="Retrieve a chat message by its unique id")
-    def retrieve(self, request, *args, **kwargs):
-        return super().retrieve(request, *args, **kwargs)
-
-    @extend_schema(summary="Create a new chat message")
-    def create(self, request, *args, **kwargs):
-        return super().create(request, *args, **kwargs)
-
-    @extend_schema(summary="Update an existing chat message")
-    def update(self, request, *args, **kwargs):
-        return super().update(request, *args, **kwargs)
-
-    @extend_schema(summary="Partially update a chat message")
-    def partial_update(self, request, *args, **kwargs):
-        return super().partial_update(request, *args, **kwargs)
-
-    @extend_schema(summary="Delete a chat message by its unique id")
-    def destroy(self, request, *args, **kwargs):
-        return super().destroy(request, *args, **kwargs)

swarm/views/chat_views.py

@@ -1,76 +1,162 @@
-"""
-Chat-related views for Open Swarm MCP Core.
-"""
-import asyncio
 import logging
 import json
+import uuid
+import time
+import asyncio
+from typing import Dict, Any, AsyncGenerator, List, Optional
+
+from django.shortcuts import render
+from django.http import StreamingHttpResponse, JsonResponse, Http404, HttpRequest, HttpResponse, HttpResponseBase
+from django.views import View
+from django.utils.decorators import method_decorator
 from django.views.decorators.csrf import csrf_exempt
+from django.contrib.auth.decorators import login_required
+from django.conf import settings
+
+from rest_framework import status
+from rest_framework.views import APIView
 from rest_framework.response import Response
-from rest_framework.decorators import api_view, authentication_classes, permission_classes
-from rest_framework.permissions import IsAuthenticated
-from swarm.auth import EnvOrTokenAuthentication
-from swarm.utils.logger_setup import setup_logger
-from swarm.views import utils as view_utils
-from swarm.extensions.config.config_loader import config
-from swarm.settings import Settings
-
-logger = setup_logger(__name__)
-
-# Removed _run_async_in_sync helper
-
-@api_view(['POST'])
-@csrf_exempt
-@authentication_classes([EnvOrTokenAuthentication])
-@permission_classes([IsAuthenticated])
-def chat_completions(request): # Sync view
-    """Handle chat completion requests via POST."""
-    if request.method != "POST":
-        return Response({"error": "Method not allowed. Use POST."}, status=405)
-    logger.info(f"Authenticated User: {request.user}")
-
-    parse_result = view_utils.parse_chat_request(request)
-    if isinstance(parse_result, Response): return parse_result
-
-    body, model, messages, context_vars, conversation_id, tool_call_id = parse_result
-    model_type = "llm" if model in config.get('llm', {}) and config.get('llm', {}).get(model, {}).get("passthrough") else "blueprint"
-    logger.info(f"Identified model type: {model_type} for model: {model}")
-
-    if model_type == "llm":
-         return Response({"error": f"LLM passthrough for model '{model}' not implemented."}, status=501)
-
-    try:
-        blueprint_instance = view_utils.get_blueprint_instance(model, context_vars)
-        messages_extended = view_utils.load_conversation_history(conversation_id, messages, tool_call_id)
-
-        # Try running the async function using asyncio.run()
-        # This might fail in test environments with existing loops.
+from rest_framework.permissions import IsAuthenticated, AllowAny
+from rest_framework.exceptions import ValidationError, PermissionDenied, NotFound, APIException, ParseError, NotAuthenticated
+
+from asgiref.sync import sync_to_async, async_to_sync # Import async_to_sync
+
+# Assuming serializers are in the same app
+from swarm.serializers import ChatCompletionRequestSerializer
+# Assuming utils are in the same app/directory level
+from .utils import get_blueprint_instance, validate_model_access, get_available_blueprints
+
+logger = logging.getLogger(__name__)
+print_logger = logging.getLogger('print_debug')
+
+# ==============================================================================
+# API Views (DRF based)
+# ==============================================================================
+
+class HealthCheckView(APIView):
+    permission_classes = [AllowAny]
+    def get(self, request, *args, **kwargs): return Response({"status": "ok"})
+
+class ChatCompletionsView(APIView):
+    """
+    Handles chat completion requests, compatible with OpenAI API.
+    Permissions are now handled by DEFAULT_PERMISSION_CLASSES in settings.py.
+    """
+    serializer_class = ChatCompletionRequestSerializer
+
+    async def _handle_non_streaming(self, blueprint_instance, messages: List[Dict[str, str]], request_id: str, model_name: str) -> Response:
+        logger.info(f"[ReqID: {request_id}] Processing non-streaming request for model '{model_name}'.")
+        final_response_data = None; start_time = time.time()
         try:
-            logger.debug("Attempting asyncio.run(run_conversation)...")
-            response_obj, updated_context = asyncio.run(
-                view_utils.run_conversation(blueprint_instance, messages_extended, context_vars)
-            )
-            logger.debug("asyncio.run(run_conversation) completed.")
-        except RuntimeError as e:
-             # Catch potential nested loop errors specifically from asyncio.run()
-             logger.error(f"Asyncio run error: {e}", exc_info=True)
-             # Return a 500 error, as the async call couldn't be completed
-             return Response({"error": f"Server execution error: {str(e)}"}, status=500)
-
-
-        serialized = view_utils.serialize_swarm_response(response_obj, model, updated_context)
-
-        if conversation_id:
-            serialized["conversation_id"] = conversation_id
-            view_utils.store_conversation_history(conversation_id, messages_extended, response_obj)
-
-        return Response(serialized, status=200)
-
-    except FileNotFoundError as e:
-         logger.warning(f"Blueprint not found for model '{model}': {e}")
-         return Response({"error": f"Blueprint not found: {model}"}, status=404)
-    # Catch other exceptions, including the potential RuntimeError from above
-    except Exception as e:
-        logger.error(f"Error during execution for model '{model}': {e}", exc_info=True)
-        error_msg = str(e) if Settings().debug else "An internal error occurred."
-        return Response({"error": f"Error during execution: {error_msg}"}, status=500)
+            # *** FIX: Remove await here. run() returns the async generator directly ***
+            async_generator = blueprint_instance.run(messages)
+            async for chunk in async_generator:
+                if isinstance(chunk, dict) and "messages" in chunk: final_response_data = chunk["messages"]; logger.debug(f"[ReqID: {request_id}] Received final data chunk: {final_response_data}"); break
+                else: logger.warning(f"[ReqID: {request_id}] Unexpected chunk format: {chunk}")
+
+            if not final_response_data or not isinstance(final_response_data, list) or not final_response_data:
+                 logger.error(f"[ReqID: {request_id}] Blueprint '{model_name}' did not return valid final data structure. Got: {final_response_data}")
+                 raise APIException("Blueprint did not return valid data.", code=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+            if not isinstance(final_response_data[0], dict) or 'role' not in final_response_data[0]:
+                 logger.error(f"[ReqID: {request_id}] Blueprint '{model_name}' returned invalid message structure. Got: {final_response_data[0]}")
+                 raise APIException("Blueprint returned invalid message structure.", code=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+            response_payload = { "id": f"chatcmpl-{request_id}", "object": "chat.completion", "created": int(time.time()), "model": model_name, "choices": [{"index": 0, "message": final_response_data[0], "logprobs": None, "finish_reason": "stop"}], "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}, "system_fingerprint": None }
+            end_time = time.time(); logger.info(f"[ReqID: {request_id}] Non-streaming request completed in {end_time - start_time:.2f}s.")
+            return Response(response_payload, status=status.HTTP_200_OK)
+        except APIException: raise
+        except Exception as e: logger.error(f"[ReqID: {request_id}] Unexpected error during non-streaming blueprint execution: {e}", exc_info=True); raise APIException(f"Internal server error during generation: {e}", code=status.HTTP_500_INTERNAL_SERVER_ERROR) from e
+
+    async def _handle_streaming(self, blueprint_instance, messages: List[Dict[str, str]], request_id: str, model_name: str) -> StreamingHttpResponse:
+        logger.info(f"[ReqID: {request_id}] Processing streaming request for model '{model_name}'.")
+        async def event_stream():
+            start_time = time.time(); chunk_index = 0
+            try:
+                logger.debug(f"[ReqID: {request_id}] Getting async generator from blueprint run...");
+                # *** FIX: Remove await here. run() returns the async generator directly ***
+                async_generator = blueprint_instance.run(messages)
+                logger.debug(f"[ReqID: {request_id}] Got async generator. Starting iteration...")
+                async for chunk in async_generator:
+                    logger.debug(f"[ReqID: {request_id}] Received stream chunk {chunk_index}: {chunk}")
+                    if not isinstance(chunk, dict) or "messages" not in chunk or not isinstance(chunk["messages"], list) or not chunk["messages"] or not isinstance(chunk["messages"][0], dict):
+                        logger.warning(f"[ReqID: {request_id}] Skipping invalid chunk format: {chunk}"); continue
+                    delta_content = chunk["messages"][0].get("content", "");
+                    delta = {"role": "assistant"}
+                    if delta_content is not None: delta["content"] = delta_content
+
+                    response_chunk = { "id": f"chatcmpl-{request_id}", "object": "chat.completion.chunk", "created": int(time.time()), "model": model_name, "choices": [{"index": 0, "delta": delta, "logprobs": None, "finish_reason": None}] }
+                    logger.debug(f"[ReqID: {request_id}] Sending SSE chunk {chunk_index}"); yield f"data: {json.dumps(response_chunk)}\n\n"; chunk_index += 1; await asyncio.sleep(0.01)
+                logger.debug(f"[ReqID: {request_id}] Finished iterating stream. Sending [DONE]."); yield "data: [DONE]\n\n"; end_time = time.time(); logger.info(f"[ReqID: {request_id}] Streaming request completed in {end_time - start_time:.2f}s.")
+            except APIException as e:
+                 logger.error(f"[ReqID: {request_id}] API error during streaming blueprint execution: {e}", exc_info=True); error_msg = f"API error during stream: {e.detail}"; error_chunk = {"error": {"message": error_msg, "type": "api_error", "code": e.status_code}}
+                 try: yield f"data: {json.dumps(error_chunk)}\n\n"; yield "data: [DONE]\n\n"
+                 except Exception as send_err: logger.error(f"[ReqID: {request_id}] Failed to send error chunk: {send_err}")
+            except Exception as e:
+                 logger.error(f"[ReqID: {request_id}] Unexpected error during streaming blueprint execution: {e}", exc_info=True); error_msg = f"Internal server error during stream: {str(e)}"; error_chunk = {"error": {"message": error_msg, "type": "internal_error"}}
+                 try: yield f"data: {json.dumps(error_chunk)}\n\n"; yield "data: [DONE]\n\n"
+                 except Exception as send_err: logger.error(f"[ReqID: {request_id}] Failed to send error chunk: {send_err}")
+        return StreamingHttpResponse(event_stream(), content_type="text/event-stream")
+
+    @method_decorator(csrf_exempt)
+    async def dispatch(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponseBase:
+        self.args = args; self.kwargs = kwargs
+        request = self.initialize_request(request, *args, **kwargs)
+        self.request = request; self.headers = self.default_response_headers
+        try:
+            print_logger.debug(f"User before initial(): {getattr(request, 'user', 'N/A')}, Auth before initial(): {getattr(request, 'auth', 'N/A')}")
+            # Wrap sync initial() call
+            await sync_to_async(self.initial)(request, *args, **kwargs)
+            print_logger.debug(f"User after initial(): {getattr(request, 'user', 'N/A')}, Auth after initial(): {getattr(request, 'auth', 'N/A')}")
+
+            if request.method.lower() in self.http_method_names: handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
+            else: handler = self.http_method_not_allowed
+
+            if asyncio.iscoroutinefunction(handler):
+                response = await handler(request, *args, **kwargs)
+            else:
+                 response = await sync_to_async(handler)(request, *args, **kwargs)
+        except Exception as exc: response = self.handle_exception(exc)
+        self.response = self.finalize_response(request, response, *args, **kwargs)
+        return self.response
+
+    async def post(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponseBase:
+        request_id = str(uuid.uuid4()); logger.info(f"[ReqID: {request_id}] Received chat completion request.")
+        print_logger.debug(f"[ReqID: {request_id}] User at start of post: {getattr(request, 'user', 'N/A')}, Auth: {getattr(request, 'auth', 'N/A')}")
+        try:
+            request_data = request.data
+        except ParseError as e: logger.error(f"[ReqID: {request_id}] Invalid JSON body: {e.detail}"); raise e
+        except json.JSONDecodeError as e: logger.error(f"[ReqID: {request_id}] JSON Decode Error: {e}"); raise ParseError(f"Invalid JSON body: {e}")
+
+        serializer = self.serializer_class(data=request_data)
+        try:
+            print_logger.debug(f"[ReqID: {request_id}] Attempting serializer.is_valid(). Data: {request_data}")
+            # Wrap sync is_valid call
+            await sync_to_async(serializer.is_valid)(raise_exception=True)
+            print_logger.debug(f"[ReqID: {request_id}] Serializer is_valid() PASSED.")
+        except ValidationError as e: print_logger.error(f"[ReqID: {request_id}] Serializer validation FAILED: {e.detail}"); raise e
+        except Exception as e: print_logger.error(f"[ReqID: {request_id}] UNEXPECTED error during serializer validation: {e}", exc_info=True); raise APIException(f"Internal error during request validation: {e}", code=status.HTTP_500_INTERNAL_SERVER_ERROR) from e
+
+        validated_data = serializer.validated_data
+        model_name = validated_data['model']
+        messages = validated_data['messages']
+        stream = validated_data.get('stream', False)
+        blueprint_params = validated_data.get('params', None)
+
+        print_logger.debug(f"[ReqID: {request_id}] Validation passed. Checking model access for user {request.user} and model {model_name}")
+        # Wrap sync validate_model_access
+        access_granted = await sync_to_async(validate_model_access)(request.user, model_name)
+        if not access_granted:
+             logger.warning(f"[ReqID: {request_id}] User {request.user} denied access to model '{model_name}'.")
+             raise PermissionDenied(f"You do not have permission to access the model '{model_name}'.")
+
+        print_logger.debug(f"[ReqID: {request_id}] Access granted. Getting blueprint instance for {model_name}")
+        blueprint_instance = await get_blueprint_instance(model_name, params=blueprint_params)
+
+        if blueprint_instance is None:
+            logger.error(f"[ReqID: {request_id}] Blueprint '{model_name}' not found or failed to initialize after access checks.")
+            raise NotFound(f"The requested model (blueprint) '{model_name}' was not found or could not be initialized.")
+
+        if stream: return await self._handle_streaming(blueprint_instance, messages, request_id, model_name)
+        else: return await self._handle_non_streaming(blueprint_instance, messages, request_id, model_name)
 

swarm/views/core_views.py

@@ -11,108 +11,103 @@ from django.http import JsonResponse, HttpResponse
 from django.conf import settings
 from django.views.decorators.csrf import csrf_exempt
 from django.contrib.auth import authenticate, login
+from django.contrib.auth.forms import AuthenticationForm # Use standard auth form
+
 
 # Assuming blueprint discovery happens elsewhere and results are available if needed
 # from .utils import blueprints_metadata # Or however metadata is accessed
-from swarm.extensions.config.config_loader import load_server_config # Import if needed
 
-logger = logging.getLogger(__name__)
+# Use the current config loader
+from swarm.extensions.config.config_loader import load_config, find_config_file, DEFAULT_CONFIG_FILENAME
 
-# Placeholder for blueprint metadata if needed by index
-# In a real app, this might be loaded dynamically or passed via context
-try:
-    # Attempt to import the discovery function if views need dynamic data
-    from swarm.extensions.blueprint.blueprint_discovery import discover_blueprints
-    # Note: Calling discover_blueprints here might be too early or cause issues.
-    # It's often better handled in specific views that need it (like list_models)
-    # or passed via Django context processors.
-    # For now, provide an empty dict as fallback.
-    try:
-        # Use settings.BLUEPRINTS_DIR which should be configured
-        blueprints_metadata = discover_blueprints(directories=[str(settings.BLUEPRINTS_DIR)])
-    except Exception:
-        blueprints_metadata = {}
-except ImportError:
-    blueprints_metadata = {}
+logger = logging.getLogger(__name__)
 
+# --- Web UI Views (if ENABLE_WEBUI is True) ---
 
-@csrf_exempt
 def index(request):
-    """Render the main index page with blueprint options."""
-    logger.debug("Rendering index page")
-    # Get blueprint names from the potentially loaded metadata
-    blueprint_names_list = list(blueprints_metadata.keys())
+    """Render the main index page (likely the chat UI)."""
+    # This view might need context data like available models/blueprints
+    # It should only be active if ENABLE_WEBUI is true (checked in urls.py)
+    logger.debug(f"Index view called for user: {request.user}")
     context = {
-        "dark_mode": request.session.get('dark_mode', True),
-        "enable_admin": os.getenv("ENABLE_ADMIN", "false").lower() in ("true", "1", "t"),
-        "blueprints": blueprint_names_list # Pass the list of names
+        'title': settings.SWARM_TITLE or "Open Swarm",
+        'description': settings.SWARM_DESCRIPTION or "A Swarm Framework Interface",
+        # Add other context needed by the template
     }
-    return render(request, "index.html", context)
-
-DEFAULT_CONFIG = {
-    "llm": {
-        "default": {
-            "provider": "openai",
-            "model": "gpt-4o", # Example fallback model
-            "base_url": "https://api.openai.com/v1",
-            "api_key": "",
-            "temperature": 0.3
-        }
-    },
-     "blueprints": {},
-     "mcpServers": {}
-}
+    # Ensure the template exists
+    template_name = "swarm/index.html"
+    # Check if template exists? Django handles TemplateDoesNotExist.
+    return render(request, template_name, context)
+
+def custom_login(request):
+    """Handles user login."""
+    if request.method == 'POST':
+        form = AuthenticationForm(request, data=request.POST)
+        if form.is_valid():
+            username = form.cleaned_data.get('username')
+            password = form.cleaned_data.get('password')
+            user = authenticate(username=username, password=password)
+            if user is not None:
+                login(request, user)
+                logger.info(f"User '{username}' logged in successfully.")
+                return redirect('/') # Redirect to index after login
+            else:
+                logger.warning(f"Login failed for user '{username}': Invalid credentials.")
+                # Return form with error (AuthenticationForm handles this)
+        else:
+            logger.warning(f"Login form invalid: {form.errors.as_json()}")
+    else:
+        form = AuthenticationForm()
+
+    # Only render if ENABLE_WEBUI is true (checked in urls.py)
+    return render(request, 'swarm/login.html', {'form': form})
+
 
 def serve_swarm_config(request):
-    """Serve the swarm configuration file as JSON."""
+    """Serves the swarm_config.json content."""
+    # Find the config file used by the blueprint base or config loader
+    # This logic might need refinement depending on where config is reliably found
+    config_path = None
     try:
-        # Use load_server_config which handles finding the file
-        config_data = load_server_config()
-        return JsonResponse(config_data)
-    except (FileNotFoundError, ValueError, Exception) as e:
-        logger.error(f"Error serving swarm_config.json: {e}. Serving default.")
-        # Return a default config on error
-        return JsonResponse(DEFAULT_CONFIG, status=500)
+         # Use the same logic as BlueprintBase if possible, or find_config_file
+         config_path = find_config_file(filename=DEFAULT_CONFIG_FILENAME, start_dir=Path(settings.BASE_DIR).parent) # Search from project root
+         if not config_path:
+              # Fallback to location relative to settings? Unlikely to be correct.
+              config_path = Path(settings.BASE_DIR) / '..' / DEFAULT_CONFIG_FILENAME # Adjust relative path if needed
+              config_path = config_path.resolve()
+
+         if config_path and config_path.exists():
+              logger.info(f"Serving config from: {config_path}")
+              # Load config to potentially redact sensitive info before serving
+              config_data = load_config(config_path)
+              # Redact sensitive keys (e.g., api_key)
+              if 'llm' in config_data:
+                   for profile in config_data['llm']: config_data['llm'][profile].pop('api_key', None)
+              return JsonResponse(config_data)
+         else:
+              logger.error(f"Swarm config file not found at expected locations (tried: {config_path})")
+              return JsonResponse({"error": "Configuration file not found."}, status=404)
+
+    except Exception as e:
+        logger.error(f"Error serving swarm config: {e}", exc_info=True)
+        return JsonResponse({"error": "Failed to load or serve configuration."}, status=500)
+
+# --- Potentially other core API views if needed ---
+# Example: A view to list available blueprints (might duplicate CLI list command logic)
+
+@csrf_exempt # If POST is needed and no CSRF token available from UI
+def list_available_blueprints_api(request):
+     """API endpoint to list discoverable blueprints."""
+     # Re-use discovery logic if possible, or adapt from CLI
+     from swarm.extensions.blueprint.discovery import discover_blueprints # Assuming this exists
+     try:
+        bp_dir = Path(settings.BLUEPRINTS_DIR) # Assuming settings has BLUEPRINTS_DIR
+        discovered = discover_blueprints(directories=[str(bp_dir)])
+        # Format the response
+        blueprint_list = [{"name": name, "description": meta.get("description", "N/A")} for name, meta in discovered.items()]
+        return JsonResponse({"blueprints": blueprint_list})
+     except Exception as e:
+          logger.error(f"Error listing blueprints via API: {e}", exc_info=True)
+          return JsonResponse({"error": "Failed to list blueprints."}, status=500)
 
 
-@csrf_exempt
-def custom_login(request):
-    """Handle custom login at /accounts/login/, redirecting to 'next' URL on success."""
-    from django.contrib.auth.models import User # Import here to avoid potential early init issues
-    if request.method == "POST":
-        username = request.POST.get("username")
-        password = request.POST.get("password")
-        user = authenticate(request, username=username, password=password)
-        if user is not None:
-            login(request, user)
-            next_url = request.GET.get("next", getattr(settings, 'LOGIN_REDIRECT_URL', '/')) # Use setting or fallback
-            logger.info(f"User '{username}' logged in successfully. Redirecting to {next_url}")
-            return redirect(next_url)
-        else:
-            # If ENABLE_API_AUTH is false, auto-login as testuser (for dev/test convenience)
-            enable_auth = os.getenv("ENABLE_API_AUTH", "true").lower() in ("true", "1", "t") # Default to TRUE
-            if not enable_auth:
-                try:
-                    # Ensure test user exists and has a known password
-                    user, created = User.objects.get_or_create(username="testuser")
-                    if created or not user.has_usable_password():
-                         user.set_password("testpass") # Set a default password
-                         user.save()
-
-                    if user.check_password("testpass"): # Check against the known password
-                        login(request, user)
-                        next_url = request.GET.get("next", getattr(settings, 'LOGIN_REDIRECT_URL', '/'))
-                        logger.info(f"Auto-logged in as 'testuser' since ENABLE_API_AUTH is false")
-                        return redirect(next_url)
-                    else:
-                         logger.warning("Auto-login failed: 'testuser' exists but password incorrect.")
-
-                except Exception as auto_login_err:
-                    logger.error(f"Error during testuser auto-login attempt: {auto_login_err}")
-            # If authentication failed (and auto-login didn't happen or failed)
-            logger.warning(f"Login failed for user '{username}'.")
-            return render(request, "account/login.html", {"error": "Invalid credentials"})
-    # If GET request
-    return render(request, "account/login.html")
-
-# Add any other views that were originally in the main views.py if needed