[Tune] Add repr for ResultGrid class

python/ray/air/result.py

@@ -44,7 +44,7 @@ class Result:
     log_dir: Optional[Path]
     metrics_dataframe: Optional["pd.DataFrame"]
     best_checkpoints: Optional[List[Tuple[Checkpoint, Dict[str, Any]]]]
-    _items_to_repr = ["metrics", "error", "log_dir"]
+    _items_to_repr = ["error", "metrics", "log_dir", "checkpoint"]
 
     @property
     def config(self) -> Optional[Dict[str, Any]]:
@@ -53,14 +53,29 @@ def config(self) -> Optional[Dict[str, Any]]:
             return None
         return self.metrics.get("config", None)
 
-    def __repr__(self):
+    def _repr_with_indent(self, offset: int = 0) -> str:
+        """Construct the representation with specified number of space indent."""
         from ray.tune.result import AUTO_RESULT_KEYS
 
         shown_attributes = {k: self.__dict__[k] for k in self._items_to_repr}
+        if self.error:
+            shown_attributes["error"] = type(self.error).__name__
+        else:
+            shown_attributes.pop("error")
 
         if self.metrics:
             shown_attributes["metrics"] = {
                 k: v for k, v in self.metrics.items() if k not in AUTO_RESULT_KEYS
             }
-        kws = [f"{key}={value!r}" for key, value in shown_attributes.items()]
-        return "{}({})".format(type(self).__name__, ", ".join(kws))
+
+        cls_indent = " " * offset
+        kws_indent = " " * (offset + 2)
+
+        kws = [
+            f"{kws_indent}{key}={value!r}" for key, value in shown_attributes.items()
+        ]
+        kws_repr = ",\n".join(kws)
+        return "{0}{1}(\n{2}\n{0})".format(cls_indent, type(self).__name__, kws_repr)
+
+    def __repr__(self) -> str:
+        return self._repr_with_indent(offset=0)

python/ray/tune/result_grid.py

@@ -69,6 +69,13 @@ def __init__(
         experiment_analysis: ExperimentAnalysis,
     ):
         self._experiment_analysis = experiment_analysis
+        self._results = list()
+
+        if experiment_analysis:
+            self._results = [
+                self._trial_to_result(trail)
+                for trail in self._experiment_analysis.trials
+            ]
 
     def get_best_result(
         self,
@@ -178,13 +185,11 @@ def get_dataframe(
         )
 
     def __len__(self) -> int:
-        return len(self._experiment_analysis.trials)
+        return len(self._results)
 
     def __getitem__(self, i: int) -> Result:
         """Returns the i'th result in the grid."""
-        return self._trial_to_result(
-            self._experiment_analysis.trials[i],
-        )
+        return self._results[i]
 
     @property
     def errors(self):
@@ -240,3 +245,8 @@ def _trial_to_result(self, trial: Trial) -> Result:
             best_checkpoints=best_checkpoints,
         )
         return result
+
+    def __repr__(self) -> str:
+        all_results_repr = [result._repr_with_indent(2) for result in self]
+        all_results_repr = ",\n".join(all_results_repr)
+        return f"ResultGrid<[\n{all_results_repr}\n]>"

python/ray/tune/tests/test_result_grid.py

@@ -224,6 +224,62 @@ def f(config):
     assert not any(key in representation for key in AUTO_RESULT_KEYS)
 
 
+def test_result_grid_repr(ray_start_2_cpus, tmpdir):
+    from ray.air.result import Result
+
+    results = list()
+    results.append(
+        Result(
+            metrics={"loss": 1.0},
+            checkpoint=Checkpoint(data_dict={"weight": 1.0}),
+            log_dir=Path("./log_1"),
+            error=None,
+            metrics_dataframe=None,
+            best_checkpoints=None,
+        )
+    )
+    results.append(
+        Result(
+            metrics={"loss": 2.0},
+            checkpoint=Checkpoint(data_dict={"weight": 2.0}),
+            log_dir=Path("./log_2"),
+            error=RuntimeError(),
+            metrics_dataframe=None,
+            best_checkpoints=None,
+        )
+    )
+
+    result_grid = ResultGrid(experiment_analysis=None)
+    result_grid._results = results
+
+    representation = result_grid.__repr__()
+
+    from ray.tune.result import AUTO_RESULT_KEYS
+
+    assert len(result_grid) == 2
+    assert not any(key in representation for key in AUTO_RESULT_KEYS)
+
+    gold_representation = """ResultGrid<[
+  Result(
+    metrics={'loss': 1.0},
+    log_dir=PosixPath('log_1'),
+    checkpoint=Checkpoint(data_dict={'weight': 1.0})
+  ),
+  Result(
+    error='RuntimeError',
+    metrics={'loss': 2.0},
+    log_dir=PosixPath('log_2'),
+    checkpoint=Checkpoint(data_dict={'weight': 2.0})
+  )
+]>"""
+
+    assert representation == gold_representation
+    assert representation.count("metrics=") == 2
+    assert representation.count("log_dir=") == 2
+    assert representation.count("checkpoint=") == 2
+    assert representation.count("error=") == 1 and "RuntimeError" in representation
+
+
 def test_no_metric_mode(ray_start_2_cpus):
     def f(config):
         tune.report(x=1)