Update app.py

app.py

@@ -12,8 +12,7 @@ import gspread
 from google.auth import default
 from tqdm import tqdm
 from duckduckgo_search import DDGS
-import spacy
-from pathlib import Path
+# Removed spacy and pathlib imports
 import base64
 
 # Suppress warnings
@@ -38,7 +37,7 @@ PRE_PASS1_BUSINESS_PART_LOOKUP_THRESHOLD = 0.5
 # --- Global variables to load once ---
 tokenizer = None
 model = None
-nlp = None # SpaCy model
+# Removed nlp = None
 embedder = None # Sentence Transformer
 data = [] # Google Sheet data
 descriptions = []
@@ -46,27 +45,7 @@ embeddings = torch.tensor([]) # Google Sheet embeddings
 
 # --- Loading Functions (Run once on startup) ---
 
-def load_spacy_model():
-    """Loads or downloads the spaCy model."""
-    model_name = "en_core_web_sm"
-    try:
-        print(f"Loading spaCy model '{model_name}'...")
-        nlp_model = spacy.load(model_name)
-        print(f"SpaCy model '{model_name}' loaded.")
-        return nlp_model
-    except OSError:
-        print(f"SpaCy model '{model_name}' not found locally. Attempting download...")
-        # For HF Spaces, ensuring it's in requirements.txt is key.
-        # We'll assume requirements.txt handles installation, and try loading again.
-        print("Assuming 'en_core_web_sm' is installed via requirements.txt. Attempting to load...")
-        try:
-             nlp_model = spacy.load(model_name)
-             print(f"SpaCy model '{model_name}' loaded after assumed installation.")
-             return nlp_model
-        except Exception as e:
-             print(f"Failed to load spaCy model '{model_name}' after assumed installation: {e}")
-             print("SpaCy will not be available.")
-             return None # Return None if loading fails
+# Removed load_spacy_model function
 
 def load_sentence_transformer():
     """Loads the Sentence Transformer model."""
@@ -92,7 +71,6 @@ def load_google_sheet_data(sheet_id, service_account_key_base64):
         key_dict = json.loads(key_bytes)
 
         # Authenticate using the service account key
-        # Use service_account.Credentials.from_service_account_info directly
         from google.oauth2 import service_account
         creds = service_account.Credentials.from_service_account_info(key_dict)
         client = gspread.authorize(creds)
@@ -118,7 +96,6 @@ def load_google_sheet_data(sheet_id, service_account_key_base64):
         descriptions = [row["Description"] for row in filtered_data]
         print(f"Loaded {len(descriptions)} entries from Google Sheet for embedding.")
 
-        # embeddings will be encoded after embedder is loaded
         return filtered_data, descriptions, None # Return descriptions, embeddings encoded later
 
     except gspread.exceptions.SpreadsheetNotFound:
@@ -131,7 +108,7 @@ def load_google_sheet_data(sheet_id, service_account_key_base64):
 
 
 def load_llm_model(model_id, hf_token):
-    """Loads the LLM in full precision (for CPU).""" # Modified description
+    """Loads the LLM in full precision (for CPU)."""
     print(f"Loading model {model_id} in full precision...")
     if not hf_token:
         print("Error: HF_TOKEN secret is not set. Cannot load Hugging Face model.")
@@ -142,12 +119,10 @@ def load_llm_model(model_id, hf_token):
         if llm_tokenizer.pad_token is None:
              llm_tokenizer.pad_token = llm_tokenizer.eos_token
 
-        # Load the model without quantization config
         llm_model = AutoModelForCausalLM.from_pretrained(
             model_id,
             token=hf_token,
             device_map="auto", # This will likely map to 'cpu'
-            # Removed quantization_config=bnb_config
         )
 
         print(f"Model {model_id} loaded in full precision.")
@@ -155,17 +130,15 @@ def load_llm_model(model_id, hf_token):
 
     except Exception as e:
         print(f"Error loading model {model_id}: {e}")
-        # Removed specific bitsandbytes message
         print("Please ensure transformers, trl, peft, and accelerate are installed.")
         print("Check your Hugging Face token.")
-        # Do not raise, return None to allow app to start without LLM
         return None, None
 
 # --- Load all assets on startup ---
 print("Loading assets...")
-nlp = load_spacy_model()
+# Removed nlp = load_spacy_model()
 embedder = load_sentence_transformer()
-data, descriptions, _ = load_google_sheet_data(SHEET_ID, GOOGLE_SERVICE_ACCOUNT_KEY_BASE64) # Load data and descriptions first
+data, descriptions, _ = load_google_sheet_data(SHEET_ID, GOOGLE_SERVICE_ACCOUNT_KEY_BASE64)
 
 if embedder and descriptions:
     print("Encoding Google Sheet descriptions...")
@@ -174,25 +147,24 @@ if embedder and descriptions:
         print("Encoding complete.")
     except Exception as e:
         print(f"Error during embedding: {e}")
-        embeddings = torch.tensor([]) # Ensure embeddings is an empty tensor on error
+        embeddings = torch.tensor([])
 else:
      print("Skipping embedding due to missing embedder or descriptions.")
-     embeddings = torch.tensor([]) # Ensure embeddings is an empty tensor if no descriptions
+     embeddings = torch.tensor([])
 
 model, tokenizer = load_llm_model(model_id, HF_TOKEN)
 
-# Check if essential components loaded
-if not model or not tokenizer or not embedder or not nlp:
+# Check if essential components loaded (Removed nlp from this check)
+if not model or not tokenizer or not embedder:
     print("\nERROR: Essential components failed to load. The application may not function correctly.")
     if not model: print("- LLM Model failed to load.")
     if not tokenizer: print("- LLM Tokenizer failed to load.")
     if not embedder: print("- Sentence Embedder failed to load.")
-    if not nlp: print("- spaCy Model failed to load.")
+    # Removed spaCy error message
     # Continue, but the main inference function will need checks
 
-# --- Helper Functions (from your script) ---
+# --- Helper Functions ---
 
-# Function to perform DuckDuckGo Search and return results with URLs
 def perform_duckduckgo_search(query, max_results=3):
     """
     Performs a search using DuckDuckGo and returns a list of dictionaries.
@@ -200,16 +172,15 @@ def perform_duckduckgo_search(query, max_results=3):
     """
     search_results_list = []
     try:
-        time.sleep(1) # Add a delay before each search
+        time.sleep(1)
         with DDGS() as ddgs:
             for r in ddgs.text(query, max_results=max_results):
-                search_results_list.append(r) # Append the dictionary directly
+                search_results_list.append(r)
     except Exception as e:
-        print(f"Error during DuckDuckgo search for '{query}': {e}")
+        print(f"Error during Duckduckgo search for '{query}': {e}")
         return []
     return search_results_list
 
-# Function to retrieve relevant business info
 def retrieve_business_info(query, data, embeddings, embedder, threshold=0.50):
     """
     Retrieves relevant business information based on query similarity.
@@ -236,26 +207,19 @@ def retrieve_business_info(query, data, embeddings, embedder, threshold=0.50):
          print(f"Error during business information retrieval: {e}")
          return None, 0.0
 
-# Function to split user query into potential sub-queries using spaCy
+# Alternative split_query function without spaCy
 def split_query(query):
-    """Splits a user query into potential sub-queries using spaCy."""
-    if nlp is None:
-        print("SpaCy model not loaded. Cannot split query.")
-        return [query] # Return original query if nlp is not available
+    """Splits a user query into potential sub-queries using regex."""
+    # This regex splits on common separators like comma, semicolon, and conjunctions followed by interrogative words
+    parts = re.split(r',|;|\band\s+(?:who|what|where|when|why|how|is|are|can|tell me about)\b', query, flags=re.IGNORECASE)
+    # Filter out empty strings and strip whitespace
+    parts = [part.strip() for part in parts if part and part.strip()]
 
-    try:
-        doc = nlp(query)
-        sentences = [sent.text.strip() for sent in doc.sents]
-        if len(sentences) == 1:
-            parts = re.split(r',| and (who|what|where|when|why|how|is|are|can|tell me about)|;', query, flags=re.IGNORECASE)
-            parts = [part.strip() for part in parts if part is not None and part.strip()]
-            if len(parts) <= 1:
-                 return [query]
-            return parts
-        return sentences
-    except Exception as e:
-        print(f"Error during query splitting: {e}")
-        return [query] # Return original query on error
+    # If splitting didn't produce multiple meaningful parts, return the original query
+    if len(parts) <= 1:
+        return [query]
+
+    return parts
 
 # --- Pass 1 System Prompt ---
 pass1_instructions_action = """You are a helpful assistant for a business. Your primary goal in this first step is to analyze the user's query and decide which actions are needed to answer it.
@@ -300,26 +264,24 @@ When search results were used to answer the question, list the URLs from the sea
 """
 
 # --- Main Inference Function for Gradio ---
-# This function will be called every time the user submits a query
-# chat_history is now a parameter managed by Gradio's State
 def respond(user_input, chat_history):
     """
     Processes user input, performs actions (lookup/search), and generates a response.
     Manages chat history within Gradio state.
     """
-    # Check if models loaded successfully
-    if model is None or tokenizer is None or embedder is None or nlp is None:
-        return "", chat_history + [(user_input, "Sorry, the application failed to load necessary components. Please try again later or contact the administrator.")] # Return empty string for input, updated history
+    # Check if models loaded successfully (Removed nlp from this check)
+    if model is None or tokenizer is None or embedder is None:
+        return "", chat_history + [(user_input, "Sorry, the application failed to load necessary components. Please try again later or contact the administrator.")]
 
     original_user_input = user_input
 
     # Initialize action results containers for this turn
     search_results_dicts = []
     business_lookup_results_formatted = []
-    response_pass1_raw = "" # To store the raw actions generated by Pass 1
+    response_pass1_raw = ""
 
     # --- Pre-Pass 1: Programmatic Business Info Check for Query Parts ---
-    query_parts = split_query(original_user_input)
+    query_parts = split_query(original_user_input) # This now uses the regex split
     business_check_results = []
     overall_pre_pass1_score = 0.0
 
@@ -357,15 +319,14 @@ def respond(user_input, chat_history):
 
     if is_likely_direct_answer:
         print("Programmatically determined likely direct answer.")
-        response_pass1_raw = f"ACTION: ANSWER_DIRECTLY: " # Signal Pass 2
+        response_pass1_raw = f"ACTION: ANSWER_DIRECTLY: "
 
     else:
         pass1_user_message_content = pass1_instructions_action.format(
              business_check_summary=business_check_summary,
-             PRE_PASS1_BUSINESS_PART_LOOKUP_THRESHOLD=PRE_PASS1_BUSINESS_PART_LOOKUP_THRESHOLD # Pass threshold to prompt
+             PRE_PASS1_BUSINESS_PART_LOOKUP_THRESHOLD=PRE_PASS1_BUSINESS_PART_LOOKUP_THRESHOLD
              ) + "\n\nUser Query: " + user_input
 
-        # Create a temporary history for Pass 1 focusing only on the current turn's user query and instructions
         temp_chat_history_pass1 = [{"role": "user", "content": pass1_user_message_content}]
 
         try:
@@ -374,9 +335,6 @@ def respond(user_input, chat_history):
                 tokenize=False,
                 add_generation_prompt=True
             )
-            # print("\n--- Pass 1 Prompt ---") # Debug print
-            # print(prompt_pass1)
-            # print("---------------------")
 
             generation_config_pass1 = GenerationConfig(
                 max_new_tokens=200,
@@ -387,8 +345,8 @@ def respond(user_input, chat_history):
                 use_cache=True
             )
 
-            input_ids_pass1 = tokenizer(prompt_pass1, return_tensors="pt").input_ids # Removed .to(model.device) as device_map="auto" handles it
-            if model and input_ids_pass1.numel() > 0: # Added check for model
+            input_ids_pass1 = tokenizer(prompt_pass1, return_tensors="pt").input_ids
+            if model and input_ids_pass1.numel() > 0:
                 outputs_pass1 = model.generate(
                     input_ids=input_ids_pass1,
                     generation_config=generation_config_pass1,
@@ -398,23 +356,15 @@ def respond(user_input, chat_history):
                     generated_tokens_pass1 = outputs_pass1[0, prompt_length_pass1:]
                     response_pass1_raw = tokenizer.decode(generated_tokens_pass1, skip_special_tokens=True).strip()
                 else:
-                    response_pass1_raw = "" # No actions generated
+                    response_pass1_raw = ""
             else:
-                 response_pass1_raw = "" # Empty input or model not loaded
-
-            # print("\n--- Raw Pass 1 Response ---") # Debug print
-            # print(response_pass1_raw)
-            # print("--------------------------")
-
+                 response_pass1_raw = ""
 
         except Exception as e:
             print(f"Error during Pass 1 (Action Identification): {e}")
-            # If Pass 1 fails, fallback to attempting a direct answer in Pass 2
             response_pass1_raw = f"ACTION: ANSWER_DIRECTLY: Error in Pass 1 - {e}"
 
-
     # --- Parse Model's Requested Actions with Validation ---
-    # Always parse even if flagged for direct answer to handle potential Pass 1 errors
     if response_pass1_raw:
         lines = response_pass1_raw.strip().split('\n')
         for line in lines:
@@ -422,7 +372,6 @@ def respond(user_input, chat_history):
             if line.startswith(SEARCH_MARKER):
                 query = line[len(SEARCH_MARKER):].strip()
                 if query:
-                     # Validate SEARCH Action
                      _, score = retrieve_business_info(query, data, embeddings, embedder, threshold=0.0)
                      if score < SEARCH_VALIDATION_THRESHOLD:
                          requested_actions.append(("SEARCH", query))
@@ -432,8 +381,7 @@ def respond(user_input, chat_history):
             elif line.startswith(BUSINESS_LOOKUP_MARKER):
                  query = line[len(BUSINESS_LOOKUP_MARKER):].strip()
                  if query:
-                      # Validate Business Lookup Query
-                      match, score = retrieve_business_info(query, data, embeddings, embedder, threshold=0.0) # Use low threshold for scoring
+                      match, score = retrieve_business_info(query, data, embeddings, embedder, threshold=0.0)
                       if score > BUSINESS_LOOKUP_VALIDATION_THRESHOLD:
                            requested_actions.append(("LOOKUP_BUSINESS_INFO", query))
                            print(f"Validated Business Lookup Action for '{query}' (Score: {score:.4f})")
@@ -441,13 +389,11 @@ def respond(user_input, chat_history):
                            print(f"Rejected Business Lookup Action for '{query}' (Score: {score:.4f}) - Below validation threshold.")
             elif line.startswith(ANSWER_DIRECTLY_MARKER):
                  answer = line[len(ANSWER_DIRECTLY_MARKER):].strip()
-                 answer_directly_provided = answer if answer else original_user_input # Use explicit answer if provided, else original query hint
-                 requested_actions = [] # Clear other actions if DIRECT_ANSWER is given
-                 break # Exit action parsing loop
+                 answer_directly_provided = answer if answer else original_user_input
+                 requested_actions = []
+                 break
 
     # --- Execute Actions (Search and Lookup) ---
-    # Only execute actions if ANSWER_DIRECTLY was NOT the primary outcome of Pass 1
-    # and there are validated requested actions.
     context_for_pass2 = ""
 
     if requested_actions:
@@ -464,7 +410,7 @@ def respond(user_input, chat_history):
 
             elif action_type == "LOOKUP_BUSINESS_INFO":
                 print(f"Performing business info lookup for: '{query}'")
-                match, score = retrieve_business_info(query, data, embeddings, embedder, threshold=retrieve_business_info.__defaults__[0]) # Use default threshold for retrieval
+                match, score = retrieve_business_info(query, data, embeddings, embedder, threshold=retrieve_business_info.__defaults__[0])
                 print(f"Actual lookup score for '{query}': {score:.4f} (Threshold: {retrieve_business_info.__defaults__[0]})")
                 if match:
                      formatted_match = f"""Service: {match.get('Service', 'N/A')}
@@ -493,20 +439,16 @@ Available: {match.get('Available', 'N/A')}"""
              context_for_pass2 = "Note: No relevant information was found in Business Information or via Search for your query."
              print("Note: No results were found for the requested actions.")
 
-    # If ANSWER_DIRECTLY was determined (either programmatically or by Pass 1 model output)
+    # If ANSWER_DIRECTLY was determined
     if answer_directly_provided is not None:
         print(f"Handling as direct answer: {answer_directly_provided}")
-        # Provide a simple context indicating it's a direct answer scenario
         context_for_pass2 = "Note: This query is a simple request or greeting."
         if answer_directly_provided != original_user_input and answer_directly_provided != "":
              context_for_pass2 += f" Initial suggestion from action step: {answer_directly_provided}"
-        # Ensure no search/lookup results are included if it was flagged as direct answer
         search_results_dicts = []
         business_lookup_results_formatted = []
 
-
-    # If no actions were requested or direct answer flagged, and no results found...
-    # This handles cases where Pass 1 failed or generated nothing useful
+    # If no actions or direct answer, and no results
     if not requested_actions and answer_directly_provided is None:
          if response_pass1_raw.strip():
               print("Warning: Pass 1 did not result in valid actions or a direct answer.")
@@ -514,42 +456,29 @@ Available: {match.get('Available', 'N/A')}"""
          else:
                print("Warning: Pass 1 generated an empty response.")
                context_for_pass2 = "Error: Pass 1 generated an empty response."
-         # In this case, we will still try Pass 2 with the limited context
-
 
     # --- Pass 2: Synthesize and Respond ---
-    final_response = "Sorry, I couldn't generate a response." # Default response on error
+    final_response = "Sorry, I couldn't generate a response."
 
     if model is not None and tokenizer is not None:
         pass2_user_message_content = pass2_instructions_synthesize + "\n\nOriginal User Query: " + original_user_input + "\n\n" + context_for_pass2
 
-        # --- Chat History Management for Pass 2 ---
-        # Gradio's chat history state is [(User1, Bot1), (User2, Bot2), ...]
-        # We need to format the history correctly for the model template
-        # The Pass 2 prompt should build upon the *actual* conversation history, not just the Pass 2 context message.
-        # Let's build the chat history for the model template
         model_chat_history = []
         for user_msg, bot_msg in chat_history:
             model_chat_history.append({"role": "user", "content": user_msg})
             model_chat_history.append({"role": "assistant", "content": bot_msg})
 
-        # Add the *current* user query and the Pass 2 specific content as the latest turn
-        # The Pass 2 instructions and context are part of the *current* user turn's input to the model
         model_chat_history.append({"role": "user", "content": pass2_user_message_content})
 
         try:
             prompt_pass2 = tokenizer.apply_chat_template(
                 model_chat_history,
                 tokenize=False,
-                add_generation_prompt=True # Add the assistant prompt token to start the response
+                add_generation_prompt=True
             )
-            # print("\n--- Pass 2 Prompt ---") # Debug print
-            # print(prompt_pass2)
-            # print("---------------------")
-
 
             generation_config_pass2 = GenerationConfig(
-                max_new_tokens=1500, # Generate a longer response
+                max_new_tokens=1500,
                 do_sample=True,
                 temperature=0.7,
                 top_k=50,
@@ -560,8 +489,8 @@ Available: {match.get('Available', 'N/A')}"""
                 use_cache=True
             )
 
-            input_ids_pass2 = tokenizer(prompt_pass2, return_tensors="pt").input_ids # Removed .to(model.device)
-            if model and input_ids_pass2.numel() > 0: # Added check for model
+            input_ids_pass2 = tokenizer(prompt_pass2, return_tensors="pt").input_ids
+            if model and input_ids_pass2.numel() > 0:
                 outputs_pass2 = model.generate(
                     input_ids=input_ids_pass2,
                     generation_config=generation_config_pass2,
@@ -572,19 +501,16 @@ Available: {match.get('Available', 'N/A')}"""
                     generated_tokens_pass2 = outputs_pass2[0, prompt_length_pass2:]
                     final_response = tokenizer.decode(generated_tokens_pass2, skip_special_tokens=True).strip()
                 else:
-                    final_response = "..." # Indicate potentially empty response
+                    final_response = "..."
             else:
-                final_response = "Error: Model or empty input for Pass 2." # Indicate model not loaded or empty input
-
+                final_response = "Error: Model or empty input for Pass 2."
 
         except Exception as gen_error:
              print(f"Error during model generation in Pass 2: {gen_error}")
              final_response = "Error generating response in Pass 2."
 
-
         # --- Post-process Final Response from Pass 2 ---
         cleaned_response = final_response
-        # Filter out the Pass 2 instructions and context markers that might bleed through
         lines = cleaned_response.split('\n')
         cleaned_lines = [line for line in lines if not line.strip().lower().startswith("business information")
                                                  and not line.strip().lower().startswith("search results")
@@ -594,37 +520,27 @@ Available: {match.get('Available', 'N/A')}"""
 
         cleaned_response = "\n".join(cleaned_lines).strip()
 
-        # Extract and list URLs from the search results that were actually used
-        # This assumes the model uses the provided snippets with URLs
         urls_to_list = [result.get('href') for result in search_results_dicts if result.get('href')]
-        urls_to_list = list(dict.fromkeys(urls_to_list)) # Remove duplicates
+        urls_to_list = list(dict.fromkeys(urls_to_list))
 
-        # Only add Sources if search was performed AND results were found
         if search_results_dicts and urls_to_list:
              cleaned_response += "\n\nSources:\n" + "\n".join(urls_to_list)
 
         final_response = cleaned_response
 
-        # Check if the final response is empty or just whitespace after cleaning
         if not final_response.strip():
              final_response = "Sorry, I couldn't generate a meaningful response based on the information found."
              print("Warning: Final response was empty after cleaning.")
 
-    else: # Model or tokenizer not loaded (this check is at the very beginning of the function)
+    else:
      final_response = "Sorry, the core language model is not available."
      print("Error: LLM model or tokenizer not loaded for Pass 2.")
 
-
     # --- Update Chat History for Gradio ---
-    # Append the user's original message and the final bot response to the history state
-    # The format is (user_input, bot_response)
     updated_chat_history = chat_history + [(original_user_input, final_response)]
 
-    # Optional: Manage history length
-    max_history_pairs = 10 # Keep last 10 turns (20 messages total)
+    max_history_pairs = 10
     if len(updated_chat_history) > max_history_pairs:
      updated_chat_history = updated_chat_history[-max_history_pairs:]
-    # print(f"History truncated. Keeping last {len(updated_chat_history)} turns.") # Debug print
 
-    # Return the updated history state and an empty string for the input box
     return "", updated_chat_history