Use per-plotAction key/suffix in StructPlotAction

Author: taranu

python/lsst/analysis/tools/atools/genericPlotAction.py

@@ -39,18 +39,19 @@ def getInputSchema(self) -> KeyedDataSchema:
         for action in self.actions:
             yield from action.getInputSchema()
 
+    def getPlotType(self) -> str:
+        return ""
+
     def getOutputNames(self, config: Config | None = None) -> Iterable[str]:
-        names = []
         for key, action in self.actions.items():
             names_action = action.getOutputNames(config=config)
             if not names_action:
                 names_action = [key]
-            names.extend(names_action)
-        return tuple(names)
+            for name in names_action:
+                yield f"{name}_{action.getPlotType()}"
 
     def __call__(self, data: KeyedData, **kwargs) -> PlotResultType:
         results = {}
         for key, action in self.actions.items():
-            result = action(data=data, **kwargs)
-            results[key] = result
+            results[f"{key}_{action.getPlotType()}"] = action(data=data, **kwargs)
         return results

python/lsst/analysis/tools/interfaces/_analysisTools.py

@@ -215,19 +215,22 @@ def _process_single_results(
         results: Mapping[str, PlotTypes] | PlotTypes | Mapping[str, Measurement] | Measurement | JointResults,
     ) -> KeyedResults:
         accumulation = {}
-        suffix = self._getPlotType()
         predicate = f"{self.identity}" if self.identity else ""
         match results:
             case Mapping():
+                suffix = self._getPlotType()
                 for key, value in results.items():
                     match value:
-                        case PlotTypes():
-                            iterable = (predicate, key, suffix)
                         case Measurement():
                             iterable = (predicate, key)
+                        case PlotTypes():
+                            iterable = (predicate, key, suffix)
+                        case _:
+                            raise RuntimeError(f"Unexpected {key=}, {value=} from:\n{self=}")
                     refKey = "_".join(x for x in iterable if x)
                     accumulation[refKey] = value
             case PlotTypes():
+                suffix = self._getPlotType()
                 refKey = "_".join(x for x in (predicate, suffix) if x)
                 accumulation[refKey] = results
             case Measurement():