update wan2gp logging by adding a wrapper script to capture output in console and pin setuptools for pkg_resources fix

Author: mohnjiles

StabilityMatrix.Core/Models/Packages/A3WebUI.cs

@@ -306,7 +306,7 @@ void HandleConsoleOutput(ProcessOutput s)
     public override IReadOnlyList<string> ExtraLaunchArguments =>
         settingsManager.IsLibraryDirSet ? ["--gradio-allowed-path", settingsManager.ImagesDirectory] : [];
 
-    private ImmutableDictionary<string, string> GetEnvVars(ImmutableDictionary<string, string> env)
+    protected virtual ImmutableDictionary<string, string> GetEnvVars(ImmutableDictionary<string, string> env)
     {
         // Set the Stable Diffusion repository URL to a working fork
         // This is required because the original Stability-AI/stablediffusion repo was removed

StabilityMatrix.Core/Models/Packages/Reforge.cs

@@ -1,4 +1,5 @@
-using Injectio.Attributes;
+using System.Collections.Immutable;
+using Injectio.Attributes;
 using StabilityMatrix.Core.Helper;
 using StabilityMatrix.Core.Helper.Cache;
 using StabilityMatrix.Core.Python;
@@ -36,4 +37,8 @@ IPipWheelService pipWheelService
     public override PackageDifficulty InstallerSortOrder => PackageDifficulty.Recommended;
     public override bool OfferInOneClickInstaller => true;
     public override PackageType PackageType => PackageType.SdInference;
+
+    protected override ImmutableDictionary<string, string> GetEnvVars(
+        ImmutableDictionary<string, string> env
+    ) => env;
 }

StabilityMatrix.Core/Models/Packages/SDWebForge.cs

@@ -189,7 +189,7 @@ torchIndex is TorchIndex.Cuda
 
         var config = new PipInstallConfig
         {
-            PrePipInstallArgs = ["joblib"],
+            PrePipInstallArgs = ["joblib", "setuptools<82"],
             RequirementsFilePaths = requirementsPaths,
             TorchVersion = "",
             TorchvisionVersion = "",
@@ -199,7 +199,7 @@ torchIndex is TorchIndex.Cuda
             [
                 "https://github.com/openai/CLIP/archive/d50d76daa670286dd6cacf3bcd80b5e4823fc8e1.zip",
             ],
-            PostInstallPipArgs = ["numpy==1.26.4"],
+            PostInstallPipArgs = ["numpy==1.26.4", "setuptools<82"],
         };
 
         await StandardPipInstallProcessAsync(

StabilityMatrix.Core/Models/Packages/Wan2GP.cs

@@ -86,6 +86,78 @@ IPipWheelService pipWheelService
     /// </summary>
     private bool IsAmdRocm => GetRecommendedTorchVersion() == TorchIndex.Rocm;
 
+    /// <summary>
+    /// Python wrapper script that patches logging to also print to stdout/stderr, so
+    /// StabilityMatrix can capture the output. Wan2GP logs through Gradio UI notifications
+    /// (gr.Info/Warning/Error) and callback-driven UI updates that never reach the console.
+    /// This script:
+    /// 1. Configures Python's logging module to output to stderr (captures library logging)
+    /// 2. Prevents transformers from suppressing its own logging (wgp.py calls set_verbosity_error)
+    /// 3. Monkey-patches gr.Info/Warning/Error to also print to stdout/stderr
+    /// 4. Runs the target script (wgp.py) via runpy
+    /// </summary>
+    private const string GradioLogPatchScript = """
+        # StabilityMatrix: Patch logging to print to console for capture.
+        import sys
+        import logging
+
+        def _apply_logging_patch():
+            # Configure Python's root logger to output to stderr at INFO level.
+            # Many libraries (torch, diffusers, transformers, etc.) use the logging
+            # module but output may be suppressed without a handler configured.
+            root = logging.getLogger()
+            if not any(isinstance(h, logging.StreamHandler) for h in root.handlers):
+                handler = logging.StreamHandler(sys.stderr)
+                handler.setFormatter(logging.Formatter("[%(name)s] %(levelname)s: %(message)s"))
+                root.addHandler(handler)
+            if root.level > logging.INFO:
+                root.setLevel(logging.INFO)
+
+            # Prevent transformers from suppressing its own logging.
+            # wgp.py calls transformers.utils.logging.set_verbosity_error() which
+            # silences all non-error messages. We neutralize those calls so model
+            # loading and download messages remain visible.
+            try:
+                import transformers.utils.logging as tf_logging
+                tf_logging.set_verbosity_error = lambda: None
+                tf_logging.set_verbosity_warning = lambda: None
+                tf_logging.set_verbosity(logging.INFO)
+            except Exception:
+                pass
+
+            # Monkey-patch Gradio's UI notification functions to also print to console.
+            # These only fire for validation/error messages, not generation progress.
+            try:
+                import gradio as gr
+                _orig_info = getattr(gr, 'Info', None)
+                _orig_warning = getattr(gr, 'Warning', None)
+                _orig_error = getattr(gr, 'Error', None)
+                if _orig_info is not None:
+                    def patched_info(message, *args, **kwargs):
+                        print(f"[Gradio] {message}", flush=True)
+                        return _orig_info(message, *args, **kwargs)
+                    gr.Info = patched_info
+                if _orig_warning is not None:
+                    def patched_warning(message, *args, **kwargs):
+                        print(f"[Gradio] WARNING: {message}", flush=True)
+                        return _orig_warning(message, *args, **kwargs)
+                    gr.Warning = patched_warning
+                if _orig_error is not None:
+                    def patched_error(message, *args, **kwargs):
+                        print(f"[Gradio] ERROR: {message}", file=sys.stderr, flush=True)
+                        return _orig_error(message, *args, **kwargs)
+                    gr.Error = patched_error
+            except Exception:
+                pass
+
+        if __name__ == "__main__":
+            _apply_logging_patch()
+            target_script = sys.argv[1]
+            sys.argv = sys.argv[1:]
+            import runpy
+            runpy.run_path(target_script, run_name="__main__")
+        """;
+
     public override List<LaunchOptionDefinition> LaunchOptions =>
         [
             new()
@@ -386,13 +458,22 @@ await SetupVenv(installLocation, pythonVersion: PyVersion.Parse(installedPackage
             return env;
         });
 
+        // Write the Gradio logging patch wrapper script so gr.Info/Warning/Error
+        // messages are also printed to stdout/stderr for console capture
+        var patchScriptPath = Path.Combine(installLocation, "_sm_gradio_log_patch.py");
+        await File.WriteAllTextAsync(patchScriptPath, GradioLogPatchScript, cancellationToken)
+            .ConfigureAwait(false);
+
+        var targetScript = Path.Combine(installLocation, options.Command ?? LaunchCommand);
+
         // Notify user that the package is starting (loading can take a while)
         onConsoleOutput?.Invoke(
             new ProcessOutput { Text = "Launching Wan2GP, please wait while the UI initializes...\n" }
         );
 
+        // Launch via the patch wrapper, which monkey-patches Gradio then runs wgp.py
         VenvRunner.RunDetached(
-            [Path.Combine(installLocation, options.Command ?? LaunchCommand), .. options.Arguments],
+            [patchScriptPath, targetScript, .. options.Arguments],
             HandleConsoleOutput,
             OnExit
         );