Updates

handler.py

@@ -50,76 +50,38 @@ class EndpointHandler:
             fighter1_name = None
             fighter2_name = None
 
-        # try:
-            # Get prediction using FightPredictor - it will handle random selection if names are None
-        f1_prob, f2_prob, details = self.predictor.get_prediction(
-            fighter1_name, 
-            fighter2_name, 
-            verbose=True
-        )
-
-        print(f"f1_prob: {f1_prob}, f2_prob: {f2_prob}, details: {details}")
-
-        # Update fighter names if it was a random matchup
-        if random_matchup:
-            fighter1_name = details.get("fighter1_name")
-            fighter2_name = details.get("fighter2_name")
-            if not fighter1_name or not fighter2_name:
-                return {"error": "Failed to get random fighters"}
+        # Get prediction using FightPredictor
+        result = self.predictor.get_prediction(fighter1_name, fighter2_name, verbose=True)
         
-        if f1_prob is None:
+        if result is None:
             return {"error": "Prediction failed"}
-
+            
+        f1_data, f2_data, details = result
+        
         # Get fighter images
-        f1_image = get_fighter_image_url(fighter1_name)
-        f2_image = get_fighter_image_url(fighter2_name)
+        f1_image = get_fighter_image_url(f1_data['name'])
+        f2_image = get_fighter_image_url(f2_data['name'])
 
         return {
             "fighter1": {
-                "name": fighter1_name,
+                "name": f1_data['name'],
                 "image_url": f1_image,
-                "probability": f1_prob,
+                "probability": f1_data['prob'],
                 "details": {
-                    "form_score": float(details.get(f"{fighter1_name}_form_score", 0)),
-                    "total_fights": int(details.get(f"{fighter1_name}_total_fights", 0))
+                    "form_score": float(f1_data['form_score']),
+                    "total_fights": f1_data['total_fights']
                 }
             },
             "fighter2": {
-                "name": fighter2_name,
+                "name": f2_data['name'],
                 "image_url": f2_image,
-                "probability": f2_prob,
+                "probability": f2_data['prob'],
                 "details": {
-                    "form_score": float(details.get(f"{fighter2_name}_form_score", 0)),
-                    "total_fights": int(details.get(f"{fighter2_name}_total_fights", 0))
+                    "form_score": float(f2_data['form_score']),
+                    "total_fights": f2_data['total_fights']
                 }
             },
             "details": {
-                "age_difference": float(details.get("age_difference", 0))
+                "age_difference": float(details['age_difference'])
             }
         }
-        
-        # except Exception as e:
-        #     print(f"Error: {str(e)}")
-        #     return {
-        #         "fighter1": {
-        #             "name": fighter1_name,
-        #             "image_url": "/default-fighter.png",
-        #             "probability": None,
-        #             "details": {
-        #                 "form_score": 0,
-        #                 "total_fights": 0
-        #             }
-        #         },
-        #         "fighter2": {
-        #             "name": fighter2_name,
-        #             "image_url": "/default-fighter.png",
-        #             "probability": None,
-        #             "details": {
-        #                 "form_score": 0,
-        #                 "total_fights": 0
-        #             }
-        #         },
-        #         "details": {
-        #             "age_difference": 0
-        #         }
-        #     }

predictor.py

@@ -111,7 +111,7 @@ class FightPredictor:
         
         return fighter1, fighter2
     
-    def get_prediction(self, f1: str, f2: str, verbose: bool = False) -> Optional[Tuple[float, float, Dict]]:
+    def get_prediction(self, f1: str, f2: str, verbose: bool = False) -> Optional[Tuple[Dict, Dict, Dict]]:
         """
         Generate fight prediction between two fighters
         
@@ -121,32 +121,23 @@ class FightPredictor:
             verbose: Whether to return additional details
             
         Returns:
-            Tuple of (fighter1_win_probability, fighter2_win_probability, details_dict)
+            Tuple of (fighter1_dict, fighter2_dict, details_dict)
             Returns None if prediction fails
         """
-        
         try:
             # If both fighters are None, get random fighters
             if not f1 and not f2:
                 f1, f2 = self.get_random_fighters()
-                if verbose:
-                    details = {"fighter1_name": f1, "fighter2_name": f2}  # Add names to details for random matchups
             
             # Validate fighters exist
             self._validate_fighters(f1, f2)
             
             # Get fighter stats and scale input
-            vstup, details = self._get_fighter_stats(f1, f2, verbose)
-            
-            if verbose and not f1 and not f2:
-                details.update({"fighter1_name": f1, "fighter2_name": f2})  # Ensure names are in details
-            
+            vstup, raw_details = self._get_fighter_stats(f1, f2, verbose=True)
             vstup_scaled = self._scale_input(vstup)
             
-            # Reshape for prediction
+            # Make predictions
             new_data = np.reshape(vstup_scaled, (1, 200, vstup_scaled.shape[1]))
-            
-            # Make predictions both ways and average
             pred_1 = self.model.predict(new_data, verbose=0)
             
             # Get reverse prediction
@@ -155,17 +146,34 @@ class FightPredictor:
             new_data_rev = np.reshape(vstup_rev_scaled, (1, 200, vstup_rev_scaled.shape[1]))
             pred_2 = self.model.predict(new_data_rev, verbose=0)
             
-            # Calculate final probability (as decimal between 0 and 1)
+            # Calculate final probability
             f1_prob = float(((1 - pred_1) + pred_2) / 2)
             f2_prob = round(1 - f1_prob, 4)
             f1_prob = round(f1_prob, 4)
             
-            # Add probability percentages to details if verbose
-            if verbose:
-                details["fighter1_win_percentage"] = f"{f1_prob * 100:.2f}%"
-                details["fighter2_win_percentage"] = f"{f2_prob * 100:.2f}%"
+            # Structure the response data
+            fighter1_data = {
+                'name': f1,
+                'form_score': raw_details.get(f"{f1}_form_score", "0.00"),
+                'total_fights': int(raw_details.get(f"{f1}_total_fights", 0)),
+                'win_percentage': f"{f1_prob * 100:.2f}%",
+                'prob': f1_prob
+            }
+            
+            fighter2_data = {
+                'name': f2,
+                'form_score': raw_details.get(f"{f2}_form_score", "0.00"),
+                'total_fights': int(raw_details.get(f"{f2}_total_fights", 0)),
+                'win_percentage': f"{f2_prob * 100:.2f}%",
+                'prob': f2_prob
+            }
+            
+            details = {
+                'age_difference': raw_details.get("age_difference", "0.0"),
+            }
+            
+            return fighter1_data, fighter2_data, details
             
-            return f1_prob, f2_prob, details
         except Exception as e:
             print(f"Prediction failed: {e}")
             return None