fixed?

app.py

@@ -4,9 +4,9 @@ import uuid
 import os
 import logging
 import zipfile
-import importlib
 import wandb
 from contextlib import redirect_stdout, redirect_stderr
+import auto_forge
 
 USE_WANDB = "WANDB_API_KEY" in os.environ
 if USE_WANDB:
@@ -295,30 +295,23 @@ def run_autoforge_process(cmd, log_path):
     from joblib import parallel_backend
     cli_args = cmd[1:]
 
-    # Import the library's high-level module which contains the main() entrypoint
-    # that uses the internal @spaces.GPU decorators (autoforge/auto_forge.py).
-    # Do NOT fall back to any other module; require the project module to be present.
-    try:
-        autoforge_main = importlib.import_module("autoforge.auto_forge")
-    except Exception as e:
-        # If the direct import fails, write the error to the log and return failure.
-        with open(log_path, "a", encoding="utf-8") as log_f:
-            log_f.write(f"\nERROR: Could not import autoforge.auto_forge: {e}\n")
-        return -1
-
     exit_code = 0
-    with open(log_path, "w", buffering=1, encoding="utf-8") as log_f, \
-            redirect_stdout(log_f), redirect_stderr(log_f), parallel_backend("threading", n_jobs=-1):
+    # Ensure local project dir is first on sys.path so `import auto_forge` imports the file in this repo
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    if script_dir not in sys.path:
+        sys.path.insert(0, script_dir)
+
+    with open(log_path, "w", buffering=1, encoding="utf-8") as log_f, redirect_stdout(log_f), redirect_stderr(log_f), parallel_backend("threading", n_jobs=-1):
         try:
-            # Provide argv so the autoforge CLI parser sees the same arguments as before.
+            # Force a fresh import of the local module by removing any cached module
+            if "auto_forge" in sys.modules:
+                del sys.modules["auto_forge"]
+            auto_forge = __import__("auto_forge")
             sys.argv = ["autoforge"] + cli_args
-            # Call the library's main() function. It may call sys.exit(); capture that.
-            autoforge_main.main()
+            auto_forge.main()
         except SystemExit as e:
-            # Preserve the exit code behavior from the subprocess-style invocation.
             exit_code = e.code if isinstance(e.code, int) or e.code is None else 0
         except Exception as e:
-            # Log exceptions to the log file and return a failure code.
             log_f.write(f"\nERROR: {e}\n")
             exit_code = -1
 
@@ -799,22 +792,12 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                     if script_dir not in sys.path:
                         sys.path.insert(0, script_dir)
 
-                    # Import the local auto_forge module using a plain import (no importlib utilities)
                     with open(self.log_path, "a", encoding="utf-8") as lf, redirect_stdout(lf), redirect_stderr(lf):
                         try:
-                            # Use plain import; if already imported, the module's top-level code won't re-run.
-                            import auto_forge
-
                             # Provide argv for the module's CLI parsing and call main()
                             sys.argv = ["autoforge"] + (self.cmd[1:] if len(self.cmd) > 1 else [])
-                            if hasattr(auto_forge, "main"):
-                                try:
-                                    auto_forge.main()
-                                    self.returncode = 0
-                                except SystemExit as se:
-                                    self.returncode = se.code if isinstance(se.code, int) or se.code is None else 0
-                            else:
-                                raise AttributeError("auto_forge module does not expose a main() function")
+                            auto_forge.main()
+                            self.returncode = 0
                         except Exception as e:
                             lf.write(f"\nERROR while importing/running auto_forge: {exc_text(e)}\n")
                             self.exc = e