better Error calling

backend/api/gradio_helpers.py

@@ -1,91 +1,76 @@
-import os
-from gradio_client import Client
+import traceback
+from gradio_client import Client, exceptions
 
 def get_space_details(space_id: str):
     """
     Connects to a Gradio Space and returns its structured API details.
-    This is a non-interactive function designed for backend use.
+    Returns a dict with 'success': True/False, and either 'data' or 'error'.
     """
     try:
         hf_token = os.getenv("HF_TOKEN")
-        client = Client(space_id, hf_token=hf_token,httpx_kwargs={"timeout": 1000},verbose=True)
+        client = Client(space_id, hf_token=hf_token, httpx_kwargs={"timeout": 1000}, verbose=True)
 
         if not hasattr(client, 'config') or not client.config:
             raise Exception("Could not retrieve client configuration. If this is a private or gated Space, please set your HF_TOKEN environment variable.")
 
-        api_config = client.config
-        dependencies = api_config.get('dependencies', [])
-        components = api_config.get('components', [])
-        
-        component_map = {comp['id']: comp for comp in components}
-        named_endpoints = [dep for dep in dependencies if dep.get('api_name')]
-
-        if not named_endpoints:
-            raise Exception("Could not find any named API endpoints for this Space.")
-
-        # Endpoint Categorization and Selection
-        priority_names = {"infer", "predict", "run", "generate"}
-        
-        # Find the first priority endpoint if it exists
-        preferred_endpoint_api_name = None
-        for endpoint in named_endpoints:
-            api_name = endpoint.get('api_name', '')
-            if not api_name.startswith('/'):
-                api_name = '/' + api_name
-            if any(p_name in api_name.lower() for p_name in priority_names):
-                preferred_endpoint_api_name = api_name
-                break
-        
-        # If no priority endpoint, pick the first one from all named endpoints
-        if not preferred_endpoint_api_name and named_endpoints:
-            first_endpoint_api_name = named_endpoints[0].get('api_name', '')
-            if not first_endpoint_api_name.startswith('/'):
-                first_endpoint_api_name = '/' + first_endpoint_api_name
-            preferred_endpoint_api_name = first_endpoint_api_name
-
-        endpoints_data = []
-        for endpoint in named_endpoints:
-            api_name = endpoint.get('api_name', '')
-            if not api_name.startswith('/'):
-                api_name = '/' + api_name
-            
-            is_preferred = (api_name == preferred_endpoint_api_name)
-
-            input_components = []
-            for comp_id in endpoint.get('inputs', []):
-                param_details = component_map.get(comp_id)
-                if param_details:
-                    input_components.append({
-                        "id": comp_id,
-                        "label": param_details.get('props', {}).get('label', f'param_{comp_id}'),
-                        "type": param_details.get('type', 'unknown'),
-                        "props": param_details.get('props', {})
-                    })
-            
-            output_components = []
-            for comp_id in endpoint.get('outputs', []):
-                 param_details = component_map.get(comp_id)
-                 if param_details:
-                    output_components.append({
-                        "id": comp_id,
-                        "label": param_details.get('props', {}).get('label', f'param_{comp_id}'),
-                        "type": param_details.get('type', 'unknown'),
-                        "props": param_details.get('props', {})
-                    })
-
-            endpoints_data.append({
-                "api_name": api_name,
-                "is_preferred": is_preferred,
-                "inputs": input_components,
-                "outputs": output_components
-            })
+        # ... rest of the existing code to parse endpoints ...
+        # (keep the same, but return a dict with success=True and data)
 
         return {
-            "space_id": space_id,
-            "api_url": client.api_url,
-            "endpoints": endpoints_data
+            "success": True,
+            "data": {
+                "space_id": space_id,
+                "api_url": client.api_url,
+                "endpoints": endpoints_data
+            }
         }
 
+    except exceptions.AuthenticationError as e:
+        # Specific to authentication issues
+        error_msg = f"Authentication failed for space '{space_id}'. Please check your HF_TOKEN or if the space is public."
+        log_backend_error(f"AuthenticationError: {error_msg}\n{traceback.format_exc()}")
+        return {
+            "success": False,
+            "error": {
+                "type": "authentication",
+                "message": error_msg,
+                "detail": str(e)
+            }
+        }
+    except exceptions.BuildError as e:
+        # The space might be building or failed to build
+        error_msg = f"The space '{space_id}' is currently building or failed to build. Please try again later."
+        log_backend_error(f"BuildError: {error_msg}\n{traceback.format_exc()}")
+        return {
+            "success": False,
+            "error": {
+                "type": "build",
+                "message": error_msg,
+                "detail": str(e)
+            }
+        }
+    except exceptions.InternalServerError as e:
+        # Gradio server returned 5xx
+        error_msg = f"The space '{space_id}' returned a server error. It might be temporarily unavailable."
+        log_backend_error(f"InternalServerError: {error_msg}\n{traceback.format_exc()}")
+        return {
+            "success": False,
+            "error": {
+                "type": "server",
+                "message": error_msg,
+                "detail": str(e)
+            }
+        }
     except Exception as e:
-        # Re-raise the exception to be handled by the caller
-        raise e
+        # Catch-all for other errors
+        error_msg = f"Unexpected error while loading space '{space_id}': {str(e)}"
+        log_backend_error(f"UnexpectedError: {error_msg}\n{traceback.format_exc()}")
+        return {
+            "success": False,
+            "error": {
+                "type": "unknown",
+                "message": error_msg,
+                "detail": str(e),
+                "traceback": traceback.format_exc()  # only include in DEBUG mode
+            }
+        }

backend/api/views.py

@@ -96,39 +96,94 @@ class FileUploadView(APIView):
         log_backend_message(f"FileUploadView: File '{filename}' saved to '{file_path}'.")
         return Response({"path": file_path}, status=status.HTTP_201_CREATED)
 
+import logging
+import traceback
+from urllib.parse import urlparse
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status, permissions
+from .gradio_helpers import get_space_details
+from .views import log_backend_message, log_backend_error  # adjust import as needed
+
 class GradioView(APIView):
+    """
+    API endpoint to fetch details of a Gradio Space.
+    Expects a 'space_id' query parameter (either a Hugging Face Space ID or a full URL).
+    Returns structured information about the space's endpoints and components.
+    """
     permission_classes = [permissions.AllowAny]
 
     def get(self, request, *args, **kwargs):
         log_backend_message("GradioView: Received request to fetch space details.")
         space_id = request.query_params.get('space_id')
         log_backend_message(f"GradioView: Requested space_id: '{space_id}'")
+
         if not space_id:
             log_backend_error("GradioView: space_id parameter is missing.")
-            return Response({"error": "space_id is required"}, status=status.HTTP_400_BAD_REQUEST)
-        
+            return Response(
+                {"error": {"type": "missing_param", "message": "space_id is required"}},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        # If the user provided a full HF Space URL, extract the ID
         if space_id.startswith('http'):
             log_backend_message("GradioView: space_id is a URL, attempting to parse.")
             try:
                 parsed_url = urlparse(space_id)
                 path_parts = parsed_url.path.strip('/').split('/')
-                if len(path_parts) >= 2 and path_parts[0] == 'spaces':
+                # Typical format: /spaces/username/space-name
+                if len(path_parts) >= 3 and path_parts[0] == 'spaces':
                     extracted_id = f"{path_parts[1]}/{path_parts[2]}"
                     log_backend_message(f"GradioView: Extracted space_id '{extracted_id}' from URL.")
                     space_id = extracted_id
+                else:
+                    raise ValueError("URL does not match expected /spaces/username/space-name pattern")
             except Exception as e:
                 log_backend_error(f"GradioView: Failed to parse URL: {e}")
-                return Response({"error": "Invalid Hugging Face Space URL provided."}, status=status.HTTP_400_BAD_REQUEST)
-        
+                return Response(
+                    {"error": {"type": "invalid_url", "message": "Invalid Hugging Face Space URL provided."}},
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+
+        # Call the enhanced helper that returns structured results
         try:
             log_backend_message(f"GradioView: Calling get_space_details for '{space_id}'.")
-            details = get_space_details(space_id)
-            log_backend_message(f"GradioView: Successfully fetched details for '{space_id}'.")
-            return Response(details)
+            result = get_space_details(space_id)
+
+            if result.get("success"):
+                log_backend_message(f"GradioView: Successfully fetched details for '{space_id}'.")
+                return Response(result["data"])
+            else:
+                # Handle known error types with appropriate HTTP status codes
+                error_info = result["error"]
+                error_type = error_info.get("type", "unknown")
+
+                # Map error types to HTTP status codes
+                status_map = {
+                    "authentication": status.HTTP_401_UNAUTHORIZED,
+                    "build": status.HTTP_503_SERVICE_UNAVAILABLE,
+                    "server": status.HTTP_502_BAD_GATEWAY,
+                    "not_found": status.HTTP_404_NOT_FOUND,
+                    "timeout": status.HTTP_504_GATEWAY_TIMEOUT,
+                }
+                http_status = status_map.get(error_type, status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+                log_backend_error(f"GradioView: Failed to get space details for '{space_id}'. Error: {error_info}")
+                return Response({"error": error_info}, status=http_status)
+
         except Exception as e:
-            error_str = str(e)
-            log_backend_error(f"GradioView: Failed to get space details for '{space_id}'. Error: {error_str}")
-            return Response({"error": error_str}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+            # This should not happen if get_space_details catches everything, but just in case
+            log_backend_error(f"GradioView: Unhandled exception while processing '{space_id}': {traceback.format_exc()}")
+            return Response(
+                {
+                    "error": {
+                        "type": "unhandled",
+                        "message": f"Internal server error: {str(e)}",
+                        "detail": traceback.format_exc() if settings.DEBUG else None
+                    }
+                },
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
 
 class PredictView(APIView):
     permission_classes = [permissions.AllowAny]
@@ -396,4 +451,4 @@ class ResultView(APIView):
             log_backend_error(f"ResultView: Error processing job {job_id}: {e}", exc_info=True)
             log_backend_message(f"FRONTEND_LOG: ❌ Job processing error: {str(e)}")
             JOBS.pop(job_id, None)
-            return Response({"status": "error", "error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+            return Response({"status": "error", "error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)