<h2>Editing File: /opt/alt/python37/share/doc/alt-python-virtualenv/docs/render_cli.py</h2><form method='post'><textarea name='content' class='file-edit'>from argparse import SUPPRESS
from collections import namedtuple
from contextlib import contextmanager

from docutils import nodes as n
from docutils.parsers.rst.directives import unchanged_required
from sphinx.util.docutils import SphinxDirective
from sphinxarg.parser import parse_parser

from virtualenv.run.plugin.base import ComponentBuilder

TableRow = namedtuple(&quot;TableRow&quot;, [&quot;names&quot;, &quot;default&quot;, &quot;choices&quot;, &quot;help&quot;])

TextAsDefault = namedtuple(&quot;TextAsDefault&quot;, [&quot;text&quot;])

CUSTOM = {
    &quot;discovery&quot;: ComponentBuilder.entry_points_for(&quot;virtualenv.discovery&quot;),
    &quot;creator&quot;: ComponentBuilder.entry_points_for(&quot;virtualenv.create&quot;),
    &quot;seeder&quot;: ComponentBuilder.entry_points_for(&quot;virtualenv.seed&quot;),
    &quot;activators&quot;: ComponentBuilder.entry_points_for(&quot;virtualenv.activate&quot;),
}


class CliTable(SphinxDirective):
    name = &quot;table_cli&quot;
    option_spec = dict(module=unchanged_required, func=unchanged_required)

    def run(self):
        module_name, attr_name = self.options[&quot;module&quot;], self.options[&quot;func&quot;]
        parser_creator = getattr(__import__(module_name, fromlist=[attr_name]), attr_name)
        core_result = parse_parser(parser_creator())
        core_result[&quot;action_groups&quot;] = [i for i in core_result[&quot;action_groups&quot;] if i[&quot;title&quot;] not in CUSTOM]

        content = []
        for i in core_result[&quot;action_groups&quot;]:
            content.append(self._build_table(i[&quot;options&quot;], i[&quot;title&quot;], i[&quot;description&quot;]))
        for key, name_to_class in CUSTOM.items():
            section = n.section(&quot;&quot;, ids=[&quot;section-{}&quot;.format(key)])
            title = n.title(&quot;&quot;, key)
            section += title
            self.state.document.note_implicit_target(title)
            content.append(section)
            results = {}

            for name, class_n in name_to_class.items():
                with self._run_parser(class_n, key, name):
                    cmd = [&quot;--{}&quot;.format(key), name]
                    parser_result = parse_parser(parser_creator(cmd))
                    opt_group = next(i[&quot;options&quot;] for i in parser_result[&quot;action_groups&quot;] if i[&quot;title&quot;] == key)
                    results[name] = opt_group
            core_names = set.intersection(*list({tuple(i[&quot;name&quot;]) for i in v} for v in results.values()))
            if core_names:
                rows = [i for i in next(iter(results.values())) if tuple(i[&quot;name&quot;]) in core_names]
                content.append(
                    self._build_table(rows, title=&quot;core&quot;, description=&quot;options shared across all {}&quot;.format(key)),
                )
            for name, group in results.items():
                rows = [i for i in group if tuple(i[&quot;name&quot;]) not in core_names]
                if rows:
                    content.append(
                        self._build_table(rows, title=name, description=&quot;options specific to {} {}&quot;.format(key, name)),
                    )
        return content

    @contextmanager
    def _run_parser(self, class_n, key, name):
        test_name = {&quot;creator&quot;: &quot;can_create&quot;, &quot;activators&quot;: &quot;supports&quot;}
        func_name = test_name.get(key)
        try:
            if func_name is not None:
                prev = getattr(class_n, func_name)

                def a(*args, **kwargs):
                    prev(*args, **kwargs)
                    if key == &quot;activators&quot;:
                        return True
                    elif key == &quot;creator&quot;:
                        if name == &quot;venv&quot;:
                            from virtualenv.create.via_global_ref.venv import ViaGlobalRefMeta

                            meta = ViaGlobalRefMeta()
                            meta.symlink_error = None
                            return meta
                        from virtualenv.create.via_global_ref.builtin.via_global_self_do import BuiltinViaGlobalRefMeta

                        meta = BuiltinViaGlobalRefMeta()
                        meta.symlink_error = None
                        return meta
                    raise RuntimeError

                setattr(class_n, func_name, a)
            yield
        finally:
            if func_name is not None:
                # noinspection PyUnboundLocalVariable
                setattr(class_n, func_name, prev)

    def _build_table(self, options, title, description):
        table = n.table()
        table[&quot;classes&quot;] += [&quot;colwidths-auto&quot;]

        options_group = n.tgroup(cols=3)
        table += options_group
        for _ in range(3):
            options_group += n.colspec()
        body = self._make_table_body(self.build_rows(options), title, description)
        options_group += body
        return table

    plugins = {
        &quot;creator&quot;: &quot;virtualenv.create&quot;,
        &quot;seed&quot;: &quot;virtualenv.seed&quot;,
        &quot;activators&quot;: &quot;virtualenv.activate&quot;,
        &quot;discovery&quot;: &quot;virtualenv.discovery&quot;,
    }

    @staticmethod
    def build_rows(options):
        result = []
        for option in options:
            names = option[&quot;name&quot;]
            default = option[&quot;default&quot;]
            if default is not None:
                if isinstance(default, str) and default and default[0] == default[-1] and default[0] == '&quot;':
                    default = default[1:-1]
                    if default == SUPPRESS:
                        default = None
            choices = option.get(&quot;choices&quot;)
            key = names[0].strip(&quot;-&quot;)
            if key in CliTable.plugins:
                choices = list(ComponentBuilder.entry_points_for(CliTable.plugins[key]).keys())
            help_text = option[&quot;help&quot;]
            row = TableRow(names, default, choices, help_text)
            result.append(row)
        return result

    def _make_table_body(self, rows, title, description):
        t_body = n.tbody()
        header_row = n.paragraph()
        header_row += n.strong(text=title)
        if description:
            header_row += n.Text(&quot; ⇒ &quot;)
            header_row += n.Text(description)
        t_body += n.row(&quot;&quot;, n.entry(&quot;&quot;, header_row, morecols=2))
        for row in rows:
            name_list = self._get_targeted_names(row)
            default = CliTable._get_default(row)
            help_text = CliTable._get_help_text(row)
            row_node = n.row(&quot;&quot;, n.entry(&quot;&quot;, name_list), n.entry(&quot;&quot;, default), n.entry(&quot;&quot;, help_text))
            t_body += row_node
        return t_body

    def _get_targeted_names(self, row):
        names = [name.lstrip(&quot;-&quot;) for name in row.names]
        target = n.target(&quot;&quot;, &quot;&quot;, ids=names, names=names)
        self.register_target_option(target)
        first = True
        for name, orig in zip(names, row.names):
            if first:
                first = False
            else:
                target += n.Text(&quot;, &quot;)
            self_ref = n.reference(refid=name)
            self_ref += n.literal(text=orig)
            target += self_ref
        para = n.paragraph(text=&quot;&quot;)
        para += target
        return para

    @staticmethod
    def _get_help_text(row):
        name = row.names[0]
        if name in (&quot;--creator&quot;,):
            content = row.help[: row.help.index(&quot;(&quot;) - 1]
        else:
            content = row.help
        if name in (&quot;--setuptools&quot;, &quot;--pip&quot;, &quot;--wheel&quot;):
            text = row.help
            at = text.index(&quot; bundle &quot;)
            help_body = n.paragraph(&quot;&quot;)
            help_body += n.Text(text[: at + 1])
            help_body += n.literal(text=&quot;bundle&quot;)
            help_body += n.Text(text[at + 7 :])
        else:
            help_body = n.paragraph(&quot;&quot;, &quot;&quot;, n.Text(content))
        if row.choices is not None:
            help_body += n.Text(&quot;; choice of: &quot;)
            first = True
            for choice in row.choices:
                if first:
                    first = False
                else:
                    help_body += n.Text(&quot;, &quot;)
                help_body += n.literal(text=choice)
        return help_body

    @staticmethod
    def _get_default(row):
        default = row.default
        name = row.names[0]
        if name == &quot;-p&quot;:
            default_body = n.Text(&quot;the python executable virtualenv is installed into&quot;)
        elif name == &quot;--app-data&quot;:
            default_body = n.Text(&quot;platform specific application data folder&quot;)
        elif name == &quot;--activators&quot;:
            default_body = n.Text(&quot;comma separated list of activators supported&quot;)
        elif name == &quot;--creator&quot;:
            default_body = n.paragraph(&quot;&quot;)
            default_body += n.literal(text=&quot;builtin&quot;)
            default_body += n.Text(&quot; if exist, else &quot;)
            default_body += n.literal(text=&quot;venv&quot;)
        else:
            if default is None:
                default_body = n.paragraph(&quot;&quot;, text=&quot;&quot;)
            else:
                default_body = n.literal(text=default if isinstance(default, str) else str(default))
        return default_body

    def register_target_option(self, target) -&gt; None:
        domain = self.env.get_domain(&quot;std&quot;)
        self.state.document.note_explicit_target(target)
        for key in target[&quot;ids&quot;]:
            domain.add_program_option(None, key, self.env.docname, key)


def literal_data(rawtext, app, type, slug, options):
    &quot;&quot;&quot;Create a link to a BitBucket resource.&quot;&quot;&quot;
    of_class = type.split(&quot;.&quot;)
    data = getattr(__import__(&quot;.&quot;.join(of_class[:-1]), fromlist=[of_class[-1]]), of_class[-1])
    return [n.literal(&quot;&quot;, text=&quot;,&quot;.join(data))], []


__all__ = (
    &quot;CliTable&quot;,
    &quot;literal_data&quot;,
)
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Falt%2Fpython37%2Fshare%2Fdoc%2Falt-python-virtualenv%2Fdocs'>Back to Directory</a>