Add results processing/display

Author: evilkermit

examples/run_ndip_tool/model.py

@@ -1,10 +1,13 @@
 """Model implementation for NDIP tool example."""
 
 from enum import Enum
-from typing import Tuple
+from io import BytesIO
+from typing import List, Tuple
 
 from nova.galaxy import Parameters, Tool
 from nova.galaxy.interfaces import BasicTool
+from PIL import Image
+from PIL.ImageStat import Stat
 from pydantic import BaseModel, Field
 
 
@@ -23,11 +26,21 @@ class FormData(BaseModel):
     fractal_type: FractalOptions = Field(default=FractalOptions.mandelbrot, title="Type")
 
 
+class ImageStatistics(BaseModel):
+    """Pydantic model for holding image statistics."""
+
+    count: List[int] = Field(default=[])
+    extrema: List[Tuple[int, int]] = Field(default=[])
+    mean: List[float] = Field(default=[])
+    median: List[int] = Field(default=[])
+
+
 class Model:
     """Model implementation for NDIP tool example."""
 
     def __init__(self) -> None:
         self.form = FormData()
+        self.stats = ImageStatistics()
 
 
 class FractalsTool(BasicTool):
@@ -47,6 +60,17 @@ def prepare_tool(self) -> Tuple[Tool, Parameters]:
 
         return self.tool, tool_params
 
-    def get_results(self) -> None:
-        # TODO: add some processing of the results.
+    def compute_stats(self) -> None:
+        outputs = self.tool.get_results()
+        output = outputs.get_dataset("output").get_content()
+
+        img = Image.open(BytesIO(output))
+        stat = Stat(img)
+
+        self.model.stats.count = stat.count
+        self.model.stats.extrema = stat.extrema
+        self.model.stats.mean = [round(mean, 3) for mean in stat.mean]
+        self.model.stats.median = stat.median
+
+    def get_results(self, tool: Tool) -> None:
         pass

examples/run_ndip_tool/view.py

@@ -4,6 +4,7 @@
 from nova.trame import ThemedApp
 from nova.trame.view.components import ExecutionButtons, InputField, ProgressBar, ToolOutputWindows
 from nova.trame.view.layouts import VBoxLayout
+from trame.widgets import html
 from trame.widgets import vuetify3 as vuetify
 
 from .model import Model
@@ -19,6 +20,7 @@ def __init__(self) -> None:
         self.create_vm()
         # If you forget to call connect, then the application will crash when you attempt to update the view.
         self.view_model.form_data_bind.connect("data")
+        self.view_model.stats_bind.connect("stats")
         # Generally, we want to initialize the view state before creating the UI for ease of use. If initialization
         # is expensive, then you can defer it. In this case, you must handle the view state potentially being
         # uninitialized in the UI via v_if statements.
@@ -38,6 +40,22 @@ def create_ui(self) -> None:
                         ProgressBar("fractals")
                         ToolOutputWindows("fractals")
 
+                        with html.Div(v_if="stats.count.length > 0"):
+                            html.P(
+                                "PIL computed {{ stats.count.length }} bands for the generated fractal image.",
+                                classes="mb-2",
+                            )
+                            html.P(
+                                (
+                                    "Band {{ index + 1 }} Stats: "
+                                    "Count={{ stats.count[index] }}, "
+                                    "Extrema={{ stats.extrema[index] }}, "
+                                    "Mean={{ stats.mean[index] }}, "
+                                    "Median={{ stats.median[index] }}"
+                                ),
+                                v_for="(_, index) in stats.count.length",
+                            )
+
             with layout.post_content:
                 # This adds UI components for running and stopping the tool.
                 ExecutionButtons("fractals")

examples/run_ndip_tool/view_model.py

@@ -1,7 +1,11 @@
 """View model implementation for NDIP tool example."""
 
 import os
+from typing import Any, Dict
 
+from blinker import signal
+from nova.common.job import WorkState
+from nova.common.signals import Signal, get_signal_id
 from nova.galaxy.tool_runner import ToolRunner
 from nova.mvvm.interface import BindingInterface
 
@@ -23,12 +27,22 @@ def __init__(self, model: Model, binding: BindingInterface) -> None:
         self.model = model
 
         self.form_data_bind = binding.new_bind(self.model.form)
+        self.stats_bind = binding.new_bind(self.model.stats)
 
         # Using the ToolRunner will allow the tool's progress to be automatically communicated to the view.
         self.tool = FractalsTool(model)
         # The "fractals" string needs to be consistent with the view components.
         self.tool_runner = ToolRunner("fractals", self.tool, self.store_factory, galaxy_url, galaxy_api_key)
 
+        # Now we need to listen for when the tool finished running.
+        self.completion_signal = signal(get_signal_id("fractals", Signal.PROGRESS))
+        self.completion_signal.connect(self.on_completion, weak=False)
+
+    async def on_completion(self, _sender: Any, state: WorkState, details: Dict[str, Any]) -> None:
+        if state == WorkState.FINISHED:
+            self.tool.compute_stats()
+            self.stats_bind.update_in_view(self.model.stats)
+
     def store_factory(self) -> str:
         # This will cause a history named "fractals" to be created on NDIP to store the tool's outputs, errors, and
         # results.

poetry.lock

@@ -23,6 +23,7 @@ requests = "*"
 ruff = "*"
 trame-code = "*"
 nltk = "*"
+pillow = "^11.3.0"
 
 [build-system]
 requires = ["poetry-core"]