Update app/sentiment.py

app/sentiment.py

@@ -1,49 +1,121 @@
 """
-Sentiment analysis module using Hugging Face Inference API to avoid local model downloads.
+Provides a robust, asynchronous SentimentAnalyzer class.
+
+This module communicates with the Hugging Face Inference API to perform sentiment
+analysis without requiring local model downloads. It's designed for use within
+an asynchronous application like FastAPI.
 """
-import os
-import hashlib
+import asyncio
 import logging
-from functools import lru_cache
+import os
+from typing import TypedDict
+
 import httpx
 
-# Environment variables (set HF_API_TOKEN in your Space's Settings)
-HF_API_TOKEN = os.getenv("HF_API_TOKEN", "")
-API_URL = "https://api-inference.huggingface.co/models/distilbert-base-uncased-finetuned-sst-2-english"
-HEADERS = {"Authorization": f"Bearer {HF_API_TOKEN}"}
+# --- Configuration & Models ---
+
+# Configure logging for this module
+logger = logging.getLogger(__name__)
+
+# Define the expected structure of a result payload for type hinting
+class SentimentResult(TypedDict):
+    id: int
+    text: str
+    result: dict[str, str | float]
+
+
+# --- Main Class: SentimentAnalyzer ---
+class SentimentAnalyzer:
+    """
+    Manages sentiment analysis requests to the Hugging Face Inference API.
 
-# In-memory cache for latest sentiment
-class SentimentCache:
-    latest_id: int = 0
-    latest_result: dict = {}
+    This class handles asynchronous API communication, manages a result queue for
+    Server-Sent Events (SSE), and encapsulates all related state and logic.
+    """
 
-    @classmethod
-    def _hash(cls, text: str) -> str:
-        return hashlib.sha256(text.encode()).hexdigest()
+    HF_API_URL = "https://api-inference.huggingface.co/models/distilbert-base-uncased-finetuned-sst-2-english"
 
-    @classmethod
-    @lru_cache(maxsize=128)
-    def _analyze(cls, text: str):
+    def __init__(self, client: httpx.AsyncClient, api_token: str | None = None):
+        """
+        Initializes the SentimentAnalyzer.
+
+        Args:
+            client: An instance of httpx.AsyncClient for making API calls.
+            api_token: The Hugging Face API token.
+        """
+        self.client = client
+        self.api_token = api_token or os.getenv("HF_API_TOKEN")
+        
+        if not self.api_token:
+            raise ValueError("Hugging Face API token is not set. Please set the HF_API_TOKEN environment variable.")
+            
+        self.headers = {"Authorization": f"Bearer {self.api_token}"}
+        
+        # A queue is the ideal structure for a producer-consumer pattern,
+        # where the API endpoint is the producer and SSE streamers are consumers.
+        self.result_queue: asyncio.Queue[SentimentResult] = asyncio.Queue()
+
+    async def compute_and_publish(self, text: str, request_id: int) -> None:
+        """
+        Performs sentiment analysis via an external API and places the result
+        into a queue for consumption by SSE streams.
+
+        Args:
+            text: The input text to analyze.
+            request_id: A unique identifier for this request.
+        """
+        analysis_result = {"label": "ERROR", "score": 0.0, "error": "Unknown failure"}
         try:
-            response = httpx.post(API_URL, headers=HEADERS, json={"inputs": text}, timeout=20)
+            response = await self.client.post(
+                self.HF_API_URL,
+                headers=self.headers,
+                json={"inputs": text, "options": {"wait_for_model": True}},
+                timeout=20.0
+            )
             response.raise_for_status()
             data = response.json()
-            # Expecting list of {label, score}
-            if isinstance(data, list) and data:
-                return data[0]
-            raise ValueError("Unexpected response format: %s" % data)
-        except Exception as e:
-            logging.error("❌ Sentiment API error: %s", e)
-            return {"label": "ERROR", "score": 0.0}
-
-    @classmethod
-    def compute(cls, text: str):
-        """Trigger sentiment inference via API and update latest result."""
-        res = cls._analyze(text)
-        cls.latest_id += 1
-        cls.latest_result = {
+
+            # Validate the expected response structure from the Inference API
+            if isinstance(data, list) and data and isinstance(data[0], list) and data[0]:
+                # The model returns a list containing a list of results
+                res = data[0][0]
+                analysis_result = {"label": res.get("label"), "score": round(res.get("score", 0.0), 4)}
+                logger.info("✅ Sentiment computed for request #%d", request_id)
+            else:
+                raise ValueError(f"Unexpected API response format: {data}")
+
+        except httpx.HTTPStatusError as e:
+            error_msg = f"API returned status {e.response.status_code}"
+            logger.error("❌ Sentiment API error for request #%d: %s", request_id, error_msg)
+            analysis_result["error"] = error_msg
+        except httpx.RequestError as e:
+            error_msg = f"Network request failed: {e}"
+            logger.error("❌ Sentiment network error for request #%d: %s", request_id, error_msg)
+            analysis_result["error"] = error_msg
+        except (ValueError, KeyError) as e:
+            error_msg = f"Failed to parse API response: {e}"
+            logger.error("❌ Sentiment parsing error for request #%d: %s", request_id, error_msg)
+            analysis_result["error"] = error_msg
+
+        # Always publish a result to the queue, even if it's an error state
+        payload: SentimentResult = {
+            "id": request_id,
             "text": text,
-            "label": res.get("label"),
-            "score": round(res.get("score", 0.0), 4)
+            "result": analysis_result
         }
-        logging.info("✅ Sentiment computed: %s", cls.latest_result)
+        await self.result_queue.put(payload)
+
+    async def stream_results(self) -> SentimentResult:
+        """
+        An async generator that yields new results as they become available.
+        This is the consumer part of the pattern.
+        """
+        while True:
+            try:
+                # This efficiently waits until an item is available in the queue
+                result = await self.result_queue.get()
+                yield result
+                self.result_queue.task_done()
+            except asyncio.CancelledError:
+                logger.info("Result stream has been cancelled.")
+                break