Remove windows python distribution from repo and add requirements.txt

1 files changed, 0 insertions, 256 deletions

diff --git a/python/click/formatting.py b/python/click/formatting.py
deleted file mode 100644
index a3d6a4d..0000000
--- a/python/click/formatting.py
+++ /dev/null
@@ -1,256 +0,0 @@
-from contextlib import contextmanager
-from .termui import get_terminal_size
-from .parser import split_opt
-from ._compat import term_len
-
-
-# Can force a width.  This is used by the test system
-FORCED_WIDTH = None
-
-
-def measure_table(rows):
-    widths = {}
-    for row in rows:
-        for idx, col in enumerate(row):
-            widths[idx] = max(widths.get(idx, 0), term_len(col))
-    return tuple(y for x, y in sorted(widths.items()))
-
-
-def iter_rows(rows, col_count):
-    for row in rows:
-        row = tuple(row)
-        yield row + ('',) * (col_count - len(row))
-
-
-def wrap_text(text, width=78, initial_indent='', subsequent_indent='',
-              preserve_paragraphs=False):
-    """A helper function that intelligently wraps text.  By default, it
-    assumes that it operates on a single paragraph of text but if the
-    `preserve_paragraphs` parameter is provided it will intelligently
-    handle paragraphs (defined by two empty lines).
-
-    If paragraphs are handled, a paragraph can be prefixed with an empty
-    line containing the ``\\b`` character (``\\x08``) to indicate that
-    no rewrapping should happen in that block.
-
-    :param text: the text that should be rewrapped.
-    :param width: the maximum width for the text.
-    :param initial_indent: the initial indent that should be placed on the
-                           first line as a string.
-    :param subsequent_indent: the indent string that should be placed on
-                              each consecutive line.
-    :param preserve_paragraphs: if this flag is set then the wrapping will
-                                intelligently handle paragraphs.
-    """
-    from ._textwrap import TextWrapper
-    text = text.expandtabs()
-    wrapper = TextWrapper(width, initial_indent=initial_indent,
-                          subsequent_indent=subsequent_indent,
-                          replace_whitespace=False)
-    if not preserve_paragraphs:
-        return wrapper.fill(text)
-
-    p = []
-    buf = []
-    indent = None
-
-    def _flush_par():
-        if not buf:
-            return
-        if buf[0].strip() == '\b':
-            p.append((indent or 0, True, '\n'.join(buf[1:])))
-        else:
-            p.append((indent or 0, False, ' '.join(buf)))
-        del buf[:]
-
-    for line in text.splitlines():
-        if not line:
-            _flush_par()
-            indent = None
-        else:
-            if indent is None:
-                orig_len = term_len(line)
-                line = line.lstrip()
-                indent = orig_len - term_len(line)
-            buf.append(line)
-    _flush_par()
-
-    rv = []
-    for indent, raw, text in p:
-        with wrapper.extra_indent(' ' * indent):
-            if raw:
-                rv.append(wrapper.indent_only(text))
-            else:
-                rv.append(wrapper.fill(text))
-
-    return '\n\n'.join(rv)
-
-
-class HelpFormatter(object):
-    """This class helps with formatting text-based help pages.  It's
-    usually just needed for very special internal cases, but it's also
-    exposed so that developers can write their own fancy outputs.
-
-    At present, it always writes into memory.
-
-    :param indent_increment: the additional increment for each level.
-    :param width: the width for the text.  This defaults to the terminal
-                  width clamped to a maximum of 78.
-    """
-
-    def __init__(self, indent_increment=2, width=None, max_width=None):
-        self.indent_increment = indent_increment
-        if max_width is None:
-            max_width = 80
-        if width is None:
-            width = FORCED_WIDTH
-            if width is None:
-                width = max(min(get_terminal_size()[0], max_width) - 2, 50)
-        self.width = width
-        self.current_indent = 0
-        self.buffer = []
-
-    def write(self, string):
-        """Writes a unicode string into the internal buffer."""
-        self.buffer.append(string)
-
-    def indent(self):
-        """Increases the indentation."""
-        self.current_indent += self.indent_increment
-
-    def dedent(self):
-        """Decreases the indentation."""
-        self.current_indent -= self.indent_increment
-
-    def write_usage(self, prog, args='', prefix='Usage: '):
-        """Writes a usage line into the buffer.
-
-        :param prog: the program name.
-        :param args: whitespace separated list of arguments.
-        :param prefix: the prefix for the first line.
-        """
-        usage_prefix = '%*s%s ' % (self.current_indent, prefix, prog)
-        text_width = self.width - self.current_indent
-
-        if text_width >= (term_len(usage_prefix) + 20):
-            # The arguments will fit to the right of the prefix.
-            indent = ' ' * term_len(usage_prefix)
-            self.write(wrap_text(args, text_width,
-                                 initial_indent=usage_prefix,
-                                 subsequent_indent=indent))
-        else:
-            # The prefix is too long, put the arguments on the next line.
-            self.write(usage_prefix)
-            self.write('\n')
-            indent = ' ' * (max(self.current_indent, term_len(prefix)) + 4)
-            self.write(wrap_text(args, text_width,
-                                 initial_indent=indent,
-                                 subsequent_indent=indent))
-
-        self.write('\n')
-
-    def write_heading(self, heading):
-        """Writes a heading into the buffer."""
-        self.write('%*s%s:\n' % (self.current_indent, '', heading))
-
-    def write_paragraph(self):
-        """Writes a paragraph into the buffer."""
-        if self.buffer:
-            self.write('\n')
-
-    def write_text(self, text):
-        """Writes re-indented text into the buffer.  This rewraps and
-        preserves paragraphs.
-        """
-        text_width = max(self.width - self.current_indent, 11)
-        indent = ' ' * self.current_indent
-        self.write(wrap_text(text, text_width,
-                             initial_indent=indent,
-                             subsequent_indent=indent,
-                             preserve_paragraphs=True))
-        self.write('\n')
-
-    def write_dl(self, rows, col_max=30, col_spacing=2):
-        """Writes a definition list into the buffer.  This is how options
-        and commands are usually formatted.
-
-        :param rows: a list of two item tuples for the terms and values.
-        :param col_max: the maximum width of the first column.
-        :param col_spacing: the number of spaces between the first and
-                            second column.
-        """
-        rows = list(rows)
-        widths = measure_table(rows)
-        if len(widths) != 2:
-            raise TypeError('Expected two columns for definition list')
-
-        first_col = min(widths[0], col_max) + col_spacing
-
-        for first, second in iter_rows(rows, len(widths)):
-            self.write('%*s%s' % (self.current_indent, '', first))
-            if not second:
-                self.write('\n')
-                continue
-            if term_len(first) <= first_col - col_spacing:
-                self.write(' ' * (first_col - term_len(first)))
-            else:
-                self.write('\n')
-                self.write(' ' * (first_col + self.current_indent))
-
-            text_width = max(self.width - first_col - 2, 10)
-            lines = iter(wrap_text(second, text_width).splitlines())
-            if lines:
-                self.write(next(lines) + '\n')
-                for line in lines:
-                    self.write('%*s%s\n' % (
-                        first_col + self.current_indent, '', line))
-            else:
-                self.write('\n')
-
-    @contextmanager
-    def section(self, name):
-        """Helpful context manager that writes a paragraph, a heading,
-        and the indents.
-
-        :param name: the section name that is written as heading.
-        """
-        self.write_paragraph()
-        self.write_heading(name)
-        self.indent()
-        try:
-            yield
-        finally:
-            self.dedent()
-
-    @contextmanager
-    def indentation(self):
-        """A context manager that increases the indentation."""
-        self.indent()
-        try:
-            yield
-        finally:
-            self.dedent()
-
-    def getvalue(self):
-        """Returns the buffer contents."""
-        return ''.join(self.buffer)
-
-
-def join_options(options):
-    """Given a list of option strings this joins them in the most appropriate
-    way and returns them in the form ``(formatted_string,
-    any_prefix_is_slash)`` where the second item in the tuple is a flag that
-    indicates if any of the option prefixes was a slash.
-    """
-    rv = []
-    any_prefix_is_slash = False
-    for opt in options:
-        prefix = split_opt(opt)[0]
-        if prefix == '/':
-            any_prefix_is_slash = True
-        rv.append((len(prefix), opt))
-
-    rv.sort(key=lambda x: x[0])
-
-    rv = ', '.join(x[1] for x in rv)
-    return rv, any_prefix_is_slash