Update app.py

app.py

@@ -10,6 +10,7 @@ import urllib.parse
 import xml.etree.ElementTree as ET
 import shutil
 import re
+import glob
 
 # =============================================================================
 # CONFIGURATION
@@ -29,43 +30,44 @@ MODEL_FILES = [
 ]
 
 # =============================================================================
-# PHASE 1: AUTO-INSTALLATION & SETUP
+# PHASE 1: SETUP & PATCHING
 # =============================================================================
-def patch_server_code():
+def recursive_patch_code():
     """
-    Patches legacy Sleep code to run on modern Java (JDK 9+).
-    Removes 'from: lib/spellutils.jar' syntax which causes ClassCastException.
+    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] PATCHING CODE FOR JAVA 17+ ---")
+    print("--- [PHASE 1.5] RECURSIVE CODE PATCHING (JAVA 17 COMPATIBILITY) ---")
     
-    # 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
-    ]
+    # Find all .sl files in the server directory
+    sl_files = glob.glob(f"{SERVER_DIR}/**/*.sl", recursive=True)
     
-    for file_path in files_to_check:
-        if not os.path.exists(file_path):
-            continue
+    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)
 
+    for file_path in sl_files:
         try:
-            with open(file_path, "r") as f:
+            with open(file_path, "r", encoding="utf-8", errors="ignore") 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)
+            # Apply the regex
+            new_content = regex.sub('', content)
             
             if content != new_content:
                 print(f"Patching {file_path}...")
-                with open(file_path, "w") as f:
+                with open(file_path, "w", encoding="utf-8") as f:
                     f.write(new_content)
-                print("-> Success: Code patched for modern Java.")
-            else:
-                print(f"-> {file_path} already clean.")
-                
+                patched_count += 1
         except Exception as e:
-            print(f"Error patching {file_path}: {e}")
+            print(f"Warning: Could not patch {file_path}: {e}")
+            
+    print(f"-> Successfully patched {patched_count} files.")
 
 def setup_server():
     print("--- [PHASE 0] CHECKING REPOSITORY ---")
@@ -86,31 +88,49 @@ def setup_server():
                 urllib.request.urlretrieve(url, filepath)
             except Exception as e:
                 print(f"  -> FAILED: {e}")
-    
-    # RUN THE PATCH BEFORE COMPILING
-    patch_server_code()
+                sys.exit(1)
+
+    # Patch code BEFORE compiling
+    recursive_patch_code()
 
     print("\n--- [PHASE 2] COMPILING RULES ---")
-    # 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)...")
+    # 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"
+        ]
+        
+        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)
 
 # =============================================================================
-# PHASE 2: SERVER MANAGEMENT
+# PHASE 2: SERVER RUNNER
 # =============================================================================
 def start_backend():
     print("\n--- [PHASE 3] STARTING SERVER ---")
     cp_sep = ";" if os.name == 'nt' else ":"
     
-    # We explicitly add spellutils.jar to classpath here, rendering the 'from:' syntax obsolete
+    # 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"
 
@@ -129,7 +149,7 @@ def start_backend():
         "atdconfig.sl"
     ]
     
-    # Start in SERVER_DIR so relative paths (./models) work
+    print("Launching Java subprocess...")
     return subprocess.Popen(cmd, cwd=SERVER_DIR)
 
 def wait_for_port(timeout=60):
@@ -157,16 +177,15 @@ class AtDClient:
             resp = conn.getresponse()
             
             # 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 []
+            if resp.status != 200: return []
+            
+            # Read response
+            xml_text = resp.read().decode('utf-8', errors='ignore')
             
-            data = resp.read()
-            # Basic check for valid XML
-            if not data.strip().startswith(b"<"):
-                return []
+            # Basic XML validation
+            if not xml_text.strip().startswith("<"): return []
 
-            root = ET.fromstring(data)
+            root = ET.fromstring(xml_text)
             errors = []
             for e in root.findall('error'):
                 err = {
@@ -196,8 +215,6 @@ def analyze_text(text):
     for err in errors:
         word = err['string']
         search_start = last_pos
-        
-        # Context aware search
         if err['precontext']:
             context_idx = text.find(err['precontext'], last_pos)
             if context_idx != -1:
@@ -223,27 +240,26 @@ if __name__ == "__main__":
     setup_server()
     server_proc = start_backend()
     
-    # Give it a moment to fail if java crashes immediately
-    time.sleep(2)
+    # Monitoring loop
+    # We check the process status before starting the UI
+    time.sleep(3)
     if server_proc.poll() is not None:
-        print("Java server crashed immediately. Checking logs...")
-        print(server_proc.stdout)
-        print(server_proc.stderr)
+        print("FATAL: Java server exited immediately. Check console for ClassCastException.")
         sys.exit(1)
 
-    if wait_for_port():
+    if wait_for_port(timeout=120): # Give it 2 minutes to load models
         with gr.Blocks(title="AtD Self-Hosted") as demo:
-            gr.Markdown("# 🛡️ After The Deadline (Self-Installing)")
-            gr.Markdown("Java 17 Compatible | Auto-Patching | Auto-Models")
+            gr.Markdown("# 🛡️ After The Deadline")
+            gr.Markdown("Running on Java 17 (Patched)")
             
             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)
+                inp = gr.Textbox(label="Input", placeholder="Type text here...", lines=6)
+                out = gr.HighlightedText(label="Analysis", 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.")
+        print("FATAL: Server did not start (Timeout).")
         server_proc.kill()