Path 1: 139 calls (0.82)

→ style None (138) 'on red' (1)

→ end_section False (138) True (1)

→ renderables tuple (104) ('COL1', 'COL2') (8) ('1', '2') (6) ('3', '4') (6) ('bar',) (2) ('Styles', 'All ansi styles: [bold]bold[/], [dim]dim[/], [italic]italic[/i...

11 run 11 not run

1def add_row(
2        self,
3        *renderables: Optional["RenderableType"],
4        style: Optional[StyleType] = None,
5        end_section: bool = False,
6    ) -> None:
7        """Add a row of renderables.
8
9        Args:
10            *renderables (None or renderable): Each cell in a row must be a renderable object (including str),
11                or ``None`` for a blank cell.
12            style (StyleType, optional): An optional style to apply to the entire row. Defaults to None.
13            end_section (bool, optional): End a section and draw a line. Defaults to False.
14
15        Raises:
16            errors.NotRenderableError: If you add something that can't be rendered.
17        """
18
19        def add_cell(column: Column, renderable: "RenderableType") -> None:
20            column._cells.append(renderable)
21
22        cell_renderables: List[Optional["RenderableType"]] = list(renderables)
23
24        columns = self.columns
25        if len(cell_renderables) < len(columns):
26            cell_renderables = [
27                *cell_renderables,
28                *[None] * (len(columns) - len(cell_renderables)),
29            ]
30        for index, renderable in enumerate(cell_renderables):
31            if index == len(columns):
32                column = Column(_index=index)
33                for _ in self.rows:
34                    add_cell(column, Text(""))
35                self.columns.append(column)
36            else:
37                column = columns[index]
38            if renderable is None:
39                add_cell(column, "")
40            elif is_renderable(renderable):
41                add_cell(column, renderable)
42            else:
43                raise errors.NotRenderableError(
44                    f"unable to render {type(renderable).__name__}; a string or other renderable object is required"
45                )
46        self.rows.append(Row(style=style, end_section=end_section))
            

Path 2: 16 calls (0.09)

→ style None (16)

→ end_section False (16)

→ renderables tuple (13) ('foo', 'bar\nbar\nbar\nbar\nbar') (3)

14 run 8 not run

1def add_row(
2        self,
3        *renderables: Optional["RenderableType"],
4        style: Optional[StyleType] = None,
5        end_section: bool = False,
6    ) -> None:
7        """Add a row of renderables.
8
9        Args:
10            *renderables (None or renderable): Each cell in a row must be a renderable object (including str),
11                or ``None`` for a blank cell.
12            style (StyleType, optional): An optional style to apply to the entire row. Defaults to None.
13            end_section (bool, optional): End a section and draw a line. Defaults to False.
14
15        Raises:
16            errors.NotRenderableError: If you add something that can't be rendered.
17        """
18
19        def add_cell(column: Column, renderable: "RenderableType") -> None:
20            column._cells.append(renderable)
21
22        cell_renderables: List[Optional["RenderableType"]] = list(renderables)
23
24        columns = self.columns
25        if len(cell_renderables) < len(columns):
26            cell_renderables = [
27                *cell_renderables,
28                *[None] * (len(columns) - len(cell_renderables)),
29            ]
30        for index, renderable in enumerate(cell_renderables):
31            if index == len(columns):
32                column = Column(_index=index)
33                for _ in self.rows:
34                    add_cell(column, Text(""))
35                self.columns.append(column)
36            else:
37                column = columns[index]
38            if renderable is None:
39                add_cell(column, "")
40            elif is_renderable(renderable):
41                add_cell(column, renderable)
42            else:
43                raise errors.NotRenderableError(
44                    f"unable to render {type(renderable).__name__}; a string or other renderable object is required"
45                )
46        self.rows.append(Row(style=style, end_section=end_section))
            

Path 3: 10 calls (0.06)

→ style None (10)

→ end_section False (10)

→ renderables tuple (9) ('foo',) (1)

13 run 9 not run

1def add_row(
2        self,
3        *renderables: Optional["RenderableType"],
4        style: Optional[StyleType] = None,
5        end_section: bool = False,
6    ) -> None:
7        """Add a row of renderables.
8
9        Args:
10            *renderables (None or renderable): Each cell in a row must be a renderable object (including str),
11                or ``None`` for a blank cell.
12            style (StyleType, optional): An optional style to apply to the entire row. Defaults to None.
13            end_section (bool, optional): End a section and draw a line. Defaults to False.
14
15        Raises:
16            errors.NotRenderableError: If you add something that can't be rendered.
17        """
18
19        def add_cell(column: Column, renderable: "RenderableType") -> None:
20            column._cells.append(renderable)
21
22        cell_renderables: List[Optional["RenderableType"]] = list(renderables)
23
24        columns = self.columns
25        if len(cell_renderables) < len(columns):
26            cell_renderables = [
27                *cell_renderables,
28                *[None] * (len(columns) - len(cell_renderables)),
29            ]
30        for index, renderable in enumerate(cell_renderables):
31            if index == len(columns):
32                column = Column(_index=index)
33                for _ in self.rows:
34                    add_cell(column, Text(""))
35                self.columns.append(column)
36            else:
37                column = columns[index]
38            if renderable is None:
39                add_cell(column, "")
40            elif is_renderable(renderable):
41                add_cell(column, renderable)
42            else:
43                raise errors.NotRenderableError(
44                    f"unable to render {type(renderable).__name__}; a string or other renderable object is required"
45                )
46        self.rows.append(Row(style=style, end_section=end_section))
            

Path 4: 1 calls (0.01)

→ style None (1)

→ end_section False (1)

→ renderables ('Averlongwordgoeshere', 'banana pancakes', None) (1)

12 run 10 not run

1def add_row(
2        self,
3        *renderables: Optional["RenderableType"],
4        style: Optional[StyleType] = None,
5        end_section: bool = False,
6    ) -> None:
7        """Add a row of renderables.
8
9        Args:
10            *renderables (None or renderable): Each cell in a row must be a renderable object (including str),
11                or ``None`` for a blank cell.
12            style (StyleType, optional): An optional style to apply to the entire row. Defaults to None.
13            end_section (bool, optional): End a section and draw a line. Defaults to False.
14
15        Raises:
16            errors.NotRenderableError: If you add something that can't be rendered.
17        """
18
19        def add_cell(column: Column, renderable: "RenderableType") -> None:
20            column._cells.append(renderable)
21
22        cell_renderables: List[Optional["RenderableType"]] = list(renderables)
23
24        columns = self.columns
25        if len(cell_renderables) < len(columns):
26            cell_renderables = [
27                *cell_renderables,
28                *[None] * (len(columns) - len(cell_renderables)),
29            ]
30        for index, renderable in enumerate(cell_renderables):
31            if index == len(columns):
32                column = Column(_index=index)
33                for _ in self.rows:
34                    add_cell(column, Text(""))
35                self.columns.append(column)
36            else:
37                column = columns[index]
38            if renderable is None:
39                add_cell(column, "")
40            elif is_renderable(renderable):
41                add_cell(column, renderable)
42            else:
43                raise errors.NotRenderableError(
44                    f"unable to render {type(renderable).__name__}; a string or other renderable object is required"
45                )
46        self.rows.append(Row(style=style, end_section=end_section))
            

Path 5: 1 calls (0.01)

→ style None (1)

→ end_section False (1)

→ renderables ('Coffee',) (1)

15 run 7 not run

1def add_row(
2        self,
3        *renderables: Optional["RenderableType"],
4        style: Optional[StyleType] = None,
5        end_section: bool = False,
6    ) -> None:
7        """Add a row of renderables.
8
9        Args:
10            *renderables (None or renderable): Each cell in a row must be a renderable object (including str),
11                or ``None`` for a blank cell.
12            style (StyleType, optional): An optional style to apply to the entire row. Defaults to None.
13            end_section (bool, optional): End a section and draw a line. Defaults to False.
14
15        Raises:
16            errors.NotRenderableError: If you add something that can't be rendered.
17        """
18
19        def add_cell(column: Column, renderable: "RenderableType") -> None:
20            column._cells.append(renderable)
21
22        cell_renderables: List[Optional["RenderableType"]] = list(renderables)
23
24        columns = self.columns
25        if len(cell_renderables) < len(columns):
26            cell_renderables = [
27                *cell_renderables,
28                *[None] * (len(columns) - len(cell_renderables)),
29            ]
30        for index, renderable in enumerate(cell_renderables):
31            if index == len(columns):
32                column = Column(_index=index)
33                for _ in self.rows:
34                    add_cell(column, Text(""))
35                self.columns.append(column)
36            else:
37                column = columns[index]
38            if renderable is None:
39                add_cell(column, "")
40            elif is_renderable(renderable):
41                add_cell(column, renderable)
42            else:
43                raise errors.NotRenderableError(
44                    f"unable to render {type(renderable).__name__}; a string or other renderable object is required"
45                )
46        self.rows.append(Row(style=style, end_section=end_section))
            

Path 6: 1 calls (0.01)

→ style None (1)

→ end_section False (1)

→ renderables ('Coffee', 'Chocolate', None, 'cinnamon') (1)

16 run 6 not run

1def add_row(
2        self,
3        *renderables: Optional["RenderableType"],
4        style: Optional[StyleType] = None,
5        end_section: bool = False,
6    ) -> None:
7        """Add a row of renderables.
8
9        Args:
10            *renderables (None or renderable): Each cell in a row must be a renderable object (including str),
11                or ``None`` for a blank cell.
12            style (StyleType, optional): An optional style to apply to the entire row. Defaults to None.
13            end_section (bool, optional): End a section and draw a line. Defaults to False.
14
15        Raises:
16            errors.NotRenderableError: If you add something that can't be rendered.
17        """
18
19        def add_cell(column: Column, renderable: "RenderableType") -> None:
20            column._cells.append(renderable)
21
22        cell_renderables: List[Optional["RenderableType"]] = list(renderables)
23
24        columns = self.columns
25        if len(cell_renderables) < len(columns):
26            cell_renderables = [
27                *cell_renderables,
28                *[None] * (len(columns) - len(cell_renderables)),
29            ]
30        for index, renderable in enumerate(cell_renderables):
31            if index == len(columns):
32                column = Column(_index=index)
33                for _ in self.rows:
34                    add_cell(column, Text(""))
35                self.columns.append(column)
36            else:
37                column = columns[index]
38            if renderable is None:
39                add_cell(column, "")
40            elif is_renderable(renderable):
41                add_cell(column, renderable)
42            else:
43                raise errors.NotRenderableError(
44                    f"unable to render {type(renderable).__name__}; a string or other renderable object is required"
45                )
46        self.rows.append(Row(style=style, end_section=end_section))
            

Path 7: 1 calls (0.01)

→ style None (1)

→ end_section False (1)

→ renderables tuple (1)

⚠ exception NotRenderableError (1)

13 run 9 not run

1def add_row(
2        self,
3        *renderables: Optional["RenderableType"],
4        style: Optional[StyleType] = None,
5        end_section: bool = False,
6    ) -> None:
7        """Add a row of renderables.
8
9        Args:
10            *renderables (None or renderable): Each cell in a row must be a renderable object (including str),
11                or ``None`` for a blank cell.
12            style (StyleType, optional): An optional style to apply to the entire row. Defaults to None.
13            end_section (bool, optional): End a section and draw a line. Defaults to False.
14
15        Raises:
16            errors.NotRenderableError: If you add something that can't be rendered.
17        """
18
19        def add_cell(column: Column, renderable: "RenderableType") -> None:
20            column._cells.append(renderable)
21
22        cell_renderables: List[Optional["RenderableType"]] = list(renderables)
23
24        columns = self.columns
25        if len(cell_renderables) < len(columns):
26            cell_renderables = [
27                *cell_renderables,
28                *[None] * (len(columns) - len(cell_renderables)),
29            ]
30        for index, renderable in enumerate(cell_renderables):
31            if index == len(columns):
32                column = Column(_index=index)
33                for _ in self.rows:
34                    add_cell(column, Text(""))
35                self.columns.append(column)
36            else:
37                column = columns[index]
38            if renderable is None:
39                add_cell(column, "")
40            elif is_renderable(renderable):
41                add_cell(column, renderable)
42            else:
43                raise errors.NotRenderableError(
44                    f"unable to render {type(renderable).__name__}; a string or other renderable object is required"
45                )
46        self.rows.append(Row(style=style, end_section=end_section))