Path 1: 90 calls (0.27)

→ color_system 'auto' (90)

→ force_terminal None (90)

→ force_jupyter None (90)

→ force_interactive None (90)

→ soft_wrap False (90)

→ theme None (90)

→ stderr False (90)

→ file None (66) StringIO (23) TextIOWrapper (1)

→ quiet False (89) True (1)

→ width None (90)

→ height None (90)

→ style None (90)

→ no_color None (90)

→ tab_size 8 (90)

→ record False (75) True (15)

→ markup True (89) False (1)

→ emoji True (89) False (1)

→ emoji_variant None (90)

→ highlight True (90)

→ log_time True (90)

→ log_path True (90)

→ log_time_format '[%X]' (90)

→ highlighter ReprHighlighter (90)

→ legacy_windows None (90)

→ safe_box True (90)

→ get_datetime None (89) test_get_time.. def (1)

→ get_time None (89) test_get_time.. def (1)

→ _environ None (90)

54 run 19 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 2: 51 calls (0.15)

→ color_system 'auto' (51)

→ force_terminal None (51)

→ force_jupyter None (51)

→ force_interactive None (51)

→ soft_wrap False (51)

→ theme None (51)

→ stderr False (51)

→ file StringIO (35) None (16)

→ quiet False (51)

→ width 100 (19) 10 (12) 20 (3) 3 (3) 5 (3) 40 (2) 120 (2) 42 (2) 2 (2) 4 (1)

→ height None (51)

→ style None (51)

→ no_color None (51)

→ tab_size 8 (51)

→ record False (33) True (18)

→ markup True (51)

→ emoji True (51)

→ emoji_variant None (51)

→ highlight True (51)

→ log_time True (51)

→ log_path True (50) False (1)

→ log_time_format '[%X]' (50) test_log_milliseconds..time_formatter def (1)

→ highlighter ReprHighlighter (51)

→ legacy_windows None (51)

→ safe_box True (51)

→ get_datetime None (51)

→ get_time None (51)

→ _environ None (51)

52 run 21 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 3: 24 calls (0.07)

→ color_system 'truecolor' (24)

→ force_terminal None (24)

→ force_jupyter None (24)

→ force_interactive None (24)

→ soft_wrap False (24)

→ theme None (24)

→ stderr False (24)

→ file StringIO (24)

→ quiet False (24)

→ width 100 (23) 20 (1)

→ height None (24)

→ style None (24)

→ no_color None (24)

→ tab_size 8 (24)

→ record False (23) True (1)

→ markup True (24)

→ emoji True (24)

→ emoji_variant None (24)

→ highlight True (24)

→ log_time True (24)

→ log_path True (24)

→ log_time_format '[%X]' (24)

→ highlighter ReprHighlighter (24)

→ legacy_windows False (24)

→ safe_box True (24)

→ get_datetime None (24)

→ get_time None (24)

→ _environ None (24)

53 run 20 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 4: 24 calls (0.07)

→ color_system 'auto' (24)

→ force_terminal None (24)

→ force_jupyter None (24)

→ force_interactive None (24)

→ soft_wrap False (24)

→ theme None (24)

→ stderr False (24)

→ file StringIO (24)

→ quiet False (24)

→ width 50 (22) 100 (2)

→ height None (24)

→ style None (24)

→ no_color None (24)

→ tab_size 8 (24)

→ record False (24)

→ markup True (24)

→ emoji True (24)

→ emoji_variant None (24)

→ highlight True (24)

→ log_time True (24)

→ log_path True (24)

→ log_time_format '[%X]' (24)

→ highlighter ReprHighlighter (24)

→ legacy_windows False (24)

→ safe_box True (24)

→ get_datetime None (24)

→ get_time None (24)

→ _environ None (24)

53 run 20 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 5: 15 calls (0.04)

→ color_system 'truecolor' (13) 'standard' (1) 'windows' (1)

→ force_terminal None (15)

→ force_jupyter None (15)

→ force_interactive None (15)

→ soft_wrap False (15)

→ theme None (15)

→ stderr False (15)

→ file StringIO (13) None (2)

→ quiet False (15)

→ width None (15)

→ height None (15)

→ style None (15)

→ no_color None (15)

→ tab_size 8 (15)

→ record False (15)

→ markup True (15)

→ emoji True (15)

→ emoji_variant None (15)

→ highlight True (15)

→ log_time True (15)

→ log_path True (15)

→ log_time_format '[%X]' (15)

→ highlighter ReprHighlighter (15)

→ legacy_windows None (15)

→ safe_box True (15)

→ get_datetime None (15)

→ get_time None (15)

→ _environ None (15)

54 run 19 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 6: 10 calls (0.03)

→ color_system None (10)

→ force_terminal None (10)

→ force_jupyter None (10)

→ force_interactive None (10)

→ soft_wrap False (10)

→ theme None (10)

→ stderr False (10)

→ file None (10)

→ quiet False (10)

→ width None (10)

→ height None (10)

→ style None (10)

→ no_color None (10)

→ tab_size 8 (10)

→ record False (10)

→ markup True (10)

→ emoji True (10)

→ emoji_variant None (10)

→ highlight True (10)

→ log_time True (10)

→ log_path True (10)

→ log_time_format '[%X]' (10)

→ highlighter ReprHighlighter (10)

→ legacy_windows None (10)

→ safe_box True (10)

→ get_datetime None (10)

→ get_time None (10)

→ _environ None (10)

53 run 20 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 7: 10 calls (0.03)

→ color_system 'truecolor' (10)

→ force_terminal True (10)

→ force_jupyter None (10)

→ force_interactive None (10)

→ soft_wrap False (10)

→ theme None (10)

→ stderr False (10)

→ file StringIO (10)

→ quiet False (10)

→ width 60 (5) 80 (3) 10 (2)

→ height None (10)

→ style None (10)

→ no_color None (10)

→ tab_size 8 (10)

→ record False (10)

→ markup True (10)

→ emoji True (10)

→ emoji_variant None (10)

→ highlight True (10)

→ log_time True (10)

→ log_path True (10)

→ log_time_format '[%X]' (10)

→ highlighter ReprHighlighter (10)

→ legacy_windows False (10)

→ safe_box True (10)

→ get_datetime None (10)

→ get_time None (10)

→ _environ {} (10)

53 run 20 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 8: 9 calls (0.03)

→ color_system 'auto' (9)

→ force_terminal True (9)

→ force_jupyter None (9)

→ force_interactive None (9)

→ soft_wrap False (9)

→ theme None (8) Theme (1)

→ stderr False (9)

→ file None (6) StringIO (3)

→ quiet False (9)

→ width None (9)

→ height None (9)

→ style None (9)

→ no_color None (9)

→ tab_size 8 (9)

→ record False (9)

→ markup True (9)

→ emoji True (9)

→ emoji_variant None (9)

→ highlight True (9)

→ log_time True (9)

→ log_path True (9)

→ log_time_format '[%X]' (9)

→ highlighter ReprHighlighter (9)

→ legacy_windows None (9)

→ safe_box True (9)

→ get_datetime None (9)

→ get_time None (9)

→ _environ {} (6) {'TERM': 'dumb'} (1) {'TERM': 'rxvt-unicode-256color'} (1) {'COLORTERM': 'truecolor'} (1)

54 run 19 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 9: 9 calls (0.03)

→ color_system None (9)

→ force_terminal True (8) False (1)

→ force_jupyter None (9)

→ force_interactive None (9)

→ soft_wrap False (9)

→ theme None (9)

→ stderr False (9)

→ file None (9)

→ quiet False (9)

→ width 60 (8) 20 (1)

→ height 5 (5) 80 (4)

→ style None (9)

→ no_color None (9)

→ tab_size 8 (9)

→ record False (9)

→ markup True (9)

→ emoji True (9)

→ emoji_variant None (9)

→ highlight True (9)

→ log_time True (9)

→ log_path True (9)

→ log_time_format '[%X]' (9)

→ highlighter ReprHighlighter (9)

→ legacy_windows False (9)

→ safe_box True (9)

→ get_datetime None (9)

→ get_time None (9)

→ _environ {} (9)

50 run 23 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 10: 7 calls (0.02)

→ color_system 'auto' (7)

→ force_terminal None (7)

→ force_jupyter None (7)

→ force_interactive None (7)

→ soft_wrap False (7)

→ theme None (7)

→ stderr False (7)

→ file None (6) StringIO (1)

→ quiet False (7)

→ width None (7)

→ height None (7)

→ style None (7)

→ no_color None (7)

→ tab_size 8 (7)

→ record False (7)

→ markup True (7)

→ emoji True (7)

→ emoji_variant None (7)

→ highlight True (7)

→ log_time True (7)

→ log_path True (7)

→ log_time_format '[%X]' (7)

→ highlighter ReprHighlighter (7)

→ legacy_windows False (7)

→ safe_box True (7)

→ get_datetime None (7)

→ get_time None (7)

→ _environ None (7)

55 run 18 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 11: 7 calls (0.02)

→ color_system 'auto' (7)

→ force_terminal None (7)

→ force_jupyter True (7)

→ force_interactive None (7)

→ soft_wrap False (7)

→ theme None (7)

→ stderr False (7)

→ file StringIO (6) None (1)

→ quiet False (7)

→ width None (7)

→ height None (7)

→ style None (7)

→ no_color None (7)

→ tab_size 8 (7)

→ record False (7)

→ markup True (7)

→ emoji True (7)

→ emoji_variant None (7)

→ highlight True (7)

→ log_time True (7)

→ log_path True (7)

→ log_time_format '[%X]' (7)

→ highlighter ReprHighlighter (7)

→ legacy_windows None (7)

→ safe_box True (7)

→ get_datetime None (7)

→ get_time None (7)

→ _environ None (7)

58 run 15 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 12: 7 calls (0.02)

→ color_system None (7)

→ force_terminal None (7)

→ force_jupyter None (7)

→ force_interactive None (7)

→ soft_wrap False (7)

→ theme None (7)

→ stderr False (7)

→ file None (6) StringIO (1)

→ quiet False (7)

→ width 100 (3) 60 (2) 20 (1) 80 (1)

→ height None (7)

→ style None (7)

→ no_color None (7)

→ tab_size 8 (7)

→ record False (7)

→ markup True (7)

→ emoji True (7)

→ emoji_variant None (7)

→ highlight True (7)

→ log_time True (6) False (1)

→ log_path True (6) False (1)

→ log_time_format '[%X]' (7)

→ highlighter ReprHighlighter (7)

→ legacy_windows None (7)

→ safe_box True (7)

→ get_datetime None (7)

→ get_time None (7)

→ _environ None (7)

51 run 22 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 13: 6 calls (0.02)

→ color_system 'auto' (6)

→ force_terminal None (6)

→ force_jupyter None (6)

→ force_interactive None (6)

→ soft_wrap False (6)

→ theme None (6)

→ stderr False (6)

→ file StringIO (6)

→ quiet False (6)

→ width 32 (4) 16 (2)

→ height None (6)

→ style None (6)

→ no_color None (6)

→ tab_size 8 (6)

→ record False (6)

→ markup True (6)

→ emoji True (6)

→ emoji_variant None (6)

→ highlight True (6)

→ log_time True (6)

→ log_path True (6)

→ log_time_format '[%X]' (6)

→ highlighter ReprHighlighter (6)

→ legacy_windows False (6)

→ safe_box True (6)

→ get_datetime None (6)

→ get_time None (6)

→ _environ {} (6)

54 run 19 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 14: 5 calls (0.01)

→ color_system 'auto' (5)

→ force_terminal True (5)

→ force_jupyter None (5)

→ force_interactive None (5)

→ soft_wrap False (5)

→ theme None (5)

→ stderr False (5)

→ file StringIO (5)

→ quiet False (5)

→ width 20 (2) 10 (2) 16 (1)

→ height None (5)

→ style None (5)

→ no_color None (5)

→ tab_size 8 (5)

→ record False (5)

→ markup True (5)

→ emoji True (5)

→ emoji_variant None (5)

→ highlight True (5)

→ log_time True (5)

→ log_path True (5)

→ log_time_format '[%X]' (5)

→ highlighter ReprHighlighter (5)

→ legacy_windows False (5)

→ safe_box True (5)

→ get_datetime None (5)

→ get_time None (5)

→ _environ {} (5)

53 run 20 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 15: 4 calls (0.01)

→ color_system 'auto' (4)

→ force_terminal True (4)

→ force_jupyter None (4)

→ force_interactive None (4)

→ soft_wrap False (4)

→ theme None (4)

→ stderr False (4)

→ file None (3) StringIO (1)

→ quiet False (4)

→ width None (4)

→ height None (4)

→ style None (4)

→ no_color None (4)

→ tab_size 8 (4)

→ record False (4)

→ markup True (4)

→ emoji True (4)

→ emoji_variant None (4)

→ highlight True (4)

→ log_time True (4)

→ log_path True (4)

→ log_time_format '[%X]' (4)

→ highlighter ReprHighlighter (4)

→ legacy_windows False (4)

→ safe_box True (4)

→ get_datetime None (4)

→ get_time None (4)

→ _environ {'TERM': 'xterm-16color'} (1) {'COLORTERM': 'truecolor', 'TERM': 'xterm-16color'} (1) {'TERM': 'xterm-kitty'} (1) {} (1)

55 run 18 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 16: 4 calls (0.01)

→ color_system 'auto' (4)

→ force_terminal True (4)

→ force_jupyter None (4)

→ force_interactive None (4)

→ soft_wrap False (4)

→ theme None (4)

→ stderr False (4)

→ file StringIO (3) None (1)

→ quiet False (4)

→ width 20 (4)

→ height None (4)

→ style None (4)

→ no_color None (4)

→ tab_size 8 (4)

→ record False (4)

→ markup True (4)

→ emoji True (4)

→ emoji_variant None (4)

→ highlight True (4)

→ log_time True (4)

→ log_path True (4)

→ log_time_format '[%X]' (4)

→ highlighter ReprHighlighter (4)

→ legacy_windows None (4)

→ safe_box True (4)

→ get_datetime None (4)

→ get_time None (3) test_spinner_update..get_time def (1)

→ _environ {} (4)

52 run 21 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 17: 4 calls (0.01)

→ color_system None (4)

→ force_terminal True (4)

→ force_jupyter None (4)

→ force_interactive None (4)

→ soft_wrap False (4)

→ theme None (4)

→ stderr False (4)

→ file StringIO (3) None (1)

→ quiet False (4)

→ width 16 (2) 80 (1) 60 (1)

→ height None (4)

→ style None (4)

→ no_color None (4)

→ tab_size 8 (4)

→ record False (4)

→ markup True (4)

→ emoji True (4)

→ emoji_variant None (4)

→ highlight True (4)

→ log_time True (4)

→ log_path True (4)

→ log_time_format '[%X]' (4)

→ highlighter ReprHighlighter (4)

→ legacy_windows False (4)

→ safe_box True (4)

→ get_datetime None (4)

→ get_time None (4)

→ _environ {} (4)

52 run 21 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 18: 3 calls (0.01)

→ color_system 'truecolor' (3)

→ force_terminal True (3)

→ force_jupyter None (3)

→ force_interactive None (3)

→ soft_wrap False (3)

→ theme None (3)

→ stderr False (3)

→ file StringIO (3)

→ quiet False (3)

→ width 80 (1) 10 (1) 140 (1)

→ height None (3)

→ style None (3)

→ no_color None (3)

→ tab_size 8 (3)

→ record False (3)

→ markup True (3)

→ emoji True (3)

→ emoji_variant None (3)

→ highlight True (3)

→ log_time True (3)

→ log_path True (3)

→ log_time_format '[%X]' (3)

→ highlighter ReprHighlighter (3)

→ legacy_windows None (3)

→ safe_box True (3)

→ get_datetime None (3)

→ get_time None (3)

→ _environ {} (3)

52 run 21 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 19: 3 calls (0.01)

→ color_system 'auto' (3)

→ force_terminal None (3)

→ force_jupyter None (3)

→ force_interactive None (3)

→ soft_wrap False (3)

→ theme None (3)

→ stderr False (3)

→ file None (3)

→ quiet False (3)

→ width 99 (1) 80 (1) 63 (1)

→ height 101 (1) 25 (1) 46 (1)

→ style None (3)

→ no_color None (3)

→ tab_size 8 (3)

→ record False (3)

→ markup True (3)

→ emoji True (3)

→ emoji_variant None (3)

→ highlight True (3)

→ log_time True (3)

→ log_path True (3)

→ log_time_format '[%X]' (3)

→ highlighter ReprHighlighter (3)

→ legacy_windows False (3)

→ safe_box True (3)

→ get_datetime None (3)

→ get_time None (3)

→ _environ None (3)

51 run 22 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 20: 3 calls (0.01)

→ color_system 'auto' (3)

→ force_terminal None (3)

→ force_jupyter None (3)

→ force_interactive None (3)

→ soft_wrap False (3)

→ theme None (3)

→ stderr False (3)

→ file None (3)

→ quiet False (3)

→ width None (3)

→ height None (3)

→ style None (3)

→ no_color None (3)

→ tab_size 8 (3)

→ record False (3)

→ markup True (3)

→ emoji True (3)

→ emoji_variant None (3)

→ highlight True (3)

→ log_time True (3)

→ log_path True (3)

→ log_time_format '[%X]' (3)

→ highlighter ReprHighlighter (3)

→ legacy_windows None (3)

→ safe_box True (3)

→ get_datetime None (3)

→ get_time None (3)

→ _environ {} (3)

55 run 18 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 21: 3 calls (0.01)

→ color_system 'auto' (3)

→ force_terminal None (3)

→ force_jupyter None (3)

→ force_interactive None (3)

→ soft_wrap False (3)

→ theme None (3)

→ stderr False (3)

→ file StringIO (3)

→ quiet False (3)

→ width None (3)

→ height None (3)

→ style None (3)

→ no_color None (3)

→ tab_size 8 (3)

→ record False (3)

→ markup True (3)

→ emoji True (3)

→ emoji_variant None (3)

→ highlight True (3)

→ log_time True (3)

→ log_path True (3)

→ log_time_format '[%X]' (3)

→ highlighter ReprHighlighter (3)

→ legacy_windows None (3)

→ safe_box True (3)

→ get_datetime None (3)

→ get_time None (3)

→ _environ {'FORCE_COLOR': ''} (1) {'FORCE_COLOR': 'something'} (1) {'FORCE_COLOR': '0'} (1)

56 run 17 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 22: 3 calls (0.01)

→ color_system 'auto' (3)

→ force_terminal None (3)

→ force_jupyter True (3)

→ force_interactive None (3)

→ soft_wrap False (3)

→ theme None (3)

→ stderr False (3)

→ file None (3)

→ quiet False (3)

→ width 40 (3)

→ height None (3)

→ style None (3)

→ no_color None (3)

→ tab_size 8 (3)

→ record False (3)

→ markup True (3)

→ emoji True (3)

→ emoji_variant None (3)

→ highlight True (3)

→ log_time True (3)

→ log_path True (3)

→ log_time_format '[%X]' (3)

→ highlighter ReprHighlighter (3)

→ legacy_windows None (3)

→ safe_box True (3)

→ get_datetime None (3)

→ get_time None (3)

→ _environ {'JUPYTER_COLUMNS': '314'} (1) {'JUPYTER_COLUMNS': 'broken'} (1) {'JUPYTER_LINES': 'broken'} (1)

56 run 17 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 23: 2 calls (0.01)

→ color_system 'truecolor' (2)

→ force_terminal True (2)

→ force_jupyter None (2)

→ force_interactive None (2)

→ soft_wrap False (2)

→ theme None (2)

→ stderr False (2)

→ file None (2)

→ quiet False (2)

→ width None (2)

→ height None (2)

→ style None (2)

→ no_color None (2)

→ tab_size 8 (2)

→ record False (2)

→ markup True (2)

→ emoji True (2)

→ emoji_variant None (2)

→ highlight True (2)

→ log_time True (2)

→ log_path True (2)

→ log_time_format '[%X]' (2)

→ highlighter ReprHighlighter (2)

→ legacy_windows False (2)

→ safe_box True (2)

→ get_datetime None (2)

→ get_time None (2)

→ _environ None (2)

54 run 19 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 24: 2 calls (0.01)

→ color_system 'auto' (2)

→ force_terminal True (2)

→ force_jupyter None (2)

→ force_interactive None (2)

→ soft_wrap False (2)

→ theme None (2)

→ stderr False (2)

→ file StringIO (2)

→ quiet False (2)

→ width 20 (2)

→ height None (2)

→ style None (2)

→ no_color None (2)

→ tab_size 8 (2)

→ record False (2)

→ markup True (2)

→ emoji True (2)

→ emoji_variant None (2)

→ highlight True (2)

→ log_time True (2)

→ log_path True (2)

→ log_time_format '[%X]' (2)

→ highlighter ReprHighlighter (2)

→ legacy_windows None (2)

→ safe_box True (2)

→ get_datetime None (2)

→ get_time None (2)

→ _environ None (2)

51 run 22 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 25: 2 calls (0.01)

→ color_system 'truecolor' (2)

→ force_terminal True (2)

→ force_jupyter None (2)

→ force_interactive None (2)

→ soft_wrap False (2)

→ theme None (2)

→ stderr False (2)

→ file StringIO (2)

→ quiet False (2)

→ width None (2)

→ height None (2)

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

→ no_color None (1) True (1)

→ tab_size 8 (2)

→ record False (2)

→ markup True (2)

→ emoji True (2)

→ emoji_variant None (2)

→ highlight True (2)

→ log_time True (2)

→ log_path True (2)

→ log_time_format '[%X]' (2)

→ highlighter ReprHighlighter (2)

→ legacy_windows None (2)

→ safe_box True (2)

→ get_datetime None (2)

→ get_time None (2)

→ _environ None (2)

53 run 20 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 26: 2 calls (0.01)

→ color_system 'auto' (2)

→ force_terminal None (2)

→ force_jupyter None (2)

→ force_interactive None (2)

→ soft_wrap False (2)

→ theme None (2)

→ stderr False (2)

→ file None (2)

→ quiet False (2)

→ width 80 (2)

→ height 46 (1) 25 (1)

→ style None (2)

→ no_color None (2)

→ tab_size 8 (2)

→ record False (2)

→ markup True (2)

→ emoji True (2)

→ emoji_variant None (2)

→ highlight True (2)

→ log_time True (2)

→ log_path True (2)

→ log_time_format '[%X]' (2)

→ highlighter ReprHighlighter (2)

→ legacy_windows None (2)

→ safe_box True (2)

→ get_datetime None (2)

→ get_time None (2)

→ _environ None (2)

50 run 23 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 27: 2 calls (0.01)

→ color_system 'auto' (2)

→ force_terminal True (2)

→ force_jupyter None (2)

→ force_interactive None (2)

→ soft_wrap False (2)

→ theme None (2)

→ stderr False (2)

→ file None (2)

→ quiet False (2)

→ width None (2)

→ height None (2)

→ style None (2)

→ no_color None (2)

→ tab_size 8 (2)

→ record False (2)

→ markup True (2)

→ emoji True (2)

→ emoji_variant None (2)

→ highlight True (2)

→ log_time True (2)

→ log_path True (2)

→ log_time_format '[%X]' (2)

→ highlighter ReprHighlighter (2)

→ legacy_windows None (2)

→ safe_box True (2)

→ get_datetime None (2)

→ get_time None (2)

→ _environ None (2)

53 run 20 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 28: 2 calls (0.01)

→ color_system 'auto' (2)

→ force_terminal True (2)

→ force_jupyter None (2)

→ force_interactive None (2)

→ soft_wrap False (2)

→ theme None (2)

→ stderr False (2)

→ file None (2)

→ quiet False (2)

→ width 20 (2)

→ height 5 (2)

→ style None (2)

→ no_color None (2)

→ tab_size 8 (2)

→ record False (2)

→ markup True (2)

→ emoji True (2)

→ emoji_variant None (2)

→ highlight True (2)

→ log_time True (2)

→ log_path True (2)

→ log_time_format '[%X]' (2)

→ highlighter ReprHighlighter (2)

→ legacy_windows None (2)

→ safe_box True (2)

→ get_datetime None (2)

→ get_time None (2)

→ _environ {} (2)

50 run 23 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 29: 2 calls (0.01)

→ color_system 'truecolor' (2)

→ force_terminal True (2)

→ force_jupyter None (2)

→ force_interactive None (2)

→ soft_wrap False (2)

→ theme None (2)

→ stderr False (2)

→ file None (2)

→ quiet False (2)

→ width 20 (2)

→ height 40 (2)

→ style None (2)

→ no_color None (2)

→ tab_size 8 (2)

→ record False (2)

→ markup True (2)

→ emoji True (2)

→ emoji_variant None (2)

→ highlight True (2)

→ log_time True (2)

→ log_path True (2)

→ log_time_format '[%X]' (2)

→ highlighter ReprHighlighter (2)

→ legacy_windows False (2)

→ safe_box True (2)

→ get_datetime None (2)

→ get_time None (2)

→ _environ None (2)

50 run 23 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 30: 2 calls (0.01)

→ color_system 'truecolor' (2)

→ force_terminal True (2)

→ force_jupyter None (2)

→ force_interactive None (2)

→ soft_wrap False (2)

→ theme None (2)

→ stderr False (2)

→ file StringIO (1) None (1)

→ quiet False (2)

→ width 80 (2)

→ height None (2)

→ style None (2)

→ no_color None (2)

→ tab_size 8 (2)

→ record False (1) True (1)

→ markup True (2)

→ emoji True (2)

→ emoji_variant None (2)

→ highlight True (2)

→ log_time True (2)

→ log_path True (2)

→ log_time_format '[TIME]' (1) '[%X]' (1)

→ highlighter ReprHighlighter (2)

→ legacy_windows False (2)

→ safe_box True (2)

→ get_datetime None (2)

→ get_time None (2)

→ _environ None (2)

52 run 21 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 31: 2 calls (0.01)

→ color_system None (2)

→ force_terminal True (2)

→ force_jupyter None (2)

→ force_interactive None (2)

→ soft_wrap False (2)

→ theme None (2)

→ stderr False (2)

→ file StringIO (2)

→ quiet False (2)

→ width 140 (2)

→ height None (2)

→ style None (2)

→ no_color None (2)

→ tab_size 8 (2)

→ record False (2)

→ markup True (2)

→ emoji True (2)

→ emoji_variant None (2)

→ highlight True (2)

→ log_time True (2)

→ log_path True (2)

→ log_time_format '[%X]' (2)

→ highlighter ReprHighlighter (2)

→ legacy_windows None (2)

→ safe_box True (2)

→ get_datetime None (2)

→ get_time None (2)

→ _environ {} (2)

51 run 22 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 32: 2 calls (0.01)

→ color_system None (2)

→ force_terminal True (2)

→ force_jupyter None (2)

→ force_interactive None (2)

→ soft_wrap False (2)

→ theme None (2)

→ stderr False (2)

→ file None (2)

→ quiet False (2)

→ width 80 (2)

→ height None (2)

→ style None (2)

→ no_color None (2)

→ tab_size 8 (2)

→ record False (2)

→ markup True (2)

→ emoji True (2)

→ emoji_variant None (2)

→ highlight True (2)

→ log_time True (2)

→ log_path True (2)

→ log_time_format '[%X]' (2)

→ highlighter ReprHighlighter (2)

→ legacy_windows None (2)

→ safe_box True (2)

→ get_datetime None (2)

→ get_time test_spinner_render..get_time def (1) None (1)

→ _environ None (2)

50 run 23 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 33: 2 calls (0.01)

→ color_system None (2)

→ force_terminal None (2)

→ force_jupyter None (2)

→ force_interactive None (2)

→ soft_wrap False (2)

→ theme None (2)

→ stderr False (2)

→ file None (2)

→ quiet False (2)

→ width 80 (2)

→ height None (2)

→ style None (2)

→ no_color None (2)

→ tab_size 8 (2)

→ record False (2)

→ markup True (2)

→ emoji True (2)

→ emoji_variant None (2)

→ highlight True (2)

→ log_time True (2)

→ log_path True (2)

→ log_time_format '[%X]' (2)

→ highlighter ReprHighlighter (2)

→ legacy_windows False (2)

→ safe_box True (2)

→ get_datetime None (2)

→ get_time test_status.. def (1) test_renderable.. def (1)

→ _environ None (2)

52 run 21 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 34: 1 calls (0.0)

→ color_system None (1)

→ force_terminal None (1)

→ force_jupyter None (1)

→ force_interactive None (1)

→ soft_wrap False (1)

→ theme None (1)

→ stderr False (1)

→ file None (1)

→ quiet False (1)

→ width None (1)

→ height 6 (1)

→ style None (1)

→ no_color None (1)

→ tab_size 8 (1)

→ record False (1)

→ markup True (1)

→ emoji True (1)

→ emoji_variant None (1)

→ highlight True (1)

→ log_time True (1)

→ log_path True (1)

→ log_time_format '[%X]' (1)

→ highlighter ReprHighlighter (1)

→ legacy_windows None (1)

→ safe_box True (1)

→ get_datetime None (1)

→ get_time None (1)

→ _environ None (1)

51 run 22 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 35: 1 calls (0.0)

→ color_system 'truecolor' (1)

→ force_terminal None (1)

→ force_jupyter None (1)

→ force_interactive None (1)

→ soft_wrap False (1)

→ theme None (1)

→ stderr False (1)

→ file StringIO (1)

→ quiet False (1)

→ width 80 (1)

→ height None (1)

→ style None (1)

→ no_color None (1)

→ tab_size 8 (1)

→ record False (1)

→ markup True (1)

→ emoji True (1)

→ emoji_variant None (1)

→ highlight True (1)

→ log_time True (1)

→ log_path False (1)

→ log_time_format 'TIME' (1)

→ highlighter ReprHighlighter (1)

→ legacy_windows None (1)

→ safe_box True (1)

→ get_datetime None (1)

→ get_time None (1)

→ _environ {} (1)

53 run 20 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 36: 1 calls (0.0)

→ color_system None (1)

→ force_terminal True (1)

→ force_jupyter None (1)

→ force_interactive True (1)

→ soft_wrap False (1)

→ theme None (1)

→ stderr False (1)

→ file None (1)

→ quiet False (1)

→ width None (1)

→ height None (1)

→ style None (1)

→ no_color None (1)

→ tab_size 8 (1)

→ record False (1)

→ markup True (1)

→ emoji True (1)

→ emoji_variant None (1)

→ highlight True (1)

→ log_time True (1)

→ log_path True (1)

→ log_time_format '[%X]' (1)

→ highlighter ReprHighlighter (1)

→ legacy_windows None (1)

→ safe_box True (1)

→ get_datetime None (1)

→ get_time None (1)

→ _environ {} (1)

54 run 19 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 37: 1 calls (0.0)

→ color_system 'truecolor' (1)

→ force_terminal True (1)

→ force_jupyter None (1)

→ force_interactive None (1)

→ soft_wrap False (1)

→ theme None (1)

→ stderr False (1)

→ file None (1)

→ quiet False (1)

→ width 20 (1)

→ height 4 (1)

→ style None (1)

→ no_color None (1)

→ tab_size 8 (1)

→ record False (1)

→ markup True (1)

→ emoji True (1)

→ emoji_variant None (1)

→ highlight True (1)

→ log_time True (1)

→ log_path True (1)

→ log_time_format '[%X]' (1)

→ highlighter ReprHighlighter (1)

→ legacy_windows None (1)

→ safe_box True (1)

→ get_datetime None (1)

→ get_time None (1)

→ _environ {} (1)

50 run 23 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 38: 1 calls (0.0)

→ color_system 'auto' (1)

→ force_terminal None (1)

→ force_jupyter None (1)

→ force_interactive None (1)

→ soft_wrap False (1)

→ theme None (1)

→ stderr False (1)

→ file None (1)

→ quiet False (1)

→ width None (1)

→ height None (1)

→ style None (1)

→ no_color None (1)

→ tab_size 8 (1)

→ record False (1)

→ markup True (1)

→ emoji True (1)

→ emoji_variant None (1)

→ highlight True (1)

→ log_time True (1)

→ log_path True (1)

→ log_time_format '[%X]' (1)

→ highlighter ReprHighlighter (1)

→ legacy_windows None (1)

→ safe_box True (1)

→ get_datetime None (1)

→ get_time None (1)

→ _environ {'LINES': '220'} (1)

56 run 17 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 39: 1 calls (0.0)

→ color_system 'auto' (1)

→ force_terminal None (1)

→ force_jupyter None (1)

→ force_interactive None (1)

→ soft_wrap False (1)

→ theme None (1)

→ stderr False (1)

→ file None (1)

→ quiet False (1)

→ width None (1)

→ height 40 (1)

→ style None (1)

→ no_color None (1)

→ tab_size 8 (1)

→ record False (1)

→ markup True (1)

→ emoji True (1)

→ emoji_variant None (1)

→ highlight True (1)

→ log_time True (1)

→ log_path True (1)

→ log_time_format '[%X]' (1)

→ highlighter ReprHighlighter (1)

→ legacy_windows None (1)

→ safe_box True (1)

→ get_datetime None (1)

→ get_time None (1)

→ _environ {'LINES': '220'} (1)

53 run 20 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 40: 1 calls (0.0)

→ color_system 'auto' (1)

→ force_terminal None (1)

→ force_jupyter None (1)

→ force_interactive None (1)

→ soft_wrap False (1)

→ theme None (1)

→ stderr False (1)

→ file None (1)

→ quiet False (1)

→ width 40 (1)

→ height None (1)

→ style None (1)

→ no_color None (1)

→ tab_size 8 (1)

→ record False (1)

→ markup True (1)

→ emoji True (1)

→ emoji_variant None (1)

→ highlight True (1)

→ log_time True (1)

→ log_path True (1)

→ log_time_format '[%X]' (1)

→ highlighter ReprHighlighter (1)

→ legacy_windows None (1)

→ safe_box True (1)

→ get_datetime None (1)

→ get_time None (1)

→ _environ {'LINES': 'broken'} (1)

53 run 20 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 41: 1 calls (0.0)

→ color_system 'auto' (1)

→ force_terminal True (1)

→ force_jupyter None (1)

→ force_interactive None (1)

→ soft_wrap False (1)

→ theme None (1)

→ stderr False (1)

→ file None (1)

→ quiet False (1)

→ width 20 (1)

→ height 5 (1)

→ style None (1)

→ no_color None (1)

→ tab_size 8 (1)

→ record False (1)

→ markup True (1)

→ emoji True (1)

→ emoji_variant None (1)

→ highlight True (1)

→ log_time True (1)

→ log_path True (1)

→ log_time_format '[%X]' (1)

→ highlighter ReprHighlighter (1)

→ legacy_windows None (1)

→ safe_box True (1)

→ get_datetime None (1)

→ get_time None (1)

→ _environ None (1)

49 run 24 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 42: 1 calls (0.0)

→ color_system 'auto' (1)

→ force_terminal None (1)

→ force_jupyter True (1)

→ force_interactive None (1)

→ soft_wrap False (1)

→ theme None (1)

→ stderr False (1)

→ file None (1)

→ quiet False (1)

→ width None (1)

→ height None (1)

→ style None (1)

→ no_color None (1)

→ tab_size 8 (1)

→ record False (1)

→ markup True (1)

→ emoji True (1)

→ emoji_variant None (1)

→ highlight True (1)

→ log_time True (1)

→ log_path True (1)

→ log_time_format '[%X]' (1)

→ highlighter ReprHighlighter (1)

→ legacy_windows None (1)

→ safe_box True (1)

→ get_datetime None (1)

→ get_time None (1)

→ _environ {'JUPYTER_COLUMNS': '314'} (1)

59 run 14 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 43: 1 calls (0.0)

→ color_system 'auto' (1)

→ force_terminal None (1)

→ force_jupyter True (1)

→ force_interactive None (1)

→ soft_wrap False (1)

→ theme None (1)

→ stderr False (1)

→ file None (1)

→ quiet False (1)

→ width None (1)

→ height None (1)

→ style None (1)

→ no_color None (1)

→ tab_size 8 (1)

→ record False (1)

→ markup True (1)

→ emoji True (1)

→ emoji_variant None (1)

→ highlight True (1)

→ log_time True (1)

→ log_path True (1)

→ log_time_format '[%X]' (1)

→ highlighter ReprHighlighter (1)

→ legacy_windows None (1)

→ safe_box True (1)

→ get_datetime None (1)

→ get_time None (1)

→ _environ {'JUPYTER_LINES': '220'} (1)

59 run 14 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 44: 1 calls (0.0)

→ color_system 'auto' (1)

→ force_terminal None (1)

→ force_jupyter True (1)

→ force_interactive None (1)

→ soft_wrap False (1)

→ theme None (1)

→ stderr False (1)

→ file None (1)

→ quiet False (1)

→ width None (1)

→ height 40 (1)

→ style None (1)

→ no_color None (1)

→ tab_size 8 (1)

→ record False (1)

→ markup True (1)

→ emoji True (1)

→ emoji_variant None (1)

→ highlight True (1)

→ log_time True (1)

→ log_path True (1)

→ log_time_format '[%X]' (1)

→ highlighter ReprHighlighter (1)

→ legacy_windows None (1)

→ safe_box True (1)

→ get_datetime None (1)

→ get_time None (1)

→ _environ {'JUPYTER_LINES': '220'} (1)

56 run 17 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 45: 1 calls (0.0)

→ color_system None (1)

→ force_terminal None (1)

→ force_jupyter None (1)

→ force_interactive None (1)

→ soft_wrap False (1)

→ theme None (1)

→ stderr False (1)

→ file None (1)

→ quiet False (1)

→ width 20 (1)

→ height 5 (1)

→ style None (1)

→ no_color None (1)

→ tab_size 8 (1)

→ record False (1)

→ markup True (1)

→ emoji True (1)

→ emoji_variant None (1)

→ highlight True (1)

→ log_time True (1)

→ log_path True (1)

→ log_time_format '[%X]' (1)

→ highlighter ReprHighlighter (1)

→ legacy_windows False (1)

→ safe_box True (1)

→ get_datetime None (1)

→ get_time None (1)

→ _environ None (1)

50 run 23 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 46: 1 calls (0.0)

→ color_system 'truecolor' (1)

→ force_terminal True (1)

→ force_jupyter None (1)

→ force_interactive None (1)

→ soft_wrap False (1)

→ theme None (1)

→ stderr False (1)

→ file StringIO (1)

→ quiet False (1)

→ width 30 (1)

→ height None (1)

→ style None (1)

→ no_color None (1)

→ tab_size 8 (1)

→ record False (1)

→ markup True (1)

→ emoji True (1)

→ emoji_variant None (1)

→ highlight True (1)

→ log_time True (1)

→ log_path True (1)

→ log_time_format '[%X]' (1)

→ highlighter ReprHighlighter (1)

→ legacy_windows None (1)

→ safe_box True (1)

→ get_datetime None (1)

→ get_time None (1)

→ _environ None (1)

51 run 22 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False
            

Path 47: 1 calls (0.0)

→ color_system 'truecolor' (1)

→ force_terminal None (1)

→ force_jupyter None (1)

→ force_interactive None (1)

→ soft_wrap False (1)

→ theme None (1)

→ stderr False (1)

→ file None (1)

→ quiet False (1)

→ width 100 (1)

→ height None (1)

→ style None (1)

→ no_color None (1)

→ tab_size 8 (1)

→ record False (1)

→ markup True (1)

→ emoji True (1)

→ emoji_variant None (1)

→ highlight True (1)

→ log_time True (1)

→ log_path True (1)

→ log_time_format '[%X]' (1)

→ highlighter ReprHighlighter (1)

→ legacy_windows None (1)

→ safe_box True (1)

→ get_datetime None (1)

→ get_time None (1)

→ _environ None (1)

52 run 21 not run

1def __init__(
2        self,
3        *,
4        color_system: Optional[
5            Literal["auto", "standard", "256", "truecolor", "windows"]
6        ] = "auto",
7        force_terminal: Optional[bool] = None,
8        force_jupyter: Optional[bool] = None,
9        force_interactive: Optional[bool] = None,
10        soft_wrap: bool = False,
11        theme: Optional[Theme] = None,
12        stderr: bool = False,
13        file: Optional[IO[str]] = None,
14        quiet: bool = False,
15        width: Optional[int] = None,
16        height: Optional[int] = None,
17        style: Optional[StyleType] = None,
18        no_color: Optional[bool] = None,
19        tab_size: int = 8,
20        record: bool = False,
21        markup: bool = True,
22        emoji: bool = True,
23        emoji_variant: Optional[EmojiVariant] = None,
24        highlight: bool = True,
25        log_time: bool = True,
26        log_path: bool = True,
27        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
28        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
29        legacy_windows: Optional[bool] = None,
30        safe_box: bool = True,
31        get_datetime: Optional[Callable[[], datetime]] = None,
32        get_time: Optional[Callable[[], float]] = None,
33        _environ: Optional[Mapping[str, str]] = None,
34    ):
35        # Copy of os.environ allows us to replace it for testing
36        if _environ is not None:
37            self._environ = _environ
38
39        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
40        if self.is_jupyter:
41            if width is None:
42                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
43                if jupyter_columns is not None and jupyter_columns.isdigit():
44                    width = int(jupyter_columns)
45                else:
46                    width = JUPYTER_DEFAULT_COLUMNS
47            if height is None:
48                jupyter_lines = self._environ.get("JUPYTER_LINES")
49                if jupyter_lines is not None and jupyter_lines.isdigit():
50                    height = int(jupyter_lines)
51                else:
52                    height = JUPYTER_DEFAULT_LINES
53
54        self.tab_size = tab_size
55        self.record = record
56        self._markup = markup
57        self._emoji = emoji
58        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
59        self._highlight = highlight
60        self.legacy_windows: bool = (
61            (detect_legacy_windows() and not self.is_jupyter)
62            if legacy_windows is None
63            else legacy_windows
64        )
65
66        if width is None:
67            columns = self._environ.get("COLUMNS")
68            if columns is not None and columns.isdigit():
69                width = int(columns) - self.legacy_windows
70        if height is None:
71            lines = self._environ.get("LINES")
72            if lines is not None and lines.isdigit():
73                height = int(lines)
74
75        self.soft_wrap = soft_wrap
76        self._width = width
77        self._height = height
78
79        self._color_system: Optional[ColorSystem]
80
81        self._force_terminal = None
82        if force_terminal is not None:
83            self._force_terminal = force_terminal
84        else:
85            # If FORCE_COLOR env var has any value at all, we force terminal.
86            force_color = self._environ.get("FORCE_COLOR")
87            if force_color is not None:
88                self._force_terminal = True
89
90        self._file = file
91        self.quiet = quiet
92        self.stderr = stderr
93
94        if color_system is None:
95            self._color_system = None
96        elif color_system == "auto":
97            self._color_system = self._detect_color_system()
98        else:
99            self._color_system = COLOR_SYSTEMS[color_system]
100
101        self._lock = threading.RLock()
102        self._log_render = LogRender(
103            show_time=log_time,
104            show_path=log_path,
105            time_format=log_time_format,
106        )
107        self.highlighter: HighlighterType = highlighter or _null_highlighter
108        self.safe_box = safe_box
109        self.get_datetime = get_datetime or datetime.now
110        self.get_time = get_time or monotonic
111        self.style = style
112        self.no_color = (
113            no_color if no_color is not None else "NO_COLOR" in self._environ
114        )
115        self.is_interactive = (
116            (self.is_terminal and not self.is_dumb_terminal)
117            if force_interactive is None
118            else force_interactive
119        )
120
121        self._record_buffer_lock = threading.RLock()
122        self._thread_locals = ConsoleThreadLocals(
123            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
124        )
125        self._record_buffer: List[Segment] = []
126        self._render_hooks: List[RenderHook] = []
127        self._live: Optional["Live"] = None
128        self._is_alt_screen = False