def description_table(descriptions, widths, headers):
    # generate table-root
    tgroup = nodes.tgroup(cols=len(widths))
    for width in widths:
        tgroup += nodes.colspec(colwidth=width)
    table = nodes.table()
    table += tgroup

    # generate table-header
    thead = nodes.thead()
    row = nodes.row()
    for header in headers:
        entry = nodes.entry()
        entry += nodes.paragraph(text=header)
        row += entry
    thead += row
    tgroup += thead

    # generate table-body
    tbody = nodes.tbody()
    for desc in descriptions:
        row = nodes.row()
        for col in desc:
            entry = nodes.entry()
            if not isinstance(col, basestring):
                col = str(col)
            paragraph = nodes.paragraph()
            paragraph += nodes.Text(col)
            entry += paragraph
            row += entry
        tbody += row
    tgroup += tbody

    return table
Example #2
0
    def run(self):
        header = self.options.get('header').split(',')
        lines = self._get_lines()
        regex = self.options.get('regex')
        max_cols = len(header)

        table = nodes.table()
        tgroup = nodes.tgroup(max_cols)
        table += tgroup

        col_widths = self.get_column_widths(max_cols)
        tgroup.extend(nodes.colspec(colwidth=col_width) for
                      col_width in col_widths)

        thead = nodes.thead()
        tgroup += thead
        thead += self.create_table_row(header)

        tbody = nodes.tbody()
        tgroup += tbody

        for row in lines:
            matched = re.search(regex, row)
            if matched:
                tbody += self.create_table_row(matched.groups())

        return [table]
Example #3
0
File: tables.py Project: axil/blog
 def build_table_from_list(self, table_data, col_widths, header_rows, stub_columns):
     table = nodes.table()
     if self.widths == 'auto':
         table['classes'] += ['colwidths-auto']
     elif self.widths: # "grid" or list of integers
         table['classes'] += ['colwidths-given']
     tgroup = nodes.tgroup(cols=len(col_widths))
     table += tgroup
     for col_width in col_widths:
         colspec = nodes.colspec()
         if col_width is not None:
             colspec.attributes['colwidth'] = col_width
         if stub_columns:
             colspec.attributes['stub'] = 1
             stub_columns -= 1
         tgroup += colspec
     rows = []
     for row in table_data:
         row_node = nodes.row()
         for cell in row:
             entry = nodes.entry()
             entry += cell
             row_node += entry
         rows.append(row_node)
     if header_rows:
         thead = nodes.thead()
         thead.extend(rows[:header_rows])
         tgroup += thead
     tbody = nodes.tbody()
     tbody.extend(rows[header_rows:])
     tgroup += tbody
     return table
Example #4
0
    def create_table(self, data, num_headers=1):
        table_node = nodes.table()

        if len(data) > 0:
            tgroup_node = nodes.tgroup(cols=len(data[0]))
            table_node += tgroup_node

            col_width = 100 // len(data[0])
            for col_index in range(len(data[0])):
                colspec_node = nodes.colspec(colwidth=col_width)
                tgroup_node += colspec_node

            thead = nodes.thead()
            tgroup_node += thead
            tbody = nodes.tbody()
            tgroup_node += tbody
            for row_index, row in enumerate(data):
                row_node = nodes.row()
                for col_index, cell_item in enumerate(row):
                    row_node += self.create_cell(col_index, cell_item, row_index < num_headers)
                if row_index < num_headers:
                    thead += row_node
                else:
                    tbody += row_node

        return table_node
Example #5
0
    def create_cross_table(self, app, docname, node, matrix, options):
        table = nodes.table()
        table["classes"].append("traceables-crosstable")
        tgroup = nodes.tgroup(cols=len(matrix.secondaries), colwidths="auto")
        table += tgroup

        # Add column specifications.
        tgroup += nodes.colspec(colwidth=1)
        for column in matrix.secondaries:
            tgroup += nodes.colspec(colwidth=1)

        # Add heading row.
        thead = nodes.thead()
        tgroup += thead
        row = nodes.row()
        thead += row
        entry = nodes.entry()
        row += entry
        for secondary in matrix.secondaries:
            entry = nodes.entry()
            row += entry
            container = nodes.container()
            entry += container
            inline = nodes.inline()
            container += inline
            paragraph = nodes.paragraph()
            inline += paragraph
            paragraph += secondary.make_reference_node(app.builder, docname)

        # Add table body.
        tbody = nodes.tbody()
        tgroup += tbody
        for primary in matrix.primaries:
            row = nodes.row()
            tbody += row
            entry = nodes.entry()
            row += entry
            paragraph = nodes.paragraph()
            entry += paragraph
            paragraph += primary.make_reference_node(app.builder, docname)

            for is_related in matrix.get_boolean_row(primary):
                entry = nodes.entry()
                row += entry
                if is_related:
                    checkmark = traceable_checkmark()
                    entry += checkmark
                    checkmark += nodes.inline(u"\u2714", u"\u2714")
                else:
                    continue

        container = traceable_matrix_crosstable()
        container += table
        container["traceables-matrix"] = matrix
#        backward = matrix.backward_relationship.capitalize()
#        forward = matrix.forward_relationship.capitalize()
#        container["relationships"] = (forward, backward)
#        container["boolean_matrix"] = 0#boolean_matrix
#        container["secondaries"] = matrix.secondaries
        return container
Example #6
0
 def build_table_from_list(self, table_data, col_widths, header_rows, stub_columns):
     table = nodes.table()
     tgroup = nodes.tgroup(cols=len(col_widths))
     table += tgroup
     for col_width in col_widths:
         colspec = nodes.colspec(colwidth=col_width)
         if stub_columns:
             colspec.attributes['stub'] = 1
             stub_columns -= 1
         tgroup += colspec
     rows = []
     for row in table_data:
         row_node = nodes.row()
         for cell in row:
             entry = nodes.entry()
             entry += cell
             row_node += entry
         rows.append(row_node)
     if header_rows:
         thead = nodes.thead()
         thead.extend(rows[:header_rows])
         tgroup += thead
     tbody = nodes.tbody()
     tbody.extend(rows[header_rows:])
     tgroup += tbody
     return table
Example #7
0
 def run(self):
     ncolumns = self.options.get('columns', 2)
     node = nodes.Element()
     node.document = self.state.document
     self.state.nested_parse(self.content, self.content_offset, node)
     if len(node.children) != 1 or not isinstance(node.children[0],
                                                  nodes.bullet_list):
         return [self.state.document.reporter.warning(
             '.. hlist content is not a list', line=self.lineno)]
     fulllist = node.children[0]
     # create a hlist node where the items are distributed
     npercol, nmore = divmod(len(fulllist), ncolumns)
     index = 0
     table = nodes.table()
     tg = nodes.tgroup()
     table += tg
     row = nodes.row()
     tbody = nodes.tbody()
     for column in range(ncolumns):
         endindex = index + (column < nmore and (npercol + 1) or npercol)
         colspec = nodes.colspec()
         colspec.attributes['stub'] = 0
         colspec.attributes['colwidth'] = 100. / ncolumns
         col = nodes.entry()
         col += nodes.bullet_list()
         col[0] += fulllist.children[index:endindex]
         index = endindex
         tg += colspec
         row += col
     tbody += row
     tg += tbody
     table['classes'].append('hlist')
     return [table]
    def build_table(self, table_data):
        table = nodes.table()
        tgroup = nodes.tgroup(cols=len(self.headers))
        table += tgroup

        tgroup.extend(
            nodes.colspec(colwidth=col_width, colname='c' + str(idx))
            for idx, col_width in enumerate(self.col_widths)
        )

        thead = nodes.thead()
        tgroup += thead

        row_node = nodes.row()
        thead += row_node
        row_node.extend(nodes.entry(h, nodes.paragraph(text=h))
                        for h in self.headers)

        tbody = nodes.tbody()
        tgroup += tbody

        rows, groups = self.get_rows(table_data)
        tbody.extend(rows)
        table.extend(groups)

        return table
Example #9
0
    def build_table(self):
        table = nodes.table()
        tgroup = nodes.tgroup(cols=len(self.headers))
        table += tgroup

        # TODO(sdague): it would be really nice to figure out how not
        # to have this stanza, it kind of messes up all of the table
        # formatting because it doesn't let tables just be the right
        # size.
        tgroup.extend(
             nodes.colspec(colwidth=col_width, colname='c' + str(idx))
             for idx, col_width in enumerate(self.col_widths)
        )

        thead = nodes.thead()
        tgroup += thead

        row_node = nodes.row()
        thead += row_node
        row_node.extend(nodes.entry(h, nodes.paragraph(text=h))
                        for h in self.headers)

        tbody = nodes.tbody()
        tgroup += tbody

        rows, groups = self.collect_rows()
        tbody.extend(rows)
        table.extend(groups)

        return table
Example #10
0
def build_table(row_nodes, colwidth_list, headrow_data=None):
    """
    Creates new rst table node tree.

    Args:
        row_nodes (list): list of docutils.nodes.row nodes,
            contains actual content of the rst table
        colwidth_list (list): list of width percentages for each column,
            eg.: use [10, 90] for 2 columns, 1st has 10% width, 2nd the rest

    Returns:
        docutils.nodes.table: rst table node tree which contains given rows
    """
    table = nodes.table()
    tgroup = nodes.tgroup(cols=len(colwidth_list))
    table += tgroup
    for colwidth in colwidth_list:
        colspec = nodes.colspec(colwidth=colwidth)
        tgroup += colspec
    if headrow_data is not None:
        thead = nodes.thead()
        tgroup += thead
        head_row_node = build_row(headrow_data)
        thead += head_row_node
    tbody = nodes.tbody()
    tgroup += tbody
    for row in row_nodes:
        tbody += row
    return table
Example #11
0
    def create_progtable(self, **attrs):
        _attrs = {
            'classes': ['progress', 'outer', 'docutils', 'field-list'],
            'colwidths': [20, 80]
        }
        _attrs.update(attrs)

        # create container elements
        node = nodes.table(classes=_attrs['classes'])
        tgroup = nodes.tgroup(cols=2)
        thead = thead = nodes.thead()
        thead += self.create_headrow()
        tbody = nodes.tbody()

        # tgroup gets:
        #  - colspec
        #  - thead
        #  - tbody
        for w in _attrs['colwidths']:
            tgroup += nodes.colspec(colwidth=w)

        # assemble the hierarchy
        tgroup += thead
        tgroup += tbody
        node += tgroup

        # return the table
        return node
 def build_table_from_list(self, table_data, num_cols, col_widths, header_rows, stub_columns):
     table = nodes.table()
     tgroup = nodes.tgroup(cols=len(col_widths))
     table += tgroup
     for col_width in col_widths:
         colspec = nodes.colspec(colwidth=col_width)
         if stub_columns:
             colspec.attributes['stub'] = 1
             stub_columns -= 1
         tgroup += colspec
     rows = []
     for row in table_data:
         row_node = nodes.row()
         for cell_index, cell in enumerate(row):
             entry = nodes.entry()
             entry += cell
             row_node += entry
             if self.bias == "left" and not cell_index:
                 remainder = num_cols - len(row)
                 if remainder:
                     entry["morecols"] = remainder
             if self.bias == "right" and cell_index == len(row) - 1:
                 remainder = num_cols - (cell_index + 1)
                 if remainder:
                     entry["morecols"] = remainder
         rows.append(row_node)
     if header_rows:
         thead = nodes.thead()
         thead.extend(rows[:header_rows])
         tgroup += thead
     tbody = nodes.tbody()
     tbody.extend(rows[header_rows:])
     tgroup += tbody
     return table
Example #13
0
 def run(self):
   if ValueTableDirective.values[0].description is None:
     list = nodes.bullet_list()
     for v in ValueTableDirective.values:
       item = nodes.list_item()
       item += nodes.literal(v.value, v.value)
       list += item
     return [list]
   table = nodes.table()
   tgroup = nodes.tgroup()
   tbody = nodes.tbody()
   for v in ValueTableDirective.values:
     row = nodes.row()
     entry = nodes.entry()
     entry += nodes.literal(v.value, v.value)
     row += entry
     entry = nodes.entry()
     entry += nodes.paragraph(text=v.description)
     row += entry
     tbody += row
   tgroup += nodes.colspec(colwidth=10)
   tgroup += nodes.colspec(colwidth=90)
   tgroup += tbody
   table += tgroup
   return [table]
Example #14
0
def gen_table(columns, data):
        table = nodes.table()
        tgroup = nodes.tgroup(cols=len(columns))
        table += tgroup
        for column in columns:
            tgroup += nodes.colspec(colwidth=1)
        thead = nodes.thead()
        tgroup += thead
        headrow = nodes.row()
        for column in columns:
            entry = nodes.entry()
            para = nodes.paragraph()
            entry += para
            header = column.header()
            para += nodes.Text(header, header)
            headrow += entry
        thead += headrow
        tbody = nodes.tbody()
        tgroup += tbody
        for obj in data:
            row = nodes.row()
            for column in columns:
                entry = nodes.entry()
                para = nodes.paragraph()
                entry += para
                para += column.data(obj)
                row += entry
            tbody += row
        return [table]
    def get_tablespec(self):
        table_spec = addnodes.tabular_col_spec()
        table_spec['spec'] = 'll'

        table = autosummary_table('')
        real_table = nodes.table('', classes=['longtable'])
        table.append(real_table)
        group = nodes.tgroup('', cols=2)
        real_table.append(group)
        group.append(nodes.colspec('', colwidth=10))
        group.append(nodes.colspec('', colwidth=90))
        body = nodes.tbody('')
        group.append(body)

        def append_row(*column_texts):
            row = nodes.row('')
            for text in column_texts:
                node = nodes.paragraph('')
                vl = ViewList()
                vl.append(text, '<autosummary>')
                self.state.nested_parse(vl, 0, node)
                try:
                    if isinstance(node[0], nodes.paragraph):
                        node = node[0]
                except IndexError:
                    pass
                row.append(nodes.entry('', node))
            body.append(row)
        return table, table_spec, append_row
Example #16
0
    def _description_table(self, descriptions, widths, headers):
        # generate table-root
        tgroup = nodes.tgroup(cols=len(widths))
        for width in widths:
            tgroup += nodes.colspec(colwidth=width)
        table = nodes.table()
        table += tgroup

        # generate table-header
        thead = nodes.thead()
        row = nodes.row()
        for header in headers:
            entry = nodes.entry()
            entry += nodes.paragraph(text=header)
            row += entry
        thead += row
        tgroup += thead

        # generate table-body
        tbody = nodes.tbody()
        for desc in descriptions:
            row = nodes.row()
            for attr in desc:
                entry = nodes.entry()
                if not isinstance(attr, string_types):
                    attr = str(attr)
                self.state.nested_parse(ViewList([attr], source=attr),
                                        0, entry)
                row += entry
            tbody += row
        tgroup += tbody

        return table
Example #17
0
def envy_resolve(app, doctree, fromdocname):
    objects = app.env.domaindata['envy']['objects']

    # add uplink info
    for holder in doctree.traverse(uplink_placeholder):
        obj = objects[holder.name]
        links = []
        for sp, pos, name, variants in obj.uplinks:
            signode = addnodes.desc_signature('', '')
            signode['first'] = False
            signode += make_refnode(app.builder, fromdocname, sp.docname, sp.iname + '-' + sp.name, addnodes.desc_addname(sp.name, sp.name), sp.name)
            text = ' {}: {}'.format(pos, name)
            signode += addnodes.desc_name(text, text)
            if variants is not None:
                text = ' [{}]'.format(variants)
                signode += addnodes.desc_annotation(text, text)
            links.append(signode)
        holder.replace_self(links)

    # add subnode list
    for holder in doctree.traverse(sub_placeholder):
        obj = objects[holder.name]
        add_variant = False
        for pos, name, child, variants in obj.subs:
            if variants is not None:
                add_variant = True
        table = nodes.table()
        headers = [(1, 'Address'), (1, 'Name'), (10, 'Description')]
        if add_variant:
            headers.insert(1, (1, 'Variants'))
        tgroup = nodes.tgroup(cols=len(headers))
        table += tgroup
        for colwidth, header in headers:
            tgroup += nodes.colspec(colwidth=colwidth)
        thead = nodes.thead()
        tgroup += thead
        headrow = nodes.row()
        for colwidth, header in headers:
            entry = nodes.entry()
            para = nodes.paragraph()
            entry += para
            para += nodes.Text(header, header)
            headrow += entry
        thead += headrow
        tbody = nodes.tbody()
        tgroup += tbody
        for pos, name, child, variants in obj.subs:
            row = nodes.row()
            row += wrap_text_entry(pos)
            if add_variant:
                row += wrap_text_entry('all' if variants is None else variants)
            row += wrap_text_entry(name)
            entry = nodes.entry()
            para = nodes.paragraph()
            entry += para
            para += make_refnode(app.builder, fromdocname, child.docname, child.iname + '-' + child.name, nodes.Text(child.brief, child.brief), obj.brief)
            row += entry
            tbody += row
        holder.replace_self([table])
    def run(self):
        table = nodes.table('')

        ## Create table
        group = nodes.tgroup('', cols=3)
        table.append(group)
        
        for colwidth in 10,40,5:
            group.append(nodes.colspec('', colwidth=colwidth))

        head = nodes.thead('')
        group.append(head)

        body = nodes.tbody('')
        group.append(body)

        def add_row(target, *column_texts):
            row = nodes.row('')
            for text in column_texts:
                if text == None:
                    text = ""
                node = nodes.paragraph('')
                vl = ViewList()
                vl.append(text, '<autosummary>')
                self.state.nested_parse(vl, 0, node)
                try:
                    if isinstance(node[0], nodes.paragraph):
                        node = node[0]
                except IndexError:
                    pass
                row.append(nodes.entry('', node))
            target.append(row)

        def get_symbol(s):
            parametertable_path = s.split('.')
            
            for i in reversed(range(len(parametertable_path))):
                module = '.'.join(parametertable_path[:i])
                symbol = parametertable_path[i:]

                try:
                    m = __import__(str(module), fromlist='true')
                except ImportError:
                    continue
                else:
                    break

            parent = m
            for sym in symbol:
                parent = getattr(parent, sym)

            return parent

        add_row(head, 'Parameter', 'Description' , 'Unit')

        for param in get_symbol(self.arguments[0]):
            add_row(body, param.name, param.desc, param.unit)

        return [table]
    def create_list_table(self, matrix, options, docname):
        table = nodes.table()
        tgroup = nodes.tgroup(cols=2, colwidths="auto")
        table += tgroup

        # Add column specifications.
        tgroup += nodes.colspec(colwidth=50)
        tgroup += nodes.colspec(colwidth=50)

        # Add heading row.
        thead = nodes.thead()
        tgroup += thead
        row = nodes.row()
        thead += row
        entry = nodes.entry()
        row += entry
        backward_relationship = matrix.backward_relationship.capitalize()
        entry += nodes.paragraph(backward_relationship,
                                 backward_relationship)
        entry = nodes.entry()
        row += entry
        forward_relationship = matrix.forward_relationship.capitalize()
        entry += nodes.paragraph(forward_relationship,
                                 forward_relationship)

        # Add table body.
        tbody = nodes.tbody()
        tgroup += tbody
        for traceable in matrix.primaries:
            relatives = matrix.get_relatives(traceable)

            # Create first row with a first column.
            row = nodes.row()
            entry = nodes.entry(morerows=len(relatives) - 1)
            row += entry
            paragraph = nodes.paragraph()
            entry += paragraph
            paragraph += traceable.make_reference_node(
                self.app.builder, docname)

            for relative in relatives:
                if not row:
                    # Create subsequent rows without a first column.
                    row = nodes.row()
                tbody += row

                entry = nodes.entry()
                row += entry
                paragraph = nodes.paragraph()
                entry += paragraph
                paragraph += relative.make_reference_node(
                    self.app.builder, docname)

                row = None

        return table
Example #20
0
    def build_links_table(self, resource):
        is_list = "is-list" in self.options

        table = nodes.table()

        tgroup = nodes.tgroup(cols=3)
        table += tgroup

        tgroup += nodes.colspec(colwidth=25)
        tgroup += nodes.colspec(colwidth=15)
        tgroup += nodes.colspec(colwidth=60)

        thead = nodes.thead()
        tgroup += thead
        append_row(thead, ["Name", "Method", "Resource"])

        tbody = nodes.tbody()
        tgroup += tbody

        request = DummyRequest()

        if is_list:
            child_resources = resource.list_child_resources
        else:
            child_resources = resource.item_child_resources

        names_to_resource = {}

        for child in child_resources:
            names_to_resource[child.name_plural] = (child, True)

        if not is_list and resource.model:
            child_keys = {}
            create_fake_resource_path(request, resource, child_keys, True)
            obj = resource.get_queryset(request, **child_keys)[0]
        else:
            obj = None

        related_links = resource.get_related_links(request=request, obj=obj)

        for key, info in related_links.iteritems():
            if "resource" in info:
                names_to_resource[key] = (info["resource"], info.get("list-resource", False))

        links = resource.get_links(child_resources, request=DummyRequest(), obj=obj)

        for linkname in sorted(links.iterkeys()):
            info = links[linkname]
            child, is_child_link = names_to_resource.get(linkname, (resource, is_list))

            paragraph = nodes.paragraph()
            paragraph += get_ref_to_resource(child, is_child_link)

            append_row(tbody, [nodes.strong(text=linkname), info["method"], paragraph])

        return table
Example #21
0
    def get_table(self, items_set):
        """Generate a proper list of table nodes for errorsummary:: directive.

        *items* is a list produced by :meth:`get_items`.
        """
        table_spec = addnodes.tabular_col_spec()
        table_spec['spec'] = 'll'

        table = autosummary_table('')
        real_table = nodes.table('', classes=['longtable'])
        table.append(real_table)
        group = nodes.tgroup('', cols=3)
        real_table.append(group)
        group.append(nodes.colspec('', colwidth=70))
        group.append(nodes.colspec('', colwidth=20))
        group.append(nodes.colspec('', colwidth=90))
        body = nodes.tbody('')
        group.append(body)

        def append_row(*column_texts):
            row = nodes.row('')
            for text in column_texts:
                node = nodes.paragraph('')
                vl = ViewList()
                vl.append(text, '<autosummary>')
                self.state.nested_parse(vl, 0, node)
                try:
                    if isinstance(node[0], nodes.paragraph):
                        node = node[0]
                except IndexError:
                    pass
                row.append(nodes.entry('', node))
            body.append(row)

        col1 = u"**Name**"
        col2 = u"**Code**"
        col3 = u"**Message**"
        append_row(col1, col2, col3)

        for class_name, items in sorted(items_set.items()):
            for name, sig, summary, real_name, code in items:
                if 'nosignatures' not in self.options:
                    col1 = '_%s' % name
                col2 = '{}'.format(code)
                translated = translate(summary, "ru") if summary else ""
                if translated != summary:
                    col3 = u"{} / {}".format(translated, summary)
                else:
                    col3 = summary

                append_row(col1, col2, col3)

        return [table_spec, table]
Example #22
0
def get_autosummary(names, state, no_signatures=False):
    """
    Generate a proper table node for autosummary:: directive.

    *names* is a list of names of Python objects to be imported and added to the
    table.  *document* is the Docutils document object.

    """
    document = state.document

    real_names = {}
    warnings = []

    prefixes = ['']
    prefixes.insert(0, document.settings.env.currmodule)

    table = nodes.table('')
    group = nodes.tgroup('', cols=2)
    table.append(group)
    group.append(nodes.colspec('', colwidth=30))
    group.append(nodes.colspec('', colwidth=70))
    body = nodes.tbody('')
    group.append(body)

    def append_row(*column_texts):
        row = nodes.row('')
        for text in column_texts:
            node = nodes.paragraph('')
            vl = ViewList()
            vl.append(text, '<autosummary>')
            state.nested_parse(vl, 0, node)
            row.append(nodes.entry('', node))
        body.append(row)

    for name in names:
        try:
            obj, real_name = import_by_name(name, prefixes=prefixes)
        except ImportError:
            warnings.append(document.reporter.warning(
                'failed to import %s' % name))
            append_row(':obj:`%s`' % name, '')
            continue

        real_names[name] = real_name

        title = ''
        qualifier = 'obj'
        col1 = ':'+qualifier+':`%s <%s>`' % (name, real_name)
        col2 = title
        append_row(col1, col2)

    return table, warnings, real_names
Example #23
0
    def run(self):
        ns = [ ]

        table = nodes.table()

        rows = [ ]
        for i in range(10):
            row = nodes.row()
            row.append(nodes.Element('aa%s'%i))
            row.append(nodes.paragraph('bb%s'%i))
            table.append(row)

        return [table ]
Example #24
0
File: wiki.py Project: tkf/neorg
def gene_table(list2d, title=None, colwidths=None, rows_highlight=[],
               classes=[], _baseclass='neorg-gene-table',
               rows_highlight_class='neorg-gene-table-rows-highlight'):
    """
    Generate table node from 2D list
    """
    allclasses = [_baseclass] + classes
    if not list2d:
        table = nodes.table()
        table['classes'] += allclasses
        return table
    nrow = len(list2d)
    ncol = len(list2d[0])
    if colwidths is None:
        colwidths = [1] * ncol

    table = nodes.table()
    tgroup = nodes.tgroup(cols=ncol)
    tbody = nodes.tbody()
    colspecs = [nodes.colspec(colwidth=cw) for cw in colwidths]
    rows = [nodes.row() for dummy in range(nrow)]

    if title:
        table += nodes.title(title, title)
    table += tgroup
    tgroup += colspecs
    tgroup += tbody
    tbody += rows

    for (row, list1d) in zip(rows, list2d):
        row += [gene_entry(elem) for elem in list1d]

    for (i, row) in enumerate(rows):
        if i in rows_highlight:
            row['classes'].append(rows_highlight_class)

    table['classes'] += allclasses
    return table
Example #25
0
def process_indigo_option_nodes(app, doctree, fromdocname):
    env = app.builder.env

    for node in doctree.traverse(optionslist):
        content = []

        tbl = nodes.table()
        tgroup = nodes.tgroup(cols=4)
        tbl += tgroup

        tgroup += nodes.colspec(colwidth=35)
        tgroup += nodes.colspec(colwidth=9)
        tgroup += nodes.colspec(colwidth=9)
        tgroup += nodes.colspec(colwidth=73)

        thead = nodes.thead()
        tgroup += thead
        row = nodes.row()
        thead += row
        row += createRowEntryText('Name')
        row += createRowEntryText('Type')
        row += createRowEntryText('Default')
        row += createRowEntryText('Short description')

        tbody = nodes.tbody()
        tgroup += tbody

        content.append(tbl)

        sorted_options = sorted(env.indigo_options, key=lambda o:o['name'])

        for opt_info in sorted_options:
            row = nodes.row()
            tbody += row

            # Create a reference
            newnode = nodes.reference('', '')
            innernode = nodes.Text(opt_info['name'], opt_info['name'])
            newnode['refdocname'] = opt_info['docname']
            newnode['refuri'] = app.builder.get_relative_uri(
                fromdocname, opt_info['docname'])
            newnode['refuri'] += '#' + normalize_name(opt_info['name'])
            newnode.append(innernode)

            row += createRowEntry(newnode)
            row += createRowEntryText(opt_info['type'])
            row += createRowEntryText(opt_info['default'])
            row += createRowEntryText(opt_info['short'])

        node.replace_self(content)
Example #26
0
    def format(self, app, docname, node, traceables, options):
        additional_attributes = options.get("attributes") or []
        columns = ["tag", "title"] + additional_attributes

        table = nodes.table()
        table["classes"].append("traceables-listtable")
        tgroup = nodes.tgroup(cols=len(columns), colwidths="auto")
        table += tgroup

        # Add column specifications.
        for attribute_name in columns:
            tgroup += nodes.colspec(colwidth=1)

        # Add heading row.
        thead = nodes.thead()
        tgroup += thead
        row = nodes.row()
        thead += row
        for attribute_name in columns:
            entry = nodes.entry()
            row += entry
            container = nodes.container()
            entry += container
            text = attribute_name.capitalize()
            inline = nodes.inline(text, text)
            container += inline

        # Add table body.
        tbody = nodes.tbody()
        tgroup += tbody
        for traceable in traceables:
            row = nodes.row()
            tbody += row

            for attribute_name in columns:
                entry = nodes.entry()
                row += entry
                if attribute_name == "tag":
                    inline = nodes.inline()
                    inline += traceable.make_reference_node(
                        app.builder, docname)
                elif attribute_name == "title":
                    text = traceable.title if traceable.has_title else ""
                    inline = nodes.inline(text, text)
                else:
                    text = traceable.attributes.get(attribute_name, "")
                    inline = nodes.inline(text, text)
                entry += inline

        return table
Example #27
0
    def build_details_table(self, error_obj):
        table = nodes.table()

        tgroup = nodes.tgroup(cols=2)
        table += tgroup

        tgroup += nodes.colspec(colwidth=20)
        tgroup += nodes.colspec(colwidth=80)

        tbody = nodes.tbody()
        tgroup += tbody

        # API Error Code
        append_detail_row(tbody, 'API Error Code',
                          nodes.literal(text=error_obj.code))

        # HTTP Status Code
        ref = parse_text(self, ':http:`%s`' % error_obj.http_status)
        append_detail_row(tbody, 'HTTP Status Code', ref)

        # Error Text
        append_detail_row(tbody, 'Error Text',
                          nodes.literal(text=error_obj.msg))

        if error_obj.headers:
            if callable(error_obj.headers):
                headers = error_obj.headers(DummyRequest())

            # HTTP Headers
            if len(headers) == 1:
                content = nodes.literal(text=headers.keys()[0])
            else:
                content = nodes.bullet_list()

                for header in headers.iterkeys():
                    item = nodes.list_item()
                    content += item

                    literal = nodes.literal(text=header)
                    item += literal

            append_detail_row(tbody, 'HTTP Headers', content)

        # Description
        append_detail_row(
            tbody, 'Description',
            parse_text(self, '\n'.join(self.content),
                       where='API error %s description' % error_obj.code))

        return table
    def _build_markup(self, notifications):
        content = []
        cols = ['Notification class', 'Payload class', 'Sample file link']
        table = nodes.table()
        content.append(table)
        group = nodes.tgroup(cols=len(cols))
        table.append(group)

        head = nodes.thead()
        group.append(head)

        for i in range(len(cols)):
            group.append(nodes.colspec(colwidth=1))

        body = nodes.tbody()
        group.append(body)

        # fill the table header
        row = nodes.row()
        body.append(row)
        for col_name in cols:
            col = nodes.entry()
            row.append(col)
            text = nodes.strong(text=col_name)
            col.append(text)

        # fill the table content, one notification per row
        for name, payload, sample in notifications:
            row = nodes.row()
            body.append(row)
            col = nodes.entry()
            row.append(col)
            text = nodes.literal(text=name)
            col.append(text)

            col = nodes.entry()
            row.append(col)
            text = nodes.literal(text=payload)
            col.append(text)

            col = nodes.entry()
            row.append(col)
            ref = nodes.reference(refuri=self.LINK_PREFIX +
                                  self.SAMPLE_ROOT + sample)
            txt = nodes.inline()
            col.append(txt)
            txt.append(ref)
            ref.append(nodes.literal(text=sample))

        return content
Example #29
0
    def run(self):
        self.assert_has_content()

        language = self.arguments[0]
        code = '\n'.join(self.content)
        pygmentize_args = {}
        if self.options.get('number-lines', None):
            pygmentize_args['linenostart'] = int(self.options['number-lines'])
        pygmentize_args['linenos'] = 'number-lines' in self.options and 'table'
        node = nodes.table() if pygmentize_args['linenos'] else nodes.literal_block()
        node['classes'] = self.options.get('class', [])
        node.attributes['data-language'] = language
        self.add_name(node)
        set_source_info(self, node)
        # if called from "include", set the source
        if 'source' in self.options:
            node.attributes['source'] = self.options['source']
        if pygmentize_args['linenos']:
            anchor_id = node['ids'][-1] if node['ids'] else md5(code.encode('utf-8')).hexdigest()
            pygmentize_args['lineanchors'] = anchor_id
            pygmentize_args['anchorlinenos'] = True
        linespec = self.options.get('emphasize-lines')
        if linespec:
            try:
                nlines = len(self.content)
                pygmentize_args['hl_lines'] = [x + 1 for x in parselinenos(linespec, nlines)]
            except ValueError as err:
                document = self.state.document
                return [document.reporter.warning(str(err), line=self.lineno)]

        output = pygmentize(code, language, **pygmentize_args)
        # remove empty span included by Pygments
        # See:
        # https://bitbucket.org/birkenfeld/pygments-main/issues/1254/empty-at-the-begining-of-the-highlight
        output = output.replace('<span></span>', '')
        pre = re.findall('<pre.*?>(.*?)\n*</pre>', output, re.DOTALL)
        if len(pre) == 1:
            node += nodes.raw(pre[0], pre[0], format='html')
        else:  # pygments returned a table
            row = nodes.row()
            node += row
            linenos_cell = nodes.entry(classes=['linenos'])
            linenos_cell += nodes.literal_block('', '', nodes.raw(pre[0], pre[0], format='html'))
            code_cell = nodes.entry(classes=['code'])
            code_cell += nodes.literal_block('', '', nodes.raw(pre[1], pre[1], format='html'))
            row += linenos_cell
            row += code_cell

        return [node]
Example #30
0
    def _build_grade_listing(self, matrix, content):

        summarytitle = nodes.subtitle(text="Grades")
        content.append(nodes.raw(text="Grades", attributes={'tagname': 'h2'}))
        content.append(summarytitle)
        table = nodes.table()
        table.set_class("table")
        table.set_class("table-condensed")
        grades = matrix.grades

        tablegroup = nodes.tgroup(cols=2)
        summarybody = nodes.tbody()
        summaryhead = nodes.thead()

        for i in range(2):
            tablegroup.append(nodes.colspec(colwidth=1))
        tablegroup.append(summaryhead)
        tablegroup.append(summarybody)
        table.append(tablegroup)
        content.append(table)

        header = nodes.row()
        blank = nodes.entry()
        blank.append(nodes.strong(text="Grade"))
        header.append(blank)

        blank = nodes.entry()
        blank.append(nodes.strong(text="Description"))
        header.append(blank)

        summaryhead.append(header)

        for grade in grades:
            item = nodes.row()
            namecol = nodes.entry()
            class_name = "label-%s" % grade.css_class
            status_text = nodes.paragraph(text=grade.title)
            status_text.set_class(class_name)
            status_text.set_class("label")
            namecol.append(status_text)
            item.append(namecol)

            notescol = nodes.entry()
            notescol.append(nodes.paragraph(text=grade.notes))
            item.append(notescol)

            summarybody.append(item)

        return content
Example #31
0
    def run(self):
        """Generate a table summary of subcommands of a click group. 

        :param name: Name of group, as used on the command line
        :param subcommands: Display only listed subcommands or skip the section if
            empty
        :param column_names: The 
        :returns: A list with a docutil node, representing the resulting table.
        """
        self.env = self.state.document.settings.env

        command = self._load_module(self.arguments[0])

        if 'prog' not in self.options:
            raise self.error(':prog: must be specified')

        prog_name = self.options.get('prog')
        column_names = self.options.get(
            'column_names', 'Subcommand, Description')
        column_names = [s.strip() for s in column_names.split(',')]
        subcommands = self.options.get('subcommands')

        ctx = click.Context(command, info_name=prog_name)

        colwidths = [1, 2]

        table = nodes.table()

        tgroup = nodes.tgroup(cols=len(column_names))
        table += tgroup
        for colwidth in colwidths:
            tgroup += nodes.colspec(colwidth=colwidth)

        thead = nodes.thead()
        tgroup += thead
        thead += self._create_table_row(column_names)

        tbody = nodes.tbody()
        tgroup += tbody

        subcommands = _filter_commands(ctx, subcommands)
        for subcommand in subcommands:
            tbody += self._create_table_row(
                (subcommand.name, subcommand.short_help))

        return [table]
def prepare_table_header(titles, widths):
    """Build docutil empty table """
    ncols = len(titles)
    assert len(widths) == ncols

    tgroup = nodes.tgroup(cols=ncols)
    for width in widths:
        tgroup += nodes.colspec(colwidth=width)
    header = nodes.row()
    for title in titles:
        header += nodes.entry('', nodes.paragraph(text=title))
    tgroup += nodes.thead('', header)

    tbody = nodes.tbody()
    tgroup += tbody

    return nodes.table('', tgroup), tbody
Example #33
0
    def get_table(self, items: List[Tuple[str, str, str, str]]) -> List[Node]:
        """Generate a proper list of table nodes for autosummary:: directive.

        *items* is a list produced by :meth:`get_items`.
        """
        table_spec = addnodes.tabular_col_spec()
        table_spec['spec'] = r'\X{1}{2}\X{1}{2}'

        table = autosummary_table('')
        real_table = nodes.table('', classes=['longtable'])
        table.append(real_table)
        group = nodes.tgroup('', cols=2)
        real_table.append(group)
        group.append(nodes.colspec('', colwidth=10))
        group.append(nodes.colspec('', colwidth=90))
        body = nodes.tbody('')
        group.append(body)

        def append_row(*column_texts: str) -> None:
            row = nodes.row('')
            source, line = self.state_machine.get_source_and_line()
            for text in column_texts:
                node = nodes.paragraph('')
                vl = StringList()
                vl.append(text, '%s:%d:<autosummary>' % (source, line))
                with switch_source_input(self.state, vl):
                    self.state.nested_parse(vl, 0, node)
                    try:
                        if isinstance(node[0], nodes.paragraph):
                            node = node[0]
                    except IndexError:
                        pass
                    row.append(nodes.entry('', node))
            body.append(row)

        for name, sig, summary, real_name in items:
            qualifier = 'obj'
            if 'nosignatures' not in self.options:
                col1 = ':%s:`%s <%s>`\\ %s' % (qualifier, name, real_name,
                                               rst.escape(sig))
            else:
                col1 = ':%s:`%s <%s>`' % (qualifier, name, real_name)
            col2 = summary
            append_row(col1, col2)

        return [table_spec, table]
Example #34
0
    def build_details_table(self, error_obj):
        table = nodes.table()

        tgroup = nodes.tgroup(cols=2)
        table += tgroup

        tgroup += nodes.colspec(colwidth=20)
        tgroup += nodes.colspec(colwidth=80)

        tbody = nodes.tbody()
        tgroup += tbody

        # API Error Code
        append_detail_row(tbody, 'API Error Code',
                          nodes.literal(text=error_obj.code))

        # HTTP Status Code
        ref = parse_text(self, ':http:`%s`' % error_obj.http_status)
        append_detail_row(tbody, 'HTTP Status Code', ref)

        # Error Text
        append_detail_row(tbody, 'Error Text',
                          nodes.literal(text=error_obj.msg))

        if error_obj.headers:
            # HTTP Headers
            if len(error_obj.headers) == 1:
                content = nodes.literal(text=error_obj.headers.keys()[0])
            else:
                content = nodes.bullet_list()

                for header in error_obj.headers.iterkeys():
                    item = nodes.list_item()
                    content += item

                    literal = nodes.literal(text=header)
                    item += literal

            append_detail_row(tbody, 'HTTP Headers', content)


        # Description
        append_detail_row(tbody, 'Description',
                          parse_text(self, '\n'.join(self.content)))

        return table
    def get_table(self, items):
        """Generate a proper list of table nodes for autosummary:: directive.

        *items* is a list produced by :meth:`get_items`.
        """
        table_spec = addnodes.tabular_col_spec()
        table_spec['spec'] = 'll'

        table = autosummary_table('')
        real_table = nodes.table('', classes=['longtable'])
        table.append(real_table)
        group = nodes.tgroup('')
        real_table.append(group)
        group.append(nodes.colspec('', colwidth=0))
        group.append(nodes.colspec('', colwidth=100))
        body = nodes.tbody('')
        group.append(body)

        def append_row(*column_texts):
            row = nodes.row('')
            for text in column_texts:
                node = nodes.paragraph('')
                vl = ViewList()
                vl.append(text, '<autosummary>')
                self.state.nested_parse(vl, 0, node)
                try:
                    if isinstance(node[0], nodes.paragraph):
                        node = node[0]
                except IndexError:
                    pass
                row.append(nodes.entry('', node))
            body.append(row)

        for name, sig, summary, real_name, prefix in items:
            qualifier = 'obj'
            if 'nosignatures' not in self.options:
                col1 = ':%s:`%s <%s>`\ %s' % (qualifier, name, real_name, sig)
            else:
                col1 = ':%s:`%s <%s>`' % (qualifier, name, real_name)
            if prefix:
                prefix = "*%s*" % prefix

            append_row(prefix, col1)

        return [table_spec, table]
    def run(self):
        env = self.state.document.settings.env

        xml_path = self.arguments[0]
        root_path = env.app.config.tr_rootdir
        if not os.path.isabs(xml_path):
            xml_path = os.path.join(root_path, xml_path)
        parser = JUnitParser(xml_path)
        results = parser.parse()

        # Construction idea taken from http://agateau.com/2015/docutils-snippets/

        main_section = []

        for testsuite in results:
            section = nodes.section()
            section += nodes.title(text=testsuite["name"])
            section += nodes.paragraph(text="Tests: {tests}, Failures: {failure}, Errors: {error}, "
                                            "Skips: {skips}".format(tests=testsuite["tests"],
                                                                    failure=testsuite["failures"],
                                                                    error=testsuite["errors"],
                                                                    skips=testsuite["skips"]
                                                                    ))
            section += nodes.paragraph(text="Time: {time}".format(time=testsuite["time"]))

            table = nodes.table()
            section += table

            tgroup = nodes.tgroup(cols=len(self.header))
            table += tgroup
            for colwidth in self.colwidths:
                tgroup += nodes.colspec(colwidth=colwidth)

            thead = nodes.thead()
            tgroup += thead
            thead += self._create_table_row(self.header)

            tbody = nodes.tbody()
            tgroup += tbody
            for testcase in testsuite["testcases"]:
                tbody += self._create_testcase_row(testcase)

            main_section += section

        return main_section
Example #37
0
    def build_errors_table(self, errors):
        """Build a table representing a list of errors.

        Args:
            errors (list of djblets.webapi.errors.WebAPIError):
                The errors to display.

        Returns:
            list of docutils.nodes.Node:
            The resulting list of nodes for the errors table.
        """
        table = nodes.table(classes=['api-errors'])

        tgroup = nodes.tgroup(cols=2)
        table += tgroup

        tgroup += nodes.colspec(colwidth=25)
        tgroup += nodes.colspec(colwidth=75)

        tbody = nodes.tbody()
        tgroup += tbody

        for error in sorted(errors, key=lambda x: x.code):
            http_code = nodes.inline(classes=['http-error'])
            http_code += nodes.reference(
                text='HTTP %s - %s' % (error.http_status,
                                       HTTP_STATUS_CODES[error.http_status]),
                refuri=(DEFAULT_HTTP_STATUS_CODES_URL
                        % error.http_status)),

            error_code = nodes.inline(classes=['api-error'])
            error_code += get_ref_to_error(error)

            error_info = nodes.inline()
            error_info += error_code
            error_info += http_code

            append_row(
                tbody,
                [
                    error_info,
                    nodes.inline(text=error.msg),
                ])

        return table
Example #38
0
    def get_table(self, items):
        # type: (List[Tuple[unicode, unicode, unicode, unicode]]) -> List[Union[addnodes.tabular_col_spec, autosummary_table]]  # NOQA
        """Generate a proper list of table nodes for autosummary:: directive.

        *items* is a list produced by :meth:`get_items`.
        """
        table_spec = addnodes.tabular_col_spec()
        table_spec['spec'] = r'p{0.5\linewidth}p{0.5\linewidth}'

        table = autosummary_table('')
        real_table = nodes.table('', classes=['longtable'])
        table.append(real_table)
        group = nodes.tgroup('', cols=2)
        real_table.append(group)
        group.append(nodes.colspec('', colwidth=10))
        group.append(nodes.colspec('', colwidth=90))
        body = nodes.tbody('')
        group.append(body)

        def append_row(*column_texts):
            # type: (unicode) -> None
            row = nodes.row('')
            for text in column_texts:
                node = nodes.paragraph('')
                vl = ViewList()
                vl.append(text, '<autosummary>')
                self.state.nested_parse(vl, 0, node)
                try:
                    if isinstance(node[0], nodes.paragraph):
                        node = node[0]
                except IndexError:
                    pass
                row.append(nodes.entry('', node))
            body.append(row)

        for name, sig, summary, real_name in items:
            qualifier = 'obj'
            if 'nosignatures' not in self.options:
                col1 = ':%s:`%s <%s>`\\ %s' % (qualifier, name, real_name, rst.escape(sig))  # type: unicode  # NOQA
            else:
                col1 = ':%s:`%s <%s>`' % (qualifier, name, real_name)
            col2 = summary
            append_row(col1, col2)

        return [table_spec, table]
Example #39
0
    def transform_content(self, contentnode: addnodes.desc_content) -> None:
        name = self.names[0]
        path = Path(name)
        js_path = path.with_suffix('.json')

        if not js_path.exists():
            w = self.state.reporter.warning(
                f'schema file {js_path} does not exist')
            contentnode += w
            return

        schema = json.loads(js_path.read_text())

        table = nodes.table(classes=['colwidths-auto'])
        tg = nodes.tgroup(cols=2)
        tg += nodes.colspec(colwidth=1)
        tg += nodes.colspec(colwidth=0)
        table += tg

        # set up the table heading
        head = nodes.thead()
        hrow = nodes.row()
        head += hrow
        hrow += nodes.entry('',
                            nodes.paragraph('', '', nodes.inline('', 'Field')))
        hrow += nodes.entry('',
                            nodes.paragraph('', '', nodes.inline('', 'Type')))
        tg += head

        # write the field table
        tb = nodes.tbody()
        tg += tb
        for field in schema.get('fields', []):
            row = nodes.row()
            row += nodes.entry(
                '', nodes.paragraph('', '', nodes.literal('', field['name'])))

            type = field['data_type']
            if field['nullable']:
                type += '?'
            row += nodes.entry(
                '', nodes.paragraph('', '', nodes.literal('', type)))
            tb += row

        contentnode += table
Example #40
0
def model_table(model):
    table = nodes.table()
    tgroup = nodes.tgroup(cols=2)

    colspec = nodes.colspec(colwidth=1)
    tgroup.append(colspec)
    colspec = nodes.colspec(colwidth=1)
    tgroup.append(colspec)

    table += tgroup

    rows = []

    row = nodes.row()
    rows.append(row)
    entry = nodes.entry()
    entry += nodes.paragraph(text="id")
    row += entry
    entry = nodes.entry()
    entry += nodes.paragraph(text=model.id)
    row += entry

    row = nodes.row()
    rows.append(row)
    entry = nodes.entry()
    entry += nodes.paragraph(text="name")
    row += entry
    entry = nodes.entry()
    entry += nodes.paragraph(text=model.name)
    row += entry

    row = nodes.row()
    rows.append(row)
    entry = nodes.entry()
    entry += nodes.paragraph(text="num_populations")
    row += entry
    entry = nodes.entry()
    entry += nodes.paragraph(text=model.num_populations)
    row += entry

    tbody = nodes.tbody()
    tbody.extend(rows)
    tgroup += tbody

    return table
Example #41
0
    def run(self, reader: LineReader, document: Element) -> bool:
        location = reader.get_source_and_line(incr=1)
        header_row, aligns = self.read_table_header(reader)
        if header_row is None:
            return False
        body_rows = self.read_table_body(reader, aligns)

        colspecs = [
            nodes.colspec('', colwidth=int(100 / len(aligns))) for _ in aligns
        ]
        thead = nodes.thead('', header_row)
        tgroup = nodes.tgroup('', *colspecs, thead, cols=len(aligns))
        if body_rows:
            tgroup += nodes.tbody('', *body_rows)
        table = nodes.table('', tgroup)
        location.set_source_info(table)
        document += table
        return True
Example #42
0
    def _get_table(self, objects):
        table_spec = addnodes.tabular_col_spec()
        table_spec["spec"] = r"p{0.5\linewidth}p{0.5\linewidth}"

        table = sphinx.ext.autosummary.autosummary_table("")
        real_table = nodes.table("", classes=["longtable"])
        table.append(real_table)
        group = nodes.tgroup("", cols=2)
        real_table.append(group)
        group.append(nodes.colspec("", colwidth=10))
        group.append(nodes.colspec("", colwidth=90))
        body = nodes.tbody("")
        group.append(body)

        for obj in objects:
            body.append(self._get_row(obj))

        return [table_spec, table]
Example #43
0
    def _get_table(self, objects):
        table_spec = addnodes.tabular_col_spec()
        table_spec['spec'] = r'p{0.5\linewidth}p{0.5\linewidth}'

        table = sphinx.ext.autosummary.autosummary_table('')
        real_table = nodes.table('', classes=['longtable'])
        table.append(real_table)
        group = nodes.tgroup('', cols=2)
        real_table.append(group)
        group.append(nodes.colspec('', colwidth=10))
        group.append(nodes.colspec('', colwidth=90))
        body = nodes.tbody('')
        group.append(body)

        for obj in objects:
            body.append(self._get_row(obj))

        return [table_spec, table]
Example #44
0
    def build_table(self, table_data, col_widths):
        table = nodes.table()

        # Set up the column specifications
        # based on the widths.
        tgroup = nodes.tgroup(cols=len(col_widths))
        table += tgroup
        tgroup.extend(
            nodes.colspec(colwidth=col_width) for col_width in col_widths)

        # Set the headers
        thead = nodes.thead()
        tgroup += thead
        row_node = nodes.row()
        thead += row_node
        row_node.extend(
            nodes.entry(h, nodes.paragraph(text=h)) for h in self.HEADERS)

        # The body of the table is made up of rows.
        # Each row contains a series of entries,
        # and each entry contains a paragraph of text.
        tbody = nodes.tbody()
        tgroup += tbody
        rows = []
        for member, tc_projects in table_data.items():
            trow = nodes.row()
            # Iterate over the headers in the same order every time.
            name = nodes.entry()
            name += nodes.paragraph(text=str(member))
            trow += name
            project = nodes.entry()
            project_list = nodes.paragraph()
            for proj in tc_projects:
                project_list += nodes.reference(proj,
                                                proj,
                                                refuri="projects/%s.html" %
                                                proj)
                project_list += nodes.Text(", ")
            project += project_list
            trow += project
            rows.append(trow)
        tbody.extend(rows)

        return table
Example #45
0
    def run(self):
        table = nodes.table(
            "",
            classes=[
                "longtable",
                "colwidths-auto",
                # "colwidths-given",
            ],
        )

        group = nodes.tgroup("", cols=3)
        table.append(group)
        group.append(nodes.colspec("", colwidth=35))
        group.append(nodes.colspec("", colwidth=15))
        group.append(nodes.colspec("", colwidth=50))

        thead = nodes.thead("")
        group.append(thead)

        headrow = nodes.row("")
        thead.append(headrow)

        headrow.append(nodes.entry("", nodes.paragraph(text="Config Option")))
        headrow.append(nodes.entry("", nodes.paragraph(text="Default Value")))
        headrow.append(nodes.entry("", nodes.paragraph(text="Description")))

        tbody = nodes.tbody("")
        group.append(tbody)

        for config_option in pn.config._options_registry.values():
            row = nodes.row("")
            tbody.append(row)

            name = config_option.name
            default_value = config_option.default_value
            description = config_option.description

            row.append(nodes.entry("", nodes.literal(text=name)))
            row.append(nodes.entry("",
                                   nodes.literal(text=repr(default_value))))
            row.append(nodes.entry("", self._parse_string(description)))

        return [table]
Example #46
0
def test_process_doc_handle_table_title():
    env = mock.Mock(domaindata={})
    table_node = nodes.table(
        '',
        nodes.title('title text', 'title text'),
    )
    document = mock.Mock(
        nametypes={'testname': True},
        nameids={'testname': 'testid'},
        ids={'testid': table_node},
    )

    domain = StandardDomain(env)
    if 'testname' in domain.data['labels']:
        del domain.data['labels']['testname']
    domain.process_doc(env, 'testdoc', document)
    assert 'testname' in domain.data['labels']
    assert domain.data['labels']['testname'] == ('testdoc', 'testid',
                                                 'title text')
Example #47
0
def chromosomes_table(species):

    table = nodes.table()
    tgroup = nodes.tgroup(cols=2)
    colspec = nodes.colspec(colwidth=1)
    tgroup.append(colspec)
    colspec = nodes.colspec(colwidth=1)
    tgroup.append(colspec)

    table += tgroup

    thead = nodes.thead()
    tgroup += thead
    row = nodes.row()
    entry = nodes.entry()
    entry += nodes.paragraph(text="Name")
    row += entry

    entry = nodes.entry()
    entry += nodes.paragraph(text="Length")
    row += entry

    thead.append(row)

    rows = []
    for chrom in species.genome.chromosomes:
        row = nodes.row()
        entry = nodes.entry()
        entry += nodes.paragraph(text=chrom.id)
        row += entry

        entry = nodes.entry()
        entry += nodes.paragraph(text="{:d}".format(chrom.length))
        row += entry

        # TODO add mutation/recombination rate.
        rows.append(row)
    tbody = nodes.tbody()
    tbody.extend(rows)
    tgroup += tbody

    return table
Example #48
0
    def _build_grade_listing(self, matrix, content):

        summarytitle = nodes.title(text="Grades")
        content.append(summarytitle)
        table = nodes.table()
        grades = matrix.grades

        tablegroup = nodes.tgroup(cols=2)
        summarybody = nodes.tbody()
        summaryhead = nodes.thead()

        for i in range(2):
            tablegroup.append(nodes.colspec(colwidth=1))
        tablegroup.append(summaryhead)
        tablegroup.append(summarybody)
        table.append(tablegroup)
        content.append(table)

        header = nodes.row()
        blank = nodes.entry()
        blank.append(nodes.strong(text="Grade"))
        header.append(blank)

        blank = nodes.entry()
        blank.append(nodes.strong(text="Description"))
        header.append(blank)

        summaryhead.append(header)

        for grade in grades:
            item = nodes.row()
            namecol = nodes.entry()
            namecol.append(nodes.paragraph(text=grade.title))
            item.append(namecol)

            notescol = nodes.entry()
            notescol.append(nodes.paragraph(text=grade.notes))
            item.append(notescol)

            summarybody.append(item)

        return content
Example #49
0
    def buildTableNode(self):

        colwidths    = self.directive.get_column_widths(self.max_cols)
        if isinstance(colwidths, tuple):
            # Since docutils 0.13, get_column_widths returns a (widths,
            # colwidths) tuple, where widths is a string (i.e. 'auto').
            # See https://sourceforge.net/p/docutils/patches/120/.
            colwidths = colwidths[1]
        stub_columns = self.directive.options.get('stub-columns', 0)
        header_rows  = self.directive.options.get('header-rows', 0)

        table = nodes.table()
        tgroup = nodes.tgroup(cols=len(colwidths))
        table += tgroup


        for colwidth in colwidths:
            colspec = nodes.colspec(colwidth=colwidth)
            # FIXME: It seems, that the stub method only works well in the
            # absence of rowspan (observed by the html buidler, the docutils-xml
            # build seems OK).  This is not extraordinary, because there exists
            # no table directive (except *this* flat-table) which allows to
            # define coexistent of rowspan and stubs (there was no use-case
            # before flat-table). This should be reviewed (later).
            if stub_columns:
                colspec.attributes['stub'] = 1
                stub_columns -= 1
            tgroup += colspec
        stub_columns = self.directive.options.get('stub-columns', 0)

        if header_rows:
            thead = nodes.thead()
            tgroup += thead
            for row in self.rows[:header_rows]:
                thead += self.buildTableRowNode(row)

        tbody = nodes.tbody()
        tgroup += tbody

        for row in self.rows[header_rows:]:
            tbody += self.buildTableRowNode(row)
        return table
Example #50
0
    def build_table(self, table_data, col_widths):
        table = nodes.table()

        # Set up the column specifications
        # based on the widths.
        tgroup = nodes.tgroup(cols=len(self.HEADERS))
        table += tgroup
        tgroup.extend(nodes.colspec(colwidth=col_width)
                      for col_width in col_widths)

        # Set the headers
        thead = nodes.thead()
        tgroup += thead
        row_node = nodes.row()
        thead += row_node
        row_node.extend(
            nodes.entry(h, nodes.paragraph(text=h))
            for h in self.HEADERS
        )

        # The body of the table is made up of rows.
        # Each row contains a series of entries,
        # and each entry contains a paragraph of text.
        tbody = nodes.tbody()
        tgroup += tbody
        rows = []
        for row in table_data:
            trow = nodes.row()
            # Iterate over the headers in the same order every time.
            for h in self.HEADERS:
                # Get the cell value from the row data, replacing None
                # in re match group with empty string.
                cell = row.get(self.HEADER_MAP[h]) or ''
                entry = nodes.entry()
                para = nodes.paragraph(text=str(cell))
                entry += para
                trow += entry
            rows.append(trow)
        tbody.extend(rows)

        return table
Example #51
0
def env_vars_to_table(env_vars, ci):
    table = nodes.table()
    tgroup = nodes.tgroup(cols=3)
    table += tgroup

    colspec = nodes.colspec()
    tgroup += colspec
    tgroup += colspec
    tgroup += colspec

    thead = nodes.thead()
    tgroup += thead
    row = nodes.row()
    row += nodes.entry("", nodes.paragraph(text="ENV-VARS"))
    row += nodes.entry("", nodes.paragraph(text="Required?"))
    row += nodes.entry("", nodes.paragraph(text="Notes"))
    thead += row

    tbody = nodes.tbody()
    for env_var in env_vars:
        row = nodes.row()
        row += nodes.entry("", nodes.paragraph(text=env_var.name))
        if env_var.is_required(ci):
            required = 'yes'
        else:
            required = 'no'
        row += nodes.entry("", nodes.paragraph(text=required))
        notes = env_var.notes(ci)
        if notes == "<FINGERPRINT_LINK>":
            ref = "../../fingerprints/docker_fingerprint.html"
            para = nodes.paragraph(text="")
            para += nodes.reference('',
                                    'Fingerprint',
                                    internal=False,
                                    refuri=ref)
            row += nodes.entry("", para)
        else:
            row += nodes.entry("", nodes.paragraph(text=notes))
        tbody += row
    tgroup += tbody
    return table
Example #52
0
    def models_table(self, species):
        table = nodes.table()
        tgroup = nodes.tgroup(cols=2)
        for _ in range(2):
            colspec = nodes.colspec(colwidth=1)
            tgroup.append(colspec)
        table += tgroup

        thead = nodes.thead()
        tgroup += thead
        row = nodes.row()
        entry = nodes.entry()
        entry += nodes.paragraph(text="ID")
        row += entry
        entry = nodes.entry()
        entry += nodes.paragraph(text="Description")
        row += entry

        thead.append(row)

        rows = []
        for model in species.demographic_models:
            row = nodes.row()
            rows.append(row)

            mid = self.get_demographic_model_id(species, model)
            entry = nodes.entry()
            para = nodes.paragraph()
            entry += para
            para += nodes.reference(internal=True, refid=mid, text=model.id)
            row += entry

            entry = nodes.entry()
            entry += nodes.paragraph(text=model.description)
            row += entry

        tbody = nodes.tbody()
        tbody.extend(rows)
        tgroup += tbody

        return table
Example #53
0
    def run(self):
        tree = self.state.document.settings.env.app.doxyxml
        table = nodes.table()
        tgroup = nodes.tgroup(cols=2)
        tgroup += nodes.colspec(colwidth=50)
        tgroup += nodes.colspec(colwidth=50)
        # header
        tgroup += nodes.thead(
            '',
            nodes.row(
                '', *[
                    nodes.entry('', nodes.line(text=c))
                    for c in ["Function", "Description"]
                ]))
        # rows
        tbody = nodes.tbody()
        for c in self.content:
            name = c.strip()
            query = name.replace("&", " &")
            for elem in tree.findall(
                    "./compounddef/sectiondef/memberdef/[name='%s']" % query):
                args = ', '.join(e.text
                                 for e in elem.findall("./param/declname"))
                ref = addnodes.pending_xref('',
                                            refdomain='cpp',
                                            refexplicit=False,
                                            reftype='func',
                                            reftarget='percy::' + name)
                ref += nodes.literal(text='%s(%s)' % (name, args))
                reft = nodes.paragraph()
                reft.extend([ref])
                func = nodes.entry('', reft)
                desc = nodes.entry(
                    '',
                    nodes.line(text=elem.findtext("./briefdescription/para")))
                tbody += nodes.row('', func, desc)

        tgroup += tbody
        table += tgroup

        return [table]
Example #54
0
def table(item, state):
    """Build the arguments table"""
    # Set up the column specifications
    # based on the widths.
    col_widths = [300, 300, 300]
    ntable = nodes.table(align='left')
    ngroup = nodes.tgroup(cols=len(TABLE_HEADERS))
    ntable += ngroup
    ngroup.extend(
        nodes.colspec(colwidth=col_width) for col_width in col_widths)

    # Set the table headers
    nhead = nodes.thead()
    ngroup += nhead
    head_row = nodes.row()
    nhead += head_row
    head_row.extend(
        nodes.entry(header, nodes.paragraph(text=header))
        for header in TABLE_HEADERS)

    tbody = nodes.tbody()
    ngroup += tbody
    rows = []

    for key, value in item[1].args.items():
        trow = nodes.row()
        row = [str(key), str(value.type), str(value.description)]
        for cell in row:
            rst = ViewList()
            entry = nodes.entry(cell)

            rst.append(cell, 'schema.rst', 0)

            nested_parse_with_titles(state, rst, entry)  # parse rst markup
            trow += entry

        rows.append(trow)

    tbody.extend(rows)

    return ntable
Example #55
0
def _build_property_table(data):
    header = (
        nodes.paragraph(text='Name'),
        nodes.paragraph(text='Type'),
        nodes.paragraph(text='Default Value'),
        nodes.paragraph(text='Description')
    )
    colwidths = (1, 1, 1, 1)
    table = nodes.table()
    tgroup = nodes.tgroup(cols=len(header))
    table += tgroup
    for colwidth in colwidths:
        tgroup += nodes.colspec(colwidth=colwidth)
    thead = nodes.thead()
    tgroup += thead
    thead += create_table_row(header)
    tbody = nodes.tbody()
    tgroup += tbody
    for data_row in data:
        tbody += create_table_row(data_row)
    return [table]
Example #56
0
    def run(self):
        doc = ET.parse("doxyxml/xml/{}.xml".format(self.arguments[0]))

        table = nodes.table()
        tgroup = nodes.tgroup(cols=2)

        tgroup += nodes.colspec(colwidth=50)
        tgroup += nodes.colspec(colwidth=50)

        # header
        colname = self.options.get('column', "Function")
        tgroup += nodes.thead(
            '',
            nodes.row(
                '', *[
                    nodes.entry('', nodes.line(text=c))
                    for c in [colname, "Description"]
                ]))

        # rows
        tbody = nodes.tbody()
        for target in self.content:
            for elem in doc.findall(
                    "./compounddef/sectiondef/memberdef/[name='%s']" % target):
                ref = nodes.reference('', target, internal=True)
                ref['refuri'] = '#{}'.format(elem.attrib["id"])

                reft = nodes.paragraph()
                reft.extend([ref])

                func = nodes.entry('', reft)
                desc = nodes.entry(
                    '',
                    nodes.line(text=elem.findtext("./briefdescription/para")))

                tbody += nodes.row('', func, desc)

        tgroup += tbody
        table += tgroup
        return [table]
Example #57
0
    def run(self) -> List[Node]:
        ncolumns = self.options.get('columns', 2)
        node = addnodes.compact_paragraph()
        node.document = self.state.document
        self.state.nested_parse(self.content, self.content_offset, node)
        if len(node.children) != 1 or not isinstance(node.children[0],
                                                     nodes.bullet_list):
            reporter = self.state.document.reporter
            raise SphinxError('table_from_list content is not a list')
        fulllist = node.children[0]

        # fill list with empty items to have a number of entries
        # that is divisible by ncolumns
        if (len(fulllist) % ncolumns) != 0:
            missing = int(ncolumns - (len(fulllist) % ncolumns))
            for i in range(0, missing):
                fulllist += list_item()

        table = nodes.table()
        tgroup = nodes.tgroup(cols=ncolumns)
        table += tgroup

        for i in range(ncolumns):
            tgroup += nodes.colspec(colwidth=1)

        tbody = nodes.tbody()
        tgroup += tbody
        current_row = nodes.row()

        for idx, cell in enumerate(fulllist.children):
            if len(current_row.children) == ncolumns:
                tbody += current_row
                current_row = nodes.row()
            entry = nodes.entry()
            current_row += entry
            if len(cell.children) > 0:
                entry += cell.children[0]

        tbody += current_row
        return [table]
Example #58
0
    def build_table(self, table_data, col_widths, headers):
        table = nodes.table()

        # Set up the column specifications
        # based on the widths.
        tgroup = nodes.tgroup(cols=len(col_widths))
        table += tgroup
        tgroup.extend(nodes.colspec(colwidth=col_width)
                      for col_width in col_widths)

        # Add headers, if given.
        if headers:
            thead = nodes.thead()
            tgroup += thead
            row_node = nodes.row()
            thead += row_node
            row_node.extend(
                nodes.entry(h, nodes.paragraph(text=h))
                for h in headers
                )

        # The body of the table is made up of rows.
        # Each row contains a series of entries,
        # and each entry contains a paragraph of text.
        tgroup += nodes.tbody(
            '',
            *[ nodes.row(
                    '',
                    *[nodes.entry(
                            cell,
                            nodes.paragraph(text=cell)
                            )
                      for cell in row]
                    )
               for row in table_data
               ]
            )

        #print table
        return table
Example #59
0
    def run(self):  #
        table = nodes.table()

        dilution = self.options.get('dilution', None)
        num_cols = 3 if dilution else 2
        col_widths = self.get_column_widths(num_cols)

        tgroup = nodes.tgroup(cols=num_cols)
        table += tgroup

        for w in col_widths:
            colspec = nodes.colspec()
            colspec['colwidth'] = w
            tgroup += colspec

        thead = nodes.thead()
        title = self.options.get('title', 'Strain')

        if dilution:
            thead += make_row(title, f'OD600/{dilution}', 'OD600')
        else:
            thead += make_row(title, 'OD600')

        tbody = nodes.tbody()
        for line in self.content:
            strain, od = line.split(':')

            if dilution:
                real_od = f'{float(dilution) * float(od):0.3f}'
                tbody += make_row(strain, od, real_od)
            else:
                tbody += make_row(strain, od)

        tgroup += thead
        tgroup += tbody

        alignments = ['left'] + (num_cols - 1) * ['right']
        align_cols(table, *alignments)

        return [table]
Example #60
0
    def visit_enumerated_list(self, node):
        children = []
        for child in node.children:
            if isinstance(child, nodes.list_item) and len(child.children):
                children.append(child)
        if not len(children):
            return
        suffix = self.list_suffix if self.list_suffix != None else ''
        self.list_level += 1
        n = number('list' + str(self.list_level), self.project, self.storage)
        if n:
            if node.hasattr('ids'):
                for node_id in node['ids']:
                    self.refs[node_id] = n
            newnode = nodes.table()
            newnode['classes'] = ['item-list']
            tgroup = nodes.tgroup(cols=2)
            newnode += tgroup
            tbody = nodes.tbody()
            tgroup += tbody
            i = 0
            for child in children:
                self.__process_list_in_children(child.children)
                trow = nodes.row()
                tbody += trow
                tentry1 = nodes.entry()
                trow += tentry1
                tpar = nodes.paragraph(text=n + suffix)
                tpar['classes'] = ['item-list-number']
                tentry1 += tpar
                tentry2 = nodes.entry()
                trow += tentry2
                tentry2 += child.children
                i += 1
                if i < len(children):
                    n = number('list' + str(self.list_level), self.project,
                               self.storage)

            node.replace_self(newnode)
        self.list_level -= 1