v2.24.0

Avoid an unnecessary computation of the length of data for non-stream requests (which determine content-length based upon body content).

.github/CONTRIBUTING.md

@@ -3,8 +3,8 @@
 Before opening any issues or proposing any pull requests, please do the
 following:
 
-1. Read our [Contributor's Guide](http://docs.python-requests.org/en/latest/dev/contributing/).
-2. Understand our [development philosophy](http://docs.python-requests.org/en/latest/dev/philosophy/).
+1. Read our [Contributor's Guide](https://requests.readthedocs.io/en/latest/dev/contributing/).
+2. Understand our [development philosophy](https://requests.readthedocs.io/en/latest/dev/philosophy/).
 
 To get the greatest chance of helpful responses, please also observe the
 following additional notes.

.github/FUNDING.yml

@@ -0,0 +1 @@
+custom: ['https://www.python.org/psf/forms/sponsor-application/']

.github/ISSUE_TEMPLATE/Bug_report.md

@@ -0,0 +1,34 @@
+---
+name: Bug report
+about: Create a report to help us improve
+
+---
+
+Summary.
+
+## Expected Result
+
+What you expected.
+
+## Actual Result
+
+What happened instead.
+
+## Reproduction Steps
+
+```python
+import requests
+
+```
+
+## System Information
+
+    $ python -m requests.help
+
+```
+<paste here>
+```
+
+This command is only available on Requests v2.16.4 and greater. Otherwise,
+please provide some basic information about your system (Python version,
+operating system, &c).

.github/ISSUE_TEMPLATE/Custom.md

@@ -0,0 +1,7 @@
+---
+name: Request for Help
+about: Guidance on using Requests.
+
+---
+
+Please refer to our [Stack Overflow tag](https://stackoverflow.com/questions/tagged/python-requests) for guidance.

.github/ISSUE_TEMPLATE/Feature_request.md

@@ -0,0 +1,7 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+
+---
+
+Requests is not accepting feature requests at this time.

.github/SECURITY.md

@@ -0,0 +1,93 @@
+# Vulnerability Disclosure
+
+If you think you have found a potential security vulnerability in
+requests, please email [Nate](mailto:nate.prewitt@gmail.com)
+and [Seth](mailto:sethmichaellarson@gmail.com) directly.
+**Do not file a public issue.**
+
+Our PGP Key fingerprints are:
+
+- 8722 7E29 AD9C FF5C FAC3  EA6A 44D3 FF97 B80D C864 ([@nateprewitt](https://keybase.io/nateprewitt))
+
+- EDD5 6765 A9D8 4653 CBC8  A134 51B0 6736 1740 F5FC ([@sethmlarson](https://keybase.io/sethmlarson))
+
+You can also contact us on [Keybase](https://keybase.io) with the
+profiles above if desired.
+
+If English is not your first language, please try to describe the
+problem and its impact to the best of your ability. For greater detail,
+please use your native language and we will try our best to translate it
+using online services.
+
+Please also include the code you used to find the problem and the
+shortest amount of code necessary to reproduce it.
+
+Please do not disclose this to anyone else. We will retrieve a CVE
+identifier if necessary and give you full credit under whatever name or
+alias you provide. We will only request an identifier when we have a fix
+and can publish it in a release.
+
+We will respect your privacy and will only publicize your involvement if
+you grant us permission.
+
+## Process
+
+This following information discusses the process the requests project
+follows in response to vulnerability disclosures. If you are disclosing
+a vulnerability, this section of the documentation lets you know how we
+will respond to your disclosure.
+
+### Timeline
+
+When you report an issue, one of the project members will respond to you
+within two days *at the outside*. In most cases responses will be
+faster, usually within 12 hours. This initial response will at the very
+least confirm receipt of the report.
+
+If we were able to rapidly reproduce the issue, the initial response
+will also contain confirmation of the issue. If we are not, we will
+often ask for more information about the reproduction scenario.
+
+Our goal is to have a fix for any vulnerability released within two
+weeks of the initial disclosure. This may potentially involve shipping
+an interim release that simply disables function while a more mature fix
+can be prepared, but will in the vast majority of cases mean shipping a
+complete release as soon as possible.
+
+Throughout the fix process we will keep you up to speed with how the fix
+is progressing. Once the fix is prepared, we will notify you that we
+believe we have a fix. Often we will ask you to confirm the fix resolves
+the problem in your environment, especially if we are not confident of
+our reproduction scenario.
+
+At this point, we will prepare for the release. We will obtain a CVE
+number if one is required, providing you with full credit for the
+discovery. We will also decide on a planned release date, and let you
+know when it is. This release date will *always* be on a weekday.
+
+At this point we will reach out to our major downstream packagers to
+notify them of an impending security-related patch so they can make
+arrangements. In addition, these packagers will be provided with the
+intended patch ahead of time, to ensure that they are able to promptly
+release their downstream packages. Currently the list of people we
+actively contact *ahead of a public release* is:
+
+-   Jeremy Cline, Red Hat (@jeremycline)
+-   Daniele Tricoli, Debian (@eriol)
+
+We will notify these individuals at least a week ahead of our planned
+release date to ensure that they have sufficient time to prepare. If you
+believe you should be on this list, please let one of the maintainers
+know at one of the email addresses at the top of this article.
+
+On release day, we will push the patch to our public repository, along
+with an updated changelog that describes the issue and credits you. We
+will then issue a PyPI release containing the patch.
+
+At this point, we will publicise the release. This will involve mails to
+mailing lists, Tweets, and all other communication mechanisms available
+to the core team.
+
+We will also explicitly mention which commits contain the fix to make it
+easier for other distributors and users to easily patch their own
+versions of requests if upgrading is not an option.

.gitignore

@@ -14,6 +14,12 @@ requests.egg-info/
 *.swp
 *.egg
 env/
+.venv/
+.eggs/
+.tox/
+.pytest_cache/
+.vscode/
+.eggs/
 
 .workon
 
@@ -23,7 +29,3 @@ t2.py
 dist
 
 /.mypy_cache/
-
-/.pytest_cache/
-
-/.tox/

.travis.yml

@@ -1,15 +1,4 @@
-sudo: false
 language: python
-python:
-  # - "3.4"
-  # - "3.5"
-  - "3.6"
-  # - "3.7-dev"
-  # - "pypy"  -- appears to hang
-  # - "pypy3"
-matrix:
-  allow_failures:
-    - python: 3.7-dev
 # command to install dependencies
 install: "make"
 # command to run tests
@@ -20,11 +9,18 @@ cache: pip
 jobs:
   include:
     - stage: test
-      script:
-        - make test-readme
-        - make ci
+      python: '2.7'
+    - stage: test
+      python: '3.5'
+    - stage: test
+      python: '3.6'
+    - stage: test
+      python: '3.7' 
+    - stage: test
+      python: 'pypy3'
+      dist: xenial
+    - stage: test
+      python: '3.8'
     - stage: coverage
-      python: 3.6
+      python: '3.6'
       script: codecov
-
-

3.0-HISTORY.rst

@@ -1,81 +0,0 @@
-3.0.0 (2017-xx-xx)
-++++++++++++++++++
-
-- Support for Python 2.6 has been dropped.
-
-  - The ``OrderedDict`` import no longer exists in compat.py because it is part
-    of ``collections`` in Python 2.7 and newer.
-
-- Simplified logic for determining Content-Length and Transfer-Encoding.
-  Requests will now avoid setting both headers on the same request, and
-  raise an exception if this is done manually by a user.
-
-- Remove the HTTPProxyAuth class in favor of supporting proxy auth via
-  the proxies parameter.
-
-- Relax how Requests strips bodies from redirects. 3.0.0 only supports body
-  removal on 301/302 POST redirects and all 303 redirects.
-
-- Remove support for non-string/bytes parameters in ``_basic_auth_str``.
-
-- Prevent ``Session.merge_environment`` from erroneously setting the
-  ``verify`` parameter to ``None`` instead of ``True``.
-
-- Streaming responses with ``Response.iter_lines`` or ``Response.iter_content``
-  now requires an encoding to be set if one isn't provided by the server.
-
-- Exception raised during read timeout for ``Response.iter_content`` and
-  ``Response.iter_lines`` changed from ``ConnectionError`` to more
-  specific ``ReadTimeout``.
-
-- Raise exception if multiple locations are returned during a redirect.
-
-- Update ConnectionPool connections when TLS/SSL settings change.
-
-- Remove simplejson import and only use standard json module.
-
-- Strip surrounding whitespace from urls.
-
-- MissingSchema and InvalidSchema renamed to MissingScheme and InvalidScheme
-  respectively.
-
-- Change merge order for environment settings to avoid excluding Session-level
-  settings.
-
-- Encode redirect URIs as latin-1 before performing redirects in Python 3 to
-  avoid mangling during the requoting process.
-
-- Remove the ``__bool__`` and ``__nonzero__`` methods from a ``Response``
-  object.
-
-  This has been a planned feature for over a year. The behaviour is surprising
-  to most people and breaks most of the assumptions that people have about
-  Response objects. This resolves issue `#2002`_
-
-- Skip over empty chunks in iterators. Empty chunks could prematurely signal
-  the end of a request body's transmission, skipping them allows all of the
-  data through. See `#2631`_ for more details.
-
-- Rename the ``req`` argument from ``Session.resolve_redirects`` method
-  to ``request``.
-
-- Rename the ``resp`` argument from ``Session.resolve_redirects`` to
-  ``response``.
-
-- New ``PreparedRequest.send`` method. Now, you can
-  ``Request().prepare().send()``.
-
-- All porcelain API functions (e.g. ``requests.get``, etc) now accept an
-  optional ``session`` parameter. If provided, the session given will be used
-  for the request, in place of one being created for you.
-
-- URLs are now automatically stripped of leading/trailing whitespace.
-
-- ``Response.raise_for_status()`` now returns the response object for good responses
-
-- Use ``HTTPHeaderDict`` for response headers, allowing easier access to
-  individual values when multiple response headers are sent using the same
-  header name.
-
-.. _#2002: https://github.com/kennethreitz/requests/issues/2002
-.. _#2631: https://github.com/kennethreitz/requests/issues/2631

AUTHORS.rst

@@ -1,13 +1,16 @@
-Requests is written and maintained by Kenneth Reitz and
-various contributors:
+Requests was lovingly created by Kenneth Reitz.
 
-Keepers of the Four Crystals
+Keepers of the Crystals
+```````````````````````
+
+- Nate Prewitt `@nateprewitt <https://github.com/nateprewitt>`_.
+- Seth M. Larson `@sethmlarson <https://github.com/sethmlarson>`_.
+
+Previous Keepers of Crystals
 ````````````````````````````
-
-- Kenneth Reitz <me@kennethreitz.org> `@kennethreitz <https://github.com/kennethreitz>`_, Keeper of the Master Crystal.
+- Kenneth Reitz <me@kennethreitz.org> `@kennethreitz <https://github.com/kennethreitz>`_, reluctant Keeper of the Master Crystal.
 - Cory Benfield <cory@lukasa.co.uk> `@lukasa <https://github.com/lukasa>`_
-- Ian Cordasco <graffatcolmingov@gmail.com> `@sigmavirus24 <https://github.com/sigmavirus24>`_
-- Nate Prewitt <nate.prewitt@gmail.com> `@nateprewitt <https://github.com/nateprewitt>`_
+- Ian Cordasco <graffatcolmingov@gmail.com> `@sigmavirus24 <https://github.com/sigmavirus24>`_.
 
 
 Patches and Suggestions
@@ -153,19 +156,16 @@ Patches and Suggestions
 - Muhammad Yasoob Ullah Khalid <yasoob.khld@gmail.com> (`@yasoob <https://github.com/yasoob>`_)
 - Paul van der Linden (`@pvanderlinden <https://github.com/pvanderlinden>`_)
 - Colin Dickson (`@colindickson <https://github.com/colindickson>`_)
-- Sabari Kumar Murugesan (`@neosab <https://github.com/neosab>`_)
 - Smiley Barry (`@smiley <https://github.com/smiley>`_)
 - Shagun Sodhani (`@shagunsodhani <https://github.com/shagunsodhani>`_)
 - Robin Linderborg (`@vienno <https://github.com/vienno>`_)
 - Brian Samek (`@bsamek <https://github.com/bsamek>`_)
 - Dmitry Dygalo (`@Stranger6667 <https://github.com/Stranger6667>`_)
-- Tomáš Heger (`@geckon <https://github.com/geckon>`_)
 - piotrjurkiewicz
 - Jesse Shapiro <jesse@jesseshapiro.net> (`@haikuginger <https://github.com/haikuginger>`_)
 - Nate Prewitt <nate.prewitt@gmail.com> (`@nateprewitt <https://github.com/nateprewitt>`_)
 - Maik Himstedt
 - Michael Hunsinger
-- Jeremy Cline <jcline@redhat.com> (`@jeremycline <https://github.com/jeremycline>`_)
 - Brian Bamsch <bbamsch32@gmail.com> (`@bbamsch <https://github.com/bbamsch>`_)
 - Om Prakash Kumar <omprakash070@gmail.com> (`@iamprakashom <https://github.com/iamprakashom>`_)
 - Philipp Konrad <gardiac2002@gmail.com> (`@gardiac2002 <https://github.com/gardiac2002>`_)
@@ -179,11 +179,14 @@ Patches and Suggestions
 - Shmuel Amar (`@shmuelamar <https://github.com/shmuelamar>`_)
 - Gary Wu (`@garywu <https://github.com/garywu>`_)
 - Ryan Pineo (`@ryanpineo <https://github.com/ryanpineo>`_)
-<<<<<<< HEAD
 - Ed Morley (`@edmorley <https://github.com/edmorley>`_)
 - Matt Liu <liumatt@gmail.com> (`@mlcrazy <https://github.com/mlcrazy>`_)
 - Taylor Hoff <primdevs@protonmail.com> (`@PrimordialHelios <https://github.com/PrimordialHelios>`_)
-- Hugo van Kemenade (`@hugovk <https://github.com/hugovk>`_)
-=======
-- Allan Crooks (`@the-allanc <https://github.com/the-allanc>`_)
->>>>>>> 4f0b496d2b3c91d72a951bebdd6be9cec33c17d6
+- Arthur Vigil (`@ahvigil <https://github.com/ahvigil>`_)
+- Nehal J Wani (`@nehaljwani <https://github.com/nehaljwani>`_)
+- Demetrios Bairaktaris (`@DemetriosBairaktaris <https://github.com/demetriosbairaktaris>`_)
+- Darren Dormer (`@ddormer <https://github.com/ddormer>`_)
+- Rajiv Mayani (`@mayani <https://github.com/mayani>`_)
+- Antti Kaihola (`@akaihola <https://github.com/akaihola>`_)
+- "Dull Bananas" <dull.bananas0@gmail.com> (`@dullbananas <https://github.com/dullbananas>`_)
+- Alessio Izzo (`@aless10 <https://github.com/aless10>`_)

LICENSE

@@ -1,10 +1,10 @@
-Copyright 2017 Kenneth Reitz
+Copyright 2019 Kenneth Reitz
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
 
-       http://www.apache.org/licenses/LICENSE-2.0
+       https://www.apache.org/licenses/LICENSE-2.0
 
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,

MANIFEST.in

@@ -1,2 +1,2 @@
-include README.rst LICENSE NOTICE HISTORY.rst pytest.ini requirements.txt
+include README.md LICENSE NOTICE HISTORY.md pytest.ini requirements.txt Pipfile Pipfile.lock
 recursive-include tests *.py

Makefile

@@ -1,12 +1,10 @@
 .PHONY: docs
 init:
 	pip install pipenv --upgrade
-	pipenv install --dev --skip-lock
+	pipenv install --dev
 test:
 	# This runs all of the tests, on both Python 2 and Python 3.
-	python setup.py test
-mypy:
-	python setup.py mypy
+	detox
 ci:
 	pipenv run py.test -n 8 --boxed --junitxml=report.xml
 

Pipfile

@@ -1,32 +1,25 @@
 [[source]]
-
-url = "https://pypi.python.org/simple"
+url = "https://pypi.org/simple/"
 verify_ssl = true
-
+name = "pypi"
 
 [dev-packages]
-
-pytest = ">=2.8.0"
+alabaster = "*"
 codecov = "*"
-pytest-httpbin = "*"
+docutils = "*"
+detox = "*"
+"flake8" = "*"
+httpbin = ">=0.7.0"
+more-itertools = "<6.0"
+pysocks = "*"
+pytest = ">=2.8.0,<=3.10.1"
+pytest-httpbin = ">=0.0.7,<1.0"
 pytest-mock = "*"
 pytest-cov = "*"
-pytest-xdist = "*"
-alabaster = "*"
+pytest-xdist = "<=1.25"
 readme-renderer = "*"
 sphinx = "<=1.5.5"
-pysocks = "*"
-docutils = "*"
-"flake8" = "*"
 tox = "*"
-detox = "*"
-httpbin = "==0.5.0"
-pytest-mypy = {git = "https://github.com/petr-muller/pytest-mypy", editable = true, ref = "flush-errors"}
-white = {version="*"}
-"e1839a8" = {path = ".", editable = true, extras=["socks"]}
-mypy = "*"
-"rfc3986" = "*"
-
 
 [packages]
-
+"requests" = {path = ".", editable = true, extras = ["socks"]}

Pipfile.lock

@@ -0,0 +1,765 @@
+{
+    "_meta": {
+        "hash": {
+            "sha256": "9c8d31d74dee008bc23d846267f23665288b0b1bee2525baca681d1061726701"
+        },
+        "pipfile-spec": 6,
+        "requires": {},
+        "sources": [
+            {
+                "name": "pypi",
+                "url": "https://pypi.org/simple/",
+                "verify_ssl": true
+            }
+        ]
+    },
+    "default": {
+        "certifi": {
+            "hashes": [
+                "sha256:017c25db2a153ce562900032d5bc68e9f191e44e9a0f762f373977de9df1fbb3",
+                "sha256:25b64c7da4cd7479594d035c08c2d809eb4aab3a26e5a990ea98cc450c320f1f"
+            ],
+            "version": "==2019.11.28"
+        },
+        "chardet": {
+            "hashes": [
+                "sha256:84ab92ed1c4d4f16916e05906b6b75a6c0fb5db821cc65e70cbd64a3e2a5eaae",
+                "sha256:fc323ffcaeaed0e0a02bf4d117757b98aed530d9ed4531e3e15460124c106691"
+            ],
+            "version": "==3.0.4"
+        },
+        "idna": {
+            "hashes": [
+                "sha256:7588d1c14ae4c77d74036e8c22ff447b26d0fde8f007354fd48a7814db15b7cb",
+                "sha256:a068a21ceac8a4d63dbfd964670474107f541babbd2250d61922f029858365fa"
+            ],
+            "version": "==2.9"
+        },
+        "pysocks": {
+            "hashes": [
+                "sha256:08e69f092cc6dbe92a0fdd16eeb9b9ffbc13cadfe5ca4c7bd92ffb078b293299",
+                "sha256:2725bd0a9925919b9b51739eea5f9e2bae91e83288108a9ad338b2e3a4435ee5",
+                "sha256:3f8804571ebe159c380ac6de37643bb4685970655d3bba243530d6558b799aa0"
+            ],
+            "version": "==1.7.1"
+        },
+        "requests": {
+            "editable": true,
+            "extras": [
+                "socks"
+            ],
+            "path": "."
+        },
+        "urllib3": {
+            "hashes": [
+                "sha256:2f3db8b19923a873b3e5256dc9c2dedfa883e33d87c690d9c7913e1f40673cdc",
+                "sha256:87716c2d2a7121198ebcb7ce7cccf6ce5e9ba539041cfbaeecfb641dc0bf6acc"
+            ],
+            "version": "==1.25.8"
+        }
+    },
+    "develop": {
+        "alabaster": {
+            "hashes": [
+                "sha256:446438bdcca0e05bd45ea2de1668c1d9b032e1a9154c2c259092d77031ddd359",
+                "sha256:a661d72d58e6ea8a57f7a86e37d86716863ee5e92788398526d58b26a4e4dc02"
+            ],
+            "index": "pypi",
+            "version": "==0.7.12"
+        },
+        "apipkg": {
+            "hashes": [
+                "sha256:37228cda29411948b422fae072f57e31d3396d2ee1c9783775980ee9c9990af6",
+                "sha256:58587dd4dc3daefad0487f6d9ae32b4542b185e1c36db6993290e7c41ca2b47c"
+            ],
+            "version": "==1.5"
+        },
+        "appdirs": {
+            "hashes": [
+                "sha256:9e5896d1372858f8dd3344faf4e5014d21849c756c8d5701f78f8a103b372d92",
+                "sha256:d8b24664561d0d34ddfaec54636d502d7cea6e29c3eaf68f3df6180863e2166e"
+            ],
+            "version": "==1.4.3"
+        },
+        "atomicwrites": {
+            "hashes": [
+                "sha256:03472c30eb2c5d1ba9227e4c2ca66ab8287fbfbbda3888aa93dc2e28fc6811b4",
+                "sha256:75a9445bac02d8d058d5e1fe689654ba5a6556a1dfd8ce6ec55a0ed79866cfa6"
+            ],
+            "version": "==1.3.0"
+        },
+        "attrs": {
+            "hashes": [
+                "sha256:08a96c641c3a74e44eb59afb61a24f2cb9f4d7188748e76ba4bb5edfa3cb7d1c",
+                "sha256:f7b7ce16570fe9965acd6d30101a28f62fb4a7f9e926b3bbc9b61f8b04247e72"
+            ],
+            "version": "==19.3.0"
+        },
+        "babel": {
+            "hashes": [
+                "sha256:1aac2ae2d0d8ea368fa90906567f5c08463d98ade155c0c4bfedd6a0f7160e38",
+                "sha256:d670ea0b10f8b723672d3a6abeb87b565b244da220d76b4dba1b66269ec152d4"
+            ],
+            "version": "==2.8.0"
+        },
+        "bleach": {
+            "hashes": [
+                "sha256:cc8da25076a1fe56c3ac63671e2194458e0c4d9c7becfd52ca251650d517903c",
+                "sha256:e78e426105ac07026ba098f04de8abe9b6e3e98b5befbf89b51a5ef0a4292b03"
+            ],
+            "version": "==3.1.4"
+        },
+        "blinker": {
+            "hashes": [
+                "sha256:471aee25f3992bd325afa3772f1063dbdbbca947a041b8b89466dc00d606f8b6"
+            ],
+            "version": "==1.4"
+        },
+        "brotlipy": {
+            "hashes": [
+                "sha256:07194f4768eb62a4f4ea76b6d0df6ade185e24ebd85877c351daa0a069f1111a",
+                "sha256:091b299bf36dd6ef7a06570dbc98c0f80a504a56c5b797f31934d2ad01ae7d17",
+                "sha256:09ec3e125d16749b31c74f021aba809541b3564e5359f8c265cbae442810b41a",
+                "sha256:0be698678a114addcf87a4b9496c552c68a2c99bf93cf8e08f5738b392e82057",
+                "sha256:0fa6088a9a87645d43d7e21e32b4a6bf8f7c3939015a50158c10972aa7f425b7",
+                "sha256:1379347337dc3d20b2d61456d44ccce13e0625db2611c368023b4194d5e2477f",
+                "sha256:1ea4e578241504b58f2456a6c69952c88866c794648bdc74baee74839da61d44",
+                "sha256:2699945a0a992c04fc7dc7fa2f1d0575a2c8b4b769f2874a08e8eae46bef36ae",
+                "sha256:2a80319ae13ea8dd60ecdc4f5ccf6da3ae64787765923256b62c598c5bba4121",
+                "sha256:2e5c64522364a9ebcdf47c5744a5ddeb3f934742d31e61ebfbbc095460b47162",
+                "sha256:36def0b859beaf21910157b4c33eb3b06d8ce459c942102f16988cca6ea164df",
+                "sha256:3a3e56ced8b15fbbd363380344f70f3b438e0fd1fcf27b7526b6172ea950e867",
+                "sha256:3c1d5e2cf945a46975bdb11a19257fa057b67591eb232f393d260e7246d9e571",
+                "sha256:4e4638b49835d567d447a2cfacec109f9a777f219f071312268b351b6839436d",
+                "sha256:50ca336374131cfad20612f26cc43c637ac0bfd2be3361495e99270883b52962",
+                "sha256:5de6f7d010b7558f72f4b061a07395c5c3fd57f0285c5af7f126a677b976a868",
+                "sha256:637847560d671657f993313ecc6c6c6666a936b7a925779fd044065c7bc035b9",
+                "sha256:653faef61241bf8bf99d73ca7ec4baa63401ba7b2a2aa88958394869379d67c7",
+                "sha256:786afc8c9bd67de8d31f46e408a3386331e126829114e4db034f91eacb05396d",
+                "sha256:79aaf217072840f3e9a3b641cccc51f7fc23037496bd71e26211856b93f4b4cb",
+                "sha256:7e31f7adcc5851ca06134705fcf3478210da45d35ad75ec181e1ce9ce345bb38",
+                "sha256:8b39abc3256c978f575df5cd7893153277216474f303e26f0e43ba3d3969ef96",
+                "sha256:9448227b0df082e574c45c983fa5cd4bda7bfb11ea6b59def0940c1647be0c3c",
+                "sha256:96bc59ff9b5b5552843dc67999486a220e07a0522dddd3935da05dc194fa485c",
+                "sha256:a07647886e24e2fb2d68ca8bf3ada398eb56fd8eac46c733d4d95c64d17f743b",
+                "sha256:af65d2699cb9f13b26ec3ba09e75e80d31ff422c03675fcb36ee4dabe588fdc2",
+                "sha256:b4c98b0d2c9c7020a524ca5bbff42027db1004c6571f8bc7b747f2b843128e7a",
+                "sha256:c6cc0036b1304dd0073eec416cb2f6b9e37ac8296afd9e481cac3b1f07f9db25",
+                "sha256:d2c1c724c4ac375feb2110f1af98ecdc0e5a8ea79d068efb5891f621a5b235cb",
+                "sha256:dc6c5ee0df9732a44d08edab32f8a616b769cc5a4155a12d2d010d248eb3fb07",
+                "sha256:fd1d1c64214af5d90014d82cee5d8141b13d44c92ada7a0c0ec0679c6f15a471"
+            ],
+            "version": "==0.7.0"
+        },
+        "certifi": {
+            "hashes": [
+                "sha256:017c25db2a153ce562900032d5bc68e9f191e44e9a0f762f373977de9df1fbb3",
+                "sha256:25b64c7da4cd7479594d035c08c2d809eb4aab3a26e5a990ea98cc450c320f1f"
+            ],
+            "version": "==2019.11.28"
+        },
+        "cffi": {
+            "hashes": [
+                "sha256:001bf3242a1bb04d985d63e138230802c6c8d4db3668fb545fb5005ddf5bb5ff",
+                "sha256:00789914be39dffba161cfc5be31b55775de5ba2235fe49aa28c148236c4e06b",
+                "sha256:028a579fc9aed3af38f4892bdcc7390508adabc30c6af4a6e4f611b0c680e6ac",
+                "sha256:14491a910663bf9f13ddf2bc8f60562d6bc5315c1f09c704937ef17293fb85b0",
+                "sha256:1cae98a7054b5c9391eb3249b86e0e99ab1e02bb0cc0575da191aedadbdf4384",
+                "sha256:2089ed025da3919d2e75a4d963d008330c96751127dd6f73c8dc0c65041b4c26",
+                "sha256:2d384f4a127a15ba701207f7639d94106693b6cd64173d6c8988e2c25f3ac2b6",
+                "sha256:337d448e5a725bba2d8293c48d9353fc68d0e9e4088d62a9571def317797522b",
+                "sha256:399aed636c7d3749bbed55bc907c3288cb43c65c4389964ad5ff849b6370603e",
+                "sha256:3b911c2dbd4f423b4c4fcca138cadde747abdb20d196c4a48708b8a2d32b16dd",
+                "sha256:3d311bcc4a41408cf5854f06ef2c5cab88f9fded37a3b95936c9879c1640d4c2",
+                "sha256:62ae9af2d069ea2698bf536dcfe1e4eed9090211dbaafeeedf5cb6c41b352f66",
+                "sha256:66e41db66b47d0d8672d8ed2708ba91b2f2524ece3dee48b5dfb36be8c2f21dc",
+                "sha256:675686925a9fb403edba0114db74e741d8181683dcf216be697d208857e04ca8",
+                "sha256:7e63cbcf2429a8dbfe48dcc2322d5f2220b77b2e17b7ba023d6166d84655da55",
+                "sha256:8a6c688fefb4e1cd56feb6c511984a6c4f7ec7d2a1ff31a10254f3c817054ae4",
+                "sha256:8c0ffc886aea5df6a1762d0019e9cb05f825d0eec1f520c51be9d198701daee5",
+                "sha256:95cd16d3dee553f882540c1ffe331d085c9e629499ceadfbda4d4fde635f4b7d",
+                "sha256:99f748a7e71ff382613b4e1acc0ac83bf7ad167fb3802e35e90d9763daba4d78",
+                "sha256:b8c78301cefcf5fd914aad35d3c04c2b21ce8629b5e4f4e45ae6812e461910fa",
+                "sha256:c420917b188a5582a56d8b93bdd8e0f6eca08c84ff623a4c16e809152cd35793",
+                "sha256:c43866529f2f06fe0edc6246eb4faa34f03fe88b64a0a9a942561c8e22f4b71f",
+                "sha256:cab50b8c2250b46fe738c77dbd25ce017d5e6fb35d3407606e7a4180656a5a6a",
+                "sha256:cef128cb4d5e0b3493f058f10ce32365972c554572ff821e175dbc6f8ff6924f",
+                "sha256:cf16e3cf6c0a5fdd9bc10c21687e19d29ad1fe863372b5543deaec1039581a30",
+                "sha256:e56c744aa6ff427a607763346e4170629caf7e48ead6921745986db3692f987f",
+                "sha256:e577934fc5f8779c554639376beeaa5657d54349096ef24abe8c74c5d9c117c3",
+                "sha256:f2b0fa0c01d8a0c7483afd9f31d7ecf2d71760ca24499c8697aeb5ca37dc090c"
+            ],
+            "version": "==1.14.0"
+        },
+        "chardet": {
+            "hashes": [
+                "sha256:84ab92ed1c4d4f16916e05906b6b75a6c0fb5db821cc65e70cbd64a3e2a5eaae",
+                "sha256:fc323ffcaeaed0e0a02bf4d117757b98aed530d9ed4531e3e15460124c106691"
+            ],
+            "version": "==3.0.4"
+        },
+        "click": {
+            "hashes": [
+                "sha256:8a18b4ea89d8820c5d0c7da8a64b2c324b4dabb695804dbfea19b9be9d88c0cc",
+                "sha256:e345d143d80bf5ee7534056164e5e112ea5e22716bbb1ce727941f4c8b471b9a"
+            ],
+            "version": "==7.1.1"
+        },
+        "codecov": {
+            "hashes": [
+                "sha256:09fb045eb044a619cd2b9dacd7789ae8e322cb7f18196378579fd8d883e6b665",
+                "sha256:aeeefa3a03cac8a78e4f988e935b51a4689bb1f17f20d4e827807ee11135f845"
+            ],
+            "index": "pypi",
+            "version": "==2.0.22"
+        },
+        "configparser": {
+            "hashes": [
+                "sha256:254c1d9c79f60c45dfde850850883d5aaa7f19a23f13561243a050d5a7c3fe4c",
+                "sha256:c7d282687a5308319bf3d2e7706e575c635b0a470342641c93bea0ea3b5331df"
+            ],
+            "markers": "python_version < '3.2'",
+            "version": "==4.0.2"
+        },
+        "contextlib2": {
+            "hashes": [
+                "sha256:01f490098c18b19d2bd5bb5dc445b2054d2fa97f09a4280ba2c5f3c394c8162e",
+                "sha256:3355078a159fbb44ee60ea80abd0d87b80b78c248643b49aa6d94673b413609b"
+            ],
+            "markers": "python_version < '3.2'",
+            "version": "==0.6.0.post1"
+        },
+        "coverage": {
+            "hashes": [
+                "sha256:03f630aba2b9b0d69871c2e8d23a69b7fe94a1e2f5f10df5049c0df99db639a0",
+                "sha256:046a1a742e66d065d16fb564a26c2a15867f17695e7f3d358d7b1ad8a61bca30",
+                "sha256:0a907199566269e1cfa304325cc3b45c72ae341fbb3253ddde19fa820ded7a8b",
+                "sha256:165a48268bfb5a77e2d9dbb80de7ea917332a79c7adb747bd005b3a07ff8caf0",
+                "sha256:1b60a95fc995649464e0cd48cecc8288bac5f4198f21d04b8229dc4097d76823",
+                "sha256:1f66cf263ec77af5b8fe14ef14c5e46e2eb4a795ac495ad7c03adc72ae43fafe",
+                "sha256:2e08c32cbede4a29e2a701822291ae2bc9b5220a971bba9d1e7615312efd3037",
+                "sha256:3844c3dab800ca8536f75ae89f3cf566848a3eb2af4d9f7b1103b4f4f7a5dad6",
+                "sha256:408ce64078398b2ee2ec08199ea3fcf382828d2f8a19c5a5ba2946fe5ddc6c31",
+                "sha256:443be7602c790960b9514567917af538cac7807a7c0c0727c4d2bbd4014920fd",
+                "sha256:4482f69e0701139d0f2c44f3c395d1d1d37abd81bfafbf9b6efbe2542679d892",
+                "sha256:4a8a259bf990044351baf69d3b23e575699dd60b18460c71e81dc565f5819ac1",
+                "sha256:513e6526e0082c59a984448f4104c9bf346c2da9961779ede1fc458e8e8a1f78",
+                "sha256:5f587dfd83cb669933186661a351ad6fc7166273bc3e3a1531ec5c783d997aac",
+                "sha256:62061e87071497951155cbccee487980524d7abea647a1b2a6eb6b9647df9006",
+                "sha256:641e329e7f2c01531c45c687efcec8aeca2a78a4ff26d49184dce3d53fc35014",
+                "sha256:65a7e00c00472cd0f59ae09d2fb8a8aaae7f4a0cf54b2b74f3138d9f9ceb9cb2",
+                "sha256:6ad6ca45e9e92c05295f638e78cd42bfaaf8ee07878c9ed73e93190b26c125f7",
+                "sha256:73aa6e86034dad9f00f4bbf5a666a889d17d79db73bc5af04abd6c20a014d9c8",
+                "sha256:7c9762f80a25d8d0e4ab3cb1af5d9dffbddb3ee5d21c43e3474c84bf5ff941f7",
+                "sha256:85596aa5d9aac1bf39fe39d9fa1051b0f00823982a1de5766e35d495b4a36ca9",
+                "sha256:86a0ea78fd851b313b2e712266f663e13b6bc78c2fb260b079e8b67d970474b1",
+                "sha256:8a620767b8209f3446197c0e29ba895d75a1e272a36af0786ec70fe7834e4307",
+                "sha256:922fb9ef2c67c3ab20e22948dcfd783397e4c043a5c5fa5ff5e9df5529074b0a",
+                "sha256:9fad78c13e71546a76c2f8789623eec8e499f8d2d799f4b4547162ce0a4df435",
+                "sha256:a37c6233b28e5bc340054cf6170e7090a4e85069513320275a4dc929144dccf0",
+                "sha256:c3fc325ce4cbf902d05a80daa47b645d07e796a80682c1c5800d6ac5045193e5",
+                "sha256:cda33311cb9fb9323958a69499a667bd728a39a7aa4718d7622597a44c4f1441",
+                "sha256:db1d4e38c9b15be1521722e946ee24f6db95b189d1447fa9ff18dd16ba89f732",
+                "sha256:eda55e6e9ea258f5e4add23bcf33dc53b2c319e70806e180aecbff8d90ea24de",
+                "sha256:f372cdbb240e09ee855735b9d85e7f50730dcfb6296b74b95a3e5dea0615c4c1"
+            ],
+            "version": "==5.0.4"
+        },
+        "decorator": {
+            "hashes": [
+                "sha256:41fa54c2a0cc4ba648be4fd43cff00aedf5b9465c9bf18d64325bc225f08f760",
+                "sha256:e3a62f0520172440ca0dcc823749319382e377f37f140a0b99ef45fecb84bfe7"
+            ],
+            "version": "==4.4.2"
+        },
+        "detox": {
+            "hashes": [
+                "sha256:e650f95f0c7f5858578014b3b193e5dac76c89285c1bbe4bae598fd641bf9cd3",
+                "sha256:fcad009e2d20ce61176dc826a2c1562bd712fe53953ca603b455171cf819080f"
+            ],
+            "index": "pypi",
+            "version": "==0.19"
+        },
+        "distlib": {
+            "hashes": [
+                "sha256:2e166e231a26b36d6dfe35a48c4464346620f8645ed0ace01ee31822b288de21"
+            ],
+            "version": "==0.3.0"
+        },
+        "dnspython": {
+            "hashes": [
+                "sha256:36c5e8e38d4369a08b6780b7f27d790a292b2b08eea01607865bf0936c558e01",
+                "sha256:f69c21288a962f4da86e56c4905b49d11aba7938d3d740e80d9e366ee4f1632d"
+            ],
+            "version": "==1.16.0"
+        },
+        "docutils": {
+            "hashes": [
+                "sha256:0c5b78adfbf7762415433f5515cd5c9e762339e23369dbe8000d84a4bf4ab3af",
+                "sha256:c2de3a60e9e7d07be26b7f2b00ca0309c207e06c100f9cc2a94931fc75a478fc"
+            ],
+            "index": "pypi",
+            "version": "==0.16"
+        },
+        "entrypoints": {
+            "hashes": [
+                "sha256:589f874b313739ad35be6e0cd7efde2a4e9b6fea91edcc34e58ecbb8dbe56d19",
+                "sha256:c70dd71abe5a8c85e55e12c19bd91ccfeec11a6e99044204511f9ed547d48451"
+            ],
+            "version": "==0.3"
+        },
+        "enum34": {
+            "hashes": [
+                "sha256:a98a201d6de3f2ab3db284e70a33b0f896fbf35f8086594e8c9e74b909058d53",
+                "sha256:c3858660960c984d6ab0ebad691265180da2b43f07e061c0f8dca9ef3cffd328",
+                "sha256:cce6a7477ed816bd2542d03d53db9f0db935dd013b70f336a95c73979289f248"
+            ],
+            "markers": "python_version == '2.7' or python_version == '3.3'",
+            "version": "==1.1.10"
+        },
+        "eventlet": {
+            "hashes": [
+                "sha256:658b1cd80937adc1a4860de2841e0528f64e2ca672885c4e00fc0e2217bde6b1",
+                "sha256:6c9c625af48424c4680d89314dbe45a76cc990cf002489f9469ff214b044ffc1"
+            ],
+            "version": "==0.25.1"
+        },
+        "execnet": {
+            "hashes": [
+                "sha256:cacb9df31c9680ec5f95553976c4da484d407e85e41c83cb812aa014f0eddc50",
+                "sha256:d4efd397930c46415f62f8a31388d6be4f27a91d7550eb79bc64a756e0056547"
+            ],
+            "version": "==1.7.1"
+        },
+        "filelock": {
+            "hashes": [
+                "sha256:18d82244ee114f543149c66a6e0c14e9c4f8a1044b5cdaadd0f82159d6a6ff59",
+                "sha256:929b7d63ec5b7d6b71b0fa5ac14e030b3f70b75747cef1b10da9b879fef15836"
+            ],
+            "version": "==3.0.12"
+        },
+        "flake8": {
+            "hashes": [
+                "sha256:45681a117ecc81e870cbf1262835ae4af5e7a8b08e40b944a8a6e6b895914cfb",
+                "sha256:49356e766643ad15072a789a20915d3c91dc89fd313ccd71802303fd67e4deca"
+            ],
+            "index": "pypi",
+            "version": "==3.7.9"
+        },
+        "flask": {
+            "hashes": [
+                "sha256:4efa1ae2d7c9865af48986de8aeb8504bf32c7f3d6fdc9353d34b21f4b127060",
+                "sha256:8a4fdd8936eba2512e9c85df320a37e694c93945b33ef33c89946a340a238557"
+            ],
+            "version": "==1.1.2"
+        },
+        "funcsigs": {
+            "hashes": [
+                "sha256:330cc27ccbf7f1e992e69fef78261dc7c6569012cf397db8d3de0234e6c937ca",
+                "sha256:a7bb0f2cf3a3fd1ab2732cb49eba4252c2af4240442415b4abce3b87022a8f50"
+            ],
+            "markers": "python_version < '3.0'",
+            "version": "==1.0.2"
+        },
+        "functools32": {
+            "hashes": [
+                "sha256:89d824aa6c358c421a234d7f9ee0bd75933a67c29588ce50aaa3acdf4d403fa0",
+                "sha256:f6253dfbe0538ad2e387bd8fdfd9293c925d63553f5813c4e587745416501e6d"
+            ],
+            "markers": "python_version < '3.2'",
+            "version": "==3.2.3.post2"
+        },
+        "greenlet": {
+            "hashes": [
+                "sha256:000546ad01e6389e98626c1367be58efa613fa82a1be98b0c6fc24b563acc6d0",
+                "sha256:0d48200bc50cbf498716712129eef819b1729339e34c3ae71656964dac907c28",
+                "sha256:23d12eacffa9d0f290c0fe0c4e81ba6d5f3a5b7ac3c30a5eaf0126bf4deda5c8",
+                "sha256:37c9ba82bd82eb6a23c2e5acc03055c0e45697253b2393c9a50cef76a3985304",
+                "sha256:51155342eb4d6058a0ffcd98a798fe6ba21195517da97e15fca3db12ab201e6e",
+                "sha256:51503524dd6f152ab4ad1fbd168fc6c30b5795e8c70be4410a64940b3abb55c0",
+                "sha256:7457d685158522df483196b16ec648b28f8e847861adb01a55d41134e7734122",
+                "sha256:8041e2de00e745c0e05a502d6e6db310db7faa7c979b3a5877123548a4c0b214",
+                "sha256:81fcd96a275209ef117e9ec91f75c731fa18dcfd9ffaa1c0adbdaa3616a86043",
+                "sha256:853da4f9563d982e4121fed8c92eea1a4594a2299037b3034c3c898cb8e933d6",
+                "sha256:8b4572c334593d449113f9dc8d19b93b7b271bdbe90ba7509eb178923327b625",
+                "sha256:9416443e219356e3c31f1f918a91badf2e37acf297e2fa13d24d1cc2380f8fbc",
+                "sha256:9854f612e1b59ec66804931df5add3b2d5ef0067748ea29dc60f0efdcda9a638",
+                "sha256:99a26afdb82ea83a265137a398f570402aa1f2b5dfb4ac3300c026931817b163",
+                "sha256:a19bf883b3384957e4a4a13e6bd1ae3d85ae87f4beb5957e35b0be287f12f4e4",
+                "sha256:a9f145660588187ff835c55a7d2ddf6abfc570c2651c276d3d4be8a2766db490",
+                "sha256:ac57fcdcfb0b73bb3203b58a14501abb7e5ff9ea5e2edfa06bb03035f0cff248",
+                "sha256:bcb530089ff24f6458a81ac3fa699e8c00194208a724b644ecc68422e1111939",
+                "sha256:beeabe25c3b704f7d56b573f7d2ff88fc99f0138e43480cecdfcaa3b87fe4f87",
+                "sha256:d634a7ea1fc3380ff96f9e44d8d22f38418c1c381d5fac680b272d7d90883720",
+                "sha256:d97b0661e1aead761f0ded3b769044bb00ed5d33e1ec865e891a8b128bf7c656",
+                "sha256:e538b8dae561080b542b0f5af64d47ef859f22517f7eca617bb314e0e03fd7ef"
+            ],
+            "version": "==0.4.15"
+        },
+        "httpbin": {
+            "hashes": [
+                "sha256:7a04b5904c80b7aa04dd0a6af6520d68ce17a5db175e66a64b971f8e93d73a26",
+                "sha256:cbb37790c91575f4f15757f42ad41d9f729eb227d5edbe89e4ec175486db8dfa"
+            ],
+            "index": "pypi",
+            "version": "==0.7.0"
+        },
+        "idna": {
+            "hashes": [
+                "sha256:7588d1c14ae4c77d74036e8c22ff447b26d0fde8f007354fd48a7814db15b7cb",
+                "sha256:a068a21ceac8a4d63dbfd964670474107f541babbd2250d61922f029858365fa"
+            ],
+            "version": "==2.9"
+        },
+        "imagesize": {
+            "hashes": [
+                "sha256:6965f19a6a2039c7d48bca7dba2473069ff854c36ae6f19d2cde309d998228a1",
+                "sha256:b1f6b5a4eab1f73479a50fb79fcf729514a900c341d8503d62a62dbc4127a2b1"
+            ],
+            "version": "==1.2.0"
+        },
+        "importlib-metadata": {
+            "hashes": [
+                "sha256:2a688cbaa90e0cc587f1df48bdc97a6eadccdcd9c35fb3f976a09e3b5016d90f",
+                "sha256:34513a8a0c4962bc66d35b359558fd8a5e10cd472d37aec5f66858addef32c1e"
+            ],
+            "markers": "python_version < '3.8'",
+            "version": "==1.6.0"
+        },
+        "importlib-resources": {
+            "hashes": [
+                "sha256:4019b6a9082d8ada9def02bece4a76b131518866790d58fdda0b5f8c603b36c2",
+                "sha256:dd98ceeef3f5ad2ef4cc287b8586da4ebad15877f351e9688987ad663a0a29b8"
+            ],
+            "markers": "python_version < '3.7'",
+            "version": "==1.4.0"
+        },
+        "itsdangerous": {
+            "hashes": [
+                "sha256:321b033d07f2a4136d3ec762eac9f16a10ccd60f53c0c91af90217ace7ba1f19",
+                "sha256:b12271b2047cb23eeb98c8b5622e2e5c5e9abd9784a153e9d8ef9cb4dd09d749"
+            ],
+            "version": "==1.1.0"
+        },
+        "jinja2": {
+            "hashes": [
+                "sha256:93187ffbc7808079673ef52771baa950426fd664d3aad1d0fa3e95644360e250",
+                "sha256:b0eaf100007721b5c16c1fc1eecb87409464edc10469ddc9a22a27a99123be49"
+            ],
+            "version": "==2.11.1"
+        },
+        "markupsafe": {
+            "hashes": [
+                "sha256:00bc623926325b26bb9605ae9eae8a215691f33cae5df11ca5424f06f2d1f473",
+                "sha256:09027a7803a62ca78792ad89403b1b7a73a01c8cb65909cd876f7fcebd79b161",
+                "sha256:09c4b7f37d6c648cb13f9230d847adf22f8171b1ccc4d5682398e77f40309235",
+                "sha256:1027c282dad077d0bae18be6794e6b6b8c91d58ed8a8d89a89d59693b9131db5",
+                "sha256:13d3144e1e340870b25e7b10b98d779608c02016d5184cfb9927a9f10c689f42",
+                "sha256:24982cc2533820871eba85ba648cd53d8623687ff11cbb805be4ff7b4c971aff",
+                "sha256:29872e92839765e546828bb7754a68c418d927cd064fd4708fab9fe9c8bb116b",
+                "sha256:43a55c2930bbc139570ac2452adf3d70cdbb3cfe5912c71cdce1c2c6bbd9c5d1",
+                "sha256:46c99d2de99945ec5cb54f23c8cd5689f6d7177305ebff350a58ce5f8de1669e",
+                "sha256:500d4957e52ddc3351cabf489e79c91c17f6e0899158447047588650b5e69183",
+                "sha256:535f6fc4d397c1563d08b88e485c3496cf5784e927af890fb3c3aac7f933ec66",
+                "sha256:596510de112c685489095da617b5bcbbac7dd6384aeebeda4df6025d0256a81b",
+                "sha256:62fe6c95e3ec8a7fad637b7f3d372c15ec1caa01ab47926cfdf7a75b40e0eac1",
+                "sha256:6788b695d50a51edb699cb55e35487e430fa21f1ed838122d722e0ff0ac5ba15",
+                "sha256:6dd73240d2af64df90aa7c4e7481e23825ea70af4b4922f8ede5b9e35f78a3b1",
+                "sha256:717ba8fe3ae9cc0006d7c451f0bb265ee07739daf76355d06366154ee68d221e",
+                "sha256:79855e1c5b8da654cf486b830bd42c06e8780cea587384cf6545b7d9ac013a0b",
+                "sha256:7c1699dfe0cf8ff607dbdcc1e9b9af1755371f92a68f706051cc8c37d447c905",
+                "sha256:88e5fcfb52ee7b911e8bb6d6aa2fd21fbecc674eadd44118a9cc3863f938e735",
+                "sha256:8defac2f2ccd6805ebf65f5eeb132adcf2ab57aa11fdf4c0dd5169a004710e7d",
+                "sha256:98c7086708b163d425c67c7a91bad6e466bb99d797aa64f965e9d25c12111a5e",
+                "sha256:9add70b36c5666a2ed02b43b335fe19002ee5235efd4b8a89bfcf9005bebac0d",
+                "sha256:9bf40443012702a1d2070043cb6291650a0841ece432556f784f004937f0f32c",
+                "sha256:ade5e387d2ad0d7ebf59146cc00c8044acbd863725f887353a10df825fc8ae21",
+                "sha256:b00c1de48212e4cc9603895652c5c410df699856a2853135b3967591e4beebc2",
+                "sha256:b1282f8c00509d99fef04d8ba936b156d419be841854fe901d8ae224c59f0be5",
+                "sha256:b2051432115498d3562c084a49bba65d97cf251f5a331c64a12ee7e04dacc51b",
+                "sha256:ba59edeaa2fc6114428f1637ffff42da1e311e29382d81b339c1817d37ec93c6",
+                "sha256:c8716a48d94b06bb3b2524c2b77e055fb313aeb4ea620c8dd03a105574ba704f",
+                "sha256:cd5df75523866410809ca100dc9681e301e3c27567cf498077e8551b6d20e42f",
+                "sha256:cdb132fc825c38e1aeec2c8aa9338310d29d337bebbd7baa06889d09a60a1fa2",
+                "sha256:e249096428b3ae81b08327a63a485ad0878de3fb939049038579ac0ef61e17e7",
+                "sha256:e8313f01ba26fbbe36c7be1966a7b7424942f670f38e666995b88d012765b9be"
+            ],
+            "version": "==1.1.1"
+        },
+        "mccabe": {
+            "hashes": [
+                "sha256:ab8a6258860da4b6677da4bd2fe5dc2c659cff31b3ee4f7f5d64e79735b80d42",
+                "sha256:dd8d182285a0fe56bace7f45b5e7d1a6ebcbf524e8f3bd87eb0f125271b8831f"
+            ],
+            "version": "==0.6.1"
+        },
+        "mock": {
+            "hashes": [
+                "sha256:83657d894c90d5681d62155c82bda9c1187827525880eda8ff5df4ec813437c3",
+                "sha256:d157e52d4e5b938c550f39eb2fd15610db062441a9c2747d3dbfa9298211d0f8"
+            ],
+            "markers": "python_version < '3.0'",
+            "version": "==3.0.5"
+        },
+        "monotonic": {
+            "hashes": [
+                "sha256:23953d55076df038541e648a53676fb24980f7a1be290cdda21300b3bc21dfb0",
+                "sha256:552a91f381532e33cbd07c6a2655a21908088962bb8fa7239ecbcc6ad1140cc7"
+            ],
+            "version": "==1.5"
+        },
+        "more-itertools": {
+            "hashes": [
+                "sha256:38a936c0a6d98a38bcc2d03fdaaedaba9f412879461dd2ceff8d37564d6522e4",
+                "sha256:c0a5785b1109a6bd7fac76d6837fd1feca158e54e521ccd2ae8bfe393cc9d4fc",
+                "sha256:fe7a7cae1ccb57d33952113ff4fa1bc5f879963600ed74918f1236e212ee50b9"
+            ],
+            "index": "pypi",
+            "version": "==5.0.0"
+        },
+        "pathlib2": {
+            "hashes": [
+                "sha256:0ec8205a157c80d7acc301c0b18fbd5d44fe655968f5d947b6ecef5290fc35db",
+                "sha256:6cd9a47b597b37cc57de1c05e56fb1a1c9cc9fab04fe78c29acd090418529868"
+            ],
+            "markers": "python_version < '3.6'",
+            "version": "==2.3.5"
+        },
+        "pluggy": {
+            "hashes": [
+                "sha256:15b2acde666561e1298d71b523007ed7364de07029219b604cf808bfa1c765b0",
+                "sha256:966c145cd83c96502c3c3868f50408687b38434af77734af1e9ca461a4081d2d"
+            ],
+            "version": "==0.13.1"
+        },
+        "py": {
+            "hashes": [
+                "sha256:5e27081401262157467ad6e7f851b7aa402c5852dbcb3dae06768434de5752aa",
+                "sha256:c20fdd83a5dbc0af9efd622bee9a5564e278f6380fffcacc43ba6f43db2813b0"
+            ],
+            "version": "==1.8.1"
+        },
+        "pycodestyle": {
+            "hashes": [
+                "sha256:95a2219d12372f05704562a14ec30bc76b05a5b297b21a5dfe3f6fac3491ae56",
+                "sha256:e40a936c9a450ad81df37f549d676d127b1b66000a6c500caa2b085bc0ca976c"
+            ],
+            "version": "==2.5.0"
+        },
+        "pycparser": {
+            "hashes": [
+                "sha256:2d475327684562c3a96cc71adf7dc8c4f0565175cf86b6d7a404ff4c771f15f0",
+                "sha256:7582ad22678f0fcd81102833f60ef8d0e57288b6b5fb00323d101be910e35705"
+            ],
+            "version": "==2.20"
+        },
+        "pyflakes": {
+            "hashes": [
+                "sha256:17dbeb2e3f4d772725c777fabc446d5634d1038f234e77343108ce445ea69ce0",
+                "sha256:d976835886f8c5b31d47970ed689944a0262b5f3afa00a5a7b4dc81e5449f8a2"
+            ],
+            "version": "==2.1.1"
+        },
+        "pygments": {
+            "hashes": [
+                "sha256:2a3fe295e54a20164a9df49c75fa58526d3be48e14aceba6d6b1e8ac0bfd6f1b",
+                "sha256:98c8aa5a9f778fcd1026a17361ddaf7330d1b7c62ae97c3bb0ae73e0b9b6b0fe"
+            ],
+            "version": "==2.5.2"
+        },
+        "pysocks": {
+            "hashes": [
+                "sha256:08e69f092cc6dbe92a0fdd16eeb9b9ffbc13cadfe5ca4c7bd92ffb078b293299",
+                "sha256:2725bd0a9925919b9b51739eea5f9e2bae91e83288108a9ad338b2e3a4435ee5",
+                "sha256:3f8804571ebe159c380ac6de37643bb4685970655d3bba243530d6558b799aa0"
+            ],
+            "version": "==1.7.1"
+        },
+        "pytest": {
+            "hashes": [
+                "sha256:3f193df1cfe1d1609d4c583838bea3d532b18d6160fd3f55c9447fdca30848ec",
+                "sha256:e246cf173c01169b9617fc07264b7b1316e78d7a650055235d6d897bc80d9660"
+            ],
+            "index": "pypi",
+            "version": "==3.10.1"
+        },
+        "pytest-cov": {
+            "hashes": [
+                "sha256:cc6742d8bac45070217169f5f72ceee1e0e55b0221f54bcf24845972d3a47f2b",
+                "sha256:cdbdef4f870408ebdbfeb44e63e07eb18bb4619fae852f6e760645fa36172626"
+            ],
+            "index": "pypi",
+            "version": "==2.8.1"
+        },
+        "pytest-forked": {
+            "hashes": [
+                "sha256:1805699ed9c9e60cb7a8179b8d4fa2b8898098e82d229b0825d8095f0f261100",
+                "sha256:1ae25dba8ee2e56fb47311c9638f9e58552691da87e82d25b0ce0e4bf52b7d87"
+            ],
+            "version": "==1.1.3"
+        },
+        "pytest-httpbin": {
+            "hashes": [
+                "sha256:8cd57e27418a7d7d205fcc9802eea246ed06170e3065abfa76c6d9b40553592c",
+                "sha256:d3919c5df0b644454129c0066a8ae62db40ac54bacb4cfd89d8cfa58615a4b42"
+            ],
+            "index": "pypi",
+            "version": "==0.3.0"
+        },
+        "pytest-mock": {
+            "hashes": [
+                "sha256:b35eb281e93aafed138db25c8772b95d3756108b601947f89af503f8c629413f",
+                "sha256:cb67402d87d5f53c579263d37971a164743dc33c159dfb4fb4a86f37c5552307"
+            ],
+            "index": "pypi",
+            "version": "==2.0.0"
+        },
+        "pytest-xdist": {
+            "hashes": [
+                "sha256:96f893094c89fddeaff3f4783f4807f7aeb138be1a0d87a8805057b6af1201b5",
+                "sha256:aab1402f2b063df48bf044b042707610f8fcc4c49d0eb9c10e79e30b3f26074f"
+            ],
+            "index": "pypi",
+            "version": "==1.25.0"
+        },
+        "pytz": {
+            "hashes": [
+                "sha256:1c557d7d0e871de1f5ccd5833f60fb2550652da6be2693c1e02300743d21500d",
+                "sha256:b02c06db6cf09c12dd25137e563b31700d3b80fcc4ad23abb7a315f2789819be"
+            ],
+            "version": "==2019.3"
+        },
+        "raven": {
+            "extras": [
+                "flask"
+            ],
+            "hashes": [
+                "sha256:3fa6de6efa2493a7c827472e984ce9b020797d0da16f1db67197bcc23c8fae54",
+                "sha256:44a13f87670836e153951af9a3c80405d36b43097db869a36e92809673692ce4"
+            ],
+            "version": "==6.10.0"
+        },
+        "readme-renderer": {
+            "hashes": [
+                "sha256:1b6d8dd1673a0b293766b4106af766b6eff3654605f9c4f239e65de6076bc222",
+                "sha256:e67d64242f0174a63c3b727801a2fff4c1f38ebe5d71d95ff7ece081945a6cd4"
+            ],
+            "index": "pypi",
+            "version": "==25.0"
+        },
+        "requests": {
+            "editable": true,
+            "extras": [
+                "socks"
+            ],
+            "path": "."
+        },
+        "scandir": {
+            "hashes": [
+                "sha256:2586c94e907d99617887daed6c1d102b5ca28f1085f90446554abf1faf73123e",
+                "sha256:2ae41f43797ca0c11591c0c35f2f5875fa99f8797cb1a1fd440497ec0ae4b022",
+                "sha256:2b8e3888b11abb2217a32af0766bc06b65cc4a928d8727828ee68af5a967fa6f",
+                "sha256:2c712840c2e2ee8dfaf36034080108d30060d759c7b73a01a52251cc8989f11f",
+                "sha256:4d4631f6062e658e9007ab3149a9b914f3548cb38bfb021c64f39a025ce578ae",
+                "sha256:67f15b6f83e6507fdc6fca22fedf6ef8b334b399ca27c6b568cbfaa82a364173",
+                "sha256:7d2d7a06a252764061a020407b997dd036f7bd6a175a5ba2b345f0a357f0b3f4",
+                "sha256:8c5922863e44ffc00c5c693190648daa6d15e7c1207ed02d6f46a8dcc2869d32",
+                "sha256:92c85ac42f41ffdc35b6da57ed991575bdbe69db895507af88b9f499b701c188",
+                "sha256:b24086f2375c4a094a6b51e78b4cf7ca16c721dcee2eddd7aa6494b42d6d519d",
+                "sha256:cb925555f43060a1745d0a321cca94bcea927c50114b623d73179189a4e100ac"
+            ],
+            "markers": "python_version < '3.5'",
+            "version": "==1.10.0"
+        },
+        "singledispatch": {
+            "hashes": [
+                "sha256:5b06af87df13818d14f08a028e42f566640aef80805c3b50c5056b086e3c2b9c",
+                "sha256:833b46966687b3de7f438c761ac475213e53b306740f1abfaa86e1d1aae56aa8"
+            ],
+            "markers": "python_version < '3.4'",
+            "version": "==3.4.0.3"
+        },
+        "six": {
+            "hashes": [
+                "sha256:236bdbdce46e6e6a3d61a337c0f8b763ca1e8717c03b369e87a7ec7ce1319c0a",
+                "sha256:8f3cd2e254d8f793e7f3d6d9df77b92252b52637291d0f0da013c76ea2724b6c"
+            ],
+            "version": "==1.14.0"
+        },
+        "snowballstemmer": {
+            "hashes": [
+                "sha256:209f257d7533fdb3cb73bdbd24f436239ca3b2fa67d56f6ff88e86be08cc5ef0",
+                "sha256:df3bac3df4c2c01363f3dd2cfa78cce2840a79b9f1c2d2de9ce8d31683992f52"
+            ],
+            "version": "==2.0.0"
+        },
+        "sphinx": {
+            "hashes": [
+                "sha256:11f271e7a9398385ed730e90f0bb41dc3815294bdcd395b46ed2d033bc2e7d87",
+                "sha256:4064ea6c56feeb268838cb8fbbee507d0c3d5d92fa63a7df935a916b52c9e2f5"
+            ],
+            "index": "pypi",
+            "version": "==1.5.5"
+        },
+        "toml": {
+            "hashes": [
+                "sha256:229f81c57791a41d65e399fc06bf0848bab550a9dfd5ed66df18ce5f05e73d5c",
+                "sha256:235682dd292d5899d361a811df37e04a8828a5b1da3115886b73cf81ebc9100e"
+            ],
+            "version": "==0.10.0"
+        },
+        "tox": {
+            "hashes": [
+                "sha256:2a8d8a63660563e41e64e3b5b677e81ce1ffa5e2a93c2c565d3768c287445800",
+                "sha256:edfca7809925f49bdc110d0a2d9966bbf35a0c25637216d9586e7a5c5de17bfb"
+            ],
+            "index": "pypi",
+            "version": "==3.6.1"
+        },
+        "typing": {
+            "hashes": [
+                "sha256:91dfe6f3f706ee8cc32d38edbbf304e9b7583fb37108fef38229617f8b3eba23",
+                "sha256:c8cabb5ab8945cd2f54917be357d134db9cc1eb039e59d1606dc1e60cb1d9d36",
+                "sha256:f38d83c5a7a7086543a0f649564d661859c5146a85775ab90c0d2f93ffaa9714"
+            ],
+            "markers": "python_version < '3.5'",
+            "version": "==3.7.4.1"
+        },
+        "urllib3": {
+            "hashes": [
+                "sha256:2f3db8b19923a873b3e5256dc9c2dedfa883e33d87c690d9c7913e1f40673cdc",
+                "sha256:87716c2d2a7121198ebcb7ce7cccf6ce5e9ba539041cfbaeecfb641dc0bf6acc"
+            ],
+            "version": "==1.25.8"
+        },
+        "virtualenv": {
+            "hashes": [
+                "sha256:4e399f48c6b71228bf79f5febd27e3bbb753d9d5905776a86667bc61ab628a25",
+                "sha256:9e81279f4a9d16d1c0654a127c2c86e5bca2073585341691882c1e66e31ef8a5"
+            ],
+            "version": "==20.0.15"
+        },
+        "webencodings": {
+            "hashes": [
+                "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78",
+                "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"
+            ],
+            "version": "==0.5.1"
+        },
+        "werkzeug": {
+            "hashes": [
+                "sha256:2de2a5db0baeae7b2d2664949077c2ac63fbd16d98da0ff71837f7d1dea3fd43",
+                "sha256:6c80b1e5ad3665290ea39320b91e1be1e0d5f60652b964a3070216de83d2e47c"
+            ],
+            "version": "==1.0.1"
+        },
+        "zipp": {
+            "hashes": [
+                "sha256:c70410551488251b0fee67b460fb9a536af8d6f9f008ad10ac51f615b6a521b1",
+                "sha256:e0d9e63797e483a30d27e09fffd308c59a700d365ec34e93cc100844168bf921"
+            ],
+            "markers": "python_version < '3.8'",
+            "version": "==1.2.0"
+        }
+    }
+}

README.md

@@ -0,0 +1,126 @@
+
+
+<span align="center">
+
+<pre>
+    <a href="https://requests.readthedocs.io/"><img src="https://raw.githubusercontent.com/psf/requests/master/ext/requests-logo.png" align="center" /></a>
+    
+    <div align="left">
+    <p></p>
+    <code> Python 3.7.4 (default, Sep  7 2019, 18:27:02)</code>
+    <code> >>> <strong>import requests</strong></code>
+    <code> >>> r = requests.get('https://api.github.com/repos/psf/requests')</code>
+    <code> >>> r.json()["description"]</code>
+    <code> 'A simple, yet elegant HTTP library.'</code>
+    </div>
+
+    <p align="center">
+This software has been designed for you, with much joy,
+by <a href="https://kennethreitz.org/">Kenneth Reitz</a> & is protected by The <a href="https://www.python.org/psf/">Python Software Foundation</a>.
+   </p>
+</pre>
+
+</span>
+
+<p>&nbsp;</p><p>&nbsp;</p>
+
+<p align="center"><strong>Requests</strong> is an elegant and simple HTTP library for Python, built with ♥.</p>
+
+<p>&nbsp;</p>
+
+```python
+>>> import requests
+>>> r = requests.get('https://api.github.com/user', auth=('user', 'pass'))
+>>> r.status_code
+200
+>>> r.headers['content-type']
+'application/json; charset=utf8'
+>>> r.encoding
+'utf-8'
+>>> r.text
+'{"type":"User"...'
+>>> r.json()
+{'disk_usage': 368627, 'private_gists': 484, ...}
+```
+
+
+
+---------------------------------------------------------------------
+
+<p>&nbsp;</p>
+
+Requests allows you to send HTTP/1.1 requests extremely easily. There’s no need to manually add query strings to your URLs, or to form-encode your `PUT` & `POST` data — but nowadays, just use the `json` method!
+
+
+Requests is one of the most downloaded Python package today, pulling in around `14M downloads / week`— according to GitHub, Requests is currently [depended upon](https://github.com/psf/requests/network/dependents?package_id=UGFja2FnZS01NzA4OTExNg%3D%3D) by `500,000+` repositories. You may certainly put your trust in this code.
+
+
+<p>&nbsp;</p>
+<p align="center"><a href="https://pepy.tech/project/requests" rel="nofollow"><img src="https://camo.githubusercontent.com/e1dedc9f5ce5cd6b6c699f33d2e812daadcf3645/68747470733a2f2f706570792e746563682f62616467652f7265717565737473" alt="Downloads" data-canonical-src="https://pepy.tech/badge/requests" style="max-width:100%;"></a>
+<a href="https://pypi.org/project/requests/" rel="nofollow"><img src="https://camo.githubusercontent.com/6d78aeec0a9a1cfe147ad064bfb99069e298e29b/68747470733a2f2f696d672e736869656c64732e696f2f707970692f707976657273696f6e732f72657175657374732e737667" alt="image" data-canonical-src="https://img.shields.io/pypi/pyversions/requests.svg" style="max-width:100%;"></a>
+<a href="https://github.com/psf/requests/graphs/contributors"><img src="https://camo.githubusercontent.com/a70ea15870b38bba9203b969f6a6b7e7845fbb8a/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f636f6e7472696275746f72732f7073662f72657175657374732e737667" alt="image" data-canonical-src="https://img.shields.io/github/contributors/psf/requests.svg" style="max-width:100%;"></a></p>
+
+<p>&nbsp;</p>
+
+<h2 align="center">Supported Features & Best–Practices</h2>
+
+Requests is ready for the demands of building robust and reliable HTTP–speak applications, for the needs of today.
+
+<pre class="test">
+         + International Domains and URLs       + Keep-Alive & Connection Pooling
+         + Sessions with Cookie Persistence     + Browser-style SSL Verification
+         + Basic & Digest Authentication        + Familiar `dict`–like Cookies
+         + Automatic Decompression of Content   + Automatic Content Decoding
+         + Automatic Connection Pooling         + Unicode Response Bodies<super>*</super>
+         + Multi-part File Uploads              + SOCKS Proxy Support
+         + Connection Timeouts                  + Streaming Downloads
+         + Automatic honoring of `.netrc`       + Chunked HTTP Requests
+
+                            &, of course, rock–solid stability!
+</pre>
+</div>
+
+<p align="center">
+        ✨ 🍰 ✨&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+</p>
+
+<p>&nbsp;</p>
+
+Requests Module Installation
+----------------------------
+
+The recommended way to install the `requests` module is to simply use [`pipenv`](https://pipenv.kennethreitz.org) (or `pip`, of
+course):
+
+```console
+$ pipenv install requests
+Adding requests to Pipfile's [packages]…
+✔ Installation Succeeded
+…
+```
+
+Requests officially supports Python 2.7 & 3.5+.
+
+-------------------------------------
+
+## P.S. — Documentation is available at [`requests.readthedocs.io`](https://requests.readthedocs.io/en/latest/).
+
+<p align="center">
+        <a href="https://requests.readthedocs.io/"><img src="https://raw.githubusercontent.com/psf/requests/master/ext/ss.png" align="center" /></a>
+</p>
+
+
+------------------
+
+
+<p>&nbsp;</p>
+
+<p align="center">
+        <a href="https://kennethreitz.org/"><img src="https://raw.githubusercontent.com/psf/requests/master/ext/kr.png" align="center" /></a>
+</p>
+
+<p>&nbsp;</p>
+
+<p align="center">
+        <a href="https://www.python.org/psf/"><img src="https://raw.githubusercontent.com/psf/requests/master/ext/psf.png" align="center" /></a>
+</p>

README.rst

@@ -1,110 +0,0 @@
-Requests: HTTP for Humans
-=========================
-
-.. image:: https://img.shields.io/pypi/v/requests.svg
-    :target: https://pypi.python.org/pypi/requests
-
-.. image:: https://img.shields.io/pypi/l/requests.svg
-    :target: https://pypi.python.org/pypi/requests
-
-.. image:: https://img.shields.io/pypi/pyversions/requests.svg
-    :target: https://pypi.python.org/pypi/requests
-
-.. image:: https://codecov.io/github/requests/requests/coverage.svg?branch=master
-    :target: https://codecov.io/github/requests/requests
-    :alt: codecov.io
-
-.. image:: https://img.shields.io/github/contributors/requests/requests.svg
-    :target: https://github.com/requests/requests/graphs/contributors
-
-.. image:: https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg
-    :target: https://saythanks.io/to/kennethreitz
-
-Requests is the only *Non-GMO* HTTP library for Python, safe for human
-consumption.
-
-.. image:: https://farm5.staticflickr.com/4317/35198386374_1939af3de6_k_d.jpg
-
-Behold, the power of Requests:
-
-.. code-block:: python
-
-    >>> r = requests.get('https://api.github.com/user', auth=('user', 'pass'))
-    >>> r.status_code
-    200
-    >>> r.headers['content-type']
-    'application/json; charset=utf8'
-    >>> r.encoding
-    'utf-8'
-    >>> r.text
-    u'{"type":"User"...'
-    >>> r.json()
-    {u'disk_usage': 368627, u'private_gists': 484, ...}
-
-See `the similar code, sans Requests <https://gist.github.com/973705>`_.
-
-.. image:: https://raw.githubusercontent.com/requests/requests/master/docs/_static/requests-logo-small.png
-    :target: http://docs.python-requests.org/
-
-
-Requests allows you to send *organic, grass-fed* HTTP/1.1 requests, without the
-need for manual labor. There's no need to manually add query strings to your
-URLs, or to form-encode your POST data. Keep-alive and HTTP connection pooling
-are 100% automatic, thanks to `urllib3 <https://github.com/shazow/urllib3>`_.
-
-Besides, all the cool kids are doing it. Requests is one of the most
-downloaded Python packages of all time, pulling in over 11,000,000 downloads
-every month. You don't want to be left out!
-
-Feature Support
----------------
-
-Requests is ready for today's web.
-
-- International Domains and URLs
-- Keep-Alive & Connection Pooling
-- Sessions with Cookie Persistence
-- Browser-style SSL Verification
-- Basic/Digest Authentication
-- Elegant Key/Value Cookies
-- Automatic Decompression
-- Automatic Content Decoding
-- Unicode Response Bodies
-- Multipart File Uploads
-- HTTP(S) Proxy Support
-- Connection Timeouts
-- Streaming Downloads
-- ``.netrc`` Support
-- Chunked Requests
-
-Requests officially supports Python 2.7 & 3.4–3.7, and runs great on PyPy.
-
-Installation
-------------
-
-To install Requests, simply use `pipenv <http://pipenv.org/>`_ (or pip, of course):
-
-.. code-block:: bash
-
-    $ pipenv install requests
-    ✨🍰✨
-
-Satisfaction guaranteed.
-
-Documentation
--------------
-
-Fantastic documentation is available at http://docs.python-requests.org/, for a limited time only.
-
-
-How to Contribute
------------------
-
-#. Check for open issues or open a fresh issue to start a discussion around a feature idea or a bug. There is a `Contributor Friendly`_ tag for issues that should be ideal for people who are not very familiar with the codebase yet.
-#. Fork `the repository`_ on GitHub to start making your changes to the **master** branch (or branch off of it).
-#. Write a test which shows that the bug was fixed or that the feature works as expected.
-#. Send a pull request and bug the maintainer until it gets merged and published. :) Make sure to add yourself to AUTHORS_.
-
-.. _`the repository`: http://github.com/requests/requests
-.. _AUTHORS: https://github.com/requests/requests/blob/master/AUTHORS.rst
-.. _Contributor Friendly: https://github.com/requests/requests/issues?direction=desc&labels=Contributor+Friendly&page=1&sort=updated&state=open

_appveyor/install.ps1

@@ -226,4 +226,4 @@ function main () {
     InstallPip $env:PYTHON
 }
 
-main
+main

appveyor.yml

@@ -1,17 +1,37 @@
 # AppVeyor.yml from https://github.com/ogrisel/python-appveyor-demo
-# License: CC0 1.0 Universal: http://creativecommons.org/publicdomain/zero/1.0/
+# License: CC0 1.0 Universal: https://creativecommons.org/publicdomain/zero/1.0/
 
 build: off
 
 environment:
   matrix:
+    - PYTHON: "C:\\Python27-x64"
+      PYTHON_VERSION: "2.7.x"
+      PYTHON_ARCH: "64"
+      TOXENV: "py27"
+
+    - PYTHON: "C:\\Python34-x64"
+      PYTHON_VERSION: "3.4.x"
+      PYTHON_ARCH: "64"
+      TOXENV: "py34"
+
+    - PYTHON: "C:\\Python35-x64"
+      PYTHON_VERSION: "3.5.x"
+      PYTHON_ARCH: "64"
+      TOXENV: "py35"
+
     - PYTHON: "C:\\Python36-x64"
       PYTHON_VERSION: "3.6.x"
       PYTHON_ARCH: "64"
       TOXENV: "py36"
 
+    - PYTHON: "C:\\Python37-x64"
+      PYTHON_VERSION: "3.7.x"
+      PYTHON_ARCH: "64"
+      TOXENV: "py37"
+
 install:
-  # Install Python (from the official .msi of http://python.org) and pip when
+  # Install Python (from the official .msi of https://www.python.org/) and pip when
   # not already installed.
   - ps: if (-not(Test-Path($env:PYTHON))) { & _appveyor\install.ps1 }
 
@@ -26,8 +46,9 @@ install:
 
   # Upgrade to the latest version of pip to avoid it displaying warnings
   # about it being out of date.
-  - "pip install --disable-pip-version-check --user --upgrade pip"
+  - "python -m pip install --upgrade pip wheel"
   - "C:\\MinGW\\bin\\mingw32-make"
+  - "pipenv install -e .[socks] --skip-lock"
 
 test_script:
   - "C:\\MinGW\\bin\\mingw32-make coverage"

docs/.nojekyll

@@ -0,0 +1 @@
+

docs/_static/custom.css

@@ -1,12 +1,21 @@
+body > div.document > div.sphinxsidebar > div > form > table > tbody > tr:nth-child(2) > td > select {
+  width: 100%!important;
+}
+
+#python27 > a {
+  color: white;
+}
+
+/* Carbon by BuySellAds */
 #carbonads {
   display: block;
   overflow: hidden;
+  margin: 1.5em 0 2em;
   padding: 1em;
+  border: solid 1px #cccccc;
+  border-radius: 2px;
   background-color: #eeeeee;
   text-align: center;
-  border: solid 1px #cccccc;
-  margin: 1.5em 0 2em;
-  border-radius: 2px;
   line-height: 1.5;
 }
 
@@ -34,6 +43,135 @@
   display: block;
   text-transform: uppercase;
   letter-spacing: 1px;
+  font-size: 10px;
   line-height: 1;
+}
+
+
+/* Native CPC by BuySellAds */
+
+#native-ribbon #_custom_ {
+  position: fixed;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  box-shadow: 0 -1px 4px 1px hsla(0, 0%, 0%, .15);
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen-Sans, Ubuntu,
+    Cantarell, "Helvetica Neue", Helvetica, Arial, sans-serif;
+  transition: all .25s ease-in-out;
+  transform: translateY(calc(100% - 35px));
+
+  flex-flow: column nowrap;
+}
+
+#native-ribbon #_custom_:hover {
+  transform: translateY(0);
+}
+
+.native-img {
+  margin-right: 20px;
+  max-height: 50px;
+  border-radius: 3px;
+}
+
+.native-sponsor {
+  margin: 10px 20px;
+  text-align: center;
+  text-transform: uppercase;
+  letter-spacing: .5px;
+  font-size: 12px;
+  transition: all .3s ease-in-out;
+  transform-origin: left;
+}
+
+#native-ribbon #_custom_:hover .native-sponsor {
+  margin: 0 20px;
+  opacity: 0;
+  transform: scaleY(0);
+}
+
+.native-flex {
+  display: flex;
+  padding: 10px 20px 25px;
+  text-decoration: none;
+
+  flex-flow: row nowrap;
+  justify-content: center;
+  align-items: center;
+}
+
+.native-main {
+  display: flex;
+
+  flex-flow: row nowrap;
+  align-items: center;
+}
+
+.native-details {
+  display: flex;
+  margin-right: 30px;
+
+  flex-flow: column nowrap;
+}
+
+.native-company {
+  margin-bottom: 4px;
+  text-transform: uppercase;
+  letter-spacing: 2px;
   font-size: 10px;
 }
+
+.native-desc {
+  letter-spacing: 1px;
+  font-weight: 300;
+  font-size: 14px;
+  line-height: 1.4;
+}
+
+.native-cta {
+  padding: 10px 14px;
+  border-radius: 3px;
+  box-shadow: 0 6px 13px 0 hsla(0, 0%, 0%, .15);
+  text-transform: uppercase;
+  white-space: nowrap;
+  letter-spacing: 1px;
+  font-weight: 400;
+  font-size: 12px;
+  transition: all .3s ease-in-out;
+  transform: translateY(-1px);
+}
+
+.native-cta:hover {
+  box-shadow: none;
+  transform: translateY(1px);
+}
+
+@media only screen and (min-width: 320px) and (max-width: 759px) {
+  .native-flex {
+    padding: 5px 5px 15px;
+    flex-direction: column;
+
+    flex-wrap: wrap;
+  }
+
+  .native-img {
+    margin: 0;
+    display: none;
+  }
+
+  .native-details {
+    margin: 0;
+  }
+
+  .native-main {
+    flex-direction: column;
+    text-align: left;
+
+    flex-wrap: wrap;
+    align-content: center;
+  }
+
+  .native-cta {
+    display: none;
+  }
+}

docs/_templates/hacks.html

@@ -1,34 +1,4 @@
 <!-- Alabaster (krTheme++) Hacks -->
-<aside id="python27">
-    Python 3, the new best practice, is here to stay.
-    Python 2 will retire in only <time></time> months!
-</aside>
-
-<!-- Python 2 Death Clock™ -->
-<style type="text/css">
-  body { margin-top: 4em; }
-  #python27 {
-      position: fixed;
-      top: 0;
-      left: 0; right: 0;
-      height:  auto;
-      text-align: center;
-      color: white;
-      background-color: black;
-      font-size: larger;
-      line-height: 3;
-  }
-
-</style>
-<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.18.1/moment.min.js"></script>
-<script>
-  var death = new Date('2020-04-12');
-
-  var diff = moment.duration(death - moment());
-
-  document.querySelector('#python27 time').innerText = (diff.years() * 12) + diff.months();
-</script>
-
 
 <!-- CSS Adjustments (I'm very picky.) -->
 <style type="text/css">
@@ -83,4 +53,58 @@
   var easter_egg = new Konami('http://fortunes.herokuapp.com/random/raw');
 </script>
 
-<!-- That was not a hack. That was art. -->
+<!-- That was not a hack. That was art. -->
+
+<!-- Native CPC by BuySellAds -->
+
+<script type="text/javascript" src="//m.servedby-buysellads.com/monetization.js"></script>
+
+<div id="native-ribbon">
+</div>
+
+<script>
+_bsa.init('custom', 'CK7D62JU', 'placement:pythonrequestsorg',
+    {
+      target: '#native-ribbon',
+      template: `
+<div class="native-sponsor">Sponsored by ##company## — Learn More</div>
+  <a href="##link##" class="native-flex">
+    <style>
+    #native-ribbon #_custom_ {
+      background: linear-gradient(-30deg, ##backgroundColor##E5, ##backgroundColor##E5 45%, ##backgroundColor## 45%) #fff;
+    }
+
+    .native-details,
+    .native-sponsor,
+    .native-bsa {
+      color: ##textColor## !important;
+    }
+
+    .native-details:hover {
+      color: ##textColorHover## !important;
+    }
+
+    .native-cta {
+      color: ##ctaTextColor##;
+      background-color: ##ctaBackgroundColor##;
+    }
+
+    .native-cta:hover {
+      color: ##ctaTextColorHover##;
+      background-color: ##ctaBackgroundColorHover##;
+    }
+    </style>
+    <div class="native-main">
+      <img class="native-img" src="##logo##">
+      <div class="native-details">
+        <span class="native-company">##title##</span>
+        <span class="native-desc">##description##</span>
+      </div>
+    </div>
+    <span class="native-cta">##callToAction##</span>
+  </a>
+</div>
+`
+    }
+  );
+</script>

docs/_templates/sidebarintro.html

@@ -1,70 +1,79 @@
 <p class="logo">
   <a href="{{ pathto(master_doc) }}">
-    <img class="logo" src="{{ pathto('_static/requests-sidebar.png', 1) }}" title="https://kennethreitz.org/tattoos"/>
+    <img class="logo" src="{{ pathto('_static/requests-sidebar.jpg', 1) }}" title="https://kennethreitz.org/tattoos" />
   </a>
 </p>
 
 <p>
-  <iframe src="http://ghbtns.com/github-btn.html?user=requests&repo=requests&type=watch&count=true&size=large"
+  <iframe src="https://ghbtns.com/github-btn.html?user=psf&repo=requests&type=watch&count=true&size=large"
     allowtransparency="true" frameborder="0" scrolling="0" width="200px" height="35px"></iframe>
 </p>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/docsearch.js@2/dist/cdn/docsearch.min.css" />
+<style>
+  .algolia-autocomplete {
+    width: 100%;
+    height: 1.5em
+  }
+
+  .algolia-autocomplete a {
+    border-bottom: none !important;
+  }
+
+  #doc_search {
+    width: 100%;
+    height: 100%;
+  }
+</style>
+<input id="doc_search" placeholder="Search the doc" autofocus />
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/docsearch.js@2/dist/cdn/docsearch.min.js" onload="docsearch({
+  apiKey: 'f177061e2354c50a97bfc635e827ffab',
+  indexName: 'python-requests',
+  inputSelector: '#doc_search',
+  debug: false // Set debug to true if you want to inspect the dropdown
+})" async></script>
 
 <p>
   Requests is an elegant and simple HTTP library for Python, built for
   human beings.
 </p>
+<p>Sponsored by <strong><a href="https://www.govcert.lu">CERT Gouvernemental - GOVCERT.LU</a></strong>.</p>
 
-<script async type="text/javascript" src="//cdn.carbonads.com/carbon.js?zoneid=1673&serve=C6AILKT&placement=pythonrequestsorg" id="_carbonads_js"></script>
+<script async type="text/javascript"
+  src="//cdn.carbonads.com/carbon.js?zoneid=1673&serve=CKYI5K3E&placement=pythonrequestsorg"
+  id="_carbonads_js"></script>
 
-<h3><a href="http://www.unixstickers.com/stickers/coding_stickers/requests-shaped-sticker">Stickers!</a></h3>
 <h3>Stay Informed</h3>
 <p>Receive updates on new releases and upcoming projects.</p>
 
-<p><iframe src="http://ghbtns.com/github-btn.html?user=kennethreitz&type=follow&count=false"
-  allowtransparency="true" frameborder="0" scrolling="0" width="200" height="20"></iframe></p>
-
-<p><a href="https://twitter.com/kennethreitz" class="twitter-follow-button" data-show-count="false">Follow @kennethreitz</a> <script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script></p>
-<p><a href="https://saythanks.io/to/kennethreitz">Say Thanks!</a></p>
-<p><a href="http://tinyletter.com/kennethreitz">Join Mailing List</a>.</p>
-<h3>Other Projects</h3>
-
-<p>More <a href="http://kennethreitz.org/">Kenneth Reitz</a> projects:</p>
-<ul>
-    <li><a href="http://edmsynths.com/">edmsynths.com</a></li>
-    <li><a href="http://pipenv.org/">pipenv</a></li>
-    <li><a href="http://pep8.org/">pep8.org</a></li>
-    <li><a href="http://httpbin.org/">httpbin.org</a></li>
-    <li><a href="http://python-guide.org">The Python Guide</a></li>
-    <li><a href="https://github.com/kennethreitz/maya">Maya: Datetimes for Humans</a></li>
-    <li><a href="https://github.com/kennethreitz/records">Records: SQL for Humans</a></li>
-    <li><a href="http://www.git-legit.org">Legit: Git for Humans</a></li>
-    <li><a href="http://docs.python-tablib.org/en/latest/">Tablib: Tabular Datasets</a></li>
-</ul>
-
+<p><iframe src="https://ghbtns.com/github-btn.html?user=kennethreitz&type=follow&count=false" allowtransparency="true"
+    frameborder="0" scrolling="0" width="200" height="20"></iframe></p>
 
 <h3>Useful Links</h3>
 <ul>
-  <li><a href="http://docs.python-requests.org/en/latest/community/recommended/">Recommended Packages and Extensions</a></li>
+  <li><a href="https://requests.readthedocs.io/en/latest/community/recommended/">Recommended Packages and Extensions</a>
+  </li>
 
   <p></p>
 
-  <li><a href="http://github.com/requests/requests">Requests @ GitHub</a></li>
-  <li><a href="http://pypi.python.org/pypi/requests">Requests @ PyPI</a></li>
-  <li><a href="http://github.com/requests/requests/issues">Issue Tracker</a></li>
-  <li><a href="http://docs.python-requests.org/en/latest/community/updates/#software-updates">Release History</a></li>
+  <li><a href="https://github.com/psf/requests">Requests @ GitHub</a></li>
+  <li><a href="https://pypi.org/project/requests/">Requests @ PyPI</a></li>
+  <li><a href="https://github.com/psf/requests/issues">Issue Tracker</a></li>
+  <li><a href="https://requests.readthedocs.io/en/latest/community/updates/#software-updates">Release History</a></li>
 </ul>
 
 
 <h3>Translations</h3>
 
 <ul>
-  <li><a href="http://docs.python-requests.org/">English</a></li>
-  <li><a href="http://fr.python-requests.org/">French</a></li>
-  <li><a href="http://de.python-requests.org/">German</a></li>
-  <li><a href="http://jp.python-requests.org/">Japanese</a></li>
-  <li><a href="http://cn.python-requests.org/">Chinese</a></li>
-  <li><a href="http://pt.python-requests.org/">Portuguese</a></li>
-  <li><a href="http://it.python-requests.org/">Italian</a></li>
-  <li><a href="http://es.python-requests.org/">Spanish</a></li>
+  <li><a href="https://requests.readthedocs.io/">English</a></li>
+  <li><a href="https://fr.python-requests.org/">French</a></li>
+  <li><a href="https://de.python-requests.org/">German</a></li>
+  <li><a href="https://jp.python-requests.org/">Japanese</a></li>
+  <li><a href="https://cn.python-requests.org/">Chinese</a></li>
+  <li><a href="https://pt.python-requests.org/">Portuguese</a></li>
+  <li><a href="https://it.python-requests.org/">Italian</a></li>
+  <li><a href="https://es.python-requests.org/">Spanish</a></li>
 </ul>
 
+<div id="native-ribbon">
+</div>

docs/_templates/sidebarlogo.html

@@ -1,62 +1,65 @@
 <p class="logo">
   <a href="{{ pathto(master_doc) }}">
-    <img class="logo" src="{{ pathto('_static/requests-sidebar.png', 1) }}" title="https://kennethreitz.org/tattoos"/>
+    <img class="logo" src="{{ pathto('_static/requests-sidebar.jpg', 1) }}" title="https://kennethreitz.org/tattoos" />
   </a>
 </p>
 <p>
-<iframe src="http://ghbtns.com/github-btn.html?user=requests&repo=requests&type=watch&count=true&size=large"
-  allowtransparency="true" frameborder="0" scrolling="0" width="200px" height="35px"></iframe>
+  <iframe src="https://ghbtns.com/github-btn.html?user=psf&repo=requests&type=watch&count=true&size=large"
+    allowtransparency="true" frameborder="0" scrolling="0" width="200px" height="35px"></iframe>
 </p>
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/docsearch.js@2/dist/cdn/docsearch.min.css" />
+<style>
+  .algolia-autocomplete {
+    width: 100%;
+    height: 1.5em
+  }
+
+  .algolia-autocomplete a {
+    border-bottom: none !important;
+  }
+
+  #doc_search {
+    width: 100%;
+    height: 100%;
+  }
+</style>
+<input id="doc_search" placeholder="Search the doc" autofocus />
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/docsearch.js@2/dist/cdn/docsearch.min.js" onload="docsearch({
+  apiKey: 'f177061e2354c50a97bfc635e827ffab',
+  indexName: 'python-requests',
+  inputSelector: '#doc_search',
+  debug: false // Set debug to true if you want to inspect the dropdown
+})" async></script>
 
 <p>
   Requests is an elegant and simple HTTP library for Python, built for
   human beings. You are currently looking at the documentation of the
   development release.
 </p>
-<h3><a href="http://www.unixstickers.com/stickers/coding_stickers/requests-shaped-sticker">Stickers!</a></h3>
-<h3>Stay Informed</h3>
-<p>Receive updates on new releases and upcoming projects.</p>
 
-<p><a href="http://tinyletter.com/kennethreitz">Join Mailing List</a>.</p>
+<p<p>Sponsored by <strong><a href="https://www.govcert.lu">CERT Gouvernemental - GOVCERT.LU</a></strong>.</p>
 
-<hr/>
+  <h3>Stay Informed</h3>
+  <p>Receive updates on new releases and upcoming projects.</p>
 
-<script async type="text/javascript" src="//cdn.carbonads.com/carbon.js?zoneid=1673&serve=C6AILKT&placement=pythonrequestsorg" id="_carbonads_js"></script>
+  <p><a href="https://tinyletter.com/kennethreitz">Join Mailing List</a>.</p>
 
-<p>If you enjoy using this project, <a href="https://saythanks.io/to/kennethreitz">Say Thanks!</a></p>
+  <hr />
 
-<p><iframe src="http://ghbtns.com/github-btn.html?user=kennethreitz&type=follow&count=false"
-  allowtransparency="true" frameborder="0" scrolling="0" width="200" height="20"></iframe></p>
-
-<p><a href="https://twitter.com/kennethreitz" class="twitter-follow-button" data-show-count="false">Follow @kennethreitz</a> <script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');</script></p>
+  <script async type="text/javascript"
+    src="//cdn.carbonads.com/carbon.js?zoneid=1673&serve=C6AILKT&placement=pythonrequestsorg"
+    id="_carbonads_js"></script>
 
 
-<h3>Other Projects</h3>
-
-<p>More <a href="http://kennethreitz.org/">Kenneth Reitz</a> projects:</p>
-<ul>
-    <li><a href="http://edmsynths.com/">edmsynths.com</a></li>
-    <li><a href="http://pipenv.org/">pipenv</a></li>
-    <li><a href="http://pep8.org/">pep8.org</a></li>
-    <li><a href="http://httpbin.org/">httpbin.org</a></li>
-    <li><a href="http://python-guide.org">The Python Guide</a></li>
-    <li><a href="https://github.com/kennethreitz/maya">Maya: Datetimes for Humans</a></li>
-    <li><a href="https://github.com/kennethreitz/records">Records: SQL for Humans</a></li>
-    <li><a href="http://www.git-legit.org">Legit: Git for Humans</a></li>
-    <li><a href="http://docs.python-tablib.org/en/latest/">Tablib: Tabular Datasets</a></li>
-</ul>
-
-
-<h3>Translations</h3>
-
-<ul>
-  <li><a href="http://docs.python-requests.org/">English</a></li>
-  <li><a href="http://fr.python-requests.org/">French</a></li>
-  <li><a href="http://de.python-requests.org/">German</a></li>
-  <li><a href="http://jp.python-requests.org/">Japanese</a></li>
-  <li><a href="http://cn.python-requests.org/">Chinese</a></li>
-  <li><a href="http://pt.python-requests.org/">Portuguese</a></li>
-  <li><a href="http://it.python-requests.org/">Italian</a></li>
-  <li><a href="http://es.python-requests.org/">Spanish</a></li>
-</ul>
+  <h3>Translations</h3>
 
+  <ul>
+    <li><a href="https://requests.readthedocs.io/">English</a></li>
+    <li><a href="https://fr.python-requests.org/">French</a></li>
+    <li><a href="https://de.python-requests.org/">German</a></li>
+    <li><a href="https://jp.python-requests.org/">Japanese</a></li>
+    <li><a href="https://cn.python-requests.org/">Chinese</a></li>
+    <li><a href="https://pt.python-requests.org/">Portuguese</a></li>
+    <li><a href="https://it.python-requests.org/">Italian</a></li>
+    <li><a href="https://es.python-requests.org/">Spanish</a></li>
+  </ul>

docs/_themes/flask_theme_support.py

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

docs/api.rst

@@ -74,6 +74,7 @@ Authentication
 
 .. autoclass:: requests.auth.AuthBase
 .. autoclass:: requests.auth.HTTPBasicAuth
+.. autoclass:: requests.auth.HTTPProxyAuth
 .. autoclass:: requests.auth.HTTPDigestAuth
 
 
@@ -108,17 +109,7 @@ Status Code Lookup
 
 .. autoclass:: requests.codes
 
-::
-
-    >>> requests.codes['temporary_redirect']
-    307
-
-    >>> requests.codes.teapot
-    418
-
-    >>> requests.codes['\o/']
-    200
-
+.. automodule:: requests.status_codes
 
 
 Migrating to 1.x
@@ -148,7 +139,7 @@ API Changes
       s = requests.Session()    # formerly, session took parameters
       s.auth = auth
       s.headers.update(headers)
-      r = s.get('http://httpbin.org/headers')
+      r = s.get('https://httpbin.org/headers')
 
 * All request hooks have been removed except 'response'.
 
@@ -190,11 +181,11 @@ API Changes
 
       logging.basicConfig() # you need to initialize logging, otherwise you will not see anything from requests
       logging.getLogger().setLevel(logging.DEBUG)
-      requests_log = logging.getLogger("requests.packages.urllib3")
+      requests_log = logging.getLogger("urllib3")
       requests_log.setLevel(logging.DEBUG)
       requests_log.propagate = True
 
-      requests.get('http://httpbin.org/headers')
+      requests.get('https://httpbin.org/headers')
 
 
 
@@ -206,8 +197,8 @@ license from the ISC_ license to the `Apache 2.0`_ license. The Apache 2.0
 license ensures that contributions to Requests are also covered by the Apache
 2.0 license.
 
-.. _ISC: http://opensource.org/licenses/ISC
-.. _Apache 2.0: http://opensource.org/licenses/Apache-2.0
+.. _ISC: https://opensource.org/licenses/ISC
+.. _Apache 2.0: https://opensource.org/licenses/Apache-2.0
 
 
 Migrating to 2.x
@@ -222,7 +213,7 @@ For more details on the changes in this release including new APIs, links
 to the relevant GitHub issues and some of the bug fixes, read Cory's blog_
 on the subject.
 
-.. _blog: http://lukasa.co.uk/2013/09/Requests_20/
+.. _blog: https://lukasa.co.uk/2013/09/Requests_20/
 
 
 API Changes
@@ -251,7 +242,7 @@ API Changes
       }
 
       # In requests 1.x, this was legal, in requests 2.x,
-      #  this raises requests.exceptions.MissingScheme
+      #  this raises requests.exceptions.MissingSchema
       requests.get("http://example.org", proxies=proxies)
 
 

docs/community/faq.rst

@@ -21,7 +21,8 @@ Custom User-Agents?
 -------------------
 
 Requests allows you to easily override User-Agent strings, along with
-any other HTTP Header.
+any other HTTP Header. See `documentation about headers <https://requests.readthedocs.io/en/master/user/quickstart/#custom-headers>`_.
+
 
 
 Why not Httplib2?
@@ -53,14 +54,19 @@ Chris Adams gave an excellent summary on
 Python 3 Support?
 -----------------
 
-Yes! Here's a list of Python platforms that are officially
-supported:
+Yes! Requests officially supports Python 2.7 & 3.5+ and PyPy.
 
-* Python 2.7
-* Python 3.4
-* Python 3.5
-* Python 3.6
-* PyPy
+Python 2 Support?
+-----------------
+
+Yes! We do not have immediate plans to `sunset
+<https://www.python.org/doc/sunset-python-2/>`_ our support for Python
+2.7. We understand that we have a large user base with varying needs,
+and intend to maintain Python 2.7 support within Requests until `pip
+stops supporting Python 2.7 (there's no estimated date on that yet)
+<https://pip.pypa.io/en/latest/development/release-process/#python-2-support>`_.
+
+That said, it is *highly* recommended users migrate to Python 3.5+ since Python 2.7 will no longer be receiving bug fixes or security updates after January 1, 2020.
 
 What are "hostname doesn't match" errors?
 -----------------------------------------

docs/community/out-there.rst

@@ -15,10 +15,10 @@ To give it a try, simply::
 
 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 Greenfeld'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/>`_
+- `Python for the Web <https://www.gun.io/blog/python-for-the-web>`_ teaches how to use Python to interact with the web, using Requests.
+- `Daniel Greenfeld's Review of Requests <https://pydanny.blogspot.com/2011/05/python-http-requests-for-humans.html>`_
+- `My 'Python for Humans' talk <http://python-for-humans.heroku.com>`_ ( `audio <https://codeconf.s3.amazonaws.com/2011/pycodeconf/talks/PyCodeConf2011%20-%20Kenneth%20Reitz.m4a>`_ )
+- `Issac Kelly's 'Consuming Web APIs' talk <https://issackelly.github.com/Consuming-Web-APIs-with-Python-Talk/slides/slides.html>`_
+- `Blog post about Requests via Yum <https://arunsag.wordpress.com/2011/08/17/new-package-python-requests-http-for-humans/>`_
+- `Russian blog post introducing Requests <https://habr.com/post/126262/>`_
 - `Sending JSON in Requests <http://www.coglib.com/~icordasc/blog/2014/11/sending-json-in-requests.html>`_

docs/community/recommended.rst

@@ -15,7 +15,7 @@ Certifi CA Bundle
 validating the trustworthiness of SSL certificates while verifying the
 identity of TLS hosts. It has been extracted from the Requests project.
 
-.. _Certifi: http://certifi.io/en/latest/
+.. _Certifi: https://github.com/certifi/python-certifi
 
 CacheControl
 ------------
@@ -34,13 +34,13 @@ but do not belong in Requests proper. This library is actively maintained
 by members of the Requests core team, and reflects the functionality most
 requested by users within the community.
 
-.. _Requests-Toolbelt: http://toolbelt.readthedocs.io/en/latest/index.html
+.. _Requests-Toolbelt: https://toolbelt.readthedocs.io/en/latest/index.html
 
 
 Requests-Threads
 ----------------
 
-`Requests-Threads` is a Requests session that returns the amazing Twisted's awaitable Deferreds instead of Response objects. This allows the use of ``async``/``await`` keyword usage on Python 3, or Twisted's style of programming, if desired.
+`Requests-Threads`_ is a Requests session that returns the amazing Twisted's awaitable Deferreds instead of Response objects. This allows the use of ``async``/``await`` keyword usage on Python 3, or Twisted's style of programming, if desired.
 
 .. _Requests-Threads: https://github.com/requests/requests-threads
 
@@ -62,6 +62,3 @@ Betamax
 A VCR imitation designed only for Python-Requests.
 
 .. _betamax: https://github.com/sigmavirus24/betamax
-
-
-

docs/community/release-process.rst

@@ -19,19 +19,18 @@ Breaking changes are changes that break backwards compatibility with prior
 versions. If the project were to change the ``text`` attribute on a
 ``Response`` object to a method, that would only happen in a Major release.
 
-Major releases may also include miscellaneous bug fixes and upgrades to
-vendored packages. The core developers of Requests are committed to providing
-a good user experience. This means we're also committed to preserving
-backwards compatibility as much as possible. Major releases will be infrequent
-and will need strong justifications before they are considered.
+Major releases may also include miscellaneous bug fixes. The core developers of
+Requests are committed to providing a good user experience. This means we're
+also committed to preserving backwards compatibility as much as possible. Major
+releases will be infrequent and will need strong justifications before they are
+considered.
 
 Minor Releases
 --------------
 
-A minor release will not include breaking changes but may include
-miscellaneous bug fixes and upgrades to vendored packages. If the previous
-version of Requests released was ``v10.2.7`` a minor release would be
-versioned as ``v10.3.0``.
+A minor release will not include breaking changes but may include miscellaneous
+bug fixes. If the previous version of Requests released was ``v10.2.7`` a minor
+release would be versioned as ``v10.3.0``.
 
 Minor releases will be backwards compatible with releases that have the same
 major version number. In other words, all versions that would start with

docs/community/support.rst

@@ -7,28 +7,29 @@ Support
 
 If you have questions or issues about Requests, there are several options:
 
-StackOverflow
+Stack Overflow
 -------------
 
 If your question does not contain sensitive (possibly proprietary)
 information or can be properly anonymized, please ask a question on
-`StackOverflow <https://stackoverflow.com/questions/tagged/python-requests>`_
+`Stack Overflow <https://stackoverflow.com/questions/tagged/python-requests>`_
 and use the tag ``python-requests``.
 
 Send a Tweet
 ------------
 
-If your question is less than 140 characters, feel free to send a tweet to
+If your question is less than 280 characters, feel free to send a tweet to
 `@kennethreitz <https://twitter.com/kennethreitz>`_,
-`@sigmavirus24 <https://twitter.com/sigmavirus24>`_, or
-`@lukasaoz <https://twitter.com/lukasaoz>`_.
+`@sigmavirus24 <https://twitter.com/sigmavirus24>`_,
+`@lukasaoz <https://twitter.com/lukasaoz>`_, or
+`@nateprewitt <https://twitter.com/nateprewitt>`_.
 
 File an Issue
 -------------
 
 If you notice some unexpected behaviour in Requests, or want to see support
 for a new feature,
-`file an issue on GitHub <https://github.com/requests/requests/issues>`_.
+`file an issue on GitHub <https://github.com/psf/requests/issues>`_.
 
 
 E-mail

docs/community/updates.rst

@@ -14,7 +14,7 @@ GitHub
 ------
 
 The best way to track the development of Requests is through
-`the GitHub repo <https://github.com/requests/requests>`_.
+`the GitHub repo <https://github.com/psf/requests>`_.
 
 Twitter
 -------
@@ -28,5 +28,4 @@ Follow `@kennethreitz <https://twitter.com/kennethreitz>`_ for updates.
 Release and Version History
 ===========================
 
-.. include:: ../../HISTORY.rst
-
+.. include:: ../../HISTORY.md

docs/community/vulnerabilities.rst

@@ -4,14 +4,16 @@ Vulnerability Disclosure
 .. image:: https://farm5.staticflickr.com/4211/34709353644_b041e9e1c2_k_d.jpg
 
 If you think you have found a potential security vulnerability in requests,
-please email `sigmavirus24 <mailto:graffatcolmingov@gmail.com>`_ and
-`Lukasa <mailto:cory@lukasa.co.uk>`_ directly. **Do not file a public issue.**
+please email `Nate <mailto:nate.prewitt@gmail.com>`_ and `Seth <mailto:@sethmichaellarson@gmail.com>`_ directly. **Do not file a public issue.**
 
 Our PGP Key fingerprints are:
 
-- 0161 BB7E B208 B5E0 4FDC  9F81 D9DA 0A04 9113 F853 (@sigmavirus24)
+- 8722 7E29 AD9C FF5C FAC3  EA6A 44D3 FF97 B80D C864 (`@nateprewitt <https://keybase.io/nateprewitt>`_)
 
-- 90DC AE40 FEA7 4B14 9B70  662D F25F 2144 EEC1 373D (@lukasa)
+- EDD5 6765 A9D8 4653 CBC8  A134 51B0 6736 1740 F5FC (`@sethmlarson <https://keybase.io/sethmlarson>`_)
+
+You can also contact us on `Keybase <https://keybase.io/>`_ with the
+profiles above if desired.
 
 If English is not your first language, please try to describe the problem and
 its impact to the best of your ability. For greater detail, please use your
@@ -95,13 +97,16 @@ if upgrading is not an option.
 Previous CVEs
 -------------
 
+- Fixed in 2.20.0
+  - `CVE 2018-18074 <https://cve.mitre.org/cgi-bin/cvename.cgi?name=2018-18074>`_
+
 - Fixed in 2.6.0
 
-  - `CVE 2015-2296 <http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=2015-2296>`_,
+  - `CVE 2015-2296 <https://cve.mitre.org/cgi-bin/cvename.cgi?name=2015-2296>`_,
     reported by Matthew Daley of `BugFuzz <https://bugfuzz.com/>`_.
 
 - Fixed in 2.3.0
 
-  - `CVE 2014-1829 <http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=2014-1829>`_
+  - `CVE 2014-1829 <https://cve.mitre.org/cgi-bin/cvename.cgi?name=2014-1829>`_
 
-  - `CVE 2014-1830 <http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=2014-1830>`_
+  - `CVE 2014-1830 <https://cve.mitre.org/cgi-bin/cvename.cgi?name=2014-1830>`_

docs/conf.py

@@ -18,11 +18,11 @@ import os
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
-#sys.path.insert(0, os.path.abspath('.'))
+# sys.path.insert(0, os.path.abspath('.'))
 
 # Insert Requests' path into the system.
-sys.path.insert(0, os.path.abspath('..'))
-sys.path.insert(0, os.path.abspath('_themes'))
+sys.path.insert(0, os.path.abspath(".."))
+sys.path.insert(0, os.path.abspath("_themes"))
 
 import requests
 
@@ -30,36 +30,36 @@ import requests
 # -- General configuration ------------------------------------------------
 
 # If your documentation needs a minimal Sphinx version, state it here.
-#needs_sphinx = '1.0'
+# needs_sphinx = '1.0'
 
 # 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.intersphinx',
-    'sphinx.ext.todo',
-    'sphinx.ext.viewcode',
+    "sphinx.ext.autodoc",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.todo",
+    "sphinx.ext.viewcode",
 ]
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]
 
 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
 # source_suffix = ['.rst', '.md']
-source_suffix = '.rst'
+source_suffix = ".rst"
 
 # The encoding of source files.
-#source_encoding = 'utf-8-sig'
+# source_encoding = 'utf-8-sig'
 
 # The master toctree document.
-master_doc = 'index'
+master_doc = "index"
 
 # General information about the project.
-project = u'Requests'
-copyright = u'MMXVII. A <a href="http://kennethreitz.com/pages/open-projects.html">Kenneth Reitz</a> Project'
-author = u'Kenneth Reitz'
+project = u"Requests"
+copyright = u'MMXVIX. A <a href="http://kennethreitz.com/pages/open-projects.html">Kenneth Reitz</a> Project'
+author = u"Kenneth Reitz"
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -79,17 +79,17 @@ language = None
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
-#today = ''
+# today = ''
 # Else, today_fmt is used as the format for a strftime call.
-#today_fmt = '%B %d, %Y'
+# today_fmt = '%B %d, %Y'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
-exclude_patterns = ['_build']
+exclude_patterns = ["_build"]
 
 # The reST default role (used for this markup: `text`) to use for all
 # documents.
-#default_role = None
+# default_role = None
 
 # If true, '()' will be appended to :func: etc. cross-reference text.
 add_function_parentheses = False
@@ -100,16 +100,16 @@ add_module_names = True
 
 # If true, sectionauthor and moduleauthor directives will be shown in the
 # output. They are ignored by default.
-#show_authors = False
+# show_authors = False
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'flask_theme_support.FlaskyStyle'
+pygments_style = "flask_theme_support.FlaskyStyle"
 
 # A list of ignored prefixes for module index sorting.
-#modindex_common_prefix = []
+# modindex_common_prefix = []
 
 # If true, keep warnings as "system message" paragraphs in the built documents.
-#keep_warnings = False
+# keep_warnings = False
 
 # If true, `todo` and `todoList` produce output, else they produce nothing.
 todo_include_todos = True
@@ -119,52 +119,52 @@ todo_include_todos = True
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
-html_theme = 'alabaster'
+html_theme = "alabaster"
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
 html_theme_options = {
-    'show_powered_by': False,
-    'github_user': 'requests',
-    'github_repo': 'requests',
-    'github_banner': True,
-    'show_related': False,
-    'note_bg': '#FFF59C'
+    "show_powered_by": False,
+    "github_user": "requests",
+    "github_repo": "requests",
+    "github_banner": True,
+    "show_related": False,
+    "note_bg": "#FFF59C",
 }
 
 # Add any paths that contain custom themes here, relative to this directory.
-#html_theme_path = []
+# html_theme_path = []
 
 # The name for this set of Sphinx documents.  If None, it defaults to
 # "<project> v<release> documentation".
-#html_title = None
+# html_title = None
 
 # A shorter title for the navigation bar.  Default is the same as html_title.
-#html_short_title = None
+# html_short_title = None
 
 # The name of an image file (relative to this directory) to place at the top
 # of the sidebar.
-#html_logo = None
+# html_logo = None
 
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
-#html_favicon = None
+# html_favicon = None
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
+html_static_path = ["_static"]
 
 # Add any extra paths that contain custom files (such as robots.txt or
 # .htaccess) here, relative to this directory. These files are copied
 # directly to the root of the documentation.
-#html_extra_path = []
+# html_extra_path = []
 
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
-#html_last_updated_fmt = '%b %d, %Y'
+# html_last_updated_fmt = '%b %d, %Y'
 
 # If true, SmartyPants will be used to convert quotes and dashes to
 # typographically correct entities.
@@ -172,24 +172,29 @@ html_use_smartypants = False
 
 # Custom sidebar templates, maps document names to template names.
 html_sidebars = {
-    'index':    ['sidebarintro.html', 'sourcelink.html', 'searchbox.html',
-                 'hacks.html'],
-    '**':       ['sidebarlogo.html', 'localtoc.html', 'relations.html',
-                 'sourcelink.html', 'searchbox.html', 'hacks.html']
+    "index": ["sidebarintro.html", "sourcelink.html", "searchbox.html", "hacks.html"],
+    "**": [
+        "sidebarlogo.html",
+        "localtoc.html",
+        "relations.html",
+        "sourcelink.html",
+        "searchbox.html",
+        "hacks.html",
+    ],
 }
 
 # Additional templates that should be rendered to pages, maps page names to
 # template names.
-#html_additional_pages = {}
+# html_additional_pages = {}
 
 # If false, no module index is generated.
-#html_domain_indices = True
+# html_domain_indices = True
 
 # If false, no index is generated.
-#html_use_index = True
+# html_use_index = True
 
 # If true, the index is split into individual pages for each letter.
-#html_split_index = False
+# html_split_index = False
 
 # If true, links to the reST sources are added to the pages.
 html_show_sourcelink = False
@@ -203,84 +208,77 @@ html_show_copyright = True
 # If true, an OpenSearch description file will be output, and all pages will
 # contain a <link> tag referring to it.  The value of this option must be the
 # base URL from which the finished HTML is served.
-#html_use_opensearch = ''
+# html_use_opensearch = ''
 
 # This is the file name suffix for HTML files (e.g. ".xhtml").
-#html_file_suffix = None
+# html_file_suffix = None
 
 # Language to be used for generating the HTML full-text search index.
 # Sphinx supports the following languages:
 #   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
 #   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'
-#html_search_language = 'en'
+# html_search_language = 'en'
 
 # A dictionary with options for the search language support, empty by default.
 # Now only 'ja' uses this config value
-#html_search_options = {'type': 'default'}
+# html_search_options = {'type': 'default'}
 
 # The name of a javascript file (relative to the configuration directory) that
 # implements a search results scorer. If empty, the default will be used.
-#html_search_scorer = 'scorer.js'
+# html_search_scorer = 'scorer.js'
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = 'Requestsdoc'
+htmlhelp_basename = "Requestsdoc"
 
 # -- Options for LaTeX output ---------------------------------------------
 
 latex_elements = {
-# The paper size ('letterpaper' or 'a4paper').
-#'papersize': 'letterpaper',
-
-# The font size ('10pt', '11pt' or '12pt').
-#'pointsize': '10pt',
-
-# Additional stuff for the LaTeX preamble.
-#'preamble': '',
-
-# Latex figure (float) alignment
-#'figure_align': 'htbp',
+    # The paper size ('letterpaper' or 'a4paper').
+    #'papersize': 'letterpaper',
+    # The font size ('10pt', '11pt' or '12pt').
+    #'pointsize': '10pt',
+    # Additional stuff for the LaTeX preamble.
+    #'preamble': '',
+    # Latex figure (float) alignment
+    #'figure_align': 'htbp',
 }
 
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-    (master_doc, 'Requests.tex', u'Requests Documentation',
-     u'Kenneth Reitz', 'manual'),
+    (master_doc, "Requests.tex", u"Requests Documentation", u"Kenneth Reitz", "manual")
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
 # the title page.
-#latex_logo = None
+# latex_logo = None
 
 # For "manual" documents, if this is true, then toplevel headings are parts,
 # not chapters.
-#latex_use_parts = False
+# latex_use_parts = False
 
 # If true, show page references after internal links.
-#latex_show_pagerefs = False
+# latex_show_pagerefs = False
 
 # If true, show URL addresses after external links.
-#latex_show_urls = False
+# latex_show_urls = False
 
 # Documents to append as an appendix to all manuals.
-#latex_appendices = []
+# latex_appendices = []
 
 # If false, no module index is generated.
-#latex_domain_indices = True
+# latex_domain_indices = True
 
 
 # -- Options for manual page output ---------------------------------------
 
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
-man_pages = [
-    (master_doc, 'requests', u'Requests Documentation',
-     [author], 1)
-]
+man_pages = [(master_doc, "requests", u"Requests Documentation", [author], 1)]
 
 # If true, show URL addresses after external links.
-#man_show_urls = False
+# man_show_urls = False
 
 
 # -- Options for Texinfo output -------------------------------------------
@@ -289,22 +287,28 @@ man_pages = [
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-    (master_doc, 'Requests', u'Requests Documentation',
-     author, 'Requests', 'One line description of project.',
-     'Miscellaneous'),
+    (
+        master_doc,
+        "Requests",
+        u"Requests Documentation",
+        author,
+        "Requests",
+        "One line description of project.",
+        "Miscellaneous",
+    )
 ]
 
 # Documents to append as an appendix to all manuals.
-#texinfo_appendices = []
+# texinfo_appendices = []
 
 # If false, no module index is generated.
-#texinfo_domain_indices = True
+# texinfo_domain_indices = True
 
 # How to display URL addresses: 'footnote', 'no', or 'inline'.
-#texinfo_show_urls = 'footnote'
+# texinfo_show_urls = 'footnote'
 
 # If true, do not generate a @detailmenu in the "Top" node's menu.
-#texinfo_no_detailmenu = False
+# texinfo_no_detailmenu = False
 
 
 # -- Options for Epub output ----------------------------------------------
@@ -316,64 +320,67 @@ epub_publisher = author
 epub_copyright = copyright
 
 # The basename for the epub file. It defaults to the project name.
-#epub_basename = project
+# epub_basename = project
 
 # The HTML theme for the epub output. Since the default themes are not
 # optimized for small screen space, using the same theme for HTML and epub
 # output is usually not wise. This defaults to 'epub', a theme designed to save
 # visual space.
-#epub_theme = 'epub'
+# epub_theme = 'epub'
 
 # The language of the text. It defaults to the language option
 # or 'en' if the language is not set.
-#epub_language = ''
+# epub_language = ''
 
 # The scheme of the identifier. Typical schemes are ISBN or URL.
-#epub_scheme = ''
+# epub_scheme = ''
 
 # The unique identifier of the text. This can be a ISBN number
 # or the project homepage.
-#epub_identifier = ''
+# epub_identifier = ''
 
 # A unique identification for the text.
-#epub_uid = ''
+# epub_uid = ''
 
 # A tuple containing the cover image and cover page html template filenames.
-#epub_cover = ()
+# epub_cover = ()
 
 # A sequence of (type, uri, title) tuples for the guide element of content.opf.
-#epub_guide = ()
+# epub_guide = ()
 
 # HTML files that should be inserted before the pages created by sphinx.
 # The format is a list of tuples containing the path and title.
-#epub_pre_files = []
+# epub_pre_files = []
 
 # HTML files that should be inserted after the pages created by sphinx.
 # The format is a list of tuples containing the path and title.
-#epub_post_files = []
+# epub_post_files = []
 
 # A list of files that should not be packed into the epub file.
-epub_exclude_files = ['search.html']
+epub_exclude_files = ["search.html"]
 
 # The depth of the table of contents in toc.ncx.
-#epub_tocdepth = 3
+# epub_tocdepth = 3
 
 # Allow duplicate toc entries.
-#epub_tocdup = True
+# epub_tocdup = True
 
 # Choose between 'default' and 'includehidden'.
-#epub_tocscope = 'default'
+# epub_tocscope = 'default'
 
 # Fix unsupported image types using the Pillow.
-#epub_fix_images = False
+# epub_fix_images = False
 
 # Scale large images.
-#epub_max_image_width = 0
+# epub_max_image_width = 0
 
 # How to display URL addresses: 'footnote', 'no', or 'inline'.
-#epub_show_urls = 'inline'
+# epub_show_urls = 'inline'
 
 # If false, no index is generated.
-#epub_use_index = True
+# epub_use_index = True
 
-intersphinx_mapping = {'urllib3': ('http://urllib3.readthedocs.io/en/latest', None)}
+intersphinx_mapping = {
+    "python": ("https://docs.python.org/3/", None),
+    "urllib3": ("https://urllib3.readthedocs.io/en/latest", None),
+}

docs/dev/contributing.rst

@@ -13,11 +13,12 @@ contributing to the Requests project is *very* generous of you.
 This document lays out guidelines and advice for contributing to this project.
 If you're thinking of contributing, please start by reading this document and
 getting a feel for how contributing to this project works. If you have any
-questions, feel free to reach out to either `Ian Cordasco`_ or `Cory Benfield`_,
-the primary maintainers.
+questions, feel free to reach out to either `Ian Cordasco`_, `Cory Benfield`_,
+or `Nate Prewitt`_, the primary maintainers.
 
 .. _Ian Cordasco: http://www.coglib.com/~icordasc/
 .. _Cory Benfield: https://lukasa.co.uk/about
+.. _Nate Prewitt: https://www.nateprewitt.com/
 
 If you have non-technical feedback, philosophical ponderings, crazy ideas, or
 other general thoughts about Requests or its position within the Python
@@ -41,7 +42,7 @@ including reporting bugs or requesting features. This golden rule is
 **All contributions are welcome**, as long as
 everyone involved is treated with respect.
 
-.. _be cordial or be on your way: http://kennethreitz.org/be-cordial-or-be-on-your-way/
+.. _be cordial or be on your way: https://www.kennethreitz.org/essays/be-cordial-or-be-on-your-way
 
 .. _early-feedback:
 
@@ -129,7 +130,14 @@ the Requests codebase::
     foo = long_function_name(var_one, var_two,
                              var_three, var_four)
 
-No. Just don't. Please.
+No. Just don't. Please. This is much better::
+
+    foo = long_function_name(
+        var_one,
+        var_two,
+        var_three,
+        var_four,
+    )
 
 Docstrings are to follow the following syntaxes::
 
@@ -157,7 +165,7 @@ model methods (e.g. ``__repr__``) are typically the exception to this rule.
 
 Thanks for helping to make the world a better place!
 
-.. _PEP 8: http://pep8.org
+.. _PEP 8: https://pep8.org/
 .. _line continuations: https://www.python.org/dev/peps/pep-0008/#indentation
 
 Documentation Contributions
@@ -189,7 +197,7 @@ through the `GitHub issues`_, **both open and closed**, to confirm that the bug
 hasn't been reported before. Duplicate bug reports are a huge drain on the time
 of other contributors, and should be avoided as much as possible.
 
-.. _GitHub issues: https://github.com/requests/requests/issues
+.. _GitHub issues: https://github.com/psf/requests/issues
 
 
 Feature Requests

docs/dev/philosophy.rst

@@ -9,9 +9,9 @@ Requests is an open but opinionated library, created by an open but opinionated
 Management Style
 ~~~~~~~~~~~~~~~~
 
-`Kenneth Reitz <http://kennethreitz.org>`_ is the BDFL. He has final say in any decision related to the Requests project. Kenneth is responsible for the direction and form of the library, as well as its presentation. In addition to making decisions based on technical merit, he is responsible for making decisions based on the development philosophy of Requests.
+`Kenneth Reitz <https://www.kennethreitz.org/>`_ is the BDFL. He has final say in any decision related to the Requests project. Kenneth is responsible for the direction and form of the library, as well as its presentation. In addition to making decisions based on technical merit, he is responsible for making decisions based on the development philosophy of Requests.
 
-`Ian Cordasco <http://www.coglib.com/~icordasc/>`_ and `Cory Benfield <https://lukasa.co.uk/about/>`_ are the core contributors. They are responsible for triaging bug reports, reviewing pull requests and ensuring that Kenneth is kept up to speed with developments around the library. The day-to-day managing of the project is done by the core contributors. They are responsible for making judgements about whether or not a feature request is likely to be accepted by Kenneth. Their word is, in some ways, more final than Kenneth's.
+`Ian Cordasco <http://www.coglib.com/~icordasc/>`_, `Cory Benfield <https://lukasa.co.uk/about/>`_, and `Nate Prewitt <https://www.nateprewitt.com/>`_ are the core contributors. They are responsible for triaging bug reports, reviewing pull requests and ensuring that Kenneth is kept up to speed with developments around the library. The day-to-day managing of the project is done by the core contributors. They are responsible for making judgements about whether or not a feature request is likely to be accepted by Kenneth. Their word is, in some ways, more final than Kenneth's.
 
 Values
 ~~~~~~
@@ -26,7 +26,7 @@ Semantic Versioning
 
 For many years, the open source community has been plagued with version number dystonia. Numbers vary so greatly from project to project, they are practically meaningless.
 
-Requests uses `Semantic Versioning <http://semver.org>`_. This specification seeks to put an end to this madness with a small set of practical guidelines for you and your colleagues to use in your next project.
+Requests uses `Semantic Versioning <https://semver.org/>`_. This specification seeks to put an end to this madness with a small set of practical guidelines for you and your colleagues to use in your next project.
 
 Standard Library?
 ~~~~~~~~~~~~~~~~~

docs/dev/todo.rst

@@ -8,11 +8,11 @@ Requests is under active development, and contributions are more than welcome!
 #. Check for open issues or open a fresh issue to start a discussion around a bug.
    There is a Contributor Friendly tag for issues that should be ideal for people who are not very
    familiar with the codebase yet.
-#. Fork `the repository <https://github.com/requests/requests>`_ on GitHub and start making your
+#. Fork `the repository <https://github.com/psf/requests>`_ on GitHub and start making your
    changes to a new branch.
 #. Write a test which shows that the bug was fixed.
 #. Send a pull request and bug the maintainer until it gets merged and published. :)
-   Make sure to add yourself to `AUTHORS <https://github.com/requests/requests/blob/master/AUTHORS.rst>`_.
+   Make sure to add yourself to `AUTHORS <https://github.com/psf/requests/blob/master/AUTHORS.rst>`_.
 
 Feature Freeze
 --------------
@@ -55,10 +55,10 @@ Requests currently supports the following versions of Python:
 - Python 3.4
 - Python 3.5
 - Python 3.6
+- Python 3.7
 - PyPy
 
 Google AppEngine is not officially supported although support is available
 with the `Requests-Toolbelt`_.
 
-.. _Requests-Toolbelt: http://toolbelt.readthedocs.io/
-
+.. _Requests-Toolbelt: https://toolbelt.readthedocs.io/

docs/index.rst

@@ -3,35 +3,26 @@
    You can adapt this file completely to your liking, but it should at least
    contain the root `toctree` directive.
 
-Requests: HTTP for Humans
-=========================
+Requests: HTTP for Humans™
+==========================
 
 Release v\ |version|. (:ref:`Installation <install>`)
 
+
+.. image:: https://pepy.tech/badge/requests
+    :target: https://pepy.tech/project/requests
+    
 .. image:: https://img.shields.io/pypi/l/requests.svg
-    :target: https://pypi.python.org/pypi/requests
+    :target: https://pypi.org/project/requests/
 
 .. image:: https://img.shields.io/pypi/wheel/requests.svg
-    :target: https://pypi.python.org/pypi/requests
+    :target: https://pypi.org/project/requests/
 
 .. image:: https://img.shields.io/pypi/pyversions/requests.svg
-    :target: https://pypi.python.org/pypi/requests
+    :target: https://pypi.org/project/requests/
 
-.. image:: https://codecov.io/github/requests/requests/coverage.svg?branch=master
-    :target: https://codecov.io/github/requests/requests
-    :alt: codecov.io
+**Requests** is an elegant and simple HTTP library for Python, built for human beings.
 
-.. image:: https://img.shields.io/badge/Say%20Thanks!-🦉-1EAEDB.svg
-    :target: https://saythanks.io/to/kennethreitz
-
-
-**Requests** is the only *Non-GMO* HTTP library for Python, safe for human
-consumption.
-
-.. note:: The use of **Python 3** is *highly* preferred over Python 2. Consider upgrading your applications and infrastructure if you find yourself *still* using Python 2 in production today. If you are using Python 3, congratulations — you are indeed a person of excellent taste.
-  —*Kenneth Reitz*
-  
-  
 -------------------
 
 **Behold, the power of Requests**::
@@ -44,45 +35,18 @@ consumption.
     >>> r.encoding
     'utf-8'
     >>> r.text
-    u'{"type":"User"...'
+    '{"type":"User"...'
     >>> r.json()
-    {u'private_gists': 419, u'total_private_repos': 77, ...}
+    {'private_gists': 419, 'total_private_repos': 77, ...}
 
 See `similar code, sans Requests <https://gist.github.com/973705>`_.
 
 
-**Requests** allows you to send *organic, grass-fed* HTTP/1.1 requests, without the
-need for manual labor. There's no need to manually add query strings to your
+**Requests** allows you to send HTTP/1.1 requests extremely easily. 
+There's no need to manually add query strings to your
 URLs, or to form-encode your POST data. Keep-alive and HTTP connection pooling
 are 100% automatic, thanks to `urllib3 <https://github.com/shazow/urllib3>`_.
 
-User Testimonials
------------------
-
-Twitter, Spotify, Microsoft, Amazon, Lyft, BuzzFeed, Reddit, The NSA, Her Majesty's Government, Google, Twilio, Runscope, Mozilla, Heroku,
-PayPal, NPR, Obama for America, Transifex, Native Instruments, The Washington
-Post, SoundCloud, Kippt, Sony, and Federal U.S.
-Institutions that prefer to be unnamed claim to use Requests internally.
-
-**Armin Ronacher**—
-    *Requests is the perfect example how beautiful an API can be with the
-    right level of abstraction.*
-
-**Matt DeBoard**—
-    *I'm going to get Kenneth Reitz's Python requests module tattooed
-    on my body, somehow. The whole thing.*
-
-**Daniel Greenfeld**—
-    *Nuked a 1200 LOC spaghetti code library with 10 lines of code thanks to
-    Kenneth Reitz's request library. Today has been AWESOME.*
-
-**Kenny Meyers**—
-    *Python HTTP: When in doubt, or when not in doubt, use Requests. Beautiful,
-    simple, Pythonic.*
-
-Requests is one of the most downloaded Python packages of all time, pulling in
-over 13,000,000 downloads every month. All the cool kids are doing it!
-
 Beloved Features
 ----------------
 
@@ -133,6 +97,7 @@ Requests ecosystem and community.
 .. toctree::
    :maxdepth: 2
 
+   community/sponsors
    community/recommended
    community/faq
    community/out-there

docs/user/advanced.rst

@@ -25,8 +25,8 @@ 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')
+    s.get('https://httpbin.org/cookies/set/sessioncookie/123456789')
+    r = s.get('https://httpbin.org/cookies')
 
     print(r.text)
     # '{"cookies": {"sessioncookie": "123456789"}}'
@@ -40,7 +40,7 @@ is done by providing data to the properties on a Session object::
     s.headers.update({'x-test': 'true'})
 
     # both 'x-test' and 'x-test2' are sent
-    s.get('http://httpbin.org/headers', headers={'x-test2': 'true'})
+    s.get('https://httpbin.org/headers', headers={'x-test2': 'true'})
 
 
 Any dictionaries that you pass to a request method will be merged with the
@@ -53,11 +53,11 @@ with the first request, but not the second::
 
     s = requests.Session()
 
-    r = s.get('http://httpbin.org/cookies', cookies={'from-my': 'browser'})
+    r = s.get('https://httpbin.org/cookies', cookies={'from-my': 'browser'})
     print(r.text)
     # '{"cookies": {"from-my": "browser"}}'
 
-    r = s.get('http://httpbin.org/cookies')
+    r = s.get('https://httpbin.org/cookies')
     print(r.text)
     # '{"cookies": {}}'
 
@@ -69,7 +69,7 @@ If you want to manually add cookies to your session, use the
 Sessions can also be used as context managers::
 
     with requests.Session() as s:
-        s.get('http://httpbin.org/cookies/set/sessioncookie/123456789')
+        s.get('https://httpbin.org/cookies/set/sessioncookie/123456789')
 
 This will make sure the session is closed as soon as the ``with`` block is
 exited, even if unhandled exceptions occurred.
@@ -97,7 +97,7 @@ The ``Response`` object contains all of the information returned by the server a
 also contains the ``Request`` object you created originally. Here is a simple
 request to get some very important information from Wikipedia's servers::
 
-    >>> r = requests.get('http://en.wikipedia.org/wiki/Monty_Python')
+    >>> r = requests.get('https://en.wikipedia.org/wiki/Monty_Python')
 
 If we want to access the headers the server sent back to us, we do this::
 
@@ -193,21 +193,21 @@ When you are using the prepared request flow, keep in mind that it does not take
 This can cause problems if you are using environment variables to change the behaviour of requests.
 For example: Self-signed SSL certificates specified in ``REQUESTS_CA_BUNDLE`` will not be taken into account.
 As a result an ``SSL: CERTIFICATE_VERIFY_FAILED`` is thrown.
-You can get around this behaviour by explicity merging the environment settings into your session::
+You can get around this behaviour by explicitly merging the environment settings into your session::
 
     from requests import Request, Session
-    
+
     s = Session()
     req = Request('GET', url)
-    
+
     prepped = s.prepare_request(req)
-    
+
     # Merge environment settings into session
-    settings = s.merge_environment_settings(prepped.url, None, None, None, None)
+    settings = s.merge_environment_settings(prepped.url, {}, None, None, None)
     resp = s.send(prepped, **settings)
-    
+
     print(resp.status_code)
-    
+
 .. _verification:
 
 SSL Cert Verification
@@ -274,21 +274,20 @@ If you specify a wrong path or an invalid cert, you'll get a SSLError::
 CA Certificates
 ---------------
 
-By default, Requests bundles a set of root CAs that it trusts, sourced from the
-`Mozilla trust store`_. However, these are only updated once for each Requests
-version. This means that if you pin a Requests version your certificates can
-become extremely out of date.
+Requests uses certificates from the package `certifi`_. This allows for users
+to update their trusted certificates without changing the version of Requests.
 
-From Requests version 2.4.0 onwards, Requests will attempt to use certificates
-from `certifi`_ if it is present on the system. This allows for users to update
-their trusted certificates without having to change the code that runs on their
-system.
+Before version 2.16, Requests bundled a set of root CAs that it trusted,
+sourced from the `Mozilla trust store`_. The certificates were only updated
+once for each Requests version. When ``certifi`` was not installed, this led to
+extremely out-of-date certificate bundles when using significantly older
+versions of Requests.
 
 For the sake of security we recommend upgrading certifi frequently!
 
 .. _HTTP persistent connection: https://en.wikipedia.org/wiki/HTTP_persistent_connection
-.. _connection pooling: http://urllib3.readthedocs.io/en/latest/reference/index.html#module-urllib3.connectionpool
-.. _certifi: http://certifi.io/
+.. _connection pooling: https://urllib3.readthedocs.io/en/latest/reference/index.html#module-urllib3.connectionpool
+.. _certifi: https://certifiio.readthedocs.io/
 .. _Mozilla trust store: https://hg.mozilla.org/mozilla-central/raw-file/tip/security/nss/lib/ckfw/builtins/certdata.txt
 
 .. _body-content-workflow:
@@ -301,7 +300,7 @@ immediately. You can override this behaviour and defer downloading the response
 body until you access the :attr:`Response.content <requests.Response.content>`
 attribute with the ``stream`` parameter::
 
-    tarball_url = 'https://github.com/requests/requests/tarball/master'
+    tarball_url = 'https://github.com/psf/requests/tarball/master'
     r = requests.get(tarball_url, stream=True)
 
 At this point only the response headers have been downloaded and the connection
@@ -324,7 +323,7 @@ inefficiency with connections. If you find yourself partially reading request
 bodies (or not reading them at all) while using ``stream=True``, you should
 make the request within a ``with`` statement to ensure it's always closed::
 
-    with requests.get('http://httpbin.org/get', stream=True) as r:
+    with requests.get('https://httpbin.org/get', stream=True) as r:
         # Do things with the response here.
 
 .. _keep-alive:
@@ -352,13 +351,11 @@ file-like object for your body::
     with open('massive-body', 'rb') as f:
         requests.post('http://some.url/streamed', data=f)
 
-.. warning:: It is strongly recommended that you open files in `binary mode`_.
-             This is because Requests may attempt to provide the
-             ``Content-Length`` header for you, and if it does this value will
-             be set to the number of *bytes* in the file. Errors may occur if
-             you open the file in *text mode*.
-
-.. _binary mode: https://docs.python.org/2/tutorial/inputoutput.html#reading-and-writing-files
+.. warning:: It is strongly recommended that you open files in :ref:`binary
+             mode <tut-files>`. This is because Requests may attempt to provide
+             the ``Content-Length`` header for you, and if it does this value
+             will be set to the number of *bytes* in the file. Errors may occur
+             if you open the file in *text mode*.
 
 
 .. _chunk-encoding:
@@ -396,10 +393,10 @@ upload image files to an HTML form with a multiple file field 'images'::
 
 To do that, just set files to a list of tuples of ``(form_field_name, file_info)``::
 
-    >>> url = 'http://httpbin.org/post'
+    >>> url = 'https://httpbin.org/post'
     >>> multiple_files = [
-            ('images', ('foo.png', open('foo.png', 'rb'), 'image/png')),
-            ('images', ('bar.png', open('bar.png', 'rb'), 'image/png'))]
+    ...     ('images', ('foo.png', open('foo.png', 'rb'), 'image/png')),
+    ...     ('images', ('bar.png', open('bar.png', 'rb'), 'image/png'))]
     >>> r = requests.post(url, files=multiple_files)
     >>> r.text
     {
@@ -409,13 +406,11 @@ To do that, just set files to a list of tuples of ``(form_field_name, file_info)
       ...
     }
 
-.. warning:: It is strongly recommended that you open files in `binary mode`_.
-             This is because Requests may attempt to provide the
-             ``Content-Length`` header for you, and if it does this value will
-             be set to the number of *bytes* in the file. Errors may occur if
-             you open the file in *text mode*.
-
-.. _binary mode: https://docs.python.org/2/tutorial/inputoutput.html#reading-and-writing-files
+.. warning:: It is strongly recommended that you open files in :ref:`binary
+             mode <tut-files>`. This is because Requests may attempt to provide
+             the ``Content-Length`` header for you, and if it does this value
+             will be set to the number of *bytes* in the file. Errors may occur
+             if you open the file in *text mode*.
 
 
 .. _event-hooks:
@@ -436,7 +431,7 @@ 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(response=print_url)
+    hooks={'response': print_url}
 
 That ``callback_function`` will receive a chunk of data as its first
 argument.
@@ -450,14 +445,38 @@ 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.
+anything, nothing else is affected.
+
+::
+
+    def record_hook(r, *args, **kwargs):
+        r.hook_called = True
+        return r
 
 Let's print some request method arguments at runtime::
 
-    >>> requests.get('http://httpbin.org', hooks=dict(response=print_url))
-    http://httpbin.org
+    >>> requests.get('https://httpbin.org/', hooks={'response': print_url})
+    https://httpbin.org/
     <Response [200]>
 
+You can add multiple hooks to a single request.  Let's call two hooks at once::
+
+    >>> r = requests.get('https://httpbin.org/', hooks={'response': [print_url, record_hook]})
+    >>> r.hook_called
+    True
+
+You can also add hooks to a ``Session`` instance.  Any hooks you add will then
+be called on every request made to the session.  For example::
+
+   >>> s = requests.Session()
+   >>> s.hooks['response'].append(print_url)
+   >>> s.get('https://httpbin.org/')
+    https://httpbin.org/
+    <Response [200]>
+
+A ``Session`` can have multiple hooks, which will be called in the order
+they are added.
+
 .. _custom-auth:
 
 Custom Authentication
@@ -510,7 +529,7 @@ set ``stream`` to ``True`` and iterate over the response with
     import json
     import requests
 
-    r = requests.get('http://httpbin.org/stream/20', stream=True)
+    r = requests.get('https://httpbin.org/stream/20', stream=True)
 
     for line in r.iter_lines():
 
@@ -524,7 +543,7 @@ When using `decode_unicode=True` with
 :meth:`Response.iter_content() <requests.Response.iter_content>`, you'll want
 to provide a fallback encoding in the event the server doesn't provide one::
 
-    r = requests.get('http://httpbin.org/stream/20', stream=True)
+    r = requests.get('https://httpbin.org/stream/20', stream=True)
 
     if r.encoding is None:
         r.encoding = 'utf-8'
@@ -633,12 +652,12 @@ When you receive a response, Requests makes a guess at the encoding to
 use for decoding the response when you access the :attr:`Response.text
 <requests.Response.text>` attribute. Requests will first check for an
 encoding in the HTTP header, and if none is present, will use `chardet
-<http://pypi.python.org/pypi/chardet>`_ to attempt to guess the encoding.
+<https://pypi.org/project/chardet/>`_ to attempt to guess the encoding.
 
 The only time Requests will not do this is if no explicit charset
 is present in the HTTP headers **and** the ``Content-Type``
 header contains ``text``. In this situation, `RFC 2616
-<http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7.1>`_ specifies
+<https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7.1>`_ specifies
 that the default charset must be ``ISO-8859-1``. Requests follows the
 specification in this case. If you require a different encoding, you can
 manually set the :attr:`Response.encoding <requests.Response.encoding>`
@@ -661,7 +680,7 @@ from GitHub. Suppose we wanted commit ``a050faf`` on Requests. We would get it
 like so::
 
     >>> import requests
-    >>> r = requests.get('https://api.github.com/repos/requests/requests/git/commits/a050faf084662f3a352dd1a941f2c7c9f886d4ad')
+    >>> r = requests.get('https://api.github.com/repos/psf/requests/git/commits/a050faf084662f3a352dd1a941f2c7c9f886d4ad')
 
 We should confirm that GitHub responded correctly. If it has, we want to work
 out what type of content it is. Do this like so::
@@ -679,12 +698,12 @@ So, GitHub returns JSON. That's great, we can use the :meth:`r.json
     >>> commit_data = r.json()
 
     >>> print(commit_data.keys())
-    [u'committer', u'author', u'url', u'tree', u'sha', u'parents', u'message']
+    ['committer', 'author', 'url', 'tree', 'sha', 'parents', 'message']
 
-    >>> print(commit_data[u'committer'])
-    {u'date': u'2012-05-10T11:10:50-07:00', u'email': u'me@kennethreitz.com', u'name': u'Kenneth Reitz'}
+    >>> print(commit_data['committer'])
+    {'date': '2012-05-10T11:10:50-07:00', 'email': 'me@kennethreitz.com', 'name': 'Kenneth Reitz'}
 
-    >>> print(commit_data[u'message'])
+    >>> print(commit_data['message'])
     makin' history
 
 So far, so simple. Well, let's investigate the GitHub API a little bit. Now,
@@ -716,37 +735,37 @@ we should probably avoid making ham-handed POSTS to it. Instead, let's play
 with the Issues feature of GitHub.
 
 This documentation was added in response to
-`Issue #482 <https://github.com/requests/requests/issues/482>`_. Given that
+`Issue #482 <https://github.com/psf/requests/issues/482>`_. Given that
 this issue already exists, we will use it as an example. Let's start by getting it.
 
 ::
 
-    >>> r = requests.get('https://api.github.com/repos/requests/requests/issues/482')
+    >>> r = requests.get('https://api.github.com/repos/psf/requests/issues/482')
     >>> r.status_code
     200
 
     >>> issue = json.loads(r.text)
 
-    >>> print(issue[u'title'])
+    >>> print(issue['title'])
     Feature any http verb in docs
 
-    >>> print(issue[u'comments'])
+    >>> print(issue['comments'])
     3
 
 Cool, we have three comments. Let's take a look at the last of them.
 
 ::
 
-    >>> r = requests.get(r.url + u'/comments')
+    >>> r = requests.get(r.url + '/comments')
     >>> r.status_code
     200
 
     >>> comments = r.json()
 
     >>> print(comments[0].keys())
-    [u'body', u'url', u'created_at', u'updated_at', u'user', u'id']
+    ['body', 'url', 'created_at', 'updated_at', 'user', 'id']
 
-    >>> print(comments[2][u'body'])
+    >>> print(comments[2]['body'])
     Probably in the "advanced" section
 
 Well, that seems like a silly place. Let's post a comment telling the poster
@@ -754,7 +773,7 @@ that he's silly. Who is the poster, anyway?
 
 ::
 
-    >>> print(comments[2][u'user'][u'login'])
+    >>> print(comments[2]['user']['login'])
     kennethreitz
 
 OK, so let's tell this Kenneth guy that we think this example should go in the
@@ -764,7 +783,7 @@ is to POST to the thread. Let's do it.
 ::
 
     >>> body = json.dumps({u"body": u"Sounds great! I'll get right on it!"})
-    >>> url = u"https://api.github.com/repos/requests/requests/issues/482/comments"
+    >>> url = u"https://api.github.com/repos/psf/requests/issues/482/comments"
 
     >>> r = requests.post(url=url, data=body)
     >>> r.status_code
@@ -784,7 +803,7 @@ the very common Basic Auth.
     201
 
     >>> content = r.json()
-    >>> print(content[u'body'])
+    >>> print(content['body'])
     Sounds great! I'll get right on it.
 
 Brilliant. Oh, wait, no! I meant to add that it would take me a while, because
@@ -798,7 +817,7 @@ that.
     5804413
 
     >>> body = json.dumps({u"body": u"Sounds great! I'll get right on it once I feed my cat."})
-    >>> url = u"https://api.github.com/repos/requests/requests/issues/comments/5804413"
+    >>> url = u"https://api.github.com/repos/psf/requests/issues/comments/5804413"
 
     >>> r = requests.patch(url=url, data=body, auth=auth)
     >>> r.status_code
@@ -860,7 +879,7 @@ Link Headers
 Many HTTP APIs feature Link headers. They make APIs more self describing and
 discoverable.
 
-GitHub uses these for `pagination <http://developer.github.com/v3/#pagination>`_
+GitHub uses these for `pagination <https://developer.github.com/v3/#pagination>`_
 in their API, for example::
 
     >>> url = 'https://api.github.com/users/kennethreitz/repos?page=1&per_page=10'
@@ -902,7 +921,7 @@ it should apply to.
 ::
 
     >>> s = requests.Session()
-    >>> s.mount('http://www.github.com', MyAdapter())
+    >>> s.mount('https://github.com/', MyAdapter())
 
 The mount call registers a specific instance of a Transport Adapter to a
 prefix. Once mounted, any HTTP request made using that session whose URL starts
@@ -927,9 +946,9 @@ passed-through to `urllib3`. We'll make a Transport Adapter that instructs the
 library to use SSLv3::
 
     import ssl
+    from urllib3.poolmanager import PoolManager
 
     from requests.adapters import HTTPAdapter
-    from requests.packages.urllib3.poolmanager import PoolManager
 
 
     class Ssl3HttpAdapter(HTTPAdapter):
@@ -940,7 +959,7 @@ library to use SSLv3::
                 num_pools=connections, maxsize=maxsize,
                 block=block, ssl_version=ssl.PROTOCOL_SSLv3)
 
-.. _`described here`: http://www.kennethreitz.org/essays/the-future-of-python-http
+.. _`described here`: https://www.kennethreitz.org/essays/the-future-of-python-http
 .. _`urllib3`: https://github.com/shazow/urllib3
 
 .. _blocking-or-nonblocking:
@@ -957,11 +976,12 @@ response at a time. However, these calls will still block.
 
 If you are concerned about the use of blocking IO, there are lots of projects
 out there that combine Requests with one of Python's asynchronicity frameworks.
-Some excellent examples are `requests-threads`_, `grequests`_,  and `requests-futures`_.
+Some excellent examples are `requests-threads`_, `grequests`_, `requests-futures`_, and `requests-async`_.
 
 .. _`requests-threads`: https://github.com/requests/requests-threads
 .. _`grequests`: https://github.com/kennethreitz/grequests
 .. _`requests-futures`: https://github.com/ross/requests-futures
+.. _`requests-async`: https://github.com/encode/requests-async
 
 Header Ordering
 ---------------
@@ -984,7 +1004,7 @@ The **connect** timeout is the number of seconds Requests will wait for your
 client to establish a connection to a remote machine (corresponding to the
 `connect()`_) call on the socket. It's a good practice to set connect timeouts
 to slightly larger than a multiple of 3, which is the default `TCP packet
-retransmission window <http://www.hjp.at/doc/rfc/rfc2988.txt>`_.
+retransmission window <https://www.hjp.at/doc/rfc/rfc2988.txt>`_.
 
 Once your client has connected to the server and sent the HTTP request, the
 **read** timeout is the number of seconds the client will wait for the server
@@ -1009,4 +1029,4 @@ coffee.
 
     r = requests.get('https://github.com', timeout=None)
 
-.. _`connect()`: http://linux.die.net/man/2/connect
+.. _`connect()`: https://linux.die.net/man/2/connect

docs/user/authentication.rst

@@ -53,7 +53,7 @@ Another very popular form of HTTP Authentication is Digest Authentication,
 and Requests supports this out of the box as well::
 
     >>> from requests.auth import HTTPDigestAuth
-    >>> url = 'http://httpbin.org/digest-auth/auth/user/pass'
+    >>> url = 'https://httpbin.org/digest-auth/auth/user/pass'
     >>> requests.get(url, auth=HTTPDigestAuth('user', 'pass'))
     <Response [200]>
 
@@ -122,7 +122,7 @@ To do so, subclass :class:`AuthBase <requests.auth.AuthBase>` and implement the
     ...         # Implement my authentication
     ...         return r
     ...
-    >>> url = 'http://httpbin.org/get'
+    >>> url = 'https://httpbin.org/get'
     >>> requests.get(url, auth=MyAuth())
     <Response [200]>
 
@@ -134,13 +134,13 @@ authentication will additionally add hooks to provide further functionality.
 Further examples can be found under the `Requests organization`_ and in the
 ``auth.py`` file.
 
-.. _OAuth: http://oauth.net/
+.. _OAuth: https://oauth.net/
 .. _requests_oauthlib: https://github.com/requests/requests-oauthlib
-.. _requests-oauthlib OAuth2 documentation: http://requests-oauthlib.readthedocs.io/en/latest/oauth2_workflow.html
-.. _Web Application Flow: http://requests-oauthlib.readthedocs.io/en/latest/oauth2_workflow.html#web-application-flow
-.. _Mobile Application Flow: http://requests-oauthlib.readthedocs.io/en/latest/oauth2_workflow.html#mobile-application-flow
-.. _Legacy Application Flow:  http://requests-oauthlib.readthedocs.io/en/latest/oauth2_workflow.html#legacy-application-flow
-.. _Backend Application Flow:  http://requests-oauthlib.readthedocs.io/en/latest/oauth2_workflow.html#backend-application-flow
+.. _requests-oauthlib OAuth2 documentation: https://requests-oauthlib.readthedocs.io/en/latest/oauth2_workflow.html
+.. _Web Application Flow: https://requests-oauthlib.readthedocs.io/en/latest/oauth2_workflow.html#web-application-flow
+.. _Mobile Application Flow: https://requests-oauthlib.readthedocs.io/en/latest/oauth2_workflow.html#mobile-application-flow
+.. _Legacy Application Flow: https://requests-oauthlib.readthedocs.io/en/latest/oauth2_workflow.html#legacy-application-flow
+.. _Backend Application Flow: https://requests-oauthlib.readthedocs.io/en/latest/oauth2_workflow.html#backend-application-flow
 .. _Kerberos: https://github.com/requests/requests-kerberos
 .. _NTLM: https://github.com/requests/requests-ntlm
 .. _Requests organization: https://github.com/requests

docs/user/install.rst

@@ -17,23 +17,23 @@ To install Requests, simply run this simple command in your terminal of choice::
 
     $ pipenv install requests
 
-If you don't have `pipenv <http://pipenv.org/>`_ installed (tisk tisk!), head over to the Pipenv website for installation instructions. Or, if you prefer to just use pip and don't have it installed,
-`this Python installation guide <http://docs.python-guide.org/en/latest/starting/installation/>`_
+If you don't have `pipenv <https://pipenv.kennethreitz.org>`_ installed (tisk tisk!), head over to the Pipenv website for installation instructions. Or, if you prefer to just use pip and don't have it installed,
+`this Python installation guide <https://docs.python-guide.org/starting/installation/>`_
 can guide you through the process.
 
 Get the Source Code
 -------------------
 
 Requests is actively developed on GitHub, where the code is
-`always available <https://github.com/requests/requests>`_.
+`always available <https://github.com/psf/requests>`_.
 
 You can either clone the public repository::
 
-    $ git clone git://github.com/requests/requests.git
+    $ git clone git://github.com/psf/requests.git
 
-Or, download the `tarball <https://github.com/requests/requests/tarball/master>`_::
+Or, download the `tarball <https://github.com/psf/requests/tarball/master>`_::
 
-    $ curl -OL https://github.com/requests/requests/tarball/master
+    $ curl -OL https://github.com/psf/requests/tarball/master
     # optionally, zipball is also available (for Windows users).
 
 Once you have a copy of the source, you can embed it in your own Python

docs/user/intro.rst

@@ -37,8 +37,8 @@ closed-source software.
 
 Requests is released under terms of `Apache2 License`_.
 
-.. _`GPL Licensed`: http://www.opensource.org/licenses/gpl-license.php
-.. _`Apache2 License`: http://opensource.org/licenses/Apache-2.0
+.. _`GPL Licensed`: https://opensource.org/licenses/gpl-license.php
+.. _`Apache2 License`: https://opensource.org/licenses/Apache-2.0
 
 
 Requests License

docs/user/quickstart.rst

@@ -39,15 +39,15 @@ get all the information we need from this object.
 Requests' simple API means that all forms of HTTP request are as obvious. For
 example, this is how you make an HTTP POST request::
 
-    >>> r = requests.post('http://httpbin.org/post', data = {'key':'value'})
+    >>> r = requests.post('https://httpbin.org/post', data = {'key':'value'})
 
 Nice, right? What about the other HTTP request types: PUT, DELETE, HEAD and
 OPTIONS? These are all just as simple::
 
-    >>> r = requests.put('http://httpbin.org/put', data = {'key':'value'})
-    >>> r = requests.delete('http://httpbin.org/delete')
-    >>> r = requests.head('http://httpbin.org/get')
-    >>> r = requests.options('http://httpbin.org/get')
+    >>> r = requests.put('https://httpbin.org/put', data = {'key':'value'})
+    >>> r = requests.delete('https://httpbin.org/delete')
+    >>> r = requests.head('https://httpbin.org/get')
+    >>> r = requests.options('https://httpbin.org/get')
 
 That's all well and good, but it's also only the start of what Requests can
 do.
@@ -65,12 +65,12 @@ using the ``params`` keyword argument. As an example, if you wanted to pass
 following code::
 
     >>> payload = {'key1': 'value1', 'key2': 'value2'}
-    >>> r = requests.get('http://httpbin.org/get', params=payload)
+    >>> r = requests.get('https://httpbin.org/get', params=payload)
 
 You can see that the URL has been correctly encoded by printing the URL::
 
     >>> print(r.url)
-    http://httpbin.org/get?key2=value2&key1=value1
+    https://httpbin.org/get?key2=value2&key1=value1
 
 Note that any dictionary key whose value is ``None`` will not be added to the
 URL's query string.
@@ -79,9 +79,9 @@ You can also pass a list of items as a value::
 
     >>> payload = {'key1': 'value1', 'key2': ['value2', 'value3']}
 
-    >>> r = requests.get('http://httpbin.org/get', params=payload)
+    >>> r = requests.get('https://httpbin.org/get', params=payload)
     >>> print(r.url)
-    http://httpbin.org/get?key1=value1&key2=value2&key2=value3
+    https://httpbin.org/get?key1=value1&key2=value2&key2=value3
 
 Response Content
 ----------------
@@ -93,7 +93,7 @@ again::
 
     >>> r = requests.get('https://api.github.com/events')
     >>> r.text
-    u'[{"repository":{"open_issues":0,"url":"https://github.com/...
+    '[{"repository":{"open_issues":0,"url":"https://github.com/...
 
 Requests will automatically decode content from the server. Most unicode
 charsets are seamlessly decoded.
@@ -110,7 +110,7 @@ using, and change it, using the ``r.encoding`` property::
 If you change the encoding, Requests will use the new value of ``r.encoding``
 whenever you call ``r.text``. You might want to do this in any situation where
 you can apply special logic to work out what the encoding of the content will
-be. For example, HTTP and XML have the ability to specify their encoding in
+be. For example, HTML and XML have the ability to specify their encoding in
 their body. In situations like this, you should use ``r.content`` to find the
 encoding, and then set ``r.encoding``. This will let you use ``r.text`` with
 the correct encoding.
@@ -148,7 +148,7 @@ There's also a builtin JSON decoder, in case you're dealing with JSON data::
 
     >>> r = requests.get('https://api.github.com/events')
     >>> r.json()
-    [{u'repository': {u'open_issues': 0, u'url': 'https://github.com/...
+    [{'repository': {'open_issues': 0, 'url': 'https://github.com/...
 
 In case the JSON decoding fails, ``r.json()`` raises an exception. For example, if
 the response gets a 204 (No Content), or if the response contains invalid JSON,
@@ -171,7 +171,7 @@ server, you can access ``r.raw``. If you want to do this, make sure you set
     >>> r = requests.get('https://api.github.com/events', stream=True)
 
     >>> r.raw
-    <requests.packages.urllib3.response.HTTPResponse object at 0x101194810>
+    <urllib3.response.HTTPResponse object at 0x101194810>
 
     >>> r.raw.read(10)
     '\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03'
@@ -189,6 +189,14 @@ download, the above is the preferred and recommended way to retrieve the
 content. Note that ``chunk_size`` can be freely adjusted to a number that
 may better fit your use cases.
 
+.. note::
+
+   An important note about using ``Response.iter_content`` versus ``Response.raw``.
+   ``Response.iter_content`` will automatically decode the ``gzip`` and ``deflate``
+   transfer-encodings.  ``Response.raw`` is a raw stream of bytes -- it does not
+   transform the response content.  If you really need access to the bytes as they
+   were returned, use ``Response.raw``.
+
 
 Custom Headers
 --------------
@@ -225,7 +233,7 @@ dictionary of data will automatically be form-encoded when the request is made::
 
     >>> payload = {'key1': 'value1', 'key2': 'value2'}
 
-    >>> r = requests.post("http://httpbin.org/post", data=payload)
+    >>> r = requests.post("https://httpbin.org/post", data=payload)
     >>> print(r.text)
     {
       ...
@@ -236,12 +244,16 @@ dictionary of data will automatically be form-encoded when the request is made::
       ...
     }
 
-You can also pass a list of tuples to the ``data`` argument. This is particularly
-useful when the form has multiple elements that use the same key::
+The ``data`` argument can also have multiple values for each key. This can be
+done by making ``data`` either a list of tuples or a dictionary with lists
+as values. This is particularly useful when the form has multiple elements that
+use the same key::
 
-    >>> payload = (('key1', 'value1'), ('key1', 'value2'))
-    >>> r = requests.post('http://httpbin.org/post', data=payload)
-    >>> print(r.text)
+    >>> payload_tuples = [('key1', 'value1'), ('key1', 'value2')]
+    >>> r1 = requests.post('https://httpbin.org/post', data=payload_tuples)
+    >>> payload_dict = {'key1': ['value1', 'value2']}
+    >>> r2 = requests.post('https://httpbin.org/post', data=payload_dict)
+    >>> print(r1.text)
     {
       ...
       "form": {
@@ -252,6 +264,8 @@ useful when the form has multiple elements that use the same key::
       },
       ...
     }
+    >>> r1.text == r2.text
+    True
 
 There are times that you may want to send data that is not form-encoded. If
 you pass in a ``string`` instead of a ``dict``, that data will be posted directly.
@@ -273,13 +287,16 @@ the ``json`` parameter (added in version 2.4.2) and it will be encoded automatic
 
     >>> r = requests.post(url, json=payload)
 
+Note, the ``json`` parameter is ignored if either ``data`` or ``files`` is passed.
+
+Using the ``json`` parameter in the request will change the ``Content-Type`` in the header to ``application/json``.
 
 POST a Multipart-Encoded File
 -----------------------------
 
 Requests makes it simple to upload Multipart-encoded files::
 
-    >>> url = 'http://httpbin.org/post'
+    >>> url = 'https://httpbin.org/post'
     >>> files = {'file': open('report.xls', 'rb')}
 
     >>> r = requests.post(url, files=files)
@@ -294,7 +311,7 @@ Requests makes it simple to upload Multipart-encoded files::
 
 You can set the filename, content_type and headers explicitly::
 
-    >>> url = 'http://httpbin.org/post'
+    >>> url = 'https://httpbin.org/post'
     >>> files = {'file': ('report.xls', open('report.xls', 'rb'), 'application/vnd.ms-excel', {'Expires': '0'})}
 
     >>> r = requests.post(url, files=files)
@@ -309,7 +326,7 @@ You can set the filename, content_type and headers explicitly::
 
 If you want, you can send strings to be received as files::
 
-    >>> url = 'http://httpbin.org/post'
+    >>> url = 'https://httpbin.org/post'
     >>> files = {'file': ('report.csv', 'some,data,to,send\nanother,row,to,send\n')}
 
     >>> r = requests.post(url, files=files)
@@ -331,13 +348,11 @@ support this, but there is a separate package which does -
 For sending multiple files in one request refer to the :ref:`advanced <advanced>`
 section.
 
-.. warning:: It is strongly recommended that you open files in `binary mode`_.
-             This is because Requests may attempt to provide the
-             ``Content-Length`` header for you, and if it does this value will
-             be set to the number of *bytes* in the file. Errors may occur if
-             you open the file in *text mode*.
-
-.. _binary mode: https://docs.python.org/2/tutorial/inputoutput.html#reading-and-writing-files
+.. warning:: It is strongly recommended that you open files in :ref:`binary
+             mode <tut-files>`. This is because Requests may attempt to provide
+             the ``Content-Length`` header for you, and if it does this value
+             will be set to the number of *bytes* in the file. Errors may occur
+             if you open the file in *text mode*.
 
 
 Response Status Codes
@@ -345,7 +360,7 @@ Response Status Codes
 
 We can check the response status code::
 
-    >>> r = requests.get('http://httpbin.org/get')
+    >>> r = requests.get('https://httpbin.org/get')
     >>> r.status_code
     200
 
@@ -359,7 +374,7 @@ If we made a bad request (a 4XX client error or 5XX server error response), we
 can raise it with
 :meth:`Response.raise_for_status() <requests.Response.raise_for_status>`::
 
-    >>> bad_r = requests.get('http://httpbin.org/status/404')
+    >>> bad_r = requests.get('https://httpbin.org/status/404')
     >>> bad_r.status_code
     404
 
@@ -373,14 +388,10 @@ But, since our ``status_code`` for ``r`` was ``200``, when we call
 ``raise_for_status()`` we get::
 
     >>> r.raise_for_status()
-    <Response [200]>
+    None
 
 All is well.
 
-.. note:: ``raise_for_status`` returns the response object for a successful response. This eases chaining in trivial cases, where we want bad codes to raise an exception, but use the response otherwise:
-
-    >>> value = requests.get('http://httpbin.org/ip').raise_for_status().json()['origin']
-
 
 Response Headers
 ----------------
@@ -399,7 +410,7 @@ We can view the server's response headers using a Python dictionary::
     }
 
 The dictionary is special, though: it's made just for HTTP headers. According to
-`RFC 7230 <http://tools.ietf.org/html/rfc7230#section-3.2>`_, HTTP Header names
+`RFC 7230 <https://tools.ietf.org/html/rfc7230#section-3.2>`_, HTTP Header names
 are case-insensitive.
 
 So, we can access the headers using any capitalization we want::
@@ -413,17 +424,13 @@ So, we can access the headers using any capitalization we want::
 It is also special in that the server could have sent the same header multiple
 times with different values, but requests combines them so they can be
 represented in the dictionary within a single mapping, as per
-`RFC 7230 <http://tools.ietf.org/html/rfc7230#section-3.2>`_:
+`RFC 7230 <https://tools.ietf.org/html/rfc7230#section-3.2>`_:
 
     A recipient MAY combine multiple header fields with the same field name
     into one "field-name: field-value" pair, without changing the semantics
     of the message, by appending each subsequent field value to the combined
     field value in order, separated by a comma.
 
-If you do need to access each individual value sent with the same header, then
-you can use the ``getlist`` method to get a sequence of all the values returned
-for a particular header.
-
 Cookies
 -------
 
@@ -438,7 +445,7 @@ If a response contains some Cookies, you can quickly access them::
 To send your own cookies to the server, you can use the ``cookies``
 parameter::
 
-    >>> url = 'http://httpbin.org/cookies'
+    >>> url = 'https://httpbin.org/cookies'
     >>> cookies = dict(cookies_are='working')
 
     >>> r = requests.get(url, cookies=cookies)
@@ -453,7 +460,7 @@ also be passed in to requests::
     >>> jar = requests.cookies.RequestsCookieJar()
     >>> jar.set('tasty_cookie', 'yum', domain='httpbin.org', path='/cookies')
     >>> jar.set('gross_cookie', 'blech', domain='httpbin.org', path='/elsewhere')
-    >>> url = 'http://httpbin.org/cookies'
+    >>> url = 'https://httpbin.org/cookies'
     >>> r = requests.get(url, cookies=jar)
     >>> r.text
     '{"cookies": {"tasty_cookie": "yum"}}'
@@ -474,7 +481,7 @@ response.
 
 For example, GitHub redirects all HTTP requests to HTTPS::
 
-    >>> r = requests.get('http://github.com')
+    >>> r = requests.get('http://github.com/')
 
     >>> r.url
     'https://github.com/'
@@ -489,7 +496,7 @@ For example, GitHub redirects all HTTP requests to HTTPS::
 If you're using GET, OPTIONS, POST, PUT, PATCH or DELETE, you can disable
 redirection handling with the ``allow_redirects`` parameter::
 
-    >>> r = requests.get('http://github.com', allow_redirects=False)
+    >>> r = requests.get('http://github.com/', allow_redirects=False)
 
     >>> r.status_code
     301
@@ -499,7 +506,7 @@ redirection handling with the ``allow_redirects`` parameter::
 
 If you're using HEAD, you can enable redirection as well::
 
-    >>> r = requests.head('http://github.com', allow_redirects=True)
+    >>> r = requests.head('http://github.com/', allow_redirects=True)
 
     >>> r.url
     'https://github.com/'
@@ -516,7 +523,7 @@ seconds with the ``timeout`` parameter. Nearly all production code should use
 this parameter in nearly all requests. Failure to do so can cause your program
 to hang indefinitely::
 
-    >>> requests.get('http://github.com', timeout=0.001)
+    >>> requests.get('https://github.com/', timeout=0.001)
     Traceback (most recent call last):
       File "<stdin>", line 1, in <module>
     requests.exceptions.Timeout: HTTPConnectionPool(host='github.com', port=80): Request timed out. (timeout=0.001)
@@ -553,3 +560,6 @@ All exceptions that Requests explicitly raises inherit from
 -----------------------
 
 Ready for more? Check out the :ref:`advanced <advanced>` section.
+
+
+If you're on the job market, consider taking `this programming quiz <https://triplebyte.com/a/b1i2FB8/requests-docs-1>`_. A substantial donation will be made to this project, if you find a job through this platform.

ext/LICENSE

@@ -0,0 +1 @@
+Copyright 2019 Kenneth Reitz. All rights reserved.

pytest.ini

@@ -1,2 +1,3 @@
 [pytest]
-addopts = -p no:warnings
+addopts = -p no:warnings --doctest-modules
+doctest_optionflags= NORMALIZE_WHITESPACE ELLIPSIS

requests/__init__.py

@@ -1,38 +1,40 @@
 # -*- coding: utf-8 -*-
+
 #   __
 #  /__)  _  _     _   _ _/   _
 # / (   (- (/ (/ (- _)  /  _)
 #          /
+
 """
 Requests HTTP Library
 ~~~~~~~~~~~~~~~~~~~~~
 
-Requests is an HTTP library, written in Python, for human beings. Basic GET
-usage:
+Requests is an HTTP library, written in Python, for human beings.
+Basic GET usage:
 
    >>> import requests
    >>> r = requests.get('https://www.python.org')
    >>> r.status_code
    200
-   >>> 'Python is a programming language' in r.content
+   >>> b'Python is a programming language' in r.content
    True
 
 ... or POST:
 
    >>> payload = dict(key1='value1', key2='value2')
-   >>> r = requests.post('http://httpbin.org/post', data=payload)
+   >>> r = requests.post('https://httpbin.org/post', data=payload)
    >>> print(r.text)
    {
      ...
      "form": {
-       "key2": "value2",
-       "key1": "value1"
+       "key1": "value1",
+       "key2": "value2"
      },
      ...
    }
 
 The other HTTP methods are supported - see `requests.api`. Full documentation
-is at <http://python-requests.org>.
+is at <https://requests.readthedocs.io>.
 
 :copyright: (c) 2017 by Kenneth Reitz.
 :license: Apache 2.0, see LICENSE for more details.
@@ -42,93 +44,89 @@ import urllib3
 import chardet
 import warnings
 from .exceptions import RequestsDependencyWarning
-from .import types
 
 
-def check_compatibility(urllib3_version: types.String, chardet_version: types.String) -> None:
-    urllib3_version = urllib3_version.split('.')  # type: ignore
-    assert urllib3_version != [
-        'dev'
-    ]  # Verify urllib3 isn't installed from git.
+def check_compatibility(urllib3_version, chardet_version):
+    urllib3_version = urllib3_version.split('.')
+    assert urllib3_version != ['dev']  # Verify urllib3 isn't installed from git.
+
     # Sometimes, urllib3 only reports its version as 16.1.
     if len(urllib3_version) == 2:
-        urllib3_version.append('0')  # type: ignore
+        urllib3_version.append('0')
+
     # Check urllib3 for compatibility.
     major, minor, patch = urllib3_version  # noqa: F811
-    major, minor, patch = int(major), int(minor), int(patch)  # type: ignore
-    # urllib3 >= 1.21.1, <= 1.22
-    assert major == 1  # type: ignore
-    assert minor >= 21  # type: ignore
-    assert minor <= 22  # type: ignore
+    major, minor, patch = int(major), int(minor), int(patch)
+    # urllib3 >= 1.21.1, <= 1.25
+    assert major == 1
+    assert minor >= 21
+    assert minor <= 25
+
     # Check chardet for compatibility.
     major, minor, patch = chardet_version.split('.')[:3]
-    major, minor, patch = int(major), int(minor), int(patch)  # type: ignore
+    major, minor, patch = int(major), int(minor), int(patch)
     # chardet >= 3.0.2, < 3.1.0
-    assert major == 3  # type: ignore
-    assert minor < 1  # type: ignore
-    assert patch >= 2  # type: ignore
+    assert major == 3
+    assert minor < 1
+    assert patch >= 2
 
 
-def _check_cryptography(cryptography_version: types.String) -> None:
+def _check_cryptography(cryptography_version):
     # cryptography < 1.3.4
     try:
-        cryptography_version = list(
-            map(int, cryptography_version.split('.'))
-        )  # type: ignore
+        cryptography_version = list(map(int, cryptography_version.split('.')))
     except ValueError:
         return
 
-    if cryptography_version < [1, 3, 4]:  # type: ignore
-        warning = 'Old version of cryptography ({0}) may cause slowdown.'.format(
-            cryptography_version
-        )
+    if cryptography_version < [1, 3, 4]:
+        warning = 'Old version of cryptography ({}) may cause slowdown.'.format(cryptography_version)
         warnings.warn(warning, RequestsDependencyWarning)
 
-
 # Check imported dependencies for compatibility.
 try:
     check_compatibility(urllib3.__version__, chardet.__version__)
 except (AssertionError, ValueError):
-    warnings.warn(
-        "urllib3 ({0}) or chardet ({1}) doesn't match a supported "
-        "version!".format(urllib3.__version__, chardet.__version__),
-        RequestsDependencyWarning,
-    )
-# Attempt to enable urllib3's SNI support, if possible
+    warnings.warn("urllib3 ({}) or chardet ({}) doesn't match a supported "
+                  "version!".format(urllib3.__version__, chardet.__version__),
+                  RequestsDependencyWarning)
+
+# Attempt to enable urllib3's fallback for SNI support
+# if the standard library doesn't support SNI or the
+# 'ssl' library isn't available.
 try:
-    from urllib3.contrib import pyopenssl
+    try:
+        import ssl
+    except ImportError:
+        ssl = None
 
-    pyopenssl.inject_into_urllib3()
-    # Check cryptography version
-    from cryptography import __version__ as cryptography_version
+    if not getattr(ssl, "HAS_SNI", False):
+        from urllib3.contrib import pyopenssl
+        pyopenssl.inject_into_urllib3()
 
-    _check_cryptography(cryptography_version)
+        # Check cryptography version
+        from cryptography import __version__ as cryptography_version
+        _check_cryptography(cryptography_version)
 except ImportError:
     pass
+
 # urllib3's DependencyWarnings should be silenced.
 from urllib3.exceptions import DependencyWarning
-
 warnings.simplefilter('ignore', DependencyWarning)
 
 from .__version__ import __title__, __description__, __url__, __version__
 from .__version__ import __build__, __author__, __author_email__, __license__
 from .__version__ import __copyright__, __cake__
 
-from .import utils
+from . import utils
+from . import packages
 from .models import Request, Response, PreparedRequest
 from .api import request, get, head, post, patch, put, delete, options
-from .sessions import Session
+from .sessions import session, Session
 from .status_codes import codes
 from .exceptions import (
-    RequestException,
-    Timeout,
-    URLRequired,
-    TooManyRedirects,
-    HTTPError,
-    ConnectionError,
-    FileModeWarning,
-    ConnectTimeout,
-    ReadTimeout,
+    RequestException, Timeout, URLRequired,
+    TooManyRedirects, HTTPError, ConnectionError,
+    FileModeWarning, ConnectTimeout, ReadTimeout
 )
 
 # Set default logging handler to avoid "No handler found" warnings.
@@ -136,5 +134,6 @@ import logging
 from logging import NullHandler
 
 logging.getLogger(__name__).addHandler(NullHandler())
+
 # FileModeWarnings go off per the default.
 warnings.simplefilter('default', FileModeWarning, append=True)

requests/__version__.py

@@ -1,13 +1,14 @@
 # .-. .-. .-. . . .-. .-. .-. .-.
 # |(  |-  |.| | | |-  `-.  |  `-.
 # ' ' `-' `-`.`-' `-' `-'  '  `-'
+
 __title__ = 'requests'
 __description__ = 'Python HTTP for Humans.'
-__url__ = 'http://python-requests.org'
-__version__ = '3.0.0'
-__build__ = 0x030000
+__url__ = 'https://requests.readthedocs.io'
+__version__ = '2.24.0'
+__build__ = 0x022400
 __author__ = 'Kenneth Reitz'
 __author_email__ = 'me@kennethreitz.org'
 __license__ = 'Apache 2.0'
-__copyright__ = 'Copyright 2017 Kenneth Reitz'
+__copyright__ = 'Copyright 2020 Kenneth Reitz'
 __cake__ = u'\u2728 \U0001f370 \u2728'

requests/_internal_utils.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 """
 requests._internal_utils
 ~~~~~~~~~~~~~~
@@ -7,7 +8,7 @@ Provides utility functions that are consumed internally by Requests
 which depend on extremely few external helpers (such as compat)
 """
 
-from .basics import builtin_str, str
+from .compat import is_py2, builtin_str, str
 
 
 def to_native_string(string, encoding='ascii'):
@@ -18,7 +19,11 @@ def to_native_string(string, encoding='ascii'):
     if isinstance(string, builtin_str):
         out = string
     else:
-        out = string.decode(encoding)
+        if is_py2:
+            out = string.encode(encoding)
+        else:
+            out = string.decode(encoding)
+
     return out
 
 
@@ -29,12 +34,9 @@ def unicode_is_ascii(u_string):
         and not Python 2 `str`.
     :rtype: bool
     """
-    if not isinstance(u_string, str):
-        return None
-
+    assert isinstance(u_string, str)
     try:
         u_string.encode('ascii')
         return True
-
     except UnicodeEncodeError:
         return False

requests/adapters.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 """
 requests.adapters
 ~~~~~~~~~~~~~~~~~
@@ -12,6 +13,7 @@ import socket
 
 from urllib3.poolmanager import PoolManager, proxy_from_url
 from urllib3.response import HTTPResponse
+from urllib3.util import parse_url
 from urllib3.util import Timeout as TimeoutSauce
 from urllib3.util.retry import Retry
 from urllib3.exceptions import ClosedPoolError
@@ -24,37 +26,25 @@ from urllib3.exceptions import ProtocolError
 from urllib3.exceptions import ReadTimeoutError
 from urllib3.exceptions import SSLError as _SSLError
 from urllib3.exceptions import ResponseError
+from urllib3.exceptions import LocationValueError
 
 from .models import Response
-from .basics import urlparse, basestring
-from .utils import (
-    DEFAULT_CA_BUNDLE_PATH,
-    get_encoding_from_headers,
-    prepend_scheme_if_needed,
-    get_auth_from_url,
-    urldefragauth,
-    select_proxy,
-)
-from .structures import HTTPHeaderDict
+from .compat import urlparse, basestring
+from .utils import (DEFAULT_CA_BUNDLE_PATH, extract_zipped_paths,
+                    get_encoding_from_headers, prepend_scheme_if_needed,
+                    get_auth_from_url, urldefragauth, select_proxy)
+from .structures import CaseInsensitiveDict
 from .cookies import extract_cookies_to_jar
-from .exceptions import (
-    ConnectionError,
-    ConnectTimeout,
-    ReadTimeout,
-    SSLError,
-    ProxyError,
-    RetryError,
-    InvalidScheme,
-)
+from .exceptions import (ConnectionError, ConnectTimeout, ReadTimeout, SSLError,
+                         ProxyError, RetryError, InvalidSchema, InvalidProxyURL,
+                         InvalidURL)
 from .auth import _basic_auth_str
 
 try:
     from urllib3.contrib.socks import SOCKSProxyManager
 except ImportError:
-
     def SOCKSProxyManager(*args, **kwargs):
-        raise InvalidScheme("Missing dependencies for SOCKS support.")
-
+        raise InvalidSchema("Missing dependencies for SOCKS support.")
 
 DEFAULT_POOLBLOCK = False
 DEFAULT_POOLSIZE = 10
@@ -62,83 +52,14 @@ DEFAULT_RETRIES = 0
 DEFAULT_POOL_TIMEOUT = None
 
 
-def _pool_kwargs(verify, cert):
-    """Create a dictionary of keyword arguments to pass to a
-    :class:`PoolManager <urllib3.poolmanager.PoolManager>` with the
-    necessary SSL configuration.
-
-    :param verify: Whether we should actually verify the certificate;
-                   optionally a path to a CA certificate bundle or
-                   directory of CA certificates.
-    :param cert: The path to the client certificate and key, if any.
-                 This can either be the path to the certificate and
-                 key concatenated in a single file, or as a tuple of
-                 (cert_file, key_file).
-    """
-    pool_kwargs = {}
-    if verify:
-        cert_loc = None
-        # Allow self-specified cert location.
-        if verify is not True:
-            cert_loc = verify
-        if not cert_loc:
-            cert_loc = DEFAULT_CA_BUNDLE_PATH
-        if not cert_loc or not os.path.exists(cert_loc):
-            raise IOError(
-                "Could not find a suitable TLS CA certificate bundle, "
-                "invalid path: {0}".format(cert_loc)
-            )
-
-        pool_kwargs['cert_reqs'] = 'CERT_REQUIRED'
-        if not os.path.isdir(cert_loc):
-            pool_kwargs['ca_certs'] = cert_loc
-            pool_kwargs['ca_cert_dir'] = None
-        else:
-            pool_kwargs['ca_cert_dir'] = cert_loc
-            pool_kwargs['ca_certs'] = None
-    else:
-        pool_kwargs['cert_reqs'] = 'CERT_NONE'
-        pool_kwargs['ca_certs'] = None
-        pool_kwargs['ca_cert_dir'] = None
-    if cert:
-        if not isinstance(cert, basestring):
-            pool_kwargs['cert_file'] = cert[0]
-            pool_kwargs['key_file'] = cert[1]
-        else:
-            pool_kwargs['cert_file'] = cert
-            pool_kwargs['key_file'] = None
-        cert_file = pool_kwargs['cert_file']
-        key_file = pool_kwargs['key_file']
-        if cert_file and not os.path.exists(cert_file):
-            raise IOError(
-                "Could not find the TLS certificate file, "
-                "invalid path: {0}".format(cert_file)
-            )
-
-        if key_file and not os.path.exists(key_file):
-            raise IOError(
-                "Could not find the TLS key file, "
-                "invalid path: {0}".format(key_file)
-            )
-
-    return pool_kwargs
-
-
 class BaseAdapter(object):
     """The Base Transport Adapter"""
 
     def __init__(self):
         super(BaseAdapter, self).__init__()
 
-    def send(
-        self,
-        request,
-        stream=False,
-        timeout=None,
-        verify=True,
-        cert=None,
-        proxies=None,
-    ):
+    def send(self, request, stream=False, timeout=None, verify=True,
+             cert=None, proxies=None):
         """Sends PreparedRequest object. Returns Response object.
 
         :param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
@@ -186,31 +107,25 @@ class HTTPAdapter(BaseAdapter):
       >>> a = requests.adapters.HTTPAdapter(max_retries=3)
       >>> s.mount('http://', a)
     """
-    __attrs__ = [
-        'max_retries',
-        'config',
-        '_pool_connections',
-        '_pool_maxsize',
-        '_pool_block',
-    ]
+    __attrs__ = ['max_retries', 'config', '_pool_connections', '_pool_maxsize',
+                 '_pool_block']
 
-    def __init__(
-        self,
-        pool_connections=DEFAULT_POOLSIZE,
-        pool_maxsize=DEFAULT_POOLSIZE,
-        max_retries=DEFAULT_RETRIES,
-        pool_block=DEFAULT_POOLBLOCK,
-    ):
+    def __init__(self, pool_connections=DEFAULT_POOLSIZE,
+                 pool_maxsize=DEFAULT_POOLSIZE, max_retries=DEFAULT_RETRIES,
+                 pool_block=DEFAULT_POOLBLOCK):
         if max_retries == DEFAULT_RETRIES:
             self.max_retries = Retry(0, read=False)
         else:
             self.max_retries = Retry.from_int(max_retries)
         self.config = {}
         self.proxy_manager = {}
+
         super(HTTPAdapter, self).__init__()
+
         self._pool_connections = pool_connections
         self._pool_maxsize = pool_maxsize
         self._pool_block = pool_block
+
         self.init_poolmanager(pool_connections, pool_maxsize, block=pool_block)
 
     def __getstate__(self):
@@ -221,15 +136,14 @@ class HTTPAdapter(BaseAdapter):
         # self.poolmanager uses a lambda function, which isn't pickleable.
         self.proxy_manager = {}
         self.config = {}
+
         for attr, value in state.items():
             setattr(self, attr, value)
-        self.init_poolmanager(
-            self._pool_connections, self._pool_maxsize, block=self._pool_block
-        )
 
-    def init_poolmanager(
-        self, connections, maxsize, block=DEFAULT_POOLBLOCK, **pool_kwargs
-    ):
+        self.init_poolmanager(self._pool_connections, self._pool_maxsize,
+                              block=self._pool_block)
+
+    def init_poolmanager(self, connections, maxsize, block=DEFAULT_POOLBLOCK, **pool_kwargs):
         """Initializes a urllib3 PoolManager.
 
         This method should not be called from user code, and is only
@@ -245,13 +159,9 @@ class HTTPAdapter(BaseAdapter):
         self._pool_connections = connections
         self._pool_maxsize = maxsize
         self._pool_block = block
-        self.poolmanager = PoolManager(
-            num_pools=connections,
-            maxsize=maxsize,
-            block=block,
-            strict=True,
-            **pool_kwargs,
-        )
+
+        self.poolmanager = PoolManager(num_pools=connections, maxsize=maxsize,
+                                       block=block, strict=True, **pool_kwargs)
 
     def proxy_manager_for(self, proxy, **proxy_kwargs):
         """Return urllib3 ProxyManager for the given proxy.
@@ -276,7 +186,7 @@ class HTTPAdapter(BaseAdapter):
                 num_pools=self._pool_connections,
                 maxsize=self._pool_maxsize,
                 block=self._pool_block,
-                **proxy_kwargs,
+                **proxy_kwargs
             )
         else:
             proxy_headers = self.proxy_headers(proxy)
@@ -286,10 +196,62 @@ class HTTPAdapter(BaseAdapter):
                 num_pools=self._pool_connections,
                 maxsize=self._pool_maxsize,
                 block=self._pool_block,
-                **proxy_kwargs,
-            )
+                **proxy_kwargs)
+
         return manager
 
+    def cert_verify(self, conn, url, verify, cert):
+        """Verify a SSL certificate. This method should not be called from user
+        code, and is only exposed for use when subclassing the
+        :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
+
+        :param conn: The urllib3 connection object associated with the cert.
+        :param url: The requested URL.
+        :param verify: Either a boolean, in which case it controls whether we verify
+            the server's TLS certificate, or a string, in which case it must be a path
+            to a CA bundle to use
+        :param cert: The SSL certificate to verify.
+        """
+        if url.lower().startswith('https') and verify:
+
+            cert_loc = None
+
+            # Allow self-specified cert location.
+            if verify is not True:
+                cert_loc = verify
+
+            if not cert_loc:
+                cert_loc = extract_zipped_paths(DEFAULT_CA_BUNDLE_PATH)
+
+            if not cert_loc or not os.path.exists(cert_loc):
+                raise IOError("Could not find a suitable TLS CA certificate bundle, "
+                              "invalid path: {}".format(cert_loc))
+
+            conn.cert_reqs = 'CERT_REQUIRED'
+
+            if not os.path.isdir(cert_loc):
+                conn.ca_certs = cert_loc
+            else:
+                conn.ca_cert_dir = cert_loc
+        else:
+            conn.cert_reqs = 'CERT_NONE'
+            conn.ca_certs = None
+            conn.ca_cert_dir = None
+
+        if cert:
+            if not isinstance(cert, basestring):
+                conn.cert_file = cert[0]
+                conn.key_file = cert[1]
+            else:
+                conn.cert_file = cert
+                conn.key_file = None
+            if conn.cert_file and not os.path.exists(conn.cert_file):
+                raise IOError("Could not find the TLS certificate file, "
+                              "invalid path: {}".format(conn.cert_file))
+            if conn.key_file and not os.path.exists(conn.key_file):
+                raise IOError("Could not find the TLS key file, "
+                              "invalid path: {}".format(conn.key_file))
+
     def build_response(self, req, resp):
         """Builds a :class:`Response <requests.Response>` object from a urllib3
         response. This should not be called from user code, and is only exposed
@@ -301,26 +263,33 @@ class HTTPAdapter(BaseAdapter):
         :rtype: requests.Response
         """
         response = Response()
+
         # Fallback to None if there's no status_code, for whatever reason.
         response.status_code = getattr(resp, 'status', None)
+
         # Make headers case-insensitive.
-        response.headers = HTTPHeaderDict(getattr(resp, 'headers', {}))
+        response.headers = CaseInsensitiveDict(getattr(resp, 'headers', {}))
+
         # Set encoding.
         response.encoding = get_encoding_from_headers(response.headers)
         response.raw = resp
         response.reason = response.raw.reason
+
         if isinstance(req.url, bytes):
             response.url = req.url.decode('utf-8')
         else:
             response.url = req.url
+
         # Add new cookies from the server.
         extract_cookies_to_jar(response.cookies, req, resp)
+
         # Give the Response some context.
         response.request = req
         response.connection = self
+
         return response
 
-    def get_connection(self, url, proxies=None, verify=None, cert=None):
+    def get_connection(self, url, proxies=None):
         """Returns a urllib3 connection for the given URL. This should not be
         called from user code, and is only exposed for use when subclassing the
         :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
@@ -329,21 +298,22 @@ class HTTPAdapter(BaseAdapter):
         :param proxies: (optional) A Requests-style dictionary of proxies used on this request.
         :rtype: urllib3.ConnectionPool
         """
-        pool_kwargs = _pool_kwargs(verify, cert)
         proxy = select_proxy(url, proxies)
+
         if proxy:
             proxy = prepend_scheme_if_needed(proxy, 'http')
+            proxy_url = parse_url(proxy)
+            if not proxy_url.host:
+                raise InvalidProxyURL("Please check proxy URL. It is malformed"
+                                      " and could be missing the host.")
             proxy_manager = self.proxy_manager_for(proxy)
-            conn = proxy_manager.connection_from_url(
-                url, pool_kwargs=pool_kwargs
-            )
+            conn = proxy_manager.connection_from_url(url)
         else:
             # Only scheme should be lower case
             parsed = urlparse(url)
             url = parsed.geturl()
-            conn = self.poolmanager.connection_from_url(
-                url, pool_kwargs=pool_kwargs
-            )
+            conn = self.poolmanager.connection_from_url(url)
+
         return conn
 
     def close(self):
@@ -372,14 +342,17 @@ class HTTPAdapter(BaseAdapter):
         """
         proxy = select_proxy(request.url, proxies)
         scheme = urlparse(request.url).scheme
+
         is_proxied_http_request = (proxy and scheme != 'https')
         using_socks_proxy = False
         if proxy:
             proxy_scheme = urlparse(proxy).scheme.lower()
             using_socks_proxy = proxy_scheme.startswith('socks')
+
         url = request.path_url
         if is_proxied_http_request and not using_socks_proxy:
             url = urldefragauth(request.url)
+
         return url
 
     def add_headers(self, request, **kwargs):
@@ -406,26 +379,19 @@ class HTTPAdapter(BaseAdapter):
         when subclassing the
         :class:`HTTPAdapter <requests.adapters.HTTPAdapter>`.
 
-        :param proxies: The url of the proxy being used for this request.
+        :param proxy: The url of the proxy being used for this request.
         :rtype: dict
         """
         headers = {}
         username, password = get_auth_from_url(proxy)
+
         if username:
-            headers['Proxy-Authorization'] = _basic_auth_str(
-                username, password
-            )
+            headers['Proxy-Authorization'] = _basic_auth_str(username,
+                                                             password)
+
         return headers
 
-    def send(
-        self,
-        request,
-        stream=False,
-        timeout=None,
-        verify=True,
-        cert=None,
-        proxies=None,
-    ):
+    def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):
         """Sends PreparedRequest object. Returns Response object.
 
         :param request: The :class:`PreparedRequest <PreparedRequest>` being sent.
@@ -441,29 +407,33 @@ class HTTPAdapter(BaseAdapter):
         :param proxies: (optional) The proxies dictionary to apply to the request.
         :rtype: requests.Response
         """
-        conn = self.get_connection(request.url, proxies, verify, cert)
+
+        try:
+            conn = self.get_connection(request.url, proxies)
+        except LocationValueError as e:
+            raise InvalidURL(e, request=request)
+
+        self.cert_verify(conn, request.url, verify, cert)
         url = self.request_url(request, proxies)
-        self.add_headers(request)
-        chunked = not (
-            request.body is None or 'Content-Length' in request.headers
-        )
+        self.add_headers(request, stream=stream, timeout=timeout, verify=verify, cert=cert, proxies=proxies)
+
+        chunked = not (request.body is None or 'Content-Length' in request.headers)
+
         if isinstance(timeout, tuple):
             try:
                 connect, read = timeout
                 timeout = TimeoutSauce(connect=connect, read=read)
             except ValueError as e:
                 # this may raise a string formatting error.
-                err = (
-                    "Invalid timeout {0}. Pass a (connect, read) "
-                    "timeout tuple, or a single float to set "
-                    "both timeouts to the same value".format(timeout)
-                )
+                err = ("Invalid timeout {}. Pass a (connect, read) "
+                       "timeout tuple, or a single float to set "
+                       "both timeouts to the same value".format(timeout))
                 raise ValueError(err)
-
         elif isinstance(timeout, TimeoutSauce):
             pass
         else:
             timeout = TimeoutSauce(connect=timeout, read=timeout)
+
         try:
             if not chunked:
                 resp = conn.urlopen(
@@ -476,46 +446,47 @@ class HTTPAdapter(BaseAdapter):
                     preload_content=False,
                     decode_content=False,
                     retries=self.max_retries,
-                    timeout=timeout,
-                    enforce_content_length=True,
+                    timeout=timeout
                 )
+
             # Send the request.
             else:
                 if hasattr(conn, 'proxy_pool'):
                     conn = conn.proxy_pool
+
                 low_conn = conn._get_conn(timeout=DEFAULT_POOL_TIMEOUT)
+
                 try:
-                    low_conn.putrequest(
-                        request.method, url, skip_accept_encoding=True
-                    )
+                    low_conn.putrequest(request.method,
+                                        url,
+                                        skip_accept_encoding=True)
+
                     for header, value in request.headers.items():
                         low_conn.putheader(header, value)
-                    low_conn.endheaders()
-                    for i in request.body:
-                        chunk_size = len(i)
-                        if chunk_size == 0:
-                            continue
 
-                        low_conn.send(hex(chunk_size)[2:].encode('utf-8'))
+                    low_conn.endheaders()
+
+                    for i in request.body:
+                        low_conn.send(hex(len(i))[2:].encode('utf-8'))
                         low_conn.send(b'\r\n')
                         low_conn.send(i)
                         low_conn.send(b'\r\n')
                     low_conn.send(b'0\r\n\r\n')
+
                     # Receive the response from the server
                     try:
                         # For Python 2.7, use buffering of HTTP responses
                         r = low_conn.getresponse(buffering=True)
                     except TypeError:
-                        # For Python 3.3+ versions, this is the default
+                        # For compatibility with Python 3.3+
                         r = low_conn.getresponse()
+
                     resp = HTTPResponse.from_httplib(
                         r,
                         pool=conn,
                         connection=low_conn,
                         preload_content=False,
-                        decode_content=False,
-                        enforce_content_length=True,
-                        request_method=request.method,
+                        decode_content=False
                     )
                 except:
                     # If we hit any problems here, clean up the connection.
@@ -554,10 +525,8 @@ class HTTPAdapter(BaseAdapter):
             if isinstance(e, _SSLError):
                 # This branch is for urllib3 versions earlier than v1.22
                 raise SSLError(e, request=request)
-
             elif isinstance(e, ReadTimeoutError):
                 raise ReadTimeout(e, request=request)
-
             else:
                 raise
 

requests/api.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 """
 requests.api
 ~~~~~~~~~~~~
@@ -9,25 +10,19 @@ This module implements the Requests API.
 :license: Apache2, see LICENSE for more details.
 """
 
-from .import sessions
-from .import types
+from . import sessions
 
 
-def request(
-    method: types.Method,
-    url: types.URL,
-    *,
-    session: types.Session = None,
-    **kwargs,
-) -> types.Response:
+def request(method, url, **kwargs):
     """Constructs and sends a :class:`Request <Request>`.
 
-    :param method: method for the new :class:`Request` object.
+    :param method: method for the new :class:`Request` object: ``GET``, ``OPTIONS``, ``HEAD``, ``POST``, ``PUT``, ``PATCH``, or ``DELETE``.
     :param url: URL for the new :class:`Request` object.
-    :param session: :class:`Session` object to use for this request. If none is given, one will be provided.
-    :param params: (optional) Dictionary or bytes to be sent in the query string for the :class:`Request`.
-    :param data: (optional) Dictionary or list of tuples ``[(key, value)]`` (will be form-encoded), bytes, or file-like object to send in the body of the :class:`Request`.
-    :param json: (optional) json data to send in the body of the :class:`Request`.
+    :param params: (optional) Dictionary, list of tuples or bytes to send
+        in the query string for the :class:`Request`.
+    :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+        object to send in the body of the :class:`Request`.
+    :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`.
     :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`.
     :param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`.
     :param files: (optional) Dictionary of ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload.
@@ -54,33 +49,34 @@ def request(
     Usage::
 
       >>> import requests
-      >>> req = requests.request('GET', 'http://httpbin.org/get')
+      >>> req = requests.request('GET', 'https://httpbin.org/get')
+      >>> req
       <Response [200]>
     """
+
     # By using the 'with' statement we are sure the session is closed, thus we
     # avoid leaving sockets open which can trigger a ResourceWarning in some
     # cases, and look like a memory leak in others.
-    session = sessions.Session() if session is None else session
-    with session:
+    with sessions.Session() as session:
         return session.request(method=method, url=url, **kwargs)
 
 
-def get(
-    url: types.URL, *, params: types.Params = None, **kwargs
-) -> types.Response:
+def get(url, params=None, **kwargs):
     r"""Sends a GET request.
 
     :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 params: (optional) Dictionary, list of tuples or bytes to send
+        in the query string for the :class:`Request`.
     :param \*\*kwargs: Optional arguments that ``request`` takes.
     :return: :class:`Response <Response>` object
     :rtype: requests.Response
     """
+
     kwargs.setdefault('allow_redirects', True)
     return request('get', url, params=params, **kwargs)
 
 
-def options(url: types.URL, **kwargs) -> types.Response:
+def options(url, **kwargs):
     r"""Sends an OPTIONS request.
 
     :param url: URL for the new :class:`Request` object.
@@ -88,72 +84,72 @@ def options(url: types.URL, **kwargs) -> types.Response:
     :return: :class:`Response <Response>` object
     :rtype: requests.Response
     """
+
     kwargs.setdefault('allow_redirects', True)
     return request('options', url, **kwargs)
 
 
-def head(url: types.URL, **kwargs) -> types.Response:
+def head(url, **kwargs):
     r"""Sends a HEAD request.
 
     :param url: URL for the new :class:`Request` object.
-    :param \*\*kwargs: Optional arguments that ``request`` takes.
+    :param \*\*kwargs: Optional arguments that ``request`` takes. If
+        `allow_redirects` is not provided, it will be set to `False` (as
+        opposed to the default :meth:`request` behavior).
     :return: :class:`Response <Response>` object
     :rtype: requests.Response
     """
+
     kwargs.setdefault('allow_redirects', False)
     return request('head', url, **kwargs)
 
 
-def post(
-    url: types.URL,
-    *,
-    data: types.Data = None,
-    json: types.JSON = None,
-    **kwargs,
-) -> types.Response:
+def post(url, data=None, json=None, **kwargs):
     r"""Sends a POST request.
 
     :param url: URL for the new :class:`Request` object.
-    :param data: (optional) Dictionary (will be form-encoded), bytes, or file-like object to send in the body of the :class:`Request`.
+    :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+        object to send in the body of the :class:`Request`.
     :param json: (optional) json data to send in the body of the :class:`Request`.
     :param \*\*kwargs: Optional arguments that ``request`` takes.
     :return: :class:`Response <Response>` object
     :rtype: requests.Response
     """
+
     return request('post', url, data=data, json=json, **kwargs)
 
 
-def put(
-    url: types.URL, *, data: types.Data = None, **kwargs
-) -> types.Response:
+def put(url, data=None, **kwargs):
     r"""Sends a PUT request.
 
     :param url: URL for the new :class:`Request` object.
-    :param data: (optional) Dictionary (will be form-encoded), bytes, or file-like object to send in the body of the :class:`Request`.
+    :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+        object to send in the body of the :class:`Request`.
     :param json: (optional) json data to send in the body of the :class:`Request`.
     :param \*\*kwargs: Optional arguments that ``request`` takes.
     :return: :class:`Response <Response>` object
     :rtype: requests.Response
     """
+
     return request('put', url, data=data, **kwargs)
 
 
-def patch(
-    url: types.URL, *, data: types.Data = None, **kwargs
-) -> types.Response:
+def patch(url, data=None, **kwargs):
     r"""Sends a PATCH request.
 
     :param url: URL for the new :class:`Request` object.
-    :param data: (optional) Dictionary (will be form-encoded), bytes, or file-like object to send in the body of the :class:`Request`.
+    :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+        object to send in the body of the :class:`Request`.
     :param json: (optional) json data to send in the body of the :class:`Request`.
     :param \*\*kwargs: Optional arguments that ``request`` takes.
     :return: :class:`Response <Response>` object
     :rtype: requests.Response
     """
+
     return request('patch', url, data=data, **kwargs)
 
 
-def delete(url: types.URL, **kwargs) -> types.Response:
+def delete(url, **kwargs):
     r"""Sends a DELETE request.
 
     :param url: URL for the new :class:`Request` object.
@@ -161,4 +157,5 @@ def delete(url: types.URL, **kwargs) -> types.Response:
     :return: :class:`Response <Response>` object
     :rtype: requests.Response
     """
+
     return request('delete', url, **kwargs)

requests/auth.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 """
 requests.auth
 ~~~~~~~~~~~~~
@@ -11,10 +12,11 @@ import re
 import time
 import hashlib
 import threading
+import warnings
 
 from base64 import b64encode
 
-from .basics import urlparse, str, basestring
+from .compat import urlparse, str, basestring
 from .cookies import extract_cookies_to_jar
 from ._internal_utils import to_native_string
 from .utils import parse_dict_header
@@ -25,25 +27,45 @@ CONTENT_TYPE_MULTI_PART = 'multipart/form-data'
 
 def _basic_auth_str(username, password):
     """Returns a Basic Auth string."""
+
+    # "I want us to put a big-ol' comment on top of it that
+    # says that this behaviour is dumb but we need to preserve
+    # it because people are relying on it."
+    #    - Lukasa
+    #
+    # These are here solely to maintain backwards compatibility
+    # for things like ints. This will be removed in 3.0.0.
     if not isinstance(username, basestring):
-        raise TypeError(
-            'username must be of type str or bytes, '
-            'instead it was %s' % type(username)
+        warnings.warn(
+            "Non-string usernames will no longer be supported in Requests "
+            "3.0.0. Please convert the object you've passed in ({!r}) to "
+            "a string or bytes object in the near future to avoid "
+            "problems.".format(username),
+            category=DeprecationWarning,
         )
+        username = str(username)
 
     if not isinstance(password, basestring):
-        raise TypeError(
-            'password must be of type str or bytes, '
-            'instead it was %s' % type(password)
+        warnings.warn(
+            "Non-string passwords will no longer be supported in Requests "
+            "3.0.0. Please convert the object you've passed in ({!r}) to "
+            "a string or bytes object in the near future to avoid "
+            "problems.".format(type(password)),
+            category=DeprecationWarning,
         )
+        password = str(password)
+    # -- End Removal --
 
     if isinstance(username, str):
         username = username.encode('latin1')
+
     if isinstance(password, str):
         password = password.encode('latin1')
+
     authstr = 'Basic ' + to_native_string(
         b64encode(b':'.join((username, password))).strip()
     )
+
     return authstr
 
 
@@ -62,20 +84,24 @@ class HTTPBasicAuth(AuthBase):
         self.password = password
 
     def __eq__(self, other):
-        return all(
-            [
-                self.username == getattr(other, 'username', None),
-                self.password == getattr(other, 'password', None),
-            ]
-        )
+        return all([
+            self.username == getattr(other, 'username', None),
+            self.password == getattr(other, 'password', None)
+        ])
 
     def __ne__(self, other):
         return not self == other
 
     def __call__(self, r):
-        r.headers['Authorization'] = _basic_auth_str(
-            self.username, self.password
-        )
+        r.headers['Authorization'] = _basic_auth_str(self.username, self.password)
+        return r
+
+
+class HTTPProxyAuth(HTTPBasicAuth):
+    """Attaches HTTP Proxy Authentication to a given Request object."""
+
+    def __call__(self, r):
+        r.headers['Proxy-Authorization'] = _basic_auth_str(self.username, self.password)
         return r
 
 
@@ -102,48 +128,63 @@ class HTTPDigestAuth(AuthBase):
         """
         :rtype: str
         """
+
         realm = self._thread_local.chal['realm']
         nonce = self._thread_local.chal['nonce']
         qop = self._thread_local.chal.get('qop')
         algorithm = self._thread_local.chal.get('algorithm')
         opaque = self._thread_local.chal.get('opaque')
         hash_utf8 = None
+
         if algorithm is None:
             _algorithm = 'MD5'
         else:
             _algorithm = algorithm.upper()
         # lambdas assume digest modules are imported at the top level
         if _algorithm == 'MD5' or _algorithm == 'MD5-SESS':
-
             def md5_utf8(x):
                 if isinstance(x, str):
                     x = x.encode('utf-8')
                 return hashlib.md5(x).hexdigest()
-
             hash_utf8 = md5_utf8
         elif _algorithm == 'SHA':
-
             def sha_utf8(x):
                 if isinstance(x, str):
                     x = x.encode('utf-8')
                 return hashlib.sha1(x).hexdigest()
-
             hash_utf8 = sha_utf8
+        elif _algorithm == 'SHA-256':
+            def sha256_utf8(x):
+                if isinstance(x, str):
+                    x = x.encode('utf-8')
+                return hashlib.sha256(x).hexdigest()
+            hash_utf8 = sha256_utf8
+        elif _algorithm == 'SHA-512':
+            def sha512_utf8(x):
+                if isinstance(x, str):
+                    x = x.encode('utf-8')
+                return hashlib.sha512(x).hexdigest()
+            hash_utf8 = sha512_utf8
+
         KD = lambda s, d: hash_utf8("%s:%s" % (s, d))
+
         if hash_utf8 is None:
             return None
 
         # XXX not implemented yet
         entdig = None
         p_parsed = urlparse(url)
-        # : path is request-uri defined in RFC 2616 which should not be empty
+        #: path is request-uri defined in RFC 2616 which should not be empty
         path = p_parsed.path or "/"
         if p_parsed.query:
             path += '?' + p_parsed.query
+
         A1 = '%s:%s:%s' % (self.username, realm, self.password)
         A2 = '%s:%s' % (method, path)
+
         HA1 = hash_utf8(A1)
         HA2 = hash_utf8(A2)
+
         if nonce == self._thread_local.last_nonce:
             self._thread_local.nonce_count += 1
         else:
@@ -153,23 +194,27 @@ class HTTPDigestAuth(AuthBase):
         s += nonce.encode('utf-8')
         s += time.ctime().encode('utf-8')
         s += os.urandom(8)
+
         cnonce = (hashlib.sha1(s).hexdigest()[:16])
         if _algorithm == 'MD5-SESS':
             HA1 = hash_utf8('%s:%s:%s' % (HA1, nonce, cnonce))
+
         if not qop:
             respdig = KD(HA1, "%s:%s" % (nonce, HA2))
         elif qop == 'auth' or 'auth' in qop.split(','):
-            noncebit = "%s:%s:%s:%s:%s" % (nonce, ncvalue, cnonce, 'auth', HA2)
+            noncebit = "%s:%s:%s:%s:%s" % (
+                nonce, ncvalue, cnonce, 'auth', HA2
+            )
             respdig = KD(HA1, noncebit)
         else:
             # XXX handle auth-int.
             return None
 
         self._thread_local.last_nonce = nonce
+
         # XXX should the partial digests be encoded too?
-        base = 'username="%s", realm="%s", nonce="%s", uri="%s", ' 'response="%s"' % (
-            self.username, realm, nonce, path, respdig
-        )
+        base = 'username="%s", realm="%s", nonce="%s", uri="%s", ' \
+               'response="%s"' % (self.username, realm, nonce, path, respdig)
         if opaque:
             base += ', opaque="%s"' % opaque
         if algorithm:
@@ -178,6 +223,7 @@ class HTTPDigestAuth(AuthBase):
             base += ', digest="%s"' % entdig
         if qop:
             base += ', qop="auth", nc=%s, cnonce="%s"' % (ncvalue, cnonce)
+
         return 'Digest %s' % (base)
 
     def handle_redirect(self, r, **kwargs):
@@ -191,8 +237,9 @@ class HTTPDigestAuth(AuthBase):
 
         :rtype: requests.Response
         """
+
         # If response is not 4xx, do not auth
-        # See https://github.com/requests/requests/issues/3772
+        # See https://github.com/psf/requests/issues/3772
         if not 400 <= r.status_code < 500:
             self._thread_local.num_401_calls = 1
             return r
@@ -202,12 +249,13 @@ class HTTPDigestAuth(AuthBase):
             # it was to resend the request.
             r.request.body.seek(self._thread_local.pos)
         s_auth = r.headers.get('www-authenticate', '')
+
         if 'digest' in s_auth.lower() and self._thread_local.num_401_calls < 2:
+
             self._thread_local.num_401_calls += 1
             pat = re.compile(r'digest ', flags=re.IGNORECASE)
-            self._thread_local.chal = parse_dict_header(
-                pat.sub('', s_auth, count=1)
-            )
+            self._thread_local.chal = parse_dict_header(pat.sub('', s_auth, count=1))
+
             # Consume content and release the original connection
             # to allow our new request to reuse the same one.
             r.content
@@ -215,12 +263,13 @@ class HTTPDigestAuth(AuthBase):
             prep = r.request.copy()
             extract_cookies_to_jar(prep._cookies, r.request, r.raw)
             prep.prepare_cookies(prep._cookies)
+
             prep.headers['Authorization'] = self.build_digest_header(
-                prep.method, prep.url
-            )
+                prep.method, prep.url)
             _r = r.connection.send(prep, **kwargs)
             _r.history.append(r)
             _r.request = prep
+
             return _r
 
         self._thread_local.num_401_calls = 1
@@ -231,9 +280,7 @@ class HTTPDigestAuth(AuthBase):
         self.init_per_thread_state()
         # If we have a saved nonce, skip the 401
         if self._thread_local.last_nonce:
-            r.headers['Authorization'] = self.build_digest_header(
-                r.method, r.url
-            )
+            r.headers['Authorization'] = self.build_digest_header(r.method, r.url)
         try:
             self._thread_local.pos = r.body.tell()
         except AttributeError:
@@ -245,15 +292,14 @@ class HTTPDigestAuth(AuthBase):
         r.register_hook('response', self.handle_401)
         r.register_hook('response', self.handle_redirect)
         self._thread_local.num_401_calls = 1
+
         return r
 
     def __eq__(self, other):
-        return all(
-            [
-                self.username == getattr(other, 'username', None),
-                self.password == getattr(other, 'password', None),
-            ]
-        )
+        return all([
+            self.username == getattr(other, 'username', None),
+            self.password == getattr(other, 'password', None)
+        ])
 
     def __ne__(self, other):
         return not self == other

requests/basics.py

@@ -1,45 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-requests.basics
-~~~~~~~~~~~~~~~
-
-This modules covers the basics.
-"""
-
-import chardet
-
-import sys
-
-# ---------
-# Specifics
-# ---------
-from urllib.parse import (
-    urlparse,
-    urlunparse,
-    urljoin,
-    urlsplit,
-    urlencode,
-    quote,
-    unquote,
-    quote_plus,
-    unquote_plus,
-    urldefrag,
-)
-from urllib.request import (
-    parse_http_list,
-    getproxies,
-    proxy_bypass,
-    proxy_bypass_environment,
-    getproxies_environment,
-)
-from http import cookiejar as cookielib
-from http.cookies import Morsel
-from io import StringIO
-from collections import OrderedDict
-
-builtin_str = str  # type: ignore
-str = str  # type: ignore
-bytes = bytes  # type: ignore
-basestring = (str, bytes)
-numeric_types = (int, float)
-integer_types = (int,)

requests/certs.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+
 """
 requests.certs
 ~~~~~~~~~~~~~~

requests/compat.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+
+"""
+requests.compat
+~~~~~~~~~~~~~~~
+
+This module handles import compatibility issues between Python 2 and
+Python 3.
+"""
+
+import chardet
+
+import sys
+
+# -------
+# Pythons
+# -------
+
+# Syntax sugar.
+_ver = sys.version_info
+
+#: Python 2.x?
+is_py2 = (_ver[0] == 2)
+
+#: Python 3.x?
+is_py3 = (_ver[0] == 3)
+
+try:
+    import simplejson as json
+except ImportError:
+    import json
+
+# ---------
+# Specifics
+# ---------
+
+if is_py2:
+    from urllib import (
+        quote, unquote, quote_plus, unquote_plus, urlencode, getproxies,
+        proxy_bypass, proxy_bypass_environment, getproxies_environment)
+    from urlparse import urlparse, urlunparse, urljoin, urlsplit, urldefrag
+    from urllib2 import parse_http_list
+    import cookielib
+    from Cookie import Morsel
+    from StringIO import StringIO
+    # Keep OrderedDict for backwards compatibility.
+    from collections import Callable, Mapping, MutableMapping, OrderedDict
+
+
+    builtin_str = str
+    bytes = str
+    str = unicode
+    basestring = basestring
+    numeric_types = (int, long, float)
+    integer_types = (int, long)
+
+elif is_py3:
+    from urllib.parse import urlparse, urlunparse, urljoin, urlsplit, urlencode, quote, unquote, quote_plus, unquote_plus, urldefrag
+    from urllib.request import parse_http_list, getproxies, proxy_bypass, proxy_bypass_environment, getproxies_environment
+    from http import cookiejar as cookielib
+    from http.cookies import Morsel
+    from io import StringIO
+    # Keep OrderedDict for backwards compatibility.
+    from collections import OrderedDict
+    from collections.abc import Callable, Mapping, MutableMapping
+
+    builtin_str = str
+    str = str
+    bytes = bytes
+    basestring = (str, bytes)
+    numeric_types = (int, float)
+    integer_types = (int,)

requests/cookies.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 """
 requests.cookies
 ~~~~~~~~~~~~~~~~
@@ -11,15 +12,14 @@ requests.utils imports from here, so be careful with imports.
 import copy
 import time
 import calendar
-import collections
 
 from ._internal_utils import to_native_string
-from .basics import cookielib, urlparse, urlunparse, Morsel
+from .compat import cookielib, urlparse, urlunparse, Morsel, MutableMapping
 
 try:
     import threading
 except ImportError:
-    import dummy_threading as threading  # type: ignore
+    import dummy_threading as threading
 
 
 class MockRequest(object):
@@ -53,21 +53,14 @@ class MockRequest(object):
         # header
         if not self._r.headers.get('Host'):
             return self._r.url
-
         # If they did set it, retrieve it and reconstruct the expected domain
         host = to_native_string(self._r.headers['Host'], encoding='utf-8')
         parsed = urlparse(self._r.url)
         # Reconstruct the URL as we expect it
-        return urlunparse(
-            [
-                parsed.scheme,
-                host,
-                parsed.path,
-                parsed.params,
-                parsed.query,
-                parsed.fragment,
-            ]
-        )
+        return urlunparse([
+            parsed.scheme, host, parsed.path, parsed.params, parsed.query,
+            parsed.fragment
+        ])
 
     def is_unverifiable(self):
         return True
@@ -80,9 +73,7 @@ class MockRequest(object):
 
     def add_header(self, key, val):
         """cookielib has no legitimate use for this method; add it back if you find one."""
-        raise NotImplementedError(
-            "Cookie headers should be added with add_unredirected_header()"
-        )
+        raise NotImplementedError("Cookie headers should be added with add_unredirected_header()")
 
     def add_unredirected_header(self, name, value):
         self._new_headers[name] = value
@@ -131,11 +122,9 @@ def extract_cookies_to_jar(jar, request, response):
     :param request: our own requests.Request object
     :param response: urllib3.HTTPResponse object
     """
-    if not (
-        hasattr(response, '_original_response') and response._original_response
-    ):
+    if not (hasattr(response, '_original_response') and
+            response._original_response):
         return
-
     # the _original_response field is the wrapped httplib.HTTPResponse object,
     req = MockRequest(request)
     # pull out the HTTPMessage with the headers and put it in the mock:
@@ -163,14 +152,12 @@ def remove_cookie_by_name(cookiejar, name, domain=None, path=None):
     for cookie in cookiejar:
         if cookie.name != name:
             continue
-
         if domain is not None and domain != cookie.domain:
             continue
-
         if path is not None and path != cookie.path:
             continue
-
         clearables.append((cookie.domain, cookie.path, cookie.name))
+
     for domain, path, name in clearables:
         cookiejar.clear(domain, path, name)
 
@@ -181,7 +168,7 @@ class CookieConflictError(RuntimeError):
     """
 
 
-class RequestsCookieJar(cookielib.CookieJar, collections.MutableMapping):
+class RequestsCookieJar(cookielib.CookieJar, MutableMapping):
     """Compatibility class; is a cookielib.CookieJar, but exposes a dict
     interface.
 
@@ -208,7 +195,6 @@ class RequestsCookieJar(cookielib.CookieJar, collections.MutableMapping):
         """
         try:
             return self._find_no_duplicates(name, domain, path)
-
         except KeyError:
             return default
 
@@ -219,12 +205,7 @@ class RequestsCookieJar(cookielib.CookieJar, collections.MutableMapping):
         """
         # support client code that unsets cookies by assignment of a None value:
         if value is None:
-            remove_cookie_by_name(
-                self,
-                name,
-                domain=kwargs.get('domain'),
-                path=kwargs.get('path'),
-            )
+            remove_cookie_by_name(self, name, domain=kwargs.get('domain'), path=kwargs.get('path'))
             return
 
         if isinstance(value, Morsel):
@@ -312,7 +293,6 @@ class RequestsCookieJar(cookielib.CookieJar, collections.MutableMapping):
         for cookie in iter(self):
             if cookie.domain is not None and cookie.domain in domains:
                 return True
-
             domains.append(cookie.domain)
         return False  # there is only one domain in jar
 
@@ -335,7 +315,6 @@ class RequestsCookieJar(cookielib.CookieJar, collections.MutableMapping):
     def __contains__(self, name):
         try:
             return super(RequestsCookieJar, self).__contains__(name)
-
         except CookieConflictError:
             return True
 
@@ -362,15 +341,9 @@ class RequestsCookieJar(cookielib.CookieJar, collections.MutableMapping):
         remove_cookie_by_name(self, name)
 
     def set_cookie(self, cookie, *args, **kwargs):
-        if hasattr(cookie.value, 'startswith') and cookie.value.startswith(
-            '"'
-        ) and cookie.value.endswith(
-            '"'
-        ):
+        if hasattr(cookie.value, 'startswith') and cookie.value.startswith('"') and cookie.value.endswith('"'):
             cookie.value = cookie.value.replace('\\"', '')
-        return super(RequestsCookieJar, self).set_cookie(
-            cookie, *args, **kwargs
-        )
+        return super(RequestsCookieJar, self).set_cookie(cookie, *args, **kwargs)
 
     def update(self, other):
         """Updates this jar with cookies from another CookieJar or dict-like"""
@@ -418,15 +391,11 @@ class RequestsCookieJar(cookielib.CookieJar, collections.MutableMapping):
                 if domain is None or cookie.domain == domain:
                     if path is None or cookie.path == path:
                         if toReturn is not None:  # if there are multiple cookies that meet passed in criteria
-                            raise CookieConflictError(
-                                'There are multiple cookies with name, %r' %
-                                (name)
-                            )
-
+                            raise CookieConflictError('There are multiple cookies with name, %r' % (name))
                         toReturn = cookie.value  # we will eventually return this as long as no cookie conflict
+
         if toReturn:
             return toReturn
-
         raise KeyError('name=%r, domain=%r, path=%r' % (name, domain, path))
 
     def __getstate__(self):
@@ -444,10 +413,15 @@ class RequestsCookieJar(cookielib.CookieJar, collections.MutableMapping):
 
     def copy(self):
         """Return a copy of this RequestsCookieJar."""
-        new_cj = RequestsCookieJar(self._policy)
+        new_cj = RequestsCookieJar()
+        new_cj.set_policy(self.get_policy())
         new_cj.update(self)
         return new_cj
 
+    def get_policy(self):
+        """Return the CookiePolicy instance used."""
+        return self._policy
+
 
 def _copy_cookie_jar(jar):
     if jar is None:
@@ -456,7 +430,6 @@ def _copy_cookie_jar(jar):
     if hasattr(jar, 'copy'):
         # We're dealing with an instance of RequestsCookieJar
         return jar.copy()
-
     # We're dealing with a generic CookieJar instance
     new_jar = copy.copy(jar)
     new_jar.clear()
@@ -486,6 +459,7 @@ def create_cookie(name, value, **kwargs):
         'rest': {'HttpOnly': None},
         'rfc2109': False,
     }
+
     badargs = set(kwargs) - set(result)
     if badargs:
         err = 'create_cookie() got unexpected keyword arguments: %s'
@@ -496,18 +470,19 @@ def create_cookie(name, value, **kwargs):
     result['domain_specified'] = bool(result['domain'])
     result['domain_initial_dot'] = result['domain'].startswith('.')
     result['path_specified'] = bool(result['path'])
+
     return cookielib.Cookie(**result)
 
 
 def morsel_to_cookie(morsel):
     """Convert a Morsel object into a Cookie containing the one k/v pair."""
+
     expires = None
     if morsel['max-age']:
         try:
             expires = int(time.time() + int(morsel['max-age']))
         except ValueError:
             raise TypeError('max-age: %s must be integer' % morsel['max-age'])
-
     elif morsel['expires']:
         time_template = '%a, %d-%b-%Y %H:%M:%S GMT'
         expires = calendar.timegm(
@@ -537,14 +512,17 @@ def cookiejar_from_dict(cookie_dict, cookiejar=None, overwrite=True):
     :param cookiejar: (optional) A cookiejar to add the cookies to.
     :param overwrite: (optional) If False, will not replace cookies
         already in the jar with new ones.
+    :rtype: CookieJar
     """
     if cookiejar is None:
         cookiejar = RequestsCookieJar()
+
     if cookie_dict is not None:
         names_from_jar = [cookie.name for cookie in cookiejar]
         for name in cookie_dict:
             if overwrite or (name not in names_from_jar):
                 cookiejar.set_cookie(create_cookie(name, cookie_dict[name]))
+
     return cookiejar
 
 
@@ -553,18 +531,19 @@ def merge_cookies(cookiejar, cookies):
 
     :param cookiejar: CookieJar object to add the cookies to.
     :param cookies: Dictionary or CookieJar object to be added.
+    :rtype: CookieJar
     """
     if not isinstance(cookiejar, cookielib.CookieJar):
         raise ValueError('You can only merge into CookieJar')
 
     if isinstance(cookies, dict):
         cookiejar = cookiejar_from_dict(
-            cookies, cookiejar=cookiejar, overwrite=False
-        )
+            cookies, cookiejar=cookiejar, overwrite=False)
     elif isinstance(cookies, cookielib.CookieJar):
         try:
             cookiejar.update(cookies)
         except AttributeError:
             for cookie_in_jar in cookies:
                 cookiejar.set_cookie(cookie_in_jar)
+
     return cookiejar

requests/exceptions.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 """
 requests.exceptions
 ~~~~~~~~~~~~~~~~~~~
@@ -18,11 +19,8 @@ class RequestException(IOError):
         response = kwargs.pop('response', None)
         self.response = response
         self.request = kwargs.pop('request', None)
-        if (
-            response is not None and
-            not self.request and
-            hasattr(response, 'request')
-        ):
+        if (response is not None and not self.request and
+                hasattr(response, 'request')):
             self.request = self.response.request
         super(RequestException, self).__init__(*args, **kwargs)
 
@@ -71,12 +69,12 @@ class TooManyRedirects(RequestException):
     """Too many redirects."""
 
 
-class MissingScheme(RequestException, ValueError):
-    """The URL scheme (e.g. http or https) is missing."""
+class MissingSchema(RequestException, ValueError):
+    """The URL schema (e.g. http or https) is missing."""
 
 
-class InvalidScheme(RequestException, ValueError):
-    """See defaults.py for valid schemes."""
+class InvalidSchema(RequestException, ValueError):
+    """See defaults.py for valid schemas."""
 
 
 class InvalidURL(RequestException, ValueError):
@@ -87,16 +85,20 @@ class InvalidHeader(RequestException, ValueError):
     """The header value provided was somehow invalid."""
 
 
+class InvalidProxyURL(InvalidURL):
+    """The proxy URL provided is invalid."""
+
+
 class ChunkedEncodingError(RequestException):
     """The server declared chunked encoding but sent an invalid chunk."""
 
 
 class ContentDecodingError(RequestException, BaseHTTPError):
-    """Failed to decode response content"""
+    """Failed to decode response content."""
 
 
 class StreamConsumedError(RequestException, TypeError):
-    """The content for this response was already consumed"""
+    """The content for this response was already consumed."""
 
 
 class RetryError(RequestException):
@@ -104,26 +106,18 @@ class RetryError(RequestException):
 
 
 class UnrewindableBodyError(RequestException):
-    """Requests encountered an error when trying to rewind a body"""
-
-
-class InvalidBodyError(RequestException, ValueError):
-    """An invalid request body was specified"""
-
-
-
+    """Requests encountered an error when trying to rewind a body."""
 
 # Warnings
+
+
 class RequestsWarning(Warning):
     """Base warning for Requests."""
-    pass
 
 
 class FileModeWarning(RequestsWarning, DeprecationWarning):
     """A file was opened in text mode, but Requests determined its binary length."""
-    pass
 
 
 class RequestsDependencyWarning(RequestsWarning):
     """An imported dependency doesn't match the expected version range."""
-    pass

requests/help.py

@@ -10,12 +10,10 @@ import idna
 import urllib3
 import chardet
 
-from .import types
-
-from .import __version__ as requests_version
+from . import __version__ as requests_version
 
 try:
-    from . packages.urllib3.contrib import pyopenssl
+    from urllib3.contrib import pyopenssl
 except ImportError:
     pyopenssl = None
     OpenSSL = None
@@ -25,7 +23,7 @@ else:
     import cryptography
 
 
-def _implementation() -> types.Help:
+def _implementation():
     """Return a dict with the Python implementation and version.
 
     Provide both the name and the version of the Python implementation
@@ -37,51 +35,65 @@ def _implementation() -> types.Help:
     to work out the correct shape of the code for those platforms.
     """
     implementation = platform.python_implementation()
+
     if implementation == 'CPython':
         implementation_version = platform.python_version()
     elif implementation == 'PyPy':
-        implementation_version = '%s.%s.%s' % (
-            sys.pypy_version_info.major,
-            sys.pypy_version_info.minor,
-            sys.pypy_version_info.micro,
-        )
+        implementation_version = '%s.%s.%s' % (sys.pypy_version_info.major,
+                                               sys.pypy_version_info.minor,
+                                               sys.pypy_version_info.micro)
         if sys.pypy_version_info.releaselevel != 'final':
-            implementation_version = ''.join(
-                [implementation_version, sys.pypy_version_info.releaselevel]
-            )
+            implementation_version = ''.join([
+                implementation_version, sys.pypy_version_info.releaselevel
+            ])
     elif implementation == 'Jython':
         implementation_version = platform.python_version()  # Complete Guess
     elif implementation == 'IronPython':
         implementation_version = platform.python_version()  # Complete Guess
     else:
         implementation_version = 'Unknown'
+
     return {'name': implementation, 'version': implementation_version}
 
 
-def info() -> types.Help:
+def info():
     """Generate information for a bug report."""
     try:
         platform_info = {
-            'system': platform.system(), 'release': platform.release()
+            'system': platform.system(),
+            'release': platform.release(),
         }
     except IOError:
-        platform_info = {'system': 'Unknown', 'release': 'Unknown'}
+        platform_info = {
+            'system': 'Unknown',
+            'release': 'Unknown',
+        }
+
     implementation_info = _implementation()
     urllib3_info = {'version': urllib3.__version__}
     chardet_info = {'version': chardet.__version__}
-    pyopenssl_info = {'version': None, 'openssl_version': ''}
+
+    pyopenssl_info = {
+        'version': None,
+        'openssl_version': '',
+    }
     if OpenSSL:
         pyopenssl_info = {
             'version': OpenSSL.__version__,
             'openssl_version': '%x' % OpenSSL.SSL.OPENSSL_VERSION_NUMBER,
         }
-    cryptography_info = {'version': getattr(cryptography, '__version__', '')}
-    idna_info = {'version': getattr(idna, '__version__', '')}
-    # OPENSSL_VERSION_NUMBER doesn't exist in the Python 2.6 ssl module.
-    system_ssl = getattr(ssl, 'OPENSSL_VERSION_NUMBER', None)
+    cryptography_info = {
+        'version': getattr(cryptography, '__version__', ''),
+    }
+    idna_info = {
+        'version': getattr(idna, '__version__', ''),
+    }
+
+    system_ssl = ssl.OPENSSL_VERSION_NUMBER
     system_ssl_info = {
         'version': '%x' % system_ssl if system_ssl is not None else ''
     }
+
     return {
         'platform': platform_info,
         'implementation': implementation_info,
@@ -92,7 +104,9 @@ def info() -> types.Help:
         'chardet': chardet_info,
         'cryptography': cryptography_info,
         'idna': idna_info,
-        'requests': {'version': requests_version},
+        'requests': {
+            'version': requests_version,
+        },
     }
 
 

requests/hooks.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 """
 requests.hooks
 ~~~~~~~~~~~~~~
@@ -16,10 +17,9 @@ HOOKS = ['response']
 def default_hooks():
     return {event: [] for event in HOOKS}
 
-
-
-
 # TODO: response is the only one
+
+
 def dispatch_hook(key, hooks, hook_data, **kwargs):
     """Dispatches a hook dictionary on a given piece of data."""
     hooks = hooks or {}

requests/packages.py

@@ -0,0 +1,14 @@
+import sys
+
+# This code exists for backwards compatibility reasons.
+# I don't like it either. Just look the other way. :)
+
+for package in ('urllib3', 'idna', 'chardet'):
+    locals()[package] = __import__(package)
+    # This traversal is apparently necessary such that the identities are
+    # preserved (requests.packages.urllib3.* is urllib3.*)
+    for mod in list(sys.modules):
+        if mod == package or mod.startswith(package + '.'):
+            sys.modules['requests.packages.' + mod] = sys.modules[mod]
+
+# Kinda cool, though, right?

requests/sessions.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 """
 requests.session
 ~~~~~~~~~~~~~~~~
@@ -7,44 +8,28 @@ This module provides a Session object to manage and persist settings across
 requests (cookies, auth, proxies).
 """
 import os
-import platform
+import sys
 import time
-from collections import Mapping, OrderedDict
 from datetime import timedelta
+from collections import OrderedDict
 
 from .auth import _basic_auth_str
-from .basics import cookielib, urljoin, urlparse, str
+from .compat import cookielib, is_py3, urljoin, urlparse, Mapping
 from .cookies import (
-    cookiejar_from_dict,
-    extract_cookies_to_jar,
-    RequestsCookieJar,
-    merge_cookies,
-    _copy_cookie_jar,
-)
+    cookiejar_from_dict, extract_cookies_to_jar, RequestsCookieJar, merge_cookies)
 from .models import Request, PreparedRequest, DEFAULT_REDIRECT_LIMIT
 from .hooks import default_hooks, dispatch_hook
 from ._internal_utils import to_native_string
-from .utils import to_key_val_list, default_headers
+from .utils import to_key_val_list, default_headers, DEFAULT_PORTS
 from .exceptions import (
-    TooManyRedirects,
-    InvalidScheme,
-    ChunkedEncodingError,
-    ConnectionError,
-    ContentDecodingError,
-    InvalidHeader,
-)
+    TooManyRedirects, InvalidSchema, ChunkedEncodingError, ContentDecodingError)
 
 from .structures import CaseInsensitiveDict
 from .adapters import HTTPAdapter
 
 from .utils import (
-    requote_uri,
-    get_environ_proxies,
-    get_netrc_auth,
-    should_bypass_proxies,
-    get_auth_from_url,
-    is_valid_location,
-    rewind_body,
+    requote_uri, get_environ_proxies, get_netrc_auth, should_bypass_proxies,
+    get_auth_from_url, rewind_body
 )
 
 from .status_codes import codes
@@ -53,7 +38,7 @@ from .status_codes import codes
 from .models import REDIRECT_STATI
 
 # Preferred clock, based on which one is more accurate on a given system.
-if platform.system() == 'Windows':
+if sys.platform == 'win32':
     try:  # Python 3.4+
         preferred_clock = time.perf_counter
     except AttributeError:  # Earlier than Python 3.
@@ -65,8 +50,9 @@ else:
 def merge_setting(request_setting, session_setting, dict_class=OrderedDict):
     """Determines appropriate setting for a given request, taking into account
     the explicit setting on that request, and the setting in the session. If a
-    setting is a dictionary, they will be merged together using `dict_class`.
+    setting is a dictionary, they will be merged together using `dict_class`
     """
+
     if session_setting is None:
         return request_setting
 
@@ -75,18 +61,20 @@ def merge_setting(request_setting, session_setting, dict_class=OrderedDict):
 
     # Bypass if not a dictionary (e.g. verify)
     if not (
-        isinstance(session_setting, Mapping) and
-        isinstance(request_setting, Mapping)
+            isinstance(session_setting, Mapping) and
+            isinstance(request_setting, Mapping)
     ):
         return request_setting
 
     merged_setting = dict_class(to_key_val_list(session_setting))
     merged_setting.update(to_key_val_list(request_setting))
+
     # Remove keys that are set to None. Extract keys first to avoid altering
     # the dictionary during iteration.
     none_keys = [k for (k, v) in merged_setting.items() if v is None]
     for key in none_keys:
         del merged_setting[key]
+
     return merged_setting
 
 
@@ -107,7 +95,7 @@ def merge_hooks(request_hooks, session_hooks, dict_class=OrderedDict):
 
 class SessionRedirectMixin(object):
 
-    def get_redirect_target(self, response):
+    def get_redirect_target(self, resp):
         """Receives a Response. Returns a redirect URI or ``None``"""
         # Due to the nature of how requests processes redirects this method will
         # be called at least once upon the original response and at least twice
@@ -115,108 +103,118 @@ class SessionRedirectMixin(object):
         # If a custom mixin is used to handle this logic, it may be advantageous
         # to cache the redirect location onto the response object as a private
         # attribute.
-        if response.is_redirect:
-            if not is_valid_location(response):
-                raise InvalidHeader(
-                    'Response contains multiple Location headers. '
-                    'Unable to perform redirect.'
-                )
-
-            location = response.headers['location']
+        if resp.is_redirect:
+            location = resp.headers['location']
             # Currently the underlying http module on py3 decode headers
             # in latin1, but empirical evidence suggests that latin1 is very
             # rarely used with non-ASCII characters in HTTP headers.
             # It is more likely to get UTF8 header rather than latin1.
             # This causes incorrect handling of UTF8 encoded location headers.
             # To solve this, we re-encode the location in latin1.
-            location = location.encode('latin1')
+            if is_py3:
+                location = location.encode('latin1')
             return to_native_string(location, 'utf8')
-
         return None
 
-    def resolve_redirects(
-        self,
-        response,
-        request,
-        stream=False,
-        timeout=None,
-        verify=True,
-        cert=None,
-        proxies=None,
-        yield_requests=False,
-        **adapter_kwargs,
-    ):
-        """Given a Response, yields Responses until 'Location' header-based
-        redirection ceases, or the Session.max_redirects limit has been
-        reached.
-        """
-        history = [
-            response
-        ]  # keep track of history; seed it with the original response
-        location_url = self.get_redirect_target(response)
-        while location_url:
-            prepared_request = request.copy()
+    def should_strip_auth(self, old_url, new_url):
+        """Decide whether Authorization header should be removed when redirecting"""
+        old_parsed = urlparse(old_url)
+        new_parsed = urlparse(new_url)
+        if old_parsed.hostname != new_parsed.hostname:
+            return True
+        # Special case: allow http -> https redirect when using the standard
+        # ports. This isn't specified by RFC 7235, but is kept to avoid
+        # breaking backwards compatibility with older versions of requests
+        # that allowed any redirects on the same host.
+        if (old_parsed.scheme == 'http' and old_parsed.port in (80, None)
+                and new_parsed.scheme == 'https' and new_parsed.port in (443, None)):
+            return False
+
+        # Handle default port usage corresponding to scheme.
+        changed_port = old_parsed.port != new_parsed.port
+        changed_scheme = old_parsed.scheme != new_parsed.scheme
+        default_port = (DEFAULT_PORTS.get(old_parsed.scheme, None), None)
+        if (not changed_scheme and old_parsed.port in default_port
+                and new_parsed.port in default_port):
+            return False
+
+        # Standard case: root URI must match
+        return changed_port or changed_scheme
+
+    def resolve_redirects(self, resp, req, stream=False, timeout=None,
+                          verify=True, cert=None, proxies=None, yield_requests=False, **adapter_kwargs):
+        """Receives a Response. Returns a generator of Responses or Requests."""
+
+        hist = []  # keep track of history
+
+        url = self.get_redirect_target(resp)
+        previous_fragment = urlparse(req.url).fragment
+        while url:
+            prepared_request = req.copy()
+
+            # Update history and keep track of redirects.
+            # resp.history must ignore the original request in this loop
+            hist.append(resp)
+            resp.history = hist[1:]
+
             try:
-                response.content  # Consume socket so it can be released
-            except (
-                ChunkedEncodingError,
-                ConnectionError,
-                ContentDecodingError,
-                RuntimeError,
-            ):
-                response.raw.read(decode_content=False)
-            if len(response.history) >= self.max_redirects:
-                raise TooManyRedirects(
-                    'Exceeded %s redirects.' % self.max_redirects,
-                    response=response,
-                )
+                resp.content  # Consume socket so it can be released
+            except (ChunkedEncodingError, ContentDecodingError, RuntimeError):
+                resp.raw.read(decode_content=False)
+
+            if len(resp.history) >= self.max_redirects:
+                raise TooManyRedirects('Exceeded {} redirects.'.format(self.max_redirects), response=resp)
 
             # Release the connection back into the pool.
-            response.close()
+            resp.close()
+
             # Handle redirection without scheme (see: RFC 1808 Section 4)
-            if location_url.startswith('//'):
-                parsed_rurl = urlparse(response.url)
-                location_url = '%s:%s' % (
-                    to_native_string(parsed_rurl.scheme), location_url
-                )
-            # The scheme should be lower case...
-            parsed = urlparse(location_url)
-            location_url = parsed.geturl()
+            if url.startswith('//'):
+                parsed_rurl = urlparse(resp.url)
+                url = ':'.join([to_native_string(parsed_rurl.scheme), url])
+
+            # Normalize url case and attach previous fragment if needed (RFC 7231 7.1.2)
+            parsed = urlparse(url)
+            if parsed.fragment == '' and previous_fragment:
+                parsed = parsed._replace(fragment=previous_fragment)
+            elif parsed.fragment:
+                previous_fragment = parsed.fragment
+            url = parsed.geturl()
+
             # Facilitate relative 'location' headers, as allowed by RFC 7231.
             # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
             # Compliant with RFC3986, we percent encode the url.
             if not parsed.netloc:
-                location_url = urljoin(response.url, requote_uri(location_url))
+                url = urljoin(resp.url, requote_uri(url))
             else:
-                location_url = requote_uri(location_url)
-            prepared_request.url = to_native_string(location_url)
-            method_changed = self.rebuild_method(prepared_request, response)
-            # https://github.com/kennethreitz/requests/issues/2590
-            # If method is changed to GET we need to remove body and associated headers.
-            if method_changed and prepared_request.method == 'GET':
-                # https://github.com/requests/requests/issues/3490
-                purged_headers = (
-                    'Content-Length', 'Content-Type', 'Transfer-Encoding'
-                )
+                url = requote_uri(url)
+
+            prepared_request.url = to_native_string(url)
+
+            self.rebuild_method(prepared_request, resp)
+
+            # https://github.com/psf/requests/issues/1084
+            if resp.status_code not in (codes.temporary_redirect, codes.permanent_redirect):
+                # https://github.com/psf/requests/issues/3490
+                purged_headers = ('Content-Length', 'Content-Type', 'Transfer-Encoding')
                 for header in purged_headers:
                     prepared_request.headers.pop(header, None)
                 prepared_request.body = None
+
             headers = prepared_request.headers
-            try:
-                del headers['Cookie']
-            except KeyError:
-                pass
+            headers.pop('Cookie', None)
+
             # Extract any cookies sent on the response to the cookiejar
             # in the new request. Because we've mutated our copied prepared
             # request, use the old one that we haven't yet touched.
-            extract_cookies_to_jar(
-                prepared_request._cookies, request, response.raw
-            )
+            extract_cookies_to_jar(prepared_request._cookies, req, resp.raw)
             merge_cookies(prepared_request._cookies, self.cookies)
             prepared_request.prepare_cookies(prepared_request._cookies)
+
             # Rebuild auth and proxy information.
             proxies = self.rebuild_proxies(prepared_request, proxies)
-            self.rebuild_auth(prepared_request, response)
+            self.rebuild_auth(prepared_request, resp)
+
             # A failed tell() sets `_body_position` to `object()`. This non-None
             # value ensures `rewindable` will be True, allowing us to raise an
             # UnrewindableBodyError, instead of hanging the connection.
@@ -224,63 +222,60 @@ class SessionRedirectMixin(object):
                 prepared_request._body_position is not None and
                 ('Content-Length' in headers or 'Transfer-Encoding' in headers)
             )
+
             # Attempt to rewind consumed file-like object.
             if rewindable:
                 rewind_body(prepared_request)
-            # Override the original request.
-            request = prepared_request
-            if yield_requests:
-                yield request
 
+            # Override the original request.
+            req = prepared_request
+
+            if yield_requests:
+                yield req
             else:
-                response = self.send(
-                    request,
+
+                resp = self.send(
+                    req,
                     stream=stream,
                     timeout=timeout,
                     verify=verify,
                     cert=cert,
                     proxies=proxies,
                     allow_redirects=False,
-                    **adapter_kwargs,
-                )
-                # copy our history tracker into the response
-                response.history = history[:]
-                # append the new response to the history tracker for the next iteration
-                history.append(response)
-                extract_cookies_to_jar(
-                    self.cookies, prepared_request, response.raw
+                    **adapter_kwargs
                 )
+
+                extract_cookies_to_jar(self.cookies, prepared_request, resp.raw)
+
                 # extract redirect url, if any, for the next loop
-                location_url = self.get_redirect_target(response)
-                yield response
+                url = self.get_redirect_target(resp)
+                yield resp
 
     def rebuild_auth(self, prepared_request, response):
         """When being redirected we may want to strip authentication from the
-        request to avoid leaking credentials. This method intelligently
-        removes
+        request to avoid leaking credentials. This method intelligently removes
         and reapplies authentication where possible to avoid credential loss.
         """
         headers = prepared_request.headers
         url = prepared_request.url
-        if 'Authorization' in headers:
+
+        if 'Authorization' in headers and self.should_strip_auth(response.request.url, url):
             # If we get redirected to a new host, we should strip out any
             # authentication headers.
-            original_parsed = urlparse(response.request.url)
-            redirect_parsed = urlparse(url)
-            if (original_parsed.hostname != redirect_parsed.hostname):
-                del headers['Authorization']
+            del headers['Authorization']
+
         # .netrc might have more auth for us on our new host.
         new_auth = get_netrc_auth(url) if self.trust_env else None
         if new_auth is not None:
             prepared_request.prepare_auth(new_auth)
-        return
+
 
     def rebuild_proxies(self, prepared_request, proxies):
-        """This method re-evaluates the proxy configuration by
-        considering the environment variables. If we are redirected to a
-        URL covered by NO_PROXY, we strip the proxy configuration.
-        Otherwise, we set missing proxy keys for this URL (in case they
-        were stripped by a previous redirect).
+        """This method re-evaluates the proxy configuration by considering the
+        environment variables. If we are redirected to a URL covered by
+        NO_PROXY, we strip the proxy configuration. Otherwise, we set missing
+        proxy keys for this URL (in case they were stripped by a previous
+        redirect).
 
         This method also replaces the Proxy-Authorization header where
         necessary.
@@ -293,46 +288,50 @@ class SessionRedirectMixin(object):
         scheme = urlparse(url).scheme
         new_proxies = proxies.copy()
         no_proxy = proxies.get('no_proxy')
+
         bypass_proxy = should_bypass_proxies(url, no_proxy=no_proxy)
         if self.trust_env and not bypass_proxy:
             environ_proxies = get_environ_proxies(url, no_proxy=no_proxy)
+
             proxy = environ_proxies.get(scheme, environ_proxies.get('all'))
+
             if proxy:
                 new_proxies.setdefault(scheme, proxy)
+
         if 'Proxy-Authorization' in headers:
             del headers['Proxy-Authorization']
+
         try:
             username, password = get_auth_from_url(new_proxies[scheme])
         except KeyError:
             username, password = None, None
+
         if username and password:
-            headers['Proxy-Authorization'] = _basic_auth_str(
-                username, password
-            )
+            headers['Proxy-Authorization'] = _basic_auth_str(username, password)
+
         return new_proxies
 
     def rebuild_method(self, prepared_request, response):
         """When being redirected we may want to change the method of the request
         based on certain specs or browser behavior.
-
-        :rtype bool:
-        :return: boolean expressing if the method changed during rebuild.
         """
-        method = original_method = prepared_request.method
-        # http://tools.ietf.org/html/rfc7231#section-6.4.4
+        method = prepared_request.method
+
+        # https://tools.ietf.org/html/rfc7231#section-6.4.4
         if response.status_code == codes.see_other and method != 'HEAD':
             method = 'GET'
-        # If a POST is responded to with a 301 or 302, turn it into a GET. This has
-        # become a common pattern in browsers and was introduced into later versions
-        # of HTTP RFCs. While some browsers transform other methods to GET, little of
-        # that has been standardized. For that reason, we're using curl as a model
-        # which only supports POST->GET.
-        if response.status_code in (
-            codes.found, codes.moved
-        ) and method == 'POST':
+
+        # Do what the browsers do, despite standards...
+        # First, turn 302s into GETs.
+        if response.status_code == codes.found and method != 'HEAD':
             method = 'GET'
+
+        # Second, if a POST is responded to with a 301, turn it into a GET.
+        # This bizarre behaviour is explained in Issue 1704.
+        if response.status_code == codes.moved and method == 'POST':
+            method = 'GET'
+
         prepared_request.method = method
-        return method != original_method
 
 
 class Session(SessionRedirectMixin):
@@ -344,71 +343,72 @@ class Session(SessionRedirectMixin):
 
       >>> import requests
       >>> s = requests.Session()
-      >>> s.get('http://httpbin.org/get')
+      >>> s.get('https://httpbin.org/get')
       <Response [200]>
 
     Or as a context manager::
 
       >>> with requests.Session() as s:
-      >>>     s.get('http://httpbin.org/get')
+      ...     s.get('https://httpbin.org/get')
       <Response [200]>
     """
-    __slots__ = [
-        'headers',
-        'cookies',
-        'auth',
-        'proxies',
-        'hooks',
-        'params',
-        'verify',
-        'cert',
-        'prefetch',
-        'adapters',
-        'stream',
-        'trust_env',
+
+    __attrs__ = [
+        'headers', 'cookies', 'auth', 'proxies', 'hooks', 'params', 'verify',
+        'cert', 'adapters', 'stream', 'trust_env',
         'max_redirects',
     ]
 
-    __slots__
-
     def __init__(self):
-        # : A case-insensitive dictionary of headers to be sent on each
+
+        #: A case-insensitive dictionary of headers to be sent on each
         #: :class:`Request <Request>` sent from this
         #: :class:`Session <Session>`.
         self.headers = default_headers()
-        # : Default Authentication tuple or object to attach to
+
+        #: Default Authentication tuple or object to attach to
         #: :class:`Request <Request>`.
         self.auth = None
-        # : Dictionary mapping protocol or protocol and host to the URL of the proxy
+
+        #: Dictionary mapping protocol or protocol and host to the URL of the proxy
         #: (e.g. {'http': 'foo.bar:3128', 'http://host.name': 'foo.bar:4012'}) to
         #: be used on each :class:`Request <Request>`.
         self.proxies = {}
-        # : Event-handling hooks.
+
+        #: Event-handling hooks.
         self.hooks = default_hooks()
-        # : Dictionary of querystring data to attach to each
+
+        #: Dictionary of querystring data to attach to each
         #: :class:`Request <Request>`. The dictionary values may be lists for
         #: representing multivalued query parameters.
         self.params = {}
-        # : Stream response content default.
+
+        #: Stream response content default.
         self.stream = False
-        # : SSL Verification default.
+
+        #: SSL Verification default.
         self.verify = True
-        # : SSL client certificate default, if String, path to ssl client
+
+        #: SSL client certificate default, if String, path to ssl client
         #: cert file (.pem). If Tuple, ('cert', 'key') pair.
         self.cert = None
-        # : Maximum number of redirects allowed. If the request exceeds this
+
+        #: Maximum number of redirects allowed. If the request exceeds this
         #: limit, a :class:`TooManyRedirects` exception is raised.
         #: This defaults to requests.models.DEFAULT_REDIRECT_LIMIT, which is
         #: 30.
         self.max_redirects = DEFAULT_REDIRECT_LIMIT
-        # : Trust environment settings for proxy configuration, default
+
+        #: Trust environment settings for proxy configuration, default
         #: authentication and similar.
         self.trust_env = True
-        # : A CookieJar containing all currently outstanding cookies set on this
+
+        #: A CookieJar containing all currently outstanding cookies set on this
         #: session. By default it is a
         #: :class:`RequestsCookieJar <requests.cookies.RequestsCookieJar>`, but
         #: may be any other ``cookielib.CookieJar`` compatible object.
         self.cookies = cookiejar_from_dict({})
+
         # Default connection adapters.
         self.adapters = OrderedDict()
         self.mount('https://', HTTPAdapter())
@@ -427,20 +427,24 @@ class Session(SessionRedirectMixin):
         :class:`Session`.
 
         :param request: :class:`Request` instance to prepare with this
-            Session's settings.
+            session's settings.
         :rtype: requests.PreparedRequest
         """
         cookies = request.cookies or {}
+
         # Bootstrap CookieJar.
         if not isinstance(cookies, cookielib.CookieJar):
             cookies = cookiejar_from_dict(cookies)
+
         # Merge with session cookies
-        session_cookies = _copy_cookie_jar(self.cookies)
-        merged_cookies = merge_cookies(session_cookies, cookies)
+        merged_cookies = merge_cookies(
+            merge_cookies(RequestsCookieJar(), self.cookies), cookies)
+
         # Set environment's basic authentication if not explicitly set.
         auth = request.auth
         if self.trust_env and not auth and not self.auth:
             auth = get_netrc_auth(request.url)
+
         p = PreparedRequest()
         p.prepare(
             method=request.method.upper(),
@@ -448,9 +452,7 @@ class Session(SessionRedirectMixin):
             files=request.files,
             data=request.data,
             json=request.json,
-            headers=merge_setting(
-                request.headers, self.headers, dict_class=CaseInsensitiveDict
-            ),
+            headers=merge_setting(request.headers, self.headers, dict_class=CaseInsensitiveDict),
             params=merge_setting(request.params, self.params),
             auth=merge_setting(auth, self.auth),
             cookies=merged_cookies,
@@ -458,34 +460,19 @@ class Session(SessionRedirectMixin):
         )
         return p
 
-    def request(
-        self,
-        method,
-        url,
-        params=None,
-        data=None,
-        headers=None,
-        cookies=None,
-        files=None,
-        auth=None,
-        timeout=None,
-        allow_redirects=True,
-        proxies=None,
-        hooks=None,
-        stream=None,
-        verify=None,
-        cert=None,
-        json=None,
-    ):
-        """Constructs a :class:`Request <Request>`, prepares it, and sends it.
+    def request(self, method, url,
+            params=None, data=None, headers=None, cookies=None, files=None,
+            auth=None, timeout=None, allow_redirects=True, proxies=None,
+            hooks=None, stream=None, verify=None, cert=None, json=None):
+        """Constructs a :class:`Request <Request>`, prepares it and sends it.
         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, bytes, or file-like object to send
-            in the body of the :class:`Request`.
+        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+            object to send in the body of the :class:`Request`.
         :param json: (optional) json to send in the body of the
             :class:`Request`.
         :param headers: (optional) Dictionary of HTTP Headers to send with the
@@ -527,14 +514,21 @@ class Session(SessionRedirectMixin):
             hooks=hooks,
         )
         prep = self.prepare_request(req)
+
         proxies = proxies or {}
+
         settings = self.merge_environment_settings(
             prep.url, proxies, stream, verify, cert
         )
+
         # Send the request.
-        send_kwargs = {'timeout': timeout, 'allow_redirects': allow_redirects}
+        send_kwargs = {
+            'timeout': timeout,
+            'allow_redirects': allow_redirects,
+        }
         send_kwargs.update(settings)
         resp = self.send(prep, **send_kwargs)
+
         return resp
 
     def get(self, url, **kwargs):
@@ -544,6 +538,7 @@ class Session(SessionRedirectMixin):
         :param \*\*kwargs: Optional arguments that ``request`` takes.
         :rtype: requests.Response
         """
+
         kwargs.setdefault('allow_redirects', True)
         return self.request('GET', url, **kwargs)
 
@@ -554,6 +549,7 @@ class Session(SessionRedirectMixin):
         :param \*\*kwargs: Optional arguments that ``request`` takes.
         :rtype: requests.Response
         """
+
         kwargs.setdefault('allow_redirects', True)
         return self.request('OPTIONS', url, **kwargs)
 
@@ -564,6 +560,7 @@ class Session(SessionRedirectMixin):
         :param \*\*kwargs: Optional arguments that ``request`` takes.
         :rtype: requests.Response
         """
+
         kwargs.setdefault('allow_redirects', False)
         return self.request('HEAD', url, **kwargs)
 
@@ -571,31 +568,37 @@ class Session(SessionRedirectMixin):
         r"""Sends a POST request. Returns :class:`Response` object.
 
         :param url: URL for the new :class:`Request` object.
-        :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`.
+        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+            object to send in the body of the :class:`Request`.
         :param json: (optional) json to send in the body of the :class:`Request`.
         :param \*\*kwargs: Optional arguments that ``request`` takes.
         :rtype: requests.Response
         """
+
         return self.request('POST', url, data=data, json=json, **kwargs)
 
     def put(self, url, data=None, **kwargs):
         r"""Sends a PUT request. Returns :class:`Response` object.
 
         :param url: URL for the new :class:`Request` object.
-        :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`.
+        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+            object to send in the body of the :class:`Request`.
         :param \*\*kwargs: Optional arguments that ``request`` takes.
         :rtype: requests.Response
         """
+
         return self.request('PUT', url, data=data, **kwargs)
 
     def patch(self, url, data=None, **kwargs):
         r"""Sends a PATCH request. Returns :class:`Response` object.
 
         :param url: URL for the new :class:`Request` object.
-        :param data: (optional) Dictionary, bytes, or file-like object to send in the body of the :class:`Request`.
+        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
+            object to send in the body of the :class:`Request`.
         :param \*\*kwargs: Optional arguments that ``request`` takes.
         :rtype: requests.Response
         """
+
         return self.request('PATCH', url, data=data, **kwargs)
 
     def delete(self, url, **kwargs):
@@ -605,6 +608,7 @@ class Session(SessionRedirectMixin):
         :param \*\*kwargs: Optional arguments that ``request`` takes.
         :rtype: requests.Response
         """
+
         return self.request('DELETE', url, **kwargs)
 
     def send(self, request, **kwargs):
@@ -618,52 +622,68 @@ class Session(SessionRedirectMixin):
         kwargs.setdefault('verify', self.verify)
         kwargs.setdefault('cert', self.cert)
         kwargs.setdefault('proxies', self.proxies)
+
         # It's possible that users might accidentally send a Request object.
         # Guard against that specific failure case.
         if isinstance(request, Request):
             raise ValueError('You can only send PreparedRequests.')
 
-        # Set up variables needed for resolve_redirects and dispatching of
-        # hooks
+        # Set up variables needed for resolve_redirects and dispatching of hooks
         allow_redirects = kwargs.pop('allow_redirects', True)
         stream = kwargs.get('stream')
         hooks = request.hooks
+
         # Get the appropriate adapter to use
         adapter = self.get_adapter(url=request.url)
+
         # Start time (approximately) of the request
         start = preferred_clock()
+
         # Send the request
         r = adapter.send(request, **kwargs)
+
         # Total elapsed time of the request (approximately)
         elapsed = preferred_clock() - start
         r.elapsed = timedelta(seconds=elapsed)
-        # Response manipulation hooks.
+
+        # Response manipulation hooks
         r = dispatch_hook('response', hooks, r, **kwargs)
+
         # Persist cookies
         if r.history:
+
             # If the hooks create history then we want those cookies too
             for resp in r.history:
                 extract_cookies_to_jar(self.cookies, resp.request, resp.raw)
+
         extract_cookies_to_jar(self.cookies, request, r.raw)
-        # Redirect resolving generator.
-        gen = self.resolve_redirects(r, request, **kwargs)
-        # Resolve redirects, if allowed.
-        history = [resp for resp in gen] if allow_redirects else []
-        # If there is a history, replace ``r`` with the last response
+
+        # Resolve redirects if allowed.
+        if allow_redirects:
+            # Redirect resolving generator.
+            gen = self.resolve_redirects(r, request, **kwargs)
+            history = [resp for resp in gen]
+        else:
+            history = []
+
+        # Shuffle things around if there's history.
         if history:
+            # Insert the first (original) request at the start
+            history.insert(0, r)
+            # Get the last request made
             r = history.pop()
+            r.history = history
+
         # If redirects aren't being followed, store the response on the Request for Response.next().
         if not allow_redirects:
             try:
-                r._next = next(
-                    self.resolve_redirects(
-                        r, request, yield_requests=True, **kwargs
-                    )
-                )
+                r._next = next(self.resolve_redirects(r, request, yield_requests=True, **kwargs))
             except StopIteration:
                 pass
+
         if not stream:
             r.content
+
         return r
 
     def merge_environment_settings(self, url, proxies, stream, verify, cert):
@@ -672,41 +692,28 @@ class Session(SessionRedirectMixin):
 
         :rtype: dict
         """
-        # Merge all the kwargs except for proxies.
-        stream = merge_setting(stream, self.stream)
-        verify = merge_setting(verify, self.verify)
-        cert = merge_setting(cert, self.cert)
         # Gather clues from the surrounding environment.
-        # We do this after merging the Session values to make sure we don't
-        # accidentally exclude them.
         if self.trust_env:
+            # Set environment's proxies.
+            no_proxy = proxies.get('no_proxy') if proxies is not None else None
+            env_proxies = get_environ_proxies(url, no_proxy=no_proxy)
+            for (k, v) in env_proxies.items():
+                proxies.setdefault(k, v)
+
             # Look for requests environment configuration and be compatible
             # with cURL.
             if verify is True or verify is None:
-                verify = (
-                    os.environ.get('REQUESTS_CA_BUNDLE') or
-                    os.environ.get('CURL_CA_BUNDLE') or
-                    verify
-                )
-        # Now we handle proxies.
-        # Proxies need to be built up backwards. This is because None values
-        # can delete proxy information, which can then be re-added by a more
-        # specific layer. So we begin by getting the environment's proxies,
-        # then add the Session, then add the request.
-        no_proxy = proxies.get('no_proxy') if proxies is not None else None
-        if no_proxy is None:
-            no_proxy = self.proxies.get('no_proxy')
-        env_proxies = {}
-        if self.trust_env:
-            env_proxies = get_environ_proxies(url, no_proxy=no_proxy) or {}
-        new_proxies = merge_setting(self.proxies, env_proxies)
-        proxies = merge_setting(proxies, new_proxies)
-        return {
-            'verify': verify,
-            'proxies': proxies,
-            'stream': stream,
-            'cert': cert,
-        }
+                verify = (os.environ.get('REQUESTS_CA_BUNDLE') or
+                          os.environ.get('CURL_CA_BUNDLE'))
+
+        # Merge all the kwargs.
+        proxies = merge_setting(proxies, self.proxies)
+        stream = merge_setting(stream, self.stream)
+        verify = merge_setting(verify, self.verify)
+        cert = merge_setting(cert, self.cert)
+
+        return {'verify': verify, 'proxies': proxies, 'stream': stream,
+                'cert': cert}
 
     def get_adapter(self, url):
         """
@@ -715,14 +722,15 @@ class Session(SessionRedirectMixin):
         :rtype: requests.adapters.BaseAdapter
         """
         for (prefix, adapter) in self.adapters.items():
-            if url.lower().startswith(prefix):
+
+            if url.lower().startswith(prefix.lower()):
                 return adapter
 
         # Nothing matches :-/
-        raise InvalidScheme("No connection adapters were found for '%s'" % url)
+        raise InvalidSchema("No connection adapters were found for {!r}".format(url))
 
     def close(self):
-        """Closes all adapters and, as such, the Session."""
+        """Closes all adapters and as such the session"""
         for v in self.adapters.values():
             v.close()
 
@@ -733,13 +741,29 @@ class Session(SessionRedirectMixin):
         """
         self.adapters[prefix] = adapter
         keys_to_move = [k for k in self.adapters if len(k) < len(prefix)]
+
         for key in keys_to_move:
             self.adapters[key] = self.adapters.pop(key)
 
     def __getstate__(self):
-        state = {attr: getattr(self, attr, None) for attr in self.__slots__}
+        state = {attr: getattr(self, attr, None) for attr in self.__attrs__}
         return state
 
     def __setstate__(self, state):
         for attr, value in state.items():
             setattr(self, attr, value)
+
+
+def session():
+    """
+    Returns a :class:`Session` for context-management.
+
+    .. deprecated:: 1.0.0
+
+        This method has been deprecated since version 1.0.0 and is only kept for
+        backwards compatibility. New code should use :class:`~requests.sessions.Session`
+        to create a session. This may be removed at a future date.
+
+    :rtype: Session
+    """
+    return Session()

requests/status_codes.py

@@ -1,7 +1,29 @@
 # -*- coding: utf-8 -*-
+
+r"""
+The ``codes`` object defines a mapping from common names for HTTP statuses
+to their numerical codes, accessible either as attributes or as dictionary
+items.
+
+Example::
+
+    >>> import requests
+    >>> requests.codes['temporary_redirect']
+    307
+    >>> requests.codes.teapot
+    418
+    >>> requests.codes['\o/']
+    200
+
+Some codes have multiple names, and both upper- and lower-case versions of
+the names are allowed. For example, ``codes.ok``, ``codes.OK``, and
+``codes.okay`` all correspond to the HTTP status code 200.
+"""
+
 from .structures import LookupDict
 
 _codes = {
+
     # Informational.
     100: ('continue',),
     101: ('switching_protocols',),
@@ -18,6 +40,7 @@ _codes = {
     207: ('multi_status', 'multiple_status', 'multi_stati', 'multiple_stati'),
     208: ('already_reported',),
     226: ('im_used',),
+
     # Redirection.
     300: ('multiple_choices',),
     301: ('moved_permanently', 'moved', '\\o-'),
@@ -27,8 +50,9 @@ _codes = {
     305: ('use_proxy',),
     306: ('switch_proxy',),
     307: ('temporary_redirect', 'temporary_moved', 'temporary'),
-    308: ('permanent_redirect', 'resume_incomplete', 'resume'),
-    # These 2 to be removed in 3.0
+    308: ('permanent_redirect',
+          'resume_incomplete', 'resume',),  # These 2 to be removed in 3.0
+
     # Client Error.
     400: ('bad_request', 'bad'),
     401: ('unauthorized',),
@@ -37,9 +61,7 @@ _codes = {
     404: ('not_found', '-o-'),
     405: ('method_not_allowed', 'not_allowed'),
     406: ('not_acceptable',),
-    407: (
-        'proxy_authentication_required', 'proxy_auth', 'proxy_authentication'
-    ),
+    407: ('proxy_authentication_required', 'proxy_auth', 'proxy_authentication'),
     408: ('request_timeout', 'timeout'),
     409: ('conflict',),
     410: ('gone',),
@@ -48,11 +70,7 @@ _codes = {
     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',
-    ),
+    416: ('requested_range_not_satisfiable', 'requested_range', 'range_not_satisfiable'),
     417: ('expectation_failed',),
     418: ('im_a_teapot', 'teapot', 'i_am_a_teapot'),
     421: ('misdirected_request',),
@@ -69,6 +87,7 @@ _codes = {
     450: ('blocked_by_windows_parental_controls', 'parental_controls'),
     451: ('unavailable_for_legal_reasons', 'legal_reasons'),
     499: ('client_closed_request',),
+
     # Server Error.
     500: ('internal_server_error', 'server_error', '/o\\', '✗'),
     501: ('not_implemented',),
@@ -80,15 +99,25 @@ _codes = {
     507: ('insufficient_storage',),
     509: ('bandwidth_limit_exceeded', 'bandwidth'),
     510: ('not_extended',),
-    511: (
-        'network_authentication_required',
-        'network_auth',
-        'network_authentication',
-    ),
+    511: ('network_authentication_required', 'network_auth', 'network_authentication'),
 }
+
 codes = LookupDict(name='status_codes')
-for code, titles in _codes.items():
-    for title in titles:  # type: ignore
-        setattr(codes, title, code)
-        if not title.startswith(('\\', '/')):
-            setattr(codes, title.upper(), code)
+
+def _init():
+    for code, titles in _codes.items():
+        for title in titles:
+            setattr(codes, title, code)
+            if not title.startswith(('\\', '/')):
+                setattr(codes, title.upper(), code)
+
+    def doc(code):
+        names = ', '.join('``%s``' % n for n in _codes[code])
+        return '* %d: %s' % (code, names)
+
+    global __doc__
+    __doc__ = (__doc__ + '\n' +
+               '\n'.join(doc(code) for code in sorted(_codes))
+               if __doc__ is not None else None)
+
+_init()

requests/structures.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 """
 requests.structures
 ~~~~~~~~~~~~~~~~~~~
@@ -6,16 +7,16 @@ requests.structures
 Data structures that power Requests.
 """
 
-import collections
+from collections import OrderedDict
 
-from .basics import basestring, OrderedDict
+from .compat import Mapping, MutableMapping
 
 
-class CaseInsensitiveDict(collections.MutableMapping):
+class CaseInsensitiveDict(MutableMapping):
     """A case-insensitive ``dict``-like object.
 
     Implements all methods and operations of
-    ``collections.MutableMapping`` as well as dict's ``copy``. Also
+    ``MutableMapping`` as well as dict's ``copy``. Also
     provides ``lower_items``.
 
     All keys are expected to be strings. The structure remembers the
@@ -37,10 +38,9 @@ class CaseInsensitiveDict(collections.MutableMapping):
     operations are given keys that have equal ``.lower()``s, the
     behavior is undefined.
     """
-    __slots__ = ('_store')
 
     def __init__(self, data=None, **kwargs):
-        self._store = collections.OrderedDict()
+        self._store = OrderedDict()
         if data is None:
             data = {}
         self.update(data, **kwargs)
@@ -65,19 +65,19 @@ class CaseInsensitiveDict(collections.MutableMapping):
     def lower_items(self):
         """Like iteritems(), but with all lowercase keys."""
         return (
-            (lowerkey, keyval[1]) for (lowerkey, keyval) in self._store.items()
+            (lowerkey, keyval[1])
+            for (lowerkey, keyval)
+            in self._store.items()
         )
 
     def __eq__(self, other):
-        if isinstance(other, collections.Mapping):
+        if isinstance(other, Mapping):
             other = CaseInsensitiveDict(other)
         else:
             return NotImplemented
-
         # Compare insensitively
         return dict(self.lower_items()) == dict(other.lower_items())
 
-
     # Copy is required
     def copy(self):
         return CaseInsensitiveDict(self._store.values())
@@ -86,128 +86,6 @@ class CaseInsensitiveDict(collections.MutableMapping):
         return str(dict(self.items()))
 
 
-class HTTPHeaderDict(CaseInsensitiveDict):
-    """A case-insensitive ``dict``-like object suitable for HTTP headers that
-    supports multiple values with the same key, via the ``add``, ``extend``,
-    ``multiget`` and ``multiset`` methods.
-    """
-
-    def __init__(self, data=None, **kwargs):
-        super(HTTPHeaderDict, self).__init__()
-        self.extend({} if data is None else data, **kwargs)
-
-
-    # We'll store tuples in the internal dictionary, but present them as a
-    # concatenated string when we use item access methods.
-    #
-    def __setitem__(self, key, val):
-        # Special–case null values.
-        if (not isinstance(val, basestring)) and (val is not None):
-            raise ValueError('only string-type values (or None) are allowed')
-
-        super(HTTPHeaderDict, self).__setitem__(key, (val,))
-
-    def __getitem__(self, key):
-        val = super(HTTPHeaderDict, self).__getitem__(key)
-        # Special–case null values.
-        if len(val) == 1 and val[0] is None:
-            return val[0]
-
-        return ', '.join(val)
-
-    def lower_items(self):
-        return (
-            (lk, ', '.join(vals)) for (lk, (k, vals)) in self._store.items()
-        )
-
-    def copy(self):
-        return type(self)(self)
-
-    def getlist(self, key):
-        """Returns a list of all the values for the named field. Returns an
-        empty list if the key isn't present in the dictionary."""
-        return list(self._store.get(key.lower(), (None, []))[1])
-
-    def setlist(self, key, values):
-        """Set a sequence of strings to the associated key - this will overwrite
-        any previously stored value."""
-        if not isinstance(values, (list, tuple)):
-            raise ValueError('argument is not sequence')
-
-        if any(not isinstance(v, basestring) for v in values):
-            raise ValueError('non-string items in sequence')
-
-        if not values:
-            self.pop(key, None)
-            return
-
-        super(HTTPHeaderDict, self).__setitem__(key, tuple(values))
-
-    def _extend(self, key, values):
-        new_value_tpl = key, values
-        # Inspired by urllib3's implementation - use one call which should be
-        # suitable for the common case.
-        old_value_tpl = self._store.setdefault(key.lower(), new_value_tpl)
-        if old_value_tpl is not new_value_tpl:
-            old_key, old_values = old_value_tpl
-            self._store[key.lower()] = (old_key, old_values + values)
-
-    def add(self, key, val):
-        """Adds a key, value pair to this dictionary - if there is already a
-        value for this key, then the value will be appended to those values.
-        """
-        if not isinstance(val, basestring):
-            raise ValueError('value must be a string-type object')
-
-        self._extend(key, (val,))
-
-    def extend(self, *args, **kwargs):
-        """Like update, but will add values to existing sequences rather than
-        replacing them. You can pass a mapping object or a sequence of two
-        tuples - values in these objects can be strings or sequence of strings.
-        """
-        if len(args) > 1:
-            raise TypeError(
-                f"extend() takes at most 1 positional "
-                "arguments ({len(args)} given)"
-            )
-
-        for other in args + (kwargs,):
-            if isinstance(other, collections.Mapping):
-                # See if looks like a HTTPHeaderDict (either urllib3's
-                # implementation or ours). If so, then we have to add values
-                # in one go for each key.
-                multiget = getattr(other, 'getlist', None)
-                if multiget:
-                    for key in other:
-                        self._extend(key, tuple(multiget(key)))
-                    continue
-
-                # Otherwise, just walk over items to get them.
-                item_seq = other.items()
-            else:
-                item_seq = other
-            for ik, iv in item_seq:
-                if isinstance(iv, basestring):
-                    self._extend(ik, (iv,))
-                elif any(not isinstance(v, basestring) for v in iv):
-                    raise ValueError('non-string items in sequence')
-
-                else:
-                    self._extend(ik, tuple(iv))
-
-    @property
-    def _as_dict(self):
-        """A dictionary representation of the HTTPHeaderDict."""
-        d = {}
-        for k, vals in self._store.values():
-            d[k] = vals[0] if len(vals) == 1 else vals
-        return d
-
-    def __repr__(self):
-        return repr(self._as_dict)
-
-
 class LookupDict(dict):
     """Dictionary lookup object."""
 
@@ -216,14 +94,12 @@ class LookupDict(dict):
         super(LookupDict, self).__init__()
 
     def __repr__(self):
-        return f'<lookup \'{self.name}\'>'
+        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 __iter__(self):
-        return super(LookupDict, self).__dir__()
+        return self.__dict__.get(key, None)
 
     def get(self, key, default=None):
         return self.__dict__.get(key, default)

requests/types.py

@@ -1,72 +0,0 @@
-from typing import (
-    Callable,
-    Optional,
-    Union,
-    Any,
-    Iterable,
-    List,
-    Mapping,
-    MutableMapping,
-    Tuple,
-    IO,
-    Text,
-    Type,
-    Dict,
-)
-
-from .import auth
-from .models import Response, PreparedRequest
-from .cookies import RequestsCookieJar
-from .sessions import Session
-
-_ParamsMappingValueType = Union[
-    str, bytes, int, float, Iterable[Union[str, bytes, int, float]]
-]
-Params = Optional[
-    Union[
-        Mapping[Union[str, bytes, int, float], _ParamsMappingValueType],
-        Union[str, bytes],
-        Tuple[Union[str, bytes, int, float], _ParamsMappingValueType],
-        Mapping[str, _ParamsMappingValueType],
-        Mapping[bytes, _ParamsMappingValueType],
-        Mapping[int, _ParamsMappingValueType],
-        Mapping[float, _ParamsMappingValueType],
-    ]
-]
-Data = Union[
-    None,
-    bytes,
-    MutableMapping[str, str],
-    MutableMapping[str, Text],
-    MutableMapping[Text, str],
-    MutableMapping[Text, Text],
-    Iterable[Tuple[str, str]],
-    IO,
-]
-_Hook = Callable[[Response], Any]
-Method = str
-URL = str
-Headers = Optional[Union[None, MutableMapping[Text, Text]]]
-Cookies = Optional[Union[None, RequestsCookieJar, MutableMapping[Text, Text]]]
-Files = Optional[MutableMapping[Text, IO]]
-Auth = Union[
-    None,
-    Tuple[Text, Text],
-    auth.AuthBase,
-    Callable[[PreparedRequest], PreparedRequest],
-]
-Timeout = Union[None, float, Tuple[float, float]]
-AllowRedirects = Optional[bool]
-Proxies = Optional[MutableMapping[Text, Text]]
-Hooks = Optional[MutableMapping[Text, Union[Iterable[_Hook], _Hook]]]
-Stream = Optional[bool]
-Verify = Union[None, bool, Text]
-Cert = Union[Text, Tuple[Text, Text]]
-JSON = Optional[MutableMapping]
-Help = Dict
-Host = str
-Sequence = List
-Filename = str
-KeyValueList = List[Tuple[Text, Text]]
-String = str
-Boolean = Union[bool, None]

setup.cfg

@@ -1,2 +1,5 @@
 [bdist_wheel]
 universal = 1
+
+[metadata]
+license_file = LICENSE

setup.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 # Learn more: https://github.com/kennethreitz/setup.py
 import os
+import re
 import sys
 
 from codecs import open
@@ -10,27 +11,16 @@ from setuptools.command.test import test as TestCommand
 
 here = os.path.abspath(os.path.dirname(__file__))
 
-
-class Format(TestCommand):
-    user_options = []
-
-    def initialize_options(self):
-        TestCommand.initialize_options(self)
-        pass
-
-    def finalize_options(self):
-        pass
-
-    def run_tests(self):
-        os.system('white requests')
-
-
 class PyTest(TestCommand):
     user_options = [('pytest-args=', 'a', "Arguments to pass into py.test")]
 
     def initialize_options(self):
         TestCommand.initialize_options(self)
-        self.pytest_args = ['-n', 'auto']
+        try:
+            from multiprocessing import cpu_count
+            self.pytest_args = ['-n', str(cpu_count()), '--boxed']
+        except (ImportError, NotImplementedError):
+            self.pytest_args = ['-n', '1', '--boxed']
 
     def finalize_options(self):
         TestCommand.finalize_options(self)
@@ -43,38 +33,20 @@ class PyTest(TestCommand):
         errno = pytest.main(self.pytest_args)
         sys.exit(errno)
 
-
-class MyPyTest(TestCommand):
-    user_options = [('pytest-args=', 'a', "Arguments to pass into py.test")]
-
-    def initialize_options(self):
-        TestCommand.initialize_options(self)
-        self.pytest_args = ['-n', 'auto', '--mypy', 'tests']
-
-    def finalize_options(self):
-        TestCommand.finalize_options(self)
-        self.test_args = []
-        self.test_suite = True
-
-    def run_tests(self):
-        import pytest
-
-        errno = pytest.main(self.pytest_args)
-        sys.exit(errno)
-
-
 # 'setup.py publish' shortcut.
 if sys.argv[-1] == 'publish':
     os.system('python setup.py sdist bdist_wheel')
     os.system('twine upload dist/*')
     sys.exit()
+
 packages = ['requests']
+
 requires = [
-    'chardet>=3.0.2,<3.1.0',
-    'idna>=2.5,<2.7',
-    'urllib3>=1.21.1,<1.23',
-    'certifi>=2017.4.17',
-    'rfc3986>=1.1.0<2',
+    'chardet>=3.0.2,<4',
+    'idna>=2.5,<3',
+    'urllib3>=1.21.1,<1.26,!=1.25.0,!=1.25.1',
+    'certifi>=2017.4.17'
+
 ]
 test_requirements = [
     'pytest-httpbin==0.0.7',
@@ -82,23 +54,24 @@ test_requirements = [
     'pytest-mock',
     'pytest-xdist',
     'PySocks>=1.5.6, !=1.5.7',
-    'pytest>=2.8.0',
-    'pytest-mypy',
-    'mypy',
-    'white',
+    'pytest>=3'
 ]
+
 about = {}
 with open(os.path.join(here, 'requests', '__version__.py'), 'r', 'utf-8') as f:
-    exec (f.read(), about)
-with open('README.rst', 'r', 'utf-8') as f:
+    exec(f.read(), about)
+
+with open('README.md', 'r', 'utf-8') as f:
     readme = f.read()
-with open('HISTORY.rst', 'r', 'utf-8') as f:
+with open('HISTORY.md', 'r', 'utf-8') as f:
     history = f.read()
+
 setup(
     name=about['__title__'],
     version=about['__version__'],
     description=about['__description__'],
-    long_description=readme + '\n\n' + history,
+    long_description=readme,
+    long_description_content_type='text/markdown',
     author=about['__author__'],
     author_email=about['__author_email__'],
     url=about['__url__'],
@@ -106,29 +79,35 @@ setup(
     package_data={'': ['LICENSE', 'NOTICE'], 'requests': ['*.pem']},
     package_dir={'requests': 'requests'},
     include_package_data=True,
+    python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*",
     install_requires=requires,
     license=about['__license__'],
     zip_safe=False,
-    classifiers=(
+    classifiers=[
         'Development Status :: 5 - Production/Stable',
         'Intended Audience :: Developers',
         'Natural Language :: English',
         'License :: OSI Approved :: Apache Software License',
         'Programming Language :: Python',
+        'Programming Language :: Python :: 2',
+        'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.4',
         'Programming Language :: Python :: 3.5',
         'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
         'Programming Language :: Python :: Implementation :: CPython',
-        'Programming Language :: Python :: Implementation :: PyPy',
-    ),
-    cmdclass={'test': PyTest, 'mypy': MyPyTest, 'format': Format},
+        'Programming Language :: Python :: Implementation :: PyPy'
+    ],
+    cmdclass={'test': PyTest},
     tests_require=test_requirements,
     extras_require={
-        'security': ['pyOpenSSL>=0.14', 'cryptography>=1.3.4', 'idna>=2.0.0'],
+        'security': ['pyOpenSSL >= 0.14', 'cryptography>=1.3.4'],
         'socks': ['PySocks>=1.5.6, !=1.5.7'],
-        'socks:sys_platform == "win32" and python_version == "2.7"': [
-            'win_inet_pton'
-        ],
+        'socks:sys_platform == "win32" and python_version == "2.7"': ['win_inet_pton'],
+    },
+    project_urls={
+        'Documentation': 'https://requests.readthedocs.io',
+        'Source': 'https://github.com/psf/requests',
     },
 )

tests/__init__.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 """Requests test package initialisation."""
 
 import warnings

tests/compat.py

@@ -1,6 +1,21 @@
 # -*- coding: utf-8 -*-
-import io as StringIO
+
+from requests.compat import is_py3
 
 
-def u(s):
-    return s
+try:
+    import StringIO
+except ImportError:
+    import io as StringIO
+
+try:
+    from cStringIO import StringIO as cStringIO
+except ImportError:
+    cStringIO = None
+
+if is_py3:
+    def u(s):
+        return s
+else:
+    def u(s):
+        return s.decode('unicode-escape')

tests/conftest.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
+
 import pytest
-from urllib.parse import urljoin
+from requests.compat import urljoin
 
 
 def prepare_url(value):

tests/test_help.py

@@ -1,4 +1,5 @@
 # -*- encoding: utf-8
+
 import sys
 
 import pytest
@@ -6,26 +7,12 @@ import pytest
 from requests.help import info
 
 
-@pytest.mark.skipif(
-    sys.version_info[:2] != (2, 6), reason="Only run on Python 2.6"
-)
-def test_system_ssl_py26():
-    """OPENSSL_VERSION_NUMBER isn't provided in Python 2.6, verify we don't
-    blow up in this case.
-    """
-    assert info()['system_ssl'] == {'version': ''}
-
-
-@pytest.mark.skipif(
-    sys.version_info < (2, 7), reason="Only run on Python 2.7+"
-)
 def test_system_ssl():
     """Verify we're actually setting system_ssl when it should be available."""
     assert info()['system_ssl']['version'] != ''
 
 
 class VersionedPackage(object):
-
     def __init__(self, version):
         self.__version__ = version
 

tests/test_hooks.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 import pytest
 
 from requests import hooks
@@ -9,12 +10,13 @@ def hook(value):
 
 
 @pytest.mark.parametrize(
-    'hooks_list, result', ((hook, 'ata'), ([hook, lambda x: None, hook], 'ta'))
+    'hooks_list, result', (
+        (hook, 'ata'),
+        ([hook, lambda x: None, hook], 'ta'),
+    )
 )
 def test_hooks(hooks_list, result):
-    assert hooks.dispatch_hook(
-        'response', {'response': hooks_list}, 'Data'
-    ) == result
+    assert hooks.dispatch_hook('response', {'response': hooks_list}, 'Data') == result
 
 
 def test_default_hooks():

tests/test_lowlevel.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 import pytest
 import threading
 import requests
@@ -13,54 +14,39 @@ def test_chunked_upload():
     close_server = threading.Event()
     server = Server.basic_response_server(wait_to_close_event=close_server)
     data = iter([b'a', b'b', b'c'])
+
     with server as (host, port):
-        url = 'http://{0}:{1}/'.format(host, port)
+        url = 'http://{}:{}/'.format(host, port)
         r = requests.post(url, data=data, stream=True)
         close_server.set()  # release server block
+
     assert r.status_code == 200
     assert r.request.headers['Transfer-Encoding'] == 'chunked'
 
 
-def test_incorrect_content_length():
-    """Test ConnectionError raised for incomplete responses"""
-    close_server = threading.Event()
-    server = Server.text_response_server(
-        "HTTP/1.1 200 OK\r\n" + "Content-Length: 50\r\n\r\n" + "Hello World."
-    )
-    with server as (host, port):
-        url = 'http://{0}:{1}/'.format(host, port)
-        r = requests.Request('GET', url).prepare()
-        s = requests.Session()
-        with pytest.raises(requests.exceptions.ConnectionError) as e:
-            resp = s.send(r)
-        assert "12 bytes read, 38 more expected" in str(e)
-        close_server.set()  # release server block
-
-
 def test_digestauth_401_count_reset_on_redirect():
     """Ensure we correctly reset num_401_calls after a successful digest auth,
     followed by a 302 redirect to another digest auth prompt.
 
-    See https://github.com/requests/requests/issues/1979.
+    See https://github.com/psf/requests/issues/1979.
     """
-    text_401 = (
-        b'HTTP/1.1 401 UNAUTHORIZED\r\n'
-        b'Content-Length: 0\r\n'
-        b'WWW-Authenticate: Digest nonce="6bf5d6e4da1ce66918800195d6b9130d"'
-        b', opaque="372825293d1c26955496c80ed6426e9e", '
-        b'realm="me@kennethreitz.com", qop=auth\r\n\r\n'
-    )
-    text_302 = (
-        b'HTTP/1.1 302 FOUND\r\n'
-        b'Content-Length: 0\r\n'
-        b'Location: /\r\n\r\n'
-    )
-    text_200 = (b'HTTP/1.1 200 OK\r\n' b'Content-Length: 0\r\n\r\n')
-    expected_digest = (
-        b'Authorization: Digest username="user", '
-        b'realm="me@kennethreitz.com", '
-        b'nonce="6bf5d6e4da1ce66918800195d6b9130d", uri="/"'
-    )
+    text_401 = (b'HTTP/1.1 401 UNAUTHORIZED\r\n'
+                b'Content-Length: 0\r\n'
+                b'WWW-Authenticate: Digest nonce="6bf5d6e4da1ce66918800195d6b9130d"'
+                b', opaque="372825293d1c26955496c80ed6426e9e", '
+                b'realm="me@kennethreitz.com", qop=auth\r\n\r\n')
+
+    text_302 = (b'HTTP/1.1 302 FOUND\r\n'
+                b'Content-Length: 0\r\n'
+                b'Location: /\r\n\r\n')
+
+    text_200 = (b'HTTP/1.1 200 OK\r\n'
+                b'Content-Length: 0\r\n\r\n')
+
+    expected_digest = (b'Authorization: Digest username="user", '
+                       b'realm="me@kennethreitz.com", '
+                       b'nonce="6bf5d6e4da1ce66918800195d6b9130d", uri="/"')
+
     auth = requests.auth.HTTPDigestAuth('user', 'pass')
 
     def digest_response_handler(sock):
@@ -68,25 +54,30 @@ def test_digestauth_401_count_reset_on_redirect():
         request_content = consume_socket_content(sock, timeout=0.5)
         assert request_content.startswith(b"GET / HTTP/1.1")
         sock.send(text_401)
+
         # Verify we receive an Authorization header in response, then redirect.
         request_content = consume_socket_content(sock, timeout=0.5)
         assert expected_digest in request_content
         sock.send(text_302)
+
         # Verify Authorization isn't sent to the redirected host,
         # then send another challenge.
         request_content = consume_socket_content(sock, timeout=0.5)
         assert b'Authorization:' not in request_content
         sock.send(text_401)
+
         # Verify Authorization is sent correctly again, and return 200 OK.
         request_content = consume_socket_content(sock, timeout=0.5)
         assert expected_digest in request_content
         sock.send(text_200)
+
         return request_content
 
     close_server = threading.Event()
     server = Server(digest_response_handler, wait_to_close_event=close_server)
+
     with server as (host, port):
-        url = 'http://{0}:{1}/'.format(host, port)
+        url = 'http://{}:{}/'.format(host, port)
         r = requests.get(url, auth=auth)
         # Verify server succeeded in authenticating.
         assert r.status_code == 200
@@ -102,18 +93,16 @@ def test_digestauth_401_only_sent_once():
     """Ensure we correctly respond to a 401 challenge once, and then
     stop responding if challenged again.
     """
-    text_401 = (
-        b'HTTP/1.1 401 UNAUTHORIZED\r\n'
-        b'Content-Length: 0\r\n'
-        b'WWW-Authenticate: Digest nonce="6bf5d6e4da1ce66918800195d6b9130d"'
-        b', opaque="372825293d1c26955496c80ed6426e9e", '
-        b'realm="me@kennethreitz.com", qop=auth\r\n\r\n'
-    )
-    expected_digest = (
-        b'Authorization: Digest username="user", '
-        b'realm="me@kennethreitz.com", '
-        b'nonce="6bf5d6e4da1ce66918800195d6b9130d", uri="/"'
-    )
+    text_401 = (b'HTTP/1.1 401 UNAUTHORIZED\r\n'
+                b'Content-Length: 0\r\n'
+                b'WWW-Authenticate: Digest nonce="6bf5d6e4da1ce66918800195d6b9130d"'
+                b', opaque="372825293d1c26955496c80ed6426e9e", '
+                b'realm="me@kennethreitz.com", qop=auth\r\n\r\n')
+
+    expected_digest = (b'Authorization: Digest username="user", '
+                       b'realm="me@kennethreitz.com", '
+                       b'nonce="6bf5d6e4da1ce66918800195d6b9130d", uri="/"')
+
     auth = requests.auth.HTTPDigestAuth('user', 'pass')
 
     def digest_failed_response_handler(sock):
@@ -121,22 +110,24 @@ def test_digestauth_401_only_sent_once():
         request_content = consume_socket_content(sock, timeout=0.5)
         assert request_content.startswith(b"GET / HTTP/1.1")
         sock.send(text_401)
+
         # Verify we receive an Authorization header in response, then
         # challenge again.
         request_content = consume_socket_content(sock, timeout=0.5)
         assert expected_digest in request_content
         sock.send(text_401)
+
         # Verify the client didn't respond to second challenge.
         request_content = consume_socket_content(sock, timeout=0.5)
         assert request_content == b''
+
         return request_content
 
     close_server = threading.Event()
-    server = Server(
-        digest_failed_response_handler, wait_to_close_event=close_server
-    )
+    server = Server(digest_failed_response_handler, wait_to_close_event=close_server)
+
     with server as (host, port):
-        url = 'http://{0}:{1}/'.format(host, port)
+        url = 'http://{}:{}/'.format(host, port)
         r = requests.get(url, auth=auth)
         # Verify server didn't authenticate us.
         assert r.status_code == 401
@@ -147,15 +138,14 @@ def test_digestauth_401_only_sent_once():
 def test_digestauth_only_on_4xx():
     """Ensure we only send digestauth on 4xx challenges.
 
-    See https://github.com/requests/requests/issues/3772.
+    See https://github.com/psf/requests/issues/3772.
     """
-    text_200_chal = (
-        b'HTTP/1.1 200 OK\r\n'
-        b'Content-Length: 0\r\n'
-        b'WWW-Authenticate: Digest nonce="6bf5d6e4da1ce66918800195d6b9130d"'
-        b', opaque="372825293d1c26955496c80ed6426e9e", '
-        b'realm="me@kennethreitz.com", qop=auth\r\n\r\n'
-    )
+    text_200_chal = (b'HTTP/1.1 200 OK\r\n'
+                     b'Content-Length: 0\r\n'
+                     b'WWW-Authenticate: Digest nonce="6bf5d6e4da1ce66918800195d6b9130d"'
+                     b', opaque="372825293d1c26955496c80ed6426e9e", '
+                     b'realm="me@kennethreitz.com", qop=auth\r\n\r\n')
+
     auth = requests.auth.HTTPDigestAuth('user', 'pass')
 
     def digest_response_handler(sock):
@@ -163,15 +153,18 @@ def test_digestauth_only_on_4xx():
         request_content = consume_socket_content(sock, timeout=0.5)
         assert request_content.startswith(b"GET / HTTP/1.1")
         sock.send(text_200_chal)
+
         # Verify the client didn't respond with auth.
         request_content = consume_socket_content(sock, timeout=0.5)
         assert request_content == b''
+
         return request_content
 
     close_server = threading.Event()
     server = Server(digest_response_handler, wait_to_close_event=close_server)
+
     with server as (host, port):
-        url = 'http://{0}:{1}/'.format(host, port)
+        url = 'http://{}:{}/'.format(host, port)
         r = requests.get(url, auth=auth)
         # Verify server didn't receive auth from us.
         assert r.status_code == 200
@@ -180,29 +173,34 @@ def test_digestauth_only_on_4xx():
 
 
 _schemes_by_var_prefix = [
-    ('http', ['http']), ('https', ['https']), ('all', ['http', 'https'])
+    ('http', ['http']),
+    ('https', ['https']),
+    ('all', ['http', 'https']),
 ]
+
 _proxy_combos = []
 for prefix, schemes in _schemes_by_var_prefix:
     for scheme in schemes:
-        _proxy_combos.append(("{0}_proxy".format(prefix), scheme))
+        _proxy_combos.append(("{}_proxy".format(prefix), scheme))
+
 _proxy_combos += [(var.upper(), scheme) for var, scheme in _proxy_combos]
 
 
 @pytest.mark.parametrize("var,scheme", _proxy_combos)
 def test_use_proxy_from_environment(httpbin, var, scheme):
-    url = "{0}://httpbin.org".format(scheme)
-    fake_proxy = Server(
-    )  # do nothing with the requests; just close the socket
+    url = "{}://httpbin.org".format(scheme)
+    fake_proxy = Server()  # do nothing with the requests; just close the socket
     with fake_proxy as (host, port):
-        proxy_url = "socks5://{0}:{1}".format(host, port)
+        proxy_url = "socks5://{}:{}".format(host, port)
         kwargs = {var: proxy_url}
         with override_environ(**kwargs):
             # fake proxy's lack of response will cause a ConnectionError
             with pytest.raises(requests.exceptions.ConnectionError):
                 requests.get(url)
+
         # the fake proxy received a request
         assert len(fake_proxy.handler_results) == 1
+
         # it had actual content (not checking for SOCKS protocol for now)
         assert len(fake_proxy.handler_results[0]) > 0
 
@@ -214,7 +212,7 @@ def test_redirect_rfc1808_to_non_ascii_location():
 
     def redirect_resp_handler(sock):
         consume_socket_content(sock, timeout=0.5)
-        location = u'//{0}:{1}/{2}'.format(host, port, path)
+        location = u'//{}:{}/{}'.format(host, port, path)
         sock.send(
             b'HTTP/1.1 301 Moved Permanently\r\n'
             b'Content-Length: 0\r\n'
@@ -226,14 +224,86 @@ def test_redirect_rfc1808_to_non_ascii_location():
 
     close_server = threading.Event()
     server = Server(redirect_resp_handler, wait_to_close_event=close_server)
+
     with server as (host, port):
-        url = u'http://{0}:{1}'.format(host, port)
+        url = u'http://{}:{}'.format(host, port)
         r = requests.get(url=url, allow_redirects=True)
         assert r.status_code == 200
         assert len(r.history) == 1
         assert r.history[0].status_code == 301
-        assert redirect_request[0].startswith(
-            b'GET /' + expected_path + b' HTTP/1.1'
-        )
-        assert r.url == u'{0}/{1}'.format(url, expected_path.decode('ascii'))
+        assert redirect_request[0].startswith(b'GET /' + expected_path + b' HTTP/1.1')
+        assert r.url == u'{}/{}'.format(url, expected_path.decode('ascii'))
+
+        close_server.set()
+
+def test_fragment_not_sent_with_request():
+    """Verify that the fragment portion of a URI isn't sent to the server."""
+    def response_handler(sock):
+        req = consume_socket_content(sock, timeout=0.5)
+        sock.send(
+            b'HTTP/1.1 200 OK\r\n'
+            b'Content-Length: '+bytes(len(req))+b'\r\n'
+            b'\r\n'+req
+        )
+
+    close_server = threading.Event()
+    server = Server(response_handler, wait_to_close_event=close_server)
+
+    with server as (host, port):
+        url = 'http://{}:{}/path/to/thing/#view=edit&token=hunter2'.format(host, port)
+        r = requests.get(url)
+        raw_request = r.content
+
+        assert r.status_code == 200
+        headers, body = raw_request.split(b'\r\n\r\n', 1)
+        status_line, headers = headers.split(b'\r\n', 1)
+
+        assert status_line == b'GET /path/to/thing/ HTTP/1.1'
+        for frag in (b'view', b'edit', b'token', b'hunter2'):
+            assert frag not in headers
+            assert frag not in body
+
+        close_server.set()
+
+def test_fragment_update_on_redirect():
+    """Verify we only append previous fragment if one doesn't exist on new
+    location. If a new fragment is encountered in a Location header, it should
+    be added to all subsequent requests.
+    """
+
+    def response_handler(sock):
+        consume_socket_content(sock, timeout=0.5)
+        sock.send(
+            b'HTTP/1.1 302 FOUND\r\n'
+            b'Content-Length: 0\r\n'
+            b'Location: /get#relevant-section\r\n\r\n'
+        )
+        consume_socket_content(sock, timeout=0.5)
+        sock.send(
+            b'HTTP/1.1 302 FOUND\r\n'
+            b'Content-Length: 0\r\n'
+            b'Location: /final-url/\r\n\r\n'
+        )
+        consume_socket_content(sock, timeout=0.5)
+        sock.send(
+            b'HTTP/1.1 200 OK\r\n\r\n'
+        )
+
+    close_server = threading.Event()
+    server = Server(response_handler, wait_to_close_event=close_server)
+
+    with server as (host, port):
+        url = 'http://{}:{}/path/to/thing/#view=edit&token=hunter2'.format(host, port)
+        r = requests.get(url)
+        raw_request = r.content
+
+        assert r.status_code == 200
+        assert len(r.history) == 2
+        assert r.history[0].request.url == url
+
+        # Verify we haven't overwritten the location with our previous fragment.
+        assert r.history[1].request.url == 'http://{}:{}/get#relevant-section'.format(host, port)
+        # Verify previous fragment is used and not the original.
+        assert r.url == 'http://{}:{}/final-url/#relevant-section'.format(host, port)
+
         close_server.set()

tests/test_packages.py

@@ -0,0 +1,13 @@
+import requests
+
+
+def test_can_access_urllib3_attribute():
+    requests.packages.urllib3
+
+
+def test_can_access_idna_attribute():
+    requests.packages.idna
+
+
+def test_can_access_chardet_attribute():
+    requests.packages.chardet

tests/test_structures.py

@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
+
 import pytest
 
-from requests.structures import CaseInsensitiveDict, LookupDict, HTTPHeaderDict
-from urllib3._collections import HTTPHeaderDict as U3HeaderDict
+from requests.structures import CaseInsensitiveDict, LookupDict
 
 
 class TestCaseInsensitiveDict:
@@ -16,9 +16,7 @@ class TestCaseInsensitiveDict:
     def test_list(self):
         assert list(self.case_insensitive_dict) == ['Accept']
 
-    possible_keys = pytest.mark.parametrize(
-        'key', ('accept', 'ACCEPT', 'aCcEpT', 'Accept')
-    )
+    possible_keys = pytest.mark.parametrize('key', ('accept', 'ACCEPT', 'aCcEpT', 'Accept'))
 
     @possible_keys
     def test_getitem(self, key):
@@ -30,14 +28,10 @@ class TestCaseInsensitiveDict:
         assert key not in self.case_insensitive_dict
 
     def test_lower_items(self):
-        assert list(self.case_insensitive_dict.lower_items()) == [
-            ('accept', 'application/json')
-        ]
+        assert list(self.case_insensitive_dict.lower_items()) == [('accept', 'application/json')]
 
     def test_repr(self):
-        assert repr(
-            self.case_insensitive_dict
-        ) == "{'Accept': 'application/json'}"
+        assert repr(self.case_insensitive_dict) == "{'Accept': 'application/json'}"
 
     def test_copy(self):
         copy = self.case_insensitive_dict.copy()
@@ -45,186 +39,16 @@ class TestCaseInsensitiveDict:
         assert copy == self.case_insensitive_dict
 
     @pytest.mark.parametrize(
-        'other, result',
-        (({'AccePT': 'application/json'}, True), ({}, False), (None, False)),
+        'other, result', (
+            ({'AccePT': 'application/json'}, True),
+            ({}, False),
+            (None, False)
+        )
     )
     def test_instance_equality(self, other, result):
         assert (self.case_insensitive_dict == other) is result
 
 
-class TestHTTPHeaderDictCompatibility(TestCaseInsensitiveDict):
-    """HTTPHeaderDict should be completely compatible with CaseInsensitiveDict
-    when used for headers, so ensure that all the tests for the base class
-    also pass for this one."""
-
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        self.case_insensitive_dict = HTTPHeaderDict()
-        self.case_insensitive_dict['Accept'] = 'application/json'
-
-
-class TestHTTPHeaderDict:
-
-    @pytest.fixture(autouse=True)
-    def setup(self):
-        self.kvs = [
-            ('animal', 'chicken'),
-            ('AnimaL', 'Cow'),
-            ('CAKE', 'Cheese!'),
-            ('Sauce', 'Bread'),
-            ('Sauce', 'Cherry, or Plum Tomato'),
-        ]
-        # HTTPHeaderDict from urllib3.
-        self.u3dict = ud = U3HeaderDict()
-        [ud.add(*tpl) for tpl in self.kvs]
-        # Regular dictionary.
-        self.ddict = dict(self.kvs)
-        self.ddict['Sauce'] = ['Bread!', 'Cherry, or Plum Tomato']
-        # Used by test_extend. All of these "extra" values are mostly
-        # equivalent to each other.
-        self.extra_hd = hd2 = HTTPHeaderDict(ANIMAL=['Dog', 'elephant'])
-        hd2['cake'] = 'Babka'
-        hd2.setlist('sound', ['quiet', 'LOUD'])
-        hd2['CUTLERY'] = 'fork'
-        self.extra_tuple_pairs = tuple_pairs = [
-            ('ANIMAL', 'Dog'),
-            ('Animal', 'elephant'),
-            ('cake', ['Babka']),
-            ('sound', 'quiet'),
-            ('sound', 'LOUD'),
-            ('CUTLERY', 'fork'),
-        ]
-        self.extra_simple_dict = dict(tuple_pairs)
-        self.extra_simple_dict['sound'] = ('quiet', 'LOUD')
-        self.extra_u3 = U3HeaderDict()
-        for k, v in tuple_pairs:
-            if isinstance(v, (tuple, list)):
-                for vi in v:
-                    self.extra_u3.add(k, vi)
-            else:
-                self.extra_u3.add(k, v)
-
-    def test_item_access(self):
-        hd = HTTPHeaderDict(self.kvs)
-        # Test that values are combined.
-        assert hd['Sauce'] == 'Bread, Cherry, or Plum Tomato'
-        assert hd['ANIMAL'] == 'chicken, Cow'
-        # Test we can overwrite values.
-        hd['animal'] = 'Goat!'
-        assert hd['anIMal'] == 'Goat!'
-        # Test deletion works.
-        del hd['sauce']
-        pytest.raises(KeyError, hd.__getitem__, 'sauce')
-        # Only string types allowed.
-        pytest.raises(ValueError, hd.__setitem__, 'cake', ['Cheese', 'sponge'])
-
-    def test_equality(self):
-        hd = HTTPHeaderDict(self.u3dict)
-        assert hd == self.u3dict
-        assert hd == HTTPHeaderDict(hd)
-        # Test that we still work even if we are comparing to a
-        # CaseInsensitiveDict instance.
-        cid = CaseInsensitiveDict(hd)
-        assert hd == cid
-        assert cid == hd
-
-    def test_lower_items(self):
-        hd = HTTPHeaderDict(self.kvs, cutlery='fork')
-        assert list(hd.lower_items()) == [
-            ('animal', 'chicken, Cow'),
-            ('cake', 'Cheese!'),
-            ('sauce', 'Bread, Cherry, or Plum Tomato'),
-            ('cutlery', 'fork'),
-        ]
-
-    def test_copy(self):
-        hd = HTTPHeaderDict(self.u3dict)
-        hd2 = hd.copy()
-        assert hd is not hd2
-        assert hd == hd2
-
-    def test_get_and_set_list(self):
-        hd = HTTPHeaderDict(self.kvs)
-        assert hd.getlist('SAUCE') == ['Bread', 'Cherry, or Plum Tomato']
-        assert hd.getlist('CAKE') == ['Cheese!']
-        assert hd.getlist('DRINK') == []
-        # Needs to be a regular sequence type containing just strings.
-        pytest.raises(ValueError, hd.setlist, 'Drink', 'Water')
-        pytest.raises(ValueError, hd.setlist, 'Drink', ['H', 2, 'O'])
-        # Test multi-setting.
-        hd.setlist('Drink', ['Water', 'Juice'])
-        assert hd.getlist('DRINK') == ['Water', 'Juice']
-        # Setting to an empty sequence should remove the entry.
-        hd.setlist('DRInk', [])
-        pytest.raises(KeyError, hd.__getitem__, 'DrinK')
-        assert hd.getlist('DRiNK') == []
-
-    def test_add(self):
-        hd = HTTPHeaderDict()
-        hd.add('sound', 'quiet')
-        hd.add('SOUND', 'LOUD')
-        assert hd.getlist('Sound') == ['quiet', 'LOUD']
-        # Enforce type-checking in the add method.
-        pytest.raises(ValueError, hd.add, 'Sound', 5)
-
-    @pytest.mark.parametrize(
-        'attr,as_arg,animal_arg_is_ordered',
-        [('extra_hd', True, True), ('extra_tuple_pairs', True, True), ('extra_simple_dict', True, False), ('extra_u3', True, False), ('extra_simple_dict', False, False)],
-        # These types will have the "animal" arguments in our preferred order.
-        # And these types will lose the ordering, so we can't make assertions
-        # about the final order of those values.
-    )
-    def test_extend(self, attr, as_arg, animal_arg_is_ordered):
-        item = getattr(self, attr)
-        # Call extend with the associated values - we should see all of the
-        # merged data in the HTTPHeaderDict instance.
-        extras = {'cutlery': 'knife'}
-        hd = HTTPHeaderDict(self.kvs)
-        if as_arg:
-            hd.extend(item, **extras)
-        else:
-            hd.extend(extras, **item)
-        # Test all the stored values are what we expect.
-        mget = hd.getlist
-        # Depending on the item we merged in, we might be able to make
-        # assumptions what the overall order of the structure is.
-        animal_seq = mget('animal')
-        if animal_arg_is_ordered:
-            assert animal_seq == ['chicken', 'Cow', 'Dog', 'elephant']
-        else:
-            # The existing order in HTTPHeadersDict of the first two values
-            # should be preserved - no guarantees in which order the other
-            # two values are added.
-            assert animal_seq in [
-                ['chicken', 'Cow', 'Dog', 'elephant'],
-                ['chicken', 'Cow', 'elephant', 'Dog'],
-            ]
-        assert mget('cake') == ['Cheese!', 'Babka']
-        assert mget('sound') == ['quiet', 'LOUD']
-        # We don't mandate the order in which these dictionaries are
-        # processed, so it's fine whichever order it is.
-        assert mget('cutlery') in [['fork', 'knife'], ['knife', 'fork']]
-
-    def test_extend_type_checking(self):
-        hd = HTTPHeaderDict()
-        pytest.raises(ValueError, hd.extend, dict(type=['xml', None, 'html']))
-
-    def test_repr(self):
-        hd = HTTPHeaderDict()
-        assert repr(hd) == '{}'
-        hd.add('type', 'xml')
-        assert repr(hd) == "{'type': 'xml'}"
-        hd.add('type', 'html')
-        assert repr(hd) == "{'type': ('xml', 'html')}"
-        # We can't guarantee order once we have more than one key.
-        hd.add('Accept', 'text/html')
-        assert repr(hd) in [
-            "{'type': ('xml', 'html'), 'Accept': 'text/html'}",
-            "{'Accept': 'text/html', 'type': ('xml', 'html')}",
-        ]
-        assert str(hd) == repr(hd)
-
-
 class TestLookupDict:
 
     @pytest.fixture(autouse=True)
@@ -237,7 +61,10 @@ class TestLookupDict:
         assert repr(self.lookup_dict) == "<lookup 'test'>"
 
     get_item_parameters = pytest.mark.parametrize(
-        'key, value', (('bad_gateway', 502), ('not_a_key', None))
+        'key, value', (
+            ('bad_gateway', 502),
+            ('not_a_key', None)
+        )
     )
 
     @get_item_parameters

tests/test_testserver.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 import threading
 import socket
 import time
@@ -33,7 +34,9 @@ class TestTestServer:
         with Server.basic_response_server() as (host, port):
             sock = socket.socket()
             sock.connect((host, port))
+
             sock.close()
+
         with pytest.raises(socket.error):
             new_sock = socket.socket()
             new_sock.connect((host, port))
@@ -41,10 +44,14 @@ class TestTestServer:
     def test_text_response(self):
         """the text_response_server sends the given text"""
         server = Server.text_response_server(
-            "HTTP/1.1 200 OK\r\n" + "Content-Length: 6\r\n" + "\r\nroflol"
+            "HTTP/1.1 200 OK\r\n" +
+            "Content-Length: 6\r\n" +
+            "\r\nroflol"
         )
+
         with server as (host, port):
-            r = requests.get('http://{0}:{1}'.format(host, port))
+            r = requests.get('http://{}:{}'.format(host, port))
+
             assert r.status_code == 200
             assert r.text == u'roflol'
             assert r.headers['Content-Length'] == '6'
@@ -52,7 +59,7 @@ class TestTestServer:
     def test_basic_response(self):
         """the basic response server returns an empty http response"""
         with Server.basic_response_server() as (host, port):
-            r = requests.get('http://{0}:{1}'.format(host, port))
+            r = requests.get('http://{}:{}'.format(host, port))
             assert r.status_code == 200
             assert r.text == u''
             assert r.headers['Content-Length'] == '0'
@@ -60,11 +67,8 @@ class TestTestServer:
     def test_basic_waiting_server(self):
         """the server waits for the block_server event to be set before closing"""
         block_server = threading.Event()
-        with Server.basic_response_server(
-            wait_to_close_event=block_server
-        ) as (
-            host, port
-        ):
+
+        with Server.basic_response_server(wait_to_close_event=block_server) as (host, port):
             sock = socket.socket()
             sock.connect((host, port))
             sock.sendall(b'send something')
@@ -75,60 +79,67 @@ class TestTestServer:
     def test_multiple_requests(self):
         """multiple requests can be served"""
         requests_to_handle = 5
-        server = Server.basic_response_server(
-            requests_to_handle=requests_to_handle
-        )
+
+        server = Server.basic_response_server(requests_to_handle=requests_to_handle)
+
         with server as (host, port):
-            server_url = 'http://{0}:{1}'.format(host, port)
+            server_url = 'http://{}:{}'.format(host, port)
             for _ in range(requests_to_handle):
                 r = requests.get(server_url)
                 assert r.status_code == 200
+
             # the (n+1)th request fails
             with pytest.raises(requests.exceptions.ConnectionError):
                 r = requests.get(server_url)
 
-    @pytest.mark.skip(
-        reason="this fails non-deterministically under pytest-xdist"
-    )
+    @pytest.mark.skip(reason="this fails non-deterministically under pytest-xdist")
     def test_request_recovery(self):
         """can check the requests content"""
         # TODO: figure out why this sometimes fails when using pytest-xdist.
         server = Server.basic_response_server(requests_to_handle=2)
         first_request = b'put your hands up in the air'
         second_request = b'put your hand down in the floor'
+
         with server as address:
             sock1 = socket.socket()
             sock2 = socket.socket()
+
             sock1.connect(address)
             sock1.sendall(first_request)
             sock1.close()
+
             sock2.connect(address)
             sock2.sendall(second_request)
             sock2.close()
+
         assert server.handler_results[0] == first_request
         assert server.handler_results[1] == second_request
 
     def test_requests_after_timeout_are_not_received(self):
         """the basic response handler times out when receiving requests"""
         server = Server.basic_response_server(request_timeout=1)
+
         with server as address:
             sock = socket.socket()
             sock.connect(address)
             time.sleep(1.5)
             sock.sendall(b'hehehe, not received')
             sock.close()
+
         assert server.handler_results[0] == b''
 
     def test_request_recovery_with_bigger_timeout(self):
         """a biggest timeout can be specified"""
         server = Server.basic_response_server(request_timeout=3)
         data = b'bananadine'
+
         with server as address:
             sock = socket.socket()
             sock.connect(address)
             time.sleep(1.5)
             sock.sendall(data)
             sock.close()
+
         assert server.handler_results[0] == data
 
     def test_server_finishes_on_error(self):
@@ -140,16 +151,16 @@ class TestTestServer:
 
         assert len(server.handler_results) == 0
 
+        # if the server thread fails to finish, the test suite will hang
+        # and get killed by the jenkins timeout.
 
-    # if the server thread fails to finish, the test suite will hang
-    # and get killed by the jenkins timeout.
     def test_server_finishes_when_no_connections(self):
         """the server thread exits even if there are no connections"""
         server = Server.basic_response_server()
         with server:
             pass
+
         assert len(server.handler_results) == 0
 
-
-# if the server thread fails to finish, the test suite will hang
-# and get killed by the jenkins timeout.
+        # if the server thread fails to finish, the test suite will hang
+        # and get killed by the jenkins timeout.

tests/test_utils.py

@@ -1,48 +1,41 @@
 # -*- coding: utf-8 -*-
+
 import os
 import copy
+import filecmp
 from io import BytesIO
+import zipfile
+from collections import deque
 
 import pytest
-from requests import basics
+from requests import compat
 from requests.cookies import RequestsCookieJar
 from requests.structures import CaseInsensitiveDict
 from requests.utils import (
-    address_in_network,
-    dotted_netmask,
-    get_auth_from_url,
-    get_encoding_from_headers,
-    get_encodings_from_content,
-    get_environ_proxies,
-    guess_filename,
-    guess_json_utf,
-    is_ipv4_address,
-    is_valid_cidr,
-    iter_slices,
-    parse_dict_header,
-    parse_header_links,
-    prepend_scheme_if_needed,
-    requote_uri,
-    select_proxy,
-    should_bypass_proxies,
-    super_len,
-    to_key_val_list,
-    unquote_header_value,
-    unquote_unreserved,
-    urldefragauth,
-    add_dict_to_cookiejar,
-    set_environ,
-)
+    address_in_network, dotted_netmask, extract_zipped_paths,
+    get_auth_from_url, _parse_content_type_header, get_encoding_from_headers,
+    get_encodings_from_content, get_environ_proxies,
+    guess_filename, guess_json_utf, is_ipv4_address,
+    is_valid_cidr, iter_slices, parse_dict_header,
+    parse_header_links, prepend_scheme_if_needed,
+    requote_uri, select_proxy, should_bypass_proxies, super_len,
+    to_key_val_list, to_native_string,
+    unquote_header_value, unquote_unreserved,
+    urldefragauth, add_dict_to_cookiejar, set_environ)
 from requests._internal_utils import unicode_is_ascii
 
-from .compat import StringIO
+from .compat import StringIO, cStringIO
 
 
 class TestSuperLen:
 
     @pytest.mark.parametrize(
-        'stream, value', ((StringIO.StringIO, 'Test'), (BytesIO, b'Test'))
-    )
+        'stream, value', (
+            (StringIO.StringIO, 'Test'),
+            (BytesIO, b'Test'),
+            pytest.param(cStringIO, 'Test',
+                         marks=pytest.mark.skipif('cStringIO is None')),
+        ))
     def test_io_streams(self, stream, value):
         """Ensures that we properly deal with different kinds of IO streams."""
         assert super_len(stream()) == 0
@@ -57,9 +50,7 @@ class TestSuperLen:
     @pytest.mark.parametrize('error', [IOError, OSError])
     def test_super_len_handles_files_raising_weird_errors_in_tell(self, error):
         """If tell() raises errors, assume the cursor is at position zero."""
-
         class BoomFile(object):
-
             def __len__(self):
                 return 5
 
@@ -71,9 +62,7 @@ class TestSuperLen:
     @pytest.mark.parametrize('error', [IOError, OSError])
     def test_super_len_tell_ioerror(self, error):
         """Ensure that if tell gives an IOError super_len doesn't fail"""
-
         class NoLenBoomFile(object):
-
             def tell(self):
                 raise error()
 
@@ -85,7 +74,11 @@ class TestSuperLen:
     def test_string(self):
         assert super_len('Test') == 4
 
-    @pytest.mark.parametrize('mode, warnings_num', (('r', 1), ('rb', 0)))
+    @pytest.mark.parametrize(
+        'mode, warnings_num', (
+            ('r', 1),
+            ('rb', 0),
+        ))
     def test_file(self, tmpdir, mode, warnings_num, recwarn):
         file_obj = tmpdir.join('test.txt')
         file_obj.write('Test')
@@ -94,14 +87,12 @@ class TestSuperLen:
         assert len(recwarn) == warnings_num
 
     def test_super_len_with__len__(self):
-        foo = [1, 2, 3, 4]
+        foo = [1,2,3,4]
         len_foo = super_len(foo)
         assert len_foo == 4
 
     def test_super_len_with_no__len__(self):
-
         class LenFile(object):
-
             def __init__(self):
                 self.len = 5
 
@@ -127,14 +118,12 @@ class TestSuperLen:
 class TestToKeyValList:
 
     @pytest.mark.parametrize(
-        'value, expected',
-        (
+        'value, expected', (
             ([('key', 'val')], [('key', 'val')]),
-            ((('key', 'val'),), [('key', 'val')]),
+            ((('key', 'val'), ), [('key', 'val')]),
             ({'key': 'val'}, [('key', 'val')]),
-            (None, None),
-        ),
-    )
+            (None, None)
+        ))
     def test_valid(self, value, expected):
         assert to_key_val_list(value) == expected
 
@@ -146,15 +135,13 @@ class TestToKeyValList:
 class TestUnquoteHeaderValue:
 
     @pytest.mark.parametrize(
-        'value, expected',
-        (
+        'value, expected', (
             (None, None),
             ('Test', 'Test'),
             ('"Test"', 'Test'),
             ('"Test\\\\"', 'Test\\'),
             ('"\\\\Comp\\Res"', '\\Comp\\Res'),
-        ),
-    )
+        ))
     def test_valid(self, value, expected):
         assert unquote_header_value(value) == expected
 
@@ -169,57 +156,46 @@ class TestGetEnvironProxies:
 
     @pytest.fixture(autouse=True, params=['no_proxy', 'NO_PROXY'])
     def no_proxy(self, request, monkeypatch):
-        monkeypatch.setenv(
-            request.param,
-            '192.168.0.0/24,127.0.0.1,localhost.localdomain,172.16.1.1',
-        )
+        monkeypatch.setenv(request.param, '192.168.0.0/24,127.0.0.1,localhost.localdomain,172.16.1.1')
 
     @pytest.mark.parametrize(
-        'url',
-        (
+        'url', (
             'http://192.168.0.1:5000/',
             'http://192.168.0.1/',
             'http://172.16.1.1/',
             'http://172.16.1.1:5000/',
             'http://localhost.localdomain:5000/v1.0/',
-        ),
-    )
+        ))
     def test_bypass(self, url):
         assert get_environ_proxies(url, no_proxy=None) == {}
 
     @pytest.mark.parametrize(
-        'url',
-        (
+        'url', (
             'http://192.168.1.1:5000/',
             'http://192.168.1.1/',
             'http://www.requests.com/',
-        ),
-    )
+        ))
     def test_not_bypass(self, url):
         assert get_environ_proxies(url, no_proxy=None) != {}
 
     @pytest.mark.parametrize(
-        'url',
-        (
+        'url', (
             'http://192.168.1.1:5000/',
             'http://192.168.1.1/',
             'http://www.requests.com/',
-        ),
-    )
+        ))
     def test_bypass_no_proxy_keyword(self, url):
         no_proxy = '192.168.1.1,requests.com'
         assert get_environ_proxies(url, no_proxy=no_proxy) == {}
 
     @pytest.mark.parametrize(
-        'url',
-        (
+        'url', (
             'http://192.168.0.1:5000/',
             'http://192.168.0.1/',
             'http://172.16.1.1/',
             'http://172.16.1.1:5000/',
             'http://localhost.localdomain:5000/v1.0/',
-        ),
-    )
+        ))
     def test_not_bypass_no_proxy_keyword(self, url, monkeypatch):
         # This is testing that the 'no_proxy' argument overrides the
         # environment variable 'no_proxy'
@@ -244,15 +220,13 @@ class TestIsValidCIDR:
         assert is_valid_cidr('192.168.1.0/24')
 
     @pytest.mark.parametrize(
-        'value',
-        (
+        'value', (
             '8.8.8.8',
             '192.168.1.0/a',
             '192.168.1.0/128',
             '192.168.1.0/-1',
             '192.168.1.999/24',
-        ),
-    )
+        ))
     def test_invalid(self, value):
         assert not is_valid_cidr(value)
 
@@ -269,15 +243,16 @@ class TestAddressInNetwork:
 class TestGuessFilename:
 
     @pytest.mark.parametrize(
-        'value', (1, type('Fake', (object,), {'name': 1})())
+        'value', (1, type('Fake', (object,), {'name': 1})()),
     )
     def test_guess_filename_invalid(self, value):
         assert guess_filename(value) is None
 
     @pytest.mark.parametrize(
-        'value, expected_type',
-        ((b'value', basics.bytes), (b'value'.decode('utf-8'), basics.str)),
-    )
+        'value, expected_type', (
+            (b'value', compat.bytes),
+            (b'value'.decode('utf-8'), compat.str)
+        ))
     def test_guess_filename_valid(self, value, expected_type):
         obj = type('Fake', (object,), {'name': value})()
         result = guess_filename(obj)
@@ -285,6 +260,32 @@ class TestGuessFilename:
         assert isinstance(result, expected_type)
 
 
+class TestExtractZippedPaths:
+
+    @pytest.mark.parametrize(
+        'path', (
+            '/',
+            __file__,
+            pytest.__file__,
+            '/etc/invalid/location',
+        ))
+    def test_unzipped_paths_unchanged(self, path):
+        assert path == extract_zipped_paths(path)
+
+    def test_zipped_paths_extracted(self, tmpdir):
+        zipped_py = tmpdir.join('test.zip')
+        with zipfile.ZipFile(zipped_py.strpath, 'w') as f:
+            f.write(__file__)
+
+        _, name = os.path.splitdrive(__file__)
+        zipped_path = os.path.join(zipped_py.strpath, name.lstrip(r'\/'))
+        extracted_path = extract_zipped_paths(zipped_path)
+
+        assert extracted_path != zipped_path
+        assert os.path.exists(extracted_path)
+        assert filecmp.cmp(extracted_path, __file__)
+
+
 class TestContentEncodingDetection:
 
     def test_none(self):
@@ -292,13 +293,16 @@ class TestContentEncodingDetection:
         assert not len(encodings)
 
     @pytest.mark.parametrize(
-        'content',
-        ('<meta charset="UTF-8">', '<meta http-equiv="Content-type" content="text/html;charset=UTF-8">', '<meta http-equiv="Content-type" content="text/html;charset=UTF-8" />', '<?xml version="1.0" encoding="UTF-8"?>'),
-        # HTML5 meta charset attribute
-        # HTML4 pragma directive
-        # XHTML 1.x served with text/html MIME type
-        # XHTML 1.x served as XML
-    )
+        'content', (
+            # HTML5 meta charset attribute
+            '<meta charset="UTF-8">',
+            # HTML4 pragma directive
+            '<meta http-equiv="Content-type" content="text/html;charset=UTF-8">',
+            # XHTML 1.x served with text/html MIME type
+            '<meta http-equiv="Content-type" content="text/html;charset=UTF-8" />',
+            # XHTML 1.x served as XML
+            '<?xml version="1.0" encoding="UTF-8"?>',
+        ))
     def test_pragmas(self, content):
         encodings = get_encodings_from_content(content)
         assert len(encodings) == 1
@@ -309,26 +313,17 @@ class TestContentEncodingDetection:
         <?xml version="1.0" encoding="XML"?>
         <meta charset="HTML5">
         <meta http-equiv="Content-type" content="text/html;charset=HTML4" />
-        '''.strip(
-        )
+        '''.strip()
         assert get_encodings_from_content(content) == ['HTML5', 'HTML4', 'XML']
 
 
 class TestGuessJSONUTF:
 
     @pytest.mark.parametrize(
-        'encoding',
-        (
-            'utf-32',
-            'utf-8-sig',
-            'utf-16',
-            'utf-8',
-            'utf-16-be',
-            'utf-16-le',
-            'utf-32-be',
-            'utf-32-le',
-        ),
-    )
+        'encoding', (
+            'utf-32', 'utf-8-sig', 'utf-16', 'utf-8', 'utf-16-be', 'utf-16-le',
+            'utf-32-be', 'utf-32-le'
+        ))
     def test_encoded(self, encoding):
         data = '{}'.encode(encoding)
         assert guess_json_utf(data) == encoding
@@ -337,154 +332,216 @@ class TestGuessJSONUTF:
         assert guess_json_utf(b'\x00\x00\x00\x00') is None
 
     @pytest.mark.parametrize(
-        ('encoding', 'expected'),
-        (
+        ('encoding', 'expected'), (
             ('utf-16-be', 'utf-16'),
             ('utf-16-le', 'utf-16'),
             ('utf-32-be', 'utf-32'),
-            ('utf-32-le', 'utf-32'),
-        ),
-    )
+            ('utf-32-le', 'utf-32')
+        ))
     def test_guess_by_bom(self, encoding, expected):
         data = u'\ufeff{}'.encode(encoding)
         assert guess_json_utf(data) == expected
 
 
 USER = PASSWORD = "%!*'();:@&=+$,/?#[] "
-ENCODED_USER = basics.quote(USER, '')
-ENCODED_PASSWORD = basics.quote(PASSWORD, '')
+ENCODED_USER = compat.quote(USER, '')
+ENCODED_PASSWORD = compat.quote(PASSWORD, '')
 
 
 @pytest.mark.parametrize(
-    'url, auth',
-    (
+    'url, auth', (
         (
-            'http://' +
-            ENCODED_USER +
-            ':' +
-            ENCODED_PASSWORD +
-            '@' +
+            'http://' + ENCODED_USER + ':' + ENCODED_PASSWORD + '@' +
             'request.com/url.html#test',
-            (USER, PASSWORD),
+            (USER, PASSWORD)
+        ),
+        (
+            'http://user:pass@complex.url.com/path?query=yes',
+            ('user', 'pass')
         ),
-        ('http://user:pass@complex.url.com/path?query=yes', ('user', 'pass')),
         (
             'http://user:pass%20pass@complex.url.com/path?query=yes',
-            ('user', 'pass pass'),
+            ('user', 'pass pass')
         ),
         (
             'http://user:pass pass@complex.url.com/path?query=yes',
-            ('user', 'pass pass'),
+            ('user', 'pass pass')
         ),
         (
             'http://user%25user:pass@complex.url.com/path?query=yes',
-            ('user%user', 'pass'),
+            ('user%user', 'pass')
         ),
         (
             'http://user:pass%23pass@complex.url.com/path?query=yes',
-            ('user', 'pass#pass'),
+            ('user', 'pass#pass')
         ),
-        ('http://complex.url.com/path?query=yes', ('', '')),
-    ),
-)
+        (
+            'http://complex.url.com/path?query=yes',
+            ('', '')
+        ),
+    ))
 def test_get_auth_from_url(url, auth):
     assert get_auth_from_url(url) == auth
 
 
 @pytest.mark.parametrize(
-    'uri, expected',
-    (('http://example.com/fiz?buz=%25ppicture', 'http://example.com/fiz?buz=%25ppicture'), ('http://example.com/fiz?buz=%ppicture', 'http://example.com/fiz?buz=%25ppicture')),
-    # Ensure requoting doesn't break expectations
-    # Ensure we handle unquoted percent signs in redirects
-)
+    'uri, expected', (
+        (
+            # Ensure requoting doesn't break expectations
+            'http://example.com/fiz?buz=%25ppicture',
+            'http://example.com/fiz?buz=%25ppicture',
+        ),
+        (
+            # Ensure we handle unquoted percent signs in redirects
+            'http://example.com/fiz?buz=%ppicture',
+            'http://example.com/fiz?buz=%25ppicture',
+        ),
+    ))
 def test_requote_uri_with_unquoted_percents(uri, expected):
-    """See: https://github.com/requests/requests/issues/2356"""
+    """See: https://github.com/psf/requests/issues/2356"""
     assert requote_uri(uri) == expected
 
 
 @pytest.mark.parametrize(
-    'uri, expected',
-    (('http://example.com/?a=%--', 'http://example.com/?a=%--'), ('http://example.com/?a=%300', 'http://example.com/?a=00')),
-    # Illegal bytes
-    # Reserved characters
-)
+    'uri, expected', (
+        (
+            # Illegal bytes
+            'http://example.com/?a=%--',
+            'http://example.com/?a=%--',
+        ),
+        (
+            # Reserved characters
+            'http://example.com/?a=%300',
+            'http://example.com/?a=00',
+        )
+    ))
 def test_unquote_unreserved(uri, expected):
     assert unquote_unreserved(uri) == expected
 
 
 @pytest.mark.parametrize(
-    'mask, expected',
-    ((8, '255.0.0.0'), (24, '255.255.255.0'), (25, '255.255.255.128')),
-)
+    'mask, expected', (
+        (8, '255.0.0.0'),
+        (24, '255.255.255.0'),
+        (25, '255.255.255.128'),
+    ))
 def test_dotted_netmask(mask, expected):
     assert dotted_netmask(mask) == expected
 
 
-http_proxies = {
-    'http': 'http://http.proxy', 'http://some.host': 'http://some.host.proxy'
-}
-all_proxies = {
-    'all': 'socks5://http.proxy', 'all://some.host': 'socks5://some.host.proxy'
-}
-mixed_proxies = {
-    'http': 'http://http.proxy',
-    'http://some.host': 'http://some.host.proxy',
-    'all': 'socks5://http.proxy',
-}
-
-
+http_proxies = {'http': 'http://http.proxy',
+                'http://some.host': 'http://some.host.proxy'}
+all_proxies = {'all': 'socks5://http.proxy',
+               'all://some.host': 'socks5://some.host.proxy'}
+mixed_proxies = {'http': 'http://http.proxy',
+                 'http://some.host': 'http://some.host.proxy',
+                 'all': 'socks5://http.proxy'}
 @pytest.mark.parametrize(
-    'url, expected, proxies',
-    (('hTTp://u:p@Some.Host/path', 'http://some.host.proxy', http_proxies), ('hTTp://u:p@Other.Host/path', 'http://http.proxy', http_proxies), ('hTTp:///path', 'http://http.proxy', http_proxies), ('hTTps://Other.Host', None, http_proxies), ('file:///etc/motd', None, http_proxies), ('hTTp://u:p@Some.Host/path', 'socks5://some.host.proxy', all_proxies), ('hTTp://u:p@Other.Host/path', 'socks5://http.proxy', all_proxies), ('hTTp:///path', 'socks5://http.proxy', all_proxies), ('hTTps://Other.Host', 'socks5://http.proxy', all_proxies), ('http://u:p@other.host/path', 'http://http.proxy', mixed_proxies), ('http://u:p@some.host/path', 'http://some.host.proxy', mixed_proxies), ('https://u:p@other.host/path', 'socks5://http.proxy', mixed_proxies), ('https://u:p@some.host/path', 'socks5://http.proxy', mixed_proxies), ('https://', 'socks5://http.proxy', mixed_proxies), ('file:///etc/motd', 'socks5://http.proxy', all_proxies)),
-    # XXX: unsure whether this is reasonable behavior
-)
+    'url, expected, proxies', (
+        ('hTTp://u:p@Some.Host/path', 'http://some.host.proxy', http_proxies),
+        ('hTTp://u:p@Other.Host/path', 'http://http.proxy', http_proxies),
+        ('hTTp:///path', 'http://http.proxy', http_proxies),
+        ('hTTps://Other.Host', None, http_proxies),
+        ('file:///etc/motd', None, http_proxies),
+
+        ('hTTp://u:p@Some.Host/path', 'socks5://some.host.proxy', all_proxies),
+        ('hTTp://u:p@Other.Host/path', 'socks5://http.proxy', all_proxies),
+        ('hTTp:///path', 'socks5://http.proxy', all_proxies),
+        ('hTTps://Other.Host', 'socks5://http.proxy', all_proxies),
+
+        ('http://u:p@other.host/path', 'http://http.proxy', mixed_proxies),
+        ('http://u:p@some.host/path', 'http://some.host.proxy', mixed_proxies),
+        ('https://u:p@other.host/path', 'socks5://http.proxy', mixed_proxies),
+        ('https://u:p@some.host/path', 'socks5://http.proxy', mixed_proxies),
+        ('https://', 'socks5://http.proxy', mixed_proxies),
+        # XXX: unsure whether this is reasonable behavior
+        ('file:///etc/motd', 'socks5://http.proxy', all_proxies),
+    ))
 def test_select_proxies(url, expected, proxies):
     """Make sure we can select per-host proxies correctly."""
     assert select_proxy(url, proxies) == expected
 
 
 @pytest.mark.parametrize(
-    'value, expected',
-    (
-        (
-            'foo="is a fish", bar="as well"',
-            {'foo': 'is a fish', 'bar': 'as well'},
-        ),
-        ('key_without_value', {'key_without_value': None}),
-    ),
-)
+    'value, expected', (
+        ('foo="is a fish", bar="as well"', {'foo': 'is a fish', 'bar': 'as well'}),
+        ('key_without_value', {'key_without_value': None})
+    ))
 def test_parse_dict_header(value, expected):
     assert parse_dict_header(value) == expected
 
 
 @pytest.mark.parametrize(
-    'value, expected',
-    (
-        (CaseInsensitiveDict(), None),
+    'value, expected', (
         (
-            CaseInsensitiveDict(
-                {'content-type': 'application/json; charset=utf-8'}
-            ),
-            'utf-8',
+            'application/xml',
+            ('application/xml', {})
         ),
-        (CaseInsensitiveDict({'content-type': 'text/plain'}), 'ISO-8859-1'),
-    ),
-)
+        (
+            'application/json ; charset=utf-8',
+            ('application/json', {'charset': 'utf-8'})
+        ),
+        (
+            'application/json ; Charset=utf-8',
+            ('application/json', {'charset': 'utf-8'})
+        ),
+        (
+            'text/plain',
+            ('text/plain', {})
+        ),
+        (
+            'multipart/form-data; boundary = something ; boundary2=\'something_else\' ; no_equals ',
+            ('multipart/form-data', {'boundary': 'something', 'boundary2': 'something_else', 'no_equals': True})
+        ),
+        (
+                'multipart/form-data; boundary = something ; boundary2="something_else" ; no_equals ',
+                ('multipart/form-data', {'boundary': 'something', 'boundary2': 'something_else', 'no_equals': True})
+        ),
+        (
+            'multipart/form-data; boundary = something ; \'boundary2=something_else\' ; no_equals ',
+            ('multipart/form-data', {'boundary': 'something', 'boundary2': 'something_else', 'no_equals': True})
+        ),
+        (
+            'multipart/form-data; boundary = something ; "boundary2=something_else" ; no_equals ',
+            ('multipart/form-data', {'boundary': 'something', 'boundary2': 'something_else', 'no_equals': True})
+        ),
+        (
+            'application/json ; ; ',
+            ('application/json', {})
+        )
+    ))
+def test__parse_content_type_header(value, expected):
+    assert _parse_content_type_header(value) == expected
+
+
+@pytest.mark.parametrize(
+    'value, expected', (
+        (
+            CaseInsensitiveDict(),
+            None
+        ),
+        (
+            CaseInsensitiveDict({'content-type': 'application/json; charset=utf-8'}),
+            'utf-8'
+        ),
+        (
+            CaseInsensitiveDict({'content-type': 'text/plain'}),
+            'ISO-8859-1'
+        ),
+    ))
 def test_get_encoding_from_headers(value, expected):
     assert get_encoding_from_headers(value) == expected
 
 
 @pytest.mark.parametrize(
-    'value, length',
-    (
+    'value, length', (
         ('', 0),
         ('T', 1),
         ('Test', 4),
         ('Cont', 0),
         ('Other', -5),
         ('Content', None),
-    ),
-)
+    ))
 def test_iter_slices(value, length):
     if length is None or (length <= 0 and len(value) > 0):
         # Reads all content at once
@@ -494,124 +551,149 @@ def test_iter_slices(value, length):
 
 
 @pytest.mark.parametrize(
-    'value, expected',
-    (
+    'value, expected', (
         (
             '<http:/.../front.jpeg>; rel=front; type="image/jpeg"',
-            [
-                {
-                    'url': 'http:/.../front.jpeg',
-                    'rel': 'front',
-                    'type': 'image/jpeg',
-                }
-            ],
+            [{'url': 'http:/.../front.jpeg', 'rel': 'front', 'type': 'image/jpeg'}]
+        ),
+        (
+            '<http:/.../front.jpeg>',
+            [{'url': 'http:/.../front.jpeg'}]
+        ),
+        (
+            '<http:/.../front.jpeg>;',
+            [{'url': 'http:/.../front.jpeg'}]
         ),
-        ('<http:/.../front.jpeg>', [{'url': 'http:/.../front.jpeg'}]),
-        ('<http:/.../front.jpeg>;', [{'url': 'http:/.../front.jpeg'}]),
         (
             '<http:/.../front.jpeg>; type="image/jpeg",<http://.../back.jpeg>;',
             [
                 {'url': 'http:/.../front.jpeg', 'type': 'image/jpeg'},
-                {'url': 'http://.../back.jpeg'},
-            ],
+                {'url': 'http://.../back.jpeg'}
+            ]
         ),
-        ('', []),
-    ),
-)
+        (
+            '',
+            []
+        ),
+    ))
 def test_parse_header_links(value, expected):
     assert parse_header_links(value) == expected
 
 
 @pytest.mark.parametrize(
-    'value, expected',
-    (
+    'value, expected', (
         ('example.com/path', 'http://example.com/path'),
         ('//example.com/path', 'http://example.com/path'),
-    ),
-)
+    ))
 def test_prepend_scheme_if_needed(value, expected):
     assert prepend_scheme_if_needed(value, 'http') == expected
 
 
 @pytest.mark.parametrize(
-    'url, expected',
-    (
-        (
-            'http://u:p@example.com/path?a=1#test',
-            'http://example.com/path?a=1',
-        ),
+    'value, expected', (
+        ('T', 'T'),
+        (b'T', 'T'),
+        (u'T', 'T'),
+    ))
+def test_to_native_string(value, expected):
+    assert to_native_string(value) == expected
+
+
+@pytest.mark.parametrize(
+    'url, expected', (
+        ('http://u:p@example.com/path?a=1#test', 'http://example.com/path?a=1'),
         ('http://example.com/path', 'http://example.com/path'),
         ('//u:p@example.com/path', '//example.com/path'),
         ('//example.com/path', '//example.com/path'),
         ('example.com/path', '//example.com/path'),
         ('scheme:u:p@example.com/path', 'scheme://example.com/path'),
-    ),
-)
+    ))
 def test_urldefragauth(url, expected):
     assert urldefragauth(url) == expected
 
 
 @pytest.mark.parametrize(
-    'url, expected',
-    (
-        ('http://192.168.0.1:5000/', True),
-        ('http://192.168.0.1/', True),
-        ('http://172.16.1.1/', True),
-        ('http://172.16.1.1:5000/', True),
-        ('http://localhost.localdomain:5000/v1.0/', True),
-        ('http://172.16.1.12/', False),
-        ('http://172.16.1.12:5000/', False),
-        ('http://google.com:5000/v1.0/', False),
-    ),
-)
+    'url, expected', (
+            ('http://192.168.0.1:5000/', True),
+            ('http://192.168.0.1/', True),
+            ('http://172.16.1.1/', True),
+            ('http://172.16.1.1:5000/', True),
+            ('http://localhost.localdomain:5000/v1.0/', True),
+            ('http://google.com:6000/', True),
+            ('http://172.16.1.12/', False),
+            ('http://172.16.1.12:5000/', False),
+            ('http://google.com:5000/v1.0/', False),
+            ('file:///some/path/on/disk', True),
+    ))
 def test_should_bypass_proxies(url, expected, monkeypatch):
     """Tests for function should_bypass_proxies to check if proxy
     can be bypassed or not
     """
-    monkeypatch.setenv(
-        'no_proxy', '192.168.0.0/24,127.0.0.1,localhost.localdomain,172.16.1.1'
-    )
-    monkeypatch.setenv(
-        'NO_PROXY', '192.168.0.0/24,127.0.0.1,localhost.localdomain,172.16.1.1'
-    )
+    monkeypatch.setenv('no_proxy', '192.168.0.0/24,127.0.0.1,localhost.localdomain,172.16.1.1, google.com:6000')
+    monkeypatch.setenv('NO_PROXY', '192.168.0.0/24,127.0.0.1,localhost.localdomain,172.16.1.1, google.com:6000')
     assert should_bypass_proxies(url, no_proxy=None) == expected
 
 
 @pytest.mark.parametrize(
-    'cookiejar', (basics.cookielib.CookieJar(), RequestsCookieJar())
-)
+    'url, expected', (
+            ('http://172.16.1.1/', '172.16.1.1'),
+            ('http://172.16.1.1:5000/', '172.16.1.1'),
+            ('http://user:pass@172.16.1.1', '172.16.1.1'),
+            ('http://user:pass@172.16.1.1:5000', '172.16.1.1'),
+            ('http://hostname/', 'hostname'),
+            ('http://hostname:5000/', 'hostname'),
+            ('http://user:pass@hostname', 'hostname'),
+            ('http://user:pass@hostname:5000', 'hostname'),
+    ))
+def test_should_bypass_proxies_pass_only_hostname(url, expected, mocker):
+    """The proxy_bypass function should be called with a hostname or IP without
+    a port number or auth credentials.
+    """
+    proxy_bypass = mocker.patch('requests.utils.proxy_bypass')
+    should_bypass_proxies(url, no_proxy=None)
+    proxy_bypass.assert_called_once_with(expected)
+
+
+@pytest.mark.parametrize(
+    'cookiejar', (
+        compat.cookielib.CookieJar(),
+        RequestsCookieJar()
+    ))
 def test_add_dict_to_cookiejar(cookiejar):
     """Ensure add_dict_to_cookiejar works for
     non-RequestsCookieJar CookieJars
     """
-    cookiedict = {'test': 'cookies', 'good': 'cookies'}
+    cookiedict = {'test': 'cookies',
+                  'good': 'cookies'}
     cj = add_dict_to_cookiejar(cookiejar, cookiedict)
     cookies = {cookie.name: cookie.value for cookie in cj}
     assert cookiedict == cookies
 
 
 @pytest.mark.parametrize(
-    'value, expected',
-    ((u'test', True), (u'æíöû', False), (u'ジェーピーニック', False)),
+    'value, expected', (
+                (u'test', True),
+                (u'æíöû', False),
+                (u'ジェーピーニック', False),
+    )
 )
 def test_unicode_is_ascii(value, expected):
     assert unicode_is_ascii(value) is expected
 
 
 @pytest.mark.parametrize(
-    'url, expected',
-    (
-        ('http://192.168.0.1:5000/', True),
-        ('http://192.168.0.1/', True),
-        ('http://172.16.1.1/', True),
-        ('http://172.16.1.1:5000/', True),
-        ('http://localhost.localdomain:5000/v1.0/', True),
-        ('http://172.16.1.12/', False),
-        ('http://172.16.1.12:5000/', False),
-        ('http://google.com:5000/v1.0/', False),
-    ),
-)
-def test_should_bypass_proxies_no_proxy(url, expected, monkeypatch):
+    'url, expected', (
+            ('http://192.168.0.1:5000/', True),
+            ('http://192.168.0.1/', True),
+            ('http://172.16.1.1/', True),
+            ('http://172.16.1.1:5000/', True),
+            ('http://localhost.localdomain:5000/v1.0/', True),
+            ('http://172.16.1.12/', False),
+            ('http://172.16.1.12:5000/', False),
+            ('http://google.com:5000/v1.0/', False),
+    ))
+def test_should_bypass_proxies_no_proxy(
+        url, expected, monkeypatch):
     """Tests for function should_bypass_proxies to check if proxy
     can be bypassed or not using the 'no_proxy' argument
     """
@@ -622,37 +704,36 @@ def test_should_bypass_proxies_no_proxy(url, expected, monkeypatch):
 
 @pytest.mark.skipif(os.name != 'nt', reason='Test only on Windows')
 @pytest.mark.parametrize(
-    'url, expected, override',
-    (
-        ('http://192.168.0.1:5000/', True, None),
-        ('http://192.168.0.1/', True, None),
-        ('http://172.16.1.1/', True, None),
-        ('http://172.16.1.1:5000/', True, None),
-        ('http://localhost.localdomain:5000/v1.0/', True, None),
-        ('http://172.16.1.22/', False, None),
-        ('http://172.16.1.22:5000/', False, None),
-        ('http://google.com:5000/v1.0/', False, None),
-        ('http://mylocalhostname:5000/v1.0/', True, '<local>'),
-        ('http://192.168.0.1/', False, ''),
-    ),
-)
-def test_should_bypass_proxies_win_registry(
-    url, expected, override, monkeypatch
-):
+    'url, expected, override', (
+            ('http://192.168.0.1:5000/', True, None),
+            ('http://192.168.0.1/', True, None),
+            ('http://172.16.1.1/', True, None),
+            ('http://172.16.1.1:5000/', True, None),
+            ('http://localhost.localdomain:5000/v1.0/', True, None),
+            ('http://172.16.1.22/', False, None),
+            ('http://172.16.1.22:5000/', False, None),
+            ('http://google.com:5000/v1.0/', False, None),
+            ('http://mylocalhostname:5000/v1.0/', True, '<local>'),
+            ('http://192.168.0.1/', False, ''),
+    ))
+def test_should_bypass_proxies_win_registry(url, expected, override,
+                                            monkeypatch):
     """Tests for function should_bypass_proxies to check if proxy
     can be bypassed or not with Windows registry settings
     """
     if override is None:
         override = '192.168.*;127.0.0.1;localhost.localdomain;172.16.1.1'
-
-    import winreg
+    if compat.is_py3:
+        import winreg
+    else:
+        import _winreg as winreg
 
     class RegHandle:
-
         def Close(self):
             pass
 
     ie_settings = RegHandle()
+    proxyEnableValues = deque([1, "1"])
 
     def OpenKey(key, subkey):
         return ie_settings
@@ -660,8 +741,9 @@ def test_should_bypass_proxies_win_registry(
     def QueryValueEx(key, value_name):
         if key is ie_settings:
             if value_name == 'ProxyEnable':
-                return [1]
-
+                # this could be a string (REG_SZ) or a 32-bit number (REG_DWORD)
+                proxyEnableValues.rotate()
+                return [proxyEnableValues[0]]
             elif value_name == 'ProxyOverride':
                 return [override]
 
@@ -672,22 +754,22 @@ def test_should_bypass_proxies_win_registry(
     monkeypatch.setenv('NO_PROXY', '')
     monkeypatch.setattr(winreg, 'OpenKey', OpenKey)
     monkeypatch.setattr(winreg, 'QueryValueEx', QueryValueEx)
+    assert should_bypass_proxies(url, None) == expected
 
 
 @pytest.mark.parametrize(
-    'env_name, value',
-    (
-        ('no_proxy', '192.168.0.0/24,127.0.0.1,localhost.localdomain'),
-        ('no_proxy', None),
-        ('a_new_key', '192.168.0.0/24,127.0.0.1,localhost.localdomain'),
-        ('a_new_key', None),
-    ),
-)
+    'env_name, value', (
+            ('no_proxy', '192.168.0.0/24,127.0.0.1,localhost.localdomain'),
+            ('no_proxy', None),
+            ('a_new_key', '192.168.0.0/24,127.0.0.1,localhost.localdomain'),
+            ('a_new_key', None),
+    ))
 def test_set_environ(env_name, value):
     """Tests set_environ will set environ values and will restore the environ."""
     environ_copy = copy.deepcopy(os.environ)
     with set_environ(env_name, value):
         assert os.environ.get(env_name) == value
+
     assert os.environ == environ_copy
 
 

tests/testserver/server.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 import threading
 import socket
 import select
@@ -7,6 +8,7 @@ import select
 def consume_socket_content(sock, timeout=0.5):
     chunks = 65536
     content = b''
+
     while True:
         more_to_read = select.select([sock], [], [], timeout)[0]
         if not more_to_read:
@@ -17,6 +19,7 @@ def consume_socket_content(sock, timeout=0.5):
             break
 
         content += new_content
+
     return content
 
 
@@ -24,40 +27,37 @@ class Server(threading.Thread):
     """Dummy server using for unit testing"""
     WAIT_EVENT_TIMEOUT = 5
 
-    def __init__(
-        self,
-        handler=None,
-        host='localhost',
-        port=0,
-        requests_to_handle=1,
-        wait_to_close_event=None,
-    ):
+    def __init__(self, handler=None, host='localhost', port=0, requests_to_handle=1, wait_to_close_event=None):
         super(Server, self).__init__()
+
         self.handler = handler or consume_socket_content
         self.handler_results = []
+
         self.host = host
         self.port = port
         self.requests_to_handle = requests_to_handle
+
         self.wait_to_close_event = wait_to_close_event
         self.ready_event = threading.Event()
         self.stop_event = threading.Event()
 
     @classmethod
     def text_response_server(cls, text, request_timeout=0.5, **kwargs):
-
         def text_response_handler(sock):
-            request_content = consume_socket_content(
-                sock, timeout=request_timeout
-            )
+            request_content = consume_socket_content(sock, timeout=request_timeout)
             sock.send(text.encode('utf-8'))
+
             return request_content
 
+
         return Server(text_response_handler, **kwargs)
 
     @classmethod
     def basic_response_server(cls, **kwargs):
         return cls.text_response_server(
-            "HTTP/1.1 200 OK\r\n" + "Content-Length: 0\r\n\r\n", **kwargs
+            "HTTP/1.1 200 OK\r\n" +
+            "Content-Length: 0\r\n\r\n",
+            **kwargs
         )
 
     def run(self):
@@ -67,10 +67,11 @@ class Server(threading.Thread):
             self.port = self.server_sock.getsockname()[1]
             self.ready_event.set()
             self._handle_requests()
+
             if self.wait_to_close_event:
                 self.wait_to_close_event.wait(self.WAIT_EVENT_TIMEOUT)
         finally:
-            self.ready_event.set()  # just in case of exception
+            self.ready_event.set() # just in case of exception
             self._close_server_sock_ignore_errors()
             self.stop_event.set()
 
@@ -93,18 +94,17 @@ class Server(threading.Thread):
                 break
 
             handler_result = self.handler(sock)
+
             self.handler_results.append(handler_result)
+            sock.close()
 
     def _accept_connection(self):
         try:
-            ready, _, _ = select.select(
-                [self.server_sock], [], [], self.WAIT_EVENT_TIMEOUT
-            )
+            ready, _, _ = select.select([self.server_sock], [], [], self.WAIT_EVENT_TIMEOUT)
             if not ready:
                 return None
 
             return self.server_sock.accept()[0]
-
         except (select.error, socket.error):
             return None
 
@@ -121,7 +121,8 @@ class Server(threading.Thread):
                 # avoid server from waiting for event timeouts
                 # if an exception is found in the main thread
                 self.wait_to_close_event.set()
+
         # ensure server thread doesn't get stuck waiting for connections
         self._close_server_sock_ignore_errors()
         self.join()
-        return False  # allow exceptions to propagate
+        return False # allow exceptions to propagate

tests/utils.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 import contextlib
 import os
 
@@ -13,7 +14,6 @@ def override_environ(**kwargs):
             os.environ[key] = value
     try:
         yield
-
     finally:
         os.environ.clear()
         os.environ.update(save_env)

tox.ini

@@ -1,8 +1,7 @@
 [tox]
-envlist = py36
+envlist = py27,py35,py36,py37,py38
 
 [testenv]
 
 commands =
-    pip install -e .[socks]
     python setup.py test