Create handler.py

handler.py

@@ -0,0 +1,83 @@
+from huggingface_hub import hf_hub_download
+import joblib
+import json
+
+class EndpointHandler:
+    def __init__(self, path=""):
+        """
+        Initialize the handler, similar to your CuisineClassifier __init__
+        """
+        print("Initializing CuisineClassifier Handler...")
+        
+        components = ["cuisine_pipeline", "label_encoder"]
+        paths = {}
+
+        print("Loading files from local path...")
+        for name in components:
+            print(f"Loading {name}.joblib...")
+            try:
+                # In Inference Endpoints, files are already local in path
+                full_path = f"{path}/{name}.joblib" if path else f"{name}.joblib"
+                paths[name] = full_path
+                print(f"{name} path set to {full_path}")
+            except Exception as e:
+                print(f"Failed to set path for {name}: {e}")
+                raise
+
+        print("Loading model components with joblib...")
+        try:
+            self.model = joblib.load(paths["cuisine_pipeline"])
+            print("Model loaded.")
+            self.label_encoder = joblib.load(paths["label_encoder"])
+            print("Label encoder loaded.")
+        except Exception as e:
+            print(f"Failed to load components: {e}")
+            raise
+
+        print("Handler initialized successfully.")
+
+    def __call__(self, data):
+        """
+        Handle inference requests
+        Expected input format: 
+        {
+            "inputs": ["salt", "flour", "sugar", "eggs"]
+        }
+        OR
+        {
+            "inputs": "salt flour sugar eggs"
+        }
+        """
+        try:
+            # Extract ingredients from request
+            inputs = data.get("inputs", [])
+            
+            # Handle both list and string inputs
+            if isinstance(inputs, list):
+                ingredients_text = " ".join(inputs)
+            else:
+                ingredients_text = str(inputs)
+            
+            print(f"Processing ingredients: {ingredients_text}")
+            
+            # Use your existing classify logic
+            predicted_class = self.model.predict([ingredients_text])
+            predicted_label = self.label_encoder.inverse_transform(predicted_class)
+            
+            # Get prediction probabilities for confidence scores
+            prediction_proba = self.model.predict_proba([ingredients_text])
+            max_confidence = float(max(prediction_proba[0]))
+            
+            # Return structured response
+            return {
+                "cuisine": predicted_label[0],
+                "confidence": max_confidence,
+                "ingredients_processed": ingredients_text
+            }
+            
+        except Exception as e:
+            return {
+                "error": str(e),
+                "cuisine": None,
+                "confidence": 0.0
+            }