Create app.py

app.py

@@ -0,0 +1,253 @@
+import os
+import sys
+import time
+import subprocess
+import urllib.request
+import socket
+import gradio as gr
+import http.client
+import urllib.parse
+import xml.etree.ElementTree as ET
+
+# =============================================================================
+# CONFIGURATION
+# =============================================================================
+REPO_URL = "https://github.com/Automattic/atd-server-next.git"
+SERVER_DIR = "atd-server-next"  # Local folder name
+MODELS_DIR = os.path.join(SERVER_DIR, "models")
+MODEL_BASE_URL = "https://openatd.svn.wordpress.org/atd-server/models/"
+HOST = "127.0.0.1"
+PORT = 1049
+
+# List of binary models to download
+MODEL_FILES = [
+    "cnetwork.bin", "cnetwork2.bin", "dictionary.txt", "edits.bin",
+    "endings.bin", "hnetwork.bin", "hnetwork2.bin", "hnetwork4.bin",
+    "lexicon.bin", "model.bin", "model.zip", "network3f.bin",
+    "network3p.bin", "not_misspelled.txt", "stringpool.bin", "trigrams.bin"
+]
+
+# =============================================================================
+# PHASE 1: AUTO-INSTALLATION & SETUP
+# =============================================================================
+def setup_server():
+    """Clones repo, downloads models, and compiles rules."""
+    print("--- [PHASE 0] CHECKING REPOSITORY ---")
+    
+    # 1. Clone Repository if missing
+    if not os.path.exists(SERVER_DIR):
+        print(f"Repository not found. Cloning from {REPO_URL}...")
+        try:
+            # Use shallow clone (--depth 1) to save space and time
+            subprocess.run(["git", "clone", "--depth", "1", REPO_URL, SERVER_DIR], check=True)
+            print("  -> Clone successful.")
+        except subprocess.CalledProcessError as e:
+            print(f"  -> FAILED to clone repository: {e}")
+            sys.exit(1)
+    else:
+        print(f"  -> Repository found at {SERVER_DIR}")
+
+    print("\n--- [PHASE 1] CHECKING MODELS ---")
+    
+    if not os.path.exists(MODELS_DIR):
+        print(f"Creating directory: {MODELS_DIR}")
+        os.makedirs(MODELS_DIR, exist_ok=True)
+
+    # 2. Download Models
+    print("Checking model files...")
+    for filename in MODEL_FILES:
+        filepath = os.path.join(MODELS_DIR, filename)
+        if not os.path.exists(filepath):
+            url = MODEL_BASE_URL + filename
+            print(f"Downloading {filename}...")
+            try:
+                urllib.request.urlretrieve(url, filepath)
+                print(f"  -> Saved.")
+            except Exception as e:
+                print(f"  -> FAILED: {e}")
+                sys.exit(1)
+        else:
+            print(f"  -> Found {filename}")
+
+    # 3. Compile Rules
+    print("\n--- [PHASE 2] COMPILING RULES ---")
+    print("Running Java Rule Compiler (this takes a moment)...")
+    
+    # Note: Classpath separator is ':' for Linux (Hugging Face), ';' for Windows
+    cp_sep = ";" if os.name == 'nt' else ":"
+    
+    try:
+        subprocess.run(
+            [
+                "java", 
+                "-Datd.lowmem=true", 
+                "-Xmx1024M", 
+                "-jar", "lib/sleep.jar", 
+                "utils/rules/rules.sl"
+            ],
+            cwd=SERVER_DIR,
+            check=True
+        )
+        print("Rules compiled successfully.")
+    except subprocess.CalledProcessError as e:
+        print(f"Error compiling rules: {e}")
+        # We don't exit here because sometimes it works anyway if previous run succeeded
+
+# =============================================================================
+# PHASE 2: SERVER MANAGEMENT
+# =============================================================================
+def start_backend():
+    """Starts the Java server in the background."""
+    print("\n--- [PHASE 3] STARTING SERVER ---")
+    
+    cp_sep = ";" if os.name == 'nt' else ":"
+    
+    # Construct classpath
+    # Linux: lib/sleep.jar:lib/moconti.jar...
+    classpath = f"lib/sleep.jar{cp_sep}lib/moconti.jar{cp_sep}lib/spellutils.jar"
+    sleep_cp = f"lib{cp_sep}service/code"
+
+    cmd = [
+        "java",
+        "-Dfile.encoding=UTF-8",
+        "-XX:+AggressiveHeap",
+        "-XX:+UseParallelGC",
+        "-Datd.lowmem=true",
+        "-Dbind.interface=127.0.0.1",
+        f"-Dserver.port={PORT}",
+        f"-Dsleep.classpath={sleep_cp}",
+        "-Dsleep.debug=24",
+        "-classpath", classpath,
+        "httpd.Moconti",
+        "atdconfig.sl"
+    ]
+
+    print(f"Executing: {' '.join(cmd)}")
+    # Start process, redirect stdout/stderr so we can see logs in HF console
+    return subprocess.Popen(cmd, cwd=SERVER_DIR)
+
+def wait_for_port(timeout=60):
+    print(f"Waiting for port {PORT}...")
+    start = time.time()
+    while time.time() - start < timeout:
+        try:
+            with socket.create_connection((HOST, PORT), timeout=1):
+                print("Server is Online!")
+                return True
+        except (ConnectionRefusedError, OSError):
+            time.sleep(1)
+    return False
+
+# =============================================================================
+# PHASE 3: CLIENT LOGIC (Embedded PyATD)
+# =============================================================================
+class AtDClient:
+    def __init__(self):
+        self.host = HOST
+        self.port = PORT
+
+    def check_document(self, text):
+        try:
+            conn = http.client.HTTPConnection(self.host, self.port, timeout=5)
+            params = urllib.parse.urlencode({'key': 'gradio', 'data': text})
+            headers = {"Content-Type": "application/x-www-form-urlencoded"}
+            conn.request("POST", "/checkDocument", params, headers)
+            resp = conn.getresponse()
+            if resp.status != 200: return []
+            
+            root = ET.fromstring(resp.read())
+            errors = []
+            for e in root.findall('error'):
+                err = {
+                    'string': e.find('string').text,
+                    'description': e.find('description').text,
+                    'type': e.find('type').text,
+                    'precontext': e.find('precontext').text or "",
+                    'suggestions': []
+                }
+                sug = e.find('suggestions')
+                if sug is not None:
+                    err['suggestions'] = [o.text for o in sug.findall('option') if o.text]
+                errors.append(err)
+            return errors
+        except Exception as e:
+            print(f"Client Error: {e}")
+            return []
+
+# =============================================================================
+# PHASE 4: GRADIO UI
+# =============================================================================
+client = AtDClient()
+
+def analyze_text(text):
+    if not text.strip(): return []
+    
+    errors = client.check_document(text)
+    
+    output = []
+    last_pos = 0
+    
+    # We need to find the errors in the text. 
+    for err in errors:
+        word = err['string']
+        # Search for the word starting from last_pos
+        # We try to use precontext to verify uniqueness
+        search_block = err['precontext'] + word
+        
+        # Try finding with context first
+        idx = text.find(search_block, last_pos)
+        
+        if idx != -1:
+            # Found with context
+            actual_word_start = idx + len(err['precontext'])
+        else:
+            # Fallback: Find just the word
+            actual_word_start = text.find(word, last_pos)
+            
+        if actual_word_start != -1:
+            # Add clean text before error
+            if actual_word_start > last_pos:
+                output.append((text[last_pos:actual_word_start], None))
+            
+            # Add error text
+            label = f"{err['type']}: {err['description']}"
+            if err['suggestions']:
+                label += f" -> {', '.join(err['suggestions'][:3])}"
+            
+            output.append((text[actual_word_start:actual_word_start+len(word)], label))
+            last_pos = actual_word_start + len(word)
+            
+    # Add remainder
+    if last_pos < len(text):
+        output.append((text[last_pos:], None))
+        
+    return output
+
+# =============================================================================
+# MAIN EXECUTION
+# =============================================================================
+if __name__ == "__main__":
+    # 1. Run Setup (Clone, Download, Compile)
+    setup_server()
+    
+    # 2. Start Server
+    server_proc = start_backend()
+    
+    # 3. Wait for ready
+    if wait_for_port():
+        # 4. Launch UI
+        with gr.Blocks(title="AtD Self-Hosted") as demo:
+            gr.Markdown("# 🛡️ After The Deadline (Self-Installing Server)")
+            gr.Markdown("This Space automatically downloaded models, compiled Java rules, and launched the server.")
+            
+            with gr.Row():
+                inp = gr.Textbox(label="Input", placeholder="Type here... e.g., I has a error.", lines=6)
+                out = gr.HighlightedText(label="Corrections", combine_adjacent=True)
+            
+            btn = gr.Button("Check Text", variant="primary")
+            btn.click(analyze_text, inputs=inp, outputs=out)
+            
+        demo.launch(server_name="0.0.0.0", server_port=7860)
+    else:
+        print("FATAL: Server did not start.")
+        server_proc.kill()