Add flat mode to console renderer

pyinstrument/frame.py

@@ -120,11 +120,13 @@ def total_self_time(self) -> float:
         The total amount of self time in this frame (including self time recorded by SelfTimeFrame
         children, and await time from AwaitTimeFrame children)
         """
-        self_time = 0
 
-        for child in self.children:
-            if child.identifier in (SELF_TIME_FRAME_IDENTIFIER, AWAIT_FRAME_IDENTIFIER):
-                self_time += child.time
+        # self time is time in this frame, minus time in children
+        self_time = self.time
+        real_children = [c for c in self.children if not c.is_synthetic]
+
+        for child in real_children:
+            self_time -= child.time
 
         return self_time
 

pyinstrument/renderers/console.py

@@ -1,5 +1,6 @@
 import time
-from typing import Any
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
 
 import pyinstrument
 from pyinstrument import processors
@@ -22,6 +23,7 @@ def __init__(
         self,
         unicode: bool = False,
         color: bool = False,
+        flat: bool = False,
         time: LiteralStr["seconds", "percent_of_total"] = "seconds",
         **kwargs: Any,
     ):
@@ -34,6 +36,7 @@ def __init__(
 
         self.unicode = unicode
         self.color = color
+        self.flat = flat
         self.colors = self.colors_enabled if color else self.colors_disabled
         self.time = time
 
@@ -48,7 +51,10 @@ def render(self, session: Session):
 
         self.root_frame = frame
 
-        result += self.render_frame(self.root_frame)
+        if self.flat:
+            result += self.render_frame_flat(self.root_frame)
+        else:
+            result += self.render_frame(self.root_frame)
         result += "\n"
 
         return result
@@ -83,10 +89,14 @@ def render_frame(self, frame: Frame, indent: str = "", child_indent: str = "") -
             or frame in frame.group.exit_frames
         ):
             if self.time == "percent_of_total":
-                percent = self.frame_proportion_of_total_time(frame) * 100
-                time_str = self._ansi_color_for_time(frame) + f"{percent:.0f}%" + self.colors.end
+                percent = self.frame_proportion_of_total_time(frame.time) * 100
+                time_str = (
+                    self._ansi_color_for_time(frame.time) + f"{percent:.0f}%" + self.colors.end
+                )
             else:
-                time_str = self._ansi_color_for_time(frame) + f"{frame.time:.3f}" + self.colors.end
+                time_str = (
+                    self._ansi_color_for_time(frame.time) + f"{frame.time:.3f}" + self.colors.end
+                )
 
             name_color = self._ansi_color_for_name(frame)
 
@@ -137,11 +147,64 @@ def render_frame(self, frame: Frame, indent: str = "", child_indent: str = "") -
 
         return result
 
-    def frame_proportion_of_total_time(self, frame: Frame):
-        return frame.time / self.root_frame.time
+    def render_frame_flat(self, frame: Frame) -> str:
+        @dataclass(frozen=True, eq=True)
+        class FrameDesc:
+            code_position_short: Optional[str]
+            function: str
+
+
+        def walk(frame: Frame):
+            frame_desc = FrameDesc(frame.code_position_short, frame.function)
+            frame_desc_to_self_time[frame_desc] = (
+                frame_desc_to_self_time.get(frame_desc, 0) + frame.total_self_time
+            )
+            frame_desc_to_frame[frame_desc] = frame
+            frame_desc_to_ncalls[frame_desc] = frame_desc_to_ncalls.get(frame_desc, 0) + 1
+
+            for child in frame.children:
+                walk(child)
+
+        frame_desc_to_self_time: Dict[FrameDesc, float] = {}
+        frame_desc_to_frame: Dict[FrameDesc, Frame] = {}
+        frame_desc_to_ncalls: Dict[FrameDesc, int] = {}
+
+        walk(frame)
+
+        cost_list: List[Tuple[FrameDesc, float]] = sorted(
+            frame_desc_to_self_time.items(), key=(lambda item: item[1]), reverse=True
+        )
+
+        res = ""
+
+        for frame_desc, self_time in cost_list:
+            if self.time == "percent_of_total":
+                val = self_time / frame.time * 100
+                unit = "%"
+            else:
+                val = self_time
+                unit = "s"
+
+            color = self._ansi_color_for_time(self_time)
+
+            res += "{color}{val:.3f}{unit}{c.end} {name_color}{function}{c.end}  {c.faint}{code_position}{c.end} {ncalls}\n".format(
+                color=color,
+                val=val,
+                unit=unit,
+                c=self.colors,
+                name_color=self._ansi_color_for_name(frame_desc_to_frame[frame_desc]),
+                function=frame_desc.function,
+                code_position=frame_desc.code_position_short,
+                ncalls=frame_desc_to_ncalls[frame_desc],
+            )
+
+        return res
+
+    def frame_proportion_of_total_time(self, time: float):
+        return time / self.root_frame.time
 
-    def _ansi_color_for_time(self, frame: Frame):
-        proportion_of_total = self.frame_proportion_of_total_time(frame)
+    def _ansi_color_for_time(self, time: float):
+        proportion_of_total = self.frame_proportion_of_total_time(time)
 
         if proportion_of_total > 0.6:
             return self.colors.red