update progress handling | fix logo link zone | prioritize sambanova as a provider

backend/tasks/get_model_providers.py

@@ -1,5 +1,5 @@
 from huggingface_hub import model_info
-PREFERRED_PROVIDERS = ["novita","sambanova"]
+PREFERRED_PROVIDERS = ["sambanova", "novita"]
 
 def filter_providers(providers):
     return [provider for provider in providers if provider in PREFERRED_PROVIDERS]

frontend/src/components/BenchmarkEvaluation.jsx

@@ -81,6 +81,62 @@ const BenchmarkEvaluation = ({ sessionId, isDefaultDocument, onComplete }) => {
       setElapsedTime(timeElapsed);
     }, 1000);
 
+    // Gestionnaire pour détecter quand la page redevient visible
+    const handleVisibilityChange = () => {
+      if (
+        document.visibilityState === "visible" &&
+        !isDefault &&
+        !evaluationComplete
+      ) {
+        console.log("Page became visible, checking evaluation status...");
+        // Force une nouvelle requête pour récupérer l'état d'évaluation
+        const checkEvaluationStatus = async () => {
+          try {
+            const logsResponse = await fetch(
+              `${API_CONFIG.BASE_URL}/evaluation-logs/${sessionId}`
+            );
+
+            if (logsResponse.ok) {
+              const logsResult = await logsResponse.json();
+              if (logsResult.is_completed) {
+                // Mettre fin à l'évaluation si elle est terminée
+                setEvaluationComplete(true);
+
+                // Avancer à la dernière étape des messages
+                setStartingMessageIndex(STARTING_MESSAGES.length - 1);
+
+                // Nettoyer les intervalles
+                if (pollingIntervalRef.current) {
+                  clearInterval(pollingIntervalRef.current);
+                }
+                if (startingMessageIntervalRef.current) {
+                  clearInterval(startingMessageIntervalRef.current);
+                }
+              } else {
+                // Si l'évaluation est toujours en cours, mettre à jour l'étape actuelle
+                // basée sur le temps écoulé
+                const progress = Math.min(
+                  Math.floor(
+                    (Date.now() - startTimeRef.current) /
+                      MESSAGE_CHANGE_INTERVAL.DEFAULT
+                  ),
+                  STARTING_MESSAGES.length - 1
+                );
+                setStartingMessageIndex(progress);
+              }
+            }
+          } catch (error) {
+            console.error("Error checking evaluation status:", error);
+          }
+        };
+
+        checkEvaluationStatus();
+      }
+    };
+
+    // Ajouter l'écouteur pour le changement de visibilité
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+
     if (isDefault) {
       simulateEvaluation();
     } else {
@@ -98,8 +154,9 @@ const BenchmarkEvaluation = ({ sessionId, isDefaultDocument, onComplete }) => {
       if (simulationTimeoutRef.current) {
         clearTimeout(simulationTimeoutRef.current);
       }
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
     };
-  }, [isDefault]);
+  }, [isDefault, sessionId, evaluationComplete]);
 
   // Simulate the evaluation process for pre-calculated documents
   const simulateEvaluation = () => {
@@ -162,13 +219,46 @@ const BenchmarkEvaluation = ({ sessionId, isDefaultDocument, onComplete }) => {
 
             if (logsResponse.ok) {
               const logsResult = await logsResponse.json();
+
+              // Vérifier si l'évaluation est terminée
               if (logsResult.is_completed) {
                 setEvaluationComplete(true);
+
+                // Avancer à la dernière étape du message
+                setStartingMessageIndex(STARTING_MESSAGES.length - 1);
+
+                // Arrêter les intervalles
                 clearInterval(pollingIntervalRef.current);
+                if (startingMessageIntervalRef.current) {
+                  clearInterval(startingMessageIntervalRef.current);
+                }
+              } else {
+                // Si l'évaluation est toujours en cours, estimer la progression
+                // en fonction du temps écoulé
+                const elapsedSinceStart = Date.now() - startTimeRef.current;
+
+                // Estimer la progression (en supposant qu'une évaluation prend environ 80 secondes)
+                const estimatedTotalTime = 80000; // 80 secondes
+                const estimatedProgress = Math.min(
+                  elapsedSinceStart / estimatedTotalTime,
+                  1
+                );
+
+                // Calculer l'étape estimée (0 à STARTING_MESSAGES.length - 1)
+                const estimatedStepIndex = Math.min(
+                  Math.floor(estimatedProgress * STARTING_MESSAGES.length),
+                  STARTING_MESSAGES.length - 1
+                );
+
+                // Mettre à jour l'index des messages de démarrage si nécessaire
+                if (estimatedStepIndex > startingMessageIndex) {
+                  setStartingMessageIndex(estimatedStepIndex);
+                }
               }
             }
           } catch (error) {
             console.log("Error polling logs:", error);
+            // Ne pas arrêter le polling en cas d'erreurs réseau temporaires
           }
         }, 2000);
       } else {

frontend/src/components/BenchmarkGenerator.jsx

@@ -98,6 +98,67 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
       setElapsedTime(timeElapsed);
     }, 1000);
 
+    // Gestionnaire pour détecter quand la page redevient visible
+    const handleVisibilityChange = () => {
+      if (
+        document.visibilityState === "visible" &&
+        !isDefault &&
+        !generationComplete
+      ) {
+        console.log("Page became visible, checking for missed steps...");
+        // Force une nouvelle requête pour récupérer les logs
+        const checkCurrentState = async () => {
+          try {
+            // D'abord essayer de récupérer les logs de benchmark
+            const logsResponse = await fetch(
+              `${API_CONFIG.BASE_URL}/benchmark-logs/${sessionId}`
+            );
+
+            if (logsResponse.ok) {
+              const logsResult = await logsResponse.json();
+              if (logsResult.logs) {
+                setGenerationLogs(logsResult.logs);
+              }
+
+              // Si la tâche est terminée, mettre à jour l'état
+              if (logsResult.is_completed) {
+                setGenerationComplete(true);
+                if (pollingIntervalRef.current) {
+                  clearInterval(pollingIntervalRef.current);
+                }
+                if (onComplete) {
+                  onComplete({
+                    success: true,
+                    sessionId,
+                    logs: logsResult.logs,
+                  });
+                }
+              }
+            } else {
+              // Si la tâche de benchmark n'existe pas, essayer les logs de configuration
+              const configResponse = await fetch(
+                `${API_CONFIG.BASE_URL}/config-logs/${sessionId}`
+              );
+
+              if (configResponse.ok) {
+                const configResult = await configResponse.json();
+                if (configResult.logs) {
+                  setGenerationLogs(configResult.logs);
+                }
+              }
+            }
+          } catch (error) {
+            console.error("Error checking for missed steps:", error);
+          }
+        };
+
+        checkCurrentState();
+      }
+    };
+
+    // Ajouter l'écouteur pour le changement de visibilité
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+
     if (isDefault) {
       simulateGeneration();
     } else {
@@ -115,8 +176,9 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
       if (simulationIntervalRef.current) {
         clearInterval(simulationIntervalRef.current);
       }
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
     };
-  }, [isDefault]);
+  }, [isDefault, sessionId, generationComplete, onComplete]);
 
   // Simulate the benchmark generation for pre-calculated documents
   const simulateGeneration = () => {
@@ -167,10 +229,11 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
   useEffect(() => {
     if (generationLogs.length === 0) return;
 
-    // Check all logs for completed stages
-    const newCompletedSteps = [...completedSteps];
-    let newActiveStep = activeStep;
+    // Recalculer complètement les étapes complétées à chaque fois
+    // au lieu de simplement ajouter les nouvelles étapes
+    const newCompletedSteps = [];
 
+    // Identifier toutes les étapes complétées dans tous les logs
     generationLogs.forEach((log) => {
       const match = log.match(/\[SUCCESS\] Stage completed: (\w+)/);
       if (match && match[1]) {
@@ -180,20 +243,28 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
           !newCompletedSteps.includes(completedStep)
         ) {
           newCompletedSteps.push(completedStep);
-          // Set active step to the index of the next step
-          const stepIndex = BENCHMARK_STEPS.indexOf(completedStep);
-          if (stepIndex >= 0 && stepIndex + 1 > newActiveStep) {
-            newActiveStep = stepIndex + 1;
-            if (newActiveStep >= BENCHMARK_STEPS.length) {
-              newActiveStep = BENCHMARK_STEPS.length;
-            }
-          }
         }
       }
     });
 
-    // Update state if there are new completed steps
-    if (newCompletedSteps.length > completedSteps.length) {
+    // Déterminer l'étape active basée sur les étapes complétées
+    let newActiveStep = 0;
+    if (newCompletedSteps.length > 0) {
+      // Trouver l'étape la plus avancée dans les logs
+      const maxCompletedStepIndex = Math.max(
+        ...newCompletedSteps.map((step) => BENCHMARK_STEPS.indexOf(step))
+      );
+      newActiveStep = maxCompletedStepIndex + 1;
+
+      // S'assurer que l'activeStep ne dépasse pas le nombre total d'étapes
+      if (newActiveStep >= BENCHMARK_STEPS.length) {
+        newActiveStep = BENCHMARK_STEPS.length;
+      }
+    }
+
+    // Mettre à jour l'état si les étapes ont changé
+    // Comparer les tableaux avec JSON.stringify pour une comparaison profonde
+    if (JSON.stringify(newCompletedSteps) !== JSON.stringify(completedSteps)) {
       setCompletedSteps(newCompletedSteps);
       setActiveStep(newActiveStep);
     }
@@ -214,8 +285,8 @@ const BenchmarkGenerator = ({ sessionId, isDefaultDocument, onComplete }) => {
           "[SUCCESS] Configuration and ingestion completed successfully"
         )
       ) ||
-      completedSteps.includes("lighteval") ||
-      newCompletedSteps.includes("lighteval");
+      newCompletedSteps.includes("lighteval") ||
+      newActiveStep >= BENCHMARK_STEPS.length;
 
     if (isComplete) {
       setCurrentPhase("complete");

frontend/src/components/Intro.jsx

@@ -12,11 +12,18 @@ const Intro = () => {
     <Box sx={{ textAlign: "center", mb: 4 }}>
       <Box
         sx={{
+          width: "60px",
           height: "60px",
-          mb: 4,
           display: "flex",
           justifyContent: "center",
           cursor: "pointer",
+          margin: "0 auto",
+          mb: 4,
+          opacity: 0.9,
+          transition: "opacity 0.3s ease",
+          "&:hover": {
+            opacity: 1,
+          },
         }}
         onClick={handleLogoClick}
       >