mod string formatting for 2.5

Clarify documentation around async.map and Request.send

.gitignore

@@ -5,4 +5,6 @@ nosetests.xml
 pylint.txt
 *.pyc
 docs/_build
-toy.py
+toy.py
+.gitignore
+junit-report.xml

AUTHORS

@@ -18,4 +18,32 @@ Patches and Suggestions
 - Rob Madole
 - Aram Dulyan
 - Johannes Gorset
-- 村山めがね (Megane Murayama)
+- 村山めがね (Megane Murayama)
+- James Rowe
+- Daniel Schauenberg
+- Zbigniew Siciarz
+- Daniele Tricoli 'Eriol'
+- Richard Boulton
+- Miguel Olivares <miguel@moliware.com>
+- Alberto Paro
+- Jérémy Bethmont
+- 潘旭 (Xu Pan)
+- Tamás Gulácsi
+- Rubén Abad
+- Peter Manser
+- Jeremy Selier
+- Jens Diemer
+- Alex <@alopatin>
+- Tom Hogans <tomhsx@gmail.com>
+- Armin Ronacher
+- Shrikant Sharat Kandula
+- Mikko Ohtamaa
+- Den Shabalin
+- Daniel Miller <danielm@vs-networks.com>
+- Alejandro Giacometti
+- Rick Mak
+- Johan Bergström
+- Josselin Jacquard
+- Travis N. Vaught
+- Fredrik Möllerstrand
+- Daniel Hengeveld

HACKING

@@ -1,15 +0,0 @@
-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,103 @@
 History
 -------
 
+0.7.0 (2011-10-22)
+++++++++++++++++++
+
+* Sessions are now the primary interface.
+* Deprecated InvalidMethodException.
+* PATCH fix.
+* New config system (no more global settings).
+
+
+0.6.6 (2011-10-19)
+++++++++++++++++++
+
+* Session parameter bugfix (params merging).
+
+
+0.6.5 (2011-10-18)
+++++++++++++++++++
+
+* Offline (fast) test suite.
+* Session dictionary argument merging.
+
+
+0.6.4 (2011-10-13)
+++++++++++++++++++
+
+* Automatic decoding of unicode, based on HTTP Headers.
+* New ``decode_unicode`` setting.
+* Removal of ``r.read/close`` methods.
+* New ``r.faw`` interface for advanced response usage.*
+* Automatic expansion of parameterized headers.
+
+
+0.6.3 (2011-10-13)
+++++++++++++++++++
+
+* Beautiful ``requests.async`` module, for making async requests w/ gevent.
+
+
+0.6.2 (2011-10-09)
+++++++++++++++++++
+
+* GET/HEAD obeys allow_redirects=False.
+
+
+0.6.1 (2011-08-20)
+++++++++++++++++++
+
+* Enhanced status codes experience ``\o/``
+* Set a maximum number of redirects (``settings.max_redirects``)
+* Full Unicode URL support
+* Support for protocol-less redirects.
+* Allow for arbitrary request types.
+* Bugfixes
+
+
+0.6.0 (2011-08-17)
+++++++++++++++++++
+
+* New callback hook system
+* New persistient sessions object and context manager
+* Transparent Dict-cookie handling
+* Status code reference object
+* Removed Response.cached
+* Added Response.request
+* All args are kwargs
+* Relative redirect support
+* HTTPError handling improvements
+* Improved https testing
+* Bugfixes
+
+
+0.5.1 (2011-07-23)
+++++++++++++++++++
+
+* International Domain Name Support!
+* Access headers without fetching entire body (``read()``)
+* Use lists as dicts for parameters
+* Add Forced Basic Authentication
+* Forced Basic is default authentication type
+* ``python-requests.org`` default User-Agent header
+* CaseInsensitiveDict lower-case caching
+* Response.history bugfix
+
+
+0.5.0 (2011-06-21)
+++++++++++++++++++
+
+* PATCH Support
+* Support for Proxies
+* HTTPBin Test Suite
+* Redirect Fixes
+* settings.verbose stream writing
+* Querystrings for all methods
+* URLErrors (Connection Refused, Timeout, Invalid URLs) are treated as explicity raised
+  ``r.requests.get('hwe://blah'); r.raise_for_status()``
+
+
 0.4.1 (2011-05-22)
 ++++++++++++++++++
 

MANIFEST.in

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

Makefile

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

README.rst

@@ -1,21 +1,46 @@
-Requests: The Simple (e.g. usable) HTTP Module
-==============================================
+Requests: HTTP for Humans
+=========================
 
-Most existing Python modules for dealing HTTP requests are insane. I have to look up *everything* that I want to do. Most of my worst Python experiences are a result of the various built-in HTTP libraries (yes, even worse than Logging).
+Requests is an ISC Licensed HTTP library, written in Python, for human
+beings.
 
-But this one's different. This one's going to be awesome. And simple.
+Most existing Python modules for sending HTTP requests are extremely
+verbose and cumbersome. Python's builtin urllib2 module provides most of
+the HTTP capabilities you should need, but the api is thoroughly broken.
+It requires an enormous amount of work (even method overrides) to
+perform the simplest of tasks.
+
+Things shouldn't be this way. Not in Python.
+
+::
+
+    >>> r = requests.get('https://api.github.com', auth=('user', 'pass'))
+    >>> r.status_code
+    204
+    >>> r.headers['content-type']
+    'application/json'
+    >>> r.content
+    ...
+
+See `the same code, without Requests <https://gist.github.com/973705>`_.
+
+Requests allow you to send  **HEAD**, **GET**, **POST**, **PUT**,
+**PATCH**, and **DELETE** HTTP requests. You can add headers, form data,
+multipart files, and parameters with simple Python dictionaries, and access the
+response data in the same way. It's powered by urllib2, but it does
+all the hard work and crazy hacks for you.
 
-Really simple.
 
 Features
 --------
 
-- Extremely simple GET, HEAD, POST, PUT, DELETE Requests
+- Extremely simple HEAD, GET, POST, PUT, PATCH, DELETE Requests
     + Simple HTTP Header Request Attachment
     + Simple Data/Params Request Attachment
     + Simple Multipart File Uploads
     + CookieJar Support
     + Redirection History
+    + Proxy Support
     + Redirection Recursion Urllib Fix
     + Auto Decompression of GZipped Content
     + Unicode URL Support
@@ -35,15 +60,14 @@ It couldn't be simpler. ::
 
 HTTPS? Basic Authentication? ::
 
-    >>> r = requests.get('https://convore.com/api/account/verify.json')
+    >>> r = requests.get('https://httpbin.ep.io/basic-auth/user/pass')
     >>> r.status_code
     401
 
 
 Uh oh, we're not authorized! Let's add authentication. ::
 
-    >>> conv_auth = ('requeststest', 'requeststest')
-    >>> r = requests.get('https://convore.com/api/account/verify.json', auth=conv_auth)
+    >>> r = requests.get('https://httpbin.ep.io/basic-auth/user/pass', auth=('user', 'pass'))
 
     >>> r.status_code
     200
@@ -52,77 +76,7 @@ Uh oh, we're not authorized! Let's add authentication. ::
     'application/json'
 
     >>> r.content
-    '{"username": "requeststest", "url": "/users/requeststest/", "id": "9408", "img": "censored-long-url"}'
-
-
-
-API
----
-
-**Requests:**
-
-All request functions return a Response object (see below).
-
-If a {filename: fileobject} dictionary is passed in (files=...), a multipart_encode upload will be performed.
-If CookieJar object is is passed in (cookies=...), the cookies will be sent with the request.
-
-  GET Requests
-    >>> requests.get(url, params={}, headers={}, cookies=None, auth=None)
-    <Response [200]>
-
-  HEAD Requests
-    >>> requests.head(url, params={}, headers={}, cookies=None, auth=None)
-    <Response [200]>
-
-  PUT Requests
-    >>> requests.put(url, data='', headers={}, files={}, cookies=None, auth=None)
-    <Response [200]>
-
-  POST Requests
-    >>> requests.post(url, data={}, headers={}, files={}, cookies=None, auth=None)
-    <Response [200]>
-
-  DELETE Requests
-    >>> requests.delete(url, params={}, headers={}, cookies=None, auth=None)
-    <Response [200]>
-
-
-**Responses:**
-
-    Response.status_code
-         (Integer) Received HTTP Status Code Response
-
-    Response.headers
-        ((CaseInsensitive) Dictionary) Received HTTP Response Headers.
-
-    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.auth_manager.add_auth(url, authobject)
-
+    '{"authenticated": true, "user": "user"}'
 
 
 Installation
@@ -146,11 +100,5 @@ Contribute
 If you'd like to contribute, simply fork `the repository`_, commit your changes to the **develop** branch (or branch off of it), and send a pull request. Make sure you add yourself to AUTHORS_.
 
 
-
-Roadmap
--------
-
-- Sphinx Documentation
-
 .. _`the repository`: http://github.com/kennethreitz/requests
 .. _AUTHORS: http://github.com/kennethreitz/requests/blob/master/AUTHORS

docs/_templates/sidebarintro.html

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

docs/_templates/sidebarlogo.html

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

docs/_themes/kr/layout.html

@@ -30,4 +30,18 @@
       })();
 
     </script>
+
+    <script type="text/javascript">
+      (function() {
+        var t   = document.createElement('script');
+        t.type  = 'text/javascript';
+        t.async = true;
+        t.id    = 'gauges-tracker';
+        t.setAttribute('data-site-id',
+                       '4ddc27f6613f5d186d000007');
+        t.src = '//secure.gaug.es/track.js';
+        var s = document.getElementsByTagName('script')[0];
+        s.parentNode.insertBefore(t, s);
+      })();
+    </script>
 {%- endblock %}

docs/_themes/kr/static/flasky.css_t

@@ -91,8 +91,8 @@ div.sphinxsidebarwrapper {
 }
 
 div.sphinxsidebarwrapper p.logo {
-    padding: 0 0 20px 0;
-    margin: 0;
+    padding: 0;
+    margin: -10px 0 0 -20px;
     text-align: center;
 }
 
@@ -461,3 +461,9 @@ a:hover tt {
     background-color: #ccc;
     -webkit-border-radius: 3px;
 }
+
+/* misc. */
+
+.revsys-inline {
+    display: none!important;
+}

docs/api.rst

@@ -13,32 +13,64 @@ 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.
+All of Request's functionality can be accessed by these 7 methods.
+They all return an instance of the :class:`Response <Response>` object.
 
+.. autofunction:: request
+.. autofunction:: head
 .. autofunction:: get
 .. autofunction:: post
 .. autofunction:: put
+.. autofunction:: patch
 .. autofunction:: delete
-.. autofunction:: head
+
 
 -----------
 
 
-.. autoclass:: requests.models.Response
+.. autoclass:: Response
    :inherited-members:
 
+Async
+-----
 
-Exceptions
-----------
+.. module:: requests.async
 
-.. autoexception:: HTTPError
 
-.. autoexception:: RequestException
+.. autofunction:: map
+.. autofunction:: request
+.. autofunction:: head
+.. autofunction:: get
+.. autofunction:: post
+.. autofunction:: put
+.. autofunction:: patch
+.. autofunction:: delete
 
-.. autoexception:: requests.models.AuthenticationError
-.. autoexception:: requests.models.URLRequired
-.. autoexception:: requests.models.InvalidMethod
+
+
+Utilities
+---------
+
+These functions are used internally, but may be useful outside of
+Requests.
+
+.. module:: requests.utils
+
+Cookies
+~~~~~~~
+
+.. autofunction:: dict_from_cookiejar
+.. autofunction:: cookiejar_from_dict
+.. autofunction:: add_dict_to_cookiejar
+
+
+Encodings
+~~~~~~~~~
+
+.. autofunction:: get_encodings_from_content
+.. autofunction:: get_encoding_from_headers
+.. autofunction:: get_unicode_from_response
+.. autofunction:: decode_gzip
 
 
 Internals
@@ -48,19 +80,26 @@ 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
-~~~~~~~~~
+Exceptions
+~~~~~~~~~~
+
+.. module:: requests
+
+.. autoexception:: HTTPError
+
+.. autoexception:: RequestException
+
+.. autoexception:: AuthenticationError
+.. autoexception:: URLRequired
+.. autoexception:: InvalidMethod
+.. autoexception:: TooManyRedirects
+
 
-.. autofunction:: request
 
 Classes
 ~~~~~~~
 
-.. autoclass:: requests.models.Request
+.. autoclass:: requests.Request
    :inherited-members:
 
-Structures
-~~~~~~~~~~
 
-.. autoclass:: requests.structures.CaseInsensitiveDict
-   :inherited-members:

docs/community/faq.rst

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

docs/community/out-there.rst

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

docs/community/support.rst

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

docs/community/updates.rst

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

docs/conf.py

@@ -155,7 +155,7 @@ html_sidebars = {
 #html_split_index = False
 
 # If true, links to the reST sources are added to the pages.
-html_show_sourcelink = True
+html_show_sourcelink = False
 
 # If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
 html_show_sphinx = False

docs/dev/authors.rst

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

docs/dev/todo.rst

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

docs/index.rst

@@ -13,7 +13,8 @@ Requests is an :ref:`ISC Licensed <isc>` HTTP library, written in Python, for hu
 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.
+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.
 
@@ -21,50 +22,76 @@ Things shouldn’t be this way. Not in Python.
 
     >>> r = requests.get('https://api.github.com', auth=('user', 'pass'))
     >>> r.status_code
-    200
+    204
     >>> r.headers['content-type']
     'application/json'
+    >>> r.content
+    ...
 
 See `the same code, without Requests <https://gist.github.com/973705>`_.
 
-Requests allow you to send **GET**, **HEAD**, **PUT**,
-**POST**, and **DELETE** HTTP requests. You can add headers, form data,
+Requests allow you to send  **HEAD**, **GET**, **POST**, **PUT**,
+**PATCH**, and **DELETE** HTTP requests. You can add headers, form data,
 multipart files, and parameters with simple Python dictionaries, and access the
 response data in the same way. It's powered by :py:class:`urllib2`, but it does
 all the hard work and crazy hacks for you.
 
-Testimonals
------------
+Testimonials
+------------
 
-`Twitter, Inc <http://twitter.com>`_ and `The Library of Congress <http://www.loc.gov/>`_ use Requests internally.
+`Twitter, Inc <http://twitter.com>`_,
+a U.S. Federal Institution,
+NIH, 
+`Readability <http://readability.com>`_, and
+`Work for Pie <http://workforpie.com>`_
+use Requests internally.
+
+**Armin Ronacher**
+    Requests is the perfect example how beautiful an API can be with the
+    right level of abstraction.
 
 **Daniel Greenfeld**
-    Nuked a 1200 LOC spaghetti code library with 10 lines of code thanks to @kennethreitz's request library. Today has been AWESOME.
+    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.
+    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.
+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
 
    user/intro
    user/install
-..   user/quickstart
+   user/quickstart
    user/advanced
 
 
+Community Guide
+-----------------
+
+This part of the documentation, which is mostly prose, details the
+Requests ecosystem and community.
+
+.. toctree::
+   :maxdepth: 2
+
+   community/faq
+   community/out-there.rst
+   community/support
+   community/updates
+
 API Documentation
 -----------------
 
@@ -87,3 +114,5 @@ you.
    :maxdepth: 2
 
    dev/internals
+   dev/todo
+   dev/authors

docs/user/advanced.rst

@@ -0,0 +1,172 @@
+.. _advanced:
+
+Advanced Usage
+==============
+
+This document covers some of Requests more advanced features.
+
+
+Session Objects
+---------------
+
+The Session object allows you to persist certain parameters across
+requests. It also establishes a CookieJar and passes it along
+to any requests made from the Session instance.
+
+A session object has all the methods of the main Requests API.
+
+Let's persist some cookies across requests::
+
+    s = requests.session()
+
+    s.get('http://httpbin.org/cookies/set/sessioncookie/123456789')
+    r = s.get("http://httpbin.org/cookies")
+
+    print r.content
+    # '{"cookies": {"sessioncookie": "123456789"}}'
+
+
+Sessions can also be used to provide default data to the request methods::
+
+    headers = {'x-test': 'true'}
+    auth = ('user', 'pass')
+
+    with requests.session(auth=auth, headers=headers) as c:
+
+        # both 'x-test' and 'x-test2' are sent
+        c.get('http://httpbin.org/headers', headers={'x-test2': 'true'})
+
+
+.. admonition:: Global Settings
+
+    Certain parameters are best set in the ``config`` dictionary
+    (e.g. user agent header).
+
+
+Asynchronous Requests
+----------------------
+
+Requests has first-class support for non-blocking i/o requests, powered
+by gevent. This allows you to send a bunch of HTTP requests at the same
+
+First, let's import the async module. Heads up — if you don't have
+`gevent <gevent>`_ this will fail::
+
+    from requests import async
+
+The ``async`` module has the exact same api as ``requests``, except it
+doesn't send the request immediately. Instead, it returns the ``Request``
+object.
+
+We can build a list of ``Request`` objects easily::
+
+    urls = [
+        'http://python-requests.org',
+        'http://httpbin.org',
+        'http://python-guide.org',
+        'http://kennethreitz.com'
+    ]
+
+    rs = [async.get(u) for u in urls]
+
+Now we have a list of ``Request`` objects, ready to be sent. We could send them
+one at a time with ``Request.send()``, but that would take a while.  Instead,
+we'll send them all at the same time with ``async.map()``.  Using ``async.map()``
+will also guarantee execution of the ``response`` hook, described below. ::
+
+    >>> async.map(rs)
+    [<Response [200]>, <Response [200]>, <Response [200]>, <Response [200]>]
+
+
+Event Hooks
+-----------
+
+Requests has a hook system that you can use to manipulate portions of
+the request process, or signal event handling.
+
+Available hooks:
+
+``args``:
+    A dictionary of the arguments being sent to Request().
+
+``pre_request``:
+    The Request object, directly before being sent.
+
+``post_request``:
+    The Request object, directly after being sent.
+
+``response``:
+    The response generated from a Request.
+
+
+You can assign a hook function on a per-request basis by passing a
+``{hook_name: callback_function}`` dictionary to the ``hooks`` request
+parameter::
+
+    hooks=dict(args=print_url)
+
+That ``callback_function`` will receive a chunk of data as its first
+argument.
+
+::
+
+    def print_url(args):
+        print args['url']
+
+If an error occurs while executing your callback, a warning is given.
+
+If the callback function returns a value, it is assumed that it is to
+replace the data that was passed in. If the function doesn't return
+anything, nothing else is effected.
+
+Let's print some request method arguments at runtime::
+
+    >>> requests.get('http://httpbin', hooks=dict(args=print_url))
+    http://httpbin
+    <Response [200]>
+
+Let's hijack some arguments this time with a new callback::
+
+    def hack_headers(args):
+        if not args[headers]:
+            args['headers'] = dict()
+
+        args['headers'].update({'X-Testing': 'True'})
+
+        return args
+
+    hooks = dict(args=hack_headers)
+    headers = dict(yo=dawg)
+
+And give it a try::
+
+    >>> requests.get('http://httpbin/headers', hooks=hooks, headers=headers)
+    {
+        "headers": {
+            "Content-Length": "",
+            "Accept-Encoding": "gzip",
+            "Yo": "dawg",
+            "X-Forwarded-For": "::ffff:24.127.96.129",
+            "Connection": "close",
+            "User-Agent": "python-requests.org",
+            "Host": "httpbin.org",
+            "X-Testing": "True",
+            "X-Forwarded-Protocol": "",
+            "Content-Type": ""
+        }
+    }
+
+
+
+Verbose Logging
+---------------
+
+If you want to get a good look at what HTTP requests are being sent
+by your application, you can turn on verbose logging.
+
+To do so, just configure Requests with a stream to write to::
+
+    >>> requests.settings.verbose = sys.stderr
+    >>> requests.get('http://httpbin.org/headers')
+    2011-08-17T03:04:23.380175   GET   http://httpbin.org/headers
+    <Response [200]>

docs/user/install.rst

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

docs/user/intro.rst

@@ -1,3 +1,5 @@
+.. _introduction:
+
 Introduction
 ============
 
@@ -19,10 +21,16 @@ 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 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.
 
-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.
+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`_.
 
@@ -39,17 +47,3 @@ Requests License
 
     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

@@ -1,84 +1,138 @@
-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:
 
 Quickstart
 ==========
 
+.. module:: requests.models
 
-GET Request
------------
+Eager to get started? This page gives a good introduction in how to get started
+with Requests. This assumes you already have Requests installed. If you do not,
+head over to the :ref:`Installation <install>` section.
+
+First, make sure that:
+
+* Requests is :ref:`installed <install>`
+* Requests is :ref:`up-to-date <updates>`
 
 
-Adding Parameters
------------------
+Lets gets started with some simple use cases and examples.
 
 
-
-Adding Headers
---------------
-
-
-
-HTTP Basic Auth
----------------
-
-
-Tracking Redirects
+Make a GET Request
 ------------------
 
+Making a standard request with Requests is very simple.
+
+Let's get GitHub's public timeline ::
+
+    r = requests.get('https://github.com/timeline.json')
+
+Now, we have a :class:`Response` object called ``r``. We can get all the
+information we need from this.
 
 
+Response Content
+----------------
 
-HTTP POST (Form Data)
+We can read the content of the server's response::
+
+    >>> r.content
+    '[{"repository":{"open_issues":0,"url":"https://github.com/...
+
+
+Response Status Codes
 ---------------------
 
+We can check the response status code::
 
-HTTP POST (Binary Data)
------------------------
+    >>> r.status_code
+    200
+
+Requests also comes with a built-in status code lookup object for easy
+reference::
+
+    >>> r.status_code == requests.codes.ok
+    True
+
+If we made a bad request, we can raise it with
+:class:`Response.raise_for_status()`::
+
+    >>> _r = requests.get('http://httpbin.org/status/404')
+    >>> _r.status_code
+    404
+
+    >>> _r.raise_for_status()
+    Traceback (most recent call last):
+      File "requests/models.py", line 394, in raise_for_status
+        raise self.error
+    urllib2.HTTPError: HTTP Error 404: NOT FOUND
+
+But, since our ``status_code`` was ``200``, when we call it::
+
+    >>> r.raise_for_status()
+    None
+
+All is well.
 
 
-HTTP POST (Multipart Files)
----------------------------
+Response Headers
+----------------
+
+We can view the server's response headers with a simple Python dictionary
+interface::
+
+    >>> r.headers
+    {
+        'status': '200 OK',
+        'content-encoding': 'gzip',
+        'transfer-encoding': 'chunked',
+        'connection': 'close',
+        'server': 'nginx/1.0.4',
+        'x-runtime': '148ms',
+        'etag': '"e1ca502697e5c9317743dc078f67693f"',
+        'content-type': 'application/json; charset=utf-8'
+    }
+
+The dictionary is special, though: it's made just for HTTP headers. According to
+`RFC 2616 <http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html>`_, HTTP
+Headers are case-insensitive.
+
+So, we can access the headers using any capitalization we want::
+
+    >>> r.headers['Content-Type']
+    'application/json; charset=utf-8'
+
+    >>> r.headers.get('content-type')
+    'application/json; charset=utf-8'
+
+If a header doesn't exist in the Response, its value defaults to ``None``::
+
+    >>> r.headers['X-Random']
+    None
 
 
-HTTP PUT
---------
+Cookies
+-------
 
+If a response contains some Cookies, you can get quick access to them::
 
-HTTP DELETE
------------
+    >>> url = 'http://httpbin.org/cookies/set/requests-is/awesome'
+    >>> r = requests.get(url)
 
+    >>> print r.cookies
+    {'requests-is': 'awesome'}
 
-HTTP HEAD
----------
+The underlying CookieJar is also available for more advanced handling::
+
+    >>> r.request.cookiejar
+    <cookielib.CookieJar>
+
+To send your own cookies to the server, you can use the ``cookies``
+parameter::
+
+    >>> url = 'http://httpbin.org/cookies'
+    >>> cookies = dict(cookies_are='working')
+
+    >>> r = requests.get(url, cookies=cookies)
+    >>> r.content
+    '{"cookies": {"cookies_are": "working"}}'

reqs.txt

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

requests/__init__.py

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

requests/api.py

@@ -4,118 +4,101 @@
 requests.api
 ~~~~~~~~~~~~
 
-This module impliments the Requests API.
+This module implements 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
+from .sessions import session
+
+__all__ = ('request', 'get', 'head', 'post', 'patch', 'put', 'delete')
 
 
-__all__ = ('request', 'get', 'head', 'post', 'put', 'delete')
+def request(method, url,
+    params=None,
+    data=None,
+    headers=None,
+    cookies=None,
+    files=None,
+    auth=None,
+    timeout=None,
+    allow_redirects=False,
+    proxies=None,
+    hooks=None,
+    return_response=True,
+    config=None):
 
-
-
-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)
+    s = session()
+    return s.request(
+        method, url, params, data, headers, cookies, files, auth,
+        timeout, allow_redirects, proxies, hooks, return_response,
+        config
     )
 
-    r.send()
-
-    return r.response
 
 
-def get(url, params={}, headers={}, cookies=None, auth=None, **kwargs):
+def get(url, **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.
+    :param **kwargs: Optional arguments that ``request`` takes.
     """
 
-    return request('GET', url, params=params, headers=headers, cookies=cookies, auth=auth, **kwargs)
+    kwargs.setdefault('allow_redirects', True)
+    return request('GET', url, **kwargs)
 
 
-def head(url, params={}, headers={}, cookies=None, auth=None, **kwargs):
+def head(url, **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.
+    :param **kwargs: Optional arguments that ``request`` takes.
     """
 
-    return request('HEAD', url, params=params, headers=headers, cookies=cookies, auth=auth, **kwargs)
+    kwargs.setdefault('allow_redirects', True)
+    return request('HEAD', url, **kwargs)
 
 
-def post(url, data={}, headers={}, files=None, cookies=None, auth=None, **kwargs):
+def post(url, data='', **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.
+    :param data: (optional) Dictionary or bytes to send in the body of the :class:`Request`.
+    :param **kwargs: Optional arguments that ``request`` takes.
     """
 
-    return request('POST', url, data=data, headers=headers, files=files, cookies=cookies, auth=auth, **kwargs)
+    return request('post', url, data=data, **kwargs)
 
 
-def put(url, data='', headers={}, files={}, cookies=None, auth=None, **kwargs):
+def put(url, data='', **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.
+    :param data: (optional) Dictionary or bytes to send in the body of the :class:`Request`.
+    :param **kwargs: Optional arguments that ``request`` takes.
     """
 
-    return request('PUT', url, data=data, headers=headers, files=files, cookies=cookies, auth=auth, **kwargs)
+    return request('put', url, data=data, **kwargs)
 
 
-def delete(url, params={}, headers={}, cookies=None, auth=None, **kwargs):
+def patch(url, data='', **kwargs):
+    """Sends a PATCH request. Returns :class:`Response` object.
+
+    :param url: URL for the new :class:`Request` object.
+    :param data: (optional) Dictionary or bytes to send in the body of the :class:`Request`.
+    :param **kwargs: Optional arguments that ``request`` takes.
+    """
+
+    return request('patch', url,  data='', **kwargs)
+
+
+def delete(url, **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.
+    :param **kwargs: Optional arguments that ``request`` takes.
     """
 
-    return request('DELETE', url, params=params, headers=headers, cookies=cookies, auth=auth, **kwargs)
+    return request('delete', url, **kwargs)

requests/async.py

@@ -1,41 +1,84 @@
 # -*- coding: utf-8 -*-
 
 """
-    requests.async
-    ~~~~~~~~~~~~~~
+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.
+This module contains an asynchronous replica of ``requests.api``, powered
+by gevent. All API methods return a ``Request`` instance (as opposed to
+``Response``). A list of requests can be sent with ``map()``.
 """
 
-
-from __future__ import absolute_import
-
-import urllib
-import urllib2
-
-from urllib2 import HTTPError
-
-
 try:
-    import eventlet
-    eventlet.monkey_patch()
+    import gevent
+    from gevent import monkey as curious_george
 except ImportError:
-    pass
+    raise RuntimeError('Gevent is required for requests.async.')
 
-if not 'eventlet' in locals():
-    try:
-        from gevent import monkey
-        monkey.patch_all()
-    except ImportError:
-        pass
+# Monkey-patch.
+curious_george.patch_all(thread=False)
+
+from . import api
+from .hooks import dispatch_hook
+
+
+__all__ = (
+    'map',
+    'get', 'head', 'post', 'put', 'patch', 'delete', 'request'
+)
+
+
+def _patched(f):
+    """Patches a given API function to not send."""
+
+    def wrapped(*args, **kwargs):
+        return f(*args, return_response=False, **kwargs)
+
+    return wrapped
+
+
+def _send(r, pools=None):
+    """Sends a given Request object."""
+
+    if pools:
+        r._pools = pools
+
+    r.send()
+
+    # Post-request hook.
+    r = dispatch_hook('post_request', r.hooks, r)
+
+    # Response manipulation hook.
+    r.response = dispatch_hook('response', r.hooks, r.response)
+
+    return r.response
+
+
+# Patched requests.api functions.
+get = _patched(api.get)
+head = _patched(api.head)
+post = _patched(api.post)
+put = _patched(api.put)
+patch = _patched(api.patch)
+delete = _patched(api.delete)
+request = _patched(api.request)
+
+
+def map(requests, prefetch=True):
+    """Concurrently converts a list of Requests to Responses.
+
+    :param requests: a collection of Request objects.
+    :param prefetch: If False, the content will not be downloaded immediately.
+    """
+
+    jobs = [gevent.spawn(_send, r) for r in requests]
+    gevent.joinall(jobs)
+
+    if prefetch:
+        [r.response.content for r in requests]
+
+    return [r.response for r in requests]
 
 
-if not 'eventlet' in locals():
-    raise ImportError('No Async adaptations of urllib2 found!')
 
 
-from .core import *

requests/config.py

@@ -1,56 +0,0 @@
-# -*- 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,25 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""
-requests.core
-~~~~~~~~~~~~~
-
-This module implements the main Requests system.
-
-:copyright: (c) 2011 by Kenneth Reitz.
-:license: ISC, see LICENSE for more details.
-
-"""
-
-__title__ = 'requests'
-__version__ = '0.4.1'
-__build__ = 0x000401
-__author__ = 'Kenneth Reitz'
-__license__ = 'ISC'
-__copyright__ = 'Copyright 2011 Kenneth Reitz'
-
-
-from models import HTTPError, auth_manager
-from api import *
-from exceptions import *
-from config import settings

requests/defaults.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.defaults
+~~~~~~~~~~~~~~~~~
+
+This module provides the Requests configuration defaults.
+
+settings parameters:
+
+- :base_headers: - Sets default User-Agent to `python-requests.org`
+- :accept_gzip:  - Whether or not to accept gzip-compressed data
+- :proxies: - http proxies?
+- :verbose: - display verbose information?
+- :timeout: - timeout time until request terminates
+- :max_redirects: - maximum number of allowed redirects?
+- :decode_unicode: - whether or not to accept unicode?
+
+"""
+
+from . import __version__
+
+defaults = dict()
+
+
+defaults['base_headers'] = {
+    'User-Agent': 'python-requests/%s' % __version__,
+    'Accept-Encoding': ', '.join([ 'identity', 'deflate', 'compress', 'gzip' ]),
+}
+
+defaults['proxies'] = {}
+defaults['verbose'] = None
+defaults['timeout'] = None
+defaults['max_redirects'] = 30
+defaults['decode_unicode'] = True
+defaults['timeout_fallback'] = True
+# defaults['keep_alive'] = True
+# defaults['max_connections'] = 10

requests/exceptions.py

@@ -2,22 +2,24 @@
 
 """
 requests.exceptions
-~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~
+
+This module contains the set of Requests' exceptions.
 
 """
 
 class RequestException(Exception):
-    """There was an ambiguous exception that occured while handling your
+    """There was an ambiguous exception that occurred 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."""
+class TooManyRedirects(RequestException):
+    """Too many redirects."""

requests/hooks.py

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

requests/models.py

@@ -1,3 +1,4 @@
+
 # -*- coding: utf-8 -*-
 
 """
@@ -6,63 +7,90 @@ requests.models
 
 """
 
-import requests
 import urllib
 import urllib2
 import socket
 import zlib
 
 from urllib2 import HTTPError
-from urlparse import urlparse
+from urlparse import urlparse, urlunparse, urljoin
+from datetime import datetime
 
-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
+from .utils import (dict_from_cookiejar, get_unicode_from_response, stream_decode_response_unicode, decode_gzip, stream_decode_gzip)
+from .status_codes import codes
+from .exceptions import Timeout, URLRequired, TooManyRedirects
+from .monkeys import Request as _Request
+from .monkeys import (
+    HTTPBasicAuthHandler, HTTPForcedBasicAuthHandler,
+    HTTPDigestAuthHandler, HTTPRedirectHandler)
+
+
+REDIRECT_STATI = (codes.moved, codes.found, codes.other, codes.temporary_moved)
 
 
 
 class Request(object):
-    """The :class:`Request <models.Request>` object. It carries out all functionality of
+    """The :class:`Request <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(),
+        params=dict(),
+        auth=None,
+        cookies=None,
+        timeout=None,
+        redirect=False,
+        allow_redirects=False,
+        proxies=None,
+        hooks=None,
+        config=None):
 
-    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)
+        #: Float describes the timeout of the request.
+        #  (Use socket.setdefaulttimeout() as fallback)
+        self.timeout = timeout
 
         #: Request URL.
         self.url = url
-        #: Dictonary of HTTP Headers to attach to the :class:`Request <models.Request>`.
+
+        #: Dictionary of HTTP Headers to attach to the :class:`Request <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.
+
+        #: HTTP Method to use.
         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
+
+        #: Dictionary or byte of request body data to attach to the
+        #: :class:`Request <Request>`.
+        self.data = None
+
+        #: Dictionary or byte of querystring data to attach to the
+        #: :class:`Request <Request>`.
+        self.params = None
+
+        #: True if :class:`Request <Request>` is part of a redirect chain (disables history
         #: and HTTPError storage).
         self.redirect = redirect
+
         #: Set to True if full redirects are allowed (e.g. re-POST-ing of data at new ``Location``)
         self.allow_redirects = allow_redirects
 
-        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
+        # Dictionary mapping protocol to the URL of the proxy (e.g. {'http': 'foo.bar:3128'})
+        self.proxies = proxies
 
-        #: :class:`Response <models.Response>` instance, containing
+        self.data, self._enc_data = self._encode_params(data)
+        self.params, self._enc_params = self._encode_params(params)
+
+        #: :class:`Response <Response>` instance, containing
         #: content and metadata of HTTP Response, once :attr:`sent <send>`.
         self.response = Response()
 
@@ -70,49 +98,64 @@ class Request(object):
             auth = AuthObject(*auth)
         if not auth:
             auth = auth_manager.get_auth(self.url)
-        #: :class:`AuthObject` to attach to :class:`Request <models.Request>`.
+
+        #: :class:`AuthObject` to attach to :class:`Request <Request>`.
         self.auth = auth
-        #: CookieJar to attach to :class:`Request <models.Request>`.
-        self.cookiejar = cookiejar
+
+        #: CookieJar to attach to :class:`Request <Request>`.
+        self.cookies = cookies
+
+        #: Dictionary of configurations for this request.
+        self.config = config
+
         #: True if Request has been sent.
         self.sent = False
 
+        #: Event-handling hooks.
+        self.hooks = hooks
+
+        if headers:
+            headers = CaseInsensitiveDict(self.headers)
+        else:
+            headers = CaseInsensitiveDict()
+
+        for (k, v) in self.config.get('base_headers', {}).items():
+            if k not in headers:
+                headers[k] = v
+
+        self.headers = headers
+
 
     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.cookies is not None:
+            _handlers.append(urllib2.HTTPCookieProcessor(self.cookies))
 
         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)
+            if not isinstance(self.auth.handler,
+                (urllib2.AbstractBasicAuthHandler,
+                urllib2.AbstractDigestAuthHandler)):
+
+                # TODO: REMOVE THIS COMPLETELY
+                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)
 
+        if self.proxies:
+            _handlers.append(urllib2.ProxyHandler(self.proxies))
 
         _handlers.append(HTTPRedirectHandler)
 
@@ -135,25 +178,32 @@ class Request(object):
 
         return opener.open
 
-    def _build_response(self, resp):
-        """Build internal :class:`Response <models.Response>` object from given response."""
+
+    def _build_response(self, resp, is_error=False):
+        """Build internal :class:`Response <Response>` object
+        from given response.
+        """
+
 
         def build(resp):
 
             response = Response()
+            response.config = self.config
             response.status_code = getattr(resp, 'code', None)
 
             try:
                 response.headers = CaseInsensitiveDict(getattr(resp.info(), 'dict', None))
-                response.content = resp.read()
+                response.raw = resp
+
+                if self.cookies:
+                    response.cookies = dict_from_cookiejar(self.cookies)
+
+
             except AttributeError:
                 pass
 
-            if response.headers['content-encoding'] == 'gzip':
-                try:
-                    response.content = zlib.decompress(response.content, 16+zlib.MAX_WBITS)
-                except zlib.error:
-                    pass
+            if is_error:
+                response.error = resp
 
             response.url = getattr(resp, 'url', None)
 
@@ -164,34 +214,49 @@ class Request(object):
 
         r = build(resp)
 
-        if self.redirect:
+        if r.status_code in REDIRECT_STATI and not self.redirect:
 
             while (
                 ('location' in r.headers) and
-                ((self.method in ('GET', 'HEAD')) or
-                (r.status_code is 303) or
-                (self.allow_redirects))
+                ((r.status_code is codes.see_other) or (self.allow_redirects))
             ):
 
+                r.raw.close()
+
+                if not len(history) < self.config.get('max_redirects'):
+                    raise TooManyRedirects()
+
                 history.append(r)
 
                 url = r.headers['location']
 
-                # Facilitate for non-RFC2616-compliant 'location' headers
+                # Handle redirection without scheme (see: RFC 1808 Section 4)
+                if url.startswith('//'):
+                    parsed_rurl = urlparse(r.url)
+                    url = '%s:%s' % (parsed_rurl.scheme, url)
+
+                # Facilitate non-RFC2616-compliant 'location' headers
                 # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
                 if not urlparse(url).netloc:
-                    parent_url_components = urlparse(self.url)
-                    url = '%s://%s/%s' % (parent_url_components.scheme, parent_url_components.netloc, url)
+                    url = urljoin(r.url, urllib.quote(urllib.unquote(url)))
 
                 # http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.4
-                if r.status_code is 303:
+                if r.status_code is codes.see_other:
                     method = 'GET'
                 else:
                     method = self.method
 
                 request = Request(
-                    url, self.headers, self.files, method,
-                    self.data, self.auth, self.cookiejar, redirect=False
+                    url=url,
+                    headers=self.headers,
+                    files=self.files,
+                    method=method,
+                    # data=self.data,
+                    # params=self.params,
+                    auth=self.auth,
+                    cookies=self.cookies,
+                    redirect=True,
+                    config=self.config
                 )
                 request.send()
                 r = request.response
@@ -199,19 +264,50 @@ class Request(object):
             r.history = history
 
         self.response = r
+        self.response.request = self
 
 
     @staticmethod
-    def _build_url(url, data=None):
-        """Build URLs."""
+    def _encode_params(data):
+        """Encode parameters in a piece of data.
 
-        if urlparse(url).query:
-            return '%s&%s' % (url, data)
+        If the data supplied is a dictionary, encodes each parameter in it, and
+        returns a list of tuples containing the encoded parameters, and a urlencoded
+        version of that.
+
+        Otherwise, assumes the data is already encoded appropriately, and
+        returns it twice.
+        """
+
+        if hasattr(data, 'items'):
+            result = []
+            for k, vs in data.items():
+                for v in isinstance(vs, list) and vs or [vs]:
+                    result.append((k.encode('utf-8') if isinstance(k, unicode) else k,
+                                   v.encode('utf-8') if isinstance(v, unicode) else v))
+            return result, urllib.urlencode(result, doseq=True)
         else:
-            if data:
-                return '%s?%s' % (url, data)
+            return data, data
+
+
+    def _build_url(self):
+        """Build the actual URL to use."""
+
+        # Support for unicode domain names and paths.
+        scheme, netloc, path, params, query, fragment = urlparse(self.url)
+        netloc = netloc.encode('idna')
+        if isinstance(path, unicode):
+            path = path.encode('utf-8')
+        path = urllib.quote(urllib.unquote(path))
+        self.url = str(urlunparse([ scheme, netloc, path, params, query, fragment ]))
+
+        if self._enc_params:
+            if urlparse(self.url).query:
+                return '%s&%s' % (self.url, self._enc_params)
             else:
-                return url
+                return '%s?%s' % (self.url, self._enc_params)
+        else:
+            return self.url
 
 
     def send(self, anyway=False):
@@ -224,92 +320,134 @@ class Request(object):
         :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)
+        # Some people...
+        if not self.url:
+            raise URLRequired
+
+        # Logging
+        if self.config.get('verbose'):
+            self.config.get('verbose').write('%s   %s   %s\n' % (
+                datetime.now().isoformat(), self.method, self.url
+            ))
+
+        # Build the URL
+        url = self._build_url()
+
+        # Attach uploaded files.
+        if self.files:
+            register_openers()
+
+            # Add form-data to the multipart.
+            if self.data:
+                self.files.update(self.data)
+
+            data, headers = multipart_encode(self.files)
+
         else:
+            data = self._enc_data
+            headers = {}
 
-            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)
+        # Build the Urllib2 Request.
+        req = _Request(url, data=data, headers=headers, method=self.method)
 
+        # Add the headers to the request.
         if self.headers:
-            req.headers.update(self.headers)
+            for k,v in self.headers.iteritems():
+                req.add_header(k, v)
 
         if not self.sent or anyway:
 
             try:
                 opener = self._get_opener()
-                resp = opener(req)
+                try:
 
-                if self.cookiejar is not None:
-                    self.cookiejar.extract_cookies(resp, req)
+                    resp = opener(req, timeout=self.timeout)
+
+                except TypeError, err:
+                    # timeout argument is new since Python v2.6
+                    if not 'timeout' in str(err):
+                        raise
+
+                    if self.config.get('timeout_fallback'):
+                        # fall-back and use global socket timeout (This is not thread-safe!)
+                        old_timeout = socket.getdefaulttimeout()
+                        socket.setdefaulttimeout(self.timeout)
+
+                    resp = opener(req)
+
+                    if self.config.get('timeout_fallback'):
+                        # restore global timeout
+                        socket.setdefaulttimeout(old_timeout)
+
+                if self.cookies is not None:
+                    self.cookies.extract_cookies(resp, req)
+
+            except (urllib2.HTTPError, urllib2.URLError), why:
+                if hasattr(why, 'reason'):
+                    if isinstance(why.reason, socket.timeout):
+                        why = Timeout(why)
+                    elif isinstance(why.reason, socket.error):
+                        why = Timeout(why)
+
+                self._build_response(why, is_error=True)
 
-            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
+    """The core :class:`Response <Response>` object. All
+    :class:`Request <Request>` objects contain a
+    :class:`response <Response>` attribute, which is an instance
     of this class.
     """
 
     def __init__(self):
-        #: 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
+
+        self._content = None
+        self._content_consumed = False
+
         #: Integer Code of responded HTTP Status.
         self.status_code = None
+
         #: Case-insensitive Dictionary of Response Headers.
         #: For example, ``headers['content-encoding']`` will return the
         #: value of a ``'Content-Encoding'`` response header.
         self.headers = CaseInsensitiveDict()
+
+        #: File-like object representation of response (for advanced usage).
+        self.raw = None
+
         #: Final URL location of Response.
         self.url = None
-        #: True if no :attr:`error` occured.
+
+        #: True if no :attr:`error` occurred.
         self.ok = False
-        #: Resulting :class:`HTTPError` of request, if one occured.
+
+        #: Resulting :class:`HTTPError` of request, if one occurred.
         self.error = None
-        #: True, if the response :attr:`content` is cached locally.
-        self.cached = False
-        #: A list of :class:`Response <models.Response>` objects from
+
+        #: A list of :class:`Response <Response>` objects from
         #: the history of the Request. Any redirect responses will end
         #: up here.
         self.history = []
 
+        #: The :class:`Request <Request>` that created the Response.
+        self.request = None
+
+        #: A dictionary of Cookies the server sent back.
+        self.cookies = None
+
+        #: Dictionary of configurations for this request.
+        self.config = None
+
 
     def __repr__(self):
         return '<Response [%s]>' % (self.status_code)
@@ -317,19 +455,71 @@ class Response(object):
 
     def __nonzero__(self):
         """Returns true if :attr:`status_code` is 'OK'."""
+
         return not self.error
 
+    def iter_content(self, chunk_size=10 * 1024, decode_unicode=None):
+        """Iterates over the response data.  This avoids reading the content
+        at once into memory for large responses.  The chunk size is the number
+        of bytes it should read into memory.  This is not necessarily the
+        length of each item returned as decoding can take place.
+        """
+        if self._content_consumed:
+            raise RuntimeError('The content for this response was '
+                               'already consumed')
+
+        def generate():
+            while 1:
+                chunk = self.raw.read(chunk_size)
+                if not chunk:
+                    break
+                yield chunk
+            self._content_consumed = True
+        gen = generate()
+        if 'gzip' in self.headers.get('content-encoding', ''):
+            gen = stream_decode_gzip(gen)
+        if decode_unicode is None:
+            decode_unicode = self.config.get('decode_unicode')
+        if decode_unicode:
+            gen = stream_decode_response_unicode(gen, self)
+        return gen
+
+    @property
+    def content(self):
+        """Content of the response, in bytes or unicode
+        (if available).
+        """
+
+        if self._content is not None:
+            return self._content
+
+        if self._content_consumed:
+            raise RuntimeError('The content for this response was '
+                               'already consumed')
+
+        # Read the contents.
+        self._content = self.raw.read()
+
+        # Decode GZip'd content.
+        if 'gzip' in self.headers.get('content-encoding', ''):
+            try:
+                self._content = decode_gzip(self._content)
+            except zlib.error:
+                pass
+
+        # Decode unicode content.
+        if self.config.get('decode_unicode'):
+            self._content = get_unicode_from_response(self)
+
+        self._content_consumed = True
+        return self._content
+
 
     def raise_for_status(self):
-        """Raises stored :class:`HTTPError`, if one occured."""
+        """Raises stored :class:`HTTPError` or :class:`URLError`, if one occurred."""
         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):
@@ -405,8 +595,10 @@ class AuthManager(object):
 
     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]
@@ -417,7 +609,9 @@ class AuthManager(object):
             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,
@@ -487,17 +681,18 @@ class AuthObject(object):
 
     _handlers = {
         'basic': HTTPBasicAuthHandler,
+        'forced_basic': HTTPForcedBasicAuthHandler,
         'digest': HTTPDigestAuthHandler,
         'proxy_basic': urllib2.ProxyBasicAuthHandler,
         'proxy_digest': urllib2.ProxyDigestAuthHandler
     }
 
-    def __init__(self, username, password, handler='basic', realm=None):
+    def __init__(self, username, password, handler='forced_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)
+            self.handler = self._handlers.get(handler.lower(), HTTPForcedBasicAuthHandler)
         else:
             self.handler = handler

requests/monkeys.py

@@ -9,7 +9,7 @@ Urllib2 Monkey patches.
 """
 
 import urllib2
-
+import re
 
 class Request(urllib2.Request):
     """Hidden wrapper around the urllib2.Request object. Allows for manual
@@ -28,7 +28,7 @@ class Request(urllib2.Request):
 
 
 class HTTPRedirectHandler(urllib2.HTTPRedirectHandler):
-
+    """HTTP Redirect handler."""
     def http_error_301(self, req, fp, code, msg, headers):
         pass
 
@@ -37,10 +37,13 @@ class HTTPRedirectHandler(urllib2.HTTPRedirectHandler):
 
 
 class HTTPBasicAuthHandler(urllib2.HTTPBasicAuthHandler):
+    """HTTP Basic Auth Handler with authentication loop fixes."""
 
     def __init__(self, *args, **kwargs):
         urllib2.HTTPBasicAuthHandler.__init__(self, *args, **kwargs)
         self.retried_req = None
+        self.retried = 0
+
 
     def reset_retry_count(self):
         # Python 2.6.5 will call this on 401 or 407 errors and thus loop
@@ -48,6 +51,7 @@ class HTTPBasicAuthHandler(urllib2.HTTPBasicAuthHandler):
         # 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:
@@ -60,6 +64,59 @@ class HTTPBasicAuthHandler(urllib2.HTTPBasicAuthHandler):
 
 
 
+class HTTPForcedBasicAuthHandler(HTTPBasicAuthHandler):
+    """HTTP Basic Auth Handler with forced Authentication."""
+
+    auth_header = 'Authorization'
+    rx = re.compile('(?:.*,)*[ \t]*([^ \t]+)[ \t]+'
+                    'realm=(["\'])(.*?)\\2', re.I)
+
+    def __init__(self,  *args, **kwargs):
+        HTTPBasicAuthHandler.__init__(self, *args, **kwargs)
+
+
+    def http_error_401(self, req, fp, code, msg, headers):
+        url = req.get_full_url()
+        response = self._http_error_auth_reqed('www-authenticate', url, req, headers)
+        self.reset_retry_count()
+        return response
+
+    http_error_404 = http_error_401
+
+
+    def _http_error_auth_reqed(self, authreq, host, req, headers):
+
+        authreq = headers.get(authreq, None)
+
+        if self.retried > 5:
+            # retry sending the username:password 5 times before failing.
+            raise urllib2.HTTPError(req.get_full_url(), 401, "basic auth failed",
+                            headers, None)
+        else:
+            self.retried += 1
+
+        if authreq:
+
+            mo = self.rx.search(authreq)
+
+            if mo:
+                scheme, quote, realm = mo.groups()
+
+                if scheme.lower() == 'basic':
+                    response = self.retry_http_basic_auth(host, req, realm)
+
+                    if response and response.code not in (401, 404):
+                        self.retried = 0
+                    return response
+        else:
+            response = self.retry_http_basic_auth(host, req, 'Realm')
+
+            if response and response.code not in (401, 404):
+                self.retried = 0
+            return response
+
+
+
 class HTTPDigestAuthHandler(urllib2.HTTPDigestAuthHandler):
 
     def __init__(self, *args, **kwargs):

requests/patches.py

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

requests/sessions.py

@@ -0,0 +1,253 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.session
+~~~~~~~~~~~~~~~
+
+This module provides a Session object to manage and persist settings across
+requests (cookies, auth, proxies).
+
+"""
+
+import cookielib
+
+from .defaults import defaults
+from .models import Request
+from .hooks import dispatch_hook
+from .utils import add_dict_to_cookiejar, cookiejar_from_dict, header_expand
+
+
+def merge_kwargs(local_kwarg, default_kwarg):
+    """Merges kwarg dictionaries.
+
+    If a local key in the dictionary is set to None, it will be removed.
+    """
+
+    if default_kwarg is None:
+        return local_kwarg
+
+    if isinstance(local_kwarg, basestring):
+        return local_kwarg
+
+    if local_kwarg is None:
+        return default_kwarg
+
+    # Bypass if not a dictionary (e.g. timeout)
+    if not hasattr(default_kwarg, 'items'):
+        return local_kwarg
+
+    # Update new values.
+    kwargs = default_kwarg.copy()
+    kwargs.update(local_kwarg)
+
+    # Remove keys that are set to None.
+    for (k,v) in local_kwarg.items():
+        if v is None:
+            del kwargs[k]
+
+    return kwargs
+
+
+class Session(object):
+    """A Requests session."""
+
+    __attrs__ = ['headers', 'cookies', 'auth', 'timeout', 'proxies', 'hooks', 'params', 'config']
+
+
+    def __init__(self,
+        headers=None,
+        cookies=None,
+        auth=None,
+        timeout=None,
+        proxies=None,
+        hooks=None,
+        params=None,
+        config=None):
+
+        self.headers = headers or {}
+        self.cookies = cookies or {}
+        self.auth = auth
+        self.timeout = timeout
+        self.proxies = proxies or {}
+        self.hooks = hooks or {}
+        self.params = params or {}
+        self.config = config or {}
+
+        for (k, v) in defaults.items():
+            self.config.setdefault(k, v)
+
+        # Set up a CookieJar to be used by default
+        self.cookies = cookielib.FileCookieJar()
+
+    def __repr__(self):
+        return '<requests-client at 0x%x>' % (id(self))
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+    def request(self, method, url,
+        params=None,
+        data=None,
+        headers=None,
+        cookies=None,
+        files=None,
+        auth=None,
+        timeout=None,
+        allow_redirects=False,
+        proxies=None,
+        hooks=None,
+        return_response=True,
+        config=None):
+
+        """Constructs and sends a :class:`Request <Request>`.
+        Returns :class:`Response <Response>` object.
+
+        :param method: method for the new :class:`Request` object.
+        :param url: URL for the new :class:`Request` object.
+        :param params: (optional) Dictionary or bytes to be sent in the query string for the :class:`Request`.
+        :param data: (optional) Dictionary or bytes to send in the body of the :class:`Request`.
+        :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`.
+        :param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`.
+        :param files: (optional) Dictionary of 'filename': file-like-objects for multipart encoding upload.
+        :param auth: (optional) 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.
+        :param proxies: (optional) Dictionary mapping protocol to the URL of the proxy.
+        :param return_response: (optional) If False, an un-sent Request object will returned.
+        :param config: (optional) A configuration dictionary.
+        """
+
+        method = str(method).upper()
+
+        if cookies is None:
+            cookies = {}
+
+        if isinstance(cookies, dict):
+            cookies = add_dict_to_cookiejar(self.cookies, cookies)
+
+        cookies = cookiejar_from_dict(cookies)
+
+        # Expand header values
+        if headers:
+            for k, v in headers.items() or {}:
+                headers[k] = header_expand(v)
+
+        args = dict(
+            method=method,
+            url=url,
+            data=data,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            files=files,
+            auth=auth,
+            hooks=hooks,
+            timeout=timeout,
+            allow_redirects=allow_redirects,
+            proxies=proxies,
+            config=config
+        )
+
+        for attr in self.__attrs__:
+            session_val = getattr(self, attr, None)
+            local_val = args.get(attr)
+
+            args[attr] = merge_kwargs(local_val, session_val)
+
+        # Arguments manipulation hook.
+        args = dispatch_hook('args', hooks, args)
+
+        r = Request(**args)
+
+        # Pre-request hook.
+        r = dispatch_hook('pre_request', hooks, r)
+
+        # Don't send if asked nicely.
+        if not return_response:
+            return r
+
+        # Send the HTTP Request.
+        r.send()
+
+        # Post-request hook.
+        r = dispatch_hook('post_request', hooks, r)
+
+        # Response manipulation hook.
+        r.response = dispatch_hook('response', hooks, r.response)
+
+        return r.response
+
+
+    def get(self, url, **kwargs):
+        """Sends a GET request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param **kwargs: Optional arguments that ``request`` takes.
+        """
+
+        kwargs.setdefault('allow_redirects', True)
+        return self.request('GET', url, **kwargs)
+
+
+    def head(self, url, **kwargs):
+        """Sends a HEAD request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param **kwargs: Optional arguments that ``request`` takes.
+        """
+
+        kwargs.setdefault('allow_redirects', True)
+        return self.request('HEAD', url, **kwargs)
+
+
+    def post(self, url, data='', **kwargs):
+        """Sends a POST request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param data: (optional) Dictionary or bytes to send in the body of the :class:`Request`.
+        :param **kwargs: Optional arguments that ``request`` takes.
+        """
+
+        return self.request('post', url, data=data, **kwargs)
+
+
+    def put(self, url, data='', **kwargs):
+        """Sends a PUT request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param data: (optional) Dictionary or bytes to send in the body of the :class:`Request`.
+        :param **kwargs: Optional arguments that ``request`` takes.
+        """
+
+        return self.request('put', url, data=data, **kwargs)
+
+
+    def patch(self, url, data='', **kwargs):
+        """Sends a PATCH request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param data: (optional) Dictionary or bytes to send in the body of the :class:`Request`.
+        :param **kwargs: Optional arguments that ``request`` takes.
+        """
+
+        return self.request('patch', url,  data='', **kwargs)
+
+
+    def delete(self, url, **kwargs):
+        """Sends a DELETE request. Returns :class:`Response` object.
+
+        :param url: URL for the new :class:`Request` object.
+        :param **kwargs: Optional arguments that ``request`` takes.
+        """
+
+        return self.request('delete', url, **kwargs)
+
+
+
+def session(**kwargs):
+    """Returns a :class:`Session` for context-management."""
+
+    return Session(**kwargs)

requests/status_codes.py

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

requests/structures.py

@@ -4,61 +4,62 @@
 requests.structures
 ~~~~~~~~~~~~~~~~~~~
 
-Datastructures that power Requests.
+Data structures that power Requests.
 
 """
 
-from UserDict import DictMixin
-
-
-class CaseInsensitiveDict(DictMixin):
-    """Case-insensitive Dictionary for :class:`Response <models.Response>` Headers.
+class CaseInsensitiveDict(dict):
+    """Case-insensitive Dictionary
 
     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]
+    @property
+    def lower_keys(self):
+        if not hasattr(self, '_lower_keys') or not self._lower_keys:
+            self._lower_keys = dict((k.lower(), k) for k in self.iterkeys())
+        return self._lower_keys
 
+    def _clear_lower_keys(self):
+        if hasattr(self, '_lower_keys'):
+            self._lower_keys.clear()
 
     def __setitem__(self, key, value):
-        return self.data.__setitem__(key, value)
-
+        dict.__setitem__(self, key, value)
+        self._clear_lower_keys()
 
     def __delitem__(self, key):
-        return self.data.__delitem__(key)
+        dict.__delitem__(self, key)
+        self._lower_keys.clear()
 
+    def __contains__(self, key):
+        return key.lower() in self.lower_keys
 
-    def __keys__(self):
-        return self.data.__keys__()
+    def __getitem__(self, key):
+        # We allow fall-through here, so values default to None
+        if key in self:
+            return dict.__getitem__(self, self.lower_keys[key.lower()])
 
+    def get(self, key, default=None):
+        if key in self:
+            return self[key]
+        else:
+            return default
 
-    def __iter__(self):
-        return self.data.__iter__()
+class LookupDict(dict):
+    """Dictionary lookup object."""
 
+    def __init__(self, name=None):
+        self.name = name
+        super(LookupDict, self).__init__()
 
-    def iteritems(self):
-        return self.data.iteritems()
+    def __repr__(self):
+        return '<lookup \'%s\'>' % (self.name)
+
+    def __getitem__(self, key):
+        # We allow fall-through here, so values default to None
+
+        return self.__dict__.get(key, None)
+
+    def get(self, key, default=None):
+        return self.__dict__.get(key, default)

requests/utils.py

@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.utils
+~~~~~~~~~~~~~~
+
+This module provides utlity functions that are used within Requests
+that are also useful for external consumption.
+
+"""
+
+import cgi
+import codecs
+import cookielib
+import re
+import zlib
+
+
+def header_expand(headers):
+    """Returns an HTTP Header value string from a dictionary.
+
+    Example expansion::
+
+        {'text/x-dvi': {'q': '.8', 'mxb': '100000', 'mxt': '5.0'}, 'text/x-c': {}}
+        # Accept: text/x-dvi; q=.8; mxb=100000; mxt=5.0, text/x-c
+
+        (('text/x-dvi', {'q': '.8', 'mxb': '100000', 'mxt': '5.0'}), ('text/x-c', {}))
+        # Accept: text/x-dvi; q=.8; mxb=100000; mxt=5.0, text/x-c
+    """
+
+    collector = []
+
+    if isinstance(headers, dict):
+        headers = headers.items()
+
+    elif isinstance(headers, basestring):
+        return headers
+
+    for i, (value, params) in enumerate(headers):
+
+        _params = []
+
+        for (p_k, p_v) in params.items():
+
+            _params.append('%s=%s' % (p_k, p_v))
+
+        collector.append(value)
+        collector.append('; ')
+
+        if len(params):
+
+            collector.append('; '.join(_params))
+
+            if not len(headers) == i+1:
+                collector.append(', ')
+
+
+    # Remove trailing separators.
+    if collector[-1] in (', ', '; '):
+        del collector[-1]
+
+    return ''.join(collector)
+
+
+
+def dict_from_cookiejar(cj):
+    """Returns a key/value dictionary from a CookieJar.
+
+    :param cj: CookieJar object to extract cookies from.
+    """
+
+    cookie_dict = {}
+
+    for _, cookies in cj._cookies.items():
+        for _, cookies in cookies.items():
+            for cookie in cookies.values():
+                # print cookie
+                cookie_dict[cookie.name] = cookie.value
+
+    return cookie_dict
+
+
+def cookiejar_from_dict(cookie_dict):
+    """Returns a CookieJar from a key/value dictionary.
+
+    :param cookie_dict: Dict of key/values to insert into CookieJar.
+    """
+
+    # return cookiejar if one was passed in
+    if isinstance(cookie_dict, cookielib.CookieJar):
+        return cookie_dict
+
+    # create cookiejar
+    cj = cookielib.CookieJar()
+
+    cj = add_dict_to_cookiejar(cj, cookie_dict)
+
+    return cj
+
+
+def add_dict_to_cookiejar(cj, cookie_dict):
+    """Returns a CookieJar from a key/value dictionary.
+
+    :param cj: CookieJar to insert cookies into.
+    :param cookie_dict: Dict of key/values to insert into CookieJar.
+    """
+
+    for k, v in cookie_dict.items():
+
+        cookie = cookielib.Cookie(
+            version=0,
+            name=k,
+            value=v,
+            port=None,
+            port_specified=False,
+            domain='',
+            domain_specified=False,
+            domain_initial_dot=False,
+            path='/',
+            path_specified=True,
+            secure=False,
+            expires=None,
+            discard=True,
+            comment=None,
+            comment_url=None,
+            rest={'HttpOnly': None},
+            rfc2109=False
+        )
+
+        # add cookie to cookiejar
+        cj.set_cookie(cookie)
+
+    return cj
+
+
+def get_encodings_from_content(content):
+    """Returns encodings from given content string.
+
+    :param content: bytestring to extract encodings from.
+    """
+
+    charset_re = re.compile(r'<meta.*?charset=["\']*(.+?)["\'>]', flags=re.I)
+
+    return charset_re.findall(content)
+
+
+def get_encoding_from_headers(headers):
+    """Returns encodings from given HTTP Header Dict.
+
+    :param headers: dictionary to extract encoding from.
+    """
+
+    content_type = headers.get('content-type')
+
+    if not content_type:
+        return None
+
+    content_type, params = cgi.parse_header(content_type)
+
+    if 'charset' in params:
+        return params['charset'].strip("'\"")
+
+
+def unicode_from_html(content):
+    """Attempts to decode an HTML string into unicode.
+    If unsuccessful, the original content is returned.
+    """
+
+    encodings = get_encodings_from_content(content)
+
+    for encoding in encodings:
+
+        try:
+            return unicode(content, encoding)
+        except (UnicodeError, TypeError):
+            pass
+
+        return content
+
+
+def stream_decode_response_unicode(iterator, r):
+    """Stream decodes a iterator."""
+    encoding = get_encoding_from_headers(r.headers)
+    if encoding is None:
+        for item in iterator:
+            yield item
+        return
+
+    decoder = codecs.getincrementaldecoder(encoding)(errors='replace')
+    for chunk in iterator:
+        rv = decoder.decode(chunk)
+        if rv:
+            yield rv
+    rv = decoder.decode('', final=True)
+    if rv:
+        yield rv
+
+
+def get_unicode_from_response(r):
+    """Returns the requested content back in unicode.
+
+    :param r: Response object to get unicode content from.
+
+    Tried:
+
+    1. charset from content-type
+
+    2. every encodings from ``<meta ... charset=XXX>``
+
+    3. fall back and replace all unicode characters
+
+    """
+
+    tried_encodings = []
+
+    # Try charset from content-type
+    encoding = get_encoding_from_headers(r.headers)
+
+    if encoding:
+        try:
+            return unicode(r.content, encoding)
+        except UnicodeError:
+            tried_encodings.append(encoding)
+
+    # Fall back:
+    try:
+        return unicode(r.content, encoding, errors='replace')
+    except TypeError:
+        return r.content
+
+
+def decode_gzip(content):
+    """Return gzip-decoded string.
+
+    :param content: bytestring to gzip-decode.
+    """
+
+    return zlib.decompress(content, 16 + zlib.MAX_WBITS)
+
+
+def stream_decode_gzip(iterator):
+    """Stream decodes a gzip-encoded iterator"""
+    try:
+        dec = zlib.decompressobj(16 + zlib.MAX_WBITS)
+        for chunk in iterator:
+            rv = dec.decompress(chunk)
+            if rv:
+                yield rv
+        buf = dec.decompress('')
+        rv = buf + dec.flush()
+        if rv:
+            yield rv
+    except zlib.error:
+        pass

setup.py

@@ -5,7 +5,10 @@ import os
 import sys
 import requests
 
-from distutils.core import setup
+try:
+    from setuptools import setup
+except ImportError:
+    from distutils.core import setup
 
 
 
@@ -25,7 +28,7 @@ if sys.version_info[:2] < (2,6):
 setup(
     name='requests',
     version=requests.__version__,
-    description='Awesome Python HTTP Library that\'s actually usable.',
+    description='Python HTTP for Humans.',
     long_description=open('README.rst').read() + '\n\n' +
                      open('HISTORY.rst').read(),
     author='Kenneth Reitz',

test_requests.py

@@ -3,53 +3,116 @@
 
 from __future__ import with_statement
 
-import unittest
+import time
 import cookielib
+import os
+import unittest
 
 import requests
+import envoy
 
+try:
+    import omnijson as json
+except ImportError:
+    import json
+
+
+# TODO: Detect an open port.
+PORT = os.environ.get('HTTPBIN_PORT', '7077')
+
+HTTPBIN_URL = 'http://0.0.0.0:%s/' % (PORT)
+# HTTPBIN_URL = 'http://127.0.0.1:8000/'
+
+
+def httpbin(*suffix):
+    """Returns url for HTTPBIN resource."""
+
+    return HTTPBIN_URL + '/'.join(suffix)
+
+
+SERVICES = (httpbin, )
+
+_httpbin = False
 
 class RequestsTestSuite(unittest.TestCase):
     """Requests test cases."""
 
+    # It goes to eleven.
+    _multiprocess_can_split_ = True
+
     def setUp(self):
-        pass
+
+        global _httpbin
+
+        if not _httpbin:
+
+            c = envoy.connect('gunicorn httpbin:app --bind=0.0.0.0:%s' % (PORT))
+
+            self.httpbin = c
+            _httpbin = True
+            time.sleep(1)
+
+
 
     def tearDown(self):
         """Teardown."""
-        pass
+        # self.httpbin.kill()
+
+    def test_entry_points(self):
+        import requests
+
+        requests.session
+        requests.session().get
+        requests.session().head
+        requests.get
+        requests.head
+        requests.put
+        requests.patch
+        requests.post
+
+
 
     def test_invalid_url(self):
         self.assertRaises(ValueError, requests.get, 'hiwpefhipowhefopw')
 
     def test_HTTP_200_OK_GET(self):
-        r = requests.get('http://google.com')
+        r = requests.get(httpbin('/get'))
         self.assertEqual(r.status_code, 200)
 
-    def test_HTTPS_200_OK_GET(self):
-        r = requests.get('https://google.com')
+    def test_HTTP_302_ALLOW_REDIRECT_GET(self):
+        r = requests.get(httpbin('redirect', '1'))
         self.assertEqual(r.status_code, 200)
 
+    def test_HTTP_302_GET(self):
+        r = requests.get(httpbin('redirect', '1'), allow_redirects=False)
+        self.assertEqual(r.status_code, 302)
+
+
     def test_HTTP_200_OK_GET_WITH_PARAMS(self):
         heads = {'User-agent': 'Mozilla/5.0'}
 
-        r = requests.get('http://www.google.com/search', params={'q': 'test'}, headers=heads)
+        r = requests.get(httpbin('user-agent'), headers=heads)
+
+        assert heads['User-agent'] in r.content
         self.assertEqual(r.status_code, 200)
 
+
     def test_HTTP_200_OK_GET_WITH_MIXED_PARAMS(self):
         heads = {'User-agent': 'Mozilla/5.0'}
 
-        r = requests.get('http://google.com/search?test=true', params={'q': 'test'}, headers=heads)
+        r = requests.get(httpbin('get') + '?test=true', params={'q': 'test'}, headers=heads)
         self.assertEqual(r.status_code, 200)
 
+
     def test_user_agent_transfers(self):
         """Issue XX"""
+
         heads = {
             'User-agent':
                 'Mozilla/5.0 (github.com/kennethreitz/requests)'
         }
 
-        r = requests.get('http://whatsmyua.com', headers=heads);
+        r = requests.get(httpbin('user-agent'), headers=heads);
         self.assertTrue(heads['User-agent'] in r.content)
 
         heads = {
@@ -57,133 +120,392 @@ class RequestsTestSuite(unittest.TestCase):
                 'Mozilla/5.0 (github.com/kennethreitz/requests)'
         }
 
-        r = requests.get('http://whatsmyua.com', headers=heads);
+        r = requests.get(httpbin('user-agent'), headers=heads);
         self.assertTrue(heads['user-agent'] in r.content)
 
+
     def test_HTTP_200_OK_HEAD(self):
-        r = requests.head('http://google.com')
+        r = requests.head(httpbin('/get'))
         self.assertEqual(r.status_code, 200)
 
-    def test_HTTPS_200_OK_HEAD(self):
-        r = requests.head('https://google.com')
+
+    def test_HTTP_200_OK_PUT(self):
+        r = requests.put(httpbin('put'))
         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)
 
+    def test_HTTP_200_OK_PATCH(self):
+        r = requests.patch(httpbin('patch'))
         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_AUTH_HTTP_200_OK_GET(self):
+
+        for service in SERVICES:
+
+            auth = ('user', 'pass')
+            url = service('basic-auth', 'user', 'pass')
+
+            r = requests.get(url, auth=auth)
+            # print r.__dict__
+            self.assertEqual(r.status_code, 200)
+
+
+            r = requests.get(url)
+            self.assertEqual(r.status_code, 200)
+
 
     def test_POSTBIN_GET_POST_FILES(self):
-        bin = requests.post('http://www.postbin.org/')
-        self.assertEqual(bin.status_code, 302)
 
-        post_url = bin.headers['location']
-        post = requests.post(post_url, data={'some': 'data'})
-        self.assertEqual(post.status_code, 201)
+        for service in SERVICES:
 
-        post2 = requests.post(post_url, files={'some': open('test_requests.py')})
-        self.assertEqual(post2.status_code, 201)
+            url = service('post')
+            post = requests.post(url).raise_for_status()
 
-        post3 = requests.post(post_url, data='[{"some": "json"}]')
-        self.assertEqual(post.status_code, 201)
+            post = requests.post(url, data={'some': 'data'})
+            self.assertEqual(post.status_code, 200)
+
+            post2 = requests.post(url, files={'some': open('test_requests.py')})
+            self.assertEqual(post2.status_code, 200)
+
+            post3 = requests.post(url, data='[{"some": "json"}]')
+            self.assertEqual(post3.status_code, 200)
 
 
     def test_POSTBIN_GET_POST_FILES_WITH_PARAMS(self):
-        bin = requests.post('http://www.postbin.org/')
-        self.assertEqual(bin.status_code, 302)
 
-        post_url = bin.headers['location']
+        for service in SERVICES:
 
-        post2 = requests.post(post_url, files={'some': open('test_requests.py')}, data={'some': 'data'})
-        self.assertEqual(post2.status_code, 201)
+            url = service('post')
+            post = requests.post(url,
+                files={'some': open('test_requests.py')},
+                data={'some': 'data'})
+
+            self.assertEqual(post.status_code, 200)
 
 
     def test_POSTBIN_GET_POST_FILES_WITH_HEADERS(self):
-        bin = requests.post('http://www.postbin.org/')
-        self.assertEqual(bin.status_code, 302)
 
-        post_url = bin.headers['location']
+        for service in SERVICES:
 
-        post2 = requests.post(post_url, files={'some': open('test_requests.py')},
-        headers = {'User-Agent': 'requests-tests'})
+            url = service('post')
 
-        self.assertEqual(post2.status_code, 201)
+            post2 = requests.post(url,
+                files={'some': open('test_requests.py')},
+                headers = {'User-Agent': 'requests-tests'})
+
+            self.assertEqual(post2.status_code, 200)
 
 
     def test_nonzero_evaluation(self):
-        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)
+        for service in SERVICES:
+
+            r = requests.get(service('status', '500'))
+            self.assertEqual(bool(r), False)
+
+            r = requests.get(service('/get'))
+            self.assertEqual(bool(r), True)
+
 
     def test_request_ok_set(self):
-        r = requests.get('http://google.com/some-404-url')
-        self.assertEqual(r.ok, False)
+
+        for service in SERVICES:
+
+            r = requests.get(service('status', '404'))
+            self.assertEqual(r.ok, False)
+
 
     def test_status_raising(self):
-        r = requests.get('http://google.com/some-404-url')
+        r = requests.get(httpbin('status', '404'))
         self.assertRaises(requests.HTTPError, r.raise_for_status)
 
-        r = requests.get('http://google.com/')
+        r = requests.get(httpbin('status', '200'))
         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)
+        url = httpbin('cookies', 'set', 'requests_cookie', 'awesome')
+        r = requests.get(url, cookies=jar)
         self.assertTrue(jar)
 
+        cookie_found = False
+        for cookie in jar:
+            if cookie.name == 'requests_cookie':
+                self.assertEquals(cookie.value, 'awesome')
+                cookie_found = True
+        self.assertTrue(cookie_found)
+
+        r = requests.get(httpbin('cookies'), cookies=jar)
+        self.assertTrue('awesome' in r.content)
+
+
     def test_decompress_gzip(self):
 
-        r = requests.get('http://api.stackoverflow.com/1.1/users/495995/top-answer-tags')
+        r = requests.get(httpbin('gzip'))
         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'})
+
+        for service in SERVICES:
+
+            url = service('/get')
+
+            requests.get(url, params={'foo': u'føø'})
+            requests.get(url, params={u'føø': u'føø'})
+            requests.get(url, params={'føø': 'føø'})
+            requests.get(url, params={'foo': u'foo'})
+            requests.get(service('ø'), params={'foo': u'foo'})
+
 
     def test_httpauth_recursion(self):
-        conv_auth = ('requeststest', 'bad_password')
 
-        r = requests.get('https://convore.com/api/account/verify.json', auth=conv_auth)
-        self.assertEquals(r.status_code, 401)
+        http_auth = ('user', 'BADpass')
 
-    def test_settings(self):
-        with requests.settings(timeout=0.0001):
-            self.assertRaises(requests.Timeout, requests.get, 'http://google.com')
+        for service in SERVICES:
+            r = requests.get(service('basic-auth', 'user', 'pass'), auth=http_auth)
+            self.assertEquals(r.status_code, 401)
+
+
+    def test_urlencoded_post_data(self):
+
+        for service in SERVICES:
+
+            r = requests.post(service('post'), data=dict(test='fooaowpeuf'))
+
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+            self.assertEquals(r.url, service('post'))
+
+            rbody = json.loads(r.content)
+
+            self.assertEquals(rbody.get('form'), dict(test='fooaowpeuf'))
+            self.assertEquals(rbody.get('data'), '')
 
-        with requests.settings(timeout=10):
-            requests.get('http://google.com')
 
     def test_nonurlencoded_post_data(self):
-        requests.post('http://google.com', data='foo')
 
+        for service in SERVICES:
+
+            r = requests.post(service('post'), data='fooaowpeuf')
+
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+            self.assertEquals(r.url, service('post'))
+
+            rbody = json.loads(r.content)
+            # Body wasn't valid url encoded data, so the server returns None as
+            # "form" and the raw body as "data".
+            self.assertEquals(rbody.get('form'), None)
+            self.assertEquals(rbody.get('data'), 'fooaowpeuf')
+
+
+    def test_urlencoded_post_querystring(self):
+
+        for service in SERVICES:
+
+            r = requests.post(service('post'), params=dict(test='fooaowpeuf'))
+
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+            self.assertEquals(r.url, service('post?test=fooaowpeuf'))
+
+            rbody = json.loads(r.content)
+            self.assertEquals(rbody.get('form'), {}) # No form supplied
+            self.assertEquals(rbody.get('data'), '')
+
+
+    def test_nonurlencoded_post_querystring(self):
+
+        for service in SERVICES:
+
+            r = requests.post(service('post'), params='fooaowpeuf')
+
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+            self.assertEquals(r.url, service('post?fooaowpeuf'))
+
+            rbody = json.loads(r.content)
+            self.assertEquals(rbody.get('form'), {}) # No form supplied
+            self.assertEquals(rbody.get('data'), '')
+
+
+    def test_urlencoded_post_query_and_data(self):
+
+        for service in SERVICES:
+
+            r = requests.post(
+                service('post'),
+                params=dict(test='fooaowpeuf'),
+                data=dict(test2="foobar"))
+
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+            self.assertEquals(r.url, service('post?test=fooaowpeuf'))
+
+            rbody = json.loads(r.content)
+            self.assertEquals(rbody.get('form'), dict(test2='foobar'))
+            self.assertEquals(rbody.get('data'), '')
+
+
+    def test_nonurlencoded_post_query_and_data(self):
+
+        for service in SERVICES:
+
+            r = requests.post(service('post'),
+                params='fooaowpeuf', data="foobar")
+
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+            self.assertEquals(r.url, service('post?fooaowpeuf'))
+
+            rbody = json.loads(r.content)
+
+            self.assertEquals(rbody.get('form'), None)
+            self.assertEquals(rbody.get('data'), 'foobar')
+
+
+    # def test_idna(self):
+    #     r = requests.get(u'http://➡.ws/httpbin')
+    #     assert 'httpbin' in r.url
+
+
+    def test_urlencoded_get_query_multivalued_param(self):
+
+        for service in SERVICES:
+
+            r = requests.get(service('get'), params=dict(test=['foo','baz']))
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.url, service('get?test=foo&test=baz'))
+
+
+    def test_urlencoded_post_querystring_multivalued(self):
+
+        for service in SERVICES:
+
+            r = requests.post(service('post'), params=dict(test=['foo','baz']))
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+            self.assertEquals(r.url, service('post?test=foo&test=baz'))
+
+            rbody = json.loads(r.content)
+            self.assertEquals(rbody.get('form'), {}) # No form supplied
+            self.assertEquals(rbody.get('data'), '')
+
+
+    def test_urlencoded_post_query_multivalued_and_data(self):
+
+        for service in SERVICES:
+
+            r = requests.post(
+                service('post'),
+                params=dict(test=['foo','baz']),
+                data=dict(test2="foobar",test3=['foo','baz']))
+
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(r.headers['content-type'], 'application/json')
+            self.assertEquals(r.url, service('post?test=foo&test=baz'))
+            rbody = json.loads(r.content)
+            self.assertEquals(rbody.get('form'), dict(test2='foobar',test3='foo'))
+            self.assertEquals(rbody.get('data'), '')
+
+
+    def test_GET_no_redirect(self):
+
+        for service in SERVICES:
+
+            r = requests.get(service('redirect', '3'), allow_redirects=False)
+            self.assertEquals(r.status_code, 302)
+            self.assertEquals(len(r.history), 0)
+
+
+    def test_HEAD_no_redirect(self):
+
+        for service in SERVICES:
+
+            r = requests.head(service('redirect', '3'), allow_redirects=False)
+            self.assertEquals(r.status_code, 302)
+            self.assertEquals(len(r.history), 0)
+
+
+    def test_redirect_history(self):
+
+        for service in SERVICES:
+
+            r = requests.get(service('redirect', '3'))
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(len(r.history), 3)
+
+
+    def test_relative_redirect_history(self):
+
+        for service in SERVICES:
+
+            r = requests.get(service('relative-redirect', '3'))
+            self.assertEquals(r.status_code, 200)
+            self.assertEquals(len(r.history), 3)
+
+
+    def test_session_HTTP_200_OK_GET(self):
+
+        s = requests.session()
+        r = s.get(httpbin('/get'))
+        self.assertEqual(r.status_code, 200)
+
+
+    def test_session_persistent_headers(self):
+
+        heads = {'User-agent': 'Mozilla/5.0'}
+
+        s = requests.session()
+        s.headers = heads
+
+        # Make 2 requests from Session object, should send header both times
+        r1 = s.get(httpbin('user-agent'))
+        assert heads['User-agent'] in r1.content
+
+        r2 = s.get(httpbin('user-agent'))
+        assert heads['User-agent'] in r2.content
+
+        new_heads = {'User-agent': 'blah'}
+        r3 = s.get(httpbin('user-agent'), headers=new_heads)
+        assert new_heads['User-agent'] in r3.content
+
+        self.assertEqual(r2.status_code, 200)
+
+
+    def test_session_persistent_params(self):
+
+        params = {'a': 'a_test'}
+
+        s = requests.session()
+        s.params = params
+
+        # Make 2 requests from Session object, should send header both times
+        r1 = s.get(httpbin('get'))
+        assert params['a'] in r1.content
+
+
+        params2 = {'b': 'b_test'}
+
+        r2 = s.get(httpbin('get'), params=params2)
+        assert params['a'] in r2.content
+        assert params2['b'] in r2.content
+
+
+        params3 = {'b': 'b_test', 'a': None, 'c': 'c_test'}
+
+        r3 = s.get(httpbin('get'), params=params3)
+
+        assert not params['a'] in r3.content
+        assert params3['b'] in r3.content
+        assert params3['c'] in r3.content
 
 
 if __name__ == '__main__':

tox.ini

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