push jvm

app.py

@@ -1,209 +1,33 @@
-import os
-import glob
-from pathlib import Path
-import jpype
-import jpype.imports
-from jpype import JClass, getDefaultJVMPath
+import gradio as gr
+import traceback
 
-def _find_psl_jars() -> list[str]:
+def _check_jvm():
     """
-    Priority:
-      1) Any *.jar inside PSL_JARS_DIR (if set)
-      2) Any *.jar in ./jars next to this script
-      3) Installed pslpython runtime jar
+    Try starting the JVM and report status + jars used.
+    Safe to call multiple times (your start_psl_jvm handles the already-started case).
     """
-    jars: list[str] = []
-
-    # 2) Local ./jars
-    this_dir = Path(__file__).resolve().parent
-    jars_dir = this_dir
-    jars.extend(glob.glob(str(jars_dir / "*.jar")))
-
-    # 3) Try the pslpython runtime jar path
-    try:
-        import pslpython  # noqa: F401
-        # common install location (pslpython wheels vendor psl-runtime.jar)
-        import site
-        candidate_sites = site.getsitepackages() + [site.getusersitepackages()]
-        for sdir in candidate_sites:
-            jar = Path(sdir) / "pslpython" / "psl-runtime.jar"
-            if jar.exists():
-                jars.append(str(jar))
-    except Exception:
-        pass
-
-    # Deduplicate while preserving order
-    dedup = []
-    seen = set()
-    for j in jars:
-        if j not in seen and Path(j).is_file():
-            seen.add(j)
-            dedup.append(j)
-
-    return dedup
-
-def start_psl_jvm(verbose: bool = True) -> list[str]:
-    """
-    Start a JVM with a classpath that includes PSL jars.
-    Returns the list of jars used.
-    """
-    if jpype.isJVMStarted():
-        if verbose:
-            print("[PSL] JVM already started.")
-        return []
-
-    jars = _find_psl_jars()
-    if not jars:
-        raise RuntimeError(
-            "No PSL jars found. Set PSL_JARS_DIR to a folder with *.jar, "
-            "or place jars under ./jars, or ensure pslpython is installed with psl-runtime.jar."
-        )
-
-    classpath = os.pathsep.join(jars)
-
-    # If getDefaultJVMPath() fails on your platform, set JAVA_HOME first.
-    jvm_path = getDefaultJVMPath()
-
-    # Start JVM
-    jpype.startJVM(
-        jvm_path,
-        f"-Djava.class.path={classpath}",
-        # Optional: tighten memory or logging here
-        # "-Xms256m", "-Xmx1024m",
-    )
-
-    # Sanity check that PSL classes are visible
-    GA = JClass("org.linqs.psl.model.atom.GroundAtom")
-    if verbose:
-        print(f"[PSL] JVM started with {len(jars)} jars.")
-        for j in jars:
-            print(f"     - {j}")
-        print(f"[PSL] Sanity check: loaded {GA}")
-
-    return jars
-
-
-def print_files():
-    print("Printing files")
-    here = Path(__file__).resolve().parent  # directory of this file
-    files = [p.name for p in here.iterdir() if p.is_file()]
-    print(files)
-
-def ensure_java_env():
-    """
-    Set JAVA_HOME/PATH for JPype/PSL on HF Spaces (Debian).
-    Tries Temurin 17 (if you unpacked it in postBuild), then Debian OpenJDK 17/11.
-    """
-    candidates = (
-        "/usr/local/lib/temurin17",               # if you installed Temurin 17 in postBuild
-        "/usr/lib/jvm/java-17-openjdk-amd64",     # Debian OpenJDK 17
-        "/usr/lib/jvm/java-11-openjdk-amd64",     # Debian OpenJDK 11 (default-jdk on many images)
-    )
-    for guess in candidates:
-        if os.path.isdir(guess):
-            os.environ.setdefault("JAVA_HOME", guess)
-            os.environ["PATH"] = f"{guess}/bin:" + os.environ["PATH"]
-            break
-
-
-# --- Actions ----------------------------------------------------------------
-
-def psl_health_check():
-    ensure_java_env()
-    print(f"Running health check")
-    out = []
-
-    # 1) JPype can start a JVM?
-    try:
-        import jpype
-        if not jpype.isJVMStarted():
-            jpype.startJVM()
-        out.append("JPype: JVM started ✔")
-    except Exception as e:
-        print(f"Caught error {e}")
-        out.append("JPype: FAILED to start JVM ❌")
-        out.append(repr(e))
-
-    # 2) pslpython installed and its runtime jar present?
     try:
-        import pslpython as _pslpy, os as _os
-        print(f"pslpython import succeeded")
-        pkg_dir = _os.path.dirname(_pslpy.__file__)
-        jar_path = _os.path.join(pkg_dir, "psl-runtime.jar")
-        out.append(f"pslpython dir: {pkg_dir}")
-        out.append(f"psl-runtime.jar present: {os.path.exists(jar_path)} -> {jar_path}")
-        if not os.path.exists(jar_path):
-            out.append("⚠ If you installed pslpython with --no-deps, "
-                       "place a matching psl-runtime.jar at the path above.")
-
-        print(f"Running find acquaintances")
-        find_acquaintances()
-        print(f"pslpython ran successfully")
+        jars = start_psl_jvm(verbose=False)  # returns [] if already started
+        already = jpype.isJVMStarted() and (len(jars) == 0)
+        status = "✅ JVM already running." if already else "✅ JVM started."
+        # sanity check load (again) in case caller didn’t run verbose path
+        _ = JClass("org.linqs.psl.model.atom.GroundAtom")
+        details = {
+            "jvm_started": True,
+            "already_running": already,
+            "jars_loaded": jars,
+        }
+        return status, details
     except Exception as e:
-        out.append("pslpython import FAILED ❌")
-        out.append(repr(e))
-        print(f"pslpython import failed with error {e}")
-
-
-
-def render_predicate_tabs(base_dir=base_dir):
-    """
-    Create a tabbed, scrollable view of all text files in `base_dir`.
-    Tabs are titled by filename; each tab shows file contents.
-    """
-    gr.Markdown(f"### Predicate files in `{base_dir}`")
-
-    if not os.path.isdir(base_dir):
-        gr.Markdown(f"⚠️ Directory not found.")
-        return
-
-    # Glob common predicate/text data files; adjust patterns as needed
-    patterns = ["*.txt", "*.tsv", "*.data"]
-    files = []
-    for pat in patterns:
-        files.extend(glob.glob(os.path.join(base_dir, pat)))
-    files = sorted(set(files))
-
-    if not files:
-        gr.Markdown("*(No matching text files found.)*")
-        return
-
-    with gr.Tabs():
-        for path in files:
-            name = os.path.basename(path)
-            try:
-                with open(path, "r", encoding="utf-8", errors="replace") as f:
-                    content = f.read()
-            except Exception as e:
-                content = f"<<Failed to read file>>\n{e!r}"
-
-            with gr.Tab(name):
-                # Scrollable code box via elem_classes and CSS below
-                gr.Code(
-                    value=content,
-                    interactive=False,
-                    elem_classes=["scrollbox"],
-                    label=name,
-                )
-
-
-
-# --- Gradio UI ---------------------------------------------------------------
-
-with gr.Blocks(css="""
-.scrollbox { max-height: 480px; overflow: auto; }
-""") as demo:
-    gr.Markdown("# PSL setup check & toy inference (top-level files)")
-    with gr.Row():
-        btn_health = gr.Button("Run health check")
-
-    out = gr.Textbox(lines=32, label="Output")
-
-    btn_health.click(fn=psl_health_check, outputs=out)
-
-    gr.Markdown("---")
-    # Render the new tabbed predicate browser
-    render_predicate_tabs()
+        tb = traceback.format_exc(limit=2)
+        return f"❌ JVM start failed: {e}", {"traceback": tb}
+
+with gr.Blocks(title="PSL JVM Sanity Check") as demo:
+    gr.Markdown("### PSL JVM loader\nClick the button to start the JVM and verify PSL classes are reachable.")
+    btn = gr.Button("Start JVM")
+    status = gr.Textbox(label="Status", interactive=False)
+    info = gr.JSON(label="Details")
+    btn.click(fn=_check_jvm, inputs=None, outputs=[status, info])
 
 if __name__ == "__main__":
     demo.launch()