com.googler.python 1.1.2 → 1.1.4

package/python3.6.2/lib/python3.6/wsgiref/validate.py

@@ -1,443 +0,0 @@
-# (c) 2005 Ian Bicking and contributors; written for Paste (http://pythonpaste.org)
-# Licensed under the MIT license: http://www.opensource.org/licenses/mit-license.php
-# Also licenced under the Apache License, 2.0: http://opensource.org/licenses/apache2.0.php
-# Licensed to PSF under a Contributor Agreement
-"""
-Middleware to check for obedience to the WSGI specification.
-
-Some of the things this checks:
-
-* Signature of the application and start_response (including that
-  keyword arguments are not used).
-
-* Environment checks:
-
-  - Environment is a dictionary (and not a subclass).
-
-  - That all the required keys are in the environment: REQUEST_METHOD,
-    SERVER_NAME, SERVER_PORT, wsgi.version, wsgi.input, wsgi.errors,
-    wsgi.multithread, wsgi.multiprocess, wsgi.run_once
-
-  - That HTTP_CONTENT_TYPE and HTTP_CONTENT_LENGTH are not in the
-    environment (these headers should appear as CONTENT_LENGTH and
-    CONTENT_TYPE).
-
-  - Warns if QUERY_STRING is missing, as the cgi module acts
-    unpredictably in that case.
-
-  - That CGI-style variables (that don't contain a .) have
-    (non-unicode) string values
-
-  - That wsgi.version is a tuple
-
-  - That wsgi.url_scheme is 'http' or 'https' (@@: is this too
-    restrictive?)
-
-  - Warns if the REQUEST_METHOD is not known (@@: probably too
-    restrictive).
-
-  - That SCRIPT_NAME and PATH_INFO are empty or start with /
-
-  - That at least one of SCRIPT_NAME or PATH_INFO are set.
-
-  - That CONTENT_LENGTH is a positive integer.
-
-  - That SCRIPT_NAME is not '/' (it should be '', and PATH_INFO should
-    be '/').
-
-  - That wsgi.input has the methods read, readline, readlines, and
-    __iter__
-
-  - That wsgi.errors has the methods flush, write, writelines
-
-* The status is a string, contains a space, starts with an integer,
-  and that integer is in range (> 100).
-
-* That the headers is a list (not a subclass, not another kind of
-  sequence).
-
-* That the items of the headers are tuples of strings.
-
-* That there is no 'status' header (that is used in CGI, but not in
-  WSGI).
-
-* That the headers don't contain newlines or colons, end in _ or -, or
-  contain characters codes below 037.
-
-* That Content-Type is given if there is content (CGI often has a
-  default content type, but WSGI does not).
-
-* That no Content-Type is given when there is no content (@@: is this
-  too restrictive?)
-
-* That the exc_info argument to start_response is a tuple or None.
-
-* That all calls to the writer are with strings, and no other methods
-  on the writer are accessed.
-
-* That wsgi.input is used properly:
-
-  - .read() is called with zero or one argument
-
-  - That it returns a string
-
-  - That readline, readlines, and __iter__ return strings
-
-  - That .close() is not called
-
-  - No other methods are provided
-
-* That wsgi.errors is used properly:
-
-  - .write() and .writelines() is called with a string
-
-  - That .close() is not called, and no other methods are provided.
-
-* The response iterator:
-
-  - That it is not a string (it should be a list of a single string; a
-    string will work, but perform horribly).
-
-  - That .__next__() returns a string
-
-  - That the iterator is not iterated over until start_response has
-    been called (that can signal either a server or application
-    error).
-
-  - That .close() is called (doesn't raise exception, only prints to
-    sys.stderr, because we only know it isn't called when the object
-    is garbage collected).
-"""
-__all__ = ['validator']
-
-
-import re
-import sys
-import warnings
-
-header_re = re.compile(r'^[a-zA-Z][a-zA-Z0-9\-_]*$')
-bad_header_value_re = re.compile(r'[\000-\037]')
-
-class WSGIWarning(Warning):
-    """
-    Raised in response to WSGI-spec-related warnings
-    """
-
-def assert_(cond, *args):
-    if not cond:
-        raise AssertionError(*args)
-
-def check_string_type(value, title):
-    if type (value) is str:
-        return value
-    raise AssertionError(
-        "{0} must be of type str (got {1})".format(title, repr(value)))
-
-def validator(application):
-
-    """
-    When applied between a WSGI server and a WSGI application, this
-    middleware will check for WSGI compliancy on a number of levels.
-    This middleware does not modify the request or response in any
-    way, but will raise an AssertionError if anything seems off
-    (except for a failure to close the application iterator, which
-    will be printed to stderr -- there's no way to raise an exception
-    at that point).
-    """
-
-    def lint_app(*args, **kw):
-        assert_(len(args) == 2, "Two arguments required")
-        assert_(not kw, "No keyword arguments allowed")
-        environ, start_response = args
-
-        check_environ(environ)
-
-        # We use this to check if the application returns without
-        # calling start_response:
-        start_response_started = []
-
-        def start_response_wrapper(*args, **kw):
-            assert_(len(args) == 2 or len(args) == 3, (
-                "Invalid number of arguments: %s" % (args,)))
-            assert_(not kw, "No keyword arguments allowed")
-            status = args[0]
-            headers = args[1]
-            if len(args) == 3:
-                exc_info = args[2]
-            else:
-                exc_info = None
-
-            check_status(status)
-            check_headers(headers)
-            check_content_type(status, headers)
-            check_exc_info(exc_info)
-
-            start_response_started.append(None)
-            return WriteWrapper(start_response(*args))
-
-        environ['wsgi.input'] = InputWrapper(environ['wsgi.input'])
-        environ['wsgi.errors'] = ErrorWrapper(environ['wsgi.errors'])
-
-        iterator = application(environ, start_response_wrapper)
-        assert_(iterator is not None and iterator != False,
-            "The application must return an iterator, if only an empty list")
-
-        check_iterator(iterator)
-
-        return IteratorWrapper(iterator, start_response_started)
-
-    return lint_app
-
-class InputWrapper:
-
-    def __init__(self, wsgi_input):
-        self.input = wsgi_input
-
-    def read(self, *args):
-        assert_(len(args) == 1)
-        v = self.input.read(*args)
-        assert_(type(v) is bytes)
-        return v
-
-    def readline(self, *args):
-        assert_(len(args) <= 1)
-        v = self.input.readline(*args)
-        assert_(type(v) is bytes)
-        return v
-
-    def readlines(self, *args):
-        assert_(len(args) <= 1)
-        lines = self.input.readlines(*args)
-        assert_(type(lines) is list)
-        for line in lines:
-            assert_(type(line) is bytes)
-        return lines
-
-    def __iter__(self):
-        while 1:
-            line = self.readline()
-            if not line:
-                return
-            yield line
-
-    def close(self):
-        assert_(0, "input.close() must not be called")
-
-class ErrorWrapper:
-
-    def __init__(self, wsgi_errors):
-        self.errors = wsgi_errors
-
-    def write(self, s):
-        assert_(type(s) is str)
-        self.errors.write(s)
-
-    def flush(self):
-        self.errors.flush()
-
-    def writelines(self, seq):
-        for line in seq:
-            self.write(line)
-
-    def close(self):
-        assert_(0, "errors.close() must not be called")
-
-class WriteWrapper:
-
-    def __init__(self, wsgi_writer):
-        self.writer = wsgi_writer
-
-    def __call__(self, s):
-        assert_(type(s) is bytes)
-        self.writer(s)
-
-class PartialIteratorWrapper:
-
-    def __init__(self, wsgi_iterator):
-        self.iterator = wsgi_iterator
-
-    def __iter__(self):
-        # We want to make sure __iter__ is called
-        return IteratorWrapper(self.iterator, None)
-
-class IteratorWrapper:
-
-    def __init__(self, wsgi_iterator, check_start_response):
-        self.original_iterator = wsgi_iterator
-        self.iterator = iter(wsgi_iterator)
-        self.closed = False
-        self.check_start_response = check_start_response
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        assert_(not self.closed,
-            "Iterator read after closed")
-        v = next(self.iterator)
-        if type(v) is not bytes:
-            assert_(False, "Iterator yielded non-bytestring (%r)" % (v,))
-        if self.check_start_response is not None:
-            assert_(self.check_start_response,
-                "The application returns and we started iterating over its body, but start_response has not yet been called")
-            self.check_start_response = None
-        return v
-
-    def close(self):
-        self.closed = True
-        if hasattr(self.original_iterator, 'close'):
-            self.original_iterator.close()
-
-    def __del__(self):
-        if not self.closed:
-            sys.stderr.write(
-                "Iterator garbage collected without being closed")
-        assert_(self.closed,
-            "Iterator garbage collected without being closed")
-
-def check_environ(environ):
-    assert_(type(environ) is dict,
-        "Environment is not of the right type: %r (environment: %r)"
-        % (type(environ), environ))
-
-    for key in ['REQUEST_METHOD', 'SERVER_NAME', 'SERVER_PORT',
-                'wsgi.version', 'wsgi.input', 'wsgi.errors',
-                'wsgi.multithread', 'wsgi.multiprocess',
-                'wsgi.run_once']:
-        assert_(key in environ,
-            "Environment missing required key: %r" % (key,))
-
-    for key in ['HTTP_CONTENT_TYPE', 'HTTP_CONTENT_LENGTH']:
-        assert_(key not in environ,
-            "Environment should not have the key: %s "
-            "(use %s instead)" % (key, key[5:]))
-
-    if 'QUERY_STRING' not in environ:
-        warnings.warn(
-            'QUERY_STRING is not in the WSGI environment; the cgi '
-            'module will use sys.argv when this variable is missing, '
-            'so application errors are more likely',
-            WSGIWarning)
-
-    for key in environ.keys():
-        if '.' in key:
-            # Extension, we don't care about its type
-            continue
-        assert_(type(environ[key]) is str,
-            "Environmental variable %s is not a string: %r (value: %r)"
-            % (key, type(environ[key]), environ[key]))
-
-    assert_(type(environ['wsgi.version']) is tuple,
-        "wsgi.version should be a tuple (%r)" % (environ['wsgi.version'],))
-    assert_(environ['wsgi.url_scheme'] in ('http', 'https'),
-        "wsgi.url_scheme unknown: %r" % environ['wsgi.url_scheme'])
-
-    check_input(environ['wsgi.input'])
-    check_errors(environ['wsgi.errors'])
-
-    # @@: these need filling out:
-    if environ['REQUEST_METHOD'] not in (
-        'GET', 'HEAD', 'POST', 'OPTIONS', 'PATCH', 'PUT', 'DELETE', 'TRACE'):
-        warnings.warn(
-            "Unknown REQUEST_METHOD: %r" % environ['REQUEST_METHOD'],
-            WSGIWarning)
-
-    assert_(not environ.get('SCRIPT_NAME')
-            or environ['SCRIPT_NAME'].startswith('/'),
-        "SCRIPT_NAME doesn't start with /: %r" % environ['SCRIPT_NAME'])
-    assert_(not environ.get('PATH_INFO')
-            or environ['PATH_INFO'].startswith('/'),
-        "PATH_INFO doesn't start with /: %r" % environ['PATH_INFO'])
-    if environ.get('CONTENT_LENGTH'):
-        assert_(int(environ['CONTENT_LENGTH']) >= 0,
-            "Invalid CONTENT_LENGTH: %r" % environ['CONTENT_LENGTH'])
-
-    if not environ.get('SCRIPT_NAME'):
-        assert_('PATH_INFO' in environ,
-            "One of SCRIPT_NAME or PATH_INFO are required (PATH_INFO "
-            "should at least be '/' if SCRIPT_NAME is empty)")
-    assert_(environ.get('SCRIPT_NAME') != '/',
-        "SCRIPT_NAME cannot be '/'; it should instead be '', and "
-        "PATH_INFO should be '/'")
-
-def check_input(wsgi_input):
-    for attr in ['read', 'readline', 'readlines', '__iter__']:
-        assert_(hasattr(wsgi_input, attr),
-            "wsgi.input (%r) doesn't have the attribute %s"
-            % (wsgi_input, attr))
-
-def check_errors(wsgi_errors):
-    for attr in ['flush', 'write', 'writelines']:
-        assert_(hasattr(wsgi_errors, attr),
-            "wsgi.errors (%r) doesn't have the attribute %s"
-            % (wsgi_errors, attr))
-
-def check_status(status):
-    status = check_string_type(status, "Status")
-    # Implicitly check that we can turn it into an integer:
-    status_code = status.split(None, 1)[0]
-    assert_(len(status_code) == 3,
-        "Status codes must be three characters: %r" % status_code)
-    status_int = int(status_code)
-    assert_(status_int >= 100, "Status code is invalid: %r" % status_int)
-    if len(status) < 4 or status[3] != ' ':
-        warnings.warn(
-            "The status string (%r) should be a three-digit integer "
-            "followed by a single space and a status explanation"
-            % status, WSGIWarning)
-
-def check_headers(headers):
-    assert_(type(headers) is list,
-        "Headers (%r) must be of type list: %r"
-        % (headers, type(headers)))
-    header_names = {}
-    for item in headers:
-        assert_(type(item) is tuple,
-            "Individual headers (%r) must be of type tuple: %r"
-            % (item, type(item)))
-        assert_(len(item) == 2)
-        name, value = item
-        name = check_string_type(name, "Header name")
-        value = check_string_type(value, "Header value")
-        assert_(name.lower() != 'status',
-            "The Status header cannot be used; it conflicts with CGI "
-            "script, and HTTP status is not given through headers "
-            "(value: %r)." % value)
-        header_names[name.lower()] = None
-        assert_('\n' not in name and ':' not in name,
-            "Header names may not contain ':' or '\\n': %r" % name)
-        assert_(header_re.search(name), "Bad header name: %r" % name)
-        assert_(not name.endswith('-') and not name.endswith('_'),
-            "Names may not end in '-' or '_': %r" % name)
-        if bad_header_value_re.search(value):
-            assert_(0, "Bad header value: %r (bad char: %r)"
-            % (value, bad_header_value_re.search(value).group(0)))
-
-def check_content_type(status, headers):
-    status = check_string_type(status, "Status")
-    code = int(status.split(None, 1)[0])
-    # @@: need one more person to verify this interpretation of RFC 2616
-    #     http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
-    NO_MESSAGE_BODY = (204, 304)
-    for name, value in headers:
-        name = check_string_type(name, "Header name")
-        if name.lower() == 'content-type':
-            if code not in NO_MESSAGE_BODY:
-                return
-            assert_(0, ("Content-Type header found in a %s response, "
-                        "which must not return content.") % code)
-    if code not in NO_MESSAGE_BODY:
-        assert_(0, "No Content-Type header found in headers (%s)" % headers)
-
-def check_exc_info(exc_info):
-    assert_(exc_info is None or type(exc_info) is tuple,
-        "exc_info (%r) is not a tuple: %r" % (exc_info, type(exc_info)))
-    # More exc_info checks?
-
-def check_iterator(iterator):
-    # Technically a bytestring is legal, which is why it's a really bad
-    # idea, because it may cause the response to be returned
-    # character-by-character
-    assert_(not isinstance(iterator, (str, bytes)),
-        "You should not return a string as your application iterator, "
-        "instead return a single-item list containing a bytestring.")

package/python3.6.2/lib/python3.6/xdrlib.py

@@ -1,241 +0,0 @@
-"""Implements (a subset of) Sun XDR -- eXternal Data Representation.
-
-See: RFC 1014
-
-"""
-
-import struct
-from io import BytesIO
-from functools import wraps
-
-__all__ = ["Error", "Packer", "Unpacker", "ConversionError"]
-
-# exceptions
-class Error(Exception):
-    """Exception class for this module. Use:
-
-    except xdrlib.Error as var:
-        # var has the Error instance for the exception
-
-    Public ivars:
-        msg -- contains the message
-
-    """
-    def __init__(self, msg):
-        self.msg = msg
-    def __repr__(self):
-        return repr(self.msg)
-    def __str__(self):
-        return str(self.msg)
-
-
-class ConversionError(Error):
-    pass
-
-def raise_conversion_error(function):
-    """ Wrap any raised struct.errors in a ConversionError. """
-
-    @wraps(function)
-    def result(self, value):
-        try:
-            return function(self, value)
-        except struct.error as e:
-            raise ConversionError(e.args[0]) from None
-    return result
-
-
-class Packer:
-    """Pack various data representations into a buffer."""
-
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        self.__buf = BytesIO()
-
-    def get_buffer(self):
-        return self.__buf.getvalue()
-    # backwards compatibility
-    get_buf = get_buffer
-
-    @raise_conversion_error
-    def pack_uint(self, x):
-        self.__buf.write(struct.pack('>L', x))
-
-    @raise_conversion_error
-    def pack_int(self, x):
-        self.__buf.write(struct.pack('>l', x))
-
-    pack_enum = pack_int
-
-    def pack_bool(self, x):
-        if x: self.__buf.write(b'\0\0\0\1')
-        else: self.__buf.write(b'\0\0\0\0')
-
-    def pack_uhyper(self, x):
-        try:
-            self.pack_uint(x>>32 & 0xffffffff)
-        except (TypeError, struct.error) as e:
-            raise ConversionError(e.args[0]) from None
-        try:
-            self.pack_uint(x & 0xffffffff)
-        except (TypeError, struct.error) as e:
-            raise ConversionError(e.args[0]) from None
-
-    pack_hyper = pack_uhyper
-
-    @raise_conversion_error
-    def pack_float(self, x):
-        self.__buf.write(struct.pack('>f', x))
-
-    @raise_conversion_error
-    def pack_double(self, x):
-        self.__buf.write(struct.pack('>d', x))
-
-    def pack_fstring(self, n, s):
-        if n < 0:
-            raise ValueError('fstring size must be nonnegative')
-        data = s[:n]
-        n = ((n+3)//4)*4
-        data = data + (n - len(data)) * b'\0'
-        self.__buf.write(data)
-
-    pack_fopaque = pack_fstring
-
-    def pack_string(self, s):
-        n = len(s)
-        self.pack_uint(n)
-        self.pack_fstring(n, s)
-
-    pack_opaque = pack_string
-    pack_bytes = pack_string
-
-    def pack_list(self, list, pack_item):
-        for item in list:
-            self.pack_uint(1)
-            pack_item(item)
-        self.pack_uint(0)
-
-    def pack_farray(self, n, list, pack_item):
-        if len(list) != n:
-            raise ValueError('wrong array size')
-        for item in list:
-            pack_item(item)
-
-    def pack_array(self, list, pack_item):
-        n = len(list)
-        self.pack_uint(n)
-        self.pack_farray(n, list, pack_item)
-
-
-
-class Unpacker:
-    """Unpacks various data representations from the given buffer."""
-
-    def __init__(self, data):
-        self.reset(data)
-
-    def reset(self, data):
-        self.__buf = data
-        self.__pos = 0
-
-    def get_position(self):
-        return self.__pos
-
-    def set_position(self, position):
-        self.__pos = position
-
-    def get_buffer(self):
-        return self.__buf
-
-    def done(self):
-        if self.__pos < len(self.__buf):
-            raise Error('unextracted data remains')
-
-    def unpack_uint(self):
-        i = self.__pos
-        self.__pos = j = i+4
-        data = self.__buf[i:j]
-        if len(data) < 4:
-            raise EOFError
-        return struct.unpack('>L', data)[0]
-
-    def unpack_int(self):
-        i = self.__pos
-        self.__pos = j = i+4
-        data = self.__buf[i:j]
-        if len(data) < 4:
-            raise EOFError
-        return struct.unpack('>l', data)[0]
-
-    unpack_enum = unpack_int
-
-    def unpack_bool(self):
-        return bool(self.unpack_int())
-
-    def unpack_uhyper(self):
-        hi = self.unpack_uint()
-        lo = self.unpack_uint()
-        return int(hi)<<32 | lo
-
-    def unpack_hyper(self):
-        x = self.unpack_uhyper()
-        if x >= 0x8000000000000000:
-            x = x - 0x10000000000000000
-        return x
-
-    def unpack_float(self):
-        i = self.__pos
-        self.__pos = j = i+4
-        data = self.__buf[i:j]
-        if len(data) < 4:
-            raise EOFError
-        return struct.unpack('>f', data)[0]
-
-    def unpack_double(self):
-        i = self.__pos
-        self.__pos = j = i+8
-        data = self.__buf[i:j]
-        if len(data) < 8:
-            raise EOFError
-        return struct.unpack('>d', data)[0]
-
-    def unpack_fstring(self, n):
-        if n < 0:
-            raise ValueError('fstring size must be nonnegative')
-        i = self.__pos
-        j = i + (n+3)//4*4
-        if j > len(self.__buf):
-            raise EOFError
-        self.__pos = j
-        return self.__buf[i:i+n]
-
-    unpack_fopaque = unpack_fstring
-
-    def unpack_string(self):
-        n = self.unpack_uint()
-        return self.unpack_fstring(n)
-
-    unpack_opaque = unpack_string
-    unpack_bytes = unpack_string
-
-    def unpack_list(self, unpack_item):
-        list = []
-        while 1:
-            x = self.unpack_uint()
-            if x == 0: break
-            if x != 1:
-                raise ConversionError('0 or 1 expected, got %r' % (x,))
-            item = unpack_item()
-            list.append(item)
-        return list
-
-    def unpack_farray(self, n, unpack_item):
-        list = []
-        for i in range(n):
-            list.append(unpack_item())
-        return list
-
-    def unpack_array(self, unpack_item):
-        n = self.unpack_uint()
-        return self.unpack_farray(n, unpack_item)

package/python3.6.2/lib/python3.6/xml/__init__.py

@@ -1,20 +0,0 @@
-"""Core XML support for Python.
-
-This package contains four sub-packages:
-
-dom -- The W3C Document Object Model.  This supports DOM Level 1 +
-       Namespaces.
-
-parsers -- Python wrappers for XML parsers (currently only supports Expat).
-
-sax -- The Simple API for XML, developed by XML-Dev, led by David
-       Megginson and ported to Python by Lars Marius Garshol.  This
-       supports the SAX 2 API.
-
-etree -- The ElementTree XML library.  This is a subset of the full
-       ElementTree XML release.
-
-"""
-
-
-__all__ = ["dom", "parsers", "sax", "etree"]