Path 1: 1867 calls (0.67)

→ renderable Text (693) Padding (575) Table (113) Control (112) LiveRender (110) Panel (66) Constrain (40) Segments (39) ProgressBar (29) Align (26)

→ options ConsoleOptions (1861) None (6)

⇇ yield Segment (31299) None (19)

⚠ exception GeneratorExit (19)

12 run 11 not run

1def render(
2        self, renderable: RenderableType, options: Optional[ConsoleOptions] = None
3    ) -> Iterable[Segment]:
4        """Render an object in to an iterable of `Segment` instances.
5
6        This method contains the logic for rendering objects with the console protocol.
7        You are unlikely to need to use it directly, unless you are extending the library.
8
9        Args:
10            renderable (RenderableType): An object supporting the console protocol, or
11                an object that may be converted to a string.
12            options (ConsoleOptions, optional): An options object, or None to use self.options. Defaults to None.
13
14        Returns:
15            Iterable[Segment]: An iterable of segments that may be rendered.
16        """
17
18        _options = options or self.options
19        if _options.max_width < 1:
20            # No space to render anything. This prevents potential recursion errors.
21            return
22        render_iterable: RenderResult
23
24        renderable = rich_cast(renderable)
25        if hasattr(renderable, "__rich_console__") and not isclass(renderable):
26            render_iterable = renderable.__rich_console__(self, _options)  # type: ignore[union-attr]
27        elif isinstance(renderable, str):
28            text_renderable = self.render_str(
29                renderable, highlight=_options.highlight, markup=_options.markup
30            )
31            render_iterable = text_renderable.__rich_console__(self, _options)
32        else:
33            raise errors.NotRenderableError(
34                f"Unable to render {renderable!r}; "
35                "A str, Segment or object with __rich_console__ method is required"
36            )
37
38        try:
39            iter_render = iter(render_iterable)
40        except TypeError:
41            raise errors.NotRenderableError(
42                f"object {render_iterable!r} is not renderable"
43            )
44        _Segment = Segment
45        _options = _options.reset_height()
46        for render_output in iter_render:
47            if isinstance(render_output, _Segment):
48                yield render_output
49            else:
50                yield from self.render(render_output, _options)
            

Path 2: 424 calls (0.15)

→ renderable '' (94) 'foo' (43) 'Averlongwordgoeshere' (21) 'bar' (20) 'Coffee' (16) 'banana pancakes' (15) 'Step 0\nStep 1\nStep 2\nStep 3\nStep 4\nStep 5\nStep 6...

→ options ConsoleOptions (424)

⇇ yield Segment (1816) None (1)

⚠ exception GeneratorExit (1)

15 run 8 not run

1def render(
2        self, renderable: RenderableType, options: Optional[ConsoleOptions] = None
3    ) -> Iterable[Segment]:
4        """Render an object in to an iterable of `Segment` instances.
5
6        This method contains the logic for rendering objects with the console protocol.
7        You are unlikely to need to use it directly, unless you are extending the library.
8
9        Args:
10            renderable (RenderableType): An object supporting the console protocol, or
11                an object that may be converted to a string.
12            options (ConsoleOptions, optional): An options object, or None to use self.options. Defaults to None.
13
14        Returns:
15            Iterable[Segment]: An iterable of segments that may be rendered.
16        """
17
18        _options = options or self.options
19        if _options.max_width < 1:
20            # No space to render anything. This prevents potential recursion errors.
21            return
22        render_iterable: RenderResult
23
24        renderable = rich_cast(renderable)
25        if hasattr(renderable, "__rich_console__") and not isclass(renderable):
26            render_iterable = renderable.__rich_console__(self, _options)  # type: ignore[union-attr]
27        elif isinstance(renderable, str):
28            text_renderable = self.render_str(
29                renderable, highlight=_options.highlight, markup=_options.markup
30            )
31            render_iterable = text_renderable.__rich_console__(self, _options)
32        else:
33            raise errors.NotRenderableError(
34                f"Unable to render {renderable!r}; "
35                "A str, Segment or object with __rich_console__ method is required"
36            )
37
38        try:
39            iter_render = iter(render_iterable)
40        except TypeError:
41            raise errors.NotRenderableError(
42                f"object {render_iterable!r} is not renderable"
43            )
44        _Segment = Segment
45        _options = _options.reset_height()
46        for render_output in iter_render:
47            if isinstance(render_output, _Segment):
48                yield render_output
49            else:
50                yield from self.render(render_output, _options)
            

Path 3: 321 calls (0.11)

→ renderable Group (74) Pretty (43) Renderables (40) Syntax (39) Paragraph (39) Rule (29) Traceback (16) Heading (13) CodeBlock (8) Constrain (5)

→ options ConsoleOptions (321)

⇇ yield Segment (10963) None (5)

⚠ exception GeneratorExit (5)

12 run 11 not run

1def render(
2        self, renderable: RenderableType, options: Optional[ConsoleOptions] = None
3    ) -> Iterable[Segment]:
4        """Render an object in to an iterable of `Segment` instances.
5
6        This method contains the logic for rendering objects with the console protocol.
7        You are unlikely to need to use it directly, unless you are extending the library.
8
9        Args:
10            renderable (RenderableType): An object supporting the console protocol, or
11                an object that may be converted to a string.
12            options (ConsoleOptions, optional): An options object, or None to use self.options. Defaults to None.
13
14        Returns:
15            Iterable[Segment]: An iterable of segments that may be rendered.
16        """
17
18        _options = options or self.options
19        if _options.max_width < 1:
20            # No space to render anything. This prevents potential recursion errors.
21            return
22        render_iterable: RenderResult
23
24        renderable = rich_cast(renderable)
25        if hasattr(renderable, "__rich_console__") and not isclass(renderable):
26            render_iterable = renderable.__rich_console__(self, _options)  # type: ignore[union-attr]
27        elif isinstance(renderable, str):
28            text_renderable = self.render_str(
29                renderable, highlight=_options.highlight, markup=_options.markup
30            )
31            render_iterable = text_renderable.__rich_console__(self, _options)
32        else:
33            raise errors.NotRenderableError(
34                f"Unable to render {renderable!r}; "
35                "A str, Segment or object with __rich_console__ method is required"
36            )
37
38        try:
39            iter_render = iter(render_iterable)
40        except TypeError:
41            raise errors.NotRenderableError(
42                f"object {render_iterable!r} is not renderable"
43            )
44        _Segment = Segment
45        _options = _options.reset_height()
46        for render_output in iter_render:
47            if isinstance(render_output, _Segment):
48                yield render_output
49            else:
50                yield from self.render(render_output, _options)
            

Path 4: 136 calls (0.05)

→ renderable Control (118) LiveRender (5) Table (5) UnknownElement (4) Padding (4)

→ options ConsoleOptions (136)

10 run 13 not run

1def render(
2        self, renderable: RenderableType, options: Optional[ConsoleOptions] = None
3    ) -> Iterable[Segment]:
4        """Render an object in to an iterable of `Segment` instances.
5
6        This method contains the logic for rendering objects with the console protocol.
7        You are unlikely to need to use it directly, unless you are extending the library.
8
9        Args:
10            renderable (RenderableType): An object supporting the console protocol, or
11                an object that may be converted to a string.
12            options (ConsoleOptions, optional): An options object, or None to use self.options. Defaults to None.
13
14        Returns:
15            Iterable[Segment]: An iterable of segments that may be rendered.
16        """
17
18        _options = options or self.options
19        if _options.max_width < 1:
20            # No space to render anything. This prevents potential recursion errors.
21            return
22        render_iterable: RenderResult
23
24        renderable = rich_cast(renderable)
25        if hasattr(renderable, "__rich_console__") and not isclass(renderable):
26            render_iterable = renderable.__rich_console__(self, _options)  # type: ignore[union-attr]
27        elif isinstance(renderable, str):
28            text_renderable = self.render_str(
29                renderable, highlight=_options.highlight, markup=_options.markup
30            )
31            render_iterable = text_renderable.__rich_console__(self, _options)
32        else:
33            raise errors.NotRenderableError(
34                f"Unable to render {renderable!r}; "
35                "A str, Segment or object with __rich_console__ method is required"
36            )
37
38        try:
39            iter_render = iter(render_iterable)
40        except TypeError:
41            raise errors.NotRenderableError(
42                f"object {render_iterable!r} is not renderable"
43            )
44        _Segment = Segment
45        _options = _options.reset_height()
46        for render_output in iter_render:
47            if isinstance(render_output, _Segment):
48                yield render_output
49            else:
50                yield from self.render(render_output, _options)
            

Path 5: 46 calls (0.02)

→ renderable Padding (41) Text (1) 'bar' (1) 'baz' (1) 'banana pancakes' (1) '' (1)

→ options ConsoleOptions (46)

↩ return None (46)

3 run 20 not run

1def render(
2        self, renderable: RenderableType, options: Optional[ConsoleOptions] = None
3    ) -> Iterable[Segment]:
4        """Render an object in to an iterable of `Segment` instances.
5
6        This method contains the logic for rendering objects with the console protocol.
7        You are unlikely to need to use it directly, unless you are extending the library.
8
9        Args:
10            renderable (RenderableType): An object supporting the console protocol, or
11                an object that may be converted to a string.
12            options (ConsoleOptions, optional): An options object, or None to use self.options. Defaults to None.
13
14        Returns:
15            Iterable[Segment]: An iterable of segments that may be rendered.
16        """
17
18        _options = options or self.options
19        if _options.max_width < 1:
20            # No space to render anything. This prevents potential recursion errors.
21            return
22        render_iterable: RenderResult
23
24        renderable = rich_cast(renderable)
25        if hasattr(renderable, "__rich_console__") and not isclass(renderable):
26            render_iterable = renderable.__rich_console__(self, _options)  # type: ignore[union-attr]
27        elif isinstance(renderable, str):
28            text_renderable = self.render_str(
29                renderable, highlight=_options.highlight, markup=_options.markup
30            )
31            render_iterable = text_renderable.__rich_console__(self, _options)
32        else:
33            raise errors.NotRenderableError(
34                f"Unable to render {renderable!r}; "
35                "A str, Segment or object with __rich_console__ method is required"
36            )
37
38        try:
39            iter_render = iter(render_iterable)
40        except TypeError:
41            raise errors.NotRenderableError(
42                f"object {render_iterable!r} is not renderable"
43            )
44        _Segment = Segment
45        _options = _options.reset_height()
46        for render_output in iter_render:
47            if isinstance(render_output, _Segment):
48                yield render_output
49            else:
50                yield from self.render(render_output, _options)
            

Path 6: 4 calls (0.0)

→ renderable ScreenUpdate (4)

→ options None (3) ConsoleOptions (1)

⇇ yield Segment (51)

13 run 10 not run

1def render(
2        self, renderable: RenderableType, options: Optional[ConsoleOptions] = None
3    ) -> Iterable[Segment]:
4        """Render an object in to an iterable of `Segment` instances.
5
6        This method contains the logic for rendering objects with the console protocol.
7        You are unlikely to need to use it directly, unless you are extending the library.
8
9        Args:
10            renderable (RenderableType): An object supporting the console protocol, or
11                an object that may be converted to a string.
12            options (ConsoleOptions, optional): An options object, or None to use self.options. Defaults to None.
13
14        Returns:
15            Iterable[Segment]: An iterable of segments that may be rendered.
16        """
17
18        _options = options or self.options
19        if _options.max_width < 1:
20            # No space to render anything. This prevents potential recursion errors.
21            return
22        render_iterable: RenderResult
23
24        renderable = rich_cast(renderable)
25        if hasattr(renderable, "__rich_console__") and not isclass(renderable):
26            render_iterable = renderable.__rich_console__(self, _options)  # type: ignore[union-attr]
27        elif isinstance(renderable, str):
28            text_renderable = self.render_str(
29                renderable, highlight=_options.highlight, markup=_options.markup
30            )
31            render_iterable = text_renderable.__rich_console__(self, _options)
32        else:
33            raise errors.NotRenderableError(
34                f"Unable to render {renderable!r}; "
35                "A str, Segment or object with __rich_console__ method is required"
36            )
37
38        try:
39            iter_render = iter(render_iterable)
40        except TypeError:
41            raise errors.NotRenderableError(
42                f"object {render_iterable!r} is not renderable"
43            )
44        _Segment = Segment
45        _options = _options.reset_height()
46        for render_output in iter_render:
47            if isinstance(render_output, _Segment):
48                yield render_output
49            else:
50                yield from self.render(render_output, _options)
            

Path 7: 1 calls (0.0)

→ renderable [] (1)

→ options ConsoleOptions (1)

⚠ exception NotRenderableError (1)

7 run 16 not run

1def render(
2        self, renderable: RenderableType, options: Optional[ConsoleOptions] = None
3    ) -> Iterable[Segment]:
4        """Render an object in to an iterable of `Segment` instances.
5
6        This method contains the logic for rendering objects with the console protocol.
7        You are unlikely to need to use it directly, unless you are extending the library.
8
9        Args:
10            renderable (RenderableType): An object supporting the console protocol, or
11                an object that may be converted to a string.
12            options (ConsoleOptions, optional): An options object, or None to use self.options. Defaults to None.
13
14        Returns:
15            Iterable[Segment]: An iterable of segments that may be rendered.
16        """
17
18        _options = options or self.options
19        if _options.max_width < 1:
20            # No space to render anything. This prevents potential recursion errors.
21            return
22        render_iterable: RenderResult
23
24        renderable = rich_cast(renderable)
25        if hasattr(renderable, "__rich_console__") and not isclass(renderable):
26            render_iterable = renderable.__rich_console__(self, _options)  # type: ignore[union-attr]
27        elif isinstance(renderable, str):
28            text_renderable = self.render_str(
29                renderable, highlight=_options.highlight, markup=_options.markup
30            )
31            render_iterable = text_renderable.__rich_console__(self, _options)
32        else:
33            raise errors.NotRenderableError(
34                f"Unable to render {renderable!r}; "
35                "A str, Segment or object with __rich_console__ method is required"
36            )
37
38        try:
39            iter_render = iter(render_iterable)
40        except TypeError:
41            raise errors.NotRenderableError(
42                f"object {render_iterable!r} is not renderable"
43            )
44        _Segment = Segment
45        _options = _options.reset_height()
46        for render_output in iter_render:
47            if isinstance(render_output, _Segment):
48                yield render_output
49            else:
50                yield from self.render(render_output, _options)
            

Path 8: 1 calls (0.0)

→ renderable BrokenRenderable (1)

→ options ConsoleOptions (1)

⚠ exception NotRenderableError (1)

10 run 13 not run

1def render(
2        self, renderable: RenderableType, options: Optional[ConsoleOptions] = None
3    ) -> Iterable[Segment]:
4        """Render an object in to an iterable of `Segment` instances.
5
6        This method contains the logic for rendering objects with the console protocol.
7        You are unlikely to need to use it directly, unless you are extending the library.
8
9        Args:
10            renderable (RenderableType): An object supporting the console protocol, or
11                an object that may be converted to a string.
12            options (ConsoleOptions, optional): An options object, or None to use self.options. Defaults to None.
13
14        Returns:
15            Iterable[Segment]: An iterable of segments that may be rendered.
16        """
17
18        _options = options or self.options
19        if _options.max_width < 1:
20            # No space to render anything. This prevents potential recursion errors.
21            return
22        render_iterable: RenderResult
23
24        renderable = rich_cast(renderable)
25        if hasattr(renderable, "__rich_console__") and not isclass(renderable):
26            render_iterable = renderable.__rich_console__(self, _options)  # type: ignore[union-attr]
27        elif isinstance(renderable, str):
28            text_renderable = self.render_str(
29                renderable, highlight=_options.highlight, markup=_options.markup
30            )
31            render_iterable = text_renderable.__rich_console__(self, _options)
32        else:
33            raise errors.NotRenderableError(
34                f"Unable to render {renderable!r}; "
35                "A str, Segment or object with __rich_console__ method is required"
36            )
37
38        try:
39            iter_render = iter(render_iterable)
40        except TypeError:
41            raise errors.NotRenderableError(
42                f"object {render_iterable!r} is not renderable"
43            )
44        _Segment = Segment
45        _options = _options.reset_height()
46        for render_output in iter_render:
47            if isinstance(render_output, _Segment):
48                yield render_output
49            else:
50                yield from self.render(render_output, _options)
            

Path 9: 1 calls (0.0)

→ renderable 'hello' (1)

→ options ConsoleOptions (1)

⚠ exception GeneratorExit (1)

0 run 0 not run

1def render(
2        self, renderable: RenderableType, options: Optional[ConsoleOptions] = None
3    ) -> Iterable[Segment]:
4        """Render an object in to an iterable of `Segment` instances.
5
6        This method contains the logic for rendering objects with the console protocol.
7        You are unlikely to need to use it directly, unless you are extending the library.
8
9        Args:
10            renderable (RenderableType): An object supporting the console protocol, or
11                an object that may be converted to a string.
12            options (ConsoleOptions, optional): An options object, or None to use self.options. Defaults to None.
13
14        Returns:
15            Iterable[Segment]: An iterable of segments that may be rendered.
16        """
17
18        _options = options or self.options
19        if _options.max_width < 1:
20            # No space to render anything. This prevents potential recursion errors.
21            return
22        render_iterable: RenderResult
23
24        renderable = rich_cast(renderable)
25        if hasattr(renderable, "__rich_console__") and not isclass(renderable):
26            render_iterable = renderable.__rich_console__(self, _options)  # type: ignore[union-attr]
27        elif isinstance(renderable, str):
28            text_renderable = self.render_str(
29                renderable, highlight=_options.highlight, markup=_options.markup
30            )
31            render_iterable = text_renderable.__rich_console__(self, _options)
32        else:
33            raise errors.NotRenderableError(
34                f"Unable to render {renderable!r}; "
35                "A str, Segment or object with __rich_console__ method is required"
36            )
37
38        try:
39            iter_render = iter(render_iterable)
40        except TypeError:
41            raise errors.NotRenderableError(
42                f"object {render_iterable!r} is not renderable"
43            )
44        _Segment = Segment
45        _options = _options.reset_height()
46        for render_output in iter_render:
47            if isinstance(render_output, _Segment):
48                yield render_output
49            else:
50                yield from self.render(render_output, _options)