Merge branch 'release/0.4.1'

reimpliment settings as singleton

.gitignore

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

AUTHORS

@@ -0,0 +1,21 @@
+Requests is written and maintained by Kenneth Reitz and
+various contributors:
+
+Development Lead
+````````````````
+
+- Kenneth Reitz <me@kennethreitz.com>
+
+
+Patches and Suggestions
+```````````````````````
+
+- Various Pocoo Members
+- Chris Adams
+- Flavio Percoco Premoli
+- Dj Gilcrease
+- Justin Murphy
+- Rob Madole
+- Aram Dulyan
+- Johannes Gorset
+- 村山めがね (Megane Murayama)

HACKING

@@ -0,0 +1,15 @@
+Where possible, please follow PEP8 with regard to coding style. Sometimes the
+line length restriction is too hard to follow, so don't bend over backwards
+there.
+
+Triple-quotes should always be """, single quotes are ' unless using " would
+result in less escaping within the string.
+
+All modules, functions, and methods should be well documented reStructuredText
+for Sphinx AutoDoc.
+
+All functionality should be available in pure Python. Optional C (via Cython)
+implementations may be written for performance reasons, but should never
+replace the Python implementation.
+
+Lastly, don't take yourself too seriously :)

HISTORY.rst

@@ -1,6 +1,99 @@
 History
 -------
 
+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)
+++++++++++++++++++
+
+* Still handles request in the event of an HTTPError. (Issue #2)
+* Eventlet and Gevent Monkeypatch support.
+* Cookie Support (Issue #1)
+
+
+0.2.1 (2011-02-14)
+++++++++++++++++++
+
+* Added file attribute to POST and PUT requests for multipart-encode file uploads.
+* Added Request.url attribute for context and redirects
+
+
 0.2.0 (2011-02-14)
 ++++++++++++++++++
 

MANIFEST.in

@@ -0,0 +1 @@
+include README.rst LICENSE HISTORY.rst 

NOTICE

@@ -0,0 +1,12 @@
+Request includes some vendorized python libraries to ease installation.
+
+Poster License
+==============
+
+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.

README.rst

@@ -1,11 +1,11 @@
 Requests: The Simple (e.g. usable) HTTP Module
 ==============================================
 
-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). 
+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).
 
 But this one's different. This one's going to be awesome. And simple.
 
-Really simple. 
+Really simple.
 
 Features
 --------
@@ -13,7 +13,14 @@ Features
 - Extremely simple GET, HEAD, POST, PUT, DELETE Requests
     + Simple HTTP Header Request Attachment
     + Simple Data/Params Request Attachment
-- Simple Basic HTTP Authentication
+    + Simple Multipart File Uploads
+    + CookieJar Support
+    + Redirection History
+    + Redirection Recursion Urllib Fix
+    + Auto Decompression of GZipped Content
+    + Unicode URL Support
+
+- Simple Authentication
     + Simple URL + HTTP Auth Registry
 
 
@@ -27,23 +34,23 @@ It couldn't be simpler. ::
 
 
 HTTPS? Basic Authentication? ::
-    
+
     >>> r = requests.get('https://convore.com/api/account/verify.json')
     >>> r.status_code
     401
 
-    
+
 Uh oh, we're not authorized! Let's add authentication. ::
-    
-    >>> conv_auth = requests.AuthObject('requeststest', 'requeststest')
+
+    >>> conv_auth = ('requeststest', 'requeststest')
     >>> r = requests.get('https://convore.com/api/account/verify.json', auth=conv_auth)
-    
+
     >>> r.status_code
-    200 
-    
+    200
+
     >>> r.headers['content-type']
     'application/json'
-    
+
     >>> r.content
     '{"username": "requeststest", "url": "/users/requeststest/", "id": "9408", "img": "censored-long-url"}'
 
@@ -51,49 +58,70 @@ Uh oh, we're not authorized! Let's add authentication. ::
 
 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={} auth=None)
-    <request object>
-    
+    >>> requests.get(url, params={}, headers={}, cookies=None, auth=None)
+    <Response [200]>
+
   HEAD Requests
-    >>> request.head(url, params={}, headers={} auth=None)
-    <request object>
-    
+    >>> requests.head(url, params={}, headers={}, cookies=None, auth=None)
+    <Response [200]>
+
   PUT Requests
-    >>> request.put(url, data='', headers={}, auth=None)
-    <request object>
-    
+    >>> requests.put(url, data='', headers={}, files={}, cookies=None, auth=None)
+    <Response [200]>
+
   POST Requests
-    >>> request.post(url, data={}, headers={}, auth=None)
-    <request object>
-    
+    >>> requests.post(url, data={}, headers={}, files={}, cookies=None, auth=None)
+    <Response [200]>
+
   DELETE Requests
-    >>> request.delete(url, params={}, headers={}, auth=None)
-    <request object>
-    
+    >>> requests.delete(url, params={}, headers={}, cookies=None, auth=None)
+    <Response [200]>
+
 
 **Responses:**
-    
-    Request.status_code:
+
+    Response.status_code
          (Integer) Received HTTP Status Code Response
 
-    Request.headers:
-        (Dictionary) Received HTTP Response Headers
+    Response.headers
+        ((CaseInsensitive) Dictionary) Received HTTP Response Headers.
 
-    Request.content:
-        (Bytes) Received Content
+    Response.content
+        (Bytes) Received Content.
+
+    Response.history
+        (List of Responses) Redirection History.
+
+    Response.url
+        (String) URL of response. Useful for detecting redirects.
+
+    Response.ok
+        (Bool) True if no errors occurred during the request, and the status_code is kosher.
+
+    Response.cached
+        (Bool) True if Response.content is stored within the object.
+
+    Response.error
+        (HTTPError) If an HTTPError occurred (e.g. status of 404), Otherwise this is None.
+
+    Response.raise_for_status()
+        Raises HTTPError if a request is not kosher.
 
 
 **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)
+    >>> requests.auth_manager.add_auth(url, authobject)
 
 
 
@@ -103,13 +131,13 @@ Installation
 To install requests, simply: ::
 
     $ pip install requests
-    
+
 Or, if you absolutely must: ::
 
     $ easy_install requests
 
 But, you really shouldn't do that.
-   
+
 
 
 Contribute
@@ -123,7 +151,6 @@ Roadmap
 -------
 
 - Sphinx Documentation
-- Exhaustive Unittests
 
 .. _`the repository`: http://github.com/kennethreitz/requests
 .. _AUTHORS: http://github.com/kennethreitz/requests/blob/master/AUTHORS

docs/_templates/sidebarintro.html

@@ -0,0 +1,22 @@
+<h3>About Requests</h3>
+<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,6 @@
+<h3><a href="http://python-requests.org">About Requests</a></h3>
+<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,33 @@
+{%- extends "basic/layout.html" %}
+{%- block extrahead %}
+  {{ super() }}
+  {% if theme_touch_icon %}
+  <link rel="apple-touch-icon" href="{{ pathto('_static/' ~ theme_touch_icon, 1) }}" />
+  {% endif %}
+  <link media="only screen and (max-device-width: 480px)" href="{{
+    pathto('_static/small_flask.css', 1) }}" type= "text/css" rel="stylesheet" />
+{% endblock %}
+{%- block relbar2 %}{% endblock %}
+{%- block footer %}
+    <div class="footer">
+      &copy; Copyright {{ copyright }}.
+    </div>
+    <a href="https://github.com/kennethreitz/requests">
+        <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" />
+    </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>
+{%- 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,463 @@
+/*
+ * 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 0 20px 0;
+    margin: 0;
+    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: 600px) {
+
+    div.sphinxsidebar {
+    	display: none;
+    }
+
+    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;
+    }
+
+    .bodywrapper {
+    	margin: 0;
+    }
+
+    .footer {
+    	width: auto;
+    }
+
+
+
+}
+
+
+/* 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;
+}

docs/_themes/kr/static/small_flask.css

@@ -0,0 +1,70 @@
+/*
+ * small_flask.css_t
+ * ~~~~~~~~~~~~~~~~~
+ *
+ * :copyright: Copyright 2010 by Armin Ronacher.
+ * :license: Flask Design License, see LICENSE for details.
+ */
+
+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;
+}

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,66 @@
+.. _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 5 methods. They
+all return a :class:`Response <models.Response>` object.
+
+.. autofunction:: get
+.. autofunction:: post
+.. autofunction:: put
+.. autofunction:: delete
+.. autofunction:: head
+
+-----------
+
+
+.. autoclass:: requests.models.Response
+   :inherited-members:
+
+
+Exceptions
+----------
+
+.. autoexception:: HTTPError
+
+.. autoexception:: RequestException
+
+.. autoexception:: requests.models.AuthenticationError
+.. autoexception:: requests.models.URLRequired
+.. autoexception:: requests.models.InvalidMethod
+
+
+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.
+
+Functions
+~~~~~~~~~
+
+.. autofunction:: request
+
+Classes
+~~~~~~~
+
+.. autoclass:: requests.models.Request
+   :inherited-members:
+
+Structures
+~~~~~~~~~~
+
+.. autoclass:: requests.structures.CaseInsensitiveDict
+   :inherited-members:

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 = True
 
 # 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/index.rst

@@ -3,18 +3,87 @@
    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.
+
+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
+    200
+    >>> r.headers['content-type']
+    'application/json'
+
+See `the same code, without Requests <https://gist.github.com/973705>`_.
+
+Requests allow you to send **GET**, **HEAD**, **PUT**,
+**POST**, and **DELETE** HTTP requests. You can add headers, form data,
+multipart files, and parameters with simple Python dictionaries, and access the
+response data in the same way. It's powered by :py:class:`urllib2`, but it does
+all the hard work and crazy hacks for you.
+
+Testimonals
+-----------
+
+`Twitter, Inc <http://twitter.com>`_ and `The Library of Congress <http://www.loc.gov/>`_ use Requests internally.
+
+**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.
+
+**Rich Leland**
+   Requests is awesome. That is all.
+
+**Steve Pike**
+  I can never remember how to do it the regular way. ``import requests; requests.get()`` is just so easy!
+
+
+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`
 
+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

docs/user/install.rst

@@ -0,0 +1,53 @@
+.. _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 install requests
+
+But, you really `shouldn't do that <http://www.pip-installer.org/en/latest/index.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 <pip.kreitz.co/>`_::
+
+    $ pip install -i http://pip.kreitz.co/simple requests
+
+
+Get the Code
+------------
+
+Requsts 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

docs/user/intro.rst

@@ -0,0 +1,55 @@
+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.
+
+
+Python Interpreters
+-------------------
+
+At this time, the following Python platforms are officially supported:
+
+* cPython 2.5
+* cPython 2.6
+* cPython 2.7
+* PyPy-c 1.4
+* PyPy-c 1.5
+
+
+Support for Python 3.x is planned.

docs/user/quickstart.rst

@@ -0,0 +1,84 @@
+Feature Overview
+================
+
+Requests is designed to solve a 90% use case — making simple requests. While most
+HTTP libraries are extremely extensible, they often attempt to support the entire HTTP Spec.
+This often leads to extremely messy and cumbersome APIs, as is the case with urllib2. Requests abandons support for edge-cases, and focuses on the essentials.
+
+
+.. _features:
+
+Requests Can:
+-------------
+
+- Make **GET**, **POST**, **PUT**, **DELETE**, and **HEAD** requests.
+- Handle HTTP and HTTPS Requests
+- Add Request headers (with a simple dictionary)
+- URLEncode your Form Data (with a simple dictionary)
+- Add Multi-part File Uploads (with a simple dictionary)
+- Handle CookieJars (with a single parameter)
+- Add HTTP Authentication (with a single parameter)
+- Handle redirects (with history)
+- Automatically decompress GZip'd responses
+- Support Unicode URLs
+- Gracefully timeout
+- Interface with Eventlet & Gevent
+
+
+Requests Can't:
+---------------
+
+- Handle Caching
+- Handle Keep-Alives
+
+
+Quickstart
+==========
+
+
+GET Request
+-----------
+
+
+Adding Parameters
+-----------------
+
+
+
+Adding Headers
+--------------
+
+
+
+HTTP Basic Auth
+---------------
+
+
+Tracking Redirects
+------------------
+
+
+
+
+HTTP POST (Form Data)
+---------------------
+
+
+HTTP POST (Binary Data)
+-----------------------
+
+
+HTTP POST (Multipart Files)
+---------------------------
+
+
+HTTP PUT
+--------
+
+
+HTTP DELETE
+-----------
+
+
+HTTP HEAD
+---------

requests/__init__.py

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

requests/api.py

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.api
+~~~~~~~~~~~~
+
+This module impliments the Requests API.
+
+:copyright: (c) 2011 by Kenneth Reitz.
+:license: ISC, see LICENSE for more details.
+
+"""
+
+import requests
+import config
+from .models import Request, Response, AuthManager, AuthObject, auth_manager
+
+
+__all__ = ('request', 'get', 'head', 'post', 'put', 'delete')
+
+
+
+def request(method, url, **kwargs):
+    """Constructs and sends a :class:`Request <models.Request>`. Returns :class:`Response <models.Response>` object.
+
+    :param method: method for the new :class:`Request` object.
+    :param url: URL for the new :class:`Request` object.
+    :param params: (optional) Dictionary of GET/HEAD/DELETE Parameters to send with the :class:`Request`.
+    :param data: (optional) Bytes/Dictionary of PUT/POST Data 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 files: (optional) Dictionary of 'filename': file-like-objects for multipart encoding upload.
+    :param auth: (optional) AuthObject to enable Basic 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.
+    """
+    data = kwargs.pop('data', dict()) or kwargs.pop('params', dict())
+
+    r = Request(method=method, url=url, data=data, headers=kwargs.pop('headers', dict()),
+        cookiejar=kwargs.get('cookies', None),
+        files=kwargs.get('files', None),
+        auth=kwargs.get('auth', auth_manager.get_auth(url)),
+        timeout=kwargs.get('timeout', config.settings.timeout),
+        allow_redirects=kwargs.get('allow_redirects', None)
+    )
+
+    r.send()
+
+    return r.response
+
+
+def get(url, params={}, headers={}, cookies=None, auth=None, **kwargs):
+    """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.
+    :param timeout: (optional) Float describing the timeout of the request.
+    """
+
+    return request('GET', url, params=params, headers=headers, cookies=cookies, auth=auth, **kwargs)
+
+
+def head(url, params={}, headers={}, cookies=None, auth=None, **kwargs):
+    """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.
+    :param timeout: (optional) Float describing the timeout of the request.
+    """
+
+    return request('HEAD', url, params=params, headers=headers, cookies=cookies, auth=auth, **kwargs)
+
+
+def post(url, data={}, headers={}, files=None, cookies=None, auth=None, **kwargs):
+    """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.
+    :param timeout: (optional) Float describing the timeout of the request.
+    """
+
+    return request('POST', url, data=data, headers=headers, files=files, cookies=cookies, auth=auth, **kwargs)
+
+
+def put(url, data='', headers={}, files={}, cookies=None, auth=None, **kwargs):
+    """Sends a PUT request. Returns :class:`Response` object.
+
+    :param url: URL for the new :class:`Request` object.
+    :param params: (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.
+    :param timeout: (optional) Float describing the timeout of the request.
+    """
+
+    return request('PUT', url, data=data, headers=headers, files=files, cookies=cookies, auth=auth, **kwargs)
+
+
+def delete(url, params={}, headers={}, cookies=None, auth=None, **kwargs):
+    """Sends a DELETE request. Returns :class:`Response` object.
+
+    :param url: URL for the new :class:`Request` object.
+    :param params: (optional) Dictionary of DELETE 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.
+    :param timeout: (optional) Float describing the timeout of the request.
+    """
+
+    return request('DELETE', url, params=params, headers=headers, cookies=cookies, auth=auth, **kwargs)

requests/async.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+"""
+    requests.async
+    ~~~~~~~~~~~~~~
+
+    This module implements the main Requests system, after monkey-patching
+    the urllib2 module with eventlet or gevent..
+
+    :copyright: (c) 2011 by Kenneth Reitz.
+    :license: ISC, see LICENSE for more details.
+"""
+
+
+from __future__ import absolute_import
+
+import urllib
+import urllib2
+
+from urllib2 import HTTPError
+
+
+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
+
+
+if not 'eventlet' in locals():
+    raise ImportError('No Async adaptations of urllib2 found!')
+
+
+from .core import *

requests/config.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.config
+~~~~~~~~~~~~~~~
+
+This module provides the Requests settings feature set.
+
+"""
+
+class Settings(object):
+    _singleton = {}
+
+    # attributes with defaults
+    __attrs__ = ('timeout',)
+
+    def __init__(self, **kwargs):
+        super(Settings, self).__init__()
+
+        self.__dict__ = self._singleton
+
+
+    def __call__(self, *args, **kwargs):
+        # new instance of class to call
+        r = self.__class__()
+
+        # cache previous settings for __exit__
+        r.__cache = self.__dict__.copy()
+        map(self.__cache.setdefault, self.__attrs__)
+
+        # set new settings
+        self.__dict__.update(*args, **kwargs)
+
+        return r
+
+
+    def __enter__(self):
+        pass
+
+
+    def __exit__(self, *args):
+
+        # restore cached copy
+        self.__dict__.update(self.__cache.copy())
+        del self.__cache
+
+
+    def __getattribute__(self, key):
+        if key in object.__getattribute__(self, '__attrs__'):
+            try:
+                return object.__getattribute__(self, key)
+            except AttributeError:
+                return None
+        return object.__getattribute__(self, key)
+
+settings = Settings()

requests/core.py

@@ -1,405 +1,25 @@
 # -*- coding: utf-8 -*-
 
 """
-    requests.core
-    ~~~~~~~~~~~~~
+requests.core
+~~~~~~~~~~~~~
 
-    This module implements the main Requests system.
+This module implements the main Requests system.
+
+:copyright: (c) 2011 by Kenneth Reitz.
+:license: ISC, see LICENSE for more details.
 
-    :copyright: (c) 2011 by Kenneth Reitz.
-    :license: ISC, see LICENSE for more details.
 """
 
-import urllib
-import urllib2
-
-
 __title__ = 'requests'
-__version__ = '0.2.0'
-__build__ = 0x000200
+__version__ = '0.4.1'
+__build__ = 0x000401
 __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.method = None
-		self.params = {}
-		self.data = {}
-		self.response = Response()
-		self.auth = None
-		self.sent = False
-		
-	def __repr__(self):
-		try:
-			repr = '<Request [%s]>' % (self.method)
-		except:
-			repr = '<Request object>'
-		return repr
-	
-	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 consistiency."""
-
-		if not self.url:
-			raise URLRequired
-
-		
-	def _get_opener(self):
-		""" Creates appropriate opener object for urllib2.
-		"""
-		
-		if self.auth:
-
-			# create a password manager
-			authr = urllib2.HTTPPasswordMgrWithDefaultRealm()
-
-			authr.add_password(None, self.url, self.auth.username, self.auth.password)
-			handler = urllib2.HTTPBasicAuthHandler(authr)
-			opener = urllib2.build_opener(handler)
-
-			# use the opener to fetch a URL
-			return opener.open
-		else:
-			return urllib2.urlopen
-
-	
-	def send(self, anyway=False):
-		"""Sends the request. Returns True of successfull, 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.response.status_code = resp.code
-					self.response.headers = resp.info().dict
-					if self.method.lower() == 'get':
-						self.response.content = resp.read()
-
-					success = True
-				except urllib2.HTTPError, why:
-					self.response.status_code = why.code
-
-
-		elif self.method == 'PUT':
-			if (not self.sent) or anyway:
-
-				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.response.status_code = resp.code
-					self.response.headers = resp.info().dict
-					self.response.content = resp.read()
-
-					success = True
-
-				except urllib2.HTTPError, why:
-					self.response.status_code = why.code
-
-
-
-
-		elif self.method == 'POST':
-			if (not self.sent) or anyway:
-
-				req = _Request(self.url, method='POST')
-
-				if self.headers:
-					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.response.status_code = resp.code
-					self.response.headers = resp.info().dict
-					self.response.content = resp.read()
-
-					success = True
-
-				except urllib2.HTTPError, why:
-					self.response.status_code = why.code
-
-		
-		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()
-		
-	def __repr__(self):
-		try:
-			repr = '<Response [%s]>' % (self.status_code)
-		except:
-			repr = '<Response object>'
-		return repr
-
-	
-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.s
-	
-	: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={}, 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 sent 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.auth = _detect_auth(url, auth)
-	
-	r.send()
-	
-	return r.response
-
-
-def head(url, params={}, headers={}, 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 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.auth = _detect_auth(url, auth)
-	
-	r.send()
-	
-	return r.response
-
-
-def post(url, data={}, headers={}, 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 auth: (optional) AuthObject to enable Basic HTTP Auth.
-	"""
-	
-	r = Request()
-
-	r.url = url
-	r.method = 'POST'
-	r.data = data
-	
-	r.headers = headers
-	r.auth = _detect_auth(url, auth)
-	
-	r.send()
-	
-	return r.response
-	
-	
-def put(url, data='', headers={}, 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 auth: (optional) AuthObject to enable Basic HTTP Auth.
-	"""
-	
-	r = Request()
-
-	r.url = url
-	r.method = 'PUT'
-	r.data = data
-	
-	r.headers = headers
-	r.auth = _detect_auth(url, auth)
-	
-	r.send()
-	
-	return r.response
-
-	
-def delete(url, params={}, headers={}, 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 auth: (optional) AuthObject to enable Basic HTTP Auth.
-	"""
-	
-	r = Request()
-
-	r.url = url
-	r.method = 'DELETE'
-	# return response object
-	
-	r.headers = headers
-	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."""
+from models import HTTPError, auth_manager
+from api import *
+from exceptions import *
+from config import settings

requests/exceptions.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.exceptions
+~~~~~~~~~~~~~~~
+
+"""
+
+class RequestException(Exception):
+    """There was an ambiguous exception that occured while handling your
+    request."""
+
+class AuthenticationError(RequestException):
+    """The authentication credentials provided were invalid."""
+    
+class Timeout(RequestException):
+    """The request timed out."""
+
+class URLRequired(RequestException):
+    """A valid URL is required to make a request."""
+
+class InvalidMethod(RequestException):
+    """An inappropriate method was attempted."""

requests/models.py

@@ -0,0 +1,503 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.models
+~~~~~~~~~~~~~~~
+
+"""
+
+import requests
+import urllib
+import urllib2
+import socket
+import zlib
+
+from urllib2 import HTTPError
+from urlparse import urlparse
+
+from .monkeys import Request as _Request, HTTPBasicAuthHandler, HTTPDigestAuthHandler, HTTPRedirectHandler
+from .structures import CaseInsensitiveDict
+from .packages.poster.encode import multipart_encode
+from .packages.poster.streaminghttp import register_openers, get_handlers
+from .exceptions import RequestException, AuthenticationError, Timeout, URLRequired, InvalidMethod
+
+
+
+class Request(object):
+    """The :class:`Request <models.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, url=None, headers=dict(), files=None, method=None,
+                 data=dict(), auth=None, cookiejar=None, timeout=None,
+                 redirect=True, allow_redirects=False):
+
+        socket.setdefaulttimeout(timeout)
+
+        #: Request URL.
+        self.url = url
+        #: Dictonary of HTTP Headers to attach to the :class:`Request <models.Request>`.
+        self.headers = headers
+        #: Dictionary of files to multipart upload (``{filename: content}``).
+        self.files = files
+        #: HTTP Method to use. Available: GET, HEAD, PUT, POST, DELETE.
+        self.method = method
+        #: Form or Byte data to attach to the :class:`Request <models.Request>`.
+        self.data = dict()
+        #: True if :class:`Request <models.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
+
+        if hasattr(data, 'items'):
+            for (k, v) in data.items():
+                self.data.update({
+                    k.encode('utf-8') if isinstance(k, unicode) else k:
+                    v.encode('utf-8') if isinstance(v, unicode) else v
+                })
+            self._enc_data = urllib.urlencode(self.data)
+        else:
+            self._enc_data = self.data = data
+
+        #: :class:`Response <models.Response>` instance, containing
+        #: content and metadata of HTTP Response, once :attr:`sent <send>`.
+        self.response = Response()
+
+        if isinstance(auth, (list, tuple)):
+            auth = AuthObject(*auth)
+        if not auth:
+            auth = auth_manager.get_auth(self.url)
+        #: :class:`AuthObject` to attach to :class:`Request <models.Request>`.
+        self.auth = auth
+        #: CookieJar to attach to :class:`Request <models.Request>`.
+        self.cookiejar = cookiejar
+        #: True if Request has been sent.
+        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.cookiejar is not None:
+            _handlers.append(urllib2.HTTPCookieProcessor(self.cookiejar))
+
+        if self.auth:
+            if not isinstance(self.auth.handler, (urllib2.AbstractBasicAuthHandler, urllib2.AbstractDigestAuthHandler)):
+                auth_manager.add_password(self.auth.realm, self.url, self.auth.username, self.auth.password)
+                self.auth.handler = self.auth.handler(auth_manager)
+                auth_manager.add_auth(self.url, self.auth)
+
+            _handlers.append(self.auth.handler)
+
+
+        _handlers.append(HTTPRedirectHandler)
+
+        if not _handlers:
+            return urllib2.urlopen
+
+        if self.data or self.files:
+            _handlers.extend(get_handlers())
+
+        opener = urllib2.build_opener(*_handlers)
+
+        if self.headers:
+            # Allow default headers in the opener to be overloaded
+            normal_keys = [k.capitalize() for k in self.headers]
+            for key, val in opener.addheaders[:]:
+                if key not in normal_keys:
+                    continue
+                # Remove it, we have a value to take its place
+                opener.addheaders.remove((key, val))
+
+        return opener.open
+
+    def _build_response(self, resp):
+        """Build internal :class:`Response <models.Response>` object from given response."""
+
+        def build(resp):
+
+            response = Response()
+            response.status_code = getattr(resp, 'code', None)
+
+            try:
+                response.headers = CaseInsensitiveDict(getattr(resp.info(), 'dict', None))
+                response.content = resp.read()
+            except AttributeError:
+                pass
+
+            if response.headers['content-encoding'] == 'gzip':
+                try:
+                    response.content = zlib.decompress(response.content, 16+zlib.MAX_WBITS)
+                except zlib.error:
+                    pass
+
+            response.url = getattr(resp, 'url', None)
+
+            return response
+
+
+        history = []
+
+        r = build(resp)
+
+        if self.redirect:
+
+            while (
+                ('location' in r.headers) and
+                ((self.method in ('GET', 'HEAD')) or
+                (r.status_code is 303) or
+                (self.allow_redirects))
+            ):
+
+                history.append(r)
+
+                url = r.headers['location']
+
+                # Facilitate for non-RFC2616-compliant 'location' headers
+                # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
+                if not urlparse(url).netloc:
+                    parent_url_components = urlparse(self.url)
+                    url = '%s://%s/%s' % (parent_url_components.scheme, parent_url_components.netloc, url)
+
+                # http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.4
+                if r.status_code is 303:
+                    method = 'GET'
+                else:
+                    method = self.method
+
+                request = Request(
+                    url, self.headers, self.files, method,
+                    self.data, self.auth, self.cookiejar, redirect=False
+                )
+                request.send()
+                r = request.response
+
+            r.history = history
+
+        self.response = r
+
+
+    @staticmethod
+    def _build_url(url, data=None):
+        """Build URLs."""
+
+        if urlparse(url).query:
+            return '%s&%s' % (url, data)
+        else:
+            if data:
+                return '%s?%s' % (url, data)
+            else:
+                return 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'):
+            req = _Request(self._build_url(self.url, self._enc_data), method=self.method)
+        else:
+
+            if self.files:
+                register_openers()
+
+                if self.data:
+                    self.files.update(self.data)
+
+                datagen, headers = multipart_encode(self.files)
+                req = _Request(self.url, data=datagen, headers=headers, method=self.method)
+
+            else:
+                req = _Request(self.url, data=self._enc_data, method=self.method)
+
+        if self.headers:
+            req.headers.update(self.headers)
+
+        if not self.sent or anyway:
+
+            try:
+                opener = self._get_opener()
+                resp = opener(req)
+
+                if self.cookiejar is not None:
+                    self.cookiejar.extract_cookies(resp, req)
+
+            except urllib2.HTTPError, why:
+                self._build_response(why)
+                if not self.redirect:
+                    self.response.error = why
+            except urllib2.URLError, error:
+                raise Timeout if isinstance(error.reason, socket.timeout) else error
+            else:
+                self._build_response(resp)
+                self.response.ok = True
+
+            self.response.cached = False
+        else:
+            self.response.cached = True
+
+        self.sent = self.response.ok
+
+        return self.sent
+
+
+    def read(self, *args):
+        return self.response.read()
+
+
+
+class Response(object):
+    """The core :class:`Response <models.Response>` object. All
+    :class:`Request <models.Request>` objects contain a
+    :class:`response <models.Response>` attribute, which is an instance
+    of this class.
+    """
+
+    def __init__(self):
+        #: Raw content of the response, in bytes.
+        #: If ``content-encoding`` of response was set to ``gzip``, the
+        #: response data will be automatically deflated.
+        self.content = None
+        #: 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()
+        #: Final URL location of Response.
+        self.url = None
+        #: True if no :attr:`error` occured.
+        self.ok = False
+        #: Resulting :class:`HTTPError` of request, if one occured.
+        self.error = None
+        #: True, if the response :attr:`content` is cached locally.
+        self.cached = False
+        #: A list of :class:`Response <models.Response>` objects from
+        #: the history of the Request. Any redirect responses will end
+        #: up here.
+        self.history = []
+
+
+    def __repr__(self):
+        return '<Response [%s]>' % (self.status_code)
+
+
+    def __nonzero__(self):
+        """Returns true if :attr:`status_code` is 'OK'."""
+        return not self.error
+
+
+    def raise_for_status(self):
+        """Raises stored :class:`HTTPError`, if one occured."""
+        if self.error:
+            raise self.error
+
+    def read(self, *args):
+        """Returns :attr:`content`. Used for file-like object compatiblity."""
+
+        return self.content
+
+
+
+class AuthManager(object):
+    """Requests Authentication Manager."""
+
+    def __new__(cls):
+        singleton = cls.__dict__.get('__singleton__')
+        if singleton is not None:
+            return singleton
+
+        cls.__singleton__ = singleton = object.__new__(cls)
+
+        return singleton
+
+
+    def __init__(self):
+        self.passwd = {}
+        self._auth = {}
+
+
+    def __repr__(self):
+        return '<AuthManager [%s]>' % (self.method)
+
+
+    def add_auth(self, uri, auth):
+        """Registers AuthObject to AuthManager."""
+
+        uri = self.reduce_uri(uri, False)
+
+        # try to make it an AuthObject
+        if not isinstance(auth, AuthObject):
+            try:
+                auth = AuthObject(*auth)
+            except TypeError:
+                pass
+
+        self._auth[uri] = auth
+
+
+    def add_password(self, realm, uri, user, passwd):
+        """Adds password to AuthManager."""
+        # uri could be a single URI or a sequence
+        if isinstance(uri, basestring):
+            uri = [uri]
+
+        reduced_uri = tuple([self.reduce_uri(u, False) for u in uri])
+
+        if reduced_uri not in self.passwd:
+            self.passwd[reduced_uri] = {}
+        self.passwd[reduced_uri] = (user, passwd)
+
+
+    def find_user_password(self, realm, authuri):
+        for uris, authinfo in self.passwd.iteritems():
+            reduced_authuri = self.reduce_uri(authuri, False)
+            for uri in uris:
+                if self.is_suburi(uri, reduced_authuri):
+                    return authinfo
+
+        return (None, None)
+
+
+    def get_auth(self, uri):
+        (in_domain, in_path) = self.reduce_uri(uri, False)
+
+        for domain, path, authority in (
+            (i[0][0], i[0][1], i[1]) for i in self._auth.iteritems()
+        ):
+            if in_domain == domain:
+                if path in in_path:
+                    return authority
+
+
+    def reduce_uri(self, uri, default_port=True):
+        """Accept authority or URI and extract only the authority and path."""
+        # note HTTP URLs do not have a userinfo component
+        parts = urllib2.urlparse.urlsplit(uri)
+        if parts[1]:
+            # URI
+            scheme = parts[0]
+            authority = parts[1]
+            path = parts[2] or '/'
+        else:
+            # host or host:port
+            scheme = None
+            authority = uri
+            path = '/'
+        host, port = urllib2.splitport(authority)
+        if default_port and port is None and scheme is not None:
+            dport = {"http": 80,
+                     "https": 443,
+                     }.get(scheme)
+            if dport is not None:
+                authority = "%s:%d" % (host, dport)
+
+        return authority, path
+
+
+    def is_suburi(self, base, test):
+        """Check if test is below base in a URI tree
+
+        Both args must be URIs in reduced form.
+        """
+        if base == test:
+            return True
+        if base[0] != test[0]:
+            return False
+        common = urllib2.posixpath.commonprefix((base[1], test[1]))
+        if len(common) == len(base[1]):
+            return True
+        return False
+
+
+    def empty(self):
+        self.passwd = {}
+
+
+    def remove(self, uri, realm=None):
+        # uri could be a single URI or a sequence
+        if isinstance(uri, basestring):
+            uri = [uri]
+
+        for default_port in True, False:
+            reduced_uri = tuple([self.reduce_uri(u, default_port) for u in uri])
+            del self.passwd[reduced_uri][realm]
+
+
+    def __contains__(self, uri):
+        # uri could be a single URI or a sequence
+        if isinstance(uri, basestring):
+            uri = [uri]
+
+        uri = tuple([self.reduce_uri(u, False) for u in uri])
+
+        if uri in self.passwd:
+            return True
+
+        return False
+
+auth_manager = AuthManager()
+
+
+
+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.
+    :param realm: (optional) the realm this auth applies to
+    :param handler: (optional) basic || digest || proxy_basic || proxy_digest
+    """
+
+    _handlers = {
+        'basic': HTTPBasicAuthHandler,
+        'digest': HTTPDigestAuthHandler,
+        'proxy_basic': urllib2.ProxyBasicAuthHandler,
+        'proxy_digest': urllib2.ProxyDigestAuthHandler
+    }
+
+    def __init__(self, username, password, handler='basic', realm=None):
+        self.username = username
+        self.password = password
+        self.realm = realm
+
+        if isinstance(handler, basestring):
+            self.handler = self._handlers.get(handler.lower(), urllib2.HTTPBasicAuthHandler)
+        else:
+            self.handler = handler

requests/monkeys.py

@@ -0,0 +1,91 @@
+#-*- coding: utf-8 -*-
+
+"""
+requests.monkeys
+~~~~~~~~~~~~~~~~
+
+Urllib2 Monkey patches.
+
+"""
+
+import urllib2
+
+
+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 HTTPRedirectHandler(urllib2.HTTPRedirectHandler):
+
+    def http_error_301(self, req, fp, code, msg, headers):
+        pass
+
+    http_error_302 = http_error_303 = http_error_307 = http_error_301
+
+
+
+class HTTPBasicAuthHandler(urllib2.HTTPBasicAuthHandler):
+
+    def __init__(self, *args, **kwargs):
+        urllib2.HTTPBasicAuthHandler.__init__(self, *args, **kwargs)
+        self.retried_req = None
+
+    def reset_retry_count(self):
+        # Python 2.6.5 will call this on 401 or 407 errors and thus loop
+        # forever. We disable reset_retry_count completely and reset in
+        # http_error_auth_reqed instead.
+        pass
+
+    def http_error_auth_reqed(self, auth_header, host, req, headers):
+        # Reset the retry counter once for each request.
+        if req is not self.retried_req:
+            self.retried_req = req
+            self.retried = 0
+
+        return urllib2.HTTPBasicAuthHandler.http_error_auth_reqed(
+            self, auth_header, host, req, headers
+        )
+
+
+
+class HTTPDigestAuthHandler(urllib2.HTTPDigestAuthHandler):
+
+    def __init__(self, *args, **kwargs):
+        urllib2.HTTPDigestAuthHandler.__init__(self, *args, **kwargs)
+        self.retried_req = None
+
+    def reset_retry_count(self):
+        # Python 2.6.5 will call this on 401 or 407 errors and thus loop
+        # forever. We disable reset_retry_count completely and reset in
+        # http_error_auth_reqed instead.
+        pass
+
+    def http_error_auth_reqed(self, auth_header, host, req, headers):
+        # Reset the retry counter once for each request.
+        if req is not self.retried_req:
+            self.retried_req = req
+            self.retried = 0
+        # In python < 2.5 AbstractDigestAuthHandler raises a ValueError if
+        # it doesn't know about the auth type requested. This can happen if
+        # somebody is using BasicAuth and types a bad password.
+
+        try:
+            return urllib2.HTTPDigestAuthHandler.http_error_auth_reqed(
+                        self, auth_header, host, req, headers)
+        except ValueError, inst:
+            arg = inst.args[0]
+            if arg.startswith("AbstractDigestAuthHandler doesn't know "):
+                return
+            raise

requests/packages/__init__.py

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

requests/packages/poster/__init__.py

@@ -0,0 +1,34 @@
+# 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 __future__ import absolute_import
+
+from . import streaminghttp
+from . import encode
+
+version = (0, 8, 0) # Thanks JP!

requests/packages/poster/encode.py

@@ -0,0 +1,414 @@
+"""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

@@ -0,0 +1,199 @@
+"""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 get_handlers():
+    handlers = [StreamingHTTPHandler, StreamingHTTPRedirectHandler]
+    if hasattr(httplib, "HTTPS"):
+        handlers.append(StreamingHTTPSHandler)
+    return handlers
+    
+def register_openers():
+    """Register the streaming http handlers in the global urllib2 default
+    opener object.
+
+    Returns the created OpenerDirector object."""
+    opener = urllib2.build_opener(*get_handlers())
+
+    urllib2.install_opener(opener)
+
+    return opener

requests/patches.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.monkeys
+"""

requests/structures.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.structures
+~~~~~~~~~~~~~~~~~~~
+
+Datastructures that power Requests.
+
+"""
+
+from UserDict import DictMixin
+
+
+class CaseInsensitiveDict(DictMixin):
+    """Case-insensitive Dictionary for :class:`Response <models.Response>` Headers.
+
+    For example, ``headers['content-encoding']`` will return the
+    value of a ``'Content-Encoding'`` response header."""
+
+    def __init__(self, *args, **kwargs):
+        # super(CaseInsensitiveDict, self).__init__()
+        self.data = dict(*args, **kwargs)
+
+    def __repr__(self):
+        return self.data.__repr__()
+
+    def __getstate__(self):
+        return self.data.copy()
+
+    def __setstate__(self, d):
+        self.data = d
+
+    def _lower_keys(self):
+        return map(str.lower, self.data.keys())
+
+
+    def __contains__(self, key):
+        return key.lower() in self._lower_keys()
+
+
+    def __getitem__(self, key):
+
+        if key.lower() in self:
+            return self.items()[self._lower_keys().index(key.lower())][1]
+
+
+    def __setitem__(self, key, value):
+        return self.data.__setitem__(key, value)
+
+
+    def __delitem__(self, key):
+        return self.data.__delitem__(key)
+
+
+    def __keys__(self):
+        return self.data.__keys__()
+
+
+    def __iter__(self):
+        return self.data.__iter__()
+
+
+    def iteritems(self):
+        return self.data.iteritems()

setup.py

@@ -3,46 +3,51 @@
 
 import os
 import sys
+import requests
 
 from distutils.core import setup
 
 
-def publish():
-	"""Publish to PyPi"""
-	os.system("python setup.py sdist upload")
 
 if sys.argv[-1] == "publish":
-	publish()
-	sys.exit()
+    os.system("python setup.py sdist upload")
+    sys.exit()
+
+if sys.argv[-1] == "test":
+    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.0',
-	description='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',
-	],
-	install_requires=required,
-	license='ISC',
-	classifiers=(
-		# 'Development Status :: 5 - Production/Stable',
-		'Intended Audience :: Developers',
-		'Natural Language :: English',
-		'License :: OSI Approved :: MIT License',
-		'Programming Language :: Python',
-        # 'Programming Language :: Python :: 2.5',
+    name='requests',
+    version=requests.__version__,
+    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='http://python-requests.org',
+    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',
         '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,47 +1,190 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+from __future__ import with_statement
+
 import unittest
+import cookielib
 
 import requests
 
 
 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')
+    def setUp(self):
+        pass
 
-	def test_HTTP_200_OK_GET(self):
-		r = requests.get('http://google.com')
-		self.assertEqual(r.status_code, 200)
+    def tearDown(self):
+        """Teardown."""
+        pass
 
-	def test_HTTPS_200_OK_GET(self):
-		r = requests.get('https://google.com')
-		self.assertEqual(r.status_code, 200)
+    def test_invalid_url(self):
+        self.assertRaises(ValueError, requests.get, 'hiwpefhipowhefopw')
 
-	def test_HTTP_200_OK_HEAD(self):
-		r = requests.head('http://google.com')
-		self.assertEqual(r.status_code, 200)
+    def test_HTTP_200_OK_GET(self):
+        r = requests.get('http://google.com')
+        self.assertEqual(r.status_code, 200)
 
-	def test_HTTPS_200_OK_HEAD(self):
-		r = requests.head('https://google.com')
-		self.assertEqual(r.status_code, 200)
+    def test_HTTPS_200_OK_GET(self):
+        r = requests.get('https://google.com')
+        self.assertEqual(r.status_code, 200)
 
-	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)
+    def test_HTTP_200_OK_GET_WITH_PARAMS(self):
+        heads = {'User-agent': 'Mozilla/5.0'}
+
+        r = requests.get('http://www.google.com/search', params={'q': 'test'}, headers=heads)
+        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('http://google.com/search?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('http://whatsmyua.com', headers=heads);
+        self.assertTrue(heads['User-agent'] in r.content)
+
+        heads = {
+            'user-agent':
+                'Mozilla/5.0 (github.com/kennethreitz/requests)'
+        }
+
+        r = requests.get('http://whatsmyua.com', headers=heads);
+        self.assertTrue(heads['user-agent'] in r.content)
+
+    def test_HTTP_200_OK_HEAD(self):
+        r = requests.head('http://google.com')
+        self.assertEqual(r.status_code, 200)
+
+    def test_HTTPS_200_OK_HEAD(self):
+        r = requests.head('https://google.com')
+        self.assertEqual(r.status_code, 200)
+
+    def test_AUTH_HTTPS_200_OK_GET(self):
+        auth = ('requeststest', 'requeststest')
+        url = 'https://convore.com/api/account/verify.json'
+        r = requests.get(url, auth=auth)
+
+        self.assertEqual(r.status_code, 200)
+
+        r = requests.get(url)
+        self.assertEqual(r.status_code, 200)
+
+        # reset auto authentication
+        requests.auth_manager.empty()
+
+    def test_POSTBIN_GET_POST_FILES(self):
+        bin = requests.post('http://www.postbin.org/')
+        self.assertEqual(bin.status_code, 302)
+
+        post_url = bin.headers['location']
+        post = requests.post(post_url, data={'some': 'data'})
+        self.assertEqual(post.status_code, 201)
+
+        post2 = requests.post(post_url, files={'some': open('test_requests.py')})
+        self.assertEqual(post2.status_code, 201)
+
+        post3 = requests.post(post_url, data='[{"some": "json"}]')
+        self.assertEqual(post.status_code, 201)
+
+
+    def test_POSTBIN_GET_POST_FILES_WITH_PARAMS(self):
+        bin = requests.post('http://www.postbin.org/')
+        self.assertEqual(bin.status_code, 302)
+
+        post_url = bin.headers['location']
+
+        post2 = requests.post(post_url, files={'some': open('test_requests.py')}, data={'some': 'data'})
+        self.assertEqual(post2.status_code, 201)
+
+
+    def test_POSTBIN_GET_POST_FILES_WITH_HEADERS(self):
+        bin = requests.post('http://www.postbin.org/')
+        self.assertEqual(bin.status_code, 302)
+
+        post_url = bin.headers['location']
+
+        post2 = requests.post(post_url, files={'some': open('test_requests.py')},
+        headers = {'User-Agent': 'requests-tests'})
+
+        self.assertEqual(post2.status_code, 201)
+
+
+    def test_nonzero_evaluation(self):
+        r = requests.get('http://google.com/some-404-url')
+        self.assertEqual(bool(r), False)
+
+        r = requests.get('http://google.com/')
+        self.assertEqual(bool(r), True)
+
+    def test_request_ok_set(self):
+        r = requests.get('http://google.com/some-404-url')
+        self.assertEqual(r.ok, False)
+
+    def test_status_raising(self):
+        r = requests.get('http://google.com/some-404-url')
+        self.assertRaises(requests.HTTPError, r.raise_for_status)
+
+        r = requests.get('http://google.com/')
+        self.assertFalse(r.error)
+        r.raise_for_status()
+
+    def test_cookie_jar(self):
+        """
+        .. todo:: This really doesn't test to make sure the cookie is working
+        """
+
+        jar = cookielib.CookieJar()
+        self.assertFalse(jar)
+
+        requests.get('http://google.com', cookies=jar)
+        self.assertTrue(jar)
+
+    def test_decompress_gzip(self):
+
+        r = requests.get('http://api.stackoverflow.com/1.1/users/495995/top-answer-tags')
+        r.content.decode('ascii')
+
+    def test_autoauth(self):
+
+        conv_auth = ('requeststest', 'requeststest')
+        requests.auth_manager.add_auth('convore.com', conv_auth)
+
+        r = requests.get('https://convore.com/api/account/verify.json')
+        self.assertEquals(r.status_code, 200)
+
+    def test_unicode_get(self):
+        requests.get('http://google.com', params={'foo': u'føø'})
+        requests.get('http://google.com', params={u'føø': u'føø'})
+        requests.get('http://google.com', params={'føø': 'føø'})
+        requests.get('http://google.com', params={'foo': u'foo'})
+        requests.get('http://google.com/ø', params={'foo': u'foo'})
+
+    def test_httpauth_recursion(self):
+        conv_auth = ('requeststest', 'bad_password')
+
+        r = requests.get('https://convore.com/api/account/verify.json', auth=conv_auth)
+        self.assertEquals(r.status_code, 401)
+
+    def test_settings(self):
+        with requests.settings(timeout=0.0001):
+            self.assertRaises(requests.Timeout, requests.get, 'http://google.com')
+
+        with requests.settings(timeout=10):
+            requests.get('http://google.com')
+
+    def test_nonurlencoded_post_data(self):
+        requests.post('http://google.com', data='foo')
 
-		self.assertEqual(r.status_code, 200)
 
 
 if __name__ == '__main__':
-	unittest.main()
+    unittest.main()

tox.ini

@@ -0,0 +1,11 @@
+[tox]
+envlist = py25,py26,py27,pypy
+
+[testenv]
+commands=py.test --junitxml=junit-{envname}.xml
+deps =
+    pytest
+
+[testenv:pypy]
+basepython=/usr/bin/pypy
+