Spaces:

Surn
/

BattleWords

Running

Surn commited on 23 days ago

Commit

1b1b6cc

1 Parent(s): 2de3d96

0.2.29

- change difficulty calculation
- add test_compare_difficulty_functions
- streamlit version update
- fix hugging face share link

Files changed (17) hide show

.streamlit/config.toml +3 -0
Dockerfile +6 -0
README.md +6 -1
battlewords/__init__.py +1 -1
battlewords/game_storage.py +6 -5
battlewords/ui.py +90 -14
battlewords/word_loader.py +177 -1
claude.md +1 -1
inject-pwa-head.sh +49 -0
pwa-head-inject.html +8 -0
pyproject.toml +2 -2
{battlewords/static → static}/icon-192.png +0 -0
{battlewords/static → static}/icon-512.png +0 -0
{battlewords/static → static}/manifest.json +27 -27
{battlewords/static → static}/service-worker.js +99 -99
tests/test_compare_difficulty_functions.py +237 -0
tests/test_generator.py +7 -2

.streamlit/config.toml CHANGED Viewed

@@ -1,3 +1,6 @@
 [theme]
 base="dark"
 primaryColor="#1d64c8"

+[server]
+enableStaticServing = true
 [theme]
 base="dark"
 primaryColor="#1d64c8"

Dockerfile CHANGED Viewed

@@ -39,9 +39,15 @@ RUN python -m pip install --upgrade pip setuptools wheel
 COPY requirements.txt ./
 RUN pip3 install -r requirements.txt
 # Copy application source
 COPY app.py ./app.py
 COPY battlewords ./battlewords
 # Hugging Face Spaces sets $PORT (default 7860). Expose it for clarity. using 8501 for local consistency with Streamlit defaults

 COPY requirements.txt ./
 RUN pip3 install -r requirements.txt
+# Copy PWA injection files
+COPY pwa-head-inject.html ./pwa-head-inject.html
+COPY inject-pwa-head.sh ./inject-pwa-head.sh
+RUN chmod +x ./inject-pwa-head.sh && ./inject-pwa-head.sh
 # Copy application source
 COPY app.py ./app.py
 COPY battlewords ./battlewords
+COPY static ./static
 # Hugging Face Spaces sets $PORT (default 7860). Expose it for clarity. using 8501 for local consistency with Streamlit defaults

README.md CHANGED Viewed

@@ -4,7 +4,7 @@ emoji: 🎲
 colorFrom: blue
 colorTo: indigo
 sdk: streamlit
-sdk_version: 1.50.0
 python_version: 3.12.8
 app_port: 8501
 app_file: app.py
@@ -187,6 +187,11 @@ CRYPTO_PK=                             # Reserved for future signing
  - Personal high scores sidebar with filtering
  - Player statistics tracking (games played, averages, bests)
 -0.2.28
  - PWA INSTALL_GUIDE.md added
  - PWA implementation with service worker and manifest.json added

 colorFrom: blue
 colorTo: indigo
 sdk: streamlit
+sdk_version: 1.51.0
 python_version: 3.12.8
 app_port: 8501
 app_file: app.py
  - Personal high scores sidebar with filtering
  - Player statistics tracking (games played, averages, bests)
+-0.2.29
+ - change difficulty calculation
+ - add test_compare_difficulty_functions
+ - streamlit version update to 1.51.0
 -0.2.28
  - PWA INSTALL_GUIDE.md added
  - PWA implementation with service worker and manifest.json added

battlewords/__init__.py CHANGED Viewed

	@@ -1,2 +1,2 @@
1	- __version__ = "0.2.28"
2	__all__ = ["models", "generator", "logic", "ui", "game_storage"]


1	+ __version__ = "0.2.29"
2	__all__ = ["models", "generator", "logic", "ui", "game_storage"]

battlewords/game_storage.py CHANGED Viewed

@@ -497,11 +497,12 @@ def get_shareable_url(sid: str, base_url: str = None) -> str:
         sep = '&' if '?' in base_url else '?'
         return f"{base_url}{sep}game_id={sid}"
-    # 2) Check for local development (common Streamlit env vars)
-    port = os.environ.get("PORT") or os.environ.get("STREAMLIT_SERVER_PORT") or "8501"
-    host = os.environ.get("HOST") or os.environ.get("STREAMLIT_SERVER_ADDRESS") or "localhost"
-    if host in ("localhost", "127.0.0.1") or os.environ.get("IS_LOCAL", "").lower() == "true":
-        return f"http://{host}:{port}/?game_id={sid}"
     # 3) Otherwise, build HuggingFace Space URL from SPACE_NAME
     space = (SPACE_NAME or "surn/battlewords").lower().replace("/", "-")

         sep = '&' if '?' in base_url else '?'
         return f"{base_url}{sep}game_id={sid}"
+    if os.environ.get("IS_LOCAL", "true").lower() == "true":
+        # 2) Check for local development (common Streamlit env vars)
+        port = os.environ.get("PORT") or os.environ.get("STREAMLIT_SERVER_PORT") or "8501"
+        host = os.environ.get("HOST") or os.environ.get("STREAMLIT_SERVER_ADDRESS") or "localhost"
+        if host in ("localhost", "127.0.0.1") or os.environ.get("IS_LOCAL", "").lower() == "true":
+            return f"http://{host}:{port}/?game_id={sid}"
     # 3) Otherwise, build HuggingFace Space URL from SPACE_NAME
     space = (SPACE_NAME or "surn/battlewords").lower().replace("/", "-")

battlewords/ui.py CHANGED Viewed

@@ -33,25 +33,99 @@ st.set_page_config(initial_sidebar_state="collapsed")
 # PWA (Progressive Web App) Support
 # Enables installing BattleWords as a native-feeling mobile app
-pwa_meta_tags = """
-<link rel="manifest" href="/app/static/manifest.json">
-<meta name="theme-color" content="#165ba8">
-<meta name="apple-mobile-web-app-capable" content="yes">
-<meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
-<meta name="apple-mobile-web-app-title" content="BattleWords">
-<link rel="apple-touch-icon" href="/app/static/icon-192.png">
-<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
-<meta name="mobile-web-app-capable" content="yes">
 <script>
 // Register service worker for offline functionality
 if ('serviceWorker' in navigator) {
   window.addEventListener('load', () => {
-    navigator.serviceWorker.register('/app/static/service-worker.js')
       .then(registration => {
         console.log('[PWA] Service Worker registered successfully:', registration.scope);
-        // Check for updates periodically
         registration.addEventListener('updatefound', () => {
           const newWorker = registration.installing;
           newWorker.addEventListener('statechange', () => {
@@ -83,7 +157,6 @@ window.addEventListener('appinstalled', () => {
 });
 </script>
 """
-st.markdown(pwa_meta_tags, unsafe_allow_html=True)
 CoordLike = Tuple[int, int]
@@ -397,7 +470,7 @@ def inject_styles() -> None:
              max-width:100%;
           }
          .stImage {max-width:300px;}
-         #text_input_3,#text_input_1 {
           background-color:#fff;
           color:#000;
           caret-color:#333;}
@@ -1808,6 +1881,9 @@ def _render_game_over(state: GameState):
                     _mount_background_audio(False, None, 0.0)
 def run_app():
     # Handle query params using new API
     try:
         params = st.query_params

 # PWA (Progressive Web App) Support
 # Enables installing BattleWords as a native-feeling mobile app
+# Note: PWA meta tags are injected into <head> via Docker build (inject-pwa-head.sh)
+# This ensures proper PWA detection by browsers
+pwa_service_worker = """
 <script>
 // Register service worker for offline functionality
+// Note: Using inline Blob URL to bypass Streamlit's text/plain content-type for .js files
 if ('serviceWorker' in navigator) {
   window.addEventListener('load', () => {
+    // Service worker code as string (inline to avoid MIME type issues)
+    const swCode = `
+const CACHE_NAME = 'battlewords-v0.2.29';
+const RUNTIME_CACHE = 'battlewords-runtime';
+const PRECACHE_URLS = [
+  '/',
+  '/app/static/manifest.json',
+  '/app/static/icon-192.png',
+  '/app/static/icon-512.png'
+];
+self.addEventListener('install', event => {
+  console.log('[ServiceWorker] Installing...');
+  event.waitUntil(
+    caches.open(CACHE_NAME)
+      .then(cache => {
+        console.log('[ServiceWorker] Precaching app shell');
+        return cache.addAll(PRECACHE_URLS);
+      })
+      .then(() => self.skipWaiting())
+  );
+});
+self.addEventListener('activate', event => {
+  console.log('[ServiceWorker] Activating...');
+  event.waitUntil(
+    caches.keys().then(cacheNames => {
+      return Promise.all(
+        cacheNames.map(cacheName => {
+          if (cacheName !== CACHE_NAME && cacheName !== RUNTIME_CACHE) {
+            console.log('[ServiceWorker] Deleting old cache:', cacheName);
+            return caches.delete(cacheName);
+          }
+        })
+      );
+    }).then(() => self.clients.claim())
+  );
+});
+self.addEventListener('fetch', event => {
+  if (event.request.method !== 'GET') return;
+  if (!event.request.url.startsWith('http')) return;
+  event.respondWith(
+    caches.open(RUNTIME_CACHE).then(cache => {
+      return fetch(event.request)
+        .then(response => {
+          if (response.status === 200) {
+            cache.put(event.request, response.clone());
+          }
+          return response;
+        })
+        .catch(() => {
+          return caches.match(event.request).then(cachedResponse => {
+            if (cachedResponse) {
+              console.log('[ServiceWorker] Serving from cache:', event.request.url);
+              return cachedResponse;
+            }
+            return new Response('Offline - Please check your connection', {
+              status: 503,
+              statusText: 'Service Unavailable',
+              headers: new Headers({'Content-Type': 'text/plain'})
+            });
+          });
+        });
+    })
+  );
+});
+self.addEventListener('message', event => {
+  if (event.data.action === 'skipWaiting') {
+    self.skipWaiting();
+  }
+});
+`;
+    // Create Blob URL for service worker
+    const blob = new Blob([swCode], { type: 'application/javascript' });
+    const swUrl = URL.createObjectURL(blob);
+    navigator.serviceWorker.register(swUrl)
       .then(registration => {
         console.log('[PWA] Service Worker registered successfully:', registration.scope);
         registration.addEventListener('updatefound', () => {
           const newWorker = registration.installing;
           newWorker.addEventListener('statechange', () => {
 });
 </script>
 """
 CoordLike = Tuple[int, int]
              max-width:100%;
           }
          .stImage {max-width:300px;}
+         [id^="text_input"] {
           background-color:#fff;
           color:#000;
           caret-color:#333;}
                     _mount_background_audio(False, None, 0.0)
 def run_app():
+    # Render PWA service worker registration (meta tags in <head> via Docker)
+    st.markdown(pwa_service_worker, unsafe_allow_html=True)
     # Handle query params using new API
     try:
         params = st.query_params

battlewords/word_loader.py CHANGED Viewed

@@ -133,7 +133,7 @@ def load_word_list(selected_file: Optional[str] = None) -> Dict[int, List[str]]:
 # Ensure this function is at module scope (not indented) and import string at top
-def compute_word_difficulties(file_path, words_array=None):
     """
     1. Read and sanitize word list: uppercase A–Z only, skip comments/blank lines.
     2. Count occurrences of each letter across all words (A..Z only).
@@ -145,6 +145,8 @@ def compute_word_difficulties(file_path, words_array=None):
     8. Get count c_w of words with same first/last, uniqueness u_w = 1 / c_w.
     9. Difficulty d_w = [k * (26 - k)] / [(k + 1) * (a_w + u_w)] if denominator != 0, else 0.
     10. Return total difficulty (sum d_w) and dict of {word: d_w}.
     """
     try:
         with open(file_path, 'r', encoding='utf-8') as f:
@@ -210,5 +212,179 @@ def compute_word_difficulties(file_path, words_array=None):
         d_w = 0 if denominator == 0 else (k * (26 - k)) / denominator
         difficulties[w] = d_w
     total_difficulty = sum(difficulties.values())
     return total_difficulty, difficulties

 # Ensure this function is at module scope (not indented) and import string at top
+def compute_word_difficulties3(file_path, words_array=None):
     """
     1. Read and sanitize word list: uppercase A–Z only, skip comments/blank lines.
     2. Count occurrences of each letter across all words (A..Z only).
     8. Get count c_w of words with same first/last, uniqueness u_w = 1 / c_w.
     9. Difficulty d_w = [k * (26 - k)] / [(k + 1) * (a_w + u_w)] if denominator != 0, else 0.
     10. Return total difficulty (sum d_w) and dict of {word: d_w}.
+    Original Version: Battlewords v0.2.24 to 0.2.28
+    2024-06: Updated to handle missing files gracefully and ensure A–Z filtering
     """
     try:
         with open(file_path, 'r', encoding='utf-8') as f:
         d_w = 0 if denominator == 0 else (k * (26 - k)) / denominator
         difficulties[w] = d_w
+    total_difficulty = sum(difficulties.values())
+    return total_difficulty, difficulties
+def compute_word_difficulties2(file_path, words_array=None):
+    """
+    1. Read and sanitize word list: uppercase A–Z only, skip comments/blank lines.
+    2. Compute corpus token frequencies p_l for letters (A..Z) from total occurrences.
+    3. Count words sharing same first/last letters for each pair (start_end_counts).
+    4. If words_array provided, use it (uppercase, A–Z only); else use full list W.
+    5. For each word w: q_l(w) = c_l(w)/len(w). Difficulty = Σ_l q_l(w) * p_l.
+       Optionally scale by (2 - u_w) where u_w = 1 / count(first,last).
+    6. Return total difficulty and per-word difficulties.
+    # Version 2: uses letter occurrence frequencies instead of presence/absence.
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            raw_lines = f.readlines()
+    except Exception:
+        return 0, {}
+    # Sanitize lines similarly to load_word_list()
+    cleaned_words = []
+    for raw in raw_lines:
+        line = raw.strip()
+        if not line or line.startswith("#"):
+            continue
+        if "#" in line:
+            line = line.split("#", 1)[0].strip()
+        word = line.upper()
+        if re.fullmatch(r"[A-Z]+", word):
+            cleaned_words.append(word)
+    W = cleaned_words
+    if not W:
+        return 0, {}
+    # Start/end pair counts (same as before)
+    start_end_counts: Dict[tuple[str, str], int] = {}
+    for w in W:
+        first, last = w[0], w[-1]
+        key = (first, last)
+        start_end_counts[key] = start_end_counts.get(key, 0) + 1
+    # Corpus token frequencies p_l (counts every occurrence, not just presence)
+    token_counts = {l: 0 for l in string.ascii_uppercase}
+    for w in W:
+        for l in w:
+            if l in token_counts:
+                token_counts[l] += 1
+    total_tokens = sum(token_counts.values()) or 1
+    p_l = {l: token_counts[l] / total_tokens for l in string.ascii_uppercase}
+    # Candidate set
+    if words_array is None:
+        words_array = W
+    else:
+        words_array = [
+            w.upper()
+            for w in words_array
+            if re.fullmatch(r"[A-Z]+", w.upper())
+        ]
+    difficulties: Dict[str, float] = {}
+    for w in words_array:
+        m = len(w)
+        if m == 0:
+            continue
+        # q_l(w) from counts within the word (accounts for repeats)
+        counts_in_w: Dict[str, int] = {}
+        for ch in w:
+            if ch in p_l:
+                counts_in_w[ch] = counts_in_w.get(ch, 0) + 1
+        # Base difficulty: alignment with common letters (q · p)
+        commonness = sum((cnt / m) * p_l.get(l, 0.0) for l, cnt in counts_in_w.items())
+        # Optional scaling for common start/end patterns
+        first, last = w[0], w[-1]
+        c_w = start_end_counts.get((first, last), 1)
+        u_w = 1.0 / c_w  # uniqueness
+        d_w = commonness * (2.0 - u_w)
+        difficulties[w] = d_w
+    total_difficulty = sum(difficulties.values())
+    return total_difficulty, difficulties
+def compute_word_difficulties(file_path, words_array=None):
+    """
+    1. Read and sanitize word list: uppercase A–Z only, skip comments/blank lines.
+    2. Count occurrences of each letter across all words (A..Z only).
+    3. Compute frequency f_l = count / n, rarity r_l = 1 - f_l for each letter.
+    4. Count words sharing same first/last letters for each pair.
+    5. If words_array provided, use it (uppercase); else use full list.
+    6. For each word: get unique letters L_w, k = |L_w|.
+    7. Compute weighted average rarity a_w = sum(r_l * count_in_word) / total_letters_in_word.
+    8. Get count c_w of words with same first/last, uniqueness u_w = 1 / c_w.
+    9. Difficulty d_w = [k * (26 - k)] / [(k + 1) * (a_w + u_w)] if denominator != 0, else 0.
+    10. Return total difficulty (sum d_w) and dict of {word: d_w}.
+    VERION 3.0
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            raw_lines = f.readlines()
+    except Exception:
+        return 0, {}
+    # Sanitize lines similarly to load_word_list()
+    cleaned_words = []
+    for raw in raw_lines:
+        line = raw.strip()
+        if not line or line.startswith("#"):
+            continue
+        if "#" in line:
+            line = line.split("#", 1)[0].strip()
+        word = line.upper()
+        # keep only A–Z words
+        if re.fullmatch(r"[A-Z]+", word):
+            cleaned_words.append(word)
+    W = cleaned_words
+    n = len(W)
+    if n == 0:
+        return 0, {}
+    letter_counts = {l: 0 for l in string.ascii_uppercase}
+    start_end_counts = {}
+    for w in W:
+        letters = set(w)
+        # Only count A..Z to avoid KeyError
+        for l in letters:
+            if l in letter_counts:
+                letter_counts[l] += 1
+        first, last = w[0], w[-1]
+        key = (first, last)
+        start_end_counts[key] = start_end_counts.get(key, 0) + 1
+    f_l = {l: count / n for l, count in letter_counts.items()}
+    r_l = {l: 1 - f for l, f in f_l.items()}
+    if words_array is None:
+        words_array = W
+    else:
+        # Ensure A–Z and uppercase for the selection as well
+        words_array = [
+            w.upper()
+            for w in words_array
+            if re.fullmatch(r"[A-Z]+", w.upper())
+        ]
+    difficulties = {}
+    for w in words_array:
+        # Count occurrences of each letter in the word
+        letter_freq = {l: w.count(l) for l in set(w)}
+        # Compute weighted average rarity
+        total_letters = len(w)
+        a_w = sum(r_l.get(l, 0) * freq for l, freq in letter_freq.items()) / total_letters
+        L_w = set(w)
+        k = len(L_w)
+        if k == 0:
+            continue
+        first, last = w[0], w[-1]
+        c_w = start_end_counts.get((first, last), 1)
+        u_w = c_w / 18  # magic number to scale uniqueness based on word lengths
+        denominator = (k + 1) * (a_w + u_w)
+        d_w = 0 if denominator == 0 else (k * (26 - k)) / denominator
+        difficulties[w] = d_w
     total_difficulty = sum(difficulties.values())
     return total_difficulty, difficulties

claude.md CHANGED Viewed

@@ -47,7 +47,7 @@ BattleWords is a vocabulary learning game inspired by Battleship mechanics, buil
 ## Technical Architecture
 ### Technology Stack
-- **Framework:** Streamlit 1.50.0
 - **Language:** Python 3.12.8
 - **Visualization:** Matplotlib, NumPy
 - **Data Processing:** Pandas, Altair

 ## Technical Architecture
 ### Technology Stack
+- **Framework:** Streamlit 1.51.0
 - **Language:** Python 3.12.8
 - **Visualization:** Matplotlib, NumPy
 - **Data Processing:** Pandas, Altair

inject-pwa-head.sh ADDED Viewed

	@@ -0,0 +1,49 @@

+#!/bin/bash
+# Inject PWA meta tags into Streamlit's index.html head section
+# This script modifies the Streamlit index.html during Docker build
+set -e
+echo "[PWA] Injecting PWA meta tags into Streamlit's index.html..."
+# Find Streamlit's index.html
+STREAMLIT_INDEX=$(python3 -c "import streamlit; import os; print(os.path.join(os.path.dirname(streamlit.__file__), 'static', 'index.html'))")
+if [ ! -f "$STREAMLIT_INDEX" ]; then
+    echo "[PWA] ERROR: Streamlit index.html not found at: $STREAMLIT_INDEX"
+    exit 1
+fi
+echo "[PWA] Found Streamlit index.html at: $STREAMLIT_INDEX"
+# Check if already injected (to make script idempotent)
+if grep -q "PWA (Progressive Web App) Meta Tags" "$STREAMLIT_INDEX"; then
+    echo "[PWA] PWA tags already injected, skipping..."
+    exit 0
+fi
+# Read the injection content
+INJECT_FILE="/app/pwa-head-inject.html"
+if [ ! -f "$INJECT_FILE" ]; then
+    echo "[PWA] ERROR: Injection file not found at: $INJECT_FILE"
+    exit 1
+fi
+# Create backup
+cp "$STREAMLIT_INDEX" "${STREAMLIT_INDEX}.backup"
+# Use awk to inject after <head> tag
+awk -v inject_file="$INJECT_FILE" '
+/<head>/ {
+    print
+    while ((getline line < inject_file) > 0) {
+        print line
+    }
+    close(inject_file)
+    next
+}
+{ print }
+' "${STREAMLIT_INDEX}.backup" > "$STREAMLIT_INDEX"
+echo "[PWA] PWA meta tags successfully injected!"
+echo "[PWA] Backup saved as: ${STREAMLIT_INDEX}.backup"

pwa-head-inject.html ADDED Viewed

	@@ -0,0 +1,8 @@

+<!-- PWA (Progressive Web App) Meta Tags -->
+<link rel="manifest" href="/app/static/manifest.json">
+<meta name="theme-color" content="#165ba8">
+<meta name="apple-mobile-web-app-capable" content="yes">
+<meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
+<meta name="apple-mobile-web-app-title" content="BattleWords">
+<link rel="apple-touch-icon" href="/app/static/icon-192.png">
+<meta name="mobile-web-app-capable" content="yes">

pyproject.toml CHANGED Viewed

@@ -1,11 +1,11 @@
 [project]
 name = "battlewords"
-version = "0.2.20"
 description = "BattleWords vocabulary game with game sharing via shortened game_id URL referencing server-side JSON settings"
 readme = "README.md"
 requires-python = ">=3.12,<3.13"
 dependencies = [
-    "streamlit>=1.50.0",
     "matplotlib>=3.8",
     "requests>=2.31.0",
 ]

 [project]
 name = "battlewords"
+version = "0.2.29"
 description = "BattleWords vocabulary game with game sharing via shortened game_id URL referencing server-side JSON settings"
 readme = "README.md"
 requires-python = ">=3.12,<3.13"
 dependencies = [
+    "streamlit>=1.51.0",
     "matplotlib>=3.8",
     "requests>=2.31.0",
 ]

{battlewords/static → static}/icon-192.png RENAMED Viewed

File without changes

{battlewords/static → static}/icon-512.png RENAMED Viewed

File without changes

{battlewords/static → static}/manifest.json RENAMED Viewed

@@ -1,27 +1,27 @@
-{
-  "name": "BattleWords",
-  "short_name": "BattleWords",
-  "description": "Vocabulary learning game inspired by Battleship mechanics. Discover hidden words on a 12x12 grid and earn points for strategic guessing.",
-  "start_url": "/",
-  "scope": "/",
-  "display": "standalone",
-  "orientation": "portrait",
-  "background_color": "#0b2a4a",
-  "theme_color": "#165ba8",
-  "icons": [
-    {
-      "src": "/app/static/icon-192.png",
-      "sizes": "192x192",
-      "type": "image/png",
-      "purpose": "any maskable"
-    },
-    {
-      "src": "/app/static/icon-512.png",
-      "sizes": "512x512",
-      "type": "image/png",
-      "purpose": "any maskable"
-    }
-  ],
-  "categories": ["games", "education"],
-  "screenshots": []
-}

+{
+  "name": "BattleWords",
+  "short_name": "BattleWords",
+  "description": "Vocabulary learning game inspired by Battleship mechanics. Discover hidden words on a 12x12 grid and earn points for strategic guessing.",
+  "start_url": "/",
+  "scope": "/",
+  "display": "standalone",
+  "orientation": "portrait",
+  "background_color": "#0b2a4a",
+  "theme_color": "#165ba8",
+  "icons": [
+    {
+      "src": "/app/static/icon-192.png",
+      "sizes": "192x192",
+      "type": "image/png",
+      "purpose": "any maskable"
+    },
+    {
+      "src": "/app/static/icon-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "any maskable"
+    }
+  ],
+  "categories": ["games", "education"],
+  "screenshots": []
+}

{battlewords/static → static}/service-worker.js RENAMED Viewed

@@ -1,99 +1,99 @@
-/**
- * BattleWords Service Worker
- * Enables PWA functionality: offline caching, install prompt, etc.
- *
- * Security Note: This file contains no secrets or sensitive data.
- * It only caches public assets for offline access.
- */
-const CACHE_NAME = 'battlewords-v0.2.27';
-const RUNTIME_CACHE = 'battlewords-runtime';
-// Assets to cache on install (minimal for faster install)
-const PRECACHE_URLS = [
-  '/',
-  '/app/static/manifest.json',
-  '/app/static/icon-192.png',
-  '/app/static/icon-512.png'
-];
-// Install event - cache essential files
-self.addEventListener('install', event => {
-  console.log('[ServiceWorker] Installing...');
-  event.waitUntil(
-    caches.open(CACHE_NAME)
-      .then(cache => {
-        console.log('[ServiceWorker] Precaching app shell');
-        return cache.addAll(PRECACHE_URLS);
-      })
-      .then(() => self.skipWaiting()) // Activate immediately
-  );
-});
-// Activate event - clean up old caches
-self.addEventListener('activate', event => {
-  console.log('[ServiceWorker] Activating...');
-  event.waitUntil(
-    caches.keys().then(cacheNames => {
-      return Promise.all(
-        cacheNames.map(cacheName => {
-          if (cacheName !== CACHE_NAME && cacheName !== RUNTIME_CACHE) {
-            console.log('[ServiceWorker] Deleting old cache:', cacheName);
-            return caches.delete(cacheName);
-          }
-        })
-      );
-    }).then(() => self.clients.claim()) // Take control immediately
-  );
-});
-// Fetch event - network first, fall back to cache
-self.addEventListener('fetch', event => {
-  // Skip non-GET requests
-  if (event.request.method !== 'GET') {
-    return;
-  }
-  // Skip chrome-extension and other non-http requests
-  if (!event.request.url.startsWith('http')) {
-    return;
-  }
-  event.respondWith(
-    caches.open(RUNTIME_CACHE).then(cache => {
-      return fetch(event.request)
-        .then(response => {
-          // Cache successful responses for future offline access
-          if (response.status === 200) {
-            cache.put(event.request, response.clone());
-          }
-          return response;
-        })
-        .catch(() => {
-          // Network failed, try cache
-          return caches.match(event.request).then(cachedResponse => {
-            if (cachedResponse) {
-              console.log('[ServiceWorker] Serving from cache:', event.request.url);
-              return cachedResponse;
-            }
-            // No cache available, return offline page or error
-            return new Response('Offline - Please check your connection', {
-              status: 503,
-              statusText: 'Service Unavailable',
-              headers: new Headers({
-                'Content-Type': 'text/plain'
-              })
-            });
-          });
-        });
-    })
-  );
-});
-// Message event - handle commands from the app
-self.addEventListener('message', event => {
-  if (event.data.action === 'skipWaiting') {
-    self.skipWaiting();
-  }
-});

+/**
+ * BattleWords Service Worker
+ * Enables PWA functionality: offline caching, install prompt, etc.
+ *
+ * Security Note: This file contains no secrets or sensitive data.
+ * It only caches public assets for offline access.
+ */
+const CACHE_NAME = 'battlewords-v0.2.29';
+const RUNTIME_CACHE = 'battlewords-runtime';
+// Assets to cache on install (minimal for faster install)
+const PRECACHE_URLS = [
+  '/',
+  '/app/static/manifest.json',
+  '/app/static/icon-192.png',
+  '/app/static/icon-512.png'
+];
+// Install event - cache essential files
+self.addEventListener('install', event => {
+  console.log('[ServiceWorker] Installing...');
+  event.waitUntil(
+    caches.open(CACHE_NAME)
+      .then(cache => {
+        console.log('[ServiceWorker] Precaching app shell');
+        return cache.addAll(PRECACHE_URLS);
+      })
+      .then(() => self.skipWaiting()) // Activate immediately
+  );
+});
+// Activate event - clean up old caches
+self.addEventListener('activate', event => {
+  console.log('[ServiceWorker] Activating...');
+  event.waitUntil(
+    caches.keys().then(cacheNames => {
+      return Promise.all(
+        cacheNames.map(cacheName => {
+          if (cacheName !== CACHE_NAME && cacheName !== RUNTIME_CACHE) {
+            console.log('[ServiceWorker] Deleting old cache:', cacheName);
+            return caches.delete(cacheName);
+          }
+        })
+      );
+    }).then(() => self.clients.claim()) // Take control immediately
+  );
+});
+// Fetch event - network first, fall back to cache
+self.addEventListener('fetch', event => {
+  // Skip non-GET requests
+  if (event.request.method !== 'GET') {
+    return;
+  }
+  // Skip chrome-extension and other non-http requests
+  if (!event.request.url.startsWith('http')) {
+    return;
+  }
+  event.respondWith(
+    caches.open(RUNTIME_CACHE).then(cache => {
+      return fetch(event.request)
+        .then(response => {
+          // Cache successful responses for future offline access
+          if (response.status === 200) {
+            cache.put(event.request, response.clone());
+          }
+          return response;
+        })
+        .catch(() => {
+          // Network failed, try cache
+          return caches.match(event.request).then(cachedResponse => {
+            if (cachedResponse) {
+              console.log('[ServiceWorker] Serving from cache:', event.request.url);
+              return cachedResponse;
+            }
+            // No cache available, return offline page or error
+            return new Response('Offline - Please check your connection', {
+              status: 503,
+              statusText: 'Service Unavailable',
+              headers: new Headers({
+                'Content-Type': 'text/plain'
+              })
+            });
+          });
+        });
+    })
+  );
+});
+// Message event - handle commands from the app
+self.addEventListener('message', event => {
+  if (event.data.action === 'skipWaiting') {
+    self.skipWaiting();
+  }
+});

tests/test_compare_difficulty_functions.py ADDED Viewed

	@@ -0,0 +1,237 @@

+# file: tests/test_compare_difficulty_functions.py
+import os
+import sys
+import pytest
+# Ensure the modules path is available
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+from battlewords.modules.constants import HF_API_TOKEN
+from battlewords.modules.storage import gen_full_url, _get_json_from_repo, HF_REPO_ID, SHORTENER_JSON_FILE
+from battlewords.word_loader import compute_word_difficulties, compute_word_difficulties2, compute_word_difficulties3
+# Ensure the token is set for Hugging Face Hub
+if HF_API_TOKEN:
+    os.environ["HF_API_TOKEN"] = HF_API_TOKEN
+# Define sample_words as a global variable
+sample_words = []
+def test_compare_difficulty_functions_for_challenge(capsys):
+    """
+    Compare compute_word_difficulties, compute_word_difficulties2, and compute_word_difficulties3
+    for all users in a challenge identified by short_id.
+    """
+    global sample_words  # Ensure we modify the global variable
+    # Use a fixed short id for testing
+    short_id = "hDjsB_dl"
+    # Step 1: Resolve short ID to full URL
+    status, full_url = gen_full_url(
+        short_url=short_id,
+        repo_id=HF_REPO_ID,
+        json_file=SHORTENER_JSON_FILE
+    )
+    if status != "success_retrieved_full" or not full_url:
+        print(
+            f"Could not resolve short id '{short_id}'. "
+            f"Status: {status}. "
+            f"Check repo '{HF_REPO_ID}' and mapping file '{SHORTENER_JSON_FILE}'."
+        )
+        captured = capsys.readouterr()
+        assert "Could not resolve short id" in captured.out
+        assert not full_url, "full_url should be empty/None on failure"
+        print("settings.json was not found or could not be resolved.")
+        return
+    print(f"✓ Resolved short id '{short_id}' to full URL: {full_url}")
+    # Step 2: Extract file path from full URL
+    url_parts = full_url.split("/resolve/main/")
+    assert len(url_parts) == 2, f"Invalid full URL format: {full_url}"
+    file_path = url_parts[1]
+    # Step 3: Download and parse settings.json
+    settings = _get_json_from_repo(HF_REPO_ID, file_path, repo_type="dataset")
+    assert settings, "Failed to download or parse settings.json"
+    print(f"✓ Downloaded settings.json")
+    # Validate settings structure
+    assert "challenge_id" in settings
+    assert "wordlist_source" in settings
+    assert "users" in settings
+    wordlist_source = settings.get("wordlist_source", "wordlist.txt")
+    users = settings.get("users", [])
+    print(f"\nChallenge ID: {settings['challenge_id']}")
+    print(f"Wordlist Source: {wordlist_source}")
+    print(f"Number of Users: {len(users)}")
+    # Step 4: Determine wordlist file path
+    # Assuming the wordlist is in battlewords/words/ directory
+    words_dir = os.path.join(os.path.dirname(__file__), "..", "battlewords", "words")
+    wordlist_path = os.path.join(words_dir, wordlist_source)
+    # If wordlist doesn't exist, try classic.txt as fallback
+    if not os.path.exists(wordlist_path):
+        print(f"⚠ Wordlist '{wordlist_source}' not found, using 'classic.txt' as fallback")
+        wordlist_path = os.path.join(words_dir, "classic.txt")
+    assert os.path.exists(wordlist_path), f"Wordlist file not found: {wordlist_path}"
+    print(f"✓ Using wordlist: {wordlist_path}")
+    # Step 5: Compare difficulty functions for each user
+    print("\n" + "="*80)
+    print("DIFFICULTY COMPARISON BY USER")
+    print("="*80)
+    all_results = []
+    for user_idx, user in enumerate(users, 1):
+        user_name = user.get("name", f"User {user_idx}")
+        word_list = user.get("word_list", [])
+        sample_words += word_list  # Update the global variable with the latest word list
+        if not word_list:
+            print(f"\n[{user_idx}] {user_name}: No words assigned, skipping")
+            continue
+        print(f"\n[{user_idx}] {user_name}")
+        print(f"     Words: {len(word_list)} words")
+        print(f"     Sample: {', '.join(word_list[:5])}{'...' if len(word_list) > 5 else ''}")
+        # Compute difficulties using all three functions
+        total_diff1, difficulties1 = compute_word_difficulties(wordlist_path, word_list)
+        total_diff2, difficulties2 = compute_word_difficulties2(wordlist_path, word_list)
+        total_diff3, difficulties3 = compute_word_difficulties3(wordlist_path, word_list)
+        print(f"\n     Function 1 (compute_word_difficulties):")
+        print(f"       Total Difficulty: {total_diff1:.4f}")
+        print(f"       Words Processed: {len(difficulties1)}")
+        print(f"\n     Function 2 (compute_word_difficulties2):")
+        print(f"       Total Difficulty: {total_diff2:.4f}")
+        print(f"       Words Processed: {len(difficulties2)}")
+        print(f"\n     Function 3 (compute_word_difficulties3):")
+        print(f"       Total Difficulty: {total_diff3:.4f}")
+        print(f"       Words Processed: {len(difficulties3)}")
+        # Calculate statistics
+        if difficulties1 and difficulties2 and difficulties3:
+            avg_diff1 = total_diff1 / len(difficulties1)
+            avg_diff2 = total_diff2 / len(difficulties2)
+            avg_diff3 = total_diff3 / len(difficulties3)
+            print(f"\n     Comparison:")
+            print(f"       Average Difficulty (Func1): {avg_diff1:.4f}")
+            print(f"       Average Difficulty (Func2): {avg_diff2:.4f}")
+            print(f"       Average Difficulty (Func3): {avg_diff3:.4f}")
+            print(f"       Difference (Func1 vs Func2): {abs(avg_diff1 - avg_diff2):.4f}")
+            print(f"       Difference (Func1 vs Func3): {abs(avg_diff1 - avg_diff3):.4f}")
+            print(f"       Difference (Func2 vs Func3): {abs(avg_diff2 - avg_diff3):.4f}")
+        # Store results for final summary
+        all_results.append({
+            "user_name": user_name,
+            "word_count": len(word_list),
+            "total_diff1": total_diff1,
+            "total_diff2": total_diff2,
+            "total_diff3": total_diff3,
+            "difficulties1": difficulties1,
+            "difficulties2": difficulties2,
+            "difficulties3": difficulties3,
+        })
+    # Step 6: Print summary comparison
+    print("\n" + "="*80)
+    print("OVERALL SUMMARY")
+    print("="*80)
+    if all_results:
+        total1_sum = sum(r["total_diff1"] for r in all_results)
+        total2_sum = sum(r["total_diff2"] for r in all_results)
+        total3_sum = sum(r["total_diff3"] for r in all_results)
+        total_words = sum(r["word_count"] for r in all_results)
+        print(f"\nTotal Users Analyzed: {len(all_results)}")
+        print(f"Total Words Across All Users: {total_words}")
+        print(f"\nAggregate Total Difficulty:")
+        print(f"  Function 1: {total1_sum:.4f}")
+        print(f"  Function 2: {total2_sum:.4f}")
+        print(f"  Function 3: {total3_sum:.4f}")
+        print(f"  Difference (Func1 vs Func2): {abs(total1_sum - total2_sum):.4f}")
+        print(f"  Difference (Func1 vs Func3): {abs(total1_sum - total3_sum):.4f}")
+        print(f"  Difference (Func2 vs Func3): {abs(total2_sum - total3_sum):.4f}")
+        # Validate that all functions returned results for all users
+        assert all(r["difficulties1"] for r in all_results), "Function 1 failed for some users"
+        assert all(r["difficulties2"] for r in all_results), "Function 2 failed for some users"
+        assert all(r["difficulties3"] for r in all_results), "Function 3 failed for some users"
+        print("\n✓ All tests passed!")
+    else:
+        print("\n⚠ No users with words found in this challenge")
+def test_compare_difficulty_functions_with_classic_wordlist():
+    """
+    Test all three difficulty functions using the classic.txt wordlist
+    with a sample set of words.
+    """
+    global sample_words  # Use the global variable
+    words_dir = os.path.join(os.path.dirname(__file__), "..", "battlewords", "words")
+    wordlist_path = os.path.join(words_dir, "classic.txt")
+    if not os.path.exists(wordlist_path):
+        pytest.skip(f"classic.txt not found at {wordlist_path}")
+    # Use the global sample_words if already populated, otherwise set a default
+    if not sample_words:
+        sample_words = ["ABLE", "ACID", "AREA", "ARMY", "BEAR", "BOWL", "CAVE", "COIN", "ECHO", "GOLD"]
+    print("\n" + "="*80)
+    print("TESTING WITH CLASSIC.TXT WORDLIST")
+    print("="*80)
+    print(f"Sample Words: {', '.join(sample_words)}")
+    # Compute difficulties
+    total_diff1, difficulties1 = compute_word_difficulties(wordlist_path, sample_words)
+    total_diff2, difficulties2 = compute_word_difficulties2(wordlist_path, sample_words)
+    total_diff3, difficulties3 = compute_word_difficulties3(wordlist_path, sample_words)
+    print(f"\nFunction compute_word_difficulties Results:")
+    print(f"  Total Difficulty: {total_diff1:.4f}")
+    for word in sample_words:
+        if word in difficulties1:
+            print(f"    {word}: {difficulties1[word]:.4f}")
+    print(f"\nFunction compute_word_difficulties2 Results:")
+    print(f"  Total Difficulty: {total_diff2:.4f}")
+    for word in sample_words:
+        if word in difficulties2:
+            print(f"    {word}: {difficulties2[word]:.4f}")
+    print(f"\nFunction compute_word_difficulties3 Results:")
+    print(f"  Total Difficulty: {total_diff3:.4f}")
+    for word in sample_words:
+        if word in difficulties3:
+            print(f"    {word}: {difficulties3[word]:.4f}")
+    # Assertions
+    assert len(difficulties1) == len(set(sample_words)), "Function 1 didn't process all words"
+    assert len(difficulties2) == len(set(sample_words)), "Function 2 didn't process all words"
+    assert len(difficulties3) == len(set(sample_words)), "Function 3 didn't process all words"
+    assert total_diff1 > 0, "Function 1 total difficulty should be positive"
+    assert total_diff2 > 0, "Function 2 total difficulty should be positive"
+    assert total_diff3 > 0, "Function 3 total difficulty should be positive"
+    print("\n✓ Classic wordlist test passed!")
+if __name__ == "__main__":
+    pytest.main(["-s", "-v", __file__])

tests/test_generator.py CHANGED Viewed

@@ -6,7 +6,13 @@ from battlewords.models import Coord
 class TestGenerator(unittest.TestCase):
     def test_generate_valid_puzzle(self):
-        p = generate_puzzle(grid_size=12, seed=1234)
         validate_puzzle(p, grid_size=12)
         # Ensure 6 words and 6 radar pulses
         self.assertEqual(len(p.words), 6)
@@ -19,6 +25,5 @@ class TestGenerator(unittest.TestCase):
                 seen.add(c)
                 self.assertTrue(0 <= c.x < 12 and 0 <= c.y < 12)
 if __name__ == "__main__":
     unittest.main()

 class TestGenerator(unittest.TestCase):
     def test_generate_valid_puzzle(self):
+        # Provide a minimal word pool for deterministic testing
+        words_by_len = {
+            4: ["TREE", "BOAT"],
+            5: ["APPLE", "RIVER"],
+            6: ["ORANGE", "PYTHON"],
+        }
+        p = generate_puzzle(grid_size=12, words_by_len=words_by_len, seed=1234)
         validate_puzzle(p, grid_size=12)
         # Ensure 6 words and 6 radar pulses
         self.assertEqual(len(p.words), 6)
                 seen.add(c)
                 self.assertTrue(0 <= c.x < 12 and 0 <= c.y < 12)
 if __name__ == "__main__":
     unittest.main()