omdev 0.0.0.dev293__py3-none-any.whl → 0.0.0.dev295__py3-none-any.whl

omdev/.manifests.json

@@ -291,7 +291,7 @@
     "module": ".tools.doc",
     "attr": "_CLI_MODULE",
     "file": "omdev/tools/doc.py",
-    "line": 103,
+    "line": 106,
     "value": {
       "$.cli.types.CliModule": {
         "cmd_name": "doc",

omdev/__about__.py

@@ -25,7 +25,7 @@ class Project(ProjectBase):
             'docutils ~= 0.21',
 
             'markdown-it-py ~= 3.0',
-            # 'mdit-py-plugins ~= 0.4',
+            'mdit-py-plugins ~= 0.4',
         ],
 
         'mypy': [

omdev/ptk/markdown/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014, Jonathan Slenders
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+  disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+  disclaimer in the documentation and/or other materials provided with the distribution.
+
+* Neither the name of the {organization} nor the names of its contributors may be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

omdev/ptk/markdown/__init__.py

@@ -0,0 +1,2 @@
+# https://github.com/prompt-toolkit/python-prompt-toolkit/pull/1604/files
+# See also: https://github.com/joouha/euporie

omdev/ptk/markdown/__main__.py

@@ -0,0 +1,4 @@
+if __name__ == '__main__':
+    from .cli import _main
+
+    _main()

omdev/ptk/markdown/border.py

@@ -0,0 +1,94 @@
+import abc
+
+
+##
+
+
+class Border(metaclass=abc.ABCMeta):
+    """Base border type."""
+
+    TOP_LEFT: str
+    TOP_SPLIT: str
+    TOP_RIGHT: str
+    HORIZONTAL: str
+    VERTICAL: str
+    LEFT_SPLIT: str
+    RIGHT_SPLIT: str
+    CROSS: str
+    BOTTOM_LEFT: str
+    BOTTOM_SPLIT: str
+    BOTTOM_RIGHT: str
+
+
+class NoBorder(Border):
+    """Invisible border."""
+
+    TOP_LEFT = ' '
+    TOP_SPLIT = ' '
+    TOP_RIGHT = ' '
+    HORIZONTAL = ' '
+    INNER_VERTICAL = ' '
+    VERTICAL = ' '
+    LEFT_SPLIT = ' '
+    RIGHT_SPLIT = ' '
+    CROSS = ' '
+    BOTTOM_LEFT = ' '
+    BOTTOM_SPLIT = ' '
+    BOTTOM_RIGHT = ' '
+
+
+class SquareBorder(Border):
+    """Square thin border."""
+
+    TOP_LEFT = '┌'
+    TOP_SPLIT = '┬'
+    TOP_RIGHT = '┐'
+    HORIZONTAL = '─'
+    VERTICAL = '│'
+    LEFT_SPLIT = '├'
+    RIGHT_SPLIT = '┤'
+    CROSS = '┼'
+    BOTTOM_LEFT = '└'
+    BOTTOM_SPLIT = '┴'
+    BOTTOM_RIGHT = '┘'
+
+
+class RoundBorder(SquareBorder):
+    """Thin border with round corners."""
+
+    TOP_LEFT = '╭'
+    TOP_RIGHT = '╮'
+    BOTTOM_LEFT = '╰'
+    BOTTOM_RIGHT = '╯'
+
+
+class DoubleBorder(Border):
+    """Square border with double lines."""
+
+    TOP_LEFT = '╔'
+    TOP_SPLIT = '╦'
+    TOP_RIGHT = '╗'
+    HORIZONTAL = '═'
+    VERTICAL = '║'
+    LEFT_SPLIT = '╠'
+    RIGHT_SPLIT = '╣'
+    CROSS = '╬'
+    BOTTOM_LEFT = '╚'
+    BOTTOM_SPLIT = '╩'
+    BOTTOM_RIGHT = '╝'
+
+
+class ThickBorder(Border):
+    """Square border with thick lines."""
+
+    TOP_LEFT = '┏'
+    TOP_SPLIT = '┳'
+    TOP_RIGHT = '┓'
+    HORIZONTAL = '━'
+    VERTICAL = '┃'
+    LEFT_SPLIT = '┣'
+    RIGHT_SPLIT = '┫'
+    CROSS = '╋'
+    BOTTOM_LEFT = '┗'
+    BOTTOM_SPLIT = '┻'
+    BOTTOM_RIGHT = '┛'

omdev/ptk/markdown/cli.py

@@ -0,0 +1,30 @@
+import argparse
+import sys
+
+from ... import ptk
+from .markdown import Markdown
+from .styles import MARKDOWN_STYLE
+
+
+##
+
+
+def _main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('file', nargs='?')
+    args = parser.parse_args()
+
+    if args.file is not None:
+        with open(args.file) as f:
+            src = f.read()
+    else:
+        src = sys.stdin.read()
+
+    ptk.print_formatted_text(
+        Markdown(src),
+        style=ptk.Style(list(MARKDOWN_STYLE)),
+    )
+
+
+if __name__ == '__main__':
+    _main()

omdev/ptk/markdown/markdown.py

@@ -0,0 +1,384 @@
+import itertools
+import typing as ta
+
+from ... import ptk
+from .border import Border
+from .border import SquareBorder
+from .parser import markdown_parser
+from .tags import TAG_INSETS
+from .tags import TAG_RULES
+from .utils import FormattedTextAlign
+from .utils import align
+from .utils import apply_style
+from .utils import last_line_length
+from .utils import lex
+from .utils import strip
+from .utils import wrap
+
+
+if ta.TYPE_CHECKING:
+    from markdown_it.token import Token
+
+
+##
+
+
+_SIDES = {
+    'left': FormattedTextAlign.LEFT,
+    'right': FormattedTextAlign.RIGHT,
+    'center': FormattedTextAlign.CENTER,
+}
+
+
+class Markdown:
+    """A markdown formatted text renderer. Accepts a markdown string and renders it at a given width."""
+
+    def __init__(
+        self,
+        markup: str,
+        width: int | None = None,
+        strip_trailing_lines: bool = True,
+    ) -> None:
+        """
+        Initialize the markdown formatter.
+
+        Args:
+            markup: The markdown text to render
+            width: The width in characters available for rendering. If :py:const:`None` the terminal width will be used
+            strip_trailing_lines: If :py:const:`True`, empty lines at the end of the rendered output will be removed
+        """
+
+        super().__init__()
+
+        self.markup = markup
+        self.width = width or ptk.get_app_session().output.get_size().columns
+        self.strip_trailing_lines = strip_trailing_lines
+
+        if (parser := markdown_parser()) is not None:
+            self.formatted_text = self.render(
+                tokens=parser.parse(self.markup),
+                width=self.width,
+            )
+        else:
+            self.formatted_text = lex(
+                ptk.to_formatted_text(self.markup),
+                lexer_name='markdown',
+            )
+
+        if strip_trailing_lines:
+            self.formatted_text = strip(
+                self.formatted_text,
+                left=False,
+                char='\n',
+            )
+
+    def render(
+        self,
+            tokens: ta.Sequence['Token'],
+            width: int = 80,
+            left: int = 0,
+    ) -> ptk.StyleAndTextTuples:
+        """
+        Render a list of parsed markdown tokens.
+
+        Args:
+            tokens: The list of parsed tokens to render
+            width: The width at which to render the tokens
+            left: The position on the current line at which to render the output - used to indent subsequent lines when
+                rendering inline blocks like images
+        Returns:
+            Formatted text
+        """
+
+        ft = []
+
+        i = 0
+        while i < len(tokens):
+            token = tokens[i]
+
+            # If this is an inline block, render it's children
+            if token.type == 'inline' and token.children:
+                ft += self.render(token.children, width)
+                i += 1
+
+            # Otherwise gather the tokens in the current block
+            else:
+                nest = 0
+                tokens_in_block = 0
+                for j, token in enumerate(tokens[i:]):
+                    nest += token.nesting
+                    if nest == 0:
+                        tokens_in_block = j
+                        break
+
+                # If there is a special method for rendering the block, use it
+
+                # Table require a lot of care
+                if token.tag == 'table':
+                    ft += self.render_table(
+                        tokens[i:i + tokens_in_block + 1],
+                        width=width,
+                        left=last_line_length(ft),
+                    )
+
+                # We need to keep track of item numbers in ordered lists
+                elif token.tag == 'ol':
+                    ft += self.render_ordered_list(
+                        tokens[i:i + tokens_in_block + 1],
+                        width=width,
+                        left=last_line_length(ft),
+                    )
+
+                # Otherwise all other blocks are rendered in the same way
+                else:
+                    ft += self.render_block(
+                        tokens[i:i + tokens_in_block + 1],
+                        width=width,
+                        left=last_line_length(ft),
+                    )
+
+                i += j + 1
+
+        return ft
+
+    def render_block(
+        self,
+        tokens: ta.Sequence['Token'],
+        width: int,
+        left: int = 0,
+    ) -> ptk.StyleAndTextTuples:
+        """
+        Render a list of parsed markdown tokens representing a block element.
+
+        Args:
+            tokens: The list of parsed tokens to render
+            width: The width at which to render the tokens
+            left: The position on the current line at which to render the output - used to indent subsequent lines when
+                rendering inline blocks like images
+        Returns:
+            Formatted text
+        """
+
+        ft = []
+        token = tokens[0]
+
+        # Restrict width if necessary
+        inset = TAG_INSETS.get(token.tag)
+        if inset:
+            width -= inset
+
+        style = 'class:md'
+        if token.tag:
+            style = f'{style}.{token.tag}'
+
+        # Render innards
+        if len(tokens) > 1:
+            ft += self.render(tokens[1:-1], width)
+            ft = apply_style(ft, style)
+        else:
+            ft.append((style, token.content))
+
+        # Apply tag rule
+        rule = TAG_RULES.get(token.tag)
+        if rule:
+            ft = rule(
+                ft,
+                width,
+                left,
+                token,
+            )
+
+        return ft
+
+    def render_ordered_list(
+        self,
+        tokens: ta.Sequence['Token'],
+        width: int,
+        left: int = 0,
+    ) -> ptk.StyleAndTextTuples:
+        """Render an ordered list by adding indices to the child list items."""
+
+        # Find the list item tokens
+        list_level_tokens = []
+        nest = 0
+        for token in tokens:
+            if nest == 1 and token.tag == 'li':
+                list_level_tokens.append(token)
+            nest += token.nesting
+
+        # Assign them a marking
+        margin_width = len(str(len(list_level_tokens)))
+        for i, token in enumerate(list_level_tokens, start=1):
+            token.attrs['data-margin'] = str(i).rjust(margin_width) + '.'
+            token.attrs['data-list-type'] = 'ol'
+
+        # Now render the tokens as normal
+        return self.render_block(
+            tokens,
+            width=width,
+            left=left,
+        )
+
+    def render_table(
+        self,
+        tokens: ta.Sequence['Token'],
+        width: int,
+        left: int = 0,
+        border: type[Border] = SquareBorder,
+    ) -> ptk.StyleAndTextTuples:
+        """
+        Render a list of parsed markdown tokens representing a table element.
+
+        Args:
+            tokens: The list of parsed tokens to render
+            width: The width at which to render the tokens
+            left: The position on the current line at which to render the output - used to indent subsequent lines when
+                rendering inline blocks like images
+            border: The border style to use to render the table
+        Returns:
+            Formatted text
+        """
+
+        ft: ptk.StyleAndTextTuples = []
+
+        # Stack the tokens in the shape of the table
+        cell_tokens: list[list[list[Token]]] = []
+        i = 0
+        while i < len(tokens):
+            token = tokens[i]
+            if token.type == 'tr_open':
+                cell_tokens.append([])
+            elif token.type in ('th_open', 'td_open'):
+                for j, token in enumerate(tokens[i:]):
+                    if token.type in ('th_close', 'td_close'):
+                        cell_tokens[-1].append(list(tokens[i:i + j + 1]))
+                        break
+                i += j
+            i += 1
+
+        def _render_token(
+                tokens: ta.Sequence['Token'],
+                width: int | None = None,
+        ) -> ptk.StyleAndTextTuples:
+            """Render a token with correct alignment."""
+
+            side = 'left'
+
+            # Check CSS for text alignment
+            for style_str in str(tokens[0].attrs.get('style', '')).split(';'):
+                if ':' in style_str:
+                    key, value = style_str.strip().split(':', 1)
+                    if key.strip() == 'text-align':
+                        side = value
+
+            # Render with a very long line length if we do not have a width
+            ft = self.render(tokens, width=width or 999999)
+
+            # If we do have a width, wrap and apply the alignment
+            if width:
+                ft = wrap(ft, width)
+                ft = align(_SIDES[side], ft, width)
+
+            return ft
+
+        # Find the naive widths of each cell
+        cell_renders: list[list[ptk.StyleAndTextTuples]] = []
+        cell_widths: list[list[int]] = []
+        for row in cell_tokens:
+            cell_widths.append([])
+            cell_renders.append([])
+            for each_tokens in row:
+                rendered = _render_token(each_tokens)
+                cell_renders[-1].append(rendered)
+                cell_widths[-1].append(ptk.fragment_list_width(rendered))
+
+        # Calculate row and column widths, accounting for broders
+        col_widths = [
+            max([row[i] for row in cell_widths])
+            for i in range(len(cell_widths[0]))
+        ]
+
+        # Adjust widths and potentially re-render cells. Reduce biggest cells until we fit in width.
+        while sum(col_widths) + 3 * (len(col_widths) - 1) + 4 > width:
+            idxmax = max(enumerate(col_widths), key=lambda x: x[1])[0]
+            col_widths[idxmax] -= 1
+
+        # Re-render changed cells
+        for i, row_widths in enumerate(cell_widths):
+            for j, new_width in enumerate(col_widths):
+                if row_widths[j] != new_width:
+                    cell_renders[i][j] = _render_token(
+                        cell_tokens[i][j],
+                        width=new_width,
+                    )
+
+        # Justify cell contents
+        for i, renders_row in enumerate(cell_renders):
+            for j, cell in enumerate(renders_row):
+                cell_renders[i][j] = align(
+                    FormattedTextAlign.LEFT,
+                    cell,
+                    width=col_widths[j],
+                )
+
+        # Render table
+        style = 'class:md.table.border'
+
+        def _draw_add_border(
+                left: str,
+                split: str,
+                right: str,
+        ) -> None:
+            ft.append((style, left + border.HORIZONTAL))
+
+            for col_width in col_widths:
+                ft.append((style, border.HORIZONTAL * col_width))
+                ft.append((style, border.HORIZONTAL + split + border.HORIZONTAL))
+
+            ft.pop()
+            ft.append((style, border.HORIZONTAL + right + '\n'))
+
+        # Draw top border
+        _draw_add_border(
+            border.TOP_LEFT,
+            border.TOP_SPLIT,
+            border.TOP_RIGHT,
+        )
+
+        # Draw each row
+        for i, renders_row in enumerate(cell_renders):
+            for row_lines in itertools.zip_longest(*map(ptk.split_lines, renders_row)):
+                # Draw each line in each row
+                ft.append((style, border.VERTICAL + ' '))
+
+                for j, line in enumerate(row_lines):
+                    if line is None:
+                        line = [('', ' ' * col_widths[j])]
+                    ft += line
+                    ft.append((style, ' ' + border.VERTICAL + ' '))
+
+                ft.pop()
+                ft.append((style, ' ' + border.VERTICAL + '\n'))
+
+            # Draw border between rows
+            if i < len(cell_renders) - 1:
+                _draw_add_border(
+                    border.LEFT_SPLIT,
+                    border.CROSS,
+                    border.RIGHT_SPLIT,
+                )
+
+        # Draw bottom border
+        _draw_add_border(
+            border.BOTTOM_LEFT,
+            border.BOTTOM_SPLIT,
+            border.BOTTOM_RIGHT,
+        )
+
+        ft.append(('', '\n'))
+        return ft
+
+    def __pt_formatted_text__(self) -> ptk.StyleAndTextTuples:
+        """Formatted text magic method."""
+
+        return self.formatted_text

omdev/ptk/markdown/parser.py

@@ -0,0 +1,42 @@
+import typing as ta
+import warnings
+
+from omlish import lang
+
+
+if ta.TYPE_CHECKING:
+    from markdown_it import MarkdownIt
+
+
+##
+
+
+@lang.cached_function(lock=True)
+def markdown_parser() -> ta.Optional['MarkdownIt']:
+    try:
+        from markdown_it import MarkdownIt
+    except ModuleNotFoundError:
+        warnings.warn('The markdown parser requires `markdown-it-py` to be installed')
+        return None
+
+    parser = (
+        MarkdownIt()
+        .enable('linkify')
+        .enable('table')
+        .enable('strikethrough')
+    )
+
+    try:
+        import mdit_py_plugins  # noqa F401
+    except ModuleNotFoundError:
+        pass
+    else:
+        from mdit_py_plugins.amsmath import amsmath_plugin  # noqa
+        from mdit_py_plugins.dollarmath.index import dollarmath_plugin  # noqa
+        from mdit_py_plugins.texmath.index import texmath_plugin  # noqa
+
+        parser.use(texmath_plugin)
+        parser.use(dollarmath_plugin)
+        parser.use(amsmath_plugin)
+
+    return parser

omdev/ptk/markdown/styles.py

@@ -0,0 +1,29 @@
+import typing as ta
+
+
+##
+
+
+MARKDOWN_STYLE: ta.Sequence[tuple[str, str]] = [
+    ('md.h1', 'bold underline'),
+    ('md.h1.border', 'fg:ansiyellow nounderline'),
+    ('md.h2', 'bold'),
+    ('md.h2.border', 'fg:grey nobold'),
+    ('md.h3', 'bold'),
+    ('md.h4', 'bold italic'),
+    ('md.h5', 'underline'),
+    ('md.h6', 'italic'),
+    ('md.code.inline', 'bg:#333'),
+    ('md.strong', 'bold'),
+    ('md.em', 'italic'),
+    ('md.hr', 'fg:ansired'),
+    ('md.ul.margin', 'fg:ansiyellow'),
+    ('md.ol.margin', 'fg:ansicyan'),
+    ('md.blockquote', 'fg:ansipurple'),
+    ('md.blockquote.margin', 'fg:grey'),
+    ('md.th', 'bold'),
+    ('md.a', 'underline fg:ansibrightblue'),
+    ('md.s', 'strike'),
+    ('md.img', 'bg:cyan fg:black'),
+    ('md.img.border', 'fg:cyan bg:default'),
+]