quickstart for encoding

Closes #282

.gitignore

@@ -1,2 +1,10 @@
 .idea
-MANIFEST
+MANIFEST
+coverage.xml
+nosetests.xml
+pylint.txt
+*.pyc
+docs/_build
+toy.py
+.gitignore
+junit-report.xml

AUTHORS

@@ -1,13 +0,0 @@
-Requests is written and maintained by Kenneth Reitz and
-various contributors:
-
-Development Lead
-````````````````
-
-- Kenneth Reitz <me@kennethreitz.com>
-
-
-Patches and Suggestions
-```````````````````````
-
-- Various Pocoo Members

AUTHORS.rst

@@ -0,0 +1,63 @@
+Requests is written and maintained by Kenneth Reitz and
+various contributors:
+
+Development Lead
+````````````````
+
+- Kenneth Reitz <me@kennethreitz.com>
+
+
+Urllib3
+```````
+
+- Andrey Petrov <andrey.petrov@shazow.net>
+
+
+Patches and Suggestions
+```````````````````````
+
+- Various Pocoo Members
+- Chris Adams
+- Flavio Percoco Premoli
+- Dj Gilcrease
+- Justin Murphy
+- Rob Madole
+- Aram Dulyan
+- Johannes Gorset
+- 村山めがね (Megane Murayama)
+- James Rowe
+- Daniel Schauenberg
+- Zbigniew Siciarz
+- Daniele Tricoli 'Eriol'
+- Richard Boulton
+- Miguel Olivares <miguel@moliware.com>
+- Alberto Paro
+- Jérémy Bethmont
+- 潘旭 (Xu Pan)
+- Tamás Gulácsi
+- Rubén Abad
+- Peter Manser
+- Jeremy Selier
+- Jens Diemer
+- Alex <@alopatin>
+- Tom Hogans <tomhsx@gmail.com>
+- Armin Ronacher
+- Shrikant Sharat Kandula
+- Mikko Ohtamaa
+- Den Shabalin
+- Daniel Miller <danielm@vs-networks.com>
+- Alejandro Giacometti
+- Rick Mak
+- Johan Bergström
+- Josselin Jacquard
+- Travis N. Vaught
+- Fredrik Möllerstrand
+- Daniel Hengeveld
+- Dan Head
+- Bruno Renié
+- David Fischer
+- Joseph McCullough
+- Juergen Brendel
+- Juan Riaza
+- Ryan Kelly
+- Rolando Espinoza La fuente

HISTORY.rst

@@ -1,6 +1,245 @@
 History
 -------
 
+0.8.2 (2011-11-19)
+++++++++++++++++++
+
+* New unicode decoding system, based on overridable `Response.encoding`.
+* Proper URL slash-quote handling.
+* Cookies with ``[``, ``]``, and ``_`` allowed.
+
+0.8.1 (2011-11-15)
+++++++++++++++++++
+
+* URL Request path fix
+* Proxy fix.
+* Timeouts fix.
+
+0.8.0 (2011-11-13)
+++++++++++++++++++
+
+* Keep-alive support!
+* Complete removal of Urllib2
+* Complete removal of Poster
+* Complete removal of CookieJars
+* New ConnectionError raising
+* Safe_mode for error catching
+* prefetch parameter for request methods
+* OPTION method
+* Async pool size throttling
+* File uploads send real names
+
+0.7.6 (2011-11-07)
+++++++++++++++++++
+
+* Digest authentication bugfix (attach query data to path)
+
+0.7.5 (2011-11-04)
+++++++++++++++++++
+
+* Response.content = None if there was an invalid repsonse.
+* Redirection auth handling.
+
+0.7.4 (2011-10-26)
+++++++++++++++++++
+
+* Sesion Hooks fix.
+
+0.7.3 (2011-10-23)
+++++++++++++++++++
+
+* Digest Auth fix.
+
+
+0.7.2 (2011-10-23)
+++++++++++++++++++
+
+* PATCH Fix.
+
+
+0.7.1 (2011-10-23)
+++++++++++++++++++
+
+* Move away from urllib2 authentication handling.
+* Fully Remove AuthManager, AuthObject, &c.
+* New tuple-based auth system with handler callbacks.
+
+
+0.7.0 (2011-10-22)
+++++++++++++++++++
+
+* Sessions are now the primary interface.
+* Deprecated InvalidMethodException.
+* PATCH fix.
+* New config system (no more global settings).
+
+
+0.6.6 (2011-10-19)
+++++++++++++++++++
+
+* Session parameter bugfix (params merging).
+
+
+0.6.5 (2011-10-18)
+++++++++++++++++++
+
+* Offline (fast) test suite.
+* Session dictionary argument merging.
+
+
+0.6.4 (2011-10-13)
+++++++++++++++++++
+
+* Automatic decoding of unicode, based on HTTP Headers.
+* New ``decode_unicode`` setting.
+* Removal of ``r.read/close`` methods.
+* New ``r.faw`` interface for advanced response usage.*
+* Automatic expansion of parameterized headers.
+
+
+0.6.3 (2011-10-13)
+++++++++++++++++++
+
+* Beautiful ``requests.async`` module, for making async requests w/ gevent.
+
+
+0.6.2 (2011-10-09)
+++++++++++++++++++
+
+* GET/HEAD obeys allow_redirects=False.
+
+
+0.6.1 (2011-08-20)
+++++++++++++++++++
+
+* Enhanced status codes experience ``\o/``
+* Set a maximum number of redirects (``settings.max_redirects``)
+* Full Unicode URL support
+* Support for protocol-less redirects.
+* Allow for arbitrary request types.
+* Bugfixes
+
+
+0.6.0 (2011-08-17)
+++++++++++++++++++
+
+* New callback hook system
+* New persistient sessions object and context manager
+* Transparent Dict-cookie handling
+* Status code reference object
+* Removed Response.cached
+* Added Response.request
+* All args are kwargs
+* Relative redirect support
+* HTTPError handling improvements
+* Improved https testing
+* Bugfixes
+
+
+0.5.1 (2011-07-23)
+++++++++++++++++++
+
+* International Domain Name Support!
+* Access headers without fetching entire body (``read()``)
+* Use lists as dicts for parameters
+* Add Forced Basic Authentication
+* Forced Basic is default authentication type
+* ``python-requests.org`` default User-Agent header
+* CaseInsensitiveDict lower-case caching
+* Response.history bugfix
+
+
+0.5.0 (2011-06-21)
+++++++++++++++++++
+
+* PATCH Support
+* Support for Proxies
+* HTTPBin Test Suite
+* Redirect Fixes
+* settings.verbose stream writing
+* Querystrings for all methods
+* URLErrors (Connection Refused, Timeout, Invalid URLs) are treated as explicity raised
+  ``r.requests.get('hwe://blah'); r.raise_for_status()``
+
+
+0.4.1 (2011-05-22)
+++++++++++++++++++
+
+* Improved Redirection Handling
+* New 'allow_redirects' param for following non-GET/HEAD Redirects
+* Settings module refactoring
+
+
+0.4.0 (2011-05-15)
+++++++++++++++++++
+
+* Response.history: list of redirected responses
+* Case-Insensitive Header Dictionaries!
+* Unicode URLs
+
+
+0.3.4 (2011-05-14)
+++++++++++++++++++
+
+* Urllib2 HTTPAuthentication Recursion fix (Basic/Digest)
+* Internal Refactor
+* Bytes data upload Bugfix
+
+
+
+0.3.3 (2011-05-12)
+++++++++++++++++++
+
+* Request timeouts
+* Unicode url-encoded data
+* Settings context manager and module
+
+
+0.3.2 (2011-04-15)
+++++++++++++++++++
+
+* Automatic Decompression of GZip Encoded Content
+* AutoAuth Support for Tupled HTTP Auth
+
+
+0.3.1 (2011-04-01)
+++++++++++++++++++
+
+* Cookie Changes
+* Response.read()
+* Poster fix
+
+
+0.3.0 (2011-02-25)
+++++++++++++++++++
+
+* Automatic Authentication API Change
+* Smarter Query URL Parameterization
+* Allow file uploads and POST data together
+* New Authentication Manager System
+    - Simpler Basic HTTP System
+    - Supports all build-in urllib2 Auths
+    - Allows for custom Auth Handlers
+
+
+0.2.4 (2011-02-19)
+++++++++++++++++++
+
+* Python 2.5 Support
+* PyPy-c v1.4 Support
+* Auto-Authentication tests
+* Improved Request object constructor
+
+0.2.3 (2011-02-15)
+++++++++++++++++++
+
+* New HTTPHandling Methods
+    - Reponse.__nonzero__ (false if bad HTTP Status)
+    - Response.ok (True if expected HTTP Status)
+    - Response.error (Logged HTTPError if bad HTTP Status)
+    - Reponse.raise_for_status() (Raises stored HTTPError)
+
+
 0.2.2 (2011-02-14)
 ++++++++++++++++++
 

MANIFEST.in

@@ -1 +1 @@
-include README.rst LICENSE HISTORY.rst 
+include README.rst LICENSE HISTORY.rst test_requests.py

Makefile

@@ -0,0 +1,16 @@
+init:
+	pip install -r reqs.txt
+
+test:
+	nosetests test_requests.py
+
+ci: init
+	nosetests test_requests.py --with-xunit --xunit-file=junit-report.xml
+
+stats:
+	pyflakes requests | awk -F\: '{printf "%s:%s: [E]%s\n", $1, $2, $3}' > violations.pyflakes.txt
+
+site:
+	cd docs; make dirhtml
+
+docs: site

README.rst

@@ -1,23 +1,48 @@
-Requests: The Simple (e.g. usable) HTTP Module
-==============================================
+Requests: HTTP for Humans
+=========================
 
-Most existing Python modules for dealing HTTP requests are insane. I have to look up *everything* that I want to do. Most of my worst Python experiences are a result of the various built-in HTTP libraries (yes, even worse than Logging). 
+Requests is an ISC Licensed HTTP library, written in Python, for human
+beings.
 
-But this one's different. This one's going to be awesome. And simple.
+Most existing Python modules for sending HTTP requests are extremely
+verbose and cumbersome. Python's builtin urllib2 module provides most of
+the HTTP capabilities you should need, but the api is thoroughly broken.
+It requires an enormous amount of work (even method overrides) to
+perform the simplest of tasks.
+
+Things shouldn't be this way. Not in Python.
+
+::
+
+    >>> r = requests.get('https://api.github.com', auth=('user', 'pass'))
+    >>> r.status_code
+    204
+    >>> r.headers['content-type']
+    'application/json'
+    >>> r.content
+    ...
+
+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,
+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.
 
-Really simple. 
 
 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
-    
-- Simple Basic HTTP Authentication
-    + Simple URL + HTTP Auth Registry
+- 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
@@ -30,80 +55,24 @@ It couldn't be simpler. ::
 
 
 HTTPS? Basic Authentication? ::
-    
-    >>> r = requests.get('https://convore.com/api/account/verify.json')
+
+    >>> 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. ::
-    
-    >>> conv_auth = requests.AuthObject('requeststest', 'requeststest')
-    >>> r = requests.get('https://convore.com/api/account/verify.json', auth=conv_auth)
-    
+
+    >>> r = requests.get('https://httpbin.ep.io/basic-auth/user/pass', auth=('user', 'pass'))
+
     >>> r.status_code
-    200 
-    
+    200
+
     >>> r.headers['content-type']
     'application/json'
-    
+
     >>> r.content
-    '{"username": "requeststest", "url": "/users/requeststest/", "id": "9408", "img": "censored-long-url"}'
-
-
-
-API
----
-    
-**Requests:**
-
-All request functions return a Response object (see below).
-
-If a {filename: fileobject} dictionary is passed in (files=...), a multipart_encode upload will be performed.
-If CookieJar object is is passed in (cookies=...), the cookies will be sent with the request.
-    
-  GET Requests
-    >>> request.get(url, params={}, headers={}, cookies=None, auth=None)
-    <request object>
-    
-  HEAD Requests
-    >>> request.head(url, params={}, headers={}, cookies=None, auth=None)
-    <request object>
-    
-  PUT Requests
-    >>> request.put(url, data='', headers={}, files={}, cookies=None, auth=None)
-    <request object>
-    
-  POST Requests
-    >>> request.post(url, data={}, headers={}, files={}, cookies=None, auth=None)
-    <request object>
-    
-  DELETE Requests
-    >>> request.delete(url, params={}, headers={}, cookies=None, auth=None)
-    <request object>
-    
-
-**Responses:**
-    
-    Request.status_code:
-         (Integer) Received HTTP Status Code Response
-
-    Request.headers:
-        (Dictionary) Received HTTP Response Headers
-
-    Request.content:
-        (Bytes) Received Content
-
-    Request.url
-        (String) URL of response. Useful for detecting redirects. 
-
-
-**HTTP Authentication Registry:**
-
-    You can register AuthObjects to automatically enable HTTP Authentication on requests that contain a registered base URL string.
-
-    >>> requests.add_autoauth(url, authobject)
-
+    '{"authenticated": true, "user": "user"}'
 
 
 Installation
@@ -112,27 +81,22 @@ Installation
 To install requests, simply: ::
 
     $ pip install requests
-    
+
 Or, if you absolutely must: ::
 
     $ easy_install requests
 
 But, you really shouldn't do that.
-   
+
 
 
 Contribute
 ----------
 
-If you'd like to contribute, simply fork `the repository`_, commit your changes to the **develop** branch (or branch off of it), and send a pull request. Make sure you add yourself to AUTHORS_.
-
-
-
-Roadmap
--------
-
-- Sphinx Documentation
-- Exhaustive Unittests
+#. Check for open issues or open a fresh issue to start a discussion around a feature idea or a bug. There is a Contributor Friendly tag for issues that should be ideal for people who are not very familiar with the codebase yet.
+#. Fork `the repository`_ on Github to start making your changes to the **develop** branch (or branch off of it).
+#. Write a test which shows that the bug was fixed or that the feature works as expected.
+#. 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

docs/_templates/sidebarintro.html

@@ -0,0 +1,27 @@
+<p class="logo">
+  <a href="{{ pathto(master_doc) }}">
+    <img class="logo" src="{{ pathto('_static/requests-sidebar.png', 1) }}" alt="Logo"/>
+  </a>
+</p>
+
+<p>
+  Requests is an elegant and simple HTTP library for Python, built for
+  human beings. You are currently looking at the documentation of the
+  development release.
+</p>
+
+<h3>Feedback</h3>
+<p>
+  Feedback is greatly appreciated. If you have any questions, comments,
+  random praise, or anonymous threats, <a href="mailto:me@kennethreitz.com">
+  shoot me an email</a>.
+</p>
+
+
+<h3>Useful Links</h3>
+<ul>
+  <li><a href="http://python-requests.org/">The Requests Website</a></li>
+  <li><a href="http://pypi.python.org/pypi/requests">Requests @ PyPI</a></li>
+  <li><a href="http://github.com/kennethreitz/requests">Requests @ GitHub</a></li>
+  <li><a href="http://github.com/kennethreitz/requests/issues">Issue Tracker</a></li>
+</ul>

docs/_templates/sidebarlogo.html

@@ -0,0 +1,11 @@
+<p class="logo">
+  <a href="{{ pathto(master_doc) }}">
+    <img class="logo" src="{{ pathto('_static/requests-sidebar.png', 1) }}" alt="Logo"/>
+  </a>
+</p>
+
+<p>
+  Requests is an elegant and simple HTTP library for Python, built for
+  human beings. You are currently looking at the documentation of the
+  development release.
+</p>

docs/_themes/.gitignore

@@ -0,0 +1,3 @@
+*.pyc
+*.pyo
+.DS_Store

docs/_themes/LICENSE

@@ -0,0 +1,45 @@
+Modifications: 
+
+Copyright (c) 2011 Kenneth Reitz.
+
+
+Original Project: 
+
+Copyright (c) 2010 by Armin Ronacher.
+
+
+Some rights reserved.
+
+Redistribution and use in source and binary forms of the theme, with or
+without modification, are permitted provided that the following conditions
+are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+* 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.
+
+* The names of the contributors may not be used to endorse or
+  promote products derived from this software without specific
+  prior written permission.
+
+We kindly ask you to only use these themes in an unmodified manner just
+for Flask and Flask-related products, not for unrelated projects.  If you
+like the visual style and want to use it for your own projects, please
+consider making some larger changes to the themes (such as changing
+font faces, sizes, colors or margins).
+
+THIS THEME 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 THEME, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

docs/_themes/README.rst

@@ -0,0 +1,25 @@
+krTheme Sphinx Style
+====================
+
+This repository contains sphinx styles Kenneth Reitz uses in most of 
+his projects. It is a drivative of Mitsuhiko's themes for Flask and Flask related
+projects.  To use this style in your Sphinx documentation, follow
+this guide:
+
+1. put this folder as _themes into your docs folder.  Alternatively
+   you can also use git submodules to check out the contents there.
+
+2. add this to your conf.py: ::
+
+	sys.path.append(os.path.abspath('_themes'))
+	html_theme_path = ['_themes']
+	html_theme = 'flask'
+
+The following themes exist:
+
+**kr**
+	the standard flask documentation theme for large projects
+
+**kr_small**
+	small one-page theme.  Intended to be used by very small addon libraries.
+

docs/_themes/flask_theme_support.py

@@ -0,0 +1,86 @@
+# flasky extensions.  flasky pygments style based on tango style
+from pygments.style import Style
+from pygments.token import Keyword, Name, Comment, String, Error, \
+     Number, Operator, Generic, Whitespace, Punctuation, Other, Literal
+
+
+class FlaskyStyle(Style):
+    background_color = "#f8f8f8"
+    default_style = ""
+
+    styles = {
+        # No corresponding class for the following:
+        #Text:                     "", # class:  ''
+        Whitespace:                "underline #f8f8f8",      # class: 'w'
+        Error:                     "#a40000 border:#ef2929", # class: 'err'
+        Other:                     "#000000",                # class 'x'
+
+        Comment:                   "italic #8f5902", # class: 'c'
+        Comment.Preproc:           "noitalic",       # class: 'cp'
+
+        Keyword:                   "bold #004461",   # class: 'k'
+        Keyword.Constant:          "bold #004461",   # class: 'kc'
+        Keyword.Declaration:       "bold #004461",   # class: 'kd'
+        Keyword.Namespace:         "bold #004461",   # class: 'kn'
+        Keyword.Pseudo:            "bold #004461",   # class: 'kp'
+        Keyword.Reserved:          "bold #004461",   # class: 'kr'
+        Keyword.Type:              "bold #004461",   # class: 'kt'
+
+        Operator:                  "#582800",   # class: 'o'
+        Operator.Word:             "bold #004461",   # class: 'ow' - like keywords
+
+        Punctuation:               "bold #000000",   # class: 'p'
+
+        # because special names such as Name.Class, Name.Function, etc.
+        # are not recognized as such later in the parsing, we choose them
+        # to look the same as ordinary variables.
+        Name:                      "#000000",        # class: 'n'
+        Name.Attribute:            "#c4a000",        # class: 'na' - to be revised
+        Name.Builtin:              "#004461",        # class: 'nb'
+        Name.Builtin.Pseudo:       "#3465a4",        # class: 'bp'
+        Name.Class:                "#000000",        # class: 'nc' - to be revised
+        Name.Constant:             "#000000",        # class: 'no' - to be revised
+        Name.Decorator:            "#888",           # class: 'nd' - to be revised
+        Name.Entity:               "#ce5c00",        # class: 'ni'
+        Name.Exception:            "bold #cc0000",   # class: 'ne'
+        Name.Function:             "#000000",        # class: 'nf'
+        Name.Property:             "#000000",        # class: 'py'
+        Name.Label:                "#f57900",        # class: 'nl'
+        Name.Namespace:            "#000000",        # class: 'nn' - to be revised
+        Name.Other:                "#000000",        # class: 'nx'
+        Name.Tag:                  "bold #004461",   # class: 'nt' - like a keyword
+        Name.Variable:             "#000000",        # class: 'nv' - to be revised
+        Name.Variable.Class:       "#000000",        # class: 'vc' - to be revised
+        Name.Variable.Global:      "#000000",        # class: 'vg' - to be revised
+        Name.Variable.Instance:    "#000000",        # class: 'vi' - to be revised
+
+        Number:                    "#990000",        # class: 'm'
+
+        Literal:                   "#000000",        # class: 'l'
+        Literal.Date:              "#000000",        # class: 'ld'
+
+        String:                    "#4e9a06",        # class: 's'
+        String.Backtick:           "#4e9a06",        # class: 'sb'
+        String.Char:               "#4e9a06",        # class: 'sc'
+        String.Doc:                "italic #8f5902", # class: 'sd' - like a comment
+        String.Double:             "#4e9a06",        # class: 's2'
+        String.Escape:             "#4e9a06",        # class: 'se'
+        String.Heredoc:            "#4e9a06",        # class: 'sh'
+        String.Interpol:           "#4e9a06",        # class: 'si'
+        String.Other:              "#4e9a06",        # class: 'sx'
+        String.Regex:              "#4e9a06",        # class: 'sr'
+        String.Single:             "#4e9a06",        # class: 's1'
+        String.Symbol:             "#4e9a06",        # class: 'ss'
+
+        Generic:                   "#000000",        # class: 'g'
+        Generic.Deleted:           "#a40000",        # class: 'gd'
+        Generic.Emph:              "italic #000000", # class: 'ge'
+        Generic.Error:             "#ef2929",        # class: 'gr'
+        Generic.Heading:           "bold #000080",   # class: 'gh'
+        Generic.Inserted:          "#00A000",        # class: 'gi'
+        Generic.Output:            "#888",           # class: 'go'
+        Generic.Prompt:            "#745334",        # class: 'gp'
+        Generic.Strong:            "bold #000000",   # class: 'gs'
+        Generic.Subheading:        "bold #800080",   # class: 'gu'
+        Generic.Traceback:         "bold #a40000",   # class: 'gt'
+    }

docs/_themes/kr/layout.html

@@ -0,0 +1,46 @@
+{%- extends "basic/layout.html" %}
+{%- block extrahead %}
+  {{ super() }}
+  {% if theme_touch_icon %}
+    <link rel="apple-touch-icon" href="{{ pathto('_static/' ~ theme_touch_icon, 1) }}" />
+  {% endif %}
+  <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9">
+{% endblock %}
+{%- block relbar2 %}{% endblock %}
+{%- block footer %}
+    <div class="footer">
+      &copy; Copyright {{ copyright }}.
+    </div>
+    <a href="https://github.com/kennethreitz/requests" class="github">
+        <img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_darkblue_121621.png" alt="Fork me on GitHub"  class="github"/>
+    </a>
+    <script type="text/javascript">
+
+      var _gaq = _gaq || [];
+      _gaq.push(['_setAccount', 'UA-8742933-11']);
+      _gaq.push(['_setDomainName', 'none']);
+      _gaq.push(['_setAllowLinker', true]);
+      _gaq.push(['_trackPageview']);
+
+      (function() {
+        var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+        ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+        var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+      })();
+
+    </script>
+
+    <script type="text/javascript">
+      (function() {
+        var t   = document.createElement('script');
+        t.type  = 'text/javascript';
+        t.async = true;
+        t.id    = 'gauges-tracker';
+        t.setAttribute('data-site-id',
+                       '4ddc27f6613f5d186d000007');
+        t.src = '//secure.gaug.es/track.js';
+        var s = document.getElementsByTagName('script')[0];
+        s.parentNode.insertBefore(t, s);
+      })();
+    </script>
+{%- endblock %}

docs/_themes/kr/relations.html

@@ -0,0 +1,19 @@
+<h3>Related Topics</h3>
+<ul>
+  <li><a href="{{ pathto(master_doc) }}">Documentation overview</a><ul>
+  {%- for parent in parents %}
+  <li><a href="{{ parent.link|e }}">{{ parent.title }}</a><ul>
+  {%- endfor %}
+    {%- if prev %}
+      <li>Previous: <a href="{{ prev.link|e }}" title="{{ _('previous chapter')
+        }}">{{ prev.title }}</a></li>
+    {%- endif %}
+    {%- if next %}
+      <li>Next: <a href="{{ next.link|e }}" title="{{ _('next chapter')
+        }}">{{ next.title }}</a></li>
+    {%- endif %}
+  {%- for parent in parents %}
+  </ul></li>
+  {%- endfor %}
+  </ul></li>
+</ul>

docs/_themes/kr/static/flasky.css_t

@@ -0,0 +1,570 @@
+/*
+ * flasky.css_t
+ * ~~~~~~~~~~~~
+ *
+ * :copyright: Copyright 2010 by Armin Ronacher. Modifications by Kenneth Reitz.
+ * :license: Flask Design License, see LICENSE for details.
+ */
+
+{% set page_width = '940px' %}
+{% set sidebar_width = '220px' %}
+
+@import url("basic.css");
+
+/* -- page layout ----------------------------------------------------------- */
+
+body {
+    font-family: 'goudy old style', 'minion pro', 'bell mt', Georgia, 'Hiragino Mincho Pro';
+    font-size: 17px;
+    background-color: white;
+    color: #000;
+    margin: 0;
+    padding: 0;
+}
+
+div.document {
+    width: {{ page_width }};
+    margin: 30px auto 0 auto;
+}
+
+div.documentwrapper {
+    float: left;
+    width: 100%;
+}
+
+div.bodywrapper {
+    margin: 0 0 0 {{ sidebar_width }};
+}
+
+div.sphinxsidebar {
+    width: {{ sidebar_width }};
+}
+
+hr {
+    border: 1px solid #B1B4B6;
+}
+
+div.body {
+    background-color: #ffffff;
+    color: #3E4349;
+    padding: 0 30px 0 30px;
+}
+
+img.floatingflask {
+    padding: 0 0 10px 10px;
+    float: right;
+}
+
+div.footer {
+    width: {{ page_width }};
+    margin: 20px auto 30px auto;
+    font-size: 14px;
+    color: #888;
+    text-align: right;
+}
+
+div.footer a {
+    color: #888;
+}
+
+div.related {
+    display: none;
+}
+
+div.sphinxsidebar a {
+    color: #444;
+    text-decoration: none;
+    border-bottom: 1px dotted #999;
+}
+
+div.sphinxsidebar a:hover {
+    border-bottom: 1px solid #999;
+}
+
+div.sphinxsidebar {
+    font-size: 14px;
+    line-height: 1.5;
+}
+
+div.sphinxsidebarwrapper {
+    padding: 18px 10px;
+}
+
+div.sphinxsidebarwrapper p.logo {
+    padding: 0;
+    margin: -10px 0 0 -20px;
+    text-align: center;
+}
+
+div.sphinxsidebar h3,
+div.sphinxsidebar h4 {
+    font-family: 'Garamond', 'Georgia', serif;
+    color: #444;
+    font-size: 24px;
+    font-weight: normal;
+    margin: 0 0 5px 0;
+    padding: 0;
+}
+
+div.sphinxsidebar h4 {
+    font-size: 20px;
+}
+
+div.sphinxsidebar h3 a {
+    color: #444;
+}
+
+div.sphinxsidebar p.logo a,
+div.sphinxsidebar h3 a,
+div.sphinxsidebar p.logo a:hover,
+div.sphinxsidebar h3 a:hover {
+    border: none;
+}
+
+div.sphinxsidebar p {
+    color: #555;
+    margin: 10px 0;
+}
+
+div.sphinxsidebar ul {
+    margin: 10px 0;
+    padding: 0;
+    color: #000;
+}
+
+div.sphinxsidebar input {
+    border: 1px solid #ccc;
+    font-family: 'Georgia', serif;
+    font-size: 1em;
+}
+
+/* -- body styles ----------------------------------------------------------- */
+
+a {
+    color: #004B6B;
+    text-decoration: underline;
+}
+
+a:hover {
+    color: #6D4100;
+    text-decoration: underline;
+}
+
+div.body h1,
+div.body h2,
+div.body h3,
+div.body h4,
+div.body h5,
+div.body h6 {
+    font-family: 'Garamond', 'Georgia', serif;
+    font-weight: normal;
+    margin: 30px 0px 10px 0px;
+    padding: 0;
+}
+
+div.body h1 { margin-top: 0; padding-top: 0; font-size: 240%; }
+div.body h2 { font-size: 180%; }
+div.body h3 { font-size: 150%; }
+div.body h4 { font-size: 130%; }
+div.body h5 { font-size: 100%; }
+div.body h6 { font-size: 100%; }
+
+a.headerlink {
+    color: #ddd;
+    padding: 0 4px;
+    text-decoration: none;
+}
+
+a.headerlink:hover {
+    color: #444;
+    background: #eaeaea;
+}
+
+div.body p, div.body dd, div.body li {
+    line-height: 1.4em;
+}
+
+div.admonition {
+    background: #fafafa;
+    margin: 20px -30px;
+    padding: 10px 30px;
+    border-top: 1px solid #ccc;
+    border-bottom: 1px solid #ccc;
+}
+
+div.admonition tt.xref, div.admonition a tt {
+    border-bottom: 1px solid #fafafa;
+}
+
+dd div.admonition {
+    margin-left: -60px;
+    padding-left: 60px;
+}
+
+div.admonition p.admonition-title {
+    font-family: 'Garamond', 'Georgia', serif;
+    font-weight: normal;
+    font-size: 24px;
+    margin: 0 0 10px 0;
+    padding: 0;
+    line-height: 1;
+}
+
+div.admonition p.last {
+    margin-bottom: 0;
+}
+
+div.highlight {
+    background-color: white;
+}
+
+dt:target, .highlight {
+    background: #FAF3E8;
+}
+
+div.note {
+    background-color: #eee;
+    border: 1px solid #ccc;
+}
+
+div.seealso {
+    background-color: #ffc;
+    border: 1px solid #ff6;
+}
+
+div.topic {
+    background-color: #eee;
+}
+
+p.admonition-title {
+    display: inline;
+}
+
+p.admonition-title:after {
+    content: ":";
+}
+
+pre, tt {
+    font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
+    font-size: 0.9em;
+}
+
+img.screenshot {
+}
+
+tt.descname, tt.descclassname {
+    font-size: 0.95em;
+}
+
+tt.descname {
+    padding-right: 0.08em;
+}
+
+img.screenshot {
+    -moz-box-shadow: 2px 2px 4px #eee;
+    -webkit-box-shadow: 2px 2px 4px #eee;
+    box-shadow: 2px 2px 4px #eee;
+}
+
+table.docutils {
+    border: 1px solid #888;
+    -moz-box-shadow: 2px 2px 4px #eee;
+    -webkit-box-shadow: 2px 2px 4px #eee;
+    box-shadow: 2px 2px 4px #eee;
+}
+
+table.docutils td, table.docutils th {
+    border: 1px solid #888;
+    padding: 0.25em 0.7em;
+}
+
+table.field-list, table.footnote {
+    border: none;
+    -moz-box-shadow: none;
+    -webkit-box-shadow: none;
+    box-shadow: none;
+}
+
+table.footnote {
+    margin: 15px 0;
+    width: 100%;
+    border: 1px solid #eee;
+    background: #fdfdfd;
+    font-size: 0.9em;
+}
+
+table.footnote + table.footnote {
+    margin-top: -15px;
+    border-top: none;
+}
+
+table.field-list th {
+    padding: 0 0.8em 0 0;
+}
+
+table.field-list td {
+    padding: 0;
+}
+
+table.footnote td.label {
+    width: 0px;
+    padding: 0.3em 0 0.3em 0.5em;
+}
+
+table.footnote td {
+    padding: 0.3em 0.5em;
+}
+
+dl {
+    margin: 0;
+    padding: 0;
+}
+
+dl dd {
+    margin-left: 30px;
+}
+
+blockquote {
+    margin: 0 0 0 30px;
+    padding: 0;
+}
+
+ul, ol {
+    margin: 10px 0 10px 30px;
+    padding: 0;
+}
+
+pre {
+    background: #eee;
+    padding: 7px 30px;
+    margin: 15px -30px;
+    line-height: 1.3em;
+}
+
+dl pre, blockquote pre, li pre {
+    margin-left: -60px;
+    padding-left: 60px;
+}
+
+dl dl pre {
+    margin-left: -90px;
+    padding-left: 90px;
+}
+
+tt {
+    background-color: #ecf0f3;
+    color: #222;
+    /* padding: 1px 2px; */
+}
+
+tt.xref, a tt {
+    background-color: #FBFBFB;
+    border-bottom: 1px solid white;
+}
+
+a.reference {
+    text-decoration: none;
+    border-bottom: 1px dotted #004B6B;
+}
+
+a.reference:hover {
+    border-bottom: 1px solid #6D4100;
+}
+
+a.footnote-reference {
+    text-decoration: none;
+    font-size: 0.7em;
+    vertical-align: top;
+    border-bottom: 1px dotted #004B6B;
+}
+
+a.footnote-reference:hover {
+    border-bottom: 1px solid #6D4100;
+}
+
+a:hover tt {
+    background: #EEE;
+}
+
+
+@media screen and (max-width: 870px) {
+
+    div.sphinxsidebar {
+    	display: none;
+    }
+
+    div.document {
+       width: 100%;
+
+    }
+
+    div.documentwrapper {
+    	margin-left: 0;
+    	margin-top: 0;
+    	margin-right: 0;
+    	margin-bottom: 0;
+    }
+
+    div.bodywrapper {
+    	margin-top: 0;
+    	margin-right: 0;
+    	margin-bottom: 0;
+    	margin-left: 0;
+    }
+
+    ul {
+    	margin-left: 0;
+    }
+
+    .document {
+    	width: auto;
+    }
+
+    .footer {
+    	width: auto;
+    }
+
+    .bodywrapper {
+    	margin: 0;
+    }
+
+    .footer {
+    	width: auto;
+    }
+
+    .github {
+        display: none;
+    }
+
+
+
+}
+
+
+
+@media screen and (max-width: 875px) {
+
+    body {
+        margin: 0;
+        padding: 20px 30px;
+    }
+
+    div.documentwrapper {
+        float: none;
+        background: white;
+    }
+
+    div.sphinxsidebar {
+        display: block;
+        float: none;
+        width: 102.5%;
+        margin: 50px -30px -20px -30px;
+        padding: 10px 20px;
+        background: #333;
+        color: white;
+    }
+
+    div.sphinxsidebar h3, div.sphinxsidebar h4, div.sphinxsidebar p,
+    div.sphinxsidebar h3 a {
+        color: white;
+    }
+
+    div.sphinxsidebar a {
+        color: #aaa;
+    }
+
+    div.sphinxsidebar p.logo {
+        display: none;
+    }
+
+    div.document {
+        width: 100%;
+        margin: 0;
+    }
+
+    div.related {
+        display: block;
+        margin: 0;
+        padding: 10px 0 20px 0;
+    }
+
+    div.related ul,
+    div.related ul li {
+        margin: 0;
+        padding: 0;
+    }
+
+    div.footer {
+        display: none;
+    }
+
+    div.bodywrapper {
+        margin: 0;
+    }
+
+    div.body {
+        min-height: 0;
+        padding: 0;
+    }
+
+    .rtd_doc_footer {
+        display: none;
+    }
+
+    .document {
+        width: auto;
+    }
+
+    .footer {
+        width: auto;
+    }
+
+    .footer {
+        width: auto;
+    }
+
+    .github {
+        display: none;
+    }
+}
+
+
+/* scrollbars */
+
+::-webkit-scrollbar {
+    width: 6px;
+    height: 6px;
+}
+
+::-webkit-scrollbar-button:start:decrement,
+::-webkit-scrollbar-button:end:increment {
+    display: block;
+    height: 10px;
+}
+
+::-webkit-scrollbar-button:vertical:increment {
+    background-color: #fff;
+}
+
+::-webkit-scrollbar-track-piece {
+    background-color: #eee;
+    -webkit-border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:vertical {
+    height: 50px;
+    background-color: #ccc;
+    -webkit-border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:horizontal {
+    width: 50px;
+    background-color: #ccc;
+    -webkit-border-radius: 3px;
+}
+
+/* misc. */
+
+.revsys-inline {
+    display: none!important;
+}

docs/_themes/kr/theme.conf

@@ -0,0 +1,7 @@
+[theme]
+inherit = basic
+stylesheet = flasky.css
+pygments_style = flask_theme_support.FlaskyStyle
+
+[options]
+touch_icon = 

docs/_themes/kr_small/layout.html

@@ -0,0 +1,22 @@
+{% extends "basic/layout.html" %}
+{% block header %}
+  {{ super() }}
+  {% if pagename == 'index' %}
+  <div class=indexwrapper>
+  {% endif %}
+{% endblock %}
+{% block footer %}
+  {% if pagename == 'index' %}
+  </div>
+  {% endif %}
+{% endblock %}
+{# do not display relbars #}
+{% block relbar1 %}{% endblock %}
+{% block relbar2 %}
+  {% if theme_github_fork %}
+    <a href="http://github.com/{{ theme_github_fork }}"><img style="position: fixed; top: 0; right: 0; border: 0;"
+    src="http://s3.amazonaws.com/github/ribbons/forkme_right_darkblue_121621.png" alt="Fork me on GitHub" /></a>
+  {% endif %}
+{% endblock %}
+{% block sidebar1 %}{% endblock %}
+{% block sidebar2 %}{% endblock %}

docs/_themes/kr_small/static/flasky.css_t

@@ -0,0 +1,287 @@
+/*
+ * flasky.css_t
+ * ~~~~~~~~~~~~
+ *
+ * Sphinx stylesheet -- flasky theme based on nature theme.
+ *
+ * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+ 
+@import url("basic.css");
+ 
+/* -- page layout ----------------------------------------------------------- */
+ 
+body {
+    font-family: 'Georgia', serif;
+    font-size: 17px;
+    color: #000;
+    background: white;
+    margin: 0;
+    padding: 0;
+}
+
+div.documentwrapper {
+    float: left;
+    width: 100%;
+}
+
+div.bodywrapper {
+    margin: 40px auto 0 auto;
+    width: 700px;
+}
+
+hr {
+    border: 1px solid #B1B4B6;
+}
+ 
+div.body {
+    background-color: #ffffff;
+    color: #3E4349;
+    padding: 0 30px 30px 30px;
+}
+
+img.floatingflask {
+    padding: 0 0 10px 10px;
+    float: right;
+}
+ 
+div.footer {
+    text-align: right;
+    color: #888;
+    padding: 10px;
+    font-size: 14px;
+    width: 650px;
+    margin: 0 auto 40px auto;
+}
+ 
+div.footer a {
+    color: #888;
+    text-decoration: underline;
+}
+ 
+div.related {
+    line-height: 32px;
+    color: #888;
+}
+
+div.related ul {
+    padding: 0 0 0 10px;
+}
+ 
+div.related a {
+    color: #444;
+}
+ 
+/* -- body styles ----------------------------------------------------------- */
+ 
+a {
+    color: #004B6B;
+    text-decoration: underline;
+}
+ 
+a:hover {
+    color: #6D4100;
+    text-decoration: underline;
+}
+
+div.body {
+    padding-bottom: 40px; /* saved for footer */
+}
+ 
+div.body h1,
+div.body h2,
+div.body h3,
+div.body h4,
+div.body h5,
+div.body h6 {
+    font-family: 'Garamond', 'Georgia', serif;
+    font-weight: normal;
+    margin: 30px 0px 10px 0px;
+    padding: 0;
+}
+
+{% if theme_index_logo %}
+div.indexwrapper h1 {
+    text-indent: -999999px;
+    background: url({{ theme_index_logo }}) no-repeat center center;
+    height: {{ theme_index_logo_height }};
+}
+{% endif %}
+ 
+div.body h2 { font-size: 180%; }
+div.body h3 { font-size: 150%; }
+div.body h4 { font-size: 130%; }
+div.body h5 { font-size: 100%; }
+div.body h6 { font-size: 100%; }
+ 
+a.headerlink {
+    color: white;
+    padding: 0 4px;
+    text-decoration: none;
+}
+ 
+a.headerlink:hover {
+    color: #444;
+    background: #eaeaea;
+}
+ 
+div.body p, div.body dd, div.body li {
+    line-height: 1.4em;
+}
+
+div.admonition {
+    background: #fafafa;
+    margin: 20px -30px;
+    padding: 10px 30px;
+    border-top: 1px solid #ccc;
+    border-bottom: 1px solid #ccc;
+}
+
+div.admonition p.admonition-title {
+    font-family: 'Garamond', 'Georgia', serif;
+    font-weight: normal;
+    font-size: 24px;
+    margin: 0 0 10px 0;
+    padding: 0;
+    line-height: 1;
+}
+
+div.admonition p.last {
+    margin-bottom: 0;
+}
+
+div.highlight{
+    background-color: white;
+}
+
+dt:target, .highlight {
+    background: #FAF3E8;
+}
+
+div.note {
+    background-color: #eee;
+    border: 1px solid #ccc;
+}
+ 
+div.seealso {
+    background-color: #ffc;
+    border: 1px solid #ff6;
+}
+ 
+div.topic {
+    background-color: #eee;
+}
+ 
+div.warning {
+    background-color: #ffe4e4;
+    border: 1px solid #f66;
+}
+ 
+p.admonition-title {
+    display: inline;
+}
+ 
+p.admonition-title:after {
+    content: ":";
+}
+
+pre, tt {
+    font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
+    font-size: 0.85em;
+}
+
+img.screenshot {
+}
+
+tt.descname, tt.descclassname {
+    font-size: 0.95em;
+}
+
+tt.descname {
+    padding-right: 0.08em;
+}
+
+img.screenshot {
+    -moz-box-shadow: 2px 2px 4px #eee;
+    -webkit-box-shadow: 2px 2px 4px #eee;
+    box-shadow: 2px 2px 4px #eee;
+}
+
+table.docutils {
+    border: 1px solid #888;
+    -moz-box-shadow: 2px 2px 4px #eee;
+    -webkit-box-shadow: 2px 2px 4px #eee;
+    box-shadow: 2px 2px 4px #eee;
+}
+
+table.docutils td, table.docutils th {
+    border: 1px solid #888;
+    padding: 0.25em 0.7em;
+}
+
+table.field-list, table.footnote {
+    border: none;
+    -moz-box-shadow: none;
+    -webkit-box-shadow: none;
+    box-shadow: none;
+}
+
+table.footnote {
+    margin: 15px 0;
+    width: 100%;
+    border: 1px solid #eee;
+}
+
+table.field-list th {
+    padding: 0 0.8em 0 0;
+}
+
+table.field-list td {
+    padding: 0;
+}
+
+table.footnote td {
+    padding: 0.5em;
+}
+
+dl {
+    margin: 0;
+    padding: 0;
+}
+
+dl dd {
+    margin-left: 30px;
+}
+ 
+pre {
+    padding: 0;
+    margin: 15px -30px;
+    padding: 8px;
+    line-height: 1.3em;
+    padding: 7px 30px;
+    background: #eee;
+    border-radius: 2px;
+    -moz-border-radius: 2px;
+    -webkit-border-radius: 2px;
+}
+
+dl pre {
+    margin-left: -60px;
+    padding-left: 60px;
+}
+
+tt {
+    background-color: #ecf0f3;
+    color: #222;
+    /* padding: 1px 2px; */
+}
+
+tt.xref, a tt {
+    background-color: #FBFBFB;
+}
+
+a:hover tt {
+    background: #EEE;
+}

docs/_themes/kr_small/theme.conf

@@ -0,0 +1,10 @@
+[theme]
+inherit = basic
+stylesheet = flasky.css
+nosidebar = true
+pygments_style = flask_theme_support.FlaskyStyle
+
+[options]
+index_logo = ''
+index_logo_height = 120px
+github_fork = ''

docs/api.rst

@@ -0,0 +1,144 @@
+.. _api:
+
+API
+===
+
+.. module:: requests
+
+This part of the documentation covers all the interfaces of Requests.  For
+parts where Requests depends on external libraries, we document the most
+important right here and provide links to the canonical documentation.
+
+
+Main Interface
+--------------
+
+All of Request's functionality can be accessed by these 7 methods.
+They all return an instance of the :class:`Response <Response>` object.
+
+.. autofunction:: request
+
+---------------------
+
+
+.. autoclass:: Response
+   :inherited-members:
+
+---------------------
+
+.. autofunction:: head
+.. autofunction:: get
+.. autofunction:: post
+.. autofunction:: put
+.. autofunction:: patch
+.. autofunction:: delete
+
+
+-----------------
+
+.. autofunction:: session
+
+
+
+Exceptions
+~~~~~~~~~~
+
+.. module:: requests
+
+.. autoexception:: RequestException
+.. autoexception:: ConnectionError
+.. autoexception:: HTTPError
+.. autoexception:: URLRequired
+.. autoexception:: TooManyRedirects
+
+
+.. _configurations:
+
+Configurations
+--------------
+
+.. automodule:: requests.defaults
+
+
+.. _async:
+
+Async
+-----
+
+.. module:: requests.async
+
+
+.. autofunction:: map
+.. autofunction:: request
+.. autofunction:: head
+.. autofunction:: get
+.. autofunction:: post
+.. autofunction:: put
+.. autofunction:: patch
+.. autofunction:: delete
+
+
+
+Utilities
+---------
+
+These functions are used internally, but may be useful outside of
+Requests.
+
+.. module:: requests.utils
+
+Status Code Lookup
+~~~~~~~~~~~~~~~~~~
+
+.. autofunction:: requests.codes
+
+::
+
+    >>> requests.codes['temporary_redirect']
+    307
+
+    >>> requests.codes.teapot
+    418
+
+    >>> requests.codes['\o/']
+    200
+
+Cookies
+~~~~~~~
+
+.. autofunction:: dict_from_cookiejar
+.. autofunction:: cookiejar_from_dict
+.. autofunction:: add_dict_to_cookiejar
+
+
+Encodings
+~~~~~~~~~
+
+.. autofunction:: get_encodings_from_content
+.. autofunction:: get_encoding_from_headers
+.. autofunction:: get_unicode_from_response
+.. autofunction:: decode_gzip
+
+
+Internals
+---------
+
+These items are an internal component to Requests, and should never be
+seen by the end user (developer). This part of the API documentation
+exists for those who are extending the functionality of Requests.
+
+
+Classes
+~~~~~~~
+
+.. autoclass:: requests.Response
+   :inherited-members:
+
+.. autoclass:: requests.Request
+   :inherited-members:
+
+.. _sessionapi:
+
+.. autoclass:: requests.Session
+   :inherited-members:
+

docs/community/faq.rst

@@ -0,0 +1,83 @@
+.. _faq:
+
+Frequently Asked Questions
+==========================
+
+This part of the documentation answers common questions about Requests.
+
+Encoded Data?
+-------------
+
+Requests automatically decompresses gzip-encoded responses, and does
+its best to decode response content to unicode when possible.
+
+You can get direct access to the raw response (and even the socket),
+if needed as well.
+
+
+Custom User-Agents?
+-------------------
+
+Requests allows you to easily override User-Agent strings, along with
+any other HTTP Header.
+
+
+Why not Httplib2?
+-----------------
+
+Chris Adams gave an excellent summary on
+`Hacker News <http://news.ycombinator.com/item?id=2884406>`_:
+
+    httplib2 is part of why you should use requests: it's far more respectable
+    as a client but not as well documented and it still takes way too much code
+    for basic operations. I appreciate what httplib2 is trying to do, that
+    there's a ton of hard low-level annoyances in building a modern HTTP
+    client, but really, just use requests instead. Kenneth Reitz is very
+    motivated and he gets the degree to which simple things should be simple
+    whereas httplib2 feels more like an academic exercise than something
+    people should use to build production systems[1].
+
+    Disclosure: I'm listed in the requests AUTHORS file but can claim credit
+    for, oh, about 0.0001% of the awesomeness.
+
+    1. http://code.google.com/p/httplib2/issues/detail?id=96 is a good example:
+    an annoying bug which affect many people, there was a fix available for
+    months, which worked great when I applied it in a fork and pounded a couple
+    TB of data through it, but it took over a year to make it into trunk and
+    even longer to make it onto PyPI where any other project which required "
+    httplib2" would get the working version.
+
+
+Python 3 Support?
+-----------------
+
+It's on the way. Here's a list of Python platforms that are officially
+supported:
+
+* cPython 2.5
+* cPython 2.5.5
+* cPython 2.5.6
+* cPython 2.6
+* cPython 2.6.6
+* cPython 2.6.7
+* cPython 2.7
+* cPython 2.7.1
+* cPython 2.7.2
+* PyPy-c 1.4
+* PyPy-c 1.5
+
+
+Support for Python 3.x is coming *very* soon.
+
+
+Keep-alive Support?
+-------------------
+
+Yep!
+
+
+Proxy Support?
+--------------
+
+You bet!
+

docs/community/out-there.rst

@@ -0,0 +1,66 @@
+Modules
+=======
+
+- `requests-oauth <https://github.com/maraujop/requests-oauth>`_, adds OAuth support to Requests.
+- `FacePy <https://github.com/jgorset/facepy>`_, a Python wrapper to the Facebook API.
+- `robotframework-requests <https://github.com/bulkan/robotframework-requests>`_, a Robot Framework API wrapper.
+- `fullerene <https://github.com/bitprophet/fullerene>`_, a Graphite Dashboard.
+- `urbanairship-python <https://github.com/benjaminws/urbanairship-python>`_, a fork of the Urban Airship API wrapper.
+- `WhitespaceBot <https://github.com/Gunio/WhitespaceBot/>`_, a project that automatically forks repos, strips trailing whitespace, and sends a pull request.
+- `python-rexster <https://github.com/CulturePlex/python-rexster>`_, Rexter client that provides a simple interface for graph databases.
+- `daikon <https://github.com/neogenix/daikon>`_, a CLI for ElasticSearch.
+
+Articles & Talks
+================
+- `Python for the Web <http://gun.io/blog/python-for-the-web/>`_ teaches how to use Python to interact with the web, using Requests.
+- `Daniel Greenfield's Review of Requests <http://pydanny.blogspot.com/2011/05/python-http-requests-for-humans.html>`_
+- `My 'Python for Humans' talk <http://python-for-humans.heroku.com>`_ ( `audio <http://codeconf.s3.amazonaws.com/2011/pycodeconf/talks/PyCodeConf2011%20-%20Kenneth%20Reitz.m4a>`_ )
+- `Issac Kelly's 'Consuming Web APIs' talk <http://issackelly.github.com/Consuming-Web-APIs-with-Python-Talk/slides/slides.html>`_
+- `Blog post about Requests via Yum <http://arunsag.wordpress.com/2011/08/17/new-package-python-requests-http-for-humans/>`_
+- `Russian blog post introducing Requests <http://habrahabr.ru/blogs/python/126262/>`_
+- `French blog post introducing Requests <http://www.nicosphere.net/requests-urllib2-de-python-simplifie-2432/>`_
+
+
+Integrations
+============
+
+ScraperWiki
+------------
+
+`ScraperWiki <https://scraperwiki.com/>`_ is an excellent service that allows
+you to run Python, Ruby, and PHP scraper scripts on the web. Now, Requests
+v0.6.1 is available to use in your scrapers!
+
+To give it a try, simply::
+
+    import requests
+
+
+Managed Packages
+================
+
+Requests is available in a number of popular package formats. Of course,
+the ideal way to install Requests is via The Cheeseshop.
+
+
+Ubuntu & Debian
+---------------
+
+Requests is available installed as a Debian package! Debian Etch Ubuntu, since Oneiric::
+
+    $ apt-get install python-requests
+
+Unfortunately, the most recent version available is  v0.5.0. If you're on the
+Debian Python Package team, I'd love an update of that :)
+
+
+Fedora and RedHat
+-----------------
+
+You can easily install Requests v0.6.1 with yum on rpm-based systems::
+
+    $ yum install python-requests
+
+
+
+

docs/community/support.rst

@@ -0,0 +1,37 @@
+.. _support:
+
+Support
+=======
+
+If you have a questions or issues about Requests, there are several options:
+
+Send a Tweet
+------------
+
+If your question is less than 140 characters, feel free to send a tweet to
+`@kennethreitz <http://twitter.com/kennethreitz>`_.
+
+
+File an Issue
+-------------
+
+If you notice some unexpected behavior in Requests, or want to see support
+for a new feature,
+`file an issue on GitHub <https://github.com/kennethreitz/requests/issues>`_.
+
+
+E-mail
+------
+
+I'm more than happy to answer any personal or in-depth questions about
+Requests. Feel free to email
+`requests@kennethreitz.com <mailto:requests@kennethreitz.com>`_.
+
+
+IRC
+---
+
+The official Freenode channel for Requests is
+`#python-requests <irc://irc.freenode.net/python-requests>`_
+
+I'm also available as **kennethreitz** on Freenode.

docs/community/updates.rst

@@ -0,0 +1,30 @@
+.. _updates:
+
+Updates
+=======
+
+If you'd like to stay up to date on the community and development of Requests,
+there are several options:
+
+GitHub
+------
+
+The best way to track the development of Requests is through
+`the GitHub repo <https://github.com/kennethreitz/requests>`_.
+
+Twitter
+-------
+
+I often tweet about new features and releases of Requests.
+
+Follow `@kennethreitz <https://twitter.com/kennethreitz>`_ for updates.
+
+
+Mailing List
+------------
+
+There's a low-volume mailing list for Requests. To subscribe to the
+mailing list, send an email to
+`requests@librelist.org <mailto:requests@librelist.org>`_.
+
+

docs/conf.py

@@ -16,7 +16,9 @@ import sys, os
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
-#sys.path.insert(0, os.path.abspath('.'))
+sys.path.insert(0, os.path.abspath('..'))
+import requests
+from requests import __version__
 
 # -- General configuration -----------------------------------------------------
 
@@ -25,7 +27,7 @@ import sys, os
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ['sphinx.ext.autodoc', 'sphinx.ext.todo', 'sphinx.ext.coverage', 'sphinx.ext.pngmath', 'sphinx.ext.jsmath', 'sphinx.ext.viewcode']
+extensions = ['sphinx.ext.autodoc']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
@@ -41,16 +43,16 @@ master_doc = 'index'
 
 # General information about the project.
 project = u'Requests'
-copyright = u'2011, Kenneth Reitz'
+copyright = u'2011. A <a href="http://kennethreitz.com/pages/open-projects.html">Kenneth Reitz</a> Project'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
 # The short X.Y version.
-version = '0.2.0'
+version = __version__
 # The full version, including alpha/beta/rc tags.
-release = '0.2.0'
+release = version
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -81,7 +83,7 @@ exclude_patterns = ['_build']
 #show_authors = False
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
+pygments_style = 'flask_theme_support.FlaskyStyle'
 
 # A list of ignored prefixes for module index sorting.
 #modindex_common_prefix = []
@@ -112,6 +114,7 @@ html_theme = 'default'
 # of the sidebar.
 #html_logo = None
 
+
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
@@ -131,7 +134,12 @@ html_static_path = ['_static']
 #html_use_smartypants = True
 
 # Custom sidebar templates, maps document names to template names.
-#html_sidebars = {}
+# Custom sidebar templates, maps document names to template names.
+html_sidebars = {
+    'index':    ['sidebarintro.html', 'sourcelink.html', 'searchbox.html'],
+    '**':       ['sidebarlogo.html', 'localtoc.html', 'relations.html',
+                 'sourcelink.html', 'searchbox.html']
+}
 
 # Additional templates that should be rendered to pages, maps page names to
 # template names.
@@ -147,10 +155,10 @@ html_static_path = ['_static']
 #html_split_index = False
 
 # If true, links to the reST sources are added to the pages.
-#html_show_sourcelink = True
+html_show_sourcelink = False
 
 # If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-#html_show_sphinx = True
+html_show_sphinx = False
 
 # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
 #html_show_copyright = True
@@ -230,3 +238,7 @@ texinfo_documents = [
 
 # Documents to append as an appendix to all manuals.
 texinfo_appendices = []
+
+sys.path.append(os.path.abspath('_themes'))
+html_theme_path = ['_themes']
+html_theme = 'kr'

docs/dev/authors.rst

@@ -0,0 +1,5 @@
+Authors
+=======
+
+
+.. include:: ../../AUTHORS.rst

docs/dev/todo.rst

@@ -0,0 +1,12 @@
+How to Help
+===========
+
+Requests is under active development, and contributions are more than welcome!
+
+
+What Needs to be Done
+---------------------
+
+- HTTP Cert Checking (`#30 <https://github.com/kennethreitz/requests/issues/30>`_)
+- Python 3.x Support (`#70 <https://github.com/kennethreitz/requests/issues/70>`_)
+- Kerberos Support (`#47 <https://github.com/kennethreitz/requests/issues/47>`_)

docs/index.rst

@@ -3,18 +3,129 @@
    You can adapt this file completely to your liking, but it should at least
    contain the root `toctree` directive.
 
-Welcome to Requests's documentation!
-====================================
+Requests: HTTP for Humans
+=========================
 
-Contents:
+Release v\ |version|. (:ref:`Installation <install>`)
+
+Requests is an :ref:`ISC Licensed <isc>` HTTP library, written in Python, for human beings.
+
+Python's standard **urllib2** module provides most of
+the HTTP capabilities you need, but the API is thoroughly **broken**.
+It was built for a different time — and a different web. It requires an *enormous* amount of work (even method overrides) to perform the simplest of tasks.
+
+Things shouldn’t be this way. Not in Python.
+
+::
+
+    >>> r = requests.get('https://api.github.com', auth=('user', 'pass'))
+    >>> r.status_code
+    204
+    >>> r.headers['content-type']
+    'application/json'
+    >>> r.content
+    ...
+
+See `the same code, without Requests <https://gist.github.com/973705>`_.
+
+Requests takes all of the work out of Python HTTP — making your integration with web services seamless. There's no need to manually add query strings to your URLs, or to form-encode your POST data.
+
+
+Testimonials
+------------
+
+`The Washington Post <http://www.washingtonpost.com/>`_,
+`Twitter, Inc <http://twitter.com>`_,
+`Readability <http://readability.com>`_, and
+Federal US Institutions
+use Requests internally. It has been installed over 45,000 times from PyPi.
+
+**Armin Ronacher**
+    Requests is the perfect example how beautiful an API can be with the
+    right level of abstraction.
+
+**Matt DeBoard**
+    I'm going to get @kennethreitz's Python requests module tattooed
+    on my body, somehow. The whole thing.
+
+**Daniel Greenfeld**
+    Nuked a 1200 LOC spaghetti code library with 10 lines of code thanks to
+    @kennethreitz's request library. Today has been AWESOME.
+
+**Kenny Meyers**
+    Python HTTP: When in doubt, or when not in doubt, use Requests. Beautiful,
+    simple, Pythonic.
+
+
+Feature Support
+---------------
+
+Requests is ready for today's web.
+
+- International Domains and URLs
+- Keep-Alive & Connection Pooling
+- Sessions with Cookie Persistence
+- Basic/Digest Authentication
+- Elegant Key/Value Cookies
+- Automatic Decompression
+- Unicode Response Bodies
+- Multipart File Uploads
+- Connection Timeouts
+- Zero Dependencies
+
+
+
+User Guide
+----------
+
+This part of the documentation, which is mostly prose, begins with some
+background information about Requests, then focuses on step-by-step
+instructions for getting the most out of Requests.
 
 .. toctree::
    :maxdepth: 2
 
-Indices and tables
-==================
+   user/intro
+   user/install
+   user/quickstart
+   user/advanced
 
-* :ref:`genindex`
-* :ref:`modindex`
-* :ref:`search`
 
+Community Guide
+-----------------
+
+This part of the documentation, which is mostly prose, details the
+Requests ecosystem and community.
+
+.. toctree::
+   :maxdepth: 2
+
+   community/faq
+   community/out-there.rst
+   community/support
+   community/updates
+
+API Documentation
+-----------------
+
+If you are looking for information on a specific function, class or method,
+this part of the documentation is for you.
+
+.. toctree::
+   :maxdepth: 2
+
+   api
+
+
+Developer Guide
+---------------
+
+If you want to contribute to the project, this part of the documentation is for
+you.
+
+.. toctree::
+   :maxdepth: 2
+
+   dev/internals
+   dev/todo
+   dev/authors

docs/user/advanced.rst

@@ -0,0 +1,254 @@
+.. _advanced:
+
+Advanced Usage
+==============
+
+This document covers some of Requests more advanced features.
+
+
+Session Objects
+---------------
+
+The Session object allows you to persist certain parameters across
+requests. It also perstists cookies across all requests made from the
+Session instance.
+
+A session object has all the methods of the main Requests API.
+
+Let's persist some cookies across requests::
+
+    s = requests.session()
+
+    s.get('http://httpbin.org/cookies/set/sessioncookie/123456789')
+    r = s.get("http://httpbin.org/cookies")
+
+    print r.content
+    # '{"cookies": {"sessioncookie": "123456789"}}'
+
+
+Sessions can also be used to provide default data to the request methods::
+
+    headers = {'x-test': 'true'}
+    auth = ('user', 'pass')
+
+    with requests.session(auth=auth, headers=headers) as c:
+
+        # both 'x-test' and 'x-test2' are sent
+        c.get('http://httpbin.org/headers', headers={'x-test2': 'true'})
+
+
+Any dictionaries that you pass to a request method will be merged with the session-level values that are set. The method-level parameters override session parameters.
+
+.. admonition:: Remove a Value From a Dict Parameter
+
+    Sometimes you'll want to omit session-level keys from a dict parameter. To do this, you simply set that key's value to ``None`` in the method-level parameter. It will automatically be omitted.
+
+All values that are contained within a session are directly available to you. See the :ref:`Session API Docs <sessionapi>` to learn more.
+
+
+Body Content Workflow
+----------------------
+
+By default, When you make a request, the body of the response isn't downloaded immediately. The response headers are downloaded when you make a request, but the content isn't downloaded until you access the :class:`Response.content` attribute.
+
+Let's walk through it::
+
+    tarball_url = 'https://github.com/kennethreitz/requests/tarball/master'
+    r = requests.get(tarball_url)
+
+The request has been made, but the connection is still open. The response body has not been downloaded yet. ::
+
+    r.content
+
+The content has been downloaded and cached.
+
+You can override this default behavior with the ``prefetch`` parameter::
+
+    r = requests.get(tarball_url, prefetch=True)
+    # Blocks until all of request body has been downloaded.
+
+
+Configuring Requests
+--------------------
+
+Sometimes you may want to configure a request to customize its behavior. To do
+this, you can pass in a ``config`` dictionary to a request or session. See the :ref:`Configuration API Docs <configurations>` to learn more.
+
+
+Keep-Alive
+----------
+
+Excellent news — thanks to urllib3, keep-alive is 100% automatic within a session! Any requests that you make within a session will automatically reuse the appropriate connection!
+
+If you'd like to disable keep-alive, you can simply set the ``keep_alive`` configuration to ``False``::
+
+    s = requests.session()
+    s.config['keep_alive'] = False
+
+
+Asynchronous Requests
+----------------------
+
+Requests has first-class support for concurrent requests, powered
+by gevent. This allows you to send a bunch of HTTP requests at the same
+
+First, let's import the async module. Heads up — if you don't have
+`gevent <http://pypi.python.org/pypi/gevent>`_ this will fail::
+
+    from requests import async
+
+The ``async`` module has the exact same api as ``requests``, except it
+doesn't send the request immediately. Instead, it returns the ``Request``
+object.
+
+We can build a list of ``Request`` objects easily::
+
+    urls = [
+        'http://python-requests.org',
+        'http://httpbin.org',
+        'http://python-guide.org',
+        'http://kennethreitz.com'
+    ]
+
+    rs = [async.get(u) for u in urls]
+
+Now we have a list of ``Request`` objects, ready to be sent. We could send them
+one at a time with ``Request.send()``, but that would take a while.  Instead,
+we'll send them all at the same time with ``async.map()``.  Using ``async.map()``
+will also guarantee execution of the ``response`` hook, described below. ::
+
+    >>> async.map(rs)
+    [<Response [200]>, <Response [200]>, <Response [200]>, <Response [200]>]
+
+.. admonition:: Throttling
+
+    The ``map`` function also takes a ``size`` parameter, that specifies the nubmer of connections to make at a time::
+
+        async.map(rs, size=5)
+
+
+Event Hooks
+-----------
+
+Requests has a hook system that you can use to manipulate portions of
+the request process, or signal event handling.
+
+Available hooks:
+
+``args``:
+    A dictionary of the arguments being sent to Request().
+
+``pre_request``:
+    The Request object, directly before being sent.
+
+``post_request``:
+    The Request object, directly after being sent.
+
+``response``:
+    The response generated from a Request.
+
+
+You can assign a hook function on a per-request basis by passing a
+``{hook_name: callback_function}`` dictionary to the ``hooks`` request
+parameter::
+
+    hooks=dict(args=print_url)
+
+That ``callback_function`` will receive a chunk of data as its first
+argument.
+
+::
+
+    def print_url(args):
+        print args['url']
+
+If an error occurs while executing your callback, a warning is given.
+
+If the callback function returns a value, it is assumed that it is to
+replace the data that was passed in. If the function doesn't return
+anything, nothing else is effected.
+
+Let's print some request method arguments at runtime::
+
+    >>> requests.get('http://httpbin', hooks=dict(args=print_url))
+    http://httpbin
+    <Response [200]>
+
+Let's hijack some arguments this time with a new callback::
+
+    def hack_headers(args):
+        if not args[headers]:
+            args['headers'] = dict()
+
+        args['headers'].update({'X-Testing': 'True'})
+
+        return args
+
+    hooks = dict(args=hack_headers)
+    headers = dict(yo=dawg)
+
+And give it a try::
+
+    >>> requests.get('http://httpbin/headers', hooks=hooks, headers=headers)
+    {
+        "headers": {
+            "Content-Length": "",
+            "Accept-Encoding": "gzip",
+            "Yo": "dawg",
+            "X-Forwarded-For": "::ffff:24.127.96.129",
+            "Connection": "close",
+            "User-Agent": "python-requests.org",
+            "Host": "httpbin.org",
+            "X-Testing": "True",
+            "X-Forwarded-Protocol": "",
+            "Content-Type": ""
+        }
+    }
+
+
+Custom Authentication
+---------------------
+
+Requests allows you to use specify your own authentication mechanism.
+
+When you pass our authentication tuple to a request method, the first
+string is the type of authentication. 'basic' is inferred if none is
+provided.
+
+You can pass in a callable object instead of a string for the first item
+in the tuple, and it will be used in place of the built in authentication
+callbacks.
+
+Let's pretend that we have a web service that will only respond if the
+``X-Pizza`` header is set to a password value. Unlikely, but just go with it.
+
+We simply need to define a callback function that will be used to update the
+Request object, right before it is dispatched.
+
+::
+
+    def pizza_auth(r, username):
+        """Attaches HTTP Pizza Authentication to the given Request object.
+        """
+        r.headers['X-Pizza'] = username
+
+        return r
+
+Then, we can make a request using our Pizza Auth::
+
+    >>> requests.get('http://pizzabin.org/admin', auth=(pizza_auth, 'kenneth'))
+    <Response [200]>
+
+
+Verbose Logging
+---------------
+
+If you want to get a good look at what HTTP requests are being sent
+by your application, you can turn on verbose logging.
+
+To do so, just configure Requests with a stream to write to::
+
+    >>> my_config = {'verbose': sys.stderr}
+    >>> requests.get('http://httpbin.org/headers', config=my_config)
+    2011-08-17T03:04:23.380175   GET   http://httpbin.org/headers
+    <Response [200]>

docs/user/install.rst

@@ -0,0 +1,78 @@
+.. _install:
+
+Installation
+============
+
+This part of the documentation covers the installation of Requests.
+The first step to using any software package is getting it properly installed.
+
+
+Distribute & Pip
+----------------
+
+Installing requests is simple with `pip <http://www.pip-installer.org/>`_::
+
+    $ pip install requests
+
+or, with `easy_install <http://pypi.python.org/pypi/setuptools>`_::
+
+    $ easy_install requests
+
+But, you really `shouldn't do that <http://www.pip-installer.org/en/latest/other-tools.html#pip-compared-to-easy-install>`_.
+
+
+
+Cheeseshop Mirror
+-----------------
+
+If the Cheeseshop is down, you can also install Requests from Kenneth Reitz's
+personal `Cheeseshop mirror <http://pip.kreitz.co/>`_::
+
+    $ pip install -i http://pip.kreitz.co/simple requests
+
+
+Get the Code
+------------
+
+Requests is actively developed on GitHub, where the code is
+`always available <https://github.com/kennethreitz/requests>`_.
+
+You can either clone the public repository::
+
+    git clone git://github.com/kennethreitz/requests.git
+
+Download the `tarball <https://github.com/kennethreitz/requests/tarball/master>`_::
+
+    $ curl -O https://github.com/kennethreitz/requests/tarball/master
+
+Or, download the `zipball <https://github.com/kennethreitz/requests/zipball/master>`_::
+
+    $ curl -O https://github.com/kennethreitz/requests/zipball/master
+
+
+Once you have a copy of the source, you can embed it in your Python package,
+or install it into your site-packages easily::
+
+    $ python setup.py install
+
+.. _gevent:
+
+Installing Gevent
+-----------------
+
+If you are using the ``requests.async`` module for making concurrent
+requests, you need to install gevent.
+
+To install gevent, you'll need ``libevent``.
+
+OSX::
+
+    $ brew install libevent
+
+Ubuntu::
+
+    $ apt-get install libevent-dev
+
+Once you have ``libevent``, you can install ``gevent`` with ``pip``::
+
+    $ pip install gevent

docs/user/intro.rst

@@ -0,0 +1,49 @@
+.. _introduction:
+
+Introduction
+============
+
+Philosophy
+----------
+
+Requests was developed with a few :pep:`20` idioms in mind.
+
+
+#. Beautiful is better than ugly.
+#. Explicit is better than implicit.
+#. Simple is better than complex.
+#. Complex is better than complicated.
+#. Readability counts.
+
+All contributions to Requests should keep these important rules in mind.
+
+
+ISC License
+-----------
+
+A large number of open source projects you find today are `GPL Licensed`_.
+While the GPL has its time and place, it should most certainly not be your
+go-to license for your next open source project.
+
+A project that is released as GPL cannot be used in any commercial product
+without the product itself also being offered as open source.
+
+The MIT, BSD, ISC, and Apache2 licenses are great alternatives to the GPL
+that allow your open-source software to be used freely in proprietary,
+closed-source software.
+
+Requests is released under terms of `The ISC License`_.
+
+.. _`GPL Licensed`: http://www.opensource.org/licenses/gpl-license.php
+.. _`The ISC License`: http://www.opensource.org/licenses/isc-license
+
+
+Requests License
+----------------
+
+    Copyright (c) 2011, 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.
+

docs/user/quickstart.rst

@@ -0,0 +1,356 @@
+.. _quickstart:
+
+Quickstart
+==========
+
+.. module:: requests.models
+
+Eager to get started? This page gives a good introduction in how to get started
+with Requests. This assumes you already have Requests installed. If you do not,
+head over to the :ref:`Installation <install>` section.
+
+First, make sure that:
+
+* Requests is :ref:`installed <install>`
+* Requests is :ref:`up-to-date <updates>`
+
+
+Lets gets started with some simple use cases and examples.
+
+
+Make a GET Request
+------------------
+
+Making a standard request with Requests is very simple.
+
+Let's get GitHub's public timeline ::
+
+    r = requests.get('https://github.com/timeline.json')
+
+Now, we have a :class:`Response` object called ``r``. We can get all the
+information we need from this.
+
+
+Response Content
+----------------
+
+We can read the content of the server's response::
+
+    >>> r.content
+    '[{"repository":{"open_issues":0,"url":"https://github.com/...
+
+Requests does its best to decode content from the server. Most unicode
+charsets, ``gzip``, and ``deflate`` encodings are all seamlessly decoded.
+
+When you make a request, ``r.encoding`` is set, based on the HTTP headers.
+Requests will attempt to use that encoding when you access ``r.content``. You
+can manually set ``r.encoding`` to any encoding you'd like (including ``None``),
+and that charset will be used.
+
+
+Make a POST Request
+-------------------
+
+POST requests are equally simple::
+
+    r = requests.post("http://httpbin.org/post")
+
+
+Typically, you want to send some form-encoded data — much like an HTML form.
+To do this, simply pass a dictionary to the `data` argument. Your
+dictionary of data will automatically be form-encoded when the request is made::
+
+    >>> payload = {'key1': 'value1', 'key2': 'value2'}
+    >>> r = requests.post("http://httpbin.org/post", data=payload)
+    >>> print r.content
+    {
+      "origin": "179.13.100.4",
+      "files": {},
+      "form": {
+        "key2": "value2",
+        "key1": "value1"
+      },
+      "url": "http://httpbin.org/post",
+      "args": {},
+      "headers": {
+        "Content-Length": "23",
+        "Accept-Encoding": "identity, deflate, compress, gzip",
+        "Accept": "*/*",
+        "User-Agent": "python-requests/0.8.0",
+        "Host": "127.0.0.1:7077",
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      "data": ""
+    }
+
+There are many times that you want to send data that is not form-encoded. If you pass in a ``string`` instead of a ``dict``, that data will be posted directly.
+
+For example, the GitHub API v3 accepts JSON-Encoded POST/PATCH data::
+
+    url = 'https://api.github.com/some/endpoint'
+    payload = {'some': 'data'}
+
+    r = requests.post(url, data=json.dumps(payload))
+
+
+Custom Headers
+--------------
+
+If you'd like to add HTTP headers to a request, simply pass in a ``dict`` to the
+``headers`` parameter.
+
+For example, we didn't specify our content-type in the previous example::
+
+    url = 'https://api.github.com/some/endpoint'
+    payload = {'some': 'data'}
+    headers = {'content-type': 'application/json'}
+
+    r = requests.post(url, data=json.dumps(payload), headers=headers)
+
+
+POST a Multipart-Encoded File
+-----------------------------
+
+Requests makes it simple to upload Multipart-encoded files::
+
+    >>> url = 'http://httpbin.org/post'
+    >>> files = {'report.xls': open('report.xls', 'rb')}
+
+    >>> r = requests.post(url, files=files)
+    >>> r.content
+    {
+      "origin": "179.13.100.4",
+      "files": {
+        "report.xls": "<censored...binary...data>"
+      },
+      "form": {},
+      "url": "http://httpbin.org/post",
+      "args": {},
+      "headers": {
+        "Content-Length": "3196",
+        "Accept-Encoding": "identity, deflate, compress, gzip",
+        "Accept": "*/*",
+        "User-Agent": "python-requests/0.8.0",
+        "Host": "httpbin.org:80",
+        "Content-Type": "multipart/form-data; boundary=127.0.0.1.502.21746.1321131593.786.1"
+      },
+      "data": ""
+    }
+
+Setting filename explicitly::
+
+    >>> url = 'http://httpbin.org/post'
+    >>> files = {'file': ('report.xls', open('report.xls', 'rb'))}
+
+    >>> r = requests.post(url, files=files)
+    >>> r.content
+    {
+      "origin": "179.13.100.4",
+      "files": {
+        "file": "<censored...binary...data>"
+      },
+      "form": {},
+      "url": "http://httpbin.org/post",
+      "args": {},
+      "headers": {
+        "Content-Length": "3196",
+        "Accept-Encoding": "identity, deflate, compress, gzip",
+        "Accept": "*/*",
+        "User-Agent": "python-requests/0.8.0",
+        "Host": "httpbin.org:80",
+        "Content-Type": "multipart/form-data; boundary=127.0.0.1.502.21746.1321131593.786.1"
+      },
+      "data": ""
+    }
+
+
+Response Status Codes
+---------------------
+
+We can check the response status code::
+
+    >>> r.status_code
+    200
+
+Requests also comes with a built-in status code lookup object for easy
+reference::
+
+    >>> r.status_code == requests.codes.ok
+    True
+
+If we made a bad request (non-200 response), we can raise it with
+:class:`Response.raise_for_status()`::
+
+    >>> _r = requests.get('http://httpbin.org/status/404')
+    >>> _r.status_code
+    404
+
+    >>> _r.raise_for_status()
+    Traceback (most recent call last):
+      File "requests/models.py", line 394, in raise_for_status
+        raise self.error
+    urllib2.HTTPError: HTTP Error 404: NOT FOUND
+
+But, since our ``status_code`` was ``200``, when we call it::
+
+    >>> r.raise_for_status()
+    None
+
+All is well.
+
+
+Response Headers
+----------------
+
+We can view the server's response headers with a simple Python dictionary
+interface::
+
+    >>> r.headers
+    {
+        'status': '200 OK',
+        'content-encoding': 'gzip',
+        'transfer-encoding': 'chunked',
+        'connection': 'close',
+        'server': 'nginx/1.0.4',
+        'x-runtime': '148ms',
+        'etag': '"e1ca502697e5c9317743dc078f67693f"',
+        'content-type': 'application/json; charset=utf-8'
+    }
+
+The dictionary is special, though: it's made just for HTTP headers. According to
+`RFC 2616 <http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html>`_, HTTP
+Headers are case-insensitive.
+
+So, we can access the headers using any capitalization we want::
+
+    >>> r.headers['Content-Type']
+    'application/json; charset=utf-8'
+
+    >>> r.headers.get('content-type')
+    'application/json; charset=utf-8'
+
+If a header doesn't exist in the Response, its value defaults to ``None``::
+
+    >>> r.headers['X-Random']
+    None
+
+
+Cookies
+-------
+
+If a response contains some Cookies, you can get quick access to them::
+
+    >>> url = 'http://httpbin.org/cookies/set/requests-is/awesome'
+    >>> r = requests.get(url)
+
+    >>> print r.cookies
+    {'requests-is': 'awesome'}
+
+To send your own cookies to the server, you can use the ``cookies``
+parameter::
+
+    >>> url = 'http://httpbin.org/cookies'
+    >>> cookies = dict(cookies_are='working')
+
+    >>> r = requests.get(url, cookies=cookies)
+    >>> r.content
+    '{"cookies": {"cookies_are": "working"}}'
+
+
+Basic Authentication
+--------------------
+
+Most web services require authentication. There many different types of
+authentication, but the most common is HTTP Basic Auth.
+
+Making requests with Basic Auth is extremely simple::
+
+    >>> requests.get('https://api.github.com/user', auth=('user', 'pass'))
+    <Response [200]>
+
+OAuth Authentication
+--------------------
+
+Miguel Araujo's `requests-oauth <http://pypi.python.org/pypi/requests-oauth>`_ project provides a simple interface for
+establishing OAuth connections. Documentation and examples can be found on the requests-oauth `git repository <https://github.com/maraujop/requests-oauth>`_.
+
+Digest Authentication
+---------------------
+
+Another popular form of web service protection is Digest Authentication::
+
+    >>> url = 'http://httpbin.org/digest-auth/auth/user/pass'
+    >>> requests.get(url, auth=('digest', 'user', 'pass'))
+    <Response [200]>
+
+
+Redirection and History
+-----------------------
+
+Requests will automatically perform location redirection while using impodotent methods.
+
+GitHub redirects all HTTP requests to HTTPS. Let's see what happens::
+
+    >>> r = requests.get('http://github.com')
+    >>> r.url
+    'https://github.com/'
+    >>> r.status_code
+    200
+    >>> r.history
+    [<Response [301]>]
+
+The :class:`Response.history` list contains a list of the
+:class:`Request` objects that were created in order to complete the request.
+
+If you're using GET, HEAD, or OPTIONS, you can disable redirection
+handling with the ``disable_redirects`` parameter::
+
+    >>> r = requests.get('http://github.com')
+    >>> r.status_code
+    301
+    >>> r.history
+    []
+
+If you're using POST, PUT, PATCH, *&c*, you can also explicitly enable redirection as well::
+
+    >>> r = requests.post('http://github.com', allow_redirects=True)
+    >>> r.url
+    'https://github.com/'
+    >>> r.history
+    [<Response [301]>]
+
+
+Timeouts
+--------
+
+You can tell requests to stop waiting for a response after a given number of seconds with the ``timeout`` parameter::
+
+    >>> requests.get('http://github.com', timeout=0.001)
+    Traceback (most recent call last):
+      File "<stdin>", line 1, in <module>
+    requests.exceptions.Timeout: Request timed out.
+
+.. admonition:: Note
+
+    ``timeout`` only effects the connection process itself, not the downloading of the respone body.
+
+
+Errors and Exceptions
+---------------------
+
+In the event of a network problem (e.g. DNS failure, refused connection, etc),
+Requests will raise a :class:`ConnectionError` exception.
+
+In the event of the rare invalid HTTP response, Requests will raise
+an  :class:`HTTPError` exception.
+
+If a request times out, a :class:`Timeout` exception is raised.
+
+If a request exceeds the configured number of maximum redirections, a :class:`TooManyRedirects` exception is raised.
+
+All exceptions that Requests explicitly raises inherit from
+:class:`requests.exceptions.RequestException`.
+
+-----------------------
+
+Ready for more? Check out the :ref:`advanced <advanced>` section.

reqs.txt

@@ -0,0 +1,7 @@
+envoy==0.0.2
+httpbin==0.0.4
+gunicorn
+nose
+pyflakes
+omnijson
+rudolf

requests/__init__.py

@@ -1,4 +1,33 @@
 # -*- coding: utf-8 -*-
 
-from . import packages
-from .core import *
+#   __
+#  /__)  _  _     _   _ _/   _
+# / (   (- (/ (/ (- _)  /  _)
+#          /
+
+"""
+requests
+~~~~~~~~
+
+:copyright: (c) 2011 by Kenneth Reitz.
+:license: ISC, see LICENSE for more details.
+
+"""
+
+__title__ = 'requests'
+__version__ = '0.8.2'
+__build__ = 0x000802
+__author__ = 'Kenneth Reitz'
+__license__ = 'ISC'
+__copyright__ = 'Copyright 2011 Kenneth Reitz'
+
+
+from . import utils
+from .models import Request, Response
+from .api import request, get, head, post, patch, put, delete, options
+from .sessions import session, Session
+from .status_codes import codes
+from .exceptions import (
+    RequestException, Timeout, URLRequired,
+    TooManyRedirects, HTTPError, ConnectionError
+)

requests/api.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.api
+~~~~~~~~~~~~
+
+This module implements the Requests API.
+
+:copyright: (c) 2011 by Kenneth Reitz.
+:license: ISC, see LICENSE for more details.
+
+"""
+
+from .sessions import session
+
+
+def request(method, url,
+    params=None,
+    data=None,
+    headers=None,
+    cookies=None,
+    files=None,
+    auth=None,
+    timeout=None,
+    allow_redirects=False,
+    proxies=None,
+    hooks=None,
+    return_response=True,
+    prefetch=False,
+    config=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 'name': file-like-objects (or {'name': ('filename', fileobj)}) for multipart encoding upload.
+    :param auth: (optional) Auth typle 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 if POST/PUT/DELETE redirect following is allowed.
+    :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.
+    """
+
+    s = session()
+    return s.request(
+        method=method,
+        url=url,
+        params=params,
+        data=data,
+        headers=headers,
+        cookies=cookies,
+        files=files,
+        auth=auth,
+        timeout=timeout,
+        allow_redirects=allow_redirects,
+        proxies=proxies,
+        hooks=hooks,
+        return_response=return_response,
+        config=config,
+        prefetch=prefetch
+    )
+
+
+
+def get(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 request('get', url, **kwargs)
+
+
+def options(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 request('options', url, **kwargs)
+
+
+def head(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', True)
+    return request('head', url, **kwargs)
+
+
+def post(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 request('post', url, data=data, **kwargs)
+
+
+def put(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 request('put', url, data=data, **kwargs)
+
+
+def patch(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 request('patch', url,  data=data, **kwargs)
+
+
+def delete(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 request('delete', url, **kwargs)

requests/async.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.async
+~~~~~~~~~~~~~~
+
+This module contains an asynchronous replica of ``requests.api``, powered
+by gevent. All API methods return a ``Request`` instance (as opposed to
+``Response``). A list of requests can be sent with ``map()``.
+"""
+
+try:
+    import gevent
+    from gevent import monkey as curious_george
+    from gevent.pool import Pool
+except ImportError:
+    raise RuntimeError('Gevent is required for requests.async.')
+
+# Monkey-patch.
+curious_george.patch_all(thread=False)
+
+from . import api
+
+
+__all__ = (
+    'map',
+    'get', 'options', 'head', 'post', 'put', 'patch', 'delete', 'request'
+)
+
+
+def patched(f):
+    """Patches a given API function to not send."""
+
+    def wrapped(*args, **kwargs):
+
+        kwargs['return_response'] = False
+        kwargs['prefetch'] = True
+
+        return f(*args, **kwargs)
+
+    return wrapped
+
+
+def send(r, pools=None):
+    """Sends a given Request object."""
+
+    if pools:
+        r._pools = pools
+
+    r.send()
+
+    return r.response
+
+
+# Patched requests.api functions.
+get = patched(api.get)
+options = patched(api.options)
+head = patched(api.head)
+post = patched(api.post)
+put = patched(api.put)
+patch = patched(api.patch)
+delete = patched(api.delete)
+request = patched(api.request)
+
+
+def map(requests, prefetch=True, size=None):
+    """Concurrently converts a list of Requests to Responses.
+
+    :param requests: a collection of Request objects.
+    :param prefetch: If False, the content will not be downloaded immediately.
+    :param size: Specifies the number of requests to make at a time. If None, no throttling occurs.
+    """
+
+    if size:
+        pool = Pool(size)
+        pool.map(send, requests)
+        pool.join()
+    else:
+        jobs = [gevent.spawn(send, r) for r in requests]
+        gevent.joinall(jobs)
+
+    if prefetch:
+        [r.response.content for r in requests]
+
+    return [r.response for r in requests]
+
+
+
+

requests/auth.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.auth
+~~~~~~~~~~~~~
+
+This module contains the authentication handlers for Requests.
+"""
+
+import time
+import hashlib
+
+from base64 import b64encode
+from urlparse import urlparse
+
+from .utils import randombytes, parse_dict_header
+
+
+def http_basic(r, username, password):
+    """Attaches HTTP Basic Authentication to the given Request object.
+    Arguments should be considered non-positional.
+
+    """
+    username = str(username)
+    password = str(password)
+
+    auth_s = b64encode('%s:%s' % (username, password))
+    r.headers['Authorization'] = ('Basic %s' % auth_s)
+
+    return r
+
+
+def http_digest(r, username, password):
+    """Attaches HTTP Digest Authentication to the given Request object.
+    Arguments should be considered non-positional.
+    """
+
+    def handle_401(r):
+        """Takes the given response and tries digest-auth, if needed."""
+
+        s_auth = r.headers.get('www-authenticate', '')
+
+        if 'digest' in s_auth.lower():
+
+            last_nonce = ''
+            nonce_count = 0
+
+            chal = parse_dict_header(s_auth.replace('Digest ', ''))
+
+            realm = chal['realm']
+            nonce = chal['nonce']
+            qop = chal.get('qop')
+            algorithm = chal.get('algorithm', 'MD5')
+            opaque = chal.get('opaque', None)
+
+            algorithm = algorithm.upper()
+            # lambdas assume digest modules are imported at the top level
+            if algorithm == 'MD5':
+                H = lambda x: hashlib.md5(x).hexdigest()
+            elif algorithm == 'SHA':
+                H = lambda x: hashlib.sha1(x).hexdigest()
+            # XXX MD5-sess
+            KD = lambda s, d: H("%s:%s" % (s, d))
+
+            if H is None:
+                return None
+
+            # XXX not implemented yet
+            entdig = None
+            p_parsed = urlparse(r.request.url)
+            path = p_parsed.path + p_parsed.query
+
+            A1 = "%s:%s:%s" % (username, realm, password)
+            A2 = "%s:%s" % (r.request.method, path)
+
+            if qop == 'auth':
+                if nonce == last_nonce:
+                    nonce_count += 1
+                else:
+                    nonce_count = 1
+                    last_nonce = nonce
+
+                ncvalue = '%08x' % nonce_count
+                cnonce = (hashlib.sha1("%s:%s:%s:%s" % (
+                    nonce_count, nonce, time.ctime(), randombytes(8)))
+                    .hexdigest()[:16]
+                )
+                noncebit = "%s:%s:%s:%s:%s" % (nonce, ncvalue, cnonce, qop, H(A2))
+                respdig = KD(H(A1), noncebit)
+            elif qop is None:
+                respdig = KD(H(A1), "%s:%s" % (nonce, H(A2)))
+            else:
+                # XXX handle auth-int.
+                return None
+
+            # XXX should the partial digests be encoded too?
+            base = 'username="%s", realm="%s", nonce="%s", uri="%s", ' \
+                   'response="%s"' % (username, realm, nonce, path, respdig)
+            if opaque:
+                base += ', opaque="%s"' % opaque
+            if entdig:
+                base += ', digest="%s"' % entdig
+            base += ', algorithm="%s"' % algorithm
+            if qop:
+                base += ', qop=auth, nc=%s, cnonce="%s"' % (ncvalue, cnonce)
+
+
+            r.request.headers['Authorization'] = 'Digest %s' % (base)
+            r.request.send(anyway=True)
+            _r = r.request.response
+            _r.history.append(r)
+
+            return _r
+
+        return r
+
+    r.hooks['response'] = handle_401
+    return r
+
+
+def dispatch(t):
+    """Given an auth tuple, return an expanded version."""
+
+    if not t:
+        return t
+    else:
+        t = list(t)
+
+    # Make sure they're passing in something.
+    assert len(t) >= 2
+
+    # If only two items are passed in, assume HTTPBasic.
+    if (len(t) == 2):
+        t.insert(0, 'basic')
+
+    # Allow built-in string referenced auths.
+    if isinstance(t[0], basestring):
+        if t[0] in ('basic', 'forced_basic'):
+            t[0] = http_basic
+        elif t[0] in ('digest',):
+            t[0] = http_digest
+
+    # Return a custom callable.
+    return (t[0], tuple(t[1:]))
+
+

requests/core.py

@@ -1,463 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-    requests.core
-    ~~~~~~~~~~~~~
-
-    This module implements the main Requests system.
-
-    :copyright: (c) 2011 by Kenneth Reitz.
-    :license: ISC, see LICENSE for more details.
-"""
-
-import urllib
-import urllib2
-
-
-try:
-	import eventlet
-	eventlet.monkey_patch()
-except ImportError:
-	pass
-
-if not 'eventlet' in locals():
-	try:
-		from gevent import monkey
-		monkey.patch_all()
-	except ImportError:
-		pass
-
-
-from .packages.poster.encode import multipart_encode
-from .packages.poster.streaminghttp import register_openers
-
-
-__title__ = 'requests'
-__version__ = '0.2.2'
-__build__ = 0x000202
-__author__ = 'Kenneth Reitz'
-__license__ = 'ISC'
-__copyright__ = 'Copyright 2011 Kenneth Reitz'
-
-
-AUTOAUTHS = []
-
-
-class _Request(urllib2.Request):
-	"""Hidden wrapper around the urllib2.Request object. Allows for manual
-    setting of HTTP methods.
-    """
-	
-	def __init__(self, url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None):
-		urllib2.Request.__init__( self, url, data, headers, origin_req_host, unverifiable)
-		self.method = method
-
-	def get_method(self):
-		if self.method:
-			return self.method
-
-		return urllib2.Request.get_method(self)
-
-
-class Request(object):
-	"""The :class:`Request` object. It carries out all functionality of
-    Requests. Recommended interface is with the Requests functions.
-    """
-	
-	_METHODS = ('GET', 'HEAD', 'PUT', 'POST', 'DELETE')
-	
-	def __init__(self):
-		self.url = None
-		self.headers = dict()
-		self.files = None
-		self.method = None
-		self.params = {}
-		self.data = {}
-		self.response = Response()
-		
-		self.auth = None
-		self.cookiejar = None
-		self.sent = False
-		
-		
-	def __repr__(self):
-		return '<Request [%s]>' % (self.method)
-	
-	
-	def __setattr__(self, name, value):
-		if (name == 'method') and (value):
-			if not value in self._METHODS:
-				raise InvalidMethod()
-		
-		object.__setattr__(self, name, value)
-	
-	
-	def _checks(self):
-		"""Deterministic checks for consistency."""
-
-		if not self.url:
-			raise URLRequired
-
-		
-	def _get_opener(self):
-		"""Creates appropriate opener object for urllib2."""
-
-		_handlers = []
-
-		if self.auth or self.cookiejar:
-
-			if self.auth:
-
-				authr = urllib2.HTTPPasswordMgrWithDefaultRealm()
-
-				authr.add_password(None, self.url, self.auth.username, self.auth.password)
-				auth_handler = urllib2.HTTPBasicAuthHandler(authr)
-
-				_handlers.append(auth_handler)
-
-			if self.cookiejar:
-
-				cookie_handler = urllib2.HTTPCookieProcessor(cookiejar)
-				_handlers.append(cookie_handler)
-
-			opener = urllib2.build_opener(*_handlers)
-			return opener.open
-
-		else:
-			return urllib2.urlopen
-
-
-	def _build_response(self, resp):
-		"""Build internal Response object from given response."""
-		
-		self.response.status_code = resp.code
-		self.response.headers = resp.info().dict
-		self.response.content = resp.read()
-		self.response.url = resp.url
-
-	
-	def send(self, anyway=False):
-		"""Sends the request. Returns True of 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.
-        """
-
-		self._checks()
-
-		success = False
-
-
-		if self.method in ('GET', 'HEAD', 'DELETE'):
-			if (not self.sent) or anyway:
-
-				# url encode GET params if it's a dict
-				if isinstance(self.params, dict):
-					params = urllib.urlencode(self.params)
-				else:
-
-					params = self.params
-
-				req = _Request(("%s?%s" % (self.url, params)), method=self.method)
-
-				if self.headers:
-					req.headers = self.headers
-
-				opener = self._get_opener()
-
-				try:
-					resp = opener(req)
-					self._build_response(resp)
-					success = True
-
-				except urllib2.HTTPError as why:
-					self._build_response(why)
-					success = False
-
-
-		elif self.method == 'PUT':
-			if (not self.sent) or anyway:
-
-				if self.files:
-					register_openers()
-					datagen, headers = multipart_encode(self.files)
-					req = _Request(self.url, data=datagen, headers=headers, method='PUT')
-
-					if self.headers:
-						req.headers.update(self.headers)
-
-				else:
-
-					req = _Request(self.url, method='PUT')
-
-					if self.headers:
-						req.headers = self.headers
-
-					req.data = self.data
-
-				try:
-					opener = self._get_opener()
-					resp =  opener(req)
-
-					self._build_response(resp)
-					success = True
-
-				except urllib2.HTTPError as why:
-					self._build_response(why)
-					success = False
-
-
-		elif self.method == 'POST':
-			if (not self.sent) or anyway:
-
-				if self.files:
-					register_openers()
-					datagen, headers = multipart_encode(self.files)
-					req = _Request(self.url, data=datagen, headers=headers, method='POST')
-
-					if self.headers:
-						req.headers.update(self.headers)
-				
-				else:
-					req = _Request(self.url, method='POST')
-					req.headers = self.headers
-
-					# url encode form data if it's a dict
-					if isinstance(self.data, dict):
-						req.data = urllib.urlencode(self.data)
-					else:
-						req.data = self.data
-
-				try:
-
-					opener = self._get_opener()
-					resp =  opener(req)
-
-					self._build_response(resp)
-					success = True
-
-				except urllib2.HTTPError as why:
-					self._build_response(why)
-					success = False
-
-		
-		self.sent = True if success else False
-		
-		return success
-		
-
-class Response(object):
-	"""The :class:`Request` object. All :class:`Request` objects contain a
-    :class:`Request.response <response>` attribute, which is an instance of
-    this class.
-    """
-
-	def __init__(self):
-		self.content = None
-		self.status_code = None
-		self.headers = dict()
-		self.url = None
-		
-	def __repr__(self):
-		return '<Response [%s]>' % (self.status_code)
-
-
-	
-class AuthObject(object):
-	"""The :class:`AuthObject` is a simple HTTP Authentication token. When
-    given to a Requests function, it enables Basic HTTP Authentication for that
-    Request. You can also enable Authorization for domain realms with AutoAuth.
-    See AutoAuth for more details.
-    
-    :param username: Username to authenticate with.
-    :param password: Password for given username.
-    """
-	
-	def __init__(self, username, password):
-		self.username = username
-		self.password = password
-
-
-
-def get(url, params={}, headers={}, cookies=None, auth=None):
-	"""Sends a GET request. Returns :class:`Response` object.
-
-    :param url: URL for the new :class:`Request` object.
-    :param params: (optional) Dictionary of GET Parameters to send with the :class:`Request`.
-    :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`.
-    :param cookies: (optional) CookieJar object to send with the :class:`Request`.
-    :param auth: (optional) AuthObject to enable Basic HTTP Auth.
-    """
-	
-	r = Request()
-	
-	r.method = 'GET'
-	r.url = url
-	r.params = params
-	r.headers = headers
-	r.cookiejar = cookies
-	r.auth = _detect_auth(url, auth)
-	
-	r.send()
-	
-	return r.response
-
-
-def head(url, params={}, headers={}, cookies=None, auth=None):
-	"""Sends a HEAD request. Returns :class:`Response` object.
-
-    :param url: URL for the new :class:`Request` object.
-    :param params: (optional) Dictionary of GET Parameters to send with the :class:`Request`.
-    :param headers: (optional) Dictionary of HTTP Headers to sent with the :class:`Request`.
-    :param cookies: (optional) CookieJar object to send with the :class:`Request`.
-    :param auth: (optional) AuthObject to enable Basic HTTP Auth.
-    """
-	
-	r = Request()
-	
-	r.method = 'HEAD'
-	r.url = url
-	# return response object
-	r.params = params
-	r.headers = headers
-	r.cookiejar = cookies
-	r.auth = _detect_auth(url, auth)
-	
-	r.send()
-	
-	return r.response
-
-
-def post(url, data={}, headers={}, files=None, cookies=None, auth=None):
-	"""Sends a POST request. Returns :class:`Response` object.
-
-    :param url: URL for the new :class:`Request` object.
-    :param data: (optional) Dictionary of POST Data to send with the :class:`Request`.
-    :param headers: (optional) Dictionary of HTTP Headers to sent with the :class:`Request`.
-    :param files: (optional) Dictionary of 'filename': file-like-objects for multipart encoding upload.
-    :param cookies: (optional) CookieJar object to send with the :class:`Request`.
-    :param auth: (optional) AuthObject to enable Basic HTTP Auth.
-    """
-	
-	r = Request()
-	
-	r.url = url
-	r.method = 'POST'
-	r.data = data
-	
-	if files:
-		r.files = files
-	
-	r.headers = headers
-	r.cookiejar = cookies
-	r.auth = _detect_auth(url, auth)
-	
-	r.send()
-	
-	return r.response
-	
-	
-def put(url, data='', headers={}, files={}, cookies=None, auth=None):
-	"""Sends a PUT request. Returns :class:`Response` object.
-
-    :param url: URL for the new :class:`Request` object.
-    :param data: (optional) Bytes of PUT Data to send with the :class:`Request`.
-    :param headers: (optional) Dictionary of HTTP Headers to sent with the :class:`Request`.
-    :param files: (optional) Dictionary of 'filename': file-like-objects for multipart encoding upload.
-    :param cookies: (optional) CookieJar object to send with the :class:`Request`.
-    :param auth: (optional) AuthObject to enable Basic HTTP Auth.
-    """
-	
-	r = Request()
-
-	r.url = url
-	r.method = 'PUT'
-	r.data = data
-	r.files = files
-	r.headers = headers
-	r.cookiejar = cookies
-	r.auth = _detect_auth(url, auth)
-	
-	r.send()
-	
-	return r.response
-
-	
-def delete(url, params={}, headers={}, cookies=None, auth=None):
-	"""Sends a DELETE request. Returns :class:`Response` object.
-
-    :param url: URL for the new :class:`Request` object.
-    :param params: (optional) Dictionary of GET Parameters to send with the :class:`Request`.
-    :param headers: (optional) Dictionary of HTTP Headers to sent with the :class:`Request`.
-    :param cookies: (optional) CookieJar object to send with the :class:`Request`.
-    :param auth: (optional) AuthObject to enable Basic HTTP Auth.
-    """
-	
-	r = Request()
-
-	r.url = url
-	r.method = 'DELETE'
-	
-	r.headers = headers
-	r.cookiejar = cookies
-	r.auth = _detect_auth(url, auth)
-	
-	r.send()
-	
-	return r.response
-
-
-def add_autoauth(url, authobject):
-	"""Registers given AuthObject to given URL domain. for auto-activation.
-    Once a URL is registered with an AuthObject, the configured HTTP
-    Authentication will be used for all requests with URLS containing the given
-    URL string.
-
-    Example: ::
-        >>> c_auth = requests.AuthObject('kennethreitz', 'xxxxxxx')
-        >>> requests.add_autoauth('https://convore.com/api/', c_auth)
-        >>> r = requests.get('https://convore.com/api/account/verify.json')
-        # Automatically HTTP Authenticated! Wh00t!
-
-    :param url: Base URL for given AuthObject to auto-activate for.
-    :param authobject: AuthObject to auto-activate.
-    """
-
-	global AUTOAUTHS
-	
-	AUTOAUTHS.append((url, authobject))
-
-
-def _detect_auth(url, auth):
-	"""Returns registered AuthObject for given url if available, defaulting to
-    given AuthObject.
-    """
-
-	return _get_autoauth(url) if not auth else auth
-
-	
-def _get_autoauth(url):
-	"""Returns registered AuthObject for given url if available."""
-	
-	for (autoauth_url, auth) in AUTOAUTHS:
-		if autoauth_url in url: 
-			return auth
-			
-	return None
-
-
-class RequestException(Exception):
-	"""There was an ambiguous exception that occured while handling your request."""
-
-class AuthenticationError(RequestException):
-	"""The authentication credentials provided were invalid."""
-	
-class URLRequired(RequestException):
-	"""A valid URL is required to make a request."""
-	
-class InvalidMethod(RequestException):
-	"""An inappropriate method was attempted."""

requests/defaults.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.defaults
+~~~~~~~~~~~~~~~~~
+
+This module provides the Requests configuration defaults.
+
+Configurations:
+
+:base_headers: Default HTTP headers.
+:verbose: Stream to write request logging to.
+:timeout: Seconds until request timeout.
+:max_redirects: Maximum njumber of redirects allowed within a request.
+:decode_unicode: Decode unicode responses automatically?
+:keep_alive: Reuse HTTP Connections?
+:max_retries: The number of times a request should be retried in the event of a connection failure.
+:safe_mode: If true, Requests will catch all errors.
+:pool_maxsize: The maximium size of an HTTP connection pool.
+:pool_connections: The number of active HTTP connection pools to use.
+
+"""
+
+from . import __version__
+
+defaults = dict()
+
+
+defaults['base_headers'] = {
+    'User-Agent': 'python-requests/%s' % __version__,
+    'Accept-Encoding': ', '.join(('identity', 'deflate', 'compress', 'gzip')),
+    'Accept': '*/*'
+}
+
+defaults['verbose'] = None
+defaults['max_redirects'] = 30
+defaults['decode_unicode'] = True
+defaults['pool_connections'] = 10
+defaults['pool_maxsize'] = 10
+defaults['max_retries'] = 0
+defaults['safe_mode'] = False
+defaults['keep_alive'] = True

requests/exceptions.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.exceptions
+~~~~~~~~~~~~~~~~~~~
+
+This module contains the set of Requests' exceptions.
+
+"""
+
+class RequestException(Exception):
+    """There was an ambiguous exception that occurred while handling your
+    request."""
+
+class HTTPError(RequestException):
+    """An HTTP error occured."""
+
+class ConnectionError(RequestException):
+    """A Connection error occured."""
+
+class Timeout(RequestException):
+    """The request timed out."""
+
+class URLRequired(RequestException):
+    """A valid URL is required to make a request."""
+
+class TooManyRedirects(RequestException):
+    """Too many redirects."""

requests/hooks.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.hooks
+~~~~~~~~~~~~~~
+
+This module provides the capabilities for the Requests hooks system.
+
+Available hooks:
+
+``args``:
+    A dictionary of the arguments being sent to Request().
+
+``pre_request``:
+    The Request object, directly before being sent.
+
+``post_request``:
+    The Request object, directly after being sent.
+
+``response``:
+    The response generated from a Request.
+
+"""
+
+import warnings
+
+
+def dispatch_hook(key, hooks, hook_data):
+    """Dispatches a hook dictionary on a given piece of data."""
+
+    hooks = hooks or dict()
+
+    if key in hooks:
+        try:
+            return hooks.get(key).__call__(hook_data) or hook_data
+
+        except Exception, why:
+            warnings.warn(str(why))
+
+    return hook_data

requests/models.py

@@ -0,0 +1,635 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.models
+~~~~~~~~~~~~~~~
+
+This module contains the primary objects that power Requests.
+"""
+
+import urllib
+import zlib
+
+from urlparse import urlparse, urlunparse, urljoin, urlsplit
+from datetime import datetime
+
+from .auth import dispatch as auth_dispatch
+from .hooks import dispatch_hook
+from .structures import CaseInsensitiveDict
+from .status_codes import codes
+from .packages import oreos
+from .packages.urllib3.exceptions import MaxRetryError
+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 .exceptions import (
+    Timeout, URLRequired, TooManyRedirects, HTTPError, ConnectionError)
+from .utils import (
+    get_encoding_from_headers, stream_decode_response_unicode,
+    decode_gzip, stream_decode_gzip, guess_filename, requote_path)
+
+
+REDIRECT_STATI = (codes.moved, codes.found, codes.other, codes.temporary_moved)
+
+
+
+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,
+        _poolmanager=None):
+
+        #: Float describes the timeout of the request.
+        #  (Use socket.setdefaulttimeout() as fallback)
+        self.timeout = timeout
+
+        #: Request URL.
+        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 = files
+
+        #: HTTP Method to use.
+        self.method = method
+
+        #: Dictionary or byte 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>`.
+        self.params = None
+        self.params = dict(params or [])
+
+        #: 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 [])
+
+        self.data, self._enc_data = self._encode_params(data)
+        self.params, self._enc_params = self._encode_params(params)
+
+        #: :class:`Response <Response>` instance, containing
+        #: content and metadata of HTTP Response, once :attr:`sent <send>`.
+        self.response = Response()
+
+        #: Authentication tuple to attach to :class:`Request <Request>`.
+        self._auth = auth
+        self.auth = auth_dispatch(auth)
+
+        #: CookieJar to attach to :class:`Request <Request>`.
+        self.cookies = dict(cookies or [])
+
+        #: Dictionary of configurations for this request.
+        self.config = dict(config or [])
+
+        #: True if Request has been sent.
+        self.sent = False
+
+        #: Event-handling hooks.
+        self.hooks = hooks
+
+        #: Session.
+        self.session = None
+
+        if headers:
+            headers = CaseInsensitiveDict(self.headers)
+        else:
+            headers = CaseInsensitiveDict()
+
+        for (k, v) in self.config.get('base_headers', {}).items():
+            if k not in headers:
+                headers[k] = v
+
+        self.headers = headers
+        self._poolmanager = _poolmanager
+
+        # Pre-request hook.
+        r = dispatch_hook('pre_request', hooks, self)
+        self.__dict__.update(r.__dict__)
+
+
+    def __repr__(self):
+        return '<Request [%s]>' % (self.method)
+
+
+    def _build_response(self, resp, is_error=False):
+        """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 staus_code, for whatever reason.
+                response.status_code = getattr(resp, 'status', None)
+
+                # Make headers case-insensitive.
+                response.headers = CaseInsensitiveDict(getattr(resp, 'headers', None))
+
+                # Set encoding.
+                response.encoding = get_encoding_from_headers(response.headers)
+
+                # Start off with our local cookies.
+                cookies = self.cookies or dict()
+
+                # Add new cookies from the server.
+                if 'set-cookie' in response.headers:
+                    cookie_header = response.headers['set-cookie']
+                    cookies = oreos.dict_from_string(cookie_header)
+
+                # Save cookies in Response.
+                response.cookies = cookies
+
+            # Save original resopnse for later.
+            response.raw = resp
+
+            if is_error:
+                response.error = resp
+
+            response.url = self.full_url
+
+            return response
+
+        history = []
+
+        r = build(resp)
+        cookies = self.cookies
+        self.cookies.update(r.cookies)
+
+        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))
+            ):
+
+                if not len(history) < self.config.get('max_redirects'):
+                    raise TooManyRedirects()
+
+                history.append(r)
+
+                url = r.headers['location']
+
+                # 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, url)
+
+                # http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.4
+                if r.status_code is codes.see_other:
+                    method = 'GET'
+                else:
+                    method = self.method
+
+                # Remove the cookie headers that were sent.
+                headers = self.headers
+                try:
+                    del headers['Cookie']
+                except KeyError:
+                    pass
+
+                request = Request(
+                    url=url,
+                    headers=headers,
+                    files=self.files,
+                    method=method,
+                    params=self.session.params,
+                    auth=self._auth,
+                    cookies=cookies,
+                    redirect=True,
+                    config=self.config,
+                    timeout=self.timeout,
+                    _poolmanager=self._poolmanager,
+                    proxies = self.proxies,
+                )
+
+                request.send()
+                cookies.update(request.response.cookies)
+                r = request.response
+                self.cookies.update(r.cookies)
+
+            r.history = history
+
+        self.response = r
+        self.response.request = self
+        self.response.cookies.update(self.cookies)
+
+
+    @staticmethod
+    def _encode_params(data):
+        """Encode parameters in a piece of data.
+
+        If the data supplied is a dictionary, encodes each parameter in it, and
+        returns a list of tuples containing the encoded parameters, and a urlencoded
+        version of that.
+
+        Otherwise, assumes the data is already encoded appropriately, and
+        returns it twice.
+        """
+
+        if hasattr(data, '__iter__'):
+            data = dict(data)
+
+        if hasattr(data, 'items'):
+            result = []
+            for k, vs in data.items():
+                for v in isinstance(vs, list) and vs or [vs]:
+                    result.append((k.encode('utf-8') if isinstance(k, unicode) else k,
+                                   v.encode('utf-8') if isinstance(v, unicode) else v))
+            return result, urllib.urlencode(result, doseq=True)
+        else:
+            return data, data
+
+    @property
+    def full_url(self):
+        """Build the actual URL to use."""
+
+        if not self.url:
+            raise URLRequired()
+
+        # Support for unicode domain names and paths.
+        scheme, netloc, path, params, query, fragment = urlparse(self.url)
+
+        if not scheme:
+            raise ValueError()
+
+        netloc = netloc.encode('idna')
+
+        if isinstance(path, unicode):
+            path = path.encode('utf-8')
+
+        path = requote_path(path)
+
+        url = str(urlunparse([ scheme, netloc, path, params, query, fragment ]))
+
+        if self._enc_params:
+            if urlparse(url).query:
+                return '%s&%s' % (url, self._enc_params)
+            else:
+                return '%s?%s' % (url, self._enc_params)
+        else:
+            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:
+            return self.full_url
+
+        path = p.path
+        if not path:
+            path = '/'
+        url.append(path)
+
+        query = p.query
+        if query:
+            url.append('?')
+            url.append(query)
+
+        return ''.join(url)
+
+
+
+    def send(self, anyway=False, prefetch=False):
+        """Sends the request. Returns True of 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.
+        """
+
+        # Logging
+        if self.config.get('verbose'):
+            self.config.get('verbose').write('%s   %s   %s\n' % (
+                datetime.now().isoformat(), self.method, self.url
+            ))
+
+        # Build the URL
+        url = self.full_url
+
+        # Nottin' on you.
+        body = None
+        content_type = None
+
+        # Multi-part file uploads.
+        if self.files:
+            if not isinstance(self.data, basestring):
+
+                try:
+                    fields = self.data.copy()
+                except AttributeError:
+                    fields = dict(self.data)
+
+                for (k, v) in self.files.items():
+                    # support for explicit filename
+                    if isinstance(v, (tuple, list)):
+                        fn, fp = v
+                    else:
+                        fn = guess_filename(v) or k
+                        fp = v
+                    fields.update({k: (fn, fp.read())})
+
+                (body, content_type) = encode_multipart_formdata(fields)
+            else:
+                pass
+                # TODO: Conflict?
+        else:
+            if self.data:
+
+                body = self._enc_data
+                if isinstance(self.data, basestring):
+                    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
+
+
+        if self.auth:
+            auth_func, auth_args = self.auth
+
+            # Allow auth to make its changes.
+            r = auth_func(self, *auth_args)
+
+            # Update self to reflect the auth changes.
+            self.__dict__.update(r.__dict__)
+
+        _p = urlparse(url)
+        proxy = self.proxies.get(_p.scheme)
+
+        if proxy:
+            conn = poolmanager.proxy_from_url(proxy)
+        else:
+            # Check to see if keep_alive is allowed.
+            if self.config.get('keep_alive'):
+                conn = self._poolmanager.connection_from_url(url)
+            else:
+                conn = connectionpool.connection_from_url(url)
+
+        if not self.sent or anyway:
+
+            if self.cookies:
+
+                # Skip if 'cookie' header is explicitly set.
+                if 'cookie' not in self.headers:
+
+                    # Simple cookie with our dict.
+                    c = oreos.monkeys.SimpleCookie()
+                    for (k, v) in self.cookies.items():
+                        c[k] = v
+
+                    # Turn it into a header.
+                    cookie_header = c.output(header='', sep='; ').strip()
+
+                    # Attach Cookie header to request.
+                    self.headers['Cookie'] = cookie_header
+
+            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=prefetch,
+                    decode_content=False,
+                    retries=self.config.get('max_retries', 0),
+                    timeout=self.timeout,
+                )
+
+
+            except MaxRetryError, e:
+                if not self.config.get('safe_mode', False):
+                    raise ConnectionError(e)
+                else:
+                    r = None
+
+            except (_SSLError, _HTTPError), e:
+                if not self.config.get('safe_mode', False):
+                    raise Timeout('Request timed out.')
+
+            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:
+                self.response._content_consumed = True
+
+            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 = None
+        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.content.
+        self.encoding = None
+
+        #: A list of :class:`Response <Response>` objects from
+        #: the history of the Request. Any redirect responses will end
+        #: up here.
+        self.history = []
+
+        #: The :class:`Request <Request>` that created the Response.
+        self.request = None
+
+        #: A dictionary of Cookies the server sent back.
+        self.cookies = {}
+
+        #: Dictionary of configurations for this request.
+        self.config = {}
+
+
+    def __repr__(self):
+        return '<Response [%s]>' % (self.status_code)
+
+    def __nonzero__(self):
+        """Returns true if :attr:`status_code` is 'OK'."""
+        return self.ok
+
+    @property
+    def ok(self):
+        try:
+            self.raise_for_status()
+        except HTTPError:
+            return False
+        return True
+
+
+    def iter_content(self, chunk_size=10 * 1024, decode_unicode=None):
+        """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:
+            raise RuntimeError(
+                'The content for this response was already consumed'
+            )
+
+        def generate():
+            while 1:
+                chunk = self.raw.read(chunk_size)
+                if not chunk:
+                    break
+                yield chunk
+            self._content_consumed = True
+
+        gen = generate()
+
+        if 'gzip' in self.headers.get('content-encoding', ''):
+            gen = stream_decode_gzip(gen)
+
+        if decode_unicode is None:
+            decode_unicode = self.config.get('decode_unicode')
+
+        if decode_unicode:
+            gen = stream_decode_response_unicode(gen, self)
+
+        return gen
+
+
+    @property
+    def content(self):
+        """Content of the response, in bytes or unicode
+        (if available).
+        """
+
+        if self._content is None:
+            # Read the contents.
+            try:
+                if self._content_consumed:
+                    raise RuntimeError(
+                        'The content for this response was already consumed')
+
+                self._content = self.raw.read()
+            except AttributeError:
+                self._content = None
+
+        content = self._content
+
+        # Decode GZip'd content.
+        if 'gzip' in self.headers.get('content-encoding', ''):
+            try:
+                content = decode_gzip(self._content)
+            except zlib.error:
+                pass
+
+        # Decode unicode content.
+        if self.config.get('decode_unicode'):
+
+            # Try charset from content-type
+
+            if self.encoding:
+                try:
+                    content = unicode(content, self.encoding)
+                except UnicodeError:
+                    pass
+
+            # Fall back:
+            try:
+                content = unicode(content, self.encoding, errors='replace')
+            except TypeError:
+                pass
+
+        self._content_consumed = True
+        return content
+
+
+    def raise_for_status(self):
+        """Raises stored :class:`HTTPError` or :class:`URLError`, if one occurred."""
+
+        if self.error:
+            raise self.error
+
+        if (self.status_code >= 300) and (self.status_code < 400):
+            raise HTTPError('%s Redirection' % self.status_code)
+
+        elif (self.status_code >= 400) and (self.status_code < 500):
+            raise HTTPError('%s Client Error' % self.status_code)
+
+        elif (self.status_code >= 500) and (self.status_code < 600):
+            raise HTTPError('%s Server Error' % self.status_code)
+
+

requests/packages/__init__.py

@@ -1 +1,3 @@
-from . import poster
+from __future__ import absolute_import
+
+from . import urllib3

requests/packages/oreos/__init__.py

@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+
+from .core import dict_from_string

requests/packages/oreos/core.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+"""
+oreos.core
+~~~~~~~~~~
+
+The creamy white center.
+"""
+
+from .monkeys import SimpleCookie
+
+
+def dict_from_string(s):
+    """Returns a MultiDict with Cookies."""
+
+    cookies = dict()
+
+    c = SimpleCookie()
+    c.load(s)
+
+    for k,v in c.items():
+        cookies.update({k: v.value})
+
+    return cookies

requests/packages/oreos/monkeys.py

@@ -0,0 +1,770 @@
+# -*- coding: utf-8 -*-
+
+"""
+oreos.monkeys
+~~~~~~~~~~~~~
+
+Monkeypatches.
+"""
+#!/usr/bin/env python
+#
+
+####
+# Copyright 2000 by Timothy O'Malley <timo@alum.mit.edu>
+#
+#                All Rights Reserved
+#
+# Permission to use, copy, modify, and distribute this software
+# and its documentation for any purpose and without fee is hereby
+# granted, provided that the above copyright notice appear in all
+# copies and that both that copyright notice and this permission
+# notice appear in supporting documentation, and that the name of
+# Timothy O'Malley  not be used in advertising or publicity
+# pertaining to distribution of the software without specific, written
+# prior permission.
+#
+# Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+# SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+# AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR
+# ANY SPECIAL, 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.
+#
+####
+#
+# Id: Cookie.py,v 2.29 2000/08/23 05:28:49 timo Exp
+#   by Timothy O'Malley <timo@alum.mit.edu>
+#
+#  Cookie.py is a Python module for the handling of HTTP
+#  cookies as a Python dictionary.  See RFC 2109 for more
+#  information on cookies.
+#
+#  The original idea to treat Cookies as a dictionary came from
+#  Dave Mitchell (davem@magnet.com) in 1995, when he released the
+#  first version of nscookie.py.
+#
+####
+
+r"""
+Here's a sample session to show how to use this module.
+At the moment, this is the only documentation.
+
+The Basics
+----------
+
+Importing is easy..
+
+   >>> import Cookie
+
+Most of the time you start by creating a cookie.  Cookies come in
+three flavors, each with slightly different encoding semantics, but
+more on that later.
+
+   >>> C = Cookie.SimpleCookie()
+   >>> C = Cookie.SerialCookie()
+   >>> C = Cookie.SmartCookie()
+
+[Note: Long-time users of Cookie.py will remember using
+Cookie.Cookie() to create an Cookie object.  Although deprecated, it
+is still supported by the code.  See the Backward Compatibility notes
+for more information.]
+
+Once you've created your Cookie, you can add values just as if it were
+a dictionary.
+
+   >>> C = Cookie.SmartCookie()
+   >>> C["fig"] = "newton"
+   >>> C["sugar"] = "wafer"
+   >>> C.output()
+   'Set-Cookie: fig=newton\r\nSet-Cookie: sugar=wafer'
+
+Notice that the printable representation of a Cookie is the
+appropriate format for a Set-Cookie: header.  This is the
+default behavior.  You can change the header and printed
+attributes by using the .output() function
+
+   >>> C = Cookie.SmartCookie()
+   >>> C["rocky"] = "road"
+   >>> C["rocky"]["path"] = "/cookie"
+   >>> print C.output(header="Cookie:")
+   Cookie: rocky=road; Path=/cookie
+   >>> print C.output(attrs=[], header="Cookie:")
+   Cookie: rocky=road
+
+The load() method of a Cookie extracts cookies from a string.  In a
+CGI script, you would use this method to extract the cookies from the
+HTTP_COOKIE environment variable.
+
+   >>> C = Cookie.SmartCookie()
+   >>> C.load("chips=ahoy; vienna=finger")
+   >>> C.output()
+   'Set-Cookie: chips=ahoy\r\nSet-Cookie: vienna=finger'
+
+The load() method is darn-tootin smart about identifying cookies
+within a string.  Escaped quotation marks, nested semicolons, and other
+such trickeries do not confuse it.
+
+   >>> C = Cookie.SmartCookie()
+   >>> C.load('keebler="E=everybody; L=\\"Loves\\"; fudge=\\012;";')
+   >>> print C
+   Set-Cookie: keebler="E=everybody; L=\"Loves\"; fudge=\012;"
+
+Each element of the Cookie also supports all of the RFC 2109
+Cookie attributes.  Here's an example which sets the Path
+attribute.
+
+   >>> C = Cookie.SmartCookie()
+   >>> C["oreo"] = "doublestuff"
+   >>> C["oreo"]["path"] = "/"
+   >>> print C
+   Set-Cookie: oreo=doublestuff; Path=/
+
+Each dictionary element has a 'value' attribute, which gives you
+back the value associated with the key.
+
+   >>> C = Cookie.SmartCookie()
+   >>> C["twix"] = "none for you"
+   >>> C["twix"].value
+   'none for you'
+
+
+A Bit More Advanced
+-------------------
+
+As mentioned before, there are three different flavors of Cookie
+objects, each with different encoding/decoding semantics.  This
+section briefly discusses the differences.
+
+SimpleCookie
+
+The SimpleCookie expects that all values should be standard strings.
+Just to be sure, SimpleCookie invokes the str() builtin to convert
+the value to a string, when the values are set dictionary-style.
+
+   >>> C = Cookie.SimpleCookie()
+   >>> C["number"] = 7
+   >>> C["string"] = "seven"
+   >>> C["number"].value
+   '7'
+   >>> C["string"].value
+   'seven'
+   >>> C.output()
+   'Set-Cookie: number=7\r\nSet-Cookie: string=seven'
+
+
+SerialCookie
+
+The SerialCookie expects that all values should be serialized using
+cPickle (or pickle, if cPickle isn't available).  As a result of
+serializing, SerialCookie can save almost any Python object to a
+value, and recover the exact same object when the cookie has been
+returned.  (SerialCookie can yield some strange-looking cookie
+values, however.)
+
+   >>> C = Cookie.SerialCookie()
+   >>> C["number"] = 7
+   >>> C["string"] = "seven"
+   >>> C["number"].value
+   7
+   >>> C["string"].value
+   'seven'
+   >>> C.output()
+   'Set-Cookie: number="I7\\012."\r\nSet-Cookie: string="S\'seven\'\\012p1\\012."'
+
+Be warned, however, if SerialCookie cannot de-serialize a value (because
+it isn't a valid pickle'd object), IT WILL RAISE AN EXCEPTION.
+
+
+SmartCookie
+
+The SmartCookie combines aspects of each of the other two flavors.
+When setting a value in a dictionary-fashion, the SmartCookie will
+serialize (ala cPickle) the value *if and only if* it isn't a
+Python string.  String objects are *not* serialized.  Similarly,
+when the load() method parses out values, it attempts to de-serialize
+the value.  If it fails, then it fallsback to treating the value
+as a string.
+
+   >>> C = Cookie.SmartCookie()
+   >>> C["number"] = 7
+   >>> C["string"] = "seven"
+   >>> C["number"].value
+   7
+   >>> C["string"].value
+   'seven'
+   >>> C.output()
+   'Set-Cookie: number="I7\\012."\r\nSet-Cookie: string=seven'
+
+
+Backwards Compatibility
+-----------------------
+
+In order to keep compatibilty with earlier versions of Cookie.py,
+it is still possible to use Cookie.Cookie() to create a Cookie.  In
+fact, this simply returns a SmartCookie.
+
+   >>> C = Cookie.Cookie()
+   >>> print C.__class__.__name__
+   SmartCookie
+
+
+Finis.
+"""  #"
+#     ^
+#     |----helps out font-lock
+
+#
+# Import our required modules
+#
+import string
+
+try:
+    from cPickle import dumps, loads
+except ImportError:
+    from pickle import dumps, loads
+
+import re, warnings
+
+__all__ = ["CookieError","BaseCookie","SimpleCookie","SerialCookie",
+           "SmartCookie","Cookie"]
+
+_nulljoin = ''.join
+_semispacejoin = '; '.join
+_spacejoin = ' '.join
+
+#
+# Define an exception visible to External modules
+#
+class CookieError(Exception):
+    pass
+
+
+# These quoting routines conform to the RFC2109 specification, which in
+# turn references the character definitions from RFC2068.  They provide
+# a two-way quoting algorithm.  Any non-text character is translated
+# into a 4 character sequence: a forward-slash followed by the
+# three-digit octal equivalent of the character.  Any '\' or '"' is
+# quoted with a preceeding '\' slash.
+#
+# These are taken from RFC2068 and RFC2109.
+#       _LegalChars       is the list of chars which don't require "'s
+#       _Translator       hash-table for fast quoting
+#
+_LegalChars       = string.ascii_letters + string.digits + "!#$%&'*+-.^_`|~[]_"
+_Translator       = {
+    '\000' : '\\000',  '\001' : '\\001',  '\002' : '\\002',
+    '\003' : '\\003',  '\004' : '\\004',  '\005' : '\\005',
+    '\006' : '\\006',  '\007' : '\\007',  '\010' : '\\010',
+    '\011' : '\\011',  '\012' : '\\012',  '\013' : '\\013',
+    '\014' : '\\014',  '\015' : '\\015',  '\016' : '\\016',
+    '\017' : '\\017',  '\020' : '\\020',  '\021' : '\\021',
+    '\022' : '\\022',  '\023' : '\\023',  '\024' : '\\024',
+    '\025' : '\\025',  '\026' : '\\026',  '\027' : '\\027',
+    '\030' : '\\030',  '\031' : '\\031',  '\032' : '\\032',
+    '\033' : '\\033',  '\034' : '\\034',  '\035' : '\\035',
+    '\036' : '\\036',  '\037' : '\\037',
+
+    # Because of the way browsers really handle cookies (as opposed
+    # to what the RFC says) we also encode , and ;
+
+    ',' : '\\054', ';' : '\\073',
+
+    '"' : '\\"',       '\\' : '\\\\',
+
+    '\177' : '\\177',  '\200' : '\\200',  '\201' : '\\201',
+    '\202' : '\\202',  '\203' : '\\203',  '\204' : '\\204',
+    '\205' : '\\205',  '\206' : '\\206',  '\207' : '\\207',
+    '\210' : '\\210',  '\211' : '\\211',  '\212' : '\\212',
+    '\213' : '\\213',  '\214' : '\\214',  '\215' : '\\215',
+    '\216' : '\\216',  '\217' : '\\217',  '\220' : '\\220',
+    '\221' : '\\221',  '\222' : '\\222',  '\223' : '\\223',
+    '\224' : '\\224',  '\225' : '\\225',  '\226' : '\\226',
+    '\227' : '\\227',  '\230' : '\\230',  '\231' : '\\231',
+    '\232' : '\\232',  '\233' : '\\233',  '\234' : '\\234',
+    '\235' : '\\235',  '\236' : '\\236',  '\237' : '\\237',
+    '\240' : '\\240',  '\241' : '\\241',  '\242' : '\\242',
+    '\243' : '\\243',  '\244' : '\\244',  '\245' : '\\245',
+    '\246' : '\\246',  '\247' : '\\247',  '\250' : '\\250',
+    '\251' : '\\251',  '\252' : '\\252',  '\253' : '\\253',
+    '\254' : '\\254',  '\255' : '\\255',  '\256' : '\\256',
+    '\257' : '\\257',  '\260' : '\\260',  '\261' : '\\261',
+    '\262' : '\\262',  '\263' : '\\263',  '\264' : '\\264',
+    '\265' : '\\265',  '\266' : '\\266',  '\267' : '\\267',
+    '\270' : '\\270',  '\271' : '\\271',  '\272' : '\\272',
+    '\273' : '\\273',  '\274' : '\\274',  '\275' : '\\275',
+    '\276' : '\\276',  '\277' : '\\277',  '\300' : '\\300',
+    '\301' : '\\301',  '\302' : '\\302',  '\303' : '\\303',
+    '\304' : '\\304',  '\305' : '\\305',  '\306' : '\\306',
+    '\307' : '\\307',  '\310' : '\\310',  '\311' : '\\311',
+    '\312' : '\\312',  '\313' : '\\313',  '\314' : '\\314',
+    '\315' : '\\315',  '\316' : '\\316',  '\317' : '\\317',
+    '\320' : '\\320',  '\321' : '\\321',  '\322' : '\\322',
+    '\323' : '\\323',  '\324' : '\\324',  '\325' : '\\325',
+    '\326' : '\\326',  '\327' : '\\327',  '\330' : '\\330',
+    '\331' : '\\331',  '\332' : '\\332',  '\333' : '\\333',
+    '\334' : '\\334',  '\335' : '\\335',  '\336' : '\\336',
+    '\337' : '\\337',  '\340' : '\\340',  '\341' : '\\341',
+    '\342' : '\\342',  '\343' : '\\343',  '\344' : '\\344',
+    '\345' : '\\345',  '\346' : '\\346',  '\347' : '\\347',
+    '\350' : '\\350',  '\351' : '\\351',  '\352' : '\\352',
+    '\353' : '\\353',  '\354' : '\\354',  '\355' : '\\355',
+    '\356' : '\\356',  '\357' : '\\357',  '\360' : '\\360',
+    '\361' : '\\361',  '\362' : '\\362',  '\363' : '\\363',
+    '\364' : '\\364',  '\365' : '\\365',  '\366' : '\\366',
+    '\367' : '\\367',  '\370' : '\\370',  '\371' : '\\371',
+    '\372' : '\\372',  '\373' : '\\373',  '\374' : '\\374',
+    '\375' : '\\375',  '\376' : '\\376',  '\377' : '\\377'
+    }
+
+_idmap = ''.join(chr(x) for x in xrange(256))
+
+def _quote(str, LegalChars=_LegalChars,
+           idmap=_idmap, translate=string.translate):
+    #
+    # If the string does not need to be double-quoted,
+    # then just return the string.  Otherwise, surround
+    # the string in doublequotes and precede quote (with a \)
+    # special characters.
+    #
+    if "" == translate(str, idmap, LegalChars):
+        return str
+    else:
+        return '"' + _nulljoin( map(_Translator.get, str, str) ) + '"'
+# end _quote
+
+
+_OctalPatt = re.compile(r"\\[0-3][0-7][0-7]")
+_QuotePatt = re.compile(r"[\\].")
+
+def _unquote(str):
+    # If there aren't any doublequotes,
+    # then there can't be any special characters.  See RFC 2109.
+    if  len(str) < 2:
+        return str
+    if str[0] != '"' or str[-1] != '"':
+        return str
+
+    # We have to assume that we must decode this string.
+    # Down to work.
+
+    # Remove the "s
+    str = str[1:-1]
+
+    # Check for special sequences.  Examples:
+    #    \012 --> \n
+    #    \"   --> "
+    #
+    i = 0
+    n = len(str)
+    res = []
+    while 0 <= i < n:
+        Omatch = _OctalPatt.search(str, i)
+        Qmatch = _QuotePatt.search(str, i)
+        if not Omatch and not Qmatch:              # Neither matched
+            res.append(str[i:])
+            break
+        # else:
+        j = k = -1
+        if Omatch: j = Omatch.start(0)
+        if Qmatch: k = Qmatch.start(0)
+        if Qmatch and ( not Omatch or k < j ):     # QuotePatt matched
+            res.append(str[i:k])
+            res.append(str[k+1])
+            i = k+2
+        else:                                      # OctalPatt matched
+            res.append(str[i:j])
+            res.append( chr( int(str[j+1:j+4], 8) ) )
+            i = j+4
+    return _nulljoin(res)
+# end _unquote
+
+# The _getdate() routine is used to set the expiration time in
+# the cookie's HTTP header.      By default, _getdate() returns the
+# current time in the appropriate "expires" format for a
+# Set-Cookie header.     The one optional argument is an offset from
+# now, in seconds.      For example, an offset of -3600 means "one hour ago".
+# The offset may be a floating point number.
+#
+
+_weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
+
+_monthname = [None,
+              'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+              'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+
+def _getdate(future=0, weekdayname=_weekdayname, monthname=_monthname):
+    from time import gmtime, time
+    now = time()
+    year, month, day, hh, mm, ss, wd, y, z = gmtime(now + future)
+    return "%s, %02d-%3s-%4d %02d:%02d:%02d GMT" % \
+           (weekdayname[wd], day, monthname[month], year, hh, mm, ss)
+
+
+#
+# A class to hold ONE key,value pair.
+# In a cookie, each such pair may have several attributes.
+#       so this class is used to keep the attributes associated
+#       with the appropriate key,value pair.
+# This class also includes a coded_value attribute, which
+#       is used to hold the network representation of the
+#       value.  This is most useful when Python objects are
+#       pickled for network transit.
+#
+
+class Morsel(dict):
+    # RFC 2109 lists these attributes as reserved:
+    #   path       comment         domain
+    #   max-age    secure      version
+    #
+    # For historical reasons, these attributes are also reserved:
+    #   expires
+    #
+    # This is an extension from Microsoft:
+    #   httponly
+    #
+    # This dictionary provides a mapping from the lowercase
+    # variant on the left to the appropriate traditional
+    # formatting on the right.
+    _reserved = { "expires" : "expires",
+                   "path"        : "Path",
+                   "comment" : "Comment",
+                   "domain"      : "Domain",
+                   "max-age" : "Max-Age",
+                   "secure"      : "secure",
+                   "httponly"  : "httponly",
+                   "version" : "Version",
+                   }
+
+    def __init__(self):
+        # Set defaults
+        self.key = self.value = self.coded_value = None
+
+        # Set default attributes
+        for K in self._reserved:
+            dict.__setitem__(self, K, "")
+    # end __init__
+
+    def __setitem__(self, K, V):
+        K = K.lower()
+        if not K in self._reserved:
+            raise CookieError("Invalid Attribute %s" % K)
+        dict.__setitem__(self, K, V)
+    # end __setitem__
+
+    def isReservedKey(self, K):
+        return K.lower() in self._reserved
+    # end isReservedKey
+
+    def set(self, key, val, coded_val,
+            LegalChars=_LegalChars,
+            idmap=_idmap, translate=string.translate):
+        # First we verify that the key isn't a reserved word
+        # Second we make sure it only contains legal characters
+        if key.lower() in self._reserved:
+            raise CookieError("Attempt to set a reserved key: %s" % key)
+        if "" != translate(key, idmap, LegalChars):
+            raise CookieError("Illegal key value: %s" % key)
+
+        # It's a good key, so save it.
+        self.key                 = key
+        self.value               = val
+        self.coded_value         = coded_val
+    # end set
+
+    def output(self, attrs=None, header = "Set-Cookie:"):
+        return "%s %s" % ( header, self.OutputString(attrs) )
+
+    __str__ = output
+
+    def __repr__(self):
+        return '<%s: %s=%s>' % (self.__class__.__name__,
+                                self.key, repr(self.value) )
+
+    def js_output(self, attrs=None):
+        # Print javascript
+        return """
+        <script type="text/javascript">
+        <!-- begin hiding
+        document.cookie = \"%s\";
+        // end hiding -->
+        </script>
+        """ % ( self.OutputString(attrs).replace('"',r'\"'), )
+    # end js_output()
+
+    def OutputString(self, attrs=None):
+        # Build up our result
+        #
+        result = []
+        RA = result.append
+
+        # First, the key=value pair
+        RA("%s=%s" % (self.key, self.coded_value))
+
+        # Now add any defined attributes
+        if attrs is None:
+            attrs = self._reserved
+        items = self.items()
+        items.sort()
+        for K,V in items:
+            if V == "": continue
+            if K not in attrs: continue
+            if K == "expires" and type(V) == type(1):
+                RA("%s=%s" % (self._reserved[K], _getdate(V)))
+            elif K == "max-age" and type(V) == type(1):
+                RA("%s=%d" % (self._reserved[K], V))
+            elif K == "secure":
+                RA(str(self._reserved[K]))
+            elif K == "httponly":
+                RA(str(self._reserved[K]))
+            else:
+                RA("%s=%s" % (self._reserved[K], V))
+
+        # Return the result
+        return _semispacejoin(result)
+    # end OutputString
+# end Morsel class
+
+
+
+#
+# Pattern for finding cookie
+#
+# This used to be strict parsing based on the RFC2109 and RFC2068
+# specifications.  I have since discovered that MSIE 3.0x doesn't
+# follow the character rules outlined in those specs.  As a
+# result, the parsing rules here are less strict.
+#
+
+_LegalCharsPatt  = r"[\w\d!#%&'~_`><@,:/\$\*\+\-\.\^\|\)\(\?\}\{\=\[\]\_]"
+
+_CookiePattern = re.compile(
+    r"(?x)"                       # This is a Verbose pattern
+    r"(?P<key>"                   # Start of group 'key'
+    ""+ _LegalCharsPatt +"+?"     # Any word of at least one letter, nongreedy
+    r")"                          # End of group 'key'
+    r"\s*=\s*"                    # Equal Sign
+    r"(?P<val>"                   # Start of group 'val'
+    r'"(?:[^\\"]|\\.)*"'            # Any doublequoted string
+    r"|"                            # or
+    r"\w{3},\s[\w\d-]{9,11}\s[\d:]{8}\sGMT" # Special case for "expires" attr
+    r"|"                            # or
+    ""+ _LegalCharsPatt +"*"        # Any word or empty string
+    r")"                          # End of group 'val'
+    r"\s*;?"                      # Probably ending in a semi-colon
+    )
+
+
+# At long last, here is the cookie class.
+#   Using this class is almost just like using a dictionary.
+# See this module's docstring for example usage.
+#
+class BaseCookie(dict):
+    # A container class for a set of Morsels
+    #
+
+    def value_decode(self, val):
+        """real_value, coded_value = value_decode(STRING)
+        Called prior to setting a cookie's value from the network
+        representation.  The VALUE is the value read from HTTP
+        header.
+        Override this function to modify the behavior of cookies.
+        """
+        return val, val
+    # end value_encode
+
+    def value_encode(self, val):
+        """real_value, coded_value = value_encode(VALUE)
+        Called prior to setting a cookie's value from the dictionary
+        representation.  The VALUE is the value being assigned.
+        Override this function to modify the behavior of cookies.
+        """
+        strval = str(val)
+        return strval, strval
+    # end value_encode
+
+    def __init__(self, input=None):
+        if input: self.load(input)
+    # end __init__
+
+    def __set(self, key, real_value, coded_value):
+        """Private method for setting a cookie's value"""
+        M = self.get(key, Morsel())
+        M.set(key, real_value, coded_value)
+        dict.__setitem__(self, key, M)
+    # end __set
+
+    def __setitem__(self, key, value):
+        """Dictionary style assignment."""
+        rval, cval = self.value_encode(value)
+        self.__set(key, rval, cval)
+    # end __setitem__
+
+    def output(self, attrs=None, header="Set-Cookie:", sep="\015\012"):
+        """Return a string suitable for HTTP."""
+        result = []
+        items = self.items()
+        items.sort()
+        for K,V in items:
+            result.append( V.output(attrs, header) )
+        return sep.join(result)
+    # end output
+
+    __str__ = output
+
+    def __repr__(self):
+        L = []
+        items = self.items()
+        items.sort()
+        for K,V in items:
+            L.append( '%s=%s' % (K,repr(V.value) ) )
+        return '<%s: %s>' % (self.__class__.__name__, _spacejoin(L))
+
+    def js_output(self, attrs=None):
+        """Return a string suitable for JavaScript."""
+        result = []
+        items = self.items()
+        items.sort()
+        for K,V in items:
+            result.append( V.js_output(attrs) )
+        return _nulljoin(result)
+    # end js_output
+
+    def load(self, rawdata):
+        """Load cookies from a string (presumably HTTP_COOKIE) or
+        from a dictionary.  Loading cookies from a dictionary 'd'
+        is equivalent to calling:
+            map(Cookie.__setitem__, d.keys(), d.values())
+        """
+        if type(rawdata) == type(""):
+            self.__ParseString(rawdata)
+        else:
+            # self.update() wouldn't call our custom __setitem__
+            for k, v in rawdata.items():
+                self[k] = v
+        return
+    # end load()
+
+    def __ParseString(self, str, patt=_CookiePattern):
+        i = 0            # Our starting point
+        n = len(str)     # Length of string
+        M = None         # current morsel
+
+        while 0 <= i < n:
+            # Start looking for a cookie
+            match = patt.search(str, i)
+            if not match: break          # No more cookies
+
+            K,V = match.group("key"), match.group("val")
+            i = match.end(0)
+
+            # Parse the key, value in case it's metainfo
+            if K[0] == "$":
+                # We ignore attributes which pertain to the cookie
+                # mechanism as a whole.  See RFC 2109.
+                # (Does anyone care?)
+                if M:
+                    M[ K[1:] ] = V
+            elif K.lower() in Morsel._reserved:
+                if M:
+                    M[ K ] = _unquote(V)
+            else:
+                rval, cval = self.value_decode(V)
+                self.__set(K, rval, cval)
+                M = self[K]
+    # end __ParseString
+# end BaseCookie class
+
+class SimpleCookie(BaseCookie):
+    """SimpleCookie
+    SimpleCookie supports strings as cookie values.  When setting
+    the value using the dictionary assignment notation, SimpleCookie
+    calls the builtin str() to convert the value to a string.  Values
+    received from HTTP are kept as strings.
+    """
+    def value_decode(self, val):
+        return _unquote( val ), val
+    def value_encode(self, val):
+        strval = str(val)
+        return strval, _quote( strval )
+# end SimpleCookie
+
+class SerialCookie(BaseCookie):
+    """SerialCookie
+    SerialCookie supports arbitrary objects as cookie values. All
+    values are serialized (using cPickle) before being sent to the
+    client.  All incoming values are assumed to be valid Pickle
+    representations.  IF AN INCOMING VALUE IS NOT IN A VALID PICKLE
+    FORMAT, THEN AN EXCEPTION WILL BE RAISED.
+
+    Note: Large cookie values add overhead because they must be
+    retransmitted on every HTTP transaction.
+
+    Note: HTTP has a 2k limit on the size of a cookie.  This class
+    does not check for this limit, so be careful!!!
+    """
+    def __init__(self, input=None):
+        warnings.warn("SerialCookie class is insecure; do not use it",
+                      DeprecationWarning)
+        BaseCookie.__init__(self, input)
+    # end __init__
+    def value_decode(self, val):
+        # This could raise an exception!
+        return loads( _unquote(val) ), val
+    def value_encode(self, val):
+        return val, _quote( dumps(val) )
+# end SerialCookie
+
+class SmartCookie(BaseCookie):
+    """SmartCookie
+    SmartCookie supports arbitrary objects as cookie values.  If the
+    object is a string, then it is quoted.  If the object is not a
+    string, however, then SmartCookie will use cPickle to serialize
+    the object into a string representation.
+
+    Note: Large cookie values add overhead because they must be
+    retransmitted on every HTTP transaction.
+
+    Note: HTTP has a 2k limit on the size of a cookie.  This class
+    does not check for this limit, so be careful!!!
+    """
+    def __init__(self, input=None):
+        warnings.warn("Cookie/SmartCookie class is insecure; do not use it",
+                      DeprecationWarning)
+        BaseCookie.__init__(self, input)
+    # end __init__
+    def value_decode(self, val):
+        strval = _unquote(val)
+        try:
+            return loads(strval), val
+        except:
+            return strval, val
+    def value_encode(self, val):
+        if type(val) == type(""):
+            return val, _quote(val)
+        else:
+            return val, _quote( dumps(val) )
+# end SmartCookie
+
+
+###########################################################
+# Backwards Compatibility:  Don't break any existing code!
+
+# We provide Cookie() as an alias for SmartCookie()
+Cookie = SmartCookie
+
+#
+###########################################################
+
+def _test():
+    import doctest, Cookie
+    return doctest.testmod(Cookie)
+
+if __name__ == "__main__":
+    _test()
+
+
+#Local Variables:
+#tab-width: 4
+#end:

requests/packages/oreos/structures.py

@@ -0,0 +1,399 @@
+# -*- coding: utf-8 -*-
+
+"""
+oreos.sructures
+~~~~~~~~~~~~~~~
+
+The plastic blue packaging.
+
+This is mostly directly stolen from mitsuhiko/werkzeug.
+"""
+
+__all__ = ('MultiDict',)
+
+class _Missing(object):
+
+    def __repr__(self):
+        return 'no value'
+
+    def __reduce__(self):
+        return '_missing'
+
+_missing = _Missing()
+
+
+
+def iter_multi_items(mapping):
+    """Iterates over the items of a mapping yielding keys and values
+    without dropping any from more complex structures.
+    """
+    if isinstance(mapping, MultiDict):
+        for item in mapping.iteritems(multi=True):
+            yield item
+    elif isinstance(mapping, dict):
+        for key, value in mapping.iteritems():
+            if isinstance(value, (tuple, list)):
+                for value in value:
+                    yield key, value
+            else:
+                yield key, value
+    else:
+        for item in mapping:
+            yield item
+
+
+
+class TypeConversionDict(dict):
+    """Works like a regular dict but the :meth:`get` method can perform
+    type conversions.  :class:`MultiDict` and :class:`CombinedMultiDict`
+    are subclasses of this class and provide the same feature.
+
+    .. versionadded:: 0.5
+    """
+
+    def get(self, key, default=None, type=None):
+        """Return the default value if the requested data doesn't exist.
+        If `type` is provided and is a callable it should convert the value,
+        return it or raise a :exc:`ValueError` if that is not possible.  In
+        this case the function will return the default as if the value was not
+        found:
+
+        >>> d = TypeConversionDict(foo='42', bar='blub')
+        >>> d.get('foo', type=int)
+        42
+        >>> d.get('bar', -1, type=int)
+        -1
+
+        :param key: The key to be looked up.
+        :param default: The default value to be returned if the key can't
+                        be looked up.  If not further specified `None` is
+                        returned.
+        :param type: A callable that is used to cast the value in the
+                     :class:`MultiDict`.  If a :exc:`ValueError` is raised
+                     by this callable the default value is returned.
+        """
+        try:
+            rv = self[key]
+            if type is not None:
+                rv = type(rv)
+        except (KeyError, ValueError):
+            rv = default
+        return rv
+
+
+class MultiDict(TypeConversionDict):
+    """A :class:`MultiDict` is a dictionary subclass customized to deal with
+    multiple values for the same key which is for example used by the parsing
+    functions in the wrappers.  This is necessary because some HTML form
+    elements pass multiple values for the same key.
+
+    :class:`MultiDict` implements all standard dictionary methods.
+    Internally, it saves all values for a key as a list, but the standard dict
+    access methods will only return the first value for a key. If you want to
+    gain access to the other values, too, you have to use the `list` methods as
+    explained below.
+
+    Basic Usage:
+
+    >>> d = MultiDict([('a', 'b'), ('a', 'c')])
+    >>> d
+    MultiDict([('a', 'b'), ('a', 'c')])
+    >>> d['a']
+    'b'
+    >>> d.getlist('a')
+    ['b', 'c']
+    >>> 'a' in d
+    True
+
+    It behaves like a normal dict thus all dict functions will only return the
+    first value when multiple values for one key are found.
+
+    From Werkzeug 0.3 onwards, the `KeyError` raised by this class is also a
+    subclass of the :exc:`~exceptions.BadRequest` HTTP exception and will
+    render a page for a ``400 BAD REQUEST`` if caught in a catch-all for HTTP
+    exceptions.
+
+    A :class:`MultiDict` can be constructed from an iterable of
+    ``(key, value)`` tuples, a dict, a :class:`MultiDict` or from Werkzeug 0.2
+    onwards some keyword parameters.
+
+    :param mapping: the initial value for the :class:`MultiDict`.  Either a
+                    regular dict, an iterable of ``(key, value)`` tuples
+                    or `None`.
+    """
+
+    def __init__(self, mapping=None):
+        if isinstance(mapping, MultiDict):
+            dict.__init__(self, ((k, l[:]) for k, l in mapping.iterlists()))
+        elif isinstance(mapping, dict):
+            tmp = {}
+            for key, value in mapping.iteritems():
+                if isinstance(value, (tuple, list)):
+                    value = list(value)
+                else:
+                    value = [value]
+                tmp[key] = value
+            dict.__init__(self, tmp)
+        else:
+            tmp = {}
+            for key, value in mapping or ():
+                tmp.setdefault(key, []).append(value)
+            dict.__init__(self, tmp)
+
+    def __getstate__(self):
+        return dict(self.lists())
+
+    def __setstate__(self, value):
+        dict.clear(self)
+        dict.update(self, value)
+
+    def __iter__(self):
+        return self.iterkeys()
+
+    def __getitem__(self, key):
+        """Return the first data value for this key;
+        raises KeyError if not found.
+
+        :param key: The key to be looked up.
+        :raise KeyError: if the key does not exist.
+        """
+        if key in self:
+            return dict.__getitem__(self, key)[0]
+        raise KeyError(key)
+
+    def __setitem__(self, key, value):
+        """Like :meth:`add` but removes an existing key first.
+
+        :param key: the key for the value.
+        :param value: the value to set.
+        """
+        dict.__setitem__(self, key, [value])
+
+    def add(self, key, value):
+        """Adds a new value for the key.
+
+        .. versionadded:: 0.6
+
+        :param key: the key for the value.
+        :param value: the value to add.
+        """
+        dict.setdefault(self, key, []).append(value)
+
+    def getlist(self, key, type=None):
+        """Return the list of items for a given key. If that key is not in the
+        `MultiDict`, the return value will be an empty list.  Just as `get`
+        `getlist` accepts a `type` parameter.  All items will be converted
+        with the callable defined there.
+
+        :param key: The key to be looked up.
+        :param type: A callable that is used to cast the value in the
+                     :class:`MultiDict`.  If a :exc:`ValueError` is raised
+                     by this callable the value will be removed from the list.
+        :return: a :class:`list` of all the values for the key.
+        """
+        try:
+            rv = dict.__getitem__(self, key)
+        except KeyError:
+            return []
+        if type is None:
+            return list(rv)
+        result = []
+        for item in rv:
+            try:
+                result.append(type(item))
+            except ValueError:
+                pass
+        return result
+
+    def setlist(self, key, new_list):
+        """Remove the old values for a key and add new ones.  Note that the list
+        you pass the values in will be shallow-copied before it is inserted in
+        the dictionary.
+
+        >>> d = MultiDict()
+        >>> d.setlist('foo', ['1', '2'])
+        >>> d['foo']
+        '1'
+        >>> d.getlist('foo')
+        ['1', '2']
+
+        :param key: The key for which the values are set.
+        :param new_list: An iterable with the new values for the key.  Old values
+                         are removed first.
+        """
+        dict.__setitem__(self, key, list(new_list))
+
+    def setdefault(self, key, default=None):
+        """Returns the value for the key if it is in the dict, otherwise it
+        returns `default` and sets that value for `key`.
+
+        :param key: The key to be looked up.
+        :param default: The default value to be returned if the key is not
+                        in the dict.  If not further specified it's `None`.
+        """
+        if key not in self:
+            self[key] = default
+        else:
+            default = self[key]
+        return default
+
+    def setlistdefault(self, key, default_list=None):
+        """Like `setdefault` but sets multiple values.  The list returned
+        is not a copy, but the list that is actually used internally.  This
+        means that you can put new values into the dict by appending items
+        to the list:
+
+        >>> d = MultiDict({"foo": 1})
+        >>> d.setlistdefault("foo").extend([2, 3])
+        >>> d.getlist("foo")
+        [1, 2, 3]
+
+        :param key: The key to be looked up.
+        :param default: An iterable of default values.  It is either copied
+                        (in case it was a list) or converted into a list
+                        before returned.
+        :return: a :class:`list`
+        """
+        if key not in self:
+            default_list = list(default_list or ())
+            dict.__setitem__(self, key, default_list)
+        else:
+            default_list = dict.__getitem__(self, key)
+        return default_list
+
+    def items(self, multi=False):
+        """Return a list of ``(key, value)`` pairs.
+
+        :param multi: If set to `True` the list returned will have a
+                      pair for each value of each key.  Otherwise it
+                      will only contain pairs for the first value of
+                      each key.
+
+        :return: a :class:`list`
+        """
+        return list(self.iteritems(multi))
+
+    def lists(self):
+        """Return a list of ``(key, values)`` pairs, where values is the list of
+        all values associated with the key.
+
+        :return: a :class:`list`
+        """
+        return list(self.iterlists())
+
+    def values(self):
+        """Returns a list of the first value on every key's value list.
+
+        :return: a :class:`list`.
+        """
+        return [self[key] for key in self.iterkeys()]
+
+    def listvalues(self):
+        """Return a list of all values associated with a key.  Zipping
+        :meth:`keys` and this is the same as calling :meth:`lists`:
+
+        >>> d = MultiDict({"foo": [1, 2, 3]})
+        >>> zip(d.keys(), d.listvalues()) == d.lists()
+        True
+
+        :return: a :class:`list`
+        """
+        return list(self.iterlistvalues())
+
+    def iteritems(self, multi=False):
+        """Like :meth:`items` but returns an iterator."""
+        for key, values in dict.iteritems(self):
+            if multi:
+                for value in values:
+                    yield key, value
+            else:
+                yield key, values[0]
+
+    def iterlists(self):
+        """Like :meth:`items` but returns an iterator."""
+        for key, values in dict.iteritems(self):
+            yield key, list(values)
+
+    def itervalues(self):
+        """Like :meth:`values` but returns an iterator."""
+        for values in dict.itervalues(self):
+            yield values[0]
+
+    def iterlistvalues(self):
+        """Like :meth:`listvalues` but returns an iterator."""
+        return dict.itervalues(self)
+
+    def copy(self):
+        """Return a shallow copy of this object."""
+        return self.__class__(self)
+
+    def to_dict(self, flat=True):
+        """Return the contents as regular dict.  If `flat` is `True` the
+        returned dict will only have the first item present, if `flat` is
+        `False` all values will be returned as lists.
+
+        :param flat: If set to `False` the dict returned will have lists
+                     with all the values in it.  Otherwise it will only
+                     contain the first value for each key.
+        :return: a :class:`dict`
+        """
+        if flat:
+            return dict(self.iteritems())
+        return dict(self.lists())
+
+    def update(self, other_dict):
+        """update() extends rather than replaces existing key lists."""
+        for key, value in iter_multi_items(other_dict):
+            MultiDict.add(self, key, value)
+
+    def pop(self, key, default=_missing):
+        """Pop the first item for a list on the dict.  Afterwards the
+        key is removed from the dict, so additional values are discarded:
+
+        >>> d = MultiDict({"foo": [1, 2, 3]})
+        >>> d.pop("foo")
+        1
+        >>> "foo" in d
+        False
+
+        :param key: the key to pop.
+        :param default: if provided the value to return if the key was
+                        not in the dictionary.
+        """
+        try:
+            return dict.pop(self, key)[0]
+        except KeyError, e:
+            if default is not _missing:
+                return default
+            raise KeyError(str(e))
+
+    def popitem(self):
+        """Pop an item from the dict."""
+        try:
+            item = dict.popitem(self)
+            return (item[0], item[1][0])
+        except KeyError, e:
+            raise KeyError(str(e))
+
+    def poplist(self, key):
+        """Pop the list for a key from the dict.  If the key is not in the dict
+        an empty list is returned.
+
+        .. versionchanged:: 0.5
+           If the key does no longer exist a list is returned instead of
+           raising an error.
+        """
+        return dict.pop(self, key, [])
+
+    def popitemlist(self):
+        """Pop a ``(key, list)`` tuple from the dict."""
+        try:
+            return dict.popitem(self)
+        except KeyError, e:
+            raise KeyError(str(e))
+
+    def __copy__(self):
+        return self.copy()
+
+    def __repr__(self):
+        return '%s(%r)' % (self.__class__.__name__, self.items(multi=True))

requests/packages/poster/__init__.py

@@ -1,32 +0,0 @@
-# Copyright (c) 2010 Chris AtLee
-# 
-# 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.
-"""poster module
-
-Support for streaming HTTP uploads, and multipart/form-data encoding
-
-```poster.version``` is a 3-tuple of integers representing the version number.
-New releases of poster will always have a version number that compares greater
-than an older version of poster.
-New in version 0.6."""
-
-from . import streaminghttp
-from . import encode
-
-version = (0, 8, 0) # Thanks JP!

requests/packages/poster/encode.py

@@ -1,414 +0,0 @@
-"""multipart/form-data encoding module
-
-This module provides functions that faciliate encoding name/value pairs
-as multipart/form-data suitable for a HTTP POST or PUT request.
-
-multipart/form-data is the standard way to upload files over HTTP"""
-
-__all__ = ['gen_boundary', 'encode_and_quote', 'MultipartParam',
-        'encode_string', 'encode_file_header', 'get_body_size', 'get_headers',
-        'multipart_encode']
-
-try:
-    import uuid
-    def gen_boundary():
-        """Returns a random string to use as the boundary for a message"""
-        return uuid.uuid4().hex
-except ImportError:
-    import random, sha
-    def gen_boundary():
-        """Returns a random string to use as the boundary for a message"""
-        bits = random.getrandbits(160)
-        return sha.new(str(bits)).hexdigest()
-
-import urllib, re, os, mimetypes
-try:
-    from email.header import Header
-except ImportError:
-    # Python 2.4
-    from email.Header import Header
-
-def encode_and_quote(data):
-    """If ``data`` is unicode, return urllib.quote_plus(data.encode("utf-8"))
-    otherwise return urllib.quote_plus(data)"""
-    if data is None:
-        return None
-
-    if isinstance(data, unicode):
-        data = data.encode("utf-8")
-    return urllib.quote_plus(data)
-
-def _strify(s):
-    """If s is a unicode string, encode it to UTF-8 and return the results,
-    otherwise return str(s), or None if s is None"""
-    if s is None:
-        return None
-    if isinstance(s, unicode):
-        return s.encode("utf-8")
-    return str(s)
-
-class MultipartParam(object):
-    """Represents a single parameter in a multipart/form-data request
-
-    ``name`` is the name of this parameter.
-
-    If ``value`` is set, it must be a string or unicode object to use as the
-    data for this parameter.
-
-    If ``filename`` is set, it is what to say that this parameter's filename
-    is.  Note that this does not have to be the actual filename any local file.
-
-    If ``filetype`` is set, it is used as the Content-Type for this parameter.
-    If unset it defaults to "text/plain; charset=utf8"
-
-    If ``filesize`` is set, it specifies the length of the file ``fileobj``
-
-    If ``fileobj`` is set, it must be a file-like object that supports
-    .read().
-
-    Both ``value`` and ``fileobj`` must not be set, doing so will
-    raise a ValueError assertion.
-
-    If ``fileobj`` is set, and ``filesize`` is not specified, then
-    the file's size will be determined first by stat'ing ``fileobj``'s
-    file descriptor, and if that fails, by seeking to the end of the file,
-    recording the current position as the size, and then by seeking back to the
-    beginning of the file.
-
-    ``cb`` is a callable which will be called from iter_encode with (self,
-    current, total), representing the current parameter, current amount
-    transferred, and the total size.
-    """
-    def __init__(self, name, value=None, filename=None, filetype=None,
-                        filesize=None, fileobj=None, cb=None):
-        self.name = Header(name).encode()
-        self.value = _strify(value)
-        if filename is None:
-            self.filename = None
-        else:
-            if isinstance(filename, unicode):
-                # Encode with XML entities
-                self.filename = filename.encode("ascii", "xmlcharrefreplace")
-            else:
-                self.filename = str(filename)
-            self.filename = self.filename.encode("string_escape").\
-                    replace('"', '\\"')
-        self.filetype = _strify(filetype)
-
-        self.filesize = filesize
-        self.fileobj = fileobj
-        self.cb = cb
-
-        if self.value is not None and self.fileobj is not None:
-            raise ValueError("Only one of value or fileobj may be specified")
-
-        if fileobj is not None and filesize is None:
-            # Try and determine the file size
-            try:
-                self.filesize = os.fstat(fileobj.fileno()).st_size
-            except (OSError, AttributeError):
-                try:
-                    fileobj.seek(0, 2)
-                    self.filesize = fileobj.tell()
-                    fileobj.seek(0)
-                except:
-                    raise ValueError("Could not determine filesize")
-
-    def __cmp__(self, other):
-        attrs = ['name', 'value', 'filename', 'filetype', 'filesize', 'fileobj']
-        myattrs = [getattr(self, a) for a in attrs]
-        oattrs = [getattr(other, a) for a in attrs]
-        return cmp(myattrs, oattrs)
-
-    def reset(self):
-        if self.fileobj is not None:
-            self.fileobj.seek(0)
-        elif self.value is None:
-            raise ValueError("Don't know how to reset this parameter")
-
-    @classmethod
-    def from_file(cls, paramname, filename):
-        """Returns a new MultipartParam object constructed from the local
-        file at ``filename``.
-
-        ``filesize`` is determined by os.path.getsize(``filename``)
-
-        ``filetype`` is determined by mimetypes.guess_type(``filename``)[0]
-
-        ``filename`` is set to os.path.basename(``filename``)
-        """
-
-        return cls(paramname, filename=os.path.basename(filename),
-                filetype=mimetypes.guess_type(filename)[0],
-                filesize=os.path.getsize(filename),
-                fileobj=open(filename, "rb"))
-
-    @classmethod
-    def from_params(cls, params):
-        """Returns a list of MultipartParam objects from a sequence of
-        name, value pairs, MultipartParam instances,
-        or from a mapping of names to values
-
-        The values may be strings or file objects, or MultipartParam objects.
-        MultipartParam object names must match the given names in the
-        name,value pairs or mapping, if applicable."""
-        if hasattr(params, 'items'):
-            params = params.items()
-
-        retval = []
-        for item in params:
-            if isinstance(item, cls):
-                retval.append(item)
-                continue
-            name, value = item
-            if isinstance(value, cls):
-                assert value.name == name
-                retval.append(value)
-                continue
-            if hasattr(value, 'read'):
-                # Looks like a file object
-                filename = getattr(value, 'name', None)
-                if filename is not None:
-                    filetype = mimetypes.guess_type(filename)[0]
-                else:
-                    filetype = None
-
-                retval.append(cls(name=name, filename=filename,
-                    filetype=filetype, fileobj=value))
-            else:
-                retval.append(cls(name, value))
-        return retval
-
-    def encode_hdr(self, boundary):
-        """Returns the header of the encoding of this parameter"""
-        boundary = encode_and_quote(boundary)
-
-        headers = ["--%s" % boundary]
-
-        if self.filename:
-            disposition = 'form-data; name="%s"; filename="%s"' % (self.name,
-                    self.filename)
-        else:
-            disposition = 'form-data; name="%s"' % self.name
-
-        headers.append("Content-Disposition: %s" % disposition)
-
-        if self.filetype:
-            filetype = self.filetype
-        else:
-            filetype = "text/plain; charset=utf-8"
-
-        headers.append("Content-Type: %s" % filetype)
-
-        headers.append("")
-        headers.append("")
-
-        return "\r\n".join(headers)
-
-    def encode(self, boundary):
-        """Returns the string encoding of this parameter"""
-        if self.value is None:
-            value = self.fileobj.read()
-        else:
-            value = self.value
-
-        if re.search("^--%s$" % re.escape(boundary), value, re.M):
-            raise ValueError("boundary found in encoded string")
-
-        return "%s%s\r\n" % (self.encode_hdr(boundary), value)
-
-    def iter_encode(self, boundary, blocksize=4096):
-        """Yields the encoding of this parameter
-        If self.fileobj is set, then blocks of ``blocksize`` bytes are read and
-        yielded."""
-        total = self.get_size(boundary)
-        current = 0
-        if self.value is not None:
-            block = self.encode(boundary)
-            current += len(block)
-            yield block
-            if self.cb:
-                self.cb(self, current, total)
-        else:
-            block = self.encode_hdr(boundary)
-            current += len(block)
-            yield block
-            if self.cb:
-                self.cb(self, current, total)
-            last_block = ""
-            encoded_boundary = "--%s" % encode_and_quote(boundary)
-            boundary_exp = re.compile("^%s$" % re.escape(encoded_boundary),
-                    re.M)
-            while True:
-                block = self.fileobj.read(blocksize)
-                if not block:
-                    current += 2
-                    yield "\r\n"
-                    if self.cb:
-                        self.cb(self, current, total)
-                    break
-                last_block += block
-                if boundary_exp.search(last_block):
-                    raise ValueError("boundary found in file data")
-                last_block = last_block[-len(encoded_boundary)-2:]
-                current += len(block)
-                yield block
-                if self.cb:
-                    self.cb(self, current, total)
-
-    def get_size(self, boundary):
-        """Returns the size in bytes that this param will be when encoded
-        with the given boundary."""
-        if self.filesize is not None:
-            valuesize = self.filesize
-        else:
-            valuesize = len(self.value)
-
-        return len(self.encode_hdr(boundary)) + 2 + valuesize
-
-def encode_string(boundary, name, value):
-    """Returns ``name`` and ``value`` encoded as a multipart/form-data
-    variable.  ``boundary`` is the boundary string used throughout
-    a single request to separate variables."""
-
-    return MultipartParam(name, value).encode(boundary)
-
-def encode_file_header(boundary, paramname, filesize, filename=None,
-        filetype=None):
-    """Returns the leading data for a multipart/form-data field that contains
-    file data.
-
-    ``boundary`` is the boundary string used throughout a single request to
-    separate variables.
-
-    ``paramname`` is the name of the variable in this request.
-
-    ``filesize`` is the size of the file data.
-
-    ``filename`` if specified is the filename to give to this field.  This
-    field is only useful to the server for determining the original filename.
-
-    ``filetype`` if specified is the MIME type of this file.
-
-    The actual file data should be sent after this header has been sent.
-    """
-
-    return MultipartParam(paramname, filesize=filesize, filename=filename,
-            filetype=filetype).encode_hdr(boundary)
-
-def get_body_size(params, boundary):
-    """Returns the number of bytes that the multipart/form-data encoding
-    of ``params`` will be."""
-    size = sum(p.get_size(boundary) for p in MultipartParam.from_params(params))
-    return size + len(boundary) + 6
-
-def get_headers(params, boundary):
-    """Returns a dictionary with Content-Type and Content-Length headers
-    for the multipart/form-data encoding of ``params``."""
-    headers = {}
-    boundary = urllib.quote_plus(boundary)
-    headers['Content-Type'] = "multipart/form-data; boundary=%s" % boundary
-    headers['Content-Length'] = str(get_body_size(params, boundary))
-    return headers
-
-class multipart_yielder:
-    def __init__(self, params, boundary, cb):
-        self.params = params
-        self.boundary = boundary
-        self.cb = cb
-
-        self.i = 0
-        self.p = None
-        self.param_iter = None
-        self.current = 0
-        self.total = get_body_size(params, boundary)
-
-    def __iter__(self):
-        return self
-
-    def next(self):
-        """generator function to yield multipart/form-data representation
-        of parameters"""
-        if self.param_iter is not None:
-            try:
-                block = self.param_iter.next()
-                self.current += len(block)
-                if self.cb:
-                    self.cb(self.p, self.current, self.total)
-                return block
-            except StopIteration:
-                self.p = None
-                self.param_iter = None
-
-        if self.i is None:
-            raise StopIteration
-        elif self.i >= len(self.params):
-            self.param_iter = None
-            self.p = None
-            self.i = None
-            block = "--%s--\r\n" % self.boundary
-            self.current += len(block)
-            if self.cb:
-                self.cb(self.p, self.current, self.total)
-            return block
-
-        self.p = self.params[self.i]
-        self.param_iter = self.p.iter_encode(self.boundary)
-        self.i += 1
-        return self.next()
-
-    def reset(self):
-        self.i = 0
-        self.current = 0
-        for param in self.params:
-            param.reset()
-
-def multipart_encode(params, boundary=None, cb=None):
-    """Encode ``params`` as multipart/form-data.
-
-    ``params`` should be a sequence of (name, value) pairs or MultipartParam
-    objects, or a mapping of names to values.
-    Values are either strings parameter values, or file-like objects to use as
-    the parameter value.  The file-like objects must support .read() and either
-    .fileno() or both .seek() and .tell().
-
-    If ``boundary`` is set, then it as used as the MIME boundary.  Otherwise
-    a randomly generated boundary will be used.  In either case, if the
-    boundary string appears in the parameter values a ValueError will be
-    raised.
-
-    If ``cb`` is set, it should be a callback which will get called as blocks
-    of data are encoded.  It will be called with (param, current, total),
-    indicating the current parameter being encoded, the current amount encoded,
-    and the total amount to encode.
-
-    Returns a tuple of `datagen`, `headers`, where `datagen` is a
-    generator that will yield blocks of data that make up the encoded
-    parameters, and `headers` is a dictionary with the assoicated
-    Content-Type and Content-Length headers.
-
-    Examples:
-
-    >>> datagen, headers = multipart_encode( [("key", "value1"), ("key", "value2")] )
-    >>> s = "".join(datagen)
-    >>> assert "value2" in s and "value1" in s
-
-    >>> p = MultipartParam("key", "value2")
-    >>> datagen, headers = multipart_encode( [("key", "value1"), p] )
-    >>> s = "".join(datagen)
-    >>> assert "value2" in s and "value1" in s
-
-    >>> datagen, headers = multipart_encode( {"key": "value1"} )
-    >>> s = "".join(datagen)
-    >>> assert "value2" not in s and "value1" in s
-
-    """
-    if boundary is None:
-        boundary = gen_boundary()
-    else:
-        boundary = urllib.quote_plus(boundary)
-
-    headers = get_headers(params, boundary)
-    params = MultipartParam.from_params(params)
-
-    return multipart_yielder(params, boundary, cb), headers

requests/packages/poster/streaminghttp.py

@@ -1,197 +0,0 @@
-"""Streaming HTTP uploads module.
-
-This module extends the standard httplib and urllib2 objects so that
-iterable objects can be used in the body of HTTP requests.
-
-In most cases all one should have to do is call :func:`register_openers()`
-to register the new streaming http handlers which will take priority over
-the default handlers, and then you can use iterable objects in the body
-of HTTP requests.
-
-**N.B.** You must specify a Content-Length header if using an iterable object
-since there is no way to determine in advance the total size that will be
-yielded, and there is no way to reset an interator.
-
-Example usage:
-
->>> from StringIO import StringIO
->>> import urllib2, poster.streaminghttp
-
->>> opener = poster.streaminghttp.register_openers()
-
->>> s = "Test file data"
->>> f = StringIO(s)
-
->>> req = urllib2.Request("http://localhost:5000", f,
-...                       {'Content-Length': str(len(s))})
-"""
-
-import httplib, urllib2, socket
-from httplib import NotConnected
-
-__all__ = ['StreamingHTTPConnection', 'StreamingHTTPRedirectHandler',
-        'StreamingHTTPHandler', 'register_openers']
-
-if hasattr(httplib, 'HTTPS'):
-    __all__.extend(['StreamingHTTPSHandler', 'StreamingHTTPSConnection'])
-
-class _StreamingHTTPMixin:
-    """Mixin class for HTTP and HTTPS connections that implements a streaming
-    send method."""
-    def send(self, value):
-        """Send ``value`` to the server.
-
-        ``value`` can be a string object, a file-like object that supports
-        a .read() method, or an iterable object that supports a .next()
-        method.
-        """
-        # Based on python 2.6's httplib.HTTPConnection.send()
-        if self.sock is None:
-            if self.auto_open:
-                self.connect()
-            else:
-                raise NotConnected()
-
-        # send the data to the server. if we get a broken pipe, then close
-        # the socket. we want to reconnect when somebody tries to send again.
-        #
-        # NOTE: we DO propagate the error, though, because we cannot simply
-        #       ignore the error... the caller will know if they can retry.
-        if self.debuglevel > 0:
-            print "send:", repr(value)
-        try:
-            blocksize = 8192
-            if hasattr(value, 'read') :
-                if hasattr(value, 'seek'):
-                    value.seek(0)
-                if self.debuglevel > 0:
-                    print "sendIng a read()able"
-                data = value.read(blocksize)
-                while data:
-                    self.sock.sendall(data)
-                    data = value.read(blocksize)
-            elif hasattr(value, 'next'):
-                if hasattr(value, 'reset'):
-                    value.reset()
-                if self.debuglevel > 0:
-                    print "sendIng an iterable"
-                for data in value:
-                    self.sock.sendall(data)
-            else:
-                self.sock.sendall(value)
-        except socket.error, v:
-            if v[0] == 32:      # Broken pipe
-                self.close()
-            raise
-
-class StreamingHTTPConnection(_StreamingHTTPMixin, httplib.HTTPConnection):
-    """Subclass of `httplib.HTTPConnection` that overrides the `send()` method
-    to support iterable body objects"""
-
-class StreamingHTTPRedirectHandler(urllib2.HTTPRedirectHandler):
-    """Subclass of `urllib2.HTTPRedirectHandler` that overrides the
-    `redirect_request` method to properly handle redirected POST requests
-
-    This class is required because python 2.5's HTTPRedirectHandler does
-    not remove the Content-Type or Content-Length headers when requesting
-    the new resource, but the body of the original request is not preserved.
-    """
-
-    handler_order = urllib2.HTTPRedirectHandler.handler_order - 1
-
-    # From python2.6 urllib2's HTTPRedirectHandler
-    def redirect_request(self, req, fp, code, msg, headers, newurl):
-        """Return a Request or None in response to a redirect.
-
-        This is called by the http_error_30x methods when a
-        redirection response is received.  If a redirection should
-        take place, return a new Request to allow http_error_30x to
-        perform the redirect.  Otherwise, raise HTTPError if no-one
-        else should try to handle this url.  Return None if you can't
-        but another Handler might.
-        """
-        m = req.get_method()
-        if (code in (301, 302, 303, 307) and m in ("GET", "HEAD")
-            or code in (301, 302, 303) and m == "POST"):
-            # Strictly (according to RFC 2616), 301 or 302 in response
-            # to a POST MUST NOT cause a redirection without confirmation
-            # from the user (of urllib2, in this case).  In practice,
-            # essentially all clients do redirect in this case, so we
-            # do the same.
-            # be conciliant with URIs containing a space
-            newurl = newurl.replace(' ', '%20')
-            newheaders = dict((k, v) for k, v in req.headers.items()
-                              if k.lower() not in (
-                                  "content-length", "content-type")
-                             )
-            return urllib2.Request(newurl,
-                           headers=newheaders,
-                           origin_req_host=req.get_origin_req_host(),
-                           unverifiable=True)
-        else:
-            raise urllib2.HTTPError(req.get_full_url(), code, msg, headers, fp)
-
-class StreamingHTTPHandler(urllib2.HTTPHandler):
-    """Subclass of `urllib2.HTTPHandler` that uses
-    StreamingHTTPConnection as its http connection class."""
-
-    handler_order = urllib2.HTTPHandler.handler_order - 1
-
-    def http_open(self, req):
-        """Open a StreamingHTTPConnection for the given request"""
-        return self.do_open(StreamingHTTPConnection, req)
-
-    def http_request(self, req):
-        """Handle a HTTP request.  Make sure that Content-Length is specified
-        if we're using an interable value"""
-        # Make sure that if we're using an iterable object as the request
-        # body, that we've also specified Content-Length
-        if req.has_data():
-            data = req.get_data()
-            if hasattr(data, 'read') or hasattr(data, 'next'):
-                if not req.has_header('Content-length'):
-                    raise ValueError(
-                            "No Content-Length specified for iterable body")
-        return urllib2.HTTPHandler.do_request_(self, req)
-
-if hasattr(httplib, 'HTTPS'):
-    class StreamingHTTPSConnection(_StreamingHTTPMixin,
-            httplib.HTTPSConnection):
-        """Subclass of `httplib.HTTSConnection` that overrides the `send()`
-        method to support iterable body objects"""
-
-    class StreamingHTTPSHandler(urllib2.HTTPSHandler):
-        """Subclass of `urllib2.HTTPSHandler` that uses
-        StreamingHTTPSConnection as its http connection class."""
-
-        handler_order = urllib2.HTTPSHandler.handler_order - 1
-
-        def https_open(self, req):
-            return self.do_open(StreamingHTTPSConnection, req)
-
-        def https_request(self, req):
-            # Make sure that if we're using an iterable object as the request
-            # body, that we've also specified Content-Length
-            if req.has_data():
-                data = req.get_data()
-                if hasattr(data, 'read') or hasattr(data, 'next'):
-                    if not req.has_header('Content-length'):
-                        raise ValueError(
-                                "No Content-Length specified for iterable body")
-            return urllib2.HTTPSHandler.do_request_(self, req)
-
-
-def register_openers():
-    """Register the streaming http handlers in the global urllib2 default
-    opener object.
-
-    Returns the created OpenerDirector object."""
-    handlers = [StreamingHTTPHandler, StreamingHTTPRedirectHandler]
-    if hasattr(httplib, "HTTPS"):
-        handlers.append(StreamingHTTPSHandler)
-
-    opener = urllib2.build_opener(*handlers)
-
-    urllib2.install_opener(opener)
-
-    return opener

requests/packages/urllib3/__init__.py

@@ -0,0 +1,48 @@
+# urllib3/__init__.py
+# Copyright 2008-2011 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
+
+"""
+urllib3 - Thread-safe connection pooling and re-using.
+"""
+
+__author__ = 'Andrey Petrov (andrey.petrov@shazow.net)'
+__license__ = 'MIT'
+__version__ = '1.0.2'
+
+
+from .connectionpool import (
+    HTTPConnectionPool,
+    HTTPSConnectionPool,
+    connection_from_url,
+    get_host,
+    make_headers)
+
+
+from .exceptions import (
+    HTTPError,
+    MaxRetryError,
+    SSLError,
+    TimeoutError)
+
+from .poolmanager import PoolManager, ProxyManager, proxy_from_url
+from .response import HTTPResponse
+from .filepost import encode_multipart_formdata
+
+
+# Set default logging handler to avoid "No handler found" warnings.
+import logging
+try:
+    from logging import NullHandler
+except ImportError:
+    class NullHandler(logging.Handler):
+        def emit(self, record):
+            pass
+
+logging.getLogger(__name__).addHandler(NullHandler())
+
+# ... Clean up.
+del logging
+del NullHandler

requests/packages/urllib3/_collections.py

@@ -0,0 +1,131 @@
+# urllib3/_collections.py
+# Copyright 2008-2011 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 collections import deque
+
+from threading import RLock
+
+__all__ = ['RecentlyUsedContainer']
+
+
+class AccessEntry(object):
+    __slots__ = ('key', 'is_valid')
+
+    def __init__(self, key, is_valid=True):
+        self.key = key
+        self.is_valid = is_valid
+
+
+class RecentlyUsedContainer(dict):
+    """
+    Provides a dict-like that maintains up to ``maxsize`` keys while throwing
+    away the least-recently-used keys beyond ``maxsize``.
+    """
+
+    # If len(self.access_log) exceeds self._maxsize * CLEANUP_FACTOR, then we
+    # will attempt to cleanup the invalidated entries in the access_log
+    # datastructure during the next 'get' operation.
+    CLEANUP_FACTOR = 10
+
+    def __init__(self, maxsize=10):
+        self._maxsize = maxsize
+
+        self._container = {}
+
+        # We use a deque to to store our keys ordered by the last access.
+        self.access_log = deque()
+        self.access_log_lock = RLock()
+
+        # We look up the access log entry by the key to invalidate it so we can
+        # insert a new authorative entry at the head without having to dig and
+        # find the old entry for removal immediately.
+        self.access_lookup = {}
+
+        # Trigger a heap cleanup when we get past this size
+        self.access_log_limit = maxsize * self.CLEANUP_FACTOR
+
+    def _invalidate_entry(self, key):
+        "If exists: Invalidate old entry and return it."
+        old_entry = self.access_lookup.get(key)
+        if old_entry:
+            old_entry.is_valid = False
+
+        return old_entry
+
+    def _push_entry(self, key):
+        "Push entry onto our access log, invalidate the old entry if exists."
+        self._invalidate_entry(key)
+
+        new_entry = AccessEntry(key)
+        self.access_lookup[key] = new_entry
+
+        self.access_log_lock.acquire()
+        self.access_log.appendleft(new_entry)
+        self.access_log_lock.release()
+
+    def _prune_entries(self, num):
+        "Pop entries from our access log until we popped ``num`` valid ones."
+        while num > 0:
+            self.access_log_lock.acquire()
+            p = self.access_log.pop()
+            self.access_log_lock.release()
+
+            if not p.is_valid:
+                continue # Invalidated entry, skip
+
+            dict.pop(self, p.key, None)
+            self.access_lookup.pop(p.key, None)
+            num -= 1
+
+    def _prune_invalidated_entries(self):
+        "Rebuild our access_log without the invalidated entries."
+        self.access_log_lock.acquire()
+        self.access_log = deque(e for e in self.access_log if e.is_valid)
+        self.access_log_lock.release()
+
+    def _get_ordered_access_keys(self):
+        "Return ordered access keys for inspection. Used for testing."
+        self.access_log_lock.acquire()
+        r = [e.key for e in self.access_log if e.is_valid]
+        self.access_log_lock.release()
+
+        return r
+
+    def __getitem__(self, key):
+        item = dict.get(self, key)
+
+        if not item:
+            raise KeyError(key)
+
+        # Insert new entry with new high priority, also implicitly invalidates
+        # the old entry.
+        self._push_entry(key)
+
+        if len(self.access_log) > self.access_log_limit:
+            # Heap is getting too big, try to clean up any tailing invalidated
+            # entries.
+            self._prune_invalidated_entries()
+
+        return item
+
+    def __setitem__(self, key, item):
+        # Add item to our container and access log
+        dict.__setitem__(self, key, item)
+        self._push_entry(key)
+
+        # Discard invalid and excess entries
+        self._prune_entries(len(self) - self._maxsize)
+
+    def __delitem__(self, key):
+        self._invalidate_entry(key)
+        self.access_lookup.pop(key, None)
+        dict.__delitem__(self, key)
+
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError:
+            return default

requests/packages/urllib3/connectionpool.py

@@ -0,0 +1,525 @@
+# urllib3/connectionpool.py
+# Copyright 2008-2011 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 httplib import HTTPConnection, HTTPSConnection, HTTPException
+from Queue import Queue, Empty, Full
+from select import select
+from socket import error as SocketError, timeout as SocketTimeout
+
+
+try:
+    import ssl
+    BaseSSLError = ssl.SSLError
+except ImportError:
+    ssl = None
+    BaseSSLError = None
+
+
+from .request import RequestMethods
+from .response import HTTPResponse
+from .exceptions import (
+    SSLError,
+    MaxRetryError,
+    TimeoutError,
+    HostChangedError,
+    EmptyPoolError,
+)
+
+
+log = logging.getLogger(__name__)
+
+_Default = object()
+
+
+## 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)
+
+
+## Pool objects
+
+class ConnectionPool(object):
+    """
+    Base class for all connection pools, such as
+    :class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`.
+    """
+    pass
+
+
+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):
+        self.host = host
+        self.port = port
+        self.strict = strict
+        self.timeout = timeout
+        self.pool = Queue(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)
+
+            # If this is a persistent connection, check if it got disconnected
+            if conn and conn.sock and select([conn.sock], [], [], 0.0)[0]:
+                # Either data is buffered (bad), or the connection is dropped.
+                log.info("Resetting dropped connection: %s" % self.host)
+                conn.close()
+
+        except Empty:
+            if self.block:
+                raise EmptyPoolError("Pool reached maximum size and no more "
+                                     "connections are allowed.")
+            pass  # Oh well, we'll create a new connection then
+
+        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 discarded because we
+        exceeded maxsize. If connections are discarded frequently, then maxsize
+        should be increased.
+        """
+        try:
+            self.pool.put(conn, block=False)
+        except Full:
+            # This should never happen if self.block == True
+            log.warning("HttpConnectionPool is full, discarding connection: %s"
+                        % self.host)
+
+    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.request(method, url, **httplib_request_kw)
+        conn.sock.settimeout(timeout)
+        httplib_response = conn.getresponse()
+
+        log.debug("\"%s %s %s\" %s %s" %
+                  (method, url,
+                   conn._http_vsn_str, # pylint: disable-msg=W0212
+                   httplib_response.status, httplib_response.length))
+
+        return httplib_response
+
+
+    def is_same_host(self, url):
+        """
+        Check if the given ``url`` is a member of the same host as this
+        conncetion pool.
+        """
+        # TODO: Add optional support for socket.gethostbyname checking.
+        return (url.startswith('/') or
+                get_host(url) == (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`.
+
+        :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:
+            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. 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("Max retries exceeded for url: %s" % url)
+
+        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("Connection pool with host '%s' tried to "
+                                   "open a foreign host: %s" % (host, url))
+
+        conn = None
+
+        try:
+            # Request a connection from the queue
+            # (Could raise SocketError: Bad file descriptor)
+            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 (SocketTimeout, Empty), e:
+            # Timed out either by socket or queue
+            raise TimeoutError("Request timed out after %s seconds" %
+                               self.timeout)
+
+        except (BaseSSLError), e:
+            # SSL certificate error
+            raise SSLError(e)
+
+        except (HTTPException, SocketError), e:
+            # Connection broken, discard. It will be replaced next _get_conn().
+            conn = None
+
+        finally:
+            if conn and release_conn:
+                # Put the connection back to be reused
+                self._put_conn(conn)
+
+        if not conn:
+            log.warn("Retrying (%d attempts remain) after connection "
+                     "broken by '%r': %s" % (retries, e, url))
+            return self.urlopen(method, url, body, headers, retries - 1,
+                                redirect, assert_same_host)  # Try again
+
+        # Handle redirection
+        if (redirect and
+            response.status in [301, 302, 303, 307] and
+            'location' in response.headers):  # Redirect, retry
+            log.info("Redirecting %s -> %s" %
+                     (url, response.headers.get('location')))
+            return self.urlopen(method, response.headers.get('location'), body,
+                                headers, retries - 1, redirect,
+                                assert_same_host)
+
+        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:
+            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
+
+
+## Helpers
+
+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 ' + \
+            basic_auth.encode('base64').strip()
+
+    return headers
+
+
+def get_host(url):
+    """
+    Given a url, return its scheme, host and port (None if it's not there).
+
+    For example: ::
+
+        >>> get_host('http://google.com/mail/')
+        ('http', 'google.com', None)
+        >>> get_host('google.com:80')
+        ('http', 'google.com', 80)
+    """
+    # This code is actually similar to urlparse.urlsplit, but much
+    # simplified for our needs.
+    port = None
+    scheme = 'http'
+    if '//' in url:
+        scheme, url = url.split('://', 1)
+    if '/' in url:
+        url, _path = url.split('/', 1)
+    if ':' in url:
+        url, port = url.split(':', 1)
+        port = int(port)
+    return scheme, url, port
+
+
+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)

requests/packages/urllib3/contrib/ntlmpool.py

@@ -0,0 +1,117 @@
+# urllib3/contrib/ntlmpool.py
+# Copyright 2008-2011 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
+
+"""
+NTLM authenticating pool, contributed by erikcederstran
+
+Issue #10, see: http://code.google.com/p/urllib3/issues/detail?id=10
+"""
+
+import httplib
+from logging import getLogger
+from ntlm import ntlm
+
+from urllib3 import HTTPSConnectionPool
+
+
+log = getLogger(__name__)
+
+
+class NTLMConnectionPool(HTTPSConnectionPool):
+    """
+    Implements an NTLM authentication version of an urllib3 connection pool
+    """
+
+    scheme = 'https'
+
+    def __init__(self, user, pw, authurl, *args, **kwargs):
+        """
+        authurl is a random URL on the server that is protected by NTLM.
+        user is the Windows user, probably in the DOMAIN\username format.
+        pw is the password for the user.
+        """
+        super(NTLMConnectionPool, self).__init__(*args, **kwargs)
+        self.authurl = authurl
+        self.rawuser = user
+        user_parts = user.split('\\', 1)
+        self.domain = user_parts[0].upper()
+        self.user = user_parts[1]
+        self.pw = pw
+
+    def _new_conn(self):
+        # Performs the NTLM handshake that secures the connection. The socket
+        # must be kept open while requests are performed.
+        self.num_connections += 1
+        log.debug('Starting NTLM HTTPS connection no. %d: https://%s%s' %
+                  (self.num_connections, self.host, self.authurl))
+
+        headers = {}
+        headers['Connection'] = 'Keep-Alive'
+        req_header = 'Authorization'
+        resp_header = 'www-authenticate'
+
+        conn = httplib.HTTPSConnection(host=self.host, port=self.port)
+
+        # Send negotiation message
+        headers[req_header] = (
+            'NTLM %s' % ntlm.create_NTLM_NEGOTIATE_MESSAGE(self.rawuser))
+        log.debug('Request headers: %s' % headers)
+        conn.request('GET', self.authurl, None, headers)
+        res = conn.getresponse()
+        reshdr = dict(res.getheaders())
+        log.debug('Response status: %s %s' % (res.status, res.reason))
+        log.debug('Response headers: %s' % reshdr)
+        log.debug('Response data: %s [...]' % res.read(100))
+
+        # Remove the reference to the socket, so that it can not be closed by
+        # the response object (we want to keep the socket open)
+        res.fp = None
+
+        # Server should respond with a challenge message
+        auth_header_values = reshdr[resp_header].split(', ')
+        auth_header_value = None
+        for s in auth_header_values:
+            if s[:5] == 'NTLM ':
+                auth_header_value = s[5:]
+        if auth_header_value is None:
+            raise Exception('Unexpected %s response header: %s' %
+                            (resp_header, reshdr[resp_header]))
+
+        # Send authentication message
+        ServerChallenge, NegotiateFlags = \
+            ntlm.parse_NTLM_CHALLENGE_MESSAGE(auth_header_value)
+        auth_msg = ntlm.create_NTLM_AUTHENTICATE_MESSAGE(ServerChallenge,
+                                                         self.user,
+                                                         self.domain,
+                                                         self.pw,
+                                                         NegotiateFlags)
+        headers[req_header] = 'NTLM %s' % auth_msg
+        log.debug('Request headers: %s' % headers)
+        conn.request('GET', self.authurl, None, headers)
+        res = conn.getresponse()
+        log.debug('Response status: %s %s' % (res.status, res.reason))
+        log.debug('Response headers: %s' % dict(res.getheaders()))
+        log.debug('Response data: %s [...]' % res.read()[:100])
+        if res.status != 200:
+            if res.status == 401:
+                raise Exception('Server rejected request: wrong '
+                                'username or password')
+            raise Exception('Wrong server response: %s %s' %
+                            (res.status, res.reason))
+
+        res.fp = None
+        log.debug('Connection established')
+        return conn
+
+    def urlopen(self, method, url, body=None, headers=None, retries=3,
+                redirect=True, assert_same_host=True):
+        if headers is None:
+            headers = {}
+        headers['Connection'] = 'Keep-Alive'
+        return super(NTLMConnectionPool, self).urlopen(method, url, body,
+                                                       headers, retries,
+                                                       redirect,
+                                                       assert_same_host)

requests/packages/urllib3/exceptions.py

@@ -0,0 +1,35 @@
+# urllib3/exceptions.py
+# Copyright 2008-2011 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
+
+## Exceptions
+
+class HTTPError(Exception):
+    "Base exception used by this module."
+    pass
+
+
+class SSLError(Exception):
+    "Raised when SSL certificate fails in an HTTPS connection."
+    pass
+
+
+class MaxRetryError(HTTPError):
+    "Raised when the maximum number of retries is exceeded."
+    pass
+
+
+class TimeoutError(HTTPError):
+    "Raised when a socket timeout occurs."
+    pass
+
+
+class HostChangedError(HTTPError):
+    "Raised when an existing pool gets a request for a foreign host."
+    pass
+
+class EmptyPoolError(HTTPError):
+    "Raised when a pool runs out of connections and no more are allowed."
+    pass

requests/packages/urllib3/filepost.py

@@ -0,0 +1,71 @@
+# urllib3/filepost.py
+# Copyright 2008-2011 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 mimetools
+import mimetypes
+
+try:
+    from cStringIO import StringIO
+except ImportError:
+    from StringIO import StringIO # pylint: disable-msg=W0404
+
+
+writer = codecs.lookup('utf-8')[3]
+
+
+def get_content_type(filename):
+    return mimetypes.guess_type(filename)[0] or 'application/octet-stream'
+
+
+def encode_multipart_formdata(fields, boundary=None):
+    """
+    Encode a dictionary of ``fields`` using the multipart/form-data mime format.
+
+    :param fields:
+        Dictionary of fields. The key is treated as the field name, and the
+        value as the body of the form-data. If the value is a tuple of two
+        elements, then the first element is treated as the filename of the
+        form-data section.
+
+    :param boundary:
+        If not specified, then a random boundary will be generated using
+        :func:`mimetools.choose_boundary`.
+    """
+    body = StringIO()
+    if boundary is None:
+        boundary = mimetools.choose_boundary()
+
+    for fieldname, value in fields.iteritems():
+        body.write('--%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('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('Content-Type: text/plain\r\n\r\n')
+
+        if isinstance(data, int):
+            data = str(data)  # Backwards compatibility
+
+        if isinstance(data, unicode):
+            writer(body).write(data)
+        else:
+            body.write(data)
+
+        body.write('\r\n')
+
+    body.write('--%s--\r\n' % (boundary))
+
+    content_type = 'multipart/form-data; boundary=%s' % boundary
+
+    return body.getvalue(), content_type

requests/packages/urllib3/poolmanager.py

@@ -0,0 +1,128 @@
+# urllib3/poolmanager.py
+# Copyright 2008-2011 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 ._collections import RecentlyUsedContainer
+from .connectionpool import (
+    HTTPConnectionPool, HTTPSConnectionPool,
+    get_host, connection_from_url,
+)
+
+
+__all__ = ['PoolManager', 'ProxyManager', 'proxy_from_url']
+
+
+from .request import RequestMethods
+from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool
+
+
+pool_classes_by_scheme = {
+    'http': HTTPConnectionPool,
+    'https': HTTPSConnectionPool,
+}
+
+port_by_scheme = {
+    'http': 80,
+    'https': 443,
+}
+
+
+class PoolManager(RequestMethods):
+    """
+    Allows for arbitrary requests while transparently keeping track of
+    necessary connection pools for you.
+
+    :param num_pools:
+        Number of connection pools to cache before discarding the least recently
+        used pool.
+
+    :param \**connection_pool_kw:
+        Additional parameters are used to create fresh
+        :class:`urllib3.connectionpool.ConnectionPool` instances.
+
+    Example: ::
+
+        >>> manager = PoolManager()
+        >>> r = manager.urlopen("http://google.com/")
+        >>> r = manager.urlopen("http://google.com/mail")
+        >>> r = manager.urlopen("http://yahoo.com/")
+        >>> len(r.pools)
+        2
+
+    """
+
+    # TODO: Make sure there are no memory leaks here.
+
+    def __init__(self, num_pools=10, **connection_pool_kw):
+        self.connection_pool_kw = connection_pool_kw
+        self.pools = RecentlyUsedContainer(num_pools)
+
+    def connection_from_host(self, host, port=80, scheme='http'):
+        """
+        Get a :class:`ConnectionPool` based on the host, port, and scheme.
+
+        Note that an appropriate ``port`` value is required here to normalize
+        connection pools in our container most effectively.
+        """
+        pool_key = (scheme, host, port)
+
+        # If the scheme, host, or port doesn't match existing open connections,
+        # open a new ConnectionPool.
+        pool = self.pools.get(pool_key)
+        if pool:
+            return pool
+
+        # Make a fresh ConnectionPool of the desired type
+        pool_cls = pool_classes_by_scheme[scheme]
+        pool = pool_cls(host, port, **self.connection_pool_kw)
+
+        self.pools[pool_key] = pool
+
+        return pool
+
+    def connection_from_url(self, url):
+        """
+        Similar to :func:`urllib3.connectionpool.connection_from_url` but
+        doesn't pass any additional parameters to the
+        :class:`urllib3.connectionpool.ConnectionPool` constructor.
+
+        Additional parameters are taken from the :class:`.PoolManager`
+        constructor.
+        """
+        scheme, host, port = get_host(url)
+
+        port = port or port_by_scheme.get(scheme, 80)
+
+        return self.connection_from_host(host, port=port, scheme=scheme)
+
+    def urlopen(self, method, url, **kw):
+        """
+        Same as :meth:`urllib3.connectionpool.HTTPConnectionPool.urlopen`.
+
+        ``url`` must be absolute, such that an appropriate
+        :class:`urllib3.connectionpool.ConnectionPool` can be chosen for it.
+        """
+        conn = self.connection_from_url(url)
+        return conn.urlopen(method, url, assert_same_host=False, **kw)
+
+
+class ProxyManager(RequestMethods):
+    """
+    Given a ConnectionPool to a proxy, the ProxyManager's ``urlopen`` method
+    will make requests to any url through the defined proxy.
+    """
+
+    def __init__(self, proxy_pool):
+        self.proxy_pool = proxy_pool
+
+    def urlopen(self, method, url, **kw):
+        "Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute."
+        kw['assert_same_host'] = False
+        return self.proxy_pool.urlopen(method, url, **kw)
+
+
+def proxy_from_url(url, **pool_kw):
+    proxy_pool = connection_from_url(url, **pool_kw)
+    return ProxyManager(proxy_pool)

requests/packages/urllib3/request.py

@@ -0,0 +1,145 @@
+# urllib3/request.py
+# Copyright 2008-2011 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 urllib import urlencode
+
+from .filepost import encode_multipart_formdata
+
+
+__all__ = ['RequestMethods']
+
+
+class RequestMethods(object):
+    """
+    Convenience mixin for classes who implement a :meth:`urlopen` method, such
+    as :class:`~urllib3.connectionpool.HTTPConnectionPool` and
+    :class:`~urllib3.poolmanager.PoolManager`.
+
+    Provides behavior for making common types of HTTP request methods and
+    decides which type of request field encoding to use.
+
+    Specifically,
+
+    :meth:`.request_encode_url` is for sending requests whose fields are encoded
+    in the URL (such as GET, HEAD, DELETE).
+
+    :meth:`.request_encode_body` is for sending requests whose fields are
+    encoded in the *body* of the request using multipart or www-orm-urlencoded
+    (such as for POST, PUT, PATCH).
+
+    :meth:`.request` is for making any kind of request, it will look up the
+    appropriate encoding format and use one of the above two methods to make
+    the request.
+    """
+
+    _encode_url_methods = set(['DELETE', 'GET', 'HEAD', 'OPTIONS'])
+
+    _encode_body_methods = set(['PATCH', 'POST', 'PUT', 'TRACE'])
+
+    def urlopen(self, method, url, body=None, headers=None,
+                encode_multipart=True, multipart_boundary=None,
+                **kw):
+        raise NotImplemented("Classes extending RequestMethods must implement "
+                             "their own ``urlopen`` method.")
+
+    def request(self, method, url, fields=None, headers=None, **urlopen_kw):
+        """
+        Make a request using :meth:`urlopen` with the appropriate encoding of
+        ``fields`` based on the ``method`` used.
+
+        This is a convenience method that requires the least amount of manual
+        effort. It can be used in most situations, while still having the option
+        to drop down to more specific methods when necessary, such as
+        :meth:`request_encode_url`, :meth:`request_encode_body`,
+        or even the lowest level :meth:`urlopen`.
+        """
+        method = method.upper()
+
+        if method in self._encode_url_methods:
+            return self.request_encode_url(method, url, fields=fields,
+                                            headers=headers,
+                                            **urlopen_kw)
+        else:
+            return self.request_encode_body(method, url, fields=fields,
+                                             headers=headers,
+                                             **urlopen_kw)
+
+    def request_encode_url(self, method, url, fields=None, **urlopen_kw):
+        """
+        Make a request using :meth:`urlopen` with the ``fields`` encoded in
+        the url. This is useful for request methods like GET, HEAD, DELETE, etc.
+        """
+        if fields:
+            url += '?' + urlencode(fields)
+        return self.urlopen(method, url, **urlopen_kw)
+
+    def request_encode_body(self, method, url, fields=None, headers=None,
+                            encode_multipart=True, multipart_boundary=None,
+                            **urlopen_kw):
+        """
+        Make a request using :meth:`urlopen` with the ``fields`` encoded in
+        the body. This is useful for request methods like POST, PUT, PATCH, etc.
+
+        When ``encode_multipart=True`` (default), then
+        :meth:`urllib3.filepost.encode_multipart_formdata` is used to encode the
+        payload with the appropriate content type. Otherwise
+        :meth:`urllib.urlencode` is used with the
+        'application/x-www-form-urlencoded' content type.
+
+        Multipart encoding must be used when posting files, and it's reasonably
+        safe to use it in other times too. However, it may break request signing,
+        such as with OAuth.
+
+        Supports an optional ``fields`` parameter of key/value strings AND
+        key/filetuple. A filetuple is a (filename, data) tuple. For example: ::
+
+            fields = {
+                'foo': 'bar',
+                'fakefile': ('foofile.txt', 'contents of foofile'),
+                'realfile': ('barfile.txt', open('realfile').read()),
+                'nonamefile': ('contents of nonamefile field'),
+            }
+
+        When uploading a file, providing a filename (the first parameter of the
+        tuple) is optional but recommended to best mimick behavior of browsers.
+
+        Note that if ``headers`` are supplied, the 'Content-Type' header will be
+        overwritten because it depends on the dynamic random boundary string
+        which is used to compose the body of the request. The random boundary
+        string can be explicitly set with the ``multipart_boundary`` parameter.
+        """
+        if encode_multipart:
+            body, content_type = encode_multipart_formdata(fields or {},
+                                    boundary=multipart_boundary)
+        else:
+            body, content_type = (urlencode(fields or {}),
+                                    'application/x-www-form-urlencoded')
+
+        headers = headers or {}
+        headers.update({'Content-Type': content_type})
+
+        return self.urlopen(method, url, body=body, headers=headers,
+                            **urlopen_kw)
+
+    # Deprecated:
+
+    def get_url(self, url, fields=None, **urlopen_kw):
+        """
+        .. deprecated:: 1.0
+           Use :meth:`request` instead.
+        """
+        return self.request_encode_url('GET', url, fields=fields,
+                                       **urlopen_kw)
+
+    def post_url(self, url, fields=None, headers=None, **urlopen_kw):
+        """
+        .. deprecated:: 1.0
+           Use :meth:`request` instead.
+        """
+        return self.request_encode_body('POST', url, fields=fields,
+                                        headers=headers,
+                                        **urlopen_kw)

requests/packages/urllib3/response.py

@@ -0,0 +1,181 @@
+# urllib3/response.py
+# Copyright 2008-2011 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
+
+
+try:
+    from cStringIO import StringIO
+except ImportError:
+    from StringIO import StringIO # pylint: disable-msg=W0404
+
+
+from .exceptions import HTTPError
+
+
+log = logging.getLogger(__name__)
+
+
+def decode_gzip(data):
+    gzipper = gzip.GzipFile(fileobj=StringIO(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 = 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:
+            self._body = self.read(decode_content=decode_content)
+
+    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(decode_content=self._decode_content,
+                             cache_content=True)
+
+    def read(self, amt=None, decode_content=True, 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)
+
+        data = self._fp and self._fp.read(amt)
+
+        try:
+
+            if amt:
+                return data
+
+            if not decode_content or not decoder:
+                if cache_content:
+                    self._body = data
+
+                return data
+
+            try:
+                data = decoder(data)
+            except IOError:
+                raise HTTPError("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()
+
+    @staticmethod
+    def from_httplib(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``.
+        """
+
+        return HTTPResponse(body=r,
+                            headers=dict(r.getheaders()),
+                            status=r.status,
+                            version=r.version,
+                            reason=r.reason,
+                            strict=r.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)

requests/sessions.py

@@ -0,0 +1,279 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.session
+~~~~~~~~~~~~~~~~
+
+This module provides a Session object to manage and persist settings across
+requests (cookies, auth, proxies).
+
+"""
+
+from .defaults import defaults
+from .models import Request
+from .hooks import dispatch_hook
+from .utils import header_expand
+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, basestring):
+        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
+
+    # 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']
+
+
+    def __init__(self,
+        headers=None,
+        cookies=None,
+        auth=None,
+        timeout=None,
+        proxies=None,
+        hooks=None,
+        params=None,
+        config=None):
+
+        self.headers = headers or {}
+        self.cookies = cookies or {}
+        self.auth = auth
+        self.timeout = timeout
+        self.proxies = proxies or {}
+        self.hooks = hooks or {}
+        self.params = params or {}
+        self.config = config or {}
+
+        for (k, v) in defaults.items():
+            self.config.setdefault(k, v)
+
+        self.poolmanager = PoolManager(
+            num_pools=self.config.get('pool_connections'),
+            maxsize=self.config.get('pool_maxsize')
+        )
+
+        # Set up a CookieJar to be used by default
+        self.cookies = {}
+
+        # Add passed cookies in.
+        if cookies is not None:
+            self.cookies.update(cookies)
+
+    def __repr__(self):
+        return '<requests-client at 0x%x>' % (id(self))
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+    def request(self, method, url,
+        params=None,
+        data=None,
+        headers=None,
+        cookies=None,
+        files=None,
+        auth=None,
+        timeout=None,
+        allow_redirects=False,
+        proxies=None,
+        hooks=None,
+        return_response=True,
+        config=None,
+        prefetch=False):
+
+        """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 typle 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 if POST/PUT/DELETE redirect following is allowed.
+        :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.
+        :param prefetch: (optional) if ``True``, the response content will be immediately downloaded.
+        """
+
+        method = str(method).upper()
+
+        # Default empty dicts for dict params.
+        cookies = {} if cookies is None else cookies
+        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
+        # use session's hooks as defaults
+        for key, cb in self.hooks.iteritems():
+            hooks.setdefault(key, cb)
+
+        # Expand header values.
+        if headers:
+            for k, v in headers.items() or {}:
+                headers[k] = header_expand(v)
+
+        args = dict(
+            method=method,
+            url=url,
+            data=data,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            files=files,
+            auth=auth,
+            hooks=hooks,
+            timeout=timeout,
+            allow_redirects=allow_redirects,
+            proxies=proxies,
+            config=config,
+            _poolmanager=self.poolmanager
+        )
+
+        # Merge local kwargs with session kwargs.
+        for attr in self.__attrs__:
+            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)
+
+        # Send any cookies back up the to the session.
+        self.cookies.update(r.response.cookies)
+
+        # 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', True)
+        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 session(**kwargs):
+    """Returns a :class:`Session` for context-management."""
+
+    return Session(**kwargs)

requests/status_codes.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+
+from .structures import LookupDict
+
+_codes = {
+
+    # Informational.
+    100: ('continue',),
+    101: ('switching_protocols',),
+    102: ('processing',),
+    103: ('checkpoint',),
+    122: ('uri_too_long', 'request_uri_too_long'),
+    200: ('ok', 'okay', 'all_ok', 'all_okay', 'all_good', '\\o/'),
+    201: ('created',),
+    202: ('accepted',),
+    203: ('non_authoritative_info', 'non_authoritative_information'),
+    204: ('no_content',),
+    205: ('reset_content', 'reset'),
+    206: ('partial_content', 'partial'),
+    207: ('multi_status', 'multiple_status', 'multi_stati', 'multiple_stati'),
+    208: ('im_used',),
+
+    # Redirection.
+    300: ('multiple_choices',),
+    301: ('moved_permanently', 'moved', '\\o-'),
+    302: ('found',),
+    303: ('see_other', 'other'),
+    304: ('not_modified',),
+    305: ('use_proxy',),
+    306: ('switch_proxy',),
+    307: ('temporary_redirect', 'temporary_moved', 'temporary'),
+    308: ('resume_incomplete', 'resume'),
+
+    # Client Error.
+    400: ('bad_request', 'bad'),
+    401: ('unauthorized',),
+    402: ('payment_required', 'payment'),
+    403: ('forbidden',),
+    404: ('not_found', '-o-'),
+    405: ('method_not_allowed', 'not_allowed'),
+    406: ('not_acceptable',),
+    407: ('proxy_authentication_required', 'proxy_auth', 'proxy_authentication'),
+    408: ('request_timeout', 'timeout'),
+    409: ('conflict',),
+    410: ('gone',),
+    411: ('length_required',),
+    412: ('precondition_failed', 'precondition'),
+    413: ('request_entity_too_large',),
+    414: ('request_uri_too_large',),
+    415: ('unsupported_media_type', 'unsupported_media', 'media_type'),
+    416: ('requested_range_not_satisfiable', 'requested_range', 'range_not_satisfiable'),
+    417: ('expectation_failed',),
+    418: ('im_a_teapot', 'teapot', 'i_am_a_teapot'),
+    422: ('unprocessable_entity', 'unprocessable'),
+    423: ('locked',),
+    424: ('failed_dependency', 'dependency'),
+    425: ('unordered_collection', 'unordered'),
+    426: ('upgrade_required', 'upgrade'),
+    428: ('precondition_required', 'precondition'),
+    429: ('too_many_requests', 'too_many'),
+    431: ('header_fields_too_large', 'fields_too_large'),
+    444: ('no_response', 'none'),
+    449: ('retry_with', 'retry'),
+    450: ('blocked_by_windows_parental_controls', 'parental_controls'),
+    499: ('client_closed_request',),
+
+    # Server Error.
+    500: ('internal_server_error', 'server_error', '/o\\'),
+    501: ('not_implemented',),
+    502: ('bad_gateway',),
+    503: ('service_unavailable', 'unavailable'),
+    504: ('gateway_timeout',),
+    505: ('http_version_not_supported', 'http_version'),
+    506: ('variant_also_negotiates',),
+    507: ('insufficient_storage',),
+    509: ('bandwidth_limit_exceeded', 'bandwidth'),
+    510: ('not_extended',),
+}
+
+codes = LookupDict(name='status_codes')
+
+for (code, titles) in _codes.items():
+    for title in titles:
+        setattr(codes, title, code)
+        if not title.startswith('\\'):
+            setattr(codes, title.upper(), code)

requests/structures.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.structures
+~~~~~~~~~~~~~~~~~~~
+
+Data structures that power Requests.
+
+"""
+
+
+class CaseInsensitiveDict(dict):
+    """Case-insensitive Dictionary
+
+    For example, ``headers['content-encoding']`` will return the
+    value of a ``'Content-Encoding'`` response header."""
+
+    @property
+    def lower_keys(self):
+        if not hasattr(self, '_lower_keys') or not self._lower_keys:
+            self._lower_keys = dict((k.lower(), k) for k in self.iterkeys())
+        return self._lower_keys
+
+    def _clear_lower_keys(self):
+        if hasattr(self, '_lower_keys'):
+            self._lower_keys.clear()
+
+    def __setitem__(self, key, value):
+        dict.__setitem__(self, key, value)
+        self._clear_lower_keys()
+
+    def __delitem__(self, key):
+        dict.__delitem__(self, key)
+        self._lower_keys.clear()
+
+    def __contains__(self, key):
+        return key.lower() in self.lower_keys
+
+    def __getitem__(self, key):
+        # We allow fall-through here, so values default to None
+        if key in self:
+            return dict.__getitem__(self, self.lower_keys[key.lower()])
+
+    def get(self, key, default=None):
+        if key in self:
+            return self[key]
+        else:
+            return default
+
+class LookupDict(dict):
+    """Dictionary lookup object."""
+
+    def __init__(self, name=None):
+        self.name = name
+        super(LookupDict, self).__init__()
+
+    def __repr__(self):
+        return '<lookup \'%s\'>' % (self.name)
+
+    def __getitem__(self, key):
+        # We allow fall-through here, so values default to None
+
+        return self.__dict__.get(key, None)
+
+    def get(self, key, default=None):
+        return self.__dict__.get(key, default)

requests/utils.py

@@ -0,0 +1,381 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.utils
+~~~~~~~~~~~~~~
+
+This module provides utlity functions that are used within Requests
+that are also useful for external consumption.
+
+"""
+
+import cgi
+import codecs
+import cookielib
+import os
+import random
+import re
+import zlib
+import urllib
+
+from urllib2 import parse_http_list as _parse_list_header
+
+
+def guess_filename(obj):
+    """Tries to guess the filename of the given object."""
+    name = getattr(obj, 'name', None)
+    if name and name[0] != '<' and name[-1] != '>':
+        return name
+
+# From mitsuhiko/werkzeug (used with permission).
+def parse_list_header(value):
+    """Parse lists as described by RFC 2068 Section 2.
+
+    In particular, parse comma-separated lists where the elements of
+    the list may include quoted-strings.  A quoted-string could
+    contain a comma.  A non-quoted string could have quotes in the
+    middle.  Quotes are removed automatically after parsing.
+
+    It basically works like :func:`parse_set_header` just that items
+    may appear multiple times and case sensitivity is preserved.
+
+    The return value is a standard :class:`list`:
+
+    >>> parse_list_header('token, "quoted value"')
+    ['token', 'quoted value']
+
+    To create a header from the :class:`list` again, use the
+    :func:`dump_header` function.
+
+    :param value: a string with a list header.
+    :return: :class:`list`
+    """
+    result = []
+    for item in _parse_list_header(value):
+        if item[:1] == item[-1:] == '"':
+            item = unquote_header_value(item[1:-1])
+        result.append(item)
+    return result
+
+
+# From mitsuhiko/werkzeug (used with permission).
+def parse_dict_header(value):
+    """Parse lists of key, value pairs as described by RFC 2068 Section 2 and
+    convert them into a python dict:
+
+    >>> d = parse_dict_header('foo="is a fish", bar="as well"')
+    >>> type(d) is dict
+    True
+    >>> sorted(d.items())
+    [('bar', 'as well'), ('foo', 'is a fish')]
+
+    If there is no value for a key it will be `None`:
+
+    >>> parse_dict_header('key_without_value')
+    {'key_without_value': None}
+
+    To create a header from the :class:`dict` again, use the
+    :func:`dump_header` function.
+
+    :param value: a string with a dict header.
+    :return: :class:`dict`
+    """
+    result = {}
+    for item in _parse_list_header(value):
+        if '=' not in item:
+            result[item] = None
+            continue
+        name, value = item.split('=', 1)
+        if value[:1] == value[-1:] == '"':
+            value = unquote_header_value(value[1:-1])
+        result[name] = value
+    return result
+
+
+# From mitsuhiko/werkzeug (used with permission).
+def unquote_header_value(value, is_filename=False):
+    r"""Unquotes a header value.  (Reversal of :func:`quote_header_value`).
+    This does not use the real unquoting but what browsers are actually
+    using for quoting.
+
+    :param value: the header value to unquote.
+    """
+    if value and value[0] == value[-1] == '"':
+        # this is not the real unquoting, but fixing this so that the
+        # RFC is met will result in bugs with internet explorer and
+        # probably some other browsers as well.  IE for example is
+        # uploading files with "C:\foo\bar.txt" as filename
+        value = value[1:-1]
+
+        # if this is a filename and the starting characters look like
+        # a UNC path, then just return the value without quotes.  Using the
+        # replace sequence below on a UNC path has the effect of turning
+        # the leading double slash into a single slash and then
+        # _fix_ie_filename() doesn't work correctly.  See #458.
+        if not is_filename or value[:2] != '\\\\':
+            return value.replace('\\\\', '\\').replace('\\"', '"')
+    return value
+
+
+def header_expand(headers):
+    """Returns an HTTP Header value string from a dictionary.
+
+    Example expansion::
+
+        {'text/x-dvi': {'q': '.8', 'mxb': '100000', 'mxt': '5.0'}, 'text/x-c': {}}
+        # Accept: text/x-dvi; q=.8; mxb=100000; mxt=5.0, text/x-c
+
+        (('text/x-dvi', {'q': '.8', 'mxb': '100000', 'mxt': '5.0'}), ('text/x-c', {}))
+        # Accept: text/x-dvi; q=.8; mxb=100000; mxt=5.0, text/x-c
+    """
+
+    collector = []
+
+    if isinstance(headers, dict):
+        headers = headers.items()
+
+    elif isinstance(headers, basestring):
+        return headers
+
+    for i, (value, params) in enumerate(headers):
+
+        _params = []
+
+        for (p_k, p_v) in params.items():
+
+            _params.append('%s=%s' % (p_k, p_v))
+
+        collector.append(value)
+        collector.append('; ')
+
+        if len(params):
+
+            collector.append('; '.join(_params))
+
+            if not len(headers) == i+1:
+                collector.append(', ')
+
+
+    # Remove trailing separators.
+    if collector[-1] in (', ', '; '):
+        del collector[-1]
+
+    return ''.join(collector)
+
+
+
+def randombytes(n):
+    """Return n random bytes."""
+    # Use /dev/urandom if it is available.  Fall back to random module
+    # if not.  It might be worthwhile to extend this function to use
+    # other platform-specific mechanisms for getting random bytes.
+    if os.path.exists("/dev/urandom"):
+        f = open("/dev/urandom")
+        s = f.read(n)
+        f.close()
+        return s
+    else:
+        L = [chr(random.randrange(0, 256)) for i in range(n)]
+        return "".join(L)
+
+
+def dict_from_cookiejar(cj):
+    """Returns a key/value dictionary from a CookieJar.
+
+    :param cj: CookieJar object to extract cookies from.
+    """
+
+    cookie_dict = {}
+
+    for _, cookies in cj._cookies.items():
+        for _, cookies in cookies.items():
+            for cookie in cookies.values():
+                # print cookie
+                cookie_dict[cookie.name] = cookie.value
+
+    return cookie_dict
+
+
+def cookiejar_from_dict(cookie_dict):
+    """Returns a CookieJar from a key/value dictionary.
+
+    :param cookie_dict: Dict of key/values to insert into CookieJar.
+    """
+
+    # return cookiejar if one was passed in
+    if isinstance(cookie_dict, cookielib.CookieJar):
+        return cookie_dict
+
+    # create cookiejar
+    cj = cookielib.CookieJar()
+
+    cj = add_dict_to_cookiejar(cj, cookie_dict)
+
+    return cj
+
+
+def add_dict_to_cookiejar(cj, cookie_dict):
+    """Returns a CookieJar from a key/value dictionary.
+
+    :param cj: CookieJar to insert cookies into.
+    :param cookie_dict: Dict of key/values to insert into CookieJar.
+    """
+
+    for k, v in cookie_dict.items():
+
+        cookie = cookielib.Cookie(
+            version=0,
+            name=k,
+            value=v,
+            port=None,
+            port_specified=False,
+            domain='',
+            domain_specified=False,
+            domain_initial_dot=False,
+            path='/',
+            path_specified=True,
+            secure=False,
+            expires=None,
+            discard=True,
+            comment=None,
+            comment_url=None,
+            rest={'HttpOnly': None},
+            rfc2109=False
+        )
+
+        # add cookie to cookiejar
+        cj.set_cookie(cookie)
+
+    return cj
+
+
+def get_encodings_from_content(content):
+    """Returns encodings from given content string.
+
+    :param content: bytestring to extract encodings from.
+    """
+
+    charset_re = re.compile(r'<meta.*?charset=["\']*(.+?)["\'>]', flags=re.I)
+
+    return charset_re.findall(content)
+
+
+def get_encoding_from_headers(headers):
+    """Returns encodings from given HTTP Header Dict.
+
+    :param headers: dictionary to extract encoding from.
+    """
+
+    content_type = headers.get('content-type')
+
+    if not content_type:
+        return None
+
+    content_type, params = cgi.parse_header(content_type)
+
+    if 'charset' in params:
+        return params['charset'].strip("'\"")
+
+
+def unicode_from_html(content):
+    """Attempts to decode an HTML string into unicode.
+    If unsuccessful, the original content is returned.
+    """
+
+    encodings = get_encodings_from_content(content)
+
+    for encoding in encodings:
+
+        try:
+            return unicode(content, encoding)
+        except (UnicodeError, TypeError):
+            pass
+
+        return content
+
+
+def stream_decode_response_unicode(iterator, r):
+    """Stream decodes a iterator."""
+
+    if r.encoding is None:
+        for item in iterator:
+            yield item
+        return
+
+    decoder = codecs.getincrementaldecoder(r.encoding)(errors='replace')
+    for chunk in iterator:
+        rv = decoder.decode(chunk)
+        if rv:
+            yield rv
+    rv = decoder.decode('', final=True)
+    if rv:
+        yield rv
+
+
+def get_unicode_from_response(r):
+    """Returns the requested content back in unicode.
+
+    :param r: Response object to get unicode content from.
+
+    Tried:
+
+    1. charset from content-type
+
+    2. every encodings from ``<meta ... charset=XXX>``
+
+    3. fall back and replace all unicode characters
+
+    """
+
+    tried_encodings = []
+
+    # Try charset from content-type
+    encoding = get_encoding_from_headers(r.headers)
+
+    if encoding:
+        try:
+            return unicode(r.content, encoding)
+        except UnicodeError:
+            tried_encodings.append(encoding)
+
+    # Fall back:
+    try:
+        return unicode(r.content, encoding, errors='replace')
+    except TypeError:
+        return r.content
+
+
+def decode_gzip(content):
+    """Return gzip-decoded string.
+
+    :param content: bytestring to gzip-decode.
+    """
+
+    return zlib.decompress(content, 16 + zlib.MAX_WBITS)
+
+
+def stream_decode_gzip(iterator):
+    """Stream decodes a gzip-encoded iterator"""
+    try:
+        dec = zlib.decompressobj(16 + zlib.MAX_WBITS)
+        for chunk in iterator:
+            rv = dec.decompress(chunk)
+            if rv:
+                yield rv
+        buf = dec.decompress('')
+        rv = buf + dec.flush()
+        if rv:
+            yield rv
+    except zlib.error:
+        pass
+
+
+def requote_path(path):
+    """Re-quote the given URL path component.
+
+    This function passes the given path through an unquote/quote cycle to
+    ensure that it is fully and consistenty quoted.
+    """
+    parts = path.split("/")
+    parts = (urllib.quote(urllib.unquote(part), safe="") for part in parts)
+    return "/".join(parts)

setup.py

@@ -3,49 +3,54 @@
 
 import os
 import sys
+import requests
+
+try:
+    from setuptools import setup
+except ImportError:
+    from distutils.core import setup
 
-from distutils.core import setup
 
 
-	
 if sys.argv[-1] == "publish":
-	os.system("python setup.py sdist upload")
-	sys.exit()
+    os.system("python setup.py sdist upload")
+    sys.exit()
 
 if sys.argv[-1] == "test":
-	os.system("python test_requests.py")
-	sys.exit()
-	
+    os.system("python test_requests.py")
+    sys.exit()
+
 required = []
 
-# if python > 2.6, require simplejson
+if sys.version_info[:2] < (2,6):
+    required.append('simplejson')
 
 setup(
-	name='requests',
-	version='0.2.2',
-	description='Awesome Python HTTP Library that\'s actually usable.',
-	long_description=open('README.rst').read() + '\n\n' +
-	                 open('HISTORY.rst').read(),
-	author='Kenneth Reitz',
-	author_email='me@kennethreitz.com',
-	url='https://github.com/kennethreitz/requests',
-	packages= [
-		'requests',
-		'requests.packages',
-		'requests.packages.poster'
-	],
-	install_requires=required,
-	license='ISC',
-	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.5',
+    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='me@kennethreitz.com',
+    url='http://python-requests.org',
+    packages= [
+        'requests',
+        'requests.packages',
+        'requests.packages.urllib3'
+    ],
+    install_requires=required,
+    license='ISC',
+    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.5',
         'Programming Language :: Python :: 2.6',
-		'Programming Language :: Python :: 2.7',
-		# 'Programming Language :: Python :: 3.0',
-		# 'Programming Language :: Python :: 3.1',
-	),
+        'Programming Language :: Python :: 2.7',
+        # 'Programming Language :: Python :: 3.0',
+        # 'Programming Language :: Python :: 3.1',
+    ),
 )

test_requests.py

@@ -1,61 +1,558 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+from __future__ import with_statement
 
+import time
+import os
 import unittest
-from cStringIO import StringIO
 
 import requests
+import envoy
+from requests import HTTPError
 
+try:
+    import omnijson as json
+except ImportError:
+    import json
+
+
+# TODO: Detect an open port.
+PORT = os.environ.get('HTTPBIN_PORT', '7077')
+
+HTTPBIN_URL = 'http://0.0.0.0:%s/' % (PORT)
+# HTTPBIN_URL = 'http://127.0.0.1:8000/'
+
+
+def httpbin(*suffix):
+    """Returns url for HTTPBIN resource."""
+
+    return HTTPBIN_URL + '/'.join(suffix)
+
+
+SERVICES = (httpbin, )
+
+_httpbin = False
 
 class RequestsTestSuite(unittest.TestCase):
-	"""Requests test cases."""
-	
-	def setUp(self):
-		pass
+    """Requests test cases."""
 
-	def tearDown(self):
-		"""Teardown."""
-		pass
-		
-	def test_invalid_url(self):
-		self.assertRaises(ValueError, requests.get, 'hiwpefhipowhefopw')
+    # It goes to eleven.
+    _multiprocess_can_split_ = True
 
-	def test_HTTP_200_OK_GET(self):
-		r = requests.get('http://google.com')
-		self.assertEqual(r.status_code, 200)
+    def setUp(self):
 
-	def test_HTTPS_200_OK_GET(self):
-		r = requests.get('https://google.com')
-		self.assertEqual(r.status_code, 200)
+        global _httpbin
 
-	def test_HTTP_200_OK_HEAD(self):
-		r = requests.head('http://google.com')
-		self.assertEqual(r.status_code, 200)
+        if not _httpbin:
 
-	def test_HTTPS_200_OK_HEAD(self):
-		r = requests.head('https://google.com')
-		self.assertEqual(r.status_code, 200)
+            c = envoy.connect('gunicorn httpbin:app --bind=0.0.0.0:%s' % (PORT))
 
-	def test_AUTH_HTTPS_200_OK_GET(self):
-		auth = requests.AuthObject('requeststest', 'requeststest')
-		url = 'https://convore.com/api/account/verify.json'
-		r = requests.get(url, auth=auth)
+            self.httpbin = c
+            _httpbin = True
+            time.sleep(1)
 
-		self.assertEqual(r.status_code, 200)
 
-	def test_POSTBIN_GET_POST_FILES(self):
 
-		bin = requests.post('http://www.postbin.org/')
-		self.assertEqual(bin.status_code, 200)
+    def tearDown(self):
+        """Teardown."""
+        # self.httpbin.kill()
+        pass
 
-		post = requests.post(bin.url, data={'some': 'data'})
-		self.assertEqual(post.status_code, 201)
 
-		post2 = requests.post(bin.url, files={'some': StringIO('data')})
-		self.assertEqual(post2.status_code, 201)
+    def test_entry_points(self):
 
+        requests.session
+        requests.session().get
+        requests.session().head
+        requests.get
+        requests.head
+        requests.put
+        requests.patch
+        requests.post
+
+
+
+    def test_invalid_url(self):
+        self.assertRaises(ValueError, requests.get, 'hiwpefhipowhefopw')
+
+    def test_HTTP_200_OK_GET(self):
+        r = requests.get(httpbin('/get'))
+        self.assertEqual(r.status_code, 200)
+
+    def test_HTTP_302_ALLOW_REDIRECT_GET(self):
+        r = requests.get(httpbin('redirect', '1'))
+        self.assertEqual(r.status_code, 200)
+
+    def test_HTTP_302_GET(self):
+        r = requests.get(httpbin('redirect', '1'), allow_redirects=False)
+        self.assertEqual(r.status_code, 302)
+
+
+    def test_HTTP_200_OK_GET_WITH_PARAMS(self):
+        heads = {'User-agent': 'Mozilla/5.0'}
+
+        r = requests.get(httpbin('user-agent'), headers=heads)
+
+        assert heads['User-agent'] in r.content
+        self.assertEqual(r.status_code, 200)
+
+
+    def test_HTTP_200_OK_GET_WITH_MIXED_PARAMS(self):
+        heads = {'User-agent': 'Mozilla/5.0'}
+
+        r = requests.get(httpbin('get') + '?test=true', params={'q': 'test'}, headers=heads)
+        self.assertEqual(r.status_code, 200)
+
+
+    def test_user_agent_transfers(self):
+        """Issue XX"""
+
+        heads = {
+            'User-agent':
+                'Mozilla/5.0 (github.com/kennethreitz/requests)'
+        }
+
+        r = requests.get(httpbin('user-agent'), headers=heads);
+        self.assertTrue(heads['User-agent'] in r.content)
+
+        heads = {
+            'user-agent':
+                'Mozilla/5.0 (github.com/kennethreitz/requests)'
+        }
+
+        r = requests.get(httpbin('user-agent'), headers=heads);
+        self.assertTrue(heads['user-agent'] in r.content)
+
+
+    def test_HTTP_200_OK_HEAD(self):
+        r = requests.head(httpbin('/get'))
+        self.assertEqual(r.status_code, 200)
+
+
+    def test_HTTP_200_OK_PUT(self):
+        r = requests.put(httpbin('put'))
+        self.assertEqual(r.status_code, 200)
+
+
+    def test_HTTP_200_OK_PATCH(self):
+        r = requests.patch(httpbin('patch'))
+        self.assertEqual(r.status_code, 200)
+
+
+    def test_BASICAUTH_HTTP_200_OK_GET(self):
+
+        for service in SERVICES:
+
+            auth = ('user', 'pass')
+            url = service('basic-auth', 'user', 'pass')
+
+            r = requests.get(url, auth=auth)
+            self.assertEqual(r.status_code, 200)
+
+            r = requests.get(url)
+            self.assertEqual(r.status_code, 401)
+
+
+            s = requests.session(auth=auth)
+            r = s.get(url)
+            self.assertEqual(r.status_code, 200)
+
+
+    def test_DIGESTAUTH_HTTP_200_OK_GET(self):
+
+        for service in SERVICES:
+
+            auth = ('digest', 'user', 'pass')
+            url = service('digest-auth', 'auth', 'user', 'pass')
+
+            r = requests.get(url, auth=auth)
+            self.assertEqual(r.status_code, 200)
+
+            r = requests.get(url)
+            self.assertEqual(r.status_code, 401)
+
+
+            s = requests.session(auth=auth)
+            r = s.get(url)
+            self.assertEqual(r.status_code, 200)
+
+    def test_POSTBIN_GET_POST_FILES(self):
+
+        for service in SERVICES:
+
+            url = service('post')
+            post = requests.post(url).raise_for_status()
+
+            post = requests.post(url, data={'some': 'data'})
+            self.assertEqual(post.status_code, 200)
+
+            post2 = requests.post(url, files={'some': open('test_requests.py')})
+            self.assertEqual(post2.status_code, 200)
+
+            post3 = requests.post(url, data='[{"some": "json"}]')
+            self.assertEqual(post3.status_code, 200)
+
+
+    def test_POSTBIN_GET_POST_FILES_WITH_PARAMS(self):
+
+        for service in SERVICES:
+
+            url = service('post')
+            post = requests.post(url,
+                files={'some': open('test_requests.py')},
+                data={'some': 'data'})
+
+            self.assertEqual(post.status_code, 200)
+
+
+    def test_POSTBIN_GET_POST_FILES_WITH_HEADERS(self):
+
+        for service in SERVICES:
+
+            url = service('post')
+
+            post2 = requests.post(url,
+                files={'some': open('test_requests.py')},
+                headers = {'User-Agent': 'requests-tests'})
+
+            self.assertEqual(post2.status_code, 200)
+
+
+    def test_nonzero_evaluation(self):
+
+        for service in SERVICES:
+
+            r = requests.get(service('status', '500'))
+            self.assertEqual(bool(r), False)
+
+            r = requests.get(service('/get'))
+            self.assertEqual(bool(r), True)
+
+
+    def test_request_ok_set(self):
+
+        for service in SERVICES:
+
+            r = requests.get(service('status', '404'))
+            # print r.status_code
+            # r.raise_for_status()
+            self.assertEqual(r.ok, False)
+
+
+    def test_status_raising(self):
+        r = requests.get(httpbin('status', '404'))
+        self.assertRaises(HTTPError, r.raise_for_status)
+
+        r = requests.get(httpbin('status', '200'))
+        self.assertFalse(r.error)
+        r.raise_for_status()
+
+
+    def test_decompress_gzip(self):
+
+        r = requests.get(httpbin('gzip'))
+        r.content.decode('ascii')
+
+
+    def test_unicode_get(self):
+
+        for service in SERVICES:
+
+            url = service('/get')
+
+            requests.get(url, params={'foo': u'føø'})
+            requests.get(url, params={u'føø': u'føø'})
+            requests.get(url, params={'føø': 'føø'})
+            requests.get(url, params={'foo': u'foo'})
+            requests.get(service('ø'), params={'foo': u'foo'})
+
+
+    def test_httpauth_recursion(self):
+
+        http_auth = ('user', 'BADpass')
+
+        for service in SERVICES:
+            r = requests.get(service('basic-auth', 'user', 'pass'), auth=http_auth)
+            self.assertEquals(r.status_code, 401)
+
+
+    def test_urlencoded_post_data(self):
+
+        for service in SERVICES:
+
+            r = requests.post(service('post'), data=dict(test='fooaowpeuf'))
+
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+            self.assertEquals(r.url, service('post'))
+
+            rbody = json.loads(r.content)
+
+            self.assertEquals(rbody.get('form'), dict(test='fooaowpeuf'))
+            self.assertEquals(rbody.get('data'), '')
+
+
+    def test_nonurlencoded_post_data(self):
+
+        for service in SERVICES:
+
+            r = requests.post(service('post'), data='fooaowpeuf')
+
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+            self.assertEquals(r.url, service('post'))
+
+            rbody = json.loads(r.content)
+            # Body wasn't valid url encoded data, so the server returns None as
+            # "form" and the raw body as "data".
+            self.assertEquals(rbody.get('form'), {})
+            self.assertEquals(rbody.get('data'), 'fooaowpeuf')
+
+
+    def test_urlencoded_post_querystring(self):
+
+        for service in SERVICES:
+
+            r = requests.post(service('post'), params=dict(test='fooaowpeuf'))
+
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+            self.assertEquals(r.url, service('post?test=fooaowpeuf'))
+
+            rbody = json.loads(r.content)
+            self.assertEquals(rbody.get('form'), {}) # No form supplied
+            self.assertEquals(rbody.get('data'), '')
+
+
+    def test_urlencoded_post_query_and_data(self):
+
+        for service in SERVICES:
+
+            r = requests.post(
+                service('post'),
+                params=dict(test='fooaowpeuf'),
+                data=dict(test2="foobar"))
+
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+            self.assertEquals(r.url, service('post?test=fooaowpeuf'))
+
+            rbody = json.loads(r.content)
+            self.assertEquals(rbody.get('form'), dict(test2='foobar'))
+            self.assertEquals(rbody.get('data'), '')
+
+
+    def test_nonurlencoded_postdata(self):
+
+        for service in SERVICES:
+
+            r = requests.post(service('post'), data="foobar")
+
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+
+            rbody = json.loads(r.content)
+
+            self.assertEquals(rbody.get('form'), {})
+            self.assertEquals(rbody.get('data'), 'foobar')
+
+
+    # def test_idna(self):
+    #     r = requests.get(u'http://➡.ws/httpbin')
+    #     assert 'httpbin' in r.url
+
+
+    def test_urlencoded_get_query_multivalued_param(self):
+
+        for service in SERVICES:
+
+            r = requests.get(service('get'), params=dict(test=['foo','baz']))
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.url, service('get?test=foo&test=baz'))
+
+
+    def test_urlencoded_post_querystring_multivalued(self):
+
+        for service in SERVICES:
+
+            r = requests.post(service('post'), params=dict(test=['foo','baz']))
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+            self.assertEquals(r.url, service('post?test=foo&test=baz'))
+
+            rbody = json.loads(r.content)
+            self.assertEquals(rbody.get('form'), {}) # No form supplied
+            self.assertEquals(rbody.get('data'), '')
+
+
+    def test_urlencoded_post_query_multivalued_and_data(self):
+
+        for service in SERVICES:
+
+            r = requests.post(
+                service('post'),
+                params=dict(test=['foo','baz']),
+                data=dict(test2="foobar",test3=['foo','baz']))
+
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+            self.assertEquals(r.url, service('post?test=foo&test=baz'))
+            rbody = json.loads(r.content)
+            self.assertEquals(rbody.get('form'), dict(test2='foobar',test3='foo'))
+            self.assertEquals(rbody.get('data'), '')
+
+
+    def test_GET_no_redirect(self):
+
+        for service in SERVICES:
+
+            r = requests.get(service('redirect', '3'), allow_redirects=False)
+            self.assertEquals(r.status_code, 302)
+            self.assertEquals(len(r.history), 0)
+
+
+    def test_HEAD_no_redirect(self):
+
+        for service in SERVICES:
+
+            r = requests.head(service('redirect', '3'), allow_redirects=False)
+            self.assertEquals(r.status_code, 302)
+            self.assertEquals(len(r.history), 0)
+
+
+    def test_redirect_history(self):
+
+        for service in SERVICES:
+
+            r = requests.get(service('redirect', '3'))
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(len(r.history), 3)
+
+
+    def test_relative_redirect_history(self):
+
+        for service in SERVICES:
+
+            r = requests.get(service('relative-redirect', '3'))
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(len(r.history), 3)
+
+
+    def test_session_HTTP_200_OK_GET(self):
+
+        s = requests.session()
+        r = s.get(httpbin('/get'))
+        self.assertEqual(r.status_code, 200)
+
+
+    def test_session_persistent_headers(self):
+
+        heads = {'User-agent': 'Mozilla/5.0'}
+
+        s = requests.session()
+        s.headers = heads
+
+        # Make 2 requests from Session object, should send header both times
+        r1 = s.get(httpbin('user-agent'))
+        assert heads['User-agent'] in r1.content
+
+        r2 = s.get(httpbin('user-agent'))
+        assert heads['User-agent'] in r2.content
+
+        new_heads = {'User-agent': 'blah'}
+        r3 = s.get(httpbin('user-agent'), headers=new_heads)
+        assert new_heads['User-agent'] in r3.content
+
+        self.assertEqual(r2.status_code, 200)
+
+    def test_session_persistent_cookies(self):
+
+        s = requests.session()
+
+        # Internally dispatched cookies are sent.
+        _c = {'kenneth': 'reitz', 'bessie': 'monke'}
+        r = s.get(httpbin('cookies'), cookies=_c)
+        r = s.get(httpbin('cookies'))
+
+        # Those cookies persist transparently.
+        c = json.loads(r.content).get('cookies')
+        assert c == _c
+
+        # Double check.
+        r = s.get(httpbin('cookies'), cookies={})
+        c = json.loads(r.content).get('cookies')
+        assert c == _c
+
+        # Remove a cookie by setting it's value to None.
+        r = s.get(httpbin('cookies'), cookies={'bessie': None})
+        c = json.loads(r.content).get('cookies')
+        del _c['bessie']
+        assert c == _c
+
+        # Test session-level cookies.
+        s = requests.session(cookies=_c)
+        r = s.get(httpbin('cookies'))
+        c = json.loads(r.content).get('cookies')
+        assert c == _c
+
+        # Have the server set a cookie.
+        r = s.get(httpbin('cookies', 'set', 'k', 'v'), allow_redirects=True)
+        c = json.loads(r.content).get('cookies')
+
+        assert 'k' in c
+
+        # And server-set cookie persistience.
+        r = s.get(httpbin('cookies'))
+        c = json.loads(r.content).get('cookies')
+
+        assert 'k' in c
+
+
+
+    def test_session_persistent_params(self):
+
+        params = {'a': 'a_test'}
+
+        s = requests.session()
+        s.params = params
+
+        # Make 2 requests from Session object, should send header both times
+        r1 = s.get(httpbin('get'))
+        assert params['a'] in r1.content
+
+
+        params2 = {'b': 'b_test'}
+
+        r2 = s.get(httpbin('get'), params=params2)
+        assert params['a'] in r2.content
+        assert params2['b'] in r2.content
+
+
+        params3 = {'b': 'b_test', 'a': None, 'c': 'c_test'}
+
+        r3 = s.get(httpbin('get'), params=params3)
+
+        assert not params['a'] in r3.content
+        assert params3['b'] in r3.content
+        assert params3['c'] in r3.content
+
+    def test_invalid_content(self):
+        # WARNING: if you're using a terrible DNS provider (comcast),
+        # this will fail.
+        try:
+            hah = 'http://somedomainthatclearlydoesntexistg.com'
+            r = requests.get(hah, allow_redirects=False)
+        except requests.ConnectionError:
+            pass   # \o/
+        else:
+            assert False
+
+
+        config = {'safe_mode': True}
+        r = requests.get(hah, allow_redirects=False, config=config)
+        assert r.content == None
 
 
 if __name__ == '__main__':
-	unittest.main()
+    unittest.main()