| from typing import Any, ClassVar, Dict, List, Optional, Type, Union |
|
|
| from commonmark.blocks import Parser |
|
|
| from . import box |
| from ._loop import loop_first |
| from ._stack import Stack |
| from .console import Console, ConsoleOptions, JustifyMethod, RenderResult, Segment |
| from .containers import Renderables |
| from .jupyter import JupyterMixin |
| from .panel import Panel |
| from .rule import Rule |
| from .style import Style, StyleStack |
| from .syntax import Syntax |
| from .text import Text, TextType |
|
|
|
|
| class MarkdownElement: |
|
|
| new_line: ClassVar[bool] = True |
|
|
| @classmethod |
| def create(cls, markdown: "Markdown", node: Any) -> "MarkdownElement": |
| """Factory to create markdown element, |
| |
| Args: |
| markdown (Markdown): THe parent Markdown object. |
| node (Any): A node from Pygments. |
| |
| Returns: |
| MarkdownElement: A new markdown element |
| """ |
| return cls() |
|
|
| def on_enter(self, context: "MarkdownContext"): |
| """Called when the node is entered. |
| |
| Args: |
| context (MarkdownContext): The markdown context. |
| """ |
|
|
| def on_text(self, context: "MarkdownContext", text: TextType) -> None: |
| """Called when text is parsed. |
| |
| Args: |
| context (MarkdownContext): The markdown context. |
| """ |
|
|
| def on_leave(self, context: "MarkdownContext") -> None: |
| """Called when the parser leaves the element. |
| |
| Args: |
| context (MarkdownContext): [description] |
| """ |
|
|
| def on_child_close( |
| self, context: "MarkdownContext", child: "MarkdownElement" |
| ) -> bool: |
| """Called when a child element is closed. |
| |
| This method allows a parent element to take over rendering of its children. |
| |
| Args: |
| context (MarkdownContext): The markdown context. |
| child (MarkdownElement): The child markdown element. |
| |
| Returns: |
| bool: Return True to render the element, or False to not render the element. |
| """ |
| return True |
|
|
| def __rich_console__( |
| self, console: "Console", options: "ConsoleOptions" |
| ) -> "RenderResult": |
| return () |
|
|
|
|
| class UnknownElement(MarkdownElement): |
| """An unknown element. |
| |
| Hopefully there will be no unknown elements, and we will have a MarkdownElement for |
| everything in the document. |
| |
| """ |
|
|
|
|
| class TextElement(MarkdownElement): |
| """Base class for elements that render text.""" |
|
|
| style_name = "none" |
|
|
| def on_enter(self, context: "MarkdownContext") -> None: |
| self.style = context.enter_style(self.style_name) |
| self.text = Text(justify="left") |
|
|
| def on_text(self, context: "MarkdownContext", text: TextType) -> None: |
| self.text.append(text, context.current_style if isinstance(text, str) else None) |
|
|
| def on_leave(self, context: "MarkdownContext") -> None: |
| context.leave_style() |
|
|
|
|
| class Paragraph(TextElement): |
| """A Paragraph.""" |
|
|
| style_name = "markdown.paragraph" |
| justify: JustifyMethod |
|
|
| @classmethod |
| def create(cls, markdown: "Markdown", node) -> "Paragraph": |
| return cls(justify=markdown.justify or "left") |
|
|
| def __init__(self, justify: JustifyMethod) -> None: |
| self.justify = justify |
|
|
| def __rich_console__( |
| self, console: Console, options: ConsoleOptions |
| ) -> RenderResult: |
| self.text.justify = self.justify |
| yield self.text |
|
|
|
|
| class Heading(TextElement): |
| """A heading.""" |
|
|
| @classmethod |
| def create(cls, markdown: "Markdown", node: Any) -> "Heading": |
| heading = cls(node.level) |
| return heading |
|
|
| def on_enter(self, context: "MarkdownContext") -> None: |
| self.text = Text() |
| context.enter_style(self.style_name) |
|
|
| def __init__(self, level: int) -> None: |
| self.level = level |
| self.style_name = f"markdown.h{level}" |
| super().__init__() |
|
|
| def __rich_console__( |
| self, console: Console, options: ConsoleOptions |
| ) -> RenderResult: |
| text = self.text |
| text.justify = "center" |
| if self.level == 1: |
| |
| yield Panel( |
| text, |
| box=box.DOUBLE, |
| style="markdown.h1.border", |
| ) |
| else: |
| |
| if self.level == 2: |
| yield Text("") |
| yield text |
|
|
|
|
| class CodeBlock(TextElement): |
| """A code block with syntax highlighting.""" |
|
|
| style_name = "markdown.code_block" |
|
|
| @classmethod |
| def create(cls, markdown: "Markdown", node: Any) -> "CodeBlock": |
| node_info = node.info or "" |
| lexer_name = node_info.partition(" ")[0] |
| return cls(lexer_name or "default", markdown.code_theme) |
|
|
| def __init__(self, lexer_name: str, theme: str) -> None: |
| self.lexer_name = lexer_name |
| self.theme = theme |
|
|
| def __rich_console__( |
| self, console: Console, options: ConsoleOptions |
| ) -> RenderResult: |
| code = str(self.text).rstrip() |
| syntax = Panel( |
| Syntax(code, self.lexer_name, theme=self.theme), |
| border_style="dim", |
| box=box.SQUARE, |
| ) |
| yield syntax |
|
|
|
|
| class BlockQuote(TextElement): |
| """A block quote.""" |
|
|
| style_name = "markdown.block_quote" |
|
|
| def __init__(self) -> None: |
| self.elements: Renderables = Renderables() |
|
|
| def on_child_close( |
| self, context: "MarkdownContext", child: "MarkdownElement" |
| ) -> bool: |
| self.elements.append(child) |
| return False |
|
|
| def __rich_console__( |
| self, console: Console, options: ConsoleOptions |
| ) -> RenderResult: |
| render_options = options.update(width=options.max_width - 4) |
| lines = console.render_lines(self.elements, render_options, style=self.style) |
| style = self.style |
| new_line = Segment("\n") |
| padding = Segment("▌ ", style) |
| for line in lines: |
| yield padding |
| yield from line |
| yield new_line |
|
|
|
|
| class HorizontalRule(MarkdownElement): |
| """A horizontal rule to divide sections.""" |
|
|
| new_line = False |
|
|
| def __rich_console__( |
| self, console: Console, options: ConsoleOptions |
| ) -> RenderResult: |
| style = console.get_style("markdown.hr", default="none") |
| yield Rule(style=style) |
|
|
|
|
| class ListElement(MarkdownElement): |
| """A list element.""" |
|
|
| @classmethod |
| def create(cls, markdown: "Markdown", node: Any) -> "ListElement": |
| list_data = node.list_data |
| return cls(list_data["type"], list_data["start"]) |
|
|
| def __init__(self, list_type: str, list_start: Optional[int]) -> None: |
| self.items: List[ListItem] = [] |
| self.list_type = list_type |
| self.list_start = list_start |
|
|
| def on_child_close( |
| self, context: "MarkdownContext", child: "MarkdownElement" |
| ) -> bool: |
| assert isinstance(child, ListItem) |
| self.items.append(child) |
| return False |
|
|
| def __rich_console__( |
| self, console: Console, options: ConsoleOptions |
| ) -> RenderResult: |
| if self.list_type == "bullet": |
| for item in self.items: |
| yield from item.render_bullet(console, options) |
| else: |
| number = 1 if self.list_start is None else self.list_start |
| last_number = number + len(self.items) |
| for item in self.items: |
| yield from item.render_number(console, options, number, last_number) |
| number += 1 |
|
|
|
|
| class ListItem(TextElement): |
| """An item in a list.""" |
|
|
| style_name = "markdown.item" |
|
|
| def __init__(self) -> None: |
| self.elements: Renderables = Renderables() |
|
|
| def on_child_close( |
| self, context: "MarkdownContext", child: "MarkdownElement" |
| ) -> bool: |
| self.elements.append(child) |
| return False |
|
|
| def render_bullet(self, console: Console, options: ConsoleOptions) -> RenderResult: |
| render_options = options.update(width=options.max_width - 3) |
| lines = console.render_lines(self.elements, render_options, style=self.style) |
| bullet_style = console.get_style("markdown.item.bullet", default="none") |
|
|
| bullet = Segment(" • ", bullet_style) |
| padding = Segment(" " * 3, bullet_style) |
| new_line = Segment("\n") |
| for first, line in loop_first(lines): |
| yield bullet if first else padding |
| yield from line |
| yield new_line |
|
|
| def render_number( |
| self, console: Console, options: ConsoleOptions, number: int, last_number: int |
| ) -> RenderResult: |
| number_width = len(str(last_number)) + 2 |
| render_options = options.update(width=options.max_width - number_width) |
| lines = console.render_lines(self.elements, render_options, style=self.style) |
| number_style = console.get_style("markdown.item.number", default="none") |
|
|
| new_line = Segment("\n") |
| padding = Segment(" " * number_width, number_style) |
| numeral = Segment(f"{number}".rjust(number_width - 1) + " ", number_style) |
| for first, line in loop_first(lines): |
| yield numeral if first else padding |
| yield from line |
| yield new_line |
|
|
|
|
| class ImageItem(TextElement): |
| """Renders a placeholder for an image.""" |
|
|
| new_line = False |
|
|
| @classmethod |
| def create(cls, markdown: "Markdown", node: Any) -> "MarkdownElement": |
| """Factory to create markdown element, |
| |
| Args: |
| markdown (Markdown): THe parent Markdown object. |
| node (Any): A node from Pygments. |
| |
| Returns: |
| MarkdownElement: A new markdown element |
| """ |
| return cls(node.destination, markdown.hyperlinks) |
|
|
| def __init__(self, destination: str, hyperlinks: bool) -> None: |
| self.destination = destination |
| self.hyperlinks = hyperlinks |
| self.link: Optional[str] = None |
| super().__init__() |
|
|
| def on_enter(self, context: "MarkdownContext") -> None: |
| self.link = context.current_style.link |
| self.text = Text(justify="left") |
| super().on_enter(context) |
|
|
| def __rich_console__( |
| self, console: Console, options: ConsoleOptions |
| ) -> RenderResult: |
| link_style = Style(link=self.link or self.destination or None) |
| title = self.text or Text(self.destination.strip("/").rsplit("/", 1)[-1]) |
| if self.hyperlinks: |
| title.stylize(link_style) |
| yield Text.assemble("🌆 ", title, " ", end="") |
|
|
|
|
| class MarkdownContext: |
| """Manages the console render state.""" |
|
|
| def __init__( |
| self, |
| console: Console, |
| options: ConsoleOptions, |
| style: Style, |
| inline_code_lexer: str = None, |
| inline_code_theme: str = "monokai", |
| ) -> None: |
| self.console = console |
| self.options = options |
| self.style_stack: StyleStack = StyleStack(style) |
| self.stack: Stack[MarkdownElement] = Stack() |
|
|
| self._syntax: Optional[Syntax] = None |
| if inline_code_lexer is not None: |
| self._syntax = Syntax("", inline_code_lexer, theme=inline_code_theme) |
|
|
| @property |
| def current_style(self) -> Style: |
| """Current style which is the product of all styles on the stack.""" |
| return self.style_stack.current |
|
|
| def on_text(self, text: str, node_type: str) -> None: |
| """Called when the parser visits text.""" |
| if node_type == "code" and self._syntax is not None: |
| highlight_text = self._syntax.highlight(text) |
| highlight_text.rstrip() |
| self.stack.top.on_text( |
| self, Text.assemble(highlight_text, style=self.style_stack.current) |
| ) |
| else: |
| self.stack.top.on_text(self, text) |
|
|
| def enter_style(self, style_name: Union[str, Style]) -> Style: |
| """Enter a style context.""" |
| style = self.console.get_style(style_name, default="none") |
| self.style_stack.push(style) |
| return self.current_style |
|
|
| def leave_style(self) -> Style: |
| """Leave a style context.""" |
| style = self.style_stack.pop() |
| return style |
|
|
|
|
| class Markdown(JupyterMixin): |
| """A Markdown renderable. |
| |
| Args: |
| markup (str): A string containing markdown. |
| code_theme (str, optional): Pygments theme for code blocks. Defaults to "monokai". |
| justify (JustifyMethod, optional): Justify value for paragraphs. Defaults to None. |
| style (Union[str, Style], optional): Optional style to apply to markdown. |
| hyperlinks (bool, optional): Enable hyperlinks. Defaults to ``True``. |
| inline_code_lexer: (str, optional): Lexer to use if inline code highlighting is |
| enabled. Defaults to "python". |
| inline_code_theme: (Optional[str], optional): Pygments theme for inline code |
| highlighting, or None for no highlighting. Defaults to None. |
| """ |
|
|
| elements: ClassVar[Dict[str, Type[MarkdownElement]]] = { |
| "paragraph": Paragraph, |
| "heading": Heading, |
| "code_block": CodeBlock, |
| "block_quote": BlockQuote, |
| "thematic_break": HorizontalRule, |
| "list": ListElement, |
| "item": ListItem, |
| "image": ImageItem, |
| } |
| inlines = {"emph", "strong", "code", "strike"} |
|
|
| def __init__( |
| self, |
| markup: str, |
| code_theme: str = "monokai", |
| justify: JustifyMethod = None, |
| style: Union[str, Style] = "none", |
| hyperlinks: bool = True, |
| inline_code_lexer: str = None, |
| inline_code_theme: str = None, |
| ) -> None: |
| self.markup = markup |
| parser = Parser() |
| self.parsed = parser.parse(markup) |
| self.code_theme = code_theme |
| self.justify = justify |
| self.style = style |
| self.hyperlinks = hyperlinks |
| self.inline_code_lexer = inline_code_lexer |
| self.inline_code_theme = inline_code_theme or code_theme |
|
|
| def __rich_console__( |
| self, console: Console, options: ConsoleOptions |
| ) -> RenderResult: |
| """Render markdown to the console.""" |
| style = console.get_style(self.style, default="none") |
| context = MarkdownContext( |
| console, |
| options, |
| style, |
| inline_code_lexer=self.inline_code_lexer, |
| inline_code_theme=self.inline_code_theme, |
| ) |
| nodes = self.parsed.walker() |
| inlines = self.inlines |
| new_line = False |
| for current, entering in nodes: |
| node_type = current.t |
| if node_type in ("html_inline", "html_block", "text"): |
| context.on_text(current.literal.replace("\n", " "), node_type) |
| elif node_type == "linebreak": |
| if entering: |
| context.on_text("\n", node_type) |
| elif node_type == "softbreak": |
| if entering: |
| context.on_text(" ", node_type) |
| elif node_type == "link": |
| if entering: |
| link_style = console.get_style("markdown.link", default="none") |
| if self.hyperlinks: |
| link_style += Style(link=current.destination) |
| context.enter_style(link_style) |
| else: |
| context.leave_style() |
| if not self.hyperlinks: |
| context.on_text(" (", node_type) |
| style = Style(underline=True) + console.get_style( |
| "markdown.link_url", default="none" |
| ) |
| context.enter_style(style) |
| context.on_text(current.destination, node_type) |
| context.leave_style() |
| context.on_text(")", node_type) |
| elif node_type in inlines: |
| if current.is_container(): |
| if entering: |
| context.enter_style(f"markdown.{node_type}") |
| else: |
| context.leave_style() |
| else: |
| context.enter_style(f"markdown.{node_type}") |
| if current.literal: |
| context.on_text(current.literal, node_type) |
| context.leave_style() |
| else: |
| element_class = self.elements.get(node_type) or UnknownElement |
| if current.is_container(): |
| if entering: |
| element = element_class.create(self, current) |
| context.stack.push(element) |
| element.on_enter(context) |
| else: |
| element = context.stack.pop() |
| if context.stack: |
| if context.stack.top.on_child_close(context, element): |
| if new_line: |
| yield Segment("\n") |
| yield from console.render(element, context.options) |
| element.on_leave(context) |
| else: |
| element.on_leave(context) |
| else: |
| element.on_leave(context) |
| yield from console.render(element, context.options) |
| new_line = element.new_line |
| else: |
| element = element_class.create(self, current) |
|
|
| context.stack.push(element) |
| element.on_enter(context) |
| if current.literal: |
| element.on_text(context, current.literal.rstrip()) |
| context.stack.pop() |
| if new_line: |
| yield Segment("\n") |
| yield from console.render(element, context.options) |
| element.on_leave(context) |
| new_line = element.new_line |
|
|
|
|
| if __name__ == "__main__": |
|
|
| import argparse |
| import sys |
|
|
| parser = argparse.ArgumentParser( |
| description="Render Markdown to the console with Rich" |
| ) |
| parser.add_argument( |
| "path", |
| metavar="PATH", |
| nargs="?", |
| help="path to markdown file", |
| ) |
| parser.add_argument( |
| "-c", |
| "--force-color", |
| dest="force_color", |
| action="store_true", |
| default=None, |
| help="force color for non-terminals", |
| ) |
| parser.add_argument( |
| "-t", |
| "--code-theme", |
| dest="code_theme", |
| default="monokai", |
| help="pygments code theme", |
| ) |
| parser.add_argument( |
| "-i", |
| "--inline-code-lexer", |
| dest="inline_code_lexer", |
| default=None, |
| help="inline_code_lexer", |
| ) |
| parser.add_argument( |
| "-y", |
| "--hyperlinks", |
| dest="hyperlinks", |
| action="store_true", |
| help="enable hyperlinks", |
| ) |
| parser.add_argument( |
| "-w", |
| "--width", |
| type=int, |
| dest="width", |
| default=None, |
| help="width of output (default will auto-detect)", |
| ) |
| parser.add_argument( |
| "-j", |
| "--justify", |
| dest="justify", |
| action="store_true", |
| help="enable full text justify", |
| ) |
| parser.add_argument( |
| "-p", |
| "--page", |
| dest="page", |
| action="store_true", |
| help="use pager to scroll output", |
| ) |
| args = parser.parse_args() |
|
|
| from rich.console import Console |
|
|
| if not args.path or args.path == "-": |
| markdown_body = sys.stdin.read() |
| else: |
| with open(args.path, "rt", encoding="utf-8") as markdown_file: |
| markdown_body = markdown_file.read() |
| markdown = Markdown( |
| markdown_body, |
| justify="full" if args.justify else "left", |
| code_theme=args.code_theme, |
| hyperlinks=args.hyperlinks, |
| inline_code_lexer=args.inline_code_lexer, |
| ) |
| if args.page: |
| import pydoc |
| import io |
|
|
| console = Console( |
| file=io.StringIO(), force_terminal=args.force_color, width=args.width |
| ) |
| console.print(markdown) |
| pydoc.pager(console.file.getvalue()) |
|
|
| else: |
| console = Console(force_terminal=args.force_color, width=args.width) |
| console.print(markdown) |
|
|
