Update app.py

app.py

@@ -8,9 +8,8 @@ import gradio as gr
 import http.client
 import urllib.parse
 import xml.etree.ElementTree as ET
+import tarfile
 import shutil
-import re
-import glob
 
 # =============================================================================
 # CONFIGURATION
@@ -18,10 +17,15 @@ import glob
 REPO_URL = "https://github.com/Automattic/atd-server-next.git"
 SERVER_DIR = "atd-server-next"
 MODELS_DIR = os.path.join(SERVER_DIR, "models")
-MODEL_BASE_URL = "https://openatd.svn.wordpress.org/atd-server/models/"
+JAVA_DIR = "jdk8"  # Folder to install portable Java
 HOST = "127.0.0.1"
 PORT = 1049
 
+# Official Adoptium Java 8 (LTS) Linux x64 URL
+JAVA_URL = "https://github.com/adoptium/temurin8-binaries/releases/download/jdk8u392-b08/OpenJDK8U-jre_x64_linux_hotspot_8u392b08.tar.gz"
+JAVA_BIN = os.path.join(os.getcwd(), JAVA_DIR, "bin", "java")
+
+MODEL_BASE_URL = "https://openatd.svn.wordpress.org/atd-server/models/"
 MODEL_FILES = [
     "cnetwork.bin", "cnetwork2.bin", "dictionary.txt", "edits.bin",
     "endings.bin", "hnetwork.bin", "hnetwork2.bin", "hnetwork4.bin",
@@ -30,49 +34,58 @@ MODEL_FILES = [
 ]
 
 # =============================================================================
-# PHASE 1: SETUP & PATCHING
+# PHASE -1: INSTALL JAVA 8 (The "Time Machine" Fix)
 # =============================================================================
-def recursive_patch_code():
-    """
-    Aggressively finds AND removes incompatible imports in ALL .sl files.
-    The syntax 'from: jarfile.jar' breaks on Java 9+.
-    We replace it with nothing, relying on the classpath passed to the java command.
-    """
-    print("--- [PHASE 1.5] RECURSIVE CODE PATCHING (JAVA 17 COMPATIBILITY) ---")
-    
-    # Find all .sl files in the server directory
-    sl_files = glob.glob(f"{SERVER_DIR}/**/*.sl", recursive=True)
+def install_java8():
+    """Downloads and installs portable Java 8."""
+    print("--- [PHASE -1] CHECKING JAVA RUNTIME ---")
     
-    patched_count = 0
-    # Regex explanation:
-    # from:     Matches the keyword
-    # \s* Matches whitespace
-    # [^;\n]+   Matches anything that ISN'T a semicolon or newline (the jar path)
-    # (?=;)     Lookahead to ensure we stop at the semicolon
-    regex = re.compile(r'from:\s*[^;\n]+(?=;)', re.IGNORECASE)
+    # If our local java binary exists, we assume it's installed
+    if os.path.exists(JAVA_BIN):
+        print(f"Portable Java 8 found at: {JAVA_BIN}")
+        return
 
-    for file_path in sl_files:
-        try:
-            with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
-                content = f.read()
-            
-            # Apply the regex
-            new_content = regex.sub('', content)
-            
-            if content != new_content:
-                print(f"Patching {file_path}...")
-                with open(file_path, "w", encoding="utf-8") as f:
-                    f.write(new_content)
-                patched_count += 1
-        except Exception as e:
-            print(f"Warning: Could not patch {file_path}: {e}")
-            
-    print(f"-> Successfully patched {patched_count} files.")
+    print("Java 8 not found. Downloading portable runtime (approx 40MB)...")
+    tar_path = "java8.tar.gz"
+    
+    try:
+        # Download
+        urllib.request.urlretrieve(JAVA_URL, tar_path)
+        print("Download complete. Extracting...")
+        
+        # Extract
+        with tarfile.open(tar_path, "r:gz") as tar:
+            # Find the root folder name inside the tar
+            root_name = tar.getnames()[0].split('/')[0]
+            tar.extractall()
+        
+        # Rename extracted folder to 'jdk8' for simplicity
+        if os.path.exists(JAVA_DIR):
+            shutil.rmtree(JAVA_DIR)
+        os.rename(root_name, JAVA_DIR)
+        
+        # Cleanup
+        os.remove(tar_path)
+        
+        # Set execute permissions
+        subprocess.run(["chmod", "+x", JAVA_BIN], check=True)
+        
+        print(f"Java 8 successfully installed to {JAVA_DIR}")
+        
+    except Exception as e:
+        print(f"FATAL: Failed to install Java 8. Error: {e}")
+        sys.exit(1)
 
+# =============================================================================
+# PHASE 1: REPO & MODELS
+# =============================================================================
 def setup_server():
-    print("--- [PHASE 0] CHECKING REPOSITORY ---")
+    # Ensure Java is ready first
+    install_java8()
+
+    print("\n--- [PHASE 0] CHECKING REPOSITORY ---")
     if not os.path.exists(SERVER_DIR):
-        print(f"Repository not found. Cloning from {REPO_URL}...")
+        print(f"Cloning {REPO_URL}...")
         subprocess.run(["git", "clone", "--depth", "1", REPO_URL, SERVER_DIR], check=True)
 
     print("\n--- [PHASE 1] CHECKING MODELS ---")
@@ -82,60 +95,47 @@ def setup_server():
     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)
+                urllib.request.urlretrieve(MODEL_BASE_URL + filename, filepath)
             except Exception as e:
                 print(f"  -> FAILED: {e}")
-                sys.exit(1)
-
-    # Patch code BEFORE compiling
-    recursive_patch_code()
 
     print("\n--- [PHASE 2] COMPILING RULES ---")
-    # We compile if rules.bin is missing. 
-    # Note: The compiler output is actually rules.bin (or parts of it loaded into memory)
-    # The previous error showed FileNotFound for models/rules.bin.
-    
-    # Classpath separator: ':' for Linux (Hugging Face), ';' for Windows
-    cp_sep = ";" if os.name == 'nt' else ":"
-    
-    try:
-        # We explicitly add the JARs to the compiler classpath too
-        cp = f"lib/sleep.jar{cp_sep}lib/moconti.jar{cp_sep}lib/spellutils.jar"
-        
-        cmd = [
-            "java", 
-            "-Datd.lowmem=true", 
-            "-Xmx1024M", 
-            "-classpath", cp,
-            "sleep.console.TextConsole", # Run the console directly to avoid jar limits
-            "utils/rules/rules.sl"
-        ]
+    # Only compile if grammar.bin doesn't exist (heuristic check)
+    if not os.path.exists(os.path.join(SERVER_DIR, "models", "grammar.bin")):
+        print("Compiling rules using Java 8...")
+        # Classpath separator is ':' on Linux
+        cp = "lib/sleep.jar:lib/moconti.jar:lib/spellutils.jar"
         
-        print("Executing Rule Compiler...")
-        subprocess.run(cmd, cwd=SERVER_DIR, check=True)
-        print("Rules compiled successfully.")
-        
-    except subprocess.CalledProcessError as e:
-        print(f"\nFATAL ERROR: Rule compilation failed with code {e.returncode}.")
-        print("This usually means the code patch failed or Java is incompatible.")
-        sys.exit(1)
+        try:
+            subprocess.run(
+                [
+                    JAVA_BIN, 
+                    "-Datd.lowmem=true", 
+                    "-Xmx1024M",
+                    "-classpath", cp, 
+                    "sleep.console.TextConsole", 
+                    "utils/rules/rules.sl"
+                ],
+                cwd=SERVER_DIR,
+                check=True
+            )
+            print("Rules compiled successfully.")
+        except subprocess.CalledProcessError as e:
+            print(f"Rule compilation warning: {e}")
 
 # =============================================================================
 # PHASE 2: SERVER RUNNER
 # =============================================================================
 def start_backend():
     print("\n--- [PHASE 3] STARTING SERVER ---")
-    cp_sep = ";" if os.name == 'nt' else ":"
     
-    # Robust Classpath
-    classpath = f"lib/sleep.jar{cp_sep}lib/moconti.jar{cp_sep}lib/spellutils.jar"
-    sleep_cp = f"lib{cp_sep}service/code"
+    classpath = "lib/sleep.jar:lib/moconti.jar:lib/spellutils.jar"
+    sleep_cp = "lib:service/code"
 
     cmd = [
-        "java",
+        JAVA_BIN,
         "-Dfile.encoding=UTF-8",
         "-XX:+AggressiveHeap",
         "-XX:+UseParallelGC",
@@ -149,7 +149,7 @@ def start_backend():
         "atdconfig.sl"
     ]
     
-    print("Launching Java subprocess...")
+    print(f"Launching with: {JAVA_BIN}")
     return subprocess.Popen(cmd, cwd=SERVER_DIR)
 
 def wait_for_port(timeout=60):
@@ -175,14 +175,9 @@ class AtDClient:
             headers = {"Content-Type": "application/x-www-form-urlencoded"}
             conn.request("POST", "/checkDocument", params, headers)
             resp = conn.getresponse()
-            
-            # If server is still warming up, it might return 503 or connection drop
             if resp.status != 200: return []
             
-            # Read response
             xml_text = resp.read().decode('utf-8', errors='ignore')
-            
-            # Basic XML validation
             if not xml_text.strip().startswith("<"): return []
 
             root = ET.fromstring(xml_text)
@@ -240,20 +235,18 @@ if __name__ == "__main__":
     setup_server()
     server_proc = start_backend()
     
-    # Monitoring loop
-    # We check the process status before starting the UI
-    time.sleep(3)
+    time.sleep(5)
     if server_proc.poll() is not None:
-        print("FATAL: Java server exited immediately. Check console for ClassCastException.")
+        print("FATAL: Java server exited immediately.")
         sys.exit(1)
 
-    if wait_for_port(timeout=120): # Give it 2 minutes to load models
+    if wait_for_port(timeout=120):
         with gr.Blocks(title="AtD Self-Hosted") as demo:
             gr.Markdown("# 🛡️ After The Deadline")
-            gr.Markdown("Running on Java 17 (Patched)")
+            gr.Markdown("Running on Portable Java 8")
             
             with gr.Row():
-                inp = gr.Textbox(label="Input", placeholder="Type text here...", lines=6)
+                inp = gr.Textbox(label="Input", placeholder="Type here... e.g., I has a error.", lines=6)
                 out = gr.HighlightedText(label="Analysis", combine_adjacent=True)
             
             btn = gr.Button("Check Text", variant="primary")