Software loading logic rewrite

Massive rewrite based on GColab working code for the 3 softwares instances.

README.md

@@ -2,9 +2,9 @@
 title: FormatAnalyser
 emoji: 🗂️
 colorFrom: red
-colorTo: green
+colorTo: yellow
 sdk: gradio
-sdk_version: 6.9.0
+sdk_version: "4.44.0"
 app_file: app.py
 pinned: false
 license: mit
@@ -76,4 +76,4 @@ python app.py
 
 - **JHOVE installer URL** may change with new releases — check [openpreservation.org](https://openpreservation.org/products/jhove/) if install fails
 - **DROID signature file** is downloaded from The National Archives; the version number in `app.py` may need updating over time
-- On Hugging Face Spaces the first analysis run triggers tool installation; subsequent runs in the same session skip this step
+- On Hugging Face Spaces the first analysis run triggers tool installation; subsequent runs in the same session skip this step

app.py

@@ -14,6 +14,10 @@ import shutil
 import tempfile
 import threading
 from pathlib import Path
+try:
+    import requests
+except ImportError:
+    requests = None
 
 import gradio as gr
 import pandas as pd
@@ -53,50 +57,109 @@ def setup_tools():
         log.append("✓ Siegfried already on PATH")
     else:
         log.append("⬇ Installing Siegfried…")
-        run_cmd("apt-get install -qq -y wget 2>/dev/null || true")
+        # try to fetch via apt/wget as before, but installation may not permit
+        # writing to /usr/local/bin on some environments (e.g. Colab), so we
+        # also support a user-space fallback where the binary is kept in a
+        # local directory and added to PATH.
+        run_cmd("apt-get install -qq -y wget unzip 2>/dev/null || true")
         run_cmd(
             "wget -q https://github.com/richardlehane/siegfried/releases/download/"
-            "v1.11.1/siegfried_1.11.1_linux64.tar.gz -O /tmp/sf.tar.gz"
+            "v1.11.4/siegfried_1-11-4_linux64.zip -O /tmp/sf.zip"
         )
-        run_cmd("tar -xzf /tmp/sf.tar.gz -C /usr/local/bin sf")
-        run_cmd("chmod +x /usr/local/bin/sf")
+        run_cmd("unzip -q /tmp/sf.zip -d /tmp/sf")
+        sf_bin = "/tmp/sf/sf"
+        # if the download/unzip above failed (no wget or unzip), try Python
+        if not os.path.exists(sf_bin):
+            # pure-Python fallback inspired by Colab snippet
+            siegfried_url = (
+                "https://github.com/richardlehane/siegfried/"
+                "releases/download/v1.11.4/siegfried_1-11-4_linux64.zip"
+            )
+            local_filename = os.path.join("/tmp", siegfried_url.split("/")[-1])
+            try:
+                import requests, zipfile
+
+                with requests.get(siegfried_url, stream=True) as r:
+                    r.raise_for_status()
+                    with open(local_filename, "wb") as f:
+                        for chunk in r.iter_content(chunk_size=8192):
+                            f.write(chunk)
+                os.makedirs("/tmp/sf", exist_ok=True)
+                with zipfile.ZipFile(local_filename, "r") as zip_ref:
+                    zip_ref.extractall(path="/tmp/sf")
+            except Exception:
+                pass
+        # ensure executable
+        if os.path.exists(sf_bin):
+            run_cmd(f"chmod +x {sf_bin}")
+        # attempt to move into system path, but don't fail if we can't
+        moved = False
+        try:
+            run_cmd(f"mv {sf_bin} /usr/local/bin/sf")
+            run_cmd("chmod +x /usr/local/bin/sf")
+            moved = True
+        except Exception:
+            # ignore permission issues
+            pass
+
+        # always make sure the directory containing the binary is in PATH
+        os.environ["PATH"] += os.pathsep + os.path.dirname(sf_bin)
+
+        # update signatures using whatever sf binary is found in PATH
         run_cmd("sf -update 2>&1 || true")
+
         if shutil.which("sf"):
             TOOL_STATE["siegfried"]["ready"] = True
-            log.append("✓ Siegfried installed")
+            log.append(
+                "✓ Siegfried installed" + (" to /usr/local/bin" if moved else " (user path)")
+            )
         else:
             log.append("✗ Siegfried install failed")
 
     # ── DROID ─────────────────────────────────────────────────────────────────
-    DROID_VERSION = "6.7.0"
-    jar_candidates = [
-        f"/opt/droid/droid-command-line-{DROID_VERSION}.jar",
-        "/opt/droid/droid-command-line.jar",
-    ]
+    DROID_VERSION = "6.9.12"
     sig_path = "/root/.droid6/signature_files/DROID_SignatureFile_V118.xml"
 
-    jar_path = next((p for p in jar_candidates if os.path.exists(p)), None)
-    if jar_path is None:
-        stdout, _, _ = run_cmd("find /opt/droid -name '*.jar' 2>/dev/null | head -1")
-        if stdout:
-            jar_path = stdout
-
-    if jar_path and os.path.exists(jar_path):
+    # check for either jar or helper script on PATH
+    jar_path = None
+    script_path = shutil.which("droid") or shutil.which("droid.sh")
+    if script_path:
+        # we can rely on the script to locate the jar itself later
         TOOL_STATE["droid"]["ready"] = True
-        TOOL_STATE["droid"]["jar"] = jar_path
-        log.append(f"✓ DROID already at {jar_path}")
+        TOOL_STATE["droid"]["jar"] = script_path
+        log.append(f"✓ DROID script already on PATH ({script_path})")
     else:
+        jar_candidates = [
+            f"/opt/droid/droid-command-line-{DROID_VERSION}.jar",
+            "/opt/droid/droid-command-line.jar",
+        ]
+        jar_path = next((p for p in jar_candidates if os.path.exists(p)), None)
+        if jar_path is None:
+            stdout, _, _ = run_cmd("find /opt/droid -name '*.jar' 2>/dev/null | head -1")
+            if stdout:
+                jar_path = stdout
+        if jar_path and os.path.exists(jar_path):
+            TOOL_STATE["droid"]["ready"] = True
+            TOOL_STATE["droid"]["jar"] = jar_path
+            log.append(f"✓ DROID already at {jar_path}")
+    # if we still aren't ready, attempt installation/fallback
+    if not TOOL_STATE["droid"]["ready"]:
         log.append("⬇ Installing DROID…")
-        run_cmd("apt-get install -qq -y default-jre unzip wget 2>/dev/null || true")
+        run_cmd("apt-get install -qq -y openjdk-21-jre-headless default-jre unzip wget 2>/dev/null || true")
+        # primary mechanism: download the binary bundle and extract locally
         DROID_URL = (
             f"https://github.com/digital-preservation/droid/releases/download/"
-            f"droid-{DROID_VERSION}/droid-command-line-{DROID_VERSION}-bin.zip"
+            f"{DROID_VERSION}/droid-binary-{DROID_VERSION}-bin.zip"
         )
         run_cmd(f"wget -q {DROID_URL} -O /tmp/droid.zip")
-        run_cmd("unzip -q /tmp/droid.zip -d /opt/droid")
-        stdout, _, _ = run_cmd("find /opt/droid -name '*.jar' 2>/dev/null | head -1")
+        run_cmd("mkdir -p /tmp/droid && unzip -q /tmp/droid.zip -d /tmp/droid")
+        # look for jar in extracted tree
+        stdout, _, _ = run_cmd("find /tmp/droid -name '*.jar' 2>/dev/null | head -1")
         if stdout:
             jar_path = stdout
+            # also add the containing directory to PATH so droid.sh can execute
+            dirname = os.path.dirname(jar_path)
+            os.environ["PATH"] += os.pathsep + dirname
             TOOL_STATE["droid"]["ready"] = True
             TOOL_STATE["droid"]["jar"] = jar_path
             log.append(f"✓ DROID installed: {jar_path}")
@@ -117,36 +180,67 @@ def setup_tools():
         log.append("⚠ DROID signature file missing — results may be limited")
 
     # ── JHOVE ──────────────────────────────────────────────────────────────────
-    jhove_sh = "/opt/jhove/jhove"
-    if not os.path.exists(jhove_sh):
+    # target installation directory (fallback to /opt if possible)
+    jhove_dir = "/opt/jhove"
+    jhove_bin = os.path.join(jhove_dir, "jhove")
+
+    # helper that sets state when we have a working binary
+    def set_jhove(path):
+        TOOL_STATE["jhove"]["ready"] = True
+        TOOL_STATE["jhove"]["path"] = path
+        log.append(f"✓ JHOVE ready at {path}")
+        # make sure environment is aware of it
+        os.environ["PATH"] += os.pathsep + os.path.dirname(path)
+        os.environ["JHOVE_HOME"] = os.path.dirname(path)
+
+    if os.path.exists(jhove_bin):
+        set_jhove(jhove_bin)
+    else:
+        # search anywhere under /opt/jhove in case installer wrote elsewhere
         stdout, _, _ = run_cmd(
             "find /opt/jhove -name 'jhove' -not -name '*.jar' 2>/dev/null | head -1"
         )
-        if stdout:
-            jhove_sh = stdout
+        if stdout and os.path.exists(stdout):
+            set_jhove(stdout)
 
-    if os.path.exists(jhove_sh):
-        TOOL_STATE["jhove"]["ready"] = True
-        TOOL_STATE["jhove"]["path"] = jhove_sh
-        log.append(f"✓ JHOVE already at {jhove_sh}")
-    else:
+    if not TOOL_STATE["jhove"]["ready"]:
         log.append("⬇ Installing JHOVE (may take ~2 min)…")
-        run_cmd("apt-get install -qq -y default-jre wget 2>/dev/null || true")
-        run_cmd(
-            "wget -q https://software.openpreservation.org/rel/jhove/"
-            "jhove-xplt-installer-1.28.0.jar -O /tmp/jhove-installer.jar"
+        # Ensure Java 21 is available
+        run_cmd("apt-get install -qq -y openjdk-21-jre-headless wget 2>/dev/null || true")
+        # download installer jar
+        run_cmd("wget -q -O /tmp/jhove-latest.jar https://software.openpreservation.org/rel/jhove-latest.jar")
+
+        # create an automated installation xml and run it
+        config_xml = "/tmp/jhove-auto.xml"
+        install_target = jhove_dir
+        xml_content = f"""<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>
+<AutomatedInstallation langpack=\"eng\">
+    <com.izforge.izpack.panels.htmlhello.HTMLHelloPanel id=\"welcome\"/>
+    <com.izforge.izpack.panels.target.TargetPanel id=\"install_dir\">
+        <installpath>{install_target}</installpath>
+    </com.izforge.izpack.panels.target.TargetPanel>
+    <com.izforge.izpack.panels.packs.PacksPanel id=\"sdk_pack_select\">
+        <pack index=\"0\" name=\"JHOVE Application\" selected=\"true\"/>
+        <pack index=\"1\" name=\"JHOVE Shell Scripts\" selected=\"true\"/>
+        <pack index=\"2\" name=\"JHOVE External Modules\" selected=\"true\"/>
+    </com.izforge.izpack.panels.packs.PacksPanel>
+    <com.izforge.izpack.panels.install.InstallPanel id=\"install\"/>
+    <com.izforge.izpack.panels.finish.FinishPanel id=\"finish\"/>
+</AutomatedInstallation>
+"""
+        try:
+            with open(config_xml, "w") as f:
+                f.write(xml_content)
+            run_cmd(f"java -jar /tmp/jhove-latest.jar {config_xml}")
+        except Exception:
+            pass
+
+        # look for the binary again in the installation directory
+        stdout, _, _ = run_cmd(
+            f"find {install_target} -name 'jhove' -not -name '*.jar' 2>/dev/null | head -1"
         )
-        run_cmd("java -jar /tmp/jhove-installer.jar -console -dir /opt/jhove")
-        if not os.path.exists(jhove_sh):
-            stdout, _, _ = run_cmd(
-                "find /opt/jhove -name 'jhove' -not -name '*.jar' 2>/dev/null | head -1"
-            )
-            if stdout:
-                jhove_sh = stdout
-        if os.path.exists(jhove_sh):
-            TOOL_STATE["jhove"]["ready"] = True
-            TOOL_STATE["jhove"]["path"] = jhove_sh
-            log.append(f"✓ JHOVE installed: {jhove_sh}")
+        if stdout and os.path.exists(stdout):
+            set_jhove(stdout)
         else:
             log.append("✗ JHOVE install failed")
 
@@ -193,14 +287,26 @@ def run_droid(filepath: str) -> dict:
         with tempfile.TemporaryDirectory() as tmp:
             profile = os.path.join(tmp, "profile.droid")
             csv_out = os.path.join(tmp, "export.csv")
-            subprocess.run(
-                ["java", "-jar", jar, "-a", filepath, "-Ns", sig, "-p", profile],
-                capture_output=True, text=True, timeout=120
-            )
-            export = subprocess.run(
-                ["java", "-jar", jar, "-p", profile, "-e", csv_out],
-                capture_output=True, text=True, timeout=60
-            )
+            # if jar points to a shell script, invoke it directly; otherwise
+            # assume it's a jar and run with java -jar.
+            if jar.endswith(".sh") or jar.endswith("droid"):
+                subprocess.run(
+                    [jar, "-a", filepath, "-Ns", sig, "-p", profile],
+                    capture_output=True, text=True, timeout=120
+                )
+                export = subprocess.run(
+                    [jar, "-p", profile, "-e", csv_out],
+                    capture_output=True, text=True, timeout=60
+                )
+            else:
+                subprocess.run(
+                    ["java", "-jar", jar, "-a", filepath, "-Ns", sig, "-p", profile],
+                    capture_output=True, text=True, timeout=120
+                )
+                export = subprocess.run(
+                    ["java", "-jar", jar, "-p", profile, "-e", csv_out],
+                    capture_output=True, text=True, timeout=60
+                )
             if os.path.exists(csv_out):
                 with open(csv_out) as f:
                     rows = list(csv.DictReader(f))

packages.txt

@@ -1,3 +1,4 @@
+openjdk-21-jre-headless
 default-jre
 wget
 unzip

requirements.txt

@@ -1,2 +1,3 @@
 gradio>=4.0.0
 pandas>=2.0.0
+requests>=2.0.0