Merge lp:~zulcss/ubuntu/precise/requests/requests-ca into lp:ubuntu/precise/requests

[Chuck Short]

Unmerged revisions

19. By Chuck Short on 2013-01-28

* New upstream release for the Ubuntu Cloud Archvie:
  - Removed python3 version.

18. By Barry Warsaw on 2012-11-01

* New upstream release (LP: #1076107). Remaining changes:
  - debian/patches/01_do-not-use-python-certifi.patch: No longer necessary.
  - debian/patches/02_do-not-use-embedded-python-six.patch: refreshed
  - debian/patches/03-dont-use-embeded-urllib3.patch: refreshed and
    renamed to 03-use-distro-packages.patch
  - debian/control: python-chardet and python3-chardet are now required
    (i.e. Depends instead of Recommends).

17. By Dave Walker on 2012-09-13

debian/control: Resolve Depends misspelling of python-urllib3.

16. By Adam Conrad on 2012-09-12

* Add -r to rm call in debian/rules removing requests/packages/urllib3
* Add python3-urllib3 to build-depends and python3-requests depends

15. By Chuck Short on 2012-09-07

debian/rules, debian/control,
debian/patches/03-dont-use-embeded-urllib3.patch:
Don't use embeded python-urllib3.

14. By James Page on 2012-08-14

d/{rules,control}: Disable tests and drop associated deps; 10/11
of them require network connectivity so they break in offline build
environments.

13. By Chuck Short on 2012-07-18

debian/control: Fix up testsuite some more.

12. By Chuck Short on 2012-06-11

debia/rules: Enable test suite.

11. By Daniele Tricoli on 2012-05-04

* New upstream release
* debian/control
  - Added python-oauthlib to python-requests' Recommends field
* debian/patches/01_do-not-use-python-certifi.patch
  - Refreshed

10. By Daniele Tricoli on 2012-04-23

* New upstream release
* debian/patches/01_do-not-use-python-certifi.patch
  - Refreshed

=== added directory '.pc'
=== added file '.pc/.quilt_patches'
--- .pc/.quilt_patches	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_patches	2013-01-28 21:17:21 +0000
@@ -0,0 +1,1 @@
+debian/patches
 
=== added file '.pc/.quilt_series'
--- .pc/.quilt_series	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_series	2013-01-28 21:17:21 +0000
@@ -0,0 +1,1 @@
+series
 
=== added file '.pc/.version'
--- .pc/.version	1970-01-01 00:00:00 +0000
+++ .pc/.version	2013-01-28 21:17:21 +0000
@@ -0,0 +1,1 @@
+2
 
=== added directory '.pc/02_do-not-use-embedded-python-six.patch'
=== added directory '.pc/02_do-not-use-embedded-python-six.patch/requests'
=== added directory '.pc/02_do-not-use-embedded-python-six.patch/requests/packages'
=== added directory '.pc/02_do-not-use-embedded-python-six.patch/requests/packages/urllib3'
=== added file '.pc/02_do-not-use-embedded-python-six.patch/requests/packages/urllib3/connectionpool.py'
--- .pc/02_do-not-use-embedded-python-six.patch/requests/packages/urllib3/connectionpool.py	1970-01-01 00:00:00 +0000
+++ .pc/02_do-not-use-embedded-python-six.patch/requests/packages/urllib3/connectionpool.py	2013-01-28 21:17:21 +0000
@@ -0,0 +1,562 @@
+# urllib3/connectionpool.py
+# Copyright 2008-2012 Andrey Petrov and contributors (see CONTRIBUTORS.txt)
+#
+# This module is part of urllib3 and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+import logging
+import socket
+
+from socket import timeout as SocketTimeout
+
+try: # Python 3
+    from http.client import HTTPConnection, HTTPException
+    from http.client import HTTP_PORT, HTTPS_PORT
+except ImportError:
+    from httplib import HTTPConnection, HTTPException
+    from httplib import HTTP_PORT, HTTPS_PORT
+
+try: # Python 3
+    from queue import LifoQueue, Empty, Full
+except ImportError:
+    from Queue import LifoQueue, Empty, Full
+
+
+try: # Compiled with SSL?
+    HTTPSConnection = object
+    BaseSSLError = None
+    ssl = None
+
+    try: # Python 3
+        from http.client import HTTPSConnection
+    except ImportError:
+        from httplib import HTTPSConnection
+
+    import ssl
+    BaseSSLError = ssl.SSLError
+
+except (ImportError, AttributeError): # Platform-specific: No SSL.
+    pass
+
+
+from .request import RequestMethods
+from .response import HTTPResponse
+from .util import get_host, is_connection_dropped
+from .exceptions import (
+    ClosedPoolError,
+    EmptyPoolError,
+    HostChangedError,
+    MaxRetryError,
+    SSLError,
+    TimeoutError,
+)
+
+from .packages.ssl_match_hostname import match_hostname, CertificateError
+from .packages import six
+
+
+xrange = six.moves.xrange
+
+log = logging.getLogger(__name__)
+
+_Default = object()
+
+port_by_scheme = {
+    'http': HTTP_PORT,
+    'https': HTTPS_PORT,
+}
+
+
+## Connection objects (extension of httplib)
+
+class VerifiedHTTPSConnection(HTTPSConnection):
+    """
+    Based on httplib.HTTPSConnection but wraps the socket with
+    SSL certification.
+    """
+    cert_reqs = None
+    ca_certs = None
+
+    def set_cert(self, key_file=None, cert_file=None,
+                 cert_reqs='CERT_NONE', ca_certs=None):
+        ssl_req_scheme = {
+            'CERT_NONE': ssl.CERT_NONE,
+            'CERT_OPTIONAL': ssl.CERT_OPTIONAL,
+            'CERT_REQUIRED': ssl.CERT_REQUIRED
+        }
+
+        self.key_file = key_file
+        self.cert_file = cert_file
+        self.cert_reqs = ssl_req_scheme.get(cert_reqs) or ssl.CERT_NONE
+        self.ca_certs = ca_certs
+
+    def connect(self):
+        # Add certificate verification
+        sock = socket.create_connection((self.host, self.port), self.timeout)
+
+        # Wrap socket using verification with the root certs in
+        # trusted_root_certs
+        self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file,
+                                    cert_reqs=self.cert_reqs,
+                                    ca_certs=self.ca_certs)
+        if self.ca_certs:
+            match_hostname(self.sock.getpeercert(), self.host)
+
+
+## Pool objects
+
+class ConnectionPool(object):
+    """
+    Base class for all connection pools, such as
+    :class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`.
+    """
+
+    scheme = None
+    QueueCls = LifoQueue
+
+    def __init__(self, host, port=None):
+        self.host = host
+        self.port = port
+
+    def __str__(self):
+        return '%s(host=%r, port=%r)' % (type(self).__name__,
+                                         self.host, self.port)
+
+
+class HTTPConnectionPool(ConnectionPool, RequestMethods):
+    """
+    Thread-safe connection pool for one host.
+
+    :param host:
+        Host used for this HTTP Connection (e.g. "localhost"), passed into
+        :class:`httplib.HTTPConnection`.
+
+    :param port:
+        Port used for this HTTP Connection (None is equivalent to 80), passed
+        into :class:`httplib.HTTPConnection`.
+
+    :param strict:
+        Causes BadStatusLine to be raised if the status line can't be parsed
+        as a valid HTTP/1.0 or 1.1 status line, passed into
+        :class:`httplib.HTTPConnection`.
+
+    :param timeout:
+        Socket timeout for each individual connection, can be a float. None
+        disables timeout.
+
+    :param maxsize:
+        Number of connections to save that can be reused. More than 1 is useful
+        in multithreaded situations. If ``block`` is set to false, more
+        connections will be created but they will not be saved once they've
+        been used.
+
+    :param block:
+        If set to True, no more than ``maxsize`` connections will be used at
+        a time. When no free connections are available, the call will block
+        until a connection has been released. This is a useful side effect for
+        particular multithreaded situations where one does not want to use more
+        than maxsize connections per host to prevent flooding.
+
+    :param headers:
+        Headers to include with all requests, unless other headers are given
+        explicitly.
+    """
+
+    scheme = 'http'
+
+    def __init__(self, host, port=None, strict=False, timeout=None, maxsize=1,
+                 block=False, headers=None):
+        super(HTTPConnectionPool, self).__init__(host, port)
+
+        self.strict = strict
+        self.timeout = timeout
+        self.pool = self.QueueCls(maxsize)
+        self.block = block
+        self.headers = headers or {}
+
+        # Fill the queue up so that doing get() on it will block properly
+        for _ in xrange(maxsize):
+            self.pool.put(None)
+
+        # These are mostly for testing and debugging purposes.
+        self.num_connections = 0
+        self.num_requests = 0
+
+    def _new_conn(self):
+        """
+        Return a fresh :class:`httplib.HTTPConnection`.
+        """
+        self.num_connections += 1
+        log.info("Starting new HTTP connection (%d): %s" %
+                 (self.num_connections, self.host))
+        return HTTPConnection(host=self.host, port=self.port)
+
+    def _get_conn(self, timeout=None):
+        """
+        Get a connection. Will return a pooled connection if one is available.
+
+        If no connections are available and :prop:`.block` is ``False``, then a
+        fresh connection is returned.
+
+        :param timeout:
+            Seconds to wait before giving up and raising
+            :class:`urllib3.exceptions.EmptyPoolError` if the pool is empty and
+            :prop:`.block` is ``True``.
+        """
+        conn = None
+        try:
+            conn = self.pool.get(block=self.block, timeout=timeout)
+
+        except AttributeError: # self.pool is None
+            raise ClosedPoolError(self, "Pool is closed.")
+
+        except Empty:
+            if self.block:
+                raise EmptyPoolError(self,
+                                     "Pool reached maximum size and no more "
+                                     "connections are allowed.")
+            pass  # Oh well, we'll create a new connection then
+
+        # If this is a persistent connection, check if it got disconnected
+        if conn and is_connection_dropped(conn):
+            log.info("Resetting dropped connection: %s" % self.host)
+            conn.close()
+
+        return conn or self._new_conn()
+
+    def _put_conn(self, conn):
+        """
+        Put a connection back into the pool.
+
+        :param conn:
+            Connection object for the current host and port as returned by
+            :meth:`._new_conn` or :meth:`._get_conn`.
+
+        If the pool is already full, the connection is closed and discarded
+        because we exceeded maxsize. If connections are discarded frequently,
+        then maxsize should be increased.
+
+        If the pool is closed, then the connection will be closed and discarded.
+        """
+        try:
+            self.pool.put(conn, block=False)
+            return # Everything is dandy, done.
+        except AttributeError:
+            # self.pool is None.
+            pass
+        except Full:
+            # This should never happen if self.block == True
+            log.warning("HttpConnectionPool is full, discarding connection: %s"
+                        % self.host)
+
+        # Connection never got put back into the pool, close it.
+        conn.close()
+
+    def _make_request(self, conn, method, url, timeout=_Default,
+                      **httplib_request_kw):
+        """
+        Perform a request on a given httplib connection object taken from our
+        pool.
+        """
+        self.num_requests += 1
+
+        if timeout is _Default:
+            timeout = self.timeout
+
+        conn.timeout = timeout # This only does anything in Py26+
+        conn.request(method, url, **httplib_request_kw)
+
+        # Set timeout
+        sock = getattr(conn, 'sock', False) # AppEngine doesn't have sock attr.
+        if sock:
+            sock.settimeout(timeout)
+
+        try: # Python 2.7+, use buffering of HTTP responses
+            httplib_response = conn.getresponse(buffering=True)
+        except TypeError: # Python 2.6 and older
+            httplib_response = conn.getresponse()
+
+        # AppEngine doesn't have a version attr.
+        http_version = getattr(conn, '_http_vsn_str', 'HTTP/?')
+        log.debug("\"%s %s %s\" %s %s" % (method, url, http_version,
+                                          httplib_response.status,
+                                          httplib_response.length))
+        return httplib_response
+
+    def close(self):
+        """
+        Close all pooled connections and disable the pool.
+        """
+        # Disable access to the pool
+        old_pool, self.pool = self.pool, None
+
+        try:
+            while True:
+                conn = old_pool.get(block=False)
+                if conn:
+                    conn.close()
+
+        except Empty:
+            pass # Done.
+
+    def is_same_host(self, url):
+        """
+        Check if the given ``url`` is a member of the same host as this
+        connection pool.
+        """
+        if url.startswith('/'):
+            return True
+
+        # TODO: Add optional support for socket.gethostbyname checking.
+        scheme, host, port = get_host(url)
+
+        if self.port and not port:
+            # Use explicit default port for comparison when none is given.
+            port = port_by_scheme.get(scheme)
+
+        return (scheme, host, port) == (self.scheme, self.host, self.port)
+
+    def urlopen(self, method, url, body=None, headers=None, retries=3,
+                redirect=True, assert_same_host=True, timeout=_Default,
+                pool_timeout=None, release_conn=None, **response_kw):
+        """
+        Get a connection from the pool and perform an HTTP request. This is the
+        lowest level call for making a request, so you'll need to specify all
+        the raw details.
+
+        .. note::
+
+           More commonly, it's appropriate to use a convenience method provided
+           by :class:`.RequestMethods`, such as :meth:`request`.
+
+        .. note::
+
+           `release_conn` will only behave as expected if
+           `preload_content=False` because we want to make
+           `preload_content=False` the default behaviour someday soon without
+           breaking backwards compatibility.
+
+        :param method:
+            HTTP request method (such as GET, POST, PUT, etc.)
+
+        :param body:
+            Data to send in the request body (useful for creating
+            POST requests, see HTTPConnectionPool.post_url for
+            more convenience).
+
+        :param headers:
+            Dictionary of custom headers to send, such as User-Agent,
+            If-None-Match, etc. If None, pool headers are used. If provided,
+            these headers completely replace any pool-specific headers.
+
+        :param retries:
+            Number of retries to allow before raising a MaxRetryError exception.
+
+        :param redirect:
+            If True, automatically handle redirects (status codes 301, 302,
+            303, 307). Each redirect counts as a retry.
+
+        :param assert_same_host:
+            If ``True``, will make sure that the host of the pool requests is
+            consistent else will raise HostChangedError. When False, you can
+            use the pool on an HTTP proxy and request foreign hosts.
+
+        :param timeout:
+            If specified, overrides the default timeout for this one request.
+
+        :param pool_timeout:
+            If set and the pool is set to block=True, then this method will
+            block for ``pool_timeout`` seconds and raise EmptyPoolError if no
+            connection is available within the time period.
+
+        :param release_conn:
+            If False, then the urlopen call will not release the connection
+            back into the pool once a response is received (but will release if
+            you read the entire contents of the response such as when
+            `preload_content=True`). This is useful if you're not preloading
+            the response's content immediately. You will need to call
+            ``r.release_conn()`` on the response ``r`` to return the connection
+            back into the pool. If None, it takes the value of
+            ``response_kw.get('preload_content', True)``.
+
+        :param \**response_kw:
+            Additional parameters are passed to
+            :meth:`urllib3.response.HTTPResponse.from_httplib`
+        """
+        if headers is None:
+            headers = self.headers
+
+        if retries < 0:
+            raise MaxRetryError(self, url)
+
+        if timeout is _Default:
+            timeout = self.timeout
+
+        if release_conn is None:
+            release_conn = response_kw.get('preload_content', True)
+
+        # Check host
+        if assert_same_host and not self.is_same_host(url):
+            host = "%s://%s" % (self.scheme, self.host)
+            if self.port:
+                host = "%s:%d" % (host, self.port)
+
+            raise HostChangedError(self, url, retries - 1)
+
+        conn = None
+
+        try:
+            # Request a connection from the queue
+            conn = self._get_conn(timeout=pool_timeout)
+
+            # Make the request on the httplib connection object
+            httplib_response = self._make_request(conn, method, url,
+                                                  timeout=timeout,
+                                                  body=body, headers=headers)
+
+            # If we're going to release the connection in ``finally:``, then
+            # the request doesn't need to know about the connection. Otherwise
+            # it will also try to release it and we'll have a double-release
+            # mess.
+            response_conn = not release_conn and conn
+
+            # Import httplib's response into our own wrapper object
+            response = HTTPResponse.from_httplib(httplib_response,
+                                                 pool=self,
+                                                 connection=response_conn,
+                                                 **response_kw)
+
+            # else:
+            #     The connection will be put back into the pool when
+            #     ``response.release_conn()`` is called (implicitly by
+            #     ``response.read()``)
+
+        except Empty as e:
+            # Timed out by queue
+            raise TimeoutError(self, "Request timed out. (pool_timeout=%s)" %
+                               pool_timeout)
+
+        except SocketTimeout as e:
+            # Timed out by socket
+            raise TimeoutError(self, "Request timed out. (timeout=%s)" %
+                               timeout)
+
+        except BaseSSLError as e:
+            # SSL certificate error
+            raise SSLError(e)
+
+        except CertificateError as e:
+            # Name mismatch
+            raise SSLError(e)
+
+        except HTTPException as e:
+            # Connection broken, discard. It will be replaced next _get_conn().
+            conn = None
+            # This is necessary so we can access e below
+            err = e
+
+        finally:
+            if release_conn:
+                # Put the connection back to be reused. If the connection is
+                # expired then it will be None, which will get replaced with a
+                # fresh connection during _get_conn.
+                self._put_conn(conn)
+
+        if not conn:
+            # Try again
+            log.warn("Retrying (%d attempts remain) after connection "
+                     "broken by '%r': %s" % (retries, err, url))
+            return self.urlopen(method, url, body, headers, retries - 1,
+                                redirect, assert_same_host,
+                                timeout=timeout, pool_timeout=pool_timeout,
+                                release_conn=release_conn, **response_kw)
+
+        # Handle redirect?
+        redirect_location = redirect and response.get_redirect_location()
+        if redirect_location:
+            if response.status == 303:
+                method = 'GET'
+            log.info("Redirecting %s -> %s" % (url, redirect_location))
+            return self.urlopen(method, redirect_location, body, headers,
+                                retries - 1, redirect, assert_same_host,
+                                timeout=timeout, pool_timeout=pool_timeout,
+                                release_conn=release_conn, **response_kw)
+
+        return response
+
+
+class HTTPSConnectionPool(HTTPConnectionPool):
+    """
+    Same as :class:`.HTTPConnectionPool`, but HTTPS.
+
+    When Python is compiled with the :mod:`ssl` module, then
+    :class:`.VerifiedHTTPSConnection` is used, which *can* verify certificates,
+    instead of :class:httplib.HTTPSConnection`.
+
+    The ``key_file``, ``cert_file``, ``cert_reqs``, and ``ca_certs`` parameters
+    are only used if :mod:`ssl` is available and are fed into
+    :meth:`ssl.wrap_socket` to upgrade the connection socket into an SSL socket.
+    """
+
+    scheme = 'https'
+
+    def __init__(self, host, port=None,
+                 strict=False, timeout=None, maxsize=1,
+                 block=False, headers=None,
+                 key_file=None, cert_file=None,
+                 cert_reqs='CERT_NONE', ca_certs=None):
+
+        super(HTTPSConnectionPool, self).__init__(host, port,
+                                                  strict, timeout, maxsize,
+                                                  block, headers)
+        self.key_file = key_file
+        self.cert_file = cert_file
+        self.cert_reqs = cert_reqs
+        self.ca_certs = ca_certs
+
+    def _new_conn(self):
+        """
+        Return a fresh :class:`httplib.HTTPSConnection`.
+        """
+        self.num_connections += 1
+        log.info("Starting new HTTPS connection (%d): %s"
+                 % (self.num_connections, self.host))
+
+        if not ssl: # Platform-specific: Python compiled without +ssl
+            if not HTTPSConnection or HTTPSConnection is object:
+                raise SSLError("Can't connect to HTTPS URL because the SSL "
+                               "module is not available.")
+
+            return HTTPSConnection(host=self.host, port=self.port)
+
+        connection = VerifiedHTTPSConnection(host=self.host, port=self.port)
+        connection.set_cert(key_file=self.key_file, cert_file=self.cert_file,
+                            cert_reqs=self.cert_reqs, ca_certs=self.ca_certs)
+        return connection
+
+
+def connection_from_url(url, **kw):
+    """
+    Given a url, return an :class:`.ConnectionPool` instance of its host.
+
+    This is a shortcut for not having to parse out the scheme, host, and port
+    of the url before creating an :class:`.ConnectionPool` instance.
+
+    :param url:
+        Absolute URL string that must include the scheme. Port is optional.
+
+    :param \**kw:
+        Passes additional parameters to the constructor of the appropriate
+        :class:`.ConnectionPool`. Useful for specifying things like
+        timeout, maxsize, headers, etc.
+
+    Example: ::
+
+        >>> conn = connection_from_url('http://google.com/')
+        >>> r = conn.request('GET', '/')
+    """
+    scheme, host, port = get_host(url)
+    if scheme == 'https':
+        return HTTPSConnectionPool(host, port=port, **kw)
+    else:
+        return HTTPConnectionPool(host, port=port, **kw)
 
=== added file '.pc/02_do-not-use-embedded-python-six.patch/requests/packages/urllib3/filepost.py'
--- .pc/02_do-not-use-embedded-python-six.patch/requests/packages/urllib3/filepost.py	1970-01-01 00:00:00 +0000
+++ .pc/02_do-not-use-embedded-python-six.patch/requests/packages/urllib3/filepost.py	2013-01-28 21:17:21 +0000
@@ -0,0 +1,91 @@
+# urllib3/filepost.py
+# Copyright 2008-2012 Andrey Petrov and contributors (see CONTRIBUTORS.txt)
+#
+# This module is part of urllib3 and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+import codecs
+import mimetypes
+
+from uuid import uuid4
+from io import BytesIO
+
+from .packages import six
+from .packages.six import b
+
+writer = codecs.lookup('utf-8')[3]
+
+
+def choose_boundary():
+    """
+    Our embarassingly-simple replacement for mimetools.choose_boundary.
+    """
+    return uuid4().hex
+
+
+def get_content_type(filename):
+    return mimetypes.guess_type(filename)[0] or 'application/octet-stream'
+
+
+def iter_fields(fields):
+    """
+    Iterate over fields.
+
+    Supports list of (k, v) tuples and dicts.
+    """
+    if isinstance(fields, dict):
+        return ((k, v) for k, v in six.iteritems(fields))
+
+    return ((k, v) for k, v in fields)
+
+
+def encode_multipart_formdata(fields, boundary=None):
+    """
+    Encode a dictionary of ``fields`` using the multipart/form-data mime format.
+
+    :param fields:
+        Dictionary of fields or list of (key, value) field tuples.  The key is
+        treated as the field name, and the value as the body of the form-data
+        bytes. If the value is a tuple of two elements, then the first element
+        is treated as the filename of the form-data section.
+
+        Field names and filenames must be unicode.
+
+    :param boundary:
+        If not specified, then a random boundary will be generated using
+        :func:`mimetools.choose_boundary`.
+    """
+    body = BytesIO()
+    if boundary is None:
+        boundary = choose_boundary()
+
+    for fieldname, value in iter_fields(fields):
+        body.write(b('--%s\r\n' % (boundary)))
+
+        if isinstance(value, tuple):
+            filename, data = value
+            writer(body).write('Content-Disposition: form-data; name="%s"; '
+                               'filename="%s"\r\n' % (fieldname, filename))
+            body.write(b('Content-Type: %s\r\n\r\n' %
+                       (get_content_type(filename))))
+        else:
+            data = value
+            writer(body).write('Content-Disposition: form-data; name="%s"\r\n'
+                               % (fieldname))
+            body.write(b'Content-Type: text/plain\r\n\r\n')
+
+        if isinstance(data, int):
+            data = str(data)  # Backwards compatibility
+
+        if isinstance(data, six.text_type):
+            writer(body).write(data)
+        else:
+            body.write(data)
+
+        body.write(b'\r\n')
+
+    body.write(b('--%s--\r\n' % (boundary)))
+
+    content_type = b('multipart/form-data; boundary=%s' % boundary)
+
+    return body.getvalue(), content_type
 
=== added file '.pc/02_do-not-use-embedded-python-six.patch/requests/packages/urllib3/response.py'
--- .pc/02_do-not-use-embedded-python-six.patch/requests/packages/urllib3/response.py	1970-01-01 00:00:00 +0000
+++ .pc/02_do-not-use-embedded-python-six.patch/requests/packages/urllib3/response.py	2013-01-28 21:17:21 +0000
@@ -0,0 +1,202 @@
+# urllib3/response.py
+# Copyright 2008-2012 Andrey Petrov and contributors (see CONTRIBUTORS.txt)
+#
+# This module is part of urllib3 and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+import gzip
+import logging
+import zlib
+
+from io import BytesIO
+
+from .exceptions import DecodeError
+from .packages.six import string_types as basestring
+
+
+log = logging.getLogger(__name__)
+
+
+def decode_gzip(data):
+    gzipper = gzip.GzipFile(fileobj=BytesIO(data))
+    return gzipper.read()
+
+
+def decode_deflate(data):
+    try:
+        return zlib.decompress(data)
+    except zlib.error:
+        return zlib.decompress(data, -zlib.MAX_WBITS)
+
+
+class HTTPResponse(object):
+    """
+    HTTP Response container.
+
+    Backwards-compatible to httplib's HTTPResponse but the response ``body`` is
+    loaded and decoded on-demand when the ``data`` property is accessed.
+
+    Extra parameters for behaviour not present in httplib.HTTPResponse:
+
+    :param preload_content:
+        If True, the response's body will be preloaded during construction.
+
+    :param decode_content:
+        If True, attempts to decode specific content-encoding's based on headers
+        (like 'gzip' and 'deflate') will be skipped and raw data will be used
+        instead.
+
+    :param original_response:
+        When this HTTPResponse wrapper is generated from an httplib.HTTPResponse
+        object, it's convenient to include the original for debug purposes. It's
+        otherwise unused.
+    """
+
+    CONTENT_DECODERS = {
+        'gzip': decode_gzip,
+        'deflate': decode_deflate,
+    }
+
+    def __init__(self, body='', headers=None, status=0, version=0, reason=None,
+                 strict=0, preload_content=True, decode_content=True,
+                 original_response=None, pool=None, connection=None):
+        self.headers = headers or {}
+        self.status = status
+        self.version = version
+        self.reason = reason
+        self.strict = strict
+
+        self._decode_content = decode_content
+        self._body = body if body and isinstance(body, basestring) else None
+        self._fp = None
+        self._original_response = original_response
+
+        self._pool = pool
+        self._connection = connection
+
+        if hasattr(body, 'read'):
+            self._fp = body
+
+        if preload_content and not self._body:
+            self._body = self.read(decode_content=decode_content)
+
+    def get_redirect_location(self):
+        """
+        Should we redirect and where to?
+
+        :returns: Truthy redirect location string if we got a redirect status
+            code and valid location. ``None`` if redirect status and no
+            location. ``False`` if not a redirect status code.
+        """
+        if self.status in [301, 302, 303, 307]:
+            return self.headers.get('location')
+
+        return False
+
+    def release_conn(self):
+        if not self._pool or not self._connection:
+            return
+
+        self._pool._put_conn(self._connection)
+        self._connection = None
+
+    @property
+    def data(self):
+        # For backwords-compat with earlier urllib3 0.4 and earlier.
+        if self._body:
+            return self._body
+
+        if self._fp:
+            return self.read(cache_content=True)
+
+    def read(self, amt=None, decode_content=None, cache_content=False):
+        """
+        Similar to :meth:`httplib.HTTPResponse.read`, but with two additional
+        parameters: ``decode_content`` and ``cache_content``.
+
+        :param amt:
+            How much of the content to read. If specified, decoding and caching
+            is skipped because we can't decode partial content nor does it make
+            sense to cache partial content as the full response.
+
+        :param decode_content:
+            If True, will attempt to decode the body based on the
+            'content-encoding' header. (Overridden if ``amt`` is set.)
+
+        :param cache_content:
+            If True, will save the returned data such that the same result is
+            returned despite of the state of the underlying file object. This
+            is useful if you want the ``.data`` property to continue working
+            after having ``.read()`` the file object. (Overridden if ``amt`` is
+            set.)
+        """
+        content_encoding = self.headers.get('content-encoding')
+        decoder = self.CONTENT_DECODERS.get(content_encoding)
+        if decode_content is None:
+            decode_content = self._decode_content
+
+        if self._fp is None:
+            return
+
+        try:
+            if amt is None:
+                # cStringIO doesn't like amt=None
+                data = self._fp.read()
+            else:
+                return self._fp.read(amt)
+
+            try:
+                if decode_content and decoder:
+                    data = decoder(data)
+            except (IOError, zlib.error):
+                raise DecodeError("Received response with content-encoding: %s, but "
+                                  "failed to decode it." % content_encoding)
+
+            if cache_content:
+                self._body = data
+
+            return data
+
+        finally:
+            if self._original_response and self._original_response.isclosed():
+                self.release_conn()
+
+    @classmethod
+    def from_httplib(ResponseCls, r, **response_kw):
+        """
+        Given an :class:`httplib.HTTPResponse` instance ``r``, return a
+        corresponding :class:`urllib3.response.HTTPResponse` object.
+
+        Remaining parameters are passed to the HTTPResponse constructor, along
+        with ``original_response=r``.
+        """
+
+        # Normalize headers between different versions of Python
+        headers = {}
+        for k, v in r.getheaders():
+            # Python 3: Header keys are returned capitalised
+            k = k.lower()
+
+            has_value = headers.get(k)
+            if has_value: # Python 3: Repeating header keys are unmerged.
+                v = ', '.join([has_value, v])
+
+            headers[k] = v
+
+        # HTTPResponse objects in Python 3 don't have a .strict attribute
+        strict = getattr(r, 'strict', 0)
+        return ResponseCls(body=r,
+                           headers=headers,
+                           status=r.status,
+                           version=r.version,
+                           reason=r.reason,
+                           strict=strict,
+                           original_response=r,
+                           **response_kw)
+
+    # Backwards-compatibility methods for httplib.HTTPResponse
+    def getheaders(self):
+        return self.headers
+
+    def getheader(self, name, default=None):
+        return self.headers.get(name, default)
 
=== added file '.pc/02_do-not-use-embedded-python-six.patch/requests/packages/urllib3/util.py'
--- .pc/02_do-not-use-embedded-python-six.patch/requests/packages/urllib3/util.py	1970-01-01 00:00:00 +0000
+++ .pc/02_do-not-use-embedded-python-six.patch/requests/packages/urllib3/util.py	2013-01-28 21:17:21 +0000
@@ -0,0 +1,252 @@
+# urllib3/util.py
+# Copyright 2008-2012 Andrey Petrov and contributors (see CONTRIBUTORS.txt)
+#
+# This module is part of urllib3 and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+
+from base64 import b64encode
+from collections import namedtuple
+from socket import error as SocketError
+
+try:
+    from select import poll, POLLIN
+except ImportError: # `poll` doesn't exist on OSX and other platforms
+    poll = False
+    try:
+        from select import select
+    except ImportError: # `select` doesn't exist on AppEngine.
+        select = False
+
+from .packages import six
+from .exceptions import LocationParseError
+
+
+class Url(namedtuple('Url', ['scheme', 'auth', 'host', 'port', 'path', 'query', 'fragment'])):
+    """
+    Datastructure for representing an HTTP URL. Used as a return value for
+    :func:`parse_url`.
+    """
+    slots = ()
+
+    def __new__(cls, scheme=None, auth=None, host=None, port=None, path=None, query=None, fragment=None):
+        return super(Url, cls).__new__(cls, scheme, auth, host, port, path, query, fragment)
+
+    @property
+    def hostname(self):
+        """For backwards-compatibility with urlparse. We're nice like that."""
+        return self.host
+
+    @property
+    def request_uri(self):
+        """Absolute path including the query string."""
+        uri = self.path or '/'
+
+        if self.query is not None:
+            uri += '?' + self.query
+
+        return uri
+
+
+def split_first(s, delims):
+    """
+    Given a string and an iterable of delimiters, split on the first found
+    delimiter. Return two split parts and the matched delimiter.
+
+    If not found, then the first part is the full input string.
+
+    Example: ::
+
+        >>> split_first('foo/bar?baz', '?/=')
+        ('foo', 'bar?baz', '/')
+        >>> split_first('foo/bar?baz', '123')
+        ('foo/bar?baz', '', None)
+
+    Scales linearly with number of delims. Not ideal for large number of delims.
+    """
+    min_idx = None
+    min_delim = None
+    for d in delims:
+        idx = s.find(d)
+        if idx < 0:
+            continue
+
+        if min_idx is None or idx < min_idx:
+            min_idx = idx
+            min_delim = d
+
+    if min_idx is None or min_idx < 0:
+        return s, '', None
+
+    return s[:min_idx], s[min_idx+1:], min_delim
+
+
+def parse_url(url):
+    """
+    Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is
+    performed to parse incomplete urls. Fields not provided will be None.
+
+    Partly backwards-compatible with :mod:`urlparse`.
+
+    Example: ::
+
+        >>> parse_url('http://google.com/mail/')
+        Url(scheme='http', host='google.com', port=None, path='/', ...)
+        >>> prase_url('google.com:80')
+        Url(scheme=None, host='google.com', port=80, path=None, ...)
+        >>> prase_url('/foo?bar')
+        Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...)
+    """
+
+    # While this code has overlap with stdlib's urlparse, it is much
+    # simplified for our needs and less annoying.
+    # Additionally, this imeplementations does silly things to be optimal
+    # on CPython.
+
+    scheme = None
+    auth = None
+    host = None
+    port = None
+    path = None
+    fragment = None
+    query = None
+
+    # Scheme
+    if '://' in url:
+        scheme, url = url.split('://', 1)
+
+    # Find the earliest Authority Terminator
+    # (http://tools.ietf.org/html/rfc3986#section-3.2)
+    url, path_, delim = split_first(url, ['/', '?', '#'])
+
+    if delim:
+        # Reassemble the path
+        path = delim + path_
+
+    # Auth
+    if '@' in url:
+        auth, url = url.split('@', 1)
+
+    # IPv6
+    if url and url[0] == '[':
+        host, url = url[1:].split(']', 1)
+
+    # Port
+    if ':' in url:
+        _host, port = url.split(':', 1)
+
+        if not host:
+            host = _host
+
+        if not port.isdigit():
+            raise LocationParseError("Failed to parse: %s" % url)
+
+        port = int(port)
+
+    elif not host and url:
+        host = url
+
+    if not path:
+        return Url(scheme, auth, host, port, path, query, fragment)
+
+    # Fragment
+    if '#' in path:
+        path, fragment = path.split('#', 1)
+
+    # Query
+    if '?' in path:
+        path, query = path.split('?', 1)
+
+    return Url(scheme, auth, host, port, path, query, fragment)
+
+
+def get_host(url):
+    """
+    Deprecated. Use :func:`.parse_url` instead.
+    """
+    p = parse_url(url)
+    return p.scheme or 'http', p.hostname, p.port
+
+
+def make_headers(keep_alive=None, accept_encoding=None, user_agent=None,
+                 basic_auth=None):
+    """
+    Shortcuts for generating request headers.
+
+    :param keep_alive:
+        If ``True``, adds 'connection: keep-alive' header.
+
+    :param accept_encoding:
+        Can be a boolean, list, or string.
+        ``True`` translates to 'gzip,deflate'.
+        List will get joined by comma.
+        String will be used as provided.
+
+    :param user_agent:
+        String representing the user-agent you want, such as
+        "python-urllib3/0.6"
+
+    :param basic_auth:
+        Colon-separated username:password string for 'authorization: basic ...'
+        auth header.
+
+    Example: ::
+
+        >>> make_headers(keep_alive=True, user_agent="Batman/1.0")
+        {'connection': 'keep-alive', 'user-agent': 'Batman/1.0'}
+        >>> make_headers(accept_encoding=True)
+        {'accept-encoding': 'gzip,deflate'}
+    """
+    headers = {}
+    if accept_encoding:
+        if isinstance(accept_encoding, str):
+            pass
+        elif isinstance(accept_encoding, list):
+            accept_encoding = ','.join(accept_encoding)
+        else:
+            accept_encoding = 'gzip,deflate'
+        headers['accept-encoding'] = accept_encoding
+
+    if user_agent:
+        headers['user-agent'] = user_agent
+
+    if keep_alive:
+        headers['connection'] = 'keep-alive'
+
+    if basic_auth:
+        headers['authorization'] = 'Basic ' + \
+            b64encode(six.b(basic_auth)).decode('utf-8')
+
+    return headers
+
+
+def is_connection_dropped(conn):
+    """
+    Returns True if the connection is dropped and should be closed.
+
+    :param conn:
+        :class:`httplib.HTTPConnection` object.
+
+    Note: For platforms like AppEngine, this will always return ``False`` to
+    let the platform handle connection recycling transparently for us.
+    """
+    sock = getattr(conn, 'sock', False)
+    if not sock: # Platform-specific: AppEngine
+        return False
+
+    if not poll: # Platform-specific
+        if not select: # Platform-specific: AppEngine
+            return False
+
+        try:
+            return select([sock], [], [], 0.0)[0]
+        except SocketError:
+            return True
+
+    # This version is better on platforms that support it.
+    p = poll()
+    p.register(sock, POLLIN)
+    for (fno, ev) in p.poll(0.0):
+        if fno == sock.fileno():
+            # Either data is buffered (bad), or the connection is dropped.
+            return True
 
=== added directory '.pc/03-use-distro-packages.patch'
=== added directory '.pc/03-use-distro-packages.patch/requests'
=== added file '.pc/03-use-distro-packages.patch/requests/adapters.py'
--- .pc/03-use-distro-packages.patch/requests/adapters.py	1970-01-01 00:00:00 +0000
+++ .pc/03-use-distro-packages.patch/requests/adapters.py	2013-01-28 21:17:21 +0000
@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.adapters
+~~~~~~~~~~~~~~~~~
+
+This module contains the transport adapters that Requests uses to define
+and maintain connections.
+"""
+
+from .packages.urllib3.poolmanager import PoolManager
+
+class BaseAdapter(object):
+    """The Base Transport Adapter"""
+
+    def __init__(self, config=None):
+        super(BaseAdapter, self).__init__()
+        self.config = config or {}
+        self.session = None
+
+    @property
+    def configure(self, config):
+        self.config.update(config)
+
+    def send(self):
+        raise NotImplementedError
+
+    def close(self):
+        raise NotImplementedError
+
+
+class HTTPAdapter(BaseAdapter):
+    """Built-In HTTP Adapter for Urllib3."""
+    def __init__(self):
+        super(HTTPAdapter, self).__init__()
+
+        self.init_poolmanager()
+
+    def init_poolmanager(self):
+        self.poolmanager = PoolManager(
+            num_pools=self.config.get('pool_connections'),
+            maxsize=self.config.get('pool_maxsize')
+        )
+
+    def close(self):
+        """Dispose of any internal state.
+
+        Currently, this just closes the PoolManager, which closes pooled
+        connections.
+        """
+        self.poolmanager.clear()
+
+    def send(self, request):
+        """Sends request object. Returns Response object."""
+        pass
+
+
+
 
=== added file '.pc/03-use-distro-packages.patch/requests/compat.py'
--- .pc/03-use-distro-packages.patch/requests/compat.py	1970-01-01 00:00:00 +0000
+++ .pc/03-use-distro-packages.patch/requests/compat.py	2013-01-28 21:17:21 +0000
@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+
+"""
+pythoncompat
+"""
+
+
+import sys
+
+# -------
+# Pythons
+# -------
+
+# Syntax sugar.
+_ver = sys.version_info
+
+#: Python 2.x?
+is_py2 = (_ver[0] == 2)
+
+#: Python 3.x?
+is_py3 = (_ver[0] == 3)
+
+#: Python 3.0.x
+is_py30 = (is_py3 and _ver[1] == 0)
+
+#: Python 3.1.x
+is_py31 = (is_py3 and _ver[1] == 1)
+
+#: Python 3.2.x
+is_py32 = (is_py3 and _ver[1] == 2)
+
+#: Python 3.3.x
+is_py33 = (is_py3 and _ver[1] == 3)
+
+#: Python 3.4.x
+is_py34 = (is_py3 and _ver[1] == 4)
+
+#: Python 2.7.x
+is_py27 = (is_py2 and _ver[1] == 7)
+
+#: Python 2.6.x
+is_py26 = (is_py2 and _ver[1] == 6)
+
+#: Python 2.5.x
+is_py25 = (is_py2 and _ver[1] == 5)
+
+#: Python 2.4.x
+is_py24 = (is_py2 and _ver[1] == 4)   # I'm assuming this is not by choice.
+
+
+# ---------
+# Platforms
+# ---------
+
+
+# Syntax sugar.
+_ver = sys.version.lower()
+
+is_pypy = ('pypy' in _ver)
+is_jython = ('jython' in _ver)
+is_ironpython = ('iron' in _ver)
+
+# Assume CPython, if nothing else.
+is_cpython = not any((is_pypy, is_jython, is_ironpython))
+
+# Windows-based system.
+is_windows = 'win32' in str(sys.platform).lower()
+
+# Standard Linux 2+ system.
+is_linux = ('linux' in str(sys.platform).lower())
+is_osx = ('darwin' in str(sys.platform).lower())
+is_hpux = ('hpux' in str(sys.platform).lower())   # Complete guess.
+is_solaris = ('solar==' in str(sys.platform).lower())   # Complete guess.
+
+try:
+    import simplejson as json
+except ImportError:
+    import json
+
+# ---------
+# Specifics
+# ---------
+
+
+if is_py2:
+    from urllib import quote, unquote, quote_plus, unquote_plus, urlencode
+    from urlparse import urlparse, urlunparse, urljoin, urlsplit, urldefrag
+    from urllib2 import parse_http_list
+    import cookielib
+    from Cookie import Morsel
+    from StringIO import StringIO
+    try:
+        import cchardet as chardet
+    except ImportError:
+        from .packages import chardet
+    from .packages.urllib3.packages.ordered_dict import OrderedDict
+
+    builtin_str = str
+    bytes = str
+    str = unicode
+    basestring = basestring
+    numeric_types = (int, long, float)
+
+
+
+elif is_py3:
+    from urllib.parse import urlparse, urlunparse, urljoin, urlsplit, urlencode, quote, unquote, quote_plus, unquote_plus, urldefrag
+    from urllib.request import parse_http_list
+    from http import cookiejar as cookielib
+    from http.cookies import Morsel
+    from io import StringIO
+    from .packages import chardet2 as chardet
+    from collections import OrderedDict
+
+    builtin_str = str
+    str = str
+    bytes = bytes
+    basestring = (str, bytes)
+    numeric_types = (int, float)
 
=== added file '.pc/03-use-distro-packages.patch/requests/models.py'
--- .pc/03-use-distro-packages.patch/requests/models.py	1970-01-01 00:00:00 +0000
+++ .pc/03-use-distro-packages.patch/requests/models.py	2013-01-28 21:17:21 +0000
@@ -0,0 +1,907 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.models
+~~~~~~~~~~~~~~~
+
+This module contains the primary objects that power Requests.
+"""
+
+import os
+import socket
+from datetime import datetime
+from io import BytesIO
+
+from .hooks import dispatch_hook, HOOKS
+from .structures import CaseInsensitiveDict
+from .status_codes import codes
+
+from .auth import HTTPBasicAuth, HTTPProxyAuth
+from .cookies import cookiejar_from_dict, extract_cookies_to_jar, get_cookie_header
+from .packages.urllib3.exceptions import MaxRetryError, LocationParseError
+from .packages.urllib3.exceptions import TimeoutError
+from .packages.urllib3.exceptions import SSLError as _SSLError
+from .packages.urllib3.exceptions import HTTPError as _HTTPError
+from .packages.urllib3 import connectionpool, poolmanager
+from .packages.urllib3.filepost import encode_multipart_formdata
+from .defaults import SCHEMAS
+from .exceptions import (
+    ConnectionError, HTTPError, RequestException, Timeout, TooManyRedirects,
+    URLRequired, SSLError, MissingSchema, InvalidSchema, InvalidURL)
+from .utils import (
+    get_encoding_from_headers, stream_untransfer, guess_filename, requote_uri,
+    stream_decode_response_unicode, get_netrc_auth, get_environ_proxies,
+    to_key_val_list, DEFAULT_CA_BUNDLE_PATH, parse_header_links, iter_slices,
+    guess_json_utf)
+from .compat import (
+    cookielib, urlparse, urlunparse, urljoin, urlsplit, urlencode, str, bytes,
+    StringIO, is_py2, chardet, json, builtin_str, urldefrag)
+
+REDIRECT_STATI = (codes.moved, codes.found, codes.other, codes.temporary_moved)
+CONTENT_CHUNK_SIZE = 10 * 1024
+
+
+class Request(object):
+    """The :class:`Request <Request>` object. It carries out all functionality
+    of Requests. Recommended interface is with the Requests functions.
+    """
+
+    def __init__(self,
+        url=None,
+        headers=dict(),
+        files=None,
+        method=None,
+        data=dict(),
+        params=dict(),
+        auth=None,
+        cookies=None,
+        timeout=None,
+        redirect=False,
+        allow_redirects=False,
+        proxies=None,
+        hooks=None,
+        config=None,
+        prefetch=True,
+        _poolmanager=None,
+        verify=None,
+        session=None,
+        cert=None):
+
+        #: Dictionary of configurations for this request.
+        self.config = dict(config or [])
+
+        #: Float describes the timeout of the request.
+        #  (Use socket.setdefaulttimeout() as fallback)
+        self.timeout = timeout
+
+        #: Request URL.
+        #: Accept objects that have string representations.
+        try:
+            self.url = unicode(url)
+        except NameError:
+            # We're on Python 3.
+            self.url = str(url)
+        except UnicodeDecodeError:
+            self.url = url
+
+        #: Dictionary of HTTP Headers to attach to the :class:`Request <Request>`.
+        self.headers = dict(headers or [])
+
+        #: Dictionary of files to multipart upload (``{filename: content}``).
+        self.files = None
+
+        #: HTTP Method to use.
+        self.method = method
+
+        #: Dictionary, bytes or file stream of request body data to attach to the
+        #: :class:`Request <Request>`.
+        self.data = None
+
+        #: Dictionary or byte of querystring data to attach to the
+        #: :class:`Request <Request>`. The dictionary values can be lists for representing
+        #: multivalued query parameters.
+        self.params = None
+
+        #: True if :class:`Request <Request>` is part of a redirect chain (disables history
+        #: and HTTPError storage).
+        self.redirect = redirect
+
+        #: Set to True if full redirects are allowed (e.g. re-POST-ing of data at new ``Location``)
+        self.allow_redirects = allow_redirects
+
+        # Dictionary mapping protocol to the URL of the proxy (e.g. {'http': 'foo.bar:3128'})
+        self.proxies = dict(proxies or [])
+
+        for proxy_type, uri_ref in list(self.proxies.items()):
+            if not uri_ref:
+                del self.proxies[proxy_type]
+
+        # If no proxies are given, allow configuration by environment variables
+        # HTTP_PROXY and HTTPS_PROXY.
+        if not self.proxies and self.config.get('trust_env'):
+            self.proxies = get_environ_proxies()
+
+        self.data = data
+        self.params = params
+        self.files = files
+
+        #: :class:`Response <Response>` instance, containing
+        #: content and metadata of HTTP Response, once :attr:`sent <send>`.
+        self.response = Response()
+
+        #: Authentication tuple or object to attach to :class:`Request <Request>`.
+        self.auth = auth
+
+        #: CookieJar to attach to :class:`Request <Request>`.
+        if isinstance(cookies, cookielib.CookieJar):
+            self.cookies = cookies
+        else:
+            self.cookies = cookiejar_from_dict(cookies)
+
+        #: True if Request has been sent.
+        self.sent = False
+
+        #: Event-handling hooks.
+        self.hooks = {}
+
+        for event in HOOKS:
+            self.hooks[event] = []
+
+        hooks = hooks or {}
+
+        for (k, v) in list(hooks.items()):
+            self.register_hook(event=k, hook=v)
+
+        #: Session.
+        self.session = session
+
+        #: SSL Verification.
+        self.verify = verify
+
+        #: SSL Certificate
+        self.cert = cert
+
+        #: Prefetch response content
+        self.prefetch = prefetch
+
+        if headers:
+            headers = CaseInsensitiveDict(self.headers)
+        else:
+            headers = CaseInsensitiveDict()
+
+        # Add configured base headers.
+        for (k, v) in list(self.config.get('base_headers', {}).items()):
+            if k not in headers:
+                headers[k] = v
+
+        self.headers = headers
+        self._poolmanager = _poolmanager
+
+    def __repr__(self):
+        return '<Request [%s]>' % (self.method)
+
+    def _build_response(self, resp):
+        """Build internal :class:`Response <Response>` object
+        from given response.
+        """
+
+        def build(resp):
+
+            response = Response()
+
+            # Pass settings over.
+            response.config = self.config
+
+            if resp:
+
+                # Fallback to None if there's no status_code, for whatever reason.
+                response.status_code = getattr(resp, 'status', None)
+
+                # Make headers case-insensitive.
+                response.headers = CaseInsensitiveDict(getattr(resp, 'headers', {}))
+
+                # Set encoding.
+                response.encoding = get_encoding_from_headers(response.headers)
+
+                # Add new cookies from the server. Don't if configured not to
+                if self.config.get('store_cookies'):
+                    extract_cookies_to_jar(self.cookies, self, resp)
+
+                # Save cookies in Response.
+                response.cookies = self.cookies
+
+                # Save cookies in Session.
+                for cookie in self.cookies:
+                    self.session.cookies.set_cookie(cookie)
+
+                # No exceptions were harmed in the making of this request.
+                response.error = getattr(resp, 'error', None)
+
+            # Save original response for later.
+            response.raw = resp
+            if isinstance(self.full_url, bytes):
+                response.url = self.full_url.decode('utf-8')
+            else:
+                response.url = self.full_url
+
+            return response
+
+        history = []
+
+        r = build(resp)
+
+        if r.status_code in REDIRECT_STATI and not self.redirect:
+
+            while (('location' in r.headers) and
+                   ((r.status_code is codes.see_other) or (self.allow_redirects))):
+
+                r.content  # Consume socket so it can be released
+
+                if not len(history) < self.config.get('max_redirects'):
+                    raise TooManyRedirects()
+
+                # Release the connection back into the pool.
+                r.raw.release_conn()
+
+                history.append(r)
+
+                url = r.headers['location']
+                data = self.data
+                files = self.files
+
+                # Handle redirection without scheme (see: RFC 1808 Section 4)
+                if url.startswith('//'):
+                    parsed_rurl = urlparse(r.url)
+                    url = '%s:%s' % (parsed_rurl.scheme, url)
+
+                # Facilitate non-RFC2616-compliant 'location' headers
+                # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
+                if not urlparse(url).netloc:
+                    url = urljoin(r.url,
+                                  # Compliant with RFC3986, we percent
+                                  # encode the url.
+                                  requote_uri(url))
+
+                # http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.4
+                if r.status_code is codes.see_other:
+                    method = 'GET'
+                    data = None
+                    files = None
+                else:
+                    method = self.method
+
+                # Do what the browsers do if strict_mode is off...
+                if (not self.config.get('strict_mode')):
+
+                    if r.status_code in (codes.moved, codes.found) and self.method == 'POST':
+                        method = 'GET'
+                        data = None
+                        files = None
+
+                    if (r.status_code == 303) and self.method != 'HEAD':
+                        method = 'GET'
+                        data = None
+                        files = None
+
+                # Remove the cookie headers that were sent.
+                headers = self.headers
+                try:
+                    del headers['Cookie']
+                except KeyError:
+                    pass
+
+                request = Request(
+                    url=url,
+                    headers=headers,
+                    files=files,
+                    method=method,
+                    params=self.session.params,
+                    auth=self.auth,
+                    cookies=self.cookies,
+                    redirect=True,
+                    data=data,
+                    config=self.config,
+                    timeout=self.timeout,
+                    _poolmanager=self._poolmanager,
+                    proxies=self.proxies,
+                    verify=self.verify,
+                    session=self.session,
+                    cert=self.cert,
+                    prefetch=self.prefetch,
+                )
+
+                request.send()
+                r = request.response
+
+            r.history = history
+
+        self.response = r
+        self.response.request = self
+
+    @staticmethod
+    def _encode_params(data):
+        """Encode parameters in a piece of data.
+
+        Will successfully encode parameters when passed as a dict or a list of
+        2-tuples. Order is retained if data is a list of 2-tuples but abritrary
+        if parameters are supplied as a dict.
+        """
+
+        if isinstance(data, (str, bytes)):
+            return data
+        elif hasattr(data, 'read'):
+            return data
+        elif hasattr(data, '__iter__'):
+            result = []
+            for k, vs in to_key_val_list(data):
+                for v in isinstance(vs, list) and vs or [vs]:
+                    if v is not None:
+                        result.append(
+                            (k.encode('utf-8') if isinstance(k, str) else k,
+                             v.encode('utf-8') if isinstance(v, str) else v))
+            return urlencode(result, doseq=True)
+        else:
+            return data
+
+    def _encode_files(self, files):
+        """Build the body for a multipart/form-data request.
+
+        Will successfully encode files when passed as a dict or a list of
+        2-tuples. Order is retained if data is a list of 2-tuples but abritrary
+        if parameters are supplied as a dict.
+
+        """
+        if (not files) or isinstance(self.data, str):
+            return None
+
+        new_fields = []
+        fields = to_key_val_list(self.data)
+        files = to_key_val_list(files)
+
+        for field, val in fields:
+            if isinstance(val, list):
+                for v in val:
+                    new_fields.append((field, builtin_str(v)))
+            else:
+                new_fields.append((field, builtin_str(val)))
+
+        for (k, v) in files:
+            # support for explicit filename
+            if isinstance(v, (tuple, list)):
+                fn, fp = v
+            else:
+                fn = guess_filename(v) or k
+                fp = v
+            if isinstance(fp, str):
+                fp = StringIO(fp)
+            if isinstance(fp, bytes):
+                fp = BytesIO(fp)
+            new_fields.append((k, (fn, fp.read())))
+
+        body, content_type = encode_multipart_formdata(new_fields)
+
+        return body, content_type
+
+    @property
+    def full_url(self):
+        """Build the actual URL to use."""
+
+        if not self.url:
+            raise URLRequired()
+
+        url = self.url
+
+        # Support for unicode domain names and paths.
+        scheme, netloc, path, params, query, fragment = urlparse(url)
+
+        if not scheme:
+            raise MissingSchema("Invalid URL %r: No schema supplied" % url)
+
+        if not scheme in SCHEMAS:
+            raise InvalidSchema("Invalid scheme %r" % scheme)
+
+        try:
+            netloc = netloc.encode('idna').decode('utf-8')
+        except UnicodeError:
+            raise InvalidURL('URL has an invalid label.')
+
+        if not path:
+            path = '/'
+
+        if is_py2:
+            if isinstance(scheme, str):
+                scheme = scheme.encode('utf-8')
+            if isinstance(netloc, str):
+                netloc = netloc.encode('utf-8')
+            if isinstance(path, str):
+                path = path.encode('utf-8')
+            if isinstance(params, str):
+                params = params.encode('utf-8')
+            if isinstance(query, str):
+                query = query.encode('utf-8')
+            if isinstance(fragment, str):
+                fragment = fragment.encode('utf-8')
+
+        enc_params = self._encode_params(self.params)
+        if enc_params:
+            if query:
+                query = '%s&%s' % (query, enc_params)
+            else:
+                query = enc_params
+
+        url = (urlunparse([scheme, netloc, path, params, query, fragment]))
+
+        if self.config.get('encode_uri', True):
+            url = requote_uri(url)
+
+        return url
+
+    @property
+    def path_url(self):
+        """Build the path URL to use."""
+
+        url = []
+
+        p = urlsplit(self.full_url)
+
+        # Proxies use full URLs.
+        if p.scheme in self.proxies:
+            url_base, frag = urldefrag(self.full_url)
+            return url_base
+
+
+        path = p.path
+        if not path:
+            path = '/'
+
+        url.append(path)
+
+        query = p.query
+        if query:
+            url.append('?')
+            url.append(query)
+
+        return ''.join(url)
+
+    def register_hook(self, event, hook):
+        """Properly register a hook."""
+        if callable(hook):
+            self.hooks[event].append(hook)
+        elif hasattr(hook, '__iter__'):
+            self.hooks[event].extend(h for h in hook if callable(h))
+
+    def deregister_hook(self, event, hook):
+        """Deregister a previously registered hook.
+        Returns True if the hook existed, False if not.
+        """
+
+        try:
+            self.hooks[event].remove(hook)
+            return True
+        except ValueError:
+            return False
+
+    def send(self, anyway=False, prefetch=None):
+        """Sends the request. Returns True if successful, False if not.
+        If there was an HTTPError during transmission,
+        self.response.status_code will contain the HTTPError code.
+
+        Once a request is successfully sent, `sent` will equal True.
+
+        :param anyway: If True, request will be sent, even if it has
+        already been sent.
+
+        :param prefetch: If not None, will override the request's own setting
+        for prefetch.
+        """
+
+        # Build the URL
+        url = self.full_url
+
+        # Pre-request hook.
+        r = dispatch_hook('pre_request', self.hooks, self)
+        self.__dict__.update(r.__dict__)
+
+        # Logging
+        if self.config.get('verbose'):
+            self.config.get('verbose').write('%s   %s   %s\n' % (
+                datetime.now().isoformat(), self.method, url
+            ))
+
+        # Use .netrc auth if none was provided.
+        if not self.auth and self.config.get('trust_env'):
+            self.auth = get_netrc_auth(url)
+
+        if self.auth:
+            if isinstance(self.auth, tuple) and len(self.auth) == 2:
+                # special-case basic HTTP auth
+                self.auth = HTTPBasicAuth(*self.auth)
+
+            # Allow auth to make its changes.
+            r = self.auth(self)
+
+            # Update self to reflect the auth changes.
+            self.__dict__.update(r.__dict__)
+
+        # Nottin' on you.
+        body = None
+        content_type = None
+
+        # Multi-part file uploads.
+        if self.files:
+            (body, content_type) = self._encode_files(self.files)
+        else:
+            if self.data:
+
+                body = self._encode_params(self.data)
+                if isinstance(self.data, str) or isinstance(self.data, builtin_str) or hasattr(self.data, 'read'):
+                    content_type = None
+                else:
+                    content_type = 'application/x-www-form-urlencoded'
+
+        # Add content-type if it wasn't explicitly provided.
+        if (content_type) and (not 'content-type' in self.headers):
+            self.headers['Content-Type'] = content_type
+
+        _p = urlparse(url)
+        no_proxy = filter(lambda x: x.strip(), self.proxies.get('no', '').split(','))
+        proxy = self.proxies.get(_p.scheme)
+
+        if proxy and not any(map(_p.hostname.endswith, no_proxy)):
+            conn = poolmanager.proxy_from_url(proxy)
+            _proxy = urlparse(proxy)
+            if '@' in _proxy.netloc:
+                auth, url = _proxy.netloc.split('@', 1)
+                self.proxy_auth = HTTPProxyAuth(*auth.split(':', 1))
+                r = self.proxy_auth(self)
+                self.__dict__.update(r.__dict__)
+        else:
+            # Check to see if keep_alive is allowed.
+            try:
+                if self.config.get('keep_alive'):
+                    conn = self._poolmanager.connection_from_url(url)
+                else:
+                    conn = connectionpool.connection_from_url(url)
+                    self.headers['Connection'] = 'close'
+            except LocationParseError as e:
+                raise InvalidURL(e)
+
+        if url.startswith('https') and self.verify:
+
+            cert_loc = None
+
+            # Allow self-specified cert location.
+            if self.verify is not True:
+                cert_loc = self.verify
+
+            # Look for configuration.
+            if not cert_loc and self.config.get('trust_env'):
+                cert_loc = os.environ.get('REQUESTS_CA_BUNDLE')
+
+            # Curl compatibility.
+            if not cert_loc and self.config.get('trust_env'):
+                cert_loc = os.environ.get('CURL_CA_BUNDLE')
+
+            if not cert_loc:
+                cert_loc = DEFAULT_CA_BUNDLE_PATH
+
+            if not cert_loc:
+                raise Exception("Could not find a suitable SSL CA certificate bundle.")
+
+            conn.cert_reqs = 'CERT_REQUIRED'
+            conn.ca_certs = cert_loc
+        else:
+            conn.cert_reqs = 'CERT_NONE'
+            conn.ca_certs = None
+
+        if self.cert:
+            if len(self.cert) == 2:
+                conn.cert_file = self.cert[0]
+                conn.key_file = self.cert[1]
+            else:
+                conn.cert_file = self.cert
+
+        if not self.sent or anyway:
+
+            # Skip if 'cookie' header is explicitly set.
+            if 'cookie' not in self.headers:
+                cookie_header = get_cookie_header(self.cookies, self)
+                if cookie_header is not None:
+                    self.headers['Cookie'] = cookie_header
+
+            # Pre-send hook.
+            r = dispatch_hook('pre_send', self.hooks, self)
+            self.__dict__.update(r.__dict__)
+
+            # catch urllib3 exceptions and throw Requests exceptions
+            try:
+                # Send the request.
+                r = conn.urlopen(
+                    method=self.method,
+                    url=self.path_url,
+                    body=body,
+                    headers=self.headers,
+                    redirect=False,
+                    assert_same_host=False,
+                    preload_content=False,
+                    decode_content=False,
+                    retries=self.config.get('max_retries', 0),
+                    timeout=self.timeout,
+                )
+                self.sent = True
+
+            except socket.error as sockerr:
+                raise ConnectionError(sockerr)
+
+            except MaxRetryError as e:
+                raise ConnectionError(e)
+
+            except (_SSLError, _HTTPError) as e:
+                if isinstance(e, _SSLError):
+                    raise SSLError(e)
+                elif isinstance(e, TimeoutError):
+                    raise Timeout(e)
+                else:
+                    raise Timeout('Request timed out.')
+
+            # build_response can throw TooManyRedirects
+            self._build_response(r)
+
+            # Response manipulation hook.
+            self.response = dispatch_hook('response', self.hooks, self.response)
+
+            # Post-request hook.
+            r = dispatch_hook('post_request', self.hooks, self)
+            self.__dict__.update(r.__dict__)
+
+            # If prefetch is True, mark content as consumed.
+            if prefetch is None:
+                prefetch = self.prefetch
+            if prefetch:
+                # Save the response.
+                self.response.content
+
+            if self.config.get('danger_mode'):
+                self.response.raise_for_status()
+
+            return self.sent
+
+
+class Response(object):
+    """The core :class:`Response <Response>` object. All
+    :class:`Request <Request>` objects contain a
+    :class:`response <Response>` attribute, which is an instance
+    of this class.
+    """
+
+    def __init__(self):
+
+        self._content = False
+        self._content_consumed = False
+
+        #: Integer Code of responded HTTP Status.
+        self.status_code = None
+
+        #: Case-insensitive Dictionary of Response Headers.
+        #: For example, ``headers['content-encoding']`` will return the
+        #: value of a ``'Content-Encoding'`` response header.
+        self.headers = CaseInsensitiveDict()
+
+        #: File-like object representation of response (for advanced usage).
+        self.raw = None
+
+        #: Final URL location of Response.
+        self.url = None
+
+        #: Resulting :class:`HTTPError` of request, if one occurred.
+        self.error = None
+
+        #: Encoding to decode with when accessing r.text.
+        self.encoding = None
+
+        #: A list of :class:`Response <Response>` objects from
+        #: the history of the Request. Any redirect responses will end
+        #: up here. The list is sorted from the oldest to the most recent request.
+        self.history = []
+
+        #: The :class:`Request <Request>` that created the Response.
+        self.request = None
+
+        #: A CookieJar of Cookies the server sent back.
+        self.cookies = None
+
+        #: Dictionary of configurations for this request.
+        self.config = {}
+
+    def __repr__(self):
+        return '<Response [%s]>' % (self.status_code)
+
+    def __bool__(self):
+        """Returns true if :attr:`status_code` is 'OK'."""
+        return self.ok
+
+    def __nonzero__(self):
+        """Returns true if :attr:`status_code` is 'OK'."""
+        return self.ok
+
+    @property
+    def ok(self):
+        try:
+            self.raise_for_status()
+        except RequestException:
+            return False
+        return True
+
+    def iter_content(self, chunk_size=1, decode_unicode=False):
+        """Iterates over the response data.  This avoids reading the content
+        at once into memory for large responses.  The chunk size is the number
+        of bytes it should read into memory.  This is not necessarily the
+        length of each item returned as decoding can take place.
+        """
+        if self._content_consumed:
+            # simulate reading small chunks of the content
+            return iter_slices(self._content, chunk_size)
+
+        def generate():
+            while 1:
+                chunk = self.raw.read(chunk_size)
+                if not chunk:
+                    break
+                yield chunk
+            self._content_consumed = True
+
+        gen = stream_untransfer(generate(), self)
+
+        if decode_unicode:
+            gen = stream_decode_response_unicode(gen, self)
+
+        return gen
+
+    def iter_lines(self, chunk_size=10 * 1024, decode_unicode=None):
+        """Iterates over the response data, one line at a time.  This
+        avoids reading the content at once into memory for large
+        responses.
+        """
+
+        pending = None
+
+        for chunk in self.iter_content(
+            chunk_size=chunk_size,
+            decode_unicode=decode_unicode):
+
+            if pending is not None:
+                chunk = pending + chunk
+            lines = chunk.splitlines()
+
+            if lines and lines[-1] and chunk and lines[-1][-1] == chunk[-1]:
+                pending = lines.pop()
+            else:
+                pending = None
+
+            for line in lines:
+                yield line
+
+        if pending is not None:
+            yield pending
+
+    @property
+    def content(self):
+        """Content of the response, in bytes."""
+
+        if self._content is False:
+            # Read the contents.
+            try:
+                if self._content_consumed:
+                    raise RuntimeError(
+                        'The content for this response was already consumed')
+
+                if self.status_code is 0:
+                    self._content = None
+                else:
+                    self._content = bytes().join(self.iter_content(CONTENT_CHUNK_SIZE)) or bytes()
+
+            except AttributeError:
+                self._content = None
+
+        self._content_consumed = True
+        # don't need to release the connection; that's been handled by urllib3
+        # since we exhausted the data.
+        return self._content
+
+    @property
+    def text(self):
+        """Content of the response, in unicode.
+
+        if Response.encoding is None and chardet module is available, encoding
+        will be guessed.
+        """
+
+        # Try charset from content-type
+        content = None
+        encoding = self.encoding
+
+        if not self.content:
+            return str('')
+
+        # Fallback to auto-detected encoding.
+        if self.encoding is None:
+            if chardet is not None:
+                encoding = chardet.detect(self.content)['encoding']
+
+        # Decode unicode from given encoding.
+        try:
+            content = str(self.content, encoding, errors='replace')
+        except (LookupError, TypeError):
+            # A LookupError is raised if the encoding was not found which could
+            # indicate a misspelling or similar mistake.
+            #
+            # A TypeError can be raised if encoding is None
+            #
+            # So we try blindly encoding.
+            content = str(self.content, errors='replace')
+
+        return content
+
+    @property
+    def json(self):
+        """Returns the json-encoded content of a response, if any."""
+
+        if not self.encoding and len(self.content) > 3:
+            # No encoding set. JSON RFC 4627 section 3 states we should expect
+            # UTF-8, -16 or -32. Detect which one to use; If the detection or
+            # decoding fails, fall back to `self.text` (using chardet to make
+            # a best guess).
+            encoding = guess_json_utf(self.content)
+            if encoding is not None:
+                try:
+                    return json.loads(self.content.decode(encoding))
+                except (ValueError, UnicodeDecodeError):
+                    pass
+        try:
+            return json.loads(self.text or self.content)
+        except ValueError:
+            return None
+
+    @property
+    def links(self):
+        """Returns the parsed header links of the response, if any."""
+
+        header = self.headers['link']
+
+        # l = MultiDict()
+        l = {}
+
+        if header:
+            links = parse_header_links(header)
+
+            for link in links:
+                key = link.get('rel') or link.get('url')
+                l[key] = link
+
+        return l
+
+    @property
+    def reason(self):
+        """The HTTP Reason for the response."""
+        return self.raw.reason
+
+    def raise_for_status(self, allow_redirects=True):
+        """Raises stored :class:`HTTPError` or :class:`URLError`, if one occurred."""
+
+        if self.error:
+            raise self.error
+
+        http_error_msg = ''
+        if 300 <= self.status_code < 400 and not allow_redirects:
+            http_error_msg = '%s Redirection: %s' % (self.status_code, self.reason)
+
+        elif 400 <= self.status_code < 500:
+            http_error_msg = '%s Client Error: %s' % (self.status_code, self.reason)
+
+        elif 500 <= self.status_code < 600:
+            http_error_msg = '%s Server Error: %s' % (self.status_code, self.reason)
+
+        if http_error_msg:
+            http_error = HTTPError(http_error_msg)
+            http_error.response = self
+            raise http_error
 
=== added directory '.pc/03-use-distro-packages.patch/requests/packages'
=== added file '.pc/03-use-distro-packages.patch/requests/packages/__init__.py'
--- .pc/03-use-distro-packages.patch/requests/packages/__init__.py	1970-01-01 00:00:00 +0000
+++ .pc/03-use-distro-packages.patch/requests/packages/__init__.py	2013-01-28 21:17:21 +0000
@@ -0,0 +1,3 @@
+from __future__ import absolute_import
+
+from . import urllib3
 
=== added file '.pc/03-use-distro-packages.patch/requests/safe_mode.py'
--- .pc/03-use-distro-packages.patch/requests/safe_mode.py	1970-01-01 00:00:00 +0000
+++ .pc/03-use-distro-packages.patch/requests/safe_mode.py	2013-01-28 21:17:21 +0000
@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.safe_mode
+~~~~~~~~~~~~
+
+This module contains a decorator that implements safe_mode.
+
+:copyright: (c) 2012 by Kenneth Reitz.
+:license: ISC, see LICENSE for more details.
+
+"""
+
+from .models import Response
+from .packages.urllib3.response import HTTPResponse
+from .exceptions import RequestException, ConnectionError, HTTPError
+import socket
+
+
+def catch_exceptions_if_in_safe_mode(function):
+    """New implementation of safe_mode. We catch all exceptions at the API level
+    and then return a blank Response object with the error field filled. This decorator
+    wraps request() in api.py.
+    """
+
+    def wrapped(method, url, **kwargs):
+        # if save_mode, we catch exceptions and fill error field
+        if (kwargs.get('config') and kwargs.get('config').get('safe_mode')) or (kwargs.get('session')
+                                            and kwargs.get('session').config.get('safe_mode')):
+            try:
+                return function(method, url, **kwargs)
+            except (RequestException, ConnectionError, HTTPError,
+                    socket.timeout, socket.gaierror) as e:
+                r = Response()
+                r.error = e
+                r.raw = HTTPResponse()  # otherwise, tests fail
+                r.status_code = 0  # with this status_code, content returns None
+                return r
+        return function(method, url, **kwargs)
+    return wrapped
 
=== added file '.pc/03-use-distro-packages.patch/requests/sessions.py'
--- .pc/03-use-distro-packages.patch/requests/sessions.py	1970-01-01 00:00:00 +0000
+++ .pc/03-use-distro-packages.patch/requests/sessions.py	2013-01-28 21:17:21 +0000
@@ -0,0 +1,328 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.session
+~~~~~~~~~~~~~~~~
+
+This module provides a Session object to manage and persist settings across
+requests (cookies, auth, proxies).
+
+"""
+
+from copy import deepcopy
+from .compat import cookielib
+from .cookies import cookiejar_from_dict, remove_cookie_by_name
+from .defaults import defaults
+from .models import Request
+from .hooks import dispatch_hook
+from .utils import header_expand, from_key_val_list
+from .packages.urllib3.poolmanager import PoolManager
+
+
+def merge_kwargs(local_kwarg, default_kwarg):
+    """Merges kwarg dictionaries.
+
+    If a local key in the dictionary is set to None, it will be removed.
+    """
+
+    if default_kwarg is None:
+        return local_kwarg
+
+    if isinstance(local_kwarg, str):
+        return local_kwarg
+
+    if local_kwarg is None:
+        return default_kwarg
+
+    # Bypass if not a dictionary (e.g. timeout)
+    if not hasattr(default_kwarg, 'items'):
+        return local_kwarg
+
+    default_kwarg = from_key_val_list(default_kwarg)
+    local_kwarg = from_key_val_list(local_kwarg)
+
+    # Update new values.
+    kwargs = default_kwarg.copy()
+    kwargs.update(local_kwarg)
+
+    # Remove keys that are set to None.
+    for (k, v) in local_kwarg.items():
+        if v is None:
+            del kwargs[k]
+
+    return kwargs
+
+
+class Session(object):
+    """A Requests session."""
+
+    __attrs__ = [
+        'headers', 'cookies', 'auth', 'timeout', 'proxies', 'hooks',
+        'params', 'config', 'verify', 'cert', 'prefetch']
+
+    def __init__(self,
+        headers=None,
+        cookies=None,
+        auth=None,
+        timeout=None,
+        proxies=None,
+        hooks=None,
+        params=None,
+        config=None,
+        prefetch=True,
+        verify=True,
+        cert=None):
+
+        self.headers = from_key_val_list(headers or [])
+        self.auth = auth
+        self.timeout = timeout
+        self.proxies = from_key_val_list(proxies or [])
+        self.hooks = from_key_val_list(hooks or {})
+        self.params = from_key_val_list(params or [])
+        self.config = from_key_val_list(config or {})
+        self.prefetch = prefetch
+        self.verify = verify
+        self.cert = cert
+
+        for (k, v) in list(defaults.items()):
+            self.config.setdefault(k, deepcopy(v))
+
+        self.init_poolmanager()
+
+        # Set up a CookieJar to be used by default
+        if isinstance(cookies, cookielib.CookieJar):
+            self.cookies = cookies
+        else:
+            self.cookies = cookiejar_from_dict(cookies)
+
+    def init_poolmanager(self):
+        self.poolmanager = PoolManager(
+            num_pools=self.config.get('pool_connections'),
+            maxsize=self.config.get('pool_maxsize')
+        )
+
+    def __repr__(self):
+        return '<requests-client at 0x%x>' % (id(self))
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def close(self):
+        """Dispose of any internal state.
+
+        Currently, this just closes the PoolManager, which closes pooled
+        connections.
+        """
+        self.poolmanager.clear()
+
+    def request(self, method, url,
+        params=None,
+        data=None,
+        headers=None,
+        cookies=None,
+        files=None,
+        auth=None,
+        timeout=None,
+        allow_redirects=True,
+        proxies=None,
+        hooks=None,
+        return_response=True,
+        config=None,
+        prefetch=None,
+        verify=None,
+        cert=None):
+
+        """Constructs and sends a :class:`Request <Request>`.
+        Returns :class:`Response <Response>` object.
+
+        :param method: method for the new :class:`Request` object.
+        :param url: URL for the new :class:`Request` object.
+        :param params: (optional) Dictionary or bytes to be sent in the query string for the :class:`Request`.
+        :param data: (optional) Dictionary or bytes to send in the body of the :class:`Request`.
+        :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`.
+        :param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`.
+        :param files: (optional) Dictionary of 'filename': file-like-objects for multipart encoding upload.
+        :param auth: (optional) Auth tuple or callable to enable Basic/Digest/Custom HTTP Auth.
+        :param timeout: (optional) Float describing the timeout of the request.
+        :param allow_redirects: (optional) Boolean. Set to True by default.
+        :param proxies: (optional) Dictionary mapping protocol to the URL of the proxy.
+        :param return_response: (optional) If False, an un-sent Request object will returned.
+        :param config: (optional) A configuration dictionary. See ``request.defaults`` for allowed keys and their default values.
+        :param prefetch: (optional) whether to immediately download the response content. Defaults to ``True``.
+        :param verify: (optional) if ``True``, the SSL cert will be verified. A CA_BUNDLE path can also be provided.
+        :param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair.
+        """
+
+        method = str(method).upper()
+
+        # Default empty dicts for dict params.
+        data = [] if data is None else data
+        files = [] if files is None else files
+        headers = {} if headers is None else headers
+        params = {} if params is None else params
+        hooks = {} if hooks is None else hooks
+        prefetch = prefetch if prefetch is not None else self.prefetch
+
+        # use session's hooks as defaults
+        for key, cb in list(self.hooks.items()):
+            hooks.setdefault(key, cb)
+
+        # Expand header values.
+        if headers:
+            for k, v in list(headers.items() or {}):
+                headers[k] = header_expand(v)
+
+        args = dict(
+            method=method,
+            url=url,
+            data=data,
+            params=from_key_val_list(params),
+            headers=from_key_val_list(headers),
+            cookies=cookies,
+            files=files,
+            auth=auth,
+            hooks=from_key_val_list(hooks),
+            timeout=timeout,
+            allow_redirects=allow_redirects,
+            proxies=from_key_val_list(proxies),
+            config=from_key_val_list(config),
+            prefetch=prefetch,
+            verify=verify,
+            cert=cert,
+            _poolmanager=self.poolmanager
+        )
+
+        # merge session cookies into passed-in ones
+        dead_cookies = None
+        # passed-in cookies must become a CookieJar:
+        if not isinstance(cookies, cookielib.CookieJar):
+            args['cookies'] = cookiejar_from_dict(cookies)
+            # support unsetting cookies that have been passed in with None values
+            # this is only meaningful when `cookies` is a dict ---
+            # for a real CookieJar, the client should use session.cookies.clear()
+            if cookies is not None:
+                dead_cookies = [name for name in cookies if cookies[name] is None]
+        # merge the session's cookies into the passed-in cookies:
+        for cookie in self.cookies:
+            args['cookies'].set_cookie(cookie)
+        # remove the unset cookies from the jar we'll be using with the current request
+        # (but not from the session's own store of cookies):
+        if dead_cookies is not None:
+            for name in dead_cookies:
+                remove_cookie_by_name(args['cookies'], name)
+
+        # Merge local kwargs with session kwargs.
+        for attr in self.__attrs__:
+            # we already merged cookies:
+            if attr == 'cookies':
+                continue
+
+            session_val = getattr(self, attr, None)
+            local_val = args.get(attr)
+            args[attr] = merge_kwargs(local_val, session_val)
+
+        # Arguments manipulation hook.
+        args = dispatch_hook('args', args['hooks'], args)
+
+        # Create the (empty) response.
+        r = Request(**args)
+
+        # Give the response some context.
+        r.session = self
+
+        # Don't send if asked nicely.
+        if not return_response:
+            return r
+
+        # Send the HTTP Request.
+        r.send(prefetch=prefetch)
+
+        # Return the response.
+        return r.response
+
+    def get(self, url, **kwargs):
+        """Sends a GET request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        """
+
+        kwargs.setdefault('allow_redirects', True)
+        return self.request('get', url, **kwargs)
+
+    def options(self, url, **kwargs):
+        """Sends a OPTIONS request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        """
+
+        kwargs.setdefault('allow_redirects', True)
+        return self.request('options', url, **kwargs)
+
+    def head(self, url, **kwargs):
+        """Sends a HEAD request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        """
+
+        kwargs.setdefault('allow_redirects', False)
+        return self.request('head', url, **kwargs)
+
+    def post(self, url, data=None, **kwargs):
+        """Sends a POST request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param data: (optional) Dictionary or bytes to send in the body of the :class:`Request`.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        """
+
+        return self.request('post', url, data=data, **kwargs)
+
+    def put(self, url, data=None, **kwargs):
+        """Sends a PUT request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param data: (optional) Dictionary or bytes to send in the body of the :class:`Request`.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        """
+
+        return self.request('put', url, data=data, **kwargs)
+
+    def patch(self, url, data=None, **kwargs):
+        """Sends a PATCH request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param data: (optional) Dictionary or bytes to send in the body of the :class:`Request`.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        """
+
+        return self.request('patch', url,  data=data, **kwargs)
+
+    def delete(self, url, **kwargs):
+        """Sends a DELETE request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param \*\*kwargs: Optional arguments that ``request`` takes.
+        """
+
+        return self.request('delete', url, **kwargs)
+
+    def __getstate__(self):
+        return dict((attr, getattr(self, attr, None)) for attr in self.__attrs__)
+
+    def __setstate__(self, state):
+        for attr, value in state.items():
+            setattr(self, attr, value)
+
+        self.init_poolmanager()
+
+
+def session(**kwargs):
+    """Returns a :class:`Session` for context-management."""
+
+    return Session(**kwargs)
 
=== added file '.pc/03-use-distro-packages.patch/setup.py'
--- .pc/03-use-distro-packages.patch/setup.py	1970-01-01 00:00:00 +0000
+++ .pc/03-use-distro-packages.patch/setup.py	2013-01-28 21:17:21 +0000
@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+
+import os
+import sys
+
+import requests
+from requests.compat import is_py2
+
+try:
+    from setuptools import setup
+except ImportError:
+    from distutils.core import setup
+
+if sys.argv[-1] == 'publish':
+    os.system('python setup.py sdist upload')
+    sys.exit()
+
+os.environ['PYTHONDONTWRITEBYTECODE'] = '1'
+
+packages = [
+    'requests',
+    'requests.packages',
+    'requests.packages.urllib3',
+    'requests.packages.urllib3.packages',
+    'requests.packages.urllib3.packages.ssl_match_hostname'
+]
+
+if is_py2:
+    packages.extend([
+        'requests.packages.oauthlib',
+        'requests.packages.oauthlib.oauth1',
+        'requests.packages.oauthlib.oauth1.rfc5849',
+        'requests.packages.oauthlib.oauth2',
+        'requests.packages.oauthlib.oauth2.draft25',
+        'requests.packages.chardet',
+    ])
+else:
+    packages.append('requests.packages.chardet2')
+
+requires = []
+
+setup(
+    name='requests',
+    version=requests.__version__,
+    description='Python HTTP for Humans.',
+    long_description=open('README.rst').read() + '\n\n' +
+                     open('HISTORY.rst').read(),
+    author='Kenneth Reitz',
+    author_email='[e-mail]',
+    url='http://python-requests.org',
+    packages=packages,
+    package_data={'': ['LICENSE', 'NOTICE'], 'requests': ['*.pem']},
+    package_dir={'requests': 'requests'},
+    include_package_data=True,
+    install_requires=requires,
+    license=open('LICENSE').read(),
+    classifiers=(
+        'Development Status :: 5 - Production/Stable',
+        'Intended Audience :: Developers',
+        'Natural Language :: English',
+        'License :: OSI Approved :: ISC License (ISCL)',
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 2.6',
+        'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.0',
+        'Programming Language :: Python :: 3.1',
+        'Programming Language :: Python :: 3.2',
+        'Programming Language :: Python :: 3.3',
+    ),
+)
+
+del os.environ['PYTHONDONTWRITEBYTECODE']
 
=== added file '.pc/applied-patches'
--- .pc/applied-patches	1970-01-01 00:00:00 +0000
+++ .pc/applied-patches	2013-01-28 21:17:21 +0000
@@ -0,0 +1,2 @@
+02_do-not-use-embedded-python-six.patch
+03-use-distro-packages.patch
 
=== modified file 'HISTORY.rst'
--- HISTORY.rst	2011-11-25 00:02:28 +0000
+++ HISTORY.rst	2013-01-28 21:17:21 +0000
@@ -1,10 +1,306 @@
+.. :changelog:
+
 History
 -------
 
+0.14.2 (2012-10-27)
++++++++++++++++++++
+
+- Improved mime-compatible JSON handling
+- Proxy fixes
+- Path hack fixes
+- Case-Insensistive Content-Encoding headers
+- Support for CJK parameters in form posts
+
+
+0.14.1 (2012-10-01)
++++++++++++++++++++
+
+- Python 3.3 Compatibility
+- Simply default accept-encoding
+- Bugfixes
+
+
+0.14.0 (2012-09-02)
+++++++++++++++++++++
+
+- No more iter_content errors if already downloaded.
+
+0.13.9 (2012-08-25)
++++++++++++++++++++
+
+- Fix for OAuth + POSTs
+- Remove exception eating from dispatch_hook
+- General bugfixes
+
+0.13.8 (2012-08-21)
++++++++++++++++++++
+
+- Incredible Link header support :)
+
+0.13.7 (2012-08-19)
++++++++++++++++++++
+
+- Support for (key, value) lists everywhere.
+- Digest Authentication improvements.
+- Ensure proxy exclusions work properly.
+- Clearer UnicodeError exceptions.
+- Automatic casting of URLs to tsrings (fURL and such)
+- Bugfixes.
+
+0.13.6 (2012-08-06)
++++++++++++++++++++
+
+- Long awaited fix for hanging connections!
+
+0.13.5 (2012-07-27)
++++++++++++++++++++
+
+- Packaging fix
+
+0.13.4 (2012-07-27)
++++++++++++++++++++
+
+- GSSAPI/Kerberos authentication!
+- App Engine 2.7 Fixes!
+- Fix leaking connections (from urllib3 update)
+- OAuthlib path hack fix
+- OAuthlib URL parameters fix.
+
+0.13.3 (2012-07-12)
++++++++++++++++++++
+
+- Use simplejson if available.
+- Do not hide SSLErrors behind Timeouts.
+- Fixed param handling with urls containing fragments.
+- Significantly improved information in User Agent.
+- client certificates are ignored when verify=False
+
+0.13.2 (2012-06-28)
++++++++++++++++++++
+
+- Zero dependencies (once again)!
+- New: Response.reason
+- Sign querystring parameters in OAuth 1.0
+- Client certificates no longer ignored when verify=False
+- Add openSUSE certificate support
+
+0.13.1 (2012-06-07)
++++++++++++++++++++
+
+- Allow passing a file or file-like object as data.
+- Allow hooks to return responses that indicate errors.
+- Fix Response.text and Response.json for body-less responses.
+
+0.13.0 (2012-05-29)
++++++++++++++++++++
+
+- Removal of Requests.async in favor of `grequests <https://github.com/kennethreitz/grequests>`_
+- Allow disabling of cookie persistiance.
+- New implimentation of safe_mode
+- cookies.get now supports default argument
+- Session cookies not saved when Session.request is called with return_response=False
+- Env: no_proxy support.
+- RequestsCookieJar improvements.
+- Various bug fixes.
+
+0.12.1 (2012-05-08)
++++++++++++++++++++
+
+- New ``Response.json`` property.
+- Ability to add string file uploads.
+- Fix out-of-range issue with iter_lines.
+- Fix iter_content default size.
+- Fix POST redirects containing files.
+
+0.12.0 (2012-05-02)
++++++++++++++++++++
+
+- EXPERIMENTAL OAUTH SUPPORT!
+- Proper CookieJar-backed cookies interface with awesome dict-like interface.
+- Speed fix for non-iterated content chunks.
+- Move ``pre_request`` to a more usable place.
+- New ``pre_send`` hook.
+- Lazily encode data, params, files.
+- Load system Certificate Bundle if ``certify`` isn't available.
+- Cleanups, fixes.
+
+0.11.2 (2012-04-22)
++++++++++++++++++++
+
+- Attempt to use the OS's certificate bundle if ``certifi`` isn't available.
+- Infinite digest auth redirect fix.
+- Multi-part file upload improvements.
+- Fix decoding of invalid %encodings in URLs.
+- If there is no content in a response don't throw an error the second time that content is attempted to be read.
+- Upload data on redirects.
+
+0.11.1 (2012-03-30)
++++++++++++++++++++
+
+* POST redirects now break RFC to do what browsers do: Follow up with a GET.
+* New ``strict_mode`` configuration to disable new redirect behavior.
+
+
+0.11.0 (2012-03-14)
++++++++++++++++++++
+
+* Private SSL Certificate support
+* Remove select.poll from Gevent monkeypatching
+* Remove redundant generator for chunked transfer encoding
+* Fix: Response.ok raises Timeout Exception in safe_mode
+
+0.10.8 (2012-03-09)
++++++++++++++++++++
+
+* Generate chunked ValueError fix
+* Proxy configuration by environment variables
+* Simplification of iter_lines.
+* New `trust_env` configuration for disabling system/environment hints.
+* Suppress cookie errors.
+
+0.10.7 (2012-03-07)
++++++++++++++++++++
+
+* `encode_uri` = False
+
+0.10.6 (2012-02-25)
++++++++++++++++++++
+
+* Allow '=' in cookies.
+
+0.10.5 (2012-02-25)
++++++++++++++++++++
+
+* Response body with 0 content-length fix.
+* New async.imap.
+* Don't fail on netrc.
+
+
+0.10.4 (2012-02-20)
++++++++++++++++++++
+
+* Honor netrc.
+
+0.10.3 (2012-02-20)
++++++++++++++++++++
+
+* HEAD requests don't follow redirects anymore.
+* raise_for_status() doesn't raise for 3xx anymore.
+* Make Session objects picklable.
+* ValueError for invalid schema URLs.
+
+0.10.2 (2012-01-15)
++++++++++++++++++++
+
+* Vastly improved URL quoting.
+* Additional allowed cookie key values.
+* Attempted fix for "Too many open files" Error
+* Replace unicode errors on first pass, no need for second pass.
+* Append '/' to bare-domain urls before query insertion.
+* Exceptions now inherit from RuntimeError.
+* Binary uploads + auth fix.
+* Bugfixes.
+
+
+0.10.1 (2012-01-23)
++++++++++++++++++++
+
+* PYTHON 3 SUPPORT!
+* Dropped 2.5 Support. (*Backwards Incompatible*)
+
+0.10.0 (2012-01-21)
++++++++++++++++++++
+
+* ``Response.content`` is now bytes-only. (*Backwards Incompatible*)
+* New ``Response.text`` is unicode-only.
+* If no ``Response.encoding`` is specified and ``chardet`` is available, ``Respoonse.text`` will guess an encoding.
+* Default to ISO-8859-1 (Western) encoding for "text" subtypes.
+* Removal of `decode_unicode`. (*Backwards Incompatible*)
+* New multiple-hooks system.
+* New ``Response.register_hook`` for registering hooks within the pipeline.
+* ``Response.url`` is now Unicode.
+
+0.9.3 (2012-01-18)
+++++++++++++++++++
+
+* SSL verify=False bugfix (apparent on windows machines).
+
+0.9.2 (2012-01-18)
+++++++++++++++++++
+
+* Asynchronous async.send method.
+* Support for proper chunk streams with boundaries.
+* session argument for Session classes.
+* Print entire hook tracebacks, not just exception instance.
+* Fix response.iter_lines from pending next line.
+* Fix but in HTTP-digest auth w/ URI having query strings.
+* Fix in Event Hooks section.
+* Urllib3 update.
+
+
+0.9.1 (2012-01-06)
+++++++++++++++++++
+
+* danger_mode for automatic Response.raise_for_status()
+* Response.iter_lines refactor
+
+0.9.0 (2011-12-28)
+++++++++++++++++++
+
+* verify ssl is default.
+
+
+0.8.9 (2011-12-28)
+++++++++++++++++++
+
+* Packaging fix.
+
+
+0.8.8 (2011-12-28)
+++++++++++++++++++
+
+* SSL CERT VERIFICATION!
+* Release of Cerifi: Mozilla's cert list.
+* New 'verify' argument for SSL requests.
+* Urllib3 update.
+
+0.8.7 (2011-12-24)
+++++++++++++++++++
+
+* iter_lines last-line truncation fix
+* Force safe_mode for async requests
+* Handle safe_mode exceptions more consistently
+* Fix iteration on null responses in safe_mode
+
+0.8.6 (2011-12-18)
+++++++++++++++++++
+
+* Socket timeout fixes.
+* Proxy Authorization support.
+
+0.8.5 (2011-12-14)
+++++++++++++++++++
+
+* Response.iter_lines!
+
+0.8.4 (2011-12-11)
+++++++++++++++++++
+
+* Prefetch bugfix.
+* Added license to installed version.
+
+0.8.3 (2011-11-27)
+++++++++++++++++++
+
+* Converted auth system to use simpler callable objects.
+* New session parameter to API methods.
+* Display full URL while logging.
+
 0.8.2 (2011-11-19)
 ++++++++++++++++++
 
-* New unicode decoding system, based on overridable `Response.encoding`.
+* New Unicode decoding system, based on over-ridable `Response.encoding`.
 * Proper URL slash-quote handling.
 * Cookies with ``[``, ``]``, and ``_`` allowed.
 
@@ -28,6 +324,7 @@
 * OPTION method
 * Async pool size throttling
 * File uploads send real names
+* Vendored in urllib3
 
 0.7.6 (2011-11-07)
 ++++++++++++++++++
@@ -43,7 +340,7 @@
 0.7.4 (2011-10-26)
 ++++++++++++++++++
 
-* Sesion Hooks fix.
+* Session Hooks fix.
 
 0.7.3 (2011-10-23)
 ++++++++++++++++++
 
=== modified file 'LICENSE'
--- LICENSE	2011-06-06 02:11:15 +0000
+++ LICENSE	2013-01-28 21:17:21 +0000
@@ -1,4 +1,4 @@
-Copyright (c) 2011 Kenneth Reitz.
+Copyright (c) 2012 Kenneth Reitz.
 
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above
 
=== modified file 'MANIFEST.in'
--- MANIFEST.in	2011-10-19 20:49:39 +0000
+++ MANIFEST.in	2013-01-28 21:17:21 +0000
@@ -1,1 +1,1 @@
-include README.rst LICENSE HISTORY.rst test_requests.py
+include README.rst LICENSE NOTICE HISTORY.rst tests/*. requests/cacert.pem
 
=== added file 'NOTICE'
--- NOTICE	1970-01-01 00:00:00 +0000
+++ NOTICE	2013-01-28 21:17:21 +0000
@@ -0,0 +1,116 @@
+Requests includes some vendorized python libraries to ease installation.
+
+Urllib3 License
+===============
+
+This is the MIT license: http://www.opensource.org/licenses/mit-license.php
+
+Copyright 2008-2011 Andrey Petrov and contributors (see CONTRIBUTORS.txt),
+Modifications copyright 2022 Kenneth Reitz.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+
+Chardet License
+===============
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+02110-1301  USA
+
+
+
+Chardet2 License
+================
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+02110-1301  USA
+
+
+
+Bundle of CA Root Certificates
+==============================
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+02110-1301
+
+
+OAuthlib
+========
+
+Copyright (c) 2011 Idan Gazit and contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of this project nor the names of its contributors may
+       be used to endorse or promote products derived from this software without
+       specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
=== modified file 'PKG-INFO'
--- PKG-INFO	2011-11-25 00:02:28 +0000
+++ PKG-INFO	2013-01-28 21:17:21 +0000
@@ -1,14 +1,30 @@
-Metadata-Version: 1.0
+Metadata-Version: 1.1
 Name: requests
-Version: 0.8.2
+Version: 0.14.2
 Summary: Python HTTP for Humans.
 Home-page: http://python-requests.org
 Author: Kenneth Reitz
 Author-email: [e-mail]
-License: ISC
+License: Copyright (c) 2012 Kenneth Reitz.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 Description: Requests: HTTP for Humans
         =========================
         
+        
+        .. image:: https://secure.travis-ci.org/kennethreitz/requests.png?branch=develop
+                :target: https://secure.travis-ci.org/kennethreitz/requests
+        
         Requests is an ISC Licensed HTTP library, written in Python, for human
         beings.
         
@@ -27,60 +43,32 @@
             204
             >>> r.headers['content-type']
             'application/json'
-            >>> r.content
+            >>> r.text
             ...
         
         See `the same code, without Requests <https://gist.github.com/973705>`_.
         
-        Requests allow you to send  **HEAD**, **GET**, **POST**, **PUT**,
-        **PATCH**, and **DELETE** HTTP requests. You can add headers, form data,
+        Requests allow you to send HTTP/1.1 requests. You can add headers, form data,
         multipart files, and parameters with simple Python dictionaries, and access the
-        response data in the same way. It's powered by httplib, but it does
-        all the hard work and crazy hacks for you.
+        response data in the same way. It's powered by httplib and `urllib3
+        <https://github.com/shazow/urllib3>`_, but it does all the hard work and crazy
+        hacks for you.
         
         
         Features
         --------
         
-        - Extremely simple HEAD, GET, POST, PUT, PATCH, DELETE Requests.
-        - Gevent support for Asyncronous Requests.
-        - Sessions with cookie persistience.
-        - Basic, Digest, and Custom Authentication support.
-        - Automatic form-encoding of dictionaries
-        - A simple dictionary interface for request/response cookies.
-        - Multipart file uploads.
-        - Automatc decoding of Unicode, gzip, and deflate responses.
-        - Full support for unicode URLs and domain names.
-        
-        
-        Usage
-        -----
-        
-        It couldn't be simpler. ::
-        
-            >>> import requests
-            >>> r = requests.get('http://google.com')
-        
-        
-        HTTPS? Basic Authentication? ::
-        
-            >>> r = requests.get('https://httpbin.ep.io/basic-auth/user/pass')
-            >>> r.status_code
-            401
-        
-        
-        Uh oh, we're not authorized! Let's add authentication. ::
-        
-            >>> r = requests.get('https://httpbin.ep.io/basic-auth/user/pass', auth=('user', 'pass'))
-        
-            >>> r.status_code
-            200
-        
-            >>> r.headers['content-type']
-            'application/json'
-        
-            >>> r.content
-            '{"authenticated": true, "user": "user"}'
+        - International Domains and URLs
+        - Keep-Alive & Connection Pooling
+        - Sessions with Cookie Persistence
+        - Browser-style SSL Verification
+        - Basic/Digest Authentication
+        - Elegant Key/Value Cookies
+        - Automatic Decompression
+        - Unicode Response Bodies
+        - Multipart File Uploads
+        - Connection Timeouts
+        - Thread-safety
         
         
         Installation
@@ -107,16 +95,312 @@
         #. Send a pull request and bug the maintainer until it gets merged and published. :) Make sure to add yourself to AUTHORS_.
         
         .. _`the repository`: http://github.com/kennethreitz/requests
-        .. _AUTHORS: http://github.com/kennethreitz/requests/blob/master/AUTHORS
-        
+        .. _AUTHORS: https://github.com/kennethreitz/requests/blob/develop/AUTHORS.rst
+        
+        
+        .. :changelog:
         
         History
         -------
         
+        0.14.2 (2012-10-27)
+        +++++++++++++++++++
+        
+        - Improved mime-compatible JSON handling
+        - Proxy fixes
+        - Path hack fixes
+        - Case-Insensistive Content-Encoding headers
+        - Support for CJK parameters in form posts
+        
+        
+        0.14.1 (2012-10-01)
+        +++++++++++++++++++
+        
+        - Python 3.3 Compatibility
+        - Simply default accept-encoding
+        - Bugfixes
+        
+        
+        0.14.0 (2012-09-02)
+        ++++++++++++++++++++
+        
+        - No more iter_content errors if already downloaded.
+        
+        0.13.9 (2012-08-25)
+        +++++++++++++++++++
+        
+        - Fix for OAuth + POSTs
+        - Remove exception eating from dispatch_hook
+        - General bugfixes
+        
+        0.13.8 (2012-08-21)
+        +++++++++++++++++++
+        
+        - Incredible Link header support :)
+        
+        0.13.7 (2012-08-19)
+        +++++++++++++++++++
+        
+        - Support for (key, value) lists everywhere.
+        - Digest Authentication improvements.
+        - Ensure proxy exclusions work properly.
+        - Clearer UnicodeError exceptions.
+        - Automatic casting of URLs to tsrings (fURL and such)
+        - Bugfixes.
+        
+        0.13.6 (2012-08-06)
+        +++++++++++++++++++
+        
+        - Long awaited fix for hanging connections!
+        
+        0.13.5 (2012-07-27)
+        +++++++++++++++++++
+        
+        - Packaging fix
+        
+        0.13.4 (2012-07-27)
+        +++++++++++++++++++
+        
+        - GSSAPI/Kerberos authentication!
+        - App Engine 2.7 Fixes!
+        - Fix leaking connections (from urllib3 update)
+        - OAuthlib path hack fix
+        - OAuthlib URL parameters fix.
+        
+        0.13.3 (2012-07-12)
+        +++++++++++++++++++
+        
+        - Use simplejson if available.
+        - Do not hide SSLErrors behind Timeouts.
+        - Fixed param handling with urls containing fragments.
+        - Significantly improved information in User Agent.
+        - client certificates are ignored when verify=False
+        
+        0.13.2 (2012-06-28)
+        +++++++++++++++++++
+        
+        - Zero dependencies (once again)!
+        - New: Response.reason
+        - Sign querystring parameters in OAuth 1.0
+        - Client certificates no longer ignored when verify=False
+        - Add openSUSE certificate support
+        
+        0.13.1 (2012-06-07)
+        +++++++++++++++++++
+        
+        - Allow passing a file or file-like object as data.
+        - Allow hooks to return responses that indicate errors.
+        - Fix Response.text and Response.json for body-less responses.
+        
+        0.13.0 (2012-05-29)
+        +++++++++++++++++++
+        
+        - Removal of Requests.async in favor of `grequests <https://github.com/kennethreitz/grequests>`_
+        - Allow disabling of cookie persistiance.
+        - New implimentation of safe_mode
+        - cookies.get now supports default argument
+        - Session cookies not saved when Session.request is called with return_response=False
+        - Env: no_proxy support.
+        - RequestsCookieJar improvements.
+        - Various bug fixes.
+        
+        0.12.1 (2012-05-08)
+        +++++++++++++++++++
+        
+        - New ``Response.json`` property.
+        - Ability to add string file uploads.
+        - Fix out-of-range issue with iter_lines.
+        - Fix iter_content default size.
+        - Fix POST redirects containing files.
+        
+        0.12.0 (2012-05-02)
+        +++++++++++++++++++
+        
+        - EXPERIMENTAL OAUTH SUPPORT!
+        - Proper CookieJar-backed cookies interface with awesome dict-like interface.
+        - Speed fix for non-iterated content chunks.
+        - Move ``pre_request`` to a more usable place.
+        - New ``pre_send`` hook.
+        - Lazily encode data, params, files.
+        - Load system Certificate Bundle if ``certify`` isn't available.
+        - Cleanups, fixes.
+        
+        0.11.2 (2012-04-22)
+        +++++++++++++++++++
+        
+        - Attempt to use the OS's certificate bundle if ``certifi`` isn't available.
+        - Infinite digest auth redirect fix.
+        - Multi-part file upload improvements.
+        - Fix decoding of invalid %encodings in URLs.
+        - If there is no content in a response don't throw an error the second time that content is attempted to be read.
+        - Upload data on redirects.
+        
+        0.11.1 (2012-03-30)
+        +++++++++++++++++++
+        
+        * POST redirects now break RFC to do what browsers do: Follow up with a GET.
+        * New ``strict_mode`` configuration to disable new redirect behavior.
+        
+        
+        0.11.0 (2012-03-14)
+        +++++++++++++++++++
+        
+        * Private SSL Certificate support
+        * Remove select.poll from Gevent monkeypatching
+        * Remove redundant generator for chunked transfer encoding
+        * Fix: Response.ok raises Timeout Exception in safe_mode
+        
+        0.10.8 (2012-03-09)
+        +++++++++++++++++++
+        
+        * Generate chunked ValueError fix
+        * Proxy configuration by environment variables
+        * Simplification of iter_lines.
+        * New `trust_env` configuration for disabling system/environment hints.
+        * Suppress cookie errors.
+        
+        0.10.7 (2012-03-07)
+        +++++++++++++++++++
+        
+        * `encode_uri` = False
+        
+        0.10.6 (2012-02-25)
+        +++++++++++++++++++
+        
+        * Allow '=' in cookies.
+        
+        0.10.5 (2012-02-25)
+        +++++++++++++++++++
+        
+        * Response body with 0 content-length fix.
+        * New async.imap.
+        * Don't fail on netrc.
+        
+        
+        0.10.4 (2012-02-20)
+        +++++++++++++++++++
+        
+        * Honor netrc.
+        
+        0.10.3 (2012-02-20)
+        +++++++++++++++++++
+        
+        * HEAD requests don't follow redirects anymore.
+        * raise_for_status() doesn't raise for 3xx anymore.
+        * Make Session objects picklable.
+        * ValueError for invalid schema URLs.
+        
+        0.10.2 (2012-01-15)
+        +++++++++++++++++++
+        
+        * Vastly improved URL quoting.
+        * Additional allowed cookie key values.
+        * Attempted fix for "Too many open files" Error
+        * Replace unicode errors on first pass, no need for second pass.
+        * Append '/' to bare-domain urls before query insertion.
+        * Exceptions now inherit from RuntimeError.
+        * Binary uploads + auth fix.
+        * Bugfixes.
+        
+        
+        0.10.1 (2012-01-23)
+        +++++++++++++++++++
+        
+        * PYTHON 3 SUPPORT!
+        * Dropped 2.5 Support. (*Backwards Incompatible*)
+        
+        0.10.0 (2012-01-21)
+        +++++++++++++++++++
+        
+        * ``Response.content`` is now bytes-only. (*Backwards Incompatible*)
+        * New ``Response.text`` is unicode-only.
+        * If no ``Response.encoding`` is specified and ``chardet`` is available, ``Respoonse.text`` will guess an encoding.
+        * Default to ISO-8859-1 (Western) encoding for "text" subtypes.
+        * Removal of `decode_unicode`. (*Backwards Incompatible*)
+        * New multiple-hooks system.
+        * New ``Response.register_hook`` for registering hooks within the pipeline.
+        * ``Response.url`` is now Unicode.
+        
+        0.9.3 (2012-01-18)
+        ++++++++++++++++++
+        
+        * SSL verify=False bugfix (apparent on windows machines).
+        
+        0.9.2 (2012-01-18)
+        ++++++++++++++++++
+        
+        * Asynchronous async.send method.
+        * Support for proper chunk streams with boundaries.
+        * session argument for Session classes.
+        * Print entire hook tracebacks, not just exception instance.
+        * Fix response.iter_lines from pending next line.
+        * Fix but in HTTP-digest auth w/ URI having query strings.
+        * Fix in Event Hooks section.
+        * Urllib3 update.
+        
+        
+        0.9.1 (2012-01-06)
+        ++++++++++++++++++
+        
+        * danger_mode for automatic Response.raise_for_status()
+        * Response.iter_lines refactor
+        
+        0.9.0 (2011-12-28)
+        ++++++++++++++++++
+        
+        * verify ssl is default.
+        
+        
+        0.8.9 (2011-12-28)
+        ++++++++++++++++++
+        
+        * Packaging fix.
+        
+        
+        0.8.8 (2011-12-28)
+        ++++++++++++++++++
+        
+        * SSL CERT VERIFICATION!
+        * Release of Cerifi: Mozilla's cert list.
+        * New 'verify' argument for SSL requests.
+        * Urllib3 update.
+        
+        0.8.7 (2011-12-24)
+        ++++++++++++++++++
+        
+        * iter_lines last-line truncation fix
+        * Force safe_mode for async requests
+        * Handle safe_mode exceptions more consistently
+        * Fix iteration on null responses in safe_mode
+        
+        0.8.6 (2011-12-18)
+        ++++++++++++++++++
+        
+        * Socket timeout fixes.
+        * Proxy Authorization support.
+        
+        0.8.5 (2011-12-14)
+        ++++++++++++++++++
+        
+        * Response.iter_lines!
+        
+        0.8.4 (2011-12-11)
+        ++++++++++++++++++
+        
+        * Prefetch bugfix.
+        * Added license to installed version.
+        
+        0.8.3 (2011-11-27)
+        ++++++++++++++++++
+        
+        * Converted auth system to use simpler callable objects.
+        * New session parameter to API methods.
+        * Display full URL while logging.
+        
         0.8.2 (2011-11-19)
         ++++++++++++++++++
         
-        * New unicode decoding system, based on overridable `Response.encoding`.
+        * New Unicode decoding system, based on over-ridable `Response.encoding`.
         * Proper URL slash-quote handling.
         * Cookies with ``[``, ``]``, and ``_`` allowed.
         
@@ -140,6 +424,7 @@
         * OPTION method
         * Async pool size throttling
         * File uploads send real names
+        * Vendored in urllib3
         
         0.7.6 (2011-11-07)
         ++++++++++++++++++
@@ -155,7 +440,7 @@
         0.7.4 (2011-10-26)
         ++++++++++++++++++
         
-        * Sesion Hooks fix.
+        * Session Hooks fix.
         
         0.7.3 (2011-10-23)
         ++++++++++++++++++
@@ -386,6 +671,10 @@
 Classifier: Natural Language :: English
 Classifier: License :: OSI Approved :: ISC License (ISCL)
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2.5
 Classifier: Programming Language :: Python :: 2.6
 Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.0
+Classifier: Programming Language :: Python :: 3.1
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: 3.3
 
=== modified file 'README.rst'
--- README.rst	2011-11-25 00:02:28 +0000
+++ README.rst	2013-01-28 21:17:21 +0000
@@ -1,6 +1,10 @@
 Requests: HTTP for Humans
 =========================
 
+
+.. image:: https://secure.travis-ci.org/kennethreitz/requests.png?branch=develop
+        :target: https://secure.travis-ci.org/kennethreitz/requests
+
 Requests is an ISC Licensed HTTP library, written in Python, for human
 beings.
 
@@ -19,60 +23,32 @@
     204
     >>> r.headers['content-type']
     'application/json'
-    >>> r.content
+    >>> r.text
     ...
 
 See `the same code, without Requests <https://gist.github.com/973705>`_.
 
-Requests allow you to send  **HEAD**, **GET**, **POST**, **PUT**,
-**PATCH**, and **DELETE** HTTP requests. You can add headers, form data,
+Requests allow you to send HTTP/1.1 requests. You can add headers, form data,
 multipart files, and parameters with simple Python dictionaries, and access the
-response data in the same way. It's powered by httplib, but it does
-all the hard work and crazy hacks for you.
+response data in the same way. It's powered by httplib and `urllib3
+<https://github.com/shazow/urllib3>`_, but it does all the hard work and crazy
+hacks for you.
 
 
 Features
 --------
 
-- Extremely simple HEAD, GET, POST, PUT, PATCH, DELETE Requests.
-- Gevent support for Asyncronous Requests.
-- Sessions with cookie persistience.
-- Basic, Digest, and Custom Authentication support.
-- Automatic form-encoding of dictionaries
-- A simple dictionary interface for request/response cookies.
-- Multipart file uploads.
-- Automatc decoding of Unicode, gzip, and deflate responses.
-- Full support for unicode URLs and domain names.
-
-
-Usage
------
-
-It couldn't be simpler. ::
-
-    >>> import requests
-    >>> r = requests.get('http://google.com')
-
-
-HTTPS? Basic Authentication? ::
-
-    >>> r = requests.get('https://httpbin.ep.io/basic-auth/user/pass')
-    >>> r.status_code
-    401
-
-
-Uh oh, we're not authorized! Let's add authentication. ::
-
-    >>> r = requests.get('https://httpbin.ep.io/basic-auth/user/pass', auth=('user', 'pass'))
-
-    >>> r.status_code
-    200
-
-    >>> r.headers['content-type']
-    'application/json'
-
-    >>> r.content
-    '{"authenticated": true, "user": "user"}'
+- International Domains and URLs
+- Keep-Alive & Connection Pooling
+- Sessions with Cookie Persistence
+- Browser-style SSL Verification
+- Basic/Digest Authentication
+- Elegant Key/Value Cookies
+- Automatic Decompression
+- Unicode Response Bodies
+- Multipart File Uploads
+- Connection Timeouts
+- Thread-safety
 
 
 Installation
@@ -99,4 +75,4 @@
 #. Send a pull request and bug the maintainer until it gets merged and published. :) Make sure to add yourself to AUTHORS_.
 
 .. _`the repository`: http://github.com/kennethreitz/requests
-.. _AUTHORS: http://github.com/kennethreitz/requests/blob/master/AUTHORS
+.. _AUTHORS: https://github.com/kennethreitz/requests/blob/develop/AUTHORS.rst
 
=== modified file 'debian/changelog'
--- debian/changelog	2011-11-25 00:02:28 +0000
+++ debian/changelog	2013-01-28 21:17:21 +0000
@@ -1,3 +1,140 @@
+requests (0.14.2-0ubuntu1~cloud0) precise-grizzly; urgency=low
+
+  * New upstream release for the Ubuntu Cloud Archvie:
+    - Removed python3 version.
+
+ -- Chuck Short <[e-mail]>  Mon, 28 Jan 2013 14:58:12 -0600
+
+requests (0.14.2-0ubuntu1) raring; urgency=low
+
+  * New upstream release (LP: #1076107).  Remaining changes:
+    - debian/patches/01_do-not-use-python-certifi.patch: No longer necessary.
+    - debian/patches/02_do-not-use-embedded-python-six.patch: refreshed
+    - debian/patches/03-dont-use-embeded-urllib3.patch: refreshed and
+      renamed to 03-use-distro-packages.patch
+    - debian/control: python-chardet and python3-chardet are now required
+      (i.e. Depends instead of Recommends).
+
+ -- Barry Warsaw <[e-mail]>  Thu, 01 Nov 2012 14:56:00 +0100
+
+requests (0.12.1-1ubuntu6) quantal; urgency=low
+
+  * debian/control: Resolve Depends misspelling of python-urllib3. 
+
+ -- Dave Walker (Daviey) <[e-mail]>  Thu, 13 Sep 2012 14:55:21 +0100
+
+requests (0.12.1-1ubuntu5) quantal; urgency=low
+
+  * Add -r to rm call in debian/rules removing requests/packages/urllib3
+  * Add python3-urllib3 to build-depends and python3-requests depends
+
+ -- Adam Conrad <[e-mail]>  Wed, 12 Sep 2012 23:05:13 -0600
+
+requests (0.12.1-1ubuntu4) quantal; urgency=low
+
+  * debian/rules, debian/control, 
+    debian/patches/03-dont-use-embeded-urllib3.patch:
+    Don't use embeded python-urllib3.
+
+ -- Chuck Short <[e-mail]>  Fri, 07 Sep 2012 09:06:26 -0500
+
+requests (0.12.1-1ubuntu3) quantal; urgency=low
+
+  * d/{rules,control}: Disable tests and drop associated deps; 10/11
+    of them require network connectivity so they break in offline build
+    environments.
+
+ -- James Page <[e-mail]>  Tue, 14 Aug 2012 12:39:19 +0100
+
+requests (0.12.1-1ubuntu2) quantal; urgency=low
+
+  * debian/control: Fix up testsuite some more. 
+
+ -- Chuck Short <[e-mail]>  Wed, 18 Jul 2012 14:25:42 -0500
+
+requests (0.12.1-1ubuntu1) quantal; urgency=low
+
+  * debia/rules: Enable test suite. 
+
+ -- Chuck Short <[e-mail]>  Mon, 11 Jun 2012 09:18:06 -0400
+
+requests (0.12.1-1) unstable; urgency=low
+
+  * New upstream release
+  * debian/control
+    - Added python-oauthlib to python-requests' Recommends field
+  * debian/patches/01_do-not-use-python-certifi.patch
+    - Refreshed
+
+ -- Daniele Tricoli <[e-mail]>  Fri, 04 May 2012 14:34:47 +0200
+
+requests (0.11.2-1) unstable; urgency=low
+
+  * New upstream release
+  * debian/patches/01_do-not-use-python-certifi.patch
+    - Refreshed
+
+ -- Daniele Tricoli <[e-mail]>  Mon, 23 Apr 2012 16:06:33 +0200
+
+requests (0.11.1-1) unstable; urgency=low
+
+  * New upstream release
+  * debian/control
+    - Added python3-chardet to python3-requests' Recommends field
+    - Updated Description field
+  * debian/patches/02_do-not-use-embedded-python-six.patch
+    - Refreshed
+
+ -- Daniele Tricoli <[e-mail]>  Sun, 01 Apr 2012 12:33:42 +0200
+
+requests (0.10.8-1) unstable; urgency=low
+
+  [ Piotr Ożarowski ]
+  * Fix typo in python3-requests' ${python3:Depends}
+
+  [ Daniele Tricoli ]
+  * New upstream release (Closes: #663561)
+  * Removed embedded copy of python-six
+    - Added debian/patches/02_do-not-use-embedded-python-six.patch
+    - Added override_dh_auto_configure to debian/rules to remove
+      the embedded copy
+    - Added python(3)-six to Builds-Depends and Depends
+  * debian/control
+    - Bumped Standards-Version to 3.9.3 (no changes needed)
+  * debian/copyright
+    - Added forgotten stanzas about packages inside the fork
+      of python-urllib3
+  * debian/patches/01_do-not-use-python-certifi.patch
+    - Refreshed
+  * debian/patches/02_fix-python3-except-sintax-error.patch
+    - Removed as it is applied upstream
+
+ -- Daniele Tricoli <[e-mail]>  Mon, 19 Mar 2012 01:20:59 +0100
+
+requests (0.10.1-1) unstable; urgency=low
+
+  * New upstream release
+    - Adds Python 3 support
+  * Builded python 3 package
+  * debian/control
+    - Added python-chardet to Recommends
+    - Bumped X-Python-Version >= 2.6
+    - Added ca-certificates to Depends
+    - Added python3-all to Build-Depends
+  * debian/copyright
+    - Updated Format URI
+    - Updated copyright years
+  * debian/patches/01_do-not-use-python-certifi.patch
+    - To verify SSL certificates for HTTPS requests, use the bundle provided by
+      ca-certificates instead of python-certifi
+  * debian/patches/02_fix-python3-except-sintax-error.patches
+    - Fix SyntaxError on Python3 because "except Error, e" is not supported
+      anymore
+  * debian/rules
+    - Added override_dh_auto_clean to make the package build twice in a row
+
+ -- Daniele Tricoli <[e-mail]>  Sun, 05 Feb 2012 04:51:38 +0100
+
 requests (0.8.2-1) unstable; urgency=low
 
   * New upstream release
 
=== modified file 'debian/control'
--- debian/control	2011-10-19 20:49:39 +0000
+++ debian/control	2013-01-28 21:17:21 +0000
@@ -1,37 +1,52 @@
 Source: requests
-Maintainer: Debian Python Modules Team <[e-mail]>
+Maintainer: Ubuntu Developers <[e-mail]>
+XSBC-Original-Maintainer: Debian Python Modules Team <[e-mail]>
 Uploaders: Daniele Tricoli <[e-mail]>
 Section: python
 Priority: optional
-Build-Depends: debhelper (>= 7.0.50~),
-               python-all (>= 2.6.6-3),
-Standards-Version: 3.9.2
-X-Python-Version: >= 2.5
+Build-Depends:
+ debhelper (>= 7.0.50~),
+ python-all (>= 2.6.6-3),
+ python-six,
+ python-chardet,
+ python-urllib3,
+ python-gevent,
+ python-oauthlib,
+ ca-certificates
+Standards-Version: 3.9.3
+X-Python-Version: >= 2.6
+X-Python3-Version: >= 3.0
 Homepage: http://python-requests.org
 Vcs-Svn: svn://svn.debian.org/python-modules/packages/requests/trunk/
 Vcs-Browser: http://svn.debian.org/viewsvn/python-modules/packages/requests/trunk/
 
 Package: python-requests
 Architecture: all
-Depends: ${misc:Depends}, ${python:Depends}
-Recommends: python-gevent
+Depends:
+ ${misc:Depends},
+ ${python:Depends},
+ ca-certificates,
+ python-urllib3,
+ python-six,
+ python-chardet
+Recommends:
+ python-gevent,
+ python-oauthlib
 Description: elegant and simple HTTP library for Python, built for human beings
- Requests allow you to send GET, HEAD, PUT, POST, and DELETE
- HTTP requests. You can add headers, form data, multipart files, and
- parameters with simple Python dictionaries, and access the response
- data in the same way. It's powered by urllib2, but it does all the
- hard work and crazy hacks for you.
+ Requests allow you to send HTTP/1.1 requests. You can add headers, form data,
+ multipart files, and parameters with simple Python dictionaries, and access the
+ response data in the same way. It's powered by httplib and urllib3, but it does
+ all the hard work and crazy hacks for you.
  .
  Features
  .
-   - Extremely simple GET, HEAD, POST, PUT, DELETE Requests
-   - Simple HTTP Header Request Attachment
-   - Simple Data/Params Request Attachment
-   - Simple Multipart File Uploads
-   - CookieJar Support
-   - Redirection History
-   - Proxy Support
-   - Redirection Recursion Urllib Fix
-   - Auto Decompression of GZipped Content
-   - Unicode URL Support
-   - Simple Authentication: Simple URL + HTTP Auth Registry
+   - International Domains and URLs
+   - Keep-Alive & Connection Pooling
+   - Sessions with Cookie Persistence
+   - Browser-style SSL Verification
+   - Basic/Digest Authentication
+   - Elegant Key/Value Cookies
+   - Automatic Decompression
+   - Unicode Response Bodies
+   - Multipart File Uploads
+   - Connection Timeouts
 
=== modified file 'debian/copyright'
--- debian/copyright	2011-11-25 00:02:28 +0000
+++ debian/copyright	2013-01-28 21:17:21 +0000
@@ -1,18 +1,30 @@
-Format: http://anonscm.debian.org/viewvc/dep/web/deps/dep5.mdwn?revision=174
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
 Upstream-Name: requests
 Upstream-Contact: Kenneth Reitz <[e-mail]>
 Source: http://pypi.python.org/pypi/requests
 
 Files: *
-Copyright: © 2011 Kenneth Reitz
+Copyright: 2011-2012, Kenneth Reitz
 License: ISC
 
 Files: requests/packages/urllib3/*
-Copyright: © 2008-2011 Andrey Petrov
+Copyright: 2008-2011, Andrey Petrov
+License: Expat
+
+Files: requests/packages/urllib3/packages/mimetools_choose_boundary/__init__.py
+Copyright: 2010, Python Software Foundation
+License: PSF-2
+
+Files: requests/packages/urllib3/packages/ssl_match_hostname/__init__.py
+Copyright: 2011, Python Software Foundation
+License: PSF-2
+
+Files: requests/packages/urllib3/packages/six.py
+Copyright: 2010-2011, Benjamin Peterson
 License: Expat
 
 Files: requests/packages/oreos/monkeys.py
-Copyright: © 2000 Timothy O'Malley
+Copyright: 2000, Timothy O'Malley
 License:
  Permission to use, copy, modify, and distribute this software
  and its documentation for any purpose and without fee is hereby
@@ -33,7 +45,7 @@
  PERFORMANCE OF THIS SOFTWARE.
 
 Files: debian/*
-Copyright: © 2011 Daniele Tricoli <[e-mail]>
+Copyright: 2011-2012, Daniele Tricoli <[e-mail]>
 License: ISC
 
 License: ISC
@@ -68,3 +80,49 @@
  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+License: PSF-2
+ 1. This LICENSE AGREEMENT is between the Python Software Foundation
+ ("PSF"), and the Individual or Organization ("Licensee") accessing
+ and otherwise using this software ("Python") in source or binary form
+ and its associated documentation.
+ .
+ 2. Subject to the terms and conditions of this License Agreement, PSF
+ hereby grants Licensee a nonexclusive, royalty-free, world-wide
+ license to reproduce, analyze, test, perform and/or display publicly,
+ prepare derivative works, distribute, and otherwise use Python alone
+ or in any derivative version, provided, however, that PSF's License
+ Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001,
+ 2002, 2003, 2004, 2005, 2006 Python Software Foundation; All Rights
+ Reserved" are retained in Python alone or in any derivative version
+ prepared by Licensee.
+ .
+ 3. In the event Licensee prepares a derivative work that is based on
+ or incorporates Python or any part thereof, and wants to make the
+ derivative work available to others as provided herein, then Licensee
+ hereby agrees to include in any such work a brief summary of the
+ changes made to Python.
+ .
+ 4. PSF is making Python available to Licensee on an "AS IS"
+ basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+ IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+ DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR
+ FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+ INFRINGE ANY THIRD PARTY RIGHTS.
+ .
+ 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+ FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A
+ RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY
+ DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+ .
+ 6. This License Agreement will automatically terminate upon a
+ material breach of its terms and conditions.
+ .
+ 7. Nothing in this License Agreement shall be deemed to create any
+ relationship of agency, partnership, or joint venture between PSF and
+ Licensee. This License Agreement does not grant permission to use PSF
+ trademarks or trade name in a trademark sense to endorse or promote
+ products or services of Licensee, or any third party.
+ .
+ 8. By copying, installing or otherwise using Python, Licensee agrees
+ to be bound by the terms and conditions of this License Agreement.
 
=== added directory 'debian/patches'
=== added file 'debian/patches/02_do-not-use-embedded-python-six.patch'
--- debian/patches/02_do-not-use-embedded-python-six.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/02_do-not-use-embedded-python-six.patch	2013-01-28 21:17:21 +0000
@@ -0,0 +1,51 @@
+Description: Do not use embedded copy of python-six.
+Author: Daniele Tricoli <[e-mail]>
+Forwarded: not-needed
+Last-Update: 2012-03-19
+
+--- a/requests/packages/urllib3/connectionpool.py
++++ b/requests/packages/urllib3/connectionpool.py
+@@ -52,7 +52,7 @@
+ )
+ 
+ from .packages.ssl_match_hostname import match_hostname, CertificateError
+-from .packages import six
++import six
+ 
+ 
+ xrange = six.moves.xrange
+--- a/requests/packages/urllib3/filepost.py
++++ b/requests/packages/urllib3/filepost.py
+@@ -10,8 +10,8 @@
+ from uuid import uuid4
+ from io import BytesIO
+ 
+-from .packages import six
+-from .packages.six import b
++import six
++from six import b
+ 
+ writer = codecs.lookup('utf-8')[3]
+ 
+--- a/requests/packages/urllib3/response.py
++++ b/requests/packages/urllib3/response.py
+@@ -11,7 +11,7 @@
+ from io import BytesIO
+ 
+ from .exceptions import DecodeError
+-from .packages.six import string_types as basestring
++from six import string_types as basestring
+ 
+ 
+ log = logging.getLogger(__name__)
+--- a/requests/packages/urllib3/util.py
++++ b/requests/packages/urllib3/util.py
+@@ -18,7 +18,7 @@
+     except ImportError: # `select` doesn't exist on AppEngine.
+         select = False
+ 
+-from .packages import six
++import six
+ from .exceptions import LocationParseError
+ 
+ 
 
=== added file 'debian/patches/03-use-distro-packages.patch'
--- debian/patches/03-use-distro-packages.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/03-use-distro-packages.patch	2013-01-28 21:17:21 +0000
@@ -0,0 +1,127 @@
+Description: Do not use embeded copy of python-urllib3
+Author: Chuck Short <[e-mail]>
+Forwarded: non-need
+Last-Update: 2012-09-05
+--- a/requests/models.py
++++ b/requests/models.py
+@@ -18,12 +18,12 @@
+ 
+ from .auth import HTTPBasicAuth, HTTPProxyAuth
+ from .cookies import cookiejar_from_dict, extract_cookies_to_jar, get_cookie_header
+-from .packages.urllib3.exceptions import MaxRetryError, LocationParseError
+-from .packages.urllib3.exceptions import TimeoutError
+-from .packages.urllib3.exceptions import SSLError as _SSLError
+-from .packages.urllib3.exceptions import HTTPError as _HTTPError
+-from .packages.urllib3 import connectionpool, poolmanager
+-from .packages.urllib3.filepost import encode_multipart_formdata
++from urllib3.exceptions import MaxRetryError, LocationParseError
++from urllib3.exceptions import TimeoutError
++from urllib3.exceptions import SSLError as _SSLError
++from urllib3.exceptions import HTTPError as _HTTPError
++from urllib3 import connectionpool, poolmanager
++from urllib3.filepost import encode_multipart_formdata
+ from .defaults import SCHEMAS
+ from .exceptions import (
+     ConnectionError, HTTPError, RequestException, Timeout, TooManyRedirects,
+--- a/requests/sessions.py
++++ b/requests/sessions.py
+@@ -16,7 +16,7 @@
+ from .models import Request
+ from .hooks import dispatch_hook
+ from .utils import header_expand, from_key_val_list
+-from .packages.urllib3.poolmanager import PoolManager
++from urllib3.poolmanager import PoolManager
+ 
+ 
+ def merge_kwargs(local_kwarg, default_kwarg):
+--- a/setup.py
++++ b/setup.py
+@@ -20,24 +20,9 @@
+ packages = [
+     'requests',
+     'requests.packages',
+-    'requests.packages.urllib3',
+-    'requests.packages.urllib3.packages',
+-    'requests.packages.urllib3.packages.ssl_match_hostname'
+ ]
+ 
+-if is_py2:
+-    packages.extend([
+-        'requests.packages.oauthlib',
+-        'requests.packages.oauthlib.oauth1',
+-        'requests.packages.oauthlib.oauth1.rfc5849',
+-        'requests.packages.oauthlib.oauth2',
+-        'requests.packages.oauthlib.oauth2.draft25',
+-        'requests.packages.chardet',
+-    ])
+-else:
+-    packages.append('requests.packages.chardet2')
+-
+-requires = []
++requires = ['python-urllib3']
+ 
+ setup(
+     name='requests',
+--- a/requests/adapters.py
++++ b/requests/adapters.py
+@@ -8,7 +8,7 @@
+ and maintain connections.
+ """
+ 
+-from .packages.urllib3.poolmanager import PoolManager
++from urllib3.poolmanager import PoolManager
+ 
+ class BaseAdapter(object):
+     """The Base Transport Adapter"""
+--- a/requests/compat.py
++++ b/requests/compat.py
+@@ -92,8 +92,20 @@
+     try:
+         import cchardet as chardet
+     except ImportError:
+-        from .packages import chardet
+-    from .packages.urllib3.packages.ordered_dict import OrderedDict
++        import chardet
++    # Here's the problem.  Generally we want to use the system's urllib3
++    # library instead of the embedded one.  setup.py imports requests.compat
++    # to get the is_py2 variable.  However, if you're building the source
++    # package on a system with an older urllib3 that doesn't have the
++    # following import, setup.py will fail, and thus you cannot build the
++    # source package.  In that case (and hopefully in no others, since the
++    # binary package Depends on python*-urllib3) grab the one from the
++    # embedded package.
++    try:
++        from urllib3.packages.ordered_dict import OrderedDict
++    except ImportError:
++        from .packages.urllib3.packages.ordered_dict import OrderedDict
++
+ 
+     builtin_str = str
+     bytes = str
+@@ -109,7 +121,7 @@
+     from http import cookiejar as cookielib
+     from http.cookies import Morsel
+     from io import StringIO
+-    from .packages import chardet2 as chardet
++    import chardet
+     from collections import OrderedDict
+ 
+     builtin_str = str
+--- a/requests/packages/__init__.py
++++ b/requests/packages/__init__.py
+@@ -1,3 +1,3 @@
+ from __future__ import absolute_import
+ 
+-from . import urllib3
++import urllib3
+--- a/requests/safe_mode.py
++++ b/requests/safe_mode.py
+@@ -12,7 +12,7 @@
+ """
+ 
+ from .models import Response
+-from .packages.urllib3.response import HTTPResponse
++from urllib3.response import HTTPResponse
+ from .exceptions import RequestException, ConnectionError, HTTPError
+ import socket
+ 
 
=== added file 'debian/patches/series'
--- debian/patches/series	1970-01-01 00:00:00 +0000
+++ debian/patches/series	2013-01-28 21:17:21 +0000
@@ -0,0 +1,2 @@
+02_do-not-use-embedded-python-six.patch
+03-use-distro-packages.patch
 
=== modified file 'debian/rules'
--- debian/rules	2011-06-06 02:11:15 +0000
+++ debian/rules	2013-01-28 21:17:21 +0000
@@ -1,7 +1,29 @@
 #!/usr/bin/make -f
 
+PYVERS := $(shell pyversions -r)
+
 %:
 	dh $@ --with python2 --buildsystem=python_distutils
 
+override_dh_auto_build:
+	set -ex; \
+	for python in $(PYVERS); do \
+		$$python setup.py build; \
+	done
+
+override_dh_auto_clean:
+	rm -rf build
+	dh_auto_clean
+
+override_dh_auto_configure:
+	rm -rf requests/packages/urllib3
+
+override_dh_auto_install:
+	set -ex; \
+	for python in $(PYVERS); do \
+		$$python setup.py install --skip-build --root debian/python-requests \
+			--install-layout deb; \
+	done
+
 override_dh_installchangelogs:
-	dh_installchangelogs HISTORY.rst upstream
+	dh_installchangelogs HISTORY.rst
 
=== modified file 'requests.egg-info/PKG-INFO'
--- requests.egg-info/PKG-INFO	2011-11-25 00:02:28 +0000
+++ requests.egg-info/PKG-INFO	2013-01-28 21:17:21 +0000
@@ -1,14 +1,30 @@
-Metadata-Version: 1.0
+Metadata-Version: 1.1
 Name: requests
-Version: 0.8.2
+Version: 0.14.2
 Summary: Python HTTP for Humans.
 Home-page: http://python-requests.org
 Author: Kenneth Reitz
 Author-email: [e-mail]
-License: ISC
+License: Copyright (c) 2012 Kenneth Reitz.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 Description: Requests: HTTP for Humans
         =========================
         
+        
+        .. image:: https://secure.travis-ci.org/kennethreitz/requests.png?branch=develop
+                :target: https://secure.travis-ci.org/kennethreitz/requests
+        
         Requests is an ISC Licensed HTTP library, written in Python, for human
         beings.
         
@@ -27,60 +43,32 @@
             204
             >>> r.headers['content-type']
             'application/json'
-            >>> r.content
+            >>> r.text
             ...
         
         See `the same code, without Requests <https://gist.github.com/973705>`_.
         
-        Requests allow you to send  **HEAD**, **GET**, **POST**, **PUT**,
-        **PATCH**, and **DELETE** HTTP requests. You can add headers, form data,
+        Requests allow you to send HTTP/1.1 requests. You can add headers, form data,
         multipart files, and parameters with simple Python dictionaries, and access the
-        response data in the same way. It's powered by httplib, but it does
-        all the hard work and crazy hacks for you.
+        response data in the same way. It's powered by httplib and `urllib3
+        <https://github.com/shazow/urllib3>`_, but it does all the hard work and crazy
+        hacks for you.
         
         
         Features
         --------
         
-        - Extremely simple HEAD, GET, POST, PUT, PATCH, DELETE Requests.
-        - Gevent support for Asyncronous Requests.
-        - Sessions with cookie persistience.
-        - Basic, Digest, and Custom Authentication support.
-        - Automatic form-encoding of dictionaries
-        - A simple dictionary interface for request/response cookies.
-        - Multipart file uploads.
-        - Automatc decoding of Unicode, gzip, and deflate responses.
-        - Full support for unicode URLs and domain names.
-        
-        
-        Usage
-        -----
-        
-        It couldn't be simpler. ::
-        
-            >>> import requests
-            >>> r = requests.get('http://google.com')
-        
-        
-        HTTPS? Basic Authentication? ::
-        
-            >>> r = requests.get('https://httpbin.ep.io/basic-auth/user/pass')
-            >>> r.status_code
-            401
-        
-        
-        Uh oh, we're not authorized! Let's add authentication. ::
-        
-            >>> r = requests.get('https://httpbin.ep.io/basic-auth/user/pass', auth=('user', 'pass'))
-        
-            >>> r.status_code
-            200
-        
-            >>> r.headers['content-type']
-            'application/json'
-        
-            >>> r.content
-            '{"authenticated": true, "user": "user"}'
+        - International Domains and URLs
+        - Keep-Alive & Connection Pooling
+        - Sessions with Cookie Persistence
+        - Browser-style SSL Verification
+        - Basic/Digest Authentication
+        - Elegant Key/Value Cookies
+        - Automatic Decompression
+        - Unicode Response Bodies
+        - Multipart File Uploads
+        - Connection Timeouts
+        - Thread-safety
         
         
         Installation
@@ -107,16 +95,312 @@
         #. Send a pull request and bug the maintainer until it gets merged and published. :) Make sure to add yourself to AUTHORS_.
         
         .. _`the repository`: http://github.com/kennethreitz/requests
-        .. _AUTHORS: http://github.com/kennethreitz/requests/blob/master/AUTHORS
-        
+        .. _AUTHORS: https://github.com/kennethreitz/requests/blob/develop/AUTHORS.rst
+        
+        
+        .. :changelog:
         
         History
         -------
         
+        0.14.2 (2012-10-27)
+        +++++++++++++++++++
+        
+        - Improved mime-compatible JSON handling
+        - Proxy fixes
+        - Path hack fixes
+        - Case-Insensistive Content-Encoding headers
+        - Support for CJK parameters in form posts
+        
+        
+        0.14.1 (2012-10-01)
+        +++++++++++++++++++
+        
+        - Python 3.3 Compatibility
+        - Simply default accept-encoding
+        - Bugfixes
+        
+        
+        0.14.0 (2012-09-02)
+        ++++++++++++++++++++
+        
+        - No more iter_content errors if already downloaded.
+        
+        0.13.9 (2012-08-25)
+        +++++++++++++++++++
+        
+        - Fix for OAuth + POSTs
+        - Remove exception eating from dispatch_hook
+        - General bugfixes
+        
+        0.13.8 (2012-08-21)
+        +++++++++++++++++++
+        
+        - Incredible Link header support :)
+        
+        0.13.7 (2012-08-19)
+        +++++++++++++++++++
+        
+        - Support for (key, value) lists everywhere.
+        - Digest Authentication improvements.
+        - Ensure proxy exclusions work properly.
+        - Clearer UnicodeError exceptions.
+        - Automatic casting of URLs to tsrings (fURL and such)
+        - Bugfixes.
+        
+        0.13.6 (2012-08-06)
+        +++++++++++++++++++
+        
+        - Long awaited fix for hanging connections!
+        
+        0.13.5 (2012-07-27)
+        +++++++++++++++++++
+        
+        - Packaging fix
+        
+        0.13.4 (2012-07-27)
+        +++++++++++++++++++
+        
+        - GSSAPI/Kerberos authentication!
+        - App Engine 2.7 Fixes!
+        - Fix leaking connections (from urllib3 update)
+        - OAuthlib path hack fix
+        - OAuthlib URL parameters fix.
+        
+        0.13.3 (2012-07-12)
+        +++++++++++++++++++
+        
+        - Use simplejson if available.
+        - Do not hide SSLErrors behind Timeouts.
+        - Fixed param handling with urls containing fragments.
+        - Significantly improved information in User Agent.
+        - client certificates are ignored when verify=False
+        
+        0.13.2 (2012-06-28)
+        +++++++++++++++++++
+        
+        - Zero dependencies (once again)!
+        - New: Response.reason
+        - Sign querystring parameters in OAuth 1.0
+        - Client certificates no longer ignored when verify=False
+        - Add openSUSE certificate support
+        
+        0.13.1 (2012-06-07)
+        +++++++++++++++++++
+        
+        - Allow passing a file or file-like object as data.
+        - Allow hooks to return responses that indicate errors.
+        - Fix Response.text and Response.json for body-less responses.
+        
+        0.13.0 (2012-05-29)
+        +++++++++++++++++++
+        
+        - Removal of Requests.async in favor of `grequests <https://github.com/kennethreitz/grequests>`_
+        - Allow disabling of cookie persistiance.
+        - New implimentation of safe_mode
+        - cookies.get now supports default argument
+        - Session cookies not saved when Session.request is called with return_response=False
+        - Env: no_proxy support.
+        - RequestsCookieJar improvements.
+        - Various bug fixes.
+        
+        0.12.1 (2012-05-08)
+        +++++++++++++++++++
+        
+        - New ``Response.json`` property.
+        - Ability to add string file uploads.
+        - Fix out-of-range issue with iter_lines.
+        - Fix iter_content default size.
+        - Fix POST redirects containing files.
+        
+        0.12.0 (2012-05-02)
+        +++++++++++++++++++
+        
+        - EXPERIMENTAL OAUTH SUPPORT!
+        - Proper CookieJar-backed cookies interface with awesome dict-like interface.
+        - Speed fix for non-iterated content chunks.
+        - Move ``pre_request`` to a more usable place.
+        - New ``pre_send`` hook.
+        - Lazily encode data, params, files.
+        - Load system Certificate Bundle if ``certify`` isn't available.
+        - Cleanups, fixes.
+        
+        0.11.2 (2012-04-22)
+        +++++++++++++++++++
+        
+        - Attempt to use the OS's certificate bundle if ``certifi`` isn't available.
+        - Infinite digest auth redirect fix.
+        - Multi-part file upload improvements.
+        - Fix decoding of invalid %encodings in URLs.
+        - If there is no content in a response don't throw an error the second time that content is attempted to be read.
+        - Upload data on redirects.
+        
+        0.11.1 (2012-03-30)
+        +++++++++++++++++++
+        
+        * POST redirects now break RFC to do what browsers do: Follow up with a GET.
+        * New ``strict_mode`` configuration to disable new redirect behavior.
+        
+        
+        0.11.0 (2012-03-14)
+        +++++++++++++++++++
+        
+        * Private SSL Certificate support
+        * Remove select.poll from Gevent monkeypatching
+        * Remove redundant generator for chunked transfer encoding
+        * Fix: Response.ok raises Timeout Exception in safe_mode
+        
+        0.10.8 (2012-03-09)
+        +++++++++++++++++++
+        
+        * Generate chunked ValueError fix
+        * Proxy configuration by environment variables
+        * Simplification of iter_lines.
+        * New `trust_env` configuration for disabling system/environment hints.
+        * Suppress cookie errors.
+        
+        0.10.7 (2012-03-07)
+        +++++++++++++++++++
+        
+        * `encode_uri` = False
+        
+        0.10.6 (2012-02-25)
+        +++++++++++++++++++
+        
+        * Allow '=' in cookies.
+        
+        0.10.5 (2012-02-25)
+        +++++++++++++++++++
+        
+        * Response body with 0 content-length fix.
+        * New async.imap.
+        * Don't fail on netrc.
+        
+        
+        0.10.4 (2012-02-20)
+        +++++++++++++++++++
+        
+        * Honor netrc.
+        
+        0.10.3 (2012-02-20)
+        +++++++++++++++++++
+        
+        * HEAD requests don't follow redirects anymore.
+        * raise_for_status() doesn't raise for 3xx anymore.
+        * Make Session objects picklable.
+        * ValueError for invalid schema URLs.
+        
+        0.10.2 (2012-01-15)
+        +++++++++++++++++++
+        
+        * Vastly improved URL quoting.
+        * Additional allowed cookie key values.
+        * Attempted fix for "Too many open files" Error
+        * Replace unicode errors on first pass, no need for second pass.
+        * Append '/' to bare-domain urls before query insertion.
+        * Exceptions now inherit from RuntimeError.
+        * Binary uploads + auth fix.
+        * Bugfixes.
+        
+        
+        0.10.1 (2012-01-23)
+        +++++++++++++++++++
+        
+        * PYTHON 3 SUPPORT!
+        * Dropped 2.5 Support. (*Backwards Incompatible*)
+        
+        0.10.0 (2012-01-21)
+        +++++++++++++++++++
+        
+        * ``Response.content`` is now bytes-only. (*Backwards Incompatible*)
+        * New ``Response.text`` is unicode-only.
+        * If no ``Response.encoding`` is specified and ``chardet`` is available, ``Respoonse.text`` will guess an encoding.
+        * Default to ISO-8859-1 (Western) encoding for "text" subtypes.
+        * Removal of `decode_unicode`. (*Backwards Incompatible*)
+        * New multiple-hooks system.
+        * New ``Response.register_hook`` for registering hooks within the pipeline.
+        * ``Response.url`` is now Unicode.
+        
+        0.9.3 (2012-01-18)
+        ++++++++++++++++++
+        
+        * SSL verify=False bugfix (apparent on windows machines).
+        
+        0.9.2 (2012-01-18)
+        ++++++++++++++++++
+        
+        * Asynchronous async.send method.
+        * Support for proper chunk streams with boundaries.
+        * session argument for Session classes.
+        * Print entire hook tracebacks, not just exception instance.
+        * Fix response.iter_lines from pending next line.
+        * Fix but in HTTP-digest auth w/ URI having query strings.
+        * Fix in Event Hooks section.
+        * Urllib3 update.
+        
+        
+        0.9.1 (2012-01-06)
+        ++++++++++++++++++
+        
+        * danger_mode for automatic Response.raise_for_status()
+        * Response.iter_lines refactor
+        
+        0.9.0 (2011-12-28)
+        ++++++++++++++++++
+        
+        * verify ssl is default.
+        
+        
+        0.8.9 (2011-12-28)
+        ++++++++++++++++++
+        
+        * Packaging fix.
+        
+        
+        0.8.8 (2011-12-28)
+        ++++++++++++++++++
+        
+        * SSL CERT VERIFICATION!
+        * Release of Cerifi: Mozilla's cert list.
+        * New 'verify' argument for SSL requests.
+        * Urllib3 update.
+        
+        0.8.7 (2011-12-24)
+        ++++++++++++++++++
+        
+        * iter_lines last-line truncation fix
+        * Force safe_mode for async requests
+        * Handle safe_mode exceptions more consistently
+        * Fix iteration on null responses in safe_mode
+        
+        0.8.6 (2011-12-18)
+        ++++++++++++++++++
+        
+        * Socket timeout fixes.
+        * Proxy Authorization support.
+        
+        0.8.5 (2011-12-14)
+        ++++++++++++++++++
+        
+        * Response.iter_lines!
+        
+        0.8.4 (2011-12-11)
+        ++++++++++++++++++
+        
+        * Prefetch bugfix.
+        * Added license to installed version.
+        
+        0.8.3 (2011-11-27)
+        ++++++++++++++++++
+        
+        * Converted auth system to use simpler callable objects.
+        * New session parameter to API methods.
+        * Display full URL while logging.
+        
         0.8.2 (2011-11-19)
         ++++++++++++++++++
         
-        * New unicode decoding system, based on overridable `Response.encoding`.
+        * New Unicode decoding system, based on over-ridable `Response.encoding`.
         * Proper URL slash-quote handling.
         * Cookies with ``[``, ``]``, and ``_`` allowed.
         
@@ -140,6 +424,7 @@
         * OPTION method
         * Async pool size throttling
         * File uploads send real names
+        * Vendored in urllib3
         
         0.7.6 (2011-11-07)
         ++++++++++++++++++
@@ -155,7 +440,7 @@
         0.7.4 (2011-10-26)
         ++++++++++++++++++
         
-        * Sesion Hooks fix.
+        * Session Hooks fix.
         
         0.7.3 (2011-10-23)
         ++++++++++++++++++
@@ -386,6 +671,10 @@
 Classifier: Natural Language :: English
 Classifier: License :: OSI Approved :: ISC License (ISCL)
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2.5
 Classifier: Programming Language :: Python :: 2.6
 Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.0
+Classifier: Programming Language :: Python :: 3.1
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Programming Language :: Python :: 3.3
 
=== modified file 'requests.egg-info/SOURCES.txt'
--- requests.egg-info/SOURCES.txt	2011-11-25 00:02:28 +0000
+++ requests.egg-info/SOURCES.txt	2013-01-28 21:17:21 +0000
@@ -1,17 +1,24 @@
 HISTORY.rst
 LICENSE
 MANIFEST.in
+NOTICE
 README.rst
 setup.py
-test_requests.py
 requests/__init__.py
+requests/_oauth.py
+requests/adapters.py
 requests/api.py
 requests/async.py
 requests/auth.py
+requests/cacert.pem
+requests/certs.py
+requests/compat.py
+requests/cookies.py
 requests/defaults.py
 requests/exceptions.py
 requests/hooks.py
 requests/models.py
+requests/safe_mode.py
 requests/sessions.py
 requests/status_codes.py
 requests/structures.py
@@ -21,10 +28,53 @@
 requests.egg-info/dependency_links.txt
 requests.egg-info/top_level.txt
 requests/packages/__init__.py
-requests/packages/oreos/__init__.py
-requests/packages/oreos/core.py
-requests/packages/oreos/monkeys.py
-requests/packages/oreos/structures.py
+requests/packages/chardet/__init__.py
+requests/packages/chardet/big5freq.py
+requests/packages/chardet/big5prober.py
+requests/packages/chardet/chardistribution.py
+requests/packages/chardet/charsetgroupprober.py
+requests/packages/chardet/charsetprober.py
+requests/packages/chardet/codingstatemachine.py
+requests/packages/chardet/constants.py
+requests/packages/chardet/escprober.py
+requests/packages/chardet/escsm.py
+requests/packages/chardet/eucjpprober.py
+requests/packages/chardet/euckrfreq.py
+requests/packages/chardet/euckrprober.py
+requests/packages/chardet/euctwfreq.py
+requests/packages/chardet/euctwprober.py
+requests/packages/chardet/gb2312freq.py
+requests/packages/chardet/gb2312prober.py
+requests/packages/chardet/hebrewprober.py
+requests/packages/chardet/jisfreq.py
+requests/packages/chardet/jpcntx.py
+requests/packages/chardet/langbulgarianmodel.py
+requests/packages/chardet/langcyrillicmodel.py
+requests/packages/chardet/langgreekmodel.py
+requests/packages/chardet/langhebrewmodel.py
+requests/packages/chardet/langhungarianmodel.py
+requests/packages/chardet/langthaimodel.py
+requests/packages/chardet/latin1prober.py
+requests/packages/chardet/mbcharsetprober.py
+requests/packages/chardet/mbcsgroupprober.py
+requests/packages/chardet/mbcssm.py
+requests/packages/chardet/sbcharsetprober.py
+requests/packages/chardet/sbcsgroupprober.py
+requests/packages/chardet/sjisprober.py
+requests/packages/chardet/universaldetector.py
+requests/packages/chardet/utf8prober.py
+requests/packages/oauthlib/__init__.py
+requests/packages/oauthlib/common.py
+requests/packages/oauthlib/oauth1/__init__.py
+requests/packages/oauthlib/oauth1/rfc5849/__init__.py
+requests/packages/oauthlib/oauth1/rfc5849/parameters.py
+requests/packages/oauthlib/oauth1/rfc5849/signature.py
+requests/packages/oauthlib/oauth1/rfc5849/utils.py
+requests/packages/oauthlib/oauth2/__init__.py
+requests/packages/oauthlib/oauth2/draft25/__init__.py
+requests/packages/oauthlib/oauth2/draft25/parameters.py
+requests/packages/oauthlib/oauth2/draft25/tokens.py
+requests/packages/oauthlib/oauth2/draft25/utils.py
 requests/packages/urllib3/__init__.py
 requests/packages/urllib3/_collections.py
 requests/packages/urllib3/connectionpool.py
@@ -32,4 +82,9 @@
 requests/packages/urllib3/filepost.py
 requests/packages/urllib3/poolmanager.py
 requests/packages/urllib3/request.py
-requests/packages/urllib3/response.py
 \ No newline at end of file
+requests/packages/urllib3/response.py
+requests/packages/urllib3/util.py
+requests/packages/urllib3/packages/__init__.py
+requests/packages/urllib3/packages/ordered_dict.py
+requests/packages/urllib3/packages/six.py
+requests/packages/urllib3/packages/ssl_match_hostname/__init__.py
 \ No newline at end of file
 
=== modified file 'requests/__init__.py'
--- requests/__init__.py	2011-11-25 00:02:28 +0000
+++ requests/__init__.py	2013-01-28 21:17:21 +0000
@@ -6,20 +6,47 @@
 #          /
 
 """
-requests
-~~~~~~~~
-
-:copyright: (c) 2011 by Kenneth Reitz.
+requests HTTP library
+~~~~~~~~~~~~~~~~~~~~~
+
+Requests is an HTTP library, written in Python, for human beings. Basic GET
+usage:
+
+   >>> import requests
+   >>> r = requests.get('http://python.org')
+   >>> r.status_code
+   200
+   >>> 'Python is a programming language' in r.content
+   True
+
+... or POST:
+
+   >>> payload = dict(key1='value1', key2='value2')
+   >>> r = requests.post("http://httpbin.org/post", data=payload)
+   >>> print r.text
+   {
+     ...
+     "form": {
+       "key2": "value2",
+       "key1": "value1"
+     },
+     ...
+   }
+
+The other HTTP methods are supported - see `requests.api`. Full documentation
+is at <http://python-requests.org>.
+
+:copyright: (c) 2012 by Kenneth Reitz.
 :license: ISC, see LICENSE for more details.
 
 """
 
 __title__ = 'requests'
-__version__ = '0.8.2'
-__build__ = 0x000802
+__version__ = '0.14.2'
+__build__ = 0x001402
 __author__ = 'Kenneth Reitz'
 __license__ = 'ISC'
-__copyright__ = 'Copyright 2011 Kenneth Reitz'
+__copyright__ = 'Copyright 2012 Kenneth Reitz'
 
 
 from . import utils
 
=== added file 'requests/_oauth.py'
--- requests/_oauth.py	1970-01-01 00:00:00 +0000
+++ requests/_oauth.py	2013-01-28 21:17:21 +0000
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests._oauth
+~~~~~~~~~~~~~~~
+
+This module contains the path hack necessary for oauthlib to be vendored into
+requests while allowing upstream changes.
+"""
+
+import os
+import sys
+
+try:
+    from oauthlib.oauth1 import rfc5849
+    from oauthlib.common import extract_params
+    from oauthlib.oauth1.rfc5849 import (Client, SIGNATURE_HMAC, SIGNATURE_TYPE_AUTH_HEADER)
+except ImportError:
+    from .packages import oauthlib
+    sys.modules['oauthlib'] = oauthlib
+    from oauthlib.oauth1 import rfc5849
+    from oauthlib.common import extract_params
+    from oauthlib.oauth1.rfc5849 import (Client, SIGNATURE_HMAC, SIGNATURE_TYPE_AUTH_HEADER)
 
=== added file 'requests/adapters.py'
--- requests/adapters.py	1970-01-01 00:00:00 +0000
+++ requests/adapters.py	2013-01-28 21:17:21 +0000
@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.adapters
+~~~~~~~~~~~~~~~~~
+
+This module contains the transport adapters that Requests uses to define
+and maintain connections.
+"""
+
+from urllib3.poolmanager import PoolManager
+
+class BaseAdapter(object):
+    """The Base Transport Adapter"""
+
+    def __init__(self, config=None):
+        super(BaseAdapter, self).__init__()
+        self.config = config or {}
+        self.session = None
+
+    @property
+    def configure(self, config):
+        self.config.update(config)
+
+    def send(self):
+        raise NotImplementedError
+
+    def close(self):
+        raise NotImplementedError
+
+
+class HTTPAdapter(BaseAdapter):
+    """Built-In HTTP Adapter for Urllib3."""
+    def __init__(self):
+        super(HTTPAdapter, self).__init__()
+
+        self.init_poolmanager()
+
+    def init_poolmanager(self):
+        self.poolmanager = PoolManager(
+            num_pools=self.config.get('pool_connections'),
+            maxsize=self.config.get('pool_maxsize')
+        )
+
+    def close(self):
+        """Dispose of any internal state.