tdrpa.tdworker 1.2.13.2__py312-none-win_amd64.whl

tdrpa/_tdxlwings/mistune/markdown.py

@@ -0,0 +1,84 @@
+from .block_parser import BlockParser, expand_leading_tab, cleanup_lines
+from .inline_parser import InlineParser
+
+
+class Markdown(object):
+    def __init__(self, renderer, block=None, inline=None, plugins=None):
+        if block is None:
+            block = BlockParser()
+
+        if inline is None:
+            inline = InlineParser(renderer)
+
+        self.block = block
+        self.inline = inline
+        self.renderer = inline.renderer
+        self.before_parse_hooks = []
+        self.before_render_hooks = []
+        self.after_render_hooks = []
+
+        if plugins:
+            for plugin in plugins:
+                plugin(self)
+
+    def use(self, plugin):
+        plugin(self)
+
+    def before_parse(self, s, state):
+        s, state = preprocess(s, state)
+        for hook in self.before_parse_hooks:
+            s, state = hook(self, s, state)
+        return s, state
+
+    def before_render(self, tokens, state):
+        for hook in self.before_render_hooks:
+            tokens = hook(self, tokens, state)
+        return tokens
+
+    def after_render(self, result, state):
+        for hook in self.after_render_hooks:
+            result = hook(self, result, state)
+        return result
+
+    def parse(self, s, state=None):
+        if state is None:
+            state = {}
+
+        s, state = self.before_parse(s, state)
+        tokens = self.block.parse(s, state)
+        tokens = self.before_render(tokens, state)
+        result = self.block.render(tokens, self.inline, state)
+        result = self.after_render(result, state)
+        return result
+
+    def read(self, filepath, state=None):
+        if state is None:
+            state = {}
+
+        state['__file__'] = filepath
+        with open(filepath, 'rb') as f:
+            s = f.read()
+
+        return self.parse(s.decode('utf-8'), state)
+
+    def __call__(self, s):
+        return self.parse(s)
+
+
+def preprocess(s, state):
+    state.update({
+        'def_links': {},
+        'def_footnotes': {},
+        'footnotes': [],
+    })
+
+    if s is None:
+        s = '\n'
+    else:
+        s = s.replace('\u2424', '\n')
+        s = cleanup_lines(s)
+        s = expand_leading_tab(s)
+        if not s.endswith('\n'):
+            s += '\n'
+
+    return s, state

tdrpa/_tdxlwings/mistune/renderers.py

@@ -0,0 +1,220 @@
+from .util import escape, escape_html
+
+
+class BaseRenderer(object):
+    NAME = 'base'
+
+    def __init__(self):
+        self._methods = {}
+
+    def register(self, name, method):
+        self._methods[name] = method
+
+    def _get_method(self, name):
+        try:
+            return object.__getattribute__(self, name)
+        except AttributeError:
+            method = self._methods.get(name)
+            if not method:
+                raise AttributeError('No renderer "{!r}"'.format(name))
+            return method
+
+    def finalize(self, data):
+        raise NotImplementedError(
+            'The renderer needs to implement the finalize method.')
+
+
+class AstRenderer(BaseRenderer):
+    NAME = 'ast'
+
+    def text(self, text):
+        return {'type': 'text', 'text': text}
+
+    def link(self, link, children=None, title=None):
+        if isinstance(children, str):
+            children = [{'type': 'text', 'text': children}]
+        return {
+            'type': 'link',
+            'link': link,
+            'children': children,
+            'title': title,
+        }
+
+    def image(self, src, alt="", title=None):
+        return {'type': 'image', 'src': src, 'alt': alt, 'title': title}
+
+    def codespan(self, text):
+        return {'type': 'codespan', 'text': text}
+
+    def linebreak(self):
+        return {'type': 'linebreak'}
+
+    def inline_html(self, html):
+        return {'type': 'inline_html', 'text': html}
+
+    def heading(self, children, level):
+        return {'type': 'heading', 'children': children, 'level': level}
+
+    def newline(self):
+        return {'type': 'newline'}
+
+    def thematic_break(self):
+        return {'type': 'thematic_break'}
+
+    def block_code(self, children, info=None):
+        return {
+            'type': 'block_code',
+            'text': children,
+            'info': info
+        }
+
+    def block_html(self, children):
+        return {'type': 'block_html', 'text': children}
+
+    def list(self, children, ordered, level, start=None):
+        token = {
+            'type': 'list',
+            'children': children,
+            'ordered': ordered,
+            'level': level,
+        }
+        if start is not None:
+            token['start'] = start
+        return token
+
+    def list_item(self, children, level):
+        return {'type': 'list_item', 'children': children, 'level': level}
+
+    def _create_default_method(self, name):
+        def __ast(children):
+            return {'type': name, 'children': children}
+        return __ast
+
+    def _get_method(self, name):
+        try:
+            return super(AstRenderer, self)._get_method(name)
+        except AttributeError:
+            return self._create_default_method(name)
+
+    def finalize(self, data):
+        return list(data)
+
+
+class HTMLRenderer(BaseRenderer):
+    NAME = 'html'
+    HARMFUL_PROTOCOLS = {
+        'javascript:',
+        'vbscript:',
+        'data:',
+    }
+
+    def __init__(self, escape=True, allow_harmful_protocols=None):
+        super(HTMLRenderer, self).__init__()
+        self._escape = escape
+        self._allow_harmful_protocols = allow_harmful_protocols
+
+    def _safe_url(self, url):
+        if self._allow_harmful_protocols is None:
+            schemes = self.HARMFUL_PROTOCOLS
+        elif self._allow_harmful_protocols is True:
+            schemes = None
+        else:
+            allowed = set(self._allow_harmful_protocols)
+            schemes = self.HARMFUL_PROTOCOLS - allowed
+
+        if schemes:
+            for s in schemes:
+                if url.lower().startswith(s):
+                    url = '#harmful-link'
+                    break
+        return url
+
+    def text(self, text):
+        if self._escape:
+            return escape(text)
+        return escape_html(text)
+
+    def link(self, link, text=None, title=None):
+        if text is None:
+            text = link
+
+        s = '<a href="' + self._safe_url(link) + '"'
+        if title:
+            s += ' title="' + escape_html(title) + '"'
+        return s + '>' + (text or link) + '</a>'
+
+    def image(self, src, alt="", title=None):
+        src = self._safe_url(src)
+        alt = escape_html(alt)
+        s = '<img src="' + src + '" alt="' + alt + '"'
+        if title:
+            s += ' title="' + escape_html(title) + '"'
+        return s + ' />'
+
+    def emphasis(self, text):
+        return '<em>' + text + '</em>'
+
+    def strong(self, text):
+        return '<strong>' + text + '</strong>'
+
+    def codespan(self, text):
+        return '<code>' + escape(text) + '</code>'
+
+    def linebreak(self):
+        return '<br />\n'
+
+    def inline_html(self, html):
+        if self._escape:
+            return escape(html)
+        return html
+
+    def paragraph(self, text):
+        return '<p>' + text + '</p>\n'
+
+    def heading(self, text, level):
+        tag = 'h' + str(level)
+        return '<' + tag + '>' + text + '</' + tag + '>\n'
+
+    def newline(self):
+        return ''
+
+    def thematic_break(self):
+        return '<hr />\n'
+
+    def block_text(self, text):
+        return text
+
+    def block_code(self, code, info=None):
+        html = '<pre><code'
+        if info is not None:
+            info = info.strip()
+        if info:
+            lang = info.split(None, 1)[0]
+            lang = escape_html(lang)
+            html += ' class="language-' + lang + '"'
+        return html + '>' + escape(code) + '</code></pre>\n'
+
+    def block_quote(self, text):
+        return '<blockquote>\n' + text + '</blockquote>\n'
+
+    def block_html(self, html):
+        if not self._escape:
+            return html + '\n'
+        return '<p>' + escape(html) + '</p>\n'
+
+    def block_error(self, html):
+        return '<div class="error">' + html + '</div>\n'
+
+    def list(self, text, ordered, level, start=None):
+        if ordered:
+            html = '<ol'
+            if start is not None:
+                html += ' start="' + str(start) + '"'
+            return html + '>\n' + text + '</ol>\n'
+        return '<ul>\n' + text + '</ul>\n'
+
+    def list_item(self, text, level):
+        return '<li>' + text + '</li>\n'
+
+    def finalize(self, data):
+        return ''.join(data)

tdrpa/_tdxlwings/mistune/scanner.py

@@ -0,0 +1,121 @@
+import re
+
+class Scanner(re.Scanner):
+    def iter(self, string, state, parse_text):
+        sc = self.scanner.scanner(string)
+
+        pos = 0
+        for match in iter(sc.search, None):
+            name, method = self.lexicon[match.lastindex - 1][1]
+            hole = string[pos:match.start()]
+            if hole:
+                yield parse_text(hole, state)
+
+            yield method(match, state)
+            pos = match.end()
+
+        hole = string[pos:]
+        if hole:
+            yield parse_text(hole, state)
+
+
+class ScannerParser(object):
+    scanner_cls = Scanner
+    RULE_NAMES = tuple()
+
+    def __init__(self):
+        self.rules = list(self.RULE_NAMES)
+        self.rule_methods = {}
+        self._cached_sc = {}
+
+    def register_rule(self, name, pattern, method):
+        self.rule_methods[name] = (pattern, lambda m, state: method(self, m, state))
+
+    def get_rule_pattern(self, name):
+        if name not in self.RULE_NAMES:
+            return self.rule_methods[name][0]
+        return getattr(self, name.upper())
+
+    def get_rule_method(self, name):
+        if name not in self.RULE_NAMES:
+            return self.rule_methods[name][1]
+        return getattr(self, 'parse_' + name)
+
+    def parse_text(self, text, state):
+        raise NotImplementedError
+
+    def _scan(self, s, state, rules):
+        sc = self._create_scanner(rules)
+        for tok in sc.iter(s, state, self.parse_text):
+            if isinstance(tok, list):
+                for t in tok:
+                    yield t
+            elif tok:
+                yield tok
+
+    def _create_scanner(self, rules):
+        sc_key = '|'.join(rules)
+        sc = self._cached_sc.get(sc_key)
+        if sc:
+            return sc
+
+        lexicon = [
+            (self.get_rule_pattern(n), (n, self.get_rule_method(n)))
+            for n in rules
+        ]
+        sc = self.scanner_cls(lexicon)
+        self._cached_sc[sc_key] = sc
+        return sc
+
+
+class Matcher(object):
+    PARAGRAPH_END = re.compile(
+        r'(?:\n{2,})|'
+        r'(?:\n {0,3}#{1,6})|'  # axt heading
+        r'(?:\n {0,3}(?:`{3,}|~{3,}))|'  # fenced code
+        r'(?:\n {0,3}>)|'  # blockquote
+        r'(?:\n {0,3}(?:[\*\+-]|1[.)]))|'  # list
+        r'(?:\n {0,3}<)'  # block html
+    )
+
+    def __init__(self, lexicon):
+        self.lexicon = lexicon
+
+    def search_pos(self, string, pos):
+        m = self.PARAGRAPH_END.search(string, pos)
+        if not m:
+            return None
+        if set(m.group(0)) == {'\n'}:
+            return m.end()
+        return m.start() + 1
+
+    def iter(self, string, state, parse_text):
+        pos = 0
+        endpos = len(string)
+        last_end = 0
+        while 1:
+            if pos >= endpos:
+                break
+            for rule, (name, method) in self.lexicon:
+                match = rule.match(string, pos)
+                if match is not None:
+                    start, end = match.span()
+                    if start > last_end:
+                        yield parse_text(string[last_end:start], state)
+
+                    if name.endswith('_start'):
+                        token = method(match, state, string)
+                        yield token[0]
+                        end = token[1]
+                    else:
+                        yield method(match, state)
+                    last_end = pos = end
+                    break
+            else:
+                found = self.search_pos(string, pos)
+                if found is None:
+                    break
+                pos = found
+
+        if last_end < endpos:
+            yield parse_text(string[last_end:], state)

tdrpa/_tdxlwings/mistune/util.py

@@ -0,0 +1,41 @@
+try:
+    from urllib.parse import quote
+    import html
+except ImportError:
+    from urllib import quote
+    html = None
+
+
+PUNCTUATION = r'''\\!"#$%&'()*+,./:;<=>?@\[\]^`{}|_~-'''
+ESCAPE_TEXT = r'\\[' + PUNCTUATION + ']'
+
+
+def escape(s, quote=True):
+    s = s.replace("&", "&amp;")
+    s = s.replace("<", "&lt;")
+    s = s.replace(">", "&gt;")
+    if quote:
+        s = s.replace('"', "&quot;")
+    return s
+
+
+def escape_url(link):
+    safe = (
+        ':/?#@'           # gen-delims - '[]' (rfc3986)
+        '!$&()*+,;='      # sub-delims - "'" (rfc3986)
+        '%'               # leave already-encoded octets alone
+    )
+
+    if html is None:
+        return quote(link.encode('utf-8'), safe=safe)
+    return html.escape(quote(html.unescape(link), safe=safe))
+
+
+def escape_html(s):
+    if html is not None:
+        return html.escape(html.unescape(s)).replace('&#x27;', "'")
+    return escape(s)
+
+
+def unikey(s):
+    return ' '.join(s.split()).lower()

tdrpa/_tdxlwings/pro/__init__.py

@@ -0,0 +1,40 @@
+"""
+Required Notice: Copyright (C) Zoomer Analytics GmbH.
+
+xlwings PRO is dual-licensed under one of the following licenses:
+
+* PolyForm Noncommercial License 1.0.0 (for noncommercial use):
+  https://polyformproject.org/licenses/noncommercial/1.0.0
+* xlwings PRO License (for commercial use):
+  https://github.com/xlwings/xlwings/blob/main/LICENSE_PRO.txt
+
+Commercial licenses can be purchased at https://www.xlwings.org
+"""
+
+from .embedded_code import dump_embedded_code, runpython_embedded_code
+from .reports import Markdown, MarkdownStyle
+from .udfs_officejs import (
+    custom_functions_call,
+    custom_functions_code,
+    custom_functions_meta,
+    xlarg as arg,
+    xlfunc as func,
+    xlret as ret,
+)
+from .utils import LicenseHandler
+
+__all__ = (
+    "dump_embedded_code",
+    "runpython_embedded_code",
+    "verify_execute_permission",
+    "Markdown",
+    "MarkdownStyle",
+    "arg",
+    "func",
+    "ret",
+    "custom_functions_code",
+    "custom_functions_meta",
+    "custom_functions_call",
+)
+
+LicenseHandler.validate_license("pro")