Update src/streamlit_app.py

src/streamlit_app.py

@@ -10,6 +10,9 @@ import json
 import logging
 from typing import Optional, Dict, Any
 import uuid
+from huggingface_hub.utils import HfHubHTTPError
+import httpx
+
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -38,23 +41,11 @@ WORD_LIMIT = 180
 
 class ConfigManager:
     def __init__(self):
-        self.hf_token = os.environ.get("HF_TOKEN") or "mock-hf-token"
-        self.google_creds_json = os.environ.get("GOOGLE_SHEETS_CREDENTIALS")
-        self.google_sheets_id = os.environ.get("GOOGLE_SHEETS_ID") or "mock-sheet-id"
+        self.hf_token = os.getenv("HF_TOKEN")
+        self.google_creds_json = os.getenv("GOOGLE_SHEETS_CREDENTIALS")
+        self.google_sheets_id = os.getenv("GOOGLE_SHEETS_ID")
 
         missing_vars = []
-        if not os.environ.get("HF_TOKEN"):
-            missing_vars.append("HF_TOKEN (using mock)")
-        if not self.google_creds_json:
-            missing_vars.append("GOOGLE_SHEETS_CREDENTIALS (Google integration disabled)")
-        if not os.environ.get("GOOGLE_SHEETS_ID"):
-            missing_vars.append("GOOGLE_SHEETS_ID (using mock)")
-
-        if missing_vars:
-            st.warning(
-                f"⚠ Missing environment variables: {', '.join(missing_vars)}. "
-                "Some features may be disabled or mocked."
-            )
 
     def get_google_client(self):
         if not self.google_creds_json:
@@ -75,55 +66,52 @@ class ConfigManager:
 
 class GoogleSheetsLogger:
     """Handles Google Sheets logging functionality"""
-    
+
     def __init__(self, config: ConfigManager):
         self.config = config
-        self._sheet = None
-    
-    @st.cache_resource
-    def _init_google_sheets(_self):
-        """Initialize Google Sheets connection with caching"""
+
+    @st.cache_resource(show_spinner=False)
+    def _init_google_sheets(creds_json: str, sheet_id: str):
+        """Initialize Google Sheets connection with caching based on inputs."""
         try:
-            creds_dict = json.loads(_self.config.google_sheets_credentials)
+            if not creds_json or not sheet_id:
+                logger.info("Google Sheets disabled: missing creds_json or sheet_id.")
+                return None
+
+            creds_dict = json.loads(creds_json)
             scope = [
                 "https://www.googleapis.com/auth/spreadsheets",
                 "https://www.googleapis.com/auth/drive"
             ]
             creds = Credentials.from_service_account_info(creds_dict, scopes=scope)
             client = gspread.authorize(creds)
-            spreadsheet = client.open_by_key(_self.config.google_sheets_id)
+            spreadsheet = client.open_by_key(sheet_id)
             sheet = spreadsheet.sheet1
-            
+
             # Initialize headers if not present
             headers = sheet.row_values(1)
             if not headers:
                 sheet.append_row([
-                    "Timestamp", "Session_ID", "Button_Clicked", 
+                    "Timestamp", "Session_ID", "Button_Clicked",
                     "Question", "Subject", "Help_Click_Count", "Retry_Count"
                 ])
-            
+
             return sheet
+
         except Exception as e:
             logger.error(f"Error connecting to Google Sheets: {e}")
-            st.error(f"Error connecting to Google Sheets: {e}")
+            # Do NOT crash the UI; just return None so logging becomes a no-op
             return None
-    
-    def log_button_click(self, button_name: str, question: str, subject: str, 
-                        help_clicks: int, retry_count: int):
-        """Log button click to Google Sheets"""
+
+    def log_button_click(self, button_name, question, subject, help_clicks, retry_count):
         try:
-            sheet = self._init_google_sheets()
+            sheet = _get_sheet(self.config.google_creds_json, self.config.google_sheets_id)
             if not sheet:
-                logger.error("Sheet is None, cannot log")
+                logger.info("Google Sheets not available; skipping log.")
                 return
-            
-            # Generate session ID if not exists
             if "session_id" not in st.session_state:
                 st.session_state.session_id = str(uuid.uuid4())
-            
             timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            
-            # Log the data
             sheet.append_row([
                 timestamp,
                 st.session_state.session_id,
@@ -133,16 +121,17 @@ class GoogleSheetsLogger:
                 help_clicks,
                 retry_count
             ])
-            logger.info(f"Successfully logged button click: {button_name} for question: {question[:50]}...")
         except Exception as e:
             logger.error(f"Error logging to Google Sheets: {e}")
-            # Don't show error to user for logging failures
+
 
 class AIAssistant:
     """Handles AI model interactions"""
     
     def __init__(self, config: ConfigManager):
-        self.client = InferenceClient(token=config.hf_token)
+        self.model = MODEL
+        self.client = InferenceClient(model=self.model, token=config.hf_token, timeout=60.0)
+
         self.base_prompt = f"""
 You are an AI assistant designed to support high school students in the subject of {SUBJECT}. 
 Your role is to offer friendly, helpful, concise, in-depth guidance, just like a supportive teacher would.
@@ -171,32 +160,73 @@ Please follow these guidelines:
         }
     
     def generate_response(self, button_name: str, question: str, retry_count: int = 0) -> str:
-        """Generate AI response based on button type and question"""
         try:
-            prompt = self.base_prompt + self.prompt_templates[button_name]
+            # Build prompts
+            system_text = self.base_prompt + self.prompt_templates.get(button_name, "")
             if retry_count > 0:
-                prompt += f"\nPlease provide a different explanation. This is attempt {retry_count + 1}."
+                system_text += f"\nPlease provide a different explanation. This is attempt {retry_count + 1}."
+            user_text = f"Question:\n{question}"
 
-            # Send prompt to HuggingFace Inference API
-            full_prompt = f"{prompt}\n\nQuestion:\n{question}"
+            full_prompt = f"{system_text}\n\n{user_text}"  # still used for text_generation
 
-            response = self.client.text_generation(
-                model=MODEL,
-                prompt=full_prompt,
-                max_new_tokens=300,
-                temperature=0.7,
-                repetition_penalty=1.1,
-            )
+            try:
+                # Try classic text-generation first
+                text = self.client.text_generation(
+                    prompt=full_prompt,
+                    max_new_tokens=300,
+                    temperature=0.7,
+                    repetition_penalty=1.1,
+                    model=self.model,  # explicit even though client is bound
+                )
+            except (HfHubHTTPError, ValueError) as e:
+                # If the provider/model doesn't support text-generation, fall back to chat
+                msg = str(e)
+                unsupported = (
+                    "Task 'text-generation' not supported" in msg
+                    or "doesn't support task 'text-generation'" in msg
+                    or "Available tasks: ['conversational']" in msg
+                )
+                if unsupported:
+                    # OpenAI-style chat interface
+                    # Build messages: system + user
+                    messages = [
+                        {"role": "system", "content": system_text},
+                        {"role": "user", "content": user_text},
+                    ]
+                    chat = self.client.chat_completion(
+                        messages=messages,
+                        max_tokens=350,
+                        temperature=0.7,
+                        model=self.model,
+                    )
+                    # Robust extraction
+                    text = ""
+                    try:
+                        # chat.choices[0].message.content (OpenAI-like)
+                        choices = getattr(chat, "choices", None) or chat.get("choices", [])
+                        if choices:
+                            msg0 = choices[0].get("message") or {}
+                            text = msg0.get("content") or ""
+                        if not text:
+                            # Some providers return 'generated_text'
+                            text = getattr(chat, "generated_text", None) or chat.get("generated_text", "") or ""
+                    except Exception:
+                        text = str(chat)
+                else:
+                    raise
+            except (httpx.ReadTimeout, httpx.ConnectTimeout):
+                return "The model request timed out. Please try again."
 
-            # `response` will be a string, so just clean it
-            cleaned_response = re.sub(r"<think>.*?</think>", "", response, flags=re.DOTALL)
-            return cleaned_response.strip()
-            
+            cleaned = re.sub(r"<think>.*?</think>", "", text or "", flags=re.DOTALL)
+            return cleaned.strip() or "Sorry, I couldn't generate a response."
         except Exception as e:
-            logger.error(f"Error generating AI response: {e}")
+            logger.exception(f"Error generating AI response: {e}")
             return "Sorry, I encountered an error generating a response. Please try again."
 
 
+
+
+
 class SessionManager:
     """Manages Streamlit session state"""
     
@@ -666,6 +696,36 @@ class HelpInterface:
         st.success("🎉 Glad I could help! Feel free to ask for help anytime.")
         st.rerun()
 
+@st.cache_resource(show_spinner=False)
+def _get_sheet(_creds_json: str, _sheet_id: str):
+    try:
+        if not _creds_json or not _sheet_id:
+            logger.info("Sheets disabled: missing creds or id.")
+            return None
+
+        creds_dict = json.loads(_creds_json)
+        scope = [
+            "https://www.googleapis.com/auth/spreadsheets",
+            "https://www.googleapis.com/auth/drive",
+        ]
+        creds = Credentials.from_service_account_info(creds_dict, scopes=scope)
+        client = gspread.authorize(creds)
+        spreadsheet = client.open_by_key(_sheet_id)
+        sheet = spreadsheet.sheet1
+
+        headers = sheet.row_values(1)
+        if not headers:
+            sheet.append_row([
+                "Timestamp","Session_ID","Button_Clicked",
+                "Question","Subject","Help_Click_Count","Retry_Count"
+            ])
+        return sheet
+    except Exception as e:
+        logger.error(f"Error connecting to Google Sheets: {e}")
+        return None
+
+
+
 def main():
     """Main application entry point"""
     st.markdown("""
@@ -778,7 +838,8 @@ def main():
     </style>
     """, unsafe_allow_html=True)
 
-if __name__ == "__main__":
-    main()
 
 
+
+if __name__ == "__main__":
+    main()