tables

Tables Extension for Python-Markdown.

Added parsing of tables to Python-Markdown.

See https://pythonhosted.org/Markdown/extensions/tables.html for documentation.

Original code Copyright 2009 Waylan Limberg

All changes Copyright 2008-2014 The Python Markdown Project

License: BSD

Classes

TableProcessor(parser)

Bases: BlockProcessor

Process Tables.

Source code in pyrevitlib/pyrevit/coreutils/markdown/extensions/tables.py

def __init__(self, parser):
    self.border = False
    self.separator = ""
    super(TableProcessor, self).__init__(parser)

Attributes

RE_CODE_PIPES = re.compile('(?:(\\\\\\\\)|(\\\\`+)|(`+)|(\\\\\\|)|(\\|))') class-attribute instance-attribute

RE_END_BORDER = re.compile('(?<!\\\\)(?:\\\\\\\\)*\\|$') class-attribute instance-attribute

border = False instance-attribute

separator = '' instance-attribute

parser = parser instance-attribute

tab_length = parser.markdown.tab_length instance-attribute

Methods:

test(parent, block)

Ensure first two rows (column header and separator row) are valid table rows.

Keep border check and separator row do avoid repeating the work.

Source code in pyrevitlib/pyrevit/coreutils/markdown/extensions/tables.py

def test(self, parent, block):
    """Ensure first two rows (column header and separator row) are valid table rows.

    Keep border check and separator row do avoid repeating the work.
    """
    is_table = False
    header = [row.strip() for row in block.split("\n")[0:2]]
    if len(header) == 2:
        self.border = header[0].startswith("|")
        row = self._split_row(header[0])
        is_table = len(row) > 1

        if is_table:
            row = self._split_row(header[1])
            is_table = len(row) > 1 and set("".join(row)) <= set("|:- ")
            if is_table:
                self.separator = row
    return is_table

run(parent, blocks)

Parse a table block and build table.

Source code in pyrevitlib/pyrevit/coreutils/markdown/extensions/tables.py

def run(self, parent, blocks):
    """Parse a table block and build table."""
    block = blocks.pop(0).split("\n")
    header = block[0].strip()
    rows = [] if len(block) < 3 else block[2:]

    # Get alignment of columns
    align = []
    for c in self.separator:
        c = c.strip()
        if c.startswith(":") and c.endswith(":"):
            align.append("center")
        elif c.startswith(":"):
            align.append("left")
        elif c.endswith(":"):
            align.append("right")
        else:
            align.append(None)

    # Build table
    table = etree.SubElement(parent, "table")
    thead = etree.SubElement(table, "thead")
    self._build_row(header, thead, align)
    tbody = etree.SubElement(table, "tbody")
    for row in rows:
        self._build_row(row.strip(), tbody, align)

lastChild(parent)

Return the last child of an etree element.

Source code in pyrevitlib/pyrevit/coreutils/markdown/blockprocessors.py

def lastChild(self, parent):
    """Return the last child of an etree element."""
    if len(parent):
        return parent[-1]
    else:
        return None

detab(text)

Remove a tab from the front of each line of the given text.

Source code in pyrevitlib/pyrevit/coreutils/markdown/blockprocessors.py

def detab(self, text):
    """Remove a tab from the front of each line of the given text."""
    newtext = []
    lines = text.split("\n")
    for line in lines:
        if line.startswith(" " * self.tab_length):
            newtext.append(line[self.tab_length :])
        elif not line.strip():
            newtext.append("")
        else:
            break
    return "\n".join(newtext), "\n".join(lines[len(newtext) :])

looseDetab(text, level=1)

Remove a tab from front of lines but allowing dedented lines.

Source code in pyrevitlib/pyrevit/coreutils/markdown/blockprocessors.py

def looseDetab(self, text, level=1):
    """Remove a tab from front of lines but allowing dedented lines."""
    lines = text.split("\n")
    for i in range(len(lines)):
        if lines[i].startswith(" " * self.tab_length * level):
            lines[i] = lines[i][self.tab_length * level :]
    return "\n".join(lines)

TableExtension(*args, **kwargs)

Bases: Extension

Add tables to Markdown.

Initiate Extension and set up configs.

Source code in pyrevitlib/pyrevit/coreutils/markdown/extensions/__init__.py

def __init__(self, *args, **kwargs):
    """Initiate Extension and set up configs."""
    # check for configs arg for backward compat.
    # (there only ever used to be one so we use arg[0])
    if len(args):
        if args[0] is not None:
            self.setConfigs(args[0])
        warnings.warn(
            "Extension classes accepting positional args is "
            "pending Deprecation. Each setting should be "
            "passed into the Class as a keyword. Positional "
            "args are deprecated and will raise "
            "an error in version 2.7. See the Release Notes for "
            "Python-Markdown version 2.6 for more info.",
            DeprecationWarning,
        )
    # check for configs kwarg for backward compat.
    if "configs" in kwargs.keys():
        if kwargs["configs"] is not None:
            self.setConfigs(kwargs.pop("configs", {}))
        warnings.warn(
            "Extension classes accepting a dict on the single "
            'keyword "config" is pending Deprecation. Each '
            "setting should be passed into the Class as a "
            'keyword directly. The "config" keyword is '
            "deprecated and raise an error in "
            "version 2.7. See the Release Notes for "
            "Python-Markdown version 2.6 for more info.",
            DeprecationWarning,
        )
    # finally, use kwargs
    self.setConfigs(kwargs)

Attributes

config = {} class-attribute instance-attribute

Methods:

extendMarkdown(md, md_globals)

Add an instance of TableProcessor to BlockParser.

Source code in pyrevitlib/pyrevit/coreutils/markdown/extensions/tables.py

def extendMarkdown(self, md, md_globals):
    """Add an instance of TableProcessor to BlockParser."""
    if "|" not in md.ESCAPED_CHARS:
        md.ESCAPED_CHARS.append("|")
    md.parser.blockprocessors.add("table", TableProcessor(md.parser), "<hashheader")

getConfig(key, default='')

Return a setting for the given key or an empty string.

Source code in pyrevitlib/pyrevit/coreutils/markdown/extensions/__init__.py

def getConfig(self, key, default=""):
    """Return a setting for the given key or an empty string."""
    if key in self.config:
        return self.config[key][0]
    else:
        return default

getConfigs()

Return all configs settings as a dict.

Source code in pyrevitlib/pyrevit/coreutils/markdown/extensions/__init__.py

def getConfigs(self):
    """Return all configs settings as a dict."""
    return dict([(key, self.getConfig(key)) for key in self.config.keys()])

getConfigInfo()

Return all config descriptions as a list of tuples.

Source code in pyrevitlib/pyrevit/coreutils/markdown/extensions/__init__.py

def getConfigInfo(self):
    """Return all config descriptions as a list of tuples."""
    return [(key, self.config[key][1]) for key in self.config.keys()]

setConfig(key, value)

Set a config setting for key with the given value.

Source code in pyrevitlib/pyrevit/coreutils/markdown/extensions/__init__.py

def setConfig(self, key, value):
    """Set a config setting for `key` with the given `value`."""
    if isinstance(self.config[key][0], bool):
        value = parseBoolValue(value)
    if self.config[key][0] is None:
        value = parseBoolValue(value, preserve_none=True)
    self.config[key][0] = value

setConfigs(items)

Set multiple config settings given a dict or list of tuples.

Source code in pyrevitlib/pyrevit/coreutils/markdown/extensions/__init__.py

def setConfigs(self, items):
    """Set multiple config settings given a dict or list of tuples."""
    if hasattr(items, "items"):
        # it's a dict
        items = items.items()
    for key, value in items:
        self.setConfig(key, value)

Functions:

makeExtension(*args, **kwargs)

Source code in pyrevitlib/pyrevit/coreutils/markdown/extensions/tables.py

def makeExtension(*args, **kwargs):
    return TableExtension(*args, **kwargs)