debugging oblige image

Author: Grant Moore

Dockerfile.oblige

@@ -22,7 +22,7 @@ WORKDIR /build
 # Download, extract, and build Oblige 7.7.0
 RUN wget http://sourceforge.net/projects/oblige/files/Oblige/7.70/oblige-770-source.zip && \
     unzip oblige-770-source.zip && \
-    mv oblige-770-source oblige
+    mv Oblige-7.70-source oblige
 
 WORKDIR /build/oblige
 
@@ -35,8 +35,10 @@ FROM ubuntu:18.04
 ENV DEBIAN_FRONTEND=noninteractive
 
 # Install only the runtime libraries required to execute the binary
+# Added libfltk-images1.3 to resolve the missing libfltk_images.so.1.3 dependency
 RUN apt-get update && apt-get install -y \
     libfltk1.3 \
+    libfltk-images1.3 \
     zlib1g \
     libxft2 \
     libxinerama1 \
@@ -57,4 +59,4 @@ COPY --from=builder /build/oblige/language/ ./language/
 COPY --from=builder /build/oblige/data/ ./data/
 
 # Default entrypoint routes to the executable
-ENTRYPOINT ["/opt/oblige/Oblige"]
+ENTRYPOINT ["./Oblige"]

app/sample/__init__.py

@@ -1,5 +1,6 @@
 
 from app.sample.randomize import randomize
 from app.sample.generate import generate
+from app.sample.init import init
 
-__all__ = [ 'generate', 'randomize']
+__all__ = [ 'generate', 'randomize', 'init']

app/sample/init.py

@@ -0,0 +1,73 @@
+"""
+Initialization Module: Environment Setup.
+"""
+# Standard Libraries
+import logging
+import subprocess
+import sys
+
+# Application Libraries
+from app.models.config import GolemConfig
+from app.utils.conf import register_command
+
+logger = logging.getLogger(__name__)
+
+@register_command("init")
+def init(cfg: GolemConfig):
+    """
+    Initializes the Golem environment by verifying and building required Docker images.
+    """
+    logger.info("Initializing Golem environment...")
+    image_name = "golem-oblige:latest"
+
+    # 1. Check if Docker is installed (executable exists in PATH)
+    try:
+        subprocess.run(
+            ["docker", "--version"], 
+            check=True, 
+            stdout=subprocess.DEVNULL, 
+            stderr=subprocess.DEVNULL
+        )
+    except FileNotFoundError:
+        logger.error("Docker is not installed or not in PATH. Please install Docker to continue.")
+        sys.exit(1)
+
+    # 2. Check if Docker daemon is running
+    daemon_check = subprocess.run(
+        ["docker", "info"], 
+        stdout=subprocess.DEVNULL, 
+        stderr=subprocess.DEVNULL
+    )
+    if daemon_check.returncode != 0:
+        logger.error("Docker daemon is not responsive. Please start Docker and try again.")
+        sys.exit(1)
+
+    # 3. Check if the Oblige image already exists
+    image_check = subprocess.run(
+        ["docker", "image", "inspect", image_name], 
+        stdout=subprocess.DEVNULL, 
+        stderr=subprocess.DEVNULL
+    )
+
+    if image_check.returncode == 0:
+        logger.info(f"Docker image '{image_name}' already exists. Ready for procedural generation.")
+        return
+
+    # 4. Build the image
+    logger.info(f"Docker image '{image_name}' not found. Initiating build...")
+    build_cmd = [
+        "docker", "buildx", "build",
+        "-f", "Dockerfile.oblige",
+        "-t", image_name,
+        "--load", # Ensures the image is loaded into the local docker daemon
+        "."
+    ]
+
+    try:
+        # Note: We do not capture stdout/stderr here so the user can see 
+        # the standard Docker build progression in their terminal.
+        subprocess.run(build_cmd, check=True)
+        logger.info(f"Successfully built '{image_name}'.")
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Failed to build '{image_name}'. Process exited with code: {e.returncode}")
+        sys.exit(1)

app/utils/doom.py

@@ -22,25 +22,26 @@
 
 class ObligeGenerator:
     def __init__(self, cfg: RandomizerConfig):
-        self.executable = resolve_path(cfg.executable)
-        self.output_dir = Path(resolve_path(cfg.output))
+        # We ensure the output directory is an absolute path for Docker volume mounting
+        self.output_dir = Path(resolve_path(cfg.output)).absolute()
         self.output_dir.mkdir(parents=True, exist_ok=True)
 
         # Dump the Pydantic model into a dict so we can sample from it
         self.base_oblige_config = cfg.oblige.model_dump()
 
-        if not os.path.exists(self.executable):
-            raise FileNotFoundError(f"Oblige executable not found at: {self.executable}")
-
     def build_map(self, filename: str = "golem_procgen.wad") -> str:
-        """Compiles the map using the headless CLI with randomized parameters."""
+        """Compiles the map using the containerized Oblige engine with randomized parameters."""
         target_wad_absolute = str(self.output_dir / filename)
-        temp_wad_name = "temp_batch.wad" 
-
-        # HACK: There is an issue with how Oblige discovered the working directory of the executable
-        #       when it is called with an absolute path. This hack emulates the terminal exactly by 
-        #       forcing argv[0] to be "./Oblige" instead of the absolute path.
-        args = ["./Oblige", "--batch", temp_wad_name]
+        temp_wad_name = "temp.wad" 
+        container_output_dir = "/output"
+
+        # Execute via Docker, mounting the host output directory to the container
+        args = [
+            "docker", "run", "--rm",
+            "-v", f"{self.output_dir}:{container_output_dir}",
+            "golem-oblige:latest",
+            "--batch", f"{container_output_dir}/{temp_wad_name}"
+        ]
 
         # Dynamically sample from lists to randomize the map config on the fly
         active_params = {}
@@ -49,24 +50,23 @@ def build_map(self, filename: str = "golem_procgen.wad") -> str:
             active_params[key] = chosen_val
             args.append(f"{key}={chosen_val}")
 
-        logger.info(f"Compiling procedural map with parameters: {active_params}")
+        logger.info(f"Compiling procedural map via Docker with parameters: {active_params}")
 
         try:
-            oblige_dir = os.path.dirname(self.executable)
-            subprocess.run(args, check=True, capture_output=True, text=True, cwd=oblige_dir)
+            subprocess.run(args, check=True, capture_output=True, text=True)
 
-            compiled_temp_path = os.path.join(oblige_dir, temp_wad_name)
-            if os.path.exists(compiled_temp_path):
-                shutil.move(compiled_temp_path, target_wad_absolute)
+            compiled_temp_path = self.output_dir / temp_wad_name
+            if compiled_temp_path.exists():
+                shutil.move(str(compiled_temp_path), target_wad_absolute)
                 logger.info(f"Map compiled and moved successfully: {target_wad_absolute}")
                 return target_wad_absolute
             else:
-                raise FileNotFoundError("Oblige returned success, but the temporary WAD file is missing.")
+                raise FileNotFoundError("Docker returned success, but the temporary WAD file is missing.")
 
         except subprocess.CalledProcessError as e:
-            logger.error(f"Oblige compilation failed with exit code {e.returncode}.")
-            logger.error(f"Oblige STDOUT:\n{e.stdout}") 
-            logger.error(f"Oblige STDERR:\n{e.stderr}")
+            logger.error(f"Oblige container failed with exit code {e.returncode}.")
+            logger.error(f"Docker STDOUT:\n{e.stdout}") 
+            logger.error(f"Docker STDERR:\n{e.stderr}")
             raise
 
 

data/wads/temp.old

@@ -166,6 +166,10 @@ The data extraction, LNN optimization, and evaluation mechanics are orchestrated
 
 ### Data Inspection & Auditing
 
-::: app.pipeline.analyze.inspect
+::: app.metrics.audit
 
-::: app.pipeline.analyze.audit
+::: app.metrics.examine
+
+::: app.metrics.inspect
+
+::: app.metrics.summary

docs/model/training.md

@@ -11,7 +11,7 @@
 from app.client import remote, server, spectate, client
 from app.metrics import audit, examine, inspect, models, summary
 from app.pipeline import intervene, train, record, run
-from app.sample import generate, randomize
+from app.sample import generate, randomize, init
 
 logger = logging.getLogger("main")