Refactor for better organization

ai.py

@@ -0,0 +1,58 @@
+from dotenv import load_dotenv
+import os
+
+from huggingface_hub import InferenceClient
+# Load environment variables from .env file if it exists
+load_dotenv()
+
+# Check if we're running locally with custom model settings
+BASE_URL = os.getenv('BASE_URL')
+LOCAL_TOKEN = os.getenv('TOKEN')
+LOCAL_MODE = bool(BASE_URL and LOCAL_TOKEN)
+MODEL_NAME = os.getenv('MODEL_NAME', 'openai/gpt-oss-20b')
+client = None
+# Choose client based on whether we're running locally or in the cloud
+if LOCAL_MODE:
+    # Running locally with custom model settings
+    # Use local inference server
+    client = InferenceClient(model=BASE_URL, token=LOCAL_TOKEN)
+else:
+    hf_token = os.environ["HF_TOKEN"]
+    client = InferenceClient(token=hf_token, model=MODEL_NAME)
+
+
+def clean_response(response):
+    """Clean up the response by removing unwanted metadata and formatting artifacts"""
+    import re
+    import json
+    
+    # Remove channel/commentary tags and similar artifacts
+    response = re.sub(r'<\|channel\|>commentary to=assistant', '', response, flags=re.IGNORECASE)
+    response = re.sub(r'<\|constrain\|>json<\|message\|>', '', response, flags=re.IGNORECASE)
+    response = re.sub(r'<\|.*?\|>', '', response)  # Remove any other <|...|> patterns
+    response = response.replace("\\n", "\n")
+    
+    # Try to parse JSON response and extract the actual message
+    try:
+        # Look for JSON-like content
+        json_match = re.search(r'\{[^}]*"response"\s*:\s*"([^"]*)"[^}]*\}', response)
+        if json_match:
+            actual_response = json_match.group(1)
+            print(f"🔍 DEBUG - Extracted from JSON: {actual_response}")
+            return actual_response
+        
+        # Try to parse as complete JSON
+        parsed = json.loads(response.strip())
+        if isinstance(parsed, dict) and "response" in parsed:
+            actual_response = parsed["response"]
+            print(f"🔍 DEBUG - Parsed JSON response: {actual_response}")
+            return actual_response
+    except (json.JSONDecodeError, AttributeError):
+        # If JSON parsing fails, continue with text cleaning
+        pass
+    
+    # Clean up extra whitespace and newlines
+    response = re.sub(r'\n\s*\n', '\n', response)  # Remove multiple empty lines
+    response = response.strip()  # Remove leading/trailing whitespace
+    
+    return response

app.py

@@ -1,151 +1,23 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
+import game
+import ai
 
-import random
-import os
-import re
-from dotenv import load_dotenv
 
-from rag import fetch_facts
 
-# Load environment variables from .env file if it exists
-load_dotenv()
 
-# Check if we're running locally with custom model settings
-BASE_URL = os.getenv('BASE_URL')
-LOCAL_TOKEN = os.getenv('TOKEN')
-LOCAL_MODE = bool(BASE_URL and LOCAL_TOKEN)
-MODEL_NAME = os.getenv('MODEL_NAME', 'openai/gpt-oss-20b')
-
-
-import json
-
-# Load country list from countries.json
-COUNTRIES_JSON_PATH = os.path.join(os.path.dirname(__file__), "countries.json")
-with open(COUNTRIES_JSON_PATH, "r", encoding="utf-8") as f:
-    GEOGRAPHY_GUESS_LIST = json.load(f)
-
-STATES_JSON_PATH = os.path.join(os.path.dirname(__file__), "us_states.json")
-with open(STATES_JSON_PATH, "r", encoding="utf-8") as f:
-    US_STATES_GUESS_LIST = json.load(f)
-
-# Game mode constants
-GAME_MODE_COUNTRIES = "Countries of the World"
-GAME_MODE_STATES = "US States"
-
-# Global variables for current game state
-current_system = ""
-selected_country = ""
-selected_country_dict = {}
-game_mode = GAME_MODE_COUNTRIES
-
-
-
-def get_system_message(mode):
-    """Generate a system message with a randomly selected location based on game mode"""
-    global selected_country, selected_country_dict, game_mode
-    
-    if mode == GAME_MODE_STATES:
-        selected_country_dict = random.choice(US_STATES_GUESS_LIST)
-        location_type = "state"
-        location_type_upper = "US state"
-    else:
-        selected_country_dict = random.choice(GEOGRAPHY_GUESS_LIST)
-        location_type = "country"
-        location_type_upper = "country"
-    
-    selected_country = selected_country_dict["name"]
-    game_mode = mode
-
-    print(f"Selected {location_type} for this session: {selected_country}")
-    print(f"Fetching facts from: {selected_country_dict['url']}")
-    
-    facts = fetch_facts(game_mode, selected_country_dict["url"])
-    print(facts)
-
-    if mode == GAME_MODE_STATES:
-        location_info = f"""
-    State: {selected_country_dict['name']}
-    Capital: {selected_country_dict['capital']}
-    Nickname: {selected_country_dict['nickname']}
-    Facts: {facts}
-    """
-        info_label = "STATE INFORMATION"
-        reveal_text = "Do NOT reveal the state name"
-    else:
-        location_info = facts
-        info_label = "COUNTRY FACTS"
-        reveal_text = "Do NOT reveal the country name"
-
-    return f"""You are a friendly geography game host playing 20 questions with students. You are thinking of the {location_type_upper}: {selected_country}
-
-{info_label} (use these to answer questions accurately - {reveal_text}):
-{location_info}
-
-RULES:
-NEVER reveal the {location_type} name ({selected_country}) in your responses
-Answer only 'Yes' or 'No' to their question
-When they correctly guess or ask if it is {selected_country}, respond with: 'Congratulations! The {location_type} was <<{selected_country}>>'
-7. If they want to play again tell them they need to reload the page.
-8. IMPORTANT: Only accept the {location_type} name "{selected_country}" as correct, but Spelling is not important and they can ask a question like it is? Do NOT accept neighboring {location_type}s, similar {location_type}s, or regions that contain this {location_type}.
-9. If they guess a neighboring {location_type} or similar {location_type}, respond with "No" and continue the game.
-10. Be very strict about the exact {location_type} match - only "{selected_country}" is the correct answer.
-11. Use the {info_label} above to provide accurate yes/no answers - do not make up information.
-
-This is the users guess number: """
-
-current_system = ""
-
-def clean_response(response):
-    """Clean up the response by removing unwanted metadata and formatting artifacts"""
-    import re
-    import json
-    
-    # Remove channel/commentary tags and similar artifacts
-    response = re.sub(r'<\|channel\|>commentary to=assistant', '', response, flags=re.IGNORECASE)
-    response = re.sub(r'<\|constrain\|>json<\|message\|>', '', response, flags=re.IGNORECASE)
-    response = re.sub(r'<\|.*?\|>', '', response)  # Remove any other <|...|> patterns
-    response = response.replace("\\n", "\n")
-    
-    # Try to parse JSON response and extract the actual message
-    try:
-        # Look for JSON-like content
-        json_match = re.search(r'\{[^}]*"response"\s*:\s*"([^"]*)"[^}]*\}', response)
-        if json_match:
-            actual_response = json_match.group(1)
-            print(f"🔍 DEBUG - Extracted from JSON: {actual_response}")
-            return actual_response
-        
-        # Try to parse as complete JSON
-        parsed = json.loads(response.strip())
-        if isinstance(parsed, dict) and "response" in parsed:
-            actual_response = parsed["response"]
-            print(f"🔍 DEBUG - Parsed JSON response: {actual_response}")
-            return actual_response
-    except (json.JSONDecodeError, AttributeError):
-        # If JSON parsing fails, continue with text cleaning
-        pass
-    
-    # Clean up extra whitespace and newlines
-    response = re.sub(r'\n\s*\n', '\n', response)  # Remove multiple empty lines
-    response = response.strip()  # Remove leading/trailing whitespace
-    
-    return response
-
-def format_game_result(response, guess_number):
+def format_game_result(response):
     """Format the game result with proper styling"""
-    global game_mode
-    location_type = "state" if game_mode == GAME_MODE_STATES else "country"
+    location_type = "state" if game.mode == game.MODE_STATES else "country"
 
     if f"The {location_type} was" in response:
-        print(f"🔍 DEBUG - Game end detected! {location_type.capitalize()} extracted: {selected_country}")
+        print(f"🔍 DEBUG - Game end detected! {location_type.capitalize()} extracted: {game.selected_country}")
     else:
         print("🔍 DEBUG - Regular response (no game end)")
 
     if "Congratulations" in response:
-        return f"🎉 **Congratulations!** You correctly guessed **{selected_country}**! It took you **{guess_number}** guesses. Well done! 🎉\n\nTo play another round, please start a new conversation or reload the page."
+        return f"🎉 **Congratulations!** You correctly guessed **{game.selected_country}**! It took you **{game.guess_number}** guesses. Well done! 🎉\n\nTo play another round, please start a new conversation or reload the page."
     elif "Game over" in response:
-        return f"😔 **Game Over!** You've used all 20 questions. The {location_type} I was thinking of was **{selected_country}**. 😔\n\nTo try again, please start a new conversation or reload the page."
+        return f"😔 **Game Over!** You've used all 20 questions. The {location_type} I was thinking of was **{game.selected_country}**. 😔\n\nTo try again, please start a new conversation or reload the page."
     
     return response
 
@@ -163,20 +35,19 @@ def respond(
     """
     For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
     """
-    global current_system, guess_number
 
     # If this is the start of a new conversation (empty history), generate a new country/state
     if not history:
-        guess_number = 0
-        if game_mode_selection == GAME_MODE_STATES:
-            current_system = get_system_message(GAME_MODE_STATES)
-            print(f"🔍 DEBUG - New session started, selected state: {selected_country}")
+        game.guess_number = 0
+        if game_mode_selection == game.MODE_STATES:
+            game.current_system = game.get_system_message(game.MODE_STATES)
+            print(f"🔍 DEBUG - New session started, selected state: {game.selected_country}")
         else:
-            current_system = get_system_message(GAME_MODE_COUNTRIES)
-            print(f"🔍 DEBUG - New session started, selected country: {selected_country}")
+            game.current_system = game.get_system_message(game.MODE_COUNTRIES)
+            print(f"🔍 DEBUG - New session started, selected country: {game.selected_country}")
 
-    guess_number += 1
-    messages = [{"role": "system", "content": current_system + str(guess_number)}]
+    game.guess_number += 1
+    messages = [{"role": "system", "content": game.current_system + str(game.guess_number)}]
     messages.append({"role": "user", "content": message})
 
     # Debug: Calculate approximate input token count
@@ -198,30 +69,16 @@ def respond(
         elif role == "assistant":
             print(f"🔍 DEBUG - Assistant message: {content[:50]}...")
 
-    # Choose client based on whether we're running locally or in the cloud
-    if LOCAL_MODE:
-        # Running locally with custom model settings
-        try:
-            # Use local inference server
-            client = InferenceClient(model=BASE_URL, token=LOCAL_TOKEN)
-        except Exception as e:
-            return f"Error connecting to local model: {str(e)}"
-    else:
-        hf_token = os.environ["HF_TOKEN"]
-        client = InferenceClient(token=hf_token, model=MODEL_NAME)
+   
 
     response = ""
     output_token_count = 0
 
     try:
-        for message_chunk in client.chat_completion(
+        for message_chunk in ai.client.chat_completion(
             messages,
-            model=MODEL_NAME,
-            max_tokens=max_tokens,
             stream=True,
             response_format={"type": "text"},
-            temperature=temperature,
-            top_p=top_p,
         ):
             choices = message_chunk.choices
             token = ""
@@ -239,16 +96,16 @@ def respond(
         print(f"🔍 DEBUG - Raw response: {response}")
 
         # Clean the response to remove unwanted artifacts
-        response = clean_response(response)
+        response = ai.clean_response(response)
         print(f"🔍 DEBUG - Cleaned response: {response}")
 
         # Check if this is a game end response and format it nicely
         if "The country was" in response or "The state was" in response:
-            print(f"🔍 DEBUG - Game end detected! Location extracted: {selected_country}")
-            return format_game_result(response, guess_number)
-        elif guess_number == 20:
-            print(f"🔍 DEBUG - Maximum guesses reached: {guess_number}")
-            return format_game_result(response, guess_number)
+            print(f"🔍 DEBUG - Game end detected! Location extracted: {game.selected_country}")
+            return format_game_result(response)
+        elif game.guess_number == 20:
+            print(f"🔍 DEBUG - Maximum guesses reached: {game.guess_number}")
+            return format_game_result(response)
         else:
             print("🔍 DEBUG - Regular response (no game end)")
             return response
@@ -256,13 +113,9 @@ def respond(
         return f"Error during inference: {str(e)}"
 
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-
 # Create description based on mode
-if LOCAL_MODE:
-    description = f"🏠 Running locally with {MODEL_NAME}. Choose your game mode and I'll think of a location for you to guess with 20 yes or no questions!"
+if ai.LOCAL_MODE:
+    description = f"🏠 Running locally with {ai.MODEL_NAME}. Choose your game mode and I'll think of a location for you to guess with 20 yes or no questions!"
 else:
     description = "Choose your game mode and I'll think of a location for you to guess with 20 yes or no questions!"
 
@@ -292,9 +145,9 @@ with gr.Blocks() as demo:
     gr.Markdown(description)
     
     # Game mode selection at the top
-    game_mode_dropdown = gr.Dropdown(
-        choices=[GAME_MODE_STATES, GAME_MODE_COUNTRIES],
-        value=GAME_MODE_STATES,
+    game.mode_dropdown = gr.Dropdown(
+        choices=[game.MODE_STATES, game.MODE_COUNTRIES],
+        value=game.MODE_STATES,
         label="Game Mode",
         info="Choose what type of location to guess"
     )
@@ -305,7 +158,7 @@ with gr.Blocks() as demo:
         type="messages",
         examples=examples,
         cache_examples=False,
-        additional_inputs=[game_mode_dropdown],
+        additional_inputs=[game.mode_dropdown],
     )
     
 

game.py

@@ -0,0 +1,77 @@
+import json
+import os
+from rag import fetch_facts
+import random
+
+# Load country list from countries.json
+COUNTRIES_JSON_PATH = os.path.join(os.path.dirname(__file__), "countries.json")
+with open(COUNTRIES_JSON_PATH, "r", encoding="utf-8") as f:
+    GEOGRAPHY_GUESS_LIST = json.load(f)
+
+STATES_JSON_PATH = os.path.join(os.path.dirname(__file__), "us_states.json")
+with open(STATES_JSON_PATH, "r", encoding="utf-8") as f:
+    US_STATES_GUESS_LIST = json.load(f)
+
+# Game mode constants
+MODE_COUNTRIES = "Countries of the World"
+MODE_STATES = "US States"
+
+
+current_system = ""
+selected_country = ""
+selected_country_dict = {}
+mode = MODE_COUNTRIES
+guess_number = 0
+
+def get_system_message(game_mode):
+    """Generate a system message with a randomly selected location based on game mode"""
+    global selected_country, selected_country_dict, mode
+    
+    if game_mode == MODE_STATES:
+        selected_country_dict = random.choice(US_STATES_GUESS_LIST)
+        location_type = "state"
+        location_type_upper = "US state"
+    else:
+        selected_country_dict = random.choice(GEOGRAPHY_GUESS_LIST)
+        location_type = "country"
+        location_type_upper = "country"
+    
+    selected_country = selected_country_dict["name"]
+    mode = game_mode
+
+    print(f"Selected {location_type} for this session: {selected_country}")
+    print(f"Fetching facts from: {selected_country_dict['url']}")
+    
+    facts = fetch_facts(game_mode, selected_country_dict["url"])
+    print(facts)
+
+    if game_mode == MODE_STATES:
+        location_info = f"""
+    State: {selected_country_dict['name']}
+    Capital: {selected_country_dict['capital']}
+    Nickname: {selected_country_dict['nickname']}
+    Facts: {facts}
+    """
+        info_label = "STATE INFORMATION"
+        reveal_text = "Do NOT reveal the state name"
+    else:
+        location_info = facts
+        info_label = "COUNTRY FACTS"
+        reveal_text = "Do NOT reveal the country name"
+
+    return f"""You are a friendly geography game host playing 20 questions with students. You are thinking of the {location_type_upper}: {selected_country}
+
+{info_label} (use these to answer questions accurately - {reveal_text}):
+{location_info}
+
+RULES:
+NEVER reveal the {location_type} name ({selected_country}) in your responses
+Answer only 'Yes' or 'No' to their question
+When they correctly guess or ask if it is {selected_country}, respond with: 'Congratulations! The {location_type} was <<{selected_country}>>'
+7. If they want to play again tell them they need to reload the page.
+8. IMPORTANT: Only accept the {location_type} name "{selected_country}" as correct, but Spelling is not important and they can ask a question like it is? Do NOT accept neighboring {location_type}s, similar {location_type}s, or regions that contain this {location_type}.
+9. If they guess a neighboring {location_type} or similar {location_type}, respond with "No" and continue the 
+10. Be very strict about the exact {location_type} match - only "{selected_country}" is the correct answer.
+11. Use the {info_label} above to provide accurate yes/no answers - do not make up information.
+
+This is the users guess number: """