Solve that OutputNode part

backend/.gitignore

@@ -1,39 +1,5 @@
-# Python
-__pycache__/
-*.pyc
-*.pyo
-*.pyd
-*build/
-*develop-eggs/
-*dist/
-*downloads/
-*eggs/
-*.egg-info/
-*lib/
-*lib64/
-*parts/
-*sdist/
-*var/
-*wheels/
-*share/python-wheels/
-*.egg-info/
-*pip-wheel-metadata/
-*share/jupyter/
-*profile_default/
-*ipython_config.py
 
-# Virtualenv
-venv/
-env/
-ENV/
-.venv/
-.env/
-
-# Database
-db.sqlite3
-*.sqlite3
-
-# Django
-*.log
-local_settings.py
-.DS_Store
+# User-generated files
+/media/
+/uploads/
+/gradio_output/

backend/api/middleware.py

@@ -0,0 +1,19 @@
+from django.contrib.auth.models import User
+from django.contrib.auth import login
+
+class AutoUserCreationMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        if not request.user.is_authenticated:
+            # Create a new user with a unique username
+            username = f"user_{User.objects.count() + 1}"
+            user = User.objects.create_user(username=username)
+            user.save()
+            
+            # Log the user in to establish a session
+            login(request, user)
+            
+        response = self.get_response(request)
+        return response

backend/api/urls.py

@@ -1,9 +1,10 @@
 from django.urls import path
-from .views import GradioView, PredictView, ResultView, FileUploadView
+from .views import GradioView, PredictView, ResultView, FileUploadView, BackendLogView
 
 urlpatterns = [
     path('space/', GradioView.as_view(), name='get_space_details'),
     path('predict/', PredictView.as_view(), name='predict_endpoint'),
     path('result/<str:job_id>/', ResultView.as_view(), name='get_result'),
     path('upload/', FileUploadView.as_view(), name='file_upload'),
+    path('logs/', BackendLogView.as_view(), name='get_backend_logs'),
 ]

backend/api/views.py

@@ -2,135 +2,244 @@ import logging
 import uuid
 import os
 import shutil
+import pathlib
 from urllib.parse import urlparse
 from django.conf import settings
 from django.core.files.storage import FileSystemStorage
 from rest_framework.views import APIView
 from rest_framework.response import Response
-from rest_framework import status
+from rest_framework import status, permissions
 from .gradio_helpers import get_space_details
 from gradio_client import Client, exceptions
 
+# In-memory log storage for debugging
+BACKEND_LOGS = []
+
+def log_backend_message(message):
+    """Adds a message to the in-memory log store."""
+    logging.info(message)
+    BACKEND_LOGS.append(f"INFO: {message}")
+
+def log_backend_error(message, exc_info=False):
+    """Adds an error to the in-memory log store."""
+    logging.error(message, exc_info=exc_info)
+    BACKEND_LOGS.append(f"ERROR: {message}")
+
+
+class BackendLogView(APIView):
+    """An endpoint to fetch and clear backend logs for debugging."""
+    permission_classes = [permissions.IsAuthenticated]
+
+    def get(self, request, *args, **kwargs):
+        logs = BACKEND_LOGS.copy()
+        BACKEND_LOGS.clear()
+        return Response({"logs": logs})
+
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 JOBS = {}
 CLIENT_CACHE = {}
 
 class FileUploadView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
     def post(self, request, *args, **kwargs):
+        log_backend_message("FileUploadView: Received file upload request.")
         file_obj = request.FILES.get('file')
         if not file_obj:
+            log_backend_error("FileUploadView: No file provided in the request.")
             return Response({"error": "File not provided"}, status=status.HTTP_400_BAD_REQUEST)
-        fs = FileSystemStorage()
+
+        user_id = str(request.user.id)
+        log_backend_message(f"FileUploadView: Upload initiated by user_id: {user_id}")
+        upload_dir = os.path.join(settings.BASE_DIR, 'uploads', user_id)
+        os.makedirs(upload_dir, exist_ok=True)
+        
+        fs = FileSystemStorage(location=upload_dir)
         filename = fs.save(file_obj.name, file_obj)
         file_path = fs.path(filename)
+        
+        log_backend_message(f"FileUploadView: File '{filename}' saved to '{file_path}'.")
         return Response({"path": file_path}, status=status.HTTP_201_CREATED)
 
 class GradioView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
     def get(self, request, *args, **kwargs):
+        log_backend_message("GradioView: Received request to fetch space details.")
         space_id = request.query_params.get('space_id')
-        logging.info(f"Received request for space_id: {space_id}")
+        log_backend_message(f"GradioView: Requested space_id: '{space_id}'")
         if not space_id:
-            logging.warning("space_id parameter is missing")
+            log_backend_error("GradioView: space_id parameter is missing.")
             return Response({"error": "space_id is required"}, status=status.HTTP_400_BAD_REQUEST)
+        
         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':
                     extracted_id = f"{path_parts[1]}/{path_parts[2]}"
-                    logging.info(f"Extracted space_id '{extracted_id}' from URL '{space_id}'")
+                    log_backend_message(f"GradioView: Extracted space_id '{extracted_id}' from URL.")
                     space_id = extracted_id
             except Exception as e:
-                logging.error(f"Failed to parse space_id from URL '{space_id}': {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)
+        
         try:
-            logging.info(f"Fetching details for space: {space_id}")
+            log_backend_message(f"GradioView: Calling get_space_details for '{space_id}'.")
             details = get_space_details(space_id)
-            logging.info(f"Successfully fetched details for space: {space_id}")
+            log_backend_message(f"GradioView: Successfully fetched details for '{space_id}'.")
             return Response(details)
         except Exception as e:
             error_str = str(e)
-            logging.error(f"An error occurred while processing space '{space_id}': {error_str}", exc_info=True)
-            if "argument of type 'bool' is not iterable" in error_str or "Could not fetch config" in error_str:
-                error_message = "The remote Hugging Face space is either invalid or has an incompatible API configuration. Please try a different space."
-                logging.warning(f"Incompatible API for space '{space_id}': {error_message}")
-                return Response({"error": error_message}, status=status.HTTP_502_BAD_GATEWAY)
+            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)
 
 class PredictView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
     def post(self, request, *args, **kwargs):
+        BACKEND_LOGS.clear() # Clear logs for new run
+        log_backend_message("PredictView: Received new prediction request.")
         space_id = request.data.get('space_id')
         api_name = request.data.get('api_name')
         inputs = request.data.get('inputs', [])
-        logging.info(f"Received prediction request for space_id: {space_id}, api_name: {api_name}")
-        logging.info(f"Inputs received: {inputs}")
+        log_backend_message(f"PredictView: Space: {space_id}, API: {api_name}, Inputs: {inputs}")
+
         if not all([space_id, api_name]):
-            logging.warning("Missing space_id or api_name in prediction request")
+            log_backend_error("PredictView: Missing space_id or api_name.")
             return Response({"error": "space_id and api_name are required"}, status=status.HTTP_400_BAD_REQUEST)
+        
         try:
             if space_id in CLIENT_CACHE:
-                logging.info(f"Reusing existing Gradio client for space: {space_id}")
+                log_backend_message(f"PredictView: Reusing existing Gradio client for space: {space_id}")
                 client = CLIENT_CACHE[space_id]
             else:
-                logging.info(f"Initializing new Gradio client for space: {space_id}")
+                log_backend_message(f"PredictView: Initializing new Gradio client for space: {space_id}")
                 client = Client(space_id)
                 CLIENT_CACHE[space_id] = client
-                logging.info(f"New client for {space_id} cached.")
+                log_backend_message(f"PredictView: New client for {space_id} cached.")
+            
+            log_backend_message("PredictView: Submitting job to Gradio client...")
             job = client.submit(*inputs, api_name=api_name)
             job_id = str(uuid.uuid4())
-            JOBS[job_id] = job
-            logging.info(f"Job submitted with ID: {job_id} for space: {space_id}")
+            JOBS[job_id] = {'job': job, 'user': request.user}
+            log_backend_message(f"PredictView: Job submitted with temporary ID: {job_id}")
             return Response({"job_id": job_id}, status=status.HTTP_202_ACCEPTED)
         except Exception as e:
-            logging.error(f"Prediction failed for space '{space_id}' with api_name '{api_name}': {str(e)}", exc_info=True)
+            log_backend_error(f"PredictView: Prediction failed for space '{space_id}': {str(e)}", exc_info=True)
             return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 
 class ResultView(APIView):
+    permission_classes = [permissions.IsAuthenticated]
+
     def _process_result(self, result, request):
-        if isinstance(result, list):
+        log_backend_message(f"ResultView._process_result: Processing item. Type: {type(result)}. Value: {result}")
+        
+        # Recursively process lists and tuples
+        if isinstance(result, list) or isinstance(result, tuple):
+            log_backend_message(f"ResultView._process_result: Item is a {type(result).__name__}, processing each element recursively.")
             return [self._process_result(item, request) for item in result]
-        if isinstance(result, str) and os.path.exists(result):
+
+        if isinstance(result, str):
+            # EAFP (Easier to Ask for Forgiveness than Permission) approach
             try:
-                unique_filename = str(uuid.uuid4()) + os.path.splitext(result)[1]
-                os.makedirs(settings.MEDIA_ROOT, exist_ok=True)
-                shutil.copy(result, os.path.join(settings.MEDIA_ROOT, unique_filename))
-                url = request.build_absolute_uri(os.path.join(settings.MEDIA_URL, unique_filename))
-                logging.info(f"Converted file path '{result}' to public URL '{url}'")
+                # Attempt to treat the string as a file path
+                log_backend_message(f"ResultView._process_result: Item is a string. Attempting to copy '{result}' as a file.")
+                
+                # An extra check to avoid trying to copy things that are clearly not paths
+                if not os.path.sep in result:
+                    log_backend_message(f"ResultView._process_result: '{result}' does not contain a path separator. Assuming it's a regular string.")
+                    return result
+
+                user_id = str(request.user.id)
+                user_media_dir = os.path.join(settings.MEDIA_ROOT, user_id)
+                
+                if not os.path.exists(user_media_dir):
+                    os.makedirs(user_media_dir)
+                    log_backend_message(f"ResultView._process_result: Created user media directory: {user_media_dir}")
+
+                # Create a unique filename to avoid conflicts
+                original_filename = os.path.basename(result)
+                unique_filename = str(uuid.uuid4()) + os.path.splitext(original_filename)[1]
+                destination_path = os.path.join(user_media_dir, unique_filename)
+                
+                log_backend_message(f"ResultView._process_result: Destination path for copy: {destination_path}")
+                
+                shutil.copy(result, destination_path)
+                log_backend_message("ResultView._process_result: File copied successfully.")
+                
+                # Construct the public URL
+                file_url_path = f"{settings.MEDIA_URL}{user_id}/{unique_filename}"
+                url = request.build_absolute_uri(file_url_path)
+                
+                log_backend_message(f"ResultView._process_result: Successfully converted file path to public URL: '{url}'")
                 return url
+            except (FileNotFoundError, IsADirectoryError, OSError) as e:
+                # This will trigger if `result` is not a valid file path
+                log_backend_message(f"ResultView._process_result: Could not treat '{result}' as a file. It's likely a regular string. Error: {e}")
+                return result
             except Exception as e:
-                logging.error(f"Failed to process file result '{result}': {e}")
+                # Catch any other unexpected errors during the copy
+                log_backend_error(f"ResultView._process_result: An unexpected error occurred while processing '{result}'. Error: {e}", exc_info=True)
                 return result
+        
+        log_backend_message(f"ResultView._process_result: Item is not a string, list, or tuple ({type(result).__name__}), returning as is.")
         return result
 
     def get(self, request, job_id, *args, **kwargs):
-        logging.info(f"Received result request for job_id: {job_id}")
-        job = JOBS.get(job_id)
-        if job is None:
-            logging.warning(f"Job with ID {job_id} not found.")
+        log_backend_message(f"ResultView: Received result request for job_id: {job_id}")
+        job_info = JOBS.get(job_id)
+        if job_info is None:
+            log_backend_error(f"ResultView: Job with ID {job_id} not found.")
             return Response({"error": "Job not found"}, status=status.HTTP_404_NOT_FOUND)
+        
+        if job_info['user'] != request.user:
+            log_backend_error(f"ResultView: User {request.user} attempted to access job {job_id} owned by {job_info['user']}")
+            return Response({"error": "Forbidden"}, status=status.HTTP_403_FORBIDDEN)
+
+        job = job_info['job']
         try:
-            if not job.done():
-                status_name = job.status().code.name.lower()
-                logging.debug(f"Job {job_id} still processing (state={status_name}).")
-                return Response({"status": "processing", "detail": status_name}, status=status.HTTP_200_OK)
-            raw_result = job.result()
-            logging.info(f"Job {job_id} completed with raw result: {raw_result}")
-            final_result = self._process_result(raw_result, request)
-            JOBS.pop(job_id, None)
-            return Response({"status": "completed", "result": final_result}, status=status.HTTP_200_OK)
-        except exceptions.AppError as e:
-            logging.error(f"Gradio AppError processing job {job_id}: {e}", exc_info=True)
-            JOBS.pop(job_id, None)
-            return Response({"status": "error", "error": f"The remote Gradio app encountered a runtime error: {e}"}, status=status.HTTP_502_BAD_GATEWAY)
+            status_name = job.status().code.name.lower()
+            log_backend_message(f"ResultView: Job {job_id} status is '{status_name}'.")
+            
+            if status_name == "finished":
+                log_backend_message(f"ResultView: Job {job_id} is finished. Processing final result.")
+                raw_results = job.result()
+                log_backend_message(f"ResultView: Job {job_id} completed with raw result: {raw_results}")
+
+                if not isinstance(raw_results, list):
+                    raw_results = [raw_results]
+
+                final_result = self._process_result(raw_results, request)
+                
+                JOBS.pop(job_id, None)
+                
+                # Capture the logs from this final processing step
+                final_logs = BACKEND_LOGS.copy()
+                BACKEND_LOGS.clear()
+
+                log_backend_message(f"ResultView: Final processed result for job {job_id}: {final_result}")
+                return Response({
+                    "status": "completed", 
+                    "result": final_result,
+                    "logs": final_logs  # Include final logs in the response
+                }, status=status.HTTP_200_OK)
+
+            elif status_name in ["cancelled", "failed"]:
+                log_backend_message(f"ResultView: Job {job_id} ended with terminal status: {status_name}")
+                JOBS.pop(job_id, None)
+                return Response({"status": status_name, "error": f"Job ended with status: {status_name}"}, status=status.HTTP_200_OK)
+
+            else: # The job is still running
+                log_backend_message(f"ResultView: Job {job_id} still processing.")
+                # For polling requests, return the current logs
+                logs = BACKEND_LOGS.copy()
+                BACKEND_LOGS.clear()
+                return Response({"status": "processing", "detail": status_name, "logs": logs}, status=status.HTTP_200_OK)
+
         except Exception as e:
-            logging.error(f"Error processing job {job_id}: {e}", exc_info=True)
+            log_backend_error(f"ResultView: Error processing job {job_id}: {e}", exc_info=True)
             JOBS.pop(job_id, None)
-            try:
-                status_name = job.status().code.name.lower()
-                if status_name in ("cancelled", "canceled"):
-                    logging.info(f"Job {job_id} was cancelled.")
-                    return Response({"status": "cancelled"}, status=status.HTTP_200_OK)
-            except Exception:
-                pass
-            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)

backend/core/settings.py

@@ -27,6 +27,10 @@ DEBUG = True
 
 ALLOWED_HOSTS = []
 
+CSRF_TRUSTED_ORIGINS = [
+    'http://localhost:3000',
+]
+
 
 # Application definition
 
@@ -42,6 +46,22 @@ INSTALLED_APPS = [
     'api',
 ]
 
+
+
+REST_FRAMEWORK = {
+    'DEFAULT_AUTHENTICATION_CLASSES': [
+        'rest_framework.authentication.SessionAuthentication',
+    ],
+    'DEFAULT_PERMISSION_CLASSES': [
+        'rest_framework.permissions.IsAuthenticated',
+    ],
+}
+
+CORS_ALLOW_CREDENTIALS = True
+
+
+
+
 MIDDLEWARE = [
     'django.middleware.security.SecurityMiddleware',
     'django.contrib.sessions.middleware.SessionMiddleware',
@@ -51,6 +71,7 @@ MIDDLEWARE = [
     'django.contrib.auth.middleware.AuthenticationMiddleware',
     'django.contrib.messages.middleware.MessageMiddleware',
     'django.middleware.clickjacking.XFrameOptionsMiddleware',
+    'api.middleware.AutoUserCreationMiddleware',
 ]
 
 ROOT_URLCONF = 'core.urls'

backend/db.sqlite3

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:32260ae775b444b3d50b69232c5544b48d362ac31e6b59904740207cda0b5438
-size 139264
+oid sha256:61db9a29d3062089c1aac27a27f5040eb8280ded478267a97a0fbda34ba2b803
+size 258048

frontend/src/App.js

@@ -1,5 +1,5 @@
 import React, { useState, useCallback, useMemo, useContext, createContext } from 'react';
-import axios from 'axios';
+import api from './api'; // Import the centralized api
 import ReactFlow, {
   MiniMap,
   Controls,
@@ -124,7 +124,7 @@ function App() {
     setNodes(nds => nds.map(n => n.id === nodeIdToReplace ? { ...n, data: { ...n.data, error: null } } : n));
 
     try {
-      const response = await axios.get(`http://localhost:8000/api/space/?space_id=${spaceId}`);
+      const response = await api.get(`/space/?space_id=${spaceId}`);
       const { endpoints } = response.data;
       const priorityEndpoint = endpoints.find(e => e.category === 'priority') || endpoints[0];
       
@@ -159,19 +159,30 @@ function App() {
     const node = nodesMap.get(nodeId);
     addLog(`[${node.data.label}] Polling for result (Job ID: ${jobId})...`);
 
+    const processLogs = (logs) => {
+      if (logs && logs.length > 0) {
+        logs.forEach(logMsg => {
+          addLog(`[BACKEND] ${logMsg}`, 'INFO');
+        });
+      }
+    };
+
     const poll = async () => {
       try {
-        const response = await axios.get(`http://localhost:8000/api/result/${jobId}`);
+        const response = await api.get(`/result/${jobId}`);
         
+        // Always process logs, whether the job is running or complete
+        processLogs(response.data.logs);
+
         if (response.data.status === 'processing') {
-          setTimeout(poll, 2000);
+          setTimeout(poll, 2000); // Continue polling
         } else if (response.data.status === 'completed') {
           addLog(`[${node.data.label}] Job completed successfully.`, 'SUCCESS');
           executionResults.set(nodeId, response.data.result);
           setNodes(nds => nds.map(n => n.id === nodeId ? { ...n, data: { ...n.data, status: 'success', result: response.data.result } } : n));
           await processNextNodes(nodeId, executionResults, nodesMap);
-        } else if (response.data.status === 'error') {
-          throw new Error(response.data.error);
+        } else if (response.data.status === 'error' || response.data.status === 'failed' || response.data.status === 'cancelled') {
+           throw new Error(response.data.error || `Job ended with status: ${response.data.status}`);
         }
       } catch (e) {
         addLog(`[${node.data.label}] Polling failed: ${e.message}`, 'ERROR');
@@ -234,7 +245,7 @@ function App() {
         }).filter(input => input !== null);
 
         addLog(`[${node.data.label}] Sending request to /api/predict/ with inputs: ${JSON.stringify(apiInputs)}`);
-        const response = await axios.post('http://localhost:8000/api/predict/', {
+        const response = await api.post('/predict/', {
           space_id: node.data.label,
           api_name: node.data.apiName,
           inputs: apiInputs,

frontend/src/CustomNode.js

@@ -1,6 +1,6 @@
 import React, { useState } from 'react';
 import { Handle, Position } from 'reactflow';
-import axios from 'axios';
+import api from './api'; // Import the centralized api
 import './CustomNode.css';
 
 // A dedicated component for the slider to manage its own state
@@ -39,7 +39,7 @@ const InputRow = ({ node_id, input, isConnected, isConnectable }) => {
     setUploadStatus('uploading');
 
     try {
-      const response = await axios.post('http://localhost:8000/api/upload/', formData, {
+      const response = await api.post('/upload/', formData, {
         headers: {
           'Content-Type': 'multipart/form-data',
         },

frontend/src/api.js

@@ -0,0 +1,39 @@
+import axios from 'axios';
+
+// Function to get the CSRF token from the cookie
+function getCookie(name) {
+  let cookieValue = null;
+  if (document.cookie && document.cookie !== '') {
+    const cookies = document.cookie.split(';');
+    for (let i = 0; i < cookies.length; i++) {
+      const cookie = cookies[i].trim();
+      // Does this cookie string begin with the name we want?
+      if (cookie.substring(0, name.length + 1) === (name + '=')) {
+        cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
+        break;
+      }
+    }
+  }
+  return cookieValue;
+}
+
+const api = axios.create({
+  baseURL: 'http://localhost:8000/api', // Your Django API base URL
+  withCredentials: true, // This is crucial for sending session cookies
+});
+
+// Add a request interceptor to include the CSRF token
+api.interceptors.request.use(
+  (config) => {
+    const token = getCookie('csrftoken');
+    if (token) {
+      config.headers['X-CSRFToken'] = token;
+    }
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
+  }
+);
+
+export default api;