Update app.py

app.py

@@ -1,236 +1,82 @@
-"""
-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 sys
-import io
-import csv
-
-
-# Includes decorative symbols (hearts, stars) and their emoji/text
-# variation selectors, so e.g. "Peo-eok\u2665\ufe0e" is treated the same
-# as "Peo-eok" -- but "pe0\u2665\ufe0e" still gets flagged because of the "0".
-OUTER_PUNCT = (
-    ".,!?;:\"'()[]{}<>*~`^\u201c\u201d\u2018\u2019\u2014\u2013\u2026"
-    "\u2665\u2764\u2661\u2606\u2605\u2726\u2727\u2729\u272a"
-    "\ufe0e\ufe0f"
-)
-ALPHA_APOSTROPHE_RE = re.compile(r"^[A-Za-z'\u2019]+$")
-
-
-def clean_outer(word: str) -> str:
-    """Strip quote/sentence punctuation from both ends only."""
-    return word.strip(OUTER_PUNCT)
-
-
-def _is_plain_ascii_alpha(c: str) -> bool:
-    """True only for plain a-z/A-Z letters (excludes accented letters
-    like é, ú, ñ, ü -- those are treated as 'suspicious' below)."""
-    return c.isalpha() and c.isascii()
-
-
-def _segment_is_clean(segment: str) -> bool:
-    """A hyphen-joined chunk is 'clean' if it's pure plain letters
-    (+apostrophe) or pure digits or empty (e.g. '36', 'year', 'old')."""
-    if segment == "":
-        return True
-    if segment.isdigit():
-        return True
-    if ALPHA_APOSTROPHE_RE.match(segment):
-        return True
-    return False
-
-
-def is_mixup_word(word: str):
-    """
-    Returns (is_mixup: bool, cleaned_word: str)
-
-    Smarter rules:
-      - Strip outer quote/sentence punctuation ("Conquer", once?, enjoyment:)
-      - Pure digits, pure special chars, or empty -> skip
-      - Pure alphabetic words, including contractions/possessives
-        (can't, who's) -> skip
-      - Hyphenated words where every hyphen-separated chunk is clean on
-        its own (36-year-old, well-known) -> skip
-      - Anything else that mixes letters with digits/symbols WITHIN the
-        same chunk (M0M, G@ng, f1ght, y3ars-0ld) -> flagged as mixup
-    """
-    cleaned = clean_outer(word)
-
-    if cleaned == "":
-        return False, cleaned
-
-    if cleaned.isdigit():                        # pure number -> skip
-        return False, cleaned
-
-    if ALPHA_APOSTROPHE_RE.match(cleaned):        # normal word/contraction -> skip
-        return False, cleaned
-
-    has_letter_overall = any(c.isalpha() for c in cleaned)
-    if not has_letter_overall:                    # pure special chars -> skip
-        return False, cleaned
-
-    if "-" in cleaned:
-        segments = cleaned.split("-")
-        if all(_segment_is_clean(s) for s in segments):
-            return False, cleaned                 # legit hyphenated word -> skip
-        return True, cleaned                       # a chunk is disguised -> flag
-
-    # No hyphen: flag if plain letters are mixed with digits/symbols/
-    # accented look-alike letters (é, ú, ñ, ü...) anywhere in the word
-    has_other = any(not _is_plain_ascii_alpha(c) for c in cleaned)
-    if has_other:
-        return True, cleaned
-
-    return False, cleaned
-
-
-def scan_text(text: str):
-    """
-    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.
-    """
-    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:
+import gradio as gr
+import tempfile
+import os
+
+# ----------------------------
+# Load replacement dictionary
+# ----------------------------
+def load_dictionary(dictionary_file):
+    replacements = []
+
+    with open(dictionary_file.name, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+
+            if not line:
+                continue
+
+            if "->" not in line:
+                continue
+
+            wrong, correct = line.split("->", 1)
+
+            wrong = wrong.strip()
+            correct = correct.strip()
+
+            replacements.append((wrong, correct))
+
+    # Longest words first
+    replacements.sort(key=lambda x: len(x[0]), reverse=True)
+
+    return replacements
+
+
+# ----------------------------
+# Replace text
+# ----------------------------
+def correct_text(txt_file, dictionary_file):
+
+    replacements = load_dictionary(dictionary_file)
+
+    with open(txt_file.name, "r", encoding="utf-8") 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']}"
-        )
-
-        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))
-
-        return summary, list_display, out_path
-
-    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."
-        )
-        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__":
-    # 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()
+    total = 0
+
+    for wrong, correct in replacements:
+
+        count = text.count(wrong)
+
+        if count:
+            text = text.replace(wrong, correct)
+            total += count
+
+    output_path = os.path.join(
+        tempfile.gettempdir(),
+        "corrected_text.txt"
+    )
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(text)
+
+    return output_path, f"Done!\n\nTotal replacements: {total}"
+
+
+# ----------------------------
+# Interface
+# ----------------------------
+demo = gr.Interface(
+    fn=correct_text,
+    inputs=[
+        gr.File(label="Upload TXT File"),
+        gr.File(label="Upload Correction Dictionary"),
+    ],
+    outputs=[
+        gr.File(label="Download Corrected TXT"),
+        gr.Textbox(label="Status"),
+    ],
+    title="Novel Word Corrector",
+    description="Upload a TXT file and a dictionary in the format 'wrong -> correct'."
+)
+
+demo.launch()