Remove windows python distribution from repo and add requirements.txt

1 files changed, 0 insertions, 484 deletions

diff --git a/python/werkzeug/_internal.py b/python/werkzeug/_internal.py
deleted file mode 100644
index 90e3dd9..0000000
--- a/python/werkzeug/_internal.py
+++ /dev/null
@@ -1,484 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    werkzeug._internal
-    ~~~~~~~~~~~~~~~~~~
-
-    This module provides internally used helpers and constants.
-
-    :copyright: 2007 Pallets
-    :license: BSD-3-Clause
-"""
-import inspect
-import logging
-import re
-import string
-from datetime import date
-from datetime import datetime
-from itertools import chain
-from weakref import WeakKeyDictionary
-
-from ._compat import int_to_byte
-from ._compat import integer_types
-from ._compat import iter_bytes
-from ._compat import range_type
-from ._compat import text_type
-
-
-_logger = None
-_signature_cache = WeakKeyDictionary()
-_epoch_ord = date(1970, 1, 1).toordinal()
-_cookie_params = {
-    b"expires",
-    b"path",
-    b"comment",
-    b"max-age",
-    b"secure",
-    b"httponly",
-    b"version",
-}
-_legal_cookie_chars = (
-    string.ascii_letters + string.digits + u"/=!#$%&'*+-.^_`|~:"
-).encode("ascii")
-
-_cookie_quoting_map = {b",": b"\\054", b";": b"\\073", b'"': b'\\"', b"\\": b"\\\\"}
-for _i in chain(range_type(32), range_type(127, 256)):
-    _cookie_quoting_map[int_to_byte(_i)] = ("\\%03o" % _i).encode("latin1")
-
-_octal_re = re.compile(br"\\[0-3][0-7][0-7]")
-_quote_re = re.compile(br"[\\].")
-_legal_cookie_chars_re = br"[\w\d!#%&\'~_`><@,:/\$\*\+\-\.\^\|\)\(\?\}\{\=]"
-_cookie_re = re.compile(
-    br"""
-    (?P<key>[^=;]+)
-    (?:\s*=\s*
-        (?P<val>
-            "(?:[^\\"]|\\.)*" |
-             (?:.*?)
-        )
-    )?
-    \s*;
-""",
-    flags=re.VERBOSE,
-)
-
-
-class _Missing(object):
-    def __repr__(self):
-        return "no value"
-
-    def __reduce__(self):
-        return "_missing"
-
-
-_missing = _Missing()
-
-
-def _get_environ(obj):
-    env = getattr(obj, "environ", obj)
-    assert isinstance(env, dict), (
-        "%r is not a WSGI environment (has to be a dict)" % type(obj).__name__
-    )
-    return env
-
-
-def _has_level_handler(logger):
-    """Check if there is a handler in the logging chain that will handle
-    the given logger's effective level.
-    """
-    level = logger.getEffectiveLevel()
-    current = logger
-
-    while current:
-        if any(handler.level <= level for handler in current.handlers):
-            return True
-
-        if not current.propagate:
-            break
-
-        current = current.parent
-
-    return False
-
-
-def _log(type, message, *args, **kwargs):
-    """Log a message to the 'werkzeug' logger.
-
-    The logger is created the first time it is needed. If there is no
-    level set, it is set to :data:`logging.INFO`. If there is no handler
-    for the logger's effective level, a :class:`logging.StreamHandler`
-    is added.
-    """
-    global _logger
-
-    if _logger is None:
-        _logger = logging.getLogger("werkzeug")
-
-        if _logger.level == logging.NOTSET:
-            _logger.setLevel(logging.INFO)
-
-        if not _has_level_handler(_logger):
-            _logger.addHandler(logging.StreamHandler())
-
-    getattr(_logger, type)(message.rstrip(), *args, **kwargs)
-
-
-def _parse_signature(func):
-    """Return a signature object for the function."""
-    if hasattr(func, "im_func"):
-        func = func.im_func
-
-    # if we have a cached validator for this function, return it
-    parse = _signature_cache.get(func)
-    if parse is not None:
-        return parse
-
-    # inspect the function signature and collect all the information
-    if hasattr(inspect, "getfullargspec"):
-        tup = inspect.getfullargspec(func)
-    else:
-        tup = inspect.getargspec(func)
-    positional, vararg_var, kwarg_var, defaults = tup[:4]
-    defaults = defaults or ()
-    arg_count = len(positional)
-    arguments = []
-    for idx, name in enumerate(positional):
-        if isinstance(name, list):
-            raise TypeError(
-                "cannot parse functions that unpack tuples in the function signature"
-            )
-        try:
-            default = defaults[idx - arg_count]
-        except IndexError:
-            param = (name, False, None)
-        else:
-            param = (name, True, default)
-        arguments.append(param)
-    arguments = tuple(arguments)
-
-    def parse(args, kwargs):
-        new_args = []
-        missing = []
-        extra = {}
-
-        # consume as many arguments as positional as possible
-        for idx, (name, has_default, default) in enumerate(arguments):
-            try:
-                new_args.append(args[idx])
-            except IndexError:
-                try:
-                    new_args.append(kwargs.pop(name))
-                except KeyError:
-                    if has_default:
-                        new_args.append(default)
-                    else:
-                        missing.append(name)
-            else:
-                if name in kwargs:
-                    extra[name] = kwargs.pop(name)
-
-        # handle extra arguments
-        extra_positional = args[arg_count:]
-        if vararg_var is not None:
-            new_args.extend(extra_positional)
-            extra_positional = ()
-        if kwargs and kwarg_var is None:
-            extra.update(kwargs)
-            kwargs = {}
-
-        return (
-            new_args,
-            kwargs,
-            missing,
-            extra,
-            extra_positional,
-            arguments,
-            vararg_var,
-            kwarg_var,
-        )
-
-    _signature_cache[func] = parse
-    return parse
-
-
-def _date_to_unix(arg):
-    """Converts a timetuple, integer or datetime object into the seconds from
-    epoch in utc.
-    """
-    if isinstance(arg, datetime):
-        arg = arg.utctimetuple()
-    elif isinstance(arg, integer_types + (float,)):
-        return int(arg)
-    year, month, day, hour, minute, second = arg[:6]
-    days = date(year, month, 1).toordinal() - _epoch_ord + day - 1
-    hours = days * 24 + hour
-    minutes = hours * 60 + minute
-    seconds = minutes * 60 + second
-    return seconds
-
-
-class _DictAccessorProperty(object):
-    """Baseclass for `environ_property` and `header_property`."""
-
-    read_only = False
-
-    def __init__(
-        self,
-        name,
-        default=None,
-        load_func=None,
-        dump_func=None,
-        read_only=None,
-        doc=None,
-    ):
-        self.name = name
-        self.default = default
-        self.load_func = load_func
-        self.dump_func = dump_func
-        if read_only is not None:
-            self.read_only = read_only
-        self.__doc__ = doc
-
-    def __get__(self, obj, type=None):
-        if obj is None:
-            return self
-        storage = self.lookup(obj)
-        if self.name not in storage:
-            return self.default
-        rv = storage[self.name]
-        if self.load_func is not None:
-            try:
-                rv = self.load_func(rv)
-            except (ValueError, TypeError):
-                rv = self.default
-        return rv
-
-    def __set__(self, obj, value):
-        if self.read_only:
-            raise AttributeError("read only property")
-        if self.dump_func is not None:
-            value = self.dump_func(value)
-        self.lookup(obj)[self.name] = value
-
-    def __delete__(self, obj):
-        if self.read_only:
-            raise AttributeError("read only property")
-        self.lookup(obj).pop(self.name, None)
-
-    def __repr__(self):
-        return "<%s %s>" % (self.__class__.__name__, self.name)
-
-
-def _cookie_quote(b):
-    buf = bytearray()
-    all_legal = True
-    _lookup = _cookie_quoting_map.get
-    _push = buf.extend
-
-    for char in iter_bytes(b):
-        if char not in _legal_cookie_chars:
-            all_legal = False
-            char = _lookup(char, char)
-        _push(char)
-
-    if all_legal:
-        return bytes(buf)
-    return bytes(b'"' + buf + b'"')
-
-
-def _cookie_unquote(b):
-    if len(b) < 2:
-        return b
-    if b[:1] != b'"' or b[-1:] != b'"':
-        return b
-
-    b = b[1:-1]
-
-    i = 0
-    n = len(b)
-    rv = bytearray()
-    _push = rv.extend
-
-    while 0 <= i < n:
-        o_match = _octal_re.search(b, i)
-        q_match = _quote_re.search(b, i)
-        if not o_match and not q_match:
-            rv.extend(b[i:])
-            break
-        j = k = -1
-        if o_match:
-            j = o_match.start(0)
-        if q_match:
-            k = q_match.start(0)
-        if q_match and (not o_match or k < j):
-            _push(b[i:k])
-            _push(b[k + 1 : k + 2])
-            i = k + 2
-        else:
-            _push(b[i:j])
-            rv.append(int(b[j + 1 : j + 4], 8))
-            i = j + 4
-
-    return bytes(rv)
-
-
-def _cookie_parse_impl(b):
-    """Lowlevel cookie parsing facility that operates on bytes."""
-    i = 0
-    n = len(b)
-
-    while i < n:
-        match = _cookie_re.search(b + b";", i)
-        if not match:
-            break
-
-        key = match.group("key").strip()
-        value = match.group("val") or b""
-        i = match.end(0)
-
-        # Ignore parameters.  We have no interest in them.
-        if key.lower() not in _cookie_params:
-            yield _cookie_unquote(key), _cookie_unquote(value)
-
-
-def _encode_idna(domain):
-    # If we're given bytes, make sure they fit into ASCII
-    if not isinstance(domain, text_type):
-        domain.decode("ascii")
-        return domain
-
-    # Otherwise check if it's already ascii, then return
-    try:
-        return domain.encode("ascii")
-    except UnicodeError:
-        pass
-
-    # Otherwise encode each part separately
-    parts = domain.split(".")
-    for idx, part in enumerate(parts):
-        parts[idx] = part.encode("idna")
-    return b".".join(parts)
-
-
-def _decode_idna(domain):
-    # If the input is a string try to encode it to ascii to
-    # do the idna decoding.  if that fails because of an
-    # unicode error, then we already have a decoded idna domain
-    if isinstance(domain, text_type):
-        try:
-            domain = domain.encode("ascii")
-        except UnicodeError:
-            return domain
-
-    # Decode each part separately.  If a part fails, try to
-    # decode it with ascii and silently ignore errors.  This makes
-    # most sense because the idna codec does not have error handling
-    parts = domain.split(b".")
-    for idx, part in enumerate(parts):
-        try:
-            parts[idx] = part.decode("idna")
-        except UnicodeError:
-            parts[idx] = part.decode("ascii", "ignore")
-
-    return ".".join(parts)
-
-
-def _make_cookie_domain(domain):
-    if domain is None:
-        return None
-    domain = _encode_idna(domain)
-    if b":" in domain:
-        domain = domain.split(b":", 1)[0]
-    if b"." in domain:
-        return domain
-    raise ValueError(
-        "Setting 'domain' for a cookie on a server running locally (ex: "
-        "localhost) is not supported by complying browsers. You should "
-        "have something like: '127.0.0.1 localhost dev.localhost' on "
-        "your hosts file and then point your server to run on "
-        "'dev.localhost' and also set 'domain' for 'dev.localhost'"
-    )
-
-
-def _easteregg(app=None):
-    """Like the name says.  But who knows how it works?"""
-
-    def bzzzzzzz(gyver):
-        import base64
-        import zlib
-
-        return zlib.decompress(base64.b64decode(gyver)).decode("ascii")
-
-    gyver = u"\n".join(
-        [
-            x + (77 - len(x)) * u" "
-            for x in bzzzzzzz(
-                b"""
-eJyFlzuOJDkMRP06xRjymKgDJCDQStBYT8BCgK4gTwfQ2fcFs2a2FzvZk+hvlcRvRJD148efHt9m
-9Xz94dRY5hGt1nrYcXx7us9qlcP9HHNh28rz8dZj+q4rynVFFPdlY4zH873NKCexrDM6zxxRymzz
-4QIxzK4bth1PV7+uHn6WXZ5C4ka/+prFzx3zWLMHAVZb8RRUxtFXI5DTQ2n3Hi2sNI+HK43AOWSY
-jmEzE4naFp58PdzhPMdslLVWHTGUVpSxImw+pS/D+JhzLfdS1j7PzUMxij+mc2U0I9zcbZ/HcZxc
-q1QjvvcThMYFnp93agEx392ZdLJWXbi/Ca4Oivl4h/Y1ErEqP+lrg7Xa4qnUKu5UE9UUA4xeqLJ5
-jWlPKJvR2yhRI7xFPdzPuc6adXu6ovwXwRPXXnZHxlPtkSkqWHilsOrGrvcVWXgGP3daXomCj317
-8P2UOw/NnA0OOikZyFf3zZ76eN9QXNwYdD8f8/LdBRFg0BO3bB+Pe/+G8er8tDJv83XTkj7WeMBJ
-v/rnAfdO51d6sFglfi8U7zbnr0u9tyJHhFZNXYfH8Iafv2Oa+DT6l8u9UYlajV/hcEgk1x8E8L/r
-XJXl2SK+GJCxtnyhVKv6GFCEB1OO3f9YWAIEbwcRWv/6RPpsEzOkXURMN37J0PoCSYeBnJQd9Giu
-LxYQJNlYPSo/iTQwgaihbART7Fcyem2tTSCcwNCs85MOOpJtXhXDe0E7zgZJkcxWTar/zEjdIVCk
-iXy87FW6j5aGZhttDBoAZ3vnmlkx4q4mMmCdLtnHkBXFMCReqthSGkQ+MDXLLCpXwBs0t+sIhsDI
-tjBB8MwqYQpLygZ56rRHHpw+OAVyGgaGRHWy2QfXez+ZQQTTBkmRXdV/A9LwH6XGZpEAZU8rs4pE
-1R4FQ3Uwt8RKEtRc0/CrANUoes3EzM6WYcFyskGZ6UTHJWenBDS7h163Eo2bpzqxNE9aVgEM2CqI
-GAJe9Yra4P5qKmta27VjzYdR04Vc7KHeY4vs61C0nbywFmcSXYjzBHdiEjraS7PGG2jHHTpJUMxN
-Jlxr3pUuFvlBWLJGE3GcA1/1xxLcHmlO+LAXbhrXah1tD6Ze+uqFGdZa5FM+3eHcKNaEarutAQ0A
-QMAZHV+ve6LxAwWnXbbSXEG2DmCX5ijeLCKj5lhVFBrMm+ryOttCAeFpUdZyQLAQkA06RLs56rzG
-8MID55vqr/g64Qr/wqwlE0TVxgoiZhHrbY2h1iuuyUVg1nlkpDrQ7Vm1xIkI5XRKLedN9EjzVchu
-jQhXcVkjVdgP2O99QShpdvXWoSwkp5uMwyjt3jiWCqWGSiaaPAzohjPanXVLbM3x0dNskJsaCEyz
-DTKIs+7WKJD4ZcJGfMhLFBf6hlbnNkLEePF8Cx2o2kwmYF4+MzAxa6i+6xIQkswOqGO+3x9NaZX8
-MrZRaFZpLeVTYI9F/djY6DDVVs340nZGmwrDqTCiiqD5luj3OzwpmQCiQhdRYowUYEA3i1WWGwL4
-GCtSoO4XbIPFeKGU13XPkDf5IdimLpAvi2kVDVQbzOOa4KAXMFlpi/hV8F6IDe0Y2reg3PuNKT3i
-RYhZqtkQZqSB2Qm0SGtjAw7RDwaM1roESC8HWiPxkoOy0lLTRFG39kvbLZbU9gFKFRvixDZBJmpi
-Xyq3RE5lW00EJjaqwp/v3EByMSpVZYsEIJ4APaHmVtpGSieV5CALOtNUAzTBiw81GLgC0quyzf6c
-NlWknzJeCsJ5fup2R4d8CYGN77mu5vnO1UqbfElZ9E6cR6zbHjgsr9ly18fXjZoPeDjPuzlWbFwS
-pdvPkhntFvkc13qb9094LL5NrA3NIq3r9eNnop9DizWOqCEbyRBFJTHn6Tt3CG1o8a4HevYh0XiJ
-sR0AVVHuGuMOIfbuQ/OKBkGRC6NJ4u7sbPX8bG/n5sNIOQ6/Y/BX3IwRlTSabtZpYLB85lYtkkgm
-p1qXK3Du2mnr5INXmT/78KI12n11EFBkJHHp0wJyLe9MvPNUGYsf+170maayRoy2lURGHAIapSpQ
-krEDuNoJCHNlZYhKpvw4mspVWxqo415n8cD62N9+EfHrAvqQnINStetek7RY2Urv8nxsnGaZfRr/
-nhXbJ6m/yl1LzYqscDZA9QHLNbdaSTTr+kFg3bC0iYbX/eQy0Bv3h4B50/SGYzKAXkCeOLI3bcAt
-mj2Z/FM1vQWgDynsRwNvrWnJHlespkrp8+vO1jNaibm+PhqXPPv30YwDZ6jApe3wUjFQobghvW9p
-7f2zLkGNv8b191cD/3vs9Q833z8t"""
-            ).splitlines()
-        ]
-    )
-
-    def easteregged(environ, start_response):
-        def injecting_start_response(status, headers, exc_info=None):
-            headers.append(("X-Powered-By", "Werkzeug"))
-            return start_response(status, headers, exc_info)
-
-        if app is not None and environ.get("QUERY_STRING") != "macgybarchakku":
-            return app(environ, injecting_start_response)
-        injecting_start_response("200 OK", [("Content-Type", "text/html")])
-        return [
-            (
-                u"""
-<!DOCTYPE html>
-<html>
-<head>
-<title>About Werkzeug</title>
-<style type="text/css">
-  body { font: 15px Georgia, serif; text-align: center; }
-  a { color: #333; text-decoration: none; }
-  h1 { font-size: 30px; margin: 20px 0 10px 0; }
-  p { margin: 0 0 30px 0; }
-  pre { font: 11px 'Consolas', 'Monaco', monospace; line-height: 0.95; }
-</style>
-</head>
-<body>
-<h1><a href="http://werkzeug.pocoo.org/">Werkzeug</a></h1>
-<p>the Swiss Army knife of Python web development.</p>
-<pre>%s\n\n\n</pre>
-</body>
-</html>"""
-                % gyver
-            ).encode("latin1")
-        ]
-
-    return easteregged