Update app.py

app.py

@@ -1,399 +1,198 @@
-import gradio as gr
-import requests
-import zipfile
-import os
+"""
+Mixed-Alphabet Word Scanner
+----------------------------
+Scans a .txt file word-by-word and flags "mixup" words — words that mix
+letters with digits and/or special characters (e.g. M0M, G@ng, f1ght).
+
+Rules:
+  - Pure numbers (e.g. "12345")        -> SKIPPED
+  - Pure special characters (e.g. "***")-> SKIPPED
+  - Normal words, even with a trailing
+    comma/period (e.g. "hello.", "world,") -> SKIPPED
+  - Pure alphabet words (e.g. "hello")  -> SKIPPED
+  - Words mixing letters with digits/symbols
+    ANYWHERE in the word (e.g. M0M, G@ng, f1ght) -> FLAGGED
+  - Duplicate flagged words are only listed once.
+
+Works two ways:
+  1. As a command-line script:
+        python app.py your_file.txt
+  2. As a Gradio web app (this is what runs when deployed to a
+     Hugging Face Space — just upload this file + requirements.txt).
+"""
+
 import re
-import time
-from datetime import datetime
-from urllib.parse import urlparse
-from bs4 import BeautifulSoup
+import sys
+import io
+import csv
+
+
+def rstrip_trailing_punct(word: str) -> str:
+    """Strip trailing commas/periods only (e.g. 'hello.,' -> 'hello')."""
+    return word.rstrip(".,")
+
+
+def is_mixup_word(word: str):
+    """
+    Returns (is_mixup: bool, cleaned_word: str)
+
+    A word is a "mixup" if, after stripping trailing , or . :
+      - it is NOT empty
+      - it is NOT purely digits
+      - it is NOT purely special characters (no letters, no digits)
+      - it is NOT purely alphabetic
+      - it DOES contain at least one letter AND at least one
+        digit/special character somewhere in it
+    """
+    cleaned = rstrip_trailing_punct(word)
+
+    if cleaned == "":
+        return False, cleaned
+
+    if cleaned.isdigit():                      # pure number -> skip
+        return False, cleaned
 
-# ── helpers ──────────────────────────────────────────────────────────────────
+    if cleaned.isalpha():                       # pure alphabet -> skip
+        return False, cleaned
 
-HEADERS = {
-    "User-Agent": (
-        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
-        "AppleWebKit/537.36 (KHTML, like Gecko) "
-        "Chrome/124.0 Safari/537.36"
-    ),
-    "Accept-Language": "en-US,en;q=0.9",
-}
+    has_letter = any(c.isalpha() for c in cleaned)
+    has_other = any((not c.isalpha()) for c in cleaned)  # digit or special
 
-OUTPUT_DIR = "fetched_pages"
-os.makedirs(OUTPUT_DIR, exist_ok=True)
+    if not has_letter:                           # pure digits/specials -> skip
+        return False, cleaned
 
+    if has_letter and has_other:                  # genuine mixup
+        return True, cleaned
 
-def safe_filename(url: str, index: int) -> str:
-    """Turn a URL into a safe filename like 001_example_com_path.html"""
-    parsed = urlparse(url)
-    slug = re.sub(r"[^\w\-]", "_", parsed.netloc + parsed.path)
-    slug = re.sub(r"_+", "_", slug).strip("_")[:80]
-    return f"{index:03d}_{slug}.html"
+    return False, cleaned
 
 
-def fetch_url(url: str, timeout: int = 15) -> tuple[str, str]:
+def scan_text(text: str):
     """
-    Fetch a URL and return (html_content, error_message).
-    error_message is empty string on success.
+    Scans text, returns (results, stats)
+      results: list of dicts [{"word": original_token, "cleaned": cleaned}]
+               in order of first appearance, duplicates removed (case-sensitive).
+      stats:   dict with counts.
     """
-    try:
-        r = requests.get(url, headers=HEADERS, timeout=timeout)
-        r.raise_for_status()
-        # normalise encoding
-        r.encoding = r.apparent_encoding or "utf-8"
-        return r.text, ""
-    except requests.exceptions.Timeout:
-        return "", f"Timed out after {timeout}s"
-    except requests.exceptions.HTTPError as e:
-        return "", f"HTTP {e.response.status_code}"
-    except Exception as e:
-        return "", str(e)
-
-
-def inject_base_tag(html: str, url: str) -> str:
-    """Inject a <base> tag so relative links resolve correctly in previews."""
-    parsed = urlparse(url)
-    base = f"{parsed.scheme}://{parsed.netloc}"
-    if "<head" in html.lower():
-        return re.sub(
-            r"(<head[^>]*>)",
-            rf'\1<base href="{base}">',
-            html,
-            count=1,
-            flags=re.IGNORECASE,
+    tokens = re.findall(r"\S+", text)
+
+    seen = set()
+    results = []
+    total_flagged_occurrences = 0
+
+    for token in tokens:
+        flagged, cleaned = is_mixup_word(token)
+        if flagged:
+            total_flagged_occurrences += 1
+            key = cleaned  # dedupe on the cleaned form, case-sensitive
+            if key not in seen:
+                seen.add(key)
+                results.append({"word": token, "cleaned": cleaned})
+
+    stats = {
+        "total_words_scanned": len(tokens),
+        "total_flagged_occurrences": total_flagged_occurrences,
+        "unique_flagged_words": len(results),
+    }
+    return results, stats
+
+
+def results_to_txt(results):
+    return "\n".join(r["cleaned"] for r in results)
+
+
+def results_to_csv(results):
+    buf = io.StringIO()
+    writer = csv.writer(buf)
+    writer.writerow(["word"])
+    for r in results:
+        writer.writerow([r["cleaned"]])
+    return buf.getvalue()
+
+
+# --------------------------------------------------------------------------
+# CLI mode
+# --------------------------------------------------------------------------
+def run_cli(path: str):
+    with open(path, "r", encoding="utf-8", errors="ignore") as f:
+        text = f.read()
+
+    results, stats = scan_text(text)
+
+    print(f"Scanned {stats['total_words_scanned']} words.")
+    print(f"Found {stats['unique_flagged_words']} unique mixed-alphabet words "
+          f"({stats['total_flagged_occurrences']} total occurrences):\n")
+
+    for r in results:
+        print(r["cleaned"])
+
+    out_path = "flagged_words.txt"
+    with open(out_path, "w", encoding="utf-8") as f:
+        f.write(results_to_txt(results))
+    print(f"\nSaved list to {out_path}")
+
+
+# --------------------------------------------------------------------------
+# Gradio web app (used on Hugging Face Spaces)
+# --------------------------------------------------------------------------
+def build_gradio_app():
+    import gradio as gr
+
+    def process(file_obj):
+        if file_obj is None:
+            return "Please upload a .txt file.", None, None
+
+        # gr.File gives a filepath (str) in recent Gradio versions
+        path = file_obj if isinstance(file_obj, str) else file_obj.name
+        with open(path, "r", encoding="utf-8", errors="ignore") as f:
+            text = f.read()
+
+        results, stats = scan_text(text)
+
+        summary = (
+            f"Scanned {stats['total_words_scanned']} words.\n"
+            f"Unique flagged words: {stats['unique_flagged_words']}\n"
+            f"Total flagged occurrences: {stats['total_flagged_occurrences']}"
         )
-    return f'<base href="{base}">' + html
 
+        list_display = "\n".join(r["cleaned"] for r in results) or "(none found)"
+
+        # Write downloadable output file
+        out_path = "/tmp/flagged_words.txt"
+        with open(out_path, "w", encoding="utf-8") as f:
+            f.write(results_to_txt(results))
 
-def make_combined(pages: list[dict], title: str = "Combined Pages") -> str:
-    """Build one big HTML file with a sidebar TOC and all pages in iframes."""
-    nav_items = ""
-    sections = ""
+        return summary, list_display, out_path
 
-    for i, page in enumerate(pages):
-        anchor = f"page_{i}"
-        label = page["title"] or page["url"]
-        status_badge = (
-            '<span style="color:#22c55e">✓</span>'
-            if page["ok"]
-            else '<span style="color:#ef4444">✗</span>'
+    with gr.Blocks(title="Mixed-Alphabet Word Scanner") as demo:
+        gr.Markdown(
+            "## Mixed-Alphabet Word Scanner\n"
+            "Upload a `.txt` file. This tool flags words that mix letters "
+            "with digits/symbols (e.g. `M0M`, `G@ng`, `f1ght`), while "
+            "skipping pure numbers, pure symbols, normal words, and words "
+            "with only a trailing comma/period."
         )
-        nav_items += f"""
-        <li>
-          <a href="#{anchor}" class="nav-link" onclick="showSection('{anchor}')">
-            {status_badge} {i+1}. {label[:60]}
-          </a>
-        </li>"""
-
-        if page["ok"]:
-            # embed raw HTML in a sandboxed iframe via srcdoc
-            escaped = page["html"].replace("&", "&amp;").replace('"', "&quot;")
-            content_block = f'<iframe srcdoc="{escaped}" class="page-frame" sandbox="allow-same-origin allow-scripts"></iframe>'
-        else:
-            content_block = f'<div class="error-box">⚠ Could not fetch this page: {page["error"]}</div>'
-
-        sections += f"""
-        <section id="{anchor}" class="page-section">
-          <div class="page-header">
-            <span class="page-index">#{i+1}</span>
-            <a href="{page['url']}" target="_blank" class="page-url">{page['url']}</a>
-          </div>
-          {content_block}
-        </section>"""
-
-    fetched_at = datetime.now().strftime("%Y-%m-%d %H:%M")
-    total = len(pages)
-    ok_count = sum(1 for p in pages if p["ok"])
-
-    return f"""<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>{title}</title>
-<style>
-  *, *::before, *::after {{ box-sizing: border-box; margin: 0; padding: 0; }}
-  :root {{
-    --bg: #0f1117;
-    --sidebar-bg: #161b22;
-    --surface: #1c2230;
-    --accent: #58a6ff;
-    --accent2: #3fb950;
-    --text: #e6edf3;
-    --muted: #8b949e;
-    --border: #30363d;
-    --radius: 8px;
-    --sidebar-w: 300px;
-  }}
-  body {{
-    font-family: 'Segoe UI', system-ui, sans-serif;
-    background: var(--bg);
-    color: var(--text);
-    display: flex;
-    height: 100vh;
-    overflow: hidden;
-  }}
-
-  /* ── Sidebar ── */
-  #sidebar {{
-    width: var(--sidebar-w);
-    min-width: var(--sidebar-w);
-    background: var(--sidebar-bg);
-    border-right: 1px solid var(--border);
-    display: flex;
-    flex-direction: column;
-    overflow: hidden;
-  }}
-  .sidebar-header {{
-    padding: 18px 16px 14px;
-    border-bottom: 1px solid var(--border);
-  }}
-  .sidebar-header h1 {{
-    font-size: 15px;
-    font-weight: 700;
-    color: var(--accent);
-    letter-spacing: .02em;
-  }}
-  .sidebar-meta {{
-    font-size: 11px;
-    color: var(--muted);
-    margin-top: 4px;
-  }}
-  #nav-list {{
-    list-style: none;
-    overflow-y: auto;
-    flex: 1;
-    padding: 8px 0;
-  }}
-  #nav-list li {{ padding: 2px 8px; }}
-  .nav-link {{
-    display: block;
-    padding: 7px 10px;
-    border-radius: var(--radius);
-    color: var(--muted);
-    text-decoration: none;
-    font-size: 12px;
-    line-height: 1.4;
-    transition: background .15s, color .15s;
-    word-break: break-all;
-  }}
-  .nav-link:hover, .nav-link.active {{
-    background: rgba(88,166,255,.12);
-    color: var(--text);
-  }}
-
-  /* ── Main ── */
-  #main {{
-    flex: 1;
-    overflow-y: auto;
-    padding: 24px 28px;
-  }}
-  .page-section {{
-    margin-bottom: 48px;
-  }}
-  .page-header {{
-    display: flex;
-    align-items: center;
-    gap: 10px;
-    margin-bottom: 10px;
-    padding-bottom: 10px;
-    border-bottom: 1px solid var(--border);
-  }}
-  .page-index {{
-    background: var(--accent);
-    color: #000;
-    font-size: 11px;
-    font-weight: 700;
-    padding: 2px 7px;
-    border-radius: 20px;
-    flex-shrink: 0;
-  }}
-  .page-url {{
-    color: var(--muted);
-    font-size: 12px;
-    word-break: break-all;
-    text-decoration: none;
-  }}
-  .page-url:hover {{ color: var(--accent); text-decoration: underline; }}
-  .page-frame {{
-    width: 100%;
-    height: 600px;
-    border: 1px solid var(--border);
-    border-radius: var(--radius);
-    background: #fff;
-  }}
-  .error-box {{
-    padding: 20px;
-    border: 1px solid #f8514933;
-    background: #f8514911;
-    border-radius: var(--radius);
-    color: #ff7b72;
-    font-size: 13px;
-  }}
-</style>
-</head>
-<body>
-
-<aside id="sidebar">
-  <div class="sidebar-header">
-    <h1>📄 {title}</h1>
-    <div class="sidebar-meta">
-      {ok_count}/{total} pages fetched &nbsp;·&nbsp; {fetched_at}
-    </div>
-  </div>
-  <ul id="nav-list">
-    {nav_items}
-  </ul>
-</aside>
-
-<main id="main">
-  {sections}
-</main>
-
-<script>
-  function showSection(id) {{
-    document.querySelectorAll('.nav-link').forEach(l => l.classList.remove('active'));
-    const link = document.querySelector(`a[href="#${{id}}"]`);
-    if (link) link.classList.add('active');
-  }}
-
-  // Highlight nav item on scroll
-  const observer = new IntersectionObserver(entries => {{
-    entries.forEach(e => {{
-      if (e.isIntersecting) {{
-        document.querySelectorAll('.nav-link').forEach(l => l.classList.remove('active'));
-        const link = document.querySelector(`a[href="#${{e.target.id}}"]`);
-        if (link) link.classList.add('active');
-      }}
-    }});
-  }}, {{ threshold: 0.3 }});
-  document.querySelectorAll('.page-section').forEach(s => observer.observe(s));
-</script>
-</body>
-</html>"""
-
-
-# ── Gradio logic ─────────────────────────────────────────────────────────────
-
-def process_urls(raw_input: str, delay: float, progress=gr.Progress(track_tqdm=True)):
-    """
-    Main processing function called by Gradio.
-    Returns (status_text, combined_html_path, zip_path)
-    """
-    lines = [l.strip() for l in raw_input.strip().splitlines() if l.strip()]
-    urls = [l for l in lines if l.startswith("http://") or l.startswith("https://")]
-
-    if not urls:
-        return "❌ No valid URLs found. Make sure each URL starts with http:// or https://", None, None
-
-    pages = []
-    log_lines = []
-
-    for i, url in enumerate(progress.tqdm(urls, desc="Fetching pages")):
-        progress((i + 1) / len(urls), desc=f"Fetching {i+1}/{len(urls)}: {url[:50]}…")
-        html, err = fetch_url(url)
-
-        if html:
-            html = inject_base_tag(html, url)
-            # try to extract a page title
-            try:
-                soup = BeautifulSoup(html, "html.parser")
-                title = soup.title.string.strip() if soup.title else ""
-            except Exception:
-                title = ""
-
-            fname = safe_filename(url, i + 1)
-            fpath = os.path.join(OUTPUT_DIR, fname)
-            with open(fpath, "w", encoding="utf-8", errors="replace") as f:
-                f.write(html)
-
-            pages.append({"url": url, "html": html, "title": title, "ok": True, "file": fpath, "error": ""})
-            log_lines.append(f"✅ [{i+1}/{len(urls)}] {url}")
-        else:
-            pages.append({"url": url, "html": "", "title": "", "ok": False, "file": None, "error": err})
-            log_lines.append(f"❌ [{i+1}/{len(urls)}] {url}  →  {err}")
-
-        if delay > 0 and i < len(urls) - 1:
-            time.sleep(delay)
-
-    # Build combined HTML
-    combined_html = make_combined(pages, title="Fetched Pages")
-    combined_path = os.path.join(OUTPUT_DIR, "combined.html")
-    with open(combined_path, "w", encoding="utf-8", errors="replace") as f:
-        f.write(combined_html)
-
-    # Build ZIP of individual files
-    zip_path = os.path.join(OUTPUT_DIR, "all_pages.zip")
-    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
-        for p in pages:
-            if p["file"]:
-                zf.write(p["file"], os.path.basename(p["file"]))
-        zf.write(combined_path, "combined.html")
-
-    ok_count = sum(1 for p in pages if p["ok"])
-    status = "\n".join(log_lines)
-    status += f"\n\n🎉 Done! {ok_count}/{len(urls)} pages saved."
-    return status, combined_path, zip_path
-
-
-# ── UI ───────────────────────────────────────────────────────────────────────
-
-with gr.Blocks(
-    title="URL → HTML Fetcher",
-    theme=gr.themes.Base(
-        primary_hue="blue",
-        neutral_hue="slate",
-    ),
-    css="""
-    #url-box textarea { font-family: monospace; font-size: 13px; }
-    #log-box textarea  { font-family: monospace; font-size: 12px; }
-    """
-) as demo:
-
-    gr.Markdown(
-        """
-# 🌐 URL → HTML Fetcher
-Paste URLs (one per line), click **Fetch**, and get:
-- Individual `.html` files for each page
-- One `combined.html` with a sidebar viewer
-- A `.zip` with everything bundled
-        """
-    )
-
-    with gr.Row():
-        with gr.Column(scale=2):
-            url_input = gr.Textbox(
-                label="URLs (one per line)",
-                placeholder="https://example.com\nhttps://another-site.com/page",
-                lines=12,
-                elem_id="url-box",
-            )
-            delay_slider = gr.Slider(
-                minimum=0,
-                maximum=5,
-                value=1,
-                step=0.5,
-                label="Delay between requests (seconds) — be polite to servers!",
-            )
-            fetch_btn = gr.Button("🚀 Fetch Pages", variant="primary")
-
-        with gr.Column(scale=1):
-            log_output = gr.Textbox(
-                label="Progress log",
-                lines=12,
-                interactive=False,
-                elem_id="log-box",
-            )
-
-    with gr.Row():
-        combined_file = gr.File(label="📄 Combined HTML (download)")
-        zip_file      = gr.File(label="📦 All pages ZIP (download)")
-
-    fetch_btn.click(
-        fn=process_urls,
-        inputs=[url_input, delay_slider],
-        outputs=[log_output, combined_file, zip_file],
-    )
+        file_input = gr.File(label="Upload .txt file", file_types=[".txt"])
+        run_btn = gr.Button("Scan File", variant="primary")
+        summary_out = gr.Textbox(label="Summary", interactive=False)
+        list_out = gr.Textbox(label="Flagged Words", lines=15, interactive=False)
+        download_out = gr.File(label="Download flagged_words.txt")
+
+        run_btn.click(
+            fn=process,
+            inputs=file_input,
+            outputs=[summary_out, list_out, download_out],
+        )
+
+    return demo
+
 
 if __name__ == "__main__":
-    demo.launch()
+    # If a filepath is passed as an argument, run in CLI mode.
+    if len(sys.argv) > 1:
+        run_cli(sys.argv[1])
+    else:
+        # Otherwise launch the Gradio web app (Hugging Face Spaces will
+        # call this file directly with no args).
+        app = build_gradio_app()
+        app.launch()