| """Rich text and beautiful formatting in the terminal.""" |
| |
| import os |
| from typing import Callable, IO, TYPE_CHECKING, Any, Optional |
| |
| from ._extension import load_ipython_extension |
| |
| __all__ = ["get_console", "reconfigure", "print", "inspect"] |
| |
| if TYPE_CHECKING: |
| from .console import Console |
| |
| # Global console used by alternative print |
| _console: Optional["Console"] = None |
| |
| _IMPORT_CWD = os.path.abspath(os.getcwd()) |
| |
| |
| def get_console() -> "Console": |
| """Get a global :class:`~rich.console.Console` instance. This function is used when Rich requires a Console, |
| and hasn't been explicitly given one. |
| |
| Returns: |
| Console: A console instance. |
| """ |
| global _console |
| if _console is None: |
| from .console import Console |
| |
| _console = Console() |
| |
| return _console |
| |
| |
| def reconfigure(*args: Any, **kwargs: Any) -> None: |
| """Reconfigures the global console by replacing it with another. |
| |
| Args: |
| console (Console): Replacement console instance. |
| """ |
| from pip._vendor.rich.console import Console |
| |
| new_console = Console(*args, **kwargs) |
| _console = get_console() |
| _console.__dict__ = new_console.__dict__ |
| |
| |
| def print( |
| *objects: Any, |
| sep: str = " ", |
| end: str = "\n", |
| file: Optional[IO[str]] = None, |
| flush: bool = False, |
| ) -> None: |
| r"""Print object(s) supplied via positional arguments. |
| This function has an identical signature to the built-in print. |
| For more advanced features, see the :class:`~rich.console.Console` class. |
| |
| Args: |
| sep (str, optional): Separator between printed objects. Defaults to " ". |
| end (str, optional): Character to write at end of output. Defaults to "\\n". |
| file (IO[str], optional): File to write to, or None for stdout. Defaults to None. |
| flush (bool, optional): Has no effect as Rich always flushes output. Defaults to False. |
| |
| """ |
| from .console import Console |
| |
| write_console = get_console() if file is None else Console(file=file) |
| return write_console.print(*objects, sep=sep, end=end) |
| |
| |
| def print_json( |
| json: Optional[str] = None, |
| *, |
| data: Any = None, |
| indent: int = 2, |
| highlight: bool = True, |
| skip_keys: bool = False, |
| ensure_ascii: bool = True, |
| check_circular: bool = True, |
| allow_nan: bool = True, |
| default: Optional[Callable[[Any], Any]] = None, |
| sort_keys: bool = False, |
| ) -> None: |
| """Pretty prints JSON. Output will be valid JSON. |
| |
| Args: |
| json (str): A string containing JSON. |
| data (Any): If json is not supplied, then encode this data. |
| indent (int, optional): Number of spaces to indent. Defaults to 2. |
| highlight (bool, optional): Enable highlighting of output: Defaults to True. |
| skip_keys (bool, optional): Skip keys not of a basic type. Defaults to False. |
| ensure_ascii (bool, optional): Escape all non-ascii characters. Defaults to False. |
| check_circular (bool, optional): Check for circular references. Defaults to True. |
| allow_nan (bool, optional): Allow NaN and Infinity values. Defaults to True. |
| default (Callable, optional): A callable that converts values that can not be encoded |
| in to something that can be JSON encoded. Defaults to None. |
| sort_keys (bool, optional): Sort dictionary keys. Defaults to False. |
| """ |
| |
| get_console().print_json( |
| json, |
| data=data, |
| indent=indent, |
| highlight=highlight, |
| skip_keys=skip_keys, |
| ensure_ascii=ensure_ascii, |
| check_circular=check_circular, |
| allow_nan=allow_nan, |
| default=default, |
| sort_keys=sort_keys, |
| ) |
| |
| |
| def inspect( |
| obj: Any, |
| *, |
| console: Optional["Console"] = None, |
| title: Optional[str] = None, |
| help: bool = False, |
| methods: bool = False, |
| docs: bool = True, |
| private: bool = False, |
| dunder: bool = False, |
| sort: bool = True, |
| all: bool = False, |
| value: bool = True, |
| ) -> None: |
| """Inspect any Python object. |
| |
| * inspect(<OBJECT>) to see summarized info. |
| * inspect(<OBJECT>, methods=True) to see methods. |
| * inspect(<OBJECT>, help=True) to see full (non-abbreviated) help. |
| * inspect(<OBJECT>, private=True) to see private attributes (single underscore). |
| * inspect(<OBJECT>, dunder=True) to see attributes beginning with double underscore. |
| * inspect(<OBJECT>, all=True) to see all attributes. |
| |
| Args: |
| obj (Any): An object to inspect. |
| title (str, optional): Title to display over inspect result, or None use type. Defaults to None. |
| help (bool, optional): Show full help text rather than just first paragraph. Defaults to False. |
| methods (bool, optional): Enable inspection of callables. Defaults to False. |
| docs (bool, optional): Also render doc strings. Defaults to True. |
| private (bool, optional): Show private attributes (beginning with underscore). Defaults to False. |
| dunder (bool, optional): Show attributes starting with double underscore. Defaults to False. |
| sort (bool, optional): Sort attributes alphabetically. Defaults to True. |
| all (bool, optional): Show all attributes. Defaults to False. |
| value (bool, optional): Pretty print value. Defaults to True. |
| """ |
| _console = console or get_console() |
| from pip._vendor.rich._inspect import Inspect |
| |
| # Special case for inspect(inspect) |
| is_inspect = obj is inspect |
| |
| _inspect = Inspect( |
| obj, |
| title=title, |
| help=is_inspect or help, |
| methods=is_inspect or methods, |
| docs=is_inspect or docs, |
| private=private, |
| dunder=dunder, |
| sort=sort, |
| all=all, |
| value=value, |
| ) |
| _console.print(_inspect) |
| |
| |
| if __name__ == "__main__": # pragma: no cover |
| print("Hello, **World**") |