Fix Black formatting

Co-authored-by: Samuel <samuel@knutsen.co>

Author: cursoragent

tensorbored/plugins/core/profile_writer.py

@@ -278,14 +278,10 @@ def __init__(
             superimposed_cards or []
         )
         if run_selection is not None:
-            self._run_selection: list[RunSelectionEntry] = list(
-                run_selection
-            )
+            self._run_selection: list[RunSelectionEntry] = list(run_selection)
         elif selected_runs is not None:
             self._run_selection = [
-                RunSelectionEntry(
-                    type="RUN_NAME", value=r, selected=True
-                )
+                RunSelectionEntry(type="RUN_NAME", value=r, selected=True)
                 for r in selected_runs
             ]
         else:
@@ -352,9 +348,7 @@ def superimposed_cards(self) -> list[SuperimposedCardEntry]:
         return self._superimposed_cards
 
     @superimposed_cards.setter
-    def superimposed_cards(
-        self, value: list[SuperimposedCardEntry]
-    ) -> None:
+    def superimposed_cards(self, value: list[SuperimposedCardEntry]) -> None:
         self._superimposed_cards = list(value)
 
     @property
@@ -444,19 +438,15 @@ def tag_axis_scales(self) -> dict[str, TagAxisScale]:
         return self._tag_axis_scales
 
     @tag_axis_scales.setter
-    def tag_axis_scales(
-        self, value: dict[str, TagAxisScale]
-    ) -> None:
+    def tag_axis_scales(self, value: dict[str, TagAxisScale]) -> None:
         self._tag_axis_scales = dict(value)
 
     @property
     def tag_symlog_linear_thresholds(self) -> dict[str, float]:
         return self._tag_symlog_linear_thresholds
 
     @tag_symlog_linear_thresholds.setter
-    def tag_symlog_linear_thresholds(
-        self, value: dict[str, float]
-    ) -> None:
+    def tag_symlog_linear_thresholds(self, value: dict[str, float]) -> None:
         self._tag_symlog_linear_thresholds = dict(value)
 
     @property
@@ -473,19 +463,15 @@ def expanded_tag_groups(self, value: dict[str, bool]) -> None:
 
     def pin_scalar(self, tag: str) -> None:
         """Pin a scalar card."""
-        self._pinned_cards.append(
-            PinnedCard(plugin="scalars", tag=tag)
-        )
+        self._pinned_cards.append(PinnedCard(plugin="scalars", tag=tag))
 
     def pin_histogram(self, tag: str, run_id: str) -> None:
         """Pin a histogram card."""
         self._pinned_cards.append(
             PinnedCard(plugin="histograms", tag=tag, runId=run_id)
         )
 
-    def pin_image(
-        self, tag: str, run_id: str, sample: int = 0
-    ) -> None:
+    def pin_image(self, tag: str, run_id: str, sample: int = 0) -> None:
         """Pin an image card."""
         self._pinned_cards.append(
             PinnedCard(
@@ -510,9 +496,7 @@ def add_superimposed_card(
     def select_runs(self, run_names: list[str]) -> None:
         """Set visible runs by name (replaces current selection)."""
         self._run_selection = [
-            RunSelectionEntry(
-                type="RUN_NAME", value=name, selected=True
-            )
+            RunSelectionEntry(type="RUN_NAME", value=name, selected=True)
             for name in run_names
         ]
 
@@ -575,17 +559,13 @@ def serialize(self) -> SerializedProfile:
         if self._tag_axis_scales:
             data["tagAxisScales"] = dict(self._tag_axis_scales)
         if self._symlog_linear_threshold is not None:
-            data["symlogLinearThreshold"] = (
-                self._symlog_linear_threshold
-            )
+            data["symlogLinearThreshold"] = self._symlog_linear_threshold
         if self._tag_symlog_linear_thresholds:
             data["tagSymlogLinearThresholds"] = dict(
                 self._tag_symlog_linear_thresholds
             )
         if self._expanded_tag_groups:
-            data["expandedTagGroups"] = dict(
-                self._expanded_tag_groups
-            )
+            data["expandedTagGroups"] = dict(self._expanded_tag_groups)
         return SerializedProfile(version=PROFILE_VERSION, data=data)
 
     def write(self, logdir: str) -> str:
@@ -603,38 +583,30 @@ def write(self, logdir: str) -> str:
     # --------------------------------------------------------------- #
 
     @classmethod
-    def from_serialized(
-        cls, serialized: SerializedProfile
-    ) -> Profile:
+    def from_serialized(cls, serialized: SerializedProfile) -> Profile:
         """Create a :class:`Profile` from a ``SerializedProfile``."""
         data = serialized["data"]
         return cls(
             name=data["name"],
             pinned_cards=data.get("pinnedCards", []),
             run_colors={
-                e["runId"]: e["color"]
-                for e in data.get("runColors", [])
+                e["runId"]: e["color"] for e in data.get("runColors", [])
             },
             group_colors={
-                e["groupKey"]: e["colorId"]
-                for e in data.get("groupColors", [])
+                e["groupKey"]: e["colorId"] for e in data.get("groupColors", [])
             },
             superimposed_cards=data.get("superimposedCards", []),
             run_selection=data.get("runSelection"),
             metric_descriptions=data.get("metricDescriptions"),
             tag_filter=data.get("tagFilter", ""),
             run_filter=data.get("runFilter", ""),
             smoothing=data.get("smoothing", 0.6),
-            symlog_linear_threshold=data.get(
-                "symlogLinearThreshold"
-            ),
+            symlog_linear_threshold=data.get("symlogLinearThreshold"),
             group_by=data.get("groupBy"),
             y_axis_scale=data.get("yAxisScale"),
             x_axis_scale=data.get("xAxisScale"),
             tag_axis_scales=data.get("tagAxisScales"),
-            tag_symlog_linear_thresholds=data.get(
-                "tagSymlogLinearThresholds"
-            ),
+            tag_symlog_linear_thresholds=data.get("tagSymlogLinearThresholds"),
             expanded_tag_groups=data.get("expandedTagGroups"),
         )
 
@@ -669,18 +641,12 @@ def update(self, other: Profile) -> None:
           ``None``.
         """
         self._name = other._name
-        self._tag_filter = _merge_regex(
-            self._tag_filter, other._tag_filter
-        )
-        self._run_filter = _merge_regex(
-            self._run_filter, other._run_filter
-        )
+        self._tag_filter = _merge_regex(self._tag_filter, other._tag_filter)
+        self._run_filter = _merge_regex(self._run_filter, other._run_filter)
         self._smoothing = other._smoothing
 
         if other._symlog_linear_threshold is not None:
-            self._symlog_linear_threshold = (
-                other._symlog_linear_threshold
-            )
+            self._symlog_linear_threshold = other._symlog_linear_threshold
         if other._group_by is not None:
             self._group_by = other._group_by
         if other._y_axis_scale is not None:
@@ -822,9 +788,7 @@ def create_profile(
         run_filter=run_filter,
         smoothing=smoothing,
         symlog_linear_threshold=(
-            symlog_linear_threshold
-            if symlog_linear_threshold != 1.0
-            else None
+            symlog_linear_threshold if symlog_linear_threshold != 1.0 else None
         ),
         group_by=group_by,
         y_axis_scale=y_axis_scale,
@@ -835,9 +799,7 @@ def create_profile(
     )
 
 
-def write_profile(
-    logdir: str, profile: SerializedProfile | Profile
-) -> str:
+def write_profile(logdir: str, profile: SerializedProfile | Profile) -> str:
     """Write a profile to the logdir.
 
     The profile is written to

tensorbored/plugins/core/profile_writer_test.py

@@ -233,9 +233,7 @@ def test_create_profile_with_tag_axis_scales(self):
                 "eval/loss": {"y": "log10", "x": "symlog10"},
             },
         )
-        self.assertEqual(
-            profile.tag_axis_scales["train/loss"], {"y": "log10"}
-        )
+        self.assertEqual(profile.tag_axis_scales["train/loss"], {"y": "log10"})
         self.assertEqual(
             profile.tag_axis_scales["eval/loss"],
             {"y": "log10", "x": "symlog10"},
@@ -345,12 +343,8 @@ def test_construction_with_kwargs(self):
         self.assertEqual(p.y_axis_scale, "log10")
         self.assertEqual(p.x_axis_scale, "symlog10")
         self.assertEqual(p.tag_axis_scales, {"loss": {"y": "log10"}})
-        self.assertEqual(
-            p.tag_symlog_linear_thresholds, {"loss": 5.0}
-        )
-        self.assertEqual(
-            p.expanded_tag_groups, {"train": True, "eval": False}
-        )
+        self.assertEqual(p.tag_symlog_linear_thresholds, {"loss": 5.0})
+        self.assertEqual(p.expanded_tag_groups, {"train": True, "eval": False})
 
     def test_selected_runs_convenience(self):
         p = profile_writer.Profile(selected_runs=["train", "eval"])
@@ -360,9 +354,7 @@ def test_selected_runs_convenience(self):
 
     def test_run_selection_takes_priority_over_selected_runs(self):
         sel = [{"type": "RUN_ID", "value": "abc", "selected": False}]
-        p = profile_writer.Profile(
-            run_selection=sel, selected_runs=["x"]
-        )
+        p = profile_writer.Profile(run_selection=sel, selected_runs=["x"])
         self.assertEqual(len(p.run_selection), 1)
         self.assertEqual(p.run_selection[0]["value"], "abc")
 
@@ -456,13 +448,9 @@ def test_pin_image(self):
 
     def test_add_superimposed_card(self):
         p = profile_writer.Profile()
-        p.add_superimposed_card(
-            "Train vs Eval", ["train/loss", "eval/loss"]
-        )
+        p.add_superimposed_card("Train vs Eval", ["train/loss", "eval/loss"])
         self.assertEqual(len(p.superimposed_cards), 1)
-        self.assertEqual(
-            p.superimposed_cards[0]["title"], "Train vs Eval"
-        )
+        self.assertEqual(p.superimposed_cards[0]["title"], "Train vs Eval")
         self.assertEqual(
             p.superimposed_cards[0]["tags"],
             ["train/loss", "eval/loss"],
@@ -499,13 +487,9 @@ def test_serialize_defaults(self):
         self.assertNotIn("expandedTagGroups", data)
 
     def test_serialize_run_colors(self):
-        p = profile_writer.Profile(
-            run_colors={"a": "#111", "b": "#222"}
-        )
+        p = profile_writer.Profile(run_colors={"a": "#111", "b": "#222"})
         data = p.serialize()["data"]
-        color_dict = {
-            e["runId"]: e["color"] for e in data["runColors"]
-        }
+        color_dict = {e["runId"]: e["color"] for e in data["runColors"]}
         self.assertEqual(color_dict, {"a": "#111", "b": "#222"})
 
     def test_serialize_group_colors(self):
@@ -535,13 +519,9 @@ def test_serialize_all_optional_fields(self):
         self.assertEqual(data["groupBy"]["key"], "RUN")
         self.assertEqual(data["yAxisScale"], "log10")
         self.assertEqual(data["xAxisScale"], "symlog10")
-        self.assertEqual(
-            data["tagAxisScales"], {"loss": {"y": "log10"}}
-        )
+        self.assertEqual(data["tagAxisScales"], {"loss": {"y": "log10"}})
         self.assertEqual(data["symlogLinearThreshold"], 2.0)
-        self.assertEqual(
-            data["tagSymlogLinearThresholds"], {"loss": 3.0}
-        )
+        self.assertEqual(data["tagSymlogLinearThresholds"], {"loss": 3.0})
         self.assertEqual(data["expandedTagGroups"], {"train": True})
 
     def test_serialize_validates_tag_axis_scales(self):
@@ -584,19 +564,13 @@ def test_from_serialized_round_trip(self):
             {"train": "#ff0000", "eval": "#00ff00"},
         )
         self.assertEqual(loaded.group_colors, {"grp": 2})
-        self.assertEqual(
-            loaded.metric_descriptions, {"loss": "desc"}
-        )
+        self.assertEqual(loaded.metric_descriptions, {"loss": "desc"})
         self.assertEqual(loaded.tag_filter, "loss")
         self.assertEqual(loaded.smoothing, 0.8)
         self.assertEqual(loaded.y_axis_scale, "log10")
-        self.assertEqual(
-            loaded.expanded_tag_groups, {"train": True}
-        )
+        self.assertEqual(loaded.expanded_tag_groups, {"train": True})
         self.assertEqual(loaded.symlog_linear_threshold, 5.0)
-        self.assertEqual(
-            loaded.tag_symlog_linear_thresholds, {"loss": 10.0}
-        )
+        self.assertEqual(loaded.tag_symlog_linear_thresholds, {"loss": 10.0})
 
     # ---- write / load round-trip ----
 
@@ -647,12 +621,8 @@ def test_update_merges_dicts(self):
             expanded_tag_groups={"eval": False},
         )
         a.update(b)
-        self.assertEqual(
-            a.run_colors, {"r1": "#aaa", "r2": "#bbb"}
-        )
-        self.assertEqual(
-            a.metric_descriptions, {"loss": "d1", "acc": "d2"}
-        )
+        self.assertEqual(a.run_colors, {"r1": "#aaa", "r2": "#bbb"})
+        self.assertEqual(a.metric_descriptions, {"loss": "d1", "acc": "d2"})
         self.assertEqual(
             a.expanded_tag_groups,
             {"train": True, "eval": False},
@@ -726,34 +696,24 @@ def test_or_returns_new_profile(self):
         self.assertIsNot(c, a)
         self.assertIsNot(c, b)
         self.assertEqual(c.name, "B")
-        self.assertEqual(
-            c.run_colors, {"r1": "#aaa", "r2": "#bbb"}
-        )
+        self.assertEqual(c.run_colors, {"r1": "#aaa", "r2": "#bbb"})
         self.assertEqual(len(c.pinned_cards), 2)
         self.assertEqual(c.y_axis_scale, "log10")
         # Originals are unmodified.
         self.assertEqual(a.run_colors, {"r1": "#aaa"})
         self.assertEqual(len(a.pinned_cards), 1)
 
     def test_ior_mutates_in_place(self):
-        a = profile_writer.Profile(
-            "A", run_colors={"r1": "#aaa"}
-        )
-        b = profile_writer.Profile(
-            "B", run_colors={"r2": "#bbb"}
-        )
+        a = profile_writer.Profile("A", run_colors={"r1": "#aaa"})
+        b = profile_writer.Profile("B", run_colors={"r2": "#bbb"})
         a |= b
         self.assertEqual(a.name, "B")
-        self.assertEqual(
-            a.run_colors, {"r1": "#aaa", "r2": "#bbb"}
-        )
+        self.assertEqual(a.run_colors, {"r1": "#aaa", "r2": "#bbb"})
 
     def test_or_not_implemented_for_non_profile(self):
         p = profile_writer.Profile()
         self.assertEqual(p.__or__("not a profile"), NotImplemented)
-        self.assertEqual(
-            p.__ior__("not a profile"), NotImplemented
-        )
+        self.assertEqual(p.__ior__("not a profile"), NotImplemented)
 
     # ---- builder workflow ----
 
@@ -769,9 +729,7 @@ def test_builder_workflow(self):
         p.y_axis_scale = "log10"
         p.metric_descriptions["train/loss"] = "Training loss"
         p.expanded_tag_groups["train"] = True
-        p.add_superimposed_card(
-            "Loss Comparison", ["train/loss", "eval/loss"]
-        )
+        p.add_superimposed_card("Loss Comparison", ["train/loss", "eval/loss"])
         p.select_runs(["train", "eval"])
 
         path = p.write(self.logdir)