tdrpa.tdworker 1.2.13.2__py312-none-win_amd64.whl

tdrpa/_tdxlwings/mistune/__init__.py

@@ -0,0 +1,63 @@
+from .markdown import Markdown
+from .block_parser import BlockParser
+from .inline_parser import InlineParser
+from .renderers import AstRenderer, HTMLRenderer
+from .plugins import PLUGINS
+from .util import escape, escape_url, escape_html, unikey
+
+
+def create_markdown(escape=True, hard_wrap=False, renderer=None, plugins=None):
+    """Create a Markdown instance based on the given condition.
+
+    :param escape: Boolean. If using html renderer, escape html.
+    :param hard_wrap: Boolean. Break every new line into ``<br>``.
+    :param renderer: renderer instance or string of ``html`` and ``ast``.
+    :param plugins: List of plugins, string or callable.
+
+    This method is used when you want to re-use a Markdown instance::
+
+        markdown = create_markdown(
+            escape=False,
+            renderer='html',
+            plugins=['url', 'strikethrough', 'footnotes', 'table'],
+        )
+        # re-use markdown function
+        markdown('.... your text ...')
+    """
+    if renderer is None or renderer == 'html':
+        renderer = HTMLRenderer(escape=escape)
+    elif renderer == 'ast':
+        renderer = AstRenderer()
+
+    if plugins:
+        _plugins = []
+        for p in plugins:
+            if isinstance(p, str):
+                _plugins.append(PLUGINS[p])
+            else:
+                _plugins.append(p)
+        plugins = _plugins
+
+    return Markdown(renderer, inline=InlineParser(renderer, hard_wrap=hard_wrap), plugins=plugins)
+
+
+html = create_markdown(
+    escape=False,
+    renderer='html',
+    plugins=['strikethrough', 'footnotes', 'table'],
+)
+
+
+def markdown(text, escape=True, renderer=None, plugins=None):
+    md = create_markdown(escape=escape, renderer=renderer, plugins=plugins)
+    return md(text)
+
+
+__all__ = [
+    'Markdown', 'AstRenderer', 'HTMLRenderer',
+    'BlockParser', 'InlineParser',
+    'escape', 'escape_url', 'escape_html', 'unikey',
+    'html', 'create_markdown', 'markdown'
+]
+
+__version__ = '2.0.2'

tdrpa/_tdxlwings/mistune/block_parser.py

@@ -0,0 +1,366 @@
+import re
+from .scanner import ScannerParser, Matcher
+from .inline_parser import ESCAPE_CHAR, LINK_LABEL
+from .util import unikey
+
+_NEW_LINES = re.compile(r'\r\n|\r')
+_BLANK_LINES = re.compile(r'^ +$', re.M)
+
+_TRIM_4 = re.compile(r'^ {1,4}')
+_EXPAND_TAB = re.compile(r'^( {0,3})\t', flags=re.M)
+_INDENT_CODE_TRIM = re.compile(r'^ {1,4}', flags=re.M)
+_BLOCK_QUOTE_TRIM = re.compile(r'^ {0,1}', flags=re.M)
+_BLOCK_QUOTE_LEADING = re.compile(r'^ *>', flags=re.M)
+_BLOCK_TAGS = {
+    'address', 'article', 'aside', 'base', 'basefont', 'blockquote',
+    'body', 'caption', 'center', 'col', 'colgroup', 'dd', 'details',
+    'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption',
+    'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3',
+    'h4', 'h5', 'h6', 'head', 'header', 'hr', 'html', 'iframe',
+    'legend', 'li', 'link', 'main', 'menu', 'menuitem', 'meta', 'nav',
+    'noframes', 'ol', 'optgroup', 'option', 'p', 'param', 'section',
+    'source', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead',
+    'title', 'tr', 'track', 'ul'
+}
+_BLOCK_HTML_RULE6 = (
+    r'</?(?:' + '|'.join(_BLOCK_TAGS) + r')'
+    r'(?: +|\n|/?>)[\s\S]*?'
+    r'(?:\n{2,}|\n*$)'
+)
+_BLOCK_HTML_RULE7 = (
+    # open tag
+    r'<(?!script|pre|style)([a-z][\w-]*)(?:'
+    r' +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"|'
+    r''' *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?'''
+    r')*? */?>(?=\s*\n)[\s\S]*?(?:\n{2,}|\n*$)|'
+    # close tag
+    r'</(?!script|pre|style)[a-z][\w-]*\s*>(?=\s*\n)[\s\S]*?(?:\n{2,}|\n*$)'
+)
+
+_PARAGRAPH_SPLIT = re.compile(r'\n{2,}')
+_LIST_BULLET = re.compile(r'^ *([\*\+-]|\d+[.)])')
+
+
+class BlockParser(ScannerParser):
+    scanner_cls = Matcher
+
+    NEWLINE = re.compile(r'\n+')
+    DEF_LINK = re.compile(
+        r' {0,3}\[(' + LINK_LABEL + r')\]:(?:[ \t]*\n)?[ \t]*'
+        r'<?([^\s>]+)>?(?:[ \t]*\n)?'
+        r'(?: +["(]([^\n]+)[")])? *\n+'
+    )
+
+    AXT_HEADING = re.compile(
+        r' {0,3}(#{1,6})(?!#+)(?: *\n+|'
+        r'\s+([^\n]*?)(?:\n+|\s+?#+\s*\n+))'
+    )
+    SETEX_HEADING = re.compile(r'([^\n]+)\n *(=|-){2,}[ \t]*\n+')
+    THEMATIC_BREAK = re.compile(
+        r' {0,3}((?:-[ \t]*){3,}|'
+        r'(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})\n+'
+    )
+
+    INDENT_CODE = re.compile(r'(?:\n*)(?:(?: {4}| *\t)[^\n]+\n*)+')
+
+    FENCED_CODE = re.compile(
+        r'( {0,3})(`{3,}|~{3,})([^`\n]*)\n'
+        r'(?:|([\s\S]*?)\n)'
+        r'(?: {0,3}\2[~`]* *\n+|$)'
+    )
+    BLOCK_QUOTE = re.compile(
+        r'(?: {0,3}>[^\n]*\n)+'
+    )
+    LIST_START = re.compile(
+        r'( {0,3})([\*\+-]|\d{1,9}[.)])(?:[ \t]*|[ \t][^\n]+)\n+'
+    )
+
+    BLOCK_HTML = re.compile((
+        r' {0,3}(?:'
+        r'<(script|pre|style)[\s>][\s\S]*?(?:</\1>[^\n]*\n+|$)|'
+        r'<!--(?!-?>)[\s\S]*?-->[^\n]*\n+|'
+        r'<\?[\s\S]*?\?>[^\n]*\n+|'
+        r'<![A-Z][\s\S]*?>[^\n]*\n+|'
+        r'<!\[CDATA\[[\s\S]*?\]\]>[^\n]*\n+'
+        r'|' + _BLOCK_HTML_RULE6 + '|' + _BLOCK_HTML_RULE7 + ')'
+    ), re.I)
+
+    LIST_MAX_DEPTH = 6
+    BLOCK_QUOTE_MAX_DEPTH = 6
+    RULE_NAMES = (
+        'newline', 'thematic_break',
+        'fenced_code', 'indent_code',
+        'block_quote', 'block_html',
+        'list_start',
+        'axt_heading', 'setex_heading',
+        'def_link',
+    )
+
+    def __init__(self):
+        super(BlockParser, self).__init__()
+        self.block_quote_rules = list(self.RULE_NAMES)
+        self.list_rules = list(self.RULE_NAMES)
+
+    def parse_newline(self, m, state):
+        return {'type': 'newline', 'blank': True}
+
+    def parse_thematic_break(self, m, state):
+        return {'type': 'thematic_break', 'blank': True}
+
+    def parse_indent_code(self, m, state):
+        text = expand_leading_tab(m.group(0))
+        code = _INDENT_CODE_TRIM.sub('', text)
+        code = code.lstrip('\n')
+        return self.tokenize_block_code(code, None, state)
+
+    def parse_fenced_code(self, m, state):
+        info = ESCAPE_CHAR.sub(r'\1', m.group(3))
+        spaces = m.group(1)
+        code = m.group(4) or ''
+        if spaces and code:
+            _trim_pattern = re.compile('^' + spaces, re.M)
+            code = _trim_pattern.sub('', code)
+        return self.tokenize_block_code(code + '\n', info, state)
+
+    def tokenize_block_code(self, code, info, state):
+        token = {'type': 'block_code', 'raw': code}
+        if info:
+            token['params'] = (info, )
+        return token
+
+    def parse_axt_heading(self, m, state):
+        level = len(m.group(1))
+        text = m.group(2) or ''
+        text = text.strip()
+        if set(text) == {'#'}:
+            text = ''
+        return self.tokenize_heading(text, level, state)
+
+    def parse_setex_heading(self, m, state):
+        level = 1 if m.group(2) == '=' else 2
+        text = m.group(1)
+        text = text.strip()
+        return self.tokenize_heading(text, level, state)
+
+    def tokenize_heading(self, text, level, state):
+        return {'type': 'heading', 'text': text, 'params': (level,)}
+
+    def get_block_quote_rules(self, depth):
+        if depth > self.BLOCK_QUOTE_MAX_DEPTH - 1:
+            rules = list(self.block_quote_rules)
+            rules.remove('block_quote')
+            return rules
+        return self.block_quote_rules
+
+    def parse_block_quote(self, m, state):
+        depth = state.get('block_quote_depth', 0) + 1
+        state['block_quote_depth'] = depth
+
+        # normalize block quote text
+        text = _BLOCK_QUOTE_LEADING.sub('', m.group(0))
+        text = expand_leading_tab(text)
+        text = _BLOCK_QUOTE_TRIM.sub('', text)
+        text = cleanup_lines(text)
+
+        rules = self.get_block_quote_rules(depth)
+        children = self.parse(text, state, rules)
+        state['block_quote_depth'] = depth - 1
+        return {'type': 'block_quote', 'children': children}
+
+    def get_list_rules(self, depth):
+        if depth > self.LIST_MAX_DEPTH - 1:
+            rules = list(self.list_rules)
+            rules.remove('list_start')
+            return rules
+        return self.list_rules
+
+    def parse_list_start(self, m, state, string):
+        items = []
+        spaces = m.group(1)
+        marker = m.group(2)
+        items, pos = _find_list_items(string, m.start(), spaces, marker)
+        tight = '\n\n' not in ''.join(items).strip()
+
+        ordered = len(marker) != 1
+        if ordered:
+            start = int(marker[:-1])
+            if start == 1:
+                start = None
+        else:
+            start = None
+
+        list_tights = state.get('list_tights', [])
+        list_tights.append(tight)
+        state['list_tights'] = list_tights
+
+        depth = len(list_tights)
+        rules = self.get_list_rules(depth)
+        children = [
+            self.parse_list_item(item, depth, state, rules)
+            for item in items
+        ]
+        list_tights.pop()
+        params = (ordered, depth, start)
+        token = {'type': 'list', 'children': children, 'params': params}
+        return token, pos
+
+    def parse_list_item(self, text, depth, state, rules):
+        text = self.normalize_list_item_text(text)
+        if not text:
+            children = [{'type': 'block_text', 'text': ''}]
+        else:
+            children = self.parse(text, state, rules)
+        return {
+            'type': 'list_item',
+            'params': (depth,),
+            'children': children,
+        }
+
+    @staticmethod
+    def normalize_list_item_text(text):
+        text_length = len(text)
+        text = _LIST_BULLET.sub('', text)
+
+        if not text.strip():
+            return ''
+
+        space = text_length - len(text)
+        text = expand_leading_tab(text)
+        if text.startswith('     '):
+            text = text[1:]
+            space += 1
+        else:
+            text_length = len(text)
+            text = _TRIM_4.sub('', text)
+            space += max(text_length - len(text), 1)
+
+        # outdent
+        if '\n ' in text:
+            pattern = re.compile(r'\n {1,' + str(space) + r'}')
+            text = pattern.sub(r'\n', text)
+        return text
+
+    def parse_block_html(self, m, state):
+        html = m.group(0).rstrip()
+        return {'type': 'block_html', 'raw': html}
+
+    def parse_def_link(self, m, state):
+        key = unikey(m.group(1))
+        link = m.group(2)
+        title = m.group(3)
+        if key not in state['def_links']:
+            state['def_links'][key] = (link, title)
+
+    def parse_text(self, text, state):
+        list_tights = state.get('list_tights')
+        if list_tights and list_tights[-1]:
+            return {'type': 'block_text', 'text': text.strip()}
+
+        tokens = []
+        for s in _PARAGRAPH_SPLIT.split(text):
+            s = s.strip()
+            if s:
+                tokens.append({'type': 'paragraph', 'text': s})
+        return tokens
+
+    def parse(self, s, state, rules=None):
+        if rules is None:
+            rules = self.rules
+
+        return list(self._scan(s, state, rules))
+
+    def render(self, tokens, inline, state):
+        data = self._iter_render(tokens, inline, state)
+        return inline.renderer.finalize(data)
+
+    def _iter_render(self, tokens, inline, state):
+        for tok in tokens:
+            method = inline.renderer._get_method(tok['type'])
+            if 'blank' in tok:
+                yield method()
+                continue
+
+            if 'children' in tok:
+                children = self.render(tok['children'], inline, state)
+            elif 'raw' in tok:
+                children = tok['raw']
+            else:
+                children = inline(tok['text'], state)
+            params = tok.get('params')
+            if params:
+                yield method(children, *params)
+            else:
+                yield method(children)
+
+
+def cleanup_lines(s):
+    s = _NEW_LINES.sub('\n', s)
+    s = _BLANK_LINES.sub('', s)
+    return s
+
+
+def expand_leading_tab(text):
+    return _EXPAND_TAB.sub(_expand_tab_repl, text)
+
+
+def _expand_tab_repl(m):
+    s = m.group(1)
+    return s + ' ' * (4 - len(s))
+
+
+def _create_list_item_pattern(spaces, marker):
+    prefix = r'( {0,' + str(len(spaces) + len(marker)) + r'})'
+
+    if len(marker) > 1:
+        if marker[-1] == '.':
+            prefix = prefix + r'\d{0,9}\.'
+        else:
+            prefix = prefix + r'\d{0,9}\)'
+    else:
+        if marker == '*':
+            prefix = prefix + r'\*'
+        elif marker == '+':
+            prefix = prefix + r'\+'
+        else:
+            prefix = prefix + r'-'
+
+    s1 = ' {' + str(len(marker) + 1) + ',}'
+    if len(marker) > 4:
+        s2 = ' {' + str(len(marker) - 4) + r',}\t'
+    else:
+        s2 = r' *\t'
+    return re.compile(
+        prefix + r'(?:[ \t]*|[ \t]+[^\n]+)\n+'
+        r'(?:\1(?:' + s1 + '|' + s2 + ')'
+        r'[^\n]+\n+)*'
+    )
+
+
+def _find_list_items(string, pos, spaces, marker):
+    items = []
+
+    if marker in {'*', '-'}:
+        is_hr = re.compile(
+            r' *((?:-[ \t]*){3,}|(?:\*[ \t]*){3,})\n+'
+        )
+    else:
+        is_hr = None
+
+    pattern = _create_list_item_pattern(spaces, marker)
+    while 1:
+        m = pattern.match(string, pos)
+        if not m:
+            break
+
+        text = m.group(0)
+        if is_hr and is_hr.match(text):
+            break
+
+        new_spaces = m.group(1)
+        if new_spaces != spaces:
+            spaces = new_spaces
+            pattern = _create_list_item_pattern(spaces, marker)
+
+        items.append(text)
+        pos = m.end()
+    return items, pos

tdrpa/_tdxlwings/mistune/inline_parser.py

@@ -0,0 +1,216 @@
+import re
+from .scanner import ScannerParser
+from .util import PUNCTUATION, ESCAPE_TEXT, escape_url, unikey
+
+HTML_TAGNAME = r'[A-Za-z][A-Za-z0-9-]*'
+HTML_ATTRIBUTES = (
+    r'(?:\s+[A-Za-z_:][A-Za-z0-9_.:-]*'
+    r'(?:\s*=\s*(?:[^ "\'=<>`]+|\'[^\']*?\'|"[^\"]*?"))?)*'
+)
+ESCAPE_CHAR = re.compile(r'\\([' + PUNCTUATION + r'])')
+LINK_TEXT = r'(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?'
+LINK_LABEL = r'(?:[^\\\[\]]|' + ESCAPE_TEXT + r'){0,1000}'
+
+
+class InlineParser(ScannerParser):
+    ESCAPE = ESCAPE_TEXT
+
+    #: link or email syntax::
+    #:
+    #: <https://example.com>
+    AUTO_LINK = (
+        r'(?<!\\)(?:\\\\)*<([A-Za-z][A-Za-z0-9+.-]{1,31}:'
+        r"[^ <>]*?|[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Za-z0-9]"
+        r'(?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?'
+        r'(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*)>'
+    )
+
+    #: link or image syntax::
+    #:
+    #: [text](/link "title")
+    #: ![alt](/src "title")
+    STD_LINK = (
+        r'!?\[(' + LINK_TEXT + r')\]\(\s*'
+
+        r'(<(?:\\[<>]?|[^\s<>\\])*>|'
+        r'(?:\\[()]?|\([^\s\x00-\x1f\\]*\)|[^\s\x00-\x1f()\\])*?)'
+
+        r'(?:\s+('
+        r'''"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)'''
+        r'))?\s*\)'
+    )
+
+    #: Get link from references. References are defined in DEF_LINK in blocks.
+    #: The syntax looks like::
+    #:
+    #:    [an example][id]
+    #:
+    #:    [id]: https://example.com "optional title"
+    REF_LINK = (
+        r'!?\[(' + LINK_TEXT + r')\]'
+        r'\[(' + LINK_LABEL + r')\]'
+    )
+
+    #: Simple form of reference link::
+    #:
+    #:    [an example]
+    #:
+    #:    [an example]: https://example.com "optional title"
+    REF_LINK2 = r'!?\[(' + LINK_LABEL + r')\]'
+
+    #: emphasis and strong * or _::
+    #:
+    #:    *emphasis*  **strong**
+    #:    _emphasis_  __strong__
+    ASTERISK_EMPHASIS = (
+        r'(\*{1,2})(?=[^\s*])('
+        r'(?:\\[\\*]|[^*])*'
+        r'(?:' + ESCAPE_TEXT + r'|[^\s*]))\1'
+    )
+    UNDERSCORE_EMPHASIS = (
+        r'\b(_{1,2})(?=[^\s_])([\s\S]*?'
+        r'(?:' + ESCAPE_TEXT + r'|[^\s_]))\1'
+        r'(?!_|[^\s' + PUNCTUATION + r'])\b'
+    )
+
+    #: codespan with `::
+    #:
+    #:    `code`
+    CODESPAN = (
+        r'(?<!\\|`)(?:\\\\)*(`+)(?!`)([\s\S]+?)(?<!`)\1(?!`)'
+    )
+
+    #: linebreak leaves two spaces at the end of line
+    LINEBREAK = r'(?:\\| {2,})\n(?!\s*$)'
+
+    INLINE_HTML = (
+        r'(?<!\\)<' + HTML_TAGNAME + HTML_ATTRIBUTES + r'\s*/?>|'  # open tag
+        r'(?<!\\)</' + HTML_TAGNAME + r'\s*>|'  # close tag
+        r'(?<!\\)<!--(?!>|->)(?:(?!--)[\s\S])+?(?<!-)-->|'  # comment
+        r'(?<!\\)<\?[\s\S]+?\?>|'
+        r'(?<!\\)<![A-Z][\s\S]+?>|'  # doctype
+        r'(?<!\\)<!\[CDATA[\s\S]+?\]\]>'  # cdata
+    )
+
+    RULE_NAMES = (
+        'escape', 'inline_html', 'auto_link',
+        'std_link', 'ref_link', 'ref_link2',
+        'asterisk_emphasis', 'underscore_emphasis',
+        'codespan', 'linebreak',
+    )
+
+    def __init__(self, renderer, hard_wrap=False):
+        super(InlineParser, self).__init__()
+        if hard_wrap:
+            #: every new line becomes <br>
+            self.LINEBREAK = r' *\n(?!\s*$)'
+        self.renderer = renderer
+        rules = list(self.RULE_NAMES)
+        rules.remove('ref_link')
+        rules.remove('ref_link2')
+        self.ref_link_rules = rules
+
+    def parse_escape(self, m, state):
+        text = m.group(0)[1:]
+        return 'text', text
+
+    def parse_auto_link(self, m, state):
+        if state.get('_in_link'):
+            return 'text', m.group(0)
+
+        text = m.group(1)
+        schemes = ('mailto:', 'http://', 'https://')
+        if '@' in text and not text.lower().startswith(schemes):
+            link = 'mailto:' + text
+        else:
+            link = text
+        return 'link', escape_url(link), text
+
+    def parse_std_link(self, m, state):
+        line = m.group(0)
+        text = m.group(1)
+        link = ESCAPE_CHAR.sub(r'\1', m.group(2))
+        if link.startswith('<') and link.endswith('>'):
+            link = link[1:-1]
+
+        title = m.group(3)
+        if title:
+            title = ESCAPE_CHAR.sub(r'\1', title[1:-1])
+
+        if line[0] == '!':
+            return 'image', escape_url(link), text, title
+
+        return self.tokenize_link(line, link, text, title, state)
+
+    def parse_ref_link(self, m, state):
+        line = m.group(0)
+        text = m.group(1)
+        key = unikey(m.group(2) or text)
+        def_links = state.get('def_links')
+        if not def_links or key not in def_links:
+            return list(self._scan(line, state, self.ref_link_rules))
+
+        link, title = def_links.get(key)
+        link = ESCAPE_CHAR.sub(r'\1', link)
+        if title:
+            title = ESCAPE_CHAR.sub(r'\1', title)
+
+        if line[0] == '!':
+            return 'image', escape_url(link), text, title
+
+        return self.tokenize_link(line, link, text, title, state)
+
+    def parse_ref_link2(self, m, state):
+        return self.parse_ref_link(m, state)
+
+    def tokenize_link(self, line, link, text, title, state):
+        if state.get('_in_link'):
+            return 'text', line
+        state['_in_link'] = True
+        text = self.render(text, state)
+        state['_in_link'] = False
+        return 'link', escape_url(link), text, title
+
+    def parse_asterisk_emphasis(self, m, state):
+        return self.tokenize_emphasis(m, state)
+
+    def parse_underscore_emphasis(self, m, state):
+        return self.tokenize_emphasis(m, state)
+
+    def tokenize_emphasis(self, m, state):
+        marker = m.group(1)
+        text = m.group(2)
+        if len(marker) == 1:
+            return 'emphasis', self.render(text, state)
+        return 'strong', self.render(text, state)
+
+    def parse_codespan(self, m, state):
+        code = re.sub(r'[ \n]+', ' ', m.group(2).strip())
+        return 'codespan', code
+
+    def parse_linebreak(self, m, state):
+        return 'linebreak',
+
+    def parse_inline_html(self, m, state):
+        html = m.group(0)
+        return 'inline_html', html
+
+    def parse_text(self, text, state):
+        return 'text', text
+
+    def parse(self, s, state, rules=None):
+        if rules is None:
+            rules = self.rules
+
+        tokens = (
+            self.renderer._get_method(t[0])(*t[1:])
+            for t in self._scan(s, state, rules)
+        )
+        return tokens
+
+    def render(self, s, state, rules=None):
+        tokens = self.parse(s, state, rules)
+        return self.renderer.finalize(tokens)
+
+    def __call__(self, s, state):
+        return self.render(s, state)