Basic Only version step 3

removed additional dead code

battlewords/audio.py

@@ -1,254 +0,0 @@
-import os
-from typing import Optional
-import streamlit as st
-import time
-
-def _get_music_dir() -> str:
-    return os.path.join(os.path.dirname(__file__), "assets", "audio", "music")
-
-def _get_effects_dir() -> str:
-    return os.path.join(os.path.dirname(__file__), "assets", "audio", "effects")
-
-def get_audio_tracks() -> list[tuple[str, str]]:
-    """Return list of (label, absolute_path) for .mp3 files in assets/audio/music."""
-    audio_dir = _get_music_dir()
-    if not os.path.isdir(audio_dir):
-        return []
-    tracks = []
-    for fname in os.listdir(audio_dir):
-        if fname.lower().endswith('.mp3'):
-            path = os.path.join(audio_dir, fname)
-            # Use the filename without extension as the display name
-            name = os.path.splitext(fname)[0]
-            tracks.append((name, path))
-    return tracks
-
-@st.cache_data(show_spinner=False)
-def _load_audio_data_url(path: str) -> str:
-    """Return a data: URL for the given audio file so the browser can play it."""
-    import base64, mimetypes
-    mime, _ = mimetypes.guess_type(path)
-    if not mime:
-        # Default to mp3 to avoid blocked playback if unknown
-        mime = "audio/mpeg"
-    with open(path, "rb") as fp:
-        encoded = base64.b64encode(fp.read()).decode("ascii")
-    return f"data:{mime};base64,{encoded}"
-
-def _mount_background_audio(enabled: bool, src_data_url: Optional[str], volume: float, loop: bool = True) -> None:
-    """Create/update a single hidden <audio> element in the top page and play/pause it.
-
-    Args:
-        enabled: Whether the background audio should be active.
-        src_data_url: data: URL for the audio source.
-        volume: 0.0–1.0 volume level.
-        loop: Whether the audio should loop (default True).
-    """
-    from streamlit.components.v1 import html as _html
-
-    if not enabled or not src_data_url:
-        _html(
-            """
-            <script>
-            (function(){
-              const doc = window.parent?.document || document;
-              const el = doc.getElementById('bw-bg-audio');
-              if (el) { try { el.pause(); } catch(e){} }
-            })();
-            </script>
-            """,
-            height=0,
-        )
-        return
-
-    # Clamp volume
-    vol = max(0.0, min(1.0, float(volume)))
-    should_loop = "true" if loop else "false"
-
-    # Inject or update a single persistent audio element and make sure it starts after interaction if autoplay is blocked
-    _html(
-        f"""
-        <script>
-        (function(){{
-          const doc = window.parent?.document || document;
-          let audio = doc.getElementById('bw-bg-audio');
-          if (!audio) {{
-            audio = doc.createElement('audio');
-            audio.id = 'bw-bg-audio';
-            audio.style.display = 'none';
-            doc.body.appendChild(audio);
-          }}
-
-          // Ensure loop is explicitly set every time, even if element already exists
-          const shouldLoop = {should_loop};
-          audio.loop = shouldLoop;
-          if (shouldLoop) {{
-            audio.setAttribute('loop', '');
-          }} else {{
-            audio.removeAttribute('loop');
-          }}
-          audio.autoplay = true;
-          audio.setAttribute('autoplay', '');
-
-          const newSrc = "{src_data_url}";
-          if (audio.src !== newSrc) {{
-            audio.src = newSrc;
-          }}
-          audio.muted = false;
-          audio.volume = {vol:.3f};
-
-          const tryPlay = () => {{
-            const p = audio.play();
-            if (p && p.catch) {{ p.catch(() => {{ /* ignore autoplay block until user gesture */ }}); }}
-          }};
-          tryPlay();
-
-          const unlock = () => {{
-            tryPlay();
-          }};
-          // Add once-only listeners to resume playback after first user interaction
-          doc.addEventListener('pointerdown', unlock, {{ once: true }});
-          doc.addEventListener('keydown', unlock, {{ once: true }});
-          doc.addEventListener('touchstart', unlock, {{ once: true }});
-        }})();
-        </script>
-        """,
-        height=0,
-    )
-
-def _inject_audio_control_sync():
-    """Inject JS to sync volume and enable/disable state immediately."""
-    from streamlit.components.v1 import html as _html
-    _html(
-        '''
-        <script>
-        (function(){
-          const doc = window.parent?.document || document;
-          const audio = doc.getElementById('bw-bg-audio');
-          if (!audio) return;
-          // Get values from Streamlit DOM
-          const volInput = doc.querySelector('input[type="range"][aria-label="Volume"]');
-          const enableInput = doc.querySelector('input[type="checkbox"][aria-label="Enable music"]');
-          if (volInput) {
-            volInput.addEventListener('input', function(){
-              audio.volume = parseFloat(this.value)/100;
-            });
-            // Set initial volume
-            audio.volume = parseFloat(volInput.value)/100;
-          }
-          if (enableInput) {
-            enableInput.addEventListener('change', function(){
-              if (this.checked) {
-                audio.muted = false;
-                audio.play().catch(()=>{});
-              } else {
-                audio.muted = true;
-                audio.pause();
-              }
-            });
-            // Set initial mute state
-            if (enableInput.checked) {
-              audio.muted = false;
-              audio.play().catch(()=>{});
-            } else {
-              audio.muted = true;
-              audio.pause();
-            }
-          }
-        })();
-        </script>
-        ''',
-        height=0,
-    )
-
-# Sound effects functionality
-def get_sound_effect_files() -> dict[str, str]:
-    """
-    Return dictionary of sound effect name -> absolute path.
-    Prefers .mp3 files; falls back to .wav if no .mp3 is found.
-    """
-    audio_dir = _get_effects_dir()
-    if not os.path.isdir(audio_dir):
-        return {}
-
-    effect_names = [
-        "correct_guess",
-        "incorrect_guess",
-        "hit",
-        "miss",
-        "congratulations",
-    ]
-
-    def _find_effect_file(base: str) -> Optional[str]:
-        # Prefer mp3, then wav for backward compatibility
-        for ext in (".mp3", ".wav"):
-            path = os.path.join(audio_dir, f"{base}{ext}")
-            if os.path.exists(path):
-                return path
-        return None
-
-    result: dict[str, str] = {}
-    for name in effect_names:
-        path = _find_effect_file(name)
-        if path:
-            result[name] = path
-
-    return result
-
-def play_sound_effect(effect_name: str, volume: float = 0.5) -> None:
-    """
-    Play a sound effect by name.
-
-    Args:
-        effect_name: One of 'correct_guess', 'incorrect_guess', 'hit', 'miss', 'congratulations'
-        volume: Volume level (0.0 to 1.0)
-    """
-    from streamlit.components.v1 import html as _html
-
-    # Respect Enable Sound Effects setting from sidebar
-    try:
-        if not st.session_state.get("enable_sound_effects", True):
-            # print(f"[DEBUG] Sound effects disabled; skipping sound effect '{effect_name}'.")
-            return
-    except Exception:
-        pass
-
-    sound_files = get_sound_effect_files()
-
-    if effect_name not in sound_files:
-        print(f"[DEBUG] Sound effect '{effect_name}' not found in available sound files.")
-        return  # Sound file doesn't exist, silently skip
-
-    sound_path = sound_files[effect_name]
-    try:
-        sound_data_url = _load_audio_data_url(sound_path)
-    except Exception as e:
-        print(f"[DEBUG] Failed to load audio data for '{effect_name}' at '{sound_path}': {e}")
-        return
-
-    # Clamp volume
-    vol = max(0.0, min(1.0, float(volume)))
-
-    # Play sound effect using a unique audio element
-    _html(
-        f"""
-        <script>
-        (function(){{
-          const doc = window.parent?.document || document;
-          const audio = doc.createElement('audio');
-          audio.src = "{sound_data_url}";
-          audio.volume = {vol:.3f};
-          audio.style.display = 'none';
-          doc.body.appendChild(audio);
-
-          // Play and remove after playback
-          audio.play().catch(e => console.error('Sound effect play error:', e));
-          audio.addEventListener('ended', () => {{
-            doc.body.removeChild(audio);
-          }});
-        }})();
-        </script>
-        """,
-        height=0,
-    )
-    time.sleep(0.1)

battlewords/generate_sounds.py

@@ -1,174 +0,0 @@
-#!/usr/bin/env python3
-"""
-Standalone script to generate sound effects using Hugging Face API.
-Uses only built-in Python libraries (no external dependencies).
-"""
-
-import os
-import json
-import urllib.request
-import time
-from pathlib import Path
-
-# Load environment variables from .env if present
-env_path = Path(__file__).parent / ".env"
-if env_path.exists():
-    with open(env_path) as f:
-        for line in f:
-            if line.strip() and not line.startswith("#"):
-                key, _, value = line.strip().partition("=")
-                os.environ[key] = value
-
-# Get Hugging Face API token from environment variable
-HF_API_TOKEN = os.environ.get("HF_API_TOKEN")
-if not HF_API_TOKEN:
-    print("Warning: HF_API_TOKEN not set in environment or .env file.")
-
-# Using your UnlimitedMusicGen Gradio Space
-SPACE_URL = "https://surn-unlimitedmusicgen.hf.space"
-GRADIO_API_URL = f"{SPACE_URL}/api/predict"
-GRADIO_STATUS_URL = f"{SPACE_URL}/call/predict/{{event_id}}"
-
-# Sound effects to generate
-EFFECT_PROMPTS = {
-    "correct_guess": {"prompt": "A short, sharp ding sound for a correct guess", "duration": 2},
-    "incorrect_guess": {"prompt": "A low buzz sound for an incorrect guess", "duration": 2},
-    "miss": {"prompt": "A soft thud sound for a miss", "duration": 1},
-    "hit": {"prompt": "A bright chime sound for a hit", "duration": 1},
-    "congratulations": {"prompt": "A triumphant fanfare sound for congratulations", "duration": 3}
-}
-
-def generate_sound_effect_gradio(effect_name: str, prompt: str, duration: float, output_dir: Path) -> bool:
-    """Generate a single sound effect using Gradio API (async call)."""
-
-    print(f"\nGenerating: {effect_name}")
-    print(f"  Prompt: {prompt}")
-    print(f"  Duration: {duration}s")
-
-    # Step 1: Submit generation request
-    payload = json.dumps({
-        "data": [prompt, duration]
-    }).encode('utf-8')
-
-    headers = {
-        "Content-Type": "application/json"
-    }
-
-    try:
-        print(f"  Submitting request to Gradio API...")
-
-        # Submit the job
-        req = urllib.request.Request(GRADIO_API_URL, data=payload, headers=headers, method='POST')
-
-        with urllib.request.urlopen(req, timeout=30) as response:
-            if response.status == 200:
-                result = json.loads(response.read().decode())
-                event_id = result.get("event_id")
-
-                if not event_id:
-                    print(f"  ✗ No event_id returned")
-                    return False
-
-                print(f"  Job submitted, event_id: {event_id}")
-
-                # Step 2: Poll for results
-                status_url = GRADIO_STATUS_URL.format(event_id=event_id)
-
-                for poll_attempt in range(30):  # Poll for up to 5 minutes
-                    time.sleep(10)
-                    print(f"  Polling for results (attempt {poll_attempt + 1}/30)...")
-
-                    status_req = urllib.request.Request(status_url, headers=headers)
-
-                    try:
-                        with urllib.request.urlopen(status_req, timeout=30) as status_response:
-                            # Gradio returns streaming events, read until we get the result
-                            for line in status_response:
-                                line = line.decode('utf-8').strip()
-                                if line.startswith('data: '):
-                                    event_data = json.loads(line[6:])  # Remove 'data: ' prefix
-
-                                    if event_data.get('msg') == 'process_completed':
-                                        # Get the audio file URL
-                                        output_data = event_data.get('output', {}).get('data', [])
-                                        if output_data and len(output_data) > 0:
-                                            audio_url = output_data[0].get('url')
-                                            if audio_url:
-                                                # Download the audio file
-                                                full_audio_url = f"https://surn-unlimitedmusicgen.hf.space{audio_url}"
-                                                print(f"  Downloading from: {full_audio_url}")
-
-                                                audio_req = urllib.request.Request(full_audio_url)
-                                                with urllib.request.urlopen(audio_req, timeout=30) as audio_response:
-                                                    audio_data = audio_response.read()
-
-                                                    # Save to file
-                                                    output_path = output_dir / f"{effect_name}.wav"
-                                                    with open(output_path, "wb") as f:
-                                                        f.write(audio_data)
-
-                                                    print(f"  ✓ Success! Saved to: {output_path}")
-                                                    print(f"  File size: {len(audio_data)} bytes")
-                                                    return True
-
-                                    elif event_data.get('msg') == 'process_error':
-                                        print(f"  ✗ Generation error: {event_data.get('output')}")
-                                        return False
-
-                    except Exception as poll_error:
-                        print(f"  Polling error: {poll_error}")
-                        continue
-
-                print(f"  ✗ Timeout waiting for generation")
-                return False
-
-            else:
-                print(f"  ✗ Error {response.status}: {response.read().decode()}")
-                return False
-
-    except Exception as e:
-        print(f"  ✗ Error: {e}")
-        return False
-
-def main():
-    """Generate all sound effects."""
-
-    print("=" * 70)
-    print("Sound Effects Generator for BattleWords")
-    print("=" * 70)
-    print(f"Using UnlimitedMusicGen Gradio API")
-    print(f"API URL: {GRADIO_API_URL}")
-    print(f"\nGenerating {len(EFFECT_PROMPTS)} sound effects...\n")
-
-    # Create output directory
-    output_dir = Path(__file__).parent / "assets" / "audio"
-    output_dir.mkdir(parents=True, exist_ok=True)
-    print(f"Output directory: {output_dir}\n")
-
-    # Generate each effect
-    success_count = 0
-    for effect_name, config in EFFECT_PROMPTS.items():
-        if generate_sound_effect_gradio(
-            effect_name,
-            config["prompt"],
-            config["duration"],
-            output_dir
-        ):
-            success_count += 1
-
-        # Small delay between requests
-        if effect_name != list(EFFECT_PROMPTS.keys())[-1]:
-            print("  Waiting 5 seconds before next request...")
-            time.sleep(5)
-
-    print("\n" + "=" * 70)
-    print(f"Generation complete! {success_count}/{len(EFFECT_PROMPTS)} successful")
-    print("=" * 70)
-
-    if success_count == len(EFFECT_PROMPTS):
-        print("\n✓ All sound effects generated successfully!")
-    else:
-        print(f"\n⚠ {len(EFFECT_PROMPTS) - success_count} sound effects failed to generate")
-
-if __name__ == "__main__":
-    main()

battlewords/local_storage.py

@@ -1,234 +0,0 @@
-# file: battlewords/local_storage.py
-"""
-Storage module for BattleWords game.
-
-Provides functionality for:
-1. Saving/loading game results to local JSON files
-2. Managing high scores and leaderboards
-3. Sharing game IDs via query strings
-
-This module also provides minimal local settings persistence helpers.
-"""
-
-from __future__ import annotations
-from dataclasses import dataclass, field, asdict
-from typing import List, Dict, Optional, Any
-from datetime import datetime
-import json
-import os
-from pathlib import Path
-
-
-def _get_settings_dir() -> str:
-    """Return the directory where local settings are stored."""
-    return os.path.join(os.path.dirname(__file__), "settings")
-
-
-def load_latest_settings() -> Dict[str, Any]:
-    """Load the most recently saved settings snapshot.
-
-    Returns:
-        Dict[str, Any]: Loaded settings or an empty dict if not found/invalid.
-    """
-    settings_path = os.path.join(_get_settings_dir(), "settings.json")
-    if not os.path.exists(settings_path):
-        return {}
-
-    try:
-        with open(settings_path, "r", encoding="utf-8") as f:
-            data = json.load(f)
-        return data if isinstance(data, dict) else {}
-    except Exception:
-        return {}
-
-
-def save_active_settings(settings: Dict[str, Any]) -> str:
-    """Persist the active settings snapshot to local storage.
-
-    Args:
-        settings: Settings dict to save.
-
-    Returns:
-        str: Full path to the written file.
-    """
-    return save_json_to_file(settings, _get_settings_dir(), filename="settings.json")
-
-
-@dataclass
-class GameResult:
-    game_id: str
-    wordlist: str
-    game_mode: str
-    score: int
-    tier: str
-    elapsed_seconds: int
-    words_found: List[str]
-    completed_at: str
-    player_name: Optional[str] = None
-    user_id: Optional[str] = None
-    subscription_level: Optional[int] = 0
-    
-
-    def to_dict(self) -> Dict[str, Any]:
-        return asdict(self)
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "GameResult":
-        return cls(**data)
-
-@dataclass
-class HighScoreEntry:
-    player_name: str
-    score: int
-    tier: str
-    wordlist: str
-    game_mode: str
-    elapsed_seconds: int
-    completed_at: str
-    game_id: str
-
-    def to_dict(self) -> Dict[str, Any]:
-        return asdict(self)
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "HighScoreEntry":
-        return cls(**data)
-
-class GameStorage:
-    def __init__(self, storage_dir: Optional[str] = None):
-        if storage_dir is None:
-            storage_dir = os.path.join(
-                os.path.expanduser("~"),
-                ".battlewords",
-                "data"
-            )
-        self.storage_dir = Path(storage_dir)
-        self.storage_dir.mkdir(parents=True, exist_ok=True)
-        self.results_file = self.storage_dir / "game_results.json"
-        self.highscores_file = self.storage_dir / "highscores.json"
-
-    def save_result(self, result: GameResult) -> bool:
-        try:
-            results = self.load_all_results()
-            results.append(result.to_dict())
-            with open(self.results_file, 'w', encoding='utf-8') as f:
-                json.dump(results, f, indent=2, ensure_ascii=False)
-            self._update_highscores(result)
-            return True
-        except Exception as e:
-            print(f"Error saving result: {e}")
-            return False
-
-    def load_all_results(self) -> List[Dict[str, Any]]:
-        if not self.results_file.exists():
-            return []
-        try:
-            with open(self.results_file, 'r', encoding='utf-8') as f:
-                return json.load(f)
-        except Exception as e:
-            print(f"Error loading results: {e}")
-            return []
-
-    def get_results_by_game_id(self, game_id: str) -> List[GameResult]:
-        all_results = self.load_all_results()
-        matching = [
-            GameResult.from_dict(r)
-            for r in all_results
-            if r.get("game_id") == game_id
-        ]
-        return sorted(matching, key=lambda x: x.score, reverse=True)
-
-    def _update_highscores(self, result: GameResult) -> None:
-        highscores = self.load_highscores()
-        entry = HighScoreEntry(
-            player_name=result.player_name or "Anonymous",
-            score=result.score,
-            tier=result.tier,
-            wordlist=result.wordlist,
-            game_mode=result.game_mode,
-            elapsed_seconds=result.elapsed_seconds,
-            completed_at=result.completed_at,
-            game_id=result.game_id
-        )
-        highscores.append(entry.to_dict())
-        highscores.sort(key=lambda x: x["score"], reverse=True)
-        highscores = highscores[:100]
-        with open(self.highscores_file, 'w', encoding='utf-8') as f:
-            json.dump(highscores, f, indent=2, ensure_ascii=False)
-
-    def load_highscores(
-        self,
-        wordlist: Optional[str] = None,
-        game_mode: Optional[str] = None,
-        limit: int = 10
-    ) -> List[HighScoreEntry]:
-        if not self.highscores_file.exists():
-            return []
-        try:
-            with open(self.highscores_file, 'r', encoding='utf-8') as f:
-                scores = json.load(f)
-            if wordlist:
-                scores = [s for s in scores if s.get("wordlist") == wordlist]
-            if game_mode:
-                scores = [s for s in scores if s.get("game_mode") == game_mode]
-            scores.sort(key=lambda x: x["score"], reverse=True)
-            return [HighScoreEntry.from_dict(s) for s in scores[:limit]]
-        except Exception as e:
-            print(f"Error loading highscores: {e}")
-            return []
-
-    def get_player_stats(self, player_name: str) -> Dict[str, Any]:
-        all_results = self.load_all_results()
-        player_results = [
-            GameResult.from_dict(r)
-            for r in all_results
-            if r.get("player_name") == player_name
-        ]
-        if not player_results:
-            return {
-                "games_played": 0,
-                "total_score": 0,
-                "average_score": 0,
-                "best_score": 0,
-                "best_tier": None
-            }
-        scores = [r.score for r in player_results]
-        return {
-            "games_played": len(player_results),
-            "total_score": sum(scores),
-            "average_score": sum(scores) / len(scores),
-            "best_score": max(scores),
-            "best_tier": max(player_results, key=lambda x: x.score).tier,
-            "fastest_time": min(r.elapsed_seconds for r in player_results)
-        }
-
-def save_json_to_file(data: dict, directory: str, filename: str = "settings.json") -> str:
-    """
-    Save a dictionary as a JSON file with a specified filename in the given directory.
-    Returns the full path to the saved file.
-    """
-    os.makedirs(directory, exist_ok=True)
-    file_path = os.path.join(directory, filename)
-    with open(file_path, "w", encoding="utf-8") as f:
-        json.dump(data, f, indent=2, ensure_ascii=False)
-    return file_path
-
-def generate_game_id_from_words(words: List[str]) -> str:
-    import hashlib
-    sorted_words = sorted([w.upper() for w in words])
-    word_string = "".join(sorted_words)
-    hash_obj = hashlib.sha256(word_string.encode('utf-8'))
-    return hash_obj.hexdigest()[:8].upper()
-
-def parse_game_id_from_url() -> Optional[str]:
-    try:
-        import streamlit as st
-        params = st.query_params
-        return params.get("game_id")
-    except Exception:
-        return None
-
-def create_shareable_url(game_id: str, base_url: Optional[str] = None) -> str:
-    if base_url is None:
-        base_url = "https://huggingface.co/spaces/Surn/BattleWords"
-    return f"{base_url}?game_id={game_id}"

battlewords/modules/__init__.py

@@ -23,18 +23,6 @@ from .constants import (
     doc_extensions_list
 )
 
-from .file_utils import (
-    get_file_parts,
-    rename_file_to_lowercase_extension,
-    get_filename,
-    convert_title_to_filename,
-    get_filename_from_filepath,
-    delete_file,
-    get_unique_file_path,
-    download_and_save_image,
-    download_and_save_file
-)
-
 __all__ = [
     # constants.py
     'APP_SETTINGS',

battlewords/modules/file_utils.py

@@ -1,204 +0,0 @@
-# file_utils
-import os
-import shutil
-from pathlib import Path
-import requests
-from PIL import Image
-from io import BytesIO
-from urllib.parse import urlparse
-
-def get_file_parts(file_path: str):
-    # Split the path into directory and filename
-    directory, filename = os.path.split(file_path)
-    
-    # Split the filename into name and extension
-    name, ext = os.path.splitext(filename)
-    
-    # Convert the extension to lowercase
-    new_ext = ext.lower()
-    return directory, filename, name, ext, new_ext
-
-def rename_file_to_lowercase_extension(file_path: str) -> str:
-    """
-    Renames a file's extension to lowercase in place.
-
-    Parameters:
-        file_path (str): The original file path.
-
-    Returns:
-        str: The new file path with the lowercase extension.
-
-    Raises:
-        OSError: If there is an error renaming the file (e.g., file not found, permissions issue).
-    """
-    directory, filename, name, ext, new_ext = get_file_parts(file_path)
-    # If the extension changes, rename the file
-    if ext != new_ext:
-        new_filename = name + new_ext
-        new_file_path = os.path.join(directory, new_filename)
-        try:
-            os.rename(file_path, new_file_path)
-            print(f"Rename {file_path} to {new_file_path}\n")
-        except Exception as e:
-            print(f"os.rename failed: {e}. Falling back to binary copy operation.")
-            try:
-                # Read the file in binary mode and write it to new_file_path
-                with open(file_path, 'rb') as f:
-                    data = f.read()
-                with open(new_file_path, 'wb') as f:
-                    f.write(data)
-                    print(f"Copied {file_path} to {new_file_path}\n")
-                # Optionally, remove the original file after copying
-                #os.remove(file_path)
-            except Exception as inner_e:
-                print(f"Failed to copy file from {file_path} to {new_file_path}: {inner_e}")
-                raise inner_e
-        return new_file_path
-    else:
-        return file_path
-
-def get_filename(file):
-    # extract filename from file object
-    filename = None
-    if file is not None:
-        filename = file.name
-    return filename
-
-def convert_title_to_filename(title):
-    # convert title to filename
-    filename = title.lower().replace(" ", "_").replace("/", "_")
-    return filename
-
-def get_filename_from_filepath(filepath):
-    file_name = os.path.basename(filepath)
-    file_base, file_extension = os.path.splitext(file_name)
-    return file_base, file_extension
-
-def delete_file(file_path: str) -> None:
-    """
-    Deletes the specified file.
-
-    Parameters:
-        file_path (str): The path to thefile to delete.
-
-    Raises:
-        FileNotFoundError: If the file does not exist.
-        Exception: If there is an error deleting the file.
-    """
-    try:
-        path = Path(file_path)
-        path.unlink()
-        print(f"Deleted original file: {file_path}")
-    except FileNotFoundError:
-        print(f"File not found: {file_path}")
-    except Exception as e:
-        print(f"Error deleting file: {e}")
-
-def get_unique_file_path(directory, filename, file_ext, counter=0):
-    """
-    Recursively increments the filename until a unique path is found.
-    
-    Parameters:
-        directory (str): The directory for the file.
-        filename (str): The base filename.
-        file_ext (str): The file extension including the leading dot.
-        counter (int): The current counter value to append.
-        
-    Returns:
-        str: A unique file path that does not exist.
-    """
-    if counter == 0:
-        filepath = os.path.join(directory, f"{filename}{file_ext}")
-    else:
-        filepath = os.path.join(directory, f"{filename}{counter}{file_ext}")
-
-    if not os.path.exists(filepath):
-        return filepath
-    else:
-        return get_unique_file_path(directory, filename, file_ext, counter + 1)
-
-# Example usage:
-# new_file_path = get_unique_file_path(video_dir, title_file_name, video_new_ext)
-
-def download_and_save_image(url: str, dst_folder: Path, token: str = None) -> Path:
-    """
-    Downloads an image from a URL with authentication if a token is provided,
-    verifies it with PIL, and saves it in dst_folder with a unique filename.
-
-    Args:
-        url (str): The image URL.
-        dst_folder (Path): The destination folder for the image.
-        token (str, optional): A valid Bearer token. If not provided, the HF_API_TOKEN
-                              environment variable is used if available.
-
-    Returns:
-        Path: The saved image's file path.
-    """
-    headers = {}
-    # Use provided token; otherwise, fall back to environment variable.
-    api_token = token
-    if api_token:
-        headers["Authorization"] = f"Bearer {api_token}"
-    
-    response = requests.get(url, headers=headers)
-    response.raise_for_status()
-    pil_image = Image.open(BytesIO(response.content))
-    
-    parsed_url = urlparse(url)
-    original_filename = os.path.basename(parsed_url.path)  # e.g., "background.png"
-    base, ext = os.path.splitext(original_filename)
-    
-    # Use get_unique_file_path from file_utils.py to generate a unique file path.
-    unique_filepath_str = get_unique_file_path(str(dst_folder), base, ext)
-    dst = Path(unique_filepath_str)
-    dst_folder.mkdir(parents=True, exist_ok=True)
-    pil_image.save(dst)
-    return dst
-
-def download_and_save_file(url: str, dst_folder: Path, token: str = None) -> Path:
-    """
-    Downloads a binary file (e.g., audio or video) from a URL with authentication if a token is provided,
-    and saves it in dst_folder with a unique filename.
-
-    Args:
-        url (str): The file URL.
-        dst_folder (Path): The destination folder for the file.
-        token (str, optional): A valid Bearer token.
-
-    Returns:
-        Path: The saved file's path.
-    """
-    headers = {}
-    if token:
-        headers["Authorization"] = f"Bearer {token}"
-    
-    response = requests.get(url, headers=headers)
-    response.raise_for_status()
-    
-    parsed_url = urlparse(url)
-    original_filename = os.path.basename(parsed_url.path)
-    base, ext = os.path.splitext(original_filename)
-    
-    unique_filepath_str = get_unique_file_path(str(dst_folder), base, ext)
-    dst = Path(unique_filepath_str)
-    dst_folder.mkdir(parents=True, exist_ok=True)
-    
-    with open(dst, "wb") as f:
-        f.write(response.content)
-    
-    return dst
-
-
-if __name__ == "__main__":
-    # Example usage
-    url = "https://example.com/image.png"
-    dst_folder = Path("downloads")
-    download_and_save_image(url, dst_folder)
-    # Example usage for file download
-    file_url = "https://example.com/file.mp3"
-    downloaded_file = download_and_save_file(file_url, dst_folder)
-    print(f"File downloaded to: {downloaded_file}")
-    # Example usage for renaming file extension
-    file_path = "example.TXT"
-    new_file_path = rename_file_to_lowercase_extension(file_path)
-    print(f"Renamed file to: {new_file_path}")

battlewords/settings_page.py

@@ -1,304 +0,0 @@
-from __future__ import annotations
-
-import os
-import time
-from typing import Any, Callable, Dict
-
-import streamlit as st
-
-from .local_storage import load_latest_settings, save_active_settings
-from battlewords.modules.version_info import versions_html  # version info footer
-from .generator import sort_word_file, filter_word_file
-from .audio import get_audio_tracks, _inject_audio_control_sync, get_sound_effect_files
-from .generator import sort_word_file
-from .word_loader import get_wordlist_files
-
-
-_PERSISTED_SETTING_KEYS: tuple[str, ...] = (
-    "game_mode",
-    "selected_wordlist",
-    "show_grid_ticks",
-    "spacer",
-    "show_incorrect_guesses",
-    "show_challenge_share_links",
-    "music_enabled",
-    "music_volume",
-    "effects_volume",
-    "enable_sound_effects",
-    "music_track_path",
-    "user_id",
-    "subscription_level",
-    "player_name",
-)
-
-
-def _load_settings_into_session(settings: Dict[str, Any]) -> bool:
-    """Load a settings dict into `st.session_state`.
-
-    Args:
-        settings: Settings values.
-
-    Returns:
-        bool: True if any session value changed.
-    """
-    changed = False
-    for key, value in settings.items():
-        if st.session_state.get(key) != value:
-            st.session_state[key] = value
-            changed = True
-    return changed
-
-
-def _sort_wordlist(filename: str, new_game_callback: Callable[[], None]) -> None:
-
-    words_dir = os.path.join(os.path.dirname(__file__), "words")
-    filepath = os.path.join(words_dir, filename)
-    sorted_words = sort_word_file(filepath)
-
-    with open(filepath, "w", encoding="utf-8") as f:
-        f.write("# Optional: place a large A-Z word list here (one word per line).\n")
-        f.write("# The app falls back to built-in pools if fewer than 500 words per length are found.\n")
-        for word in sorted_words:
-            f.write(f"{word}\n")
-
-    st.success(f"{filename} sorted by length and alphabetically. Starting new game in 5 seconds...")
-    time.sleep(5)
-    new_game_callback()
-
-
-def _filter_wordlist(filename: str) -> None:
-    words_dir = os.path.join(os.path.dirname(__file__), "words")
-    filepath = os.path.join(words_dir, filename)
-
-    try:
-        with open(filepath, "r", encoding="utf-8") as f:
-            lines = f.readlines()
-    except Exception as exc:
-        st.error(f"Failed to read wordlist: {exc}")
-        return
-
-    header_lines = [ln for ln in lines if ln.strip().startswith("#")]
-    word_lines = [ln.strip() for ln in lines if ln.strip() and not ln.strip().startswith("#")]
-
-    # Keep only A-Z words, uppercase, lengths 4-6; dedupe while preserving order
-    kept: list[str] = []
-    seen: set[str] = set()
-    removed_count = 0
-    for raw in word_lines:
-        w = raw.strip().upper()
-        if not w.isalpha() or not w.isascii():
-            removed_count += 1
-            continue
-        if len(w) not in (4, 5, 6):
-            removed_count += 1
-            continue
-        if w in seen:
-            removed_count += 1
-            continue
-        seen.add(w)
-        kept.append(w)
-
-    with open(filepath, "w", encoding="utf-8") as f:
-        if header_lines:
-            for ln in header_lines:
-                f.write(ln if ln.endswith("\n") else ln + "\n")
-        else:
-            f.write("# Optional: place a large A-Z word list here (one word per line).\n")
-            f.write("# The app falls back to built-in pools if fewer than 500 words per length are found.\n")
-        for w in kept:
-            f.write(f"{w}\n")
-
-    st.success(
-        f"Filtered wordlist '{filename}': removed {removed_count} invalid/duplicate/out-of-range entries."
-    )
-
-
-def render_settings_page(new_game_callback: Callable[[], None]) -> None:
-    """Render the Settings page.
-
-    This is a minimal port of Wrdler's dedicated settings page concept.
-    BattleWords previously used sidebar controls; this page persists preferences
-    locally and applies them by starting a new game.
-
-    Args:
-        new_game_callback: Callback that clears challenge state (if any) and
-            starts a new game with the updated settings.
-    """
-    st.markdown('<div id="settings"></div>', unsafe_allow_html=True)
-    st.header("Settings")
-
-    if not st.session_state.get("_settings_first_load", False):
-        latest = load_latest_settings()
-        if latest:
-            if _load_settings_into_session(latest):
-                st.session_state["_settings_first_load"] = True
-                st.rerun()
-        st.session_state["_settings_first_load"] = True
-
-    st.subheader("Game")
-
-    game_modes = ["classic", "too easy"]
-    if "game_mode" not in st.session_state:
-        st.session_state.game_mode = "classic"
-
-    st.selectbox(
-        "Game mode",
-        options=game_modes,
-        index=game_modes.index(st.session_state.game_mode)
-        if st.session_state.game_mode in game_modes
-        else 0,
-        key="game_mode",
-    )
-
-    st.subheader("Wordlist Controls")
-
-    files = get_wordlist_files()
-    if files and "selected_wordlist" not in st.session_state:
-        st.session_state.selected_wordlist = "classic.txt" if "classic.txt" in files else files[0]
-
-    if files:
-        st.selectbox(
-            "Select wordlist",
-            options=files,
-            index=files.index(st.session_state.selected_wordlist)
-            if st.session_state.selected_wordlist in files
-            else 0,
-            key="selected_wordlist",
-        )
-
-        col_sort, col_filter = st.columns(2)
-        with col_sort:
-            if st.button("Sort Wordlist", key="sort_wordlist_btn", width=125):
-                _sort_wordlist(st.session_state.selected_wordlist, new_game_callback)
-        with col_filter:
-            if st.button("Filter Wordlist", key="filter_wordlist_btn", width=125):
-                _filter_wordlist(st.session_state.selected_wordlist)
-    else:
-        st.info("No word lists found in words/ directory.")
-
-    if "show_grid_ticks" not in st.session_state:
-        st.session_state.show_grid_ticks = False
-    st.checkbox("Show grid ticks", key="show_grid_ticks")
-
-    spacer_options = [0, 1, 2]
-    if "spacer" not in st.session_state:
-        st.session_state.spacer = 1
-    st.selectbox(
-        "Spacer (space between words)",
-        options=spacer_options,
-        index=spacer_options.index(st.session_state.spacer)
-        if st.session_state.spacer in spacer_options
-        else 1,
-        key="spacer",
-    )
-
-    if "show_incorrect_guesses" not in st.session_state:
-        st.session_state.show_incorrect_guesses = True
-    st.checkbox("Show incorrect guesses", key="show_incorrect_guesses")
-
-    if "show_challenge_share_links" not in st.session_state:
-        st.session_state.show_challenge_share_links = False
-    st.checkbox("Show challenge share links", key="show_challenge_share_links")
-
-    # Audio settings
-    st.header("Audio")
-
-    # --- List sound effects in effects folder ---
-    effects = get_sound_effect_files()
-    if effects:
-        effect_list = ", ".join(sorted(effects.keys()))
-        st.caption(f"Sound effects found in wrdler/assets/audio/effects: {effect_list}")
-    else:
-        st.caption("No sound effects found in wrdler/assets/audio/effects.")
-
-    if "music_enabled" not in st.session_state:
-        st.session_state.music_enabled = False
-    if "music_volume" not in st.session_state:
-        st.session_state.music_volume = 15
-
-    if "enable_sound_effects" not in st.session_state:
-        st.session_state.enable_sound_effects = True
-    st.checkbox("Enable sound effects", key="enable_sound_effects")
-
-    if "effects_volume" not in st.session_state:
-        st.session_state.effects_volume = 25
-    st.slider(
-        "Sound effects volume",
-        0,
-        100,
-        value=int(st.session_state.effects_volume),
-        step=1,
-        key="effects_volume",
-    )
-
-    tracks = get_audio_tracks()
-    st.caption(f"{len(tracks)} audio file{'s' if len(tracks) != 1 else ''} found in wrdler/assets/audio/music")
-
-    enabled = st.checkbox("Enable music", value=st.session_state.music_enabled, key="music_enabled")
-
-    st.slider(
-        "Volume",
-        0,
-        100,
-        value=int(st.session_state.music_volume),
-        step=1,
-        key="music_volume",
-        disabled=not (enabled and bool(tracks)),
-    )
-
-    selected_path = None
-    if tracks:
-        options = [p for _, p in tracks]
-        # Default to first track if none chosen yet
-        if "music_track_path" not in st.session_state or st.session_state.music_track_path not in options:
-            st.session_state.music_track_path = options[0]
-
-        def _fmt(p: str) -> str:
-            # Find friendly label for path
-            for name, path in tracks:
-                if path == p:
-                    return name
-            return os.path.splitext(os.path.basename(p))[0]
-
-        selected_path = st.selectbox(
-            "Track",
-            options=options,
-            index=options.index(st.session_state.music_track_path),
-            format_func=_fmt,
-            key="music_track_path",
-            disabled=not enabled,
-        )
-    else:
-        st.caption("Place .mp3 files in wrdler/assets/audio/music to enable music.")
-
-    st.markdown("---")
-
-    col_apply, col_reset = st.columns(2)
-
-    with col_apply:
-        if st.button("Save & Apply", key="settings_save_apply_btn", width="stretch"):
-            snapshot = {key: st.session_state.get(key) for key in _PERSISTED_SETTING_KEYS}
-            save_active_settings(snapshot)
-            st.session_state["_settings_saved_notice"] = "Settings saved."
-            new_game_callback()
-            try:
-                st.query_params["page"] = "play"
-            except Exception:
-                pass
-            st.rerun()
-
-    with col_reset:
-        if st.button("Discard changes", key="settings_discard_btn", width="stretch"):
-            latest = load_latest_settings()
-            if latest:
-                _load_settings_into_session(latest)
-            st.rerun()
-
-    notice = st.session_state.pop("_settings_saved_notice", None)
-    if notice:
-        st.success(notice)
-
-    settings_dir = os.path.join(os.path.dirname(__file__), "settings")
-    st.caption(f"Settings are stored locally under: {settings_dir}")
-
-    st.markdown(versions_html(), unsafe_allow_html=True)

battlewords/sounds.py

@@ -1,195 +0,0 @@
-# file: battlewords/sounds.py
-
-import os
-import tempfile
-import base64
-import requests
-import time
-from io import BytesIO
-from pathlib import Path
-
-# Load environment variables from .env file
-def _load_env():
-    """Load .env file from project root"""
-    env_path = Path(__file__).parent.parent / ".env"
-    if env_path.exists():
-        with open(env_path) as f:
-            for line in f:
-                line = line.strip()
-                if line and not line.startswith("#") and "=" in line:
-                    key, value = line.split("=", 1)
-                    os.environ.setdefault(key.strip(), value.strip())
-
-_load_env()
-
-# Predefined prompts for sound effects: key: {"prompt": text, "duration": seconds}
-EFFECT_PROMPTS = {
-    "correct_guess": {"prompt": "A short, sharp ding sound for a correct guess", "duration": 2},
-    "incorrect_guess": {"prompt": "A low buzz sound for an incorrect guess", "duration": 2},
-    "miss": {"prompt": "A soft thud sound for a miss", "duration": 1},
-    "hit": {"prompt": "A bright chime sound for a hit", "duration": 1},
-    "congratulations": {"prompt": "A triumphant fanfare sound for congratulations", "duration": 3}
-}
-
-_sound_cache = {}
-
-# Hugging Face Inference API configuration
-# Loaded from .env file or environment variable: HF_API_TOKEN
-HF_API_TOKEN = os.environ.get("HF_API_TOKEN", None)
-if HF_API_TOKEN:
-    print(f"Using HF_API_TOKEN: {HF_API_TOKEN[:10]}...")
-HF_API_URL = "https://api-inference.huggingface.co/models/facebook/audiogen-medium"
-
-def generate_sound_effect(effect: str, save_to_assets: bool = False, use_api: str = "huggingface") -> str:
-    """
-    Generate a sound effect using external API based on the effect string.
-    Returns the path to the generated audio file.
-
-    Args:
-        effect: Name of the effect (must be in EFFECT_PROMPTS)
-        save_to_assets: If True, save to battlewords/assets/audio/effects/ instead of temp directory
-        use_api: API to use - "huggingface" (default) or "replicate"
-    """
-    if effect not in EFFECT_PROMPTS:
-        raise ValueError(f"Unknown effect: {effect}. Available effects: {list(EFFECT_PROMPTS.keys())}")
-
-    # Check cache first (only for temp files)
-    if effect in _sound_cache and not save_to_assets:
-        if os.path.exists(_sound_cache[effect]):
-            return _sound_cache[effect]
-
-    effect_config = EFFECT_PROMPTS[effect]
-    prompt = effect_config["prompt"]
-    duration = effect_config["duration"]
-
-    print(f"Generating sound effect: {effect}")
-    print(f"  Prompt: {prompt}")
-    print(f"  Duration: {duration}s")
-    print(f"  Using API: {use_api}")
-
-    audio_bytes = None
-
-    if use_api == "huggingface":
-        audio_bytes = _generate_via_huggingface(prompt, duration)
-    else:
-        raise ValueError(f"Unknown API: {use_api}")
-
-    if audio_bytes is None:
-        raise RuntimeError(f"Failed to generate sound effect: {effect}")
-
-    # Determine save location
-    if save_to_assets:
-        # Save to effects assets directory (preferred by audio.py)
-        assets_dir = os.path.join(os.path.dirname(__file__), "assets", "audio", "effects")
-        os.makedirs(assets_dir, exist_ok=True)
-        filename = f"{effect}.wav"
-        path = os.path.join(assets_dir, filename)
-        with open(path, "wb") as f:
-            f.write(audio_bytes)
-        print(f"  Saved to: {path}")
-    else:
-        # Save to temporary file
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmpfile:
-            tmpfile.write(audio_bytes)
-            path = tmpfile.name
-            print(f"  Saved to: {path}")
-
-    # Cache the path
-    _sound_cache[effect] = path
-    return path
-
-def _generate_via_huggingface(prompt: str, duration: float, max_retries: int = 3) -> bytes:
-    """
-    Generate audio using Hugging Face Inference API.
-    Uses facebook/audiogen-medium model for sound effects.
-    """
-    headers = {}
-    if HF_API_TOKEN:
-        headers["Authorization"] = f"Bearer {HF_API_TOKEN}"
-
-    payload = {
-        "inputs": prompt,
-        "parameters": {
-            "duration": duration
-        }
-    }
-
-    for attempt in range(max_retries):
-        try:
-            print(f"  Calling Hugging Face API (attempt {attempt + 1}/{max_retries})...")
-            response = requests.post(HF_API_URL, headers=headers, json=payload, timeout=60)
-
-            if response.status_code == 503:
-                # Model is loading, wait and retry
-                print(f"  Model loading, waiting 10 seconds...")
-                time.sleep(10)
-                continue
-
-            if response.status_code == 200:
-                print(f"  Success! Received {len(response.content)} bytes")
-                return response.content
-            else:
-                print(f"  Error {response.status_code}: {response.text}")
-                if attempt < max_retries - 1:
-                    time.sleep(5)
-                    continue
-                else:
-                    raise RuntimeError(f"API request failed: {response.status_code} - {response.text}")
-
-        except requests.exceptions.Timeout:
-            print(f"  Request timed out")
-            if attempt < max_retries - 1:
-                time.sleep(5)
-                continue
-            else:
-                raise RuntimeError("API request timed out after multiple attempts")
-        except Exception as e:
-            print(f"  Error: {e}")
-            if attempt < max_retries - 1:
-                time.sleep(5)
-                continue
-            else:
-                raise
-
-    return None
-
-def get_sound_effect_path(effect: str) -> str:
-    """
-    Get the path to a sound effect, generating it if necessary.
-    """
-    return generate_sound_effect(effect)
-
-def get_sound_effect_data_url(effect: str) -> str:
-    """
-    Get a data URL for the sound effect, suitable for embedding in HTML.
-    """
-    path = generate_sound_effect(effect)
-    with open(path, "rb") as f:
-        data = f.read()
-    encoded = base64.b64encode(data).decode()
-    return f"data:audio/wav;base64,{encoded}"
-
-def generate_all_effects(save_to_assets: bool = True):
-    """
-    Generate all sound effects defined in EFFECT_PROMPTS.
-
-    Args:
-        save_to_assets: If True, save to battlewords/assets/audio/effects/ directory
-    """
-    print(f"\nGenerating {len(EFFECT_PROMPTS)} sound effects...")
-    print("=" * 60)
-
-    for effect_name in EFFECT_PROMPTS.keys():
-        try:
-            generate_sound_effect(effect_name, save_to_assets=save_to_assets)
-            print()
-        except Exception as e:
-            print(f"ERROR generating {effect_name}: {e}")
-            print()
-
-    print("=" * 60)
-    print("Sound effect generation complete!")
-
-if __name__ == "__main__":
-    # Generate all sound effects when run as a script
-    generate_all_effects(save_to_assets=True)