Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/rich/console.py: 47%

614 log_time_format (Union[str, TimeFormatterCallable], optional): If ``log_time`` is enabled, either string for strftime or callable that formats the time. Defaults to "[%X] ".

615 highlighter (HighlighterType, optional): Default highlighter.

616 legacy_windows (bool, optional): Enable legacy Windows mode, or ``None`` to auto detect. Defaults to ``None``.

617 safe_box (bool, optional): Restrict box options that don't render on legacy Windows.

618 get_datetime (Callable[[], datetime], optional): Callable that gets the current time as a datetime.datetime object (used by Console.log),

619 or None for datetime.now.

620 get_time (Callable[[], time], optional): Callable that gets the current time in seconds, default uses time.monotonic.

621 """

622

623 _environ: Mapping[str, str] = os.environ

624

625 def __init__(

626 self,

627 *,

628 color_system: Optional[

629 Literal["auto", "standard", "256", "truecolor", "windows"]

630 ] = "auto",

631 force_terminal: Optional[bool] = None,

632 force_jupyter: Optional[bool] = None,

633 force_interactive: Optional[bool] = None,

634 soft_wrap: bool = False,

635 theme: Optional[Theme] = None,

636 stderr: bool = False,

637 file: Optional[IO[str]] = None,

638 quiet: bool = False,

639 width: Optional[int] = None,

640 height: Optional[int] = None,

641 style: Optional[StyleType] = None,

642 no_color: Optional[bool] = None,

643 tab_size: int = 8,

644 record: bool = False,

645 markup: bool = True,

646 emoji: bool = True,

647 emoji_variant: Optional[EmojiVariant] = None,

648 highlight: bool = True,

649 log_time: bool = True,

650 log_path: bool = True,

651 log_time_format: Union[str, FormatTimeCallable] = "[%X]",

652 highlighter: Optional["HighlighterType"] = ReprHighlighter(),

653 legacy_windows: Optional[bool] = None,

654 safe_box: bool = True,

655 get_datetime: Optional[Callable[[], datetime]] = None,

656 get_time: Optional[Callable[[], float]] = None,

657 _environ: Optional[Mapping[str, str]] = None,

658 ):

659 # Copy of os.environ allows us to replace it for testing

660 if _environ is not None:

661 self._environ = _environ

662

663 self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter

664 if self.is_jupyter:

665 if width is None:

666 jupyter_columns = self._environ.get("JUPYTER_COLUMNS")

667 if jupyter_columns is not None and jupyter_columns.isdigit():

668 width = int(jupyter_columns)

669 else:

670 width = JUPYTER_DEFAULT_COLUMNS

671 if height is None:

672 jupyter_lines = self._environ.get("JUPYTER_LINES")

673 if jupyter_lines is not None and jupyter_lines.isdigit():

674 height = int(jupyter_lines)

675 else:

676 height = JUPYTER_DEFAULT_LINES

677

678 self.tab_size = tab_size

679 self.record = record

680 self._markup = markup

681 self._emoji = emoji

682 self._emoji_variant: Optional[EmojiVariant] = emoji_variant

683 self._highlight = highlight

684 self.legacy_windows: bool = (

685 (detect_legacy_windows() and not self.is_jupyter)

686 if legacy_windows is None

687 else legacy_windows

688 )

689

690 if width is None:

691 columns = self._environ.get("COLUMNS")

692 if columns is not None and columns.isdigit():

693 width = int(columns) - self.legacy_windows

694 if height is None:

695 lines = self._environ.get("LINES")

696 if lines is not None and lines.isdigit():

697 height = int(lines)

698

699 self.soft_wrap = soft_wrap

700 self._width = width

701 self._height = height

702

703 self._color_system: Optional[ColorSystem]

704

705 self._force_terminal = None

706 if force_terminal is not None:

707 self._force_terminal = force_terminal

708

709 self._file = file

710 self.quiet = quiet

711 self.stderr = stderr

712

713 if color_system is None:

714 self._color_system = None

715 elif color_system == "auto":

716 self._color_system = self._detect_color_system()

717 else:

718 self._color_system = COLOR_SYSTEMS[color_system]

719

720 self._lock = threading.RLock()

721 self._log_render = LogRender(

722 show_time=log_time,

723 show_path=log_path,

724 time_format=log_time_format,

725 )

726 self.highlighter: HighlighterType = highlighter or _null_highlighter

727 self.safe_box = safe_box

728 self.get_datetime = get_datetime or datetime.now

729 self.get_time = get_time or monotonic

730 self.style = style

731 self.no_color = (

732 no_color

733 if no_color is not None

734 else self._environ.get("NO_COLOR", "") != ""

735 )

736 if force_interactive is None:

737 tty_interactive = self._environ.get("TTY_INTERACTIVE", None)

738 if tty_interactive is not None:

739 if tty_interactive == "0":

740 force_interactive = False

741 elif tty_interactive == "1":

742 force_interactive = True

743

744 self.is_interactive = (

745 (self.is_terminal and not self.is_dumb_terminal)

746 if force_interactive is None

747 else force_interactive

748 )

749

750 self._record_buffer_lock = threading.RLock()

751 self._thread_locals = ConsoleThreadLocals(

752 theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)

753 )

754 self._record_buffer: List[Segment] = []

755 self._render_hooks: List[RenderHook] = []

756 self._live_stack: List[Live] = []

757 self._is_alt_screen = False

758

759 def __repr__(self) -> str:

760 return f"<console width={self.width} {self._color_system!s}>"

761

762 @property

763 def file(self) -> IO[str]:

764 """Get the file object to write to."""

765 file = self._file or (sys.stderr if self.stderr else sys.stdout)

766 file = getattr(file, "rich_proxied_file", file)

767 if file is None:

768 file = NULL_FILE

769 return file

770

771 @file.setter

772 def file(self, new_file: IO[str]) -> None:

773 """Set a new file object."""

774 self._file = new_file

775

776 @property

777 def _buffer(self) -> List[Segment]:

778 """Get a thread local buffer."""

779 return self._thread_locals.buffer

780

781 @property

782 def _buffer_index(self) -> int:

783 """Get a thread local buffer."""

784 return self._thread_locals.buffer_index

785

786 @_buffer_index.setter

787 def _buffer_index(self, value: int) -> None:

788 self._thread_locals.buffer_index = value

789

790 @property

791 def _theme_stack(self) -> ThemeStack:

792 """Get the thread local theme stack."""

793 return self._thread_locals.theme_stack

794

795 def _detect_color_system(self) -> Optional[ColorSystem]:

796 """Detect color system from env vars."""

797 if self.is_jupyter:

798 return ColorSystem.TRUECOLOR

799 if not self.is_terminal or self.is_dumb_terminal:

800 return None

801 if WINDOWS: # pragma: no cover

802 if self.legacy_windows: # pragma: no cover

803 return ColorSystem.WINDOWS

804 windows_console_features = get_windows_console_features()

805 return (

806 ColorSystem.TRUECOLOR

807 if windows_console_features.truecolor

808 else ColorSystem.EIGHT_BIT

809 )

810 else:

811 color_term = self._environ.get("COLORTERM", "").strip().lower()

812 if color_term in ("truecolor", "24bit"):

813 return ColorSystem.TRUECOLOR

814 term = self._environ.get("TERM", "").strip().lower()

815 _term_name, _hyphen, colors = term.rpartition("-")

816 color_system = _TERM_COLORS.get(colors, ColorSystem.STANDARD)

817 return color_system

818

819 def _enter_buffer(self) -> None:

820 """Enter in to a buffer context, and buffer all output."""

821 self._buffer_index += 1

822

823 def _exit_buffer(self) -> None:

824 """Leave buffer context, and render content if required."""

825 self._buffer_index -= 1

826 self._check_buffer()

827

828 def set_live(self, live: "Live") -> bool:

829 """Set Live instance. Used by Live context manager (no need to call directly).

830

831 Args:

832 live (Live): Live instance using this Console.

833

834 Returns:

835 Boolean that indicates if the live is the topmost of the stack.

836

837 Raises:

838 errors.LiveError: If this Console has a Live context currently active.

839 """

840 with self._lock:

841 self._live_stack.append(live)

842 return len(self._live_stack) == 1

843

844 def clear_live(self) -> None:

845 """Clear the Live instance. Used by the Live context manager (no need to call directly)."""

846 with self._lock:

847 self._live_stack.pop()

848

849 def push_render_hook(self, hook: RenderHook) -> None:

850 """Add a new render hook to the stack.

851

852 Args:

853 hook (RenderHook): Render hook instance.

854 """

855 with self._lock:

856 self._render_hooks.append(hook)

857

858 def pop_render_hook(self) -> None:

859 """Pop the last renderhook from the stack."""

860 with self._lock:

861 self._render_hooks.pop()

862

863 def __enter__(self) -> "Console":

864 """Own context manager to enter buffer context."""

865 self._enter_buffer()

866 return self

867

868 def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:

869 """Exit buffer context."""

870 self._exit_buffer()

871

872 def begin_capture(self) -> None:

873 """Begin capturing console output. Call :meth:`end_capture` to exit capture mode and return output."""

874 self._enter_buffer()

875

876 def end_capture(self) -> str:

877 """End capture mode and return captured string.

878

879 Returns:

880 str: Console output.

881 """

882 render_result = self._render_buffer(self._buffer)

883 del self._buffer[:]

884 self._exit_buffer()

885 return render_result

886

887 def push_theme(self, theme: Theme, *, inherit: bool = True) -> None:

888 """Push a new theme on to the top of the stack, replacing the styles from the previous theme.

889 Generally speaking, you should call :meth:`~rich.console.Console.use_theme` to get a context manager, rather

890 than calling this method directly.

891

892 Args:

893 theme (Theme): A theme instance.

894 inherit (bool, optional): Inherit existing styles. Defaults to True.

895 """

896 self._theme_stack.push_theme(theme, inherit=inherit)

897

898 def pop_theme(self) -> None:

899 """Remove theme from top of stack, restoring previous theme."""

900 self._theme_stack.pop_theme()

901

902 def use_theme(self, theme: Theme, *, inherit: bool = True) -> ThemeContext:

903 """Use a different theme for the duration of the context manager.

904

905 Args:

906 theme (Theme): Theme instance to user.

907 inherit (bool, optional): Inherit existing console styles. Defaults to True.

908

909 Returns:

910 ThemeContext: [description]

911 """

912 return ThemeContext(self, theme, inherit)

913

914 @property

915 def color_system(self) -> Optional[str]:

916 """Get color system string.

917

918 Returns:

919 Optional[str]: "standard", "256" or "truecolor".

920 """

921

922 if self._color_system is not None:

923 return _COLOR_SYSTEMS_NAMES[self._color_system]

924 else:

925 return None

926

927 @property

928 def encoding(self) -> str:

929 """Get the encoding of the console file, e.g. ``"utf-8"``.

930

931 Returns:

932 str: A standard encoding string.

933 """

934 return (getattr(self.file, "encoding", "utf-8") or "utf-8").lower()

935

936 @property

937 def is_terminal(self) -> bool:

938 """Check if the console is writing to a terminal.

939

940 Returns:

941 bool: True if the console writing to a device capable of

942 understanding escape sequences, otherwise False.

943 """

944 # If dev has explicitly set this value, return it

945 if self._force_terminal is not None:

946 return self._force_terminal

947

948 # Fudge for Idle

949 if hasattr(sys.stdin, "__module__") and sys.stdin.__module__.startswith(

950 "idlelib"

951 ):

952 # Return False for Idle which claims to be a tty but can't handle ansi codes

953 return False

954

955 if self.is_jupyter:

956 # return False for Jupyter, which may have FORCE_COLOR set

957 return False

958

959 environ = self._environ

960

961 tty_compatible = environ.get("TTY_COMPATIBLE", "")

962 # 0 indicates device is not tty compatible

963 if tty_compatible == "0":

964 return False

965 # 1 indicates device is tty compatible

966 if tty_compatible == "1":

967 return True

968

969 # https://force-color.org/

970 force_color = environ.get("FORCE_COLOR")

971 if force_color is not None:

972 return force_color != ""

973

974 # Any other value defaults to auto detect

975 isatty: Optional[Callable[[], bool]] = getattr(self.file, "isatty", None)

976 try:

977 return False if isatty is None else isatty()

978 except ValueError:

979 # in some situation (at the end of a pytest run for example) isatty() can raise

980 # ValueError: I/O operation on closed file

981 # return False because we aren't in a terminal anymore

982 return False

983

984 @property

985 def is_dumb_terminal(self) -> bool:

986 """Detect dumb terminal.

987

988 Returns:

989 bool: True if writing to a dumb terminal, otherwise False.

990

991 """

992 _term = self._environ.get("TERM", "")

993 is_dumb = _term.lower() in ("dumb", "unknown")

994 return self.is_terminal and is_dumb

995

996 @property

997 def options(self) -> ConsoleOptions:

998 """Get default console options."""

999 size = self.size

1000 return ConsoleOptions(

1001 max_height=size.height,

1002 size=size,

1003 legacy_windows=self.legacy_windows,

1004 min_width=1,

1005 max_width=size.width,

1006 encoding=self.encoding,

1007 is_terminal=self.is_terminal,

1008 )

1009

1010 @property

1011 def size(self) -> ConsoleDimensions:

1012 """Get the size of the console.

1013

1014 Returns:

1015 ConsoleDimensions: A named tuple containing the dimensions.

1016 """

1017

1018 if self._width is not None and self._height is not None:

1019 return ConsoleDimensions(self._width - self.legacy_windows, self._height)

1020

1021 if self.is_dumb_terminal:

1022 return ConsoleDimensions(80, 25)

1023

1024 width: Optional[int] = None

1025 height: Optional[int] = None

1026

1027 streams = _STD_STREAMS_OUTPUT if WINDOWS else _STD_STREAMS

1028 for file_descriptor in streams:

1029 try:

1030 width, height = os.get_terminal_size(file_descriptor)

1031 except (AttributeError, ValueError, OSError): # Probably not a terminal

1032 pass

1033 else:

1034 break

1035

1036 columns = self._environ.get("COLUMNS")

1037 if columns is not None and columns.isdigit():

1038 width = int(columns)

1039 lines = self._environ.get("LINES")

1040 if lines is not None and lines.isdigit():

1041 height = int(lines)

1042

1043 # get_terminal_size can report 0, 0 if run from pseudo-terminal

1044 width = width or 80

1045 height = height or 25

1046 return ConsoleDimensions(

1047 width - self.legacy_windows if self._width is None else self._width,

1048 height if self._height is None else self._height,

1049 )

1050

1051 @size.setter

1052 def size(self, new_size: Tuple[int, int]) -> None:

1053 """Set a new size for the terminal.

1054

1055 Args:

1056 new_size (Tuple[int, int]): New width and height.

1057 """

1058 width, height = new_size

1059 self._width = width

1060 self._height = height

1061

1062 @property

1063 def width(self) -> int:

1064 """Get the width of the console.

1065

1066 Returns:

1067 int: The width (in characters) of the console.

1068 """

1069 return self.size.width

1070

1071 @width.setter

1072 def width(self, width: int) -> None:

1073 """Set width.

1074

1075 Args:

1076 width (int): New width.

1077 """

1078 self._width = width

1079

1080 @property

1081 def height(self) -> int:

1082 """Get the height of the console.

1083

1084 Returns:

1085 int: The height (in lines) of the console.

1086 """

1087 return self.size.height

1088

1089 @height.setter

1090 def height(self, height: int) -> None:

1091 """Set height.

1092

1093 Args:

1094 height (int): new height.

1095 """

1096 self._height = height

1097

1098 def bell(self) -> None:

1099 """Play a 'bell' sound (if supported by the terminal)."""

1100 self.control(Control.bell())

1101

1102 def capture(self) -> Capture:

1103 """A context manager to *capture* the result of print() or log() in a string,

1104 rather than writing it to the console.

1105

1106 Example:

1107 >>> from rich.console import Console

1108 >>> console = Console()

1109 >>> with console.capture() as capture:

1110 ... console.print("[bold magenta]Hello World[/]")

1111 >>> print(capture.get())

1112

1113 Returns:

1114 Capture: Context manager with disables writing to the terminal.

1115 """

1116 capture = Capture(self)

1117 return capture

1118

1119 def pager(

1120 self, pager: Optional[Pager] = None, styles: bool = False, links: bool = False

1121 ) -> PagerContext:

1122 """A context manager to display anything printed within a "pager". The pager application

1123 is defined by the system and will typically support at least pressing a key to scroll.

1124

1125 Args:

1126 pager (Pager, optional): A pager object, or None to use :class:`~rich.pager.SystemPager`. Defaults to None.

1127 styles (bool, optional): Show styles in pager. Defaults to False.

1128 links (bool, optional): Show links in pager. Defaults to False.

1129

1130 Example:

1131 >>> from rich.console import Console

1132 >>> from rich.__main__ import make_test_card

1133 >>> console = Console()

1134 >>> with console.pager():

1135 console.print(make_test_card())

1136

1137 Returns:

1138 PagerContext: A context manager.

1139 """

1140 return PagerContext(self, pager=pager, styles=styles, links=links)

1141

1142 def line(self, count: int = 1) -> None:

1143 """Write new line(s).

1144

1145 Args:

1146 count (int, optional): Number of new lines. Defaults to 1.

1147 """

1148

1149 assert count >= 0, "count must be >= 0"

1150 self.print(NewLine(count))

1151

1152 def clear(self, home: bool = True) -> None:

1153 """Clear the screen.

1154

1155 Args:

1156 home (bool, optional): Also move the cursor to 'home' position. Defaults to True.

1157 """

1158 if home:

1159 self.control(Control.clear(), Control.home())

1160 else:

1161 self.control(Control.clear())

1162

1163 def status(

1164 self,

1165 status: RenderableType,

1166 *,

1167 spinner: str = "dots",

1168 spinner_style: StyleType = "status.spinner",

1169 speed: float = 1.0,

1170 refresh_per_second: float = 12.5,

1171 ) -> "Status":

1172 """Display a status and spinner.

1173

1174 Args:

1175 status (RenderableType): A status renderable (str or Text typically).

1176 spinner (str, optional): Name of spinner animation (see python -m rich.spinner). Defaults to "dots".

1177 spinner_style (StyleType, optional): Style of spinner. Defaults to "status.spinner".

1178 speed (float, optional): Speed factor for spinner animation. Defaults to 1.0.

1179 refresh_per_second (float, optional): Number of refreshes per second. Defaults to 12.5.

1180

1181 Returns:

1182 Status: A Status object that may be used as a context manager.

1183 """

1184 from .status import Status

1185

1186 status_renderable = Status(

1187 status,

1188 console=self,

1189 spinner=spinner,

1190 spinner_style=spinner_style,

1191 speed=speed,

1192 refresh_per_second=refresh_per_second,

1193 )

1194 return status_renderable

1195

1196 def show_cursor(self, show: bool = True) -> bool:

1197 """Show or hide the cursor.

1198

1199 Args:

1200 show (bool, optional): Set visibility of the cursor.

1201 """

1202 if self.is_terminal:

1203 self.control(Control.show_cursor(show))

1204 return True

1205 return False

1206

1207 def set_alt_screen(self, enable: bool = True) -> bool:

1208 """Enables alternative screen mode.

1209

1210 Note, if you enable this mode, you should ensure that is disabled before

1211 the application exits. See :meth:`~rich.Console.screen` for a context manager

1212 that handles this for you.

1213

1214 Args:

1215 enable (bool, optional): Enable (True) or disable (False) alternate screen. Defaults to True.

1216

1217 Returns:

1218 bool: True if the control codes were written.

1219

1220 """

1221 changed = False

1222 if self.is_terminal and not self.legacy_windows:

1223 self.control(Control.alt_screen(enable))

1224 changed = True

1225 self._is_alt_screen = enable

1226 return changed

1227

1228 @property

1229 def is_alt_screen(self) -> bool:

1230 """Check if the alt screen was enabled.

1231

1232 Returns:

1233 bool: True if the alt screen was enabled, otherwise False.

1234 """

1235 return self._is_alt_screen

1236

1237 def set_window_title(self, title: str) -> bool:

1238 """Set the title of the console terminal window.

1239

1240 Warning: There is no means within Rich of "resetting" the window title to its

1241 previous value, meaning the title you set will persist even after your application

1242 exits.

1243

1244 ``fish`` shell resets the window title before and after each command by default,

1245 negating this issue. Windows Terminal and command prompt will also reset the title for you.

1246 Most other shells and terminals, however, do not do this.

1247

1248 Some terminals may require configuration changes before you can set the title.

1249 Some terminals may not support setting the title at all.

1250

1251 Other software (including the terminal itself, the shell, custom prompts, plugins, etc.)

1252 may also set the terminal window title. This could result in whatever value you write

1253 using this method being overwritten.

1254

1255 Args:

1256 title (str): The new title of the terminal window.

1257

1258 Returns:

1259 bool: True if the control code to change the terminal title was

1260 written, otherwise False. Note that a return value of True

1261 does not guarantee that the window title has actually changed,

1262 since the feature may be unsupported/disabled in some terminals.

1263 """

1264 if self.is_terminal:

1265 self.control(Control.title(title))

1266 return True

1267 return False

1268

1269 def screen(

1270 self, hide_cursor: bool = True, style: Optional[StyleType] = None

1271 ) -> "ScreenContext":

1272 """Context manager to enable and disable 'alternative screen' mode.

1273

1274 Args:

1275 hide_cursor (bool, optional): Also hide the cursor. Defaults to False.

1276 style (Style, optional): Optional style for screen. Defaults to None.

1277

1278 Returns:

1279 ~ScreenContext: Context which enables alternate screen on enter, and disables it on exit.

1280 """

1281 return ScreenContext(self, hide_cursor=hide_cursor, style=style or "")

1282

1283 def measure(

1284 self, renderable: RenderableType, *, options: Optional[ConsoleOptions] = None

1285 ) -> Measurement:

1286 """Measure a renderable. Returns a :class:`~rich.measure.Measurement` object which contains

1287 information regarding the number of characters required to print the renderable.

1288

1289 Args:

1290 renderable (RenderableType): Any renderable or string.

1291 options (Optional[ConsoleOptions], optional): Options to use when measuring, or None

1292 to use default options. Defaults to None.

1293

1294 Returns:

1295 Measurement: A measurement of the renderable.

1296 """

1297 measurement = Measurement.get(self, options or self.options, renderable)

1298 return measurement

1299

1300 def render(

1301 self, renderable: RenderableType, options: Optional[ConsoleOptions] = None

1302 ) -> Iterable[Segment]:

1303 """Render an object in to an iterable of `Segment` instances.

1304

1305 This method contains the logic for rendering objects with the console protocol.

1306 You are unlikely to need to use it directly, unless you are extending the library.

1307

1308 Args:

1309 renderable (RenderableType): An object supporting the console protocol, or

1310 an object that may be converted to a string.

1311 options (ConsoleOptions, optional): An options object, or None to use self.options. Defaults to None.

1312

1313 Returns:

1314 Iterable[Segment]: An iterable of segments that may be rendered.

1315 """

1316

1317 _options = options or self.options

1318 if _options.max_width < 1:

1319 # No space to render anything. This prevents potential recursion errors.

1320 return

1321 render_iterable: RenderResult

1322

1323 renderable = rich_cast(renderable)

1324 if hasattr(renderable, "__rich_console__") and not isclass(renderable):

1325 render_iterable = renderable.__rich_console__(self, _options)

1326 elif isinstance(renderable, str):

1327 text_renderable = self.render_str(

1328 renderable, highlight=_options.highlight, markup=_options.markup

1329 )

1330 render_iterable = text_renderable.__rich_console__(self, _options)

1331 else:

1332 raise errors.NotRenderableError(

1333 f"Unable to render {renderable!r}; "

1334 "A str, Segment or object with __rich_console__ method is required"

1335 )

1336

1337 try:

1338 iter_render = iter(render_iterable)

1339 except TypeError:

1340 raise errors.NotRenderableError(

1341 f"object {render_iterable!r} is not renderable"

1342 )

1343 _Segment = Segment

1344 _options = _options.reset_height()

1345 for render_output in iter_render:

1346 if isinstance(render_output, _Segment):

1347 yield render_output

1348 else:

1349 yield from self.render(render_output, _options)

1350

1351 def render_lines(

1352 self,

1353 renderable: RenderableType,

1354 options: Optional[ConsoleOptions] = None,

1355 *,

1356 style: Optional[Style] = None,

1357 pad: bool = True,

1358 new_lines: bool = False,

1359 ) -> List[List[Segment]]:

1360 """Render objects in to a list of lines.

1361

1362 The output of render_lines is useful when further formatting of rendered console text

1363 is required, such as the Panel class which draws a border around any renderable object.

1364

1365 Args:

1366 renderable (RenderableType): Any object renderable in the console.

1367 options (Optional[ConsoleOptions], optional): Console options, or None to use self.options. Default to ``None``.

1368 style (Style, optional): Optional style to apply to renderables. Defaults to ``None``.

1369 pad (bool, optional): Pad lines shorter than render width. Defaults to ``True``.

1370 new_lines (bool, optional): Include "\n" characters at end of lines.

1371

1372 Returns:

1373 List[List[Segment]]: A list of lines, where a line is a list of Segment objects.

1374 """

1375 with self._lock:

1376 render_options = options or self.options

1377 _rendered = self.render(renderable, render_options)

1378 if style:

1379 _rendered = Segment.apply_style(_rendered, style)

1380

1381 render_height = render_options.height

1382 if render_height is not None:

1383 render_height = max(0, render_height)

1384

1385 lines = list(

1386 islice(

1387 Segment.split_and_crop_lines(

1388 _rendered,

1389 render_options.max_width,

1390 include_new_lines=new_lines,

1391 pad=pad,

1392 style=style,

1393 ),

1394 None,

1395 render_height,

1396 )

1397 )

1398 if render_options.height is not None:

1399 extra_lines = render_options.height - len(lines)

1400 if extra_lines > 0:

1401 pad_line = [

1402 (

1403 [

1404 Segment(" " * render_options.max_width, style),

1405 Segment("\n"),

1406 ]

1407 if new_lines

1408 else [Segment(" " * render_options.max_width, style)]

1409 )

1410 ]

1411 lines.extend(pad_line * extra_lines)

1412

1413 return lines

1414

1415 def render_str(

1416 self,

1417 text: str,

1418 *,

1419 style: Union[str, Style] = "",

1420 justify: Optional[JustifyMethod] = None,

1421 overflow: Optional[OverflowMethod] = None,

1422 emoji: Optional[bool] = None,

1423 markup: Optional[bool] = None,

1424 highlight: Optional[bool] = None,

1425 highlighter: Optional[HighlighterType] = None,

1426 ) -> "Text":

1427 """Convert a string to a Text instance. This is called automatically if

1428 you print or log a string.

1429

1430 Args:

1431 text (str): Text to render.

1432 style (Union[str, Style], optional): Style to apply to rendered text.

1433 justify (str, optional): Justify method: "default", "left", "center", "full", or "right". Defaults to ``None``.

1434 overflow (str, optional): Overflow method: "crop", "fold", or "ellipsis". Defaults to ``None``.

1435 emoji (Optional[bool], optional): Enable emoji, or ``None`` to use Console default.

1436 markup (Optional[bool], optional): Enable markup, or ``None`` to use Console default.

1437 highlight (Optional[bool], optional): Enable highlighting, or ``None`` to use Console default.

1438 highlighter (HighlighterType, optional): Optional highlighter to apply.

1439 Returns:

1440 ConsoleRenderable: Renderable object.

1441

1442 """

1443 emoji_enabled = emoji or (emoji is None and self._emoji)

1444 markup_enabled = markup or (markup is None and self._markup)

1445 highlight_enabled = highlight or (highlight is None and self._highlight)

1446

1447 if markup_enabled:

1448 rich_text = render_markup(

1449 text,

1450 style=style,

1451 emoji=emoji_enabled,

1452 emoji_variant=self._emoji_variant,

1453 )

1454 rich_text.justify = justify

1455 rich_text.overflow = overflow

1456 else:

1457 rich_text = Text(

1458 (

1459 _emoji_replace(text, default_variant=self._emoji_variant)

1460 if emoji_enabled

1461 else text

1462 ),

1463 justify=justify,

1464 overflow=overflow,

1465 style=style,

1466 )

1467

1468 _highlighter = (highlighter or self.highlighter) if highlight_enabled else None

1469 if _highlighter is not None:

1470 highlight_text = _highlighter(str(rich_text))

1471 highlight_text.copy_styles(rich_text)

1472 return highlight_text

1473

1474 return rich_text

1475

1476 def get_style(

1477 self, name: Union[str, Style], *, default: Optional[Union[Style, str]] = None

1478 ) -> Style:

1479 """Get a Style instance by its theme name or parse a definition.

1480

1481 Args:

1482 name (str): The name of a style or a style definition.

1483

1484 Returns:

1485 Style: A Style object.

1486

1487 Raises:

1488 MissingStyle: If no style could be parsed from name.

1489

1490 """

1491 if isinstance(name, Style):

1492 return name

1493

1494 try:

1495 style = self._theme_stack.get(name)

1496 if style is None:

1497 style = Style.parse(name)

1498 return style.copy() if style.link else style

1499 except errors.StyleSyntaxError as error:

1500 if default is not None:

1501 return self.get_style(default)

1502 raise errors.MissingStyle(

1503 f"Failed to get style {name!r}; {error}"

1504 ) from None

1505

1506 def _collect_renderables(

1507 self,

1508 objects: Iterable[Any],

1509 sep: str,

1510 end: str,

1511 *,

1512 justify: Optional[JustifyMethod] = None,

1513 emoji: Optional[bool] = None,

1514 markup: Optional[bool] = None,

1515 highlight: Optional[bool] = None,

1516 ) -> List[ConsoleRenderable]:

1517 """Combine a number of renderables and text into one renderable.

1518

1519 Args:

1520 objects (Iterable[Any]): Anything that Rich can render.

1521 sep (str): String to write between print data.

1522 end (str): String to write at end of print data.

1523 justify (str, optional): One of "left", "right", "center", or "full". Defaults to ``None``.

1524 emoji (Optional[bool], optional): Enable emoji code, or ``None`` to use console default.

1525 markup (Optional[bool], optional): Enable markup, or ``None`` to use console default.

1526 highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default.

1527

1528 Returns:

1529 List[ConsoleRenderable]: A list of things to render.

1530 """

1531 renderables: List[ConsoleRenderable] = []

1532 _append = renderables.append

1533 text: List[Text] = []

1534 append_text = text.append

1535

1536 append = _append

1537 if justify in ("left", "center", "right"):

1538

1539 def align_append(renderable: RenderableType) -> None:

1540 _append(Align(renderable, cast(AlignMethod, justify)))

1541

1542 append = align_append

1543

1544 _highlighter: HighlighterType = _null_highlighter

1545 if highlight or (highlight is None and self._highlight):

1546 _highlighter = self.highlighter

1547

1548 def check_text() -> None:

1549 if text:

1550 sep_text = Text(sep, justify=justify, end=end)

1551 append(sep_text.join(text))

1552 text.clear()

1553

1554 for renderable in objects:

1555 renderable = rich_cast(renderable)

1556 if isinstance(renderable, str):

1557 append_text(

1558 self.render_str(

1559 renderable,

1560 emoji=emoji,

1561 markup=markup,

1562 highlight=highlight,

1563 highlighter=_highlighter,

1564 )

1565 )

1566 elif isinstance(renderable, Text):

1567 append_text(renderable)

1568 elif isinstance(renderable, ConsoleRenderable):

1569 check_text()

1570 append(renderable)

1571 elif is_expandable(renderable):

1572 check_text()

1573 append(Pretty(renderable, highlighter=_highlighter))

1574 else:

1575 append_text(_highlighter(str(renderable)))

1576

1577 check_text()

1578

1579 if self.style is not None:

1580 style = self.get_style(self.style)

1581 renderables = [Styled(renderable, style) for renderable in renderables]

1582

1583 return renderables

1584

1585 def rule(

1586 self,

1587 title: TextType = "",

1588 *,

1589 characters: str = "─",

1590 style: Union[str, Style] = "rule.line",

1591 align: AlignMethod = "center",

1592 ) -> None:

1593 """Draw a line with optional centered title.

1594

1595 Args:

1596 title (str, optional): Text to render over the rule. Defaults to "".

1597 characters (str, optional): Character(s) to form the line. Defaults to "─".

1598 style (str, optional): Style of line. Defaults to "rule.line".

1599 align (str, optional): How to align the title, one of "left", "center", or "right". Defaults to "center".

1600 """

1601 from .rule import Rule

1602

1603 rule = Rule(title=title, characters=characters, style=style, align=align)

1604 self.print(rule)

1605

1606 def control(self, *control: Control) -> None:

1607 """Insert non-printing control codes.

1608

1609 Args:

1610 control_codes (str): Control codes, such as those that may move the cursor.

1611 """

1612 if not self.is_dumb_terminal:

1613 with self:

1614 self._buffer.extend(_control.segment for _control in control)

1615

1616 def out(

1617 self,

1618 *objects: Any,

1619 sep: str = " ",

1620 end: str = "\n",

1621 style: Optional[Union[str, Style]] = None,

1622 highlight: Optional[bool] = None,

1623 ) -> None:

1624 """Output to the terminal. This is a low-level way of writing to the terminal which unlike

1625 :meth:`~rich.console.Console.print` won't pretty print, wrap text, or apply markup, but will

1626 optionally apply highlighting and a basic style.

1627

1628 Args:

1629 sep (str, optional): String to write between print data. Defaults to " ".

1630 end (str, optional): String to write at end of print data. Defaults to "\\\\n".

1631 style (Union[str, Style], optional): A style to apply to output. Defaults to None.

1632 highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use

1633 console default. Defaults to ``None``.

1634 """

1635 raw_output: str = sep.join(str(_object) for _object in objects)

1636 self.print(

1637 raw_output,

1638 style=style,

1639 highlight=highlight,

1640 emoji=False,

1641 markup=False,

1642 no_wrap=True,

1643 overflow="ignore",

1644 crop=False,

1645 end=end,

1646 )

1647

1648 def print(

1649 self,

1650 *objects: Any,

1651 sep: str = " ",

1652 end: str = "\n",

1653 style: Optional[Union[str, Style]] = None,

1654 justify: Optional[JustifyMethod] = None,

1655 overflow: Optional[OverflowMethod] = None,

1656 no_wrap: Optional[bool] = None,

1657 emoji: Optional[bool] = None,

1658 markup: Optional[bool] = None,

1659 highlight: Optional[bool] = None,

1660 width: Optional[int] = None,

1661 height: Optional[int] = None,

1662 crop: bool = True,

1663 soft_wrap: Optional[bool] = None,

1664 new_line_start: bool = False,

1665 ) -> None:

1666 """Print to the console.

1667

1668 Args:

1669 objects (positional args): Objects to log to the terminal.

1670 sep (str, optional): String to write between print data. Defaults to " ".

1671 end (str, optional): String to write at end of print data. Defaults to "\\\\n".

1672 style (Union[str, Style], optional): A style to apply to output. Defaults to None.

1673 justify (str, optional): Justify method: "default", "left", "right", "center", or "full". Defaults to ``None``.

1674 overflow (str, optional): Overflow method: "ignore", "crop", "fold", or "ellipsis". Defaults to None.

1675 no_wrap (Optional[bool], optional): Disable word wrapping. Defaults to None.

1676 emoji (Optional[bool], optional): Enable emoji code, or ``None`` to use console default. Defaults to ``None``.

1677 markup (Optional[bool], optional): Enable markup, or ``None`` to use console default. Defaults to ``None``.

1678 highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default. Defaults to ``None``.

1679 width (Optional[int], optional): Width of output, or ``None`` to auto-detect. Defaults to ``None``.

1680 crop (Optional[bool], optional): Crop output to width of terminal. Defaults to True.

1681 soft_wrap (bool, optional): Enable soft wrap mode which disables word wrapping and cropping of text or ``None`` for

1682 Console default. Defaults to ``None``.

1683 new_line_start (bool, False): Insert a new line at the start if the output contains more than one line. Defaults to ``False``.

1684 """

1685 if not objects:

1686 objects = (NewLine(),)

1687

1688 if soft_wrap is None:

1689 soft_wrap = self.soft_wrap

1690 if soft_wrap:

1691 if no_wrap is None:

1692 no_wrap = True

1693 if overflow is None:

1694 overflow = "ignore"

1695 crop = False

1696 render_hooks = self._render_hooks[:]

1697 with self:

1698 renderables = self._collect_renderables(

1699 objects,

1700 sep,

1701 end,

1702 justify=justify,

1703 emoji=emoji,

1704 markup=markup,

1705 highlight=highlight,

1706 )

1707 for hook in render_hooks:

1708 renderables = hook.process_renderables(renderables)

1709 render_options = self.options.update(

1710 justify=justify,

1711 overflow=overflow,

1712 width=min(width, self.width) if width is not None else NO_CHANGE,

1713 height=height,

1714 no_wrap=no_wrap,

1715 markup=markup,

1716 highlight=highlight,

1717 )

1718

1719 new_segments: List[Segment] = []

1720 extend = new_segments.extend

1721 render = self.render

1722 if style is None:

1723 for renderable in renderables:

1724 extend(render(renderable, render_options))

1725 else:

1726 for renderable in renderables:

1727 extend(

1728 Segment.apply_style(

1729 render(renderable, render_options), self.get_style(style)

1730 )

1731 )

1732 if new_line_start:

1733 if (

1734 len("".join(segment.text for segment in new_segments).splitlines())

1735 > 1

1736 ):

1737 new_segments.insert(0, Segment.line())

1738 if crop:

1739 buffer_extend = self._buffer.extend

1740 for line in Segment.split_and_crop_lines(

1741 new_segments, self.width, pad=False

1742 ):

1743 buffer_extend(line)

1744 else:

1745 self._buffer.extend(new_segments)

1746

1747 def print_json(

1748 self,

1749 json: Optional[str] = None,

1750 *,

1751 data: Any = None,

1752 indent: Union[None, int, str] = 2,

1753 highlight: bool = True,

1754 skip_keys: bool = False,

1755 ensure_ascii: bool = False,

1756 check_circular: bool = True,

1757 allow_nan: bool = True,

1758 default: Optional[Callable[[Any], Any]] = None,

1759 sort_keys: bool = False,

1760 ) -> None:

1761 """Pretty prints JSON. Output will be valid JSON.

1762

1763 Args:

1764 json (Optional[str]): A string containing JSON.

1765 data (Any): If json is not supplied, then encode this data.

1766 indent (Union[None, int, str], optional): Number of spaces to indent. Defaults to 2.

1767 highlight (bool, optional): Enable highlighting of output: Defaults to True.

1768 skip_keys (bool, optional): Skip keys not of a basic type. Defaults to False.

1769 ensure_ascii (bool, optional): Escape all non-ascii characters. Defaults to False.

1770 check_circular (bool, optional): Check for circular references. Defaults to True.

1771 allow_nan (bool, optional): Allow NaN and Infinity values. Defaults to True.

1772 default (Callable, optional): A callable that converts values that can not be encoded

1773 in to something that can be JSON encoded. Defaults to None.

1774 sort_keys (bool, optional): Sort dictionary keys. Defaults to False.

1775 """

1776 from rich.json import JSON

1777

1778 if json is None:

1779 json_renderable = JSON.from_data(

1780 data,

1781 indent=indent,

1782 highlight=highlight,

1783 skip_keys=skip_keys,

1784 ensure_ascii=ensure_ascii,

1785 check_circular=check_circular,

1786 allow_nan=allow_nan,

1787 default=default,

1788 sort_keys=sort_keys,

1789 )

1790 else:

1791 if not isinstance(json, str):

1792 raise TypeError(

1793 f"json must be str. Did you mean print_json(data={json!r}) ?"

1794 )

1795 json_renderable = JSON(

1796 json,

1797 indent=indent,

1798 highlight=highlight,

1799 skip_keys=skip_keys,

1800 ensure_ascii=ensure_ascii,

1801 check_circular=check_circular,

1802 allow_nan=allow_nan,

1803 default=default,

1804 sort_keys=sort_keys,

1805 )

1806 self.print(json_renderable, soft_wrap=True)

1807

1808 def update_screen(

1809 self,

1810 renderable: RenderableType,

1811 *,

1812 region: Optional[Region] = None,

1813 options: Optional[ConsoleOptions] = None,

1814 ) -> None:

1815 """Update the screen at a given offset.

1816

1817 Args:

1818 renderable (RenderableType): A Rich renderable.

1819 region (Region, optional): Region of screen to update, or None for entire screen. Defaults to None.

1820 x (int, optional): x offset. Defaults to 0.

1821 y (int, optional): y offset. Defaults to 0.

1822

1823 Raises:

1824 errors.NoAltScreen: If the Console isn't in alt screen mode.

1825

1826 """

1827 if not self.is_alt_screen:

1828 raise errors.NoAltScreen("Alt screen must be enabled to call update_screen")

1829 render_options = options or self.options

1830 if region is None:

1831 x = y = 0

1832 render_options = render_options.update_dimensions(

1833 render_options.max_width, render_options.height or self.height

1834 )

1835 else:

1836 x, y, width, height = region

1837 render_options = render_options.update_dimensions(width, height)

1838

1839 lines = self.render_lines(renderable, options=render_options)

1840 self.update_screen_lines(lines, x, y)

1841

1842 def update_screen_lines(

1843 self, lines: List[List[Segment]], x: int = 0, y: int = 0

1844 ) -> None:

1845 """Update lines of the screen at a given offset.

1846

1847 Args:

1848 lines (List[List[Segment]]): Rendered lines (as produced by :meth:`~rich.Console.render_lines`).

1849 x (int, optional): x offset (column no). Defaults to 0.

1850 y (int, optional): y offset (column no). Defaults to 0.

1851

1852 Raises:

1853 errors.NoAltScreen: If the Console isn't in alt screen mode.

1854 """

1855 if not self.is_alt_screen:

1856 raise errors.NoAltScreen("Alt screen must be enabled to call update_screen")

1857 screen_update = ScreenUpdate(lines, x, y)

1858 segments = self.render(screen_update)

1859 self._buffer.extend(segments)

1860 self._check_buffer()

1861

1862 def print_exception(

1863 self,

1864 *,

1865 width: Optional[int] = 100,

1866 extra_lines: int = 3,

1867 theme: Optional[str] = None,

1868 word_wrap: bool = False,

1869 show_locals: bool = False,

1870 suppress: Iterable[Union[str, ModuleType]] = (),

1871 max_frames: int = 100,

1872 ) -> None:

1873 """Prints a rich render of the last exception and traceback.

1874

1875 Args:

1876 width (Optional[int], optional): Number of characters used to render code. Defaults to 100.

1877 extra_lines (int, optional): Additional lines of code to render. Defaults to 3.

1878 theme (str, optional): Override pygments theme used in traceback

1879 word_wrap (bool, optional): Enable word wrapping of long lines. Defaults to False.

1880 show_locals (bool, optional): Enable display of local variables. Defaults to False.

1881 suppress (Iterable[Union[str, ModuleType]]): Optional sequence of modules or paths to exclude from traceback.

1882 max_frames (int): Maximum number of frames to show in a traceback, 0 for no maximum. Defaults to 100.

1883 """

1884 from .traceback import Traceback

1885

1886 traceback = Traceback(

1887 width=width,

1888 extra_lines=extra_lines,

1889 theme=theme,

1890 word_wrap=word_wrap,

1891 show_locals=show_locals,

1892 suppress=suppress,

1893 max_frames=max_frames,

1894 )

1895 self.print(traceback)

1896

1897 @staticmethod

1898 def _caller_frame_info(

1899 offset: int,

1900 currentframe: Callable[[], Optional[FrameType]] = inspect.currentframe,

1901 ) -> Tuple[str, int, Dict[str, Any]]:

1902 """Get caller frame information.

1903

1904 Args:

1905 offset (int): the caller offset within the current frame stack.

1906 currentframe (Callable[[], Optional[FrameType]], optional): the callable to use to

1907 retrieve the current frame. Defaults to ``inspect.currentframe``.

1908

1909 Returns:

1910 Tuple[str, int, Dict[str, Any]]: A tuple containing the filename, the line number and

1911 the dictionary of local variables associated with the caller frame.

1912

1913 Raises:

1914 RuntimeError: If the stack offset is invalid.

1915 """

1916 # Ignore the frame of this local helper

1917 offset += 1

1918

1919 frame = currentframe()

1920 if frame is not None:

1921 # Use the faster currentframe where implemented

1922 while offset and frame is not None:

1923 frame = frame.f_back

1924 offset -= 1

1925 assert frame is not None

1926 return frame.f_code.co_filename, frame.f_lineno, frame.f_locals

1927 else:

1928 # Fallback to the slower stack

1929 frame_info = inspect.stack()[offset]

1930 return frame_info.filename, frame_info.lineno, frame_info.frame.f_locals

1931

1932 def log(

1933 self,

1934 *objects: Any,

1935 sep: str = " ",

1936 end: str = "\n",

1937 style: Optional[Union[str, Style]] = None,

1938 justify: Optional[JustifyMethod] = None,

1939 emoji: Optional[bool] = None,

1940 markup: Optional[bool] = None,

1941 highlight: Optional[bool] = None,

1942 log_locals: bool = False,

1943 _stack_offset: int = 1,

1944 ) -> None:

1945 """Log rich content to the terminal.

1946

1947 Args:

1948 objects (positional args): Objects to log to the terminal.

1949 sep (str, optional): String to write between print data. Defaults to " ".

1950 end (str, optional): String to write at end of print data. Defaults to "\\\\n".

1951 style (Union[str, Style], optional): A style to apply to output. Defaults to None.

1952 justify (str, optional): One of "left", "right", "center", or "full". Defaults to ``None``.

1953 emoji (Optional[bool], optional): Enable emoji code, or ``None`` to use console default. Defaults to None.

1954 markup (Optional[bool], optional): Enable markup, or ``None`` to use console default. Defaults to None.

1955 highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default. Defaults to None.

1956 log_locals (bool, optional): Boolean to enable logging of locals where ``log()``

1957 was called. Defaults to False.

1958 _stack_offset (int, optional): Offset of caller from end of call stack. Defaults to 1.

1959 """

1960 if not objects:

1961 objects = (NewLine(),)

1962

1963 render_hooks = self._render_hooks[:]

1964

1965 with self:

1966 renderables = self._collect_renderables(

1967 objects,

1968 sep,

1969 end,

1970 justify=justify,

1971 emoji=emoji,

1972 markup=markup,

1973 highlight=highlight,

1974 )

1975 if style is not None:

1976 renderables = [Styled(renderable, style) for renderable in renderables]

1977

1978 filename, line_no, locals = self._caller_frame_info(_stack_offset)

1979 link_path = None if filename.startswith("<") else os.path.abspath(filename)

1980 path = filename.rpartition(os.sep)[-1]

1981 if log_locals:

1982 locals_map = {

1983 key: value

1984 for key, value in locals.items()

1985 if not key.startswith("__")

1986 }

1987 renderables.append(render_scope(locals_map, title="[i]locals"))

1988

1989 renderables = [

1990 self._log_render(

1991 self,

1992 renderables,

1993 log_time=self.get_datetime(),

1994 path=path,

1995 line_no=line_no,

1996 link_path=link_path,

1997 )

1998 ]

1999 for hook in render_hooks:

2000 renderables = hook.process_renderables(renderables)

2001 new_segments: List[Segment] = []

2002 extend = new_segments.extend

2003 render = self.render

2004 render_options = self.options

2005 for renderable in renderables:

2006 extend(render(renderable, render_options))

2007 buffer_extend = self._buffer.extend

2008 for line in Segment.split_and_crop_lines(

2009 new_segments, self.width, pad=False

2010 ):

2011 buffer_extend(line)

2012

2013 def on_broken_pipe(self) -> None:

2014 """This function is called when a `BrokenPipeError` is raised.

2015

2016 This can occur when piping Textual output in Linux and macOS.

2017 The default implementation is to exit the app, but you could implement

2018 this method in a subclass to change the behavior.

2019

2020 See https://docs.python.org/3/library/signal.html#note-on-sigpipe for details.

2021 """

2022 self.quiet = True

2023 devnull = os.open(os.devnull, os.O_WRONLY)

2024 os.dup2(devnull, sys.stdout.fileno())

2025 raise SystemExit(1)

2026

2027 def _check_buffer(self) -> None:

2028 """Check if the buffer may be rendered. Render it if it can (e.g. Console.quiet is False)

2029 Rendering is supported on Windows, Unix and Jupyter environments. For

2030 legacy Windows consoles, the win32 API is called directly.

2031 This method will also record what it renders if recording is enabled via Console.record.

2032 """

2033 if self.quiet:

2034 del self._buffer[:]

2035 return

2036

2037 try:

2038 self._write_buffer()

2039 except BrokenPipeError:

2040 self.on_broken_pipe()

2041

2042 def _write_buffer(self) -> None:

2043 """Write the buffer to the output file."""

2044

2045 with self._lock:

2046 if self.record and not self._buffer_index:

2047 with self._record_buffer_lock:

2048 self._record_buffer.extend(self._buffer[:])

2049

2050 if self._buffer_index == 0:

2051 if self.is_jupyter: # pragma: no cover

2052 from .jupyter import display

2053

2054 display(self._buffer, self._render_buffer(self._buffer[:]))

2055 del self._buffer[:]

2056 else:

2057 if WINDOWS:

2058 use_legacy_windows_render = False

2059 if self.legacy_windows:

2060 fileno = get_fileno(self.file)

2061 if fileno is not None:

2062 use_legacy_windows_render = (

2063 fileno in _STD_STREAMS_OUTPUT

2064 )

2065

2066 if use_legacy_windows_render:

2067 from rich._win32_console import LegacyWindowsTerm

2068 from rich._windows_renderer import legacy_windows_render

2069

2070 buffer = self._buffer[:]

2071 if self.no_color and self._color_system:

2072 buffer = list(Segment.remove_color(buffer))

2073

2074 legacy_windows_render(buffer, LegacyWindowsTerm(self.file))

2075 else:

2076 # Either a non-std stream on legacy Windows, or modern Windows.

2077 text = self._render_buffer(self._buffer[:])

2078 # https://bugs.python.org/issue37871

2079 # https://github.com/python/cpython/issues/82052

2080 # We need to avoid writing more than 32Kb in a single write, due to the above bug

2081 write = self.file.write

2082 # Worse case scenario, every character is 4 bytes of utf-8

2083 MAX_WRITE = 32 * 1024 // 4

2084 try:

2085 if len(text) <= MAX_WRITE:

2086 write(text)

2087 else:

2088 batch: List[str] = []

2089 batch_append = batch.append

2090 size = 0

2091 for line in text.splitlines(True):

2092 if size + len(line) > MAX_WRITE and batch:

2093 write("".join(batch))

2094 batch.clear()

2095 size = 0

2096 batch_append(line)

2097 size += len(line)

2098 if batch:

2099 write("".join(batch))

2100 batch.clear()

2101 except UnicodeEncodeError as error:

2102 error.reason = f"{error.reason}\n*** You may need to add PYTHONIOENCODING=utf-8 to your environment ***"

2103 raise

2104 else:

2105 text = self._render_buffer(self._buffer[:])

2106 try:

2107 self.file.write(text)

2108 except UnicodeEncodeError as error:

2109 error.reason = f"{error.reason}\n*** You may need to add PYTHONIOENCODING=utf-8 to your environment ***"

2110 raise

2111

2112 self.file.flush()

2113 del self._buffer[:]

2114

2115 def _render_buffer(self, buffer: Iterable[Segment]) -> str:

2116 """Render buffered output, and clear buffer."""

2117 output: List[str] = []

2118 append = output.append

2119 color_system = self._color_system

2120 legacy_windows = self.legacy_windows

2121 not_terminal = not self.is_terminal

2122 if self.no_color and color_system:

2123 buffer = Segment.remove_color(buffer)

2124 for text, style, control in buffer:

2125 if style:

2126 append(

2127 style.render(

2128 text,

2129 color_system=color_system,

2130 legacy_windows=legacy_windows,

2131 )

2132 )

2133 elif not (not_terminal and control):

2134 append(text)

2135

2136 rendered = "".join(output)

2137 return rendered

2138

2139 def input(

2140 self,

2141 prompt: TextType = "",

2142 *,

2143 markup: bool = True,

2144 emoji: bool = True,

2145 password: bool = False,

2146 stream: Optional[TextIO] = None,

2147 ) -> str:

2148 """Displays a prompt and waits for input from the user. The prompt may contain color / style.

2149

2150 It works in the same way as Python's builtin :func:`input` function and provides elaborate line editing and history features if Python's builtin :mod:`readline` module is previously loaded.

2151

2152 Args:

2153 prompt (Union[str, Text]): Text to render in the prompt.

2154 markup (bool, optional): Enable console markup (requires a str prompt). Defaults to True.

2155 emoji (bool, optional): Enable emoji (requires a str prompt). Defaults to True.

2156 password: (bool, optional): Hide typed text. Defaults to False.

2157 stream: (TextIO, optional): Optional file to read input from (rather than stdin). Defaults to None.

2158

2159 Returns:

2160 str: Text read from stdin.

2161 """

2162 if prompt: