| from __future__ import absolute_import |
| |
| from inspect import cleandoc, getdoc, getfile, isclass, ismodule, signature |
| from typing import Any, Iterable, Optional, Tuple |
| |
| from .console import RenderableType, Group |
| from .highlighter import ReprHighlighter |
| from .jupyter import JupyterMixin |
| from .panel import Panel |
| from .pretty import Pretty |
| from .table import Table |
| from .text import Text, TextType |
| |
| |
| def _first_paragraph(doc: str) -> str: |
| """Get the first paragraph from a docstring.""" |
| paragraph, _, _ = doc.partition("\n\n") |
| return paragraph |
| |
| |
| def _reformat_doc(doc: str) -> str: |
| """Reformat docstring.""" |
| doc = cleandoc(doc).strip() |
| return doc |
| |
| |
| class Inspect(JupyterMixin): |
| """A renderable to inspect any Python Object. |
| |
| 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 of object. Defaults to True. |
| """ |
| |
| def __init__( |
| self, |
| obj: Any, |
| *, |
| title: Optional[TextType] = None, |
| help: bool = False, |
| methods: bool = False, |
| docs: bool = True, |
| private: bool = False, |
| dunder: bool = False, |
| sort: bool = True, |
| all: bool = True, |
| value: bool = True, |
| ) -> None: |
| self.highlighter = ReprHighlighter() |
| self.obj = obj |
| self.title = title or self._make_title(obj) |
| if all: |
| methods = private = dunder = True |
| self.help = help |
| self.methods = methods |
| self.docs = docs or help |
| self.private = private or dunder |
| self.dunder = dunder |
| self.sort = sort |
| self.value = value |
| |
| def _make_title(self, obj: Any) -> Text: |
| """Make a default title.""" |
| title_str = ( |
| str(obj) |
| if (isclass(obj) or callable(obj) or ismodule(obj)) |
| else str(type(obj)) |
| ) |
| title_text = self.highlighter(title_str) |
| return title_text |
| |
| def __rich__(self) -> Panel: |
| return Panel.fit( |
| Group(*self._render()), |
| title=self.title, |
| border_style="scope.border", |
| padding=(0, 1), |
| ) |
| |
| def _get_signature(self, name: str, obj: Any) -> Optional[Text]: |
| """Get a signature for a callable.""" |
| try: |
| _signature = str(signature(obj)) + ":" |
| except ValueError: |
| _signature = "(...)" |
| except TypeError: |
| return None |
| |
| source_filename: Optional[str] = None |
| try: |
| source_filename = getfile(obj) |
| except TypeError: |
| pass |
| |
| callable_name = Text(name, style="inspect.callable") |
| if source_filename: |
| callable_name.stylize(f"link file://{source_filename}") |
| signature_text = self.highlighter(_signature) |
| |
| qualname = name or getattr(obj, "__qualname__", name) |
| qual_signature = Text.assemble( |
| ("def ", "inspect.def"), (qualname, "inspect.callable"), signature_text |
| ) |
| |
| return qual_signature |
| |
| def _render(self) -> Iterable[RenderableType]: |
| """Render object.""" |
| |
| def sort_items(item: Tuple[str, Any]) -> Tuple[bool, str]: |
| key, (_error, value) = item |
| return (callable(value), key.strip("_").lower()) |
| |
| def safe_getattr(attr_name: str) -> Tuple[Any, Any]: |
| """Get attribute or any exception.""" |
| try: |
| return (None, getattr(obj, attr_name)) |
| except Exception as error: |
| return (error, None) |
| |
| obj = self.obj |
| keys = dir(obj) |
| total_items = len(keys) |
| if not self.dunder: |
| keys = [key for key in keys if not key.startswith("__")] |
| if not self.private: |
| keys = [key for key in keys if not key.startswith("_")] |
| not_shown_count = total_items - len(keys) |
| items = [(key, safe_getattr(key)) for key in keys] |
| if self.sort: |
| items.sort(key=sort_items) |
| |
| items_table = Table.grid(padding=(0, 1), expand=False) |
| items_table.add_column(justify="right") |
| add_row = items_table.add_row |
| highlighter = self.highlighter |
| |
| if callable(obj): |
| signature = self._get_signature("", obj) |
| if signature is not None: |
| yield signature |
| yield "" |
| |
| if self.docs: |
| _doc = getdoc(obj) |
| if _doc is not None: |
| if not self.help: |
| _doc = _first_paragraph(_doc) |
| doc_text = Text(_reformat_doc(_doc), style="inspect.help") |
| doc_text = highlighter(doc_text) |
| yield doc_text |
| yield "" |
| |
| if self.value and not (isclass(obj) or callable(obj) or ismodule(obj)): |
| yield Panel( |
| Pretty(obj, indent_guides=True, max_length=10, max_string=60), |
| border_style="inspect.value.border", |
| ) |
| yield "" |
| |
| for key, (error, value) in items: |
| key_text = Text.assemble( |
| ( |
| key, |
| "inspect.attr.dunder" if key.startswith("__") else "inspect.attr", |
| ), |
| (" =", "inspect.equals"), |
| ) |
| if error is not None: |
| warning = key_text.copy() |
| warning.stylize("inspect.error") |
| add_row(warning, highlighter(repr(error))) |
| continue |
| |
| if callable(value): |
| if not self.methods: |
| continue |
| |
| _signature_text = self._get_signature(key, value) |
| if _signature_text is None: |
| add_row(key_text, Pretty(value, highlighter=highlighter)) |
| else: |
| if self.docs: |
| docs = getdoc(value) |
| if docs is not None: |
| _doc = _reformat_doc(str(docs)) |
| if not self.help: |
| _doc = _first_paragraph(_doc) |
| _signature_text.append("\n" if "\n" in _doc else " ") |
| doc = highlighter(_doc) |
| doc.stylize("inspect.doc") |
| _signature_text.append(doc) |
| |
| add_row(key_text, _signature_text) |
| else: |
| add_row(key_text, Pretty(value, highlighter=highlighter)) |
| if items_table.row_count: |
| yield items_table |
| else: |
| yield Text.from_markup( |
| f"[b cyan]{not_shown_count}[/][i] attribute(s) not shown.[/i] Run [b][magenta]inspect[/]([not b]inspect[/])[/b] for options." |
| ) |
