Update app.py

app.py

@@ -8,18 +8,19 @@ import gradio as gr
 import http.client
 import urllib.parse
 import xml.etree.ElementTree as ET
+import shutil
+import re
 
 # =============================================================================
 # CONFIGURATION
 # =============================================================================
 REPO_URL = "https://github.com/Automattic/atd-server-next.git"
-SERVER_DIR = "atd-server-next"  # Local folder name
+SERVER_DIR = "atd-server-next"
 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",
@@ -30,31 +31,52 @@ MODEL_FILES = [
 # =============================================================================
 # PHASE 1: AUTO-INSTALLATION & SETUP
 # =============================================================================
+def patch_server_code():
+    """
+    Patches legacy Sleep code to run on modern Java (JDK 9+).
+    Removes 'from: lib/spellutils.jar' syntax which causes ClassCastException.
+    """
+    print("--- [PHASE 1.5] PATCHING CODE FOR JAVA 17+ ---")
+    
+    # Files that are known to contain the incompatible import syntax
+    files_to_check = [
+        os.path.join(SERVER_DIR, "lib", "spellcheck.sl"),
+        os.path.join(SERVER_DIR, "utils", "spell", "trainspell.sl") # Potentially here too
+    ]
+    
+    for file_path in files_to_check:
+        if not os.path.exists(file_path):
+            continue
+
+        try:
+            with open(file_path, "r") as f:
+                content = f.read()
+            
+            # Regex to remove 'from: lib/spellutils.jar' but keep the semicolon
+            # Matches: from: [whitespace] lib/spellutils.jar
+            new_content = re.sub(r'from:\s*lib/spellutils\.jar', '', content)
+            
+            if content != new_content:
+                print(f"Patching {file_path}...")
+                with open(file_path, "w") as f:
+                    f.write(new_content)
+                print("-> Success: Code patched for modern Java.")
+            else:
+                print(f"-> {file_path} already clean.")
+                
+        except Exception as e:
+            print(f"Error patching {file_path}: {e}")
+
 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}")
+        subprocess.run(["git", "clone", "--depth", "1", REPO_URL, SERVER_DIR], check=True)
 
     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):
@@ -62,48 +84,33 @@ def setup_server():
             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}")
+    
+    # RUN THE PATCH BEFORE COMPILING
+    patch_server_code()
 
-    # 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
+    # Only compile if the output file doesn't exist to save startup time on reboots
+    if not os.path.exists(os.path.join(SERVER_DIR, "models", "grammar.bin")): # Heuristic check
+        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:
+            print("Rule compilation warning (ignoring)...")
 
 # =============================================================================
 # 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...
+    # We explicitly add spellutils.jar to classpath here, rendering the 'from:' syntax obsolete
     classpath = f"lib/sleep.jar{cp_sep}lib/moconti.jar{cp_sep}lib/spellutils.jar"
     sleep_cp = f"lib{cp_sep}service/code"
 
@@ -121,9 +128,8 @@ def start_backend():
         "httpd.Moconti",
         "atdconfig.sl"
     ]
-
-    print(f"Executing: {' '.join(cmd)}")
-    # Start process, redirect stdout/stderr so we can see logs in HF console
+    
+    # Start in SERVER_DIR so relative paths (./models) work
     return subprocess.Popen(cmd, cwd=SERVER_DIR)
 
 def wait_for_port(timeout=60):
@@ -139,23 +145,28 @@ def wait_for_port(timeout=60):
     return False
 
 # =============================================================================
-# PHASE 3: CLIENT LOGIC (Embedded PyATD)
+# PHASE 3: CLIENT
 # =============================================================================
 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)
+            conn = http.client.HTTPConnection(HOST, 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())
+            # If server is still warming up, it might return 503 or connection drop
+            if resp.status != 200: 
+                print(f"Server returned status: {resp.status}")
+                return []
+            
+            data = resp.read()
+            # Basic check for valid XML
+            if not data.strip().startswith(b"<"):
+                return []
+
+            root = ET.fromstring(data)
             errors = []
             for e in root.findall('error'):
                 err = {
@@ -174,71 +185,56 @@ class AtDClient:
             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)
+        search_start = last_pos
         
+        # Context aware search
+        if err['precontext']:
+            context_idx = text.find(err['precontext'], last_pos)
+            if context_idx != -1:
+                search_start = context_idx + len(err['precontext'])
+
+        idx = text.find(word, search_start)
         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 idx > last_pos:
+                output.append((text[last_pos:idx], None))
             
-        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)
+            output.append((text[idx:idx+len(word)], label))
+            last_pos = idx + 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
+    # Give it a moment to fail if java crashes immediately
+    time.sleep(2)
+    if server_proc.poll() is not None:
+        print("Java server crashed immediately. Checking logs...")
+        print(server_proc.stdout)
+        print(server_proc.stderr)
+        sys.exit(1)
+
     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.")
+            gr.Markdown("# 🛡️ After The Deadline (Self-Installing)")
+            gr.Markdown("Java 17 Compatible | Auto-Patching | Auto-Models")
             
             with gr.Row():
                 inp = gr.Textbox(label="Input", placeholder="Type here... e.g., I has a error.", lines=6)