Merge branch 'release/0.3.4'

---

raised Attribute Error when post str data something like json because of not having items attribute.
move encoding data to utf-8 inside hasattr(data, items)

.gitignore

@@ -1,2 +1,6 @@
 .idea
-MANIFEST
+MANIFEST
+coverage.xml
+nosetests.xml
+pylint.txt
+*.pyc

AUTHORS

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

HACKING

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

HISTORY.rst

@@ -1,6 +1,83 @@
 History
 -------
 
+0.3.4
++++++
+
+* Urllib2 HTTPAuthentication Recursion fix (Basic/Digest)
+* Internal Refactor
+* Bytes data upload Bugfix
+
+
+
+0.3.3 (2011-05-12)
+++++++++++++++++++
+
+* Request timeouts
+* Unicode url-encoded data
+* Settings context manager and module
+
+
+0.3.2 (2011-04-15)
+++++++++++++++++++
+
+* Automatic Decompression of GZip Encoded Content
+* AutoAuth Support for Tupled HTTP Auth
+
+
+0.3.1 (2011-04-01)
+++++++++++++++++++
+
+* Cookie Changes
+* Response.read()
+* Poster fix
+
+
+0.3.0 (2011-02-25)
+++++++++++++++++++
+
+* Automatic Authentication API Change
+* Smarter Query URL Parameterization
+* Allow file uploads and POST data together
+* New Authentication Manager System
+    - Simpler Basic HTTP System
+    - Supports all build-in urllib2 Auths
+    - Allows for custom Auth Handlers
+
+
+0.2.4 (2011-02-19)
+++++++++++++++++++
+
+* Python 2.5 Support
+* PyPy-c v1.4 Support
+* Auto-Authentication tests
+* Improved Request object constructor
+
+0.2.3 (2011-02-15)
+++++++++++++++++++
+
+* New HTTPHandling Methods
+    - Reponse.__nonzero__ (false if bad HTTP Status)
+    - Response.ok (True if expected HTTP Status)
+    - Response.error (Logged HTTPError if bad HTTP Status)
+    - Reponse.raise_for_status() (Raises stored HTTPError)
+
+
+0.2.2 (2011-02-14)
+++++++++++++++++++
+
+* Still handles request in the event of an HTTPError. (Issue #2)
+* Eventlet and Gevent Monkeypatch support.
+* Cookie Support (Issue #1)
+
+
+0.2.1 (2011-02-14)
+++++++++++++++++++
+
+* Added file attribute to POST and PUT requests for multipart-encode file uploads.
+* Added Request.url attribute for context and redirects
+
+
 0.2.0 (2011-02-14)
 ++++++++++++++++++
 

MANIFEST.in

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

NOTICE

@@ -0,0 +1,12 @@
+Request includes some vendorized python libraries to ease installation.
+
+Poster License
+==============
+
+Copyright (c) 2010 Chris AtLee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.rst

@@ -1,11 +1,11 @@
 Requests: The Simple (e.g. usable) HTTP Module
 ==============================================
 
-Most existing Python modules for dealing HTTP requests are insane. I have to look up *everything* that I want to do. Most of my worst Python experiences are a result of the various built-in HTTP libraries (yes, even worse than Logging). 
+Most existing Python modules for dealing HTTP requests are insane. I have to look up *everything* that I want to do. Most of my worst Python experiences are a result of the various built-in HTTP libraries (yes, even worse than Logging).
 
 But this one's different. This one's going to be awesome. And simple.
 
-Really simple. 
+Really simple.
 
 Features
 --------
@@ -13,7 +13,10 @@ Features
 - Extremely simple GET, HEAD, POST, PUT, DELETE Requests
     + Simple HTTP Header Request Attachment
     + Simple Data/Params Request Attachment
-- Simple Basic HTTP Authentication
+    + Simple Multipart File Uploads
+    + CookieJar Support
+
+- Simple Authentication
     + Simple URL + HTTP Auth Registry
 
 
@@ -27,23 +30,23 @@ It couldn't be simpler. ::
 
 
 HTTPS? Basic Authentication? ::
-    
+
     >>> r = requests.get('https://convore.com/api/account/verify.json')
     >>> r.status_code
     401
 
-    
+
 Uh oh, we're not authorized! Let's add authentication. ::
-    
-    >>> conv_auth = requests.AuthObject('requeststest', 'requeststest')
+
+    >>> conv_auth = ('requeststest', 'requeststest')
     >>> r = requests.get('https://convore.com/api/account/verify.json', auth=conv_auth)
-    
+
     >>> r.status_code
-    200 
-    
+    200
+
     >>> r.headers['content-type']
     'application/json'
-    
+
     >>> r.content
     '{"username": "requeststest", "url": "/users/requeststest/", "id": "9408", "img": "censored-long-url"}'
 
@@ -51,49 +54,67 @@ Uh oh, we're not authorized! Let's add authentication. ::
 
 API
 ---
-    
+
 **Requests:**
 
 All request functions return a Response object (see below).
-    
+
+If a {filename: fileobject} dictionary is passed in (files=...), a multipart_encode upload will be performed.
+If CookieJar object is is passed in (cookies=...), the cookies will be sent with the request.
+
   GET Requests
-    >>> request.get(url, params={}, headers={} auth=None)
-    <request object>
-    
+    >>> requests.get(url, params={}, headers={}, cookies=None, auth=None)
+    <Response [200]>
+
   HEAD Requests
-    >>> request.head(url, params={}, headers={} auth=None)
-    <request object>
-    
+    >>> requests.head(url, params={}, headers={}, cookies=None, auth=None)
+    <Response [200]>
+
   PUT Requests
-    >>> request.put(url, data='', headers={}, auth=None)
-    <request object>
-    
+    >>> requests.put(url, data='', headers={}, files={}, cookies=None, auth=None)
+    <Response [200]>
+
   POST Requests
-    >>> request.post(url, data={}, headers={}, auth=None)
-    <request object>
-    
+    >>> requests.post(url, data={}, headers={}, files={}, cookies=None, auth=None)
+    <Response [200]>
+
   DELETE Requests
-    >>> request.delete(url, params={}, headers={}, auth=None)
-    <request object>
-    
+    >>> requests.delete(url, params={}, headers={}, cookies=None, auth=None)
+    <Response [200]>
+
 
 **Responses:**
-    
-    Request.status_code:
+
+    Response.status_code
          (Integer) Received HTTP Status Code Response
 
-    Request.headers:
+    Response.headers
         (Dictionary) Received HTTP Response Headers
 
-    Request.content:
+    Response.content
         (Bytes) Received Content
 
+    Response.url
+        (String) URL of response. Useful for detecting redirects.
+
+    Response.ok
+        (Bool) True if no errors occurred during the request, and the status_code is kosher.
+
+    Response.cached
+        (Bool) True if Response.content is stored within the object.
+
+    Response.error
+        (HTTPError) If an HTTPError occurred (e.g. status of 404), Otherwise this is None.
+
+    Response.raise_for_status()
+        Raises HTTPError if a request is not kosher.
+
 
 **HTTP Authentication Registry:**
 
     You can register AuthObjects to automatically enable HTTP Authentication on requests that contain a registered base URL string.
 
-    >>> requests.add_autoauth(url, authobject)
+    >>> requests.auth_manager.add_auth(url, authobject)
 
 
 
@@ -103,13 +124,13 @@ Installation
 To install requests, simply: ::
 
     $ pip install requests
-    
+
 Or, if you absolutely must: ::
 
     $ easy_install requests
 
 But, you really shouldn't do that.
-   
+
 
 
 Contribute
@@ -122,8 +143,10 @@ If you'd like to contribute, simply fork `the repository`_, commit your changes
 Roadmap
 -------
 
-- Sphinx Documentation
-- Exhaustive Unittests
+- Sphinx Documentation (http://code.kennethreitz.com/requests/)
+- Exhaustive unit tests
+- Get rid of Poster (gets really nasty in py3.x)
+- Python 3.x Support
 
 .. _`the repository`: http://github.com/kennethreitz/requests
 .. _AUTHORS: http://github.com/kennethreitz/requests/blob/master/AUTHORS

docs/conf.py

@@ -25,7 +25,7 @@ import sys, os
 
 # Add any Sphinx extension module names here, as strings. They can be extensions
 # coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ['sphinx.ext.autodoc', 'sphinx.ext.todo', 'sphinx.ext.coverage', 'sphinx.ext.pngmath', 'sphinx.ext.jsmath', 'sphinx.ext.viewcode']
+extensions = ['sphinx.ext.autodoc']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
@@ -48,9 +48,9 @@ copyright = u'2011, Kenneth Reitz'
 # built documents.
 #
 # The short X.Y version.
-version = '0.2.0'
+version = '0.3.3'
 # The full version, including alpha/beta/rc tags.
-release = '0.2.0'
+release = version
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

requests/__init__.py

@@ -1,3 +1,31 @@
 # -*- coding: utf-8 -*-
 
-from .core import *
+import inspect
+
+import packages
+from core import *
+
+from core import __version__
+
+timeout = None
+
+class settings:
+    """Context manager for settings."""
+    
+    cache = {}
+    
+    def __init__(self, timeout):
+        self.module = inspect.getmodule(self)
+        
+        # Cache settings
+        self.cache['timeout'] = self.module.timeout
+        
+        self.module.timeout = timeout
+        
+    def __enter__(self):
+        pass
+        
+    def __exit__(self, type, value, traceback):
+        # Restore settings 
+        for key in self.cache:
+            setattr(self.module, key, self.cache[key])

requests/api.py

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

requests/async.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+
+"""
+    requests.async
+    ~~~~~~~~~~~~~~
+
+    This module implements the main Requests system, after monkey-patching
+    the urllib2 module with eventlet or gevent..
+
+    :copyright: (c) 2011 by Kenneth Reitz.
+    :license: ISC, see LICENSE for more details.
+"""
+
+
+from __future__ import absolute_import
+
+import urllib
+import urllib2
+
+from urllib2 import HTTPError
+
+
+try:
+    import eventlet
+    eventlet.monkey_patch()
+except ImportError:
+    pass
+
+if not 'eventlet' in locals():
+    try:
+        from gevent import monkey
+        monkey.patch_all()
+    except ImportError:
+        pass
+
+
+if not 'eventlet' in locals():
+    raise ImportError('No Async adaptations of urllib2 found!')
+
+
+from .core import *
+
+
+__all__ = [
+    'Request', 'Response', 'request', 'get', 'head', 'post', 'put', 'delete', 
+    'auth_manager', 'AuthObject','RequestException', 'AuthenticationError', 
+    'URLRequired', 'InvalidMethod', 'HTTPError'
+]

requests/core.py

@@ -1,405 +1,23 @@
 # -*- coding: utf-8 -*-
 
 """
-    requests.core
-    ~~~~~~~~~~~~~
+requests.core
+~~~~~~~~~~~~~
 
-    This module implements the main Requests system.
+This module implements the main Requests system.
+
+:copyright: (c) 2011 by Kenneth Reitz.
+:license: ISC, see LICENSE for more details.
 
-    :copyright: (c) 2011 by Kenneth Reitz.
-    :license: ISC, see LICENSE for more details.
 """
 
-import urllib
-import urllib2
-
-
 __title__ = 'requests'
-__version__ = '0.2.0'
-__build__ = 0x000200
+__version__ = '0.3.4'
+__build__ = 0x000304
 __author__ = 'Kenneth Reitz'
 __license__ = 'ISC'
 __copyright__ = 'Copyright 2011 Kenneth Reitz'
 
 
-AUTOAUTHS = []
-
-
-class _Request(urllib2.Request):
-	"""Hidden wrapper around the urllib2.Request object. Allows for manual
-	setting of HTTP methods.
-	"""
-	
-	def __init__(self, url,
-					data=None, headers={}, origin_req_host=None,
-					unverifiable=False, method=None):
-		urllib2.Request.__init__( self, url, data, headers, origin_req_host,
-								  unverifiable)
-	   	self.method = method
-
-	def get_method(self):
-		if self.method:
-			return self.method
-
-		return urllib2.Request.get_method(self)
-
-
-class Request(object):
-	"""The :class:`Request` object. It carries out all functionality of
-	Requests. Recommended interface is with the Requests functions.
-	
-	"""
-	
-	_METHODS = ('GET', 'HEAD', 'PUT', 'POST', 'DELETE')
-	
-	def __init__(self):
-		self.url = None
-		self.headers = dict()
-		self.method = None
-		self.params = {}
-		self.data = {}
-		self.response = Response()
-		self.auth = None
-		self.sent = False
-		
-	def __repr__(self):
-		try:
-			repr = '<Request [%s]>' % (self.method)
-		except:
-			repr = '<Request object>'
-		return repr
-	
-	def __setattr__(self, name, value):
-		if (name == 'method') and (value):
-			if not value in self._METHODS:
-				raise InvalidMethod()
-		
-		object.__setattr__(self, name, value)
-	
-	
-	def _checks(self):
-		"""Deterministic checks for consistiency."""
-
-		if not self.url:
-			raise URLRequired
-
-		
-	def _get_opener(self):
-		""" Creates appropriate opener object for urllib2.
-		"""
-		
-		if self.auth:
-
-			# create a password manager
-			authr = urllib2.HTTPPasswordMgrWithDefaultRealm()
-
-			authr.add_password(None, self.url, self.auth.username, self.auth.password)
-			handler = urllib2.HTTPBasicAuthHandler(authr)
-			opener = urllib2.build_opener(handler)
-
-			# use the opener to fetch a URL
-			return opener.open
-		else:
-			return urllib2.urlopen
-
-	
-	def send(self, anyway=False):
-		"""Sends the request. Returns True of successfull, false if not.
-		    If there was an HTTPError during transmission,
-		    self.response.status_code will contain the HTTPError code.
-
-		    Once a request is successfully sent, `sent` will equal True.
-		
-		    :param anyway: If True, request will be sent, even if it has
-		    already been sent.
-		"""
-		self._checks()
-
-		success = False
-		
-		if self.method in ('GET', 'HEAD', 'DELETE'):
-			if (not self.sent) or anyway:
-
-				# url encode GET params if it's a dict
-				if isinstance(self.params, dict):
-					params = urllib.urlencode(self.params)
-				else:
-
-					params = self.params
-
-				req = _Request(("%s?%s" % (self.url, params)), method=self.method)
-
-				if self.headers:
-					req.headers = self.headers
-
-				opener = self._get_opener()
-
-				try:
-					resp = opener(req)
-					self.response.status_code = resp.code
-					self.response.headers = resp.info().dict
-					if self.method.lower() == 'get':
-						self.response.content = resp.read()
-
-					success = True
-				except urllib2.HTTPError, why:
-					self.response.status_code = why.code
-
-
-		elif self.method == 'PUT':
-			if (not self.sent) or anyway:
-
-				req = _Request(self.url, method='PUT')
-
-				if self.headers:
-					req.headers = self.headers
-
-				req.data = self.data
-
-				try:
-					opener = self._get_opener()
-					resp =  opener(req)
-
-					self.response.status_code = resp.code
-					self.response.headers = resp.info().dict
-					self.response.content = resp.read()
-
-					success = True
-
-				except urllib2.HTTPError, why:
-					self.response.status_code = why.code
-
-
-
-
-		elif self.method == 'POST':
-			if (not self.sent) or anyway:
-
-				req = _Request(self.url, method='POST')
-
-				if self.headers:
-					req.headers = self.headers
-
-				# url encode form data if it's a dict
-				if isinstance(self.data, dict):
-					req.data = urllib.urlencode(self.data)
-				else:
-					req.data = self.data
-
-				try:
-
-					opener = self._get_opener()
-					resp =  opener(req)
-
-					self.response.status_code = resp.code
-					self.response.headers = resp.info().dict
-					self.response.content = resp.read()
-
-					success = True
-
-				except urllib2.HTTPError, why:
-					self.response.status_code = why.code
-
-		
-		self.sent = True if success else False
-		
-		return success
-		
-
-class Response(object):
-	"""The :class:`Request` object. All :class:`Request` objects contain a
-	:class:`Request.response <response>` attribute, which is an instance of
-	this class.
-	"""
-
-	def __init__(self):
-		self.content = None
-		self.status_code = None
-		self.headers = dict()
-		
-	def __repr__(self):
-		try:
-			repr = '<Response [%s]>' % (self.status_code)
-		except:
-			repr = '<Response object>'
-		return repr
-
-	
-class AuthObject(object):
-	"""The :class:`AuthObject` is a simple HTTP Authentication token. When
-	given to a Requests function, it enables Basic HTTP Authentication for that
-	Request. You can also enable Authorization for domain realms with AutoAuth.
-	See AutoAuth for more details.s
-	
-	:param username: Username to authenticate with.
-    :param password: Password for given username.
-	"""
-	
-	def __init__(self, username, password):
-		self.username = username
-		self.password = password
-
-
-
-def get(url, params={}, headers={}, auth=None):
-	"""Sends a GET request. Returns :class:`Response` object.
-
-	:param url: URL for the new :class:`Request` object.
-	:param params: (optional) Dictionary of GET Parameters to send with the :class:`Request`.
-	:param headers: (optional) Dictionary of HTTP Headers to sent with the :class:`Request`.
-	:param auth: (optional) AuthObject to enable Basic HTTP Auth.
-	"""
-	
-	r = Request()
-	
-	r.method = 'GET'
-	r.url = url
-	r.params = params
-	r.headers = headers
-	r.auth = _detect_auth(url, auth)
-	
-	r.send()
-	
-	return r.response
-
-
-def head(url, params={}, headers={}, auth=None):
-	"""Sends a HEAD request. Returns :class:`Response` object.
-
-	:param url: URL for the new :class:`Request` object.
-	:param params: (optional) Dictionary of GET Parameters to send with the :class:`Request`.
-	:param headers: (optional) Dictionary of HTTP Headers to sent with the :class:`Request`.
-	:param auth: (optional) AuthObject to enable Basic HTTP Auth.
-	"""
-	
-	r = Request()
-	
-	r.method = 'HEAD'
-	r.url = url
-	# return response object
-	r.params = params
-	r.headers = headers
-	r.auth = _detect_auth(url, auth)
-	
-	r.send()
-	
-	return r.response
-
-
-def post(url, data={}, headers={}, auth=None):
-	"""Sends a POST request. Returns :class:`Response` object.
-
-	:param url: URL for the new :class:`Request` object.
-	:param data: (optional) Dictionary of POST Data to send with the :class:`Request`.
-	:param headers: (optional) Dictionary of HTTP Headers to sent with the :class:`Request`.
-	:param auth: (optional) AuthObject to enable Basic HTTP Auth.
-	"""
-	
-	r = Request()
-
-	r.url = url
-	r.method = 'POST'
-	r.data = data
-	
-	r.headers = headers
-	r.auth = _detect_auth(url, auth)
-	
-	r.send()
-	
-	return r.response
-	
-	
-def put(url, data='', headers={}, auth=None):
-	"""Sends a PUT request. Returns :class:`Response` object.
-
-	:param url: URL for the new :class:`Request` object.
-	:param data: (optional) Bytes of PUT Data to send with the :class:`Request`.
-	:param headers: (optional) Dictionary of HTTP Headers to sent with the :class:`Request`.
-	:param auth: (optional) AuthObject to enable Basic HTTP Auth.
-	"""
-	
-	r = Request()
-
-	r.url = url
-	r.method = 'PUT'
-	r.data = data
-	
-	r.headers = headers
-	r.auth = _detect_auth(url, auth)
-	
-	r.send()
-	
-	return r.response
-
-	
-def delete(url, params={}, headers={}, auth=None):
-	"""Sends a DELETE request. Returns :class:`Response` object.
-
-	:param url: URL for the new :class:`Request` object.
-	:param params: (optional) Dictionary of GET Parameters to send with the :class:`Request`.
-	:param headers: (optional) Dictionary of HTTP Headers to sent with the :class:`Request`.
-	:param auth: (optional) AuthObject to enable Basic HTTP Auth.
-	"""
-	
-	r = Request()
-
-	r.url = url
-	r.method = 'DELETE'
-	# return response object
-	
-	r.headers = headers
-	r.auth = _detect_auth(url, auth)
-	
-	r.send()
-	
-	return r.response
-
-
-def add_autoauth(url, authobject):
-	"""Registers given AuthObject to given URL domain. for auto-activation.
-	Once a URL is registered with an AuthObject, the configured HTTP
-	Authentication will be used for all requests with URLS containing the given
-	URL string.
-
-	Example: ::
-	    >>> c_auth = requests.AuthObject('kennethreitz', 'xxxxxxx')
-	    >>> requests.add_autoauth('https://convore.com/api/', c_auth)
-	    >>> r = requests.get('https://convore.com/api/account/verify.json')
-	    # Automatically HTTP Authenticated! Wh00t!
-
-	:param url: Base URL for given AuthObject to auto-activate for.
-	:param authobject: AuthObject to auto-activate.
-	"""
-	global AUTOAUTHS
-	
-	AUTOAUTHS.append((url, authobject))
-
-
-def _detect_auth(url, auth):
-	"""Returns registered AuthObject for given url if available, defaulting to
-	given AuthObject."""
-
-	return _get_autoauth(url) if not auth else auth
-
-	
-def _get_autoauth(url):
-	"""Returns registered AuthObject for given url if available.
-	"""
-	
-	for (autoauth_url, auth) in AUTOAUTHS:
-		if autoauth_url in url: 
-			return auth
-			
-	return None
-
-class RequestException(Exception):
-	"""There was an ambiguous exception that occured while handling your request."""
-
-class AuthenticationError(RequestException):
-	"""The authentication credentials provided were invalid."""
-	
-class URLRequired(RequestException):
-	"""A valid URL is required to make a request."""
-	
-class InvalidMethod(RequestException):
-	"""An inappropriate method was attempted."""
+from .models import HTTPError, auth_manager
+from .api import *

requests/models.py

@@ -0,0 +1,435 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.system
+~~~~~~~~~~~~~~~
+
+"""
+
+import requests
+import urllib
+import urllib2
+import socket
+import zlib
+
+from urllib2 import HTTPError
+from urlparse import urlparse
+
+from .monkeys import Request as _Request, HTTPBasicAuthHandler, HTTPDigestAuthHandler
+
+from .packages.poster.encode import multipart_encode
+from .packages.poster.streaminghttp import register_openers, get_handlers
+
+
+
+class Request(object):
+    """The :class:`Request` object. It carries out all functionality of
+    Requests. Recommended interface is with the Requests functions.
+    """
+
+    _METHODS = ('GET', 'HEAD', 'PUT', 'POST', 'DELETE')
+
+    def __init__(self, url=None, headers=dict(), files=None, method=None,
+                 data=dict(), auth=None, cookiejar=None, timeout=None):
+
+        socket.setdefaulttimeout(timeout)
+
+        self.url = url
+        self.headers = headers
+        self.files = files
+        self.method = method
+        self.data = {}
+
+        # self.data = {}
+        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
+                })
+
+        # url encode data if it's a dict
+        if hasattr(data, 'items'):
+            self._enc_data = urllib.urlencode(self.data)
+        else:
+            self._enc_data = data
+
+
+        self.response = Response()
+
+        if isinstance(auth, (list, tuple)):
+            auth = AuthObject(*auth)
+        if not auth:
+            auth = auth_manager.get_auth(self.url)
+        self.auth = auth
+        self.cookiejar = cookiejar
+        self.sent = False
+
+
+    def __repr__(self):
+        return '<Request [%s]>' % (self.method)
+
+
+    def __setattr__(self, name, value):
+        if (name == 'method') and (value):
+            if not value in self._METHODS:
+                raise InvalidMethod()
+
+        object.__setattr__(self, name, value)
+
+
+    def _checks(self):
+        """Deterministic checks for consistency."""
+
+        if not self.url:
+            raise URLRequired
+
+
+    def _get_opener(self):
+        """Creates appropriate opener object for urllib2."""
+
+        _handlers = []
+
+        if self.cookiejar is not None:
+            _handlers.append(urllib2.HTTPCookieProcessor(self.cookiejar))
+
+        if self.auth:
+            if not isinstance(self.auth.handler, (urllib2.AbstractBasicAuthHandler, urllib2.AbstractDigestAuthHandler)):
+                auth_manager.add_password(self.auth.realm, self.url, self.auth.username, self.auth.password)
+                self.auth.handler = self.auth.handler(auth_manager)
+                auth_manager.add_auth(self.url, self.auth)
+
+            _handlers.append(self.auth.handler)
+
+        if not _handlers:
+            return urllib2.urlopen
+
+        _handlers.extend(get_handlers())
+        opener = urllib2.build_opener(*_handlers)
+
+        if self.headers:
+            # Allow default headers in the opener to be overloaded
+            normal_keys = [k.capitalize() for k in self.headers]
+            for key, val in opener.addheaders[:]:
+                if key not in normal_keys:
+                    continue
+                # Remove it, we have a value to take its place
+                opener.addheaders.remove((key, val))
+
+        return opener.open
+
+    def _build_response(self, resp):
+        """Build internal Response object from given response."""
+        if isinstance(resp, HTTPError):
+            # print resp.__dict__
+            pass
+
+        self.response.status_code = getattr(resp, 'code', None)
+
+        try:
+            self.response.headers = getattr(resp.info(), 'dict', None)
+            self.response.content = resp.read()
+        except AttributeError, why:
+            pass
+
+        if self.response.headers.get('content-encoding', None) == 'gzip':
+            try:
+                self.response.content = zlib.decompress(self.response.content, 16+zlib.MAX_WBITS)
+            except zlib.error:
+                pass
+
+        self.response.url = getattr(resp, 'url', None)
+
+
+    @staticmethod
+    def _build_url(url, data=None):
+        """Build URLs."""
+
+        if urlparse(url).query:
+            return '%s&%s' % (url, data)
+        else:
+            if data:
+                return '%s?%s' % (url, data)
+            else:
+                return url
+
+
+    def send(self, anyway=False):
+        """Sends the request. Returns True of successful, false if not.
+        If there was an HTTPError during transmission,
+        self.response.status_code will contain the HTTPError code.
+
+        Once a request is successfully sent, `sent` will equal True.
+
+        :param anyway: If True, request will be sent, even if it has
+        already been sent.
+        """
+        self._checks()
+        success = False
+
+        if self.method in ('GET', 'HEAD', 'DELETE'):
+            req = _Request(self._build_url(self.url, self._enc_data), method=self.method)
+        else:
+
+            if self.files:
+                register_openers()
+
+                if self.data:
+                    self.files.update(self.data)
+
+                datagen, headers = multipart_encode(self.files)
+                req = _Request(self.url, data=datagen, headers=headers, method=self.method)
+
+            else:
+                req = _Request(self.url, data=self._enc_data, method=self.method)
+
+        if self.headers:
+            req.headers.update(self.headers)
+
+        if not self.sent or anyway:
+
+            try:
+                opener = self._get_opener()
+                resp = opener(req)
+
+                if self.cookiejar is not None:
+                    self.cookiejar.extract_cookies(resp, req)
+
+            except urllib2.HTTPError, why:
+                self._build_response(why)
+                self.response.error = why
+            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 :class:`Request` object. All :class:`Request` objects contain a
+    :class:`Request.response <response>` attribute, which is an instance of
+    this class.
+    """
+
+    def __init__(self):
+        self.content = None
+        self.status_code = None
+        self.headers = dict()
+        self.url = None
+        self.ok = False
+        self.error = None
+        self.cached = False
+
+
+    def __repr__(self):
+        return '<Response [%s]>' % (self.status_code)
+
+
+    def __nonzero__(self):
+        """Returns true if status_code is 'OK'."""
+        return not self.error
+
+
+    def raise_for_status(self):
+        """Raises stored HTTPError if one exists."""
+        if self.error:
+            raise self.error
+
+    def read(self, *args):
+        return self.content
+
+
+
+class AuthManager(object):
+    """Authentication Manager."""
+
+    def __new__(cls):
+        singleton = cls.__dict__.get('__singleton__')
+        if singleton is not None:
+            return singleton
+
+        cls.__singleton__ = singleton = object.__new__(cls)
+
+        return singleton
+
+
+    def __init__(self):
+        self.passwd = {}
+        self._auth = {}
+
+
+    def __repr__(self):
+        return '<AuthManager [%s]>' % (self.method)
+
+
+    def add_auth(self, uri, auth):
+        """Registers AuthObject to AuthManager."""
+
+        uri = self.reduce_uri(uri, False)
+
+        # try to make it an AuthObject
+        if not isinstance(auth, AuthObject):
+            try:
+                auth = AuthObject(*auth)
+            except TypeError:
+                pass
+
+        self._auth[uri] = auth
+
+
+    def add_password(self, realm, uri, user, passwd):
+        """Adds password to AuthManager."""
+        # uri could be a single URI or a sequence
+        if isinstance(uri, basestring):
+            uri = [uri]
+
+        reduced_uri = tuple([self.reduce_uri(u, False) for u in uri])
+
+        if reduced_uri not in self.passwd:
+            self.passwd[reduced_uri] = {}
+        self.passwd[reduced_uri] = (user, passwd)
+
+
+    def find_user_password(self, realm, authuri):
+        for uris, authinfo in self.passwd.iteritems():
+            reduced_authuri = self.reduce_uri(authuri, False)
+            for uri in uris:
+                if self.is_suburi(uri, reduced_authuri):
+                    return authinfo
+
+        return (None, None)
+
+
+    def get_auth(self, uri):
+        (in_domain, in_path) = self.reduce_uri(uri, False)
+
+        for domain, path, authority in (
+            (i[0][0], i[0][1], i[1]) for i in self._auth.iteritems()
+        ):
+            if in_domain == domain:
+                if path in in_path:
+                    return authority
+
+
+    def reduce_uri(self, uri, default_port=True):
+        """Accept authority or URI and extract only the authority and path."""
+        # note HTTP URLs do not have a userinfo component
+        parts = urllib2.urlparse.urlsplit(uri)
+        if parts[1]:
+            # URI
+            scheme = parts[0]
+            authority = parts[1]
+            path = parts[2] or '/'
+        else:
+            # host or host:port
+            scheme = None
+            authority = uri
+            path = '/'
+        host, port = urllib2.splitport(authority)
+        if default_port and port is None and scheme is not None:
+            dport = {"http": 80,
+                     "https": 443,
+                     }.get(scheme)
+            if dport is not None:
+                authority = "%s:%d" % (host, dport)
+
+        return authority, path
+
+
+    def is_suburi(self, base, test):
+        """Check if test is below base in a URI tree
+
+        Both args must be URIs in reduced form.
+        """
+        if base == test:
+            return True
+        if base[0] != test[0]:
+            return False
+        common = urllib2.posixpath.commonprefix((base[1], test[1]))
+        if len(common) == len(base[1]):
+            return True
+        return False
+
+
+    def empty(self):
+        self.passwd = {}
+
+
+    def remove(self, uri, realm=None):
+        # uri could be a single URI or a sequence
+        if isinstance(uri, basestring):
+            uri = [uri]
+
+        for default_port in True, False:
+            reduced_uri = tuple([self.reduce_uri(u, default_port) for u in uri])
+            del self.passwd[reduced_uri][realm]
+
+
+    def __contains__(self, uri):
+        # uri could be a single URI or a sequence
+        if isinstance(uri, basestring):
+            uri = [uri]
+
+        uri = tuple([self.reduce_uri(u, False) for u in uri])
+
+        if uri in self.passwd:
+            return True
+
+        return False
+
+auth_manager = AuthManager()
+
+
+
+class AuthObject(object):
+    """The :class:`AuthObject` is a simple HTTP Authentication token. When
+    given to a Requests function, it enables Basic HTTP Authentication for that
+    Request. You can also enable Authorization for domain realms with AutoAuth.
+    See AutoAuth for more details.
+
+    :param username: Username to authenticate with.
+    :param password: Password for given username.
+    :param realm: (optional) the realm this auth applies to
+    :param handler: (optional) basic || digest || proxy_basic || proxy_digest
+    """
+
+    _handlers = {
+        'basic': HTTPBasicAuthHandler,
+        'digest': HTTPDigestAuthHandler,
+        'proxy_basic': urllib2.ProxyBasicAuthHandler,
+        'proxy_digest': urllib2.ProxyDigestAuthHandler
+    }
+
+    def __init__(self, username, password, handler='basic', realm=None):
+        self.username = username
+        self.password = password
+        self.realm = realm
+
+        if isinstance(handler, basestring):
+            self.handler = self._handlers.get(handler.lower(), urllib2.HTTPBasicAuthHandler)
+        else:
+            self.handler = handler
+
+class RequestException(Exception):
+    """There was an ambiguous exception that occured while handling your
+    request."""
+
+class AuthenticationError(RequestException):
+    """The authentication credentials provided were invalid."""
+
+class URLRequired(RequestException):
+    """A valid URL is required to make a request."""
+
+class InvalidMethod(RequestException):
+    """An inappropriate method was attempted."""

requests/monkeys.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.monkeys
+~~~~~~~~~~~~~~~~
+
+Urllib2 Monkey patches.
+
+"""
+
+import urllib2
+
+
+class Request(urllib2.Request):
+    """Hidden wrapper around the urllib2.Request object. Allows for manual
+    setting of HTTP methods.
+    """
+
+    def __init__(self, url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None):
+        urllib2.Request.__init__(self, url, data, headers, origin_req_host, unverifiable)
+        self.method = method
+
+    def get_method(self):
+        if self.method:
+            return self.method
+
+        return urllib2.Request.get_method(self)
+
+
+class HTTPBasicAuthHandler(urllib2.HTTPBasicAuthHandler):
+    # from mercurial
+
+    def __init__(self, *args, **kwargs):
+        urllib2.HTTPBasicAuthHandler.__init__(self, *args, **kwargs)
+        self.retried_req = None
+
+    def reset_retry_count(self):
+        # Python 2.6.5 will call this on 401 or 407 errors and thus loop
+        # forever. We disable reset_retry_count completely and reset in
+        # http_error_auth_reqed instead.
+        pass
+
+    def http_error_auth_reqed(self, auth_header, host, req, headers):
+        # Reset the retry counter once for each request.
+        if req is not self.retried_req:
+            self.retried_req = req
+            self.retried = 0
+        return urllib2.HTTPBasicAuthHandler.http_error_auth_reqed(
+                        self, auth_header, host, req, headers)
+
+
+
+class HTTPDigestAuthHandler(urllib2.HTTPDigestAuthHandler):
+
+    def __init__(self, *args, **kwargs):
+        urllib2.HTTPDigestAuthHandler.__init__(self, *args, **kwargs)
+        self.retried_req = None
+
+    def reset_retry_count(self):
+        # Python 2.6.5 will call this on 401 or 407 errors and thus loop
+        # forever. We disable reset_retry_count completely and reset in
+        # http_error_auth_reqed instead.
+        pass
+
+    def http_error_auth_reqed(self, auth_header, host, req, headers):
+        # Reset the retry counter once for each request.
+        if req is not self.retried_req:
+            self.retried_req = req
+            self.retried = 0
+        # In python < 2.5 AbstractDigestAuthHandler raises a ValueError if
+        # it doesn't know about the auth type requested. This can happen if
+        # somebody is using BasicAuth and types a bad password.
+
+        try:
+            return urllib2.HTTPDigestAuthHandler.http_error_auth_reqed(
+                        self, auth_header, host, req, headers)
+        except ValueError, inst:
+            arg = inst.args[0]
+            if arg.startswith("AbstractDigestAuthHandler doesn't know "):
+                return
+            raise

requests/packages/__init__.py

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

requests/packages/poster/__init__.py

@@ -0,0 +1,34 @@
+# Copyright (c) 2010 Chris AtLee
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+"""poster module
+
+Support for streaming HTTP uploads, and multipart/form-data encoding
+
+```poster.version``` is a 3-tuple of integers representing the version number.
+New releases of poster will always have a version number that compares greater
+than an older version of poster.
+New in version 0.6."""
+
+from __future__ import absolute_import
+
+from . import streaminghttp
+from . import encode
+
+version = (0, 8, 0) # Thanks JP!

requests/packages/poster/encode.py

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

requests/packages/poster/streaminghttp.py

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

requests/patches.py

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

requests/structures.py

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

setup.py

@@ -3,46 +3,51 @@
 
 import os
 import sys
+import requests
 
 from distutils.core import setup
 
 
-def publish():
-	"""Publish to PyPi"""
-	os.system("python setup.py sdist upload")
 
 if sys.argv[-1] == "publish":
-	publish()
-	sys.exit()
+    os.system("python setup.py sdist upload")
+    sys.exit()
+
+if sys.argv[-1] == "test":
+    os.system("python test_requests.py")
+    sys.exit()
 
 required = []
 
-# if python > 2.6, require simplejson
+if sys.version_info[:2] < (2,6):
+    required.append('simplejson')
 
 setup(
-	name='requests',
-	version='0.2.0',
-	description='Python HTTP Library that\'s actually usable.',
-	long_description=open('README.rst').read() + '\n\n' +
-	                 open('HISTORY.rst').read(),
-	author='Kenneth Reitz',
-	author_email='me@kennethreitz.com',
-	url='https://github.com/kennethreitz/requests',
-	packages= [
-		'requests',
-	],
-	install_requires=required,
-	license='ISC',
-	classifiers=(
-		# 'Development Status :: 5 - Production/Stable',
-		'Intended Audience :: Developers',
-		'Natural Language :: English',
-		'License :: OSI Approved :: MIT License',
-		'Programming Language :: Python',
-        # 'Programming Language :: Python :: 2.5',
+    name='requests',
+    version=requests.__version__,
+    description='Awesome Python HTTP Library that\'s actually usable.',
+    long_description=open('README.rst').read() + '\n\n' +
+                     open('HISTORY.rst').read(),
+    author='Kenneth Reitz',
+    author_email='me@kennethreitz.com',
+    url='https://github.com/kennethreitz/requests',
+    packages= [
+        'requests',
+        'requests.packages',
+        'requests.packages.poster'
+    ],
+    install_requires=required,
+    license='ISC',
+    classifiers=(
+        'Development Status :: 5 - Production/Stable',
+        'Intended Audience :: Developers',
+        'Natural Language :: English',
+        'License :: OSI Approved :: ISC License (ISCL)',
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 2.5',
         'Programming Language :: Python :: 2.6',
-		'Programming Language :: Python :: 2.7',
-		# 'Programming Language :: Python :: 3.0',
-		# 'Programming Language :: Python :: 3.1',
-	),
+        'Programming Language :: Python :: 2.7',
+        # 'Programming Language :: Python :: 3.0',
+        # 'Programming Language :: Python :: 3.1',
+    ),
 )

test_requests.py

@@ -2,46 +2,160 @@
 # -*- coding: utf-8 -*-
 
 import unittest
+import cookielib
 
 import requests
 
 
 class RequestsTestSuite(unittest.TestCase):
-	"""Requests test cases."""
-	
-	def setUp(self):
-		pass
+    """Requests test cases."""
 
-	def tearDown(self):
-		"""Teardown."""
-		pass
-		
-	def test_invalid_url(self):
-		self.assertRaises(ValueError, requests.get, 'hiwpefhipowhefopw')
+    def setUp(self):
+        pass
 
-	def test_HTTP_200_OK_GET(self):
-		r = requests.get('http://google.com')
-		self.assertEqual(r.status_code, 200)
+    def tearDown(self):
+        """Teardown."""
+        pass
 
-	def test_HTTPS_200_OK_GET(self):
-		r = requests.get('https://google.com')
-		self.assertEqual(r.status_code, 200)
+    def test_invalid_url(self):
+        self.assertRaises(ValueError, requests.get, 'hiwpefhipowhefopw')
 
-	def test_HTTP_200_OK_HEAD(self):
-		r = requests.head('http://google.com')
-		self.assertEqual(r.status_code, 200)
+    def test_HTTP_200_OK_GET(self):
+        r = requests.get('http://google.com')
+        self.assertEqual(r.status_code, 200)
 
-	def test_HTTPS_200_OK_HEAD(self):
-		r = requests.head('https://google.com')
-		self.assertEqual(r.status_code, 200)
+    def test_HTTPS_200_OK_GET(self):
+        r = requests.get('https://google.com')
+        self.assertEqual(r.status_code, 200)
 
-	def test_AUTH_HTTPS_200_OK_GET(self):
-		auth = requests.AuthObject('requeststest', 'requeststest')
-		url = 'https://convore.com/api/account/verify.json'
-		r = requests.get(url, auth=auth)
+    def test_HTTP_200_OK_GET_WITH_PARAMS(self):
+        heads = {'User-agent': 'Mozilla/5.0'}
 
-		self.assertEqual(r.status_code, 200)
+        r = requests.get('http://www.google.com/search', params={'q': 'test'}, headers=heads)
+        self.assertEqual(r.status_code, 200)
+
+    def test_HTTP_200_OK_GET_WITH_MIXED_PARAMS(self):
+        heads = {'User-agent': 'Mozilla/5.0'}
+
+        r = requests.get('http://google.com/search?test=true', params={'q': 'test'}, headers=heads)
+        self.assertEqual(r.status_code, 200)
+
+    def test_user_agent_transfers(self):
+        """Issue XX"""
+        heads = {'User-agent':
+                 'Mozilla/5.0 (github.com/kennethreitz/requests)'}
+
+        r = requests.get('http://whatsmyua.com', headers=heads);
+        self.assertTrue(heads['User-agent'] in r.content)
+
+    def test_HTTP_200_OK_HEAD(self):
+        r = requests.head('http://google.com')
+        self.assertEqual(r.status_code, 200)
+
+    def test_HTTPS_200_OK_HEAD(self):
+        r = requests.head('https://google.com')
+        self.assertEqual(r.status_code, 200)
+
+    def test_AUTH_HTTPS_200_OK_GET(self):
+        auth = ('requeststest', 'requeststest')
+        url = 'https://convore.com/api/account/verify.json'
+        r = requests.get(url, auth=auth)
+
+        self.assertEqual(r.status_code, 200)
+
+        r = requests.get(url)
+        self.assertEqual(r.status_code, 200)
+
+        # reset auto authentication
+        requests.auth_manager.empty()
+
+    def test_POSTBIN_GET_POST_FILES(self):
+        bin = requests.post('http://www.postbin.org/')
+        self.assertEqual(bin.status_code, 200)
+
+        post = requests.post(bin.url, data={'some': 'data'})
+        self.assertEqual(post.status_code, 201)
+
+        post2 = requests.post(bin.url, files={'some': open('test_requests.py')})
+        self.assertEqual(post2.status_code, 201)
+
+        post3 = requests.post(bin.url, data='[{"some": "json"}]')
+        self.assertEqual(post.status_code, 201)
+
+    def test_POSTBIN_GET_POST_FILES_WITH_PARAMS(self):
+        bin = requests.post('http://www.postbin.org/')
+
+        self.assertEqual(bin.status_code, 200)
+
+        post2 = requests.post(bin.url, files={'some': open('test_requests.py')}, data={'some': 'data'})
+        self.assertEqual(post2.status_code, 201)
+
+
+    def test_POSTBIN_GET_POST_FILES_WITH_HEADERS(self):
+        bin = requests.post('http://www.postbin.org/')
+        self.assertEqual(bin.status_code, 200)
+
+        post2 = requests.post(bin.url, files={'some': open('test_requests.py')},
+        headers={'User-Agent': 'requests-tests'})
+
+        self.assertEqual(post2.status_code, 201)
+
+    def test_nonzero_evaluation(self):
+        r = requests.get('http://google.com/some-404-url')
+        self.assertEqual(bool(r), False)
+
+        r = requests.get('http://google.com/')
+        self.assertEqual(bool(r), True)
+
+    def test_request_ok_set(self):
+        r = requests.get('http://google.com/some-404-url')
+        self.assertEqual(r.ok, False)
+
+    def test_status_raising(self):
+        r = requests.get('http://google.com/some-404-url')
+        self.assertRaises(requests.HTTPError, r.raise_for_status)
+
+        r = requests.get('http://google.com/')
+        self.assertFalse(r.error)
+        r.raise_for_status()
+
+    def test_cookie_jar(self):
+        """
+        .. todo:: This really doesn't test to make sure the cookie is working
+        """
+
+        jar = cookielib.CookieJar()
+        self.assertFalse(jar)
+
+        requests.get('http://google.com', cookies=jar)
+        self.assertTrue(jar)
+
+    def test_decompress_gzip(self):
+
+        r = requests.get('http://api.stackoverflow.com/1.1/users/495995/top-answer-tags')
+        r.content.decode('ascii')
+
+    def test_autoauth(self):
+
+        conv_auth = ('requeststest', 'requeststest')
+        requests.auth_manager.add_auth('convore.com', conv_auth)
+
+        r = requests.get('https://convore.com/api/account/verify.json')
+        self.assertEquals(r.status_code, 200)
+
+    def test_unicode_get(self):
+        requests.get('http://google.com', params={'foo': u'føø'})
+        requests.get('http://google.com', params={u'føø': u'føø'})
+        requests.get('http://google.com', params={'føø': 'føø'})
+        requests.get('http://google.com', params={'foo': u'foo'})
+        requests.get('http://google.com/ø', params={'foo': u'foo'})
+
+    def test_httpauth_recursion(self):
+        conv_auth = ('requeststest', 'bad_password')
+
+        r = requests.get('https://convore.com/api/account/verify.json', auth=conv_auth)
+        self.assertEquals(r.status_code, 401)
 
 
 if __name__ == '__main__':
-	unittest.main()
+    unittest.main()

tox.ini

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