diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
index e1530fcc..18e12434 100644
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -1,27 +1,27 @@
 Be sure to check the existing issues (both open and closed!), and make sure you are running the latest version of Pipenv.
 
-If you're requesting a new feature or leaving feedback, please use this forum instead:
+If you're requesting a new feature, please use the PEEP process:
 
-    https://kenneth-reitz.uservoice.com/forums/913660-general
+    https://github.com/pypa/pipenv/blob/master/peeps/PEEP-000.md
 
 Check the [diagnose documentation](https://docs.pipenv.org/diagnose/) for common issues before posting! We may close your issue if it is very similar to one of them. Please be considerate, or be on your way.
 
 Make sure to mention your debugging experience if the documented solution failed.
 
 
-##### Issue description
+### Issue description
 
 Describe the issue briefly here.
 
-##### Expected result
+### Expected result
 
 Describe what you expected.
 
-##### Actual result
+### Actual result
 
 When possible, provide the verbose output (`--verbose`), especially for locking and dependencies resolving issues.
 
-##### Steps to replicate
+### Steps to replicate
 
 Provide the steps to replicate (which usually at least includes the commands and the Pipfile).
 
diff --git a/.github/ISSUE_TEMPLATE/Bug_report.md b/.github/ISSUE_TEMPLATE/Bug_report.md
index 0a9b3421..c470a867 100644
--- a/.github/ISSUE_TEMPLATE/Bug_report.md
+++ b/.github/ISSUE_TEMPLATE/Bug_report.md
@@ -5,28 +5,24 @@ about: Create a report to help us improve
 
 Be sure to check the existing issues (both open and closed!), and make sure you are running the latest version of Pipenv.
 
-If you're requesting a new feature or leaving feedback, please use this forum instead:
-
-    https://kenneth-reitz.uservoice.com/forums/913660-general
-
 Check the [diagnose documentation](https://docs.pipenv.org/diagnose/) for common issues before posting! We may close your issue if it is very similar to one of them. Please be considerate, or be on your way.
 
 Make sure to mention your debugging experience if the documented solution failed.
 
 
-##### Issue description
+### Issue description
 
 Describe the issue briefly here.
 
-##### Expected result
+### Expected result
 
 Describe what you expected.
 
-##### Actual result
+### Actual result
 
 When possible, provide the verbose output (`--verbose`), especially for locking and dependencies resolving issues.
 
-##### Steps to replicate
+### Steps to replicate
 
 Provide the steps to replicate (which usually at least includes the commands and the Pipfile).
 
diff --git a/.github/ISSUE_TEMPLATE/Custom.md b/.github/ISSUE_TEMPLATE/Custom.md
index 407e90cc..33839850 100644
--- a/.github/ISSUE_TEMPLATE/Custom.md
+++ b/.github/ISSUE_TEMPLATE/Custom.md
@@ -5,10 +5,6 @@ about: Requests for assistance or general usage guidance.
 
 **AVOID POSTING ISSUES UNDER THIS CATEGORY.**
 
-If you're requesting a new feature or leaving feedback, please use this forum instead:
-
-    https://kenneth-reitz.uservoice.com/forums/913660-general
-
 If Pipenv is not functioning as you would like it to, consider filing either a bug report, or a feature request instead.
 
 Please refer to [StackOverflow tag](https://stackoverflow.com/questions/tagged/pipenv) for more information.
diff --git a/.github/ISSUE_TEMPLATE/Feature_request.md b/.github/ISSUE_TEMPLATE/Feature_request.md
index 4292912e..8a30d5aa 100644
--- a/.github/ISSUE_TEMPLATE/Feature_request.md
+++ b/.github/ISSUE_TEMPLATE/Feature_request.md
@@ -5,28 +5,23 @@ about: Suggest an idea for this project
 
 Be sure to check the existing issues (both open and closed!), and make sure you are running the latest version of Pipenv.
 
-If you're requesting a new feature or leaving feedback, please use this forum instead:
-
-    https://kenneth-reitz.uservoice.com/forums/913660-general
-
-Check the [diagnose documentation](https://docs.pipenv.org/diagnose/) for common issues before posting! We may close your issue if it is very similar to one of them. Please be considerate, or be on your way.
+Check the [diagnose documentation](https://docs.pipenv.org/diagnose/) for common issues and the [PEEP list](https://github.com/pypa/pipenv/blob/master/peeps/) before posting! We may close your issue if it is very similar to one of them. Please be considerate and follow the PEEP process, or be on your way.
 
 Make sure to mention your debugging experience if the documented solution failed.
 
-
-##### Is your feature request related to a problem? Please describe.
+### Is your feature request related to a problem? Please describe.
 
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 
-##### Describe the solution you'd like
+### Describe the solution you'd like
 
 A clear and concise description of what you want to happen.
 
-##### Describe alternatives you've considered
+### Describe alternatives you've considered
 
 A clear and concise description of any alternative solutions or features you've considered.
 
-##### Additional context
+### Additional context
 
 Add any other context or screenshots about the feature request here. It may be a good idea to mention that platform and Python version you are on.
 
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 9eb5f393..0e1c095b 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,25 +1,28 @@
 Thank you for contributing to Pipenv!
 
 
-##### The issue
+### The issue
 
 What is the thing you want to fix? Is it associated with an issue on GitHub? Please mention it.
 
 Always consider opening an issue first to describe your problem, so we can discuss what is the best way to amend it.  Note that if you do not describe the goal of this change or link to a related issue, the maintainers may close the PR without further review.
 
+If your pull request makes a non-insignificant change to Pipenv, such as the user interface or intended functionality, please file a PEEP. 
 
-##### The fix
+    https://github.com/pypa/pipenv/blob/master/peeps/PEEP-000.md
+
+### The fix
 
 How does this pull request fix your problem? Did you consider any alternatives? Why is this the *best* solution, in your opinion?
 
 
-##### The checklist
+### The checklist
 
 * [ ] Associated issue
 * [ ] A news fragment in the `news/` directory to describe this fix with the extension `.bugfix`, `.feature`, `.behavior`, `.doc`. `.vendor`. or `.trivial` (this will appear in the release changelog). Use semantic line breaks and name the file after the issue number or the PR #.
 
 <!--
-##### If this is a patch to the `vendor` directory…
+### If this is a patch to the `vendor` directory…
 
 Please try to refrain from submitting patches directly to `vendor` or `patched`, but raise your issue to the upstream project instead, and inform Pipenv to upgrade when the upstream project accepts the fix.
 
diff --git a/.gitignore b/.gitignore
index 2cee5455..4809d065 100644
--- a/.gitignore
+++ b/.gitignore
@@ -130,6 +130,9 @@ venv.bak/
 .spyderproject
 .spyproject
 
+# PyCharm project settings
+.idea
+
 # Rope project settings
 .ropeproject
 
diff --git a/.vsts-ci/linux.yml b/.vsts-ci/linux.yml
index 7968801c..95c62dc5 100644
--- a/.vsts-ci/linux.yml
+++ b/.vsts-ci/linux.yml
@@ -1,3 +1,22 @@
+name: Pipenv Build Rules
+trigger:
+  batch: true
+  branches:
+    include:
+    - master
+  paths:
+    exclude:
+    - docs/*
+    - news/*
+    - README.md
+    - pipenv/*.txt
+    - CHANGELOG.rst
+    - CONTRIBUTING.md
+    - CODE_OF_CONDUCT.md
+    - .gitignore
+    - .gitattributes
+    - .editorconfig
+
 phases:
 - template: phases/test.yml
   parameters:
diff --git a/.vsts-ci/phases/run-tests.yml b/.vsts-ci/phases/run-tests.yml
index 81f02875..fe35ad8d 100644
--- a/.vsts-ci/phases/run-tests.yml
+++ b/.vsts-ci/phases/run-tests.yml
@@ -11,10 +11,10 @@ steps:
    mkdir -p "$AGENT_HOMEDIRECTORY/.virtualenvs"
    mkdir -p "$WORKON_HOME"
    pip install certifi
-   export GIT_SSL_CAINFO=$(python -m certifi)
-   export LANG=C.UTF-8
+   export GIT_SSL_CAINFO="$(python -m certifi)"
+   export LANG="C.UTF-8"
    export PIP_PROCESS_DEPENDENCY_LINKS="1"
-   echo "Path: $PATH"
+   echo "Path $PATH"
    echo "Installing Pipenv…"
    pip install -e "$(pwd)" --upgrade
    pipenv install --deploy --dev
@@ -23,8 +23,8 @@ steps:
 
 - script: |
     # Fix Git SSL errors
-    export GIT_SSL_CAINFO=$(python -m certifi)
-    export LANG=C.UTF-8
+    export GIT_SSL_CAINFO="$(python -m certifi)"
+    export LANG="C.UTF-8"
     export PIP_PROCESS_DEPENDENCY_LINKS="1"
     pipenv run pytest --junitxml=test-results.xml
   displayName: Run integration tests
diff --git a/.vsts-ci/steps/run-tests.yml b/.vsts-ci/steps/run-tests.yml
index cb24b092..a7b99a13 100644
--- a/.vsts-ci/steps/run-tests.yml
+++ b/.vsts-ci/steps/run-tests.yml
@@ -3,13 +3,16 @@ steps:
     # Fix Git SSL errors
     pip install certifi
     python -m certifi > cacert.txt
-    $env:GIT_SSL_CAINFO = $(Get-Content cacert.txt)
+    Write-Host "##vso[task.setvariable variable=GIT_SSL_CAINFO]$(Get-Content cacert.txt)"
+    $env:GIT_SSL_CAINFO="$(Get-Content cacert.txt)"
     # Shorten paths to get under MAX_PATH or else integration tests will fail
     # https://bugs.python.org/issue18199
-    subst T: $env:TEMP
-    $env:TEMP = "T:\"
-    $env:TMP = "T:\"
-    D:\.venv\Scripts\pipenv run pytest -n 4 --ignore=pipenv\patched --ignore=pipenv\vendor --junitxml=test-results.xml tests
+    subst T: "$env:TEMP"
+    Write-Host "##vso[task.setvariable variable=TEMP]T:\"
+    $env:TEMP='T:\'
+    Write-Host "##vso[task.setvariable variable=TMP]T:\"
+    $env:TEMP='T:\'
+    D:\.venv\Scripts\pipenv run pytest -ra --ignore=pipenv\patched --ignore=pipenv\vendor --junitxml=test-results.xml tests
   displayName: Run integration tests
 
 - task: PublishTestResults@2
diff --git a/.vsts-ci/windows.yml b/.vsts-ci/windows.yml
index a397a23c..e423c3ab 100644
--- a/.vsts-ci/windows.yml
+++ b/.vsts-ci/windows.yml
@@ -1,3 +1,22 @@
+name: Pipenv Build Rules
+trigger:
+  batch: true
+  branches:
+    include:
+    - master
+  paths:
+    exclude:
+    - docs/*
+    - news/*
+    - README.md
+    - pipenv/*.txt
+    - CHANGELOG.rst
+    - CONTRIBUTING.md
+    - CODE_OF_CONDUCT.md
+    - .gitignore
+    - .gitattributes
+    - .editorconfig
+
 phases:
 - template: phases/test.yml
   parameters:
diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 198983c6..ec8eaef1 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -1,3 +1,257 @@
+2018.10.13 (2018-10-13)
+=======================
+
+Bug Fixes
+---------
+
+- Fixed a bug in ``pipenv clean`` which caused global packages to sometimes be inadvertently targeted for cleanup.  `#2849 <https://github.com/pypa/pipenv/issues/2849>`_
+  
+- Fix broken backport imports for vendored vistir.  `#2950 <https://github.com/pypa/pipenv/issues/2950>`_,
+  `#2955 <https://github.com/pypa/pipenv/issues/2955>`_,
+  `#2961 <https://github.com/pypa/pipenv/issues/2961>`_
+  
+- Fixed a bug with importing local vendored dependencies when running ``pipenv graph``.  `#2952 <https://github.com/pypa/pipenv/issues/2952>`_
+  
+- Fixed a bug which caused executable discovery to fail when running inside a virtualenv.  `#2957 <https://github.com/pypa/pipenv/issues/2957>`_
+  
+- Fix parsing of outline tables.  `#2971 <https://github.com/pypa/pipenv/issues/2971>`_
+  
+- Fixed a bug which caused ``verify_ssl`` to fail to drop through to ``pip install`` correctly as ``trusted-host``.  `#2979 <https://github.com/pypa/pipenv/issues/2979>`_
+  
+- Fixed a bug which caused canonicalized package names to fail to resolve against PyPI.  `#2989 <https://github.com/pypa/pipenv/issues/2989>`_
+  
+- Enhanced CI detection to detect Azure Devops builds.  `#2993 <https://github.com/pypa/pipenv/issues/2993>`_
+  
+- Fixed a bug which prevented installing pinned versions which used redirection symbols from the command line.  `#2998 <https://github.com/pypa/pipenv/issues/2998>`_
+  
+- Fixed a bug which prevented installing the local directory in non-editable mode.  `#3005 <https://github.com/pypa/pipenv/issues/3005>`_
+  
+
+Vendored Libraries
+------------------
+
+- Updated ``requirementslib`` to version ``1.1.9``.  `#2989 <https://github.com/pypa/pipenv/issues/2989>`_
+  
+- Upgraded ``pythonfinder => 1.1.1`` and ``vistir => 0.1.7``.  `#3007 <https://github.com/pypa/pipenv/issues/3007>`_
+
+
+2018.10.9 (2018-10-09)
+======================
+
+Features & Improvements
+-----------------------
+
+- Added environment variables `PIPENV_VERBOSE` and `PIPENV_QUIET` to control
+  output verbosity without needing to pass options.  `#2527 <https://github.com/pypa/pipenv/issues/2527>`_
+  
+- Updated test-pypi addon to better support json-api access (forward compatibility).
+  Improved testing process for new contributors.  `#2568 <https://github.com/pypa/pipenv/issues/2568>`_
+  
+- Greatly enhanced python discovery functionality:
+
+  - Added pep514 (windows launcher/finder) support for python discovery.
+  - Introduced architecture discovery for python installations which support different architectures.  `#2582 <https://github.com/pypa/pipenv/issues/2582>`_
+  
+- Added support for ``pipenv shell`` on msys and cygwin/mingw/git bash for Windows.  `#2641 <https://github.com/pypa/pipenv/issues/2641>`_
+  
+- Enhanced resolution of editable and VCS dependencies.  `#2643 <https://github.com/pypa/pipenv/issues/2643>`_
+  
+- Deduplicate and refactor CLI to use stateful arguments and object passing.  See `this issue <https://github.com/pallets/click/issues/108>`_ for reference.  `#2814 <https://github.com/pypa/pipenv/issues/2814>`_
+  
+
+Behavior Changes
+----------------
+
+- Virtual environment activation for ``run`` is revised to improve interpolation
+  with other Python discovery tools.  `#2503 <https://github.com/pypa/pipenv/issues/2503>`_
+  
+- Improve terminal coloring to display better in Powershell.  `#2511 <https://github.com/pypa/pipenv/issues/2511>`_
+  
+- Invoke ``virtualenv`` directly for virtual environment creation, instead of depending on ``pew``.  `#2518 <https://github.com/pypa/pipenv/issues/2518>`_
+  
+- ``pipenv --help`` will now include short help descriptions.  `#2542 <https://github.com/pypa/pipenv/issues/2542>`_
+  
+- Add ``COMSPEC`` to fallback option (along with ``SHELL`` and ``PYENV_SHELL``)
+  if shell detection fails, improving robustness on Windows.  `#2651 <https://github.com/pypa/pipenv/issues/2651>`_
+  
+- Fallback to shell mode if `run` fails with Windows error 193 to handle non-executable commands. This should improve usability on Windows, where some users run non-executable files without specifying a command, relying on Windows file association to choose the current command.  `#2718 <https://github.com/pypa/pipenv/issues/2718>`_
+  
+
+Bug Fixes
+---------
+
+- Fixed a bug which prevented installation of editable requirements using ``ssh://`` style urls  `#1393 <https://github.com/pypa/pipenv/issues/1393>`_
+  
+- VCS Refs for locked local editable dependencies will now update appropriately to the latest hash when running ``pipenv update``.  `#1690 <https://github.com/pypa/pipenv/issues/1690>`_
+  
+- ``.tar.gz`` and ``.zip`` artifacts will now have dependencies installed even when they are missing from the lockfile.  `#2173 <https://github.com/pypa/pipenv/issues/2173>`_
+  
+- The command line parser will now handle multiple ``-e/--editable`` dependencies properly via click's option parser to help mitigate future parsing issues.  `#2279 <https://github.com/pypa/pipenv/issues/2279>`_
+  
+- Fixed the ability of pipenv to parse ``dependency_links`` from ``setup.py`` when ``PIP_PROCESS_DEPENDENCY_LINKS`` is enabled.  `#2434 <https://github.com/pypa/pipenv/issues/2434>`_
+  
+- Fixed a bug which could cause ``-i/--index`` arguments to sometimes be incorrectly picked up in packages.  This is now handled in the command line parser.  `#2494 <https://github.com/pypa/pipenv/issues/2494>`_
+  
+- Fixed non-deterministic resolution issues related to changes to the internal package finder in ``pip 10``.  `#2499 <https://github.com/pypa/pipenv/issues/2499>`_,
+  `#2529 <https://github.com/pypa/pipenv/issues/2529>`_,
+  `#2589 <https://github.com/pypa/pipenv/issues/2589>`_,
+  `#2666 <https://github.com/pypa/pipenv/issues/2666>`_,
+  `#2767 <https://github.com/pypa/pipenv/issues/2767>`_,
+  `#2785 <https://github.com/pypa/pipenv/issues/2785>`_,
+  `#2795 <https://github.com/pypa/pipenv/issues/2795>`_,
+  `#2801 <https://github.com/pypa/pipenv/issues/2801>`_,
+  `#2824 <https://github.com/pypa/pipenv/issues/2824>`_,
+  `#2862 <https://github.com/pypa/pipenv/issues/2862>`_,
+  `#2879 <https://github.com/pypa/pipenv/issues/2879>`_,
+  `#2894 <https://github.com/pypa/pipenv/issues/2894>`_,
+  `#2933 <https://github.com/pypa/pipenv/issues/2933>`_
+  
+- Fix subshell invocation on Windows for Python 2.  `#2515 <https://github.com/pypa/pipenv/issues/2515>`_
+  
+- Fixed a bug which sometimes caused pipenv to throw a ``TypeError`` or to run into encoding issues when writing lockfiles on python 2.  `#2561 <https://github.com/pypa/pipenv/issues/2561>`_
+  
+- Improve quoting logic for ``pipenv run`` so it works better with Windows
+  built-in commands.  `#2563 <https://github.com/pypa/pipenv/issues/2563>`_
+  
+- Fixed a bug related to parsing vcs requirements with both extras and subdirectory fragments.
+  Corrected an issue in the ``requirementslib`` parser which led to some markers being discarded rather than evaluated.  `#2564 <https://github.com/pypa/pipenv/issues/2564>`_
+  
+- Fixed multiple issues with finding the correct system python locations.  `#2582 <https://github.com/pypa/pipenv/issues/2582>`_
+  
+- Catch JSON decoding error to prevent exception when the lock file is of
+  invalid format.  `#2607 <https://github.com/pypa/pipenv/issues/2607>`_
+  
+- Fixed a rare bug which could sometimes cause errors when installing packages with custom sources.  `#2610 <https://github.com/pypa/pipenv/issues/2610>`_
+  
+- Update requirementslib to fix a bug which could raise an ``UnboundLocalError`` when parsing malformed VCS URIs.  `#2617 <https://github.com/pypa/pipenv/issues/2617>`_
+  
+- Fixed an issue which prevented passing multiple ``--ignore`` parameters to ``pipenv check``.  `#2632 <https://github.com/pypa/pipenv/issues/2632>`_
+  
+- Fixed a bug which caused attempted hashing of ``ssh://`` style URIs which could cause failures during installation of private ssh repositories.
+  - Corrected path conversion issues which caused certain editable VCS paths to be converted to ``ssh://`` URIs improperly.  `#2639 <https://github.com/pypa/pipenv/issues/2639>`_
+  
+- Fixed a bug which caused paths to be formatted incorrectly when using ``pipenv shell`` in bash for windows.  `#2641 <https://github.com/pypa/pipenv/issues/2641>`_
+  
+- Dependency links to private repositories defined via ``ssh://`` schemes will now install correctly and skip hashing as long as ``PIP_PROCESS_DEPENDENCY_LINKS=1``.  `#2643 <https://github.com/pypa/pipenv/issues/2643>`_
+  
+- Fixed a bug which sometimes caused pipenv to parse the ``trusted_host`` argument to pip incorrectly when parsing source URLs which specify ``verify_ssl = false``.  `#2656 <https://github.com/pypa/pipenv/issues/2656>`_
+  
+- Prevent crashing when a virtual environment in ``WORKON_HOME`` is faulty.  `#2676 <https://github.com/pypa/pipenv/issues/2676>`_
+  
+- Fixed virtualenv creation failure when a .venv file is present in the project root.  `#2680 <https://github.com/pypa/pipenv/issues/2680>`_
+  
+- Fixed a bug which could cause the ``-e/--editable`` argument on a dependency to be accidentally parsed as a dependency itself.  `#2714 <https://github.com/pypa/pipenv/issues/2714>`_
+  
+- Correctly pass `verbose` and `debug` flags to the resolver subprocess so it generates appropriate output. This also resolves a bug introduced by the fix to #2527.  `#2732 <https://github.com/pypa/pipenv/issues/2732>`_
+  
+- All markers are now included in ``pipenv lock --requirements`` output.  `#2748 <https://github.com/pypa/pipenv/issues/2748>`_
+  
+- Fixed a bug in marker resolution which could cause duplicate and non-deterministic markers.  `#2760 <https://github.com/pypa/pipenv/issues/2760>`_
+  
+- Fixed a bug in the dependency resolver which caused regular issues when handling ``setup.py`` based dependency resolution.  `#2766 <https://github.com/pypa/pipenv/issues/2766>`_
+  
+- Updated vendored dependencies:
+    - ``pip-tools`` (updated and patched to latest w/ ``pip 18.0`` compatibilty)
+    - ``pip 10.0.1 => 18.0``
+    - ``click 6.7 => 7.0``
+    - ``toml 0.9.4 => 0.10.0``
+    - ``pyparsing 2.2.0 => 2.2.2``
+    - ``delegator 0.1.0 => 0.1.1``
+    - ``attrs 18.1.0 => 18.2.0``
+    - ``distlib 0.2.7 => 0.2.8``
+    - ``packaging 17.1.0 => 18.0``
+    - ``passa 0.2.0 => 0.3.1``
+    - ``pip_shims 0.1.2 => 0.3.1``
+    - ``plette 0.1.1 => 0.2.2``
+    - ``pythonfinder 1.0.2 => 1.1.0``
+    - ``pytoml 0.1.18 => 0.1.19``
+    - ``requirementslib 1.1.16 => 1.1.17``
+    - ``shellingham 1.2.4 => 1.2.6``
+    - ``tomlkit 0.4.2 => 0.4.4``
+    - ``vistir 0.1.4 => 0.1.6``  `#2802 <https://github.com/pypa/pipenv/issues/2802>`_,
+  `#2867 <https://github.com/pypa/pipenv/issues/2867>`_,
+  `#2880 <https://github.com/pypa/pipenv/issues/2880>`_
+  
+- Fixed a bug where `pipenv` crashes when the `WORKON_HOME` directory does not exist.  `#2877 <https://github.com/pypa/pipenv/issues/2877>`_
+  
+- Fixed pip is not loaded from pipenv's patched one but the system one  `#2912 <https://github.com/pypa/pipenv/issues/2912>`_
+  
+- Fixed various bugs related to ``pip 18.1`` release which prevented locking, installation, and syncing, and dumping to a ``requirements.txt`` file.  `#2924 <https://github.com/pypa/pipenv/issues/2924>`_
+  
+
+Vendored Libraries
+------------------
+
+- Pew is no longer vendored. Entry point ``pewtwo``, packages ``pipenv.pew`` and
+  ``pipenv.patched.pew`` are removed.  `#2521 <https://github.com/pypa/pipenv/issues/2521>`_
+  
+- Update ``pythonfinder`` to major release ``1.0.0`` for integration.  `#2582 <https://github.com/pypa/pipenv/issues/2582>`_
+  
+- Update requirementslib to fix a bug which could raise an ``UnboundLocalError`` when parsing malformed VCS URIs.  `#2617 <https://github.com/pypa/pipenv/issues/2617>`_
+  
+- - Vendored new libraries ``vistir`` and ``pip-shims``, ``tomlkit``, ``modutil``, and ``plette``.
+
+  - Update vendored libraries:
+    - ``scandir`` to ``1.9.0``
+    - ``click-completion`` to ``0.4.1``
+    - ``semver`` to ``2.8.1``
+    - ``shellingham`` to ``1.2.4``
+    - ``pytoml`` to ``0.1.18``
+    - ``certifi`` to ``2018.8.24``
+    - ``ptyprocess`` to ``0.6.0``
+    - ``requirementslib`` to ``1.1.5``
+    - ``pythonfinder`` to ``1.0.2``
+    - ``pipdeptree`` to ``0.13.0``
+    - ``python-dotenv`` to ``0.9.1``  `#2639 <https://github.com/pypa/pipenv/issues/2639>`_
+  
+- Updated vendored dependencies:
+    - ``pip-tools`` (updated and patched to latest w/ ``pip 18.0`` compatibilty)
+    - ``pip 10.0.1 => 18.0``
+    - ``click 6.7 => 7.0``
+    - ``toml 0.9.4 => 0.10.0``
+    - ``pyparsing 2.2.0 => 2.2.2``
+    - ``delegator 0.1.0 => 0.1.1``
+    - ``attrs 18.1.0 => 18.2.0``
+    - ``distlib 0.2.7 => 0.2.8``
+    - ``packaging 17.1.0 => 18.0``
+    - ``passa 0.2.0 => 0.3.1``
+    - ``pip_shims 0.1.2 => 0.3.1``
+    - ``plette 0.1.1 => 0.2.2``
+    - ``pythonfinder 1.0.2 => 1.1.0``
+    - ``pytoml 0.1.18 => 0.1.19``
+    - ``requirementslib 1.1.16 => 1.1.17``
+    - ``shellingham 1.2.4 => 1.2.6``
+    - ``tomlkit 0.4.2 => 0.4.4``
+    - ``vistir 0.1.4 => 0.1.6``  `#2902 <https://github.com/pypa/pipenv/issues/2902>`_,
+  `#2935 <https://github.com/pypa/pipenv/issues/2935>`_
+  
+
+Improved Documentation
+----------------------
+
+- Simplified the test configuration process.  `#2568 <https://github.com/pypa/pipenv/issues/2568>`_
+  
+- Updated documentation to use working fortune cookie addon.  `#2644 <https://github.com/pypa/pipenv/issues/2644>`_
+  
+- Added additional information about troubleshooting ``pipenv shell`` by using the the ``$PIPENV_SHELL`` environment variable.  `#2671 <https://github.com/pypa/pipenv/issues/2671>`_
+  
+- Added a link to ``PEP-440`` version specifiers in the documentation for additional detail.  `#2674 <https://github.com/pypa/pipenv/issues/2674>`_
+  
+- Added simple example to README.md for installing from git.  `#2685 <https://github.com/pypa/pipenv/issues/2685>`_
+  
+- Stopped recommending `--system` for Docker contexts.  `#2762 <https://github.com/pypa/pipenv/issues/2762>`_
+  
+- Fixed the example url for doing "pipenv install -e
+  some-repo-url#egg=something", it was missing the "egg=" in the fragment
+  identifier.  `#2792 <https://github.com/pypa/pipenv/issues/2792>`_
+  
+- Fixed link to the "be cordial" essay in the contribution documentation.  `#2793 <https://github.com/pypa/pipenv/issues/2793>`_
+  
+- Clarify `pipenv install` documentation  `#2844 <https://github.com/pypa/pipenv/issues/2844>`_
+  
+- Replace reference to uservoice with PEEP-000  `#2909 <https://github.com/pypa/pipenv/issues/2909>`_
+
+
 2018.7.1 (2018-07-01)
 =====================
 
diff --git a/Dockerfile b/Dockerfile
index b5f681b1..c6b6fb7d 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,11 +1,18 @@
-FROM ubuntu:18.04
-
-# -- Install Pipenv:
-RUN apt update && apt install python3-pip git -y && pip3 install pipenv
+FROM heroku/heroku:18-build
 
+ENV DEBIAN_FRONTEND noninteractive
 ENV LC_ALL C.UTF-8
 ENV LANG C.UTF-8
 
+# -- Install Pipenv:
+RUN apt update && apt upgrade -y && apt install python3.7-dev -y
+RUN curl --silent https://bootstrap.pypa.io/get-pip.py | python3.7
+
+# Backwards compatility.
+RUN rm -fr /usr/bin/python3 && ln /usr/bin/python3.7 /usr/bin/python3
+
+RUN pip3 install pipenv
+
 # -- Install Application into container:
 RUN set -ex && mkdir /app
 
diff --git a/MANIFEST.in b/MANIFEST.in
index e5cc05f2..a8d08c6c 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -8,6 +8,7 @@ recursive-include pipenv *.md *.APACHE *.BSD
 recursive-include pipenv Makefile
 recursive-include pipenv/vendor vendor.txt
 recursive-include pipenv README
+recursive-include pipenv *.json
 include pipenv/patched/notpip/_vendor/vendor.txt
 include pipenv/patched/safety.zip pipenv/patched/patched.txt
 include pipenv/vendor/pipreqs/stdlib pipenv/vendor/pipreqs/mapping
@@ -23,7 +24,8 @@ recursive-include docs Makefile *.rst *.py *.bat
 recursive-include docs/_templates *.html
 recursive-include docs/_static *.js *.css *.png
 recursive-exclude docs requirements*.txt
-
+recursive-exclude pipenv *.pyi
+recursive-exclude pipenv *.typed
 
 prune peeps
 prune .buildkite
diff --git a/NOTICES b/NOTICES
index d8f11f79..e237e5b6 100644
--- a/NOTICES
+++ b/NOTICES
@@ -1,3 +1,5 @@
 The contents of the vendor and patched directories are subject to different licenses
-than the rest of this project. Their respective licenses can be looked
-up at pypi.python.org or in their corresponding LICENSE files.
+than the rest of this project. 
+
+Their respective licenses can be looked up at pypi.python.org or in their 
+corresponding LICENSE files.
diff --git a/Pipfile.lock b/Pipfile.lock
index a5f12e14..3990a451 100644
--- a/Pipfile.lock
+++ b/Pipfile.lock
@@ -17,17 +17,16 @@
     "develop": {
         "alabaster": {
             "hashes": [
-                "sha256:674bb3bab080f598371f4443c5008cbfeb1a5e622dd312395d2d82af2c54c456",
-                "sha256:b63b1f4dc77c074d386752ec4a8a7517600f6c0db8cd42980cae17ab7b3275d7"
+                "sha256:446438bdcca0e05bd45ea2de1668c1d9b032e1a9154c2c259092d77031ddd359",
+                "sha256:a661d72d58e6ea8a57f7a86e37d86716863ee5e92788398526d58b26a4e4dc02"
             ],
-            "version": "==0.7.11"
+            "version": "==0.7.12"
         },
         "apipkg": {
             "hashes": [
                 "sha256:37228cda29411948b422fae072f57e31d3396d2ee1c9783775980ee9c9990af6",
                 "sha256:58587dd4dc3daefad0487f6d9ae32b4542b185e1c36db6993290e7c41ca2b47c"
             ],
-            "markers": "python_version >= '2.7' and python_version != '3.1.*' and python_version != '3.2.*' and python_version != '3.3.*' and python_version != '3.0.*'",
             "version": "==1.5"
         },
         "appdirs": {
@@ -54,17 +53,17 @@
         },
         "atomicwrites": {
             "hashes": [
-                "sha256:240831ea22da9ab882b551b31d4225591e5e447a68c5e188db5b89ca1d487585",
-                "sha256:a24da68318b08ac9c9c45029f4a10371ab5b20e4226738e150e6e7c571630ae6"
+                "sha256:0312ad34fcad8fac3704d441f7b317e50af620823353ec657a53e981f92920c0",
+                "sha256:ec9ae8adaae229e4f8446952d204a3e4b5fdd2d099f9be3aaf556120135fb3ee"
             ],
-            "version": "==1.1.5"
+            "version": "==1.2.1"
         },
         "attrs": {
             "hashes": [
-                "sha256:4b90b09eeeb9b88c35bc642cbac057e45a5fd85367b985bd2809c62b7b939265",
-                "sha256:e0d0eb91441a3b53dab4d9b743eafc1ac44476296a2053b6ca3af0b139faf87b"
+                "sha256:10cbf6e27dbce8c30807caf056c8eb50917e0eaafe86347671b57254006c3e69",
+                "sha256:ca4be454458f9dec299268d472aaa5a11f67a4ff70093396e1ceae9c76cf4bbb"
             ],
-            "version": "==18.1.0"
+            "version": "==18.2.0"
         },
         "babel": {
             "hashes": [
@@ -75,12 +74,19 @@
         },
         "black": {
             "hashes": [
-                "sha256:22158b89c1a6b4eb333a1e65e791a3f8b998cf3b11ae094adb2570f31f769a44",
-                "sha256:4b475bbd528acce094c503a3d2dbc2d05a4075f6d0ef7d9e7514518e14cc5191"
+                "sha256:817243426042db1d36617910df579a54f1afd659adb96fc5032fcf4b36209739",
+                "sha256:e030a9a28f542debc08acceb273f228ac422798e5215ba2a791a6ddeaaca22a5"
             ],
             "index": "pypi",
             "markers": "python_version >= '3.6'",
-            "version": "==18.6b4"
+            "version": "==18.9b0"
+        },
+        "bleach": {
+            "hashes": [
+                "sha256:9c471c0dd9c820f6bf4ee5ca3e348ceccefbc1475d9a40c397ed5d04e0b42c54",
+                "sha256:b407b2612b37e6cdc6704f84cec18c1f140b78e6c625652a844e89d6b9855f6b"
+            ],
+            "version": "==3.0.0"
         },
         "cerberus": {
             "hashes": [
@@ -90,10 +96,47 @@
         },
         "certifi": {
             "hashes": [
-                "sha256:4c1d68a1408dd090d2f3a869aa94c3947cc1d967821d1ed303208c9f41f0f2f4",
-                "sha256:b6e8b28b2b7e771a41ecdd12d4d43262ecab52adebbafa42c77d6b57fb6ad3a4"
+                "sha256:376690d6f16d32f9d1fe8932551d80b23e9d393a8578c5633a2ed39a64861638",
+                "sha256:456048c7e371c089d0a77a5212fb37a2c2dce1e24146e3b7e0261736aaeaa22a"
             ],
-            "version": "==2018.8.13"
+            "version": "==2018.8.24"
+        },
+        "cffi": {
+            "hashes": [
+                "sha256:151b7eefd035c56b2b2e1eb9963c90c6302dc15fbd8c1c0a83a163ff2c7d7743",
+                "sha256:1553d1e99f035ace1c0544050622b7bc963374a00c467edafac50ad7bd276aef",
+                "sha256:1b0493c091a1898f1136e3f4f991a784437fac3673780ff9de3bcf46c80b6b50",
+                "sha256:2ba8a45822b7aee805ab49abfe7eec16b90587f7f26df20c71dd89e45a97076f",
+                "sha256:3bb6bd7266598f318063e584378b8e27c67de998a43362e8fce664c54ee52d30",
+                "sha256:3c85641778460581c42924384f5e68076d724ceac0f267d66c757f7535069c93",
+                "sha256:3eb6434197633b7748cea30bf0ba9f66727cdce45117a712b29a443943733257",
+                "sha256:495c5c2d43bf6cebe0178eb3e88f9c4aa48d8934aa6e3cddb865c058da76756b",
+                "sha256:4c91af6e967c2015729d3e69c2e51d92f9898c330d6a851bf8f121236f3defd3",
+                "sha256:57b2533356cb2d8fac1555815929f7f5f14d68ac77b085d2326b571310f34f6e",
+                "sha256:770f3782b31f50b68627e22f91cb182c48c47c02eb405fd689472aa7b7aa16dc",
+                "sha256:79f9b6f7c46ae1f8ded75f68cf8ad50e5729ed4d590c74840471fc2823457d04",
+                "sha256:7a33145e04d44ce95bcd71e522b478d282ad0eafaf34fe1ec5bbd73e662f22b6",
+                "sha256:857959354ae3a6fa3da6651b966d13b0a8bed6bbc87a0de7b38a549db1d2a359",
+                "sha256:87f37fe5130574ff76c17cab61e7d2538a16f843bb7bca8ebbc4b12de3078596",
+                "sha256:95d5251e4b5ca00061f9d9f3d6fe537247e145a8524ae9fd30a2f8fbce993b5b",
+                "sha256:9d1d3e63a4afdc29bd76ce6aa9d58c771cd1599fbba8cf5057e7860b203710dd",
+                "sha256:a36c5c154f9d42ec176e6e620cb0dd275744aa1d804786a71ac37dc3661a5e95",
+                "sha256:a6a5cb8809091ec9ac03edde9304b3ad82ad4466333432b16d78ef40e0cce0d5",
+                "sha256:ae5e35a2c189d397b91034642cb0eab0e346f776ec2eb44a49a459e6615d6e2e",
+                "sha256:b0f7d4a3df8f06cf49f9f121bead236e328074de6449866515cea4907bbc63d6",
+                "sha256:b75110fb114fa366b29a027d0c9be3709579602ae111ff61674d28c93606acca",
+                "sha256:ba5e697569f84b13640c9e193170e89c13c6244c24400fc57e88724ef610cd31",
+                "sha256:be2a9b390f77fd7676d80bc3cdc4f8edb940d8c198ed2d8c0be1319018c778e1",
+                "sha256:ca1bd81f40adc59011f58159e4aa6445fc585a32bb8ac9badf7a2c1aa23822f2",
+                "sha256:d5d8555d9bfc3f02385c1c37e9f998e2011f0db4f90e250e5bc0c0a85a813085",
+                "sha256:e55e22ac0a30023426564b1059b035973ec82186ddddbac867078435801c7801",
+                "sha256:e90f17980e6ab0f3c2f3730e56d1fe9bcba1891eeea58966e89d352492cc74f4",
+                "sha256:ecbb7b01409e9b782df5ded849c178a0aa7c906cf8c5a67368047daab282b184",
+                "sha256:ed01918d545a38998bfa5902c7c00e0fee90e957ce036a4000a88e3fe2264917",
+                "sha256:edabd457cd23a02965166026fd9bfd196f4324fe6032e866d0f3bd0301cd486f",
+                "sha256:fdf1c1dc5bafc32bc5d08b054f94d659422b05aba244d6be4ddc1c72d9aa70fb"
+            ],
+            "version": "==1.11.5"
         },
         "chardet": {
             "hashes": [
@@ -104,11 +147,44 @@
         },
         "click": {
             "hashes": [
-                "sha256:29f99fc6125fbc931b758dc053b3114e55c77a6e4c6c3a2674a2dc986016381d",
-                "sha256:f15516df478d5a56180fbf80e68f206010e6d160fc39fa508b65e035fd75130b"
+                "sha256:2335065e6395b9e67ca716de5f7526736bfa6ceead690adf616d925bdc622b13",
+                "sha256:5b94b49521f6456670fdb30cd82a4eca9412788a93fa6dd6df72c94d5a8ff2d7"
             ],
             "index": "pypi",
-            "version": "==6.7"
+            "version": "==7.0"
+        },
+        "cmarkgfm": {
+            "hashes": [
+                "sha256:0186dccca79483e3405217993b83b914ba4559fe9a8396efc4eea56561b74061",
+                "sha256:1a625afc6f62da428df96ec325dc30866cc5781520cbd904ff4ec44cf018171c",
+                "sha256:207b7673ff4e177374c572feeae0e4ef33be620ec9171c08fd22e2b796e03e3d",
+                "sha256:275905bb371a99285c74931700db3f0c078e7603bed383e8cf1a09f3ee05a3de",
+                "sha256:50098f1c4950722521f0671e54139e0edc1837d63c990cf0f3d2c49607bb51a2",
+                "sha256:50ed116d0b60a07df0dc7b180c28569064b9d37d1578d4c9021cff04d725cb63",
+                "sha256:61a72def110eed903cd1848245897bcb80d295cd9d13944d4f9f30cba5b76655",
+                "sha256:64186fb75d973a06df0e6ea12879533b71f6e7ba1ab01ffee7fc3e7534758889",
+                "sha256:665303d34d7f14f10d7b0651082f25ebf7107f29ef3d699490cac16cdc0fc8ce",
+                "sha256:70b18f843aec58e4e64aadce48a897fe7c50426718b7753aaee399e72df64190",
+                "sha256:761ee7b04d1caee2931344ac6bfebf37102ffb203b136b676b0a71a3f0ea3c87",
+                "sha256:811527e9b7280b136734ed6cb6845e5fbccaeaa132ddf45f0246cbe544016957",
+                "sha256:987b0e157f70c72a84f3c2f9ef2d7ab0f26c08f2bf326c12c087ff9eebcb3ff5",
+                "sha256:9fc6a2183d0a9b0974ec7cdcdad42bd78a3be674cc3e65f87dd694419b3b0ab7",
+                "sha256:a3d17ee4ae739fe16f7501a52255c2e287ac817cfd88565b9859f70520afffea",
+                "sha256:ba5b5488719c0f2ced0aa1986376f7baff1a1653a8eb5fdfcf3f84c7ce46ef8d",
+                "sha256:c573ea89dd95d41b6d8cf36799c34b6d5b1eac4aed0212dee0f0a11fb7b01e8f",
+                "sha256:c5f1b9e8592d2c448c44e6bc0d91224b16ea5f8293908b1561de1f6d2d0658b1",
+                "sha256:cbe581456357d8f0674d6a590b1aaf46c11d01dd0a23af147a51a798c3818034",
+                "sha256:cf219bec69e601fe27e3974b7307d2f06082ab385d42752738ad2eb630a47d65",
+                "sha256:cf5014eb214d814a83a7a47407272d5db10b719dbeaf4d3cfe5969309d0fcf4b",
+                "sha256:d08bad67fa18f7e8ff738c090628ee0cbf0505d74a991c848d6d04abfe67b697",
+                "sha256:d6f716d7b1182bf35862b5065112f933f43dd1aa4f8097c9bcfb246f71528a34",
+                "sha256:e08e479102627641c7cb4ece421c6ed4124820b1758765db32201136762282d9",
+                "sha256:e20ac21418af0298437d29599f7851915497ce9f2866bc8e86b084d8911ee061",
+                "sha256:e25f53c37e319241b9a412382140dffac98ca756ba8f360ac7ab5e30cad9670a",
+                "sha256:e8932bddf159064f04e946fbb64693753488de21586f20e840b3be51745c8c09",
+                "sha256:f20900f16377f2109783ae9348d34bc80530808439591c3d3df73d5c7ef1a00c"
+            ],
+            "version": "==0.4.2"
         },
         "colorama": {
             "hashes": [
@@ -127,9 +203,9 @@
         },
         "distlib": {
             "hashes": [
-                "sha256:cd502c66fc27c535bab62dc4f482e403e2369c2c05281a79cc2d4e2f42a87f20"
+                "sha256:57977cd7d9ea27986ec62f425630e4ddb42efe651ff80bc58ed8dbc3c7c21f19"
             ],
-            "version": "==0.2.7"
+            "version": "==0.2.8"
         },
         "docutils": {
             "hashes": [
@@ -154,7 +230,6 @@
                 "sha256:a7a84d5fa07a089186a329528f127c9d73b9de57f1a1131b82bb5320ee651f6a",
                 "sha256:fc155a6b553c66c838d1a22dba1dc9f5f505c43285a878c6f74a79c024750b83"
             ],
-            "markers": "python_version >= '2.7' and python_version != '3.1.*' and python_version != '3.2.*' and python_version != '3.3.*' and python_version != '3.0.*'",
             "version": "==1.5.0"
         },
         "first": {
@@ -203,6 +278,12 @@
             "markers": "python_version < '3' and python_version >= '2.6'",
             "version": "==3.2.0"
         },
+        "future": {
+            "hashes": [
+                "sha256:e39ced1ab767b5936646cedba8bcce582398233d6a627067d4c6a454c90cfedb"
+            ],
+            "version": "==0.16.0"
+        },
         "idna": {
             "hashes": [
                 "sha256:156a6814fb5ac1fc6850fb002e0852d56c0c8d2531923a51032d1b70760e186e",
@@ -212,10 +293,10 @@
         },
         "imagesize": {
             "hashes": [
-                "sha256:3620cc0cadba3f7475f9940d22431fc4d407269f1be59ec9b8edcca26440cf18",
-                "sha256:5b326e4678b6925158ccc66a9fa3122b6106d7c876ee32d7de6ce59385b96315"
+                "sha256:3f349de3eb99145973fefb7dbe38554414e5c30abd0c8e4b970a7c9d09f3a1d8",
+                "sha256:f3832918bc3c66617f92e35f5d70729187676313caa60c187eb0f28b8fe5e3b5"
             ],
-            "version": "==1.0.0"
+            "version": "==1.1.0"
         },
         "incremental": {
             "hashes": [
@@ -226,12 +307,12 @@
         },
         "invoke": {
             "hashes": [
-                "sha256:1c2cf54c9b9af973ad9704d8ba81b225117cab612568cacbfb3fc42958cc20a9",
-                "sha256:334495ea16e73948894e9535019f87a88a44b73e7977492b12c2d1b5085f8197",
-                "sha256:54bdd3fd0245abd1185e05359fd2e4f26be0657cfe7d7bb1bed735e054fa53ab"
+                "sha256:4f4de934b15c2276caa4fbc5a3b8a61c0eb0b234f2be1780d2b793321995c2d6",
+                "sha256:dc492f8f17a0746e92081aec3f86ae0b4750bf41607ea2ad87e5a7b5705121b7",
+                "sha256:eb6f9262d4d25b40330fb21d1e99bf0f85011ccc3526980f8a3eaedd4b43892e"
             ],
             "index": "pypi",
-            "version": "==1.1.1"
+            "version": "==1.2.0"
         },
         "isort": {
             "hashes": [
@@ -250,11 +331,11 @@
         },
         "jedi": {
             "hashes": [
-                "sha256:b409ed0f6913a701ed474a614a3bb46e6953639033e31f769ca7581da5bd1ec1",
-                "sha256:c254b135fb39ad76e78d4d8f92765ebc9bf92cbc76f49e97ade1d5f5121e1f6f"
+                "sha256:0191c447165f798e6a730285f2eee783fff81b0d3df261945ecb80983b5c3ca7",
+                "sha256:b7493f73a2febe0dc33d51c99b474547f7f6c0b2c8fb2b21f453eef204c12148"
             ],
             "index": "pypi",
-            "version": "==0.12.1"
+            "version": "==0.13.1"
         },
         "jinja2": {
             "hashes": [
@@ -284,14 +365,6 @@
             "index": "pypi",
             "version": "==2.0.0"
         },
-        "modutil": {
-            "hashes": [
-                "sha256:2c85c1666649e92e56de17c00e1e831313602d9b55e8661d39c01e39003b45f7",
-                "sha256:cc3dad264e36ed359fdd67c4588959d2996bd0402ad9c9d974ca906821537218"
-            ],
-            "markers": "python_version >= '3.7'",
-            "version": "==2.0.0"
-        },
         "more-itertools": {
             "hashes": [
                 "sha256:c187a73da93e7a8acc0001572aebc7e3c69daf7bf6881a2cea10650bd4420092",
@@ -302,10 +375,10 @@
         },
         "packaging": {
             "hashes": [
-                "sha256:e9215d2d2535d3ae866c3d6efc77d5b24a0192cce0ff20e42896cc0664f889c0",
-                "sha256:f019b770dd64e585a99714f1fd5e01c7a8f11b45635aa953fd41c689a657375b"
+                "sha256:0886227f54515e592aaa2e5a553332c73962917f2831f1b0f9b9f4380a4b9807",
+                "sha256:f95a1e147590f204328170981833854229bb2912ac3d5f89e2a8ccd2834800c9"
             ],
-            "version": "==17.1"
+            "version": "==18.0"
         },
         "parso": {
             "hashes": [
@@ -325,21 +398,21 @@
         "passa": {
             "editable": true,
             "git": "https://github.com/sarugaku/passa.git",
-            "ref": "54e65e01744cafbcab44eb15422e1604b615caae"
+            "ref": "4f3b8102f122cf0b75e5d7c513a2e61b0b093dcd"
         },
         "pbr": {
             "hashes": [
-                "sha256:1b8be50d938c9bb75d0eaf7eda111eec1bf6dc88a62a6412e33bf077457e0f45",
-                "sha256:b486975c0cafb6beeb50ca0e17ba047647f229087bd74e37f4a7e2cac17d2caa"
+                "sha256:1be135151a0da949af8c5d0ee9013d9eafada71237eb80b3ba8896b4f12ec5dc",
+                "sha256:cf36765bf2218654ae824ec8e14257259ba44e43b117fd573c8d07a9895adbdd"
             ],
-            "version": "==4.2.0"
+            "version": "==4.3.0"
         },
         "pip-shims": {
             "hashes": [
-                "sha256:9c8a568b4a8ce4000a2982224f48a35736fca81214dfdb30dcae24287866a7e4",
-                "sha256:ebc2bb29ddd21fa00c0cf28a5d8c725100f2f7ee98703aba237efd02e205c1c1"
+                "sha256:164b93bc94b207613d9632f28f4d55eba9301f9454aaaba335de36c24d92d106",
+                "sha256:27e2439aa93af8c1b8e58cf63a40cbcd26959b26424904f2e6d57837af8f76c5"
             ],
-            "version": "==0.1.2"
+            "version": "==0.3.0"
         },
         "pipenv": {
             "editable": true,
@@ -354,11 +427,10 @@
         },
         "plette": {
             "hashes": [
-                "sha256:3c2bbf439dad64d9a89459c20305b976d797ae1c2ad48a540e7022b377717851",
-                "sha256:cc9490a009494395dea286f4f488e0839ac06e1361d4951cc12fe621b6f0a68c"
+                "sha256:c0e3553c1e581d8423daccbd825789c6e7f29b7d9e00e5331b12e1642a1a26d3",
+                "sha256:dde5d525cf5f0cbad4d938c83b93db17887918daf63c13eafed257c4f61b07b4"
             ],
-            "markers": "python_version >= '2.6'",
-            "version": "==0.1.1"
+            "version": "==0.2.2"
         },
         "pluggy": {
             "hashes": [
@@ -369,10 +441,10 @@
         },
         "py": {
             "hashes": [
-                "sha256:3fd59af7435864e1a243790d322d763925431213b6b8529c6ca71081ace3bbf7",
-                "sha256:e31fb2767eb657cbde86c454f02e99cb846d3cd9d61b318525140214fdc0e98e"
+                "sha256:06a30435d058473046be836d3fc4f27167fd84c45b99704f2fb5509ef61f9af1",
+                "sha256:50402e9d1c9005d759426988a492e0edaadb7f4e68bcddfea586bc7432d009c6"
             ],
-            "version": "==1.5.4"
+            "version": "==1.6.0"
         },
         "pycodestyle": {
             "hashes": [
@@ -381,6 +453,12 @@
             ],
             "version": "==2.3.1"
         },
+        "pycparser": {
+            "hashes": [
+                "sha256:a988718abfad80b6b157acce7bf130a30876d27603738ac39f140993246b25b3"
+            ],
+            "version": "==2.19"
+        },
         "pyflakes": {
             "hashes": [
                 "sha256:08bd6a50edf8cffa9fa09a463063c425ecaaf10d1eb0335a7e8b1401aef89e6f",
@@ -397,25 +475,24 @@
         },
         "pyparsing": {
             "hashes": [
-                "sha256:0832bcf47acd283788593e7a0f542407bd9550a55a8a8435214a1960e04bcb04",
-                "sha256:fee43f17a9c4087e7ed1605bd6df994c6173c1e977d7ade7b651292fab2bd010"
+                "sha256:bc6c7146b91af3f567cf6daeaec360bc07d45ffec4cf5353f4d7a208ce7ca30a",
+                "sha256:d29593d8ebe7b57d6967b62494f8c72b03ac0262b1eed63826c6f788b3606401"
             ],
-            "version": "==2.2.0"
+            "version": "==2.2.2"
         },
         "pytest": {
             "hashes": [
-                "sha256:3459a123ad5532852d36f6f4501dfe1acf4af1dd9541834a164666aa40395b02",
-                "sha256:96bfd45dbe863b447a3054145cd78a9d7f31475d2bce6111b133c0cc4f305118"
+                "sha256:7e258ee50338f4e46957f9e09a0f10fb1c2d05493fa901d113a8dafd0790de4e",
+                "sha256:9332147e9af2dcf46cd7ceb14d5acadb6564744ddff1fe8c17f0ce60ece7d9a2"
             ],
             "index": "pypi",
-            "version": "==3.7.2"
+            "version": "==3.8.2"
         },
         "pytest-forked": {
             "hashes": [
                 "sha256:e4500cd0509ec4a26535f7d4112a8cc0f17d3a41c29ffd4eab479d2a55b30805",
                 "sha256:f275cb48a73fc61a6710726348e1da6d68a978f0ec0c54ece5a5fae5977e5a08"
             ],
-            "markers": "python_version >= '2.7' and python_version != '3.1.*' and python_version != '3.2.*' and python_version != '3.3.*' and python_version != '3.0.*'",
             "version": "==0.2"
         },
         "pytest-pypy": {
@@ -424,19 +501,19 @@
         },
         "pytest-tap": {
             "hashes": [
-                "sha256:06ff3ca882b69814f20e36533157394372479c91c21233964dab52c071faf8d3",
-                "sha256:ea621f3ab77c12dc662ad6daeeb0152cfab522e2ef968d90500cf4c0a59dc965"
+                "sha256:3b05ec931424bbe44e944726b68f7ef185bb6d25ce9ce21ac52c9af7ffa9b506",
+                "sha256:ca063de56298034302f3cbce55c87a27d7bfa7af7de591cdb9ec6ce45fea5467"
             ],
             "index": "pypi",
-            "version": "==2.2"
+            "version": "==2.3"
         },
         "pytest-xdist": {
             "hashes": [
-                "sha256:3308c4f6221670432d01e0b393b333d77c1fd805532e1d64450e8140855eb51b",
-                "sha256:cce08b4b7f56d34d43b365e2b3667ebb8edcf91d01c2a8fccf45c56d37e71bc1"
+                "sha256:06aa39361694c9365baaa03bec71159b59ad06c9826c6279ebba368cb3571561",
+                "sha256:1ef0d05c905cfa0c5442c90e9e350e65c6ada120e33a00a066ca51c89f5f869a"
             ],
             "index": "pypi",
-            "version": "==1.22.5"
+            "version": "==1.23.2"
         },
         "pytz": {
             "hashes": [
@@ -446,6 +523,13 @@
             "index": "pypi",
             "version": "==2018.5"
         },
+        "readme-renderer": {
+            "hashes": [
+                "sha256:237ca8705ffea849870de41101dba41543561da05c0ae45b2f1c547efa9843d2",
+                "sha256:f75049a3a7afa57165551e030dd8f9882ebf688b9600535a3f7e23596651875d"
+            ],
+            "version": "==22.0"
+        },
         "requests": {
             "hashes": [
                 "sha256:63b52e3c866428a224f97cab011de738c36aec0185aa91cfacd418b5d58911d1",
@@ -462,17 +546,17 @@
         },
         "requirementslib": {
             "hashes": [
-                "sha256:698a566272669a470a8a439250353b0b628468ea0879f4f32e22245c2b9d9e44",
-                "sha256:c7031b128e13eb8d8847f9ce409f3bfab49e8d111e7e8fca432ff8a737820653"
+                "sha256:39fb4aab3ebd7f46b266ddc98a3ac731127ee35fe6cf1b3e11be7c6551cc2c9b",
+                "sha256:810d8961f333d8fef92400f58b25f80003151fb424a545e244073fc3d95ae2dd"
             ],
-            "version": "==1.1.1"
+            "version": "==1.1.7"
         },
         "resolvelib": {
             "hashes": [
-                "sha256:d52f2c0762deeb2a4cc34a84371a7a5ac85e111bdc69ce9ae729d8d636606ad6",
-                "sha256:eb759d43bbf50de9bf36afb9f6c269fabf9ff49084dbfad4ba67252d134bf4b5"
+                "sha256:6c4c6690b0bdd78bcc002e1a5d1b6abbde58c694a6ea1838f165b20d2c943db7",
+                "sha256:8734e53271ef98f38a2c99324d5e7905bc00c97dc3fc5bb7d83c82a979e71c04"
             ],
-            "version": "==0.2.1"
+            "version": "==0.2.2"
         },
         "rope": {
             "hashes": [
@@ -528,45 +612,44 @@
         },
         "tap.py": {
             "hashes": [
-                "sha256:03accd27118473475b33b44703b223df2f148679b9b01b6ac59866df0b580073",
-                "sha256:06416d376f0d398ab163674f30ea3b4a320957e4baa51793b8e86bdfdfeb857d"
+                "sha256:8ad62ba6898fcef4913c67d468d0c4beae3109b74c03363538145e31b1840b29",
+                "sha256:f6532fd7483c5fdc2ed13575fa4494e7d037f797f8a2c6f8809a859be61271f5"
             ],
-            "version": "==2.4"
+            "version": "==2.5"
         },
         "toml": {
             "hashes": [
-                "sha256:8e86bd6ce8cc11b9620cb637466453d94f5d57ad86f17e98a98d1f73e3baab2d"
+                "sha256:229f81c57791a41d65e399fc06bf0848bab550a9dfd5ed66df18ce5f05e73d5c",
+                "sha256:235682dd292d5899d361a811df37e04a8828a5b1da3115886b73cf81ebc9100e"
             ],
-            "version": "==0.9.4"
+            "version": "==0.10.0"
         },
         "tomlkit": {
             "hashes": [
-                "sha256:4f112445d6e52a038adf23b027ccb11905fdf88976990116e8f7b171b768cedb",
-                "sha256:8b84ac193aa6366769f89541cf213efe9784ac125f08164974400c43f18fcd9f"
+                "sha256:8ab16e93162fc44d3ad83d2aa29a7140b8f7d996ae1790a73b9a7aed6fb504ac",
+                "sha256:ca181cee7aee805d455628f7c94eb8ae814763769a93e69157f250fe4ebe1926"
             ],
-            "markers": "python_version != '3.2.*' and python_version != '3.3.*' and python_version != '3.1.*' and python_version != '3.0.*' and python_version >= '2.7'",
-            "version": "==0.4.2"
+            "version": "==0.4.4"
         },
         "towncrier": {
             "editable": true,
             "git": "https://github.com/hawkowl/towncrier.git",
-            "ref": "3d600a813b8bb4277b8bd77360e54531ce274b58"
+            "ref": "47754a607a9b03f06affaf167d65b990786aae25"
         },
         "tqdm": {
             "hashes": [
-                "sha256:5ef526702c0d265d5a960a3b27f3971fac13c26cf0fb819294bfa71fc6026c88",
-                "sha256:a3364bd83ce4777320b862e3c8a93d7da91e20a95f06ef79bed7dd71c654cafa"
+                "sha256:18f1818ce951aeb9ea162ae1098b43f583f7d057b34d706f66939353d1208889",
+                "sha256:df02c0650160986bac0218bb07952245fc6960d23654648b5d5526ad5a4128c9"
             ],
-            "markers": "python_version != '3.1.*' and python_version != '3.0.*' and python_version >= '2.6'",
-            "version": "==4.25.0"
+            "version": "==4.26.0"
         },
         "twine": {
             "hashes": [
-                "sha256:08eb132bbaec40c6d25b358f546ec1dc96ebd2638a86eea68769d9e67fe2b129",
-                "sha256:2fd9a4d9ff0bcacf41fdc40c8cb0cfaef1f1859457c9653fd1b92237cc4e9f25"
+                "sha256:7d89bc6acafb31d124e6e5b295ef26ac77030bf098960c2a4c4e058335827c5c",
+                "sha256:fad6f1251195f7ddd1460cb76d6ea106c93adb4e56c41e0da79658e56e547d2c"
             ],
             "index": "pypi",
-            "version": "==1.11.0"
+            "version": "==1.12.1"
         },
         "typing": {
             "hashes": [
@@ -589,7 +672,6 @@
                 "sha256:2ce32cd126117ce2c539f0134eb89de91a8413a29baac49cbab3eb50e2026669",
                 "sha256:ca07b4c0b54e14a91af9f34d0919790b016923d157afda5efdde55c96718f752"
             ],
-            "markers": "python_version != '3.0.*' and python_version >= '2.7' and python_version != '3.2.*' and python_version != '3.1.*'",
             "version": "==16.0.0"
         },
         "virtualenv-clone": {
@@ -601,10 +683,17 @@
         },
         "vistir": {
             "hashes": [
-                "sha256:011e52dd2e09f948f638262dc39fef38998d134538705a810e88ad6d7bb94c1c",
-                "sha256:f447923d4c59e8d50add4a9d8275b25a1f038f1a1a00ded50ee3c3d00a3c7f5d"
+                "sha256:8a360ac20cbcc0863d6dbbe7a52e8b2c9ebf48abd6833c3813a82c70708244af",
+                "sha256:bc6e10284792485c10585536e6aede9e38996c841cc9d2a67238cd05742c2d0b"
             ],
-            "version": "==0.1.4"
+            "version": "==0.1.6"
+        },
+        "webencodings": {
+            "hashes": [
+                "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78",
+                "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"
+            ],
+            "version": "==0.5.1"
         },
         "werkzeug": {
             "hashes": [
@@ -615,11 +704,17 @@
         },
         "wheel": {
             "hashes": [
-                "sha256:0a2e54558a0628f2145d2fc822137e322412115173e8a2ddbe1c9024338ae83c",
-                "sha256:80044e51ec5bbf6c894ba0bc48d26a8c20a9ba629f4ca19ea26ecfcf87685f5f"
+                "sha256:9fa1f772f1a2df2bd00ddb4fa57e1cc349301e1facb98fbe62329803a9ff1196",
+                "sha256:d215f4520a1ba1851a3c00ba2b4122665cd3d6b0834d2ba2816198b1e3024a0e"
             ],
-            "markers": "python_version != '3.0.*' and python_version >= '2.7' and python_version != '3.2.*' and python_version != '3.3.*' and python_version != '3.1.*'",
-            "version": "==0.31.1"
+            "version": "==0.32.1"
+        },
+        "yaspin": {
+            "hashes": [
+                "sha256:36fdccc5e0637b5baa8892fe2c3d927782df7d504e9020f40eb2c1502518aa5a",
+                "sha256:8e52bf8079a48e2a53f3dfeec9e04addb900c101d1591c85df69cf677d3237e7"
+            ],
+            "version": "==0.14.0"
         }
     }
 }
diff --git a/README.md b/README.md
index f6af5917..3b5b1efb 100644
--- a/README.md
+++ b/README.md
@@ -4,8 +4,8 @@ Pipenv: Python Development Workflow for Humans
 [![image](https://img.shields.io/pypi/v/pipenv.svg)](https://python.org/pypi/pipenv)
 [![image](https://img.shields.io/pypi/l/pipenv.svg)](https://python.org/pypi/pipenv)
 [![image](https://badge.buildkite.com/79c7eccf056b17c3151f3c4d0e4c4b8b724539d84f1e037b9b.svg?branch=master)](https://code.kennethreitz.org/source/pipenv/)
-[![VSTS build status (Windows)](https://pypa.visualstudio.com/pipenv/_apis/build/status/pipenv%20CI%20(Windows)?branchName=master&label=Windows)](https://pypa.visualstudio.com/pipenv/_build/latest?definitionId=9&branchName=master)
-[![VSTS build status (Linux)](https://pypa.visualstudio.com/pipenv/_apis/build/status/pipenv%20CI%20(Linux)?branchName=master&label=Linux)](https://pypa.visualstudio.com/pipenv/_build/latest?definitionId=10&branchName=master)
+[![VSTS build status (Windows)](https://dev.azure.com/pypa/pipenv/_apis/build/status/pipenv%20CI%20(Windows)?branchName=master&label=Windows)](https://dev.azure.com/pypa/pipenv/_build/latest?definitionId=9&branchName=master)
+[![VSTS build status (Linux)](https://dev.azure.com/pypa/pipenv/_apis/build/status/pipenv%20CI%20(Linux)?branchName=master&label=Linux)](https://dev.azure.com/pypa/pipenv/_build/latest?definitionId=10&branchName=master)
 [![image](https://img.shields.io/pypi/pyversions/pipenv.svg)](https://python.org/pypi/pipenv)
 [![image](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](https://saythanks.io/to/kennethreitz)
 
@@ -35,6 +35,10 @@ The problems that Pipenv seeks to solve are multi-faceted:
 -   Give you insight into your dependency graph (e.g. `$ pipenv graph`).
 -   Streamline development workflow by loading `.env` files.
 
+You can quickly play with Pipenv right in your browser:
+
+[![Try in browser](https://cdn.rawgit.com/rootnroll/library/assets/try.svg)](https://rootnroll.com/d/pipenv/)
+
 Installation
 ------------
 
diff --git a/docs/advanced.rst b/docs/advanced.rst
index f2fdee05..3ac323e6 100644
--- a/docs/advanced.rst
+++ b/docs/advanced.rst
@@ -119,7 +119,7 @@ Or you can install packages exactly as specified in ``Pipfile.lock`` using the `
 
 .. note::
 
-    ``pipenv install --ignore-pipfile`` is nearly equivalent to ``pipenv sync``, but you ``pipenv sync`` will *never* attempt to re-lock your dependencies as it is considered an atomic operation.  ``pipenv install`` by default does attempt to re-lock unless using the ``--deploy`` flag.
+    ``pipenv install --ignore-pipfile`` is nearly equivalent to ``pipenv sync``, but ``pipenv sync`` will *never* attempt to re-lock your dependencies as it is considered an atomic operation.  ``pipenv install`` by default does attempt to re-lock unless using the ``--deploy`` flag.
 
 Deploying System Dependencies
 /////////////////////////////
diff --git a/docs/basics.rst b/docs/basics.rst
index 5d41249f..ee2e6621 100644
--- a/docs/basics.rst
+++ b/docs/basics.rst
@@ -135,7 +135,6 @@ Example Pipfile.lock
 
 Clone / create project repository::
 
-    …
     $ cd myproject
 
 Install from Pipfile, if there is one::
@@ -152,7 +151,8 @@ Next, activate the Pipenv shell::
 
     $ pipenv shell
     $ python --version
-    …
+
+This will spawn a new shell subprocess, which can be deactivated by using ``exit``.
 
 .. _initialization:
 
@@ -182,13 +182,38 @@ in your ``Pipfile.lock`` for now, run ``pipenv lock --keep-outdated``.  Make sur
 ☤ Specifying Versions of a Package
 ----------------------------------
 
-To tell pipenv to install a specific version of a library, the usage is simple::
+You can specify versions of a package using the `Semantic Versioning scheme <https://semver.org/>`_ 
+(i.e. ``major.minor.micro``). 
 
-    $ pipenv install requests==2.13.0
+For example, to install requests you can use: ::
+
+    $ pipenv install requests~=1.2   # equivalent to requests~=1.2.0 
+
+Pipenv will install version ``1.2`` and any minor update, but not ``2.0``.
 
 This will update your ``Pipfile`` to reflect this requirement, automatically.
 
-For other version specifiers, see `the relevant section of PEP-440`_.
+In general, Pipenv uses the same specifier format as pip. However, note that according to `PEP 440`_ , you can't use versions containing a hyphen or a plus sign.
+
+.. _`PEP 440`: <https://www.python.org/dev/peps/pep-0440/>
+
+To make inclusive or exclusive version comparisons you can use: ::
+
+    $ pipenv install "requests>=1.4"   # will install a version equal or larger than 1.4.0
+    $ pipenv install "requests<=2.13"  # will install a version equal or lower than 2.13.0
+    $ pipenv install "requests>2.19"   # will install 2.19.1 but not 2.19.0 
+
+.. note:: The use of ``" "`` around the package and version specification is highly recommended 
+    to avoid issues with `Input and output redirection <https://robots.thoughtbot.com/input-output-redirection-in-the-shell>`_
+    in Unix-based operating systems. 
+
+The use of ``~=`` is preferred over the ``==`` identifier as the former prevents pipenv from updating the packages:  ::
+
+    $ pipenv install "requests~=2.2"  # locks the major version of the package (this is equivalent to using ==2.*)
+
+To avoid installing a specific version you can use the ``!=`` identifier.
+
+For an in depth explanation of the valid identifiers and more complex use cases check `the relevant section of PEP-440`_.
 
 .. _`the relevant section of PEP-440`: https://www.python.org/dev/peps/pep-0440/#version-specifiers>
 
diff --git a/docs/dev/contributing.rst b/docs/dev/contributing.rst
index 4cbb9e3f..db7f14cc 100644
--- a/docs/dev/contributing.rst
+++ b/docs/dev/contributing.rst
@@ -67,7 +67,7 @@ Steps for Submitting Code
 When contributing code, you'll want to follow this checklist:
 
 1. Fork the repository on GitHub.
-2. Run the tests to confirm they all pass on your system. If they don't, you'll
+2. `Run the tests`_ to confirm they all pass on your system. If they don't, you'll
    need to investigate why they fail. If you're unable to diagnose this
    yourself, raise it as a bug report by following the guidelines in this
    document: :ref:`bug-reports`.
@@ -120,3 +120,38 @@ 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/pypa/pipenv/issues
+
+Run the tests
+-------------
+
+Three ways of running the tests are as follows:
+
+1. ``make test`` (which uses ``docker``)
+2. ``./run-tests.sh`` or ``run-tests.bat``
+3. Using pipenv::
+
+    pipenv install --dev
+    pipenv run pytest
+
+For the last two, it is important that your environment is setup correctly, and
+this may take some work, for example, on a specific Mac installation, the following
+steps may be needed::
+
+    # Make sure the tests can access github
+    if [ "$SSH_AGENT_PID" = "" ]
+    then
+       eval `ssh-agent`
+       ssh-add
+    fi
+
+    # Use unix like utilities, installed with brew,
+    # e.g. brew install coreutils
+    for d in /usr/local/opt/*/libexec/gnubin /usr/local/opt/python/libexec/bin
+    do
+      [[ ":$PATH:" != *":$d:"* ]] && PATH="$d:${PATH}"
+    done
+
+    export PATH
+
+    # PIP_FIND_LINKS currently breaks test_uninstall.py
+    unset PIP_FIND_LINKS
diff --git a/docs/index.rst b/docs/index.rst
index 957d6c8c..b6822409 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -39,6 +39,12 @@ The problems that Pipenv seeks to solve are multi-faceted:
 - Give you insight into your dependency graph (e.g. ``$ pipenv graph``).
 - Streamline development workflow by loading ``.env`` files.
 
+You can quickly play with Pipenv right in your browser:
+
+.. image:: https://cdn.rawgit.com/rootnroll/library/assets/try.svg
+    :target: https://rootnroll.com/d/pipenv/
+    :alt: Try in browser
+
 
 Install Pipenv Today!
 ---------------------
@@ -102,7 +108,7 @@ Other Commands
 //////////////
 
 - ``graph`` will show you a dependency graph of your installed dependencies.
-- ``shell`` will spawn a shell with the virtualenv activated.
+- ``shell`` will spawn a shell with the virtualenv activated. This shell can be deactivated by using ``exit``.
 - ``run`` will run a given command from the virtualenv, with any arguments forwarded (e.g. ``$ pipenv run python`` or ``$ pipenv run pip freeze``).
 - ``check`` checks for security vulnerabilities and asserts that PEP 508 requirements are being met by the current environment.
 
diff --git a/docs/install.rst b/docs/install.rst
index 9df6a5fc..f529e249 100644
--- a/docs/install.rst
+++ b/docs/install.rst
@@ -119,7 +119,7 @@ To install::
     `modifying ~/.profile`_.
 
     On Windows you can find the user base binary directory by running
-    ``py -m site --user-site`` and replacing ``site-packages`` with
+    ``python -m site --user-site`` and replacing ``site-packages`` with
     ``Scripts``. For example, this could return
     ``C:\Users\Username\AppData\Roaming\Python36\site-packages`` so you would
     need to set your ``PATH`` to include
@@ -222,6 +222,15 @@ your script. It's also possible to spawn a new shell that ensures all commands
 have access to your installed packages with ``$ pipenv shell``.
 
 
+☤ Virtualenv mapping caveat
+============
+
+- Pipenv automatically maps projects to their specific virtualenvs.
+- The virtualenv is stored globally with the name of the project’s root directory plus the hash of the full path to the project's root (e.g., ``my_project-a3de50``).
+- If you change your project's path, you break such a default mapping and pipenv will no longer be able to find and to use the project's virtualenv.
+- You might want to set ``export PIPENV_VENV_IN_PROJECT=1`` in your .bashrc/.zshrc (or any shell configuration file) for creating the virtualenv inside your project's directory, avoiding problems with subsequent path changes.
+
+
 ☤ Next steps
 ============
 
diff --git a/news/1690.bugfix b/news/1690.bugfix
deleted file mode 100644
index ec94c663..00000000
--- a/news/1690.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-VCS Refs for locked local editable dependencies will now update appropriately to the latest hash when running ``pipenv update``.
diff --git a/news/1977.feature.rst b/news/1977.feature.rst
new file mode 100644
index 00000000..33274c0f
--- /dev/null
+++ b/news/1977.feature.rst
@@ -0,0 +1 @@
+Improved exceptions and error handling on failures.
diff --git a/news/2173.bugfix b/news/2173.bugfix
deleted file mode 100644
index 8d79613a..00000000
--- a/news/2173.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-``.tar.gz`` and ``.zip`` artifacts will now have dependencies installed even when they are missing from the lockfile.
diff --git a/news/2279.bugfix b/news/2279.bugfix
deleted file mode 100644
index f211ba47..00000000
--- a/news/2279.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-The command line parser will now handle multiple ``-e/--editable`` dependencies properly via click's option parser to help mitigate future parsing issues.
diff --git a/news/2411.feature.rst b/news/2411.feature.rst
new file mode 100644
index 00000000..d99bfca8
--- /dev/null
+++ b/news/2411.feature.rst
@@ -0,0 +1 @@
+Added improved messaging about available but skipped updates due to dependency conflicts when running ``pipenv update --outdated``.
diff --git a/news/2434.bugfix b/news/2434.bugfix
deleted file mode 100644
index 0a9603e1..00000000
--- a/news/2434.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixed the ability of pipenv to parse ``dependency_links`` from ``setup.py`` when ``PIP_PROCESS_DEPENDENCY_LINKS`` is enabled.
diff --git a/news/2494.bugfix b/news/2494.bugfix
deleted file mode 100644
index 8aab779b..00000000
--- a/news/2494.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixed a bug which could cause ``-i/--index`` arguments to sometimes be incorrectly picked up in packages.  This is now handled in the command line parser.
diff --git a/news/2503.behavior b/news/2503.behavior
deleted file mode 100644
index b32028c7..00000000
--- a/news/2503.behavior
+++ /dev/null
@@ -1,2 +0,0 @@
-Virtual environment activation for ``run`` is revised to improve interpolation
-with other Python discovery tools.
diff --git a/news/2511.behavior b/news/2511.behavior
deleted file mode 100644
index 18a7a40f..00000000
--- a/news/2511.behavior
+++ /dev/null
@@ -1 +0,0 @@
-Improve terminal coloring to display better in Powershell.
diff --git a/news/2515.bugfix b/news/2515.bugfix
deleted file mode 100644
index 0c4e5868..00000000
--- a/news/2515.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fix subshell invocation on Windows for Python 2.
diff --git a/news/2518.behavior b/news/2518.behavior
deleted file mode 100644
index a097e558..00000000
--- a/news/2518.behavior
+++ /dev/null
@@ -1 +0,0 @@
-Invoke ``virtualenv`` directly for virtual environment creation, instead of depending on ``pew``.
diff --git a/news/2521.vendor b/news/2521.vendor
deleted file mode 100644
index b2c652a6..00000000
--- a/news/2521.vendor
+++ /dev/null
@@ -1,2 +0,0 @@
-Pew is no longer vendored. Entry point ``pewtwo``, packages ``pipenv.pew`` and
-``pipenv.patched.pew`` are removed.
diff --git a/news/2527.feature b/news/2527.feature
deleted file mode 100644
index ad8e5c30..00000000
--- a/news/2527.feature
+++ /dev/null
@@ -1,2 +0,0 @@
-Added environment variables `PIPENV_VERBOSE` and `PIPENV_QUIET` to control
-output verbosity without needing to pass options.
diff --git a/news/2542.behavior b/news/2542.behavior
deleted file mode 100644
index 245bae63..00000000
--- a/news/2542.behavior
+++ /dev/null
@@ -1 +0,0 @@
-``pipenv --help`` will now include short help descriptions.
diff --git a/news/2561.bugfix b/news/2561.bugfix
deleted file mode 100644
index 98f1738b..00000000
--- a/news/2561.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixed a bug which sometimes caused pipenv to throw a ``TypeError`` or to run into encoding issues when writing lockfiles on python 2.
diff --git a/news/2563.bugfix b/news/2563.bugfix
deleted file mode 100644
index 4d2e6570..00000000
--- a/news/2563.bugfix
+++ /dev/null
@@ -1,2 +0,0 @@
-Improve quoting logic for ``pipenv run`` so it works better with Windows
-built-in commands.
diff --git a/news/2564.bugfix b/news/2564.bugfix
deleted file mode 100644
index 31fc0b1a..00000000
--- a/news/2564.bugfix
+++ /dev/null
@@ -1,2 +0,0 @@
-Fixed a bug related to parsing vcs requirements with both extras and subdirectory fragments.
-Corrected an issue in the ``requirementslib`` parser which led to some markers being discarded rather than evaluated.
diff --git a/news/2568.doc b/news/2568.doc
deleted file mode 100644
index ab2644ff..00000000
--- a/news/2568.doc
+++ /dev/null
@@ -1,2 +0,0 @@
-Simplified the test configuration process.
-
diff --git a/news/2568.feature b/news/2568.feature
deleted file mode 100644
index 47972186..00000000
--- a/news/2568.feature
+++ /dev/null
@@ -1,2 +0,0 @@
-Updated test-pypi addon to better support json-api access (forward compatibility).
-Improved testing process for new contributors.
diff --git a/news/2582.bugfix b/news/2582.bugfix
deleted file mode 100644
index f434be81..00000000
--- a/news/2582.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixed multiple issues with finding the correct system python locations.
diff --git a/news/2582.feature b/news/2582.feature
deleted file mode 100644
index 4d1f7a36..00000000
--- a/news/2582.feature
+++ /dev/null
@@ -1,4 +0,0 @@
-Greatly enhanced python discovery functionality:
-
-- Added pep514 (windows launcher/finder) support for python discovery.
-- Introduced architecture discovery for python installations which support different architectures.
diff --git a/news/2582.vendor b/news/2582.vendor
deleted file mode 100644
index 1a031eb7..00000000
--- a/news/2582.vendor
+++ /dev/null
@@ -1 +0,0 @@
-Update ``pythonfinder`` to major release ``1.0.0`` for integration.
diff --git a/news/2607.bugfix b/news/2607.bugfix
deleted file mode 100644
index 101124a8..00000000
--- a/news/2607.bugfix
+++ /dev/null
@@ -1,2 +0,0 @@
-Catch JSON decoding error to prevent exception when the lock file is of
-invalid format.
diff --git a/news/2610.bugfix b/news/2610.bugfix
deleted file mode 100644
index f20eff45..00000000
--- a/news/2610.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixed a rare bug which could sometimes cause errors when installing packages with custom sources.
diff --git a/news/2617.bugfix b/news/2617.bugfix
deleted file mode 100644
index 2a2c5842..00000000
--- a/news/2617.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Update requirementslib to fix a bug which could raise an ``UnboundLocalError`` when parsing malformed VCS URIs.
diff --git a/news/2617.vendor b/news/2617.vendor
deleted file mode 100644
index 2a2c5842..00000000
--- a/news/2617.vendor
+++ /dev/null
@@ -1 +0,0 @@
-Update requirementslib to fix a bug which could raise an ``UnboundLocalError`` when parsing malformed VCS URIs.
diff --git a/news/2632.bugfix b/news/2632.bugfix
deleted file mode 100644
index eff1d897..00000000
--- a/news/2632.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixed an issue which prevented passing multiple ``--ignore`` parameters to ``pipenv check``.
diff --git a/news/2639.bugfix b/news/2639.bugfix
deleted file mode 100644
index c1036f7b..00000000
--- a/news/2639.bugfix
+++ /dev/null
@@ -1,2 +0,0 @@
-Fixed a bug which caused attempted hashing of ``ssh://`` style URIs which could cause failures during installation of private ssh repositories.
-- Corrected path conversion issues which caused certain editable VCS paths to be converted to ``ssh://`` URIs improperly.
diff --git a/news/2639.vendor b/news/2639.vendor
deleted file mode 100644
index b159c33f..00000000
--- a/news/2639.vendor
+++ /dev/null
@@ -1,14 +0,0 @@
-- Vendored new libraries ``vistir`` and ``pip-shims``, ``tomlkit``, ``modutil``, and ``plette``.
-
-- Update vendored libraries:
-  - ``scandir`` to ``1.9.0``
-  - ``click-completion`` to ``0.4.1``
-  - ``semver`` to ``2.8.1``
-  - ``shellingham`` to ``1.2.4``
-  - ``pytoml`` to ``0.1.18``
-  - ``certifi`` to ``2018.8.24``
-  - ``ptyprocess`` to ``0.6.0``
-  - ``requirementslib`` to ``1.1.5``
-  - ``pythonfinder`` to ``1.0.2``
-  - ``pipdeptree`` to ``0.13.0``
-  - ``python-dotenv`` to ``0.9.1``
diff --git a/news/2641.bugfix b/news/2641.bugfix
deleted file mode 100644
index 6b19fcc5..00000000
--- a/news/2641.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixed a bug which caused paths to be formatted incorrectly when using ``pipenv shell`` in bash for windows.
diff --git a/news/2641.feature b/news/2641.feature
deleted file mode 100644
index c8de0dd9..00000000
--- a/news/2641.feature
+++ /dev/null
@@ -1 +0,0 @@
-Added support for ``pipenv shell`` on msys and cygwin/mingw/git bash for windwos.
diff --git a/news/2643.bugfix b/news/2643.bugfix
deleted file mode 100644
index 566879af..00000000
--- a/news/2643.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Dependency links to private repositories defined via ``ssh://`` schemes will now install correctly and skip hashing as long as ``PIP_PROCESS_DEPENDENCY_LINKS=1``.
diff --git a/news/2643.feature b/news/2643.feature
deleted file mode 100644
index 052398c7..00000000
--- a/news/2643.feature
+++ /dev/null
@@ -1 +0,0 @@
-Enhanced resolution of editable and VCS dependencies.
diff --git a/news/2644.doc b/news/2644.doc
deleted file mode 100644
index 7087c719..00000000
--- a/news/2644.doc
+++ /dev/null
@@ -1 +0,0 @@
-Updated documentation to use working fortune cookie addon.
diff --git a/news/2651.behavior b/news/2651.behavior
deleted file mode 100644
index be5f2d01..00000000
--- a/news/2651.behavior
+++ /dev/null
@@ -1,2 +0,0 @@
-Add ``COMSPEC`` to fallback option (along with ``SHELL`` and ``PYENV_SHELL``)
-if shell detection fails, improving robustness on Windows.
diff --git a/news/2656.bugfix b/news/2656.bugfix
deleted file mode 100644
index c9b26c47..00000000
--- a/news/2656.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixed a bug which sometimes caused pipenv to parse the ``trusted_host`` argument to pip incorrectly when parsing source URLs which specify ``verify_ssl = false``.
diff --git a/news/2671.doc b/news/2671.doc
deleted file mode 100644
index 859cc377..00000000
--- a/news/2671.doc
+++ /dev/null
@@ -1 +0,0 @@
-Added additional information about troubleshooting ``pipenv shell`` by using the the ``$PIPENV_SHELL`` environment variable.
diff --git a/news/2674.doc b/news/2674.doc
deleted file mode 100644
index 33fbd49e..00000000
--- a/news/2674.doc
+++ /dev/null
@@ -1 +0,0 @@
-Added a link to ``PEP-440`` version specifiers in the documentation for additional detail.
diff --git a/news/2676.bugfix b/news/2676.bugfix
deleted file mode 100644
index fb47d64b..00000000
--- a/news/2676.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Prevent crashing when a virtual environment in ``WORKON_HOME`` is faulty.
diff --git a/news/2680.bugfix b/news/2680.bugfix
deleted file mode 100644
index 405fb1dd..00000000
--- a/news/2680.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixed virtualenv creation failure when a .venv file is present in the project root.
diff --git a/news/2685.doc b/news/2685.doc
deleted file mode 100644
index 6f2a0aff..00000000
--- a/news/2685.doc
+++ /dev/null
@@ -1 +0,0 @@
-Added simple example to README.md for installing from git.
diff --git a/news/2696.trivial b/news/2696.trivial
deleted file mode 100644
index dc68eca0..00000000
--- a/news/2696.trivial
+++ /dev/null
@@ -1 +0,0 @@
-Added additional information to error messaging during failed resolution.
diff --git a/news/2714.bugfix b/news/2714.bugfix
deleted file mode 100644
index 74c7fac0..00000000
--- a/news/2714.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixed a bug which could cause the ``-e/--editable`` argument on a dependency to be accidentally parsed as a dependency itself.
diff --git a/news/2718.behavior b/news/2718.behavior
deleted file mode 100644
index c00b1d46..00000000
--- a/news/2718.behavior
+++ /dev/null
@@ -1 +0,0 @@
-Fallback to shell mode if `run` fails with Windows error 193 to handle non-executable commands. This should improve usability on Windows, where some users run non-executable files without specifying a command, relying on Windows file association to choose the current command.
diff --git a/news/2732.bugfix b/news/2732.bugfix
deleted file mode 100644
index d1cf591b..00000000
--- a/news/2732.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Correctly pass `verbose` and `debug` flags to the resolver subprocess so it generates appropriate output. This also resolves a bug introduced by the fix to #2527.
diff --git a/news/2748.bugfix b/news/2748.bugfix
deleted file mode 100644
index fc807047..00000000
--- a/news/2748.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-All markers are now included in ``pipenv lock --requirements`` output.
diff --git a/news/2754.trivial b/news/2754.trivial
deleted file mode 100644
index 64ce2f5d..00000000
--- a/news/2754.trivial
+++ /dev/null
@@ -1 +0,0 @@
-Added a warning message if the ``PIPENV_DOTENV_LOCATION`` environment variable is set but the specified file does not exist.
diff --git a/news/2760.bugfix b/news/2760.bugfix
deleted file mode 100644
index 11bc2e63..00000000
--- a/news/2760.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixed a bug in marker resolution which could cause duplicate and non-deterministic markers.
diff --git a/news/2762.doc b/news/2762.doc
deleted file mode 100644
index d2e6fe48..00000000
--- a/news/2762.doc
+++ /dev/null
@@ -1 +0,0 @@
-Stopped recommending `--system` for Docker contexts.
diff --git a/news/2766.bugfix b/news/2766.bugfix
deleted file mode 100644
index f83cd084..00000000
--- a/news/2766.bugfix
+++ /dev/null
@@ -1 +0,0 @@
-Fixed a bug in the dependency resolver which caused regular issues when handling ``setup.py`` based dependency resolution.
diff --git a/news/2792.doc b/news/2792.doc
deleted file mode 100644
index 7695f020..00000000
--- a/news/2792.doc
+++ /dev/null
@@ -1,3 +0,0 @@
-Fixed the example url for doing "pipenv install -e
-some-repo-url#egg=something", it was missing the "egg=" in the fragment
-identifier.
\ No newline at end of file
diff --git a/news/2793.doc b/news/2793.doc
deleted file mode 100644
index a73814c7..00000000
--- a/news/2793.doc
+++ /dev/null
@@ -1 +0,0 @@
-Fixed link to the "be cordial" essay in the contribution documentation.
\ No newline at end of file
diff --git a/news/2808.trivial b/news/2808.trivial
deleted file mode 100644
index 04c2f48b..00000000
--- a/news/2808.trivial
+++ /dev/null
@@ -1 +0,0 @@
-Fix 2 ResourceWarning: unclosed file, in tests.
diff --git a/news/2814.feature b/news/2814.feature
deleted file mode 100644
index 01818bc2..00000000
--- a/news/2814.feature
+++ /dev/null
@@ -1 +0,0 @@
-Deduplicate and refactor CLI to use stateful arguments and object passing.  See `this issue <https://github.com/pallets/click/issues/108>`_ for reference.
diff --git a/news/2828.feature.rst b/news/2828.feature.rst
new file mode 100644
index 00000000..688c47ee
--- /dev/null
+++ b/news/2828.feature.rst
@@ -0,0 +1 @@
+Added additional output to ``pipenv update --outdated`` to indicate that the operation succeded and all packages were already up to date.
diff --git a/news/2844.doc b/news/2844.doc
deleted file mode 100644
index 28f26514..00000000
--- a/news/2844.doc
+++ /dev/null
@@ -1 +0,0 @@
-Clarify `pipenv install` documentation
diff --git a/news/2885.bugfix.rst b/news/2885.bugfix.rst
new file mode 100644
index 00000000..72a7656c
--- /dev/null
+++ b/news/2885.bugfix.rst
@@ -0,0 +1 @@
+Fixed a bug which caused uninstallation to sometimes fail to successfullly remove packages from ``Pipfiles`` with comments on preceding or following lines.
diff --git a/news/2996.trivial b/news/2996.trivial
new file mode 100644
index 00000000..dbe1006a
--- /dev/null
+++ b/news/2996.trivial
@@ -0,0 +1 @@
+Set `PIPENV_ACTIVE=1` when running `pipenv run`.  This is what `pipenv shell` already does.
\ No newline at end of file
diff --git a/news/3020.feature.rst b/news/3020.feature.rst
new file mode 100644
index 00000000..aebfab57
--- /dev/null
+++ b/news/3020.feature.rst
@@ -0,0 +1 @@
+Updated ``crayons`` patch to enable colors on native powershell but swap native blue for magenta.
diff --git a/news/3026.bugfix b/news/3026.bugfix
new file mode 100644
index 00000000..6a194d1f
--- /dev/null
+++ b/news/3026.bugfix
@@ -0,0 +1 @@
+Fixed unnecessary extras are added when translating markers
diff --git a/news/3041.feature b/news/3041.feature
new file mode 100644
index 00000000..79a1d5de
--- /dev/null
+++ b/news/3041.feature
@@ -0,0 +1 @@
+--bare now has an effect on clean, and sync's bare option is now used to reduce output.
diff --git a/news/3047.bugfix.rst b/news/3047.bugfix.rst
new file mode 100644
index 00000000..6c44bd42
--- /dev/null
+++ b/news/3047.bugfix.rst
@@ -0,0 +1 @@
+Fixed a virtualenv creation issue which could cause new virtualenvs to inadvertently attempt to read and write to global site packages.
diff --git a/news/3055.bugfix.rst b/news/3055.bugfix.rst
new file mode 100644
index 00000000..7b2a0fa1
--- /dev/null
+++ b/news/3055.bugfix.rst
@@ -0,0 +1 @@
+Fixed an issue with virtualenv path derivation which could cause errors, particularly for users on WSL bash.
diff --git a/news/3069.trivial b/news/3069.trivial
new file mode 100644
index 00000000..733a3cac
--- /dev/null
+++ b/news/3069.trivial
@@ -0,0 +1 @@
+- Fix PIPENV_VERBOSITY parsing logic
diff --git a/news/3074.doc.rst b/news/3074.doc.rst
new file mode 100644
index 00000000..85feefd5
--- /dev/null
+++ b/news/3074.doc.rst
@@ -0,0 +1 @@
+Expanded development and testing documentation for contributors to get started.
diff --git a/news/3088.bugfix.rst b/news/3088.bugfix.rst
new file mode 100644
index 00000000..b10c4b2b
--- /dev/null
+++ b/news/3088.bugfix.rst
@@ -0,0 +1 @@
+Fixed a bug which caused ``Unexpected EOF`` errors to be thrown when PIP awaited input from users who put login credentials in their environment.
diff --git a/news/3089.feature.rst b/news/3089.feature.rst
new file mode 100644
index 00000000..47f280ee
--- /dev/null
+++ b/news/3089.feature.rst
@@ -0,0 +1 @@
+Added windows-compatible spinner via upgraded ``vistir`` dependency.
diff --git a/news/3089.vendor.rst b/news/3089.vendor.rst
new file mode 100644
index 00000000..c57209f6
--- /dev/null
+++ b/news/3089.vendor.rst
@@ -0,0 +1,11 @@
+Updated vendored dependencies:
+  - ``certifi 2018.08.24 => 2018.10.15``
+  - ``urllib3 1.23 => 1.24``
+  - ``requests 2.19.1 => 2.20.0``
+  - ``shellingham ``1.2.6 => 1.2.7``
+  - ``tomlkit 0.4.4. => 0.4.6``
+  - ``vistir 0.1.6 => 0.1.8``
+  - ``pythonfinder 0.1.2 => 0.1.3``
+  - ``requirementslib 1.1.9 => 1.1.10``
+  - ``backports.functools_lru_cache 1.5.0 (new)``
+  - ``cursor 1.2.0 (new)``
diff --git a/news/3090.bugfix.rst b/news/3090.bugfix.rst
new file mode 100644
index 00000000..af772c3d
--- /dev/null
+++ b/news/3090.bugfix.rst
@@ -0,0 +1 @@
+Fixed a bug in ``requirementslib`` which prevented successful installation from mercurial repositories.
diff --git a/news/3094.bugfix.rst b/news/3094.bugfix.rst
new file mode 100644
index 00000000..e17b2e32
--- /dev/null
+++ b/news/3094.bugfix.rst
@@ -0,0 +1 @@
+Fixed random resource warnings when using pyenv or any other subprocess calls.
diff --git a/news/3099.bugfix.rst b/news/3099.bugfix.rst
new file mode 100644
index 00000000..72a7656c
--- /dev/null
+++ b/news/3099.bugfix.rst
@@ -0,0 +1 @@
+Fixed a bug which caused uninstallation to sometimes fail to successfullly remove packages from ``Pipfiles`` with comments on preceding or following lines.
diff --git a/news/3102.bugfix.rst b/news/3102.bugfix.rst
new file mode 100644
index 00000000..2224ac0b
--- /dev/null
+++ b/news/3102.bugfix.rst
@@ -0,0 +1 @@
+Fixed an issue in ``delegator.py`` related to subprocess calls when using ``PopenSpawn`` to stream output, which sometimes threw unexpected ``EOF`` errors.
diff --git a/news/3104.bugfix b/news/3104.bugfix
new file mode 100644
index 00000000..1915494d
--- /dev/null
+++ b/news/3104.bugfix
@@ -0,0 +1 @@
+Fix the path casing issue that makes `pipenv clean` fail on Windows
diff --git a/news/3109.bugfix.rst b/news/3109.bugfix.rst
new file mode 100644
index 00000000..af5718b6
--- /dev/null
+++ b/news/3109.bugfix.rst
@@ -0,0 +1 @@
+Fixed issues with broken subprocess calls leaking resource handles and causing random and sporadic failures.
diff --git a/news/3113.bugfix.rst b/news/3113.bugfix.rst
new file mode 100644
index 00000000..75ee6de4
--- /dev/null
+++ b/news/3113.bugfix.rst
@@ -0,0 +1 @@
+Fixed an issue which caused ``pipenv clean`` to sometimes clean packages from the base ``site-packages`` folder or fail entirely.
diff --git a/news/3114.bugfix.rst b/news/3114.bugfix.rst
new file mode 100644
index 00000000..2224ac0b
--- /dev/null
+++ b/news/3114.bugfix.rst
@@ -0,0 +1 @@
+Fixed an issue in ``delegator.py`` related to subprocess calls when using ``PopenSpawn`` to stream output, which sometimes threw unexpected ``EOF`` errors.
diff --git a/news/3117.bugfix.rst b/news/3117.bugfix.rst
new file mode 100644
index 00000000..2224ac0b
--- /dev/null
+++ b/news/3117.bugfix.rst
@@ -0,0 +1 @@
+Fixed an issue in ``delegator.py`` related to subprocess calls when using ``PopenSpawn`` to stream output, which sometimes threw unexpected ``EOF`` errors.
diff --git a/news/3121.bugfix.rst b/news/3121.bugfix.rst
new file mode 100644
index 00000000..fb815c42
--- /dev/null
+++ b/news/3121.bugfix.rst
@@ -0,0 +1 @@
+Updated ``pythonfinder`` to correct an issue with unnesting of nested paths when searching for python versions.
diff --git a/news/3121.vendor.rst b/news/3121.vendor.rst
new file mode 100644
index 00000000..fb815c42
--- /dev/null
+++ b/news/3121.vendor.rst
@@ -0,0 +1 @@
+Updated ``pythonfinder`` to correct an issue with unnesting of nested paths when searching for python versions.
diff --git a/news/3131.bugfix.rst b/news/3131.bugfix.rst
new file mode 100644
index 00000000..6eaa4bdd
--- /dev/null
+++ b/news/3131.bugfix.rst
@@ -0,0 +1 @@
+Added additional logic for ignoring and replacing non-ascii characters when formatting console output on non-UTF-8 systems.
diff --git a/news/3134.bugfix.rst b/news/3134.bugfix.rst
new file mode 100644
index 00000000..9193321a
--- /dev/null
+++ b/news/3134.bugfix.rst
@@ -0,0 +1 @@
+Fix virtual environment discovery when `PIPENV_VENV_IN_PROJECT` is set, but the in-project `.venv` is a file.
diff --git a/pipenv/__init__.py b/pipenv/__init__.py
index 471dcb94..f8a1a8b3 100644
--- a/pipenv/__init__.py
+++ b/pipenv/__init__.py
@@ -1,11 +1,14 @@
+# -*- coding=utf-8 -*-
 # |~~\'    |~~
 # |__/||~~\|--|/~\\  /
 # |   ||__/|__|   |\/
 #      |
+
 import os
 import sys
-from .__version__ import __version__
+import warnings
 
+from .__version__ import __version__
 
 PIPENV_ROOT = os.path.dirname(os.path.realpath(__file__))
 PIPENV_VENDOR = os.sep.join([PIPENV_ROOT, "vendor"])
@@ -14,12 +17,29 @@ PIPENV_PATCHED = os.sep.join([PIPENV_ROOT, "patched"])
 sys.path.insert(0, PIPENV_VENDOR)
 # Inject patched directory into system path.
 sys.path.insert(0, PIPENV_PATCHED)
+
+from pipenv.vendor.urllib3.exceptions import DependencyWarning
+from pipenv.vendor.vistir.compat import ResourceWarning, fs_str
+warnings.filterwarnings("ignore", category=DependencyWarning)
+warnings.filterwarnings("ignore", category=ResourceWarning)
+warnings.filterwarnings("ignore", category=UserWarning)
+
+if sys.version_info >= (3, 1) and sys.version_info <= (3, 6):
+    if sys.stdout.isatty() and sys.stderr.isatty():
+        import io
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf8')
+        sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf8')
+
+os.environ["PIP_DISABLE_PIP_VERSION_CHECK"] = fs_str("1")
+os.environ["PIP_SHIMS_BASE_MODULE"] = fs_str("pipenv.patched.notpip")
+
 # Hack to make things work better.
 try:
     if "concurrency" in sys.modules:
         del sys.modules["concurrency"]
 except Exception:
     pass
+
 from .cli import cli
 from . import resolver
 
diff --git a/pipenv/__version__.py b/pipenv/__version__.py
index 104f7941..b2df6ad1 100644
--- a/pipenv/__version__.py
+++ b/pipenv/__version__.py
@@ -2,4 +2,4 @@
 #   //   ) ) / / //   ) ) //___) ) //   ) ) ||  / /
 #  //___/ / / / //___/ / //       //   / /  || / /
 # //       / / //       ((____   //   / /   ||/ /
-__version__ = "2018.7.1.dev0"
+__version__ = "2018.10.14.dev0"
diff --git a/pipenv/_compat.py b/pipenv/_compat.py
index 558df3b8..6e5ae6a7 100644
--- a/pipenv/_compat.py
+++ b/pipenv/_compat.py
@@ -11,6 +11,7 @@ import os
 import six
 import sys
 import warnings
+import vistir
 from tempfile import _bin_openflags, gettempdir, _mkstemp_inner, mkdtemp
 from .utils import logging, rmtree
 
@@ -59,10 +60,10 @@ except ImportError:
                 return False
 
 
-if six.PY2:
+from vistir.compat import ResourceWarning
 
-    class ResourceWarning(Warning):
-        pass
+
+warnings.filterwarnings("ignore", category=ResourceWarning)
 
 
 def pip_import(module_path, subimport=None, old_path=None):
@@ -300,3 +301,102 @@ def NamedTemporaryFile(
         os.unlink(name)
         os.close(fd)
         raise
+
+
+def getpreferredencoding():
+    import locale
+    # Borrowed from Invoke
+    # (see https://github.com/pyinvoke/invoke/blob/93af29d/invoke/runners.py#L881)
+    _encoding = locale.getpreferredencoding(False)
+    if six.PY2 and not sys.platform == "win32":
+        _default_encoding = locale.getdefaultlocale()[1]
+        if _default_encoding is not None:
+            _encoding = _default_encoding
+    return _encoding
+
+
+DEFAULT_ENCODING = getpreferredencoding()
+
+
+# From https://github.com/CarlFK/veyepar/blob/5c5de47/dj/scripts/fixunicode.py
+# MIT LIcensed, thanks Carl!
+def force_encoding():
+    try:
+        stdout_isatty = sys.stdout.isatty
+        stderr_isatty = sys.stderr.isatty
+    except AttributeError:
+        return DEFAULT_ENCODING, DEFAULT_ENCODING
+    else:
+        if not (stdout_isatty() and stderr_isatty()):
+            return DEFAULT_ENCODING, DEFAULT_ENCODING
+    stdout_encoding = sys.stdout.encoding
+    stderr_encoding = sys.stderr.encoding
+    if sys.platform == "win32" and sys.version_info >= (3, 1):
+        return DEFAULT_ENCODING, DEFAULT_ENCODING
+    if stdout_encoding.lower() != "utf-8" or stderr_encoding.lower() != "utf-8":
+
+        from ctypes import pythonapi, py_object, c_char_p
+        try:
+            PyFile_SetEncoding = pythonapi.PyFile_SetEncoding
+        except AttributeError:
+            return DEFAULT_ENCODING, DEFAULT_ENCODING
+        else:
+            PyFile_SetEncoding.argtypes = (py_object, c_char_p)
+            if stdout_encoding.lower() != "utf-8":
+                try:
+                    was_set = PyFile_SetEncoding(sys.stdout, "utf-8")
+                except OSError:
+                    was_set = False
+                if not was_set:
+                    stdout_encoding = DEFAULT_ENCODING
+                else:
+                    stdout_encoding = "utf-8"
+
+            if stderr_encoding.lower() != "utf-8":
+                try:
+                    was_set = PyFile_SetEncoding(sys.stderr, "utf-8")
+                except OSError:
+                    was_set = False
+                if not was_set:
+                    stderr_encoding = DEFAULT_ENCODING
+                else:
+                    stderr_encoding = "utf-8"
+
+    return stdout_encoding, stderr_encoding
+
+
+OUT_ENCODING, ERR_ENCODING = force_encoding()
+
+
+UNICODE_TO_ASCII_TRANSLATION_MAP = {
+    8230: u"...",
+    8211: u"-"
+}
+
+
+def decode_output(output):
+    if not isinstance(output, six.string_types):
+        return output
+    try:
+        output = output.encode(DEFAULT_ENCODING)
+    except (AttributeError, UnicodeDecodeError, UnicodeEncodeError):
+        if six.PY2:
+            output = unicode.translate(vistir.misc.to_text(output),
+                                            UNICODE_TO_ASCII_TRANSLATION_MAP)
+        else:
+            output = output.translate(UNICODE_TO_ASCII_TRANSLATION_MAP)
+        output = output.encode(DEFAULT_ENCODING, "replace")
+    return vistir.misc.to_text(output, encoding=DEFAULT_ENCODING, errors="replace")
+    return output
+
+
+def fix_utf8(text):
+    if not isinstance(text, six.string_types):
+        return text
+    from ._compat import decode_output
+    try:
+        text = decode_output(text)
+    except UnicodeDecodeError:
+        if six.PY2:
+            text = unicode.translate(vistir.misc.to_text(text), UNICODE_TO_ASCII_TRANSLATION_MAP)
+    return text
diff --git a/pipenv/cli/command.py b/pipenv/cli/command.py
index b552778f..40d3f0fe 100644
--- a/pipenv/cli/command.py
+++ b/pipenv/cli/command.py
@@ -268,7 +268,9 @@ def install(
 )
 @uninstall_options
 @pass_state
+@pass_context
 def uninstall(
+    ctx,
     state,
     lock=False,
     all_dev=False,
@@ -289,6 +291,7 @@ def uninstall(
         all=all,
         keep_outdated=state.installstate.keep_outdated,
         pypi_mirror=state.pypi_mirror,
+        ctx=ctx
     )
     if retcode:
         sys.exit(retcode)
@@ -297,7 +300,9 @@ def uninstall(
 @cli.command(short_help="Generates Pipfile.lock.")
 @lock_options
 @pass_state
+@pass_context
 def lock(
+    ctx,
     state,
     **kwargs
 ):
@@ -308,8 +313,9 @@ def lock(
     ensure_project(three=state.three, python=state.python, pypi_mirror=state.pypi_mirror)
     if state.installstate.requirementstxt:
         do_init(dev=state.installstate.dev, requirements=state.installstate.requirementstxt,
-                        pypi_mirror=state.pypi_mirror)
+                        pypi_mirror=state.pypi_mirror, pre=state.installstate.pre)
     do_lock(
+        ctx=ctx,
         clear=state.clear,
         pre=state.installstate.pre,
         keep_outdated=state.installstate.keep_outdated,
@@ -533,7 +539,13 @@ def graph(bare=False, json=False, json_tree=False, reverse=False):
 @argument("module", nargs=1)
 @pass_state
 def run_open(state, module, *args, **kwargs):
-    """View a given module in your editor."""
+    """View a given module in your editor.
+
+    This uses the EDITOR environment variable. You can temporarily override it,
+    for example:
+
+        EDITOR=atom pipenv open requests
+    """
     from ..core import which, ensure_project
 
     # Ensure that virtualenv is available.
@@ -590,6 +602,7 @@ def sync(
 
 
 @cli.command(short_help="Uninstalls all packages not specified in Pipfile.lock.")
+@option("--bare", is_flag=True, default=False, help="Minimal output.")
 @option("--dry-run", is_flag=True, default=False, help="Just output unneeded packages.")
 @verbose_option
 @three_option
diff --git a/pipenv/core.py b/pipenv/core.py
index 91633aed..b97b1a73 100644
--- a/pipenv/core.py
+++ b/pipenv/core.py
@@ -1,11 +1,11 @@
 # -*- coding=utf-8 -*-
+
 import contextlib
 import logging
 import os
 import sys
 import shutil
 import time
-import tempfile
 import json as simplejson
 import click
 import click_completion
@@ -13,9 +13,13 @@ import crayons
 import dotenv
 import delegator
 import pipfile
-from blindspin import spinner
+import vistir
+import warnings
 import six
 
+import urllib3.util as urllib3_util
+from functools import partial
+
 from .cmdparse import Script
 from .project import Project, SourceNotFound
 from .utils import (
@@ -23,8 +27,6 @@ from .utils import (
     is_required_version,
     proper_case,
     pep423_name,
-    split_file,
-    merge_deps,
     venv_resolve_deps,
     escape_grouped_arguments,
     python_version,
@@ -37,16 +39,15 @@ from .utils import (
     is_pinned,
     is_star,
     rmtree,
-    fs_str,
     clean_resolved_dep,
+    parse_indexes,
+    escape_cmd,
+    fix_venv_site
 )
-from ._compat import TemporaryDirectory, Path
 from . import environments, pep508checker, progress
 from .environments import (
     PIPENV_COLORBLIND,
-    PIPENV_NOSPIN,
     PIPENV_SHELL_FANCY,
-    PIPENV_TIMEOUT,
     PIPENV_SKIP_VALIDATION,
     PIPENV_HIDE_EMOJIS,
     PIPENV_YES,
@@ -57,6 +58,8 @@ from .environments import (
     PIPENV_CACHE_DIR,
     PIPENV_PYUP_API_KEY,
 )
+from ._compat import fix_utf8
+from . import exceptions
 
 # Packages that should be ignored later.
 BAD_PACKAGES = (
@@ -67,6 +70,8 @@ BAD_PACKAGES = (
     "setuptools",
     "wheel",
 )
+
+FIRST_PACKAGES = ("cython",)
 # Are we using the default Python?
 USING_DEFAULT_PYTHON = True
 if not PIPENV_HIDE_EMOJIS:
@@ -94,19 +99,36 @@ click_completion.init()
 # Disable colors, for the color blind and others who do not prefer colors.
 if PIPENV_COLORBLIND:
     crayons.disable()
-# Disable spinner, for cleaner build logs (the unworthy).
-if PIPENV_NOSPIN:
 
-    @contextlib.contextmanager  # noqa: F811
-    def spinner():
-        yield
+
+@contextlib.contextmanager
+def _spinner(text=None, nospin=None, spinner_name=None):
+    if not text:
+        text = "Running..."
+    if not spinner_name:
+        spinner_name = environments.PIPENV_SPINNER
+    if nospin is None:
+        nospin = environments.PIPENV_NOSPIN
+    with vistir.spin.create_spinner(
+            spinner_name=spinner_name,
+            start_text=text,
+            nospin=nospin
+    ) as sp:
+        yield sp
+
+
+spinner = partial(_spinner, text="Running...", nospin=environments.PIPENV_NOSPIN,
+                        spinner_name=environments.PIPENV_SPINNER)
 
 
 def which(command, location=None, allow_global=False):
     if not allow_global and location is None:
-        location = project.virtualenv_location or os.environ.get("VIRTUAL_ENV", "")
-    if not location and os.path.exists(location):
-        raise RuntimeError("virtualenv not created nor specified")
+        if project.virtualenv_exists:
+            location = project.virtualenv_location
+        else:
+            location = os.environ.get("VIRTUAL_ENV", None)
+    if not (location and os.path.exists(location)) and not allow_global:
+        raise RuntimeError("location not created nor specified")
     if not allow_global:
         if os.name == "nt":
             p = find_windows_executable(os.path.join(location, "Scripts"), command)
@@ -127,7 +149,7 @@ project = Project(which=which)
 
 
 def do_clear():
-    click.echo(crayons.white("Clearing caches…", bold=True))
+    click.echo(crayons.white(fix_utf8("Clearing caches…"), bold=True))
     try:
         from pip._internal import locations
     except ImportError:  # pip 9.
@@ -156,7 +178,7 @@ def load_dot_env():
 
         if os.path.isfile(dotenv_file):
             click.echo(
-                crayons.normal("Loading .env environment variables…", bold=True),
+                crayons.normal(fix_utf8("Loading .env environment variables…"), bold=True),
                 err=True,
             )
         else:
@@ -199,7 +221,7 @@ def cleanup_virtualenv(bare=True):
 
 def import_requirements(r=None, dev=False):
     from .patched.notpip._vendor import requests as pip_requests
-    from .patched.notpip._internal.req.req_file import parse_requirements
+    from .vendor.pip_shims.shims import parse_requirements
 
     # Parse requirements.txt file with Pip's parser.
     # Pip requires a `PipSession` which is a subclass of requests.Session.
@@ -212,10 +234,14 @@ def import_requirements(r=None, dev=False):
     with open(r, "r") as f:
         contents = f.read()
     indexes = []
+    trusted_hosts = []
     # Find and add extra indexes.
     for line in contents.split("\n"):
-        if line.startswith(("-i ", "--index ", "--index-url ")):
-            indexes.append(line.split()[1])
+        line_indexes, _trusted_hosts, _ = parse_indexes(line.strip())
+        indexes.extend(line_indexes)
+        trusted_hosts.extend(_trusted_hosts)
+    indexes = sorted(set(indexes))
+    trusted_hosts = sorted(set(trusted_hosts))
     reqs = [f for f in parse_requirements(r, session=pip_requests)]
     for package in reqs:
         if package.name not in BAD_PACKAGES:
@@ -229,7 +255,8 @@ def import_requirements(r=None, dev=False):
             else:
                 project.add_package_to_pipfile(str(package.req), dev=dev)
     for index in indexes:
-        project.add_index_to_pipfile(index)
+        trusted = index in trusted_hosts
+        project.add_index_to_pipfile(index, verify_ssl=trusted)
     project.recase_pipfile()
 
 
@@ -273,27 +300,30 @@ def ensure_pipfile(validate=True, skip_requirements=False, system=False):
     if project.pipfile_is_empty:
         # Show an error message and exit if system is passed and no pipfile exists
         if system and not PIPENV_VIRTUALENV:
-            click.echo(
-                "{0}: --system is intended to be used for pre-existing Pipfile "
-                "installation, not installation of specific packages. Aborting.".format(
-                    crayons.red("Warning", bold=True)
-                ),
-                err=True,
+            raise exceptions.PipenvOptionsError("--system",
+                "--system is intended to be used for pre-existing Pipfile "
+                "installation, not installation of specific packages. Aborting."
             )
-            sys.exit(1)
         # If there's a requirements file, but no Pipfile…
         if project.requirements_exists and not skip_requirements:
             click.echo(
                 crayons.normal(
-                    u"requirements.txt found, instead of Pipfile! Converting…",
+                    fix_utf8("requirements.txt found, instead of Pipfile! Converting…"),
                     bold=True,
                 )
             )
             # Create a Pipfile…
             project.create_pipfile(python=python)
-            with spinner():
+            with spinner(text=vistir.compat.fs_str("Importing requirements..."),
+                    spinner_name=environments.PIPENV_SPINNER,
+                    nospin=environments.PIPENV_NOSPIN) as sp:
                 # Import requirements.txt.
-                import_requirements()
+                try:
+                    import_requirements()
+                except Exception:
+                    sp.fail(environments.PIPENV_SPINNER_FAIL_TEXT.format("Failed..."))
+                else:
+                    sp.ok(environments.PIPENV_SPINNER_FAIL_TEXT.format("Success!"))
             # Warn the user of side-effects.
             click.echo(
                 u"{0}: Your {1} now contains pinned versions, if your {2} did. \n"
@@ -307,7 +337,7 @@ def ensure_pipfile(validate=True, skip_requirements=False, system=False):
             )
         else:
             click.echo(
-                crayons.normal(u"Creating a Pipfile for this project…", bold=True),
+                crayons.normal(fix_utf8("Creating a Pipfile for this project…"), bold=True),
                 err=True,
             )
             # Create the pipfile if it doesn't exist.
@@ -342,9 +372,9 @@ def find_a_system_python(line):
     if os.path.isabs(line):
         return line
     from .vendor.pythonfinder import Finder
+
     finder = Finder(system=False, global_search=True)
-    if ((line.startswith("py ") or line.startswith("py.exe "))
-            and os.name == 'nt'):
+    if (line.startswith("py ") or line.startswith("py.exe ")) and os.name == "nt":
         line = line.split(" ", 1)[1].lstrip("-")
     elif line.startswith("py"):
         python_entry = finder.which(line)
@@ -395,12 +425,13 @@ def ensure_python(three=None, python=None):
             u"{0}: Python {1} {2}".format(
                 crayons.red("Warning", bold=True),
                 crayons.blue(python),
-                u"was not found on your system…",
+                fix_utf8("was not found on your system…"),
             ),
             err=True,
         )
         # Pyenv is installed
         from .vendor.pythonfinder.environment import PYENV_INSTALLED
+
         if not PYENV_INSTALLED:
             abort()
         else:
@@ -413,7 +444,7 @@ def ensure_python(three=None, python=None):
                 except ValueError:
                     abort()
                 except PyenvError as e:
-                    click.echo(u"Something went wrong…")
+                    click.echo(fix_utf8("Something went wrong…"))
                     click.echo(crayons.blue(e.err), err=True)
                     abort()
                 s = "{0} {1} {2}".format(
@@ -432,17 +463,24 @@ def ensure_python(three=None, python=None):
                             crayons.green(u"CPython {0}".format(version), bold=True),
                             crayons.normal(u"with pyenv", bold=True),
                             crayons.normal(u"(this may take a few minutes)"),
-                            crayons.normal(u"…", bold=True),
+                            crayons.normal(fix_utf8("…"), bold=True),
                         )
                     )
-                    with spinner():
+                    with spinner(text=vistir.compat.fs_str("Installing python..."),
+                                    spinner_name=environments.PIPENV_SPINNER,
+                                    nospin=environments.PIPENV_NOSPIN) as sp:
                         try:
                             c = pyenv.install(version)
                         except PyenvError as e:
-                            click.echo(u"Something went wrong…")
+                            sp.fail(environments.PIPENV_SPINNER_FAIL_TEXT.format(
+                                "Failed...")
+                            )
+                            click.echo(fix_utf8("Something went wrong…"), err=True)
                             click.echo(crayons.blue(e.err), err=True)
+                        else:
+                            environments.PIPENV_SPINNER_OK_TEXT.format("Success!")
                         # Print the results, in a beautiful blue…
-                        click.echo(crayons.blue(c.out), err=True)
+                            click.echo(crayons.blue(c.out), err=True)
                     # Find the newly installed Python, hopefully.
                     version = str(version)
                     path_to_python = find_a_system_python(version)
@@ -507,7 +545,7 @@ def ensure_virtualenv(three=None, python=None, site_packages=False, pypi_mirror=
             ):
                 abort()
         click.echo(
-            crayons.normal(u"Removing existing virtualenv…", bold=True), err=True
+            crayons.normal(fix_utf8("Removing existing virtualenv…"), bold=True), err=True
         )
         # Remove the virtualenv.
         cleanup_virtualenv(bare=True)
@@ -543,8 +581,11 @@ def ensure_project(
     # Automatically use an activated virtualenv.
     if PIPENV_USE_SYSTEM:
         system = True
-    if not project.pipfile_exists and not deploy:
-        project.touch_pipfile()
+    if not project.pipfile_exists:
+        if deploy is True:
+            raise exceptions.PipfileNotFound
+        else:
+            project.touch_pipfile()
     # Skip virtualenv creation when --system was used.
     if not system:
         ensure_virtualenv(
@@ -573,9 +614,7 @@ def ensure_project(
                     )
                     click.echo(
                         "  {0} and rebuilding the virtual environment "
-                        "may resolve the issue.".format(
-                            crayons.green("$ pipenv --rm"),
-                        ),
+                        "may resolve the issue.".format(crayons.green("$ pipenv --rm")),
                         err=True,
                     )
                     if not deploy:
@@ -585,8 +624,7 @@ def ensure_project(
                             err=True,
                         )
                     else:
-                        click.echo(crayons.red("Deploy aborted."), err=True)
-                        sys.exit(1)
+                        raise exceptions.DeployException
     # Ensure the Pipfile exists.
     ensure_pipfile(
         validate=validate, skip_requirements=skip_requirements, system=system
@@ -656,26 +694,31 @@ def do_install_dependencies(
 
     If requirements is True, simply spits out a requirements format to stdout.
     """
-    from .vendor.requirementslib import Requirement
+    from six.moves import queue
 
     def cleanup_procs(procs, concurrent):
-        for c in procs:
-            if concurrent:
-                c.block()
+        while not procs.empty():
+            c = procs.get()
+            # if concurrent:
+            c.block()
+            failed = False
+            if c.return_code != 0:
+                failed = True
             if "Ignoring" in c.out:
                 click.echo(crayons.yellow(c.out.strip()))
             elif environments.is_verbose():
-                click.echo(crayons.blue(c.out or c.err))
+                click.echo(crayons.blue(c.out.strip() or c.err.strip()))
             # The Installation failed…
-            if c.return_code != 0:
+            if failed:
                 # Save the Failed Dependency for later.
-                failed_deps_list.append((c.dep, c.ignore_hash))
+                dep = c.dep.copy()
+                failed_deps_list.append(dep)
                 # Alert the user.
                 click.echo(
                     "{0} {1}! Will try again.".format(
                         crayons.red("An error occurred while installing"),
-                        crayons.green(c.dep.as_line()),
-                    )
+                        crayons.green(dep.as_line()),
+                    ), err=True
                 )
 
     if requirements:
@@ -685,135 +728,136 @@ def do_install_dependencies(
     if skip_lock or only or not project.lockfile_exists:
         if not bare:
             click.echo(
-                crayons.normal(u"Installing dependencies from Pipfile…", bold=True)
+                crayons.normal(fix_utf8("Installing dependencies from Pipfile…"), bold=True)
             )
-            lockfile = split_file(project._lockfile)
+            lockfile = project.get_or_create_lockfile()
     else:
-        with open(project.lockfile_location) as f:
-            lockfile = split_file(simplejson.load(f))
+        lockfile = project.get_or_create_lockfile()
         if not bare:
             click.echo(
                 crayons.normal(
-                    u"Installing dependencies from Pipfile.lock ({0})…".format(
+                    fix_utf8("Installing dependencies from Pipfile.lock ({0})…".format(
                         lockfile["_meta"].get("hash", {}).get("sha256")[-6:]
-                    ),
+                    )),
                     bold=True,
                 )
             )
     # Allow pip to resolve dependencies when in skip-lock mode.
     no_deps = not skip_lock
-    deps_list, dev_deps_list = merge_deps(
-        lockfile,
-        project,
-        dev=dev,
-        requirements=requirements,
-        ignore_hashes=ignore_hashes,
-        blocking=blocking,
-        only=only,
-    )
     failed_deps_list = []
+    deps_list = list(lockfile.get_requirements(dev=dev, only=only))
     if requirements:
         index_args = prepare_pip_source_args(project.sources)
         index_args = " ".join(index_args).replace(" -", "\n-")
-        deps_list = [dep for dep, ignore_hash, block in deps_list]
-        dev_deps_list = [dep for dep, ignore_hash, block in dev_deps_list]
+        deps = [
+            req.as_line(sources=project.sources, include_hashes=False) for req in deps_list
+        ]
         # Output only default dependencies
         click.echo(index_args)
-        if not dev:
-            click.echo("\n".join(d.partition('--hash')[0].strip() for d in sorted(deps_list)))
-            sys.exit(0)
-        # Output only dev dependencies
-        if dev:
-            click.echo("\n".join(d.partition('--hash')[0].strip() for d in sorted(dev_deps_list)))
-            sys.exit(0)
-    procs = []
-    deps_list_bar = progress.bar(
-        deps_list, label=INSTALL_LABEL if os.name != "nt" else ""
-    )
-    for dep, ignore_hash, block in deps_list_bar:
-        if len(procs) < PIPENV_MAX_SUBPROCESS:
-            # Use a specific index, if specified.
-            index = None
-            if ' --index' in dep:
-                dep, _, index = dep.partition(' --index')
-                index = index.lstrip('=')
-            elif ' -i ' in dep:
-                dep, _, index = dep.partition(' -i ')
-            extra_indexes = []
-            if '--extra-index-url' in dep:
-                split_dep = dep.split('--extra-index-url')
-                dep, extra_indexes = split_dep[0], split_dep[1:]
-            dep = Requirement.from_line(dep)
-            if index:
-                _index = None
-                try:
-                    _index = project.find_source(index).get('name')
-                except SourceNotFound:
-                    _index = None
-                dep.index = _index
-                dep._index = index
-                dep.extra_indexes = extra_indexes
-            # Install the module.
-            prev_no_deps_setting = no_deps
-            if dep.is_file_or_url and any(dep.req.uri.endswith(ext) for ext in ['zip', 'tar.gz']):
-                no_deps = False
+        click.echo(
+            "\n".join(sorted(deps))
+        )
+        sys.exit(0)
+
+    procs = queue.Queue(maxsize=PIPENV_MAX_SUBPROCESS)
+    trusted_hosts = []
+
+    deps_list_bar = progress.bar(deps_list, width=32,
+                                    label=INSTALL_LABEL if os.name != "nt" else "")
+    indexes = []
+    for dep in deps_list_bar:
+        index = None
+        if dep.index:
+            index = project.find_source(dep.index)
+            indexes.append(index)
+            if not index.get("verify_ssl", False):
+                trusted_hosts.append(urllib3_util.parse_url(index.get("url")).host)
+        # Install the module.
+        is_artifact = False
+        if dep.is_file_or_url and any(
+            dep.req.uri.endswith(ext) for ext in ["zip", "tar.gz"]
+        ):
+            is_artifact = True
+
+        extra_indexes = []
+        if not index and indexes:
+            index = next(iter(indexes))
+            if len(indexes) > 1:
+                extra_indexes = indexes[1:]
+        with vistir.contextmanagers.temp_environ():
+            os.environ["PIP_USER"] = vistir.compat.fs_str("0")
             c = pip_install(
                 dep,
-                ignore_hashes=ignore_hash,
+                ignore_hashes=any([ignore_hashes, dep.editable, dep.is_vcs]),
                 allow_global=allow_global,
-                no_deps=no_deps,
-                block=block,
+                no_deps=False if is_artifact else no_deps,
+                block=any([dep.editable, blocking]),
                 index=index,
                 requirements_dir=requirements_dir,
-                extra_indexes=extra_indexes,
                 pypi_mirror=pypi_mirror,
+                trusted_hosts=trusted_hosts,
+                extra_indexes=extra_indexes
             )
-            c.dep = dep
-            c.ignore_hash = ignore_hash
-            c.index = index
-            c.extra_indexes = extra_indexes
-            procs.append(c)
-            no_deps = prev_no_deps_setting
-        if len(procs) >= PIPENV_MAX_SUBPROCESS or len(procs) == len(deps_list):
-            cleanup_procs(procs, concurrent)
-            procs = []
-    cleanup_procs(procs, concurrent)
+            if procs.qsize() < PIPENV_MAX_SUBPROCESS:
+                c.dep = dep
+                procs.put(c)
+
+            if procs.full() or procs.qsize() == len(deps_list):
+                cleanup_procs(procs, concurrent)
+    if not procs.empty():
+        cleanup_procs(procs, concurrent)
+
     # Iterate over the hopefully-poorly-packaged dependencies…
     if failed_deps_list:
         click.echo(
-            crayons.normal(u"Installing initially failed dependencies…", bold=True)
+            crayons.normal(fix_utf8("Installing initially failed dependencies…"), bold=True)
         )
-        for dep, ignore_hash in progress.bar(failed_deps_list, label=INSTALL_LABEL2):
+        for dep in progress.bar(failed_deps_list, label=INSTALL_LABEL2):
             # Use a specific index, if specified.
             # Install the module.
-            prev_no_deps_setting = no_deps
-            if dep.is_file_or_url and any(dep.req.uri.endswith(ext) for ext in ['zip', 'tar.gz']):
-                no_deps = False
-            c = pip_install(
-                dep,
-                ignore_hashes=ignore_hash,
-                allow_global=allow_global,
-                no_deps=no_deps,
-                index=getattr(dep, "_index", None),
-                requirements_dir=requirements_dir,
-                extra_indexes=getattr(dep, "extra_indexes", None),
-            )
-            no_deps = prev_no_deps_setting
-            # The Installation failed…
-            if c.return_code != 0:
-                # We echo both c.out and c.err because pip returns error details on out.
-                click.echo(crayons.blue(format_pip_output(c.out)))
-                click.echo(crayons.blue(format_pip_error(c.err)), err=True)
-                # Return the subprocess' return code.
-                sys.exit(c.return_code)
-            else:
-                click.echo(
-                    "{0} {1}{2}".format(
-                        crayons.green("Success installing"),
-                        crayons.green(dep.name),
-                        crayons.green("!"),
-                    )
+            is_artifact = False
+            index = None
+            if dep.index:
+                index = project.find_source(dep.index)
+            if dep.is_file_or_url and any(
+                dep.req.uri.endswith(ext) for ext in ["zip", "tar.gz"]
+            ):
+                is_artifact = True
+            extra_indexes = []
+            if not index and indexes:
+                index = next(iter(indexes))
+                if len(indexes) > 1:
+                    extra_indexes = indexes[1:]
+            with vistir.contextmanagers.temp_environ():
+                os.environ["PIP_USER"] = vistir.compat.fs_str("0")
+                c = pip_install(
+                    dep,
+                    ignore_hashes=any([ignore_hashes, dep.editable, dep.is_vcs]),
+                    allow_global=allow_global,
+                    no_deps=True if is_artifact else no_deps,
+                    index=index,
+                    requirements_dir=requirements_dir,
+                    pypi_mirror=pypi_mirror,
+                    trusted_hosts=trusted_hosts,
+                    extra_indexes=extra_indexes,
+                    block=True
                 )
+                # The Installation failed…
+                if c.return_code != 0:
+                    # We echo both c.out and c.err because pip returns error details on out.
+                    click.echo(crayons.blue(format_pip_output(c.out)))
+                    click.echo(crayons.blue(format_pip_error(c.err)), err=True)
+                    # Return the subprocess' return code.
+                    sys.exit(c.return_code)
+                else:
+                    if environments.is_verbose():
+                        click.echo(
+                            "{0} {1}{2}".format(
+                                crayons.green("Success installing"),
+                                crayons.green(dep.as_line(include_hashes=False)),
+                                crayons.green("!"),
+                            ),
+                        )
 
 
 def convert_three_to_python(three, python):
@@ -834,7 +878,7 @@ def convert_three_to_python(three, python):
 def do_create_virtualenv(python=None, site_packages=False, pypi_mirror=None):
     """Creates a virtualenv."""
     click.echo(
-        crayons.normal(u"Creating a virtualenv for this project…", bold=True), err=True
+        crayons.normal(fix_utf8("Creating a virtualenv for this project…"), bold=True), err=True
     )
     click.echo(
         u"Pipfile: {0}".format(crayons.red(project.pipfile_location, bold=True)),
@@ -848,17 +892,17 @@ def do_create_virtualenv(python=None, site_packages=False, pypi_mirror=None):
         u"{0} {1} {3} {2}".format(
             crayons.normal("Using", bold=True),
             crayons.red(python, bold=True),
-            crayons.normal(u"to create virtualenv…", bold=True),
+            crayons.normal(fix_utf8("to create virtualenv…"), bold=True),
             crayons.green("({0})".format(python_version(python))),
         ),
         err=True,
     )
 
     cmd = [
-        sys.executable,
+        vistir.compat.Path(sys.executable).absolute().as_posix(),
         "-m",
         "virtualenv",
-        "--prompt=({0})".format(project.name),
+        "--prompt=({0}) ".format(project.name),
         "--python={0}".format(python),
         project.get_location_for_virtualenv(),
     ]
@@ -866,34 +910,31 @@ def do_create_virtualenv(python=None, site_packages=False, pypi_mirror=None):
     # Pass site-packages flag to virtualenv, if desired…
     if site_packages:
         click.echo(
-            crayons.normal(u"Making site-packages available…", bold=True), err=True
+            crayons.normal(fix_utf8("Making site-packages available…"), bold=True), err=True
         )
         cmd.append("--system-site-packages")
 
     if pypi_mirror:
-        pip_config = {"PIP_INDEX_URL": fs_str(pypi_mirror)}
+        pip_config = {"PIP_INDEX_URL": vistir.misc.fs_str(pypi_mirror)}
     else:
         pip_config = {}
 
     # Actually create the virtualenv.
-    with spinner():
-        c = delegator.run(
-            cmd, block=False, timeout=PIPENV_TIMEOUT, env=pip_config,
-        )
-        c.block()
+    nospin = os.environ.get("PIPENV_ACTIVE", environments.PIPENV_NOSPIN)
+    c = vistir.misc.run(cmd, verbose=False, return_object=True,
+                spinner_name=environments.PIPENV_SPINNER, combine_stderr=False,
+                block=False, nospin=nospin, env=pip_config)
     click.echo(crayons.blue("{0}".format(c.out)), err=True)
-    if c.return_code != 0:
-        click.echo(crayons.blue("{0}".format(c.err)), err=True)
-        click.echo(u"{0}: Failed to create virtual environment.".format(
-            crayons.red("Warning", bold=True),
-        ), err=True)
-        sys.exit(1)
+    if c.returncode != 0:
+        raise exceptions.VirtualenvCreationException(
+            extra=[crayons.blue("{0}".format(c.err)),]
+        )
 
     # Associate project directory with the environment.
     # This mimics Pew's "setproject".
     project_file_name = os.path.join(project.virtualenv_location, ".project")
     with open(project_file_name, "w") as f:
-        f.write(fs_str(project.project_directory))
+        f.write(vistir.misc.fs_str(project.project_directory))
 
     # Say where the virtualenv is.
     do_where(virtualenv=True, bare=False)
@@ -906,7 +947,7 @@ def parse_download_fname(fname, name):
     if fname.endswith(".tar"):
         fname, _ = os.path.splitext(fname)
     # Substring out package name (plus dash) from file name to get version.
-    version = fname[len(name) + 1:]
+    version = fname[len(name) + 1 :]
     # Ignore implicit post releases in version number.
     if "-" in version and version.split("-")[1].isdigit():
         version = version.split("-")[0]
@@ -914,7 +955,7 @@ def parse_download_fname(fname, name):
 
 
 def get_downloads_info(names_map, section):
-    from .vendor.requirementslib import Requirement
+    from .vendor.requirementslib.models.requirements import Requirement
 
     info = []
     p = project.parsed_pipfile
@@ -939,6 +980,7 @@ def get_downloads_info(names_map, section):
 
 
 def do_lock(
+    ctx=None,
     system=False,
     clear=False,
     pre=False,
@@ -954,12 +996,10 @@ def do_lock(
         pre = project.settings.get("allow_prereleases")
     if keep_outdated:
         if not project.lockfile_exists:
-            click.echo(
-                "{0}: Pipfile.lock must exist to use --keep-outdated!".format(
-                    crayons.red("Warning", bold=True)
-                )
+            raise exceptions.PipenvOptionsError(
+                "--keep-outdated", ctx=ctx,
+                message="Pipfile.lock must exist to use --keep-outdated!"
             )
-            sys.exit(1)
         cached_lockfile = project.lockfile_content
     # Create the lockfile.
     lockfile = project._lockfile
@@ -974,9 +1014,6 @@ def do_lock(
         if dev_package in project.packages:
             dev_packages[dev_package] = project.packages[dev_package]
     # Resolve dev-package dependencies, with pip-tools.
-    pip_freeze = delegator.run(
-        "{0} freeze".format(escape_grouped_arguments(which_pip(allow_global=system)))
-    ).out
     sections = {
         "dev": {
             "packages": project.dev_packages,
@@ -1001,9 +1038,9 @@ def do_lock(
             # Alert the user of progress.
             click.echo(
                 u"{0} {1} {2}".format(
-                    crayons.normal("Locking"),
-                    crayons.red("[{0}]".format(settings["log_string"])),
-                    crayons.normal("dependencies…"),
+                    crayons.normal(u"Locking"),
+                    crayons.red(u"[{0}]".format(settings["log_string"])),
+                    crayons.normal(fix_utf8("dependencies…")),
                 ),
                 err=True,
             )
@@ -1032,7 +1069,6 @@ def do_lock(
         # TODO: be smarter about this.
         vcs_reqs, vcs_lockfile = get_vcs_deps(
             project,
-            pip_freeze,
             which=which,
             clear=clear,
             pre=pre,
@@ -1103,51 +1139,38 @@ def do_lock(
 
 def do_purge(bare=False, downloads=False, allow_global=False):
     """Executes the purge functionality."""
-    from .vendor.requirementslib.models.requirements import Requirement
 
     if downloads:
         if not bare:
-            click.echo(crayons.normal(u"Clearing out downloads directory…", bold=True))
+            click.echo(crayons.normal(fix_utf8("Clearing out downloads directory…"), bold=True))
         shutil.rmtree(project.download_location)
         return
 
-    freeze = delegator.run(
-        "{0} freeze".format(
-            escape_grouped_arguments(which_pip(allow_global=allow_global))
-        )
-    ).out
     # Remove comments from the output, if any.
-    installed = [
-        line for line in freeze.splitlines() if not line.lstrip().startswith("#")
-    ]
-    # Remove setuptools and friends from installed, if present.
-    for package_name in BAD_PACKAGES:
-        for i, package in enumerate(installed):
-            if package.startswith(package_name):
-                del installed[i]
-    actually_installed = []
-    for package in installed:
-        try:
-            dep = Requirement.from_line(package)
-        except AssertionError:
-            dep = None
-        if dep and not dep.is_vcs and not dep.editable:
-            dep = dep.name
-            actually_installed.append(dep)
+    installed = set([
+        pep423_name(pkg.project_name) for pkg in project.get_installed_packages()
+    ])
+    bad_pkgs = set([pep423_name(pkg) for pkg in BAD_PACKAGES])
+    # Remove setuptools, pip, etc from targets for removal
+    to_remove = installed - bad_pkgs
+
     if not bare:
         click.echo(
-            u"Found {0} installed package(s), purging…".format(len(actually_installed))
+            fix_utf8("Found {0} installed package(s), purging…".format(len(to_remove)))
         )
     command = "{0} uninstall {1} -y".format(
         escape_grouped_arguments(which_pip(allow_global=allow_global)),
-        " ".join(actually_installed),
+        " ".join(to_remove),
     )
     if environments.is_verbose():
         click.echo("$ {0}".format(command))
     c = delegator.run(command)
+    if c.return_code != 0:
+        raise exceptions.UninstallError(installed, command, c.out + c.err, c.return_code)
     if not bare:
         click.echo(crayons.blue(c.out))
         click.echo(crayons.green("Environment now purged and fresh!"))
+    return installed
 
 
 def do_init(
@@ -1167,7 +1190,6 @@ def do_init(
     """Executes the init functionality."""
     from .environments import PIPENV_VIRTUALENV
 
-    cleanup_reqdir = False
     if not system:
         if not project.virtualenv_exists:
             try:
@@ -1179,8 +1201,9 @@ def do_init(
     if not deploy:
         ensure_pipfile(system=system)
     if not requirements_dir:
-        cleanup_reqdir = True
-        requirements_dir = TemporaryDirectory(suffix="-requirements", prefix="pipenv-")
+        requirements_dir = vistir.path.create_tracked_tempdir(
+            suffix="-requirements", prefix="pipenv-"
+        )
     # Write out the lockfile if it doesn't exist, but not if the Pipfile is being ignored
     if (project.lockfile_exists and not ignore_pipfile) and not skip_lock:
         old_hash = project.get_lockfile_hash()
@@ -1194,31 +1217,30 @@ def do_init(
                         )
                     )
                 )
-                click.echo(crayons.normal("Aborting deploy.", bold=True), err=True)
-                requirements_dir.cleanup()
+                raise exceptions.DeployException
                 sys.exit(1)
             elif (system or allow_global) and not (PIPENV_VIRTUALENV):
                 click.echo(
-                    crayons.red(
-                        u"Pipfile.lock ({0}) out of date, but installation "
-                        u"uses {1}… re-building lockfile must happen in "
-                        u"isolation. Please rebuild lockfile in a virtualenv. "
-                        u"Continuing anyway…".format(
+                    crayons.red(fix_utf8(
+                        "Pipfile.lock ({0}) out of date, but installation "
+                        "uses {1}… re-building lockfile must happen in "
+                        "isolation. Please rebuild lockfile in a virtualenv. "
+                        "Continuing anyway…".format(
                             crayons.white(old_hash[-6:]), crayons.white("--system")
-                        ),
+                        )),
                         bold=True,
                     ),
                     err=True,
                 )
             else:
                 if old_hash:
-                    msg = u"Pipfile.lock ({1}) out of date, updating to ({0})…"
+                    msg = fix_utf8("Pipfile.lock ({1}) out of date, updating to ({0})…")
                 else:
-                    msg = u"Pipfile.lock is corrupted, replaced with ({0})…"
-                click.echo(crayons.red(
-                    msg.format(old_hash[-6:], new_hash[-6:]),
-                    bold=True,
-                ), err=True)
+                    msg = fix_utf8("Pipfile.lock is corrupted, replaced with ({0})…")
+                click.echo(
+                    crayons.red(msg.format(old_hash[-6:], new_hash[-6:]), bold=True),
+                    err=True,
+                )
                 do_lock(
                     system=system,
                     pre=pre,
@@ -1231,19 +1253,14 @@ def do_init(
         # Unless we're in a virtualenv not managed by pipenv, abort if we're
         # using the system's python.
         if (system or allow_global) and not (PIPENV_VIRTUALENV):
-            click.echo(
-                "{0}: --system is intended to be used for Pipfile installation, "
-                "not installation of specific packages. Aborting.".format(
-                    crayons.red("Warning", bold=True)
-                ),
-                err=True,
+            raise exceptions.PipenvOptionsError("--system",
+                "--system is intended to be used for Pipfile installation, "
+                "not installation of specific packages. Aborting.\n"
+                "See also: --deploy flag."
             )
-            click.echo("See also: --deploy flag.", err=True)
-            requirements_dir.cleanup()
-            sys.exit(1)
         else:
             click.echo(
-                crayons.normal(u"Pipfile.lock not found, creating…", bold=True),
+                crayons.normal(fix_utf8("Pipfile.lock not found, creating…"), bold=True),
                 err=True,
             )
             do_lock(
@@ -1259,11 +1276,9 @@ def do_init(
         allow_global=allow_global,
         skip_lock=skip_lock,
         concurrent=concurrent,
-        requirements_dir=requirements_dir.name,
+        requirements_dir=requirements_dir,
         pypi_mirror=pypi_mirror,
     )
-    if cleanup_reqdir:
-        requirements_dir.cleanup()
 
     # Hint the user what to do to activate the virtualenv.
     if not allow_global and not deploy and "PIPENV_ACTIVE" not in os.environ:
@@ -1289,24 +1304,41 @@ def pip_install(
     requirements_dir=None,
     extra_indexes=None,
     pypi_mirror=None,
+    trusted_hosts=None
 ):
     from notpip._internal import logger as piplogger
-    src = []
+    from .utils import Mapping
+    from .vendor.urllib3.util import parse_url
 
+    src = []
+    write_to_tmpfile = False
+    if requirement:
+        needs_hashes = not requirement.editable and not ignore_hashes and r is None
+        has_subdir = requirement.is_vcs and requirement.req.subdirectory
+        write_to_tmpfile = needs_hashes or has_subdir
+
+    if not trusted_hosts:
+        trusted_hosts = []
+    trusted_hosts.extend(os.environ.get("PIP_TRUSTED_HOSTS", []))
     if environments.is_verbose():
         piplogger.setLevel(logging.INFO)
         if requirement:
             click.echo(
                 crayons.normal("Installing {0!r}".format(requirement.name), bold=True),
-                err=True
+                err=True,
             )
     # Create files for hash mode.
-    if requirement and not requirement.editable and (not ignore_hashes) and (r is None):
-        fd, r = tempfile.mkstemp(
-            prefix="pipenv-", suffix="-requirement.txt", dir=requirements_dir
+    if write_to_tmpfile:
+        if not requirements_dir:
+            requirements_dir = vistir.path.create_tracked_tempdir(
+                prefix="pipenv", suffix="requirements")
+        f = vistir.compat.NamedTemporaryFile(
+            prefix="pipenv-", suffix="-requirement.txt", dir=requirements_dir,
+            delete=False
         )
-        with os.fdopen(fd, "w") as f:
-            f.write(requirement.as_line())
+        f.write(vistir.misc.to_bytes(requirement.as_line()))
+        r = f.name
+        f.close()
     # Install dependencies when a package is a VCS dependency.
     if requirement and requirement.vcs:
         no_deps = False
@@ -1316,23 +1348,38 @@ def pip_install(
 
     # Try installing for each source in project.sources.
     if index:
-        if not is_valid_url(index):
-            index = project.find_source(index).get("url")
-        sources = [{"url": index}]
+        if isinstance(index, (Mapping, dict)):
+            index_source = index
+        else:
+            try:
+                index_source = project.find_source(index)
+                index_source = index_source.copy()
+            except SourceNotFound:
+                src_name = project.src_name_from_url(index)
+                index_url = parse_url(index)
+                verify_ssl = index_url.host not in trusted_hosts
+                index_source = {"url": index, "verify_ssl": verify_ssl, "name": src_name}
+        sources = [index_source.copy(),]
         if extra_indexes:
             if isinstance(extra_indexes, six.string_types):
-                extra_indexes = [extra_indexes]
+                extra_indexes = [extra_indexes,]
             for idx in extra_indexes:
-                try:
-                    extra_src = project.find_source(idx).get("url")
-                except SourceNotFound:
+                extra_src = None
+                if isinstance(idx, (Mapping, dict)):
                     extra_src = idx
-                if extra_src != index:
-                    sources.append({"url": extra_src})
+                try:
+                    extra_src = project.find_source(idx) if not extra_src else extra_src
+                except SourceNotFound:
+                    src_name = project.src_name_from_url(idx)
+                    src_url = parse_url(idx)
+                    verify_ssl = src_url.host not in trusted_hosts
+                    extra_src = {"url": idx, "verify_ssl": verify_ssl, "name": extra_src}
+                if extra_src["url"] != index_source["url"]:
+                    sources.append(extra_src)
         else:
             for idx in project.pipfile_sources:
                 if idx["url"] != sources[0]["url"]:
-                    sources.append({"url": idx["url"]})
+                    sources.append(idx)
     else:
         sources = project.pipfile_sources
     if pypi_mirror:
@@ -1340,23 +1387,26 @@ def pip_install(
             create_mirror_source(pypi_mirror) if is_pypi_url(source["url"]) else source
             for source in sources
         ]
-    if (requirement and requirement.editable) or not r:
-        install_reqs = requirement.as_line(as_list=True)
+    if (requirement and requirement.editable) and not r:
+        line_kwargs = {"as_list": True}
+        if requirement.markers:
+            line_kwargs["include_markers"] = False
+        install_reqs = requirement.as_line(**line_kwargs)
         if requirement.editable and install_reqs[0].startswith("-e "):
             req, install_reqs = install_reqs[0], install_reqs[1:]
             editable_opt, req = req.split(" ", 1)
             install_reqs = [editable_opt, req] + install_reqs
-        if not any(item.startswith("--hash") for item in install_reqs):
+        if not all(item.startswith("--hash") for item in install_reqs):
             ignore_hashes = True
-    else:
+    elif r:
         install_reqs = ["-r", r]
         with open(r) as f:
             if "--hash" not in f.read():
                 ignore_hashes = True
-    pip_command = [
-        which_pip(allow_global=allow_global),
-        "install"
-    ]
+    else:
+        ignore_hashes = True if not requirement.hashes else False
+        install_reqs = [escape_cmd(r) for r in requirement.as_line(as_list=True)]
+    pip_command = [which_pip(allow_global=allow_global), "install"]
     if pre:
         pip_command.append("--pre")
     if src:
@@ -1375,29 +1425,34 @@ def pip_install(
 
     if environments.is_verbose():
         click.echo("$ {0}".format(pip_command), err=True)
-    cache_dir = Path(PIPENV_CACHE_DIR)
+    cache_dir = vistir.compat.Path(PIPENV_CACHE_DIR)
     pip_config = {
-        "PIP_CACHE_DIR": fs_str(cache_dir.as_posix()),
-        "PIP_WHEEL_DIR": fs_str(cache_dir.joinpath("wheels").as_posix()),
-        "PIP_DESTINATION_DIR": fs_str(cache_dir.joinpath("pkgs").as_posix()),
-        "PIP_EXISTS_ACTION": fs_str("w"),
-        "PATH": fs_str(os.environ.get("PATH"))
+        "PIP_CACHE_DIR": vistir.misc.fs_str(cache_dir.as_posix()),
+        "PIP_WHEEL_DIR": vistir.misc.fs_str(cache_dir.joinpath("wheels").as_posix()),
+        "PIP_DESTINATION_DIR": vistir.misc.fs_str(
+            cache_dir.joinpath("pkgs").as_posix()
+        ),
+        "PIP_EXISTS_ACTION": vistir.misc.fs_str("w"),
+        "PATH": vistir.misc.fs_str(os.environ.get("PATH")),
     }
     if src:
-        pip_config.update({
-            "PIP_SRC": fs_str(project.virtualenv_src_location)
-        })
-    pip_command = Script.parse(pip_command).cmdify()
+        pip_config.update(
+            {"PIP_SRC": vistir.misc.fs_str(project.virtualenv_src_location)}
+        )
+    cmd = Script.parse(pip_command)
+    pip_command = cmd.cmdify()
     c = delegator.run(pip_command, block=block, env=pip_config)
     return c
 
 
 def pip_download(package_name):
-    cache_dir = Path(PIPENV_CACHE_DIR)
+    cache_dir = vistir.compat.Path(PIPENV_CACHE_DIR)
     pip_config = {
-        "PIP_CACHE_DIR": fs_str(cache_dir.as_posix()),
-        "PIP_WHEEL_DIR": fs_str(cache_dir.joinpath("wheels").as_posix()),
-        "PIP_DESTINATION_DIR": fs_str(cache_dir.joinpath("pkgs").as_posix()),
+        "PIP_CACHE_DIR": vistir.misc.fs_str(cache_dir.as_posix()),
+        "PIP_WHEEL_DIR": vistir.misc.fs_str(cache_dir.joinpath("wheels").as_posix()),
+        "PIP_DESTINATION_DIR": vistir.misc.fs_str(
+            cache_dir.joinpath("pkgs").as_posix()
+        ),
     }
     for source in project.sources:
         cmd = '{0} download "{1}" -i {2} -d {3}'.format(
@@ -1430,22 +1485,34 @@ def which_pip(allow_global=False):
 def system_which(command, mult=False):
     """Emulates the system's which. Returns None if not found."""
     _which = "which -a" if not os.name == "nt" else "where"
-    c = delegator.run("{0} {1}".format(_which, command))
+    os.environ = {
+        vistir.compat.fs_str(k): vistir.compat.fs_str(val)
+        for k, val in os.environ.items()
+    }
     try:
-        # Which Not found…
-        if c.return_code == 127:
-            click.echo(
-                "{}: the {} system utility is required for Pipenv to find Python installations properly."
-                "\n  Please install it.".format(
-                    crayons.red("Warning", bold=True), crayons.red(_which)
-                ),
-                err=True,
-            )
-        assert c.return_code == 0
-    except AssertionError:
-        return None if not mult else []
-
-    result = c.out.strip() or c.err.strip()
+        c = delegator.run("{0} {1}".format(_which, command))
+        try:
+            # Which Not found…
+            if c.return_code == 127:
+                click.echo(
+                    "{}: the {} system utility is required for Pipenv to find Python installations properly."
+                    "\n  Please install it.".format(
+                        crayons.red("Warning", bold=True), crayons.red(_which)
+                    ),
+                    err=True,
+                )
+            assert c.return_code == 0
+        except AssertionError:
+            return None if not mult else []
+    except TypeError:
+        from .vendor.pythonfinder import Finder
+        finder = Finder()
+        result = finder.which(command)
+        if result:
+            return result.path.as_posix()
+        return
+    else:
+        result = c.out.strip() or c.err.strip()
     if mult:
         return result.split("\n")
 
@@ -1548,8 +1615,9 @@ def format_pip_output(out, r=None):
 def warn_in_virtualenv():
     # Only warn if pipenv isn't already active.
     pipenv_active = os.environ.get("PIPENV_ACTIVE")
-    if ((environments.PIPENV_USE_SYSTEM or environments.PIPENV_VIRTUALENV) and
-            not (pipenv_active or environments.is_quiet())):
+    if (environments.PIPENV_USE_SYSTEM or environments.PIPENV_VIRTUALENV) and not (
+        pipenv_active or environments.is_quiet()
+    ):
         click.echo(
             "{0}: Pipenv found itself running within a virtual environment, "
             "so it will automatically use that environment, instead of "
@@ -1576,9 +1644,9 @@ def ensure_lockfile(keep_outdated=False, pypi_mirror=None):
         if new_hash != old_hash:
             click.echo(
                 crayons.red(
-                    u"Pipfile.lock ({0}) out of date, updating to ({1})…".format(
+                    fix_utf8("Pipfile.lock ({0}) out of date, updating to ({1})…".format(
                         old_hash[-6:], new_hash[-6:]
-                    ),
+                    )),
                     bold=True,
                 ),
                 err=True,
@@ -1596,13 +1664,22 @@ def do_py(system=False):
 
 
 def do_outdated(pypi_mirror=None):
-    from .vendor.requirementslib import Requirement
+    # TODO: Allow --skip-lock here?
+    from .vendor.requirementslib.models.requirements import Requirement
+    from .vendor.packaging.utils import canonicalize_name
+    from collections import namedtuple
 
     packages = {}
-    results = delegator.run("{0} freeze".format(which("pip"))).out.strip().split("\n")
-    results = filter(bool, results)
-    for result in results:
-        dep = Requirement.from_line(result)
+    package_info = namedtuple("PackageInfo", ["name", "installed", "available"])
+
+    installed_packages = project.get_installed_packages()
+    outdated_packages = {
+        canonicalize_name(pkg.project_name): package_info
+        (pkg.project_name, pkg.parsed_version, pkg.latest_version)
+        for pkg in project.get_outdated_packages()
+    }
+    for result in installed_packages:
+        dep = Requirement.from_line(str(result.as_requirement()))
         packages.update(dep.as_pipfile())
     updated_packages = {}
     lockfile = do_lock(write=False, pypi_mirror=pypi_mirror)
@@ -1613,13 +1690,25 @@ def do_outdated(pypi_mirror=None):
             except KeyError:
                 pass
     outdated = []
+    skipped = []
     for package in packages:
         norm_name = pep423_name(package)
         if norm_name in updated_packages:
             if updated_packages[norm_name] != packages[package]:
                 outdated.append(
-                    (package, updated_packages[norm_name], packages[package])
+                    package_info(package, updated_packages[norm_name], packages[package])
                 )
+            elif canonicalize_name(package) in outdated_packages:
+                skipped.append(outdated_packages[canonicalize_name(package)])
+    for package, old_version, new_version in skipped:
+        click.echo(crayons.yellow(
+            "Skipped Update of Package {0!s}: {1!s} installed, {2!s} available.".format(
+                package, old_version, new_version
+            )), err=True
+        )
+    if not outdated:
+        click.echo(crayons.green("All packages are up to date!", bold=True))
+        sys.exit(0)
     for package, new_version, old_version in outdated:
         click.echo(
             "Package {0!r} out-of-date: {1!r} installed, {2!r} available.".format(
@@ -1651,11 +1740,12 @@ def do_install(
     selective_upgrade=False,
 ):
     from .environments import PIPENV_VIRTUALENV, PIPENV_USE_SYSTEM
-    from notpip._internal.exceptions import PipError
+    from .vendor.pip_shims.shims import PipError
 
-    requirements_directory = TemporaryDirectory(
+    requirements_directory = vistir.path.create_tracked_tempdir(
         suffix="-requirements", prefix="pipenv-"
     )
+    warnings.filterwarnings("default", category=vistir.compat.ResourceWarning)
     if selective_upgrade:
         keep_outdated = True
     packages = packages if packages else []
@@ -1665,6 +1755,10 @@ def do_install(
     # Don't search for requirements.txt files if the user provides one
     if requirements or package_args or project.pipfile_exists:
         skip_requirements = True
+    # Don't attempt to install develop and default packages if Pipfile is missing
+    if not project.pipfile_exists and not packages and dev:
+        click.echo("Could not find Pipfile.", err=True)
+        sys.exit(1)
     concurrent = not sequential
     # Ensure that virtualenv is available.
     ensure_project(
@@ -1692,27 +1786,29 @@ def do_install(
             err=True,
         )
         click.echo("See also: --deploy flag.", err=True)
-        requirements_directory.cleanup()
         sys.exit(1)
     # Automatically use an activated virtualenv.
     if PIPENV_USE_SYSTEM:
         system = True
     # Check if the file is remote or not
     if remote:
-        fd, temp_reqs = tempfile.mkstemp(
-            prefix="pipenv-", suffix="-requirement.txt", dir=requirements_directory.name
-        )
-        requirements_url = requirements
-        # Download requirements file
         click.echo(
             crayons.normal(
-                u"Remote requirements file provided! Downloading…", bold=True
+                fix_utf8("Remote requirements file provided! Downloading…"), bold=True
             ),
             err=True,
         )
+        fd = vistir.path.create_tracked_tempfile(
+            prefix="pipenv-", suffix="-requirement.txt", dir=requirements_directory
+        )
+        temp_reqs = fd.name
+        requirements_url = requirements
+        # Download requirements file
         try:
             download_file(requirements, temp_reqs)
         except IOError:
+            fd.close()
+            os.unlink(temp_reqs)
             click.echo(
                 crayons.red(
                     u"Unable to find requirements file at {0}.".format(
@@ -1721,8 +1817,9 @@ def do_install(
                 ),
                 err=True,
             )
-            requirements_directory.cleanup()
             sys.exit(1)
+        finally:
+            fd.close()
         # Replace the url with the temporary requirements file
         requirements = temp_reqs
         remote = True
@@ -1730,7 +1827,7 @@ def do_install(
         error, traceback = None, None
         click.echo(
             crayons.normal(
-                u"Requirements file provided! Importing into Pipfile…", bold=True
+                fix_utf8("Requirements file provided! Importing into Pipfile…"), bold=True
             ),
             err=True,
         )
@@ -1753,23 +1850,19 @@ def do_install(
         finally:
             # If requirements file was provided by remote url delete the temporary file
             if remote:
-                os.close(fd)  # Close for windows to allow file cleanup.
-                os.remove(project.path_to(temp_reqs))
+                fd.close()  # Close for windows to allow file cleanup.
+                os.remove(temp_reqs)
             if error and traceback:
                 click.echo(crayons.red(error))
                 click.echo(crayons.blue(str(traceback)), err=True)
-                requirements_directory.cleanup()
                 sys.exit(1)
     if code:
         click.echo(
-            crayons.normal(u"Discovering imports from local codebase…", bold=True)
+            crayons.normal(fix_utf8("Discovering imports from local codebase…"), bold=True)
         )
         for req in import_from_code(code):
             click.echo("  Found {0}!".format(crayons.green(req)))
             project.add_package_to_pipfile(req)
-    # Capture . argument and assign it to nothing
-    if len(packages) == 1 and packages[0] == ".":
-        packages = False
     # Install editable local packages before locking - this gives us access to dist-info
     if project.pipfile_exists and (
         # double negatives are for english readability, leave them alone.
@@ -1785,18 +1878,20 @@ def do_install(
             )
             if req:
                 req = req[0]
-                req = req[len("-e "):] if req.startswith("-e ") else req
+                req = req[len("-e ") :] if req.startswith("-e ") else req
                 if not editable_packages:
                     editable_packages = [req]
                 else:
                     editable_packages.extend([req])
     # Allow more than one package to be provided.
-    package_args = [p for p in packages] + ["-e {0}".format(pkg) for pkg in editable_packages]
+    package_args = [p for p in packages] + [
+        "-e {0}".format(pkg) for pkg in editable_packages
+    ]
     # Support for --selective-upgrade.
     # We should do this part first to make sure that we actually do selectively upgrade
     # the items specified
     if selective_upgrade:
-        from .vendor.requirementslib import Requirement
+        from .vendor.requirementslib.models.requirements import Requirement
 
         for i, package in enumerate(package_args[:]):
             section = project.packages if not dev else project.dev_packages
@@ -1833,23 +1928,27 @@ def do_install(
     # This is for if the user passed in dependencies, then we want to maek sure we
     else:
         from .vendor.requirementslib import Requirement
+
         # make a tuple of (display_name, entry)
         pkg_list = packages + ["-e {0}".format(pkg) for pkg in editable_packages]
 
         for pkg_line in pkg_list:
             click.echo(
                 crayons.normal(
-                    u"Installing {0}…".format(crayons.green(pkg_line, bold=True)),
+                    fix_utf8("Installing {0}…".format(crayons.green(pkg_line, bold=True))),
                     bold=True,
                 )
             )
             # pip install:
-            with spinner():
+            with vistir.contextmanagers.temp_environ(), spinner(text="Installing...",
+                    spinner_name=environments.PIPENV_SPINNER,
+                    nospin=environments.PIPENV_NOSPIN) as sp:
+                os.environ["PIP_USER"] = vistir.compat.fs_str("0")
                 try:
                     pkg_requirement = Requirement.from_line(pkg_line)
                 except ValueError as e:
-                    click.echo("{0}: {1}".format(crayons.red("WARNING"), e))
-                    requirements_directory.cleanup()
+                    sp.write_err(vistir.compat.fs_str("{0}: {1}".format(crayons.red("WARNING"), e)))
+                    sp.fail(environments.PIPENV_SPINNER_FAIL_TEXT.format("Installation Failed"))
                     sys.exit(1)
                 if index_url:
                     pkg_requirement.index = index_url
@@ -1860,14 +1959,14 @@ def do_install(
                     selective_upgrade=selective_upgrade,
                     no_deps=False,
                     pre=pre,
-                    requirements_dir=requirements_directory.name,
+                    requirements_dir=requirements_directory,
                     index=index_url,
                     extra_indexes=extra_index_url,
                     pypi_mirror=pypi_mirror,
                 )
                 # Warn if --editable wasn't passed.
                 if pkg_requirement.is_vcs and not pkg_requirement.editable:
-                    click.echo(
+                    sp.write_err(
                         "{0}: You installed a VCS dependency in non-editable mode. "
                         "This will work fine, but sub-dependencies will not be resolved by {1}."
                         "\n  To enable this sub-dependency functionality, specify that this dependency is editable."
@@ -1876,44 +1975,39 @@ def do_install(
                             crayons.red("$ pipenv lock"),
                         )
                     )
-            click.echo(crayons.blue(format_pip_output(c.out)))
-            # Ensure that package was successfully installed.
-            try:
-                assert c.return_code == 0
-            except AssertionError:
-                click.echo(
-                    "{0} An error occurred while installing {1}!".format(
-                        crayons.red("Error: ", bold=True), crayons.green(pkg_line)
-                    ),
-                    err=True,
-                )
-                click.echo(crayons.blue(format_pip_error(c.err)), err=True)
-                if "setup.py egg_info" in c.err:
-                    click.echo(
-                        "This is likely caused by a bug in {0}. "
-                        "Report this to its maintainers.".format(
-                            crayons.green(pkg_requirement.name)
+                click.echo(crayons.blue(format_pip_output(c.out)))
+                # Ensure that package was successfully installed.
+                if c.return_code != 0:
+                    sp.write_err(vistir.compat.fs_str(
+                        "{0} An error occurred while installing {1}!".format(
+                            crayons.red("Error: ", bold=True), crayons.green(pkg_line)
                         ),
-                        err=True,
+                    ))
+                    sp.write_err(vistir.compat.fs_str(crayons.blue(format_pip_error(c.err))))
+                    if "setup.py egg_info" in c.err:
+                        sp.write_err(vistir.compat.fs_str(
+                            "This is likely caused by a bug in {0}. "
+                            "Report this to its maintainers.".format(
+                                crayons.green(pkg_requirement.name)
+                            )
+                        ))
+                    sp.fail(environments.PIPENV_SPINNER_FAIL_TEXT.format("Installation Failed"))
+                    sys.exit(1)
+                sp.write(vistir.compat.fs_str(
+                    u"{0} {1} {2} {3}{4}".format(
+                        crayons.normal(u"Adding", bold=True),
+                        crayons.green(u"{0}".format(pkg_requirement.name), bold=True),
+                        crayons.normal(u"to Pipfile's", bold=True),
+                        crayons.red(u"[dev-packages]" if dev else u"[packages]", bold=True),
+                        crayons.normal(fix_utf8("…"), bold=True),
                     )
-                requirements_directory.cleanup()
-                sys.exit(1)
-            click.echo(
-                "{0} {1} {2} {3}{4}".format(
-                    crayons.normal("Adding", bold=True),
-                    crayons.green(pkg_requirement.name, bold=True),
-                    crayons.normal("to Pipfile's", bold=True),
-                    crayons.red("[dev-packages]" if dev else "[packages]", bold=True),
-                    crayons.normal("…", bold=True),
-                )
-            )
+                ))
+                sp.ok(environments.PIPENV_SPINNER_OK_TEXT.format("Installation Succeeded"))
             # Add the package to the Pipfile.
             try:
                 project.add_package_to_pipfile(pkg_requirement, dev)
             except ValueError as e:
-                click.echo(
-                    "{0} {1}".format(crayons.red("ERROR (PACKAGE NOT INSTALLED):"), e)
-                )
+                raise exceptions.PipfileException(e)
             # Update project settings with pre preference.
             if pre:
                 project.update_settings({"allow_prereleases": pre})
@@ -1928,7 +2022,6 @@ def do_install(
             pypi_mirror=pypi_mirror,
             skip_lock=skip_lock,
         )
-    requirements_directory.cleanup()
     sys.exit(0)
 
 
@@ -1943,9 +2036,11 @@ def do_uninstall(
     all=False,
     keep_outdated=False,
     pypi_mirror=None,
+    ctx=None
 ):
     from .environments import PIPENV_USE_SYSTEM
-    from .vendor.requirementslib import Requirement
+    from .vendor.requirementslib.models.requirements import Requirement
+    from .vendor.packaging.utils import canonicalize_name
 
     # Automatically use an activated virtualenv.
     if PIPENV_USE_SYSTEM:
@@ -1954,23 +2049,42 @@ def do_uninstall(
     # TODO: We probably shouldn't ensure a project exists if the outcome will be to just
     # install things in order to remove them... maybe tell the user to install first?
     ensure_project(three=three, python=python, pypi_mirror=pypi_mirror)
-    editable_pkgs = [
-        Requirement.from_line("-e {0}".format(p)).name
-        for p in editable_packages
-        if p
-    ]
-    package_names = [p for p in packages if p] + editable_pkgs
-    pipfile_remove = True
     # Un-install all dependencies, if --all was provided.
-    if all is True:
-        click.echo(
-            crayons.normal(u"Un-installing all packages from virtualenv…", bold=True)
+    if not any([packages, editable_packages, all_dev, all]):
+        raise exceptions.MissingParameter(crayons.red("No package provided!"), ctx=ctx,
+                                                                    param_type="parameter")
+    editable_pkgs = [
+        Requirement.from_line("-e {0}".format(p)).name for p in editable_packages if p
+    ]
+    packages = packages + editable_pkgs
+    package_names = [p for p in packages if p]
+    package_map = {
+        canonicalize_name(p): p for p in packages if p
+    }
+    installed_package_names = set([
+        canonicalize_name(pkg.project_name) for pkg in project.get_installed_packages()
+    ])
+    # Intelligently detect if --dev should be used or not.
+    lockfile_packages = set()
+    if project.lockfile_exists:
+        develop = set(
+            [canonicalize_name(k) for k in project.lockfile_content["develop"].keys()]
         )
-        do_purge(allow_global=system)
-        return
+        default = set(
+            [canonicalize_name(k) for k in project.lockfile_content["default"].keys()]
+        )
+        lockfile_packages |= develop | default
+    else:
+        develop = set(
+            [canonicalize_name(k) for k in project.dev_packages.keys()]
+        )
+        default = set(
+            [canonicalize_name(k) for k in project.packages.keys()]
+        )
+    pipfile_remove = True
     # Uninstall [dev-packages], if --dev was provided.
     if all_dev:
-        if "dev-packages" not in project.parsed_pipfile:
+        if "dev-packages" not in project.parsed_pipfile and not develop:
             click.echo(
                 crayons.normal(
                     "No {0} to uninstall.".format(crayons.red("[dev-packages]")),
@@ -1980,28 +2094,70 @@ def do_uninstall(
             return
         click.echo(
             crayons.normal(
-                u"Un-installing {0}…".format(crayons.red("[dev-packages]")), bold=True
+                fix_utf8("Un-installing {0}…".format(crayons.red("[dev-packages]"))), bold=True
             )
         )
-        package_names = project.dev_packages.keys()
-    if packages is False and editable_packages is False and not all_dev:
-        click.echo(crayons.red("No package provided!"), err=True)
-        return 1
-    for package_name in package_names:
-        click.echo(u"Un-installing {0}…".format(crayons.green(package_name)))
-        cmd = "{0} uninstall {1} -y".format(
-            escape_grouped_arguments(which_pip(allow_global=system)), package_name
+        package_names = develop
+    fix_venv_site(project.env_paths["lib"])
+    # Remove known "bad packages" from the list.
+    bad_pkgs = set([canonicalize_name(pkg) for pkg in BAD_PACKAGES])
+    for bad_package in BAD_PACKAGES:
+        normalized_bad_pkg = canonicalize_name(bad_package)
+        if normalized_bad_pkg in package_map:
+            if environments.is_verbose():
+                click.echo("Ignoring {0}.".format(repr(bad_package)), err=True)
+            pkg_name_index = package_names.index(package_map[normalized_bad_pkg])
+            del package_names[pkg_name_index]
+    used_packages = develop | default & installed_package_names
+    failure = False
+    packages_to_remove = set()
+    if all:
+        package_names = develop | default
+        click.echo(
+            crayons.normal(fix_utf8("Un-installing all packages from virtualenv…"), bold=True)
         )
-        if environments.is_verbose():
-            click.echo("$ {0}".format(cmd))
-        c = delegator.run(cmd)
-        click.echo(crayons.blue(c.out))
-        if pipfile_remove:
+        do_purge(allow_global=system)
+        removed = package_names - bad_pkgs
+        project.remove_packages_from_pipfile(removed)
+        if lock:
+            do_lock(system=system, keep_outdated=keep_outdated, pypi_mirror=pypi_mirror)
+        return
+    if all_dev:
+        package_names = develop
+    else:
+        package_names = set([pkg_name for pkg_name in package_names])
+    selected_pkg_map = {
+        canonicalize_name(p): p for p in package_names
+    }
+    packages_to_remove = [
+        p for normalized, p in selected_pkg_map.items()
+        if (normalized in used_packages and normalized not in bad_pkgs)
+    ]
+    for normalized, package_name in selected_pkg_map.items():
+        click.echo(
+            crayons.white(
+                fix_utf8("Uninstalling {0}…".format(repr(package_name))), bold=True
+            )
+        )
+        # Uninstall the package.
+        if package_name in packages_to_remove:
+            cmd = "{0} uninstall {1} -y".format(
+                        escape_grouped_arguments(which_pip()), package_name
+                    )
+            if environments.is_verbose():
+                click.echo("$ {0}".format(cmd))
+            c = delegator.run(cmd)
+            click.echo(crayons.blue(c.out))
+            if c.return_code != 0:
+                failure = True
+        if not failure and pipfile_remove:
             in_packages = project.get_package_name_in_pipfile(package_name, dev=False)
             in_dev_packages = project.get_package_name_in_pipfile(
                 package_name, dev=True
             )
-            if not in_dev_packages and not in_packages:
+            if not (in_dev_packages or in_packages):
+                if normalized in lockfile_packages:
+                    continue
                 click.echo(
                     "No package {0} to remove from Pipfile.".format(
                         crayons.green(package_name)
@@ -2010,20 +2166,23 @@ def do_uninstall(
                 continue
 
             click.echo(
-                u"Removing {0} from Pipfile…".format(crayons.green(package_name))
+                fix_utf8("Removing {0} from Pipfile…".format(crayons.green(package_name)))
             )
             # Remove package from both packages and dev-packages.
-            project.remove_package_from_pipfile(package_name, dev=True)
-            project.remove_package_from_pipfile(package_name, dev=False)
+            if in_dev_packages:
+                project.remove_package_from_pipfile(package_name, dev=True)
+            if in_packages:
+                project.remove_package_from_pipfile(package_name, dev=False)
     if lock:
         do_lock(system=system, keep_outdated=keep_outdated, pypi_mirror=pypi_mirror)
+    sys.exit(int(failure))
 
 
 def do_shell(three=None, python=False, fancy=False, shell_args=None, pypi_mirror=None):
     # Ensure that virtualenv is available.
     ensure_project(three=three, python=python, validate=False, pypi_mirror=pypi_mirror)
     # Set an environment variable, so we know we're in the environment.
-    os.environ["PIPENV_ACTIVE"] = "1"
+    os.environ["PIPENV_ACTIVE"] = vistir.misc.fs_str("1")
     # Support shell compatibility mode.
     if PIPENV_SHELL_FANCY:
         fancy = True
@@ -2031,7 +2190,7 @@ def do_shell(three=None, python=False, fancy=False, shell_args=None, pypi_mirror
     from .shells import choose_shell
 
     shell = choose_shell()
-    click.echo("Launching subshell in virtual environment…", err=True)
+    click.echo(fix_utf8("Launching subshell in virtual environment…"), err=True)
 
     fork_args = (project.virtualenv_location, project.project_directory, shell_args)
 
@@ -2042,9 +2201,9 @@ def do_shell(three=None, python=False, fancy=False, shell_args=None, pypi_mirror
     try:
         shell.fork_compat(*fork_args)
     except (AttributeError, ImportError):
-        click.echo(
-            u"Compatibility mode not supported. "
-            u"Trying to continue as well-configured shell…",
+        click.echo(fix_utf8(
+            "Compatibility mode not supported. "
+            "Trying to continue as well-configured shell…"),
             err=True,
         )
         shell.fork(*fork_args)
@@ -2054,13 +2213,7 @@ def _inline_activate_virtualenv():
     try:
         activate_this = which("activate_this.py")
         if not activate_this or not os.path.exists(activate_this):
-            click.echo(
-                u"{0}: activate_this.py not found. Your environment is most "
-                u"certainly not activated. Continuing anyway…"
-                u"".format(crayons.red("Warning", bold=True)),
-                err=True,
-            )
-            return
+            raise exceptions.VirtualenvActivationException()
         with open(activate_this) as f:
             code = compile(f.read(), activate_this, "exec")
             exec(code, dict(__file__=activate_this))
@@ -2100,7 +2253,7 @@ def inline_activate_virtual_environment():
     else:
         _inline_activate_virtualenv()
     if "VIRTUAL_ENV" not in os.environ:
-        os.environ["VIRTUAL_ENV"] = root
+        os.environ["VIRTUAL_ENV"] = vistir.misc.fs_str(root)
 
 
 def _launch_windows_subprocess(script):
@@ -2170,6 +2323,8 @@ def do_run(command, args, three=None, python=False, pypi_mirror=None):
 
     # Ensure that virtualenv is available.
     ensure_project(three=three, python=python, validate=False, pypi_mirror=pypi_mirror)
+    # Set an environment variable, so we know we're in the environment.
+    os.environ["PIPENV_ACTIVE"] = vistir.misc.fs_str("1")
     load_dot_env()
     # Activate virtualenv under the current interpreter's environment
     inline_activate_virtual_environment()
@@ -2222,7 +2377,7 @@ def do_check(
             sys.exit(1)
         else:
             sys.exit(0)
-    click.echo(crayons.normal(u"Checking PEP 508 requirements…", bold=True))
+    click.echo(crayons.normal(fix_utf8("Checking PEP 508 requirements…"), bold=True))
     if system:
         python = system_which("python")
     else:
@@ -2258,7 +2413,7 @@ def do_check(
         sys.exit(1)
     else:
         click.echo(crayons.green("Passed!"))
-    click.echo(crayons.normal(u"Checking installed package safety…", bold=True))
+    click.echo(crayons.normal(fix_utf8("Checking installed package safety…"), bold=True))
     path = pep508checker.__file__.rstrip("cdo")
     path = os.sep.join(__file__.split(os.sep)[:-1] + ["patched", "safety.zip"])
     if not system:
@@ -2305,7 +2460,6 @@ def do_check(
 
 def do_graph(bare=False, json=False, json_tree=False, reverse=False):
     import pipdeptree
-
     try:
         python_path = which("python")
     except AttributeError:
@@ -2367,7 +2521,7 @@ def do_graph(bare=False, json=False, json_tree=False, reverse=False):
             err=True,
         )
         sys.exit(1)
-    cmd = '"{0}" {1} {2}'.format(
+    cmd = '"{0}" {1} {2} -l'.format(
         python_path, escape_grouped_arguments(pipdeptree.__file__.rstrip("cdo")), flag
     )
     # Run dep-tree.
@@ -2439,13 +2593,7 @@ def do_sync(
 ):
     # The lock file needs to exist because sync won't write to it.
     if not project.lockfile_exists:
-        click.echo(
-            "{0}: Pipfile.lock is missing! You need to run {1} first.".format(
-                crayons.red("Error", bold=True), crayons.red("$ pipenv lock", bold=True)
-            ),
-            err=True,
-        )
-        return 1
+        raise exceptions.LockfileNotFound(project.lockfile_location)
 
     # Ensure that virtualenv is available if not system.
     ensure_project(
@@ -2457,7 +2605,9 @@ def do_sync(
     )
 
     # Install everything.
-    requirements_dir = TemporaryDirectory(suffix="-requirements", prefix="pipenv-")
+    requirements_dir = vistir.path.create_tracked_tempdir(
+        suffix="-requirements", prefix="pipenv-"
+    )
     do_init(
         dev=dev,
         concurrent=(not sequential),
@@ -2467,45 +2617,48 @@ def do_sync(
         deploy=deploy,
         system=system,
     )
-    requirements_dir.cleanup()
-    click.echo(crayons.green("All dependencies are now up-to-date!"))
+    if not bare:
+        click.echo(crayons.green("All dependencies are now up-to-date!"))
 
 
-def do_clean(
-    ctx,
-    three=None,
-    python=None,
-    dry_run=False,
-    bare=False,
-    pypi_mirror=None,
-):
+def do_clean(ctx, three=None, python=None, dry_run=False, bare=False, pypi_mirror=None):
     # Ensure that virtualenv is available.
-
+    from packaging.utils import canonicalize_name
     ensure_project(three=three, python=python, validate=False, pypi_mirror=pypi_mirror)
     ensure_lockfile(pypi_mirror=pypi_mirror)
-    installed_package_names = [pkg.project_name for pkg in project.get_installed_packages()]
+    # Make sure that the virtualenv's site packages are configured correctly
+    # otherwise we may end up removing from the global site packages directory
+    fix_venv_site(project.env_paths["lib"])
+    installed_package_names = [
+        canonicalize_name(pkg.project_name) for pkg in project.get_installed_packages()
+    ]
     # Remove known "bad packages" from the list.
     for bad_package in BAD_PACKAGES:
-        if bad_package in installed_package_names:
+        if canonicalize_name(bad_package) in installed_package_names:
             if environments.is_verbose():
                 click.echo("Ignoring {0}.".format(repr(bad_package)), err=True)
-            del installed_package_names[installed_package_names.index(bad_package)]
+            del installed_package_names[installed_package_names.index(
+                canonicalize_name(bad_package)
+            )]
     # Intelligently detect if --dev should be used or not.
-    develop = [k.lower() for k in project.lockfile_content["develop"].keys()]
-    default = [k.lower() for k in project.lockfile_content["default"].keys()]
+    develop = [canonicalize_name(k) for k in project.lockfile_content["develop"].keys()]
+    default = [canonicalize_name(k) for k in project.lockfile_content["default"].keys()]
     for used_package in set(develop + default):
         if used_package in installed_package_names:
-            del installed_package_names[installed_package_names.index(used_package)]
+            del installed_package_names[installed_package_names.index(
+                canonicalize_name(used_package)
+            )]
     failure = False
     for apparent_bad_package in installed_package_names:
-        if dry_run:
+        if dry_run and not bare:
             click.echo(apparent_bad_package)
         else:
-            click.echo(
-                crayons.white(
-                    "Uninstalling {0}…".format(repr(apparent_bad_package)), bold=True
+            if not bare:
+                click.echo(
+                    crayons.white(
+                        fix_utf8("Uninstalling {0}…".format(repr(apparent_bad_package))), bold=True
+                    )
                 )
-            )
             # Uninstall the package.
             c = delegator.run(
                 "{0} uninstall {1} -y".format(which_pip(), apparent_bad_package)
diff --git a/pipenv/environments.py b/pipenv/environments.py
index 558bafd2..4ee8b90f 100644
--- a/pipenv/environments.py
+++ b/pipenv/environments.py
@@ -1,16 +1,23 @@
+# -*- coding=utf-8 -*-
+
 import os
 import sys
 from appdirs import user_cache_dir
+from .vendor.vistir.misc import fs_str, to_text
 
 
 # HACK: avoid resolver.py uses the wrong byte code files.
 # I hope I can remove this one day.
-os.environ["PYTHONDONTWRITEBYTECODE"] = "1"
+os.environ["PYTHONDONTWRITEBYTECODE"] = fs_str("1")
+
+PIPENV_IS_CI = bool("CI" in os.environ or "TF_BUILD" in os.environ)
 
 # HACK: Prevent invalid shebangs with Homebrew-installed Python:
 # https://bugs.python.org/issue22490
 os.environ.pop("__PYVENV_LAUNCHER__", None)
 
+# Load patched pip instead of system pip
+os.environ["PIP_SHIMS_BASE_MODULE"] = fs_str("pipenv.patched.notpip")
 
 PIPENV_CACHE_DIR = os.environ.get("PIPENV_CACHE_DIR", user_cache_dir("pipenv"))
 """Location for Pipenv to store it's package cache.
@@ -65,7 +72,7 @@ PIPENV_HIDE_EMOJIS = bool(os.environ.get("PIPENV_HIDE_EMOJIS"))
 
 Default is to show emojis. This is automatically set on Windows.
 """
-if os.name == "nt":
+if os.name == "nt" or PIPENV_IS_CI:
     PIPENV_HIDE_EMOJIS = True
 
 PIPENV_IGNORE_VIRTUALENVS = bool(os.environ.get("PIPENV_IGNORE_VIRTUALENVS"))
@@ -91,7 +98,7 @@ Default is 3. See also ``PIPENV_NO_INHERIT``.
 
 PIPENV_MAX_RETRIES = int(os.environ.get(
     "PIPENV_MAX_RETRIES",
-    "1" if "CI" in os.environ else "0",
+    "1" if PIPENV_IS_CI else "0",
 ))
 """Specify how many retries Pipenv should attempt for network requests.
 
@@ -125,9 +132,18 @@ PIPENV_NOSPIN = bool(os.environ.get("PIPENV_NOSPIN"))
 This can make the logs cleaner. Automatically set on Windows, and in CI
 environments.
 """
-if os.name == "nt" or "CI" in os.environ:
+if PIPENV_IS_CI:
     PIPENV_NOSPIN = True
 
+PIPENV_SPINNER = "dots"
+"""Sets the default spinner type.
+
+Spinners are identitcal to the node.js spinners and can be found at
+https://github.com/sindresorhus/cli-spinners
+"""
+if os.name == "nt":
+    PIPENV_SPINNER = "bouncingBar"
+
 PIPENV_PIPFILE = os.environ.get("PIPENV_PIPFILE")
 """If set, this specifies a custom Pipfile location.
 
@@ -227,9 +243,9 @@ SESSION_IS_INTERACTIVE = bool(os.isatty(sys.stdout.fileno()))
 # Internal, consolidated verbosity representation as an integer. The default
 # level is 0, increased for wordiness and decreased for terseness.
 PIPENV_VERBOSITY = os.environ.get("PIPENV_VERBOSITY", "")
-if PIPENV_VERBOSITY.isdigit():
+try:
     PIPENV_VERBOSITY = int(PIPENV_VERBOSITY)
-else:
+except (ValueError, TypeError):
     if PIPENV_VERBOSE:
         PIPENV_VERBOSITY = 1
     elif PIPENV_QUIET:
@@ -246,3 +262,8 @@ def is_verbose(threshold=1):
 
 def is_quiet(threshold=-1):
     return PIPENV_VERBOSITY <= threshold
+
+
+PIPENV_SPINNER_FAIL_TEXT = fs_str(to_text(u"✘ {0}")) if not PIPENV_HIDE_EMOJIS else ("{0}")
+
+PIPENV_SPINNER_OK_TEXT = fs_str(to_text(u"✔ {0}")) if not PIPENV_HIDE_EMOJIS else ("{0}")
diff --git a/pipenv/exceptions.py b/pipenv/exceptions.py
new file mode 100644
index 00000000..86643c8a
--- /dev/null
+++ b/pipenv/exceptions.py
@@ -0,0 +1,239 @@
+# -*- coding=utf-8 -*-
+
+import itertools
+import sys
+
+from traceback import format_exception
+from pprint import pformat
+
+import six
+
+from ._compat import fix_utf8
+from .patched import crayons
+from . import environments
+from .vendor.click.utils import echo as click_echo
+from .vendor.click._compat import get_text_stderr
+from .vendor.click.exceptions import (
+    Abort,
+    BadOptionUsage,
+    BadParameter,
+    ClickException,
+    Exit,
+    FileError,
+    MissingParameter,
+    UsageError,
+)
+from .vendor.click.types import Path
+
+
+def handle_exception(exc_type, exception, traceback, hook=sys.excepthook):
+    if environments.is_verbose() or not issubclass(exc_type, ClickException):
+        hook(exc_type, exception, traceback)
+    else:
+        exc = format_exception(exc_type, exception, traceback)
+        lines = itertools.chain.from_iterable([l.splitlines() for l in exc])
+        lines = list(lines)[-11:-1]
+        for line in lines:
+            line = line.strip("'").strip('"').strip("\n").strip()
+            if not line.startswith("File"):
+                line = "      {0}".format(line)
+            else:
+                line = "  {0}".format(line)
+            line = "[pipenv.exceptions.{0!s}]: {1}".format(
+                exception.__class__.__name__, line
+            )
+            click_echo(fix_utf8(line), err=True)
+        exception.show()
+
+
+sys.excepthook = handle_exception
+
+
+class PipenvException(ClickException):
+    message = "{0}: {{0}}".format(crayons.red("ERROR", bold=True))
+
+    def __init__(self, message=None, **kwargs):
+        if not message:
+            message = "Pipenv encountered a problem and had to exit."
+        extra = kwargs.pop("extra", [])
+        message = self.message.format(message)
+        ClickException.__init__(self, message)
+        self.extra = extra
+
+    def show(self, file=None):
+        if file is None:
+            file = get_text_stderr()
+        if self.extra:
+            if isinstance(self.extra, six.string_types):
+                self.extra = [self.extra,]
+            for extra in self.extra:
+                extra = "[pipenv.exceptions.{0!s}]: {1}".format(
+                    self.__class__.__name__, extra
+                )
+                click_echo(extra, file=file)
+        click_echo(fix_utf8("{0}".format(self.message)), file=file)
+
+
+class PipenvUsageError(UsageError):
+
+    def __init__(self, message=None, ctx=None, **kwargs):
+        formatted_message = "{0}: {1}"
+        msg_prefix = crayons.red("ERROR:", bold=True)
+        if not message:
+            message = "Pipenv encountered a problem and had to exit."
+        message = formatted_message.format(msg_prefix, crayons.white(message, bold=True))
+        self.message = message
+        extra = kwargs.pop("extra", [])
+        UsageError.__init__(self, message, ctx)
+        self.extra = extra
+
+    def show(self, file=None):
+        if file is None:
+            file = get_text_stderr()
+        color = None
+        if self.ctx is not None:
+            color = self.ctx.color
+        if self.extra:
+            if isinstance(self.extra, six.string_types):
+                self.extra = [self.extra,]
+            for extra in self.extra:
+                if color:
+                    extra = getattr(crayons, color, "normal")
+                click_echo(extra, file=file)
+        hint = ''
+        if (self.cmd is not None and
+                self.cmd.get_help_option(self.ctx) is not None):
+            hint = ('Try "%s %s" for help.\n'
+                    % (self.ctx.command_path, self.ctx.help_option_names[0]))
+        if self.ctx is not None:
+            click_echo(self.ctx.get_usage() + '\n%s' % hint, file=file, color=color)
+        click_echo(self.message, file=file)
+
+
+class PipenvFileError(FileError):
+    formatted_message = "{0} {{0}} {{1}}".format(
+        crayons.red("ERROR:", bold=True)
+    )
+
+    def __init__(self, filename, message=None, **kwargs):
+        extra = kwargs.pop("extra", [])
+        if not message:
+            message = crayons.white("Please ensure that the file exists!", bold=True)
+        message = self.formatted_message.format(
+            crayons.white("{0} not found!".format(filename), bold=True),
+            message
+        )
+        FileError.__init__(self, filename=filename, hint=message, **kwargs)
+        self.extra = extra
+
+    def show(self, file=None):
+        if file is None:
+            file = get_text_stderr()
+        if self.extra:
+            if isinstance(self.extra, six.string_types):
+                self.extra = [self.extra,]
+            for extra in self.extra:
+                click_echo(extra, file=file)
+        click_echo(self.message, file=file)
+
+
+class PipfileNotFound(PipenvFileError):
+    def __init__(self, filename="Pipfile", extra=None, **kwargs):
+        extra = kwargs.pop("extra", [])
+        message = ("{0}. {1}".format(
+                crayons.red("Aborting!", bold=True),
+                crayons.white("Please ensure that the file exists and is located in your"
+                                " project root directory.", bold=True)
+            )
+        )
+        super(PipfileNotFound, self).__init__(filename, message=message, extra=extra, **kwargs)
+
+
+class LockfileNotFound(PipenvFileError):
+    def __init__(self, filename="Pipfile.lock", extra=None, **kwargs):
+        extra = kwargs.pop("extra", [])
+        message = "{0} {1} {2}".format(
+            crayons.white("You need to run", bold=True),
+            crayons.red("$ pipenv lock", bold=True),
+            crayons.white("before you can continue.", bold=True)
+        )
+        super(LockfileNotFound, self).__init__(filename, message=message, extra=extra, **kwargs)
+
+
+class DeployException(PipenvUsageError):
+    def __init__(self, message=None, **kwargs):
+        if not message:
+            message = crayons.normal("Aborting deploy", bold=True)
+        extra = kwargs.pop("extra", [])
+        PipenvUsageError.__init__(message=message, extra=extra, **kwargs)
+
+
+class PipenvOptionsError(PipenvUsageError):
+    def __init__(self, option_name, message=None, ctx=None, **kwargs):
+        extra = kwargs.pop("extra", [])
+        PipenvUsageError.__init__(self, message=message, ctx=ctx, **kwargs)
+        self.extra = extra
+        self.option_name = option_name
+
+
+class PipfileException(PipenvFileError):
+    def __init__(self, hint=None, **kwargs):
+        from .core import project
+
+        if not hint:
+            hint = "{0} {1}".format(crayons.red("ERROR (PACKAGE NOT INSTALLED):"), hint)
+        filename = project.pipfile_location
+        extra = kwargs.pop("extra", [])
+        PipenvFileError.__init__(self, filename, hint, extra=extra, **kwargs)
+
+
+class SetupException(PipenvException):
+    def __init__(self, message=None, **kwargs):
+        PipenvException.__init__(message, **kwargs)
+
+
+class VirtualenvException(PipenvException):
+
+    def __init__(self, message=None, **kwargs):
+        if not message:
+            message = (
+                "There was an unexpected error while activating your virtualenv. "
+                "Continuing anyway..."
+            )
+        PipenvException.__init__(self, message, **kwargs)
+
+
+class VirtualenvActivationException(VirtualenvException):
+    def __init__(self, message=None, **kwargs):
+        if not message:
+            message = (
+                "activate_this.py not found. Your environment is most certainly "
+                "not activated. Continuing anyway…"
+            )
+        self.message = message
+        VirtualenvException.__init__(self, message, **kwargs)
+
+
+class VirtualenvCreationException(VirtualenvException):
+    def __init__(self, message=None, **kwargs):
+        if not message:
+            message = "Failed to create virtual environment."
+        self.message = message
+        VirtualenvException.__init__(self, message, **kwargs)
+
+
+class UninstallError(PipenvException):
+    def __init__(self, package, command, return_values, return_code, **kwargs):
+        extra = [crayons.blue("Attempted to run command: {0}".format(
+            crayons.yellow("$ {0}".format(command), bold=True)
+        )),]
+        extra.extend([crayons.blue(line.strip()) for line in return_values.splitlines()])
+        if isinstance(package, (tuple, list)):
+            package = " ".join(package)
+        message = "{0} {1}...".format(
+            crayons.normal("Failed to uninstall package(s)"),
+            crayons.yellow(package, bold=True)
+        )
+        self.exit_code = return_code
+        PipenvException.__init__(self, message=message, extra=extra)
+        self.extra = extra
diff --git a/pipenv/patched/crayons.py b/pipenv/patched/crayons.py
index bb4b3d97..de735daf 100644
--- a/pipenv/patched/crayons.py
+++ b/pipenv/patched/crayons.py
@@ -39,6 +39,7 @@ if (
     os.environ.get("CMDER_ROOT")
     or os.environ.get("VSCODE_PID")
     or os.environ.get("TERM_PROGRAM") == "Hyper"
+    or "VSCODE_CWD" in os.environ
 ):
     is_native_powershell = False
 else:
@@ -49,14 +50,16 @@ try:
 except shellingham.ShellDetectionFailure:
     is_powershell = False
 
-if is_ipython or (is_powershell and is_native_powershell):
+DISABLE_COLOR = False
+REPLACE_BLUE = False
+if is_ipython:
     """when ipython is fired lot of variables like _oh, etc are used.
        There are so many ways to find current python interpreter is ipython.
        get_ipython is easiest is most appealing for readers to understand.
     """
     DISABLE_COLOR = True
-else:
-    DISABLE_COLOR = False
+elif is_powershell and is_native_powershell:
+    REPLACE_BLUE = True
 
 
 class ColoredString(object):
@@ -68,6 +71,9 @@ class ColoredString(object):
             self.s = s.encode("utf-8")
         else:
             self.s = s
+
+        if color == "BLUE" and REPLACE_BLUE:
+            color = "MAGENTA"
         self.color = color
         self.always_color = always_color
         self.bold = bold
diff --git a/pipenv/patched/notpip/LICENSE.txt b/pipenv/patched/notpip/LICENSE.txt
index f63eac3d..d3379fac 100644
--- a/pipenv/patched/notpip/LICENSE.txt
+++ b/pipenv/patched/notpip/LICENSE.txt
@@ -1,4 +1,4 @@
-Copyright (c) 2008-2016 The pip developers (see AUTHORS.txt file)
+Copyright (c) 2008-2018 The pip developers (see AUTHORS.txt file)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/pipenv/patched/notpip/__init__.py b/pipenv/patched/notpip/__init__.py
index ab649641..ae265fa7 100644
--- a/pipenv/patched/notpip/__init__.py
+++ b/pipenv/patched/notpip/__init__.py
@@ -1 +1 @@
-__version__ = "10.0.1"
+__version__ = "18.1"
diff --git a/pipenv/patched/notpip/__main__.py b/pipenv/patched/notpip/__main__.py
index e63d7ae9..a4879980 100644
--- a/pipenv/patched/notpip/__main__.py
+++ b/pipenv/patched/notpip/__main__.py
@@ -13,7 +13,7 @@ if __package__ == '':
     path = os.path.dirname(os.path.dirname(__file__))
     sys.path.insert(0, path)
 
-from pipenv.patched.notpip._internal import main as _main  # noqa
+from pipenv.patched.notpip._internal import main as _main  # isort:skip # noqa
 
 if __name__ == '__main__':
     sys.exit(_main())
diff --git a/pipenv/patched/notpip/_internal/__init__.py b/pipenv/patched/notpip/_internal/__init__.py
index dadf6e11..6d223928 100644
--- a/pipenv/patched/notpip/_internal/__init__.py
+++ b/pipenv/patched/notpip/_internal/__init__.py
@@ -4,7 +4,6 @@ from __future__ import absolute_import
 import locale
 import logging
 import os
-import optparse
 import warnings
 
 import sys
@@ -38,17 +37,12 @@ else:
         else:
             securetransport.inject_into_urllib3()
 
-from pipenv.patched.notpip import __version__
-from pipenv.patched.notpip._internal import cmdoptions
-from pipenv.patched.notpip._internal.exceptions import CommandError, PipError
-from pipenv.patched.notpip._internal.utils.misc import get_installed_distributions, get_prog
+from pipenv.patched.notpip._internal.cli.autocompletion import autocomplete
+from pipenv.patched.notpip._internal.cli.main_parser import parse_command
+from pipenv.patched.notpip._internal.commands import commands_dict
+from pipenv.patched.notpip._internal.exceptions import PipError
 from pipenv.patched.notpip._internal.utils import deprecation
 from pipenv.patched.notpip._internal.vcs import git, mercurial, subversion, bazaar  # noqa
-from pipenv.patched.notpip._internal.baseparser import (
-    ConfigOptionParser, UpdatingDefaultsHelpFormatter,
-)
-from pipenv.patched.notpip._internal.commands import get_summaries, get_similar_commands
-from pipenv.patched.notpip._internal.commands import commands_dict
 from pipenv.patched.notpip._vendor.urllib3.exceptions import InsecureRequestWarning
 
 logger = logging.getLogger(__name__)
@@ -57,168 +51,6 @@ logger = logging.getLogger(__name__)
 warnings.filterwarnings("ignore", category=InsecureRequestWarning)
 
 
-def autocomplete():
-    """Command and option completion for the main option parser (and options)
-    and its subcommands (and options).
-
-    Enable by sourcing one of the completion shell scripts (bash, zsh or fish).
-    """
-    # Don't complete if user hasn't sourced bash_completion file.
-    if 'PIP_AUTO_COMPLETE' not in os.environ:
-        return
-    cwords = os.environ['COMP_WORDS'].split()[1:]
-    cword = int(os.environ['COMP_CWORD'])
-    try:
-        current = cwords[cword - 1]
-    except IndexError:
-        current = ''
-
-    subcommands = [cmd for cmd, summary in get_summaries()]
-    options = []
-    # subcommand
-    try:
-        subcommand_name = [w for w in cwords if w in subcommands][0]
-    except IndexError:
-        subcommand_name = None
-
-    parser = create_main_parser()
-    # subcommand options
-    if subcommand_name:
-        # special case: 'help' subcommand has no options
-        if subcommand_name == 'help':
-            sys.exit(1)
-        # special case: list locally installed dists for show and uninstall
-        should_list_installed = (
-            subcommand_name in ['show', 'uninstall'] and
-            not current.startswith('-')
-        )
-        if should_list_installed:
-            installed = []
-            lc = current.lower()
-            for dist in get_installed_distributions(local_only=True):
-                if dist.key.startswith(lc) and dist.key not in cwords[1:]:
-                    installed.append(dist.key)
-            # if there are no dists installed, fall back to option completion
-            if installed:
-                for dist in installed:
-                    print(dist)
-                sys.exit(1)
-
-        subcommand = commands_dict[subcommand_name]()
-
-        for opt in subcommand.parser.option_list_all:
-            if opt.help != optparse.SUPPRESS_HELP:
-                for opt_str in opt._long_opts + opt._short_opts:
-                    options.append((opt_str, opt.nargs))
-
-        # filter out previously specified options from available options
-        prev_opts = [x.split('=')[0] for x in cwords[1:cword - 1]]
-        options = [(x, v) for (x, v) in options if x not in prev_opts]
-        # filter options by current input
-        options = [(k, v) for k, v in options if k.startswith(current)]
-        for option in options:
-            opt_label = option[0]
-            # append '=' to options which require args
-            if option[1] and option[0][:2] == "--":
-                opt_label += '='
-            print(opt_label)
-    else:
-        # show main parser options only when necessary
-        if current.startswith('-') or current.startswith('--'):
-            opts = [i.option_list for i in parser.option_groups]
-            opts.append(parser.option_list)
-            opts = (o for it in opts for o in it)
-
-            for opt in opts:
-                if opt.help != optparse.SUPPRESS_HELP:
-                    subcommands += opt._long_opts + opt._short_opts
-
-        print(' '.join([x for x in subcommands if x.startswith(current)]))
-    sys.exit(1)
-
-
-def create_main_parser():
-    parser_kw = {
-        'usage': '\n%prog <command> [options]',
-        'add_help_option': False,
-        'formatter': UpdatingDefaultsHelpFormatter(),
-        'name': 'global',
-        'prog': get_prog(),
-    }
-
-    parser = ConfigOptionParser(**parser_kw)
-    parser.disable_interspersed_args()
-
-    pip_pkg_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    parser.version = 'pip %s from %s (python %s)' % (
-        __version__, pip_pkg_dir, sys.version[:3],
-    )
-
-    # add the general options
-    gen_opts = cmdoptions.make_option_group(cmdoptions.general_group, parser)
-    parser.add_option_group(gen_opts)
-
-    parser.main = True  # so the help formatter knows
-
-    # create command listing for description
-    command_summaries = get_summaries()
-    description = [''] + ['%-27s %s' % (i, j) for i, j in command_summaries]
-    parser.description = '\n'.join(description)
-
-    return parser
-
-
-def parseopts(args):
-    parser = create_main_parser()
-
-    # Note: parser calls disable_interspersed_args(), so the result of this
-    # call is to split the initial args into the general options before the
-    # subcommand and everything else.
-    # For example:
-    #  args: ['--timeout=5', 'install', '--user', 'INITools']
-    #  general_options: ['--timeout==5']
-    #  args_else: ['install', '--user', 'INITools']
-    general_options, args_else = parser.parse_args(args)
-
-    # --version
-    if general_options.version:
-        sys.stdout.write(parser.version)
-        sys.stdout.write(os.linesep)
-        sys.exit()
-
-    # pip || pip help -> print_help()
-    if not args_else or (args_else[0] == 'help' and len(args_else) == 1):
-        parser.print_help()
-        sys.exit()
-
-    # the subcommand name
-    cmd_name = args_else[0]
-
-    if cmd_name not in commands_dict:
-        guess = get_similar_commands(cmd_name)
-
-        msg = ['unknown command "%s"' % cmd_name]
-        if guess:
-            msg.append('maybe you meant "%s"' % guess)
-
-        raise CommandError(' - '.join(msg))
-
-    # all the args without the subcommand
-    cmd_args = args[:]
-    cmd_args.remove(cmd_name)
-
-    return cmd_name, cmd_args
-
-
-def check_isolated(args):
-    isolated = False
-
-    if "--isolated" in args:
-        isolated = True
-
-    return isolated
-
-
 def main(args=None):
     if args is None:
         args = sys.argv[1:]
@@ -229,7 +61,7 @@ def main(args=None):
     autocomplete()
 
     try:
-        cmd_name, cmd_args = parseopts(args)
+        cmd_name, cmd_args = parse_command(args)
     except PipError as exc:
         sys.stderr.write("ERROR: %s" % exc)
         sys.stderr.write(os.linesep)
@@ -242,5 +74,5 @@ def main(args=None):
     except locale.Error as e:
         # setlocale can apparently crash if locale are uninitialized
         logger.debug("Ignoring error %s when setting locale", e)
-    command = commands_dict[cmd_name](isolated=check_isolated(cmd_args))
+    command = commands_dict[cmd_name](isolated=("--isolated" in cmd_args))
     return command.main(cmd_args)
diff --git a/pipenv/patched/notpip/_internal/build_env.py b/pipenv/patched/notpip/_internal/build_env.py
index c41696ef..6d696fbd 100644
--- a/pipenv/patched/notpip/_internal/build_env.py
+++ b/pipenv/patched/notpip/_internal/build_env.py
@@ -1,28 +1,34 @@
 """Build Environment used for isolation during sdist building
 """
 
+import logging
 import os
+import sys
 from distutils.sysconfig import get_python_lib
 from sysconfig import get_paths
 
+from pipenv.patched.notpip._vendor.pkg_resources import Requirement, VersionConflict, WorkingSet
+
+from pipenv.patched.notpip._internal.utils.misc import call_subprocess
 from pipenv.patched.notpip._internal.utils.temp_dir import TempDirectory
+from pipenv.patched.notpip._internal.utils.ui import open_spinner
+
+logger = logging.getLogger(__name__)
 
 
 class BuildEnvironment(object):
     """Creates and manages an isolated environment to install build deps
     """
 
-    def __init__(self, no_clean):
+    def __init__(self):
         self._temp_dir = TempDirectory(kind="build-env")
-        self._no_clean = no_clean
+        self._temp_dir.create()
 
     @property
     def path(self):
         return self._temp_dir.path
 
     def __enter__(self):
-        self._temp_dir.create()
-
         self.save_path = os.environ.get('PATH', None)
         self.save_pythonpath = os.environ.get('PYTHONPATH', None)
         self.save_nousersite = os.environ.get('PYTHONNOUSERSITE', None)
@@ -58,9 +64,6 @@ class BuildEnvironment(object):
         return self.path
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        if not self._no_clean:
-            self._temp_dir.cleanup()
-
         def restore_var(varname, old_value):
             if old_value is None:
                 os.environ.pop(varname, None)
@@ -74,12 +77,56 @@ class BuildEnvironment(object):
     def cleanup(self):
         self._temp_dir.cleanup()
 
+    def missing_requirements(self, reqs):
+        """Return a list of the requirements from reqs that are not present
+        """
+        missing = []
+        with self:
+            ws = WorkingSet(os.environ["PYTHONPATH"].split(os.pathsep))
+            for req in reqs:
+                try:
+                    if ws.find(Requirement.parse(req)) is None:
+                        missing.append(req)
+                except VersionConflict:
+                    missing.append(req)
+            return missing
+
+    def install_requirements(self, finder, requirements, message):
+        args = [
+            sys.executable, '-m', 'pip', 'install', '--ignore-installed',
+            '--no-user', '--prefix', self.path, '--no-warn-script-location',
+        ]
+        if logger.getEffectiveLevel() <= logging.DEBUG:
+            args.append('-v')
+        for format_control in ('no_binary', 'only_binary'):
+            formats = getattr(finder.format_control, format_control)
+            args.extend(('--' + format_control.replace('_', '-'),
+                         ','.join(sorted(formats or {':none:'}))))
+        if finder.index_urls:
+            args.extend(['-i', finder.index_urls[0]])
+            for extra_index in finder.index_urls[1:]:
+                args.extend(['--extra-index-url', extra_index])
+        else:
+            args.append('--no-index')
+        for link in finder.find_links:
+            args.extend(['--find-links', link])
+        for _, host, _ in finder.secure_origins:
+            args.extend(['--trusted-host', host])
+        if finder.allow_all_prereleases:
+            args.append('--pre')
+        if finder.process_dependency_links:
+            args.append('--process-dependency-links')
+        args.append('--')
+        args.extend(requirements)
+        with open_spinner(message) as spinner:
+            call_subprocess(args, show_stdout=False, spinner=spinner)
+
 
 class NoOpBuildEnvironment(BuildEnvironment):
     """A no-op drop-in replacement for BuildEnvironment
     """
 
-    def __init__(self, no_clean):
+    def __init__(self):
         pass
 
     def __enter__(self):
@@ -90,3 +137,6 @@ class NoOpBuildEnvironment(BuildEnvironment):
 
     def cleanup(self):
         pass
+
+    def install_requirements(self, finder, requirements, message):
+        raise NotImplementedError()
diff --git a/pipenv/patched/notpip/_internal/cache.py b/pipenv/patched/notpip/_internal/cache.py
index a3a28fd8..d91b8170 100644
--- a/pipenv/patched/notpip/_internal/cache.py
+++ b/pipenv/patched/notpip/_internal/cache.py
@@ -8,9 +8,9 @@ import os
 
 from pipenv.patched.notpip._vendor.packaging.utils import canonicalize_name
 
-from pipenv.patched.notpip._internal import index
-from pipenv.patched.notpip._internal.compat import expanduser
 from pipenv.patched.notpip._internal.download import path_to_url
+from pipenv.patched.notpip._internal.models.link import Link
+from pipenv.patched.notpip._internal.utils.compat import expanduser
 from pipenv.patched.notpip._internal.utils.temp_dir import TempDirectory
 from pipenv.patched.notpip._internal.wheel import InvalidWheelFilename, Wheel
 
@@ -22,7 +22,7 @@ class Cache(object):
 
 
         :param cache_dir: The root of the cache.
-        :param format_control: A pip.index.FormatControl object to limit
+        :param format_control: An object of FormatControl class to limit
             binaries being read from the cache.
         :param allowed_formats: which formats of files the cache should store.
             ('binary' and 'source' are the only allowed values)
@@ -72,8 +72,8 @@ class Cache(object):
             return []
 
         canonical_name = canonicalize_name(package_name)
-        formats = index.fmt_ctl_formats(
-            self.format_control, canonical_name
+        formats = self.format_control.get_allowed_formats(
+            canonical_name
         )
         if not self.allowed_formats.intersection(formats):
             return []
@@ -101,7 +101,7 @@ class Cache(object):
         root = self.get_path_for_link(link)
         path = os.path.join(root, candidate)
 
-        return index.Link(path_to_url(path))
+        return Link(path_to_url(path))
 
     def cleanup(self):
         pass
diff --git a/pipenv/patched/notpip/_internal/cli/__init__.py b/pipenv/patched/notpip/_internal/cli/__init__.py
new file mode 100644
index 00000000..e589bb91
--- /dev/null
+++ b/pipenv/patched/notpip/_internal/cli/__init__.py
@@ -0,0 +1,4 @@
+"""Subpackage containing all of pip's command line interface related code
+"""
+
+# This file intentionally does not import submodules
diff --git a/pipenv/patched/notpip/_internal/cli/autocompletion.py b/pipenv/patched/notpip/_internal/cli/autocompletion.py
new file mode 100644
index 00000000..15b560a1
--- /dev/null
+++ b/pipenv/patched/notpip/_internal/cli/autocompletion.py
@@ -0,0 +1,152 @@
+"""Logic that powers autocompletion installed by ``pip completion``.
+"""
+
+import optparse
+import os
+import sys
+
+from pipenv.patched.notpip._internal.cli.main_parser import create_main_parser
+from pipenv.patched.notpip._internal.commands import commands_dict, get_summaries
+from pipenv.patched.notpip._internal.utils.misc import get_installed_distributions
+
+
+def autocomplete():
+    """Entry Point for completion of main and subcommand options.
+    """
+    # Don't complete if user hasn't sourced bash_completion file.
+    if 'PIP_AUTO_COMPLETE' not in os.environ:
+        return
+    cwords = os.environ['COMP_WORDS'].split()[1:]
+    cword = int(os.environ['COMP_CWORD'])
+    try:
+        current = cwords[cword - 1]
+    except IndexError:
+        current = ''
+
+    subcommands = [cmd for cmd, summary in get_summaries()]
+    options = []
+    # subcommand
+    try:
+        subcommand_name = [w for w in cwords if w in subcommands][0]
+    except IndexError:
+        subcommand_name = None
+
+    parser = create_main_parser()
+    # subcommand options
+    if subcommand_name:
+        # special case: 'help' subcommand has no options
+        if subcommand_name == 'help':
+            sys.exit(1)
+        # special case: list locally installed dists for show and uninstall
+        should_list_installed = (
+            subcommand_name in ['show', 'uninstall'] and
+            not current.startswith('-')
+        )
+        if should_list_installed:
+            installed = []
+            lc = current.lower()
+            for dist in get_installed_distributions(local_only=True):
+                if dist.key.startswith(lc) and dist.key not in cwords[1:]:
+                    installed.append(dist.key)
+            # if there are no dists installed, fall back to option completion
+            if installed:
+                for dist in installed:
+                    print(dist)
+                sys.exit(1)
+
+        subcommand = commands_dict[subcommand_name]()
+
+        for opt in subcommand.parser.option_list_all:
+            if opt.help != optparse.SUPPRESS_HELP:
+                for opt_str in opt._long_opts + opt._short_opts:
+                    options.append((opt_str, opt.nargs))
+
+        # filter out previously specified options from available options
+        prev_opts = [x.split('=')[0] for x in cwords[1:cword - 1]]
+        options = [(x, v) for (x, v) in options if x not in prev_opts]
+        # filter options by current input
+        options = [(k, v) for k, v in options if k.startswith(current)]
+        # get completion type given cwords and available subcommand options
+        completion_type = get_path_completion_type(
+            cwords, cword, subcommand.parser.option_list_all,
+        )
+        # get completion files and directories if ``completion_type`` is
+        # ``<file>``, ``<dir>`` or ``<path>``
+        if completion_type:
+            options = auto_complete_paths(current, completion_type)
+            options = ((opt, 0) for opt in options)
+        for option in options:
+            opt_label = option[0]
+            # append '=' to options which require args
+            if option[1] and option[0][:2] == "--":
+                opt_label += '='
+            print(opt_label)
+    else:
+        # show main parser options only when necessary
+
+        opts = [i.option_list for i in parser.option_groups]
+        opts.append(parser.option_list)
+        opts = (o for it in opts for o in it)
+        if current.startswith('-'):
+            for opt in opts:
+                if opt.help != optparse.SUPPRESS_HELP:
+                    subcommands += opt._long_opts + opt._short_opts
+        else:
+            # get completion type given cwords and all available options
+            completion_type = get_path_completion_type(cwords, cword, opts)
+            if completion_type:
+                subcommands = auto_complete_paths(current, completion_type)
+
+        print(' '.join([x for x in subcommands if x.startswith(current)]))
+    sys.exit(1)
+
+
+def get_path_completion_type(cwords, cword, opts):
+    """Get the type of path completion (``file``, ``dir``, ``path`` or None)
+
+    :param cwords: same as the environmental variable ``COMP_WORDS``
+    :param cword: same as the environmental variable ``COMP_CWORD``
+    :param opts: The available options to check
+    :return: path completion type (``file``, ``dir``, ``path`` or None)
+    """
+    if cword < 2 or not cwords[cword - 2].startswith('-'):
+        return
+    for opt in opts:
+        if opt.help == optparse.SUPPRESS_HELP:
+            continue
+        for o in str(opt).split('/'):
+            if cwords[cword - 2].split('=')[0] == o:
+                if not opt.metavar or any(
+                        x in ('path', 'file', 'dir')
+                        for x in opt.metavar.split('/')):
+                    return opt.metavar
+
+
+def auto_complete_paths(current, completion_type):
+    """If ``completion_type`` is ``file`` or ``path``, list all regular files
+    and directories starting with ``current``; otherwise only list directories
+    starting with ``current``.
+
+    :param current: The word to be completed
+    :param completion_type: path completion type(`file`, `path` or `dir`)i
+    :return: A generator of regular files and/or directories
+    """
+    directory, filename = os.path.split(current)
+    current_path = os.path.abspath(directory)
+    # Don't complete paths if they can't be accessed
+    if not os.access(current_path, os.R_OK):
+        return
+    filename = os.path.normcase(filename)
+    # list all files that start with ``filename``
+    file_list = (x for x in os.listdir(current_path)
+                 if os.path.normcase(x).startswith(filename))
+    for f in file_list:
+        opt = os.path.join(current_path, f)
+        comp_file = os.path.normcase(os.path.join(directory, f))
+        # complete regular files when there is not ``<dir>`` after option
+        # complete directories when there is ``<file>``, ``<path>`` or
+        # ``<dir>``after option
+        if completion_type != 'dir' and os.path.isfile(opt):
+            yield comp_file
+        elif os.path.isdir(opt):
+            yield os.path.join(comp_file, '')
diff --git a/pipenv/patched/notpip/_internal/basecommand.py b/pipenv/patched/notpip/_internal/cli/base_command.py
similarity index 62%
rename from pipenv/patched/notpip/_internal/basecommand.py
rename to pipenv/patched/notpip/_internal/cli/base_command.py
index e35bf3d1..229831f2 100644
--- a/pipenv/patched/notpip/_internal/basecommand.py
+++ b/pipenv/patched/notpip/_internal/cli/base_command.py
@@ -6,13 +6,15 @@ import logging.config
 import optparse
 import os
 import sys
-import warnings
 
-from pipenv.patched.notpip._internal import cmdoptions
-from pipenv.patched.notpip._internal.baseparser import (
+from pipenv.patched.notpip._internal.cli import cmdoptions
+from pipenv.patched.notpip._internal.cli.parser import (
     ConfigOptionParser, UpdatingDefaultsHelpFormatter,
 )
-from pipenv.patched.notpip._internal.compat import WINDOWS
+from pipenv.patched.notpip._internal.cli.status_codes import (
+    ERROR, PREVIOUS_BUILD_DIR_ERROR, SUCCESS, UNKNOWN_ERROR,
+    VIRTUALENV_NOT_FOUND,
+)
 from pipenv.patched.notpip._internal.download import PipSession
 from pipenv.patched.notpip._internal.exceptions import (
     BadCommand, CommandError, InstallationError, PreviousBuildDirError,
@@ -20,20 +22,17 @@ from pipenv.patched.notpip._internal.exceptions import (
 )
 from pipenv.patched.notpip._internal.index import PackageFinder
 from pipenv.patched.notpip._internal.locations import running_under_virtualenv
-from pipenv.patched.notpip._internal.req.req_file import parse_requirements
-from pipenv.patched.notpip._internal.req.req_install import InstallRequirement
-from pipenv.patched.notpip._internal.status_codes import (
-    ERROR, PREVIOUS_BUILD_DIR_ERROR, SUCCESS, UNKNOWN_ERROR,
-    VIRTUALENV_NOT_FOUND,
+from pipenv.patched.notpip._internal.req.constructors import (
+    install_req_from_editable, install_req_from_line,
 )
-from pipenv.patched.notpip._internal.utils import deprecation
-from pipenv.patched.notpip._internal.utils.logging import IndentingFormatter
+from pipenv.patched.notpip._internal.req.req_file import parse_requirements
+from pipenv.patched.notpip._internal.utils.logging import setup_logging
 from pipenv.patched.notpip._internal.utils.misc import get_prog, normalize_path
 from pipenv.patched.notpip._internal.utils.outdated import pip_version_check
 from pipenv.patched.notpip._internal.utils.typing import MYPY_CHECK_RUNNING
 
 if MYPY_CHECK_RUNNING:
-    from typing import Optional
+    from typing import Optional  # noqa: F401
 
 __all__ = ['Command']
 
@@ -45,7 +44,6 @@ class Command(object):
     usage = None  # type: Optional[str]
     hidden = False  # type: bool
     ignore_require_venv = False  # type: bool
-    log_streams = ("ext://sys.stdout", "ext://sys.stderr")
 
     def __init__(self, isolated=False):
         parser_kw = {
@@ -117,96 +115,15 @@ class Command(object):
         # Set verbosity so that it can be used elsewhere.
         self.verbosity = options.verbose - options.quiet
 
-        if self.verbosity >= 1:
-            level = "DEBUG"
-        elif self.verbosity == -1:
-            level = "WARNING"
-        elif self.verbosity == -2:
-            level = "ERROR"
-        elif self.verbosity <= -3:
-            level = "CRITICAL"
-        else:
-            level = "INFO"
+        setup_logging(
+            verbosity=self.verbosity,
+            no_color=options.no_color,
+            user_log_file=options.log,
+        )
 
-        # The root logger should match the "console" level *unless* we
-        # specified "--log" to send debug logs to a file.
-        root_level = level
-        if options.log:
-            root_level = "DEBUG"
-
-        logger_class = "pip._internal.utils.logging.ColorizedStreamHandler"
-        handler_class = "pip._internal.utils.logging.BetterRotatingFileHandler"
-
-        logging.config.dictConfig({
-            "version": 1,
-            "disable_existing_loggers": False,
-            "filters": {
-                "exclude_warnings": {
-                    "()": "pip._internal.utils.logging.MaxLevelFilter",
-                    "level": logging.WARNING,
-                },
-            },
-            "formatters": {
-                "indent": {
-                    "()": IndentingFormatter,
-                    "format": "%(message)s",
-                },
-            },
-            "handlers": {
-                "console": {
-                    "level": level,
-                    "class": logger_class,
-                    "no_color": options.no_color,
-                    "stream": self.log_streams[0],
-                    "filters": ["exclude_warnings"],
-                    "formatter": "indent",
-                },
-                "console_errors": {
-                    "level": "WARNING",
-                    "class": logger_class,
-                    "no_color": options.no_color,
-                    "stream": self.log_streams[1],
-                    "formatter": "indent",
-                },
-                "user_log": {
-                    "level": "DEBUG",
-                    "class": handler_class,
-                    "filename": options.log or "/dev/null",
-                    "delay": True,
-                    "formatter": "indent",
-                },
-            },
-            "root": {
-                "level": root_level,
-                "handlers": list(filter(None, [
-                    "console",
-                    "console_errors",
-                    "user_log" if options.log else None,
-                ])),
-            },
-            # Disable any logging besides WARNING unless we have DEBUG level
-            # logging enabled. These use both pip._vendor and the bare names
-            # for the case where someone unbundles our libraries.
-            "loggers": {
-                name: {
-                    "level": (
-                        "WARNING" if level in ["INFO", "ERROR"] else "DEBUG"
-                    )
-                } for name in [
-                    "pip._vendor", "distlib", "requests", "urllib3"
-                ]
-            },
-        })
-
-        if sys.version_info[:2] == (3, 3):
-            warnings.warn(
-                "Python 3.3 supported has been deprecated and support for it "
-                "will be dropped in the future. Please upgrade your Python.",
-                deprecation.RemovedInPip11Warning,
-            )
-
-        # TODO: try to get these passing down from the command?
-        #      without resorting to os.environ to hold these.
+        # TODO: Try to get these passing down from the command?
+        #       without resorting to os.environ to hold these.
+        #       This also affects isolated builds and it should.
 
         if options.no_input:
             os.environ['PIP_NO_INPUT'] = '1'
@@ -222,8 +139,6 @@ class Command(object):
                 )
                 sys.exit(VIRTUALENV_NOT_FOUND)
 
-        original_root_handlers = set(logging.root.handlers)
-
         try:
             status = self.run(options, args)
             # FIXME: all commands should return an exit status
@@ -250,23 +165,29 @@ class Command(object):
             logger.debug('Exception information:', exc_info=True)
 
             return ERROR
-        except:
+        except BaseException:
             logger.critical('Exception:', exc_info=True)
 
             return UNKNOWN_ERROR
         finally:
+            allow_version_check = (
+                # Does this command have the index_group options?
+                hasattr(options, "no_index") and
+                # Is this command allowed to perform this check?
+                not (options.disable_pip_version_check or options.no_index)
+            )
             # Check if we're using the latest version of pip available
-            if (not options.disable_pip_version_check and not
-                    getattr(options, "no_index", False)):
-                with self._build_session(
-                        options,
-                        retries=0,
-                        timeout=min(5, options.timeout)) as session:
+            if allow_version_check:
+                session = self._build_session(
+                    options,
+                    retries=0,
+                    timeout=min(5, options.timeout)
+                )
+                with session:
                     pip_version_check(session, options)
-            # Avoid leaking loggers
-            for handler in set(logging.root.handlers) - original_root_handlers:
-                # this method benefit from the Logger class internal lock
-                logging.root.removeHandler(handler)
+
+            # Shutdown the logging module
+            logging.shutdown()
 
         return SUCCESS
 
@@ -291,7 +212,7 @@ class RequirementCommand(Command):
                 requirement_set.add_requirement(req_to_add)
 
         for req in args:
-            req_to_add = InstallRequirement.from_line(
+            req_to_add = install_req_from_line(
                 req, None, isolated=options.isolated_mode,
                 wheel_cache=wheel_cache
             )
@@ -299,7 +220,7 @@ class RequirementCommand(Command):
             requirement_set.add_requirement(req_to_add)
 
         for req in options.editables:
-            req_to_add = InstallRequirement.from_editable(
+            req_to_add = install_req_from_editable(
                 req,
                 isolated=options.isolated_mode,
                 wheel_cache=wheel_cache
@@ -330,23 +251,6 @@ class RequirementCommand(Command):
                     'You must give at least one requirement to %(name)s '
                     '(see "pip help %(name)s")' % opts)
 
-        # On Windows, any operation modifying pip should be run as:
-        #     python -m pip ...
-        # See https://github.com/pypa/pip/issues/1299 for more discussion
-        should_show_use_python_msg = (
-            WINDOWS and
-            requirement_set.has_requirement("pip") and
-            os.path.basename(sys.argv[0]).startswith("pip")
-        )
-        if should_show_use_python_msg:
-            new_command = [
-                sys.executable, "-m", "pip"
-            ] + sys.argv[1:]
-            raise CommandError(
-                'To modify pip, please run the following command:\n{}'
-                .format(" ".join(new_command))
-            )
-
     def _build_package_finder(self, options, session,
                               platform=None, python_versions=None,
                               abi=None, implementation=None):
@@ -370,4 +274,5 @@ class RequirementCommand(Command):
             versions=python_versions,
             abi=abi,
             implementation=implementation,
+            prefer_binary=options.prefer_binary,
         )
diff --git a/pipenv/patched/notpip/_internal/cmdoptions.py b/pipenv/patched/notpip/_internal/cli/cmdoptions.py
similarity index 79%
rename from pipenv/patched/notpip/_internal/cmdoptions.py
rename to pipenv/patched/notpip/_internal/cli/cmdoptions.py
index 0b1c031a..a075a67e 100644
--- a/pipenv/patched/notpip/_internal/cmdoptions.py
+++ b/pipenv/patched/notpip/_internal/cli/cmdoptions.py
@@ -13,17 +13,16 @@ import warnings
 from functools import partial
 from optparse import SUPPRESS_HELP, Option, OptionGroup
 
-from pipenv.patched.notpip._internal.index import (
-    FormatControl, fmt_ctl_handle_mutual_exclude, fmt_ctl_no_binary,
-)
+from pipenv.patched.notpip._internal.exceptions import CommandError
 from pipenv.patched.notpip._internal.locations import USER_CACHE_DIR, src_prefix
-from pipenv.patched.notpip._internal.models import PyPI
+from pipenv.patched.notpip._internal.models.format_control import FormatControl
+from pipenv.patched.notpip._internal.models.index import PyPI
 from pipenv.patched.notpip._internal.utils.hashes import STRONG_HASHES
 from pipenv.patched.notpip._internal.utils.typing import MYPY_CHECK_RUNNING
 from pipenv.patched.notpip._internal.utils.ui import BAR_TYPES
 
 if MYPY_CHECK_RUNNING:
-    from typing import Any
+    from typing import Any  # noqa: F401
 
 
 def make_option_group(group, parser):
@@ -53,13 +52,52 @@ def check_install_build_global(options, check_options=None):
     names = ["build_options", "global_options", "install_options"]
     if any(map(getname, names)):
         control = options.format_control
-        fmt_ctl_no_binary(control)
+        control.disallow_binaries()
         warnings.warn(
             'Disabling all use of wheels due to the use of --build-options '
             '/ --global-options / --install-options.', stacklevel=2,
         )
 
 
+def check_dist_restriction(options, check_target=False):
+    """Function for determining if custom platform options are allowed.
+
+    :param options: The OptionParser options.
+    :param check_target: Whether or not to check if --target is being used.
+    """
+    dist_restriction_set = any([
+        options.python_version,
+        options.platform,
+        options.abi,
+        options.implementation,
+    ])
+
+    binary_only = FormatControl(set(), {':all:'})
+    sdist_dependencies_allowed = (
+        options.format_control != binary_only and
+        not options.ignore_dependencies
+    )
+
+    # Installations or downloads using dist restrictions must not combine
+    # source distributions and dist-specific wheels, as they are not
+    # gauranteed to be locally compatible.
+    if dist_restriction_set and sdist_dependencies_allowed:
+        raise CommandError(
+            "When restricting platform and interpreter constraints using "
+            "--python-version, --platform, --abi, or --implementation, "
+            "either --no-deps must be set, or --only-binary=:all: must be "
+            "set and --no-binary must not be set (or must be set to "
+            ":none:)."
+        )
+
+    if check_target:
+        if dist_restriction_set and not options.target_dir:
+            raise CommandError(
+                "Can not use any platform or abi specific options unless "
+                "installing via '--target'"
+            )
+
+
 ###########
 # options #
 ###########
@@ -365,24 +403,25 @@ def _get_format_control(values, option):
 
 
 def _handle_no_binary(option, opt_str, value, parser):
-    existing = getattr(parser.values, option.dest)
-    fmt_ctl_handle_mutual_exclude(
+    existing = _get_format_control(parser.values, option)
+    FormatControl.handle_mutual_excludes(
         value, existing.no_binary, existing.only_binary,
     )
 
 
 def _handle_only_binary(option, opt_str, value, parser):
-    existing = getattr(parser.values, option.dest)
-    fmt_ctl_handle_mutual_exclude(
+    existing = _get_format_control(parser.values, option)
+    FormatControl.handle_mutual_excludes(
         value, existing.only_binary, existing.no_binary,
     )
 
 
 def no_binary():
+    format_control = FormatControl(set(), set())
     return Option(
         "--no-binary", dest="format_control", action="callback",
         callback=_handle_no_binary, type="str",
-        default=FormatControl(set(), set()),
+        default=format_control,
         help="Do not use binary packages. Can be supplied multiple times, and "
              "each time adds to the existing value. Accepts either :all: to "
              "disable all binary packages, :none: to empty the set, or one or "
@@ -393,10 +432,11 @@ def no_binary():
 
 
 def only_binary():
+    format_control = FormatControl(set(), set())
     return Option(
         "--only-binary", dest="format_control", action="callback",
         callback=_handle_only_binary, type="str",
-        default=FormatControl(set(), set()),
+        default=format_control,
         help="Do not use source packages. Can be supplied multiple times, and "
              "each time adds to the existing value. Accepts either :all: to "
              "disable all source packages, :none: to empty the set, or one or "
@@ -406,6 +446,71 @@ def only_binary():
     )
 
 
+platform = partial(
+    Option,
+    '--platform',
+    dest='platform',
+    metavar='platform',
+    default=None,
+    help=("Only use wheels compatible with <platform>. "
+          "Defaults to the platform of the running system."),
+)
+
+
+python_version = partial(
+    Option,
+    '--python-version',
+    dest='python_version',
+    metavar='python_version',
+    default=None,
+    help=("Only use wheels compatible with Python "
+          "interpreter version <version>. If not specified, then the "
+          "current system interpreter minor version is used. A major "
+          "version (e.g. '2') can be specified to match all "
+          "minor revs of that major version.  A minor version "
+          "(e.g. '34') can also be specified."),
+)
+
+
+implementation = partial(
+    Option,
+    '--implementation',
+    dest='implementation',
+    metavar='implementation',
+    default=None,
+    help=("Only use wheels compatible with Python "
+          "implementation <implementation>, e.g. 'pp', 'jy', 'cp', "
+          " or 'ip'. If not specified, then the current "
+          "interpreter implementation is used.  Use 'py' to force "
+          "implementation-agnostic wheels."),
+)
+
+
+abi = partial(
+    Option,
+    '--abi',
+    dest='abi',
+    metavar='abi',
+    default=None,
+    help=("Only use wheels compatible with Python "
+          "abi <abi>, e.g. 'pypy_41'.  If not specified, then the "
+          "current interpreter abi tag is used.  Generally "
+          "you will need to specify --implementation, "
+          "--platform, and --python-version when using "
+          "this option."),
+)
+
+
+def prefer_binary():
+    return Option(
+        "--prefer-binary",
+        dest="prefer_binary",
+        action="store_true",
+        default=False,
+        help="Prefer older binary packages over newer source packages."
+    )
+
+
 cache_dir = partial(
     Option,
     "--cache-dir",
@@ -491,7 +596,7 @@ no_clean = partial(
     '--no-clean',
     action='store_true',
     default=False,
-    help="Don't clean up build directories)."
+    help="Don't clean up build directories."
 )  # type: Any
 
 pre = partial(
diff --git a/pipenv/patched/notpip/_internal/cli/main_parser.py b/pipenv/patched/notpip/_internal/cli/main_parser.py
new file mode 100644
index 00000000..abe2f69e
--- /dev/null
+++ b/pipenv/patched/notpip/_internal/cli/main_parser.py
@@ -0,0 +1,96 @@
+"""A single place for constructing and exposing the main parser
+"""
+
+import os
+import sys
+
+from pipenv.patched.notpip import __version__
+from pipenv.patched.notpip._internal.cli import cmdoptions
+from pipenv.patched.notpip._internal.cli.parser import (
+    ConfigOptionParser, UpdatingDefaultsHelpFormatter,
+)
+from pipenv.patched.notpip._internal.commands import (
+    commands_dict, get_similar_commands, get_summaries,
+)
+from pipenv.patched.notpip._internal.exceptions import CommandError
+from pipenv.patched.notpip._internal.utils.misc import get_prog
+
+__all__ = ["create_main_parser", "parse_command"]
+
+
+def create_main_parser():
+    """Creates and returns the main parser for pip's CLI
+    """
+
+    parser_kw = {
+        'usage': '\n%prog <command> [options]',
+        'add_help_option': False,
+        'formatter': UpdatingDefaultsHelpFormatter(),
+        'name': 'global',
+        'prog': get_prog(),
+    }
+
+    parser = ConfigOptionParser(**parser_kw)
+    parser.disable_interspersed_args()
+
+    pip_pkg_dir = os.path.abspath(os.path.join(
+        os.path.dirname(__file__), "..", "..",
+    ))
+    parser.version = 'pip %s from %s (python %s)' % (
+        __version__, pip_pkg_dir, sys.version[:3],
+    )
+
+    # add the general options
+    gen_opts = cmdoptions.make_option_group(cmdoptions.general_group, parser)
+    parser.add_option_group(gen_opts)
+
+    parser.main = True  # so the help formatter knows
+
+    # create command listing for description
+    command_summaries = get_summaries()
+    description = [''] + ['%-27s %s' % (i, j) for i, j in command_summaries]
+    parser.description = '\n'.join(description)
+
+    return parser
+
+
+def parse_command(args):
+    parser = create_main_parser()
+
+    # Note: parser calls disable_interspersed_args(), so the result of this
+    # call is to split the initial args into the general options before the
+    # subcommand and everything else.
+    # For example:
+    #  args: ['--timeout=5', 'install', '--user', 'INITools']
+    #  general_options: ['--timeout==5']
+    #  args_else: ['install', '--user', 'INITools']
+    general_options, args_else = parser.parse_args(args)
+
+    # --version
+    if general_options.version:
+        sys.stdout.write(parser.version)
+        sys.stdout.write(os.linesep)
+        sys.exit()
+
+    # pip || pip help -> print_help()
+    if not args_else or (args_else[0] == 'help' and len(args_else) == 1):
+        parser.print_help()
+        sys.exit()
+
+    # the subcommand name
+    cmd_name = args_else[0]
+
+    if cmd_name not in commands_dict:
+        guess = get_similar_commands(cmd_name)
+
+        msg = ['unknown command "%s"' % cmd_name]
+        if guess:
+            msg.append('maybe you meant "%s"' % guess)
+
+        raise CommandError(' - '.join(msg))
+
+    # all the args without the subcommand
+    cmd_args = args[:]
+    cmd_args.remove(cmd_name)
+
+    return cmd_name, cmd_args
diff --git a/pipenv/patched/notpip/_internal/baseparser.py b/pipenv/patched/notpip/_internal/cli/parser.py
similarity index 88%
rename from pipenv/patched/notpip/_internal/baseparser.py
rename to pipenv/patched/notpip/_internal/cli/parser.py
index f82093bf..2d2c8f4d 100644
--- a/pipenv/patched/notpip/_internal/baseparser.py
+++ b/pipenv/patched/notpip/_internal/cli/parser.py
@@ -9,8 +9,9 @@ from distutils.util import strtobool
 
 from pipenv.patched.notpip._vendor.six import string_types
 
-from pipenv.patched.notpip._internal.compat import get_terminal_size
+from pipenv.patched.notpip._internal.cli.status_codes import UNKNOWN_ERROR
 from pipenv.patched.notpip._internal.configuration import Configuration, ConfigurationError
+from pipenv.patched.notpip._internal.utils.compat import get_terminal_size
 
 logger = logging.getLogger(__name__)
 
@@ -192,7 +193,14 @@ class ConfigOptionParser(CustomOptionParser):
                 continue
 
             if option.action in ('store_true', 'store_false', 'count'):
-                val = strtobool(val)
+                try:
+                    val = strtobool(val)
+                except ValueError:
+                    error_msg = invalid_config_error_message(
+                        option.action, key, val
+                    )
+                    self.error(error_msg)
+
             elif option.action == 'append':
                 val = val.split()
                 val = [self.check_default(option, key, v) for v in val]
@@ -225,7 +233,7 @@ class ConfigOptionParser(CustomOptionParser):
         try:
             self.config.load()
         except ConfigurationError as err:
-            self.exit(2, err.args[0])
+            self.exit(UNKNOWN_ERROR, str(err))
 
         defaults = self._update_defaults(self.defaults.copy())  # ours
         for option in self._get_all_options():
@@ -237,4 +245,17 @@ class ConfigOptionParser(CustomOptionParser):
 
     def error(self, msg):
         self.print_usage(sys.stderr)
-        self.exit(2, "%s\n" % msg)
+        self.exit(UNKNOWN_ERROR, "%s\n" % msg)
+
+
+def invalid_config_error_message(action, key, val):
+    """Returns a better error message when invalid configuration option
+    is provided."""
+    if action in ('store_true', 'store_false'):
+        return ("{0} is not a valid value for {1} option, "
+                "please specify a boolean value like yes/no, "
+                "true/false or 1/0 instead.").format(val, key)
+
+    return ("{0} is not a valid value for {1} option, "
+            "please specify a numerical value like 1/0 "
+            "instead.").format(val, key)
diff --git a/pipenv/patched/notpip/_internal/status_codes.py b/pipenv/patched/notpip/_internal/cli/status_codes.py
similarity index 100%
rename from pipenv/patched/notpip/_internal/status_codes.py
rename to pipenv/patched/notpip/_internal/cli/status_codes.py
diff --git a/pipenv/patched/notpip/_internal/commands/__init__.py b/pipenv/patched/notpip/_internal/commands/__init__.py
index 101fa373..a403c6f9 100644
--- a/pipenv/patched/notpip/_internal/commands/__init__.py
+++ b/pipenv/patched/notpip/_internal/commands/__init__.py
@@ -20,8 +20,8 @@ from pipenv.patched.notpip._internal.commands.wheel import WheelCommand
 from pipenv.patched.notpip._internal.utils.typing import MYPY_CHECK_RUNNING
 
 if MYPY_CHECK_RUNNING:
-    from typing import List, Type
-    from pipenv.patched.notpip._internal.basecommand import Command
+    from typing import List, Type  # noqa: F401
+    from pipenv.patched.notpip._internal.cli.base_command import Command  # noqa: F401
 
 commands_order = [
     InstallCommand,
diff --git a/pipenv/patched/notpip/_internal/commands/check.py b/pipenv/patched/notpip/_internal/commands/check.py
index c9acaff5..adf4f5e7 100644
--- a/pipenv/patched/notpip/_internal/commands/check.py
+++ b/pipenv/patched/notpip/_internal/commands/check.py
@@ -1,10 +1,9 @@
 import logging
 
-from pipenv.patched.notpip._internal.basecommand import Command
+from pipenv.patched.notpip._internal.cli.base_command import Command
 from pipenv.patched.notpip._internal.operations.check import (
     check_package_set, create_package_set_from_installed,
 )
-from pipenv.patched.notpip._internal.utils.misc import get_installed_distributions
 
 logger = logging.getLogger(__name__)
 
diff --git a/pipenv/patched/notpip/_internal/commands/completion.py b/pipenv/patched/notpip/_internal/commands/completion.py
index f4c31c1b..cb8a11a7 100644
--- a/pipenv/patched/notpip/_internal/commands/completion.py
+++ b/pipenv/patched/notpip/_internal/commands/completion.py
@@ -3,7 +3,7 @@ from __future__ import absolute_import
 import sys
 import textwrap
 
-from pipenv.patched.notpip._internal.basecommand import Command
+from pipenv.patched.notpip._internal.cli.base_command import Command
 from pipenv.patched.notpip._internal.utils.misc import get_prog
 
 BASE_COMPLETION = """
diff --git a/pipenv/patched/notpip/_internal/commands/configuration.py b/pipenv/patched/notpip/_internal/commands/configuration.py
index 090109c5..6c1dbdfd 100644
--- a/pipenv/patched/notpip/_internal/commands/configuration.py
+++ b/pipenv/patched/notpip/_internal/commands/configuration.py
@@ -2,11 +2,11 @@ import logging
 import os
 import subprocess
 
-from pipenv.patched.notpip._internal.basecommand import Command
+from pipenv.patched.notpip._internal.cli.base_command import Command
+from pipenv.patched.notpip._internal.cli.status_codes import ERROR, SUCCESS
 from pipenv.patched.notpip._internal.configuration import Configuration, kinds
 from pipenv.patched.notpip._internal.exceptions import PipError
 from pipenv.patched.notpip._internal.locations import venv_config_file
-from pipenv.patched.notpip._internal.status_codes import ERROR, SUCCESS
 from pipenv.patched.notpip._internal.utils.misc import get_prog
 
 logger = logging.getLogger(__name__)
diff --git a/pipenv/patched/notpip/_internal/commands/download.py b/pipenv/patched/notpip/_internal/commands/download.py
index e2cdae5e..e5d87121 100644
--- a/pipenv/patched/notpip/_internal/commands/download.py
+++ b/pipenv/patched/notpip/_internal/commands/download.py
@@ -3,12 +3,11 @@ from __future__ import absolute_import
 import logging
 import os
 
-from pipenv.patched.notpip._internal import cmdoptions
-from pipenv.patched.notpip._internal.basecommand import RequirementCommand
-from pipenv.patched.notpip._internal.exceptions import CommandError
-from pipenv.patched.notpip._internal.index import FormatControl
+from pipenv.patched.notpip._internal.cli import cmdoptions
+from pipenv.patched.notpip._internal.cli.base_command import RequirementCommand
 from pipenv.patched.notpip._internal.operations.prepare import RequirementPreparer
 from pipenv.patched.notpip._internal.req import RequirementSet
+from pipenv.patched.notpip._internal.req.req_tracker import RequirementTracker
 from pipenv.patched.notpip._internal.resolve import Resolver
 from pipenv.patched.notpip._internal.utils.filesystem import check_path_owner
 from pipenv.patched.notpip._internal.utils.misc import ensure_dir, normalize_path
@@ -52,6 +51,7 @@ class DownloadCommand(RequirementCommand):
         cmd_opts.add_option(cmdoptions.global_options())
         cmd_opts.add_option(cmdoptions.no_binary())
         cmd_opts.add_option(cmdoptions.only_binary())
+        cmd_opts.add_option(cmdoptions.prefer_binary())
         cmd_opts.add_option(cmdoptions.src())
         cmd_opts.add_option(cmdoptions.pre())
         cmd_opts.add_option(cmdoptions.no_clean())
@@ -67,52 +67,10 @@ class DownloadCommand(RequirementCommand):
             help=("Download packages into <dir>."),
         )
 
-        cmd_opts.add_option(
-            '--platform',
-            dest='platform',
-            metavar='platform',
-            default=None,
-            help=("Only download wheels compatible with <platform>. "
-                  "Defaults to the platform of the running system."),
-        )
-
-        cmd_opts.add_option(
-            '--python-version',
-            dest='python_version',
-            metavar='python_version',
-            default=None,
-            help=("Only download wheels compatible with Python "
-                  "interpreter version <version>. If not specified, then the "
-                  "current system interpreter minor version is used. A major "
-                  "version (e.g. '2') can be specified to match all "
-                  "minor revs of that major version.  A minor version "
-                  "(e.g. '34') can also be specified."),
-        )
-
-        cmd_opts.add_option(
-            '--implementation',
-            dest='implementation',
-            metavar='implementation',
-            default=None,
-            help=("Only download wheels compatible with Python "
-                  "implementation <implementation>, e.g. 'pp', 'jy', 'cp', "
-                  " or 'ip'. If not specified, then the current "
-                  "interpreter implementation is used.  Use 'py' to force "
-                  "implementation-agnostic wheels."),
-        )
-
-        cmd_opts.add_option(
-            '--abi',
-            dest='abi',
-            metavar='abi',
-            default=None,
-            help=("Only download wheels compatible with Python "
-                  "abi <abi>, e.g. 'pypy_41'.  If not specified, then the "
-                  "current interpreter abi tag is used.  Generally "
-                  "you will need to specify --implementation, "
-                  "--platform, and --python-version when using "
-                  "this option."),
-        )
+        cmd_opts.add_option(cmdoptions.platform())
+        cmd_opts.add_option(cmdoptions.python_version())
+        cmd_opts.add_option(cmdoptions.implementation())
+        cmd_opts.add_option(cmdoptions.abi())
 
         index_opts = cmdoptions.make_option_group(
             cmdoptions.index_group,
@@ -133,25 +91,7 @@ class DownloadCommand(RequirementCommand):
         else:
             python_versions = None
 
-        dist_restriction_set = any([
-            options.python_version,
-            options.platform,
-            options.abi,
-            options.implementation,
-        ])
-        binary_only = FormatControl(set(), {':all:'})
-        no_sdist_dependencies = (
-            options.format_control != binary_only and
-            not options.ignore_dependencies
-        )
-        if dist_restriction_set and no_sdist_dependencies:
-            raise CommandError(
-                "When restricting platform and interpreter constraints using "
-                "--python-version, --platform, --abi, or --implementation, "
-                "either --no-deps must be set, or --only-binary=:all: must be "
-                "set and --no-binary must not be set (or must be set to "
-                ":none:)."
-            )
+        cmdoptions.check_dist_restriction(options)
 
         options.src_dir = os.path.abspath(options.src_dir)
         options.download_dir = normalize_path(options.download_dir)
@@ -179,7 +119,7 @@ class DownloadCommand(RequirementCommand):
                 )
                 options.cache_dir = None
 
-            with TempDirectory(
+            with RequirementTracker() as req_tracker, TempDirectory(
                 options.build_dir, delete=build_delete, kind="download"
             ) as directory:
 
@@ -203,6 +143,7 @@ class DownloadCommand(RequirementCommand):
                     wheel_download_dir=None,
                     progress_bar=options.progress_bar,
                     build_isolation=options.build_isolation,
+                    req_tracker=req_tracker,
                 )
 
                 resolver = Resolver(
diff --git a/pipenv/patched/notpip/_internal/commands/freeze.py b/pipenv/patched/notpip/_internal/commands/freeze.py
index 6959b6ab..343227ba 100644
--- a/pipenv/patched/notpip/_internal/commands/freeze.py
+++ b/pipenv/patched/notpip/_internal/commands/freeze.py
@@ -2,11 +2,11 @@ from __future__ import absolute_import
 
 import sys
 
-from pipenv.patched.notpip._internal import index
-from pipenv.patched.notpip._internal.basecommand import Command
 from pipenv.patched.notpip._internal.cache import WheelCache
-from pipenv.patched.notpip._internal.compat import stdlib_pkgs
+from pipenv.patched.notpip._internal.cli.base_command import Command
+from pipenv.patched.notpip._internal.models.format_control import FormatControl
 from pipenv.patched.notpip._internal.operations.freeze import freeze
+from pipenv.patched.notpip._internal.utils.compat import stdlib_pkgs
 
 DEV_PKGS = {'pip', 'setuptools', 'distribute', 'wheel'}
 
@@ -71,7 +71,7 @@ class FreezeCommand(Command):
         self.parser.insert_option_group(0, self.cmd_opts)
 
     def run(self, options, args):
-        format_control = index.FormatControl(set(), set())
+        format_control = FormatControl(set(), set())
         wheel_cache = WheelCache(options.cache_dir, format_control)
         skip = set(stdlib_pkgs)
         if not options.freeze_all:
diff --git a/pipenv/patched/notpip/_internal/commands/hash.py b/pipenv/patched/notpip/_internal/commands/hash.py
index a86574da..183f11ae 100644
--- a/pipenv/patched/notpip/_internal/commands/hash.py
+++ b/pipenv/patched/notpip/_internal/commands/hash.py
@@ -4,8 +4,8 @@ import hashlib
 import logging
 import sys
 
-from pipenv.patched.notpip._internal.basecommand import Command
-from pipenv.patched.notpip._internal.status_codes import ERROR
+from pipenv.patched.notpip._internal.cli.base_command import Command
+from pipenv.patched.notpip._internal.cli.status_codes import ERROR
 from pipenv.patched.notpip._internal.utils.hashes import FAVORITE_HASH, STRONG_HASHES
 from pipenv.patched.notpip._internal.utils.misc import read_chunks
 
diff --git a/pipenv/patched/notpip/_internal/commands/help.py b/pipenv/patched/notpip/_internal/commands/help.py
index aaf0f87e..f2c61965 100644
--- a/pipenv/patched/notpip/_internal/commands/help.py
+++ b/pipenv/patched/notpip/_internal/commands/help.py
@@ -1,6 +1,7 @@
 from __future__ import absolute_import
 
-from pipenv.patched.notpip._internal.basecommand import SUCCESS, Command
+from pipenv.patched.notpip._internal.cli.base_command import Command
+from pipenv.patched.notpip._internal.cli.status_codes import SUCCESS
 from pipenv.patched.notpip._internal.exceptions import CommandError
 
 
diff --git a/pipenv/patched/notpip/_internal/commands/install.py b/pipenv/patched/notpip/_internal/commands/install.py
index 136310de..ddcb4759 100644
--- a/pipenv/patched/notpip/_internal/commands/install.py
+++ b/pipenv/patched/notpip/_internal/commands/install.py
@@ -7,9 +7,12 @@ import os
 import shutil
 from optparse import SUPPRESS_HELP
 
-from pipenv.patched.notpip._internal import cmdoptions
-from pipenv.patched.notpip._internal.basecommand import RequirementCommand
+from pipenv.patched.notpip._vendor import pkg_resources
+
 from pipenv.patched.notpip._internal.cache import WheelCache
+from pipenv.patched.notpip._internal.cli import cmdoptions
+from pipenv.patched.notpip._internal.cli.base_command import RequirementCommand
+from pipenv.patched.notpip._internal.cli.status_codes import ERROR
 from pipenv.patched.notpip._internal.exceptions import (
     CommandError, InstallationError, PreviousBuildDirError,
 )
@@ -17,10 +20,13 @@ from pipenv.patched.notpip._internal.locations import distutils_scheme, virtuale
 from pipenv.patched.notpip._internal.operations.check import check_install_conflicts
 from pipenv.patched.notpip._internal.operations.prepare import RequirementPreparer
 from pipenv.patched.notpip._internal.req import RequirementSet, install_given_reqs
+from pipenv.patched.notpip._internal.req.req_tracker import RequirementTracker
 from pipenv.patched.notpip._internal.resolve import Resolver
-from pipenv.patched.notpip._internal.status_codes import ERROR
 from pipenv.patched.notpip._internal.utils.filesystem import check_path_owner
-from pipenv.patched.notpip._internal.utils.misc import ensure_dir, get_installed_version
+from pipenv.patched.notpip._internal.utils.misc import (
+    ensure_dir, get_installed_version,
+    protect_pip_from_modification_on_windows,
+)
 from pipenv.patched.notpip._internal.utils.temp_dir import TempDirectory
 from pipenv.patched.notpip._internal.wheel import WheelBuilder
 
@@ -77,6 +83,11 @@ class InstallCommand(RequirementCommand):
                  '<dir>. Use --upgrade to replace existing packages in <dir> '
                  'with new versions.'
         )
+        cmd_opts.add_option(cmdoptions.platform())
+        cmd_opts.add_option(cmdoptions.python_version())
+        cmd_opts.add_option(cmdoptions.implementation())
+        cmd_opts.add_option(cmdoptions.abi())
+
         cmd_opts.add_option(
             '--user',
             dest='use_user_site',
@@ -183,6 +194,7 @@ class InstallCommand(RequirementCommand):
 
         cmd_opts.add_option(cmdoptions.no_binary())
         cmd_opts.add_option(cmdoptions.only_binary())
+        cmd_opts.add_option(cmdoptions.prefer_binary())
         cmd_opts.add_option(cmdoptions.no_clean())
         cmd_opts.add_option(cmdoptions.require_hashes())
         cmd_opts.add_option(cmdoptions.progress_bar())
@@ -197,7 +209,6 @@ class InstallCommand(RequirementCommand):
 
     def run(self, options, args):
         cmdoptions.check_install_build_global(options)
-
         upgrade_strategy = "to-satisfy-only"
         if options.upgrade:
             upgrade_strategy = options.upgrade_strategy
@@ -205,6 +216,13 @@ class InstallCommand(RequirementCommand):
         if options.build_dir:
             options.build_dir = os.path.abspath(options.build_dir)
 
+        cmdoptions.check_dist_restriction(options, check_target=True)
+
+        if options.python_version:
+            python_versions = [options.python_version]
+        else:
+            python_versions = None
+
         options.src_dir = os.path.abspath(options.src_dir)
         install_options = options.install_options or []
         if options.use_user_site:
@@ -239,7 +257,14 @@ class InstallCommand(RequirementCommand):
         global_options = options.global_options or []
 
         with self._build_session(options) as session:
-            finder = self._build_package_finder(options, session)
+            finder = self._build_package_finder(
+                options=options,
+                session=session,
+                platform=options.platform,
+                python_versions=python_versions,
+                abi=options.abi,
+                implementation=options.implementation,
+            )
             build_delete = (not (options.no_clean or options.build_dir))
             wheel_cache = WheelCache(options.cache_dir, options.format_control)
 
@@ -254,11 +279,12 @@ class InstallCommand(RequirementCommand):
                 )
                 options.cache_dir = None
 
-            with TempDirectory(
+            with RequirementTracker() as req_tracker, TempDirectory(
                 options.build_dir, delete=build_delete, kind="install"
             ) as directory:
                 requirement_set = RequirementSet(
                     require_hashes=options.require_hashes,
+                    check_supported_wheels=not options.target_dir,
                 )
 
                 try:
@@ -273,6 +299,7 @@ class InstallCommand(RequirementCommand):
                         wheel_download_dir=None,
                         progress_bar=options.progress_bar,
                         build_isolation=options.build_isolation,
+                        req_tracker=req_tracker,
                     )
 
                     resolver = Resolver(
@@ -290,6 +317,10 @@ class InstallCommand(RequirementCommand):
                     )
                     resolver.resolve(requirement_set)
 
+                    protect_pip_from_modification_on_windows(
+                        modifying_pip=requirement_set.has_requirement("pip")
+                    )
+
                     # If caching is disabled or wheel is not installed don't
                     # try to build wheels.
                     if wheel and options.cache_dir:
@@ -335,20 +366,22 @@ class InstallCommand(RequirementCommand):
                         use_user_site=options.use_user_site,
                     )
 
-                    possible_lib_locations = get_lib_location_guesses(
+                    lib_locations = get_lib_location_guesses(
                         user=options.use_user_site,
                         home=target_temp_dir.path,
                         root=options.root_path,
                         prefix=options.prefix_path,
                         isolated=options.isolated_mode,
                     )
+                    working_set = pkg_resources.WorkingSet(lib_locations)
+
                     reqs = sorted(installed, key=operator.attrgetter('name'))
                     items = []
                     for req in reqs:
                         item = req.name
                         try:
                             installed_version = get_installed_version(
-                                req.name, possible_lib_locations
+                                req.name, working_set=working_set
                             )
                             if installed_version:
                                 item += '-' + installed_version
diff --git a/pipenv/patched/notpip/_internal/commands/list.py b/pipenv/patched/notpip/_internal/commands/list.py
index dc3c0f2c..577c0b5f 100644
--- a/pipenv/patched/notpip/_internal/commands/list.py
+++ b/pipenv/patched/notpip/_internal/commands/list.py
@@ -2,16 +2,14 @@ from __future__ import absolute_import
 
 import json
 import logging
-import warnings
 
 from pipenv.patched.notpip._vendor import six
 from pipenv.patched.notpip._vendor.six.moves import zip_longest
 
-from pipenv.patched.notpip._internal.basecommand import Command
-from pipenv.patched.notpip._internal.cmdoptions import index_group, make_option_group
+from pipenv.patched.notpip._internal.cli import cmdoptions
+from pipenv.patched.notpip._internal.cli.base_command import Command
 from pipenv.patched.notpip._internal.exceptions import CommandError
 from pipenv.patched.notpip._internal.index import PackageFinder
-from pipenv.patched.notpip._internal.utils.deprecation import RemovedInPip11Warning
 from pipenv.patched.notpip._internal.utils.misc import (
     dist_is_editable, get_installed_distributions,
 )
@@ -78,9 +76,9 @@ class ListCommand(Command):
             action='store',
             dest='list_format',
             default="columns",
-            choices=('legacy', 'columns', 'freeze', 'json'),
+            choices=('columns', 'freeze', 'json'),
             help="Select the output format among: columns (default), freeze, "
-                 "json, or legacy.",
+                 "or json",
         )
 
         cmd_opts.add_option(
@@ -104,7 +102,9 @@ class ListCommand(Command):
             help='Include editable package from output.',
             default=True,
         )
-        index_opts = make_option_group(index_group, self.parser)
+        index_opts = cmdoptions.make_option_group(
+            cmdoptions.index_group, self.parser
+        )
 
         self.parser.insert_option_group(0, index_opts)
         self.parser.insert_option_group(0, cmd_opts)
@@ -123,13 +123,6 @@ class ListCommand(Command):
         )
 
     def run(self, options, args):
-        if options.list_format == "legacy":
-            warnings.warn(
-                "The legacy format has been deprecated and will be removed "
-                "in the future.",
-                RemovedInPip11Warning,
-            )
-
         if options.outdated and options.uptodate:
             raise CommandError(
                 "Options --outdated and --uptodate cannot be combined.")
@@ -208,30 +201,6 @@ class ListCommand(Command):
                 dist.latest_filetype = typ
                 yield dist
 
-    def output_legacy(self, dist, options):
-        if options.verbose >= 1:
-            return '%s (%s, %s, %s)' % (
-                dist.project_name,
-                dist.version,
-                dist.location,
-                get_installer(dist),
-            )
-        elif dist_is_editable(dist):
-            return '%s (%s, %s)' % (
-                dist.project_name,
-                dist.version,
-                dist.location,
-            )
-        else:
-            return '%s (%s)' % (dist.project_name, dist.version)
-
-    def output_legacy_latest(self, dist, options):
-        return '%s - Latest: %s [%s]' % (
-            self.output_legacy(dist, options),
-            dist.latest_version,
-            dist.latest_filetype,
-        )
-
     def output_package_listing(self, packages, options):
         packages = sorted(
             packages,
@@ -249,12 +218,6 @@ class ListCommand(Command):
                     logger.info("%s==%s", dist.project_name, dist.version)
         elif options.list_format == 'json':
             logger.info(format_for_json(packages, options))
-        elif options.list_format == "legacy":
-            for dist in packages:
-                if options.outdated:
-                    logger.info(self.output_legacy_latest(dist, options))
-                else:
-                    logger.info(self.output_legacy(dist, options))
 
     def output_package_listing_columns(self, data, header):
         # insert the header first: we need to know the size of column names
diff --git a/pipenv/patched/notpip/_internal/commands/search.py b/pipenv/patched/notpip/_internal/commands/search.py
index 32a111ae..986208f9 100644
--- a/pipenv/patched/notpip/_internal/commands/search.py
+++ b/pipenv/patched/notpip/_internal/commands/search.py
@@ -11,12 +11,12 @@ from pipenv.patched.notpip._vendor.packaging.version import parse as parse_versi
 #       why we ignore the type on this import
 from pipenv.patched.notpip._vendor.six.moves import xmlrpc_client  # type: ignore
 
-from pipenv.patched.notpip._internal.basecommand import SUCCESS, Command
-from pipenv.patched.notpip._internal.compat import get_terminal_size
+from pipenv.patched.notpip._internal.cli.base_command import Command
+from pipenv.patched.notpip._internal.cli.status_codes import NO_MATCHES_FOUND, SUCCESS
 from pipenv.patched.notpip._internal.download import PipXmlrpcTransport
 from pipenv.patched.notpip._internal.exceptions import CommandError
-from pipenv.patched.notpip._internal.models import PyPI
-from pipenv.patched.notpip._internal.status_codes import NO_MATCHES_FOUND
+from pipenv.patched.notpip._internal.models.index import PyPI
+from pipenv.patched.notpip._internal.utils.compat import get_terminal_size
 from pipenv.patched.notpip._internal.utils.logging import indent_log
 
 logger = logging.getLogger(__name__)
diff --git a/pipenv/patched/notpip/_internal/commands/show.py b/pipenv/patched/notpip/_internal/commands/show.py
index 3bac8b4f..3fd24482 100644
--- a/pipenv/patched/notpip/_internal/commands/show.py
+++ b/pipenv/patched/notpip/_internal/commands/show.py
@@ -7,14 +7,18 @@ from email.parser import FeedParser  # type: ignore
 from pipenv.patched.notpip._vendor import pkg_resources
 from pipenv.patched.notpip._vendor.packaging.utils import canonicalize_name
 
-from pipenv.patched.notpip._internal.basecommand import Command
-from pipenv.patched.notpip._internal.status_codes import ERROR, SUCCESS
+from pipenv.patched.notpip._internal.cli.base_command import Command
+from pipenv.patched.notpip._internal.cli.status_codes import ERROR, SUCCESS
 
 logger = logging.getLogger(__name__)
 
 
 class ShowCommand(Command):
-    """Show information about one or more installed packages."""
+    """
+    Show information about one or more installed packages.
+
+    The output is in RFC-compliant mail header format.
+    """
     name = 'show'
     usage = """
       %prog [options] <package> ..."""
diff --git a/pipenv/patched/notpip/_internal/commands/uninstall.py b/pipenv/patched/notpip/_internal/commands/uninstall.py
index 262c2c45..cf6a511c 100644
--- a/pipenv/patched/notpip/_internal/commands/uninstall.py
+++ b/pipenv/patched/notpip/_internal/commands/uninstall.py
@@ -2,9 +2,11 @@ from __future__ import absolute_import
 
 from pipenv.patched.notpip._vendor.packaging.utils import canonicalize_name
 
-from pipenv.patched.notpip._internal.basecommand import Command
+from pipenv.patched.notpip._internal.cli.base_command import Command
 from pipenv.patched.notpip._internal.exceptions import InstallationError
-from pipenv.patched.notpip._internal.req import InstallRequirement, parse_requirements
+from pipenv.patched.notpip._internal.req import parse_requirements
+from pipenv.patched.notpip._internal.req.constructors import install_req_from_line
+from pipenv.patched.notpip._internal.utils.misc import protect_pip_from_modification_on_windows
 
 
 class UninstallCommand(Command):
@@ -46,7 +48,7 @@ class UninstallCommand(Command):
         with self._build_session(options) as session:
             reqs_to_uninstall = {}
             for name in args:
-                req = InstallRequirement.from_line(
+                req = install_req_from_line(
                     name, isolated=options.isolated_mode,
                 )
                 if req.name:
@@ -63,6 +65,11 @@ class UninstallCommand(Command):
                     'You must give at least one requirement to %(name)s (see '
                     '"pip help %(name)s")' % dict(name=self.name)
                 )
+
+            protect_pip_from_modification_on_windows(
+                modifying_pip="pip" in reqs_to_uninstall
+            )
+
             for req in reqs_to_uninstall.values():
                 uninstall_pathset = req.uninstall(
                     auto_confirm=options.yes, verbose=self.verbosity > 0,
diff --git a/pipenv/patched/notpip/_internal/commands/wheel.py b/pipenv/patched/notpip/_internal/commands/wheel.py
index e97d5988..08d695ab 100644
--- a/pipenv/patched/notpip/_internal/commands/wheel.py
+++ b/pipenv/patched/notpip/_internal/commands/wheel.py
@@ -4,12 +4,13 @@ from __future__ import absolute_import
 import logging
 import os
 
-from pipenv.patched.notpip._internal import cmdoptions
-from pipenv.patched.notpip._internal.basecommand import RequirementCommand
 from pipenv.patched.notpip._internal.cache import WheelCache
+from pipenv.patched.notpip._internal.cli import cmdoptions
+from pipenv.patched.notpip._internal.cli.base_command import RequirementCommand
 from pipenv.patched.notpip._internal.exceptions import CommandError, PreviousBuildDirError
 from pipenv.patched.notpip._internal.operations.prepare import RequirementPreparer
 from pipenv.patched.notpip._internal.req import RequirementSet
+from pipenv.patched.notpip._internal.req.req_tracker import RequirementTracker
 from pipenv.patched.notpip._internal.resolve import Resolver
 from pipenv.patched.notpip._internal.utils.temp_dir import TempDirectory
 from pipenv.patched.notpip._internal.wheel import WheelBuilder
@@ -57,6 +58,7 @@ class WheelCommand(RequirementCommand):
         )
         cmd_opts.add_option(cmdoptions.no_binary())
         cmd_opts.add_option(cmdoptions.only_binary())
+        cmd_opts.add_option(cmdoptions.prefer_binary())
         cmd_opts.add_option(
             '--build-option',
             dest='build_options',
@@ -119,9 +121,10 @@ class WheelCommand(RequirementCommand):
             build_delete = (not (options.no_clean or options.build_dir))
             wheel_cache = WheelCache(options.cache_dir, options.format_control)
 
-            with TempDirectory(
+            with RequirementTracker() as req_tracker, TempDirectory(
                 options.build_dir, delete=build_delete, kind="wheel"
             ) as directory:
+
                 requirement_set = RequirementSet(
                     require_hashes=options.require_hashes,
                 )
@@ -139,6 +142,7 @@ class WheelCommand(RequirementCommand):
                         wheel_download_dir=options.wheel_dir,
                         progress_bar=options.progress_bar,
                         build_isolation=options.build_isolation,
+                        req_tracker=req_tracker,
                     )
 
                     resolver = Resolver(
diff --git a/pipenv/patched/notpip/_internal/configuration.py b/pipenv/patched/notpip/_internal/configuration.py
index 7b9b5a45..3c02c955 100644
--- a/pipenv/patched/notpip/_internal/configuration.py
+++ b/pipenv/patched/notpip/_internal/configuration.py
@@ -18,7 +18,9 @@ import os
 from pipenv.patched.notpip._vendor import six
 from pipenv.patched.notpip._vendor.six.moves import configparser
 
-from pipenv.patched.notpip._internal.exceptions import ConfigurationError
+from pipenv.patched.notpip._internal.exceptions import (
+    ConfigurationError, ConfigurationFileCouldNotBeLoaded,
+)
 from pipenv.patched.notpip._internal.locations import (
     legacy_config_file, new_config_file, running_under_virtualenv,
     site_config_files, venv_config_file,
@@ -27,7 +29,9 @@ from pipenv.patched.notpip._internal.utils.misc import ensure_dir, enum
 from pipenv.patched.notpip._internal.utils.typing import MYPY_CHECK_RUNNING
 
 if MYPY_CHECK_RUNNING:
-    from typing import Any, Dict, Iterable, List, NewType, Optional, Tuple
+    from typing import (  # noqa: F401
+        Any, Dict, Iterable, List, NewType, Optional, Tuple
+    )
 
     RawConfigParser = configparser.RawConfigParser  # Shorthand
     Kind = NewType("Kind", str)
@@ -287,11 +291,16 @@ class Configuration(object):
             try:
                 parser.read(fname)
             except UnicodeDecodeError:
-                raise ConfigurationError((
-                    "ERROR: "
-                    "Configuration file contains invalid %s characters.\n"
-                    "Please fix your configuration, located at %s\n"
-                ) % (locale.getpreferredencoding(False), fname))
+                # See https://github.com/pypa/pip/issues/4963
+                raise ConfigurationFileCouldNotBeLoaded(
+                    reason="contains invalid {} characters".format(
+                        locale.getpreferredencoding(False)
+                    ),
+                    fname=fname,
+                )
+            except configparser.Error as error:
+                # See https://github.com/pypa/pip/issues/4893
+                raise ConfigurationFileCouldNotBeLoaded(error=error)
         return parser
 
     def _load_environment_vars(self):
diff --git a/pipenv/patched/notpip/_internal/download.py b/pipenv/patched/notpip/_internal/download.py
index f00e3984..8f4c38f5 100644
--- a/pipenv/patched/notpip/_internal/download.py
+++ b/pipenv/patched/notpip/_internal/download.py
@@ -31,10 +31,9 @@ from pipenv.patched.notpip._vendor.six.moves.urllib.parse import unquote as urll
 from pipenv.patched.notpip._vendor.urllib3.util import IS_PYOPENSSL
 
 import pipenv.patched.notpip
-from pipenv.patched.notpip._internal.compat import WINDOWS
 from pipenv.patched.notpip._internal.exceptions import HashMismatch, InstallationError
 from pipenv.patched.notpip._internal.locations import write_delete_marker_file
-from pipenv.patched.notpip._internal.models import PyPI
+from pipenv.patched.notpip._internal.models.index import PyPI
 from pipenv.patched.notpip._internal.utils.encoding import auto_decode
 from pipenv.patched.notpip._internal.utils.filesystem import check_path_owner
 from pipenv.patched.notpip._internal.utils.glibc import libc_ver
@@ -324,7 +323,7 @@ class InsecureHTTPAdapter(HTTPAdapter):
         conn.ca_certs = None
 
 
-class PipSession(Session):
+class PipSession(requests.Session):
 
     timeout = None
 
@@ -754,7 +753,7 @@ def _copy_dist_from_dir(link_path, location):
 
     # build an sdist
     setup_py = 'setup.py'
-    sdist_args = [os.environ.get('PIP_PYTHON_PATH', sys.executable)]
+    sdist_args = [sys.executable]
     sdist_args.append('-c')
     sdist_args.append(SETUPTOOLS_SHIM % setup_py)
     sdist_args.append('sdist')
diff --git a/pipenv/patched/notpip/_internal/exceptions.py b/pipenv/patched/notpip/_internal/exceptions.py
index 43595977..2eadcf28 100644
--- a/pipenv/patched/notpip/_internal/exceptions.py
+++ b/pipenv/patched/notpip/_internal/exceptions.py
@@ -247,3 +247,22 @@ class HashMismatch(HashError):
 class UnsupportedPythonVersion(InstallationError):
     """Unsupported python version according to Requires-Python package
     metadata."""
+
+
+class ConfigurationFileCouldNotBeLoaded(ConfigurationError):
+    """When there are errors while loading a configuration file
+    """
+
+    def __init__(self, reason="could not be loaded", fname=None, error=None):
+        super(ConfigurationFileCouldNotBeLoaded, self).__init__(error)
+        self.reason = reason
+        self.fname = fname
+        self.error = error
+
+    def __str__(self):
+        if self.fname is not None:
+            message_part = " in {}.".format(self.fname)
+        else:
+            assert self.error is not None
+            message_part = ".\n{}\n".format(self.error.message)
+        return "Configuration file {}{}".format(self.reason, message_part)
diff --git a/pipenv/patched/notpip/_internal/index.py b/pipenv/patched/notpip/_internal/index.py
index 8fa39c4f..b4b02373 100644
--- a/pipenv/patched/notpip/_internal/index.py
+++ b/pipenv/patched/notpip/_internal/index.py
@@ -9,7 +9,6 @@ import os
 import posixpath
 import re
 import sys
-import warnings
 from collections import namedtuple
 
 from pipenv.patched.notpip._vendor import html5lib, requests, six
@@ -21,24 +20,27 @@ from pipenv.patched.notpip._vendor.requests.exceptions import SSLError
 from pipenv.patched.notpip._vendor.six.moves.urllib import parse as urllib_parse
 from pipenv.patched.notpip._vendor.six.moves.urllib import request as urllib_request
 
-from pipenv.patched.notpip._internal.compat import ipaddress
 from pipenv.patched.notpip._internal.download import HAS_TLS, is_url, path_to_url, url_to_path
 from pipenv.patched.notpip._internal.exceptions import (
     BestVersionAlreadyInstalled, DistributionNotFound, InvalidWheelFilename,
     UnsupportedWheel,
 )
-from pipenv.patched.notpip._internal.models import PyPI
+from pipenv.patched.notpip._internal.models.candidate import InstallationCandidate
+from pipenv.patched.notpip._internal.models.format_control import FormatControl
+from pipenv.patched.notpip._internal.models.index import PyPI
+from pipenv.patched.notpip._internal.models.link import Link
 from pipenv.patched.notpip._internal.pep425tags import get_supported
-from pipenv.patched.notpip._internal.utils.deprecation import RemovedInPip11Warning
+from pipenv.patched.notpip._internal.utils.compat import ipaddress
+from pipenv.patched.notpip._internal.utils.deprecation import deprecated
 from pipenv.patched.notpip._internal.utils.logging import indent_log
 from pipenv.patched.notpip._internal.utils.misc import (
-    ARCHIVE_EXTENSIONS, SUPPORTED_EXTENSIONS, cached_property, normalize_path,
-    splitext,
+    ARCHIVE_EXTENSIONS, SUPPORTED_EXTENSIONS, normalize_path,
+    remove_auth_from_url,
 )
 from pipenv.patched.notpip._internal.utils.packaging import check_requires_python
 from pipenv.patched.notpip._internal.wheel import Wheel, wheel_ext
 
-__all__ = ['FormatControl', 'fmt_ctl_handle_mutual_exclude', 'PackageFinder']
+__all__ = ['FormatControl', 'PackageFinder']
 
 
 SECURE_ORIGINS = [
@@ -57,46 +59,120 @@ SECURE_ORIGINS = [
 logger = logging.getLogger(__name__)
 
 
-class InstallationCandidate(object):
+def _get_content_type(url, session):
+    """Get the Content-Type of the given url, using a HEAD request"""
+    scheme, netloc, path, query, fragment = urllib_parse.urlsplit(url)
+    if scheme not in {'http', 'https'}:
+        # FIXME: some warning or something?
+        # assertion error?
+        return ''
 
-    def __init__(self, project, version, location, requires_python=''):
-        self.project = project
-        self.version = parse_version(version)
-        self.location = location
-        self._key = (self.project, self.version, self.location)
-        self.requires_python = requires_python
+    resp = session.head(url, allow_redirects=True)
+    resp.raise_for_status()
 
-    def __repr__(self):
-        return "<InstallationCandidate({!r}, {!r}, {!r})>".format(
-            self.project, self.version, self.location,
+    return resp.headers.get("Content-Type", "")
+
+
+def _handle_get_page_fail(link, reason, url, meth=None):
+    if meth is None:
+        meth = logger.debug
+    meth("Could not fetch URL %s: %s - skipping", link, reason)
+
+
+def _get_html_page(link, session=None):
+    if session is None:
+        raise TypeError(
+            "_get_html_page() missing 1 required keyword argument: 'session'"
         )
 
-    def __hash__(self):
-        return hash(self._key)
+    url = link.url
+    url = url.split('#', 1)[0]
 
-    def __lt__(self, other):
-        return self._compare(other, lambda s, o: s < o)
+    # Check for VCS schemes that do not support lookup as web pages.
+    from pipenv.patched.notpip._internal.vcs import VcsSupport
+    for scheme in VcsSupport.schemes:
+        if url.lower().startswith(scheme) and url[len(scheme)] in '+:':
+            logger.debug('Cannot look at %s URL %s', scheme, link)
+            return None
 
-    def __le__(self, other):
-        return self._compare(other, lambda s, o: s <= o)
+    try:
+        filename = link.filename
+        for bad_ext in ARCHIVE_EXTENSIONS:
+            if filename.endswith(bad_ext):
+                content_type = _get_content_type(url, session=session)
+                if content_type.lower().startswith('text/html'):
+                    break
+                else:
+                    logger.debug(
+                        'Skipping page %s because of Content-Type: %s',
+                        link,
+                        content_type,
+                    )
+                    return
 
-    def __eq__(self, other):
-        return self._compare(other, lambda s, o: s == o)
+        logger.debug('Getting page %s', url)
 
-    def __ge__(self, other):
-        return self._compare(other, lambda s, o: s >= o)
+        # Tack index.html onto file:// URLs that point to directories
+        (scheme, netloc, path, params, query, fragment) = \
+            urllib_parse.urlparse(url)
+        if (scheme == 'file' and
+                os.path.isdir(urllib_request.url2pathname(path))):
+            # add trailing slash if not present so urljoin doesn't trim
+            # final segment
+            if not url.endswith('/'):
+                url += '/'
+            url = urllib_parse.urljoin(url, 'index.html')
+            logger.debug(' file: URL is directory, getting %s', url)
 
-    def __gt__(self, other):
-        return self._compare(other, lambda s, o: s > o)
+        resp = session.get(
+            url,
+            headers={
+                "Accept": "text/html",
+                # We don't want to blindly returned cached data for
+                # /simple/, because authors generally expecting that
+                # twine upload && pip install will function, but if
+                # they've done a pip install in the last ~10 minutes
+                # it won't. Thus by setting this to zero we will not
+                # blindly use any cached data, however the benefit of
+                # using max-age=0 instead of no-cache, is that we will
+                # still support conditional requests, so we will still
+                # minimize traffic sent in cases where the page hasn't
+                # changed at all, we will just always incur the round
+                # trip for the conditional GET now instead of only
+                # once per 10 minutes.
+                # For more information, please see pypa/pip#5670.
+                "Cache-Control": "max-age=0",
+            },
+        )
+        resp.raise_for_status()
 
-    def __ne__(self, other):
-        return self._compare(other, lambda s, o: s != o)
+        # The check for archives above only works if the url ends with
+        # something that looks like an archive. However that is not a
+        # requirement of an url. Unless we issue a HEAD request on every
+        # url we cannot know ahead of time for sure if something is HTML
+        # or not. However we can check after we've downloaded it.
+        content_type = resp.headers.get('Content-Type', 'unknown')
+        if not content_type.lower().startswith("text/html"):
+            logger.debug(
+                'Skipping page %s because of Content-Type: %s',
+                link,
+                content_type,
+            )
+            return
 
-    def _compare(self, other, method):
-        if not isinstance(other, InstallationCandidate):
-            return NotImplemented
-
-        return method(self._key, other._key)
+        inst = HTMLPage(resp.content, resp.url, resp.headers)
+    except requests.HTTPError as exc:
+        _handle_get_page_fail(link, exc, url)
+    except SSLError as exc:
+        reason = "There was a problem confirming the ssl certificate: "
+        reason += str(exc)
+        _handle_get_page_fail(link, reason, url, meth=logger.info)
+    except requests.ConnectionError as exc:
+        _handle_get_page_fail(link, "connection error: %s" % exc, url)
+    except requests.Timeout:
+        _handle_get_page_fail(link, "timed out", url)
+    else:
+        return inst
 
 
 class PackageFinder(object):
@@ -109,7 +185,8 @@ class PackageFinder(object):
     def __init__(self, find_links, index_urls, allow_all_prereleases=False,
                  trusted_hosts=None, process_dependency_links=False,
                  session=None, format_control=None, platform=None,
-                 versions=None, abi=None, implementation=None):
+                 versions=None, abi=None, implementation=None,
+                 prefer_binary=False):
         """Create a PackageFinder.
 
         :param format_control: A FormatControl object or None. Used to control
@@ -169,7 +246,7 @@ class PackageFinder(object):
         # The Session we'll use to make requests
         self.session = session
 
-        # Kenneth's Hack.
+        # Kenneth's Hack
         self.extra = None
 
         # The valid tags to check potential found wheel candidates against
@@ -180,6 +257,9 @@ class PackageFinder(object):
             impl=implementation,
         )
 
+        # Do we prefer old, but valid, binary dist over new source dist
+        self.prefer_binary = prefer_binary
+
         # If we don't have TLS enabled, then WARN if anyplace we're looking
         # relies on TLS.
         if not HAS_TLS:
@@ -197,7 +277,8 @@ class PackageFinder(object):
         lines = []
         if self.index_urls and self.index_urls != [PyPI.simple_url]:
             lines.append(
-                "Looking in indexes: {}".format(", ".join(self.index_urls))
+                "Looking in indexes: {}".format(", ".join(
+                    remove_auth_from_url(url) for url in self.index_urls))
             )
         if self.find_links:
             lines.append(
@@ -206,15 +287,17 @@ class PackageFinder(object):
         return "\n".join(lines)
 
     def add_dependency_links(self, links):
-        # # FIXME: this shouldn't be global list this, it should only
-        # # apply to requirements of the package that specifies the
-        # # dependency_links value
-        # # FIXME: also, we should track comes_from (i.e., use Link)
+        # FIXME: this shouldn't be global list this, it should only
+        # apply to requirements of the package that specifies the
+        # dependency_links value
+        # FIXME: also, we should track comes_from (i.e., use Link)
         if self.process_dependency_links:
-            warnings.warn(
+            deprecated(
                 "Dependency Links processing has been deprecated and will be "
                 "removed in a future release.",
-                RemovedInPip11Warning,
+                replacement="PEP 508 URL dependencies",
+                gone_in="18.2",
+                issue=4187,
             )
             self.dependency_links.extend(links)
 
@@ -236,6 +319,7 @@ class PackageFinder(object):
 
         return extras
 
+
     @staticmethod
     def _sort_locations(locations, expand_dir=False):
         """
@@ -297,12 +381,14 @@ class PackageFinder(object):
           1. existing installs
           2. wheels ordered via Wheel.support_index_min(self.valid_tags)
           3. source archives
+        If prefer_binary was set, then all wheels are sorted above sources.
         Note: it was considered to embed this logic into the Link
               comparison operators, but then different sdist links
               with the same version, would have to be considered equal
         """
         support_num = len(self.valid_tags)
         build_tag = tuple()
+        binary_preference = 0
         if candidate.location.is_wheel:
             # can raise InvalidWheelFilename
             wheel = Wheel(candidate.location.filename)
@@ -311,7 +397,8 @@ class PackageFinder(object):
                     "%s is not a supported wheel for this platform. It "
                     "can't be sorted." % wheel.filename
                 )
-
+            if self.prefer_binary:
+                binary_preference = 1
             tags = self.valid_tags if not ignore_compatibility else None
             try:
                 pri = -(wheel.support_index_min(tags=tags))
@@ -324,7 +411,7 @@ class PackageFinder(object):
                 build_tag = (int(build_tag_groups[0]), build_tag_groups[1])
         else:  # sdist
             pri = -(support_num)
-        return (candidate.version, build_tag, pri)
+        return (binary_preference, candidate.version, build_tag, pri)
 
     def _validate_secure_origin(self, logger, location):
         # Determine if this url used a secure transport mechanism
@@ -458,7 +545,7 @@ class PackageFinder(object):
             logger.debug('* %s', location)
 
         canonical_name = canonicalize_name(project_name)
-        formats = fmt_ctl_formats(self.format_control, canonical_name)
+        formats = self.format_control.get_allowed_formats(canonical_name)
         search = Search(project_name, canonical_name, formats)
         find_links_versions = self._package_versions(
             # We trust every directly linked archive in find_links
@@ -468,10 +555,13 @@ class PackageFinder(object):
 
         page_versions = []
         for page in self._get_pages(url_locations, project_name):
-            logger.debug('Analyzing links from page %s', page.url)
+            try:
+                logger.debug('Analyzing links from page %s', page.url)
+            except AttributeError:
+                continue
             with indent_log():
                 page_versions.extend(
-                    self._package_versions(page.links, search)
+                    self._package_versions(page.iter_links(), search)
                 )
 
         dependency_versions = self._package_versions(
@@ -512,25 +602,22 @@ class PackageFinder(object):
         all_candidates = self.find_all_candidates(req.name)
 
         # Filter out anything which doesn't match our specifier
-        if not ignore_compatibility:
-            compatible_versions = set(
-                req.specifier.filter(
-                    # We turn the version object into a str here because otherwise
-                    # when we're debundled but setuptools isn't, Python will see
-                    # packaging.version.Version and
-                    # pkg_resources._vendor.packaging.version.Version as different
-                    # types. This way we'll use a str as a common data interchange
-                    # format. If we stop using the pkg_resources provided specifier
-                    # and start using our own, we can drop the cast to str().
-                    [str(c.version) for c in all_candidates],
-                    prereleases=(
-                        self.allow_all_prereleases
-                        if self.allow_all_prereleases else None
-                    ),
-                )
+        compatible_versions = set(
+            req.specifier.filter(
+                # We turn the version object into a str here because otherwise
+                # when we're debundled but setuptools isn't, Python will see
+                # packaging.version.Version and
+                # pkg_resources._vendor.packaging.version.Version as different
+                # types. This way we'll use a str as a common data interchange
+                # format. If we stop using the pkg_resources provided specifier
+                # and start using our own, we can drop the cast to str().
+                [str(c.version) for c in all_candidates],
+                prereleases=(
+                    self.allow_all_prereleases
+                    if self.allow_all_prereleases else None
+                ),
             )
-        else:
-            compatible_versions = [str(c.version) for c in all_candidates]
+        )
         applicable_candidates = [
             # Again, converting to str to deal with debundling.
             c for c in all_candidates if str(c.version) in compatible_versions
@@ -617,8 +704,8 @@ class PackageFinder(object):
 
             try:
                 page = self._get_page(location)
-            except requests.HTTPError as e:
-                page = None
+            except requests.HTTPError:
+                continue
             if page is None:
                 continue
 
@@ -666,7 +753,6 @@ class PackageFinder(object):
             if not ext:
                 self._log_skipped_link(link, 'not a file')
                 return
-            # Always ignore unsupported extensions even when we ignore compatibility
             if ext not in SUPPORTED_EXTENSIONS:
                 self._log_skipped_link(
                     link, 'unsupported archive format: %s' % ext,
@@ -709,7 +795,7 @@ class PackageFinder(object):
             version = egg_info_matches(egg_info, search.supplied, link)
         if version is None:
             self._log_skipped_link(
-                link, 'wrong project name (not %s)' % search.supplied)
+                link, 'Missing project version for %s' % search.supplied)
             return
 
         match = self._py_version_re.search(version)
@@ -737,7 +823,7 @@ class PackageFinder(object):
         return InstallationCandidate(search.supplied, version, link, link.requires_python)
 
     def _get_page(self, link):
-        return HTMLPage.get_page(link, session=self.session)
+        return _get_html_page(link, session=self.session)
 
 
 def egg_info_matches(
@@ -757,7 +843,7 @@ def egg_info_matches(
         return None
     if search_name is None:
         full_match = match.group(0)
-        return full_match[full_match.index('-'):]
+        return full_match.split('-', 1)[-1]
     name = match.group(0).lower()
     # To match the "safe" name that pkg_resources creates:
     name = name.replace('_', '-')
@@ -769,377 +855,71 @@ def egg_info_matches(
         return None
 
 
+def _determine_base_url(document, page_url):
+    """Determine the HTML document's base URL.
+
+    This looks for a ``<base>`` tag in the HTML document. If present, its href
+    attribute denotes the base URL of anchor tags in the document. If there is
+    no such tag (or if it does not have a valid href attribute), the HTML
+    file's URL is used as the base URL.
+
+    :param document: An HTML document representation. The current
+        implementation expects the result of ``html5lib.parse()``.
+    :param page_url: The URL of the HTML document.
+    """
+    for base in document.findall(".//base"):
+        href = base.get("href")
+        if href is not None:
+            return href
+    return page_url
+
+
+def _get_encoding_from_headers(headers):
+    """Determine if we have any encoding information in our headers.
+    """
+    if headers and "Content-Type" in headers:
+        content_type, params = cgi.parse_header(headers["Content-Type"])
+        if "charset" in params:
+            return params['charset']
+    return None
+
+
+_CLEAN_LINK_RE = re.compile(r'[^a-z0-9$&+,/:;=?@.#%_\\|-]', re.I)
+
+
+def _clean_link(url):
+    """Makes sure a link is fully encoded.  That is, if a ' ' shows up in
+    the link, it will be rewritten to %20 (while not over-quoting
+    % or other characters)."""
+    return _CLEAN_LINK_RE.sub(lambda match: '%%%2x' % ord(match.group(0)), url)
+
+
 class HTMLPage(object):
     """Represents one page, along with its URL"""
 
     def __init__(self, content, url, headers=None):
-        # Determine if we have any encoding information in our headers
-        encoding = None
-        if headers and "Content-Type" in headers:
-            content_type, params = cgi.parse_header(headers["Content-Type"])
-
-            if "charset" in params:
-                encoding = params['charset']
-
         self.content = content
-        self.parsed = html5lib.parse(
-            self.content,
-            transport_encoding=encoding,
-            namespaceHTMLElements=False,
-        )
         self.url = url
         self.headers = headers
 
     def __str__(self):
         return self.url
 
-    @classmethod
-    def get_page(cls, link, skip_archives=True, session=None):
-        if session is None:
-            raise TypeError(
-                "get_page() missing 1 required keyword argument: 'session'"
-            )
-
-        url = link.url
-        url = url.split('#', 1)[0]
-
-        # Check for VCS schemes that do not support lookup as web pages.
-        from pipenv.patched.notpip._internal.vcs import VcsSupport
-        for scheme in VcsSupport.schemes:
-            if url.lower().startswith(scheme) and url[len(scheme)] in '+:':
-                logger.debug('Cannot look at %s URL %s', scheme, link)
-                return None
-
-        try:
-            if skip_archives:
-                filename = link.filename
-                for bad_ext in ARCHIVE_EXTENSIONS:
-                    if filename.endswith(bad_ext):
-                        content_type = cls._get_content_type(
-                            url, session=session,
-                        )
-                        if content_type.lower().startswith('text/html'):
-                            break
-                        else:
-                            logger.debug(
-                                'Skipping page %s because of Content-Type: %s',
-                                link,
-                                content_type,
-                            )
-                            return
-
-            logger.debug('Getting page %s', url)
-
-            # Tack index.html onto file:// URLs that point to directories
-            (scheme, netloc, path, params, query, fragment) = \
-                urllib_parse.urlparse(url)
-            if (scheme == 'file' and
-                    os.path.isdir(urllib_request.url2pathname(path))):
-                # add trailing slash if not present so urljoin doesn't trim
-                # final segment
-                if not url.endswith('/'):
-                    url += '/'
-                url = urllib_parse.urljoin(url, 'index.html')
-                logger.debug(' file: URL is directory, getting %s', url)
-
-            resp = session.get(
-                url,
-                headers={
-                    "Accept": "text/html",
-                    "Cache-Control": "max-age=600",
-                },
-            )
-            resp.raise_for_status()
-
-            # The check for archives above only works if the url ends with
-            # something that looks like an archive. However that is not a
-            # requirement of an url. Unless we issue a HEAD request on every
-            # url we cannot know ahead of time for sure if something is HTML
-            # or not. However we can check after we've downloaded it.
-            content_type = resp.headers.get('Content-Type', 'unknown')
-            if not content_type.lower().startswith("text/html"):
-                logger.debug(
-                    'Skipping page %s because of Content-Type: %s',
-                    link,
-                    content_type,
-                )
-                return
-
-            inst = cls(resp.content, resp.url, resp.headers)
-        except requests.HTTPError as exc:
-            cls._handle_fail(link, exc, url)
-        except SSLError as exc:
-            reason = "There was a problem confirming the ssl certificate: "
-            reason += str(exc)
-            cls._handle_fail(link, reason, url, meth=logger.info)
-        except requests.ConnectionError as exc:
-            cls._handle_fail(link, "connection error: %s" % exc, url)
-        except requests.Timeout:
-            cls._handle_fail(link, "timed out", url)
-        else:
-            return inst
-
-    @staticmethod
-    def _handle_fail(link, reason, url, meth=None):
-        if meth is None:
-            meth = logger.debug
-
-        meth("Could not fetch URL %s: %s - skipping", link, reason)
-
-    @staticmethod
-    def _get_content_type(url, session):
-        """Get the Content-Type of the given url, using a HEAD request"""
-        scheme, netloc, path, query, fragment = urllib_parse.urlsplit(url)
-        if scheme not in {'http', 'https'}:
-            # FIXME: some warning or something?
-            # assertion error?
-            return ''
-
-        resp = session.head(url, allow_redirects=True)
-        resp.raise_for_status()
-
-        return resp.headers.get("Content-Type", "")
-
-    @cached_property
-    def base_url(self):
-        bases = [
-            x for x in self.parsed.findall(".//base")
-            if x.get("href") is not None
-        ]
-        if bases and bases[0].get("href"):
-            return bases[0].get("href")
-        else:
-            return self.url
-
-    @property
-    def links(self):
+    def iter_links(self):
         """Yields all links in the page"""
-        for anchor in self.parsed.findall(".//a"):
+        document = html5lib.parse(
+            self.content,
+            transport_encoding=_get_encoding_from_headers(self.headers),
+            namespaceHTMLElements=False,
+        )
+        base_url = _determine_base_url(document, self.url)
+        for anchor in document.findall(".//a"):
             if anchor.get("href"):
                 href = anchor.get("href")
-                url = self.clean_link(
-                    urllib_parse.urljoin(self.base_url, href)
-                )
+                url = _clean_link(urllib_parse.urljoin(base_url, href))
                 pyrequire = anchor.get('data-requires-python')
                 pyrequire = unescape(pyrequire) if pyrequire else None
-                yield Link(url, self, requires_python=pyrequire)
-
-    _clean_re = re.compile(r'[^a-z0-9$&+,/:;=?@.#%_\\|-]', re.I)
-
-    def clean_link(self, url):
-        """Makes sure a link is fully encoded.  That is, if a ' ' shows up in
-        the link, it will be rewritten to %20 (while not over-quoting
-        % or other characters)."""
-        return self._clean_re.sub(
-            lambda match: '%%%2x' % ord(match.group(0)), url)
-
-
-class Link(object):
-
-    def __init__(self, url, comes_from=None, requires_python=None):
-        """
-        Object representing a parsed link from https://pypi.org/simple/*
-
-        url:
-            url of the resource pointed to (href of the link)
-        comes_from:
-            instance of HTMLPage where the link was found, or string.
-        requires_python:
-            String containing the `Requires-Python` metadata field, specified
-            in PEP 345. This may be specified by a data-requires-python
-            attribute in the HTML link tag, as described in PEP 503.
-        """
-
-        # url can be a UNC windows share
-        if url.startswith('\\\\'):
-            url = path_to_url(url)
-
-        self.url = url
-        self.comes_from = comes_from
-        self.requires_python = requires_python if requires_python else None
-
-    def __str__(self):
-        if self.requires_python:
-            rp = ' (requires-python:%s)' % self.requires_python
-        else:
-            rp = ''
-        if self.comes_from:
-            return '%s (from %s)%s' % (self.url, self.comes_from, rp)
-        else:
-            return str(self.url)
-
-    def __repr__(self):
-        return '<Link %s>' % self
-
-    def __eq__(self, other):
-        if not isinstance(other, Link):
-            return NotImplemented
-        return self.url == other.url
-
-    def __ne__(self, other):
-        if not isinstance(other, Link):
-            return NotImplemented
-        return self.url != other.url
-
-    def __lt__(self, other):
-        if not isinstance(other, Link):
-            return NotImplemented
-        return self.url < other.url
-
-    def __le__(self, other):
-        if not isinstance(other, Link):
-            return NotImplemented
-        return self.url <= other.url
-
-    def __gt__(self, other):
-        if not isinstance(other, Link):
-            return NotImplemented
-        return self.url > other.url
-
-    def __ge__(self, other):
-        if not isinstance(other, Link):
-            return NotImplemented
-        return self.url >= other.url
-
-    def __hash__(self):
-        return hash(self.url)
-
-    @property
-    def filename(self):
-        _, netloc, path, _, _ = urllib_parse.urlsplit(self.url)
-        name = posixpath.basename(path.rstrip('/')) or netloc
-        name = urllib_parse.unquote(name)
-        assert name, ('URL %r produced no filename' % self.url)
-        return name
-
-    @property
-    def scheme(self):
-        return urllib_parse.urlsplit(self.url)[0]
-
-    @property
-    def netloc(self):
-        return urllib_parse.urlsplit(self.url)[1]
-
-    @property
-    def path(self):
-        return urllib_parse.unquote(urllib_parse.urlsplit(self.url)[2])
-
-    def splitext(self):
-        return splitext(posixpath.basename(self.path.rstrip('/')))
-
-    @property
-    def ext(self):
-        return self.splitext()[1]
-
-    @property
-    def url_without_fragment(self):
-        scheme, netloc, path, query, fragment = urllib_parse.urlsplit(self.url)
-        return urllib_parse.urlunsplit((scheme, netloc, path, query, None))
-
-    _egg_fragment_re = re.compile(r'[#&]egg=([^&]*)')
-
-    @property
-    def egg_fragment(self):
-        match = self._egg_fragment_re.search(self.url)
-        if not match:
-            return None
-        return match.group(1)
-
-    _subdirectory_fragment_re = re.compile(r'[#&]subdirectory=([^&]*)')
-
-    @property
-    def subdirectory_fragment(self):
-        match = self._subdirectory_fragment_re.search(self.url)
-        if not match:
-            return None
-        return match.group(1)
-
-    _hash_re = re.compile(
-        r'(sha1|sha224|sha384|sha256|sha512|md5)=([a-f0-9]+)'
-    )
-
-    @property
-    def hash(self):
-        match = self._hash_re.search(self.url)
-        if match:
-            return match.group(2)
-        return None
-
-    @property
-    def hash_name(self):
-        match = self._hash_re.search(self.url)
-        if match:
-            return match.group(1)
-        return None
-
-    @property
-    def show_url(self):
-        return posixpath.basename(self.url.split('#', 1)[0].split('?', 1)[0])
-
-    @property
-    def is_wheel(self):
-        return self.ext == wheel_ext
-
-    @property
-    def is_artifact(self):
-        """
-        Determines if this points to an actual artifact (e.g. a tarball) or if
-        it points to an "abstract" thing like a path or a VCS location.
-        """
-        from pipenv.patched.notpip._internal.vcs import vcs
-
-        if self.scheme in vcs.all_schemes:
-            return False
-
-        return True
-
-
-FormatControl = namedtuple('FormatControl', 'no_binary only_binary')
-"""This object has two fields, no_binary and only_binary.
-
-If a field is falsy, it isn't set. If it is {':all:'}, it should match all
-packages except those listed in the other field. Only one field can be set
-to {':all:'} at a time. The rest of the time exact package name matches
-are listed, with any given package only showing up in one field at a time.
-"""
-
-
-def fmt_ctl_handle_mutual_exclude(value, target, other):
-    new = value.split(',')
-    while ':all:' in new:
-        other.clear()
-        target.clear()
-        target.add(':all:')
-        del new[:new.index(':all:') + 1]
-        if ':none:' not in new:
-            # Without a none, we want to discard everything as :all: covers it
-            return
-    for name in new:
-        if name == ':none:':
-            target.clear()
-            continue
-        name = canonicalize_name(name)
-        other.discard(name)
-        target.add(name)
-
-
-def fmt_ctl_formats(fmt_ctl, canonical_name):
-    result = {"binary", "source"}
-    if canonical_name in fmt_ctl.only_binary:
-        result.discard('source')
-    elif canonical_name in fmt_ctl.no_binary:
-        result.discard('binary')
-    elif ':all:' in fmt_ctl.only_binary:
-        result.discard('source')
-    elif ':all:' in fmt_ctl.no_binary:
-        result.discard('binary')
-    return frozenset(result)
-
-
-def fmt_ctl_no_binary(fmt_ctl):
-    fmt_ctl_handle_mutual_exclude(
-        ':all:', fmt_ctl.no_binary, fmt_ctl.only_binary,
-    )
+                yield Link(url, self.url, requires_python=pyrequire)
 
 
 Search = namedtuple('Search', 'supplied canonical formats')
diff --git a/pipenv/patched/notpip/_internal/locations.py b/pipenv/patched/notpip/_internal/locations.py
index 43586f4b..3c7d5bd8 100644
--- a/pipenv/patched/notpip/_internal/locations.py
+++ b/pipenv/patched/notpip/_internal/locations.py
@@ -8,10 +8,10 @@ import site
 import sys
 import sysconfig
 from distutils import sysconfig as distutils_sysconfig
-from distutils.command.install import SCHEME_KEYS, install  # type: ignore
+from distutils.command.install import SCHEME_KEYS  # type: ignore
 
-from pipenv.patched.notpip._internal.compat import WINDOWS, expanduser
 from pipenv.patched.notpip._internal.utils import appdirs
+from pipenv.patched.notpip._internal.utils.compat import WINDOWS, expanduser
 
 # Application Directories
 USER_CACHE_DIR = appdirs.user_cache_dir("pip")
diff --git a/pipenv/patched/notpip/_internal/models/__init__.py b/pipenv/patched/notpip/_internal/models/__init__.py
index e4de2e9d..7855226e 100644
--- a/pipenv/patched/notpip/_internal/models/__init__.py
+++ b/pipenv/patched/notpip/_internal/models/__init__.py
@@ -1,4 +1,2 @@
-from pipenv.patched.notpip._internal.models.index import Index, PyPI
-
-
-__all__ = ["Index", "PyPI"]
+"""A package that contains models that represent entities.
+"""
diff --git a/pipenv/patched/notpip/_internal/models/candidate.py b/pipenv/patched/notpip/_internal/models/candidate.py
new file mode 100644
index 00000000..9627589e
--- /dev/null
+++ b/pipenv/patched/notpip/_internal/models/candidate.py
@@ -0,0 +1,24 @@
+from pipenv.patched.notpip._vendor.packaging.version import parse as parse_version
+
+from pipenv.patched.notpip._internal.utils.models import KeyBasedCompareMixin
+
+
+class InstallationCandidate(KeyBasedCompareMixin):
+    """Represents a potential "candidate" for installation.
+    """
+
+    def __init__(self, project, version, location, requires_python=None):
+        self.project = project
+        self.version = parse_version(version)
+        self.location = location
+        self.requires_python = requires_python
+
+        super(InstallationCandidate, self).__init__(
+            key=(self.project, self.version, self.location),
+            defining_class=InstallationCandidate
+        )
+
+    def __repr__(self):
+        return "<InstallationCandidate({!r}, {!r}, {!r})>".format(
+            self.project, self.version, self.location,
+        )
diff --git a/pipenv/patched/notpip/_internal/models/format_control.py b/pipenv/patched/notpip/_internal/models/format_control.py
new file mode 100644
index 00000000..caad3cba
--- /dev/null
+++ b/pipenv/patched/notpip/_internal/models/format_control.py
@@ -0,0 +1,62 @@
+from pipenv.patched.notpip._vendor.packaging.utils import canonicalize_name
+
+
+class FormatControl(object):
+    """A helper class for controlling formats from which packages are installed.
+    If a field is falsy, it isn't set. If it is {':all:'}, it should match all
+    packages except those listed in the other field. Only one field can be set
+    to {':all:'} at a time. The rest of the time exact package name matches
+    are listed, with any given package only showing up in one field at a time.
+    """
+    def __init__(self, no_binary=None, only_binary=None):
+        self.no_binary = set() if no_binary is None else no_binary
+        self.only_binary = set() if only_binary is None else only_binary
+
+    def __eq__(self, other):
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __repr__(self):
+        return "{}({}, {})".format(
+            self.__class__.__name__,
+            self.no_binary,
+            self.only_binary
+        )
+
+    @staticmethod
+    def handle_mutual_excludes(value, target, other):
+        new = value.split(',')
+        while ':all:' in new:
+            other.clear()
+            target.clear()
+            target.add(':all:')
+            del new[:new.index(':all:') + 1]
+            # Without a none, we want to discard everything as :all: covers it
+            if ':none:' not in new:
+                return
+        for name in new:
+            if name == ':none:':
+                target.clear()
+                continue
+            name = canonicalize_name(name)
+            other.discard(name)
+            target.add(name)
+
+    def get_allowed_formats(self, canonical_name):
+        result = {"binary", "source"}
+        if canonical_name in self.only_binary:
+            result.discard('source')
+        elif canonical_name in self.no_binary:
+            result.discard('binary')
+        elif ':all:' in self.only_binary:
+            result.discard('source')
+        elif ':all:' in self.no_binary:
+            result.discard('binary')
+        return frozenset(result)
+
+    def disallow_binaries(self):
+        self.handle_mutual_excludes(
+            ':all:', self.no_binary, self.only_binary,
+        )
diff --git a/pipenv/patched/notpip/_internal/models/index.py b/pipenv/patched/notpip/_internal/models/index.py
index f9e84894..0983fc9c 100644
--- a/pipenv/patched/notpip/_internal/models/index.py
+++ b/pipenv/patched/notpip/_internal/models/index.py
@@ -1,15 +1,29 @@
 from pipenv.patched.notpip._vendor.six.moves.urllib import parse as urllib_parse
 
 
-class Index(object):
-    def __init__(self, url):
+class PackageIndex(object):
+    """Represents a Package Index and provides easier access to endpoints
+    """
+
+    def __init__(self, url, file_storage_domain):
+        super(PackageIndex, self).__init__()
         self.url = url
         self.netloc = urllib_parse.urlsplit(url).netloc
-        self.simple_url = self.url_to_path('simple')
-        self.pypi_url = self.url_to_path('pypi')
+        self.simple_url = self._url_for_path('simple')
+        self.pypi_url = self._url_for_path('pypi')
 
-    def url_to_path(self, path):
+        # This is part of a temporary hack used to block installs of PyPI
+        # packages which depend on external urls only necessary until PyPI can
+        # block such packages themselves
+        self.file_storage_domain = file_storage_domain
+
+    def _url_for_path(self, path):
         return urllib_parse.urljoin(self.url, path)
 
 
-PyPI = Index('https://pypi.org/')
+PyPI = PackageIndex(
+    'https://pypi.org/', file_storage_domain='files.pythonhosted.org'
+)
+TestPyPI = PackageIndex(
+    'https://test.pypi.org/', file_storage_domain='test-files.pythonhosted.org'
+)
diff --git a/pipenv/patched/notpip/_internal/models/link.py b/pipenv/patched/notpip/_internal/models/link.py
new file mode 100644
index 00000000..686af1d0
--- /dev/null
+++ b/pipenv/patched/notpip/_internal/models/link.py
@@ -0,0 +1,141 @@
+import posixpath
+import re
+
+from pipenv.patched.notpip._vendor.six.moves.urllib import parse as urllib_parse
+
+from pipenv.patched.notpip._internal.download import path_to_url
+from pipenv.patched.notpip._internal.utils.misc import splitext
+from pipenv.patched.notpip._internal.utils.models import KeyBasedCompareMixin
+from pipenv.patched.notpip._internal.wheel import wheel_ext
+
+
+class Link(KeyBasedCompareMixin):
+    """Represents a parsed link from a Package Index's simple URL
+    """
+
+    def __init__(self, url, comes_from=None, requires_python=None):
+        """
+        url:
+            url of the resource pointed to (href of the link)
+        comes_from:
+            instance of HTMLPage where the link was found, or string.
+        requires_python:
+            String containing the `Requires-Python` metadata field, specified
+            in PEP 345. This may be specified by a data-requires-python
+            attribute in the HTML link tag, as described in PEP 503.
+        """
+
+        # url can be a UNC windows share
+        if url.startswith('\\\\'):
+            url = path_to_url(url)
+
+        self.url = url
+        self.comes_from = comes_from
+        self.requires_python = requires_python if requires_python else None
+
+        super(Link, self).__init__(
+            key=(self.url),
+            defining_class=Link
+        )
+
+    def __str__(self):
+        if self.requires_python:
+            rp = ' (requires-python:%s)' % self.requires_python
+        else:
+            rp = ''
+        if self.comes_from:
+            return '%s (from %s)%s' % (self.url, self.comes_from, rp)
+        else:
+            return str(self.url)
+
+    def __repr__(self):
+        return '<Link %s>' % self
+
+    @property
+    def filename(self):
+        _, netloc, path, _, _ = urllib_parse.urlsplit(self.url)
+        name = posixpath.basename(path.rstrip('/')) or netloc
+        name = urllib_parse.unquote(name)
+        assert name, ('URL %r produced no filename' % self.url)
+        return name
+
+    @property
+    def scheme(self):
+        return urllib_parse.urlsplit(self.url)[0]
+
+    @property
+    def netloc(self):
+        return urllib_parse.urlsplit(self.url)[1]
+
+    @property
+    def path(self):
+        return urllib_parse.unquote(urllib_parse.urlsplit(self.url)[2])
+
+    def splitext(self):
+        return splitext(posixpath.basename(self.path.rstrip('/')))
+
+    @property
+    def ext(self):
+        return self.splitext()[1]
+
+    @property
+    def url_without_fragment(self):
+        scheme, netloc, path, query, fragment = urllib_parse.urlsplit(self.url)
+        return urllib_parse.urlunsplit((scheme, netloc, path, query, None))
+
+    _egg_fragment_re = re.compile(r'[#&]egg=([^&]*)')
+
+    @property
+    def egg_fragment(self):
+        match = self._egg_fragment_re.search(self.url)
+        if not match:
+            return None
+        return match.group(1)
+
+    _subdirectory_fragment_re = re.compile(r'[#&]subdirectory=([^&]*)')
+
+    @property
+    def subdirectory_fragment(self):
+        match = self._subdirectory_fragment_re.search(self.url)
+        if not match:
+            return None
+        return match.group(1)
+
+    _hash_re = re.compile(
+        r'(sha1|sha224|sha384|sha256|sha512|md5)=([a-f0-9]+)'
+    )
+
+    @property
+    def hash(self):
+        match = self._hash_re.search(self.url)
+        if match:
+            return match.group(2)
+        return None
+
+    @property
+    def hash_name(self):
+        match = self._hash_re.search(self.url)
+        if match:
+            return match.group(1)
+        return None
+
+    @property
+    def show_url(self):
+        return posixpath.basename(self.url.split('#', 1)[0].split('?', 1)[0])
+
+    @property
+    def is_wheel(self):
+        return self.ext == wheel_ext
+
+    @property
+    def is_artifact(self):
+        """
+        Determines if this points to an actual artifact (e.g. a tarball) or if
+        it points to an "abstract" thing like a path or a VCS location.
+        """
+        from pipenv.patched.notpip._internal.vcs import vcs
+
+        if self.scheme in vcs.all_schemes:
+            return False
+
+        return True
diff --git a/pipenv/patched/notpip/_internal/operations/check.py b/pipenv/patched/notpip/_internal/operations/check.py
index bc2c2b61..9c8ea08e 100644
--- a/pipenv/patched/notpip/_internal/operations/check.py
+++ b/pipenv/patched/notpip/_internal/operations/check.py
@@ -6,13 +6,14 @@ from collections import namedtuple
 from pipenv.patched.notpip._vendor.packaging.utils import canonicalize_name
 
 from pipenv.patched.notpip._internal.operations.prepare import make_abstract_dist
-
 from pipenv.patched.notpip._internal.utils.misc import get_installed_distributions
 from pipenv.patched.notpip._internal.utils.typing import MYPY_CHECK_RUNNING
 
 if MYPY_CHECK_RUNNING:
-    from pipenv.patched.notpip._internal.req.req_install import InstallRequirement
-    from typing import Any, Dict, Iterator, Set, Tuple, List
+    from pipenv.patched.notpip._internal.req.req_install import InstallRequirement  # noqa: F401
+    from typing import (  # noqa: F401
+        Any, Callable, Dict, Iterator, Optional, Set, Tuple, List
+    )
 
     # Shorthands
     PackageSet = Dict[str, 'PackageDetails']
@@ -33,17 +34,25 @@ def create_package_set_from_installed(**kwargs):
     # Default to using all packages installed on the system
     if kwargs == {}:
         kwargs = {"local_only": False, "skip": ()}
-    retval = {}
+
+    package_set = {}
     for dist in get_installed_distributions(**kwargs):
         name = canonicalize_name(dist.project_name)
-        retval[name] = PackageDetails(dist.version, dist.requires())
-    return retval
+        package_set[name] = PackageDetails(dist.version, dist.requires())
+    return package_set
 
 
-def check_package_set(package_set):
-    # type: (PackageSet) -> CheckResult
+def check_package_set(package_set, should_ignore=None):
+    # type: (PackageSet, Optional[Callable[[str], bool]]) -> CheckResult
     """Check if a package set is consistent
+
+    If should_ignore is passed, it should be a callable that takes a
+    package name and returns a boolean.
     """
+    if should_ignore is None:
+        def should_ignore(name):
+            return False
+
     missing = dict()
     conflicting = dict()
 
@@ -52,6 +61,9 @@ def check_package_set(package_set):
         missing_deps = set()  # type: Set[Missing]
         conflicting_deps = set()  # type: Set[Conflicting]
 
+        if should_ignore(package_name):
+            continue
+
         for req in package_set[package_name].requires:
             name = canonicalize_name(req.project_name)  # type: str
 
@@ -69,13 +81,10 @@ def check_package_set(package_set):
             if not req.specifier.contains(version, prereleases=True):
                 conflicting_deps.add((name, version, req))
 
-        def str_key(x):
-            return str(x)
-
         if missing_deps:
-            missing[package_name] = sorted(missing_deps, key=str_key)
+            missing[package_name] = sorted(missing_deps, key=str)
         if conflicting_deps:
-            conflicting[package_name] = sorted(conflicting_deps, key=str_key)
+            conflicting[package_name] = sorted(conflicting_deps, key=str)
 
     return missing, conflicting
 
@@ -86,21 +95,54 @@ def check_install_conflicts(to_install):
     installing given requirements
     """
     # Start from the current state
-    state = create_package_set_from_installed()
-    _simulate_installation_of(to_install, state)
-    return state, check_package_set(state)
+    package_set = create_package_set_from_installed()
+    # Install packages
+    would_be_installed = _simulate_installation_of(to_install, package_set)
+
+    # Only warn about directly-dependent packages; create a whitelist of them
+    whitelist = _create_whitelist(would_be_installed, package_set)
+
+    return (
+        package_set,
+        check_package_set(
+            package_set, should_ignore=lambda name: name not in whitelist
+        )
+    )
 
 
 # NOTE from @pradyunsg
 # This required a minor update in dependency link handling logic over at
 # operations.prepare.IsSDist.dist() to get it working
-def _simulate_installation_of(to_install, state):
-    # type: (List[InstallRequirement], PackageSet) -> None
+def _simulate_installation_of(to_install, package_set):
+    # type: (List[InstallRequirement], PackageSet) -> Set[str]
     """Computes the version of packages after installing to_install.
     """
 
+    # Keep track of packages that were installed
+    installed = set()
+
     # Modify it as installing requirement_set would (assuming no errors)
     for inst_req in to_install:
         dist = make_abstract_dist(inst_req).dist(finder=None)
         name = canonicalize_name(dist.key)
-        state[name] = PackageDetails(dist.version, dist.requires())
+        package_set[name] = PackageDetails(dist.version, dist.requires())
+
+        installed.add(name)
+
+    return installed
+
+
+def _create_whitelist(would_be_installed, package_set):
+    # type: (Set[str], PackageSet) -> Set[str]
+    packages_affected = set(would_be_installed)
+
+    for package_name in package_set:
+        if package_name in packages_affected:
+            continue
+
+        for req in package_set[package_name].requires:
+            if canonicalize_name(req.name) in packages_affected:
+                packages_affected.add(package_name)
+                break
+
+    return packages_affected
diff --git a/pipenv/patched/notpip/_internal/operations/freeze.py b/pipenv/patched/notpip/_internal/operations/freeze.py
index e81cc1cb..b18b98e4 100644
--- a/pipenv/patched/notpip/_internal/operations/freeze.py
+++ b/pipenv/patched/notpip/_internal/operations/freeze.py
@@ -4,18 +4,19 @@ import collections
 import logging
 import os
 import re
-import warnings
 
 from pipenv.patched.notpip._vendor import pkg_resources, six
 from pipenv.patched.notpip._vendor.packaging.utils import canonicalize_name
 from pipenv.patched.notpip._vendor.pkg_resources import RequirementParseError
 
 from pipenv.patched.notpip._internal.exceptions import InstallationError
-from pipenv.patched.notpip._internal.req import InstallRequirement
+from pipenv.patched.notpip._internal.req.constructors import (
+    install_req_from_editable, install_req_from_line,
+)
 from pipenv.patched.notpip._internal.req.req_file import COMMENT_RE
-from pipenv.patched.notpip._internal.utils.deprecation import RemovedInPip11Warning
+from pipenv.patched.notpip._internal.utils.deprecation import deprecated
 from pipenv.patched.notpip._internal.utils.misc import (
-    dist_is_editable, get_installed_distributions,
+    dist_is_editable, get_installed_distributions, make_vcs_requirement_url,
 )
 
 logger = logging.getLogger(__name__)
@@ -100,13 +101,13 @@ def freeze(
                             line = line[2:].strip()
                         else:
                             line = line[len('--editable'):].strip().lstrip('=')
-                        line_req = InstallRequirement.from_editable(
+                        line_req = install_req_from_editable(
                             line,
                             isolated=isolated,
                             wheel_cache=wheel_cache,
                         )
                     else:
-                        line_req = InstallRequirement.from_line(
+                        line_req = install_req_from_line(
                             COMMENT_RE.sub('', line).strip(),
                             isolated=isolated,
                             wheel_cache=wheel_cache,
@@ -167,7 +168,13 @@ class FrozenRequirement(object):
     _date_re = re.compile(r'-(20\d\d\d\d\d\d)$')
 
     @classmethod
-    def from_dist(cls, dist, dependency_links):
+    def _init_args_from_dist(cls, dist, dependency_links):
+        """
+        Compute and return arguments (req, editable, comments) to pass to
+        FrozenRequirement.__init__().
+
+        This method is for use in FrozenRequirement.from_dist().
+        """
         location = os.path.normcase(os.path.abspath(dist.location))
         comments = []
         from pipenv.patched.notpip._internal.vcs import vcs, get_src_requirement
@@ -216,10 +223,12 @@ class FrozenRequirement(object):
                         'for this package:'
                     )
                 else:
-                    warnings.warn(
+                    deprecated(
                         "SVN editable detection based on dependency links "
                         "will be dropped in the future.",
-                        RemovedInPip11Warning,
+                        replacement=None,
+                        gone_in="18.2",
+                        issue=4187,
                     )
                     comments.append(
                         '# Installing as editable to satisfy requirement %s:' %
@@ -230,12 +239,15 @@ class FrozenRequirement(object):
                     else:
                         rev = '{%s}' % date_match.group(1)
                     editable = True
-                    req = '%s@%s#egg=%s' % (
-                        svn_location,
-                        rev,
-                        cls.egg_name(dist)
-                    )
-        return cls(dist.project_name, req, editable, comments)
+                    egg_name = cls.egg_name(dist)
+                    req = make_vcs_requirement_url(svn_location, rev, egg_name)
+
+        return (req, editable, comments)
+
+    @classmethod
+    def from_dist(cls, dist, dependency_links):
+        args = cls._init_args_from_dist(dist, dependency_links)
+        return cls(dist.project_name, *args)
 
     @staticmethod
     def egg_name(dist):
diff --git a/pipenv/patched/notpip/_internal/operations/prepare.py b/pipenv/patched/notpip/_internal/operations/prepare.py
index 46538373..d61270b4 100644
--- a/pipenv/patched/notpip/_internal/operations/prepare.py
+++ b/pipenv/patched/notpip/_internal/operations/prepare.py
@@ -1,16 +1,12 @@
 """Prepares a distribution for installation
 """
 
-import itertools
 import logging
 import os
-import sys
-from copy import copy
 
 from pipenv.patched.notpip._vendor import pkg_resources, requests
 
-from pipenv.patched.notpip._internal.build_env import NoOpBuildEnvironment
-from pipenv.patched.notpip._internal.compat import expanduser
+from pipenv.patched.notpip._internal.build_env import BuildEnvironment
 from pipenv.patched.notpip._internal.download import (
     is_dir_url, is_file_url, is_vcs_url, unpack_url, url_to_path,
 )
@@ -18,14 +14,10 @@ from pipenv.patched.notpip._internal.exceptions import (
     DirectoryUrlHashUnsupported, HashUnpinned, InstallationError,
     PreviousBuildDirError, VcsHashUnsupported,
 )
-from pipenv.patched.notpip._internal.index import FormatControl
-from pipenv.patched.notpip._internal.req.req_install import InstallRequirement
+from pipenv.patched.notpip._internal.utils.compat import expanduser
 from pipenv.patched.notpip._internal.utils.hashes import MissingHashes
 from pipenv.patched.notpip._internal.utils.logging import indent_log
-from pipenv.patched.notpip._internal.utils.misc import (
-    call_subprocess, display_path, normalize_path,
-)
-from pipenv.patched.notpip._internal.utils.ui import open_spinner
+from pipenv.patched.notpip._internal.utils.misc import display_path, normalize_path, rmtree
 from pipenv.patched.notpip._internal.vcs import vcs
 
 logger = logging.getLogger(__name__)
@@ -47,26 +39,6 @@ def make_abstract_dist(req):
         return IsSDist(req)
 
 
-def _install_build_reqs(finder, prefix, build_requirements):
-    # NOTE: What follows is not a very good thing.
-    #       Eventually, this should move into the BuildEnvironment class and
-    #       that should handle all the isolation and sub-process invocation.
-    finder = copy(finder)
-    finder.format_control = FormatControl(set(), set([":all:"]))
-    urls = [
-        finder.find_requirement(
-            InstallRequirement.from_line(r), upgrade=False).url
-        for r in build_requirements
-    ]
-    args = [
-        sys.executable, '-m', 'pip', 'install', '--ignore-installed',
-        '--no-user', '--prefix', prefix,
-    ] + list(urls)
-
-    with open_spinner("Installing build dependencies") as spinner:
-        call_subprocess(args, show_stdout=False, spinner=spinner)
-
-
 class DistAbstraction(object):
     """Abstracts out the wheel vs non-wheel Resolver.resolve() logic.
 
@@ -93,7 +65,7 @@ class DistAbstraction(object):
         """Return a setuptools Dist object."""
         raise NotImplementedError(self.dist)
 
-    def prep_for_dist(self, finder):
+    def prep_for_dist(self, finder, build_isolation):
         """Ensure that we can get a Dist for this requirement."""
         raise NotImplementedError(self.dist)
 
@@ -121,35 +93,35 @@ class IsSDist(DistAbstraction):
         return dist
 
     def prep_for_dist(self, finder, build_isolation):
-        # Before calling "setup.py egg_info", we need to set-up the build
-        # environment.
-        build_requirements, isolate = self.req.get_pep_518_info()
-        should_isolate = build_isolation and isolate
+        # Prepare for building. We need to:
+        #   1. Load pyproject.toml (if it exists)
+        #   2. Set up the build environment
 
-        minimum_requirements = ('setuptools', 'wheel')
-        missing_requirements = set(minimum_requirements) - set(
-            pkg_resources.Requirement(r).key
-            for r in build_requirements
-        )
-        if missing_requirements:
-            def format_reqs(rs):
-                return ' and '.join(map(repr, sorted(rs)))
-            logger.warning(
-                "Missing build time requirements in pyproject.toml for %s: "
-                "%s.", self.req, format_reqs(missing_requirements)
-            )
-            logger.warning(
-                "This version of pip does not implement PEP 517 so it cannot "
-                "build a wheel without %s.", format_reqs(minimum_requirements)
-            )
+        self.req.load_pyproject_toml()
+        should_isolate = self.req.use_pep517 and build_isolation
 
         if should_isolate:
-            with self.req.build_env:
-                pass
-            _install_build_reqs(finder, self.req.build_env.path,
-                                build_requirements)
-        else:
-            self.req.build_env = NoOpBuildEnvironment(no_clean=False)
+            # Isolate in a BuildEnvironment and install the build-time
+            # requirements.
+            self.req.build_env = BuildEnvironment()
+            self.req.build_env.install_requirements(
+                finder, self.req.pyproject_requires,
+                "Installing build dependencies"
+            )
+            missing = []
+            if self.req.requirements_to_check:
+                check = self.req.requirements_to_check
+                missing = self.req.build_env.missing_requirements(check)
+            if missing:
+                logger.warning(
+                    "Missing build requirements in pyproject.toml for %s.",
+                    self.req,
+                )
+                logger.warning(
+                    "The project does not specify a build backend, and pip "
+                    "cannot fall back to setuptools without %s.",
+                    " and ".join(map(repr, sorted(missing)))
+                )
 
         try:
             self.req.run_egg_info()
@@ -164,7 +136,7 @@ class Installed(DistAbstraction):
     def dist(self, finder):
         return self.req.satisfied_by
 
-    def prep_for_dist(self, finder):
+    def prep_for_dist(self, finder, build_isolation):
         pass
 
 
@@ -173,11 +145,12 @@ class RequirementPreparer(object):
     """
 
     def __init__(self, build_dir, download_dir, src_dir, wheel_download_dir,
-                 progress_bar, build_isolation):
+                 progress_bar, build_isolation, req_tracker):
         super(RequirementPreparer, self).__init__()
 
         self.src_dir = src_dir
         self.build_dir = build_dir
+        self.req_tracker = req_tracker
 
         # Where still packed archives should be written to. If None, they are
         # not saved, and are deleted immediately after unpacking.
@@ -236,16 +209,8 @@ class RequirementPreparer(object):
             # installation.
             # FIXME: this won't upgrade when there's an existing
             # package unpacked in `req.source_dir`
-            # package unpacked in `req.source_dir`
-            # if os.path.exists(os.path.join(req.source_dir, 'setup.py')):
-            #     raise PreviousBuildDirError(
-            #         "pip can't proceed with requirements '%s' due to a"
-            #         " pre-existing build directory (%s). This is "
-            #         "likely due to a previous installation that failed"
-            #         ". pip is being responsible and not assuming it "
-            #         "can delete this. Please delete it and try again."
-            #         % (req, req.source_dir)
-            #     )
+            if os.path.exists(os.path.join(req.source_dir, 'setup.py')):
+                rmtree(req.source_dir)
             req.populate_link(finder, upgrade_allowed, require_hashes)
 
             # We can't hit this spot and have populate_link return None.
@@ -325,7 +290,8 @@ class RequirementPreparer(object):
                     (req, exc, req.link)
                 )
             abstract_dist = make_abstract_dist(req)
-            abstract_dist.prep_for_dist(finder, self.build_isolation)
+            with self.req_tracker.track(req):
+                abstract_dist.prep_for_dist(finder, self.build_isolation)
             if self._download_should_save:
                 # Make a .zip of the source_dir we already created.
                 if req.link.scheme in vcs.all_schemes:
@@ -351,7 +317,8 @@ class RequirementPreparer(object):
             req.update_editable(not self._download_should_save)
 
             abstract_dist = make_abstract_dist(req)
-            abstract_dist.prep_for_dist(finder, self.build_isolation)
+            with self.req_tracker.track(req):
+                abstract_dist.prep_for_dist(finder, self.build_isolation)
 
             if self._download_should_save:
                 req.archive(self.download_dir)
diff --git a/pipenv/patched/notpip/_internal/pep425tags.py b/pipenv/patched/notpip/_internal/pep425tags.py
index 4205f6e0..182c1c88 100644
--- a/pipenv/patched/notpip/_internal/pep425tags.py
+++ b/pipenv/patched/notpip/_internal/pep425tags.py
@@ -10,7 +10,12 @@ import sysconfig
 import warnings
 from collections import OrderedDict
 
-import pipenv.patched.notpip._internal.utils.glibc
+try:
+    import pipenv.patched.notpip._internal.utils.glibc
+except ImportError:
+    import pipenv.patched.notpip.utils.glibc
+
+from pipenv.patched.notpip._internal.utils.compat import get_extension_suffixes
 
 logger = logging.getLogger(__name__)
 
@@ -252,10 +257,9 @@ def get_supported(versions=None, noarch=False, platform=None,
         abis[0:0] = [abi]
 
     abi3s = set()
-    import imp
-    for suffix in imp.get_suffixes():
-        if suffix[0].startswith('.abi'):
-            abi3s.add(suffix[0].split('.', 2)[1])
+    for suffix in get_extension_suffixes():
+        if suffix.startswith('.abi'):
+            abi3s.add(suffix.split('.', 2)[1])
 
     abis.extend(sorted(list(abi3s)))
 
diff --git a/pipenv/patched/notpip/_internal/pyproject.py b/pipenv/patched/notpip/_internal/pyproject.py
new file mode 100644
index 00000000..a47e0f05
--- /dev/null
+++ b/pipenv/patched/notpip/_internal/pyproject.py
@@ -0,0 +1,144 @@
+from __future__ import absolute_import
+
+import io
+import os
+
+from pipenv.patched.notpip._vendor import pytoml, six
+
+from pipenv.patched.notpip._internal.exceptions import InstallationError
+
+
+def _is_list_of_str(obj):
+    return (
+        isinstance(obj, list) and
+        all(isinstance(item, six.string_types) for item in obj)
+    )
+
+
+def load_pyproject_toml(use_pep517, pyproject_toml, setup_py, req_name):
+    """Load the pyproject.toml file.
+
+    Parameters:
+        use_pep517 - Has the user requested PEP 517 processing? None
+                     means the user hasn't explicitly specified.
+        pyproject_toml - Location of the project's pyproject.toml file
+        setup_py - Location of the project's setup.py file
+        req_name - The name of the requirement we're processing (for
+                   error reporting)
+
+    Returns:
+        None if we should use the legacy code path, otherwise a tuple
+        (
+            requirements from pyproject.toml,
+            name of PEP 517 backend,
+            requirements we should check are installed after setting
+                up the build environment
+        )
+    """
+    has_pyproject = os.path.isfile(pyproject_toml)
+    has_setup = os.path.isfile(setup_py)
+
+    if has_pyproject:
+        with io.open(pyproject_toml, encoding="utf-8") as f:
+            pp_toml = pytoml.load(f)
+        build_system = pp_toml.get("build-system")
+    else:
+        build_system = None
+
+    # The following cases must use PEP 517
+    # We check for use_pep517 equalling False because that
+    # means the user explicitly requested --no-use-pep517
+    if has_pyproject and not has_setup:
+        if use_pep517 is False:
+            raise InstallationError(
+                "Disabling PEP 517 processing is invalid: "
+                "project does not have a setup.py"
+            )
+        use_pep517 = True
+    elif build_system and "build-backend" in build_system:
+        if use_pep517 is False:
+            raise InstallationError(
+                "Disabling PEP 517 processing is invalid: "
+                "project specifies a build backend of {} "
+                "in pyproject.toml".format(
+                    build_system["build-backend"]
+                )
+            )
+        use_pep517 = True
+
+    # If we haven't worked out whether to use PEP 517 yet,
+    # and the user hasn't explicitly stated a preference,
+    # we do so if the project has a pyproject.toml file.
+    elif use_pep517 is None:
+        use_pep517 = has_pyproject
+
+    # At this point, we know whether we're going to use PEP 517.
+    assert use_pep517 is not None
+
+    # If we're using the legacy code path, there is nothing further
+    # for us to do here.
+    if not use_pep517:
+        return None
+
+    if build_system is None:
+        # Either the user has a pyproject.toml with no build-system
+        # section, or the user has no pyproject.toml, but has opted in
+        # explicitly via --use-pep517.
+        # In the absence of any explicit backend specification, we
+        # assume the setuptools backend, and require wheel and a version
+        # of setuptools that supports that backend.
+        build_system = {
+            "requires": ["setuptools>=38.2.5", "wheel"],
+            "build-backend": "setuptools.build_meta",
+        }
+
+    # If we're using PEP 517, we have build system information (either
+    # from pyproject.toml, or defaulted by the code above).
+    # Note that at this point, we do not know if the user has actually
+    # specified a backend, though.
+    assert build_system is not None
+
+    # Ensure that the build-system section in pyproject.toml conforms
+    # to PEP 518.
+    error_template = (
+        "{package} has a pyproject.toml file that does not comply "
+        "with PEP 518: {reason}"
+    )
+
+    # Specifying the build-system table but not the requires key is invalid
+    if "requires" not in build_system:
+        raise InstallationError(
+            error_template.format(package=req_name, reason=(
+                "it has a 'build-system' table but not "
+                "'build-system.requires' which is mandatory in the table"
+            ))
+        )
+
+    # Error out if requires is not a list of strings
+    requires = build_system["requires"]
+    if not _is_list_of_str(requires):
+        raise InstallationError(error_template.format(
+            package=req_name,
+            reason="'build-system.requires' is not a list of strings.",
+        ))
+
+    backend = build_system.get("build-backend")
+    check = []
+    if backend is None:
+        # If the user didn't specify a backend, we assume they want to use
+        # the setuptools backend. But we can't be sure they have included
+        # a version of setuptools which supplies the backend, or wheel
+        # (which is neede by the backend) in their requirements. So we
+        # make a note to check that those requirements are present once
+        # we have set up the environment.
+        # TODO: Review this - it's quite a lot of work to check for a very
+        # specific case. The problem is, that case is potentially quite
+        # common - projects that adopted PEP 518 early for the ability to
+        # specify requirements to execute setup.py, but never considered
+        # needing to mention the build tools themselves. The original PEP
+        # 518 code had a similar check (but implemented in a different
+        # way).
+        backend = "setuptools.build_meta"
+        check = ["setuptools>=38.2.5", "wheel"]
+
+    return (requires, backend, check)
diff --git a/pipenv/patched/notpip/_internal/req/__init__.py b/pipenv/patched/notpip/_internal/req/__init__.py
index 9eece6ec..72aecb7c 100644
--- a/pipenv/patched/notpip/_internal/req/__init__.py
+++ b/pipenv/patched/notpip/_internal/req/__init__.py
@@ -48,7 +48,7 @@ def install_given_reqs(to_install, install_options, global_options=(),
                     *args,
                     **kwargs
                 )
-            except:
+            except Exception:
                 should_rollback = (
                     requirement.conflicts_with and
                     not requirement.install_succeeded
diff --git a/pipenv/patched/notpip/_internal/req/constructors.py b/pipenv/patched/notpip/_internal/req/constructors.py
new file mode 100644
index 00000000..9fe28d88
--- /dev/null
+++ b/pipenv/patched/notpip/_internal/req/constructors.py
@@ -0,0 +1,298 @@
+"""Backing implementation for InstallRequirement's various constructors
+
+The idea here is that these formed a major chunk of InstallRequirement's size
+so, moving them and support code dedicated to them outside of that class
+helps creates for better understandability for the rest of the code.
+
+These are meant to be used elsewhere within pip to create instances of
+InstallRequirement.
+"""
+
+import logging
+import os
+import re
+import traceback
+
+from pipenv.patched.notpip._vendor.packaging.markers import Marker
+from pipenv.patched.notpip._vendor.packaging.requirements import InvalidRequirement, Requirement
+from pipenv.patched.notpip._vendor.packaging.specifiers import Specifier
+from pipenv.patched.notpip._vendor.pkg_resources import RequirementParseError, parse_requirements
+
+from pipenv.patched.notpip._internal.download import (
+    is_archive_file, is_url, path_to_url, url_to_path,
+)
+from pipenv.patched.notpip._internal.exceptions import InstallationError
+from pipenv.patched.notpip._internal.models.index import PyPI, TestPyPI
+from pipenv.patched.notpip._internal.models.link import Link
+from pipenv.patched.notpip._internal.req.req_install import InstallRequirement
+from pipenv.patched.notpip._internal.utils.misc import is_installable_dir
+from pipenv.patched.notpip._internal.vcs import vcs
+from pipenv.patched.notpip._internal.wheel import Wheel
+
+__all__ = [
+    "install_req_from_editable", "install_req_from_line",
+    "parse_editable"
+]
+
+logger = logging.getLogger(__name__)
+operators = Specifier._operators.keys()
+
+
+def _strip_extras(path):
+    m = re.match(r'^(.+)(\[[^\]]+\])$', path)
+    extras = None
+    if m:
+        path_no_extras = m.group(1)
+        extras = m.group(2)
+    else:
+        path_no_extras = path
+
+    return path_no_extras, extras
+
+
+def parse_editable(editable_req):
+    """Parses an editable requirement into:
+        - a requirement name
+        - an URL
+        - extras
+        - editable options
+    Accepted requirements:
+        svn+http://blahblah@rev#egg=Foobar[baz]&subdirectory=version_subdir
+        .[some_extra]
+    """
+
+    url = editable_req
+
+    # If a file path is specified with extras, strip off the extras.
+    url_no_extras, extras = _strip_extras(url)
+
+    if os.path.isdir(url_no_extras):
+        if not os.path.exists(os.path.join(url_no_extras, 'setup.py')):
+            raise InstallationError(
+                "Directory %r is not installable. File 'setup.py' not found." %
+                url_no_extras
+            )
+        # Treating it as code that has already been checked out
+        url_no_extras = path_to_url(url_no_extras)
+
+    if url_no_extras.lower().startswith('file:'):
+        package_name = Link(url_no_extras).egg_fragment
+        if extras:
+            return (
+                package_name,
+                url_no_extras,
+                Requirement("placeholder" + extras.lower()).extras,
+            )
+        else:
+            return package_name, url_no_extras, None
+
+    for version_control in vcs:
+        if url.lower().startswith('%s:' % version_control):
+            url = '%s+%s' % (version_control, url)
+            break
+
+    if '+' not in url:
+        raise InstallationError(
+            '%s should either be a path to a local project or a VCS url '
+            'beginning with svn+, git+, hg+, or bzr+' %
+            editable_req
+        )
+
+    vc_type = url.split('+', 1)[0].lower()
+
+    if not vcs.get_backend(vc_type):
+        error_message = 'For --editable=%s only ' % editable_req + \
+            ', '.join([backend.name + '+URL' for backend in vcs.backends]) + \
+            ' is currently supported'
+        raise InstallationError(error_message)
+
+    package_name = Link(url).egg_fragment
+    if not package_name:
+        raise InstallationError(
+            "Could not detect requirement name for '%s', please specify one "
+            "with #egg=your_package_name" % editable_req
+        )
+    return package_name, url, None
+
+
+def deduce_helpful_msg(req):
+    """Returns helpful msg in case requirements file does not exist,
+    or cannot be parsed.
+
+    :params req: Requirements file path
+    """
+    msg = ""
+    if os.path.exists(req):
+        msg = " It does exist."
+        # Try to parse and check if it is a requirements file.
+        try:
+            with open(req, 'r') as fp:
+                # parse first line only
+                next(parse_requirements(fp.read()))
+                msg += " The argument you provided " + \
+                    "(%s) appears to be a" % (req) + \
+                    " requirements file. If that is the" + \
+                    " case, use the '-r' flag to install" + \
+                    " the packages specified within it."
+        except RequirementParseError:
+            logger.debug("Cannot parse '%s' as requirements \
+            file" % (req), exc_info=1)
+    else:
+        msg += " File '%s' does not exist." % (req)
+    return msg
+
+
+# ---- The actual constructors follow ----
+
+
+def install_req_from_editable(
+    editable_req, comes_from=None, isolated=False, options=None,
+    wheel_cache=None, constraint=False
+):
+    name, url, extras_override = parse_editable(editable_req)
+    if url.startswith('file:'):
+        source_dir = url_to_path(url)
+    else:
+        source_dir = None
+
+    if name is not None:
+        try:
+            req = Requirement(name)
+        except InvalidRequirement:
+            raise InstallationError("Invalid requirement: '%s'" % name)
+    else:
+        req = None
+    return InstallRequirement(
+        req, comes_from, source_dir=source_dir,
+        editable=True,
+        link=Link(url),
+        constraint=constraint,
+        isolated=isolated,
+        options=options if options else {},
+        wheel_cache=wheel_cache,
+        extras=extras_override or (),
+    )
+
+
+def install_req_from_line(
+    name, comes_from=None, isolated=False, options=None, wheel_cache=None,
+    constraint=False
+):
+    """Creates an InstallRequirement from a name, which might be a
+    requirement, directory containing 'setup.py', filename, or URL.
+    """
+    if is_url(name):
+        marker_sep = '; '
+    else:
+        marker_sep = ';'
+    if marker_sep in name:
+        name, markers = name.split(marker_sep, 1)
+        markers = markers.strip()
+        if not markers:
+            markers = None
+        else:
+            markers = Marker(markers)
+    else:
+        markers = None
+    name = name.strip()
+    req = None
+    path = os.path.normpath(os.path.abspath(name))
+    link = None
+    extras = None
+
+    if is_url(name):
+        link = Link(name)
+    else:
+        p, extras = _strip_extras(path)
+        looks_like_dir = os.path.isdir(p) and (
+            os.path.sep in name or
+            (os.path.altsep is not None and os.path.altsep in name) or
+            name.startswith('.')
+        )
+        if looks_like_dir:
+            if not is_installable_dir(p):
+                raise InstallationError(
+                    "Directory %r is not installable. Neither 'setup.py' "
+                    "nor 'pyproject.toml' found." % name
+                )
+            link = Link(path_to_url(p))
+        elif is_archive_file(p):
+            if not os.path.isfile(p):
+                logger.warning(
+                    'Requirement %r looks like a filename, but the '
+                    'file does not exist',
+                    name
+                )
+            link = Link(path_to_url(p))
+
+    # it's a local file, dir, or url
+    if link:
+        # Handle relative file URLs
+        if link.scheme == 'file' and re.search(r'\.\./', link.url):
+            link = Link(
+                path_to_url(os.path.normpath(os.path.abspath(link.path))))
+        # wheel file
+        if link.is_wheel:
+            wheel = Wheel(link.filename)  # can raise InvalidWheelFilename
+            req = "%s==%s" % (wheel.name, wheel.version)
+        else:
+            # set the req to the egg fragment.  when it's not there, this
+            # will become an 'unnamed' requirement
+            req = link.egg_fragment
+
+    # a requirement specifier
+    else:
+        req = name
+
+    if extras:
+        extras = Requirement("placeholder" + extras.lower()).extras
+    else:
+        extras = ()
+    if req is not None:
+        try:
+            req = Requirement(req)
+        except InvalidRequirement:
+            if os.path.sep in req:
+                add_msg = "It looks like a path."
+                add_msg += deduce_helpful_msg(req)
+            elif '=' in req and not any(op in req for op in operators):
+                add_msg = "= is not a valid operator. Did you mean == ?"
+            else:
+                add_msg = traceback.format_exc()
+            raise InstallationError(
+                "Invalid requirement: '%s'\n%s" % (req, add_msg)
+            )
+
+    return InstallRequirement(
+        req, comes_from, link=link, markers=markers,
+        isolated=isolated,
+        options=options if options else {},
+        wheel_cache=wheel_cache,
+        constraint=constraint,
+        extras=extras,
+    )
+
+
+def install_req_from_req(
+    req, comes_from=None, isolated=False, wheel_cache=None
+):
+    try:
+        req = Requirement(req)
+    except InvalidRequirement:
+        raise InstallationError("Invalid requirement: '%s'" % req)
+
+    domains_not_allowed = [
+        PyPI.file_storage_domain,
+        TestPyPI.file_storage_domain,
+    ]
+    if req.url and comes_from.link.netloc in domains_not_allowed:
+        # Explicitly disallow pypi packages that depend on external urls
+        raise InstallationError(
+            "Packages installed from PyPI cannot depend on packages "
+            "which are not also hosted on PyPI.\n"
+            "%s depends on %s " % (comes_from.name, req)
+        )
+
+    return InstallRequirement(
+        req, comes_from, isolated=isolated, wheel_cache=wheel_cache
+    )
diff --git a/pipenv/patched/notpip/_internal/req/req_file.py b/pipenv/patched/notpip/_internal/req/req_file.py
index 66a58022..5f23cd3a 100644
--- a/pipenv/patched/notpip/_internal/req/req_file.py
+++ b/pipenv/patched/notpip/_internal/req/req_file.py
@@ -13,10 +13,12 @@ import sys
 from pipenv.patched.notpip._vendor.six.moves import filterfalse
 from pipenv.patched.notpip._vendor.six.moves.urllib import parse as urllib_parse
 
-from pipenv.patched.notpip._internal import cmdoptions
+from pipenv.patched.notpip._internal.cli import cmdoptions
 from pipenv.patched.notpip._internal.download import get_file_content
 from pipenv.patched.notpip._internal.exceptions import RequirementsFileParseError
-from pipenv.patched.notpip._internal.req.req_install import InstallRequirement
+from pipenv.patched.notpip._internal.req.constructors import (
+    install_req_from_editable, install_req_from_line,
+)
 
 __all__ = ['parse_requirements']
 
@@ -151,7 +153,7 @@ def process_line(line, filename, line_number, finder=None, comes_from=None,
         for dest in SUPPORTED_OPTIONS_REQ_DEST:
             if dest in opts.__dict__ and opts.__dict__[dest]:
                 req_options[dest] = opts.__dict__[dest]
-        yield InstallRequirement.from_line(
+        yield install_req_from_line(
             args_str, line_comes_from, constraint=constraint,
             isolated=isolated, options=req_options, wheel_cache=wheel_cache
         )
@@ -159,7 +161,7 @@ def process_line(line, filename, line_number, finder=None, comes_from=None,
     # yield an editable requirement
     elif opts.editables:
         isolated = options.isolated_mode if options else False
-        yield InstallRequirement.from_editable(
+        yield install_req_from_editable(
             opts.editables[0], comes_from=line_comes_from,
             constraint=constraint, isolated=isolated, wheel_cache=wheel_cache
         )
diff --git a/pipenv/patched/notpip/_internal/req/req_install.py b/pipenv/patched/notpip/_internal/req/req_install.py
index 6347200c..3f32892c 100644
--- a/pipenv/patched/notpip/_internal/req/req_install.py
+++ b/pipenv/patched/notpip/_internal/req/req_install.py
@@ -2,66 +2,45 @@ from __future__ import absolute_import
 
 import logging
 import os
-import re
 import shutil
 import sys
 import sysconfig
-import traceback
-import warnings
 import zipfile
 from distutils.util import change_root
-from email.parser import FeedParser  # type: ignore
 
-from pipenv.patched.notpip._vendor import pkg_resources, pytoml, six
-from pipenv.patched.notpip._vendor.packaging import specifiers
-from pipenv.patched.notpip._vendor.packaging.markers import Marker
-from pipenv.patched.notpip._vendor.packaging.requirements import InvalidRequirement, Requirement
+from pipenv.patched.notpip._vendor import pkg_resources, six
+from pipenv.patched.notpip._vendor.packaging.requirements import Requirement
 from pipenv.patched.notpip._vendor.packaging.utils import canonicalize_name
-from pipenv.patched.notpip._vendor.packaging.version import parse as parse_version
 from pipenv.patched.notpip._vendor.packaging.version import Version
-from pipenv.patched.notpip._vendor.pkg_resources import RequirementParseError, parse_requirements
+from pipenv.patched.notpip._vendor.packaging.version import parse as parse_version
+from pipenv.patched.notpip._vendor.pep517.wrappers import Pep517HookCaller
 
 from pipenv.patched.notpip._internal import wheel
-from pipenv.patched.notpip._internal.build_env import BuildEnvironment
-from pipenv.patched.notpip._internal.compat import native_str
-from pipenv.patched.notpip._internal.download import (
-    is_archive_file, is_url, path_to_url, url_to_path,
-)
-from pipenv.patched.notpip._internal.exceptions import InstallationError, UninstallationError
+from pipenv.patched.notpip._internal.build_env import NoOpBuildEnvironment
+from pipenv.patched.notpip._internal.exceptions import InstallationError
 from pipenv.patched.notpip._internal.locations import (
     PIP_DELETE_MARKER_FILENAME, running_under_virtualenv,
 )
+from pipenv.patched.notpip._internal.models.link import Link
+from pipenv.patched.notpip._internal.pyproject import load_pyproject_toml
 from pipenv.patched.notpip._internal.req.req_uninstall import UninstallPathSet
-from pipenv.patched.notpip._internal.utils.deprecation import RemovedInPip11Warning
+from pipenv.patched.notpip._internal.utils.compat import native_str
 from pipenv.patched.notpip._internal.utils.hashes import Hashes
 from pipenv.patched.notpip._internal.utils.logging import indent_log
 from pipenv.patched.notpip._internal.utils.misc import (
     _make_build_dir, ask_path_exists, backup_dir, call_subprocess,
     display_path, dist_in_site_packages, dist_in_usersite, ensure_dir,
-    get_installed_version, is_installable_dir, read_text_file, rmtree,
+    get_installed_version, rmtree,
 )
+from pipenv.patched.notpip._internal.utils.packaging import get_metadata
 from pipenv.patched.notpip._internal.utils.setuptools_build import SETUPTOOLS_SHIM
 from pipenv.patched.notpip._internal.utils.temp_dir import TempDirectory
 from pipenv.patched.notpip._internal.utils.ui import open_spinner
 from pipenv.patched.notpip._internal.vcs import vcs
-from pipenv.patched.notpip._internal.wheel import Wheel, move_wheel_files
+from pipenv.patched.notpip._internal.wheel import move_wheel_files
 
 logger = logging.getLogger(__name__)
 
-operators = specifiers.Specifier._operators.keys()
-
-
-def _strip_extras(path):
-    m = re.match(r'^(.+)(\[[^\]]+\])$', path)
-    extras = None
-    if m:
-        path_no_extras = m.group(1)
-        extras = m.group(2)
-    else:
-        path_no_extras = path
-
-    return path_no_extras, extras
-
 
 class InstallRequirement(object):
     """
@@ -88,7 +67,6 @@ class InstallRequirement(object):
         if link is not None:
             self.link = self.original_link = link
         else:
-            from pipenv.patched.notpip._internal.index import Link
             self.link = self.original_link = req and req.url and Link(req.url)
 
         if extras:
@@ -127,155 +105,34 @@ class InstallRequirement(object):
         self.is_direct = False
 
         self.isolated = isolated
-        self.build_env = BuildEnvironment(no_clean=True)
+        self.build_env = NoOpBuildEnvironment()
 
-    @classmethod
-    def from_editable(cls, editable_req, comes_from=None, isolated=False,
-                      options=None, wheel_cache=None, constraint=False):
-        from pipenv.patched.notpip._internal.index import Link
+        # The static build requirements (from pyproject.toml)
+        self.pyproject_requires = None
 
-        name, url, extras_override = parse_editable(editable_req)
-        if url.startswith('file:'):
-            source_dir = url_to_path(url)
-        else:
-            source_dir = None
+        # Build requirements that we will check are available
+        # TODO: We don't do this for --no-build-isolation. Should we?
+        self.requirements_to_check = []
 
-        if name is not None:
-            try:
-                req = Requirement(name)
-            except InvalidRequirement:
-                raise InstallationError("Invalid requirement: '%s'" % name)
-        else:
-            req = None
-        return cls(
-            req, comes_from, source_dir=source_dir,
-            editable=True,
-            link=Link(url),
-            constraint=constraint,
-            isolated=isolated,
-            options=options if options else {},
-            wheel_cache=wheel_cache,
-            extras=extras_override or (),
-        )
+        # The PEP 517 backend we should use to build the project
+        self.pep517_backend = None
 
-    @classmethod
-    def from_req(cls, req, comes_from=None, isolated=False, wheel_cache=None):
-        try:
-            req = Requirement(req)
-        except InvalidRequirement:
-            raise InstallationError("Invalid requirement: '%s'" % req)
-        if req.url:
-            raise InstallationError(
-                "Direct url requirement (like %s) are not allowed for "
-                "dependencies" % req
-            )
-        return cls(req, comes_from, isolated=isolated, wheel_cache=wheel_cache)
-
-    @classmethod
-    def from_line(
-            cls, name, comes_from=None, isolated=False, options=None,
-            wheel_cache=None, constraint=False):
-        """Creates an InstallRequirement from a name, which might be a
-        requirement, directory containing 'setup.py', filename, or URL.
-        """
-        from pipenv.patched.notpip._internal.index import Link
-
-        if is_url(name):
-            marker_sep = '; '
-        else:
-            marker_sep = ';'
-        if marker_sep in name:
-            name, markers = name.split(marker_sep, 1)
-            markers = markers.strip()
-            if not markers:
-                markers = None
-            else:
-                markers = Marker(markers)
-        else:
-            markers = None
-        name = name.strip()
-        req = None
-        path = os.path.normpath(os.path.abspath(name))
-        link = None
-        extras = None
-
-        if is_url(name):
-            link = Link(name)
-        else:
-            p, extras = _strip_extras(path)
-            looks_like_dir = os.path.isdir(p) and (
-                os.path.sep in name or
-                (os.path.altsep is not None and os.path.altsep in name) or
-                name.startswith('.')
-            )
-            if looks_like_dir:
-                if not is_installable_dir(p):
-                    raise InstallationError(
-                        "Directory %r is not installable. File 'setup.py' "
-                        "not found." % name
-                    )
-                link = Link(path_to_url(p))
-            elif is_archive_file(p):
-                if not os.path.isfile(p):
-                    logger.warning(
-                        'Requirement %r looks like a filename, but the '
-                        'file does not exist',
-                        name
-                    )
-                link = Link(path_to_url(p))
-
-        # it's a local file, dir, or url
-        if link:
-            # Handle relative file URLs
-            if link.scheme == 'file' and re.search(r'\.\./', link.url):
-                link = Link(
-                    path_to_url(os.path.normpath(os.path.abspath(link.path))))
-            # wheel file
-            if link.is_wheel:
-                wheel = Wheel(link.filename)  # can raise InvalidWheelFilename
-                req = "%s==%s" % (wheel.name, wheel.version)
-            else:
-                # set the req to the egg fragment.  when it's not there, this
-                # will become an 'unnamed' requirement
-                req = link.egg_fragment
-
-        # a requirement specifier
-        else:
-            req = name
-
-        if extras:
-            extras = Requirement("placeholder" + extras.lower()).extras
-        else:
-            extras = ()
-        if req is not None:
-            try:
-                req = Requirement(req)
-            except InvalidRequirement:
-                if os.path.sep in req:
-                    add_msg = "It looks like a path."
-                    add_msg += deduce_helpful_msg(req)
-                elif '=' in req and not any(op in req for op in operators):
-                    add_msg = "= is not a valid operator. Did you mean == ?"
-                else:
-                    add_msg = traceback.format_exc()
-                raise InstallationError(
-                    "Invalid requirement: '%s'\n%s" % (req, add_msg))
-        return cls(
-            req, comes_from, link=link, markers=markers,
-            isolated=isolated,
-            options=options if options else {},
-            wheel_cache=wheel_cache,
-            constraint=constraint,
-            extras=extras,
-        )
+        # Are we using PEP 517 for this requirement?
+        # After pyproject.toml has been loaded, the only valid values are True
+        # and False. Before loading, None is valid (meaning "use the default").
+        # Setting an explicit value before loading pyproject.toml is supported,
+        # but after loading this flag should be treated as read only.
+        self.use_pep517 = None
 
     def __str__(self):
         if self.req:
             s = str(self.req)
             if self.link:
                 s += ' from %s' % self.link.url
+        elif self.link:
+            s = self.link.url
         else:
-            s = self.link.url if self.link else None
+            s = '<InstallRequirement>'
         if self.satisfied_by is not None:
             s += ' in %s' % display_path(self.satisfied_by.location)
         if self.comes_from:
@@ -311,6 +168,13 @@ class InstallRequirement(object):
             if old_link != self.link:
                 logger.debug('Using cached wheel link: %s', self.link)
 
+    # Things that are valid for all kinds of requirements?
+    @property
+    def name(self):
+        if self.req is None:
+            return None
+        return native_str(pkg_resources.safe_name(self.req.name))
+
     @property
     def specifier(self):
         return self.req.specifier
@@ -325,7 +189,56 @@ class InstallRequirement(object):
         return (len(specifiers) == 1 and
                 next(iter(specifiers)).operator in {'==', '==='})
 
+    @property
+    def installed_version(self):
+        return get_installed_version(self.name)
+
+    def match_markers(self, extras_requested=None):
+        if not extras_requested:
+            # Provide an extra to safely evaluate the markers
+            # without matching any extra
+            extras_requested = ('',)
+        if self.markers is not None:
+            return any(
+                self.markers.evaluate({'extra': extra})
+                for extra in extras_requested)
+        else:
+            return True
+
+    @property
+    def has_hash_options(self):
+        """Return whether any known-good hashes are specified as options.
+
+        These activate --require-hashes mode; hashes specified as part of a
+        URL do not.
+
+        """
+        return bool(self.options.get('hashes', {}))
+
+    def hashes(self, trust_internet=True):
+        """Return a hash-comparer that considers my option- and URL-based
+        hashes to be known-good.
+
+        Hashes in URLs--ones embedded in the requirements file, not ones
+        downloaded from an index server--are almost peers with ones from
+        flags. They satisfy --require-hashes (whether it was implicitly or
+        explicitly activated) but do not activate it. md5 and sha224 are not
+        allowed in flags, which should nudge people toward good algos. We
+        always OR all hashes together, even ones from URLs.
+
+        :param trust_internet: Whether to trust URL-based (#md5=...) hashes
+            downloaded from the internet, as by populate_link()
+
+        """
+        good_hashes = self.options.get('hashes', {}).copy()
+        link = self.link if trust_internet else self.original_link
+        if link and link.hash:
+            good_hashes.setdefault(link.hash_name, []).append(link.hash)
+        return Hashes(good_hashes)
+
     def from_path(self):
+        """Format a nice indicator to show where this "comes from"
+        """
         if self.req is None:
             return None
         s = str(self.req)
@@ -372,7 +285,7 @@ class InstallRequirement(object):
         package is not available until we run egg_info, so the build_location
         will return a temporary directory and store the _ideal_build_dir.
 
-        This is only called by self.egg_info_path to fix the temporary build
+        This is only called by self.run_egg_info to fix the temporary build
         directory.
         """
         if self.source_dir is not None:
@@ -398,12 +311,78 @@ class InstallRequirement(object):
         self.source_dir = os.path.normpath(os.path.abspath(new_location))
         self._egg_info_path = None
 
-    @property
-    def name(self):
-        if self.req is None:
-            return None
-        return native_str(pkg_resources.safe_name(self.req.name))
+    def remove_temporary_source(self):
+        """Remove the source files from this requirement, if they are marked
+        for deletion"""
+        if self.source_dir and os.path.exists(
+                os.path.join(self.source_dir, PIP_DELETE_MARKER_FILENAME)):
+            logger.debug('Removing source in %s', self.source_dir)
+            rmtree(self.source_dir)
+        self.source_dir = None
+        self._temp_build_dir.cleanup()
+        self.build_env.cleanup()
 
+    def check_if_exists(self, use_user_site):
+        """Find an installed distribution that satisfies or conflicts
+        with this requirement, and set self.satisfied_by or
+        self.conflicts_with appropriately.
+        """
+        if self.req is None:
+            return False
+        try:
+            # get_distribution() will resolve the entire list of requirements
+            # anyway, and we've already determined that we need the requirement
+            # in question, so strip the marker so that we don't try to
+            # evaluate it.
+            no_marker = Requirement(str(self.req))
+            no_marker.marker = None
+            self.satisfied_by = pkg_resources.get_distribution(str(no_marker))
+            if self.editable and self.satisfied_by:
+                self.conflicts_with = self.satisfied_by
+                # when installing editables, nothing pre-existing should ever
+                # satisfy
+                self.satisfied_by = None
+                return True
+        except pkg_resources.DistributionNotFound:
+            return False
+        except pkg_resources.VersionConflict:
+            existing_dist = pkg_resources.get_distribution(
+                self.req.name
+            )
+            if use_user_site:
+                if dist_in_usersite(existing_dist):
+                    self.conflicts_with = existing_dist
+                elif (running_under_virtualenv() and
+                        dist_in_site_packages(existing_dist)):
+                    raise InstallationError(
+                        "Will not install to the user site because it will "
+                        "lack sys.path precedence to %s in %s" %
+                        (existing_dist.project_name, existing_dist.location)
+                    )
+            else:
+                self.conflicts_with = existing_dist
+        return True
+
+    # Things valid for wheels
+    @property
+    def is_wheel(self):
+        return self.link and self.link.is_wheel
+
+    def move_wheel_files(self, wheeldir, root=None, home=None, prefix=None,
+                         warn_script_location=True, use_user_site=False,
+                         pycompile=True):
+        move_wheel_files(
+            self.name, self.req, wheeldir,
+            user=use_user_site,
+            home=home,
+            root=root,
+            prefix=prefix,
+            pycompile=pycompile,
+            isolated=self.isolated,
+            warn_script_location=warn_script_location,
+        )
+
+    # Things valid for sdists
     @property
     def setup_py_dir(self):
         return os.path.join(
@@ -434,21 +413,29 @@ class InstallRequirement(object):
 
         return pp_toml
 
-    def get_pep_518_info(self):
-        """Get a list of the packages required to build the project, if any,
-        and a flag indicating whether pyproject.toml is present, indicating
-        that the build should be isolated.
+    def load_pyproject_toml(self):
+        """Load the pyproject.toml file.
 
-        Build requirements can be specified in a pyproject.toml, as described
-        in PEP 518. If this file exists but doesn't specify build
-        requirements, pip will default to installing setuptools and wheel.
+        After calling this routine, all of the attributes related to PEP 517
+        processing for this requirement have been set. In particular, the
+        use_pep517 attribute can be used to determine whether we should
+        follow the PEP 517 or legacy (setup.py) code path.
         """
-        if os.path.isfile(self.pyproject_toml):
-            with open(self.pyproject_toml) as f:
-                pp_toml = pytoml.load(f)
-            build_sys = pp_toml.get('build-system', {})
-            return (build_sys.get('requires', ['setuptools', 'wheel']), True)
-        return (['setuptools', 'wheel'], False)
+        pep517_data = load_pyproject_toml(
+            self.use_pep517,
+            self.pyproject_toml,
+            self.setup_py,
+            str(self)
+        )
+
+        if pep517_data is None:
+            self.use_pep517 = False
+        else:
+            self.use_pep517 = True
+            requires, backend, check = pep517_data
+            self.requirements_to_check = check
+            self.pyproject_requires = requires
+            self.pep517_backend = Pep517HookCaller(self.setup_py_dir, backend)
 
     def run_egg_info(self):
         assert self.source_dir
@@ -465,7 +452,8 @@ class InstallRequirement(object):
 
         with indent_log():
             script = SETUPTOOLS_SHIM % self.setup_py
-            base_cmd = [os.environ.get('PIP_PYTHON_PATH', sys.executable), '-c', script]
+            sys_executable = os.environ.get('PIP_PYTHON_PATH', sys.executable)
+            base_cmd = [sys_executable, '-c', script]
             if self.isolated:
                 base_cmd += ["--no-user-cfg"]
             egg_info_cmd = base_cmd + ['egg_info']
@@ -486,20 +474,20 @@ class InstallRequirement(object):
                     command_desc='python setup.py egg_info')
 
         if not self.req:
-            if isinstance(parse_version(self.pkg_info()["Version"]), Version):
+            if isinstance(parse_version(self.metadata["Version"]), Version):
                 op = "=="
             else:
                 op = "==="
             self.req = Requirement(
                 "".join([
-                    self.pkg_info()["Name"],
+                    self.metadata["Name"],
                     op,
-                    self.pkg_info()["Version"],
+                    self.metadata["Version"],
                 ])
             )
             self._correct_build_location()
         else:
-            metadata_name = canonicalize_name(self.pkg_info()["Name"])
+            metadata_name = canonicalize_name(self.metadata["Name"])
             if canonicalize_name(self.req.name) != metadata_name:
                 logger.warning(
                     'Running setup.py (path:%s) egg_info for package %s '
@@ -509,19 +497,8 @@ class InstallRequirement(object):
                 )
                 self.req = Requirement(metadata_name)
 
-    def egg_info_data(self, filename):
-        if self.satisfied_by is not None:
-            if not self.satisfied_by.has_metadata(filename):
-                return None
-            return self.satisfied_by.get_metadata(filename)
-        assert self.source_dir
-        filename = self.egg_info_path(filename)
-        if not os.path.exists(filename):
-            return None
-        data = read_text_file(filename)
-        return data
-
-    def egg_info_path(self, filename):
+    @property
+    def egg_info_path(self):
         if self._egg_info_path is None:
             if self.editable:
                 base = self.source_dir
@@ -559,11 +536,8 @@ class InstallRequirement(object):
 
             if not filenames:
                 raise InstallationError(
-                    'No files/directories in %s (from %s)' % (base, filename)
+                    "Files/directories not found in %s" % base
                 )
-            assert filenames, \
-                "No files/directories in %s (from %s)" % (base, filename)
-
             # if we have more than one match, we pick the toplevel one.  This
             # can easily be the case if there is a dist folder which contains
             # an extracted tarball for testing purposes.
@@ -573,28 +547,30 @@ class InstallRequirement(object):
                     (os.path.altsep and x.count(os.path.altsep) or 0)
                 )
             self._egg_info_path = os.path.join(base, filenames[0])
-        return os.path.join(self._egg_info_path, filename)
-
-    def pkg_info(self):
-        p = FeedParser()
-        data = self.egg_info_data('PKG-INFO')
-        if not data:
-            logger.warning(
-                'No PKG-INFO file found in %s',
-                display_path(self.egg_info_path('PKG-INFO')),
-            )
-        p.feed(data or '')
-        return p.close()
-
-    _requirements_section_re = re.compile(r'\[(.*?)\]')
+        return self._egg_info_path
 
     @property
-    def installed_version(self):
-        return get_installed_version(self.name)
+    def metadata(self):
+        if not hasattr(self, '_metadata'):
+            self._metadata = get_metadata(self.get_dist())
+
+        return self._metadata
+
+    def get_dist(self):
+        """Return a pkg_resources.Distribution built from self.egg_info_path"""
+        egg_info = self.egg_info_path.rstrip(os.path.sep)
+        base_dir = os.path.dirname(egg_info)
+        metadata = pkg_resources.PathMetadata(base_dir, egg_info)
+        dist_name = os.path.splitext(os.path.basename(egg_info))[0]
+        return pkg_resources.Distribution(
+            os.path.dirname(egg_info),
+            project_name=dist_name,
+            metadata=metadata,
+        )
 
     def assert_source_matches_version(self):
         assert self.source_dir
-        version = self.pkg_info()['version']
+        version = self.metadata['version']
         if self.req.specifier and version not in self.req.specifier:
             logger.warning(
                 'Requested %s, but installing version %s',
@@ -609,6 +585,53 @@ class InstallRequirement(object):
                 self,
             )
 
+    # For both source distributions and editables
+    def ensure_has_source_dir(self, parent_dir):
+        """Ensure that a source_dir is set.
+
+        This will create a temporary build dir if the name of the requirement
+        isn't known yet.
+
+        :param parent_dir: The ideal pip parent_dir for the source_dir.
+            Generally src_dir for editables and build_dir for sdists.
+        :return: self.source_dir
+        """
+        if self.source_dir is None:
+            self.source_dir = self.build_location(parent_dir)
+        return self.source_dir
+
+    # For editable installations
+    def install_editable(self, install_options,
+                         global_options=(), prefix=None):
+        logger.info('Running setup.py develop for %s', self.name)
+
+        if self.isolated:
+            global_options = list(global_options) + ["--no-user-cfg"]
+
+        if prefix:
+            prefix_param = ['--prefix={}'.format(prefix)]
+            install_options = list(install_options) + prefix_param
+
+        with indent_log():
+            # FIXME: should we do --install-headers here too?
+            sys_executable = os.environ.get('PIP_PYTHON_PATH', sys.executable)
+            with self.build_env:
+                call_subprocess(
+                    [
+                        sys_executable,
+                        '-c',
+                        SETUPTOOLS_SHIM % self.setup_py
+                    ] +
+                    list(global_options) +
+                    ['develop', '--no-deps'] +
+                    list(install_options),
+
+                    cwd=self.setup_py_dir,
+                    show_stdout=False,
+                )
+
+        self.install_succeeded = True
+
     def update_editable(self, obtain=True):
         if not self.link:
             logger.debug(
@@ -638,6 +661,7 @@ class InstallRequirement(object):
                 'Unexpected version control type (in %s): %s'
                 % (self.link, vc_type))
 
+    # Top-level Actions
     def uninstall(self, auto_confirm=False, verbose=False,
                   use_user_site=False):
         """
@@ -661,10 +685,20 @@ class InstallRequirement(object):
         uninstalled_pathset.remove(auto_confirm, verbose)
         return uninstalled_pathset
 
+    def _clean_zip_name(self, name, prefix):  # only used by archive.
+        assert name.startswith(prefix + os.path.sep), (
+            "name %r doesn't start with prefix %r" % (name, prefix)
+        )
+        name = name[len(prefix) + 1:]
+        name = name.replace(os.path.sep, '/')
+        return name
+
+    # TODO: Investigate if this should be kept in InstallRequirement
+    #       Seems to be used only when VCS + downloads
     def archive(self, build_dir):
         assert self.source_dir
         create_archive = True
-        archive_name = '%s-%s.zip' % (self.name, self.pkg_info()["version"])
+        archive_name = '%s-%s.zip' % (self.name, self.metadata["version"])
         archive_path = os.path.join(build_dir, archive_name)
         if os.path.exists(archive_path):
             response = ask_path_exists(
@@ -709,26 +743,6 @@ class InstallRequirement(object):
             zip.close()
             logger.info('Saved %s', display_path(archive_path))
 
-    def _clean_zip_name(self, name, prefix):
-        assert name.startswith(prefix + os.path.sep), (
-            "name %r doesn't start with prefix %r" % (name, prefix)
-        )
-        name = name[len(prefix) + 1:]
-        name = name.replace(os.path.sep, '/')
-        return name
-
-    def match_markers(self, extras_requested=None):
-        if not extras_requested:
-            # Provide an extra to safely evaluate the markers
-            # without matching any extra
-            extras_requested = ('',)
-        if self.markers is not None:
-            return any(
-                self.markers.evaluate({'extra': extra})
-                for extra in extras_requested)
-        else:
-            return True
-
     def install(self, install_options, global_options=None, root=None,
                 home=None, prefix=None, warn_script_location=True,
                 use_user_site=False, pycompile=True):
@@ -820,23 +834,10 @@ class InstallRequirement(object):
             with open(inst_files_path, 'w') as f:
                 f.write('\n'.join(new_lines) + '\n')
 
-    def ensure_has_source_dir(self, parent_dir):
-        """Ensure that a source_dir is set.
-
-        This will create a temporary build dir if the name of the requirement
-        isn't known yet.
-
-        :param parent_dir: The ideal pip parent_dir for the source_dir.
-            Generally src_dir for editables and build_dir for sdists.
-        :return: self.source_dir
-        """
-        if self.source_dir is None:
-            self.source_dir = self.build_location(parent_dir)
-        return self.source_dir
-
     def get_install_args(self, global_options, record_filename, root, prefix,
                          pycompile):
-        install_args = [os.environ.get('PIP_PYTHON_PATH', sys.executable), "-u"]
+        sys_executable = os.environ.get('PIP_PYTHON_PATH', sys.executable)
+        install_args = [sys_executable, "-u"]
         install_args.append('-c')
         install_args.append(SETUPTOOLS_SHIM % self.setup_py)
         install_args += list(global_options) + \
@@ -860,256 +861,3 @@ class InstallRequirement(object):
                                           py_ver_str, self.name)]
 
         return install_args
-
-    def remove_temporary_source(self):
-        """Remove the source files from this requirement, if they are marked
-        for deletion"""
-        if self.source_dir and os.path.exists(
-                os.path.join(self.source_dir, PIP_DELETE_MARKER_FILENAME)):
-            logger.debug('Removing source in %s', self.source_dir)
-            rmtree(self.source_dir)
-        self.source_dir = None
-        self._temp_build_dir.cleanup()
-        self.build_env.cleanup()
-
-    def install_editable(self, install_options,
-                         global_options=(), prefix=None):
-        logger.info('Running setup.py develop for %s', self.name)
-
-        if self.isolated:
-            global_options = list(global_options) + ["--no-user-cfg"]
-
-        if prefix:
-            prefix_param = ['--prefix={}'.format(prefix)]
-            install_options = list(install_options) + prefix_param
-
-        with indent_log():
-            # FIXME: should we do --install-headers here too?
-            with self.build_env:
-                call_subprocess(
-                    [
-                        os.environ.get('PIP_PYTHON_PATH', sys.executable),
-                        '-c',
-                        SETUPTOOLS_SHIM % self.setup_py
-                    ] +
-                    list(global_options) +
-                    ['develop', '--no-deps'] +
-                    list(install_options),
-
-                    cwd=self.setup_py_dir,
-                    show_stdout=False,
-                )
-
-        self.install_succeeded = True
-
-    def check_if_exists(self, use_user_site):
-        """Find an installed distribution that satisfies or conflicts
-        with this requirement, and set self.satisfied_by or
-        self.conflicts_with appropriately.
-        """
-        if self.req is None:
-            return False
-        try:
-            # get_distribution() will resolve the entire list of requirements
-            # anyway, and we've already determined that we need the requirement
-            # in question, so strip the marker so that we don't try to
-            # evaluate it.
-            no_marker = Requirement(str(self.req))
-            no_marker.marker = None
-            self.satisfied_by = pkg_resources.get_distribution(str(no_marker))
-            if self.editable and self.satisfied_by:
-                self.conflicts_with = self.satisfied_by
-                # when installing editables, nothing pre-existing should ever
-                # satisfy
-                self.satisfied_by = None
-                return True
-        except pkg_resources.DistributionNotFound:
-            return False
-        except pkg_resources.VersionConflict:
-            existing_dist = pkg_resources.get_distribution(
-                self.req.name
-            )
-            if use_user_site:
-                if dist_in_usersite(existing_dist):
-                    self.conflicts_with = existing_dist
-                elif (running_under_virtualenv() and
-                        dist_in_site_packages(existing_dist)):
-                    raise InstallationError(
-                        "Will not install to the user site because it will "
-                        "lack sys.path precedence to %s in %s" %
-                        (existing_dist.project_name, existing_dist.location)
-                    )
-            else:
-                self.conflicts_with = existing_dist
-        return True
-
-    @property
-    def is_wheel(self):
-        return self.link and self.link.is_wheel
-
-    def move_wheel_files(self, wheeldir, root=None, home=None, prefix=None,
-                         warn_script_location=True, use_user_site=False,
-                         pycompile=True):
-        move_wheel_files(
-            self.name, self.req, wheeldir,
-            user=use_user_site,
-            home=home,
-            root=root,
-            prefix=prefix,
-            pycompile=pycompile,
-            isolated=self.isolated,
-            warn_script_location=warn_script_location,
-        )
-
-    def get_dist(self):
-        """Return a pkg_resources.Distribution built from self.egg_info_path"""
-        egg_info = self.egg_info_path('').rstrip(os.path.sep)
-        base_dir = os.path.dirname(egg_info)
-        metadata = pkg_resources.PathMetadata(base_dir, egg_info)
-        dist_name = os.path.splitext(os.path.basename(egg_info))[0]
-        return pkg_resources.Distribution(
-            os.path.dirname(egg_info),
-            project_name=dist_name,
-            metadata=metadata,
-        )
-
-    @property
-    def has_hash_options(self):
-        """Return whether any known-good hashes are specified as options.
-
-        These activate --require-hashes mode; hashes specified as part of a
-        URL do not.
-
-        """
-        return bool(self.options.get('hashes', {}))
-
-    def hashes(self, trust_internet=True):
-        """Return a hash-comparer that considers my option- and URL-based
-        hashes to be known-good.
-
-        Hashes in URLs--ones embedded in the requirements file, not ones
-        downloaded from an index server--are almost peers with ones from
-        flags. They satisfy --require-hashes (whether it was implicitly or
-        explicitly activated) but do not activate it. md5 and sha224 are not
-        allowed in flags, which should nudge people toward good algos. We
-        always OR all hashes together, even ones from URLs.
-
-        :param trust_internet: Whether to trust URL-based (#md5=...) hashes
-            downloaded from the internet, as by populate_link()
-
-        """
-        good_hashes = self.options.get('hashes', {}).copy()
-        link = self.link if trust_internet else self.original_link
-        if link and link.hash:
-            good_hashes.setdefault(link.hash_name, []).append(link.hash)
-        return Hashes(good_hashes)
-
-
-def _strip_postfix(req):
-    """
-        Strip req postfix ( -dev, 0.2, etc )
-    """
-    # FIXME: use package_to_requirement?
-    match = re.search(r'^(.*?)(?:-dev|-\d.*)$', req)
-    if match:
-        # Strip off -dev, -0.2, etc.
-        warnings.warn(
-            "#egg cleanup for editable urls will be dropped in the future",
-            RemovedInPip11Warning,
-        )
-        req = match.group(1)
-    return req
-
-
-def parse_editable(editable_req):
-    """Parses an editable requirement into:
-        - a requirement name
-        - an URL
-        - extras
-        - editable options
-    Accepted requirements:
-        svn+http://blahblah@rev#egg=Foobar[baz]&subdirectory=version_subdir
-        .[some_extra]
-    """
-
-    from pipenv.patched.notpip._internal.index import Link
-
-    url = editable_req
-
-    # If a file path is specified with extras, strip off the extras.
-    url_no_extras, extras = _strip_extras(url)
-
-    if os.path.isdir(url_no_extras):
-        if not os.path.exists(os.path.join(url_no_extras, 'setup.py')):
-            raise InstallationError(
-                "Directory %r is not installable. File 'setup.py' not found." %
-                url_no_extras
-            )
-        # Treating it as code that has already been checked out
-        url_no_extras = path_to_url(url_no_extras)
-
-    if url_no_extras.lower().startswith('file:'):
-        package_name = Link(url_no_extras).egg_fragment
-        if extras:
-            return (
-                package_name,
-                url_no_extras,
-                Requirement("placeholder" + extras.lower()).extras,
-            )
-        else:
-            return package_name, url_no_extras, None
-
-    for version_control in vcs:
-        if url.lower().startswith('%s:' % version_control):
-            url = '%s+%s' % (version_control, url)
-            break
-
-    if '+' not in url:
-        raise InstallationError(
-            '%s should either be a path to a local project or a VCS url '
-            'beginning with svn+, git+, hg+, or bzr+' %
-            editable_req
-        )
-
-    vc_type = url.split('+', 1)[0].lower()
-
-    if not vcs.get_backend(vc_type):
-        error_message = 'For --editable=%s only ' % editable_req + \
-            ', '.join([backend.name + '+URL' for backend in vcs.backends]) + \
-            ' is currently supported'
-        raise InstallationError(error_message)
-
-    package_name = Link(url).egg_fragment
-    if not package_name:
-        raise InstallationError(
-            "Could not detect requirement name for '%s', please specify one "
-            "with #egg=your_package_name" % editable_req
-        )
-    return _strip_postfix(package_name), url, None
-
-
-def deduce_helpful_msg(req):
-    """Returns helpful msg in case requirements file does not exist,
-    or cannot be parsed.
-
-    :params req: Requirements file path
-    """
-    msg = ""
-    if os.path.exists(req):
-        msg = " It does exist."
-        # Try to parse and check if it is a requirements file.
-        try:
-            with open(req, 'r') as fp:
-                # parse first line only
-                next(parse_requirements(fp.read()))
-                msg += " The argument you provided " + \
-                    "(%s) appears to be a" % (req) + \
-                    " requirements file. If that is the" + \
-                    " case, use the '-r' flag to install" + \
-                    " the packages specified within it."
-        except RequirementParseError:
-            logger.debug("Cannot parse '%s' as requirements \
-            file" % (req), exc_info=1)
-    else:
-        msg += " File '%s' does not exist." % (req)
-    return msg
diff --git a/pipenv/patched/notpip/_internal/req/req_set.py b/pipenv/patched/notpip/_internal/req/req_set.py
index 2fd09f5e..a65851ff 100644
--- a/pipenv/patched/notpip/_internal/req/req_set.py
+++ b/pipenv/patched/notpip/_internal/req/req_set.py
@@ -12,22 +12,22 @@ logger = logging.getLogger(__name__)
 
 class RequirementSet(object):
 
-    def __init__(self, require_hashes=False, ignore_compatibility=True):
+    def __init__(self, require_hashes=False, check_supported_wheels=True, ignore_compatibility=True):
         """Create a RequirementSet.
-
-        :param wheel_cache: The pip wheel cache, for passing to
-            InstallRequirement.
         """
 
         self.requirements = OrderedDict()
         self.require_hashes = require_hashes
+        self.check_supported_wheels = check_supported_wheels
+        if ignore_compatibility:
+            self.check_supported_wheels = False
+        self.ignore_compatibility = True if (check_supported_wheels is False or ignore_compatibility is True) else False
 
         # Mapping of alias: real_name
         self.requirement_aliases = {}
         self.unnamed_requirements = []
         self.successfully_downloaded = []
         self.reqs_to_cleanup = []
-        self.ignore_compatibility = ignore_compatibility
 
     def __str__(self):
         reqs = [req for req in self.requirements.values()
@@ -59,17 +59,22 @@ class RequirementSet(object):
             requirement is applicable and has just been added.
         """
         name = install_req.name
+
+        # If the markers do not match, ignore this requirement.
         if not install_req.match_markers(extras_requested):
-            logger.info("Ignoring %s: markers '%s' don't match your "
-                        "environment", install_req.name,
-                        install_req.markers)
+            logger.info(
+                "Ignoring %s: markers '%s' don't match your environment",
+                name, install_req.markers,
+            )
             return [], None
 
-        # This check has to come after we filter requirements with the
-        # environment markers.
+        # If the wheel is not supported, raise an error.
+        # Should check this after filtering out based on environment markers to
+        # allow specifying different wheels based on the environment/OS, in a
+        # single requirements file.
         if install_req.link and install_req.link.is_wheel:
             wheel = Wheel(install_req.link.filename)
-            if not wheel.supported() and not self.ignore_compatibility:
+            if self.check_supported_wheels and not wheel.supported():
                 raise InstallationError(
                     "%s is not a supported wheel on this platform." %
                     wheel.filename
@@ -81,59 +86,73 @@ class RequirementSet(object):
             "a non direct req should have a parent"
         )
 
+        # Unnamed requirements are scanned again and the requirement won't be
+        # added as a dependency until after scanning.
         if not name:
             # url or path requirement w/o an egg fragment
             self.unnamed_requirements.append(install_req)
             return [install_req], None
-        else:
-            try:
-                existing_req = self.get_requirement(name)
-            except KeyError:
-                existing_req = None
-            if (parent_req_name is None and existing_req and not
-                    existing_req.constraint and
-                    existing_req.extras == install_req.extras and not
-                    existing_req.req.specifier == install_req.req.specifier):
-                raise InstallationError(
-                    'Double requirement given: %s (already in %s, name=%r)'
-                    % (install_req, existing_req, name))
-            if not existing_req:
-                # Add requirement
-                self.requirements[name] = install_req
-                # FIXME: what about other normalizations?  E.g., _ vs. -?
-                if name.lower() != name:
-                    self.requirement_aliases[name.lower()] = name
-                result = [install_req]
-            else:
-                # Assume there's no need to scan, and that we've already
-                # encountered this for scanning.
-                result = []
-                if not install_req.constraint and existing_req.constraint:
-                    if (install_req.link and not (existing_req.link and
-                       install_req.link.path == existing_req.link.path)):
-                        self.reqs_to_cleanup.append(install_req)
-                        raise InstallationError(
-                            "Could not satisfy constraints for '%s': "
-                            "installation from path or url cannot be "
-                            "constrained to a version" % name,
-                        )
-                    # If we're now installing a constraint, mark the existing
-                    # object for real installation.
-                    existing_req.constraint = False
-                    existing_req.extras = tuple(
-                        sorted(set(existing_req.extras).union(
-                               set(install_req.extras))))
-                    logger.debug("Setting %s extras to: %s",
-                                 existing_req, existing_req.extras)
-                    # And now we need to scan this.
-                    result = [existing_req]
-                # Canonicalise to the already-added object for the backref
-                # check below.
-                install_req = existing_req
 
-            # We return install_req here to allow for the caller to add it to
-            # the dependency information for the parent package.
-            return result, install_req
+        try:
+            existing_req = self.get_requirement(name)
+        except KeyError:
+            existing_req = None
+
+        has_conflicting_requirement = (
+            parent_req_name is None and
+            existing_req and
+            not existing_req.constraint and
+            existing_req.extras == install_req.extras and
+            existing_req.req.specifier != install_req.req.specifier
+        )
+        if has_conflicting_requirement:
+            raise InstallationError(
+                "Double requirement given: %s (already in %s, name=%r)"
+                % (install_req, existing_req, name)
+            )
+
+        # When no existing requirement exists, add the requirement as a
+        # dependency and it will be scanned again after.
+        if not existing_req:
+            self.requirements[name] = install_req
+            # FIXME: what about other normalizations?  E.g., _ vs. -?
+            if name.lower() != name:
+                self.requirement_aliases[name.lower()] = name
+            # We'd want to rescan this requirements later
+            return [install_req], install_req
+
+        # Assume there's no need to scan, and that we've already
+        # encountered this for scanning.
+        if install_req.constraint or not existing_req.constraint:
+            return [], existing_req
+
+        does_not_satisfy_constraint = (
+            install_req.link and
+            not (
+                existing_req.link and
+                install_req.link.path == existing_req.link.path
+            )
+        )
+        if does_not_satisfy_constraint:
+            self.reqs_to_cleanup.append(install_req)
+            raise InstallationError(
+                "Could not satisfy constraints for '%s': "
+                "installation from path or url cannot be "
+                "constrained to a version" % name,
+            )
+        # If we're now installing a constraint, mark the existing
+        # object for real installation.
+        existing_req.constraint = False
+        existing_req.extras = tuple(sorted(
+            set(existing_req.extras) | set(install_req.extras)
+        ))
+        logger.debug(
+            "Setting %s extras to: %s",
+            existing_req, existing_req.extras,
+        )
+        # Return the existing requirement for addition to the parent and
+        # scanning again.
+        return [existing_req], existing_req
 
     def has_requirement(self, project_name):
         name = project_name.lower()
@@ -155,7 +174,7 @@ class RequirementSet(object):
                 return self.requirements[name]
             if name in self.requirement_aliases:
                 return self.requirements[self.requirement_aliases[name]]
-        # raise KeyError("No project with the name %r" % project_name)
+        pass
 
     def cleanup_files(self):
         """Clean up files, remove builds."""
diff --git a/pipenv/patched/notpip/_internal/req/req_tracker.py b/pipenv/patched/notpip/_internal/req/req_tracker.py
new file mode 100644
index 00000000..6e0201fe
--- /dev/null
+++ b/pipenv/patched/notpip/_internal/req/req_tracker.py
@@ -0,0 +1,76 @@
+from __future__ import absolute_import
+
+import contextlib
+import errno
+import hashlib
+import logging
+import os
+
+from pipenv.patched.notpip._internal.utils.temp_dir import TempDirectory
+
+logger = logging.getLogger(__name__)
+
+
+class RequirementTracker(object):
+
+    def __init__(self):
+        self._root = os.environ.get('PIP_REQ_TRACKER')
+        if self._root is None:
+            self._temp_dir = TempDirectory(delete=False, kind='req-tracker')
+            self._temp_dir.create()
+            self._root = os.environ['PIP_REQ_TRACKER'] = self._temp_dir.path
+            logger.debug('Created requirements tracker %r', self._root)
+        else:
+            self._temp_dir = None
+            logger.debug('Re-using requirements tracker %r', self._root)
+        self._entries = set()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.cleanup()
+
+    def _entry_path(self, link):
+        hashed = hashlib.sha224(link.url_without_fragment.encode()).hexdigest()
+        return os.path.join(self._root, hashed)
+
+    def add(self, req):
+        link = req.link
+        info = str(req)
+        entry_path = self._entry_path(link)
+        try:
+            with open(entry_path) as fp:
+                # Error, these's already a build in progress.
+                raise LookupError('%s is already being built: %s'
+                                  % (link, fp.read()))
+        except IOError as e:
+            if e.errno != errno.ENOENT:
+                raise
+            assert req not in self._entries
+            with open(entry_path, 'w') as fp:
+                fp.write(info)
+            self._entries.add(req)
+            logger.debug('Added %s to build tracker %r', req, self._root)
+
+    def remove(self, req):
+        link = req.link
+        self._entries.remove(req)
+        os.unlink(self._entry_path(link))
+        logger.debug('Removed %s from build tracker %r', req, self._root)
+
+    def cleanup(self):
+        for req in set(self._entries):
+            self.remove(req)
+        remove = self._temp_dir is not None
+        if remove:
+            self._temp_dir.cleanup()
+        logger.debug('%s build tracker %r',
+                     'Removed' if remove else 'Cleaned',
+                     self._root)
+
+    @contextlib.contextmanager
+    def track(self, req):
+        self.add(req)
+        yield
+        self.remove(req)
diff --git a/pipenv/patched/notpip/_internal/req/req_uninstall.py b/pipenv/patched/notpip/_internal/req/req_uninstall.py
index 0104a09e..4cd15d84 100644
--- a/pipenv/patched/notpip/_internal/req/req_uninstall.py
+++ b/pipenv/patched/notpip/_internal/req/req_uninstall.py
@@ -9,9 +9,9 @@ import sysconfig
 
 from pipenv.patched.notpip._vendor import pkg_resources
 
-from pipenv.patched.notpip._internal.compat import WINDOWS, cache_from_source, uses_pycache
 from pipenv.patched.notpip._internal.exceptions import UninstallationError
 from pipenv.patched.notpip._internal.locations import bin_py, bin_user
+from pipenv.patched.notpip._internal.utils.compat import WINDOWS, cache_from_source, uses_pycache
 from pipenv.patched.notpip._internal.utils.logging import indent_log
 from pipenv.patched.notpip._internal.utils.misc import (
     FakeFile, ask, dist_in_usersite, dist_is_local, egg_link_path, is_local,
@@ -57,12 +57,12 @@ def _unique(fn):
 @_unique
 def uninstallation_paths(dist):
     """
-    Yield all the uninstallation paths for dist based on RECORD-without-.pyc
+    Yield all the uninstallation paths for dist based on RECORD-without-.py[co]
 
     Yield paths to all the files in RECORD. For each .py file in RECORD, add
-    the .pyc in the same directory.
+    the .pyc and .pyo in the same directory.
 
-    UninstallPathSet.add() takes care of the __pycache__ .pyc.
+    UninstallPathSet.add() takes care of the __pycache__ .py[co].
     """
     r = csv.reader(FakeFile(dist.get_metadata_lines('RECORD')))
     for row in r:
@@ -73,6 +73,8 @@ def uninstallation_paths(dist):
             base = fn[:-3]
             path = os.path.join(dn, base + '.pyc')
             yield path
+            path = os.path.join(dn, base + '.pyo')
+            yield path
 
 
 def compact(paths):
@@ -118,6 +120,8 @@ def compress_for_output_listing(paths):
             folders.add(os.path.dirname(path))
         files.add(path)
 
+    _normcased_files = set(map(os.path.normcase, files))
+
     folders = compact(folders)
 
     # This walks the tree using os.walk to not miss extra folders
@@ -128,8 +132,9 @@ def compress_for_output_listing(paths):
                 if fname.endswith(".pyc"):
                     continue
 
-                file_ = os.path.normcase(os.path.join(dirpath, fname))
-                if os.path.isfile(file_) and file_ not in files:
+                file_ = os.path.join(dirpath, fname)
+                if (os.path.isfile(file_) and
+                        os.path.normcase(file_) not in _normcased_files):
                     # We are skipping this file. Add it to the set.
                     will_skip.add(file_)
 
diff --git a/pipenv/patched/notpip/_internal/resolve.py b/pipenv/patched/notpip/_internal/resolve.py
index 5b3d0c00..b0d096f9 100644
--- a/pipenv/patched/notpip/_internal/resolve.py
+++ b/pipenv/patched/notpip/_internal/resolve.py
@@ -18,8 +18,7 @@ from pipenv.patched.notpip._internal.exceptions import (
     BestVersionAlreadyInstalled, DistributionNotFound, HashError, HashErrors,
     UnsupportedPythonVersion,
 )
-
-from pipenv.patched.notpip._internal.req.req_install import InstallRequirement
+from pipenv.patched.notpip._internal.req.constructors import install_req_from_req
 from pipenv.patched.notpip._internal.utils.logging import indent_log
 from pipenv.patched.notpip._internal.utils.misc import dist_in_usersite, ensure_dir
 from pipenv.patched.notpip._internal.utils.packaging import check_dist_requires_python
@@ -164,7 +163,7 @@ class Resolver(object):
 
         if not self._is_upgrade_allowed(req_to_install):
             if self.upgrade_strategy == "only-if-needed":
-                return 'not upgraded as not directly required'
+                return 'already satisfied, skipping upgrade'
             return 'already satisfied'
 
         # Check for the possibility of an upgrade.  For link-based
@@ -250,9 +249,6 @@ class Resolver(object):
         # Tell user what we are doing for this requirement:
         # obtain (editable), skipping, processing (local url), collecting
         # (remote url or package name)
-        if ignore_requires_python or self.ignore_requires_python:
-            self.ignore_compatibility = True
-
         if req_to_install.constraint or req_to_install.prepared:
             return []
 
@@ -268,7 +264,7 @@ class Resolver(object):
         try:
             check_dist_requires_python(dist)
         except UnsupportedPythonVersion as err:
-            if self.ignore_compatibility:
+            if self.ignore_requires_python or self.ignore_compatibility:
                 logger.warning(err.args[0])
             else:
                 raise
@@ -282,7 +278,7 @@ class Resolver(object):
         more_reqs = []
 
         def add_req(subreq, extras_requested):
-            sub_install_req = InstallRequirement.from_req(
+            sub_install_req = install_req_from_req(
                 str(subreq),
                 req_to_install,
                 isolated=self.isolated,
@@ -304,10 +300,10 @@ class Resolver(object):
             # We add req_to_install before its dependencies, so that we
             # can refer to it when adding dependencies.
             if not requirement_set.has_requirement(req_to_install.name):
+                # 'unnamed' requirements will get added here
                 available_requested = sorted(
                     set(dist.extras) & set(req_to_install.extras)
                 )
-                # 'unnamed' requirements will get added here
                 req_to_install.is_direct = True
                 requirement_set.add_requirement(
                     req_to_install, parent_req_name=None,
@@ -339,7 +335,7 @@ class Resolver(object):
                 for available in available_requested:
                     if hasattr(dist, '_DistInfoDistribution__dep_map'):
                         for req in dist._DistInfoDistribution__dep_map[available]:
-                            req = InstallRequirement.from_req(
+                            req = install_req_from_req(
                                 str(req),
                                 req_to_install,
                                 isolated=self.isolated,
diff --git a/pipenv/patched/notpip/_internal/utils/appdirs.py b/pipenv/patched/notpip/_internal/utils/appdirs.py
index 291de7a9..e8e14526 100644
--- a/pipenv/patched/notpip/_internal/utils/appdirs.py
+++ b/pipenv/patched/notpip/_internal/utils/appdirs.py
@@ -9,7 +9,7 @@ import sys
 
 from pipenv.patched.notpip._vendor.six import PY2, text_type
 
-from pipenv.patched.notpip._internal.compat import WINDOWS, expanduser
+from pipenv.patched.notpip._internal.utils.compat import WINDOWS, expanduser
 
 
 def user_cache_dir(appname):
diff --git a/pipenv/patched/notpip/_internal/compat.py b/pipenv/patched/notpip/_internal/utils/compat.py
similarity index 94%
rename from pipenv/patched/notpip/_internal/compat.py
rename to pipenv/patched/notpip/_internal/utils/compat.py
index 3407880c..483bfdc8 100644
--- a/pipenv/patched/notpip/_internal/compat.py
+++ b/pipenv/patched/notpip/_internal/utils/compat.py
@@ -25,6 +25,7 @@ except ImportError:
 __all__ = [
     "ipaddress", "uses_pycache", "console_to_str", "native_str",
     "get_path_uid", "stdlib_pkgs", "WINDOWS", "samefile", "get_terminal_size",
+    "get_extension_suffixes",
 ]
 
 
@@ -160,11 +161,23 @@ def get_path_uid(path):
     return file_uid
 
 
+if sys.version_info >= (3, 4):
+    from importlib.machinery import EXTENSION_SUFFIXES
+
+    def get_extension_suffixes():
+        return EXTENSION_SUFFIXES
+else:
+    from imp import get_suffixes
+
+    def get_extension_suffixes():
+        return [suffix[0] for suffix in get_suffixes()]
+
+
 def expanduser(path):
     """
     Expand ~ and ~user constructions.
 
-    Includes a workaround for http://bugs.python.org/issue14768
+    Includes a workaround for https://bugs.python.org/issue14768
     """
     expanded = os.path.expanduser(path)
     if path.startswith('~/') and expanded.startswith('//'):
@@ -217,7 +230,7 @@ else:
                     'hh',
                     fcntl.ioctl(fd, termios.TIOCGWINSZ, '12345678')
                 )
-            except:
+            except Exception:
                 return None
             if cr == (0, 0):
                 return None
@@ -228,7 +241,7 @@ else:
                 fd = os.open(os.ctermid(), os.O_RDONLY)
                 cr = ioctl_GWINSZ(fd)
                 os.close(fd)
-            except:
+            except Exception:
                 pass
         if not cr:
             cr = (os.environ.get('LINES', 25), os.environ.get('COLUMNS', 80))
diff --git a/pipenv/patched/notpip/_internal/utils/deprecation.py b/pipenv/patched/notpip/_internal/utils/deprecation.py
index e5ab59ab..b140ac71 100644
--- a/pipenv/patched/notpip/_internal/utils/deprecation.py
+++ b/pipenv/patched/notpip/_internal/utils/deprecation.py
@@ -6,72 +6,84 @@ from __future__ import absolute_import
 import logging
 import warnings
 
+from pipenv.patched.notpip._vendor.packaging.version import parse
+
+from pipenv.patched.notpip import __version__ as current_version
 from pipenv.patched.notpip._internal.utils.typing import MYPY_CHECK_RUNNING
 
 if MYPY_CHECK_RUNNING:
-    from typing import Any
+    from typing import Any, Optional  # noqa: F401
 
 
 class PipDeprecationWarning(Warning):
     pass
 
 
-class Pending(object):
-    pass
-
-
-class RemovedInPip11Warning(PipDeprecationWarning):
-    pass
-
-
-class RemovedInPip12Warning(PipDeprecationWarning, Pending):
-    pass
+_original_showwarning = None  # type: Any
 
 
 # Warnings <-> Logging Integration
-
-
-_warnings_showwarning = None  # type: Any
-
-
 def _showwarning(message, category, filename, lineno, file=None, line=None):
     if file is not None:
-        if _warnings_showwarning is not None:
-            _warnings_showwarning(
+        if _original_showwarning is not None:
+            _original_showwarning(
                 message, category, filename, lineno, file, line,
             )
+    elif issubclass(category, PipDeprecationWarning):
+        # We use a specially named logger which will handle all of the
+        # deprecation messages for pip.
+        logger = logging.getLogger("pip._internal.deprecations")
+        logger.warning(message)
     else:
-        if issubclass(category, PipDeprecationWarning):
-            # We use a specially named logger which will handle all of the
-            # deprecation messages for pip.
-            logger = logging.getLogger("pip._internal.deprecations")
-
-            # This is purposely using the % formatter here instead of letting
-            # the logging module handle the interpolation. This is because we
-            # want it to appear as if someone typed this entire message out.
-            log_message = "DEPRECATION: %s" % message
-
-            # PipDeprecationWarnings that are Pending still have at least 2
-            # versions to go until they are removed so they can just be
-            # warnings.  Otherwise, they will be removed in the very next
-            # version of pip. We want these to be more obvious so we use the
-            # ERROR logging level.
-            if issubclass(category, Pending):
-                logger.warning(log_message)
-            else:
-                logger.error(log_message)
-        else:
-            _warnings_showwarning(
-                message, category, filename, lineno, file, line,
-            )
+        _original_showwarning(
+            message, category, filename, lineno, file, line,
+        )
 
 
 def install_warning_logger():
     # Enable our Deprecation Warnings
     warnings.simplefilter("default", PipDeprecationWarning, append=True)
 
-    global _warnings_showwarning
+    global _original_showwarning
 
-    if _warnings_showwarning is None:
-        _warnings_showwarning = warnings.showwarning
+    if _original_showwarning is None:
+        _original_showwarning = warnings.showwarning
         warnings.showwarning = _showwarning
+
+
+def deprecated(reason, replacement, gone_in, issue=None):
+    # type: (str, Optional[str], Optional[str], Optional[int]) -> None
+    """Helper to deprecate existing functionality.
+
+    reason:
+        Textual reason shown to the user about why this functionality has
+        been deprecated.
+    replacement:
+        Textual suggestion shown to the user about what alternative
+        functionality they can use.
+    gone_in:
+        The version of pip does this functionality should get removed in.
+        Raises errors if pip's current version is greater than or equal to
+        this.
+    issue:
+        Issue number on the tracker that would serve as a useful place for
+        users to find related discussion and provide feedback.
+
+    Always pass replacement, gone_in and issue as keyword arguments for clarity
+    at the call site.
+    """
+
+    # Construct a nice message.
+    # This is purposely eagerly formatted as we want it to appear as if someone
+    # typed this entire message out.
+    message = "DEPRECATION: " + reason
+    if replacement is not None:
+        message += " A possible replacement is {}.".format(replacement)
+    if issue is not None:
+        url = "https://github.com/pypa/pip/issues/" + str(issue)
+        message += " You can find discussion regarding this at {}.".format(url)
+
+    # Raise as an error if it has to be removed.
+    if gone_in is not None and parse(current_version) >= parse(gone_in):
+        raise PipDeprecationWarning(message)
+    warnings.warn(message, category=PipDeprecationWarning, stacklevel=2)
diff --git a/pipenv/patched/notpip/_internal/utils/filesystem.py b/pipenv/patched/notpip/_internal/utils/filesystem.py
index 91976486..e8d6a2bb 100644
--- a/pipenv/patched/notpip/_internal/utils/filesystem.py
+++ b/pipenv/patched/notpip/_internal/utils/filesystem.py
@@ -1,7 +1,7 @@
 import os
 import os.path
 
-from pipenv.patched.notpip._internal.compat import get_path_uid
+from pipenv.patched.notpip._internal.utils.compat import get_path_uid
 
 
 def check_path_owner(path):
diff --git a/pipenv/patched/notpip/_internal/utils/logging.py b/pipenv/patched/notpip/_internal/utils/logging.py
index 5864fe14..576c4fa0 100644
--- a/pipenv/patched/notpip/_internal/utils/logging.py
+++ b/pipenv/patched/notpip/_internal/utils/logging.py
@@ -5,7 +5,7 @@ import logging
 import logging.handlers
 import os
 
-from pipenv.patched.notpip._internal.compat import WINDOWS
+from pipenv.patched.notpip._internal.utils.compat import WINDOWS
 from pipenv.patched.notpip._internal.utils.misc import ensure_dir
 
 try:
@@ -97,7 +97,7 @@ class ColorizedStreamHandler(logging.StreamHandler):
         if hasattr(real_stream, "isatty") and real_stream.isatty():
             return True
 
-        # If we have an ASNI term we should color it
+        # If we have an ANSI term we should color it
         if os.environ.get("TERM") == "ANSI":
             return True
 
@@ -130,3 +130,96 @@ class MaxLevelFilter(logging.Filter):
 
     def filter(self, record):
         return record.levelno < self.level
+
+
+def setup_logging(verbosity, no_color, user_log_file):
+    """Configures and sets up all of the logging
+    """
+
+    # Determine the level to be logging at.
+    if verbosity >= 1:
+        level = "DEBUG"
+    elif verbosity == -1:
+        level = "WARNING"
+    elif verbosity == -2:
+        level = "ERROR"
+    elif verbosity <= -3:
+        level = "CRITICAL"
+    else:
+        level = "INFO"
+
+    # The "root" logger should match the "console" level *unless* we also need
+    # to log to a user log file.
+    include_user_log = user_log_file is not None
+    if include_user_log:
+        additional_log_file = user_log_file
+        root_level = "DEBUG"
+    else:
+        additional_log_file = "/dev/null"
+        root_level = level
+
+    # Disable any logging besides WARNING unless we have DEBUG level logging
+    # enabled for vendored libraries.
+    vendored_log_level = "WARNING" if level in ["INFO", "ERROR"] else "DEBUG"
+
+    # Shorthands for clarity
+    log_streams = {
+        "stdout": "ext://sys.stdout",
+        "stderr": "ext://sys.stderr",
+    }
+    handler_classes = {
+        "stream": "pip._internal.utils.logging.ColorizedStreamHandler",
+        "file": "pip._internal.utils.logging.BetterRotatingFileHandler",
+    }
+
+    logging.config.dictConfig({
+        "version": 1,
+        "disable_existing_loggers": False,
+        "filters": {
+            "exclude_warnings": {
+                "()": "pip._internal.utils.logging.MaxLevelFilter",
+                "level": logging.WARNING,
+            },
+        },
+        "formatters": {
+            "indent": {
+                "()": IndentingFormatter,
+                "format": "%(message)s",
+            },
+        },
+        "handlers": {
+            "console": {
+                "level": level,
+                "class": handler_classes["stream"],
+                "no_color": no_color,
+                "stream": log_streams["stdout"],
+                "filters": ["exclude_warnings"],
+                "formatter": "indent",
+            },
+            "console_errors": {
+                "level": "WARNING",
+                "class": handler_classes["stream"],
+                "no_color": no_color,
+                "stream": log_streams["stderr"],
+                "formatter": "indent",
+            },
+            "user_log": {
+                "level": "DEBUG",
+                "class": handler_classes["file"],
+                "filename": additional_log_file,
+                "delay": True,
+                "formatter": "indent",
+            },
+        },
+        "root": {
+            "level": root_level,
+            "handlers": ["console", "console_errors"] + (
+                ["user_log"] if include_user_log else []
+            ),
+        },
+        "loggers": {
+            "pip._vendor": {
+                "level": vendored_log_level
+            }
+        },
+    })
diff --git a/pipenv/patched/notpip/_internal/utils/misc.py b/pipenv/patched/notpip/_internal/utils/misc.py
index 459b309a..45e5204c 100644
--- a/pipenv/patched/notpip/_internal/utils/misc.py
+++ b/pipenv/patched/notpip/_internal/utils/misc.py
@@ -24,13 +24,16 @@ from pipenv.patched.notpip._vendor import pkg_resources
 from pipenv.patched.notpip._vendor.retrying import retry  # type: ignore
 from pipenv.patched.notpip._vendor.six import PY2
 from pipenv.patched.notpip._vendor.six.moves import input
+from pipenv.patched.notpip._vendor.six.moves.urllib import parse as urllib_parse
 
-from pipenv.patched.notpip._internal.compat import console_to_str, expanduser, stdlib_pkgs
-from pipenv.patched.notpip._internal.exceptions import InstallationError
+from pipenv.patched.notpip._internal.exceptions import CommandError, InstallationError
 from pipenv.patched.notpip._internal.locations import (
     running_under_virtualenv, site_packages, user_site, virtualenv_no_global,
     write_delete_marker_file,
 )
+from pipenv.patched.notpip._internal.utils.compat import (
+    WINDOWS, console_to_str, expanduser, stdlib_pkgs,
+)
 
 if PY2:
     from io import BytesIO as StringIO
@@ -47,7 +50,7 @@ __all__ = ['rmtree', 'display_path', 'backup_dir',
            'unzip_file', 'untar_file', 'unpack_file', 'call_subprocess',
            'captured_stdout', 'ensure_dir',
            'ARCHIVE_EXTENSIONS', 'SUPPORTED_EXTENSIONS',
-           'get_installed_version']
+           'get_installed_version', 'remove_auth_from_url']
 
 
 logger = std_logging.getLogger(__name__)
@@ -93,7 +96,7 @@ def get_prog():
     try:
         prog = os.path.basename(sys.argv[0])
         if prog in ('__main__.py', '-c'):
-            return "%s -m pip" % os.environ.get('PIP_PYTHON_PATH', sys.executable)
+            return "%s -m pip" % sys.executable
         else:
             return prog
     except (AttributeError, TypeError, IndexError):
@@ -184,12 +187,16 @@ def format_size(bytes):
 
 
 def is_installable_dir(path):
-    """Return True if `path` is a directory containing a setup.py file."""
+    """Is path is a directory containing setup.py or pyproject.toml?
+    """
     if not os.path.isdir(path):
         return False
     setup_py = os.path.join(path, 'setup.py')
     if os.path.isfile(setup_py):
         return True
+    pyproject_toml = os.path.join(path, 'pyproject.toml')
+    if os.path.isfile(pyproject_toml):
+        return True
     return False
 
 
@@ -818,17 +825,15 @@ class cached_property(object):
         return value
 
 
-def get_installed_version(dist_name, lookup_dirs=None):
+def get_installed_version(dist_name, working_set=None):
     """Get the installed version of dist_name avoiding pkg_resources cache"""
     # Create a requirement that we'll look for inside of setuptools.
     req = pkg_resources.Requirement.parse(dist_name)
 
-    # We want to avoid having this cached, so we need to construct a new
-    # working set each time.
-    if lookup_dirs is None:
+    if working_set is None:
+        # We want to avoid having this cached, so we need to construct a new
+        # working set each time.
         working_set = pkg_resources.WorkingSet()
-    else:
-        working_set = pkg_resources.WorkingSet(lookup_dirs)
 
     # Get the installed distribution from our working set
     dist = working_set.find(req)
@@ -849,3 +854,87 @@ def enum(*sequential, **named):
     reverse = {value: key for key, value in enums.items()}
     enums['reverse_mapping'] = reverse
     return type('Enum', (), enums)
+
+
+def make_vcs_requirement_url(repo_url, rev, egg_project_name, subdir=None):
+    """
+    Return the URL for a VCS requirement.
+
+    Args:
+      repo_url: the remote VCS url, with any needed VCS prefix (e.g. "git+").
+    """
+    req = '{}@{}#egg={}'.format(repo_url, rev, egg_project_name)
+    if subdir:
+        req += '&subdirectory={}'.format(subdir)
+
+    return req
+
+
+def split_auth_from_netloc(netloc):
+    """
+    Parse out and remove the auth information from a netloc.
+
+    Returns: (netloc, (username, password)).
+    """
+    if '@' not in netloc:
+        return netloc, (None, None)
+
+    # Split from the right because that's how urllib.parse.urlsplit()
+    # behaves if more than one @ is present (which can be checked using
+    # the password attribute of urlsplit()'s return value).
+    auth, netloc = netloc.rsplit('@', 1)
+    if ':' in auth:
+        # Split from the left because that's how urllib.parse.urlsplit()
+        # behaves if more than one : is present (which again can be checked
+        # using the password attribute of the return value)
+        user_pass = tuple(auth.split(':', 1))
+    else:
+        user_pass = auth, None
+
+    return netloc, user_pass
+
+
+def remove_auth_from_url(url):
+    # Return a copy of url with 'username:password@' removed.
+    # username/pass params are passed to subversion through flags
+    # and are not recognized in the url.
+
+    # parsed url
+    purl = urllib_parse.urlsplit(url)
+    netloc, user_pass = split_auth_from_netloc(purl.netloc)
+
+    # stripped url
+    url_pieces = (
+        purl.scheme, netloc, purl.path, purl.query, purl.fragment
+    )
+    surl = urllib_parse.urlunsplit(url_pieces)
+    return surl
+
+
+def protect_pip_from_modification_on_windows(modifying_pip):
+    """Protection of pip.exe from modification on Windows
+
+    On Windows, any operation modifying pip should be run as:
+        python -m pip ...
+    """
+    pip_names = [
+        "pip.exe",
+        "pip{}.exe".format(sys.version_info[0]),
+        "pip{}.{}.exe".format(*sys.version_info[:2])
+    ]
+
+    # See https://github.com/pypa/pip/issues/1299 for more discussion
+    should_show_use_python_msg = (
+        modifying_pip and
+        WINDOWS and
+        os.path.basename(sys.argv[0]) in pip_names
+    )
+
+    if should_show_use_python_msg:
+        new_command = [
+            sys.executable, "-m", "pip"
+        ] + sys.argv[1:]
+        raise CommandError(
+            'To modify pip, please run the following command:\n{}'
+            .format(" ".join(new_command))
+        )
diff --git a/pipenv/patched/notpip/_internal/utils/models.py b/pipenv/patched/notpip/_internal/utils/models.py
new file mode 100644
index 00000000..d5cb80a7
--- /dev/null
+++ b/pipenv/patched/notpip/_internal/utils/models.py
@@ -0,0 +1,40 @@
+"""Utilities for defining models
+"""
+
+import operator
+
+
+class KeyBasedCompareMixin(object):
+    """Provides comparision capabilities that is based on a key
+    """
+
+    def __init__(self, key, defining_class):
+        self._compare_key = key
+        self._defining_class = defining_class
+
+    def __hash__(self):
+        return hash(self._compare_key)
+
+    def __lt__(self, other):
+        return self._compare(other, operator.__lt__)
+
+    def __le__(self, other):
+        return self._compare(other, operator.__le__)
+
+    def __gt__(self, other):
+        return self._compare(other, operator.__gt__)
+
+    def __ge__(self, other):
+        return self._compare(other, operator.__ge__)
+
+    def __eq__(self, other):
+        return self._compare(other, operator.__eq__)
+
+    def __ne__(self, other):
+        return self._compare(other, operator.__ne__)
+
+    def _compare(self, other, method):
+        if not isinstance(other, self._defining_class):
+            return NotImplemented
+
+        return method(self._compare_key, other._compare_key)
diff --git a/pipenv/patched/notpip/_internal/utils/outdated.py b/pipenv/patched/notpip/_internal/utils/outdated.py
index 87911380..f8b1fe04 100644
--- a/pipenv/patched/notpip/_internal/utils/outdated.py
+++ b/pipenv/patched/notpip/_internal/utils/outdated.py
@@ -6,12 +6,11 @@ import logging
 import os.path
 import sys
 
-from pipenv.patched.notpip._vendor import lockfile
+from pipenv.patched.notpip._vendor import lockfile, pkg_resources
 from pipenv.patched.notpip._vendor.packaging import version as packaging_version
 
-from pipenv.patched.notpip._internal.compat import WINDOWS
 from pipenv.patched.notpip._internal.index import PackageFinder
-from pipenv.patched.notpip._internal.locations import USER_CACHE_DIR, running_under_virtualenv
+from pipenv.patched.notpip._internal.utils.compat import WINDOWS
 from pipenv.patched.notpip._internal.utils.filesystem import check_path_owner
 from pipenv.patched.notpip._internal.utils.misc import ensure_dir, get_installed_version
 
@@ -21,43 +20,27 @@ SELFCHECK_DATE_FMT = "%Y-%m-%dT%H:%M:%SZ"
 logger = logging.getLogger(__name__)
 
 
-class VirtualenvSelfCheckState(object):
-    def __init__(self):
-        self.statefile_path = os.path.join(sys.prefix, "pip-selfcheck.json")
+class SelfCheckState(object):
+    def __init__(self, cache_dir):
+        self.state = {}
+        self.statefile_path = None
 
-        # Load the existing state
-        try:
-            with open(self.statefile_path) as statefile:
-                self.state = json.load(statefile)
-        except (IOError, ValueError):
-            self.state = {}
+        # Try to load the existing state
+        if cache_dir:
+            self.statefile_path = os.path.join(cache_dir, "selfcheck.json")
+            try:
+                with open(self.statefile_path) as statefile:
+                    self.state = json.load(statefile)[sys.prefix]
+            except (IOError, ValueError, KeyError):
+                # Explicitly suppressing exceptions, since we don't want to
+                # error out if the cache file is invalid.
+                pass
 
     def save(self, pypi_version, current_time):
-        # Attempt to write out our version check file
-        with open(self.statefile_path, "w") as statefile:
-            json.dump(
-                {
-                    "last_check": current_time.strftime(SELFCHECK_DATE_FMT),
-                    "pypi_version": pypi_version,
-                },
-                statefile,
-                sort_keys=True,
-                separators=(",", ":")
-            )
+        # If we do not have a path to cache in, don't bother saving.
+        if not self.statefile_path:
+            return
 
-
-class GlobalSelfCheckState(object):
-    def __init__(self):
-        self.statefile_path = os.path.join(USER_CACHE_DIR, "selfcheck.json")
-
-        # Load the existing state
-        try:
-            with open(self.statefile_path) as statefile:
-                self.state = json.load(statefile)[sys.prefix]
-        except (IOError, ValueError, KeyError):
-            self.state = {}
-
-    def save(self, pypi_version, current_time):
         # Check to make sure that we own the directory
         if not check_path_owner(os.path.dirname(self.statefile_path)):
             return
@@ -84,11 +67,18 @@ class GlobalSelfCheckState(object):
                           separators=(",", ":"))
 
 
-def load_selfcheck_statefile():
-    if running_under_virtualenv():
-        return VirtualenvSelfCheckState()
-    else:
-        return GlobalSelfCheckState()
+def was_installed_by_pip(pkg):
+    """Checks whether pkg was installed by pip
+
+    This is used not to display the upgrade message when pip is in fact
+    installed by system package manager, such as dnf on Fedora.
+    """
+    try:
+        dist = pkg_resources.get_distribution(pkg)
+        return (dist.has_metadata('INSTALLER') and
+                'pip' in dist.get_metadata_lines('INSTALLER'))
+    except pkg_resources.DistributionNotFound:
+        return False
 
 
 def pip_version_check(session, options):
@@ -106,7 +96,7 @@ def pip_version_check(session, options):
     pypi_version = None
 
     try:
-        state = load_selfcheck_statefile()
+        state = SelfCheckState(cache_dir=options.cache_dir)
 
         current_time = datetime.datetime.utcnow()
         # Determine if we need to refresh the state
@@ -143,7 +133,8 @@ def pip_version_check(session, options):
 
         # Determine if our pypi_version is older
         if (pip_version < remote_version and
-                pip_version.base_version != remote_version.base_version):
+                pip_version.base_version != remote_version.base_version and
+                was_installed_by_pip('pip')):
             # Advise "python -m pip" on Windows to avoid issues
             # with overwriting pip.exe.
             if WINDOWS:
diff --git a/pipenv/patched/notpip/_internal/utils/packaging.py b/pipenv/patched/notpip/_internal/utils/packaging.py
index eee21469..d1e8ecaa 100644
--- a/pipenv/patched/notpip/_internal/utils/packaging.py
+++ b/pipenv/patched/notpip/_internal/utils/packaging.py
@@ -1,7 +1,6 @@
 from __future__ import absolute_import
 
 import logging
-import os
 import sys
 from email.parser import FeedParser  # type: ignore
 
@@ -9,6 +8,7 @@ from pipenv.patched.notpip._vendor import pkg_resources
 from pipenv.patched.notpip._vendor.packaging import specifiers, version
 
 from pipenv.patched.notpip._internal import exceptions
+from pipenv.patched.notpip._internal.utils.misc import display_path
 
 logger = logging.getLogger(__name__)
 
@@ -36,28 +36,31 @@ def check_requires_python(requires_python):
 def get_metadata(dist):
     if (isinstance(dist, pkg_resources.DistInfoDistribution) and
             dist.has_metadata('METADATA')):
-        return dist.get_metadata('METADATA')
+        metadata = dist.get_metadata('METADATA')
     elif dist.has_metadata('PKG-INFO'):
-        return dist.get_metadata('PKG-INFO')
+        metadata = dist.get_metadata('PKG-INFO')
+    else:
+        logger.warning("No metadata found in %s", display_path(dist.location))
+        metadata = ''
+
+    feed_parser = FeedParser()
+    feed_parser.feed(metadata)
+    return feed_parser.close()
 
 
 def check_dist_requires_python(dist, absorb=True):
-    metadata = get_metadata(dist)
-    feed_parser = FeedParser()
-    feed_parser.feed(metadata)
-    pkg_info_dict = feed_parser.close()
+    pkg_info_dict = get_metadata(dist)
     requires_python = pkg_info_dict.get('Requires-Python')
-    if not absorb:
+    if absorb:
         return requires_python
     try:
         if not check_requires_python(requires_python):
-            # raise exceptions.UnsupportedPythonVersion(
-            #     "%s requires Python '%s' but the running Python is %s" % (
-            #         dist.project_name,
-            #         requires_python,
-            #         '.'.join(map(str, sys.version_info[:3])),)
-            # )
-            return
+            raise exceptions.UnsupportedPythonVersion(
+                "%s requires Python '%s' but the running Python is %s" % (
+                    dist.project_name,
+                    requires_python,
+                    '.'.join(map(str, sys.version_info[:3])),)
+            )
     except specifiers.InvalidSpecifier as e:
         logger.warning(
             "Package %s has an invalid Requires-Python entry %s - %s",
diff --git a/pipenv/patched/notpip/_internal/utils/temp_dir.py b/pipenv/patched/notpip/_internal/utils/temp_dir.py
index ba472b0d..893dc975 100644
--- a/pipenv/patched/notpip/_internal/utils/temp_dir.py
+++ b/pipenv/patched/notpip/_internal/utils/temp_dir.py
@@ -3,8 +3,10 @@ from __future__ import absolute_import
 import logging
 import os.path
 import tempfile
+import warnings
 
 from pipenv.patched.notpip._internal.utils.misc import rmtree
+from pipenv.vendor.vistir.compat import finalize, ResourceWarning
 
 logger = logging.getLogger(__name__)
 
@@ -45,6 +47,20 @@ class TempDirectory(object):
         self.path = path
         self.delete = delete
         self.kind = kind
+        self._finalizer = None
+        if path:
+            self._register_finalizer()
+
+    def _register_finalizer(self):
+        if self.delete and self.path:
+            self._finalizer = finalize(
+                self,
+                self._cleanup,
+                self.path,
+                warn_message=None
+            )
+        else:
+            self._finalizer = None
 
     def __repr__(self):
         return "<{} {!r}>".format(self.__class__.__name__, self.path)
@@ -72,11 +88,27 @@ class TempDirectory(object):
         self.path = os.path.realpath(
             tempfile.mkdtemp(prefix="pip-{}-".format(self.kind))
         )
+        self._register_finalizer()
         logger.debug("Created temporary directory: {}".format(self.path))
 
+    @classmethod
+    def _cleanup(cls, name, warn_message=None):
+        try:
+            rmtree(name)
+        except OSError:
+            pass
+        else:
+            if warn_message:
+                warnings.warn(warn_message, ResourceWarning)
+
     def cleanup(self):
         """Remove the temporary directory created and reset state
         """
-        if self.path is not None and os.path.exists(self.path):
-            rmtree(self.path)
-        self.path = None
+        if getattr(self._finalizer, "detach", None) and self._finalizer.detach():
+            if os.path.exists(self.path):
+                try:
+                    rmtree(self.path)
+                except OSError:
+                    pass
+                else:
+                    self.path = None
diff --git a/pipenv/patched/notpip/_internal/utils/typing.py b/pipenv/patched/notpip/_internal/utils/typing.py
index 170cc6c0..56f2fa87 100644
--- a/pipenv/patched/notpip/_internal/utils/typing.py
+++ b/pipenv/patched/notpip/_internal/utils/typing.py
@@ -18,10 +18,10 @@ curious maintainer can reach here to read this.
 
 In pip, all static-typing related imports should be guarded as follows:
 
-    from pipenv.patched.notpip.utils.typing import MYPY_CHECK_RUNNING
+    from pipenv.patched.notpip._internal.utils.typing import MYPY_CHECK_RUNNING
 
     if MYPY_CHECK_RUNNING:
-        from typing import ...
+        from typing import ...  # noqa: F401
 
 Ref: https://github.com/python/mypy/issues/3216
 """
diff --git a/pipenv/patched/notpip/_internal/utils/ui.py b/pipenv/patched/notpip/_internal/utils/ui.py
index 2b692a81..6eebd17d 100644
--- a/pipenv/patched/notpip/_internal/utils/ui.py
+++ b/pipenv/patched/notpip/_internal/utils/ui.py
@@ -15,13 +15,13 @@ from pipenv.patched.notpip._vendor.progress.bar import (
 from pipenv.patched.notpip._vendor.progress.helpers import HIDE_CURSOR, SHOW_CURSOR, WritelnMixin
 from pipenv.patched.notpip._vendor.progress.spinner import Spinner
 
-from pipenv.patched.notpip._internal.compat import WINDOWS
+from pipenv.patched.notpip._internal.utils.compat import WINDOWS
 from pipenv.patched.notpip._internal.utils.logging import get_indentation
 from pipenv.patched.notpip._internal.utils.misc import format_size
 from pipenv.patched.notpip._internal.utils.typing import MYPY_CHECK_RUNNING
 
 if MYPY_CHECK_RUNNING:
-    from typing import Any
+    from typing import Any  # noqa: F401
 
 try:
     from pipenv.patched.notpip._vendor import colorama
diff --git a/pipenv/patched/notpip/_internal/vcs/__init__.py b/pipenv/patched/notpip/_internal/vcs/__init__.py
index f115de4c..5aeac633 100644
--- a/pipenv/patched/notpip/_internal/vcs/__init__.py
+++ b/pipenv/patched/notpip/_internal/vcs/__init__.py
@@ -1,7 +1,6 @@
 """Handles all VCS (version control) support"""
 from __future__ import absolute_import
 
-import copy
 import errno
 import logging
 import os
@@ -17,8 +16,8 @@ from pipenv.patched.notpip._internal.utils.misc import (
 from pipenv.patched.notpip._internal.utils.typing import MYPY_CHECK_RUNNING
 
 if MYPY_CHECK_RUNNING:
-    from typing import Dict, Optional, Tuple
-    from pipenv.patched.notpip._internal.basecommand import Command
+    from typing import Dict, Optional, Tuple  # noqa: F401
+    from pipenv.patched.notpip._internal.cli.base_command import Command  # noqa: F401
 
 __all__ = ['vcs', 'get_src_requirement']
 
@@ -201,12 +200,6 @@ class VersionControl(object):
         drive, tail = os.path.splitdrive(repo)
         return repo.startswith(os.path.sep) or drive
 
-    # See issue #1083 for why this method was introduced:
-    # https://github.com/pypa/pip/issues/1083
-    def translate_egg_surname(self, surname):
-        # For example, Django has branches of the form "stable/1.7.x".
-        return surname.replace('/', '_')
-
     def export(self, location):
         """
         Export the repository at the url to the destination location
@@ -214,32 +207,64 @@ class VersionControl(object):
         """
         raise NotImplementedError
 
-    def get_url_rev(self):
+    def get_netloc_and_auth(self, netloc, scheme):
         """
-        Returns the correct repository URL and revision by parsing the given
-        repository URL
+        Parse the repository URL's netloc, and return the new netloc to use
+        along with auth information.
+
+        Args:
+          netloc: the original repository URL netloc.
+          scheme: the repository URL's scheme without the vcs prefix.
+
+        This is mainly for the Subversion class to override, so that auth
+        information can be provided via the --username and --password options
+        instead of through the URL.  For other subclasses like Git without
+        such an option, auth information must stay in the URL.
+
+        Returns: (netloc, (username, password)).
+        """
+        return netloc, (None, None)
+
+    def get_url_rev_and_auth(self, url):
+        """
+        Parse the repository URL to use, and return the URL, revision,
+        and auth info to use.
+
+        Returns: (url, rev, (username, password)).
         """
-        error_message = (
-            "Sorry, '%s' is a malformed VCS url. "
-            "The format is <vcs>+<protocol>://<url>, "
-            "e.g. svn+http://myrepo/svn/MyApp#egg=MyApp"
-        )
-        assert '+' in self.url, error_message % self.url
-        url = self.url.split('+', 1)[1]
         scheme, netloc, path, query, frag = urllib_parse.urlsplit(url)
+        if '+' not in scheme:
+            raise ValueError(
+                "Sorry, {!r} is a malformed VCS url. "
+                "The format is <vcs>+<protocol>://<url>, "
+                "e.g. svn+http://myrepo/svn/MyApp#egg=MyApp".format(url)
+            )
+        # Remove the vcs prefix.
+        scheme = scheme.split('+', 1)[1]
+        netloc, user_pass = self.get_netloc_and_auth(netloc, scheme)
         rev = None
         if '@' in path:
             path, rev = path.rsplit('@', 1)
         url = urllib_parse.urlunsplit((scheme, netloc, path, query, ''))
-        return url, rev
+        return url, rev, user_pass
 
-    def get_info(self, location):
+    def make_rev_args(self, username, password):
         """
-        Returns (url, revision), where both are strings
+        Return the RevOptions "extra arguments" to use in obtain().
         """
-        assert not location.rstrip('/').endswith(self.dirname), \
-            'Bad directory: %s' % location
-        return self.get_url(location), self.get_revision(location)
+        return []
+
+    def get_url_rev_options(self, url):
+        """
+        Return the URL and RevOptions object to use in obtain() and in
+        some cases export(), as a tuple (url, rev_options).
+        """
+        url, rev, user_pass = self.get_url_rev_and_auth(url)
+        username, password = user_pass
+        extra_args = self.make_rev_args(username, password)
+        rev_options = self.make_rev_options(rev, extra_args=extra_args)
+
+        return url, rev_options
 
     def normalize_url(self, url):
         """
@@ -254,10 +279,14 @@ class VersionControl(object):
         """
         return (self.normalize_url(url1) == self.normalize_url(url2))
 
-    def obtain(self, dest):
+    def fetch_new(self, dest, url, rev_options):
         """
-        Called when installing or updating an editable package, takes the
-        source path of the checkout.
+        Fetch a revision from a repository, in the case that this is the
+        first fetch from the repository.
+
+        Args:
+          dest: the directory to fetch the repository to.
+          rev_options: a RevOptions object.
         """
         raise NotImplementedError
 
@@ -270,7 +299,7 @@ class VersionControl(object):
         """
         raise NotImplementedError
 
-    def update(self, dest, rev_options):
+    def update(self, dest, url, rev_options):
         """
         Update an already-existing repo to the given ``rev_options``.
 
@@ -289,94 +318,95 @@ class VersionControl(object):
         """
         raise NotImplementedError
 
-    def check_destination(self, dest, url, rev_options):
+    def obtain(self, dest):
         """
-        Prepare a location to receive a checkout/clone.
-
-        Return True if the location is ready for (and requires) a
-        checkout/clone, False otherwise.
+        Install or update in editable mode the package represented by this
+        VersionControl object.
 
         Args:
-          rev_options: a RevOptions object.
+          dest: the repository directory in which to install or update.
         """
-        checkout = True
-        prompt = False
-        rev_display = rev_options.to_display()
-        if os.path.exists(dest):
-            checkout = False
-            if os.path.exists(os.path.join(dest, self.dirname)):
-                existing_url = self.get_url(dest)
-                if self.compare_urls(existing_url, url):
-                    logger.debug(
-                        '%s in %s exists, and has correct URL (%s)',
-                        self.repo_name.title(),
-                        display_path(dest),
-                        url,
-                    )
-                    if not self.is_commit_id_equal(dest, rev_options.rev):
-                        logger.info(
-                            'Updating %s %s%s',
-                            display_path(dest),
-                            self.repo_name,
-                            rev_display,
-                        )
-                        self.update(dest, rev_options)
-                    else:
-                        logger.info(
-                            'Skipping because already up-to-date.')
-                else:
-                    logger.warning(
-                        '%s %s in %s exists with URL %s',
-                        self.name,
-                        self.repo_name,
-                        display_path(dest),
-                        existing_url,
-                    )
-                    prompt = ('(s)witch, (i)gnore, (w)ipe, (b)ackup ',
-                              ('s', 'i', 'w', 'b'))
-            else:
-                logger.warning(
-                    'Directory %s already exists, and is not a %s %s.',
-                    dest,
-                    self.name,
-                    self.repo_name,
-                )
-                prompt = ('(i)gnore, (w)ipe, (b)ackup ', ('i', 'w', 'b'))
-        if prompt:
-            logger.warning(
-                'The plan is to install the %s repository %s',
-                self.name,
-                url,
-            )
-            response = ask_path_exists('What to do?  %s' % prompt[0],
-                                       prompt[1])
+        url, rev_options = self.get_url_rev_options(self.url)
 
-            if response == 's':
-                logger.info(
-                    'Switching %s %s to %s%s',
-                    self.repo_name,
+        if not os.path.exists(dest):
+            self.fetch_new(dest, url, rev_options)
+            return
+
+        rev_display = rev_options.to_display()
+        if self.is_repository_directory(dest):
+            existing_url = self.get_url(dest)
+            if self.compare_urls(existing_url, url):
+                logger.debug(
+                    '%s in %s exists, and has correct URL (%s)',
+                    self.repo_name.title(),
                     display_path(dest),
                     url,
-                    rev_display,
                 )
-                self.switch(dest, url, rev_options)
-            elif response == 'i':
-                # do nothing
-                pass
-            elif response == 'w':
-                logger.warning('Deleting %s', display_path(dest))
-                rmtree(dest)
-                checkout = True
-            elif response == 'b':
-                dest_dir = backup_dir(dest)
-                logger.warning(
-                    'Backing up %s to %s', display_path(dest), dest_dir,
-                )
-                shutil.move(dest, dest_dir)
-                checkout = True
-            elif response == 'a':
-                sys.exit(-1)
-        return checkout
+                if not self.is_commit_id_equal(dest, rev_options.rev):
+                    logger.info(
+                        'Updating %s %s%s',
+                        display_path(dest),
+                        self.repo_name,
+                        rev_display,
+                    )
+                    self.update(dest, url, rev_options)
+                else:
+                    logger.info('Skipping because already up-to-date.')
+                return
+
+            logger.warning(
+                '%s %s in %s exists with URL %s',
+                self.name,
+                self.repo_name,
+                display_path(dest),
+                existing_url,
+            )
+            prompt = ('(s)witch, (i)gnore, (w)ipe, (b)ackup ',
+                      ('s', 'i', 'w', 'b'))
+        else:
+            logger.warning(
+                'Directory %s already exists, and is not a %s %s.',
+                dest,
+                self.name,
+                self.repo_name,
+            )
+            prompt = ('(i)gnore, (w)ipe, (b)ackup ', ('i', 'w', 'b'))
+
+        logger.warning(
+            'The plan is to install the %s repository %s',
+            self.name,
+            url,
+        )
+        response = ask_path_exists('What to do?  %s' % prompt[0], prompt[1])
+
+        if response == 'a':
+            sys.exit(-1)
+
+        if response == 'w':
+            logger.warning('Deleting %s', display_path(dest))
+            rmtree(dest)
+            self.fetch_new(dest, url, rev_options)
+            return
+
+        if response == 'b':
+            dest_dir = backup_dir(dest)
+            logger.warning(
+                'Backing up %s to %s', display_path(dest), dest_dir,
+            )
+            shutil.move(dest, dest_dir)
+            self.fetch_new(dest, url, rev_options)
+            return
+
+        # Do nothing if the response is "i".
+        if response == 's':
+            logger.info(
+                'Switching %s %s to %s%s',
+                self.repo_name,
+                display_path(dest),
+                url,
+                rev_display,
+            )
+            self.switch(dest, url, rev_options)
 
     def unpack(self, location):
         """
@@ -399,7 +429,6 @@ class VersionControl(object):
     def get_url(self, location):
         """
         Return the url used at location
-        Used in get_info or check_destination
         """
         raise NotImplementedError
 
@@ -436,17 +465,26 @@ class VersionControl(object):
             else:
                 raise  # re-raise exception if a different error occurred
 
+    @classmethod
+    def is_repository_directory(cls, path):
+        """
+        Return whether a directory path is a repository directory.
+        """
+        logger.debug('Checking in %s for %s (%s)...',
+                     path, cls.dirname, cls.name)
+        return os.path.exists(os.path.join(path, cls.dirname))
+
     @classmethod
     def controls_location(cls, location):
         """
         Check if a location is controlled by the vcs.
         It is meant to be overridden to implement smarter detection
         mechanisms for specific vcs.
+
+        This can do more than is_repository_directory() alone.  For example,
+        the Git override checks that Git is actually available.
         """
-        logger.debug('Checking in %s for %s (%s)...',
-                     location, cls.dirname, cls.name)
-        path = os.path.join(location, cls.dirname)
-        return os.path.exists(path)
+        return cls.is_repository_directory(location)
 
 
 def get_src_requirement(dist, location):
diff --git a/pipenv/patched/notpip/_internal/vcs/bazaar.py b/pipenv/patched/notpip/_internal/vcs/bazaar.py
index f9a36a93..890448ed 100644
--- a/pipenv/patched/notpip/_internal/vcs/bazaar.py
+++ b/pipenv/patched/notpip/_internal/vcs/bazaar.py
@@ -6,7 +6,9 @@ import os
 from pipenv.patched.notpip._vendor.six.moves.urllib import parse as urllib_parse
 
 from pipenv.patched.notpip._internal.download import path_to_url
-from pipenv.patched.notpip._internal.utils.misc import display_path, rmtree
+from pipenv.patched.notpip._internal.utils.misc import (
+    display_path, make_vcs_requirement_url, rmtree,
+)
 from pipenv.patched.notpip._internal.utils.temp_dir import TempDirectory
 from pipenv.patched.notpip._internal.vcs import VersionControl, vcs
 
@@ -48,33 +50,30 @@ class Bazaar(VersionControl):
                 cwd=temp_dir.path, show_stdout=False,
             )
 
+    def fetch_new(self, dest, url, rev_options):
+        rev_display = rev_options.to_display()
+        logger.info(
+            'Checking out %s%s to %s',
+            url,
+            rev_display,
+            display_path(dest),
+        )
+        cmd_args = ['branch', '-q'] + rev_options.to_args() + [url, dest]
+        self.run_command(cmd_args)
+
     def switch(self, dest, url, rev_options):
         self.run_command(['switch', url], cwd=dest)
 
-    def update(self, dest, rev_options):
+    def update(self, dest, url, rev_options):
         cmd_args = ['pull', '-q'] + rev_options.to_args()
         self.run_command(cmd_args, cwd=dest)
 
-    def obtain(self, dest):
-        url, rev = self.get_url_rev()
-        rev_options = self.make_rev_options(rev)
-        if self.check_destination(dest, url, rev_options):
-            rev_display = rev_options.to_display()
-            logger.info(
-                'Checking out %s%s to %s',
-                url,
-                rev_display,
-                display_path(dest),
-            )
-            cmd_args = ['branch', '-q'] + rev_options.to_args() + [url, dest]
-            self.run_command(cmd_args)
-
-    def get_url_rev(self):
+    def get_url_rev_and_auth(self, url):
         # hotfix the URL scheme after removing bzr+ from bzr+ssh:// readd it
-        url, rev = super(Bazaar, self).get_url_rev()
+        url, rev, user_pass = super(Bazaar, self).get_url_rev_and_auth(url)
         if url.startswith('ssh://'):
             url = 'bzr+' + url
-        return url, rev
+        return url, rev, user_pass
 
     def get_url(self, location):
         urls = self.run_command(['info'], show_stdout=False, cwd=location)
@@ -101,9 +100,9 @@ class Bazaar(VersionControl):
             return None
         if not repo.lower().startswith('bzr:'):
             repo = 'bzr+' + repo
-        egg_project_name = dist.egg_name().split('-', 1)[0]
         current_rev = self.get_revision(location)
-        return '%s@%s#egg=%s' % (repo, current_rev, egg_project_name)
+        egg_project_name = dist.egg_name().split('-', 1)[0]
+        return make_vcs_requirement_url(repo, current_rev, egg_project_name)
 
     def is_commit_id_equal(self, dest, name):
         """Always assume the versions don't match"""
diff --git a/pipenv/patched/notpip/_internal/vcs/git.py b/pipenv/patched/notpip/_internal/vcs/git.py
index dd862bfe..3db56144 100644
--- a/pipenv/patched/notpip/_internal/vcs/git.py
+++ b/pipenv/patched/notpip/_internal/vcs/git.py
@@ -8,9 +8,9 @@ from pipenv.patched.notpip._vendor.packaging.version import parse as parse_versi
 from pipenv.patched.notpip._vendor.six.moves.urllib import parse as urllib_parse
 from pipenv.patched.notpip._vendor.six.moves.urllib import request as urllib_request
 
-from pipenv.patched.notpip._internal.compat import samefile
 from pipenv.patched.notpip._internal.exceptions import BadCommand
-from pipenv.patched.notpip._internal.utils.misc import display_path
+from pipenv.patched.notpip._internal.utils.compat import samefile
+from pipenv.patched.notpip._internal.utils.misc import display_path, make_vcs_requirement_url
 from pipenv.patched.notpip._internal.utils.temp_dir import TempDirectory
 from pipenv.patched.notpip._internal.vcs import VersionControl, vcs
 
@@ -43,7 +43,7 @@ class Git(VersionControl):
     def __init__(self, url=None, *args, **kwargs):
 
         # Works around an apparent Git bug
-        # (see http://article.gmane.org/gmane.comp.version-control.git/146500)
+        # (see https://article.gmane.org/gmane.comp.version-control.git/146500)
         if url:
             scheme, netloc, path, query, fragment = urlsplit(url)
             if scheme.endswith('file'):
@@ -77,6 +77,20 @@ class Git(VersionControl):
         version = '.'.join(version.split('.')[:3])
         return parse_version(version)
 
+    def get_branch(self, location):
+        """
+        Return the current branch, or None if HEAD isn't at a branch
+        (e.g. detached HEAD).
+        """
+        args = ['rev-parse', '--abbrev-ref', 'HEAD']
+        output = self.run_command(args, show_stdout=False, cwd=location)
+        branch = output.strip()
+
+        if branch == 'HEAD':
+            return None
+
+        return branch
+
     def export(self, location):
         """Export the Git repository at the url to the destination location"""
         if not location.endswith('/'):
@@ -91,8 +105,8 @@ class Git(VersionControl):
 
     def get_revision_sha(self, dest, rev):
         """
-        Return a commit hash for the given revision if it names a remote
-        branch or tag.  Otherwise, return None.
+        Return (sha_or_none, is_branch), where sha_or_none is a commit hash
+        if the revision names a remote branch or tag, otherwise None.
 
         Args:
           dest: the repository directory.
@@ -115,22 +129,30 @@ class Git(VersionControl):
         branch_ref = 'refs/remotes/origin/{}'.format(rev)
         tag_ref = 'refs/tags/{}'.format(rev)
 
-        return refs.get(branch_ref) or refs.get(tag_ref)
+        sha = refs.get(branch_ref)
+        if sha is not None:
+            return (sha, True)
 
-    def check_rev_options(self, dest, rev_options):
-        """Check the revision options before checkout.
+        sha = refs.get(tag_ref)
 
-        Returns a new RevOptions object for the SHA1 of the branch or tag
-        if found.
+        return (sha, False)
+
+    def resolve_revision(self, dest, url, rev_options):
+        """
+        Resolve a revision to a new RevOptions object with the SHA1 of the
+        branch, tag, or ref if found.
 
         Args:
           rev_options: a RevOptions object.
         """
         rev = rev_options.arg_rev
-        sha = self.get_revision_sha(dest, rev)
+        sha, is_branch = self.get_revision_sha(dest, rev)
 
         if sha is not None:
-            return rev_options.make_new(sha)
+            rev_options = rev_options.make_new(sha)
+            rev_options.branch_name = rev if is_branch else None
+
+            return rev_options
 
         # Do not show a warning for the common case of something that has
         # the form of a Git commit hash.
@@ -139,6 +161,19 @@ class Git(VersionControl):
                 "Did not find branch or tag '%s', assuming revision or ref.",
                 rev,
             )
+
+        if not rev.startswith('refs/'):
+            return rev_options
+
+        # If it looks like a ref, we have to fetch it explicitly.
+        self.run_command(
+            ['fetch', '-q', url] + rev_options.to_args(),
+            cwd=dest,
+        )
+        # Change the revision to the SHA of the ref we fetched
+        sha = self.get_revision(dest, rev='FETCH_HEAD')
+        rev_options = rev_options.make_new(sha)
+
         return rev_options
 
     def is_commit_id_equal(self, dest, name):
@@ -155,6 +190,35 @@ class Git(VersionControl):
 
         return self.get_revision(dest) == name
 
+    def fetch_new(self, dest, url, rev_options):
+        rev_display = rev_options.to_display()
+        logger.info(
+            'Cloning %s%s to %s', url, rev_display, display_path(dest),
+        )
+        self.run_command(['clone', '-q', url, dest])
+
+        if rev_options.rev:
+            # Then a specific revision was requested.
+            rev_options = self.resolve_revision(dest, url, rev_options)
+            branch_name = getattr(rev_options, 'branch_name', None)
+            if branch_name is None:
+                # Only do a checkout if the current commit id doesn't match
+                # the requested revision.
+                if not self.is_commit_id_equal(dest, rev_options.rev):
+                    cmd_args = ['checkout', '-q'] + rev_options.to_args()
+                    self.run_command(cmd_args, cwd=dest)
+            elif self.get_branch(dest) != branch_name:
+                # Then a specific branch was requested, and that branch
+                # is not yet checked out.
+                track_branch = 'origin/{}'.format(branch_name)
+                cmd_args = [
+                    'checkout', '-b', branch_name, '--track', track_branch,
+                ]
+                self.run_command(cmd_args, cwd=dest)
+
+        #: repo may contain submodules
+        self.update_submodules(dest)
+
     def switch(self, dest, url, rev_options):
         self.run_command(['config', 'remote.origin.url', url], cwd=dest)
         cmd_args = ['checkout', '-q'] + rev_options.to_args()
@@ -162,7 +226,7 @@ class Git(VersionControl):
 
         self.update_submodules(dest)
 
-    def update(self, dest, rev_options):
+    def update(self, dest, url, rev_options):
         # First fetch changes from the default remote
         if self.get_git_version() >= parse_version('1.9.0'):
             # fetch tags in addition to everything else
@@ -170,41 +234,12 @@ class Git(VersionControl):
         else:
             self.run_command(['fetch', '-q'], cwd=dest)
         # Then reset to wanted revision (maybe even origin/master)
-        rev_options = self.check_rev_options(dest, rev_options)
+        rev_options = self.resolve_revision(dest, url, rev_options)
         cmd_args = ['reset', '--hard', '-q'] + rev_options.to_args()
         self.run_command(cmd_args, cwd=dest)
         #: update submodules
         self.update_submodules(dest)
 
-    def obtain(self, dest):
-        url, rev = self.get_url_rev()
-        rev_options = self.make_rev_options(rev)
-        if self.check_destination(dest, url, rev_options):
-            rev_display = rev_options.to_display()
-            logger.info(
-                'Cloning %s%s to %s', url, rev_display, display_path(dest),
-            )
-            self.run_command(['clone', '-q', url, dest])
-
-            if rev:
-                rev_options = self.check_rev_options(dest, rev_options)
-                # Only do a checkout if the current commit id doesn't match
-                # the requested revision.
-                if not self.is_commit_id_equal(dest, rev_options.rev):
-                    rev = rev_options.rev
-                    # Only fetch the revision if it's a ref
-                    if rev.startswith('refs/'):
-                        self.run_command(
-                            ['fetch', '-q', url] + rev_options.to_args(),
-                            cwd=dest,
-                        )
-                        # Change the revision to the SHA of the ref we fetched
-                        rev = 'FETCH_HEAD'
-                    self.run_command(['checkout', '-q', rev], cwd=dest)
-
-            #: repo may contain submodules
-            self.update_submodules(dest)
-
     def get_url(self, location):
         """Return URL of the first remote encountered."""
         remotes = self.run_command(
@@ -220,9 +255,11 @@ class Git(VersionControl):
         url = found_remote.split(' ')[1]
         return url.strip()
 
-    def get_revision(self, location):
+    def get_revision(self, location, rev=None):
+        if rev is None:
+            rev = 'HEAD'
         current_rev = self.run_command(
-            ['rev-parse', 'HEAD'], show_stdout=False, cwd=location,
+            ['rev-parse', rev], show_stdout=False, cwd=location,
         )
         return current_rev.strip()
 
@@ -257,32 +294,30 @@ class Git(VersionControl):
         repo = self.get_url(location)
         if not repo.lower().startswith('git:'):
             repo = 'git+' + repo
-        egg_project_name = dist.egg_name().split('-', 1)[0]
-        if not repo:
-            return None
         current_rev = self.get_revision(location)
-        req = '%s@%s#egg=%s' % (repo, current_rev, egg_project_name)
-        subdirectory = self._get_subdirectory(location)
-        if subdirectory:
-            req += '&subdirectory=' + subdirectory
+        egg_project_name = dist.egg_name().split('-', 1)[0]
+        subdir = self._get_subdirectory(location)
+        req = make_vcs_requirement_url(repo, current_rev, egg_project_name,
+                                       subdir=subdir)
+
         return req
 
-    def get_url_rev(self):
+    def get_url_rev_and_auth(self, url):
         """
         Prefixes stub URLs like 'user@hostname:user/repo.git' with 'ssh://'.
-        That's required because although they use SSH they sometimes doesn't
-        work with a ssh:// scheme (e.g. Github). But we need a scheme for
+        That's required because although they use SSH they sometimes don't
+        work with a ssh:// scheme (e.g. GitHub). But we need a scheme for
         parsing. Hence we remove it again afterwards and return it as a stub.
         """
-        if '://' not in self.url:
-            assert 'file:' not in self.url
-            self.url = self.url.replace('git+', 'git+ssh://')
-            url, rev = super(Git, self).get_url_rev()
+        if '://' not in url:
+            assert 'file:' not in url
+            url = url.replace('git+', 'git+ssh://')
+            url, rev, user_pass = super(Git, self).get_url_rev_and_auth(url)
             url = url.replace('ssh://', '')
         else:
-            url, rev = super(Git, self).get_url_rev()
+            url, rev, user_pass = super(Git, self).get_url_rev_and_auth(url)
 
-        return url, rev
+        return url, rev, user_pass
 
     def update_submodules(self, location):
         if not os.path.exists(os.path.join(location, '.gitmodules')):
diff --git a/pipenv/patched/notpip/_internal/vcs/mercurial.py b/pipenv/patched/notpip/_internal/vcs/mercurial.py
index e28228fc..d76d47f3 100644
--- a/pipenv/patched/notpip/_internal/vcs/mercurial.py
+++ b/pipenv/patched/notpip/_internal/vcs/mercurial.py
@@ -6,7 +6,7 @@ import os
 from pipenv.patched.notpip._vendor.six.moves import configparser
 
 from pipenv.patched.notpip._internal.download import path_to_url
-from pipenv.patched.notpip._internal.utils.misc import display_path
+from pipenv.patched.notpip._internal.utils.misc import display_path, make_vcs_requirement_url
 from pipenv.patched.notpip._internal.utils.temp_dir import TempDirectory
 from pipenv.patched.notpip._internal.vcs import VersionControl, vcs
 
@@ -31,6 +31,18 @@ class Mercurial(VersionControl):
                 ['archive', location], show_stdout=False, cwd=temp_dir.path
             )
 
+    def fetch_new(self, dest, url, rev_options):
+        rev_display = rev_options.to_display()
+        logger.info(
+            'Cloning hg %s%s to %s',
+            url,
+            rev_display,
+            display_path(dest),
+        )
+        self.run_command(['clone', '--noupdate', '-q', url, dest])
+        cmd_args = ['update', '-q'] + rev_options.to_args()
+        self.run_command(cmd_args, cwd=dest)
+
     def switch(self, dest, url, rev_options):
         repo_config = os.path.join(dest, self.dirname, 'hgrc')
         config = configparser.SafeConfigParser()
@@ -47,26 +59,11 @@ class Mercurial(VersionControl):
             cmd_args = ['update', '-q'] + rev_options.to_args()
             self.run_command(cmd_args, cwd=dest)
 
-    def update(self, dest, rev_options):
+    def update(self, dest, url, rev_options):
         self.run_command(['pull', '-q'], cwd=dest)
         cmd_args = ['update', '-q'] + rev_options.to_args()
         self.run_command(cmd_args, cwd=dest)
 
-    def obtain(self, dest):
-        url, rev = self.get_url_rev()
-        rev_options = self.make_rev_options(rev)
-        if self.check_destination(dest, url, rev_options):
-            rev_display = rev_options.to_display()
-            logger.info(
-                'Cloning hg %s%s to %s',
-                url,
-                rev_display,
-                display_path(dest),
-            )
-            self.run_command(['clone', '--noupdate', '-q', url, dest])
-            cmd_args = ['update', '-q'] + rev_options.to_args()
-            self.run_command(cmd_args, cwd=dest)
-
     def get_url(self, location):
         url = self.run_command(
             ['showconfig', 'paths.default'],
@@ -91,11 +88,10 @@ class Mercurial(VersionControl):
         repo = self.get_url(location)
         if not repo.lower().startswith('hg:'):
             repo = 'hg+' + repo
-        egg_project_name = dist.egg_name().split('-', 1)[0]
-        if not repo:
-            return None
         current_rev_hash = self.get_revision_hash(location)
-        return '%s@%s#egg=%s' % (repo, current_rev_hash, egg_project_name)
+        egg_project_name = dist.egg_name().split('-', 1)[0]
+        return make_vcs_requirement_url(repo, current_rev_hash,
+                                        egg_project_name)
 
     def is_commit_id_equal(self, dest, name):
         """Always assume the versions don't match"""
diff --git a/pipenv/patched/notpip/_internal/vcs/subversion.py b/pipenv/patched/notpip/_internal/vcs/subversion.py
index 6f480ae3..f3c3db4d 100644
--- a/pipenv/patched/notpip/_internal/vcs/subversion.py
+++ b/pipenv/patched/notpip/_internal/vcs/subversion.py
@@ -4,17 +4,15 @@ import logging
 import os
 import re
 
-from pipenv.patched.notpip._vendor.six.moves.urllib import parse as urllib_parse
-
-from pipenv.patched.notpip._internal.index import Link
+from pipenv.patched.notpip._internal.models.link import Link
 from pipenv.patched.notpip._internal.utils.logging import indent_log
-from pipenv.patched.notpip._internal.utils.misc import display_path, rmtree
+from pipenv.patched.notpip._internal.utils.misc import (
+    display_path, make_vcs_requirement_url, rmtree, split_auth_from_netloc,
+)
 from pipenv.patched.notpip._internal.vcs import VersionControl, vcs
 
 _svn_xml_url_re = re.compile('url="([^"]+)"')
 _svn_rev_re = re.compile(r'committed-rev="(\d+)"')
-_svn_url_re = re.compile(r'URL: (.+)')
-_svn_revision_re = re.compile(r'Revision: (.+)')
 _svn_info_xml_rev_re = re.compile(r'\s*revision="(\d+)"')
 _svn_info_xml_url_re = re.compile(r'<url>(.*)</url>')
 
@@ -31,39 +29,10 @@ class Subversion(VersionControl):
     def get_base_rev_args(self, rev):
         return ['-r', rev]
 
-    def get_info(self, location):
-        """Returns (url, revision), where both are strings"""
-        assert not location.rstrip('/').endswith(self.dirname), \
-            'Bad directory: %s' % location
-        output = self.run_command(
-            ['info', location],
-            show_stdout=False,
-            extra_environ={'LANG': 'C'},
-        )
-        match = _svn_url_re.search(output)
-        if not match:
-            logger.warning(
-                'Cannot determine URL of svn checkout %s',
-                display_path(location),
-            )
-            logger.debug('Output that cannot be parsed: \n%s', output)
-            return None, None
-        url = match.group(1).strip()
-        match = _svn_revision_re.search(output)
-        if not match:
-            logger.warning(
-                'Cannot determine revision of svn checkout %s',
-                display_path(location),
-            )
-            logger.debug('Output that cannot be parsed: \n%s', output)
-            return url, None
-        return url, match.group(1)
-
     def export(self, location):
         """Export the svn repository at the url to the destination location"""
-        url, rev = self.get_url_rev()
-        rev_options = get_rev_options(self, url, rev)
-        url = self.remove_auth_from_url(url)
+        url, rev_options = self.get_url_rev_options(self.url)
+
         logger.info('Exporting svn repository %s to %s', url, location)
         with indent_log():
             if os.path.exists(location):
@@ -73,29 +42,25 @@ class Subversion(VersionControl):
             cmd_args = ['export'] + rev_options.to_args() + [url, location]
             self.run_command(cmd_args, show_stdout=False)
 
+    def fetch_new(self, dest, url, rev_options):
+        rev_display = rev_options.to_display()
+        logger.info(
+            'Checking out %s%s to %s',
+            url,
+            rev_display,
+            display_path(dest),
+        )
+        cmd_args = ['checkout', '-q'] + rev_options.to_args() + [url, dest]
+        self.run_command(cmd_args)
+
     def switch(self, dest, url, rev_options):
         cmd_args = ['switch'] + rev_options.to_args() + [url, dest]
         self.run_command(cmd_args)
 
-    def update(self, dest, rev_options):
+    def update(self, dest, url, rev_options):
         cmd_args = ['update'] + rev_options.to_args() + [dest]
         self.run_command(cmd_args)
 
-    def obtain(self, dest):
-        url, rev = self.get_url_rev()
-        rev_options = get_rev_options(self, url, rev)
-        url = self.remove_auth_from_url(url)
-        if self.check_destination(dest, url, rev_options):
-            rev_display = rev_options.to_display()
-            logger.info(
-                'Checking out %s%s to %s',
-                url,
-                rev_display,
-                display_path(dest),
-            )
-            cmd_args = ['checkout', '-q'] + rev_options.to_args() + [url, dest]
-            self.run_command(cmd_args)
-
     def get_location(self, dist, dependency_links):
         for url in dependency_links:
             egg_fragment = Link(url).egg_fragment
@@ -137,12 +102,34 @@ class Subversion(VersionControl):
             revision = max(revision, localrev)
         return revision
 
-    def get_url_rev(self):
+    def get_netloc_and_auth(self, netloc, scheme):
+        """
+        This override allows the auth information to be passed to svn via the
+        --username and --password options instead of via the URL.
+        """
+        if scheme == 'ssh':
+            # The --username and --password options can't be used for
+            # svn+ssh URLs, so keep the auth information in the URL.
+            return super(Subversion, self).get_netloc_and_auth(
+                netloc, scheme)
+
+        return split_auth_from_netloc(netloc)
+
+    def get_url_rev_and_auth(self, url):
         # hotfix the URL scheme after removing svn+ from svn+ssh:// readd it
-        url, rev = super(Subversion, self).get_url_rev()
+        url, rev, user_pass = super(Subversion, self).get_url_rev_and_auth(url)
         if url.startswith('ssh://'):
             url = 'svn+' + url
-        return url, rev
+        return url, rev, user_pass
+
+    def make_rev_args(self, username, password):
+        extra_args = []
+        if username:
+            extra_args += ['--username', username]
+        if password:
+            extra_args += ['--password', password]
+
+        return extra_args
 
     def get_url(self, location):
         # In cases where the source is in a subdirectory, not alongside
@@ -212,60 +199,15 @@ class Subversion(VersionControl):
         repo = self.get_url(location)
         if repo is None:
             return None
+        repo = 'svn+' + repo
+        rev = self.get_revision(location)
         # FIXME: why not project name?
         egg_project_name = dist.egg_name().split('-', 1)[0]
-        rev = self.get_revision(location)
-        return 'svn+%s@%s#egg=%s' % (repo, rev, egg_project_name)
+        return make_vcs_requirement_url(repo, rev, egg_project_name)
 
     def is_commit_id_equal(self, dest, name):
         """Always assume the versions don't match"""
         return False
 
-    @staticmethod
-    def remove_auth_from_url(url):
-        # Return a copy of url with 'username:password@' removed.
-        # username/pass params are passed to subversion through flags
-        # and are not recognized in the url.
-
-        # parsed url
-        purl = urllib_parse.urlsplit(url)
-        stripped_netloc = \
-            purl.netloc.split('@')[-1]
-
-        # stripped url
-        url_pieces = (
-            purl.scheme, stripped_netloc, purl.path, purl.query, purl.fragment
-        )
-        surl = urllib_parse.urlunsplit(url_pieces)
-        return surl
-
-
-def get_rev_options(vcs, url, rev):
-    """
-    Return a RevOptions object.
-    """
-    r = urllib_parse.urlsplit(url)
-    if hasattr(r, 'username'):
-        # >= Python-2.5
-        username, password = r.username, r.password
-    else:
-        netloc = r[1]
-        if '@' in netloc:
-            auth = netloc.split('@')[0]
-            if ':' in auth:
-                username, password = auth.split(':', 1)
-            else:
-                username, password = auth, None
-        else:
-            username, password = None, None
-
-    extra_args = []
-    if username:
-        extra_args += ['--username', username]
-    if password:
-        extra_args += ['--password', password]
-
-    return vcs.make_rev_options(rev, extra_args=extra_args)
-
 
 vcs.register(Subversion)
diff --git a/pipenv/patched/notpip/_internal/wheel.py b/pipenv/patched/notpip/_internal/wheel.py
index fe3bf7d2..6df5a3a3 100644
--- a/pipenv/patched/notpip/_internal/wheel.py
+++ b/pipenv/patched/notpip/_internal/wheel.py
@@ -5,7 +5,6 @@ from __future__ import absolute_import
 
 import collections
 import compileall
-import copy
 import csv
 import hashlib
 import logging
@@ -24,7 +23,6 @@ from pipenv.patched.notpip._vendor.packaging.utils import canonicalize_name
 from pipenv.patched.notpip._vendor.six import StringIO
 
 from pipenv.patched.notpip._internal import pep425tags
-from pipenv.patched.notpip._internal.build_env import BuildEnvironment
 from pipenv.patched.notpip._internal.download import path_to_url, unpack_url
 from pipenv.patched.notpip._internal.exceptions import (
     InstallationError, InvalidWheelFilename, UnsupportedWheel,
@@ -42,7 +40,7 @@ from pipenv.patched.notpip._internal.utils.typing import MYPY_CHECK_RUNNING
 from pipenv.patched.notpip._internal.utils.ui import open_spinner
 
 if MYPY_CHECK_RUNNING:
-    from typing import Dict, List, Optional
+    from typing import Dict, List, Optional  # noqa: F401
 
 wheel_ext = '.whl'
 
@@ -52,9 +50,9 @@ VERSION_COMPATIBLE = (1, 0)
 logger = logging.getLogger(__name__)
 
 
-def rehash(path, algo='sha256', blocksize=1 << 20):
-    """Return (hash, length) for path using hashlib.new(algo)"""
-    h = hashlib.new(algo)
+def rehash(path, blocksize=1 << 20):
+    """Return (hash, length) for path using hashlib.sha256()"""
+    h = hashlib.sha256()
     length = 0
     with open(path, 'rb') as f:
         for block in read_chunks(f, size=blocksize):
@@ -164,11 +162,13 @@ def message_about_scripts_not_on_PATH(scripts):
 
     # We don't want to warn for directories that are on PATH.
     not_warn_dirs = [
-        os.path.normcase(i) for i in os.environ["PATH"].split(os.pathsep)
+        os.path.normcase(i).rstrip(os.sep) for i in
+        os.environ.get("PATH", "").split(os.pathsep)
     ]
     # If an executable sits with sys.executable, we don't warn for it.
     #     This covers the case of venv invocations without activating the venv.
-    not_warn_dirs.append(os.path.normcase(os.path.dirname(sys.executable)))
+    executable_loc = os.environ.get("PIP_PYTHON_PATH", sys.executable)
+    not_warn_dirs.append(os.path.normcase(os.path.dirname(executable_loc)))
     warn_for = {
         parent_dir: scripts for parent_dir, scripts in grouped_by_dir.items()
         if os.path.normcase(parent_dir) not in not_warn_dirs
@@ -284,6 +284,17 @@ def move_wheel_files(name, req, wheeldir, user=False, home=None, root=None,
                 # uninstalled.
                 ensure_dir(destdir)
 
+                # copyfile (called below) truncates the destination if it
+                # exists and then writes the new contents. This is fine in most
+                # cases, but can cause a segfault if pip has loaded a shared
+                # object (e.g. from pyopenssl through its vendored urllib3)
+                # Since the shared object is mmap'd an attempt to call a
+                # symbol in it will then cause a segfault. Unlinking the file
+                # allows writing of new contents while allowing the process to
+                # continue to use the old copy.
+                if os.path.exists(destfile):
+                    os.unlink(destfile)
+
                 # We use copyfile (not move, copy, or copy2) to be extra sure
                 # that we are not moving directories over (copyfile fails for
                 # directories) as well as to ensure that we are not copying
@@ -465,7 +476,7 @@ if __name__ == '__main__':
         if warn_script_location:
             msg = message_about_scripts_not_on_PATH(generated_console_scripts)
             if msg is not None:
-                logger.warn(msg)
+                logger.warning(msg)
 
     if len(gui) > 0:
         generated.extend(
@@ -490,16 +501,19 @@ if __name__ == '__main__':
         with open_for_csv(temp_record, 'w+') as record_out:
             reader = csv.reader(record_in)
             writer = csv.writer(record_out)
+            outrows = []
             for row in reader:
                 row[0] = installed.pop(row[0], row[0])
                 if row[0] in changed:
                     row[1], row[2] = rehash(row[0])
-                writer.writerow(row)
+                outrows.append(tuple(row))
             for f in generated:
-                h, l = rehash(f)
-                writer.writerow((normpath(f, lib_dir), h, l))
+                digest, length = rehash(f)
+                outrows.append((normpath(f, lib_dir), digest, length))
             for f in installed:
-                writer.writerow((installed[f], '', ''))
+                outrows.append((installed[f], '', ''))
+            for row in sorted(outrows):
+                writer.writerow(row)
     shutil.move(temp_record, record)
 
 
@@ -518,7 +532,7 @@ def wheel_version(source_dir):
         version = wheel_data['Wheel-Version'].strip()
         version = tuple(map(int, version.split('.')))
         return version
-    except:
+    except Exception:
         return False
 
 
@@ -643,7 +657,7 @@ class WheelBuilder(object):
                     )
                     logger.info('Stored in directory: %s', output_dir)
                     return wheel_path
-                except:
+                except Exception:
                     pass
             # Ignore return, we can't do anything else useful.
             self._clean_one(req)
@@ -654,8 +668,9 @@ class WheelBuilder(object):
         # isolating. Currently, it breaks Python in virtualenvs, because it
         # relies on site.py to find parts of the standard library outside the
         # virtualenv.
+        executable_loc = os.environ.get('PIP_PYTHON_PATH', sys.executable)
         return [
-            os.environ.get('PIP_PYTHON_PATH', sys.executable), '-u', '-c',
+            executable_loc, '-u', '-c',
             SETUPTOOLS_SHIM % req.setup_py
         ] + list(self.global_options)
 
@@ -675,7 +690,7 @@ class WheelBuilder(object):
                 call_subprocess(wheel_args, cwd=req.setup_py_dir,
                                 show_stdout=False, spinner=spinner)
                 return True
-            except:
+            except Exception:
                 spinner.finish("error")
                 logger.error('Failed building wheel for %s', req.name)
                 return False
@@ -688,7 +703,7 @@ class WheelBuilder(object):
         try:
             call_subprocess(clean_args, cwd=req.source_dir, show_stdout=False)
             return True
-        except:
+        except Exception:
             logger.error('Failed cleaning build dir for %s', req.name)
             return False
 
@@ -700,6 +715,7 @@ class WheelBuilder(object):
         :return: True if all the wheels built correctly.
         """
         from pipenv.patched.notpip._internal import index
+        from pipenv.patched.notpip._internal.models.link import Link
 
         building_is_possible = self._wheel_dir or (
             autobuilding and self.wheel_cache.cache_dir
@@ -707,6 +723,7 @@ class WheelBuilder(object):
         assert building_is_possible
 
         buildset = []
+        format_control = self.finder.format_control
         for req in requirements:
             if req.constraint:
                 continue
@@ -730,8 +747,7 @@ class WheelBuilder(object):
                     if index.egg_info_matches(base, None, link) is None:
                         # E.g. local directory. Build wheel just for this run.
                         ephem_cache = True
-                    if "binary" not in index.fmt_ctl_formats(
-                            self.finder.format_control,
+                    if "binary" not in format_control.get_allowed_formats(
                             canonicalize_name(req.name)):
                         logger.info(
                             "Skipping bdist_wheel for %s, due to binaries "
@@ -792,7 +808,7 @@ class WheelBuilder(object):
                             self.preparer.build_dir
                         )
                         # Update the link for this.
-                        req.link = index.Link(path_to_url(wheel_file))
+                        req.link = Link(path_to_url(wheel_file))
                         assert req.link.is_wheel
                         # extract the wheel into the dir
                         unpack_url(
diff --git a/pipenv/patched/notpip/_vendor/__init__.py b/pipenv/patched/notpip/_vendor/__init__.py
index 40ce7a01..b6294b21 100644
--- a/pipenv/patched/notpip/_vendor/__init__.py
+++ b/pipenv/patched/notpip/_vendor/__init__.py
@@ -107,5 +107,4 @@ if DEBUNDLED:
     vendored("requests.packages.urllib3.util.ssl_")
     vendored("requests.packages.urllib3.util.timeout")
     vendored("requests.packages.urllib3.util.url")
-
-import requests
+    vendored("urllib3")
diff --git a/pipenv/patched/notpip/_vendor/cachecontrol/__init__.py b/pipenv/patched/notpip/_vendor/cachecontrol/__init__.py
index f386d492..8fdee66f 100644
--- a/pipenv/patched/notpip/_vendor/cachecontrol/__init__.py
+++ b/pipenv/patched/notpip/_vendor/cachecontrol/__init__.py
@@ -2,9 +2,9 @@
 
 Make it easy to import from cachecontrol without long namespaces.
 """
-__author__ = 'Eric Larson'
-__email__ = 'eric@ionrock.org'
-__version__ = '0.12.4'
+__author__ = "Eric Larson"
+__email__ = "eric@ionrock.org"
+__version__ = "0.12.5"
 
 from .wrapper import CacheControl
 from .adapter import CacheControlAdapter
diff --git a/pipenv/patched/notpip/_vendor/cachecontrol/_cmd.py b/pipenv/patched/notpip/_vendor/cachecontrol/_cmd.py
index b5e44db8..fb90adf4 100644
--- a/pipenv/patched/notpip/_vendor/cachecontrol/_cmd.py
+++ b/pipenv/patched/notpip/_vendor/cachecontrol/_cmd.py
@@ -17,14 +17,11 @@ def setup_logging():
 
 def get_session():
     adapter = CacheControlAdapter(
-        DictCache(),
-        cache_etags=True,
-        serializer=None,
-        heuristic=None,
+        DictCache(), cache_etags=True, serializer=None, heuristic=None
     )
     sess = requests.Session()
-    sess.mount('http://', adapter)
-    sess.mount('https://', adapter)
+    sess.mount("http://", adapter)
+    sess.mount("https://", adapter)
 
     sess.cache_controller = adapter.controller
     return sess
@@ -32,7 +29,7 @@ def get_session():
 
 def get_args():
     parser = ArgumentParser()
-    parser.add_argument('url', help='The URL to try and cache')
+    parser.add_argument("url", help="The URL to try and cache")
     return parser.parse_args()
 
 
@@ -51,10 +48,10 @@ def main(args=None):
 
     # Now try to get it
     if sess.cache_controller.cached_request(resp.request):
-        print('Cached!')
+        print("Cached!")
     else:
-        print('Not cached :(')
+        print("Not cached :(")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/pipenv/patched/notpip/_vendor/cachecontrol/adapter.py b/pipenv/patched/notpip/_vendor/cachecontrol/adapter.py
index bcf107ee..2f290998 100644
--- a/pipenv/patched/notpip/_vendor/cachecontrol/adapter.py
+++ b/pipenv/patched/notpip/_vendor/cachecontrol/adapter.py
@@ -10,25 +10,27 @@ from .filewrapper import CallbackFileWrapper
 
 
 class CacheControlAdapter(HTTPAdapter):
-    invalidating_methods = set(['PUT', 'DELETE'])
+    invalidating_methods = {"PUT", "DELETE"}
 
-    def __init__(self, cache=None,
-                 cache_etags=True,
-                 controller_class=None,
-                 serializer=None,
-                 heuristic=None,
-                 cacheable_methods=None,
-                 *args, **kw):
+    def __init__(
+        self,
+        cache=None,
+        cache_etags=True,
+        controller_class=None,
+        serializer=None,
+        heuristic=None,
+        cacheable_methods=None,
+        *args,
+        **kw
+    ):
         super(CacheControlAdapter, self).__init__(*args, **kw)
         self.cache = cache or DictCache()
         self.heuristic = heuristic
-        self.cacheable_methods = cacheable_methods or ('GET',)
+        self.cacheable_methods = cacheable_methods or ("GET",)
 
         controller_factory = controller_class or CacheController
         self.controller = controller_factory(
-            self.cache,
-            cache_etags=cache_etags,
-            serializer=serializer,
+            self.cache, cache_etags=cache_etags, serializer=serializer
         )
 
     def send(self, request, cacheable_methods=None, **kw):
@@ -43,20 +45,18 @@ class CacheControlAdapter(HTTPAdapter):
             except zlib.error:
                 cached_response = None
             if cached_response:
-                return self.build_response(request, cached_response,
-                                           from_cache=True)
+                return self.build_response(request, cached_response, from_cache=True)
 
             # check for etags and add headers if appropriate
-            request.headers.update(
-                self.controller.conditional_headers(request)
-            )
+            request.headers.update(self.controller.conditional_headers(request))
 
         resp = super(CacheControlAdapter, self).send(request, **kw)
 
         return resp
 
-    def build_response(self, request, response, from_cache=False,
-                       cacheable_methods=None):
+    def build_response(
+        self, request, response, from_cache=False, cacheable_methods=None
+    ):
         """
         Build a response by making a request or using the cache.
 
@@ -101,10 +101,8 @@ class CacheControlAdapter(HTTPAdapter):
                 response._fp = CallbackFileWrapper(
                     response._fp,
                     functools.partial(
-                        self.controller.cache_response,
-                        request,
-                        response,
-                    )
+                        self.controller.cache_response, request, response
+                    ),
                 )
                 if response.chunked:
                     super_update_chunk_length = response._update_chunk_length
@@ -113,11 +111,12 @@ class CacheControlAdapter(HTTPAdapter):
                         super_update_chunk_length()
                         if self.chunk_left == 0:
                             self._fp._close()
-                    response._update_chunk_length = types.MethodType(_update_chunk_length, response)
 
-        resp = super(CacheControlAdapter, self).build_response(
-            request, response
-        )
+                    response._update_chunk_length = types.MethodType(
+                        _update_chunk_length, response
+                    )
+
+        resp = super(CacheControlAdapter, self).build_response(request, response)
 
         # See if we should invalidate the cache.
         if request.method in self.invalidating_methods and resp.ok:
diff --git a/pipenv/patched/notpip/_vendor/cachecontrol/cache.py b/pipenv/patched/notpip/_vendor/cachecontrol/cache.py
index 7389a73f..94e07732 100644
--- a/pipenv/patched/notpip/_vendor/cachecontrol/cache.py
+++ b/pipenv/patched/notpip/_vendor/cachecontrol/cache.py
@@ -8,13 +8,13 @@ from threading import Lock
 class BaseCache(object):
 
     def get(self, key):
-        raise NotImplemented()
+        raise NotImplementedError()
 
     def set(self, key, value):
-        raise NotImplemented()
+        raise NotImplementedError()
 
     def delete(self, key):
-        raise NotImplemented()
+        raise NotImplementedError()
 
     def close(self):
         pass
diff --git a/pipenv/patched/notpip/_vendor/cachecontrol/caches/file_cache.py b/pipenv/patched/notpip/_vendor/cachecontrol/caches/file_cache.py
index cbe75851..06f7d09e 100644
--- a/pipenv/patched/notpip/_vendor/cachecontrol/caches/file_cache.py
+++ b/pipenv/patched/notpip/_vendor/cachecontrol/caches/file_cache.py
@@ -9,7 +9,7 @@ try:
     FileNotFoundError
 except NameError:
     # py2.X
-    FileNotFoundError = OSError
+    FileNotFoundError = (IOError, OSError)
 
 
 def _secure_open_write(filename, fmode):
@@ -46,6 +46,7 @@ def _secure_open_write(filename, fmode):
     fd = os.open(filename, flags, fmode)
     try:
         return os.fdopen(fd, "wb")
+
     except:
         # An error occurred wrapping our FD in a file object
         os.close(fd)
@@ -53,8 +54,16 @@ def _secure_open_write(filename, fmode):
 
 
 class FileCache(BaseCache):
-    def __init__(self, directory, forever=False, filemode=0o0600,
-                 dirmode=0o0700, use_dir_lock=None, lock_class=None):
+
+    def __init__(
+        self,
+        directory,
+        forever=False,
+        filemode=0o0600,
+        dirmode=0o0700,
+        use_dir_lock=None,
+        lock_class=None,
+    ):
 
         if use_dir_lock is not None and lock_class is not None:
             raise ValueError("Cannot use use_dir_lock and lock_class together")
@@ -63,12 +72,15 @@ class FileCache(BaseCache):
             from pipenv.patched.notpip._vendor.lockfile import LockFile
             from pipenv.patched.notpip._vendor.lockfile.mkdirlockfile import MkdirLockFile
         except ImportError:
-            notice = dedent("""
+            notice = dedent(
+                """
             NOTE: In order to use the FileCache you must have
             lockfile installed. You can install it via pip:
               pip install lockfile
-            """)
+            """
+            )
             raise ImportError(notice)
+
         else:
             if use_dir_lock:
                 lock_class = MkdirLockFile
@@ -95,11 +107,12 @@ class FileCache(BaseCache):
 
     def get(self, key):
         name = self._fn(key)
-        if not os.path.exists(name):
-            return None
+        try:
+            with open(name, "rb") as fh:
+                return fh.read()
 
-        with open(name, 'rb') as fh:
-            return fh.read()
+        except FileNotFoundError:
+            return None
 
     def set(self, key, value):
         name = self._fn(key)
diff --git a/pipenv/patched/notpip/_vendor/cachecontrol/caches/redis_cache.py b/pipenv/patched/notpip/_vendor/cachecontrol/caches/redis_cache.py
index c0458856..0cc5e979 100644
--- a/pipenv/patched/notpip/_vendor/cachecontrol/caches/redis_cache.py
+++ b/pipenv/patched/notpip/_vendor/cachecontrol/caches/redis_cache.py
@@ -4,16 +4,6 @@ from datetime import datetime
 from pipenv.patched.notpip._vendor.cachecontrol.cache import BaseCache
 
 
-def total_seconds(td):
-    """Python 2.6 compatability"""
-    if hasattr(td, 'total_seconds'):
-        return int(td.total_seconds())
-
-    ms = td.microseconds
-    secs = (td.seconds + td.days * 24 * 3600)
-    return int((ms + secs * 10**6) / 10**6)
-
-
 class RedisCache(BaseCache):
 
     def __init__(self, conn):
@@ -27,7 +17,7 @@ class RedisCache(BaseCache):
             self.conn.set(key, value)
         else:
             expires = expires - datetime.utcnow()
-            self.conn.setex(key, total_seconds(expires), value)
+            self.conn.setex(key, int(expires.total_seconds()), value)
 
     def delete(self, key):
         self.conn.delete(key)
diff --git a/pipenv/patched/notpip/_vendor/cachecontrol/controller.py b/pipenv/patched/notpip/_vendor/cachecontrol/controller.py
index 1621813c..0448910f 100644
--- a/pipenv/patched/notpip/_vendor/cachecontrol/controller.py
+++ b/pipenv/patched/notpip/_vendor/cachecontrol/controller.py
@@ -30,8 +30,10 @@ def parse_uri(uri):
 class CacheController(object):
     """An interface to see if request should cached or not.
     """
-    def __init__(self, cache=None, cache_etags=True, serializer=None,
-                 status_codes=None):
+
+    def __init__(
+        self, cache=None, cache_etags=True, serializer=None, status_codes=None
+    ):
         self.cache = cache or DictCache()
         self.cache_etags = cache_etags
         self.serializer = serializer or Serializer()
@@ -64,34 +66,35 @@ class CacheController(object):
     def parse_cache_control(self, headers):
         known_directives = {
             # https://tools.ietf.org/html/rfc7234#section-5.2
-            'max-age': (int, True,),
-            'max-stale': (int, False,),
-            'min-fresh': (int, True,),
-            'no-cache': (None, False,),
-            'no-store': (None, False,),
-            'no-transform': (None, False,),
-            'only-if-cached' : (None, False,),
-            'must-revalidate': (None, False,),
-            'public': (None, False,),
-            'private': (None, False,),
-            'proxy-revalidate': (None, False,),
-            's-maxage': (int, True,)
+            "max-age": (int, True),
+            "max-stale": (int, False),
+            "min-fresh": (int, True),
+            "no-cache": (None, False),
+            "no-store": (None, False),
+            "no-transform": (None, False),
+            "only-if-cached": (None, False),
+            "must-revalidate": (None, False),
+            "public": (None, False),
+            "private": (None, False),
+            "proxy-revalidate": (None, False),
+            "s-maxage": (int, True),
         }
 
-        cc_headers = headers.get('cache-control',
-                                 headers.get('Cache-Control', ''))
+        cc_headers = headers.get("cache-control", headers.get("Cache-Control", ""))
 
         retval = {}
 
-        for cc_directive in cc_headers.split(','):
-            parts = cc_directive.split('=', 1)
+        for cc_directive in cc_headers.split(","):
+            if not cc_directive.strip():
+                continue
+
+            parts = cc_directive.split("=", 1)
             directive = parts[0].strip()
 
             try:
                 typ, required = known_directives[directive]
             except KeyError:
-                logger.debug('Ignoring unknown cache-control directive: %s',
-                             directive)
+                logger.debug("Ignoring unknown cache-control directive: %s", directive)
                 continue
 
             if not typ or not required:
@@ -101,11 +104,16 @@ class CacheController(object):
                     retval[directive] = typ(parts[1].strip())
                 except IndexError:
                     if required:
-                        logger.debug('Missing value for cache-control '
-                                     'directive: %s', directive)
+                        logger.debug(
+                            "Missing value for cache-control " "directive: %s",
+                            directive,
+                        )
                 except ValueError:
-                    logger.debug('Invalid value for cache-control directive '
-                                 '%s, must be %s', directive, typ.__name__)
+                    logger.debug(
+                        "Invalid value for cache-control directive " "%s, must be %s",
+                        directive,
+                        typ.__name__,
+                    )
 
         return retval
 
@@ -119,24 +127,24 @@ class CacheController(object):
         cc = self.parse_cache_control(request.headers)
 
         # Bail out if the request insists on fresh data
-        if 'no-cache' in cc:
+        if "no-cache" in cc:
             logger.debug('Request header has "no-cache", cache bypassed')
             return False
 
-        if 'max-age' in cc and cc['max-age'] == 0:
+        if "max-age" in cc and cc["max-age"] == 0:
             logger.debug('Request header has "max_age" as 0, cache bypassed')
             return False
 
         # Request allows serving from the cache, let's see if we find something
         cache_data = self.cache.get(cache_url)
         if cache_data is None:
-            logger.debug('No cache entry available')
+            logger.debug("No cache entry available")
             return False
 
         # Check whether it can be deserialized
         resp = self.serializer.loads(request, cache_data)
         if not resp:
-            logger.warning('Cache entry deserialization failed, entry ignored')
+            logger.warning("Cache entry deserialization failed, entry ignored")
             return False
 
         # If we have a cached 301, return it immediately. We don't
@@ -148,27 +156,27 @@ class CacheController(object):
         # Client can try to refresh the value by repeating the request
         # with cache busting headers as usual (ie no-cache).
         if resp.status == 301:
-            msg = ('Returning cached "301 Moved Permanently" response '
-                   '(ignoring date and etag information)')
+            msg = (
+                'Returning cached "301 Moved Permanently" response '
+                "(ignoring date and etag information)"
+            )
             logger.debug(msg)
             return resp
 
         headers = CaseInsensitiveDict(resp.headers)
-        if not headers or 'date' not in headers:
-            if 'etag' not in headers:
+        if not headers or "date" not in headers:
+            if "etag" not in headers:
                 # Without date or etag, the cached response can never be used
                 # and should be deleted.
-                logger.debug('Purging cached response: no date or etag')
+                logger.debug("Purging cached response: no date or etag")
                 self.cache.delete(cache_url)
-            logger.debug('Ignoring cached response: no date')
+            logger.debug("Ignoring cached response: no date")
             return False
 
         now = time.time()
-        date = calendar.timegm(
-            parsedate_tz(headers['date'])
-        )
+        date = calendar.timegm(parsedate_tz(headers["date"]))
         current_age = max(0, now - date)
-        logger.debug('Current age based on date: %i', current_age)
+        logger.debug("Current age based on date: %i", current_age)
 
         # TODO: There is an assumption that the result will be a
         #       urllib3 response object. This may not be best since we
@@ -180,45 +188,41 @@ class CacheController(object):
         freshness_lifetime = 0
 
         # Check the max-age pragma in the cache control header
-        if 'max-age' in resp_cc:
-            freshness_lifetime = resp_cc['max-age']
-            logger.debug('Freshness lifetime from max-age: %i',
-                         freshness_lifetime)
+        if "max-age" in resp_cc:
+            freshness_lifetime = resp_cc["max-age"]
+            logger.debug("Freshness lifetime from max-age: %i", freshness_lifetime)
 
         # If there isn't a max-age, check for an expires header
-        elif 'expires' in headers:
-            expires = parsedate_tz(headers['expires'])
+        elif "expires" in headers:
+            expires = parsedate_tz(headers["expires"])
             if expires is not None:
                 expire_time = calendar.timegm(expires) - date
                 freshness_lifetime = max(0, expire_time)
-                logger.debug("Freshness lifetime from expires: %i",
-                             freshness_lifetime)
+                logger.debug("Freshness lifetime from expires: %i", freshness_lifetime)
 
         # Determine if we are setting freshness limit in the
         # request. Note, this overrides what was in the response.
-        if 'max-age' in cc:
-            freshness_lifetime = cc['max-age']
-            logger.debug('Freshness lifetime from request max-age: %i',
-                         freshness_lifetime)
+        if "max-age" in cc:
+            freshness_lifetime = cc["max-age"]
+            logger.debug(
+                "Freshness lifetime from request max-age: %i", freshness_lifetime
+            )
 
-        if 'min-fresh' in cc:
-            min_fresh = cc['min-fresh']
+        if "min-fresh" in cc:
+            min_fresh = cc["min-fresh"]
             # adjust our current age by our min fresh
             current_age += min_fresh
-            logger.debug('Adjusted current age from min-fresh: %i',
-                         current_age)
+            logger.debug("Adjusted current age from min-fresh: %i", current_age)
 
         # Return entry if it is fresh enough
         if freshness_lifetime > current_age:
             logger.debug('The response is "fresh", returning cached response')
-            logger.debug('%i > %i', freshness_lifetime, current_age)
+            logger.debug("%i > %i", freshness_lifetime, current_age)
             return resp
 
         # we're not fresh. If we don't have an Etag, clear it out
-        if 'etag' not in headers:
-            logger.debug(
-                'The cached response is "stale" with no etag, purging'
-            )
+        if "etag" not in headers:
+            logger.debug('The cached response is "stale" with no etag, purging')
             self.cache.delete(cache_url)
 
         # return the original handler
@@ -232,16 +236,15 @@ class CacheController(object):
         if resp:
             headers = CaseInsensitiveDict(resp.headers)
 
-            if 'etag' in headers:
-                new_headers['If-None-Match'] = headers['ETag']
+            if "etag" in headers:
+                new_headers["If-None-Match"] = headers["ETag"]
 
-            if 'last-modified' in headers:
-                new_headers['If-Modified-Since'] = headers['Last-Modified']
+            if "last-modified" in headers:
+                new_headers["If-Modified-Since"] = headers["Last-Modified"]
 
         return new_headers
 
-    def cache_response(self, request, response, body=None,
-                       status_codes=None):
+    def cache_response(self, request, response, body=None, status_codes=None):
         """
         Algorithm for caching requests.
 
@@ -252,9 +255,7 @@ class CacheController(object):
         cacheable_status_codes = status_codes or self.cacheable_status_codes
         if response.status not in cacheable_status_codes:
             logger.debug(
-                'Status code %s not in %s',
-                response.status,
-                cacheable_status_codes
+                "Status code %s not in %s", response.status, cacheable_status_codes
             )
             return
 
@@ -264,10 +265,12 @@ class CacheController(object):
         # Content-Length is valid then we can check to see if the body we've
         # been given matches the expected size, and if it doesn't we'll just
         # skip trying to cache it.
-        if (body is not None and
-                "content-length" in response_headers and
-                response_headers["content-length"].isdigit() and
-                int(response_headers["content-length"]) != len(body)):
+        if (
+            body is not None
+            and "content-length" in response_headers
+            and response_headers["content-length"].isdigit()
+            and int(response_headers["content-length"]) != len(body)
+        ):
             return
 
         cc_req = self.parse_cache_control(request.headers)
@@ -278,53 +281,49 @@ class CacheController(object):
 
         # Delete it from the cache if we happen to have it stored there
         no_store = False
-        if 'no-store' in cc:
+        if "no-store" in cc:
             no_store = True
             logger.debug('Response header has "no-store"')
-        if 'no-store' in cc_req:
+        if "no-store" in cc_req:
             no_store = True
             logger.debug('Request header has "no-store"')
         if no_store and self.cache.get(cache_url):
             logger.debug('Purging existing cache entry to honor "no-store"')
             self.cache.delete(cache_url)
+        if no_store:
+            return
 
         # If we've been given an etag, then keep the response
-        if self.cache_etags and 'etag' in response_headers:
-            logger.debug('Caching due to etag')
+        if self.cache_etags and "etag" in response_headers:
+            logger.debug("Caching due to etag")
             self.cache.set(
-                cache_url,
-                self.serializer.dumps(request, response, body=body),
+                cache_url, self.serializer.dumps(request, response, body=body)
             )
 
         # Add to the cache any 301s. We do this before looking that
         # the Date headers.
         elif response.status == 301:
-            logger.debug('Caching permanant redirect')
-            self.cache.set(
-                cache_url,
-                self.serializer.dumps(request, response)
-            )
+            logger.debug("Caching permanant redirect")
+            self.cache.set(cache_url, self.serializer.dumps(request, response))
 
         # Add to the cache if the response headers demand it. If there
         # is no date header then we can't do anything about expiring
         # the cache.
-        elif 'date' in response_headers:
+        elif "date" in response_headers:
             # cache when there is a max-age > 0
-            if 'max-age' in cc and cc['max-age'] > 0:
-                logger.debug('Caching b/c date exists and max-age > 0')
+            if "max-age" in cc and cc["max-age"] > 0:
+                logger.debug("Caching b/c date exists and max-age > 0")
                 self.cache.set(
-                    cache_url,
-                    self.serializer.dumps(request, response, body=body),
+                    cache_url, self.serializer.dumps(request, response, body=body)
                 )
 
             # If the request can expire, it means we should cache it
             # in the meantime.
-            elif 'expires' in response_headers:
-                if response_headers['expires']:
-                    logger.debug('Caching b/c of expires header')
+            elif "expires" in response_headers:
+                if response_headers["expires"]:
+                    logger.debug("Caching b/c of expires header")
                     self.cache.set(
-                        cache_url,
-                        self.serializer.dumps(request, response, body=body),
+                        cache_url, self.serializer.dumps(request, response, body=body)
                     )
 
     def update_cached_response(self, request, response):
@@ -336,10 +335,7 @@ class CacheController(object):
         """
         cache_url = self.cache_url(request.url)
 
-        cached_response = self.serializer.loads(
-            request,
-            self.cache.get(cache_url)
-        )
+        cached_response = self.serializer.loads(request, self.cache.get(cache_url))
 
         if not cached_response:
             # we didn't have a cached response
@@ -352,22 +348,20 @@ class CacheController(object):
         # the cached body invalid. But... just in case, we'll be sure
         # to strip out ones we know that might be problmatic due to
         # typical assumptions.
-        excluded_headers = [
-            "content-length",
-        ]
+        excluded_headers = ["content-length"]
 
         cached_response.headers.update(
-            dict((k, v) for k, v in response.headers.items()
-                 if k.lower() not in excluded_headers)
+            dict(
+                (k, v)
+                for k, v in response.headers.items()
+                if k.lower() not in excluded_headers
+            )
         )
 
         # we want a 200 b/c we have content via the cache
         cached_response.status = 200
 
         # update our cache
-        self.cache.set(
-            cache_url,
-            self.serializer.dumps(request, cached_response),
-        )
+        self.cache.set(cache_url, self.serializer.dumps(request, cached_response))
 
         return cached_response
diff --git a/pipenv/patched/notpip/_vendor/cachecontrol/filewrapper.py b/pipenv/patched/notpip/_vendor/cachecontrol/filewrapper.py
index f1e1ce05..30ed4c5a 100644
--- a/pipenv/patched/notpip/_vendor/cachecontrol/filewrapper.py
+++ b/pipenv/patched/notpip/_vendor/cachecontrol/filewrapper.py
@@ -27,17 +27,19 @@ class CallbackFileWrapper(object):
         # self.__fp hasn't been set.
         #
         # [0] https://docs.python.org/2/reference/expressions.html#atom-identifiers
-        fp = self.__getattribute__('_CallbackFileWrapper__fp')
+        fp = self.__getattribute__("_CallbackFileWrapper__fp")
         return getattr(fp, name)
 
     def __is_fp_closed(self):
         try:
             return self.__fp.fp is None
+
         except AttributeError:
             pass
 
         try:
             return self.__fp.closed
+
         except AttributeError:
             pass
 
@@ -66,7 +68,7 @@ class CallbackFileWrapper(object):
 
     def _safe_read(self, amt):
         data = self.__fp._safe_read(amt)
-        if amt == 2 and data == b'\r\n':
+        if amt == 2 and data == b"\r\n":
             # urllib executes this read to toss the CRLF at the end
             # of the chunk.
             return data
diff --git a/pipenv/patched/notpip/_vendor/cachecontrol/heuristics.py b/pipenv/patched/notpip/_vendor/cachecontrol/heuristics.py
index f182ff02..6c0e9790 100644
--- a/pipenv/patched/notpip/_vendor/cachecontrol/heuristics.py
+++ b/pipenv/patched/notpip/_vendor/cachecontrol/heuristics.py
@@ -46,7 +46,7 @@ class BaseHeuristic(object):
             response.headers.update(updated_headers)
             warning_header_value = self.warning(response)
             if warning_header_value is not None:
-                response.headers.update({'Warning': warning_header_value})
+                response.headers.update({"Warning": warning_header_value})
 
         return response
 
@@ -56,15 +56,15 @@ class OneDayCache(BaseHeuristic):
     Cache the response by providing an expires 1 day in the
     future.
     """
+
     def update_headers(self, response):
         headers = {}
 
-        if 'expires' not in response.headers:
-            date = parsedate(response.headers['date'])
-            expires = expire_after(timedelta(days=1),
-                                   date=datetime(*date[:6]))
-            headers['expires'] = datetime_to_header(expires)
-            headers['cache-control'] = 'public'
+        if "expires" not in response.headers:
+            date = parsedate(response.headers["date"])
+            expires = expire_after(timedelta(days=1), date=datetime(*date[:6]))
+            headers["expires"] = datetime_to_header(expires)
+            headers["cache-control"] = "public"
         return headers
 
 
@@ -78,13 +78,10 @@ class ExpiresAfter(BaseHeuristic):
 
     def update_headers(self, response):
         expires = expire_after(self.delta)
-        return {
-            'expires': datetime_to_header(expires),
-            'cache-control': 'public',
-        }
+        return {"expires": datetime_to_header(expires), "cache-control": "public"}
 
     def warning(self, response):
-        tmpl = '110 - Automatically cached for %s. Response might be stale'
+        tmpl = "110 - Automatically cached for %s. Response might be stale"
         return tmpl % self.delta
 
 
@@ -100,27 +97,27 @@ class LastModified(BaseHeuristic):
     http://lxr.mozilla.org/mozilla-release/source/netwerk/protocol/http/nsHttpResponseHead.cpp#397
     Unlike mozilla we limit this to 24-hr.
     """
-    cacheable_by_default_statuses = set([
+    cacheable_by_default_statuses = {
         200, 203, 204, 206, 300, 301, 404, 405, 410, 414, 501
-    ])
+    }
 
     def update_headers(self, resp):
         headers = resp.headers
 
-        if 'expires' in headers:
+        if "expires" in headers:
             return {}
 
-        if 'cache-control' in headers and headers['cache-control'] != 'public':
+        if "cache-control" in headers and headers["cache-control"] != "public":
             return {}
 
         if resp.status not in self.cacheable_by_default_statuses:
             return {}
 
-        if 'date' not in headers or 'last-modified' not in headers:
+        if "date" not in headers or "last-modified" not in headers:
             return {}
 
-        date = calendar.timegm(parsedate_tz(headers['date']))
-        last_modified = parsedate(headers['last-modified'])
+        date = calendar.timegm(parsedate_tz(headers["date"]))
+        last_modified = parsedate(headers["last-modified"])
         if date is None or last_modified is None:
             return {}
 
@@ -132,7 +129,7 @@ class LastModified(BaseHeuristic):
             return {}
 
         expires = date + freshness_lifetime
-        return {'expires': time.strftime(TIME_FMT, time.gmtime(expires))}
+        return {"expires": time.strftime(TIME_FMT, time.gmtime(expires))}
 
     def warning(self, resp):
         return None
diff --git a/pipenv/patched/notpip/_vendor/cachecontrol/serialize.py b/pipenv/patched/notpip/_vendor/cachecontrol/serialize.py
index 0f552ba8..e7106c02 100644
--- a/pipenv/patched/notpip/_vendor/cachecontrol/serialize.py
+++ b/pipenv/patched/notpip/_vendor/cachecontrol/serialize.py
@@ -48,23 +48,22 @@ class Serializer(object):
             u"response": {
                 u"body": body,
                 u"headers": dict(
-                    (text_type(k), text_type(v))
-                    for k, v in response.headers.items()
+                    (text_type(k), text_type(v)) for k, v in response.headers.items()
                 ),
                 u"status": response.status,
                 u"version": response.version,
                 u"reason": text_type(response.reason),
                 u"strict": response.strict,
                 u"decode_content": response.decode_content,
-            },
+            }
         }
 
         # Construct our vary headers
         data[u"vary"] = {}
         if u"vary" in response_headers:
-            varied_headers = response_headers[u'vary'].split(',')
+            varied_headers = response_headers[u"vary"].split(",")
             for header in varied_headers:
-                header = header.strip()
+                header = text_type(header).strip()
                 header_value = request.headers.get(header, None)
                 if header_value is not None:
                     header_value = text_type(header_value)
@@ -95,7 +94,8 @@ class Serializer(object):
 
         # Dispatch to the actual load method for the given version
         try:
-            return getattr(self, "_loads_v{0}".format(ver))(request, data)
+            return getattr(self, "_loads_v{}".format(ver))(request, data)
+
         except AttributeError:
             # This is a version we don't have a loads function for, so we'll
             # just treat it as a miss and return None
@@ -118,11 +118,11 @@ class Serializer(object):
 
         body_raw = cached["response"].pop("body")
 
-        headers = CaseInsensitiveDict(data=cached['response']['headers'])
-        if headers.get('transfer-encoding', '') == 'chunked':
-            headers.pop('transfer-encoding')
+        headers = CaseInsensitiveDict(data=cached["response"]["headers"])
+        if headers.get("transfer-encoding", "") == "chunked":
+            headers.pop("transfer-encoding")
 
-        cached['response']['headers'] = headers
+        cached["response"]["headers"] = headers
 
         try:
             body = io.BytesIO(body_raw)
@@ -133,13 +133,9 @@ class Serializer(object):
             # fail with:
             #
             #     TypeError: 'str' does not support the buffer interface
-            body = io.BytesIO(body_raw.encode('utf8'))
+            body = io.BytesIO(body_raw.encode("utf8"))
 
-        return HTTPResponse(
-            body=body,
-            preload_content=False,
-            **cached["response"]
-        )
+        return HTTPResponse(body=body, preload_content=False, **cached["response"])
 
     def _loads_v0(self, request, data):
         # The original legacy cache data. This doesn't contain enough
@@ -162,16 +158,12 @@ class Serializer(object):
             return
 
         # We need to decode the items that we've base64 encoded
-        cached["response"]["body"] = _b64_decode_bytes(
-            cached["response"]["body"]
-        )
+        cached["response"]["body"] = _b64_decode_bytes(cached["response"]["body"])
         cached["response"]["headers"] = dict(
             (_b64_decode_str(k), _b64_decode_str(v))
             for k, v in cached["response"]["headers"].items()
         )
-        cached["response"]["reason"] = _b64_decode_str(
-            cached["response"]["reason"],
-        )
+        cached["response"]["reason"] = _b64_decode_str(cached["response"]["reason"])
         cached["vary"] = dict(
             (_b64_decode_str(k), _b64_decode_str(v) if v is not None else v)
             for k, v in cached["vary"].items()
@@ -187,7 +179,7 @@ class Serializer(object):
 
     def _loads_v4(self, request, data):
         try:
-            cached = msgpack.loads(data, encoding='utf-8')
+            cached = msgpack.loads(data, encoding="utf-8")
         except ValueError:
             return
 
diff --git a/pipenv/patched/notpip/_vendor/cachecontrol/wrapper.py b/pipenv/patched/notpip/_vendor/cachecontrol/wrapper.py
index b50a6e27..265bfc8b 100644
--- a/pipenv/patched/notpip/_vendor/cachecontrol/wrapper.py
+++ b/pipenv/patched/notpip/_vendor/cachecontrol/wrapper.py
@@ -2,14 +2,16 @@ from .adapter import CacheControlAdapter
 from .cache import DictCache
 
 
-def CacheControl(sess,
-                 cache=None,
-                 cache_etags=True,
-                 serializer=None,
-                 heuristic=None,
-                 controller_class=None,
-                 adapter_class=None,
-                 cacheable_methods=None):
+def CacheControl(
+    sess,
+    cache=None,
+    cache_etags=True,
+    serializer=None,
+    heuristic=None,
+    controller_class=None,
+    adapter_class=None,
+    cacheable_methods=None,
+):
 
     cache = cache or DictCache()
     adapter_class = adapter_class or CacheControlAdapter
@@ -19,9 +21,9 @@ def CacheControl(sess,
         serializer=serializer,
         heuristic=heuristic,
         controller_class=controller_class,
-        cacheable_methods=cacheable_methods
+        cacheable_methods=cacheable_methods,
     )
-    sess.mount('http://', adapter)
-    sess.mount('https://', adapter)
+    sess.mount("http://", adapter)
+    sess.mount("https://", adapter)
 
     return sess
diff --git a/pipenv/patched/notpip/_vendor/certifi/__init__.py b/pipenv/patched/notpip/_vendor/certifi/__init__.py
index 556193ce..aa329fbb 100644
--- a/pipenv/patched/notpip/_vendor/certifi/__init__.py
+++ b/pipenv/patched/notpip/_vendor/certifi/__init__.py
@@ -1,3 +1,3 @@
 from .core import where, old_where
 
-__version__ = "2018.01.18"
+__version__ = "2018.08.24"
diff --git a/pipenv/patched/notpip/_vendor/certifi/__main__.py b/pipenv/patched/notpip/_vendor/certifi/__main__.py
index 5f1da0dd..983ed0f9 100644
--- a/pipenv/patched/notpip/_vendor/certifi/__main__.py
+++ b/pipenv/patched/notpip/_vendor/certifi/__main__.py
@@ -1,2 +1,2 @@
-from certifi import where
+from pipenv.patched.notpip._vendor.certifi import where
 print(where())
diff --git a/pipenv/patched/notpip/_vendor/certifi/cacert.pem b/pipenv/patched/notpip/_vendor/certifi/cacert.pem
index 101ac98f..85de024e 100644
--- a/pipenv/patched/notpip/_vendor/certifi/cacert.pem
+++ b/pipenv/patched/notpip/_vendor/certifi/cacert.pem
@@ -3483,39 +3483,6 @@ AAoACxGV2lZFA4gKn2fQ1XmxqI1AbQ3CekD6819kR5LLU7m7Wc5P/dAVUwHY3+vZ
 5nbv0CO7O6l5s9UCKc2Jo5YPSjXnTkLAdc0Hz+Ys63su
 -----END CERTIFICATE-----
 
-# Issuer: CN=T\xdcRKTRUST Elektronik Sertifika Hizmet Sa\u011flay\u0131c\u0131s\u0131 H5 O=T\xdcRKTRUST Bilgi \u0130leti\u015fim ve Bili\u015fim G\xfcvenli\u011fi Hizmetleri A.\u015e.
-# Subject: CN=T\xdcRKTRUST Elektronik Sertifika Hizmet Sa\u011flay\u0131c\u0131s\u0131 H5 O=T\xdcRKTRUST Bilgi \u0130leti\u015fim ve Bili\u015fim G\xfcvenli\u011fi Hizmetleri A.\u015e.
-# Label: "T\xdcRKTRUST Elektronik Sertifika Hizmet Sa\u011flay\u0131c\u0131s\u0131 H5"
-# Serial: 156233699172481
-# MD5 Fingerprint: da:70:8e:f0:22:df:93:26:f6:5f:9f:d3:15:06:52:4e
-# SHA1 Fingerprint: c4:18:f6:4d:46:d1:df:00:3d:27:30:13:72:43:a9:12:11:c6:75:fb
-# SHA256 Fingerprint: 49:35:1b:90:34:44:c1:85:cc:dc:5c:69:3d:24:d8:55:5c:b2:08:d6:a8:14:13:07:69:9f:4a:f0:63:19:9d:78
------BEGIN CERTIFICATE-----
-MIIEJzCCAw+gAwIBAgIHAI4X/iQggTANBgkqhkiG9w0BAQsFADCBsTELMAkGA1UE
-BhMCVFIxDzANBgNVBAcMBkFua2FyYTFNMEsGA1UECgxEVMOcUktUUlVTVCBCaWxn
-aSDEsGxldGnFn2ltIHZlIEJpbGnFn2ltIEfDvHZlbmxpxJ9pIEhpem1ldGxlcmkg
-QS7Fni4xQjBABgNVBAMMOVTDnFJLVFJVU1QgRWxla3Ryb25payBTZXJ0aWZpa2Eg
-SGl6bWV0IFNhxJ9sYXnEsWPEsXPEsSBINTAeFw0xMzA0MzAwODA3MDFaFw0yMzA0
-MjgwODA3MDFaMIGxMQswCQYDVQQGEwJUUjEPMA0GA1UEBwwGQW5rYXJhMU0wSwYD
-VQQKDERUw5xSS1RSVVNUIEJpbGdpIMSwbGV0acWfaW0gdmUgQmlsacWfaW0gR8O8
-dmVubGnEn2kgSGl6bWV0bGVyaSBBLsWeLjFCMEAGA1UEAww5VMOcUktUUlVTVCBF
-bGVrdHJvbmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sxc8SxIEg1MIIB
-IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApCUZ4WWe60ghUEoI5RHwWrom
-/4NZzkQqL/7hzmAD/I0Dpe3/a6i6zDQGn1k19uwsu537jVJp45wnEFPzpALFp/kR
-Gml1bsMdi9GYjZOHp3GXDSHHmflS0yxjXVW86B8BSLlg/kJK9siArs1mep5Fimh3
-4khon6La8eHBEJ/rPCmBp+EyCNSgBbGM+42WAA4+Jd9ThiI7/PS98wl+d+yG6w8z
-5UNP9FR1bSmZLmZaQ9/LXMrI5Tjxfjs1nQ/0xVqhzPMggCTTV+wVunUlm+hkS7M0
-hO8EuPbJbKoCPrZV4jI3X/xml1/N1p7HIL9Nxqw/dV8c7TKcfGkAaZHjIxhT6QID
-AQABo0IwQDAdBgNVHQ4EFgQUVpkHHtOsDGlktAxQR95DLL4gwPswDgYDVR0PAQH/
-BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAJ5FdnsX
-SDLyOIspve6WSk6BGLFRRyDN0GSxDsnZAdkJzsiZ3GglE9Rc8qPoBP5yCccLqh0l
-VX6Wmle3usURehnmp349hQ71+S4pL+f5bFgWV1Al9j4uPqrtd3GqqpmWRgqujuwq
-URawXs3qZwQcWDD1YIq9pr1N5Za0/EKJAWv2cMhQOQwt1WbZyNKzMrcbGW3LM/nf
-peYVhDfwwvJllpKQd/Ct9JDpEXjXk4nAPQu6KfTomZ1yju2dL+6SfaHx/126M2CF
-Yv4HAqGEVka+lgqaE9chTLd8B59OTj+RdPsnnRHM3eaxynFNExc5JsUpISuTKWqW
-+qtB4Uu2NQvAmxU=
------END CERTIFICATE-----
-
 # Issuer: CN=Certinomis - Root CA O=Certinomis OU=0002 433998903
 # Subject: CN=Certinomis - Root CA O=Certinomis OU=0002 433998903
 # Label: "Certinomis - Root CA"
@@ -3725,169 +3692,6 @@ lSTAGiecMjvAwNW6qef4BENThe5SId6d9SWDPp5YSy/XZxMOIQIwBeF1Ad5o7Sof
 TUwJCA3sS61kFyjndc5FZXIhF8siQQ6ME5g4mlRtm8rifOoCWCKR
 -----END CERTIFICATE-----
 
-# Issuer: CN=Certplus Root CA G1 O=Certplus
-# Subject: CN=Certplus Root CA G1 O=Certplus
-# Label: "Certplus Root CA G1"
-# Serial: 1491911565779898356709731176965615564637713
-# MD5 Fingerprint: 7f:09:9c:f7:d9:b9:5c:69:69:56:d5:37:3e:14:0d:42
-# SHA1 Fingerprint: 22:fd:d0:b7:fd:a2:4e:0d:ac:49:2c:a0:ac:a6:7b:6a:1f:e3:f7:66
-# SHA256 Fingerprint: 15:2a:40:2b:fc:df:2c:d5:48:05:4d:22:75:b3:9c:7f:ca:3e:c0:97:80:78:b0:f0:ea:76:e5:61:a6:c7:43:3e
------BEGIN CERTIFICATE-----
-MIIFazCCA1OgAwIBAgISESBVg+QtPlRWhS2DN7cs3EYRMA0GCSqGSIb3DQEBDQUA
-MD4xCzAJBgNVBAYTAkZSMREwDwYDVQQKDAhDZXJ0cGx1czEcMBoGA1UEAwwTQ2Vy
-dHBsdXMgUm9vdCBDQSBHMTAeFw0xNDA1MjYwMDAwMDBaFw0zODAxMTUwMDAwMDBa
-MD4xCzAJBgNVBAYTAkZSMREwDwYDVQQKDAhDZXJ0cGx1czEcMBoGA1UEAwwTQ2Vy
-dHBsdXMgUm9vdCBDQSBHMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB
-ANpQh7bauKk+nWT6VjOaVj0W5QOVsjQcmm1iBdTYj+eJZJ+622SLZOZ5KmHNr49a
-iZFluVj8tANfkT8tEBXgfs+8/H9DZ6itXjYj2JizTfNDnjl8KvzsiNWI7nC9hRYt
-6kuJPKNxQv4c/dMcLRC4hlTqQ7jbxofaqK6AJc96Jh2qkbBIb6613p7Y1/oA/caP
-0FG7Yn2ksYyy/yARujVjBYZHYEMzkPZHogNPlk2dT8Hq6pyi/jQu3rfKG3akt62f
-6ajUeD94/vI4CTYd0hYCyOwqaK/1jpTvLRN6HkJKHRUxrgwEV/xhc/MxVoYxgKDE
-EW4wduOU8F8ExKyHcomYxZ3MVwia9Az8fXoFOvpHgDm2z4QTd28n6v+WZxcIbekN
-1iNQMLAVdBM+5S//Ds3EC0pd8NgAM0lm66EYfFkuPSi5YXHLtaW6uOrc4nBvCGrc
-h2c0798wct3zyT8j/zXhviEpIDCB5BmlIOklynMxdCm+4kLV87ImZsdo/Rmz5yCT
-mehd4F6H50boJZwKKSTUzViGUkAksnsPmBIgJPaQbEfIDbsYIC7Z/fyL8inqh3SV
-4EJQeIQEQWGw9CEjjy3LKCHyamz0GqbFFLQ3ZU+V/YDI+HLlJWvEYLF7bY5KinPO
-WftwenMGE9nTdDckQQoRb5fc5+R+ob0V8rqHDz1oihYHAgMBAAGjYzBhMA4GA1Ud
-DwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSowcCbkahDFXxd
-Bie0KlHYlwuBsTAfBgNVHSMEGDAWgBSowcCbkahDFXxdBie0KlHYlwuBsTANBgkq
-hkiG9w0BAQ0FAAOCAgEAnFZvAX7RvUz1isbwJh/k4DgYzDLDKTudQSk0YcbX8ACh
-66Ryj5QXvBMsdbRX7gp8CXrc1cqh0DQT+Hern+X+2B50ioUHj3/MeXrKls3N/U/7
-/SMNkPX0XtPGYX2eEeAC7gkE2Qfdpoq3DIMku4NQkv5gdRE+2J2winq14J2by5BS
-S7CTKtQ+FjPlnsZlFT5kOwQ/2wyPX1wdaR+v8+khjPPvl/aatxm2hHSco1S1cE5j
-2FddUyGbQJJD+tZ3VTNPZNX70Cxqjm0lpu+F6ALEUz65noe8zDUa3qHpimOHZR4R
-Kttjd5cUvpoUmRGywO6wT/gUITJDT5+rosuoD6o7BlXGEilXCNQ314cnrUlZp5Gr
-RHpejXDbl85IULFzk/bwg2D5zfHhMf1bfHEhYxQUqq/F3pN+aLHsIqKqkHWetUNy
-6mSjhEv9DKgma3GX7lZjZuhCVPnHHd/Qj1vfyDBviP4NxDMcU6ij/UgQ8uQKTuEV
-V/xuZDDCVRHc6qnNSlSsKWNEz0pAoNZoWRsz+e86i9sgktxChL8Bq4fA1SCC28a5
-g4VCXA9DO2pJNdWY9BW/+mGBDAkgGNLQFwzLSABQ6XaCjGTXOqAHVcweMcDvOrRl
-++O/QmueD6i9a5jc2NvLi6Td11n0bt3+qsOR0C5CB8AMTVPNJLFMWx5R9N/pkvo=
------END CERTIFICATE-----
-
-# Issuer: CN=Certplus Root CA G2 O=Certplus
-# Subject: CN=Certplus Root CA G2 O=Certplus
-# Label: "Certplus Root CA G2"
-# Serial: 1492087096131536844209563509228951875861589
-# MD5 Fingerprint: a7:ee:c4:78:2d:1b:ee:2d:b9:29:ce:d6:a7:96:32:31
-# SHA1 Fingerprint: 4f:65:8e:1f:e9:06:d8:28:02:e9:54:47:41:c9:54:25:5d:69:cc:1a
-# SHA256 Fingerprint: 6c:c0:50:41:e6:44:5e:74:69:6c:4c:fb:c9:f8:0f:54:3b:7e:ab:bb:44:b4:ce:6f:78:7c:6a:99:71:c4:2f:17
------BEGIN CERTIFICATE-----
-MIICHDCCAaKgAwIBAgISESDZkc6uo+jF5//pAq/Pc7xVMAoGCCqGSM49BAMDMD4x
-CzAJBgNVBAYTAkZSMREwDwYDVQQKDAhDZXJ0cGx1czEcMBoGA1UEAwwTQ2VydHBs
-dXMgUm9vdCBDQSBHMjAeFw0xNDA1MjYwMDAwMDBaFw0zODAxMTUwMDAwMDBaMD4x
-CzAJBgNVBAYTAkZSMREwDwYDVQQKDAhDZXJ0cGx1czEcMBoGA1UEAwwTQ2VydHBs
-dXMgUm9vdCBDQSBHMjB2MBAGByqGSM49AgEGBSuBBAAiA2IABM0PW1aC3/BFGtat
-93nwHcmsltaeTpwftEIRyoa/bfuFo8XlGVzX7qY/aWfYeOKmycTbLXku54uNAm8x
-Ik0G42ByRZ0OQneezs/lf4WbGOT8zC5y0xaTTsqZY1yhBSpsBqNjMGEwDgYDVR0P
-AQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFNqDYwJ5jtpMxjwj
-FNiPwyCrKGBZMB8GA1UdIwQYMBaAFNqDYwJ5jtpMxjwjFNiPwyCrKGBZMAoGCCqG
-SM49BAMDA2gAMGUCMHD+sAvZ94OX7PNVHdTcswYO/jOYnYs5kGuUIe22113WTNch
-p+e/IQ8rzfcq3IUHnQIxAIYUFuXcsGXCwI4Un78kFmjlvPl5adytRSv3tjFzzAal
-U5ORGpOucGpnutee5WEaXw==
------END CERTIFICATE-----
-
-# Issuer: CN=OpenTrust Root CA G1 O=OpenTrust
-# Subject: CN=OpenTrust Root CA G1 O=OpenTrust
-# Label: "OpenTrust Root CA G1"
-# Serial: 1492036577811947013770400127034825178844775
-# MD5 Fingerprint: 76:00:cc:81:29:cd:55:5e:88:6a:7a:2e:f7:4d:39:da
-# SHA1 Fingerprint: 79:91:e8:34:f7:e2:ee:dd:08:95:01:52:e9:55:2d:14:e9:58:d5:7e
-# SHA256 Fingerprint: 56:c7:71:28:d9:8c:18:d9:1b:4c:fd:ff:bc:25:ee:91:03:d4:75:8e:a2:ab:ad:82:6a:90:f3:45:7d:46:0e:b4
------BEGIN CERTIFICATE-----
-MIIFbzCCA1egAwIBAgISESCzkFU5fX82bWTCp59rY45nMA0GCSqGSIb3DQEBCwUA
-MEAxCzAJBgNVBAYTAkZSMRIwEAYDVQQKDAlPcGVuVHJ1c3QxHTAbBgNVBAMMFE9w
-ZW5UcnVzdCBSb290IENBIEcxMB4XDTE0MDUyNjA4NDU1MFoXDTM4MDExNTAwMDAw
-MFowQDELMAkGA1UEBhMCRlIxEjAQBgNVBAoMCU9wZW5UcnVzdDEdMBsGA1UEAwwU
-T3BlblRydXN0IFJvb3QgQ0EgRzEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK
-AoICAQD4eUbalsUwXopxAy1wpLuwxQjczeY1wICkES3d5oeuXT2R0odsN7faYp6b
-wiTXj/HbpqbfRm9RpnHLPhsxZ2L3EVs0J9V5ToybWL0iEA1cJwzdMOWo010hOHQX
-/uMftk87ay3bfWAfjH1MBcLrARYVmBSO0ZB3Ij/swjm4eTrwSSTilZHcYTSSjFR0
-77F9jAHiOH3BX2pfJLKOYheteSCtqx234LSWSE9mQxAGFiQD4eCcjsZGT44ameGP
-uY4zbGneWK2gDqdkVBFpRGZPTBKnjix9xNRbxQA0MMHZmf4yzgeEtE7NCv82TWLx
-p2NX5Ntqp66/K7nJ5rInieV+mhxNaMbBGN4zK1FGSxyO9z0M+Yo0FMT7MzUj8czx
-Kselu7Cizv5Ta01BG2Yospb6p64KTrk5M0ScdMGTHPjgniQlQ/GbI4Kq3ywgsNw2
-TgOzfALU5nsaqocTvz6hdLubDuHAk5/XpGbKuxs74zD0M1mKB3IDVedzagMxbm+W
-G+Oin6+Sx+31QrclTDsTBM8clq8cIqPQqwWyTBIjUtz9GVsnnB47ev1CI9sjgBPw
-vFEVVJSmdz7QdFG9URQIOTfLHzSpMJ1ShC5VkLG631UAC9hWLbFJSXKAqWLXwPYY
-EQRVzXR7z2FwefR7LFxckvzluFqrTJOVoSfupb7PcSNCupt2LQIDAQABo2MwYTAO
-BgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl0YhVyE1
-2jZVx/PxN3DlCPaTKbYwHwYDVR0jBBgwFoAUl0YhVyE12jZVx/PxN3DlCPaTKbYw
-DQYJKoZIhvcNAQELBQADggIBAB3dAmB84DWn5ph76kTOZ0BP8pNuZtQ5iSas000E
-PLuHIT839HEl2ku6q5aCgZG27dmxpGWX4m9kWaSW7mDKHyP7Rbr/jyTwyqkxf3kf
-gLMtMrpkZ2CvuVnN35pJ06iCsfmYlIrM4LvgBBuZYLFGZdwIorJGnkSI6pN+VxbS
-FXJfLkur1J1juONI5f6ELlgKn0Md/rcYkoZDSw6cMoYsYPXpSOqV7XAp8dUv/TW0
-V8/bhUiZucJvbI/NeJWsZCj9VrDDb8O+WVLhX4SPgPL0DTatdrOjteFkdjpY3H1P
-XlZs5VVZV6Xf8YpmMIzUUmI4d7S+KNfKNsSbBfD4Fdvb8e80nR14SohWZ25g/4/I
-i+GOvUKpMwpZQhISKvqxnUOOBZuZ2mKtVzazHbYNeS2WuOvyDEsMpZTGMKcmGS3t
-TAZQMPH9WD25SxdfGbRqhFS0OE85og2WaMMolP3tLR9Ka0OWLpABEPs4poEL0L91
-09S5zvE/bw4cHjdx5RiHdRk/ULlepEU0rbDK5uUTdg8xFKmOLZTW1YVNcxVPS/Ky
-Pu1svf0OnWZzsD2097+o4BGkxK51CUpjAEggpsadCwmKtODmzj7HPiY46SvepghJ
-AwSQiumPv+i2tCqjI40cHLI5kqiPAlxAOXXUc0ECd97N4EOH1uS6SsNsEn/+KuYj
-1oxx
------END CERTIFICATE-----
-
-# Issuer: CN=OpenTrust Root CA G2 O=OpenTrust
-# Subject: CN=OpenTrust Root CA G2 O=OpenTrust
-# Label: "OpenTrust Root CA G2"
-# Serial: 1492012448042702096986875987676935573415441
-# MD5 Fingerprint: 57:24:b6:59:24:6b:ae:c8:fe:1c:0c:20:f2:c0:4e:eb
-# SHA1 Fingerprint: 79:5f:88:60:c5:ab:7c:3d:92:e6:cb:f4:8d:e1:45:cd:11:ef:60:0b
-# SHA256 Fingerprint: 27:99:58:29:fe:6a:75:15:c1:bf:e8:48:f9:c4:76:1d:b1:6c:22:59:29:25:7b:f4:0d:08:94:f2:9e:a8:ba:f2
------BEGIN CERTIFICATE-----
-MIIFbzCCA1egAwIBAgISESChaRu/vbm9UpaPI+hIvyYRMA0GCSqGSIb3DQEBDQUA
-MEAxCzAJBgNVBAYTAkZSMRIwEAYDVQQKDAlPcGVuVHJ1c3QxHTAbBgNVBAMMFE9w
-ZW5UcnVzdCBSb290IENBIEcyMB4XDTE0MDUyNjAwMDAwMFoXDTM4MDExNTAwMDAw
-MFowQDELMAkGA1UEBhMCRlIxEjAQBgNVBAoMCU9wZW5UcnVzdDEdMBsGA1UEAwwU
-T3BlblRydXN0IFJvb3QgQ0EgRzIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK
-AoICAQDMtlelM5QQgTJT32F+D3Y5z1zCU3UdSXqWON2ic2rxb95eolq5cSG+Ntmh
-/LzubKh8NBpxGuga2F8ORAbtp+Dz0mEL4DKiltE48MLaARf85KxP6O6JHnSrT78e
-CbY2albz4e6WiWYkBuTNQjpK3eCasMSCRbP+yatcfD7J6xcvDH1urqWPyKwlCm/6
-1UWY0jUJ9gNDlP7ZvyCVeYCYitmJNbtRG6Q3ffyZO6v/v6wNj0OxmXsWEH4db0fE
-FY8ElggGQgT4hNYdvJGmQr5J1WqIP7wtUdGejeBSzFfdNTVY27SPJIjki9/ca1TS
-gSuyzpJLHB9G+h3Ykst2Z7UJmQnlrBcUVXDGPKBWCgOz3GIZ38i1MH/1PCZ1Eb3X
-G7OHngevZXHloM8apwkQHZOJZlvoPGIytbU6bumFAYueQ4xncyhZW+vj3CzMpSZy
-YhK05pyDRPZRpOLAeiRXyg6lPzq1O4vldu5w5pLeFlwoW5cZJ5L+epJUzpM5ChaH
-vGOz9bGTXOBut9Dq+WIyiET7vycotjCVXRIouZW+j1MY5aIYFuJWpLIsEPUdN6b4
-t/bQWVyJ98LVtZR00dX+G7bw5tYee9I8y6jj9RjzIR9u701oBnstXW5DiabA+aC/
-gh7PU3+06yzbXfZqfUAkBXKJOAGTy3HCOV0GEfZvePg3DTmEJwIDAQABo2MwYTAO
-BgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUajn6QiL3
-5okATV59M4PLuG53hq8wHwYDVR0jBBgwFoAUajn6QiL35okATV59M4PLuG53hq8w
-DQYJKoZIhvcNAQENBQADggIBAJjLq0A85TMCl38th6aP1F5Kr7ge57tx+4BkJamz
-Gj5oXScmp7oq4fBXgwpkTx4idBvpkF/wrM//T2h6OKQQbA2xx6R3gBi2oihEdqc0
-nXGEL8pZ0keImUEiyTCYYW49qKgFbdEfwFFEVn8nNQLdXpgKQuswv42hm1GqO+qT
-RmTFAHneIWv2V6CG1wZy7HBGS4tz3aAhdT7cHcCP009zHIXZ/n9iyJVvttN7jLpT
-wm+bREx50B1ws9efAvSyB7DH5fitIw6mVskpEndI2S9G/Tvw/HRwkqWOOAgfZDC2
-t0v7NqwQjqBSM2OdAzVWxWm9xiNaJ5T2pBL4LTM8oValX9YZ6e18CL13zSdkzJTa
-TkZQh+D5wVOAHrut+0dSixv9ovneDiK3PTNZbNTe9ZUGMg1RGUFcPk8G97krgCf2
-o6p6fAbhQ8MTOWIaNr3gKC6UAuQpLmBVrkA9sHSSXvAgZJY/X0VdiLWK2gKgW0VU
-3jg9CcCoSmVGFvyqv1ROTVu+OEO3KMqLM6oaJbolXCkvW0pujOotnCr2BXbgd5eA
-iN1nE28daCSLT7d0geX0YJ96Vdc+N9oWaz53rK4YcJUIeSkDiv7BO7M/Gg+kO14f
-WKGVyasvc0rQLW6aWQ9VGHgtPFGml4vmu7JwqkwR3v98KzfUetF3NI/n+UL3PIEM
-S1IK
------END CERTIFICATE-----
-
-# Issuer: CN=OpenTrust Root CA G3 O=OpenTrust
-# Subject: CN=OpenTrust Root CA G3 O=OpenTrust
-# Label: "OpenTrust Root CA G3"
-# Serial: 1492104908271485653071219941864171170455615
-# MD5 Fingerprint: 21:37:b4:17:16:92:7b:67:46:70:a9:96:d7:a8:13:24
-# SHA1 Fingerprint: 6e:26:64:f3:56:bf:34:55:bf:d1:93:3f:7c:01:de:d8:13:da:8a:a6
-# SHA256 Fingerprint: b7:c3:62:31:70:6e:81:07:8c:36:7c:b8:96:19:8f:1e:32:08:dd:92:69:49:dd:8f:57:09:a4:10:f7:5b:62:92
------BEGIN CERTIFICATE-----
-MIICITCCAaagAwIBAgISESDm+Ez8JLC+BUCs2oMbNGA/MAoGCCqGSM49BAMDMEAx
-CzAJBgNVBAYTAkZSMRIwEAYDVQQKDAlPcGVuVHJ1c3QxHTAbBgNVBAMMFE9wZW5U
-cnVzdCBSb290IENBIEczMB4XDTE0MDUyNjAwMDAwMFoXDTM4MDExNTAwMDAwMFow
-QDELMAkGA1UEBhMCRlIxEjAQBgNVBAoMCU9wZW5UcnVzdDEdMBsGA1UEAwwUT3Bl
-blRydXN0IFJvb3QgQ0EgRzMwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAARK7liuTcpm
-3gY6oxH84Bjwbhy6LTAMidnW7ptzg6kjFYwvWYpa3RTqnVkrQ7cG7DK2uu5Bta1d
-oYXM6h0UZqNnfkbilPPntlahFVmhTzeXuSIevRHr9LIfXsMUmuXZl5mjYzBhMA4G
-A1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRHd8MUi2I5
-DMlv4VBN0BBY3JWIbTAfBgNVHSMEGDAWgBRHd8MUi2I5DMlv4VBN0BBY3JWIbTAK
-BggqhkjOPQQDAwNpADBmAjEAj6jcnboMBBf6Fek9LykBl7+BFjNAk2z8+e2AcG+q
-j9uEwov1NcoG3GRvaBbhj5G5AjEA2Euly8LQCGzpGPta3U1fJAuwACEl74+nBCZx
-4nxp5V2a+EEfOzmTk51V6s2N8fvB
------END CERTIFICATE-----
-
 # Issuer: CN=ISRG Root X1 O=Internet Security Research Group
 # Subject: CN=ISRG Root X1 O=Internet Security Research Group
 # Label: "ISRG Root X1"
@@ -4431,3 +4235,66 @@ MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUW8pe5d7SgarNqC1kUbbZcpuX
 ytRrJPOwPYdGWBrssd9v+1a6cGvHOMzosYxPD/fxZ3YOg9AeUY8CMD32IygmTMZg
 h5Mmm7I1HrrW9zzRHM76JTymGoEVW/MSD2zuZYrJh6j5B+BimoxcSg==
 -----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R6
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R6
+# Label: "GlobalSign Root CA - R6"
+# Serial: 1417766617973444989252670301619537
+# MD5 Fingerprint: 4f:dd:07:e4:d4:22:64:39:1e:0c:37:42:ea:d1:c6:ae
+# SHA1 Fingerprint: 80:94:64:0e:b5:a7:a1:ca:11:9c:1f:dd:d5:9f:81:02:63:a7:fb:d1
+# SHA256 Fingerprint: 2c:ab:ea:fe:37:d0:6c:a2:2a:ba:73:91:c0:03:3d:25:98:29:52:c4:53:64:73:49:76:3a:3a:b5:ad:6c:cf:69
+-----BEGIN CERTIFICATE-----
+MIIFgzCCA2ugAwIBAgIORea7A4Mzw4VlSOb/RVEwDQYJKoZIhvcNAQEMBQAwTDEg
+MB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjYxEzARBgNVBAoTCkdsb2Jh
+bFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTQxMjEwMDAwMDAwWhcNMzQx
+MjEwMDAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSNjET
+MBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCAiIwDQYJ
+KoZIhvcNAQEBBQADggIPADCCAgoCggIBAJUH6HPKZvnsFMp7PPcNCPG0RQssgrRI
+xutbPK6DuEGSMxSkb3/pKszGsIhrxbaJ0cay/xTOURQh7ErdG1rG1ofuTToVBu1k
+ZguSgMpE3nOUTvOniX9PeGMIyBJQbUJmL025eShNUhqKGoC3GYEOfsSKvGRMIRxD
+aNc9PIrFsmbVkJq3MQbFvuJtMgamHvm566qjuL++gmNQ0PAYid/kD3n16qIfKtJw
+LnvnvJO7bVPiSHyMEAc4/2ayd2F+4OqMPKq0pPbzlUoSB239jLKJz9CgYXfIWHSw
+1CM69106yqLbnQneXUQtkPGBzVeS+n68UARjNN9rkxi+azayOeSsJDa38O+2HBNX
+k7besvjihbdzorg1qkXy4J02oW9UivFyVm4uiMVRQkQVlO6jxTiWm05OWgtH8wY2
+SXcwvHE35absIQh1/OZhFj931dmRl4QKbNQCTXTAFO39OfuD8l4UoQSwC+n+7o/h
+bguyCLNhZglqsQY6ZZZZwPA1/cnaKI0aEYdwgQqomnUdnjqGBQCe24DWJfncBZ4n
+WUx2OVvq+aWh2IMP0f/fMBH5hc8zSPXKbWQULHpYT9NLCEnFlWQaYw55PfWzjMpY
+rZxCRXluDocZXFSxZba/jJvcE+kNb7gu3GduyYsRtYQUigAZcIN5kZeR1Bonvzce
+MgfYFGM8KEyvAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTAD
+AQH/MB0GA1UdDgQWBBSubAWjkxPioufi1xzWx/B/yGdToDAfBgNVHSMEGDAWgBSu
+bAWjkxPioufi1xzWx/B/yGdToDANBgkqhkiG9w0BAQwFAAOCAgEAgyXt6NH9lVLN
+nsAEoJFp5lzQhN7craJP6Ed41mWYqVuoPId8AorRbrcWc+ZfwFSY1XS+wc3iEZGt
+Ixg93eFyRJa0lV7Ae46ZeBZDE1ZXs6KzO7V33EByrKPrmzU+sQghoefEQzd5Mr61
+55wsTLxDKZmOMNOsIeDjHfrYBzN2VAAiKrlNIC5waNrlU/yDXNOd8v9EDERm8tLj
+vUYAGm0CuiVdjaExUd1URhxN25mW7xocBFymFe944Hn+Xds+qkxV/ZoVqW/hpvvf
+cDDpw+5CRu3CkwWJ+n1jez/QcYF8AOiYrg54NMMl+68KnyBr3TsTjxKM4kEaSHpz
+oHdpx7Zcf4LIHv5YGygrqGytXm3ABdJ7t+uA/iU3/gKbaKxCXcPu9czc8FB10jZp
+nOZ7BN9uBmm23goJSFmH63sUYHpkqmlD75HHTOwY3WzvUy2MmeFe8nI+z1TIvWfs
+pA9MRf/TuTAjB0yPEL+GltmZWrSZVxykzLsViVO6LAUP5MSeGbEYNNVMnbrt9x+v
+JJUEeKgDu+6B5dpffItKoZB0JaezPkvILFa9x8jvOOJckvB595yEunQtYQEgfn7R
+8k8HWV+LLUNS60YMlOH1Zkd5d9VUWx+tJDfLRVpOoERIyNiwmcUVhAn21klJwGW4
+5hpxbqCo8YLoRT5s1gLXCmeDBVrJpBA=
+-----END CERTIFICATE-----
+
+# Issuer: CN=OISTE WISeKey Global Root GC CA O=WISeKey OU=OISTE Foundation Endorsed
+# Subject: CN=OISTE WISeKey Global Root GC CA O=WISeKey OU=OISTE Foundation Endorsed
+# Label: "OISTE WISeKey Global Root GC CA"
+# Serial: 44084345621038548146064804565436152554
+# MD5 Fingerprint: a9:d6:b9:2d:2f:93:64:f8:a5:69:ca:91:e9:68:07:23
+# SHA1 Fingerprint: e0:11:84:5e:34:de:be:88:81:b9:9c:f6:16:26:d1:96:1f:c3:b9:31
+# SHA256 Fingerprint: 85:60:f9:1c:36:24:da:ba:95:70:b5:fe:a0:db:e3:6f:f1:1a:83:23:be:94:86:85:4f:b3:f3:4a:55:71:19:8d
+-----BEGIN CERTIFICATE-----
+MIICaTCCAe+gAwIBAgIQISpWDK7aDKtARb8roi066jAKBggqhkjOPQQDAzBtMQsw
+CQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUgRm91
+bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9iYWwg
+Um9vdCBHQyBDQTAeFw0xNzA1MDkwOTQ4MzRaFw00MjA1MDkwOTU4MzNaMG0xCzAJ
+BgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBGb3Vu
+ZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2JhbCBS
+b290IEdDIENBMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAETOlQwMYPchi82PG6s4ni
+eUqjFqdrVCTbUf/q9Akkwwsin8tqJ4KBDdLArzHkdIJuyiXZjHWd8dvQmqJLIX4W
+p2OQ0jnUsYd4XxiWD1AbNTcPasbc2RNNpI6QN+a9WzGRo1QwUjAOBgNVHQ8BAf8E
+BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSIcUrOPDnpBgOtfKie7T
+rYy0UGYwEAYJKwYBBAGCNxUBBAMCAQAwCgYIKoZIzj0EAwMDaAAwZQIwJsdpW9zV
+57LnyAyMjMPdeYwbY9XJUpROTYJKcx6ygISpJcBMWm1JKWB4E+J+SOtkAjEA2zQg
+Mgj/mkkCtojeFK9dbJlxjRo/i9fgojaGHAeCOnZT/cKi7e97sIBPWA9LUzm9
+-----END CERTIFICATE-----
diff --git a/pipenv/patched/notpip/_vendor/distlib/t32.exe b/pipenv/patched/notpip/_vendor/distlib/t32.exe
old mode 100755
new mode 100644
diff --git a/pipenv/patched/notpip/_vendor/distlib/t64.exe b/pipenv/patched/notpip/_vendor/distlib/t64.exe
old mode 100755
new mode 100644
diff --git a/pipenv/patched/notpip/_vendor/distlib/w32.exe b/pipenv/patched/notpip/_vendor/distlib/w32.exe
old mode 100755
new mode 100644
diff --git a/pipenv/patched/notpip/_vendor/distlib/w64.exe b/pipenv/patched/notpip/_vendor/distlib/w64.exe
old mode 100755
new mode 100644
diff --git a/pipenv/patched/notpip/_vendor/distro.py b/pipenv/patched/notpip/_vendor/distro.py
index 39bfce79..aa4defc3 100644
--- a/pipenv/patched/notpip/_vendor/distro.py
+++ b/pipenv/patched/notpip/_vendor/distro.py
@@ -1,4 +1,4 @@
-# Copyright 2015,2016 Nir Cohen
+# Copyright 2015,2016,2017 Nir Cohen
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -23,7 +23,7 @@ functionality. An alternative implementation became necessary because Python
 3.5 deprecated this function, and Python 3.7 is expected to remove it
 altogether. Its predecessor function :py:func:`platform.dist` was already
 deprecated since Python 2.6 and is also expected to be removed in Python 3.7.
-Still, there are many cases in which access to Linux distribution information
+Still, there are many cases in which access to OS distribution information
 is needed. See `Python issue 1322 <https://bugs.python.org/issue1322>`_ for
 more information.
 """
@@ -94,7 +94,7 @@ _DISTRO_RELEASE_IGNORE_BASENAMES = (
 
 def linux_distribution(full_distribution_name=True):
     """
-    Return information about the current Linux distribution as a tuple
+    Return information about the current OS distribution as a tuple
     ``(id_name, version, codename)`` with items as follows:
 
     * ``id_name``:  If *full_distribution_name* is false, the result of
@@ -110,22 +110,22 @@ def linux_distribution(full_distribution_name=True):
 
     The data it returns may not exactly be the same, because it uses more data
     sources than the original function, and that may lead to different data if
-    the Linux distribution is not consistent across multiple data sources it
+    the OS distribution is not consistent across multiple data sources it
     provides (there are indeed such distributions ...).
 
     Another reason for differences is the fact that the :func:`distro.id`
     method normalizes the distro ID string to a reliable machine-readable value
-    for a number of popular Linux distributions.
+    for a number of popular OS distributions.
     """
     return _distro.linux_distribution(full_distribution_name)
 
 
 def id():
     """
-    Return the distro ID of the current Linux distribution, as a
+    Return the distro ID of the current distribution, as a
     machine-readable string.
 
-    For a number of Linux distributions, the returned distro ID value is
+    For a number of OS distributions, the returned distro ID value is
     *reliable*, in the sense that it is documented and that it does not change
     across releases of the distribution.
 
@@ -158,6 +158,9 @@ def id():
     "scientific"    Scientific Linux
     "slackware"     Slackware
     "xenserver"     XenServer
+    "openbsd"       OpenBSD
+    "netbsd"        NetBSD
+    "freebsd"       FreeBSD
     ==============  =========================================
 
     If you have a need to get distros for reliable IDs added into this set,
@@ -187,7 +190,7 @@ def id():
     * a normalization of the ID is performed, based upon
       `normalization tables`_. The purpose of this normalization is to ensure
       that the ID is as reliable as possible, even across incompatible changes
-      in the Linux distributions. A common reason for an incompatible change is
+      in the OS distributions. A common reason for an incompatible change is
       the addition of an os-release file, or the addition of the lsb_release
       command, with ID values that differ from what was previously determined
       from the distro release file name.
@@ -197,7 +200,7 @@ def id():
 
 def name(pretty=False):
     """
-    Return the name of the current Linux distribution, as a human-readable
+    Return the name of the current OS distribution, as a human-readable
     string.
 
     If *pretty* is false, the name is returned without version or codename.
@@ -236,7 +239,7 @@ def name(pretty=False):
 
 def version(pretty=False, best=False):
     """
-    Return the version of the current Linux distribution, as a human-readable
+    Return the version of the current OS distribution, as a human-readable
     string.
 
     If *pretty* is false, the version is returned without codename (e.g.
@@ -280,7 +283,7 @@ def version(pretty=False, best=False):
 
 def version_parts(best=False):
     """
-    Return the version of the current Linux distribution as a tuple
+    Return the version of the current OS distribution as a tuple
     ``(major, minor, build_number)`` with items as follows:
 
     * ``major``:  The result of :func:`distro.major_version`.
@@ -297,7 +300,7 @@ def version_parts(best=False):
 
 def major_version(best=False):
     """
-    Return the major version of the current Linux distribution, as a string,
+    Return the major version of the current OS distribution, as a string,
     if provided.
     Otherwise, the empty string is returned. The major version is the first
     part of the dot-separated version string.
@@ -310,7 +313,7 @@ def major_version(best=False):
 
 def minor_version(best=False):
     """
-    Return the minor version of the current Linux distribution, as a string,
+    Return the minor version of the current OS distribution, as a string,
     if provided.
     Otherwise, the empty string is returned. The minor version is the second
     part of the dot-separated version string.
@@ -323,7 +326,7 @@ def minor_version(best=False):
 
 def build_number(best=False):
     """
-    Return the build number of the current Linux distribution, as a string,
+    Return the build number of the current OS distribution, as a string,
     if provided.
     Otherwise, the empty string is returned. The build number is the third part
     of the dot-separated version string.
@@ -337,7 +340,7 @@ def build_number(best=False):
 def like():
     """
     Return a space-separated list of distro IDs of distributions that are
-    closely related to the current Linux distribution in regards to packaging
+    closely related to the current OS distribution in regards to packaging
     and programming interfaces, for example distributions the current
     distribution is a derivative from.
 
@@ -353,7 +356,7 @@ def like():
 
 def codename():
     """
-    Return the codename for the release of the current Linux distribution,
+    Return the codename for the release of the current OS distribution,
     as a string.
 
     If the distribution does not have a codename, an empty string is returned.
@@ -377,7 +380,7 @@ def codename():
 
 def info(pretty=False, best=False):
     """
-    Return certain machine-readable information items about the current Linux
+    Return certain machine-readable information items about the current OS
     distribution in a dictionary, as shown in the following example:
 
     .. sourcecode:: python
@@ -422,7 +425,7 @@ def info(pretty=False, best=False):
 def os_release_info():
     """
     Return a dictionary containing key-value pairs for the information items
-    from the os-release file data source of the current Linux distribution.
+    from the os-release file data source of the current OS distribution.
 
     See `os-release file`_ for details about these information items.
     """
@@ -432,7 +435,7 @@ def os_release_info():
 def lsb_release_info():
     """
     Return a dictionary containing key-value pairs for the information items
-    from the lsb_release command data source of the current Linux distribution.
+    from the lsb_release command data source of the current OS distribution.
 
     See `lsb_release command output`_ for details about these information
     items.
@@ -443,17 +446,25 @@ def lsb_release_info():
 def distro_release_info():
     """
     Return a dictionary containing key-value pairs for the information items
-    from the distro release file data source of the current Linux distribution.
+    from the distro release file data source of the current OS distribution.
 
     See `distro release file`_ for details about these information items.
     """
     return _distro.distro_release_info()
 
 
+def uname_info():
+    """
+    Return a dictionary containing key-value pairs for the information items
+    from the distro release file data source of the current OS distribution.
+    """
+    return _distro.uname_info()
+
+
 def os_release_attr(attribute):
     """
     Return a single named information item from the os-release file data source
-    of the current Linux distribution.
+    of the current OS distribution.
 
     Parameters:
 
@@ -472,7 +483,7 @@ def os_release_attr(attribute):
 def lsb_release_attr(attribute):
     """
     Return a single named information item from the lsb_release command output
-    data source of the current Linux distribution.
+    data source of the current OS distribution.
 
     Parameters:
 
@@ -492,7 +503,7 @@ def lsb_release_attr(attribute):
 def distro_release_attr(attribute):
     """
     Return a single named information item from the distro release file
-    data source of the current Linux distribution.
+    data source of the current OS distribution.
 
     Parameters:
 
@@ -508,6 +519,23 @@ def distro_release_attr(attribute):
     return _distro.distro_release_attr(attribute)
 
 
+def uname_attr(attribute):
+    """
+    Return a single named information item from the distro release file
+    data source of the current OS distribution.
+
+    Parameters:
+
+    * ``attribute`` (string): Key of the information item.
+
+    Returns:
+
+    * (string): Value of the information item, if the item exists.
+                The empty string, if the item does not exist.
+    """
+    return _distro.uname_attr(attribute)
+
+
 class cached_property(object):
     """A version of @property which caches the value.  On access, it calls the
     underlying function and sets the value in `__dict__` so future accesses
@@ -525,13 +553,13 @@ class cached_property(object):
 
 class LinuxDistribution(object):
     """
-    Provides information about a Linux distribution.
+    Provides information about a OS distribution.
 
     This package creates a private module-global instance of this class with
     default initialization arguments, that is used by the
     `consolidated accessor functions`_ and `single source accessor functions`_.
     By using default initialization arguments, that module-global instance
-    returns data about the current Linux distribution (i.e. the distro this
+    returns data about the current OS distribution (i.e. the distro this
     package runs on).
 
     Normally, it is not necessary to create additional instances of this class.
@@ -544,7 +572,8 @@ class LinuxDistribution(object):
     def __init__(self,
                  include_lsb=True,
                  os_release_file='',
-                 distro_release_file=''):
+                 distro_release_file='',
+                 include_uname=True):
         """
         The initialization method of this class gathers information from the
         available data sources, and stores that in private instance attributes.
@@ -578,6 +607,11 @@ class LinuxDistribution(object):
           distro release file can be found, the data source for the distro
           release file will be empty.
 
+        * ``include_name`` (bool): Controls whether uname command output is
+          included as a data source. If the uname command is not available in
+          the program execution path the data source for the uname command will
+          be empty.
+
         Public instance attributes:
 
         * ``os_release_file`` (string): The path name of the
@@ -591,6 +625,10 @@ class LinuxDistribution(object):
         * ``include_lsb`` (bool): The result of the ``include_lsb`` parameter.
           This controls whether the lsb information will be loaded.
 
+        * ``include_uname`` (bool): The result of the ``include_uname``
+          parameter. This controls whether the uname information will
+          be loaded.
+
         Raises:
 
         * :py:exc:`IOError`: Some I/O issue with an os-release file or distro
@@ -607,6 +645,7 @@ class LinuxDistribution(object):
             os.path.join(_UNIXCONFDIR, _OS_RELEASE_BASENAME)
         self.distro_release_file = distro_release_file or ''  # updated later
         self.include_lsb = include_lsb
+        self.include_uname = include_uname
 
     def __repr__(self):
         """Return repr of all info
@@ -616,14 +655,16 @@ class LinuxDistribution(object):
             "os_release_file={self.os_release_file!r}, " \
             "distro_release_file={self.distro_release_file!r}, " \
             "include_lsb={self.include_lsb!r}, " \
+            "include_uname={self.include_uname!r}, " \
             "_os_release_info={self._os_release_info!r}, " \
             "_lsb_release_info={self._lsb_release_info!r}, " \
-            "_distro_release_info={self._distro_release_info!r})".format(
+            "_distro_release_info={self._distro_release_info!r}, " \
+            "_uname_info={self._uname_info!r})".format(
                 self=self)
 
     def linux_distribution(self, full_distribution_name=True):
         """
-        Return information about the Linux distribution that is compatible
+        Return information about the OS distribution that is compatible
         with Python's :func:`platform.linux_distribution`, supporting a subset
         of its parameters.
 
@@ -636,7 +677,7 @@ class LinuxDistribution(object):
         )
 
     def id(self):
-        """Return the distro ID of the Linux distribution, as a string.
+        """Return the distro ID of the OS distribution, as a string.
 
         For details, see :func:`distro.id`.
         """
@@ -656,22 +697,28 @@ class LinuxDistribution(object):
         if distro_id:
             return normalize(distro_id, NORMALIZED_DISTRO_ID)
 
+        distro_id = self.uname_attr('id')
+        if distro_id:
+            return normalize(distro_id, NORMALIZED_DISTRO_ID)
+
         return ''
 
     def name(self, pretty=False):
         """
-        Return the name of the Linux distribution, as a string.
+        Return the name of the OS distribution, as a string.
 
         For details, see :func:`distro.name`.
         """
         name = self.os_release_attr('name') \
             or self.lsb_release_attr('distributor_id') \
-            or self.distro_release_attr('name')
+            or self.distro_release_attr('name') \
+            or self.uname_attr('name')
         if pretty:
             name = self.os_release_attr('pretty_name') \
                 or self.lsb_release_attr('description')
             if not name:
-                name = self.distro_release_attr('name')
+                name = self.distro_release_attr('name') \
+                       or self.uname_attr('name')
                 version = self.version(pretty=True)
                 if version:
                     name = name + ' ' + version
@@ -679,7 +726,7 @@ class LinuxDistribution(object):
 
     def version(self, pretty=False, best=False):
         """
-        Return the version of the Linux distribution, as a string.
+        Return the version of the OS distribution, as a string.
 
         For details, see :func:`distro.version`.
         """
@@ -690,7 +737,8 @@ class LinuxDistribution(object):
             self._parse_distro_release_content(
                 self.os_release_attr('pretty_name')).get('version_id', ''),
             self._parse_distro_release_content(
-                self.lsb_release_attr('description')).get('version_id', '')
+                self.lsb_release_attr('description')).get('version_id', ''),
+            self.uname_attr('release')
         ]
         version = ''
         if best:
@@ -712,7 +760,7 @@ class LinuxDistribution(object):
 
     def version_parts(self, best=False):
         """
-        Return the version of the Linux distribution, as a tuple of version
+        Return the version of the OS distribution, as a tuple of version
         numbers.
 
         For details, see :func:`distro.version_parts`.
@@ -736,7 +784,7 @@ class LinuxDistribution(object):
 
     def minor_version(self, best=False):
         """
-        Return the minor version number of the Linux distribution.
+        Return the minor version number of the current distribution.
 
         For details, see :func:`distro.minor_version`.
         """
@@ -744,7 +792,7 @@ class LinuxDistribution(object):
 
     def build_number(self, best=False):
         """
-        Return the build number of the Linux distribution.
+        Return the build number of the current distribution.
 
         For details, see :func:`distro.build_number`.
         """
@@ -752,7 +800,7 @@ class LinuxDistribution(object):
 
     def like(self):
         """
-        Return the IDs of distributions that are like the Linux distribution.
+        Return the IDs of distributions that are like the OS distribution.
 
         For details, see :func:`distro.like`.
         """
@@ -760,7 +808,7 @@ class LinuxDistribution(object):
 
     def codename(self):
         """
-        Return the codename of the Linux distribution.
+        Return the codename of the OS distribution.
 
         For details, see :func:`distro.codename`.
         """
@@ -771,7 +819,7 @@ class LinuxDistribution(object):
 
     def info(self, pretty=False, best=False):
         """
-        Return certain machine-readable information about the Linux
+        Return certain machine-readable information about the OS
         distribution.
 
         For details, see :func:`distro.info`.
@@ -791,7 +839,7 @@ class LinuxDistribution(object):
     def os_release_info(self):
         """
         Return a dictionary containing key-value pairs for the information
-        items from the os-release file data source of the Linux distribution.
+        items from the os-release file data source of the OS distribution.
 
         For details, see :func:`distro.os_release_info`.
         """
@@ -800,7 +848,7 @@ class LinuxDistribution(object):
     def lsb_release_info(self):
         """
         Return a dictionary containing key-value pairs for the information
-        items from the lsb_release command data source of the Linux
+        items from the lsb_release command data source of the OS
         distribution.
 
         For details, see :func:`distro.lsb_release_info`.
@@ -810,17 +858,25 @@ class LinuxDistribution(object):
     def distro_release_info(self):
         """
         Return a dictionary containing key-value pairs for the information
-        items from the distro release file data source of the Linux
+        items from the distro release file data source of the OS
         distribution.
 
         For details, see :func:`distro.distro_release_info`.
         """
         return self._distro_release_info
 
+    def uname_info(self):
+        """
+        Return a dictionary containing key-value pairs for the information
+        items from the uname command data source of the OS distribution.
+
+        For details, see :func:`distro.uname_info`.
+        """
+
     def os_release_attr(self, attribute):
         """
         Return a single named information item from the os-release file data
-        source of the Linux distribution.
+        source of the OS distribution.
 
         For details, see :func:`distro.os_release_attr`.
         """
@@ -829,7 +885,7 @@ class LinuxDistribution(object):
     def lsb_release_attr(self, attribute):
         """
         Return a single named information item from the lsb_release command
-        output data source of the Linux distribution.
+        output data source of the OS distribution.
 
         For details, see :func:`distro.lsb_release_attr`.
         """
@@ -838,12 +894,21 @@ class LinuxDistribution(object):
     def distro_release_attr(self, attribute):
         """
         Return a single named information item from the distro release file
-        data source of the Linux distribution.
+        data source of the OS distribution.
 
         For details, see :func:`distro.distro_release_attr`.
         """
         return self._distro_release_info.get(attribute, '')
 
+    def uname_attr(self, attribute):
+        """
+        Return a single named information item from the uname command
+        output data source of the OS distribution.
+
+        For details, see :func:`distro.uname_release_attr`.
+        """
+        return self._uname_info.get(attribute, '')
+
     @cached_property
     def _os_release_info(self):
         """
@@ -960,6 +1025,34 @@ class LinuxDistribution(object):
             props.update({k.replace(' ', '_').lower(): v.strip()})
         return props
 
+    @cached_property
+    def _uname_info(self):
+        with open(os.devnull, 'w') as devnull:
+            try:
+                cmd = ('uname', '-rs')
+                stdout = subprocess.check_output(cmd, stderr=devnull)
+            except OSError:
+                return {}
+        content = stdout.decode(sys.getfilesystemencoding()).splitlines()
+        return self._parse_uname_content(content)
+
+    @staticmethod
+    def _parse_uname_content(lines):
+        props = {}
+        match = re.search(r'^([^\s]+)\s+([\d\.]+)', lines[0].strip())
+        if match:
+            name, version = match.groups()
+
+            # This is to prevent the Linux kernel version from
+            # appearing as the 'best' version on otherwise
+            # identifiable distributions.
+            if name == 'Linux':
+                return {}
+            props['id'] = name.lower()
+            props['name'] = name
+            props['release'] = version
+        return props
+
     @cached_property
     def _distro_release_info(self):
         """
@@ -1082,7 +1175,7 @@ def main():
     logger.setLevel(logging.DEBUG)
     logger.addHandler(logging.StreamHandler(sys.stdout))
 
-    parser = argparse.ArgumentParser(description="Linux distro info tool")
+    parser = argparse.ArgumentParser(description="OS distro info tool")
     parser.add_argument(
         '--json',
         '-j',
diff --git a/pipenv/patched/notpip/_vendor/idna/LICENSE.rst b/pipenv/patched/notpip/_vendor/idna/LICENSE.rst
index 9d38815e..3ee64fba 100644
--- a/pipenv/patched/notpip/_vendor/idna/LICENSE.rst
+++ b/pipenv/patched/notpip/_vendor/idna/LICENSE.rst
@@ -1,7 +1,7 @@
 License
 -------
 
-Copyright (c) 2013-2017, Kim Davies. All rights reserved.
+Copyright (c) 2013-2018, Kim Davies. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
diff --git a/pipenv/patched/notpip/_vendor/idna/core.py b/pipenv/patched/notpip/_vendor/idna/core.py
index b55b6645..090c2c18 100644
--- a/pipenv/patched/notpip/_vendor/idna/core.py
+++ b/pipenv/patched/notpip/_vendor/idna/core.py
@@ -34,7 +34,11 @@ class InvalidCodepointContext(IDNAError):
 
 
 def _combining_class(cp):
-    return unicodedata.combining(unichr(cp))
+    v = unicodedata.combining(unichr(cp))
+    if v == 0:
+        if not unicodedata.name(unichr(cp)):
+            raise ValueError("Unknown character in unicodedata")
+    return v
 
 def _is_script(cp, script):
     return intranges_contain(ord(cp), idnadata.scripts[script])
@@ -71,7 +75,6 @@ def check_bidi(label, check_ltr=False):
             raise IDNABidiError('Unknown directionality in label {0} at position {1}'.format(repr(label), idx))
         if direction in ['R', 'AL', 'AN']:
             bidi_label = True
-            break
     if not bidi_label and not check_ltr:
         return True
 
@@ -244,8 +247,13 @@ def check_label(label):
         if intranges_contain(cp_value, idnadata.codepoint_classes['PVALID']):
             continue
         elif intranges_contain(cp_value, idnadata.codepoint_classes['CONTEXTJ']):
-            if not valid_contextj(label, pos):
-                raise InvalidCodepointContext('Joiner {0} not allowed at position {1} in {2}'.format(_unot(cp_value), pos+1, repr(label)))
+            try:
+                if not valid_contextj(label, pos):
+                    raise InvalidCodepointContext('Joiner {0} not allowed at position {1} in {2}'.format(
+                        _unot(cp_value), pos+1, repr(label)))
+            except ValueError:
+                raise IDNAError('Unknown codepoint adjacent to joiner {0} at position {1} in {2}'.format(
+                    _unot(cp_value), pos+1, repr(label)))
         elif intranges_contain(cp_value, idnadata.codepoint_classes['CONTEXTO']):
             if not valid_contexto(label, pos):
                 raise InvalidCodepointContext('Codepoint {0} not allowed at position {1} in {2}'.format(_unot(cp_value), pos+1, repr(label)))
@@ -317,10 +325,10 @@ def uts46_remap(domain, std3_rules=True, transitional=False):
             replacement = uts46row[2] if len(uts46row) == 3 else None
             if (status == "V" or
                     (status == "D" and not transitional) or
-                    (status == "3" and std3_rules and replacement is None)):
+                    (status == "3" and not std3_rules and replacement is None)):
                 output += char
             elif replacement is not None and (status == "M" or
-                    (status == "3" and std3_rules) or
+                    (status == "3" and not std3_rules) or
                     (status == "D" and transitional)):
                 output += replacement
             elif status != "I":
@@ -344,15 +352,17 @@ def encode(s, strict=False, uts46=False, std3_rules=False, transitional=False):
         labels = s.split('.')
     else:
         labels = _unicode_dots_re.split(s)
-    while labels and not labels[0]:
-        del labels[0]
-    if not labels:
+    if not labels or labels == ['']:
         raise IDNAError('Empty domain')
     if labels[-1] == '':
         del labels[-1]
         trailing_dot = True
     for label in labels:
-        result.append(alabel(label))
+        s = alabel(label)
+        if s:
+            result.append(s)
+        else:
+            raise IDNAError('Empty label')
     if trailing_dot:
         result.append(b'')
     s = b'.'.join(result)
@@ -373,15 +383,17 @@ def decode(s, strict=False, uts46=False, std3_rules=False):
         labels = _unicode_dots_re.split(s)
     else:
         labels = s.split(u'.')
-    while labels and not labels[0]:
-        del labels[0]
-    if not labels:
+    if not labels or labels == ['']:
         raise IDNAError('Empty domain')
     if not labels[-1]:
         del labels[-1]
         trailing_dot = True
     for label in labels:
-        result.append(ulabel(label))
+        s = ulabel(label)
+        if s:
+            result.append(s)
+        else:
+            raise IDNAError('Empty label')
     if trailing_dot:
         result.append(u'')
     return u'.'.join(result)
diff --git a/pipenv/patched/notpip/_vendor/idna/idnadata.py b/pipenv/patched/notpip/_vendor/idna/idnadata.py
index c48f1b50..17974e23 100644
--- a/pipenv/patched/notpip/_vendor/idna/idnadata.py
+++ b/pipenv/patched/notpip/_vendor/idna/idnadata.py
@@ -1,11 +1,12 @@
 # This file is automatically generated by tools/idna-data
 
-__version__ = "6.3.0"
+__version__ = "10.0.0"
 scripts = {
     'Greek': (
         0x37000000374,
         0x37500000378,
         0x37a0000037e,
+        0x37f00000380,
         0x38400000385,
         0x38600000387,
         0x3880000038b,
@@ -34,7 +35,9 @@ scripts = {
         0x1ff200001ff5,
         0x1ff600001fff,
         0x212600002127,
-        0x101400001018b,
+        0xab650000ab66,
+        0x101400001018f,
+        0x101a0000101a1,
         0x1d2000001d246,
     ),
     'Han': (
@@ -46,12 +49,14 @@ scripts = {
         0x30210000302a,
         0x30380000303c,
         0x340000004db6,
-        0x4e0000009fcd,
+        0x4e0000009feb,
         0xf9000000fa6e,
         0xfa700000fada,
         0x200000002a6d7,
         0x2a7000002b735,
         0x2b7400002b81e,
+        0x2b8200002cea2,
+        0x2ceb00002ebe1,
         0x2f8000002fa1e,
     ),
     'Hebrew': (
@@ -68,7 +73,7 @@ scripts = {
     'Hiragana': (
         0x304100003097,
         0x309d000030a0,
-        0x1b0010001b002,
+        0x1b0010001b11f,
         0x1f2000001f201,
     ),
     'Katakana': (
@@ -88,6 +93,7 @@ joining_types = {
     0x602: 85,
     0x603: 85,
     0x604: 85,
+    0x605: 85,
     0x608: 85,
     0x60b: 85,
     0x620: 68,
@@ -365,7 +371,7 @@ joining_types = {
     0x844: 68,
     0x845: 68,
     0x846: 82,
-    0x847: 68,
+    0x847: 82,
     0x848: 68,
     0x849: 82,
     0x84a: 68,
@@ -373,7 +379,7 @@ joining_types = {
     0x84c: 68,
     0x84d: 68,
     0x84e: 68,
-    0x84f: 82,
+    0x84f: 68,
     0x850: 68,
     0x851: 68,
     0x852: 68,
@@ -383,7 +389,19 @@ joining_types = {
     0x856: 85,
     0x857: 85,
     0x858: 85,
+    0x860: 68,
+    0x861: 85,
+    0x862: 68,
+    0x863: 68,
+    0x864: 68,
+    0x865: 68,
+    0x866: 85,
+    0x867: 82,
+    0x868: 68,
+    0x869: 82,
+    0x86a: 82,
     0x8a0: 68,
+    0x8a1: 68,
     0x8a2: 68,
     0x8a3: 68,
     0x8a4: 68,
@@ -395,6 +413,23 @@ joining_types = {
     0x8aa: 82,
     0x8ab: 82,
     0x8ac: 82,
+    0x8ad: 85,
+    0x8ae: 82,
+    0x8af: 68,
+    0x8b0: 68,
+    0x8b1: 82,
+    0x8b2: 82,
+    0x8b3: 68,
+    0x8b4: 68,
+    0x8b6: 68,
+    0x8b7: 68,
+    0x8b8: 68,
+    0x8b9: 82,
+    0x8ba: 68,
+    0x8bb: 68,
+    0x8bc: 68,
+    0x8bd: 68,
+    0x8e2: 85,
     0x1806: 85,
     0x1807: 68,
     0x180a: 67,
@@ -492,8 +527,8 @@ joining_types = {
     0x1882: 85,
     0x1883: 85,
     0x1884: 85,
-    0x1885: 85,
-    0x1886: 85,
+    0x1885: 84,
+    0x1886: 84,
     0x1887: 68,
     0x1888: 68,
     0x1889: 68,
@@ -531,6 +566,7 @@ joining_types = {
     0x18aa: 68,
     0x200c: 85,
     0x200d: 67,
+    0x202f: 85,
     0x2066: 85,
     0x2067: 85,
     0x2068: 85,
@@ -587,6 +623,141 @@ joining_types = {
     0xa871: 68,
     0xa872: 76,
     0xa873: 85,
+    0x10ac0: 68,
+    0x10ac1: 68,
+    0x10ac2: 68,
+    0x10ac3: 68,
+    0x10ac4: 68,
+    0x10ac5: 82,
+    0x10ac6: 85,
+    0x10ac7: 82,
+    0x10ac8: 85,
+    0x10ac9: 82,
+    0x10aca: 82,
+    0x10acb: 85,
+    0x10acc: 85,
+    0x10acd: 76,
+    0x10ace: 82,
+    0x10acf: 82,
+    0x10ad0: 82,
+    0x10ad1: 82,
+    0x10ad2: 82,
+    0x10ad3: 68,
+    0x10ad4: 68,
+    0x10ad5: 68,
+    0x10ad6: 68,
+    0x10ad7: 76,
+    0x10ad8: 68,
+    0x10ad9: 68,
+    0x10ada: 68,
+    0x10adb: 68,
+    0x10adc: 68,
+    0x10add: 82,
+    0x10ade: 68,
+    0x10adf: 68,
+    0x10ae0: 68,
+    0x10ae1: 82,
+    0x10ae2: 85,
+    0x10ae3: 85,
+    0x10ae4: 82,
+    0x10aeb: 68,
+    0x10aec: 68,
+    0x10aed: 68,
+    0x10aee: 68,
+    0x10aef: 82,
+    0x10b80: 68,
+    0x10b81: 82,
+    0x10b82: 68,
+    0x10b83: 82,
+    0x10b84: 82,
+    0x10b85: 82,
+    0x10b86: 68,
+    0x10b87: 68,
+    0x10b88: 68,
+    0x10b89: 82,
+    0x10b8a: 68,
+    0x10b8b: 68,
+    0x10b8c: 82,
+    0x10b8d: 68,
+    0x10b8e: 82,
+    0x10b8f: 82,
+    0x10b90: 68,
+    0x10b91: 82,
+    0x10ba9: 82,
+    0x10baa: 82,
+    0x10bab: 82,
+    0x10bac: 82,
+    0x10bad: 68,
+    0x10bae: 68,
+    0x10baf: 85,
+    0x1e900: 68,
+    0x1e901: 68,
+    0x1e902: 68,
+    0x1e903: 68,
+    0x1e904: 68,
+    0x1e905: 68,
+    0x1e906: 68,
+    0x1e907: 68,
+    0x1e908: 68,
+    0x1e909: 68,
+    0x1e90a: 68,
+    0x1e90b: 68,
+    0x1e90c: 68,
+    0x1e90d: 68,
+    0x1e90e: 68,
+    0x1e90f: 68,
+    0x1e910: 68,
+    0x1e911: 68,
+    0x1e912: 68,
+    0x1e913: 68,
+    0x1e914: 68,
+    0x1e915: 68,
+    0x1e916: 68,
+    0x1e917: 68,
+    0x1e918: 68,
+    0x1e919: 68,
+    0x1e91a: 68,
+    0x1e91b: 68,
+    0x1e91c: 68,
+    0x1e91d: 68,
+    0x1e91e: 68,
+    0x1e91f: 68,
+    0x1e920: 68,
+    0x1e921: 68,
+    0x1e922: 68,
+    0x1e923: 68,
+    0x1e924: 68,
+    0x1e925: 68,
+    0x1e926: 68,
+    0x1e927: 68,
+    0x1e928: 68,
+    0x1e929: 68,
+    0x1e92a: 68,
+    0x1e92b: 68,
+    0x1e92c: 68,
+    0x1e92d: 68,
+    0x1e92e: 68,
+    0x1e92f: 68,
+    0x1e930: 68,
+    0x1e931: 68,
+    0x1e932: 68,
+    0x1e933: 68,
+    0x1e934: 68,
+    0x1e935: 68,
+    0x1e936: 68,
+    0x1e937: 68,
+    0x1e938: 68,
+    0x1e939: 68,
+    0x1e93a: 68,
+    0x1e93b: 68,
+    0x1e93c: 68,
+    0x1e93d: 68,
+    0x1e93e: 68,
+    0x1e93f: 68,
+    0x1e940: 68,
+    0x1e941: 68,
+    0x1e942: 68,
+    0x1e943: 68,
 }
 codepoint_classes = {
     'PVALID': (
@@ -858,6 +1029,10 @@ codepoint_classes = {
         0x52300000524,
         0x52500000526,
         0x52700000528,
+        0x5290000052a,
+        0x52b0000052c,
+        0x52d0000052e,
+        0x52f00000530,
         0x5590000055a,
         0x56100000587,
         0x591000005be,
@@ -881,15 +1056,14 @@ codepoint_classes = {
         0x7c0000007f6,
         0x8000000082e,
         0x8400000085c,
-        0x8a0000008a1,
-        0x8a2000008ad,
-        0x8e4000008ff,
-        0x90000000958,
+        0x8600000086b,
+        0x8a0000008b5,
+        0x8b6000008be,
+        0x8d4000008e2,
+        0x8e300000958,
         0x96000000964,
         0x96600000970,
-        0x97100000978,
-        0x97900000980,
-        0x98100000984,
+        0x97100000984,
         0x9850000098d,
         0x98f00000991,
         0x993000009a9,
@@ -902,6 +1076,7 @@ codepoint_classes = {
         0x9d7000009d8,
         0x9e0000009e4,
         0x9e6000009f2,
+        0x9fc000009fd,
         0xa0100000a04,
         0xa0500000a0b,
         0xa0f00000a11,
@@ -930,6 +1105,7 @@ codepoint_classes = {
         0xad000000ad1,
         0xae000000ae4,
         0xae600000af0,
+        0xaf900000b00,
         0xb0100000b04,
         0xb0500000b0d,
         0xb0f00000b11,
@@ -960,20 +1136,19 @@ codepoint_classes = {
         0xbd000000bd1,
         0xbd700000bd8,
         0xbe600000bf0,
-        0xc0100000c04,
+        0xc0000000c04,
         0xc0500000c0d,
         0xc0e00000c11,
         0xc1200000c29,
-        0xc2a00000c34,
-        0xc3500000c3a,
+        0xc2a00000c3a,
         0xc3d00000c45,
         0xc4600000c49,
         0xc4a00000c4e,
         0xc5500000c57,
-        0xc5800000c5a,
+        0xc5800000c5b,
         0xc6000000c64,
         0xc6600000c70,
-        0xc8200000c84,
+        0xc8000000c84,
         0xc8500000c8d,
         0xc8e00000c91,
         0xc9200000ca9,
@@ -987,15 +1162,14 @@ codepoint_classes = {
         0xce000000ce4,
         0xce600000cf0,
         0xcf100000cf3,
-        0xd0200000d04,
+        0xd0000000d04,
         0xd0500000d0d,
         0xd0e00000d11,
-        0xd1200000d3b,
-        0xd3d00000d45,
+        0xd1200000d45,
         0xd4600000d49,
         0xd4a00000d4f,
-        0xd5700000d58,
-        0xd6000000d64,
+        0xd5400000d58,
+        0xd5f00000d64,
         0xd6600000d70,
         0xd7a00000d80,
         0xd8200000d84,
@@ -1008,6 +1182,7 @@ codepoint_classes = {
         0xdcf00000dd5,
         0xdd600000dd7,
         0xdd800000de0,
+        0xde600000df0,
         0xdf200000df4,
         0xe0100000e33,
         0xe3400000e3b,
@@ -1082,11 +1257,12 @@ codepoint_classes = {
         0x13180000135b,
         0x135d00001360,
         0x138000001390,
-        0x13a0000013f5,
+        0x13a0000013f6,
         0x14010000166d,
         0x166f00001680,
         0x16810000169b,
         0x16a0000016eb,
+        0x16f1000016f9,
         0x17000000170d,
         0x170e00001715,
         0x172000001735,
@@ -1103,7 +1279,7 @@ codepoint_classes = {
         0x182000001878,
         0x1880000018ab,
         0x18b0000018f6,
-        0x19000000191d,
+        0x19000000191f,
         0x19200000192c,
         0x19300000193c,
         0x19460000196e,
@@ -1117,6 +1293,7 @@ codepoint_classes = {
         0x1a7f00001a8a,
         0x1a9000001a9a,
         0x1aa700001aa8,
+        0x1ab000001abe,
         0x1b0000001b4c,
         0x1b5000001b5a,
         0x1b6b00001b74,
@@ -1125,15 +1302,15 @@ codepoint_classes = {
         0x1c4000001c4a,
         0x1c4d00001c7e,
         0x1cd000001cd3,
-        0x1cd400001cf7,
+        0x1cd400001cfa,
         0x1d0000001d2c,
         0x1d2f00001d30,
         0x1d3b00001d3c,
         0x1d4e00001d4f,
         0x1d6b00001d78,
         0x1d7900001d9b,
-        0x1dc000001de7,
-        0x1dfc00001e00,
+        0x1dc000001dfa,
+        0x1dfb00001e00,
         0x1e0100001e02,
         0x1e0300001e04,
         0x1e0500001e06,
@@ -1367,11 +1544,11 @@ codepoint_classes = {
         0x309d0000309f,
         0x30a1000030fb,
         0x30fc000030ff,
-        0x31050000312e,
+        0x31050000312f,
         0x31a0000031bb,
         0x31f000003200,
         0x340000004db6,
-        0x4e0000009fcd,
+        0x4e0000009feb,
         0xa0000000a48d,
         0xa4d00000a4fe,
         0xa5000000a60d,
@@ -1413,7 +1590,9 @@ codepoint_classes = {
         0xa6930000a694,
         0xa6950000a696,
         0xa6970000a698,
-        0xa69f0000a6e6,
+        0xa6990000a69a,
+        0xa69b0000a69c,
+        0xa69e0000a6e6,
         0xa6f00000a6f2,
         0xa7170000a720,
         0xa7230000a724,
@@ -1463,30 +1642,39 @@ codepoint_classes = {
         0xa7850000a786,
         0xa7870000a789,
         0xa78c0000a78d,
-        0xa78e0000a78f,
+        0xa78e0000a790,
         0xa7910000a792,
-        0xa7930000a794,
+        0xa7930000a796,
+        0xa7970000a798,
+        0xa7990000a79a,
+        0xa79b0000a79c,
+        0xa79d0000a79e,
+        0xa79f0000a7a0,
         0xa7a10000a7a2,
         0xa7a30000a7a4,
         0xa7a50000a7a6,
         0xa7a70000a7a8,
         0xa7a90000a7aa,
+        0xa7b50000a7b6,
+        0xa7b70000a7b8,
+        0xa7f70000a7f8,
         0xa7fa0000a828,
         0xa8400000a874,
-        0xa8800000a8c5,
+        0xa8800000a8c6,
         0xa8d00000a8da,
         0xa8e00000a8f8,
         0xa8fb0000a8fc,
+        0xa8fd0000a8fe,
         0xa9000000a92e,
         0xa9300000a954,
         0xa9800000a9c1,
         0xa9cf0000a9da,
+        0xa9e00000a9ff,
         0xaa000000aa37,
         0xaa400000aa4e,
         0xaa500000aa5a,
         0xaa600000aa77,
-        0xaa7a0000aa7c,
-        0xaa800000aac3,
+        0xaa7a0000aac3,
         0xaadb0000aade,
         0xaae00000aaf0,
         0xaaf20000aaf7,
@@ -1495,6 +1683,8 @@ codepoint_classes = {
         0xab110000ab17,
         0xab200000ab27,
         0xab280000ab2f,
+        0xab300000ab5b,
+        0xab600000ab66,
         0xabc00000abeb,
         0xabec0000abee,
         0xabf00000abfa,
@@ -1507,7 +1697,7 @@ codepoint_classes = {
         0xfa230000fa25,
         0xfa270000fa2a,
         0xfb1e0000fb1f,
-        0xfe200000fe27,
+        0xfe200000fe30,
         0xfe730000fe74,
         0x100000001000c,
         0x1000d00010027,
@@ -1519,20 +1709,32 @@ codepoint_classes = {
         0x101fd000101fe,
         0x102800001029d,
         0x102a0000102d1,
-        0x103000001031f,
-        0x1033000010341,
+        0x102e0000102e1,
+        0x1030000010320,
+        0x1032d00010341,
         0x103420001034a,
+        0x103500001037b,
         0x103800001039e,
         0x103a0000103c4,
         0x103c8000103d0,
         0x104280001049e,
         0x104a0000104aa,
+        0x104d8000104fc,
+        0x1050000010528,
+        0x1053000010564,
+        0x1060000010737,
+        0x1074000010756,
+        0x1076000010768,
         0x1080000010806,
         0x1080800010809,
         0x1080a00010836,
         0x1083700010839,
         0x1083c0001083d,
         0x1083f00010856,
+        0x1086000010877,
+        0x108800001089f,
+        0x108e0000108f3,
+        0x108f4000108f6,
         0x1090000010916,
         0x109200001093a,
         0x10980000109b8,
@@ -1545,31 +1747,137 @@ codepoint_classes = {
         0x10a3800010a3b,
         0x10a3f00010a40,
         0x10a6000010a7d,
+        0x10a8000010a9d,
+        0x10ac000010ac8,
+        0x10ac900010ae7,
         0x10b0000010b36,
         0x10b4000010b56,
         0x10b6000010b73,
+        0x10b8000010b92,
         0x10c0000010c49,
+        0x10cc000010cf3,
         0x1100000011047,
         0x1106600011070,
-        0x11080000110bb,
+        0x1107f000110bb,
         0x110d0000110e9,
         0x110f0000110fa,
         0x1110000011135,
         0x1113600011140,
+        0x1115000011174,
+        0x1117600011177,
         0x11180000111c5,
-        0x111d0000111da,
+        0x111ca000111cd,
+        0x111d0000111db,
+        0x111dc000111dd,
+        0x1120000011212,
+        0x1121300011238,
+        0x1123e0001123f,
+        0x1128000011287,
+        0x1128800011289,
+        0x1128a0001128e,
+        0x1128f0001129e,
+        0x1129f000112a9,
+        0x112b0000112eb,
+        0x112f0000112fa,
+        0x1130000011304,
+        0x113050001130d,
+        0x1130f00011311,
+        0x1131300011329,
+        0x1132a00011331,
+        0x1133200011334,
+        0x113350001133a,
+        0x1133c00011345,
+        0x1134700011349,
+        0x1134b0001134e,
+        0x1135000011351,
+        0x1135700011358,
+        0x1135d00011364,
+        0x113660001136d,
+        0x1137000011375,
+        0x114000001144b,
+        0x114500001145a,
+        0x11480000114c6,
+        0x114c7000114c8,
+        0x114d0000114da,
+        0x11580000115b6,
+        0x115b8000115c1,
+        0x115d8000115de,
+        0x1160000011641,
+        0x1164400011645,
+        0x116500001165a,
         0x11680000116b8,
         0x116c0000116ca,
-        0x120000001236f,
+        0x117000001171a,
+        0x1171d0001172c,
+        0x117300001173a,
+        0x118c0000118ea,
+        0x118ff00011900,
+        0x11a0000011a3f,
+        0x11a4700011a48,
+        0x11a5000011a84,
+        0x11a8600011a9a,
+        0x11ac000011af9,
+        0x11c0000011c09,
+        0x11c0a00011c37,
+        0x11c3800011c41,
+        0x11c5000011c5a,
+        0x11c7200011c90,
+        0x11c9200011ca8,
+        0x11ca900011cb7,
+        0x11d0000011d07,
+        0x11d0800011d0a,
+        0x11d0b00011d37,
+        0x11d3a00011d3b,
+        0x11d3c00011d3e,
+        0x11d3f00011d48,
+        0x11d5000011d5a,
+        0x120000001239a,
+        0x1248000012544,
         0x130000001342f,
+        0x1440000014647,
         0x1680000016a39,
+        0x16a4000016a5f,
+        0x16a6000016a6a,
+        0x16ad000016aee,
+        0x16af000016af5,
+        0x16b0000016b37,
+        0x16b4000016b44,
+        0x16b5000016b5a,
+        0x16b6300016b78,
+        0x16b7d00016b90,
         0x16f0000016f45,
         0x16f5000016f7f,
         0x16f8f00016fa0,
-        0x1b0000001b002,
+        0x16fe000016fe2,
+        0x17000000187ed,
+        0x1880000018af3,
+        0x1b0000001b11f,
+        0x1b1700001b2fc,
+        0x1bc000001bc6b,
+        0x1bc700001bc7d,
+        0x1bc800001bc89,
+        0x1bc900001bc9a,
+        0x1bc9d0001bc9f,
+        0x1da000001da37,
+        0x1da3b0001da6d,
+        0x1da750001da76,
+        0x1da840001da85,
+        0x1da9b0001daa0,
+        0x1daa10001dab0,
+        0x1e0000001e007,
+        0x1e0080001e019,
+        0x1e01b0001e022,
+        0x1e0230001e025,
+        0x1e0260001e02b,
+        0x1e8000001e8c5,
+        0x1e8d00001e8d7,
+        0x1e9220001e94b,
+        0x1e9500001e95a,
         0x200000002a6d7,
         0x2a7000002b735,
         0x2b7400002b81e,
+        0x2b8200002cea2,
+        0x2ceb00002ebe1,
     ),
     'CONTEXTJ': (
         0x200c0000200e,
diff --git a/pipenv/patched/notpip/_vendor/idna/package_data.py b/pipenv/patched/notpip/_vendor/idna/package_data.py
index fc331392..39c192ba 100644
--- a/pipenv/patched/notpip/_vendor/idna/package_data.py
+++ b/pipenv/patched/notpip/_vendor/idna/package_data.py
@@ -1,2 +1,2 @@
-__version__ = '2.6'
+__version__ = '2.7'
 
diff --git a/pipenv/patched/notpip/_vendor/idna/uts46data.py b/pipenv/patched/notpip/_vendor/idna/uts46data.py
index f9b3236f..79731cb9 100644
--- a/pipenv/patched/notpip/_vendor/idna/uts46data.py
+++ b/pipenv/patched/notpip/_vendor/idna/uts46data.py
@@ -4,7 +4,7 @@
 """IDNA Mapping Table from UTS46."""
 
 
-__version__ = "6.3.0"
+__version__ = "10.0.0"
 def _seg_0():
     return [
     (0x0, '3'),
@@ -635,7 +635,8 @@ def _seg_6():
     (0x37A, '3', u' ι'),
     (0x37B, 'V'),
     (0x37E, '3', u';'),
-    (0x37F, 'X'),
+    (0x37F, 'M', u'ϳ'),
+    (0x380, 'X'),
     (0x384, '3', u' ́'),
     (0x385, '3', u' ̈́'),
     (0x386, 'M', u'ά'),
@@ -730,11 +731,11 @@ def _seg_6():
     (0x400, 'M', u'ѐ'),
     (0x401, 'M', u'ё'),
     (0x402, 'M', u'ђ'),
-    (0x403, 'M', u'ѓ'),
     ]
 
 def _seg_7():
     return [
+    (0x403, 'M', u'ѓ'),
     (0x404, 'M', u'є'),
     (0x405, 'M', u'ѕ'),
     (0x406, 'M', u'і'),
@@ -834,11 +835,11 @@ def _seg_7():
     (0x49B, 'V'),
     (0x49C, 'M', u'ҝ'),
     (0x49D, 'V'),
-    (0x49E, 'M', u'ҟ'),
     ]
 
 def _seg_8():
     return [
+    (0x49E, 'M', u'ҟ'),
     (0x49F, 'V'),
     (0x4A0, 'M', u'ҡ'),
     (0x4A1, 'V'),
@@ -938,11 +939,11 @@ def _seg_8():
     (0x500, 'M', u'ԁ'),
     (0x501, 'V'),
     (0x502, 'M', u'ԃ'),
-    (0x503, 'V'),
     ]
 
 def _seg_9():
     return [
+    (0x503, 'V'),
     (0x504, 'M', u'ԅ'),
     (0x505, 'V'),
     (0x506, 'M', u'ԇ'),
@@ -979,7 +980,15 @@ def _seg_9():
     (0x525, 'V'),
     (0x526, 'M', u'ԧ'),
     (0x527, 'V'),
-    (0x528, 'X'),
+    (0x528, 'M', u'ԩ'),
+    (0x529, 'V'),
+    (0x52A, 'M', u'ԫ'),
+    (0x52B, 'V'),
+    (0x52C, 'M', u'ԭ'),
+    (0x52D, 'V'),
+    (0x52E, 'M', u'ԯ'),
+    (0x52F, 'V'),
+    (0x530, 'X'),
     (0x531, 'M', u'ա'),
     (0x532, 'M', u'բ'),
     (0x533, 'M', u'գ'),
@@ -1026,7 +1035,7 @@ def _seg_9():
     (0x588, 'X'),
     (0x589, 'V'),
     (0x58B, 'X'),
-    (0x58F, 'V'),
+    (0x58D, 'V'),
     (0x590, 'X'),
     (0x591, 'V'),
     (0x5C8, 'X'),
@@ -1034,6 +1043,10 @@ def _seg_9():
     (0x5EB, 'X'),
     (0x5F0, 'V'),
     (0x5F5, 'X'),
+    ]
+
+def _seg_10():
+    return [
     (0x606, 'V'),
     (0x61C, 'X'),
     (0x61E, 'V'),
@@ -1043,10 +1056,6 @@ def _seg_9():
     (0x678, 'M', u'يٴ'),
     (0x679, 'V'),
     (0x6DD, 'X'),
-    ]
-
-def _seg_10():
-    return [
     (0x6DE, 'V'),
     (0x70E, 'X'),
     (0x710, 'V'),
@@ -1063,13 +1072,15 @@ def _seg_10():
     (0x85C, 'X'),
     (0x85E, 'V'),
     (0x85F, 'X'),
+    (0x860, 'V'),
+    (0x86B, 'X'),
     (0x8A0, 'V'),
-    (0x8A1, 'X'),
-    (0x8A2, 'V'),
-    (0x8AD, 'X'),
-    (0x8E4, 'V'),
-    (0x8FF, 'X'),
-    (0x900, 'V'),
+    (0x8B5, 'X'),
+    (0x8B6, 'V'),
+    (0x8BE, 'X'),
+    (0x8D4, 'V'),
+    (0x8E2, 'X'),
+    (0x8E3, 'V'),
     (0x958, 'M', u'क़'),
     (0x959, 'M', u'ख़'),
     (0x95A, 'M', u'ग़'),
@@ -1079,10 +1090,6 @@ def _seg_10():
     (0x95E, 'M', u'फ़'),
     (0x95F, 'M', u'य़'),
     (0x960, 'V'),
-    (0x978, 'X'),
-    (0x979, 'V'),
-    (0x980, 'X'),
-    (0x981, 'V'),
     (0x984, 'X'),
     (0x985, 'V'),
     (0x98D, 'X'),
@@ -1111,7 +1118,7 @@ def _seg_10():
     (0x9E0, 'V'),
     (0x9E4, 'X'),
     (0x9E6, 'V'),
-    (0x9FC, 'X'),
+    (0x9FE, 'X'),
     (0xA01, 'V'),
     (0xA04, 'X'),
     (0xA05, 'V'),
@@ -1140,6 +1147,10 @@ def _seg_10():
     (0xA4E, 'X'),
     (0xA51, 'V'),
     (0xA52, 'X'),
+    ]
+
+def _seg_11():
+    return [
     (0xA59, 'M', u'ਖ਼'),
     (0xA5A, 'M', u'ਗ਼'),
     (0xA5B, 'M', u'ਜ਼'),
@@ -1147,10 +1158,6 @@ def _seg_10():
     (0xA5D, 'X'),
     (0xA5E, 'M', u'ਫ਼'),
     (0xA5F, 'X'),
-    ]
-
-def _seg_11():
-    return [
     (0xA66, 'V'),
     (0xA76, 'X'),
     (0xA81, 'V'),
@@ -1179,6 +1186,8 @@ def _seg_11():
     (0xAE4, 'X'),
     (0xAE6, 'V'),
     (0xAF2, 'X'),
+    (0xAF9, 'V'),
+    (0xB00, 'X'),
     (0xB01, 'V'),
     (0xB04, 'X'),
     (0xB05, 'V'),
@@ -1240,8 +1249,12 @@ def _seg_11():
     (0xBD8, 'X'),
     (0xBE6, 'V'),
     (0xBFB, 'X'),
-    (0xC01, 'V'),
+    (0xC00, 'V'),
     (0xC04, 'X'),
+    ]
+
+def _seg_12():
+    return [
     (0xC05, 'V'),
     (0xC0D, 'X'),
     (0xC0E, 'V'),
@@ -1249,12 +1262,6 @@ def _seg_11():
     (0xC12, 'V'),
     (0xC29, 'X'),
     (0xC2A, 'V'),
-    (0xC34, 'X'),
-    (0xC35, 'V'),
-    ]
-
-def _seg_12():
-    return [
     (0xC3A, 'X'),
     (0xC3D, 'V'),
     (0xC45, 'X'),
@@ -1265,14 +1272,12 @@ def _seg_12():
     (0xC55, 'V'),
     (0xC57, 'X'),
     (0xC58, 'V'),
-    (0xC5A, 'X'),
+    (0xC5B, 'X'),
     (0xC60, 'V'),
     (0xC64, 'X'),
     (0xC66, 'V'),
     (0xC70, 'X'),
     (0xC78, 'V'),
-    (0xC80, 'X'),
-    (0xC82, 'V'),
     (0xC84, 'X'),
     (0xC85, 'V'),
     (0xC8D, 'X'),
@@ -1300,27 +1305,21 @@ def _seg_12():
     (0xCF0, 'X'),
     (0xCF1, 'V'),
     (0xCF3, 'X'),
-    (0xD02, 'V'),
+    (0xD00, 'V'),
     (0xD04, 'X'),
     (0xD05, 'V'),
     (0xD0D, 'X'),
     (0xD0E, 'V'),
     (0xD11, 'X'),
     (0xD12, 'V'),
-    (0xD3B, 'X'),
-    (0xD3D, 'V'),
     (0xD45, 'X'),
     (0xD46, 'V'),
     (0xD49, 'X'),
     (0xD4A, 'V'),
-    (0xD4F, 'X'),
-    (0xD57, 'V'),
-    (0xD58, 'X'),
-    (0xD60, 'V'),
+    (0xD50, 'X'),
+    (0xD54, 'V'),
     (0xD64, 'X'),
     (0xD66, 'V'),
-    (0xD76, 'X'),
-    (0xD79, 'V'),
     (0xD80, 'X'),
     (0xD82, 'V'),
     (0xD84, 'X'),
@@ -1342,6 +1341,8 @@ def _seg_12():
     (0xDD7, 'X'),
     (0xDD8, 'V'),
     (0xDE0, 'X'),
+    (0xDE6, 'V'),
+    (0xDF0, 'X'),
     (0xDF2, 'V'),
     (0xDF5, 'X'),
     (0xE01, 'V'),
@@ -1354,11 +1355,11 @@ def _seg_12():
     (0xE83, 'X'),
     (0xE84, 'V'),
     (0xE85, 'X'),
-    (0xE87, 'V'),
     ]
 
 def _seg_13():
     return [
+    (0xE87, 'V'),
     (0xE89, 'X'),
     (0xE8A, 'V'),
     (0xE8B, 'X'),
@@ -1458,11 +1459,11 @@ def _seg_13():
     (0x124E, 'X'),
     (0x1250, 'V'),
     (0x1257, 'X'),
-    (0x1258, 'V'),
     ]
 
 def _seg_14():
     return [
+    (0x1258, 'V'),
     (0x1259, 'X'),
     (0x125A, 'V'),
     (0x125E, 'X'),
@@ -1493,13 +1494,20 @@ def _seg_14():
     (0x1380, 'V'),
     (0x139A, 'X'),
     (0x13A0, 'V'),
-    (0x13F5, 'X'),
+    (0x13F6, 'X'),
+    (0x13F8, 'M', u'Ᏸ'),
+    (0x13F9, 'M', u'Ᏹ'),
+    (0x13FA, 'M', u'Ᏺ'),
+    (0x13FB, 'M', u'Ᏻ'),
+    (0x13FC, 'M', u'Ᏼ'),
+    (0x13FD, 'M', u'Ᏽ'),
+    (0x13FE, 'X'),
     (0x1400, 'V'),
     (0x1680, 'X'),
     (0x1681, 'V'),
     (0x169D, 'X'),
     (0x16A0, 'V'),
-    (0x16F1, 'X'),
+    (0x16F9, 'X'),
     (0x1700, 'V'),
     (0x170D, 'X'),
     (0x170E, 'V'),
@@ -1536,7 +1544,7 @@ def _seg_14():
     (0x18B0, 'V'),
     (0x18F6, 'X'),
     (0x1900, 'V'),
-    (0x191D, 'X'),
+    (0x191F, 'X'),
     (0x1920, 'V'),
     (0x192C, 'X'),
     (0x1930, 'V'),
@@ -1555,6 +1563,10 @@ def _seg_14():
     (0x19DB, 'X'),
     (0x19DE, 'V'),
     (0x1A1C, 'X'),
+    ]
+
+def _seg_15():
+    return [
     (0x1A1E, 'V'),
     (0x1A5F, 'X'),
     (0x1A60, 'V'),
@@ -1563,12 +1575,10 @@ def _seg_14():
     (0x1A8A, 'X'),
     (0x1A90, 'V'),
     (0x1A9A, 'X'),
-    ]
-
-def _seg_15():
-    return [
     (0x1AA0, 'V'),
     (0x1AAE, 'X'),
+    (0x1AB0, 'V'),
+    (0x1ABF, 'X'),
     (0x1B00, 'V'),
     (0x1B4C, 'X'),
     (0x1B50, 'V'),
@@ -1580,11 +1590,19 @@ def _seg_15():
     (0x1C3B, 'V'),
     (0x1C4A, 'X'),
     (0x1C4D, 'V'),
-    (0x1C80, 'X'),
+    (0x1C80, 'M', u'в'),
+    (0x1C81, 'M', u'д'),
+    (0x1C82, 'M', u'о'),
+    (0x1C83, 'M', u'с'),
+    (0x1C84, 'M', u'т'),
+    (0x1C86, 'M', u'ъ'),
+    (0x1C87, 'M', u'ѣ'),
+    (0x1C88, 'M', u'ꙋ'),
+    (0x1C89, 'X'),
     (0x1CC0, 'V'),
     (0x1CC8, 'X'),
     (0x1CD0, 'V'),
-    (0x1CF7, 'X'),
+    (0x1CFA, 'X'),
     (0x1D00, 'V'),
     (0x1D2C, 'M', u'a'),
     (0x1D2D, 'M', u'æ'),
@@ -1649,6 +1667,10 @@ def _seg_15():
     (0x1D68, 'M', u'ρ'),
     (0x1D69, 'M', u'φ'),
     (0x1D6A, 'M', u'χ'),
+    ]
+
+def _seg_16():
+    return [
     (0x1D6B, 'V'),
     (0x1D78, 'M', u'н'),
     (0x1D79, 'V'),
@@ -1667,10 +1689,6 @@ def _seg_15():
     (0x1DA7, 'M', u'ᵻ'),
     (0x1DA8, 'M', u'ʝ'),
     (0x1DA9, 'M', u'ɭ'),
-    ]
-
-def _seg_16():
-    return [
     (0x1DAA, 'M', u'ᶅ'),
     (0x1DAB, 'M', u'ʟ'),
     (0x1DAC, 'M', u'ɱ'),
@@ -1694,8 +1712,8 @@ def _seg_16():
     (0x1DBE, 'M', u'ʒ'),
     (0x1DBF, 'M', u'θ'),
     (0x1DC0, 'V'),
-    (0x1DE7, 'X'),
-    (0x1DFC, 'V'),
+    (0x1DFA, 'X'),
+    (0x1DFB, 'V'),
     (0x1E00, 'M', u'ḁ'),
     (0x1E01, 'V'),
     (0x1E02, 'M', u'ḃ'),
@@ -1753,6 +1771,10 @@ def _seg_16():
     (0x1E36, 'M', u'ḷ'),
     (0x1E37, 'V'),
     (0x1E38, 'M', u'ḹ'),
+    ]
+
+def _seg_17():
+    return [
     (0x1E39, 'V'),
     (0x1E3A, 'M', u'ḻ'),
     (0x1E3B, 'V'),
@@ -1771,10 +1793,6 @@ def _seg_16():
     (0x1E48, 'M', u'ṉ'),
     (0x1E49, 'V'),
     (0x1E4A, 'M', u'ṋ'),
-    ]
-
-def _seg_17():
-    return [
     (0x1E4B, 'V'),
     (0x1E4C, 'M', u'ṍ'),
     (0x1E4D, 'V'),
@@ -1857,6 +1875,10 @@ def _seg_17():
     (0x1E9F, 'V'),
     (0x1EA0, 'M', u'ạ'),
     (0x1EA1, 'V'),
+    ]
+
+def _seg_18():
+    return [
     (0x1EA2, 'M', u'ả'),
     (0x1EA3, 'V'),
     (0x1EA4, 'M', u'ấ'),
@@ -1875,10 +1897,6 @@ def _seg_17():
     (0x1EB1, 'V'),
     (0x1EB2, 'M', u'ẳ'),
     (0x1EB3, 'V'),
-    ]
-
-def _seg_18():
-    return [
     (0x1EB4, 'M', u'ẵ'),
     (0x1EB5, 'V'),
     (0x1EB6, 'M', u'ặ'),
@@ -1961,6 +1979,10 @@ def _seg_18():
     (0x1F0B, 'M', u'ἃ'),
     (0x1F0C, 'M', u'ἄ'),
     (0x1F0D, 'M', u'ἅ'),
+    ]
+
+def _seg_19():
+    return [
     (0x1F0E, 'M', u'ἆ'),
     (0x1F0F, 'M', u'ἇ'),
     (0x1F10, 'V'),
@@ -1979,10 +2001,6 @@ def _seg_18():
     (0x1F2B, 'M', u'ἣ'),
     (0x1F2C, 'M', u'ἤ'),
     (0x1F2D, 'M', u'ἥ'),
-    ]
-
-def _seg_19():
-    return [
     (0x1F2E, 'M', u'ἦ'),
     (0x1F2F, 'M', u'ἧ'),
     (0x1F30, 'V'),
@@ -2065,6 +2083,10 @@ def _seg_19():
     (0x1F9A, 'M', u'ἢι'),
     (0x1F9B, 'M', u'ἣι'),
     (0x1F9C, 'M', u'ἤι'),
+    ]
+
+def _seg_20():
+    return [
     (0x1F9D, 'M', u'ἥι'),
     (0x1F9E, 'M', u'ἦι'),
     (0x1F9F, 'M', u'ἧι'),
@@ -2083,10 +2105,6 @@ def _seg_19():
     (0x1FAC, 'M', u'ὤι'),
     (0x1FAD, 'M', u'ὥι'),
     (0x1FAE, 'M', u'ὦι'),
-    ]
-
-def _seg_20():
-    return [
     (0x1FAF, 'M', u'ὧι'),
     (0x1FB0, 'V'),
     (0x1FB2, 'M', u'ὰι'),
@@ -2169,6 +2187,10 @@ def _seg_20():
     (0x2024, 'X'),
     (0x2027, 'V'),
     (0x2028, 'X'),
+    ]
+
+def _seg_21():
+    return [
     (0x202F, '3', u' '),
     (0x2030, 'V'),
     (0x2033, 'M', u'′′'),
@@ -2187,10 +2209,6 @@ def _seg_20():
     (0x204A, 'V'),
     (0x2057, 'M', u'′′′′'),
     (0x2058, 'V'),
-    ]
-
-def _seg_21():
-    return [
     (0x205F, '3', u' '),
     (0x2060, 'I'),
     (0x2061, 'X'),
@@ -2244,7 +2262,7 @@ def _seg_21():
     (0x20A0, 'V'),
     (0x20A8, 'M', u'rs'),
     (0x20A9, 'V'),
-    (0x20BB, 'X'),
+    (0x20C0, 'X'),
     (0x20D0, 'V'),
     (0x20F1, 'X'),
     (0x2100, '3', u'a/c'),
@@ -2273,6 +2291,10 @@ def _seg_21():
     (0x2120, 'M', u'sm'),
     (0x2121, 'M', u'tel'),
     (0x2122, 'M', u'tm'),
+    ]
+
+def _seg_22():
+    return [
     (0x2123, 'V'),
     (0x2124, 'M', u'z'),
     (0x2125, 'V'),
@@ -2291,10 +2313,6 @@ def _seg_21():
     (0x2133, 'M', u'm'),
     (0x2134, 'M', u'o'),
     (0x2135, 'M', u'א'),
-    ]
-
-def _seg_22():
-    return [
     (0x2136, 'M', u'ב'),
     (0x2137, 'M', u'ג'),
     (0x2138, 'M', u'ד'),
@@ -2363,7 +2381,8 @@ def _seg_22():
     (0x2183, 'X'),
     (0x2184, 'V'),
     (0x2189, 'M', u'0⁄3'),
-    (0x218A, 'X'),
+    (0x218A, 'V'),
+    (0x218C, 'X'),
     (0x2190, 'V'),
     (0x222C, 'M', u'∫∫'),
     (0x222D, 'M', u'∫∫∫'),
@@ -2376,10 +2395,12 @@ def _seg_22():
     (0x226E, '3'),
     (0x2270, 'V'),
     (0x2329, 'M', u'〈'),
+    ]
+
+def _seg_23():
+    return [
     (0x232A, 'M', u'〉'),
     (0x232B, 'V'),
-    (0x23F4, 'X'),
-    (0x2400, 'V'),
     (0x2427, 'X'),
     (0x2440, 'V'),
     (0x244B, 'X'),
@@ -2395,10 +2416,6 @@ def _seg_22():
     (0x2469, 'M', u'10'),
     (0x246A, 'M', u'11'),
     (0x246B, 'M', u'12'),
-    ]
-
-def _seg_23():
-    return [
     (0x246C, 'M', u'13'),
     (0x246D, 'M', u'14'),
     (0x246E, 'M', u'15'),
@@ -2482,6 +2499,10 @@ def _seg_23():
     (0x24CF, 'M', u'z'),
     (0x24D0, 'M', u'a'),
     (0x24D1, 'M', u'b'),
+    ]
+
+def _seg_24():
+    return [
     (0x24D2, 'M', u'c'),
     (0x24D3, 'M', u'd'),
     (0x24D4, 'M', u'e'),
@@ -2499,10 +2520,6 @@ def _seg_23():
     (0x24E0, 'M', u'q'),
     (0x24E1, 'M', u'r'),
     (0x24E2, 'M', u's'),
-    ]
-
-def _seg_24():
-    return [
     (0x24E3, 'M', u't'),
     (0x24E4, 'M', u'u'),
     (0x24E5, 'M', u'v'),
@@ -2512,8 +2529,6 @@ def _seg_24():
     (0x24E9, 'M', u'z'),
     (0x24EA, 'M', u'0'),
     (0x24EB, 'V'),
-    (0x2700, 'X'),
-    (0x2701, 'V'),
     (0x2A0C, 'M', u'∫∫∫∫'),
     (0x2A0D, 'V'),
     (0x2A74, '3', u'::='),
@@ -2522,9 +2537,17 @@ def _seg_24():
     (0x2A77, 'V'),
     (0x2ADC, 'M', u'⫝̸'),
     (0x2ADD, 'V'),
-    (0x2B4D, 'X'),
-    (0x2B50, 'V'),
-    (0x2B5A, 'X'),
+    (0x2B74, 'X'),
+    (0x2B76, 'V'),
+    (0x2B96, 'X'),
+    (0x2B98, 'V'),
+    (0x2BBA, 'X'),
+    (0x2BBD, 'V'),
+    (0x2BC9, 'X'),
+    (0x2BCA, 'V'),
+    (0x2BD3, 'X'),
+    (0x2BEC, 'V'),
+    (0x2BF0, 'X'),
     (0x2C00, 'M', u'ⰰ'),
     (0x2C01, 'M', u'ⰱ'),
     (0x2C02, 'M', u'ⰲ'),
@@ -2580,6 +2603,10 @@ def _seg_24():
     (0x2C62, 'M', u'ɫ'),
     (0x2C63, 'M', u'ᵽ'),
     (0x2C64, 'M', u'ɽ'),
+    ]
+
+def _seg_25():
+    return [
     (0x2C65, 'V'),
     (0x2C67, 'M', u'ⱨ'),
     (0x2C68, 'V'),
@@ -2603,10 +2630,6 @@ def _seg_24():
     (0x2C80, 'M', u'ⲁ'),
     (0x2C81, 'V'),
     (0x2C82, 'M', u'ⲃ'),
-    ]
-
-def _seg_25():
-    return [
     (0x2C83, 'V'),
     (0x2C84, 'M', u'ⲅ'),
     (0x2C85, 'V'),
@@ -2684,6 +2707,10 @@ def _seg_25():
     (0x2CCD, 'V'),
     (0x2CCE, 'M', u'ⳏ'),
     (0x2CCF, 'V'),
+    ]
+
+def _seg_26():
+    return [
     (0x2CD0, 'M', u'ⳑ'),
     (0x2CD1, 'V'),
     (0x2CD2, 'M', u'ⳓ'),
@@ -2707,10 +2734,6 @@ def _seg_25():
     (0x2CEB, 'M', u'ⳬ'),
     (0x2CEC, 'V'),
     (0x2CED, 'M', u'ⳮ'),
-    ]
-
-def _seg_26():
-    return [
     (0x2CEE, 'V'),
     (0x2CF2, 'M', u'ⳳ'),
     (0x2CF3, 'V'),
@@ -2745,7 +2768,7 @@ def _seg_26():
     (0x2DD8, 'V'),
     (0x2DDF, 'X'),
     (0x2DE0, 'V'),
-    (0x2E3C, 'X'),
+    (0x2E4A, 'X'),
     (0x2E80, 'V'),
     (0x2E9A, 'X'),
     (0x2E9B, 'V'),
@@ -2788,6 +2811,10 @@ def _seg_26():
     (0x2F20, 'M', u'士'),
     (0x2F21, 'M', u'夂'),
     (0x2F22, 'M', u'夊'),
+    ]
+
+def _seg_27():
+    return [
     (0x2F23, 'M', u'夕'),
     (0x2F24, 'M', u'大'),
     (0x2F25, 'M', u'女'),
@@ -2811,10 +2838,6 @@ def _seg_26():
     (0x2F37, 'M', u'弋'),
     (0x2F38, 'M', u'弓'),
     (0x2F39, 'M', u'彐'),
-    ]
-
-def _seg_27():
-    return [
     (0x2F3A, 'M', u'彡'),
     (0x2F3B, 'M', u'彳'),
     (0x2F3C, 'M', u'心'),
@@ -2892,6 +2915,10 @@ def _seg_27():
     (0x2F84, 'M', u'至'),
     (0x2F85, 'M', u'臼'),
     (0x2F86, 'M', u'舌'),
+    ]
+
+def _seg_28():
+    return [
     (0x2F87, 'M', u'舛'),
     (0x2F88, 'M', u'舟'),
     (0x2F89, 'M', u'艮'),
@@ -2915,10 +2942,6 @@ def _seg_27():
     (0x2F9B, 'M', u'走'),
     (0x2F9C, 'M', u'足'),
     (0x2F9D, 'M', u'身'),
-    ]
-
-def _seg_28():
-    return [
     (0x2F9E, 'M', u'車'),
     (0x2F9F, 'M', u'辛'),
     (0x2FA0, 'M', u'辰'),
@@ -2996,9 +3019,13 @@ def _seg_28():
     (0x309F, 'M', u'より'),
     (0x30A0, 'V'),
     (0x30FF, 'M', u'コト'),
+    ]
+
+def _seg_29():
+    return [
     (0x3100, 'X'),
     (0x3105, 'V'),
-    (0x312E, 'X'),
+    (0x312F, 'X'),
     (0x3131, 'M', u'ᄀ'),
     (0x3132, 'M', u'ᄁ'),
     (0x3133, 'M', u'ᆪ'),
@@ -3019,10 +3046,6 @@ def _seg_28():
     (0x3142, 'M', u'ᄇ'),
     (0x3143, 'M', u'ᄈ'),
     (0x3144, 'M', u'ᄡ'),
-    ]
-
-def _seg_29():
-    return [
     (0x3145, 'M', u'ᄉ'),
     (0x3146, 'M', u'ᄊ'),
     (0x3147, 'M', u'ᄋ'),
@@ -3100,6 +3123,10 @@ def _seg_29():
     (0x318F, 'X'),
     (0x3190, 'V'),
     (0x3192, 'M', u'一'),
+    ]
+
+def _seg_30():
+    return [
     (0x3193, 'M', u'二'),
     (0x3194, 'M', u'三'),
     (0x3195, 'M', u'四'),
@@ -3123,10 +3150,6 @@ def _seg_29():
     (0x3202, '3', u'(ᄃ)'),
     (0x3203, '3', u'(ᄅ)'),
     (0x3204, '3', u'(ᄆ)'),
-    ]
-
-def _seg_30():
-    return [
     (0x3205, '3', u'(ᄇ)'),
     (0x3206, '3', u'(ᄉ)'),
     (0x3207, '3', u'(ᄋ)'),
@@ -3204,6 +3227,10 @@ def _seg_30():
     (0x3256, 'M', u'26'),
     (0x3257, 'M', u'27'),
     (0x3258, 'M', u'28'),
+    ]
+
+def _seg_31():
+    return [
     (0x3259, 'M', u'29'),
     (0x325A, 'M', u'30'),
     (0x325B, 'M', u'31'),
@@ -3227,10 +3254,6 @@ def _seg_30():
     (0x326D, 'M', u'ᄒ'),
     (0x326E, 'M', u'가'),
     (0x326F, 'M', u'나'),
-    ]
-
-def _seg_31():
-    return [
     (0x3270, 'M', u'다'),
     (0x3271, 'M', u'라'),
     (0x3272, 'M', u'마'),
@@ -3308,6 +3331,10 @@ def _seg_31():
     (0x32BA, 'M', u'45'),
     (0x32BB, 'M', u'46'),
     (0x32BC, 'M', u'47'),
+    ]
+
+def _seg_32():
+    return [
     (0x32BD, 'M', u'48'),
     (0x32BE, 'M', u'49'),
     (0x32BF, 'M', u'50'),
@@ -3331,10 +3358,6 @@ def _seg_31():
     (0x32D1, 'M', u'イ'),
     (0x32D2, 'M', u'ウ'),
     (0x32D3, 'M', u'エ'),
-    ]
-
-def _seg_32():
-    return [
     (0x32D4, 'M', u'オ'),
     (0x32D5, 'M', u'カ'),
     (0x32D6, 'M', u'キ'),
@@ -3412,6 +3435,10 @@ def _seg_32():
     (0x331E, 'M', u'コーポ'),
     (0x331F, 'M', u'サイクル'),
     (0x3320, 'M', u'サンチーム'),
+    ]
+
+def _seg_33():
+    return [
     (0x3321, 'M', u'シリング'),
     (0x3322, 'M', u'センチ'),
     (0x3323, 'M', u'セント'),
@@ -3435,10 +3462,6 @@ def _seg_32():
     (0x3335, 'M', u'フラン'),
     (0x3336, 'M', u'ヘクタール'),
     (0x3337, 'M', u'ペソ'),
-    ]
-
-def _seg_33():
-    return [
     (0x3338, 'M', u'ペニヒ'),
     (0x3339, 'M', u'ヘルツ'),
     (0x333A, 'M', u'ペンス'),
@@ -3516,6 +3539,10 @@ def _seg_33():
     (0x3382, 'M', u'μa'),
     (0x3383, 'M', u'ma'),
     (0x3384, 'M', u'ka'),
+    ]
+
+def _seg_34():
+    return [
     (0x3385, 'M', u'kb'),
     (0x3386, 'M', u'mb'),
     (0x3387, 'M', u'gb'),
@@ -3539,10 +3566,6 @@ def _seg_33():
     (0x3399, 'M', u'fm'),
     (0x339A, 'M', u'nm'),
     (0x339B, 'M', u'μm'),
-    ]
-
-def _seg_34():
-    return [
     (0x339C, 'M', u'mm'),
     (0x339D, 'M', u'cm'),
     (0x339E, 'M', u'km'),
@@ -3620,6 +3643,10 @@ def _seg_34():
     (0x33E6, 'M', u'7日'),
     (0x33E7, 'M', u'8日'),
     (0x33E8, 'M', u'9日'),
+    ]
+
+def _seg_35():
+    return [
     (0x33E9, 'M', u'10日'),
     (0x33EA, 'M', u'11日'),
     (0x33EB, 'M', u'12日'),
@@ -3643,14 +3670,10 @@ def _seg_34():
     (0x33FD, 'M', u'30日'),
     (0x33FE, 'M', u'31日'),
     (0x33FF, 'M', u'gal'),
-    ]
-
-def _seg_35():
-    return [
     (0x3400, 'V'),
     (0x4DB6, 'X'),
     (0x4DC0, 'V'),
-    (0x9FCD, 'X'),
+    (0x9FEB, 'X'),
     (0xA000, 'V'),
     (0xA48D, 'X'),
     (0xA490, 'V'),
@@ -3724,11 +3747,20 @@ def _seg_35():
     (0xA692, 'M', u'ꚓ'),
     (0xA693, 'V'),
     (0xA694, 'M', u'ꚕ'),
+    ]
+
+def _seg_36():
+    return [
     (0xA695, 'V'),
     (0xA696, 'M', u'ꚗ'),
     (0xA697, 'V'),
-    (0xA698, 'X'),
-    (0xA69F, 'V'),
+    (0xA698, 'M', u'ꚙ'),
+    (0xA699, 'V'),
+    (0xA69A, 'M', u'ꚛ'),
+    (0xA69B, 'V'),
+    (0xA69C, 'M', u'ъ'),
+    (0xA69D, 'M', u'ь'),
+    (0xA69E, 'V'),
     (0xA6F8, 'X'),
     (0xA700, 'V'),
     (0xA722, 'M', u'ꜣ'),
@@ -3747,10 +3779,6 @@ def _seg_35():
     (0xA72F, 'V'),
     (0xA732, 'M', u'ꜳ'),
     (0xA733, 'V'),
-    ]
-
-def _seg_36():
-    return [
     (0xA734, 'M', u'ꜵ'),
     (0xA735, 'V'),
     (0xA736, 'M', u'ꜷ'),
@@ -3823,6 +3851,10 @@ def _seg_36():
     (0xA780, 'M', u'ꞁ'),
     (0xA781, 'V'),
     (0xA782, 'M', u'ꞃ'),
+    ]
+
+def _seg_37():
+    return [
     (0xA783, 'V'),
     (0xA784, 'M', u'ꞅ'),
     (0xA785, 'V'),
@@ -3832,12 +3864,20 @@ def _seg_36():
     (0xA78C, 'V'),
     (0xA78D, 'M', u'ɥ'),
     (0xA78E, 'V'),
-    (0xA78F, 'X'),
     (0xA790, 'M', u'ꞑ'),
     (0xA791, 'V'),
     (0xA792, 'M', u'ꞓ'),
     (0xA793, 'V'),
-    (0xA794, 'X'),
+    (0xA796, 'M', u'ꞗ'),
+    (0xA797, 'V'),
+    (0xA798, 'M', u'ꞙ'),
+    (0xA799, 'V'),
+    (0xA79A, 'M', u'ꞛ'),
+    (0xA79B, 'V'),
+    (0xA79C, 'M', u'ꞝ'),
+    (0xA79D, 'V'),
+    (0xA79E, 'M', u'ꞟ'),
+    (0xA79F, 'V'),
     (0xA7A0, 'M', u'ꞡ'),
     (0xA7A1, 'V'),
     (0xA7A2, 'M', u'ꞣ'),
@@ -3849,12 +3889,22 @@ def _seg_36():
     (0xA7A8, 'M', u'ꞩ'),
     (0xA7A9, 'V'),
     (0xA7AA, 'M', u'ɦ'),
-    (0xA7AB, 'X'),
+    (0xA7AB, 'M', u'ɜ'),
+    (0xA7AC, 'M', u'ɡ'),
+    (0xA7AD, 'M', u'ɬ'),
+    (0xA7AE, 'M', u'ɪ'),
+    (0xA7AF, 'X'),
+    (0xA7B0, 'M', u'ʞ'),
+    (0xA7B1, 'M', u'ʇ'),
+    (0xA7B2, 'M', u'ʝ'),
+    (0xA7B3, 'M', u'ꭓ'),
+    (0xA7B4, 'M', u'ꞵ'),
+    (0xA7B5, 'V'),
+    (0xA7B6, 'M', u'ꞷ'),
+    (0xA7B7, 'V'),
+    (0xA7B8, 'X'),
+    (0xA7F7, 'V'),
     (0xA7F8, 'M', u'ħ'),
-    ]
-
-def _seg_37():
-    return [
     (0xA7F9, 'M', u'œ'),
     (0xA7FA, 'V'),
     (0xA82C, 'X'),
@@ -3863,11 +3913,11 @@ def _seg_37():
     (0xA840, 'V'),
     (0xA878, 'X'),
     (0xA880, 'V'),
-    (0xA8C5, 'X'),
+    (0xA8C6, 'X'),
     (0xA8CE, 'V'),
     (0xA8DA, 'X'),
     (0xA8E0, 'V'),
-    (0xA8FC, 'X'),
+    (0xA8FE, 'X'),
     (0xA900, 'V'),
     (0xA954, 'X'),
     (0xA95F, 'V'),
@@ -3877,7 +3927,7 @@ def _seg_37():
     (0xA9CF, 'V'),
     (0xA9DA, 'X'),
     (0xA9DE, 'V'),
-    (0xA9E0, 'X'),
+    (0xA9FF, 'X'),
     (0xAA00, 'V'),
     (0xAA37, 'X'),
     (0xAA40, 'V'),
@@ -3885,8 +3935,6 @@ def _seg_37():
     (0xAA50, 'V'),
     (0xAA5A, 'X'),
     (0xAA5C, 'V'),
-    (0xAA7C, 'X'),
-    (0xAA80, 'V'),
     (0xAAC3, 'X'),
     (0xAADB, 'V'),
     (0xAAF7, 'X'),
@@ -3900,6 +3948,97 @@ def _seg_37():
     (0xAB27, 'X'),
     (0xAB28, 'V'),
     (0xAB2F, 'X'),
+    (0xAB30, 'V'),
+    (0xAB5C, 'M', u'ꜧ'),
+    (0xAB5D, 'M', u'ꬷ'),
+    (0xAB5E, 'M', u'ɫ'),
+    (0xAB5F, 'M', u'ꭒ'),
+    (0xAB60, 'V'),
+    (0xAB66, 'X'),
+    ]
+
+def _seg_38():
+    return [
+    (0xAB70, 'M', u'Ꭰ'),
+    (0xAB71, 'M', u'Ꭱ'),
+    (0xAB72, 'M', u'Ꭲ'),
+    (0xAB73, 'M', u'Ꭳ'),
+    (0xAB74, 'M', u'Ꭴ'),
+    (0xAB75, 'M', u'Ꭵ'),
+    (0xAB76, 'M', u'Ꭶ'),
+    (0xAB77, 'M', u'Ꭷ'),
+    (0xAB78, 'M', u'Ꭸ'),
+    (0xAB79, 'M', u'Ꭹ'),
+    (0xAB7A, 'M', u'Ꭺ'),
+    (0xAB7B, 'M', u'Ꭻ'),
+    (0xAB7C, 'M', u'Ꭼ'),
+    (0xAB7D, 'M', u'Ꭽ'),
+    (0xAB7E, 'M', u'Ꭾ'),
+    (0xAB7F, 'M', u'Ꭿ'),
+    (0xAB80, 'M', u'Ꮀ'),
+    (0xAB81, 'M', u'Ꮁ'),
+    (0xAB82, 'M', u'Ꮂ'),
+    (0xAB83, 'M', u'Ꮃ'),
+    (0xAB84, 'M', u'Ꮄ'),
+    (0xAB85, 'M', u'Ꮅ'),
+    (0xAB86, 'M', u'Ꮆ'),
+    (0xAB87, 'M', u'Ꮇ'),
+    (0xAB88, 'M', u'Ꮈ'),
+    (0xAB89, 'M', u'Ꮉ'),
+    (0xAB8A, 'M', u'Ꮊ'),
+    (0xAB8B, 'M', u'Ꮋ'),
+    (0xAB8C, 'M', u'Ꮌ'),
+    (0xAB8D, 'M', u'Ꮍ'),
+    (0xAB8E, 'M', u'Ꮎ'),
+    (0xAB8F, 'M', u'Ꮏ'),
+    (0xAB90, 'M', u'Ꮐ'),
+    (0xAB91, 'M', u'Ꮑ'),
+    (0xAB92, 'M', u'Ꮒ'),
+    (0xAB93, 'M', u'Ꮓ'),
+    (0xAB94, 'M', u'Ꮔ'),
+    (0xAB95, 'M', u'Ꮕ'),
+    (0xAB96, 'M', u'Ꮖ'),
+    (0xAB97, 'M', u'Ꮗ'),
+    (0xAB98, 'M', u'Ꮘ'),
+    (0xAB99, 'M', u'Ꮙ'),
+    (0xAB9A, 'M', u'Ꮚ'),
+    (0xAB9B, 'M', u'Ꮛ'),
+    (0xAB9C, 'M', u'Ꮜ'),
+    (0xAB9D, 'M', u'Ꮝ'),
+    (0xAB9E, 'M', u'Ꮞ'),
+    (0xAB9F, 'M', u'Ꮟ'),
+    (0xABA0, 'M', u'Ꮠ'),
+    (0xABA1, 'M', u'Ꮡ'),
+    (0xABA2, 'M', u'Ꮢ'),
+    (0xABA3, 'M', u'Ꮣ'),
+    (0xABA4, 'M', u'Ꮤ'),
+    (0xABA5, 'M', u'Ꮥ'),
+    (0xABA6, 'M', u'Ꮦ'),
+    (0xABA7, 'M', u'Ꮧ'),
+    (0xABA8, 'M', u'Ꮨ'),
+    (0xABA9, 'M', u'Ꮩ'),
+    (0xABAA, 'M', u'Ꮪ'),
+    (0xABAB, 'M', u'Ꮫ'),
+    (0xABAC, 'M', u'Ꮬ'),
+    (0xABAD, 'M', u'Ꮭ'),
+    (0xABAE, 'M', u'Ꮮ'),
+    (0xABAF, 'M', u'Ꮯ'),
+    (0xABB0, 'M', u'Ꮰ'),
+    (0xABB1, 'M', u'Ꮱ'),
+    (0xABB2, 'M', u'Ꮲ'),
+    (0xABB3, 'M', u'Ꮳ'),
+    (0xABB4, 'M', u'Ꮴ'),
+    (0xABB5, 'M', u'Ꮵ'),
+    (0xABB6, 'M', u'Ꮶ'),
+    (0xABB7, 'M', u'Ꮷ'),
+    (0xABB8, 'M', u'Ꮸ'),
+    (0xABB9, 'M', u'Ꮹ'),
+    (0xABBA, 'M', u'Ꮺ'),
+    (0xABBB, 'M', u'Ꮻ'),
+    (0xABBC, 'M', u'Ꮼ'),
+    (0xABBD, 'M', u'Ꮽ'),
+    (0xABBE, 'M', u'Ꮾ'),
+    (0xABBF, 'M', u'Ꮿ'),
     (0xABC0, 'V'),
     (0xABEE, 'X'),
     (0xABF0, 'V'),
@@ -3920,6 +4059,10 @@ def _seg_37():
     (0xF907, 'M', u'龜'),
     (0xF909, 'M', u'契'),
     (0xF90A, 'M', u'金'),
+    ]
+
+def _seg_39():
+    return [
     (0xF90B, 'M', u'喇'),
     (0xF90C, 'M', u'奈'),
     (0xF90D, 'M', u'懶'),
@@ -3955,10 +4098,6 @@ def _seg_37():
     (0xF92B, 'M', u'狼'),
     (0xF92C, 'M', u'郎'),
     (0xF92D, 'M', u'來'),
-    ]
-
-def _seg_38():
-    return [
     (0xF92E, 'M', u'冷'),
     (0xF92F, 'M', u'勞'),
     (0xF930, 'M', u'擄'),
@@ -4024,6 +4163,10 @@ def _seg_38():
     (0xF96C, 'M', u'塞'),
     (0xF96D, 'M', u'省'),
     (0xF96E, 'M', u'葉'),
+    ]
+
+def _seg_40():
+    return [
     (0xF96F, 'M', u'說'),
     (0xF970, 'M', u'殺'),
     (0xF971, 'M', u'辰'),
@@ -4059,10 +4202,6 @@ def _seg_38():
     (0xF98F, 'M', u'憐'),
     (0xF990, 'M', u'戀'),
     (0xF991, 'M', u'撚'),
-    ]
-
-def _seg_39():
-    return [
     (0xF992, 'M', u'漣'),
     (0xF993, 'M', u'煉'),
     (0xF994, 'M', u'璉'),
@@ -4128,6 +4267,10 @@ def _seg_39():
     (0xF9D0, 'M', u'類'),
     (0xF9D1, 'M', u'六'),
     (0xF9D2, 'M', u'戮'),
+    ]
+
+def _seg_41():
+    return [
     (0xF9D3, 'M', u'陸'),
     (0xF9D4, 'M', u'倫'),
     (0xF9D5, 'M', u'崙'),
@@ -4163,10 +4306,6 @@ def _seg_39():
     (0xF9F3, 'M', u'麟'),
     (0xF9F4, 'M', u'林'),
     (0xF9F5, 'M', u'淋'),
-    ]
-
-def _seg_40():
-    return [
     (0xF9F6, 'M', u'臨'),
     (0xF9F7, 'M', u'立'),
     (0xF9F8, 'M', u'笠'),
@@ -4232,6 +4371,10 @@ def _seg_40():
     (0xFA39, 'M', u'塀'),
     (0xFA3A, 'M', u'墨'),
     (0xFA3B, 'M', u'層'),
+    ]
+
+def _seg_42():
+    return [
     (0xFA3C, 'M', u'屮'),
     (0xFA3D, 'M', u'悔'),
     (0xFA3E, 'M', u'慨'),
@@ -4267,10 +4410,6 @@ def _seg_40():
     (0xFA5C, 'M', u'臭'),
     (0xFA5D, 'M', u'艹'),
     (0xFA5F, 'M', u'著'),
-    ]
-
-def _seg_41():
-    return [
     (0xFA60, 'M', u'褐'),
     (0xFA61, 'M', u'視'),
     (0xFA62, 'M', u'謁'),
@@ -4336,6 +4475,10 @@ def _seg_41():
     (0xFA9F, 'M', u'犯'),
     (0xFAA0, 'M', u'猪'),
     (0xFAA1, 'M', u'瑱'),
+    ]
+
+def _seg_43():
+    return [
     (0xFAA2, 'M', u'甆'),
     (0xFAA3, 'M', u'画'),
     (0xFAA4, 'M', u'瘝'),
@@ -4371,10 +4514,6 @@ def _seg_41():
     (0xFAC2, 'M', u'輸'),
     (0xFAC3, 'M', u'遲'),
     (0xFAC4, 'M', u'醙'),
-    ]
-
-def _seg_42():
-    return [
     (0xFAC5, 'M', u'鉶'),
     (0xFAC6, 'M', u'陼'),
     (0xFAC7, 'M', u'難'),
@@ -4440,6 +4579,10 @@ def _seg_42():
     (0xFB38, 'M', u'טּ'),
     (0xFB39, 'M', u'יּ'),
     (0xFB3A, 'M', u'ךּ'),
+    ]
+
+def _seg_44():
+    return [
     (0xFB3B, 'M', u'כּ'),
     (0xFB3C, 'M', u'לּ'),
     (0xFB3D, 'X'),
@@ -4475,10 +4618,6 @@ def _seg_42():
     (0xFB7A, 'M', u'چ'),
     (0xFB7E, 'M', u'ڇ'),
     (0xFB82, 'M', u'ڍ'),
-    ]
-
-def _seg_43():
-    return [
     (0xFB84, 'M', u'ڌ'),
     (0xFB86, 'M', u'ڎ'),
     (0xFB88, 'M', u'ڈ'),
@@ -4544,6 +4683,10 @@ def _seg_43():
     (0xFC19, 'M', u'خج'),
     (0xFC1A, 'M', u'خح'),
     (0xFC1B, 'M', u'خم'),
+    ]
+
+def _seg_45():
+    return [
     (0xFC1C, 'M', u'سج'),
     (0xFC1D, 'M', u'سح'),
     (0xFC1E, 'M', u'سخ'),
@@ -4579,10 +4722,6 @@ def _seg_43():
     (0xFC3C, 'M', u'كم'),
     (0xFC3D, 'M', u'كى'),
     (0xFC3E, 'M', u'كي'),
-    ]
-
-def _seg_44():
-    return [
     (0xFC3F, 'M', u'لج'),
     (0xFC40, 'M', u'لح'),
     (0xFC41, 'M', u'لخ'),
@@ -4648,6 +4787,10 @@ def _seg_44():
     (0xFC7D, 'M', u'في'),
     (0xFC7E, 'M', u'قى'),
     (0xFC7F, 'M', u'قي'),
+    ]
+
+def _seg_46():
+    return [
     (0xFC80, 'M', u'كا'),
     (0xFC81, 'M', u'كل'),
     (0xFC82, 'M', u'كم'),
@@ -4683,10 +4826,6 @@ def _seg_44():
     (0xFCA0, 'M', u'به'),
     (0xFCA1, 'M', u'تج'),
     (0xFCA2, 'M', u'تح'),
-    ]
-
-def _seg_45():
-    return [
     (0xFCA3, 'M', u'تخ'),
     (0xFCA4, 'M', u'تم'),
     (0xFCA5, 'M', u'ته'),
@@ -4752,6 +4891,10 @@ def _seg_45():
     (0xFCE1, 'M', u'بم'),
     (0xFCE2, 'M', u'به'),
     (0xFCE3, 'M', u'تم'),
+    ]
+
+def _seg_47():
+    return [
     (0xFCE4, 'M', u'ته'),
     (0xFCE5, 'M', u'ثم'),
     (0xFCE6, 'M', u'ثه'),
@@ -4787,10 +4930,6 @@ def _seg_45():
     (0xFD04, 'M', u'خي'),
     (0xFD05, 'M', u'صى'),
     (0xFD06, 'M', u'صي'),
-    ]
-
-def _seg_46():
-    return [
     (0xFD07, 'M', u'ضى'),
     (0xFD08, 'M', u'ضي'),
     (0xFD09, 'M', u'شج'),
@@ -4856,6 +4995,10 @@ def _seg_46():
     (0xFD57, 'M', u'تمخ'),
     (0xFD58, 'M', u'جمح'),
     (0xFD5A, 'M', u'حمي'),
+    ]
+
+def _seg_48():
+    return [
     (0xFD5B, 'M', u'حمى'),
     (0xFD5C, 'M', u'سحج'),
     (0xFD5D, 'M', u'سجح'),
@@ -4891,10 +5034,6 @@ def _seg_46():
     (0xFD87, 'M', u'لمح'),
     (0xFD89, 'M', u'محج'),
     (0xFD8A, 'M', u'محم'),
-    ]
-
-def _seg_47():
-    return [
     (0xFD8B, 'M', u'محي'),
     (0xFD8C, 'M', u'مجح'),
     (0xFD8D, 'M', u'مجم'),
@@ -4960,6 +5099,10 @@ def _seg_47():
     (0xFDF3, 'M', u'اكبر'),
     (0xFDF4, 'M', u'محمد'),
     (0xFDF5, 'M', u'صلعم'),
+    ]
+
+def _seg_49():
+    return [
     (0xFDF6, 'M', u'رسول'),
     (0xFDF7, 'M', u'عليه'),
     (0xFDF8, 'M', u'وسلم'),
@@ -4981,7 +5124,7 @@ def _seg_47():
     (0xFE18, 'M', u'〗'),
     (0xFE19, 'X'),
     (0xFE20, 'V'),
-    (0xFE27, 'X'),
+    (0xFE30, 'X'),
     (0xFE31, 'M', u'—'),
     (0xFE32, 'M', u'–'),
     (0xFE33, '3', u'_'),
@@ -4995,10 +5138,6 @@ def _seg_47():
     (0xFE3C, 'M', u'】'),
     (0xFE3D, 'M', u'《'),
     (0xFE3E, 'M', u'》'),
-    ]
-
-def _seg_48():
-    return [
     (0xFE3F, 'M', u'〈'),
     (0xFE40, 'M', u'〉'),
     (0xFE41, 'M', u'「'),
@@ -5064,6 +5203,10 @@ def _seg_48():
     (0xFE8F, 'M', u'ب'),
     (0xFE93, 'M', u'ة'),
     (0xFE95, 'M', u'ت'),
+    ]
+
+def _seg_50():
+    return [
     (0xFE99, 'M', u'ث'),
     (0xFE9D, 'M', u'ج'),
     (0xFEA1, 'M', u'ح'),
@@ -5099,10 +5242,6 @@ def _seg_48():
     (0xFF00, 'X'),
     (0xFF01, '3', u'!'),
     (0xFF02, '3', u'"'),
-    ]
-
-def _seg_49():
-    return [
     (0xFF03, '3', u'#'),
     (0xFF04, '3', u'$'),
     (0xFF05, '3', u'%'),
@@ -5168,6 +5307,10 @@ def _seg_49():
     (0xFF41, 'M', u'a'),
     (0xFF42, 'M', u'b'),
     (0xFF43, 'M', u'c'),
+    ]
+
+def _seg_51():
+    return [
     (0xFF44, 'M', u'd'),
     (0xFF45, 'M', u'e'),
     (0xFF46, 'M', u'f'),
@@ -5203,10 +5346,6 @@ def _seg_49():
     (0xFF64, 'M', u'、'),
     (0xFF65, 'M', u'・'),
     (0xFF66, 'M', u'ヲ'),
-    ]
-
-def _seg_50():
-    return [
     (0xFF67, 'M', u'ァ'),
     (0xFF68, 'M', u'ィ'),
     (0xFF69, 'M', u'ゥ'),
@@ -5272,6 +5411,10 @@ def _seg_50():
     (0xFFA5, 'M', u'ᆬ'),
     (0xFFA6, 'M', u'ᆭ'),
     (0xFFA7, 'M', u'ᄃ'),
+    ]
+
+def _seg_52():
+    return [
     (0xFFA8, 'M', u'ᄄ'),
     (0xFFA9, 'M', u'ᄅ'),
     (0xFFAA, 'M', u'ᆰ'),
@@ -5307,10 +5450,6 @@ def _seg_50():
     (0xFFCB, 'M', u'ᅨ'),
     (0xFFCC, 'M', u'ᅩ'),
     (0xFFCD, 'M', u'ᅪ'),
-    ]
-
-def _seg_51():
-    return [
     (0xFFCE, 'M', u'ᅫ'),
     (0xFFCF, 'M', u'ᅬ'),
     (0xFFD0, 'X'),
@@ -5360,21 +5499,29 @@ def _seg_51():
     (0x10107, 'V'),
     (0x10134, 'X'),
     (0x10137, 'V'),
-    (0x1018B, 'X'),
+    (0x1018F, 'X'),
     (0x10190, 'V'),
     (0x1019C, 'X'),
+    (0x101A0, 'V'),
+    (0x101A1, 'X'),
     (0x101D0, 'V'),
     (0x101FE, 'X'),
     (0x10280, 'V'),
     (0x1029D, 'X'),
     (0x102A0, 'V'),
     (0x102D1, 'X'),
+    (0x102E0, 'V'),
+    (0x102FC, 'X'),
     (0x10300, 'V'),
-    (0x1031F, 'X'),
-    (0x10320, 'V'),
     (0x10324, 'X'),
-    (0x10330, 'V'),
+    (0x1032D, 'V'),
+    ]
+
+def _seg_53():
+    return [
     (0x1034B, 'X'),
+    (0x10350, 'V'),
+    (0x1037B, 'X'),
     (0x10380, 'V'),
     (0x1039E, 'X'),
     (0x1039F, 'V'),
@@ -5411,10 +5558,6 @@ def _seg_51():
     (0x1041B, 'M', u'𐑃'),
     (0x1041C, 'M', u'𐑄'),
     (0x1041D, 'M', u'𐑅'),
-    ]
-
-def _seg_52():
-    return [
     (0x1041E, 'M', u'𐑆'),
     (0x1041F, 'M', u'𐑇'),
     (0x10420, 'M', u'𐑈'),
@@ -5429,6 +5572,61 @@ def _seg_52():
     (0x1049E, 'X'),
     (0x104A0, 'V'),
     (0x104AA, 'X'),
+    (0x104B0, 'M', u'𐓘'),
+    (0x104B1, 'M', u'𐓙'),
+    (0x104B2, 'M', u'𐓚'),
+    (0x104B3, 'M', u'𐓛'),
+    (0x104B4, 'M', u'𐓜'),
+    (0x104B5, 'M', u'𐓝'),
+    (0x104B6, 'M', u'𐓞'),
+    (0x104B7, 'M', u'𐓟'),
+    (0x104B8, 'M', u'𐓠'),
+    (0x104B9, 'M', u'𐓡'),
+    (0x104BA, 'M', u'𐓢'),
+    (0x104BB, 'M', u'𐓣'),
+    (0x104BC, 'M', u'𐓤'),
+    (0x104BD, 'M', u'𐓥'),
+    (0x104BE, 'M', u'𐓦'),
+    (0x104BF, 'M', u'𐓧'),
+    (0x104C0, 'M', u'𐓨'),
+    (0x104C1, 'M', u'𐓩'),
+    (0x104C2, 'M', u'𐓪'),
+    (0x104C3, 'M', u'𐓫'),
+    (0x104C4, 'M', u'𐓬'),
+    (0x104C5, 'M', u'𐓭'),
+    (0x104C6, 'M', u'𐓮'),
+    (0x104C7, 'M', u'𐓯'),
+    (0x104C8, 'M', u'𐓰'),
+    (0x104C9, 'M', u'𐓱'),
+    (0x104CA, 'M', u'𐓲'),
+    (0x104CB, 'M', u'𐓳'),
+    (0x104CC, 'M', u'𐓴'),
+    (0x104CD, 'M', u'𐓵'),
+    (0x104CE, 'M', u'𐓶'),
+    (0x104CF, 'M', u'𐓷'),
+    (0x104D0, 'M', u'𐓸'),
+    (0x104D1, 'M', u'𐓹'),
+    (0x104D2, 'M', u'𐓺'),
+    (0x104D3, 'M', u'𐓻'),
+    (0x104D4, 'X'),
+    (0x104D8, 'V'),
+    (0x104FC, 'X'),
+    (0x10500, 'V'),
+    (0x10528, 'X'),
+    (0x10530, 'V'),
+    (0x10564, 'X'),
+    (0x1056F, 'V'),
+    (0x10570, 'X'),
+    (0x10600, 'V'),
+    (0x10737, 'X'),
+    ]
+
+def _seg_54():
+    return [
+    (0x10740, 'V'),
+    (0x10756, 'X'),
+    (0x10760, 'V'),
+    (0x10768, 'X'),
     (0x10800, 'V'),
     (0x10806, 'X'),
     (0x10808, 'V'),
@@ -5442,8 +5640,14 @@ def _seg_52():
     (0x1083F, 'V'),
     (0x10856, 'X'),
     (0x10857, 'V'),
-    (0x10860, 'X'),
-    (0x10900, 'V'),
+    (0x1089F, 'X'),
+    (0x108A7, 'V'),
+    (0x108B0, 'X'),
+    (0x108E0, 'V'),
+    (0x108F3, 'X'),
+    (0x108F4, 'V'),
+    (0x108F6, 'X'),
+    (0x108FB, 'V'),
     (0x1091C, 'X'),
     (0x1091F, 'V'),
     (0x1093A, 'X'),
@@ -5451,9 +5655,9 @@ def _seg_52():
     (0x10940, 'X'),
     (0x10980, 'V'),
     (0x109B8, 'X'),
-    (0x109BE, 'V'),
-    (0x109C0, 'X'),
-    (0x10A00, 'V'),
+    (0x109BC, 'V'),
+    (0x109D0, 'X'),
+    (0x109D2, 'V'),
     (0x10A04, 'X'),
     (0x10A05, 'V'),
     (0x10A07, 'X'),
@@ -5470,7 +5674,11 @@ def _seg_52():
     (0x10A50, 'V'),
     (0x10A59, 'X'),
     (0x10A60, 'V'),
-    (0x10A80, 'X'),
+    (0x10AA0, 'X'),
+    (0x10AC0, 'V'),
+    (0x10AE7, 'X'),
+    (0x10AEB, 'V'),
+    (0x10AF7, 'X'),
     (0x10B00, 'V'),
     (0x10B36, 'X'),
     (0x10B39, 'V'),
@@ -5478,16 +5686,80 @@ def _seg_52():
     (0x10B58, 'V'),
     (0x10B73, 'X'),
     (0x10B78, 'V'),
-    (0x10B80, 'X'),
+    (0x10B92, 'X'),
+    (0x10B99, 'V'),
+    (0x10B9D, 'X'),
+    (0x10BA9, 'V'),
+    (0x10BB0, 'X'),
     (0x10C00, 'V'),
     (0x10C49, 'X'),
+    (0x10C80, 'M', u'𐳀'),
+    (0x10C81, 'M', u'𐳁'),
+    (0x10C82, 'M', u'𐳂'),
+    (0x10C83, 'M', u'𐳃'),
+    (0x10C84, 'M', u'𐳄'),
+    (0x10C85, 'M', u'𐳅'),
+    (0x10C86, 'M', u'𐳆'),
+    (0x10C87, 'M', u'𐳇'),
+    (0x10C88, 'M', u'𐳈'),
+    (0x10C89, 'M', u'𐳉'),
+    (0x10C8A, 'M', u'𐳊'),
+    (0x10C8B, 'M', u'𐳋'),
+    (0x10C8C, 'M', u'𐳌'),
+    (0x10C8D, 'M', u'𐳍'),
+    (0x10C8E, 'M', u'𐳎'),
+    (0x10C8F, 'M', u'𐳏'),
+    (0x10C90, 'M', u'𐳐'),
+    (0x10C91, 'M', u'𐳑'),
+    (0x10C92, 'M', u'𐳒'),
+    (0x10C93, 'M', u'𐳓'),
+    (0x10C94, 'M', u'𐳔'),
+    (0x10C95, 'M', u'𐳕'),
+    (0x10C96, 'M', u'𐳖'),
+    (0x10C97, 'M', u'𐳗'),
+    (0x10C98, 'M', u'𐳘'),
+    (0x10C99, 'M', u'𐳙'),
+    (0x10C9A, 'M', u'𐳚'),
+    (0x10C9B, 'M', u'𐳛'),
+    (0x10C9C, 'M', u'𐳜'),
+    (0x10C9D, 'M', u'𐳝'),
+    ]
+
+def _seg_55():
+    return [
+    (0x10C9E, 'M', u'𐳞'),
+    (0x10C9F, 'M', u'𐳟'),
+    (0x10CA0, 'M', u'𐳠'),
+    (0x10CA1, 'M', u'𐳡'),
+    (0x10CA2, 'M', u'𐳢'),
+    (0x10CA3, 'M', u'𐳣'),
+    (0x10CA4, 'M', u'𐳤'),
+    (0x10CA5, 'M', u'𐳥'),
+    (0x10CA6, 'M', u'𐳦'),
+    (0x10CA7, 'M', u'𐳧'),
+    (0x10CA8, 'M', u'𐳨'),
+    (0x10CA9, 'M', u'𐳩'),
+    (0x10CAA, 'M', u'𐳪'),
+    (0x10CAB, 'M', u'𐳫'),
+    (0x10CAC, 'M', u'𐳬'),
+    (0x10CAD, 'M', u'𐳭'),
+    (0x10CAE, 'M', u'𐳮'),
+    (0x10CAF, 'M', u'𐳯'),
+    (0x10CB0, 'M', u'𐳰'),
+    (0x10CB1, 'M', u'𐳱'),
+    (0x10CB2, 'M', u'𐳲'),
+    (0x10CB3, 'X'),
+    (0x10CC0, 'V'),
+    (0x10CF3, 'X'),
+    (0x10CFA, 'V'),
+    (0x10D00, 'X'),
     (0x10E60, 'V'),
     (0x10E7F, 'X'),
     (0x11000, 'V'),
     (0x1104E, 'X'),
     (0x11052, 'V'),
     (0x11070, 'X'),
-    (0x11080, 'V'),
+    (0x1107F, 'V'),
     (0x110BD, 'X'),
     (0x110BE, 'V'),
     (0x110C2, 'X'),
@@ -5499,36 +5771,235 @@ def _seg_52():
     (0x11135, 'X'),
     (0x11136, 'V'),
     (0x11144, 'X'),
+    (0x11150, 'V'),
+    (0x11177, 'X'),
     (0x11180, 'V'),
-    (0x111C9, 'X'),
+    (0x111CE, 'X'),
     (0x111D0, 'V'),
-    (0x111DA, 'X'),
+    (0x111E0, 'X'),
+    (0x111E1, 'V'),
+    (0x111F5, 'X'),
+    (0x11200, 'V'),
+    (0x11212, 'X'),
+    (0x11213, 'V'),
+    (0x1123F, 'X'),
+    (0x11280, 'V'),
+    (0x11287, 'X'),
+    (0x11288, 'V'),
+    (0x11289, 'X'),
+    (0x1128A, 'V'),
+    (0x1128E, 'X'),
+    (0x1128F, 'V'),
+    (0x1129E, 'X'),
+    (0x1129F, 'V'),
+    (0x112AA, 'X'),
+    (0x112B0, 'V'),
+    (0x112EB, 'X'),
+    (0x112F0, 'V'),
+    (0x112FA, 'X'),
+    (0x11300, 'V'),
+    (0x11304, 'X'),
+    (0x11305, 'V'),
+    (0x1130D, 'X'),
+    (0x1130F, 'V'),
+    (0x11311, 'X'),
+    (0x11313, 'V'),
+    (0x11329, 'X'),
+    (0x1132A, 'V'),
+    (0x11331, 'X'),
+    (0x11332, 'V'),
+    (0x11334, 'X'),
+    (0x11335, 'V'),
+    (0x1133A, 'X'),
+    (0x1133C, 'V'),
+    (0x11345, 'X'),
+    (0x11347, 'V'),
+    (0x11349, 'X'),
+    (0x1134B, 'V'),
+    (0x1134E, 'X'),
+    (0x11350, 'V'),
+    (0x11351, 'X'),
+    (0x11357, 'V'),
+    (0x11358, 'X'),
+    (0x1135D, 'V'),
+    (0x11364, 'X'),
+    (0x11366, 'V'),
+    (0x1136D, 'X'),
+    (0x11370, 'V'),
+    (0x11375, 'X'),
+    ]
+
+def _seg_56():
+    return [
+    (0x11400, 'V'),
+    (0x1145A, 'X'),
+    (0x1145B, 'V'),
+    (0x1145C, 'X'),
+    (0x1145D, 'V'),
+    (0x1145E, 'X'),
+    (0x11480, 'V'),
+    (0x114C8, 'X'),
+    (0x114D0, 'V'),
+    (0x114DA, 'X'),
+    (0x11580, 'V'),
+    (0x115B6, 'X'),
+    (0x115B8, 'V'),
+    (0x115DE, 'X'),
+    (0x11600, 'V'),
+    (0x11645, 'X'),
+    (0x11650, 'V'),
+    (0x1165A, 'X'),
+    (0x11660, 'V'),
+    (0x1166D, 'X'),
     (0x11680, 'V'),
     (0x116B8, 'X'),
     (0x116C0, 'V'),
     (0x116CA, 'X'),
-    (0x12000, 'V'),
-    (0x1236F, 'X'),
-    (0x12400, 'V'),
-    (0x12463, 'X'),
-    (0x12470, 'V'),
-    (0x12474, 'X'),
-    (0x13000, 'V'),
-    (0x1342F, 'X'),
+    (0x11700, 'V'),
+    (0x1171A, 'X'),
+    (0x1171D, 'V'),
+    (0x1172C, 'X'),
+    (0x11730, 'V'),
+    (0x11740, 'X'),
+    (0x118A0, 'M', u'𑣀'),
+    (0x118A1, 'M', u'𑣁'),
+    (0x118A2, 'M', u'𑣂'),
+    (0x118A3, 'M', u'𑣃'),
+    (0x118A4, 'M', u'𑣄'),
+    (0x118A5, 'M', u'𑣅'),
+    (0x118A6, 'M', u'𑣆'),
+    (0x118A7, 'M', u'𑣇'),
+    (0x118A8, 'M', u'𑣈'),
+    (0x118A9, 'M', u'𑣉'),
+    (0x118AA, 'M', u'𑣊'),
+    (0x118AB, 'M', u'𑣋'),
+    (0x118AC, 'M', u'𑣌'),
+    (0x118AD, 'M', u'𑣍'),
+    (0x118AE, 'M', u'𑣎'),
+    (0x118AF, 'M', u'𑣏'),
+    (0x118B0, 'M', u'𑣐'),
+    (0x118B1, 'M', u'𑣑'),
+    (0x118B2, 'M', u'𑣒'),
+    (0x118B3, 'M', u'𑣓'),
+    (0x118B4, 'M', u'𑣔'),
+    (0x118B5, 'M', u'𑣕'),
+    (0x118B6, 'M', u'𑣖'),
+    (0x118B7, 'M', u'𑣗'),
+    (0x118B8, 'M', u'𑣘'),
+    (0x118B9, 'M', u'𑣙'),
+    (0x118BA, 'M', u'𑣚'),
+    (0x118BB, 'M', u'𑣛'),
+    (0x118BC, 'M', u'𑣜'),
+    (0x118BD, 'M', u'𑣝'),
+    (0x118BE, 'M', u'𑣞'),
+    (0x118BF, 'M', u'𑣟'),
+    (0x118C0, 'V'),
+    (0x118F3, 'X'),
+    (0x118FF, 'V'),
+    (0x11900, 'X'),
+    (0x11A00, 'V'),
+    (0x11A48, 'X'),
+    (0x11A50, 'V'),
+    (0x11A84, 'X'),
+    (0x11A86, 'V'),
+    (0x11A9D, 'X'),
+    (0x11A9E, 'V'),
+    (0x11AA3, 'X'),
+    (0x11AC0, 'V'),
+    (0x11AF9, 'X'),
+    (0x11C00, 'V'),
+    (0x11C09, 'X'),
+    (0x11C0A, 'V'),
+    (0x11C37, 'X'),
+    (0x11C38, 'V'),
+    (0x11C46, 'X'),
+    (0x11C50, 'V'),
+    (0x11C6D, 'X'),
+    (0x11C70, 'V'),
+    (0x11C90, 'X'),
+    (0x11C92, 'V'),
+    (0x11CA8, 'X'),
+    (0x11CA9, 'V'),
+    (0x11CB7, 'X'),
+    (0x11D00, 'V'),
+    (0x11D07, 'X'),
+    (0x11D08, 'V'),
+    (0x11D0A, 'X'),
+    (0x11D0B, 'V'),
+    (0x11D37, 'X'),
+    (0x11D3A, 'V'),
+    (0x11D3B, 'X'),
+    (0x11D3C, 'V'),
+    (0x11D3E, 'X'),
     ]
 
-def _seg_53():
+def _seg_57():
     return [
+    (0x11D3F, 'V'),
+    (0x11D48, 'X'),
+    (0x11D50, 'V'),
+    (0x11D5A, 'X'),
+    (0x12000, 'V'),
+    (0x1239A, 'X'),
+    (0x12400, 'V'),
+    (0x1246F, 'X'),
+    (0x12470, 'V'),
+    (0x12475, 'X'),
+    (0x12480, 'V'),
+    (0x12544, 'X'),
+    (0x13000, 'V'),
+    (0x1342F, 'X'),
+    (0x14400, 'V'),
+    (0x14647, 'X'),
     (0x16800, 'V'),
     (0x16A39, 'X'),
+    (0x16A40, 'V'),
+    (0x16A5F, 'X'),
+    (0x16A60, 'V'),
+    (0x16A6A, 'X'),
+    (0x16A6E, 'V'),
+    (0x16A70, 'X'),
+    (0x16AD0, 'V'),
+    (0x16AEE, 'X'),
+    (0x16AF0, 'V'),
+    (0x16AF6, 'X'),
+    (0x16B00, 'V'),
+    (0x16B46, 'X'),
+    (0x16B50, 'V'),
+    (0x16B5A, 'X'),
+    (0x16B5B, 'V'),
+    (0x16B62, 'X'),
+    (0x16B63, 'V'),
+    (0x16B78, 'X'),
+    (0x16B7D, 'V'),
+    (0x16B90, 'X'),
     (0x16F00, 'V'),
     (0x16F45, 'X'),
     (0x16F50, 'V'),
     (0x16F7F, 'X'),
     (0x16F8F, 'V'),
     (0x16FA0, 'X'),
+    (0x16FE0, 'V'),
+    (0x16FE2, 'X'),
+    (0x17000, 'V'),
+    (0x187ED, 'X'),
+    (0x18800, 'V'),
+    (0x18AF3, 'X'),
     (0x1B000, 'V'),
-    (0x1B002, 'X'),
+    (0x1B11F, 'X'),
+    (0x1B170, 'V'),
+    (0x1B2FC, 'X'),
+    (0x1BC00, 'V'),
+    (0x1BC6B, 'X'),
+    (0x1BC70, 'V'),
+    (0x1BC7D, 'X'),
+    (0x1BC80, 'V'),
+    (0x1BC89, 'X'),
+    (0x1BC90, 'V'),
+    (0x1BC9A, 'X'),
+    (0x1BC9C, 'V'),
+    (0x1BCA0, 'I'),
+    (0x1BCA4, 'X'),
     (0x1D000, 'V'),
     (0x1D0F6, 'X'),
     (0x1D100, 'V'),
@@ -5551,7 +6022,7 @@ def _seg_53():
     (0x1D1BF, 'M', u'𝆹𝅥𝅯'),
     (0x1D1C0, 'M', u'𝆺𝅥𝅯'),
     (0x1D1C1, 'V'),
-    (0x1D1DE, 'X'),
+    (0x1D1E9, 'X'),
     (0x1D200, 'V'),
     (0x1D246, 'X'),
     (0x1D300, 'V'),
@@ -5564,6 +6035,10 @@ def _seg_53():
     (0x1D403, 'M', u'd'),
     (0x1D404, 'M', u'e'),
     (0x1D405, 'M', u'f'),
+    ]
+
+def _seg_58():
+    return [
     (0x1D406, 'M', u'g'),
     (0x1D407, 'M', u'h'),
     (0x1D408, 'M', u'i'),
@@ -5619,10 +6094,6 @@ def _seg_53():
     (0x1D43A, 'M', u'g'),
     (0x1D43B, 'M', u'h'),
     (0x1D43C, 'M', u'i'),
-    ]
-
-def _seg_54():
-    return [
     (0x1D43D, 'M', u'j'),
     (0x1D43E, 'M', u'k'),
     (0x1D43F, 'M', u'l'),
@@ -5668,6 +6139,10 @@ def _seg_54():
     (0x1D467, 'M', u'z'),
     (0x1D468, 'M', u'a'),
     (0x1D469, 'M', u'b'),
+    ]
+
+def _seg_59():
+    return [
     (0x1D46A, 'M', u'c'),
     (0x1D46B, 'M', u'd'),
     (0x1D46C, 'M', u'e'),
@@ -5723,10 +6198,6 @@ def _seg_54():
     (0x1D49E, 'M', u'c'),
     (0x1D49F, 'M', u'd'),
     (0x1D4A0, 'X'),
-    ]
-
-def _seg_55():
-    return [
     (0x1D4A2, 'M', u'g'),
     (0x1D4A3, 'X'),
     (0x1D4A5, 'M', u'j'),
@@ -5772,6 +6243,10 @@ def _seg_55():
     (0x1D4CE, 'M', u'y'),
     (0x1D4CF, 'M', u'z'),
     (0x1D4D0, 'M', u'a'),
+    ]
+
+def _seg_60():
+    return [
     (0x1D4D1, 'M', u'b'),
     (0x1D4D2, 'M', u'c'),
     (0x1D4D3, 'M', u'd'),
@@ -5827,10 +6302,6 @@ def _seg_55():
     (0x1D505, 'M', u'b'),
     (0x1D506, 'X'),
     (0x1D507, 'M', u'd'),
-    ]
-
-def _seg_56():
-    return [
     (0x1D508, 'M', u'e'),
     (0x1D509, 'M', u'f'),
     (0x1D50A, 'M', u'g'),
@@ -5876,6 +6347,10 @@ def _seg_56():
     (0x1D533, 'M', u'v'),
     (0x1D534, 'M', u'w'),
     (0x1D535, 'M', u'x'),
+    ]
+
+def _seg_61():
+    return [
     (0x1D536, 'M', u'y'),
     (0x1D537, 'M', u'z'),
     (0x1D538, 'M', u'a'),
@@ -5931,10 +6406,6 @@ def _seg_56():
     (0x1D56C, 'M', u'a'),
     (0x1D56D, 'M', u'b'),
     (0x1D56E, 'M', u'c'),
-    ]
-
-def _seg_57():
-    return [
     (0x1D56F, 'M', u'd'),
     (0x1D570, 'M', u'e'),
     (0x1D571, 'M', u'f'),
@@ -5980,6 +6451,10 @@ def _seg_57():
     (0x1D599, 'M', u't'),
     (0x1D59A, 'M', u'u'),
     (0x1D59B, 'M', u'v'),
+    ]
+
+def _seg_62():
+    return [
     (0x1D59C, 'M', u'w'),
     (0x1D59D, 'M', u'x'),
     (0x1D59E, 'M', u'y'),
@@ -6035,10 +6510,6 @@ def _seg_57():
     (0x1D5D0, 'M', u'w'),
     (0x1D5D1, 'M', u'x'),
     (0x1D5D2, 'M', u'y'),
-    ]
-
-def _seg_58():
-    return [
     (0x1D5D3, 'M', u'z'),
     (0x1D5D4, 'M', u'a'),
     (0x1D5D5, 'M', u'b'),
@@ -6084,6 +6555,10 @@ def _seg_58():
     (0x1D5FD, 'M', u'p'),
     (0x1D5FE, 'M', u'q'),
     (0x1D5FF, 'M', u'r'),
+    ]
+
+def _seg_63():
+    return [
     (0x1D600, 'M', u's'),
     (0x1D601, 'M', u't'),
     (0x1D602, 'M', u'u'),
@@ -6139,10 +6614,6 @@ def _seg_58():
     (0x1D634, 'M', u's'),
     (0x1D635, 'M', u't'),
     (0x1D636, 'M', u'u'),
-    ]
-
-def _seg_59():
-    return [
     (0x1D637, 'M', u'v'),
     (0x1D638, 'M', u'w'),
     (0x1D639, 'M', u'x'),
@@ -6188,6 +6659,10 @@ def _seg_59():
     (0x1D661, 'M', u'l'),
     (0x1D662, 'M', u'm'),
     (0x1D663, 'M', u'n'),
+    ]
+
+def _seg_64():
+    return [
     (0x1D664, 'M', u'o'),
     (0x1D665, 'M', u'p'),
     (0x1D666, 'M', u'q'),
@@ -6243,10 +6718,6 @@ def _seg_59():
     (0x1D698, 'M', u'o'),
     (0x1D699, 'M', u'p'),
     (0x1D69A, 'M', u'q'),
-    ]
-
-def _seg_60():
-    return [
     (0x1D69B, 'M', u'r'),
     (0x1D69C, 'M', u's'),
     (0x1D69D, 'M', u't'),
@@ -6292,6 +6763,10 @@ def _seg_60():
     (0x1D6C6, 'M', u'ε'),
     (0x1D6C7, 'M', u'ζ'),
     (0x1D6C8, 'M', u'η'),
+    ]
+
+def _seg_65():
+    return [
     (0x1D6C9, 'M', u'θ'),
     (0x1D6CA, 'M', u'ι'),
     (0x1D6CB, 'M', u'κ'),
@@ -6347,10 +6822,6 @@ def _seg_60():
     (0x1D6FE, 'M', u'γ'),
     (0x1D6FF, 'M', u'δ'),
     (0x1D700, 'M', u'ε'),
-    ]
-
-def _seg_61():
-    return [
     (0x1D701, 'M', u'ζ'),
     (0x1D702, 'M', u'η'),
     (0x1D703, 'M', u'θ'),
@@ -6396,6 +6867,10 @@ def _seg_61():
     (0x1D72C, 'M', u'ρ'),
     (0x1D72D, 'M', u'θ'),
     (0x1D72E, 'M', u'σ'),
+    ]
+
+def _seg_66():
+    return [
     (0x1D72F, 'M', u'τ'),
     (0x1D730, 'M', u'υ'),
     (0x1D731, 'M', u'φ'),
@@ -6451,10 +6926,6 @@ def _seg_61():
     (0x1D764, 'M', u'ο'),
     (0x1D765, 'M', u'π'),
     (0x1D766, 'M', u'ρ'),
-    ]
-
-def _seg_62():
-    return [
     (0x1D767, 'M', u'θ'),
     (0x1D768, 'M', u'σ'),
     (0x1D769, 'M', u'τ'),
@@ -6500,6 +6971,10 @@ def _seg_62():
     (0x1D792, 'M', u'γ'),
     (0x1D793, 'M', u'δ'),
     (0x1D794, 'M', u'ε'),
+    ]
+
+def _seg_67():
+    return [
     (0x1D795, 'M', u'ζ'),
     (0x1D796, 'M', u'η'),
     (0x1D797, 'M', u'θ'),
@@ -6555,10 +7030,6 @@ def _seg_62():
     (0x1D7CA, 'M', u'ϝ'),
     (0x1D7CC, 'X'),
     (0x1D7CE, 'M', u'0'),
-    ]
-
-def _seg_63():
-    return [
     (0x1D7CF, 'M', u'1'),
     (0x1D7D0, 'M', u'2'),
     (0x1D7D1, 'M', u'3'),
@@ -6604,11 +7075,74 @@ def _seg_63():
     (0x1D7F9, 'M', u'3'),
     (0x1D7FA, 'M', u'4'),
     (0x1D7FB, 'M', u'5'),
+    ]
+
+def _seg_68():
+    return [
     (0x1D7FC, 'M', u'6'),
     (0x1D7FD, 'M', u'7'),
     (0x1D7FE, 'M', u'8'),
     (0x1D7FF, 'M', u'9'),
-    (0x1D800, 'X'),
+    (0x1D800, 'V'),
+    (0x1DA8C, 'X'),
+    (0x1DA9B, 'V'),
+    (0x1DAA0, 'X'),
+    (0x1DAA1, 'V'),
+    (0x1DAB0, 'X'),
+    (0x1E000, 'V'),
+    (0x1E007, 'X'),
+    (0x1E008, 'V'),
+    (0x1E019, 'X'),
+    (0x1E01B, 'V'),
+    (0x1E022, 'X'),
+    (0x1E023, 'V'),
+    (0x1E025, 'X'),
+    (0x1E026, 'V'),
+    (0x1E02B, 'X'),
+    (0x1E800, 'V'),
+    (0x1E8C5, 'X'),
+    (0x1E8C7, 'V'),
+    (0x1E8D7, 'X'),
+    (0x1E900, 'M', u'𞤢'),
+    (0x1E901, 'M', u'𞤣'),
+    (0x1E902, 'M', u'𞤤'),
+    (0x1E903, 'M', u'𞤥'),
+    (0x1E904, 'M', u'𞤦'),
+    (0x1E905, 'M', u'𞤧'),
+    (0x1E906, 'M', u'𞤨'),
+    (0x1E907, 'M', u'𞤩'),
+    (0x1E908, 'M', u'𞤪'),
+    (0x1E909, 'M', u'𞤫'),
+    (0x1E90A, 'M', u'𞤬'),
+    (0x1E90B, 'M', u'𞤭'),
+    (0x1E90C, 'M', u'𞤮'),
+    (0x1E90D, 'M', u'𞤯'),
+    (0x1E90E, 'M', u'𞤰'),
+    (0x1E90F, 'M', u'𞤱'),
+    (0x1E910, 'M', u'𞤲'),
+    (0x1E911, 'M', u'𞤳'),
+    (0x1E912, 'M', u'𞤴'),
+    (0x1E913, 'M', u'𞤵'),
+    (0x1E914, 'M', u'𞤶'),
+    (0x1E915, 'M', u'𞤷'),
+    (0x1E916, 'M', u'𞤸'),
+    (0x1E917, 'M', u'𞤹'),
+    (0x1E918, 'M', u'𞤺'),
+    (0x1E919, 'M', u'𞤻'),
+    (0x1E91A, 'M', u'𞤼'),
+    (0x1E91B, 'M', u'𞤽'),
+    (0x1E91C, 'M', u'𞤾'),
+    (0x1E91D, 'M', u'𞤿'),
+    (0x1E91E, 'M', u'𞥀'),
+    (0x1E91F, 'M', u'𞥁'),
+    (0x1E920, 'M', u'𞥂'),
+    (0x1E921, 'M', u'𞥃'),
+    (0x1E922, 'V'),
+    (0x1E94B, 'X'),
+    (0x1E950, 'V'),
+    (0x1E95A, 'X'),
+    (0x1E95E, 'V'),
+    (0x1E960, 'X'),
     (0x1EE00, 'M', u'ا'),
     (0x1EE01, 'M', u'ب'),
     (0x1EE02, 'M', u'ج'),
@@ -6645,6 +7179,10 @@ def _seg_63():
     (0x1EE21, 'M', u'ب'),
     (0x1EE22, 'M', u'ج'),
     (0x1EE23, 'X'),
+    ]
+
+def _seg_69():
+    return [
     (0x1EE24, 'M', u'ه'),
     (0x1EE25, 'X'),
     (0x1EE27, 'M', u'ح'),
@@ -6659,10 +7197,6 @@ def _seg_63():
     (0x1EE30, 'M', u'ف'),
     (0x1EE31, 'M', u'ص'),
     (0x1EE32, 'M', u'ق'),
-    ]
-
-def _seg_64():
-    return [
     (0x1EE33, 'X'),
     (0x1EE34, 'M', u'ش'),
     (0x1EE35, 'M', u'ت'),
@@ -6749,6 +7283,10 @@ def _seg_64():
     (0x1EE90, 'M', u'ف'),
     (0x1EE91, 'M', u'ص'),
     (0x1EE92, 'M', u'ق'),
+    ]
+
+def _seg_70():
+    return [
     (0x1EE93, 'M', u'ر'),
     (0x1EE94, 'M', u'ش'),
     (0x1EE95, 'M', u'ت'),
@@ -6763,10 +7301,6 @@ def _seg_64():
     (0x1EEA2, 'M', u'ج'),
     (0x1EEA3, 'M', u'د'),
     (0x1EEA4, 'X'),
-    ]
-
-def _seg_65():
-    return [
     (0x1EEA5, 'M', u'و'),
     (0x1EEA6, 'M', u'ز'),
     (0x1EEA7, 'M', u'ح'),
@@ -6800,11 +7334,11 @@ def _seg_65():
     (0x1F0A0, 'V'),
     (0x1F0AF, 'X'),
     (0x1F0B1, 'V'),
-    (0x1F0BF, 'X'),
+    (0x1F0C0, 'X'),
     (0x1F0C1, 'V'),
     (0x1F0D0, 'X'),
     (0x1F0D1, 'V'),
-    (0x1F0E0, 'X'),
+    (0x1F0F6, 'X'),
     (0x1F101, '3', u'0,'),
     (0x1F102, '3', u'1,'),
     (0x1F103, '3', u'2,'),
@@ -6815,7 +7349,8 @@ def _seg_65():
     (0x1F108, '3', u'7,'),
     (0x1F109, '3', u'8,'),
     (0x1F10A, '3', u'9,'),
-    (0x1F10B, 'X'),
+    (0x1F10B, 'V'),
+    (0x1F10D, 'X'),
     (0x1F110, '3', u'(a)'),
     (0x1F111, '3', u'(b)'),
     (0x1F112, '3', u'(c)'),
@@ -6852,6 +7387,10 @@ def _seg_65():
     (0x1F131, 'M', u'b'),
     (0x1F132, 'M', u'c'),
     (0x1F133, 'M', u'd'),
+    ]
+
+def _seg_71():
+    return [
     (0x1F134, 'M', u'e'),
     (0x1F135, 'M', u'f'),
     (0x1F136, 'M', u'g'),
@@ -6867,10 +7406,6 @@ def _seg_65():
     (0x1F140, 'M', u'q'),
     (0x1F141, 'M', u'r'),
     (0x1F142, 'M', u's'),
-    ]
-
-def _seg_66():
-    return [
     (0x1F143, 'M', u't'),
     (0x1F144, 'M', u'u'),
     (0x1F145, 'M', u'v'),
@@ -6891,7 +7426,7 @@ def _seg_66():
     (0x1F170, 'V'),
     (0x1F190, 'M', u'dj'),
     (0x1F191, 'V'),
-    (0x1F19B, 'X'),
+    (0x1F1AD, 'X'),
     (0x1F1E6, 'V'),
     (0x1F200, 'M', u'ほか'),
     (0x1F201, 'M', u'ココ'),
@@ -6940,7 +7475,8 @@ def _seg_66():
     (0x1F238, 'M', u'申'),
     (0x1F239, 'M', u'割'),
     (0x1F23A, 'M', u'営'),
-    (0x1F23B, 'X'),
+    (0x1F23B, 'M', u'配'),
+    (0x1F23C, 'X'),
     (0x1F240, 'M', u'〔本〕'),
     (0x1F241, 'M', u'〔三〕'),
     (0x1F242, 'M', u'〔二〕'),
@@ -6954,52 +7490,56 @@ def _seg_66():
     (0x1F250, 'M', u'得'),
     (0x1F251, 'M', u'可'),
     (0x1F252, 'X'),
-    (0x1F300, 'V'),
-    (0x1F321, 'X'),
-    (0x1F330, 'V'),
-    (0x1F336, 'X'),
-    (0x1F337, 'V'),
-    (0x1F37D, 'X'),
-    (0x1F380, 'V'),
-    (0x1F394, 'X'),
-    (0x1F3A0, 'V'),
-    (0x1F3C5, 'X'),
-    (0x1F3C6, 'V'),
-    (0x1F3CB, 'X'),
-    (0x1F3E0, 'V'),
-    (0x1F3F1, 'X'),
-    (0x1F400, 'V'),
-    (0x1F43F, 'X'),
-    (0x1F440, 'V'),
+    (0x1F260, 'V'),
     ]
 
-def _seg_67():
+def _seg_72():
     return [
-    (0x1F441, 'X'),
-    (0x1F442, 'V'),
-    (0x1F4F8, 'X'),
-    (0x1F4F9, 'V'),
-    (0x1F4FD, 'X'),
-    (0x1F500, 'V'),
-    (0x1F53E, 'X'),
-    (0x1F540, 'V'),
-    (0x1F544, 'X'),
-    (0x1F550, 'V'),
-    (0x1F568, 'X'),
-    (0x1F5FB, 'V'),
-    (0x1F641, 'X'),
-    (0x1F645, 'V'),
-    (0x1F650, 'X'),
-    (0x1F680, 'V'),
-    (0x1F6C6, 'X'),
+    (0x1F266, 'X'),
+    (0x1F300, 'V'),
+    (0x1F6D5, 'X'),
+    (0x1F6E0, 'V'),
+    (0x1F6ED, 'X'),
+    (0x1F6F0, 'V'),
+    (0x1F6F9, 'X'),
     (0x1F700, 'V'),
     (0x1F774, 'X'),
+    (0x1F780, 'V'),
+    (0x1F7D5, 'X'),
+    (0x1F800, 'V'),
+    (0x1F80C, 'X'),
+    (0x1F810, 'V'),
+    (0x1F848, 'X'),
+    (0x1F850, 'V'),
+    (0x1F85A, 'X'),
+    (0x1F860, 'V'),
+    (0x1F888, 'X'),
+    (0x1F890, 'V'),
+    (0x1F8AE, 'X'),
+    (0x1F900, 'V'),
+    (0x1F90C, 'X'),
+    (0x1F910, 'V'),
+    (0x1F93F, 'X'),
+    (0x1F940, 'V'),
+    (0x1F94D, 'X'),
+    (0x1F950, 'V'),
+    (0x1F96C, 'X'),
+    (0x1F980, 'V'),
+    (0x1F998, 'X'),
+    (0x1F9C0, 'V'),
+    (0x1F9C1, 'X'),
+    (0x1F9D0, 'V'),
+    (0x1F9E7, 'X'),
     (0x20000, 'V'),
     (0x2A6D7, 'X'),
     (0x2A700, 'V'),
     (0x2B735, 'X'),
     (0x2B740, 'V'),
     (0x2B81E, 'X'),
+    (0x2B820, 'V'),
+    (0x2CEA2, 'X'),
+    (0x2CEB0, 'V'),
+    (0x2EBE1, 'X'),
     (0x2F800, 'M', u'丽'),
     (0x2F801, 'M', u'丸'),
     (0x2F802, 'M', u'乁'),
@@ -7055,6 +7595,10 @@ def _seg_67():
     (0x2F836, 'M', u'及'),
     (0x2F837, 'M', u'叟'),
     (0x2F838, 'M', u'𠭣'),
+    ]
+
+def _seg_73():
+    return [
     (0x2F839, 'M', u'叫'),
     (0x2F83A, 'M', u'叱'),
     (0x2F83B, 'M', u'吆'),
@@ -7075,10 +7619,6 @@ def _seg_67():
     (0x2F84B, 'M', u'圖'),
     (0x2F84C, 'M', u'嘆'),
     (0x2F84D, 'M', u'圗'),
-    ]
-
-def _seg_68():
-    return [
     (0x2F84E, 'M', u'噑'),
     (0x2F84F, 'M', u'噴'),
     (0x2F850, 'M', u'切'),
@@ -7159,6 +7699,10 @@ def _seg_68():
     (0x2F89E, 'M', u'志'),
     (0x2F89F, 'M', u'忹'),
     (0x2F8A0, 'M', u'悁'),
+    ]
+
+def _seg_74():
+    return [
     (0x2F8A1, 'M', u'㤺'),
     (0x2F8A2, 'M', u'㤜'),
     (0x2F8A3, 'M', u'悔'),
@@ -7179,10 +7723,6 @@ def _seg_68():
     (0x2F8B2, 'M', u'成'),
     (0x2F8B3, 'M', u'戛'),
     (0x2F8B4, 'M', u'扝'),
-    ]
-
-def _seg_69():
-    return [
     (0x2F8B5, 'M', u'抱'),
     (0x2F8B6, 'M', u'拔'),
     (0x2F8B7, 'M', u'捐'),
@@ -7263,6 +7803,10 @@ def _seg_69():
     (0x2F902, 'M', u'流'),
     (0x2F903, 'M', u'浩'),
     (0x2F904, 'M', u'浸'),
+    ]
+
+def _seg_75():
+    return [
     (0x2F905, 'M', u'涅'),
     (0x2F906, 'M', u'𣴞'),
     (0x2F907, 'M', u'洴'),
@@ -7283,10 +7827,6 @@ def _seg_69():
     (0x2F916, 'M', u'㶖'),
     (0x2F917, 'M', u'灊'),
     (0x2F918, 'M', u'災'),
-    ]
-
-def _seg_70():
-    return [
     (0x2F919, 'M', u'灷'),
     (0x2F91A, 'M', u'炭'),
     (0x2F91B, 'M', u'𠔥'),
@@ -7367,6 +7907,10 @@ def _seg_70():
     (0x2F969, 'M', u'糣'),
     (0x2F96A, 'M', u'紀'),
     (0x2F96B, 'M', u'𥾆'),
+    ]
+
+def _seg_76():
+    return [
     (0x2F96C, 'M', u'絣'),
     (0x2F96D, 'M', u'䌁'),
     (0x2F96E, 'M', u'緇'),
@@ -7387,10 +7931,6 @@ def _seg_70():
     (0x2F97D, 'M', u'聠'),
     (0x2F97E, 'M', u'𦖨'),
     (0x2F97F, 'M', u'聰'),
-    ]
-
-def _seg_71():
-    return [
     (0x2F980, 'M', u'𣍟'),
     (0x2F981, 'M', u'䏕'),
     (0x2F982, 'M', u'育'),
@@ -7471,6 +8011,10 @@ def _seg_71():
     (0x2F9CD, 'M', u'䚾'),
     (0x2F9CE, 'M', u'䛇'),
     (0x2F9CF, 'M', u'誠'),
+    ]
+
+def _seg_77():
+    return [
     (0x2F9D0, 'M', u'諭'),
     (0x2F9D1, 'M', u'變'),
     (0x2F9D2, 'M', u'豕'),
@@ -7491,10 +8035,6 @@ def _seg_71():
     (0x2F9E1, 'M', u'𨗭'),
     (0x2F9E2, 'M', u'邔'),
     (0x2F9E3, 'M', u'郱'),
-    ]
-
-def _seg_72():
-    return [
     (0x2F9E4, 'M', u'鄑'),
     (0x2F9E5, 'M', u'𨜮'),
     (0x2F9E6, 'M', u'鄛'),
@@ -7631,4 +8171,9 @@ uts46data = tuple(
     + _seg_70()
     + _seg_71()
     + _seg_72()
+    + _seg_73()
+    + _seg_74()
+    + _seg_75()
+    + _seg_76()
+    + _seg_77()
 )
diff --git a/pipenv/patched/notpip/_vendor/ipaddress.py b/pipenv/patched/notpip/_vendor/ipaddress.py
index 8cfdd58a..f2d07668 100644
--- a/pipenv/patched/notpip/_vendor/ipaddress.py
+++ b/pipenv/patched/notpip/_vendor/ipaddress.py
@@ -14,7 +14,7 @@ from __future__ import unicode_literals
 import itertools
 import struct
 
-__version__ = '1.0.19'
+__version__ = '1.0.22'
 
 # Compatibility functions
 _compat_int_types = (int,)
diff --git a/pipenv/patched/notpip/_vendor/packaging/__about__.py b/pipenv/patched/notpip/_vendor/packaging/__about__.py
index 4255c5b5..21fc6ce3 100644
--- a/pipenv/patched/notpip/_vendor/packaging/__about__.py
+++ b/pipenv/patched/notpip/_vendor/packaging/__about__.py
@@ -12,10 +12,10 @@ __title__ = "packaging"
 __summary__ = "Core utilities for Python packages"
 __uri__ = "https://github.com/pypa/packaging"
 
-__version__ = "17.1"
+__version__ = "18.0"
 
 __author__ = "Donald Stufft and individual contributors"
 __email__ = "donald@stufft.io"
 
 __license__ = "BSD or Apache License, Version 2.0"
-__copyright__ = "Copyright 2014-2016 %s" % __author__
+__copyright__ = "Copyright 2014-2018 %s" % __author__
diff --git a/pipenv/patched/notpip/_vendor/packaging/requirements.py b/pipenv/patched/notpip/_vendor/packaging/requirements.py
index 0da25914..5ec5d74a 100644
--- a/pipenv/patched/notpip/_vendor/packaging/requirements.py
+++ b/pipenv/patched/notpip/_vendor/packaging/requirements.py
@@ -92,16 +92,16 @@ class Requirement(object):
         try:
             req = REQUIREMENT.parseString(requirement_string)
         except ParseException as e:
-            raise InvalidRequirement(
-                "Invalid requirement, parse error at \"{0!r}\"".format(
-                    requirement_string[e.loc:e.loc + 8]))
+            raise InvalidRequirement("Parse error at \"{0!r}\": {1}".format(
+                requirement_string[e.loc:e.loc + 8], e.msg
+            ))
 
         self.name = req.name
         if req.url:
             parsed_url = urlparse.urlparse(req.url)
             if not (parsed_url.scheme and parsed_url.netloc) or (
                     not parsed_url.scheme and not parsed_url.netloc):
-                raise InvalidRequirement("Invalid URL given")
+                raise InvalidRequirement("Invalid URL: {0}".format(req.url))
             self.url = req.url
         else:
             self.url = None
diff --git a/pipenv/patched/notpip/_vendor/packaging/specifiers.py b/pipenv/patched/notpip/_vendor/packaging/specifiers.py
index 9b6353f0..4c798999 100644
--- a/pipenv/patched/notpip/_vendor/packaging/specifiers.py
+++ b/pipenv/patched/notpip/_vendor/packaging/specifiers.py
@@ -503,7 +503,7 @@ class Specifier(_IndividualSpecifier):
                 return False
 
         # Ensure that we do not allow a local version of the version mentioned
-        # in the specifier, which is techincally greater than, to match.
+        # in the specifier, which is technically greater than, to match.
         if prospective.local is not None:
             if Version(prospective.base_version) == Version(spec.base_version):
                 return False
diff --git a/pipenv/patched/piptools/LICENSE.txt b/pipenv/patched/notpip/_vendor/pep517/LICENSE
similarity index 94%
rename from pipenv/patched/piptools/LICENSE.txt
rename to pipenv/patched/notpip/_vendor/pep517/LICENSE
index 89de3547..b0ae9dbc 100644
--- a/pipenv/patched/piptools/LICENSE.txt
+++ b/pipenv/patched/notpip/_vendor/pep517/LICENSE
@@ -1,3 +1,7 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Thomas Kluyver
+
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
diff --git a/pipenv/patched/notpip/_vendor/pep517/__init__.py b/pipenv/patched/notpip/_vendor/pep517/__init__.py
new file mode 100644
index 00000000..8beedea4
--- /dev/null
+++ b/pipenv/patched/notpip/_vendor/pep517/__init__.py
@@ -0,0 +1,4 @@
+"""Wrappers to build Python packages using PEP 517 hooks
+"""
+
+__version__ = '0.2'
diff --git a/pipenv/patched/notpip/_vendor/pep517/_in_process.py b/pipenv/patched/notpip/_vendor/pep517/_in_process.py
new file mode 100644
index 00000000..baa14d38
--- /dev/null
+++ b/pipenv/patched/notpip/_vendor/pep517/_in_process.py
@@ -0,0 +1,182 @@
+"""This is invoked in a subprocess to call the build backend hooks.
+
+It expects:
+- Command line args: hook_name, control_dir
+- Environment variable: PEP517_BUILD_BACKEND=entry.point:spec
+- control_dir/input.json:
+  - {"kwargs": {...}}
+
+Results:
+- control_dir/output.json
+  - {"return_val": ...}
+"""
+from glob import glob
+from importlib import import_module
+import os
+from os.path import join as pjoin
+import re
+import shutil
+import sys
+
+# This is run as a script, not a module, so it can't do a relative import
+import compat
+
+def _build_backend():
+    """Find and load the build backend"""
+    ep = os.environ['PEP517_BUILD_BACKEND']
+    mod_path, _, obj_path = ep.partition(':')
+    obj = import_module(mod_path)
+    if obj_path:
+        for path_part in obj_path.split('.'):
+            obj = getattr(obj, path_part)
+    return obj
+
+def get_requires_for_build_wheel(config_settings):
+    """Invoke the optional get_requires_for_build_wheel hook
+    
+    Returns [] if the hook is not defined.
+    """
+    backend = _build_backend()
+    try:
+        hook = backend.get_requires_for_build_wheel
+    except AttributeError:
+        return []
+    else:
+        return hook(config_settings)
+
+def prepare_metadata_for_build_wheel(metadata_directory, config_settings):
+    """Invoke optional prepare_metadata_for_build_wheel
+    
+    Implements a fallback by building a wheel if the hook isn't defined.
+    """
+    backend = _build_backend()
+    try:
+        hook = backend.prepare_metadata_for_build_wheel
+    except AttributeError:
+        return _get_wheel_metadata_from_wheel(backend, metadata_directory,
+                                              config_settings)
+    else:
+        return hook(metadata_directory, config_settings)
+
+WHEEL_BUILT_MARKER = 'PEP517_ALREADY_BUILT_WHEEL'
+
+def _dist_info_files(whl_zip):
+    """Identify the .dist-info folder inside a wheel ZipFile."""
+    res = []
+    for path in whl_zip.namelist():
+        m = re.match(r'[^/\\]+-[^/\\]+\.dist-info/', path)
+        if m:
+            res.append(path)
+    if res:
+        return res
+    raise Exception("No .dist-info folder found in wheel")
+
+def _get_wheel_metadata_from_wheel(backend, metadata_directory, config_settings):
+    """Build a wheel and extract the metadata from it.
+    
+    Fallback for when the build backend does not define the 'get_wheel_metadata'
+    hook.
+    """
+    from zipfile import ZipFile
+    whl_basename = backend.build_wheel(metadata_directory, config_settings)
+    with open(os.path.join(metadata_directory, WHEEL_BUILT_MARKER), 'wb'):
+        pass  # Touch marker file
+
+    whl_file = os.path.join(metadata_directory, whl_basename)
+    with ZipFile(whl_file) as zipf:
+        dist_info = _dist_info_files(zipf)
+        zipf.extractall(path=metadata_directory, members=dist_info)
+    return dist_info[0].split('/')[0]
+
+def _find_already_built_wheel(metadata_directory):
+    """Check for a wheel already built during the get_wheel_metadata hook.
+    """
+    if not metadata_directory:
+        return None
+    metadata_parent = os.path.dirname(metadata_directory)
+    if not os.path.isfile(pjoin(metadata_parent, WHEEL_BUILT_MARKER)):
+        return None
+
+    whl_files = glob(os.path.join(metadata_parent, '*.whl'))
+    if not whl_files:
+        print('Found wheel built marker, but no .whl files')
+        return None
+    if len(whl_files) > 1:
+        print('Found multiple .whl files; unspecified behaviour. '
+              'Will call build_wheel.')
+        return None
+    
+    # Exactly one .whl file
+    return whl_files[0]
+
+def build_wheel(wheel_directory, config_settings, metadata_directory=None):
+    """Invoke the mandatory build_wheel hook.
+    
+    If a wheel was already built in the prepare_metadata_for_build_wheel fallback, this
+    will copy it rather than rebuilding the wheel.
+    """
+    prebuilt_whl = _find_already_built_wheel(metadata_directory)
+    if prebuilt_whl:
+        shutil.copy2(prebuilt_whl, wheel_directory)
+        return os.path.basename(prebuilt_whl)
+
+    return _build_backend().build_wheel(wheel_directory, config_settings,
+                                        metadata_directory)
+
+
+def get_requires_for_build_sdist(config_settings):
+    """Invoke the optional get_requires_for_build_wheel hook
+
+    Returns [] if the hook is not defined.
+    """
+    backend = _build_backend()
+    try:
+        hook = backend.get_requires_for_build_sdist
+    except AttributeError:
+        return []
+    else:
+        return hook(config_settings)
+
+class _DummyException(Exception):
+    """Nothing should ever raise this exception"""
+
+class GotUnsupportedOperation(Exception):
+    """For internal use when backend raises UnsupportedOperation"""
+
+def build_sdist(sdist_directory, config_settings):
+    """Invoke the mandatory build_sdist hook."""
+    backend = _build_backend()
+    try:
+        return backend.build_sdist(sdist_directory, config_settings)
+    except getattr(backend, 'UnsupportedOperation', _DummyException):
+        raise GotUnsupportedOperation
+
+HOOK_NAMES = {
+    'get_requires_for_build_wheel',
+    'prepare_metadata_for_build_wheel',
+    'build_wheel',
+    'get_requires_for_build_sdist',
+    'build_sdist',
+}
+
+def main():
+    if len(sys.argv) < 3:
+        sys.exit("Needs args: hook_name, control_dir")
+    hook_name = sys.argv[1]
+    control_dir = sys.argv[2]
+    if hook_name not in HOOK_NAMES:
+        sys.exit("Unknown hook: %s" % hook_name)
+    hook = globals()[hook_name]
+
+    hook_input = compat.read_json(pjoin(control_dir, 'input.json'))
+
+    json_out = {'unsupported': False, 'return_val': None}
+    try:
+        json_out['return_val'] = hook(**hook_input['kwargs'])
+    except GotUnsupportedOperation:
+        json_out['unsupported'] = True
+    
+    compat.write_json(json_out, pjoin(control_dir, 'output.json'), indent=2)
+
+if __name__ == '__main__':
+    main()
diff --git a/pipenv/patched/notpip/_vendor/pep517/check.py b/pipenv/patched/notpip/_vendor/pep517/check.py
new file mode 100644
index 00000000..3dffd2e0
--- /dev/null
+++ b/pipenv/patched/notpip/_vendor/pep517/check.py
@@ -0,0 +1,194 @@
+"""Check a project and backend by attempting to build using PEP 517 hooks.
+"""
+import argparse
+import logging
+import os
+from os.path import isfile, join as pjoin
+from pipenv.patched.notpip._vendor.pytoml import TomlError, load as toml_load
+import shutil
+from subprocess import CalledProcessError
+import sys
+import tarfile
+from tempfile import mkdtemp
+import zipfile
+
+from .colorlog import enable_colourful_output
+from .envbuild import BuildEnvironment
+from .wrappers import Pep517HookCaller
+
+log = logging.getLogger(__name__)
+
+def check_build_sdist(hooks):
+    with BuildEnvironment() as env:
+        try:
+            env.pip_install(hooks.build_sys_requires)
+            log.info('Installed static build dependencies')
+        except CalledProcessError:
+            log.error('Failed to install static build dependencies')
+            return False
+
+        try:
+            reqs = hooks.get_requires_for_build_sdist({})
+            log.info('Got build requires: %s', reqs)
+        except:
+            log.error('Failure in get_requires_for_build_sdist', exc_info=True)
+            return False
+
+        try:
+            env.pip_install(reqs)
+            log.info('Installed dynamic build dependencies')
+        except CalledProcessError:
+            log.error('Failed to install dynamic build dependencies')
+            return False
+
+        td = mkdtemp()
+        log.info('Trying to build sdist in %s', td)
+        try:
+            try:
+                filename = hooks.build_sdist(td, {})
+                log.info('build_sdist returned %r', filename)
+            except:
+                log.info('Failure in build_sdist', exc_info=True)
+                return False
+
+            if not filename.endswith('.tar.gz'):
+                log.error("Filename %s doesn't have .tar.gz extension", filename)
+                return False
+
+            path = pjoin(td, filename)
+            if isfile(path):
+                log.info("Output file %s exists", path)
+            else:
+                log.error("Output file %s does not exist", path)
+                return False
+
+            if tarfile.is_tarfile(path):
+                log.info("Output file is a tar file")
+            else:
+                log.error("Output file is not a tar file")
+                return False
+
+        finally:
+            shutil.rmtree(td)
+
+        return True
+
+def check_build_wheel(hooks):
+    with BuildEnvironment() as env:
+        try:
+            env.pip_install(hooks.build_sys_requires)
+            log.info('Installed static build dependencies')
+        except CalledProcessError:
+            log.error('Failed to install static build dependencies')
+            return False
+
+        try:
+            reqs = hooks.get_requires_for_build_wheel({})
+            log.info('Got build requires: %s', reqs)
+        except:
+            log.error('Failure in get_requires_for_build_sdist', exc_info=True)
+            return False
+
+        try:
+            env.pip_install(reqs)
+            log.info('Installed dynamic build dependencies')
+        except CalledProcessError:
+            log.error('Failed to install dynamic build dependencies')
+            return False
+
+        td = mkdtemp()
+        log.info('Trying to build wheel in %s', td)
+        try:
+            try:
+                filename = hooks.build_wheel(td, {})
+                log.info('build_wheel returned %r', filename)
+            except:
+                log.info('Failure in build_wheel', exc_info=True)
+                return False
+
+            if not filename.endswith('.whl'):
+                log.error("Filename %s doesn't have .whl extension", filename)
+                return False
+
+            path = pjoin(td, filename)
+            if isfile(path):
+                log.info("Output file %s exists", path)
+            else:
+                log.error("Output file %s does not exist", path)
+                return False
+
+            if zipfile.is_zipfile(path):
+                log.info("Output file is a zip file")
+            else:
+                log.error("Output file is not a zip file")
+                return False
+
+        finally:
+            shutil.rmtree(td)
+
+        return True
+
+
+def check(source_dir):
+    pyproject = pjoin(source_dir, 'pyproject.toml')
+    if isfile(pyproject):
+        log.info('Found pyproject.toml')
+    else:
+        log.error('Missing pyproject.toml')
+        return False
+
+    try:
+        with open(pyproject) as f:
+            pyproject_data = toml_load(f)
+        # Ensure the mandatory data can be loaded
+        buildsys = pyproject_data['build-system']
+        requires = buildsys['requires']
+        backend = buildsys['build-backend']
+        log.info('Loaded pyproject.toml')
+    except (TomlError, KeyError):
+        log.error("Invalid pyproject.toml", exc_info=True)
+        return False
+
+    hooks = Pep517HookCaller(source_dir, backend)
+
+    sdist_ok = check_build_sdist(hooks)
+    wheel_ok = check_build_wheel(hooks)
+
+    if not sdist_ok:
+        log.warning('Sdist checks failed; scroll up to see')
+    if not wheel_ok:
+        log.warning('Wheel checks failed')
+
+    return sdist_ok
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser()
+    ap.add_argument('source_dir',
+        help="A directory containing pyproject.toml")
+    args = ap.parse_args(argv)
+
+    enable_colourful_output()
+
+    ok = check(args.source_dir)
+
+    if ok:
+        print(ansi('Checks passed', 'green'))
+    else:
+        print(ansi('Checks failed', 'red'))
+        sys.exit(1)
+
+ansi_codes = {
+    'reset': '\x1b[0m',
+    'bold': '\x1b[1m',
+    'red': '\x1b[31m',
+    'green': '\x1b[32m',
+}
+def ansi(s, attr):
+    if os.name != 'nt' and sys.stdout.isatty():
+        return ansi_codes[attr] + str(s) + ansi_codes['reset']
+    else:
+        return str(s)
+
+if __name__ == '__main__':
+    main()
diff --git a/pipenv/patched/notpip/_vendor/pep517/colorlog.py b/pipenv/patched/notpip/_vendor/pep517/colorlog.py
new file mode 100644
index 00000000..26cf7480
--- /dev/null
+++ b/pipenv/patched/notpip/_vendor/pep517/colorlog.py
@@ -0,0 +1,110 @@
+"""Nicer log formatting with colours.
+
+Code copied from Tornado, Apache licensed.
+"""
+# Copyright 2012 Facebook
+#
+# 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
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import logging
+import sys
+
+try:
+    import curses
+except ImportError:
+    curses = None
+
+def _stderr_supports_color():
+    color = False
+    if curses and hasattr(sys.stderr, 'isatty') and sys.stderr.isatty():
+        try:
+            curses.setupterm()
+            if curses.tigetnum("colors") > 0:
+                color = True
+        except Exception:
+            pass
+    return color
+
+class LogFormatter(logging.Formatter):
+    """Log formatter with colour support
+    """
+    DEFAULT_COLORS = {
+        logging.INFO: 2, # Green
+        logging.WARNING: 3, # Yellow
+        logging.ERROR: 1, # Red
+        logging.CRITICAL: 1,
+    }
+
+    def __init__(self, color=True, datefmt=None):
+        r"""
+        :arg bool color: Enables color support.
+        :arg string fmt: Log message format.
+        It will be applied to the attributes dict of log records. The
+        text between ``%(color)s`` and ``%(end_color)s`` will be colored
+        depending on the level if color support is on.
+        :arg dict colors: color mappings from logging level to terminal color
+        code
+        :arg string datefmt: Datetime format.
+        Used for formatting ``(asctime)`` placeholder in ``prefix_fmt``.
+        .. versionchanged:: 3.2
+        Added ``fmt`` and ``datefmt`` arguments.
+        """
+        logging.Formatter.__init__(self, datefmt=datefmt)
+        self._colors = {}
+        if color and _stderr_supports_color():
+            # The curses module has some str/bytes confusion in
+            # python3. Until version 3.2.3, most methods return
+            # bytes, but only accept strings. In addition, we want to
+            # output these strings with the logging module, which
+            # works with unicode strings. The explicit calls to
+            # unicode() below are harmless in python2 but will do the
+            # right conversion in python 3.
+            fg_color = (curses.tigetstr("setaf") or
+                        curses.tigetstr("setf") or "")
+            if (3, 0) < sys.version_info < (3, 2, 3):
+                fg_color = str(fg_color, "ascii")
+
+            for levelno, code in self.DEFAULT_COLORS.items():
+                self._colors[levelno] = str(curses.tparm(fg_color, code), "ascii")
+            self._normal = str(curses.tigetstr("sgr0"), "ascii")
+
+            scr = curses.initscr()
+            self.termwidth = scr.getmaxyx()[1]
+            curses.endwin()
+        else:
+            self._normal = ''
+            # Default width is usually 80, but too wide is worse than too narrow
+            self.termwidth = 70
+
+    def formatMessage(self, record):
+        l = len(record.message)
+        right_text = '{initial}-{name}'.format(initial=record.levelname[0],
+                                               name=record.name)
+        if l + len(right_text) < self.termwidth:
+            space = ' ' * (self.termwidth - (l + len(right_text)))
+        else:
+            space = '  '
+
+        if record.levelno in self._colors:
+            start_color = self._colors[record.levelno]
+            end_color = self._normal
+        else:
+            start_color = end_color = ''
+
+        return record.message + space + start_color + right_text + end_color
+
+def enable_colourful_output(level=logging.INFO):
+    handler = logging.StreamHandler()
+    handler.setFormatter(LogFormatter())
+    logging.root.addHandler(handler)
+    logging.root.setLevel(level)
diff --git a/pipenv/patched/notpip/_vendor/pep517/compat.py b/pipenv/patched/notpip/_vendor/pep517/compat.py
new file mode 100644
index 00000000..01c66fc7
--- /dev/null
+++ b/pipenv/patched/notpip/_vendor/pep517/compat.py
@@ -0,0 +1,23 @@
+"""Handle reading and writing JSON in UTF-8, on Python 3 and 2."""
+import json
+import sys
+
+if sys.version_info[0] >= 3:
+    # Python 3
+    def write_json(obj, path, **kwargs):
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(obj, f, **kwargs)
+
+    def read_json(path):
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+else:
+    # Python 2
+    def write_json(obj, path, **kwargs):
+        with open(path, 'wb') as f:
+            json.dump(obj, f, encoding='utf-8', **kwargs)
+
+    def read_json(path):
+        with open(path, 'rb') as f:
+            return json.load(f)
diff --git a/pipenv/patched/notpip/_vendor/pep517/envbuild.py b/pipenv/patched/notpip/_vendor/pep517/envbuild.py
new file mode 100644
index 00000000..c54d3585
--- /dev/null
+++ b/pipenv/patched/notpip/_vendor/pep517/envbuild.py
@@ -0,0 +1,150 @@
+"""Build wheels/sdists by installing build deps to a temporary environment.
+"""
+
+import os
+import logging
+from pipenv.patched.notpip._vendor import pytoml
+import shutil
+from subprocess import check_call
+import sys
+from sysconfig import get_paths
+from tempfile import mkdtemp
+
+from .wrappers import Pep517HookCaller
+
+log = logging.getLogger(__name__)
+
+def _load_pyproject(source_dir):
+    with open(os.path.join(source_dir, 'pyproject.toml')) as f:
+        pyproject_data = pytoml.load(f)
+    buildsys = pyproject_data['build-system']
+    return buildsys['requires'], buildsys['build-backend']
+
+
+class BuildEnvironment(object):
+    """Context manager to install build deps in a simple temporary environment
+
+    Based on code I wrote for pip, which is MIT licensed.
+    """
+    # Copyright (c) 2008-2016 The pip developers (see AUTHORS.txt file)
+    #
+    # Permission is hereby granted, free of charge, to any person obtaining
+    # a copy of this software and associated documentation files (the
+    # "Software"), to deal in the Software without restriction, including
+    # without limitation the rights to use, copy, modify, merge, publish,
+    # distribute, sublicense, and/or sell copies of the Software, and to
+    # permit persons to whom the Software is furnished to do so, subject to
+    # the following conditions:
+    #
+    # The above copyright notice and this permission notice shall be
+    # included in all copies or substantial portions of the Software.
+    #
+    # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+    path = None
+
+    def __init__(self, cleanup=True):
+        self._cleanup = cleanup
+
+    def __enter__(self):
+        self.path = mkdtemp(prefix='pep517-build-env-')
+        log.info('Temporary build environment: %s', self.path)
+
+        self.save_path = os.environ.get('PATH', None)
+        self.save_pythonpath = os.environ.get('PYTHONPATH', None)
+
+        install_scheme = 'nt' if (os.name == 'nt') else 'posix_prefix'
+        install_dirs = get_paths(install_scheme, vars={
+            'base': self.path,
+            'platbase': self.path,
+        })
+
+        scripts = install_dirs['scripts']
+        if self.save_path:
+            os.environ['PATH'] = scripts + os.pathsep + self.save_path
+        else:
+            os.environ['PATH'] = scripts + os.pathsep + os.defpath
+
+        if install_dirs['purelib'] == install_dirs['platlib']:
+            lib_dirs = install_dirs['purelib']
+        else:
+            lib_dirs = install_dirs['purelib'] + os.pathsep + \
+                install_dirs['platlib']
+        if self.save_pythonpath:
+            os.environ['PYTHONPATH'] = lib_dirs + os.pathsep + \
+                self.save_pythonpath
+        else:
+            os.environ['PYTHONPATH'] = lib_dirs
+
+        return self
+
+    def pip_install(self, reqs):
+        """Install dependencies into this env by calling pip in a subprocess"""
+        if not reqs:
+            return
+        log.info('Calling pip to install %s', reqs)
+        check_call([sys.executable, '-m', 'pip', 'install', '--ignore-installed',
+                    '--prefix', self.path] + list(reqs))
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self._cleanup and (self.path is not None) and os.path.isdir(self.path):
+            shutil.rmtree(self.path)
+
+        if self.save_path is None:
+            os.environ.pop('PATH', None)
+        else:
+            os.environ['PATH'] = self.save_path
+
+        if self.save_pythonpath is None:
+            os.environ.pop('PYTHONPATH', None)
+        else:
+            os.environ['PYTHONPATH'] = self.save_pythonpath
+
+def build_wheel(source_dir, wheel_dir, config_settings=None):
+    """Build a wheel from a source directory using PEP 517 hooks.
+
+    :param str source_dir: Source directory containing pyproject.toml
+    :param str wheel_dir: Target directory to create wheel in
+    :param dict config_settings: Options to pass to build backend
+
+    This is a blocking function which will run pip in a subprocess to install
+    build requirements.
+    """
+    if config_settings is None:
+        config_settings = {}
+    requires, backend = _load_pyproject(source_dir)
+    hooks = Pep517HookCaller(source_dir, backend)
+
+    with BuildEnvironment() as env:
+        env.pip_install(requires)
+        reqs = hooks.get_requires_for_build_wheel(config_settings)
+        env.pip_install(reqs)
+        return hooks.build_wheel(wheel_dir, config_settings)
+
+
+def build_sdist(source_dir, sdist_dir, config_settings=None):
+    """Build an sdist from a source directory using PEP 517 hooks.
+
+    :param str source_dir: Source directory containing pyproject.toml
+    :param str sdist_dir: Target directory to place sdist in
+    :param dict config_settings: Options to pass to build backend
+
+    This is a blocking function which will run pip in a subprocess to install
+    build requirements.
+    """
+    if config_settings is None:
+        config_settings = {}
+    requires, backend = _load_pyproject(source_dir)
+    hooks = Pep517HookCaller(source_dir, backend)
+
+    with BuildEnvironment() as env:
+        env.pip_install(requires)
+        reqs = hooks.get_requires_for_build_sdist(config_settings)
+        env.pip_install(reqs)
+        return hooks.build_sdist(sdist_dir, config_settings)
diff --git a/pipenv/patched/notpip/_vendor/pep517/wrappers.py b/pipenv/patched/notpip/_vendor/pep517/wrappers.py
new file mode 100644
index 00000000..28260f32
--- /dev/null
+++ b/pipenv/patched/notpip/_vendor/pep517/wrappers.py
@@ -0,0 +1,134 @@
+from contextlib import contextmanager
+import os
+from os.path import dirname, abspath, join as pjoin
+import shutil
+from subprocess import check_call
+import sys
+from tempfile import mkdtemp
+
+from . import compat
+
+_in_proc_script = pjoin(dirname(abspath(__file__)), '_in_process.py')
+
+@contextmanager
+def tempdir():
+    td = mkdtemp()
+    try:
+        yield td
+    finally:
+        shutil.rmtree(td)
+
+class UnsupportedOperation(Exception):
+    """May be raised by build_sdist if the backend indicates that it can't."""
+
+class Pep517HookCaller(object):
+    """A wrapper around a source directory to be built with a PEP 517 backend.
+
+    source_dir : The path to the source directory, containing pyproject.toml.
+    backend : The build backend spec, as per PEP 517, from pyproject.toml.
+    """
+    def __init__(self, source_dir, build_backend):
+        self.source_dir = abspath(source_dir)
+        self.build_backend = build_backend
+
+    def get_requires_for_build_wheel(self, config_settings=None):
+        """Identify packages required for building a wheel
+
+        Returns a list of dependency specifications, e.g.:
+            ["wheel >= 0.25", "setuptools"]
+
+        This does not include requirements specified in pyproject.toml.
+        It returns the result of calling the equivalently named hook in a
+        subprocess.
+        """
+        return self._call_hook('get_requires_for_build_wheel', {
+            'config_settings': config_settings
+        })
+
+    def prepare_metadata_for_build_wheel(self, metadata_directory, config_settings=None):
+        """Prepare a *.dist-info folder with metadata for this project.
+
+        Returns the name of the newly created folder.
+
+        If the build backend defines a hook with this name, it will be called
+        in a subprocess. If not, the backend will be asked to build a wheel,
+        and the dist-info extracted from that.
+        """
+        return self._call_hook('prepare_metadata_for_build_wheel', {
+            'metadata_directory': abspath(metadata_directory),
+            'config_settings': config_settings,
+        })
+
+    def build_wheel(self, wheel_directory, config_settings=None, metadata_directory=None):
+        """Build a wheel from this project.
+
+        Returns the name of the newly created file.
+
+        In general, this will call the 'build_wheel' hook in the backend.
+        However, if that was previously called by
+        'prepare_metadata_for_build_wheel', and the same metadata_directory is
+        used, the previously built wheel will be copied to wheel_directory.
+        """
+        if metadata_directory is not None:
+            metadata_directory = abspath(metadata_directory)
+        return self._call_hook('build_wheel', {
+            'wheel_directory': abspath(wheel_directory),
+            'config_settings': config_settings,
+            'metadata_directory': metadata_directory,
+        })
+
+    def get_requires_for_build_sdist(self, config_settings=None):
+        """Identify packages required for building a wheel
+
+        Returns a list of dependency specifications, e.g.:
+            ["setuptools >= 26"]
+
+        This does not include requirements specified in pyproject.toml.
+        It returns the result of calling the equivalently named hook in a
+        subprocess.
+        """
+        return self._call_hook('get_requires_for_build_sdist', {
+            'config_settings': config_settings
+        })
+
+    def build_sdist(self, sdist_directory, config_settings=None):
+        """Build an sdist from this project.
+
+        Returns the name of the newly created file.
+
+        This calls the 'build_sdist' backend hook in a subprocess.
+        """
+        return self._call_hook('build_sdist', {
+            'sdist_directory': abspath(sdist_directory),
+            'config_settings': config_settings,
+        })
+
+
+    def _call_hook(self, hook_name, kwargs):
+        env = os.environ.copy()
+
+        # On Python 2, pytoml returns Unicode values (which is correct) but the
+        # environment passed to check_call needs to contain string values. We
+        # convert here by encoding using ASCII (the backend can only contain
+        # letters, digits and _, . and : characters, and will be used as a
+        # Python identifier, so non-ASCII content is wrong on Python 2 in
+        # any case).
+        if sys.version_info[0] == 2:
+            build_backend = self.build_backend.encode('ASCII')
+        else:
+            build_backend = self.build_backend
+
+        env['PEP517_BUILD_BACKEND'] = build_backend
+        with tempdir() as td:
+            compat.write_json({'kwargs': kwargs}, pjoin(td, 'input.json'),
+                              indent=2)
+
+            # Run the hook in a subprocess
+            check_call([sys.executable, _in_proc_script, hook_name, td],
+                       cwd=self.source_dir, env=env)
+
+            data = compat.read_json(pjoin(td, 'output.json'))
+            if data.get('unsupported'):
+                raise UnsupportedOperation
+            return data['return_val']
+
diff --git a/pipenv/patched/notpip/_vendor/pkg_resources/__init__.py b/pipenv/patched/notpip/_vendor/pkg_resources/__init__.py
index 3f3a0a4e..ac893b66 100644
--- a/pipenv/patched/notpip/_vendor/pkg_resources/__init__.py
+++ b/pipenv/patched/notpip/_vendor/pkg_resources/__init__.py
@@ -47,6 +47,11 @@ except ImportError:
     # Python 3.2 compatibility
     import imp as _imp
 
+try:
+    FileExistsError
+except NameError:
+    FileExistsError = OSError
+
 from pipenv.patched.notpip._vendor import six
 from pipenv.patched.notpip._vendor.six.moves import urllib, map, filter
 
@@ -78,8 +83,11 @@ __import__('pipenv.patched.notpip._vendor.packaging.requirements')
 __import__('pipenv.patched.notpip._vendor.packaging.markers')
 
 
-if (3, 0) < sys.version_info < (3, 3):
-    raise RuntimeError("Python 3.3 or later is required")
+__metaclass__ = type
+
+
+if (3, 0) < sys.version_info < (3, 4):
+    raise RuntimeError("Python 3.4 or later is required")
 
 if six.PY2:
     # Those builtin exceptions are only defined in Python 3
@@ -377,11 +385,7 @@ def get_build_platform():
     XXX Currently this is the same as ``distutils.util.get_platform()``, but it
     needs some hacks for Linux and Mac OS X.
     """
-    try:
-        # Python 2.7 or >=3.2
-        from sysconfig import get_platform
-    except ImportError:
-        from distutils.util import get_platform
+    from sysconfig import get_platform
 
     plat = get_platform()
     if sys.platform == "darwin" and not plat.startswith('macosx-'):
@@ -541,7 +545,7 @@ class IResourceProvider(IMetadataProvider):
         """List of resource names in the directory (like ``os.listdir()``)"""
 
 
-class WorkingSet(object):
+class WorkingSet:
     """A collection of active distributions on sys.path (or a similar list)"""
 
     def __init__(self, entries=None):
@@ -641,13 +645,12 @@ class WorkingSet(object):
         distributions in the working set, otherwise only ones matching
         both `group` and `name` are yielded (in distribution order).
         """
-        for dist in self:
-            entries = dist.get_entry_map(group)
-            if name is None:
-                for ep in entries.values():
-                    yield ep
-            elif name in entries:
-                yield entries[name]
+        return (
+            entry
+            for dist in self
+            for entry in dist.get_entry_map(group).values()
+            if name is None or name == entry.name
+        )
 
     def run_script(self, requires, script_name):
         """Locate distribution for `requires` and run `script_name` script"""
@@ -948,7 +951,7 @@ class _ReqExtras(dict):
         return not req.marker or any(extra_evals)
 
 
-class Environment(object):
+class Environment:
     """Searchable snapshot of distributions on a search path"""
 
     def __init__(
@@ -963,7 +966,7 @@ class Environment(object):
         `platform` is an optional string specifying the name of the platform
         that platform-specific distributions must be compatible with.  If
         unspecified, it defaults to the current platform.  `python` is an
-        optional string naming the desired version of Python (e.g. ``'3.3'``);
+        optional string naming the desired version of Python (e.g. ``'3.6'``);
         it defaults to the current version.
 
         You may explicitly set `platform` (and/or `python`) to ``None`` if you
@@ -1518,12 +1521,10 @@ class DefaultProvider(EggProvider):
 
     @classmethod
     def _register(cls):
-        loader_cls = getattr(
-            importlib_machinery,
-            'SourceFileLoader',
-            type(None),
-        )
-        register_loader_type(loader_cls, cls)
+        loader_names = 'SourceFileLoader', 'SourcelessFileLoader',
+        for name in loader_names:
+            loader_cls = getattr(importlib_machinery, name, type(None))
+            register_loader_type(loader_cls, cls)
 
 
 DefaultProvider._register()
@@ -2093,7 +2094,12 @@ def _handle_ns(packageName, path_item):
     importer = get_importer(path_item)
     if importer is None:
         return None
-    loader = importer.find_module(packageName)
+
+    # capture warnings due to #1111
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        loader = importer.find_module(packageName)
+
     if loader is None:
         return None
     module = sys.modules.get(packageName)
@@ -2138,12 +2144,13 @@ def _rebuild_mod_path(orig_path, package_name, module):
         parts = path_parts[:-module_parts]
         return safe_sys_path_index(_normalize_cached(os.sep.join(parts)))
 
-    if not isinstance(orig_path, list):
-        # Is this behavior useful when module.__path__ is not a list?
-        return
+    new_path = sorted(orig_path, key=position_in_sys_path)
+    new_path = [_normalize_cached(p) for p in new_path]
 
-    orig_path.sort(key=position_in_sys_path)
-    module.__path__[:] = [_normalize_cached(p) for p in orig_path]
+    if isinstance(module.__path__, list):
+        module.__path__[:] = new_path
+    else:
+        module.__path__ = new_path
 
 
 def declare_namespace(packageName):
@@ -2154,9 +2161,10 @@ def declare_namespace(packageName):
         if packageName in _namespace_packages:
             return
 
-        path, parent = sys.path, None
-        if '.' in packageName:
-            parent = '.'.join(packageName.split('.')[:-1])
+        path = sys.path
+        parent, _, _ = packageName.rpartition('.')
+
+        if parent:
             declare_namespace(parent)
             if parent not in _namespace_packages:
                 __import__(parent)
@@ -2167,7 +2175,7 @@ def declare_namespace(packageName):
 
         # Track what packages are namespaces, so when new path items are added,
         # they can be updated
-        _namespace_packages.setdefault(parent, []).append(packageName)
+        _namespace_packages.setdefault(parent or None, []).append(packageName)
         _namespace_packages.setdefault(packageName, [])
 
         for path_item in path:
@@ -2285,7 +2293,7 @@ EGG_NAME = re.compile(
 ).match
 
 
-class EntryPoint(object):
+class EntryPoint:
     """Object representing an advertised importable object"""
 
     def __init__(self, name, module_name, attrs=(), extras=(), dist=None):
@@ -2439,7 +2447,7 @@ def _version_from_file(lines):
     return safe_version(value.strip()) or None
 
 
-class Distribution(object):
+class Distribution:
     """Wrap an actual or potential sys.path entry w/metadata"""
     PKG_INFO = 'PKG-INFO'
 
@@ -2669,6 +2677,19 @@ class Distribution(object):
             raise AttributeError(attr)
         return getattr(self._provider, attr)
 
+    def __dir__(self):
+        return list(
+            set(super(Distribution, self).__dir__())
+            | set(
+                attr for attr in self._provider.__dir__()
+                if not attr.startswith('_')
+            )
+        )
+
+    if not hasattr(object, '__dir__'):
+        # python 2.7 not supported
+        del __dir__
+
     @classmethod
     def from_filename(cls, filename, metadata=None, **kw):
         return cls.from_location(
@@ -3020,7 +3041,10 @@ def _bypass_ensure_directory(path):
     dirname, filename = split(path)
     if dirname and filename and not isdir(dirname):
         _bypass_ensure_directory(dirname)
-        mkdir(dirname, 0o755)
+        try:
+            mkdir(dirname, 0o755)
+        except FileExistsError:
+            pass
 
 
 def split_sections(s):
diff --git a/pipenv/patched/notpip/_vendor/pkg_resources/py31compat.py b/pipenv/patched/notpip/_vendor/pkg_resources/py31compat.py
index 331a51bb..3a44fa1c 100644
--- a/pipenv/patched/notpip/_vendor/pkg_resources/py31compat.py
+++ b/pipenv/patched/notpip/_vendor/pkg_resources/py31compat.py
@@ -2,6 +2,8 @@ import os
 import errno
 import sys
 
+from pipenv.patched.notpip._vendor import six
+
 
 def _makedirs_31(path, exist_ok=False):
     try:
@@ -15,8 +17,7 @@ def _makedirs_31(path, exist_ok=False):
 #  and exists_ok considerations are disentangled.
 # See https://github.com/pypa/setuptools/pull/1083#issuecomment-315168663
 needs_makedirs = (
-    sys.version_info < (3, 2, 5) or
-    (3, 3) <= sys.version_info < (3, 3, 6) or
+    six.PY2 or
     (3, 4) <= sys.version_info < (3, 4, 1)
 )
 makedirs = _makedirs_31 if needs_makedirs else os.makedirs
diff --git a/pipenv/patched/notpip/_vendor/progress/__init__.py b/pipenv/patched/notpip/_vendor/progress/__init__.py
index 09dfc1eb..a41f65dc 100644
--- a/pipenv/patched/notpip/_vendor/progress/__init__.py
+++ b/pipenv/patched/notpip/_vendor/progress/__init__.py
@@ -21,7 +21,7 @@ from sys import stderr
 from time import time
 
 
-__version__ = '1.3'
+__version__ = '1.4'
 
 
 class Infinite(object):
diff --git a/pipenv/patched/notpip/_vendor/progress/bar.py b/pipenv/patched/notpip/_vendor/progress/bar.py
index 5ee968f0..025e61c4 100644
--- a/pipenv/patched/notpip/_vendor/progress/bar.py
+++ b/pipenv/patched/notpip/_vendor/progress/bar.py
@@ -15,6 +15,9 @@
 # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 from __future__ import unicode_literals
+
+import sys
+
 from . import Progress
 from .helpers import WritelnMixin
 
@@ -61,7 +64,10 @@ class FillingCirclesBar(ChargingBar):
 
 
 class IncrementalBar(Bar):
-    phases = (' ', '▏', '▎', '▍', '▌', '▋', '▊', '▉', '█')
+    if sys.platform.startswith('win'):
+        phases = (u' ', u'▌', u'█')
+    else:
+        phases = (' ', '▏', '▎', '▍', '▌', '▋', '▊', '▉', '█')
 
     def update(self):
         nphases = len(self.phases)
diff --git a/pipenv/patched/notpip/_vendor/progress/helpers.py b/pipenv/patched/notpip/_vendor/progress/helpers.py
index 9ed90b2b..0cde44ec 100644
--- a/pipenv/patched/notpip/_vendor/progress/helpers.py
+++ b/pipenv/patched/notpip/_vendor/progress/helpers.py
@@ -28,14 +28,14 @@ class WriteMixin(object):
         if message:
             self.message = message
 
-        if self.file.isatty():
+        if self.file and self.file.isatty():
             if self.hide_cursor:
                 print(HIDE_CURSOR, end='', file=self.file)
             print(self.message, end='', file=self.file)
             self.file.flush()
 
     def write(self, s):
-        if self.file.isatty():
+        if self.file and self.file.isatty():
             b = '\b' * self._width
             c = s.ljust(self._width)
             print(b + c, end='', file=self.file)
@@ -43,7 +43,7 @@ class WriteMixin(object):
             self.file.flush()
 
     def finish(self):
-        if self.file.isatty() and self.hide_cursor:
+        if self.file and self.file.isatty() and self.hide_cursor:
             print(SHOW_CURSOR, end='', file=self.file)
 
 
@@ -55,21 +55,21 @@ class WritelnMixin(object):
         if message:
             self.message = message
 
-        if self.file.isatty() and self.hide_cursor:
+        if self.file and self.file.isatty() and self.hide_cursor:
             print(HIDE_CURSOR, end='', file=self.file)
 
     def clearln(self):
-        if self.file.isatty():
+        if self.file and self.file.isatty():
             print('\r\x1b[K', end='', file=self.file)
 
     def writeln(self, line):
-        if self.file.isatty():
+        if self.file and self.file.isatty():
             self.clearln()
             print(line, end='', file=self.file)
             self.file.flush()
 
     def finish(self):
-        if self.file.isatty():
+        if self.file and self.file.isatty():
             print(file=self.file)
             if self.hide_cursor:
                 print(SHOW_CURSOR, end='', file=self.file)
diff --git a/pipenv/patched/notpip/_vendor/pyparsing.py b/pipenv/patched/notpip/_vendor/pyparsing.py
index b5ba3d5f..455d1151 100644
--- a/pipenv/patched/notpip/_vendor/pyparsing.py
+++ b/pipenv/patched/notpip/_vendor/pyparsing.py
@@ -1,6 +1,6 @@
 # module pyparsing.py
 #
-# Copyright (c) 2003-2016  Paul T. McGuire
+# Copyright (c) 2003-2018  Paul T. McGuire
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -25,6 +25,7 @@
 __doc__ = \
 """
 pyparsing module - Classes and methods to define and execute parsing grammars
+=============================================================================
 
 The pyparsing module is an alternative approach to creating and executing simple grammars,
 vs. the traditional lex/yacc approach, or the use of regular expressions.  With pyparsing, you
@@ -58,10 +59,23 @@ The pyparsing module handles some of the problems that are typically vexing when
  - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello  ,  World  !", etc.)
  - quoted strings
  - embedded comments
+
+
+Getting Started -
+-----------------
+Visit the classes L{ParserElement} and L{ParseResults} to see the base classes that most other pyparsing
+classes inherit from. Use the docstrings for examples of how to:
+ - construct literal match expressions from L{Literal} and L{CaselessLiteral} classes
+ - construct character word-group expressions using the L{Word} class
+ - see how to create repetitive expressions using L{ZeroOrMore} and L{OneOrMore} classes
+ - use L{'+'<And>}, L{'|'<MatchFirst>}, L{'^'<Or>}, and L{'&'<Each>} operators to combine simple expressions into more complex ones
+ - associate names with your parsed results using L{ParserElement.setResultsName}
+ - find some helpful expression short-cuts like L{delimitedList} and L{oneOf}
+ - find more useful common expressions in the L{pyparsing_common} namespace class
 """
 
-__version__ = "2.2.0"
-__versionTime__ = "06 Mar 2017 02:06 UTC"
+__version__ = "2.2.1"
+__versionTime__ = "18 Sep 2018 00:49 UTC"
 __author__ = "Paul McGuire <ptmcg@users.sourceforge.net>"
 
 import string
@@ -82,6 +96,15 @@ try:
 except ImportError:
     from threading import RLock
 
+try:
+    # Python 3
+    from collections.abc import Iterable
+    from collections.abc import MutableMapping
+except ImportError:
+    # Python 2.7
+    from collections import Iterable
+    from collections import MutableMapping
+
 try:
     from collections import OrderedDict as _OrderedDict
 except ImportError:
@@ -940,7 +963,7 @@ class ParseResults(object):
     def __dir__(self):
         return (dir(type(self)) + list(self.keys()))
 
-collections.MutableMapping.register(ParseResults)
+MutableMapping.register(ParseResults)
 
 def col (loc,strg):
     """Returns current column within a string, counting newlines as line separators.
@@ -1025,11 +1048,11 @@ def _trim_arity(func, maxargs=2):
             # special handling for Python 3.5.0 - extra deep call stack by 1
             offset = -3 if system_version == (3,5,0) else -2
             frame_summary = traceback.extract_stack(limit=-offset+limit-1)[offset]
-            return [(frame_summary.filename, frame_summary.lineno)]
+            return [frame_summary[:2]]
         def extract_tb(tb, limit=0):
             frames = traceback.extract_tb(tb, limit=limit)
             frame_summary = frames[-1]
-            return [(frame_summary.filename, frame_summary.lineno)]
+            return [frame_summary[:2]]
     else:
         extract_stack = traceback.extract_stack
         extract_tb = traceback.extract_tb
@@ -1374,7 +1397,7 @@ class ParserElement(object):
             else:
                 preloc = loc
             tokensStart = preloc
-            if self.mayIndexError or loc >= len(instring):
+            if self.mayIndexError or preloc >= len(instring):
                 try:
                     loc,tokens = self.parseImpl( instring, preloc, doActions )
                 except IndexError:
@@ -1408,7 +1431,6 @@ class ParserElement(object):
                                                   self.resultsName,
                                                   asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
                                                   modal=self.modalResults )
-
         if debugging:
             #~ print ("Matched",self,"->",retTokens.asList())
             if (self.debugActions[1] ):
@@ -3242,7 +3264,7 @@ class ParseExpression(ParserElement):
 
         if isinstance( exprs, basestring ):
             self.exprs = [ ParserElement._literalStringClass( exprs ) ]
-        elif isinstance( exprs, collections.Iterable ):
+        elif isinstance( exprs, Iterable ):
             exprs = list(exprs)
             # if sequence of strings provided, wrap with Literal
             if all(isinstance(expr, basestring) for expr in exprs):
@@ -4393,7 +4415,7 @@ def traceParseAction(f):
 
         @traceParseAction
         def remove_duplicate_chars(tokens):
-            return ''.join(sorted(set(''.join(tokens)))
+            return ''.join(sorted(set(''.join(tokens))))
 
         wds = OneOrMore(wd).setParseAction(remove_duplicate_chars)
         print(wds.parseString("slkdjs sld sldd sdlf sdljf"))
@@ -4583,7 +4605,7 @@ def oneOf( strs, caseless=False, useRegex=True ):
     symbols = []
     if isinstance(strs,basestring):
         symbols = strs.split()
-    elif isinstance(strs, collections.Iterable):
+    elif isinstance(strs, Iterable):
         symbols = list(strs)
     else:
         warnings.warn("Invalid argument to oneOf, expected string or iterable",
@@ -4734,7 +4756,7 @@ stringEnd   = StringEnd().setName("stringEnd")
 _escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1])
 _escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0].lstrip(r'\0x'),16)))
 _escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],8)))
-_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | Word(printables, excludeChars=r'\]', exact=1) | Regex(r"\w", re.UNICODE)
+_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | CharsNotIn(r'\]', exact=1)
 _charRange = Group(_singleChar + Suppress("-") + _singleChar)
 _reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]"
 
diff --git a/pipenv/patched/notpip/_vendor/pytoml/parser.py b/pipenv/patched/notpip/_vendor/pytoml/parser.py
index 7fc3d34d..9f94e923 100644
--- a/pipenv/patched/notpip/_vendor/pytoml/parser.py
+++ b/pipenv/patched/notpip/_vendor/pytoml/parser.py
@@ -6,35 +6,35 @@ if sys.version_info[0] == 2:
 else:
     _chr = chr
 
-def load(fin, translate=lambda t, x, v: v):
-    return loads(fin.read(), translate=translate, filename=getattr(fin, 'name', repr(fin)))
+def load(fin, translate=lambda t, x, v: v, object_pairs_hook=dict):
+    return loads(fin.read(), translate=translate, object_pairs_hook=object_pairs_hook, filename=getattr(fin, 'name', repr(fin)))
 
-def loads(s, filename='<string>', translate=lambda t, x, v: v):
+def loads(s, filename='<string>', translate=lambda t, x, v: v, object_pairs_hook=dict):
     if isinstance(s, bytes):
         s = s.decode('utf-8')
 
     s = s.replace('\r\n', '\n')
 
-    root = {}
-    tables = {}
+    root = object_pairs_hook()
+    tables = object_pairs_hook()
     scope = root
 
     src = _Source(s, filename=filename)
-    ast = _p_toml(src)
+    ast = _p_toml(src, object_pairs_hook=object_pairs_hook)
 
     def error(msg):
         raise TomlError(msg, pos[0], pos[1], filename)
 
-    def process_value(v):
+    def process_value(v, object_pairs_hook):
         kind, text, value, pos = v
         if kind == 'str' and value.startswith('\n'):
             value = value[1:]
         if kind == 'array':
             if value and any(k != value[0][0] for k, t, v, p in value[1:]):
                 error('array-type-mismatch')
-            value = [process_value(item) for item in value]
+            value = [process_value(item, object_pairs_hook=object_pairs_hook) for item in value]
         elif kind == 'table':
-            value = dict([(k, process_value(value[k])) for k in value])
+            value = object_pairs_hook([(k, process_value(value[k], object_pairs_hook=object_pairs_hook)) for k in value])
         return translate(kind, text, value)
 
     for kind, value, pos in ast:
@@ -42,7 +42,7 @@ def loads(s, filename='<string>', translate=lambda t, x, v: v):
             k, v = value
             if k in scope:
                 error('duplicate_keys. Key "{0}" was used more than once.'.format(k))
-            scope[k] = process_value(v)
+            scope[k] = process_value(v, object_pairs_hook=object_pairs_hook)
         else:
             is_table_array = (kind == 'table_array')
             cur = tables
@@ -50,19 +50,19 @@ def loads(s, filename='<string>', translate=lambda t, x, v: v):
                 if isinstance(cur.get(name), list):
                     d, cur = cur[name][-1]
                 else:
-                    d, cur = cur.setdefault(name, (None, {}))
+                    d, cur = cur.setdefault(name, (None, object_pairs_hook()))
 
-            scope = {}
+            scope = object_pairs_hook()
             name = value[-1]
             if name not in cur:
                 if is_table_array:
-                    cur[name] = [(scope, {})]
+                    cur[name] = [(scope, object_pairs_hook())]
                 else:
-                    cur[name] = (scope, {})
+                    cur[name] = (scope, object_pairs_hook())
             elif isinstance(cur[name], list):
                 if not is_table_array:
                     error('table_type_mismatch')
-                cur[name].append((scope, {}))
+                cur[name].append((scope, object_pairs_hook()))
             else:
                 if is_table_array:
                     error('table_type_mismatch')
@@ -73,7 +73,7 @@ def loads(s, filename='<string>', translate=lambda t, x, v: v):
 
     def merge_tables(scope, tables):
         if scope is None:
-            scope = {}
+            scope = object_pairs_hook()
         for k in tables:
             if k in scope:
                 error('key_table_conflict')
@@ -223,9 +223,9 @@ _float_re = re.compile(r'[+-]?(?:0|[1-9](?:_?\d)*)(?:\.\d(?:_?\d)*)?(?:[eE][+-]?
 _datetime_re = re.compile(r'(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d+)?(?:Z|([+-]\d{2}):(\d{2}))')
 
 _basicstr_ml_re = re.compile(r'(?:(?:|"|"")[^"\\\000-\011\013-\037])*')
-_litstr_re = re.compile(r"[^'\000-\037]*")
-_litstr_ml_re = re.compile(r"(?:(?:|'|'')(?:[^'\000-\011\013-\037]))*")
-def _p_value(s):
+_litstr_re = re.compile(r"[^'\000\010\012-\037]*")
+_litstr_ml_re = re.compile(r"(?:(?:|'|'')(?:[^'\000-\010\013-\037]))*")
+def _p_value(s, object_pairs_hook):
     pos = s.pos()
 
     if s.consume('true'):
@@ -283,7 +283,7 @@ def _p_value(s):
         with s:
             while True:
                 _p_ews(s)
-                items.append(_p_value(s))
+                items.append(_p_value(s, object_pairs_hook=object_pairs_hook))
                 s.commit()
                 _p_ews(s)
                 s.expect(',')
@@ -294,13 +294,13 @@ def _p_value(s):
 
     if s.consume('{'):
         _p_ws(s)
-        items = {}
+        items = object_pairs_hook()
         if not s.consume('}'):
             k = _p_key(s)
             _p_ws(s)
             s.expect('=')
             _p_ws(s)
-            items[k] = _p_value(s)
+            items[k] = _p_value(s, object_pairs_hook=object_pairs_hook)
             _p_ws(s)
             while s.consume(','):
                 _p_ws(s)
@@ -308,14 +308,14 @@ def _p_value(s):
                 _p_ws(s)
                 s.expect('=')
                 _p_ws(s)
-                items[k] = _p_value(s)
+                items[k] = _p_value(s, object_pairs_hook=object_pairs_hook)
                 _p_ws(s)
             s.expect('}')
         return 'table', None, items, pos
 
     s.fail()
 
-def _p_stmt(s):
+def _p_stmt(s, object_pairs_hook):
     pos = s.pos()
     if s.consume(   '['):
         is_array = s.consume('[')
@@ -335,19 +335,19 @@ def _p_stmt(s):
     _p_ws(s)
     s.expect('=')
     _p_ws(s)
-    value = _p_value(s)
+    value = _p_value(s, object_pairs_hook=object_pairs_hook)
     return 'kv', (key, value), pos
 
 _stmtsep_re = re.compile(r'(?:[ \t]*(?:#[^\n]*)?\n)+[ \t]*')
-def _p_toml(s):
+def _p_toml(s, object_pairs_hook):
     stmts = []
     _p_ews(s)
     with s:
-        stmts.append(_p_stmt(s))
+        stmts.append(_p_stmt(s, object_pairs_hook=object_pairs_hook))
         while True:
             s.commit()
             s.expect_re(_stmtsep_re)
-            stmts.append(_p_stmt(s))
+            stmts.append(_p_stmt(s, object_pairs_hook=object_pairs_hook))
     _p_ews(s)
     s.expect_eof()
     return stmts
diff --git a/pipenv/patched/notpip/_vendor/requests/LICENSE b/pipenv/patched/notpip/_vendor/requests/LICENSE
index db78ea69..2e68b82e 100644
--- a/pipenv/patched/notpip/_vendor/requests/LICENSE
+++ b/pipenv/patched/notpip/_vendor/requests/LICENSE
@@ -1,4 +1,4 @@
-Copyright 2017 Kenneth Reitz
+Copyright 2018 Kenneth Reitz
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
diff --git a/pipenv/patched/notpip/_vendor/requests/__init__.py b/pipenv/patched/notpip/_vendor/requests/__init__.py
index 9270af26..af3d4b1d 100644
--- a/pipenv/patched/notpip/_vendor/requests/__init__.py
+++ b/pipenv/patched/notpip/_vendor/requests/__init__.py
@@ -57,10 +57,10 @@ def check_compatibility(urllib3_version, chardet_version):
     # Check urllib3 for compatibility.
     major, minor, patch = urllib3_version  # noqa: F811
     major, minor, patch = int(major), int(minor), int(patch)
-    # urllib3 >= 1.21.1, <= 1.22
+    # urllib3 >= 1.21.1, <= 1.23
     assert major == 1
     assert minor >= 21
-    assert minor <= 22
+    assert minor <= 23
 
     # Check chardet for compatibility.
     major, minor, patch = chardet_version.split('.')[:3]
@@ -71,6 +71,17 @@ def check_compatibility(urllib3_version, chardet_version):
     assert patch >= 2
 
 
+def _check_cryptography(cryptography_version):
+    # cryptography < 1.3.4
+    try:
+        cryptography_version = list(map(int, cryptography_version.split('.')))
+    except ValueError:
+        return
+
+    if cryptography_version < [1, 3, 4]:
+        warning = 'Old version of cryptography ({0}) may cause slowdown.'.format(cryptography_version)
+        warnings.warn(warning, RequestsDependencyWarning)
+
 # Check imported dependencies for compatibility.
 try:
     check_compatibility(urllib3.__version__, chardet.__version__)
@@ -80,11 +91,15 @@ except (AssertionError, ValueError):
                   RequestsDependencyWarning)
 
 # Attempt to enable urllib3's SNI support, if possible
-from pipenv.patched.notpip._internal.compat import WINDOWS
+from pipenv.patched.notpip._internal.utils.compat import WINDOWS
 if not WINDOWS:
     try:
         from pipenv.patched.notpip._vendor.urllib3.contrib import pyopenssl
         pyopenssl.inject_into_urllib3()
+
+        # Check cryptography version
+        from cryptography import __version__ as cryptography_version
+        _check_cryptography(cryptography_version)
     except ImportError:
         pass
 
diff --git a/pipenv/patched/notpip/_vendor/requests/__version__.py b/pipenv/patched/notpip/_vendor/requests/__version__.py
index dc33eef6..ef61ec0f 100644
--- a/pipenv/patched/notpip/_vendor/requests/__version__.py
+++ b/pipenv/patched/notpip/_vendor/requests/__version__.py
@@ -5,10 +5,10 @@
 __title__ = 'requests'
 __description__ = 'Python HTTP for Humans.'
 __url__ = 'http://python-requests.org'
-__version__ = '2.18.4'
-__build__ = 0x021804
+__version__ = '2.19.1'
+__build__ = 0x021901
 __author__ = 'Kenneth Reitz'
 __author_email__ = 'me@kennethreitz.org'
 __license__ = 'Apache 2.0'
-__copyright__ = 'Copyright 2017 Kenneth Reitz'
+__copyright__ = 'Copyright 2018 Kenneth Reitz'
 __cake__ = u'\u2728 \U0001f370 \u2728'
diff --git a/pipenv/patched/notpip/_vendor/requests/adapters.py b/pipenv/patched/notpip/_vendor/requests/adapters.py
index 58cea3a6..014c2675 100644
--- a/pipenv/patched/notpip/_vendor/requests/adapters.py
+++ b/pipenv/patched/notpip/_vendor/requests/adapters.py
@@ -13,6 +13,7 @@ import socket
 
 from pipenv.patched.notpip._vendor.urllib3.poolmanager import PoolManager, proxy_from_url
 from pipenv.patched.notpip._vendor.urllib3.response import HTTPResponse
+from pipenv.patched.notpip._vendor.urllib3.util import parse_url
 from pipenv.patched.notpip._vendor.urllib3.util import Timeout as TimeoutSauce
 from pipenv.patched.notpip._vendor.urllib3.util.retry import Retry
 from pipenv.patched.notpip._vendor.urllib3.exceptions import ClosedPoolError
@@ -28,13 +29,13 @@ from pipenv.patched.notpip._vendor.urllib3.exceptions import ResponseError
 
 from .models import Response
 from .compat 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 .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, InvalidSchema)
+                         ProxyError, RetryError, InvalidSchema, InvalidProxyURL)
 from .auth import _basic_auth_str
 
 try:
@@ -219,7 +220,7 @@ class HTTPAdapter(BaseAdapter):
                 cert_loc = verify
 
             if not cert_loc:
-                cert_loc = DEFAULT_CA_BUNDLE_PATH
+                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, "
@@ -300,6 +301,10 @@ class HTTPAdapter(BaseAdapter):
 
         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)
         else:
@@ -406,7 +411,7 @@ class HTTPAdapter(BaseAdapter):
 
         self.cert_verify(conn, request.url, verify, cert)
         url = self.request_url(request, proxies)
-        self.add_headers(request)
+        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)
 
diff --git a/pipenv/patched/notpip/_vendor/requests/api.py b/pipenv/patched/notpip/_vendor/requests/api.py
index bc2115c1..a2cc84d7 100644
--- a/pipenv/patched/notpip/_vendor/requests/api.py
+++ b/pipenv/patched/notpip/_vendor/requests/api.py
@@ -20,7 +20,7 @@ def request(method, url, **kwargs):
     :param url: URL for the new :class:`Request` object.
     :param params: (optional) Dictionary or bytes to be sent in the query string for the :class:`Request`.
     :param data: (optional) Dictionary or 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 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.
diff --git a/pipenv/patched/notpip/_vendor/requests/auth.py b/pipenv/patched/notpip/_vendor/requests/auth.py
index 1a182dff..4ae45947 100644
--- a/pipenv/patched/notpip/_vendor/requests/auth.py
+++ b/pipenv/patched/notpip/_vendor/requests/auth.py
@@ -153,6 +153,18 @@ class HTTPDigestAuth(AuthBase):
                     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))
 
diff --git a/pipenv/patched/notpip/_vendor/requests/compat.py b/pipenv/patched/notpip/_vendor/requests/compat.py
index 011972c6..4fbd6231 100644
--- a/pipenv/patched/notpip/_vendor/requests/compat.py
+++ b/pipenv/patched/notpip/_vendor/requests/compat.py
@@ -47,6 +47,7 @@ if is_py2:
     import cookielib
     from Cookie import Morsel
     from StringIO import StringIO
+    from collections import Callable, Mapping, MutableMapping
 
     from pipenv.patched.notpip._vendor.urllib3.packages.ordered_dict import OrderedDict
 
@@ -64,6 +65,7 @@ elif is_py3:
     from http.cookies import Morsel
     from io import StringIO
     from collections import OrderedDict
+    from collections.abc import Callable, Mapping, MutableMapping
 
     builtin_str = str
     str = str
diff --git a/pipenv/patched/notpip/_vendor/requests/cookies.py b/pipenv/patched/notpip/_vendor/requests/cookies.py
index ab3c88b9..50883a84 100644
--- a/pipenv/patched/notpip/_vendor/requests/cookies.py
+++ b/pipenv/patched/notpip/_vendor/requests/cookies.py
@@ -12,10 +12,9 @@ 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 .compat import cookielib, urlparse, urlunparse, Morsel
+from .compat import cookielib, urlparse, urlunparse, Morsel, MutableMapping
 
 try:
     import threading
@@ -169,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.
 
@@ -415,9 +414,14 @@ class RequestsCookieJar(cookielib.CookieJar, collections.MutableMapping):
     def copy(self):
         """Return a copy of this RequestsCookieJar."""
         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:
diff --git a/pipenv/patched/notpip/_vendor/requests/exceptions.py b/pipenv/patched/notpip/_vendor/requests/exceptions.py
index ea644a8f..78b573c7 100644
--- a/pipenv/patched/notpip/_vendor/requests/exceptions.py
+++ b/pipenv/patched/notpip/_vendor/requests/exceptions.py
@@ -85,6 +85,10 @@ 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."""
 
diff --git a/pipenv/patched/notpip/_vendor/requests/help.py b/pipenv/patched/notpip/_vendor/requests/help.py
index abc097a7..eba69edb 100644
--- a/pipenv/patched/notpip/_vendor/requests/help.py
+++ b/pipenv/patched/notpip/_vendor/requests/help.py
@@ -13,7 +13,7 @@ from pipenv.patched.notpip._vendor import chardet
 from . import __version__ as requests_version
 
 try:
-    from .packages.urllib3.contrib import pyopenssl
+    from pipenv.patched.notpip._vendor.urllib3.contrib import pyopenssl
 except ImportError:
     pyopenssl = None
     OpenSSL = None
diff --git a/pipenv/patched/notpip/_vendor/requests/models.py b/pipenv/patched/notpip/_vendor/requests/models.py
index 157a2782..6708f09b 100644
--- a/pipenv/patched/notpip/_vendor/requests/models.py
+++ b/pipenv/patched/notpip/_vendor/requests/models.py
@@ -7,7 +7,6 @@ requests.models
 This module contains the primary objects that power Requests.
 """
 
-import collections
 import datetime
 import sys
 
@@ -37,6 +36,7 @@ from .utils import (
     stream_decode_response_unicode, to_key_val_list, parse_header_links,
     iter_slices, guess_json_utf, super_len, check_header_validity)
 from .compat import (
+    Callable, Mapping,
     cookielib, urlunparse, urlsplit, urlencode, str, bytes,
     is_py2, chardet, builtin_str, basestring)
 from .compat import json as complexjson
@@ -155,8 +155,12 @@ class RequestEncodingMixin(object):
 
             if isinstance(fp, (str, bytes, bytearray)):
                 fdata = fp
-            else:
+            elif hasattr(fp, 'read'):
                 fdata = fp.read()
+            elif fp is None:
+                continue
+            else:
+                fdata = fp
 
             rf = RequestField(name=k, data=fdata, filename=fn, headers=fh)
             rf.make_multipart(content_type=ft)
@@ -174,10 +178,10 @@ class RequestHooksMixin(object):
         if event not in self.hooks:
             raise ValueError('Unsupported event specified, with event name "%s"' % (event))
 
-        if isinstance(hook, collections.Callable):
+        if isinstance(hook, Callable):
             self.hooks[event].append(hook)
         elif hasattr(hook, '__iter__'):
-            self.hooks[event].extend(h for h in hook if isinstance(h, collections.Callable))
+            self.hooks[event].extend(h for h in hook if isinstance(h, Callable))
 
     def deregister_hook(self, event, hook):
         """Deregister a previously registered hook.
@@ -461,7 +465,7 @@ class PreparedRequest(RequestEncodingMixin, RequestHooksMixin):
 
         is_stream = all([
             hasattr(data, '__iter__'),
-            not isinstance(data, (basestring, list, tuple, collections.Mapping))
+            not isinstance(data, (basestring, list, tuple, Mapping))
         ])
 
         try:
@@ -686,11 +690,11 @@ class Response(object):
 
     @property
     def ok(self):
-        """Returns True if :attr:`status_code` is less than 400.
+        """Returns True if :attr:`status_code` is less than 400, False if not.
 
         This attribute checks if the status code of the response is between
         400 and 600 to see if there was a client error or a server error. If
-        the status code, is between 200 and 400, this will return True. This
+        the status code is between 200 and 400, this will return True. This
         is **not** a check to see if the response code is ``200 OK``.
         """
         try:
@@ -820,7 +824,7 @@ class Response(object):
             if self.status_code == 0 or self.raw is None:
                 self._content = None
             else:
-                self._content = bytes().join(self.iter_content(CONTENT_CHUNK_SIZE)) or bytes()
+                self._content = b''.join(self.iter_content(CONTENT_CHUNK_SIZE)) or b''
 
         self._content_consumed = True
         # don't need to release the connection; that's been handled by urllib3
diff --git a/pipenv/patched/notpip/_vendor/requests/sessions.py b/pipenv/patched/notpip/_vendor/requests/sessions.py
index 6570e733..ba135268 100644
--- a/pipenv/patched/notpip/_vendor/requests/sessions.py
+++ b/pipenv/patched/notpip/_vendor/requests/sessions.py
@@ -8,13 +8,12 @@ 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
 from datetime import timedelta
 
 from .auth import _basic_auth_str
-from .compat import cookielib, is_py3, OrderedDict, urljoin, urlparse
+from .compat import cookielib, is_py3, OrderedDict, urljoin, urlparse, Mapping
 from .cookies import (
     cookiejar_from_dict, extract_cookies_to_jar, RequestsCookieJar, merge_cookies)
 from .models import Request, PreparedRequest, DEFAULT_REDIRECT_LIMIT
@@ -38,8 +37,8 @@ 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':
-    try:  # Python 3.3+
+if sys.platform == 'win32':
+    try:  # Python 3.4+
         preferred_clock = time.perf_counter
     except AttributeError:  # Earlier than Python 3.
         preferred_clock = time.clock
@@ -123,6 +122,7 @@ class SessionRedirectMixin(object):
         hist = []  # keep track of history
 
         url = self.get_redirect_target(resp)
+        previous_fragment = urlparse(req.url).fragment
         while url:
             prepared_request = req.copy()
 
@@ -147,8 +147,12 @@ class SessionRedirectMixin(object):
                 parsed_rurl = urlparse(resp.url)
                 url = '%s:%s' % (to_native_string(parsed_rurl.scheme), url)
 
-            # The scheme should be lower case...
+            # 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.
@@ -696,7 +700,7 @@ class Session(SessionRedirectMixin):
         """
         for (prefix, adapter) in self.adapters.items():
 
-            if url.lower().startswith(prefix):
+            if url.lower().startswith(prefix.lower()):
                 return adapter
 
         # Nothing matches :-/
diff --git a/pipenv/patched/notpip/_vendor/requests/status_codes.py b/pipenv/patched/notpip/_vendor/requests/status_codes.py
index dee89190..ff462c6c 100644
--- a/pipenv/patched/notpip/_vendor/requests/status_codes.py
+++ b/pipenv/patched/notpip/_vendor/requests/status_codes.py
@@ -1,5 +1,22 @@
 # -*- coding: utf-8 -*-
 
+"""
+The ``codes`` object defines a mapping from common names for HTTP statuses
+to their numerical codes, accessible either as attributes or as dictionary
+items.
+
+>>> 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 = {
@@ -84,8 +101,20 @@ _codes = {
 
 codes = LookupDict(name='status_codes')
 
-for code, titles in _codes.items():
-    for title in titles:
-        setattr(codes, title, code)
-        if not title.startswith(('\\', '/')):
-            setattr(codes, title.upper(), code)
+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()
diff --git a/pipenv/patched/notpip/_vendor/requests/structures.py b/pipenv/patched/notpip/_vendor/requests/structures.py
index 05d2b3f5..da930e28 100644
--- a/pipenv/patched/notpip/_vendor/requests/structures.py
+++ b/pipenv/patched/notpip/_vendor/requests/structures.py
@@ -7,16 +7,14 @@ requests.structures
 Data structures that power Requests.
 """
 
-import collections
-
-from .compat import OrderedDict
+from .compat import OrderedDict, 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
@@ -71,7 +69,7 @@ class CaseInsensitiveDict(collections.MutableMapping):
         )
 
     def __eq__(self, other):
-        if isinstance(other, collections.Mapping):
+        if isinstance(other, Mapping):
             other = CaseInsensitiveDict(other)
         else:
             return NotImplemented
diff --git a/pipenv/patched/notpip/_vendor/requests/utils.py b/pipenv/patched/notpip/_vendor/requests/utils.py
index 5c47de98..431f6be0 100644
--- a/pipenv/patched/notpip/_vendor/requests/utils.py
+++ b/pipenv/patched/notpip/_vendor/requests/utils.py
@@ -8,17 +8,17 @@ This module provides utility functions that are used within Requests
 that are also useful for external consumption.
 """
 
-import cgi
 import codecs
-import collections
 import contextlib
 import io
 import os
-import platform
 import re
 import socket
 import struct
+import sys
+import tempfile
 import warnings
+import zipfile
 
 from .__version__ import __version__
 from . import certs
@@ -28,7 +28,7 @@ from .compat import parse_http_list as _parse_list_header
 from .compat import (
     quote, urlparse, bytes, str, OrderedDict, unquote, getproxies,
     proxy_bypass, urlunparse, basestring, integer_types, is_py3,
-    proxy_bypass_environment, getproxies_environment)
+    proxy_bypass_environment, getproxies_environment, Mapping)
 from .cookies import cookiejar_from_dict
 from .structures import CaseInsensitiveDict
 from .exceptions import (
@@ -39,19 +39,25 @@ NETRC_FILES = ('.netrc', '_netrc')
 DEFAULT_CA_BUNDLE_PATH = certs.where()
 
 
-if platform.system() == 'Windows':
+if sys.platform == 'win32':
     # provide a proxy_bypass version on Windows without DNS lookups
 
     def proxy_bypass_registry(host):
-        if is_py3:
-            import winreg
-        else:
-            import _winreg as winreg
+        try:
+            if is_py3:
+                import winreg
+            else:
+                import _winreg as winreg
+        except ImportError:
+            return False
+
         try:
             internetSettings = winreg.OpenKey(winreg.HKEY_CURRENT_USER,
                 r'Software\Microsoft\Windows\CurrentVersion\Internet Settings')
-            proxyEnable = winreg.QueryValueEx(internetSettings,
-                                              'ProxyEnable')[0]
+            # ProxyEnable could be REG_SZ or REG_DWORD, normalizing it
+            proxyEnable = int(winreg.QueryValueEx(internetSettings,
+                                              'ProxyEnable')[0])
+            # ProxyOverride is almost always a string
             proxyOverride = winreg.QueryValueEx(internetSettings,
                                                 'ProxyOverride')[0]
         except OSError:
@@ -216,6 +222,38 @@ def guess_filename(obj):
         return os.path.basename(name)
 
 
+def extract_zipped_paths(path):
+    """Replace nonexistent paths that look like they refer to a member of a zip
+    archive with the location of an extracted copy of the target, or else
+    just return the provided path unchanged.
+    """
+    if os.path.exists(path):
+        # this is already a valid path, no need to do anything further
+        return path
+
+    # find the first valid part of the provided path and treat that as a zip archive
+    # assume the rest of the path is the name of a member in the archive
+    archive, member = os.path.split(path)
+    while archive and not os.path.exists(archive):
+        archive, prefix = os.path.split(archive)
+        member = '/'.join([prefix, member])
+
+    if not zipfile.is_zipfile(archive):
+        return path
+
+    zip_file = zipfile.ZipFile(archive)
+    if member not in zip_file.namelist():
+        return path
+
+    # we have a valid zip archive and a valid member of that archive
+    tmp = tempfile.gettempdir()
+    extracted_path = os.path.join(tmp, *member.split('/'))
+    if not os.path.exists(extracted_path):
+        extracted_path = zip_file.extract(member, path=tmp)
+
+    return extracted_path
+
+
 def from_key_val_list(value):
     """Take an object and test to see if it can be represented as a
     dictionary. Unless it can not be represented as such, return an
@@ -262,7 +300,7 @@ def to_key_val_list(value):
     if isinstance(value, (str, bytes, bool, int)):
         raise ValueError('cannot encode objects that are not 2-tuples')
 
-    if isinstance(value, collections.Mapping):
+    if isinstance(value, Mapping):
         value = value.items()
 
     return list(value)
@@ -407,6 +445,31 @@ def get_encodings_from_content(content):
             xml_re.findall(content))
 
 
+def _parse_content_type_header(header):
+    """Returns content type and parameters from given header
+
+    :param header: string
+    :return: tuple containing content type and dictionary of
+         parameters
+    """
+
+    tokens = header.split(';')
+    content_type, params = tokens[0].strip(), tokens[1:]
+    params_dict = {}
+    items_to_strip = "\"' "
+
+    for param in params:
+        param = param.strip()
+        if param:
+            key, value = param, True
+            index_of_equals = param.find("=")
+            if index_of_equals != -1:
+                key = param[:index_of_equals].strip(items_to_strip)
+                value = param[index_of_equals + 1:].strip(items_to_strip)
+            params_dict[key] = value
+    return content_type, params_dict
+
+
 def get_encoding_from_headers(headers):
     """Returns encodings from given HTTP Header Dict.
 
@@ -419,7 +482,7 @@ def get_encoding_from_headers(headers):
     if not content_type:
         return None
 
-    content_type, params = cgi.parse_header(content_type)
+    content_type, params = _parse_content_type_header(content_type)
 
     if 'charset' in params:
         return params['charset'].strip("'\"")
@@ -632,6 +695,8 @@ def should_bypass_proxies(url, no_proxy):
 
     :rtype: bool
     """
+    # Prioritize lowercase environment variables over uppercase
+    # to keep a consistent behaviour with other http projects (curl, wget).
     get_proxy = lambda k: os.environ.get(k) or os.environ.get(k.upper())
 
     # First check whether no_proxy is defined. If it is, check that the URL
@@ -639,28 +704,31 @@ def should_bypass_proxies(url, no_proxy):
     no_proxy_arg = no_proxy
     if no_proxy is None:
         no_proxy = get_proxy('no_proxy')
-    netloc = urlparse(url).netloc
+    parsed = urlparse(url)
 
     if no_proxy:
         # We need to check whether we match here. We need to see if we match
-        # the end of the netloc, both with and without the port.
+        # the end of the hostname, both with and without the port.
         no_proxy = (
             host for host in no_proxy.replace(' ', '').split(',') if host
         )
 
-        ip = netloc.split(':')[0]
-        if is_ipv4_address(ip):
+        if is_ipv4_address(parsed.hostname):
             for proxy_ip in no_proxy:
                 if is_valid_cidr(proxy_ip):
-                    if address_in_network(ip, proxy_ip):
+                    if address_in_network(parsed.hostname, proxy_ip):
                         return True
-                elif ip == proxy_ip:
+                elif parsed.hostname == proxy_ip:
                     # If no_proxy ip was defined in plain IP notation instead of cidr notation &
                     # matches the IP of the index
                     return True
         else:
+            host_with_port = parsed.hostname
+            if parsed.port:
+                host_with_port += ':{0}'.format(parsed.port)
+
             for host in no_proxy:
-                if netloc.endswith(host) or netloc.split(':')[0].endswith(host):
+                if parsed.hostname.endswith(host) or host_with_port.endswith(host):
                     # The URL does match something in no_proxy, so we don't want
                     # to apply the proxies on this URL.
                     return True
@@ -673,7 +741,7 @@ def should_bypass_proxies(url, no_proxy):
     # legitimate problems.
     with set_environ('no_proxy', no_proxy_arg):
         try:
-            bypass = proxy_bypass(netloc)
+            bypass = proxy_bypass(parsed.hostname)
         except (TypeError, socket.gaierror):
             bypass = False
 
@@ -743,7 +811,7 @@ def default_headers():
 
 
 def parse_header_links(value):
-    """Return a dict of parsed link headers proxies.
+    """Return a list of parsed link headers proxies.
 
     i.e. Link: <http:/.../front.jpeg>; rel=front; type="image/jpeg",<http://.../back.jpeg>; rel=back;type="image/jpeg"
 
@@ -754,6 +822,10 @@ def parse_header_links(value):
 
     replace_chars = ' \'"'
 
+    value = value.strip(replace_chars)
+    if not value:
+        return links
+
     for val in re.split(', *<', value):
         try:
             url, params = val.split(';', 1)
diff --git a/pipenv/patched/notpip/_vendor/urllib3/__init__.py b/pipenv/patched/notpip/_vendor/urllib3/__init__.py
index aaa6b1c6..4bd533b5 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/__init__.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/__init__.py
@@ -32,7 +32,7 @@ except ImportError:
 
 __author__ = 'Andrey Petrov (andrey.petrov@shazow.net)'
 __license__ = 'MIT'
-__version__ = '1.22'
+__version__ = '1.23'
 
 __all__ = (
     'HTTPConnectionPool',
diff --git a/pipenv/patched/notpip/_vendor/urllib3/_collections.py b/pipenv/patched/notpip/_vendor/urllib3/_collections.py
index 5df2372c..6e36b84e 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/_collections.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/_collections.py
@@ -1,5 +1,8 @@
 from __future__ import absolute_import
-from collections import Mapping, MutableMapping
+try:
+    from collections.abc import Mapping, MutableMapping
+except ImportError:
+    from collections import Mapping, MutableMapping
 try:
     from threading import RLock
 except ImportError:  # Platform-specific: No threads available
@@ -15,6 +18,7 @@ try:  # Python 2.7+
     from collections import OrderedDict
 except ImportError:
     from .packages.ordered_dict import OrderedDict
+from .exceptions import InvalidHeader
 from .packages.six import iterkeys, itervalues, PY3
 
 
@@ -305,13 +309,22 @@ class HTTPHeaderDict(MutableMapping):
         # python2.7 does not expose a proper API for exporting multiheaders
         # efficiently. This function re-reads raw lines from the message
         # object and extracts the multiheaders properly.
+        obs_fold_continued_leaders = (' ', '\t')
         headers = []
 
         for line in message.headers:
-            if line.startswith((' ', '\t')):
-                key, value = headers[-1]
-                headers[-1] = (key, value + '\r\n' + line.rstrip())
-                continue
+            if line.startswith(obs_fold_continued_leaders):
+                if not headers:
+                    # We received a header line that starts with OWS as described
+                    # in RFC-7230 S3.2.4. This indicates a multiline header, but
+                    # there exists no previous header to which we can attach it.
+                    raise InvalidHeader(
+                        'Header continuation with no previous header: %s' % line
+                    )
+                else:
+                    key, value = headers[-1]
+                    headers[-1] = (key, value + ' ' + line.strip())
+                    continue
 
             key, value = line.split(':', 1)
             headers.append((key, value.strip()))
diff --git a/pipenv/patched/notpip/_vendor/urllib3/connection.py b/pipenv/patched/notpip/_vendor/urllib3/connection.py
index c0d83299..a03b573f 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/connection.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/connection.py
@@ -56,10 +56,11 @@ port_by_scheme = {
     'https': 443,
 }
 
-# When updating RECENT_DATE, move it to
-# within two years of the current date, and no
-# earlier than 6 months ago.
-RECENT_DATE = datetime.date(2016, 1, 1)
+# When updating RECENT_DATE, move it to within two years of the current date,
+# and not less than 6 months ago.
+# Example: if Today is 2018-01-01, then RECENT_DATE should be any date on or
+# after 2016-01-01 (today - 2 years) AND before 2017-07-01 (today - 6 months)
+RECENT_DATE = datetime.date(2017, 6, 30)
 
 
 class DummyConnection(object):
@@ -124,6 +125,35 @@ class HTTPConnection(_HTTPConnection, object):
         # Superclass also sets self.source_address in Python 2.7+.
         _HTTPConnection.__init__(self, *args, **kw)
 
+    @property
+    def host(self):
+        """
+        Getter method to remove any trailing dots that indicate the hostname is an FQDN.
+
+        In general, SSL certificates don't include the trailing dot indicating a
+        fully-qualified domain name, and thus, they don't validate properly when
+        checked against a domain name that includes the dot. In addition, some
+        servers may not expect to receive the trailing dot when provided.
+
+        However, the hostname with trailing dot is critical to DNS resolution; doing a
+        lookup with the trailing dot will properly only resolve the appropriate FQDN,
+        whereas a lookup without a trailing dot will search the system's search domain
+        list. Thus, it's important to keep the original host around for use only in
+        those cases where it's appropriate (i.e., when doing DNS lookup to establish the
+        actual TCP connection across which we're going to send HTTP requests).
+        """
+        return self._dns_host.rstrip('.')
+
+    @host.setter
+    def host(self, value):
+        """
+        Setter for the `host` property.
+
+        We assume that only urllib3 uses the _dns_host attribute; httplib itself
+        only uses `host`, and it seems reasonable that other libraries follow suit.
+        """
+        self._dns_host = value
+
     def _new_conn(self):
         """ Establish a socket connection and set nodelay settings on it.
 
@@ -138,7 +168,7 @@ class HTTPConnection(_HTTPConnection, object):
 
         try:
             conn = connection.create_connection(
-                (self.host, self.port), self.timeout, **extra_kw)
+                (self._dns_host, self.port), self.timeout, **extra_kw)
 
         except SocketTimeout as e:
             raise ConnectTimeoutError(
diff --git a/pipenv/patched/notpip/_vendor/urllib3/connectionpool.py b/pipenv/patched/notpip/_vendor/urllib3/connectionpool.py
index ec9600f8..8fcb0bce 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/connectionpool.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/connectionpool.py
@@ -40,13 +40,10 @@ from .util.request import set_file_position
 from .util.response import assert_header_parsing
 from .util.retry import Retry
 from .util.timeout import Timeout
-from .util.url import get_host, Url
+from .util.url import get_host, Url, NORMALIZABLE_SCHEMES
+from .util.queue import LifoQueue
 
 
-if six.PY2:
-    # Queue is imported for side effects on MS Windows
-    import Queue as _unused_module_Queue  # noqa: F401
-
 xrange = six.moves.xrange
 
 log = logging.getLogger(__name__)
@@ -62,13 +59,13 @@ class ConnectionPool(object):
     """
 
     scheme = None
-    QueueCls = queue.LifoQueue
+    QueueCls = LifoQueue
 
     def __init__(self, host, port=None):
         if not host:
             raise LocationValueError("No host specified.")
 
-        self.host = _ipv6_host(host).lower()
+        self.host = _ipv6_host(host, self.scheme)
         self._proxy_host = host.lower()
         self.port = port
 
@@ -204,8 +201,8 @@ class HTTPConnectionPool(ConnectionPool, RequestMethods):
         Return a fresh :class:`HTTPConnection`.
         """
         self.num_connections += 1
-        log.debug("Starting new HTTP connection (%d): %s",
-                  self.num_connections, self.host)
+        log.debug("Starting new HTTP connection (%d): %s:%s",
+                  self.num_connections, self.host, self.port or "80")
 
         conn = self.ConnectionCls(host=self.host, port=self.port,
                                   timeout=self.timeout.connect_timeout,
@@ -411,6 +408,8 @@ class HTTPConnectionPool(ConnectionPool, RequestMethods):
         """
         Close all pooled connections and disable the pool.
         """
+        if self.pool is None:
+            return
         # Disable access to the pool
         old_pool, self.pool = self.pool, None
 
@@ -434,7 +433,7 @@ class HTTPConnectionPool(ConnectionPool, RequestMethods):
         # TODO: Add optional support for socket.gethostbyname checking.
         scheme, host, port = get_host(url)
 
-        host = _ipv6_host(host).lower()
+        host = _ipv6_host(host, self.scheme)
 
         # Use explicit default port for comparison when none is given
         if self.port and not port:
@@ -820,8 +819,8 @@ class HTTPSConnectionPool(HTTPConnectionPool):
         Return a fresh :class:`httplib.HTTPSConnection`.
         """
         self.num_connections += 1
-        log.debug("Starting new HTTPS connection (%d): %s",
-                  self.num_connections, self.host)
+        log.debug("Starting new HTTPS connection (%d): %s:%s",
+                  self.num_connections, self.host, self.port or "443")
 
         if not self.ConnectionCls or self.ConnectionCls is DummyConnection:
             raise SSLError("Can't connect to HTTPS URL because the SSL "
@@ -886,7 +885,7 @@ def connection_from_url(url, **kw):
         return HTTPConnectionPool(host, port=port, **kw)
 
 
-def _ipv6_host(host):
+def _ipv6_host(host, scheme):
     """
     Process IPv6 address literals
     """
@@ -902,4 +901,6 @@ def _ipv6_host(host):
     # percent sign might be URIencoded, convert it back into ASCII
     if host.startswith('[') and host.endswith(']'):
         host = host.replace('%25', '%').strip('[]')
+    if scheme in NORMALIZABLE_SCHEMES:
+        host = host.lower()
     return host
diff --git a/pipenv/patched/notpip/_vendor/urllib3/contrib/_securetransport/low_level.py b/pipenv/patched/notpip/_vendor/urllib3/contrib/_securetransport/low_level.py
index 5e3494bc..b13cd9e7 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/contrib/_securetransport/low_level.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/contrib/_securetransport/low_level.py
@@ -111,6 +111,9 @@ def _cert_array_from_pem(pem_bundle):
     Given a bundle of certs in PEM format, turns them into a CFArray of certs
     that can be used to validate a cert chain.
     """
+    # Normalize the PEM bundle's line endings.
+    pem_bundle = pem_bundle.replace(b"\r\n", b"\n")
+
     der_certs = [
         base64.b64decode(match.group(1))
         for match in _PEM_CERTS_RE.finditer(pem_bundle)
@@ -183,8 +186,8 @@ def _temporary_keychain():
     # some random bytes to password-protect the keychain we're creating, so we
     # ask for 40 random bytes.
     random_bytes = os.urandom(40)
-    filename = base64.b64encode(random_bytes[:8]).decode('utf-8')
-    password = base64.b64encode(random_bytes[8:])  # Must be valid UTF-8
+    filename = base64.b16encode(random_bytes[:8]).decode('utf-8')
+    password = base64.b16encode(random_bytes[8:])  # Must be valid UTF-8
     tempdirectory = tempfile.mkdtemp()
 
     keychain_path = os.path.join(tempdirectory, filename).encode('utf-8')
diff --git a/pipenv/patched/notpip/_vendor/urllib3/contrib/appengine.py b/pipenv/patched/notpip/_vendor/urllib3/contrib/appengine.py
index 504d5bf0..06586352 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/contrib/appengine.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/contrib/appengine.py
@@ -236,15 +236,24 @@ class AppEngineManager(RequestMethods):
             encodings.remove('chunked')
             urlfetch_resp.headers['transfer-encoding'] = ','.join(encodings)
 
-        return HTTPResponse(
+        original_response = HTTPResponse(
             # In order for decoding to work, we must present the content as
             # a file-like object.
             body=BytesIO(urlfetch_resp.content),
+            msg=urlfetch_resp.header_msg,
             headers=urlfetch_resp.headers,
             status=urlfetch_resp.status_code,
             **response_kw
         )
 
+        return HTTPResponse(
+            body=BytesIO(urlfetch_resp.content),
+            headers=urlfetch_resp.headers,
+            status=urlfetch_resp.status_code,
+            original_response=original_response,
+            **response_kw
+        )
+
     def _get_absolute_timeout(self, timeout):
         if timeout is Timeout.DEFAULT_TIMEOUT:
             return None  # Defer to URLFetch's default.
diff --git a/pipenv/patched/notpip/_vendor/urllib3/contrib/pyopenssl.py b/pipenv/patched/notpip/_vendor/urllib3/contrib/pyopenssl.py
index 62bd3e13..7787d4e4 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/contrib/pyopenssl.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/contrib/pyopenssl.py
@@ -47,6 +47,12 @@ import OpenSSL.SSL
 from cryptography import x509
 from cryptography.hazmat.backends.openssl import backend as openssl_backend
 from cryptography.hazmat.backends.openssl.x509 import _Certificate
+try:
+    from cryptography.x509 import UnsupportedExtension
+except ImportError:
+    # UnsupportedExtension is gone in cryptography >= 2.1.0
+    class UnsupportedExtension(Exception):
+        pass
 
 from socket import timeout, error as SocketError
 from io import BytesIO
@@ -199,7 +205,7 @@ def get_subj_alt_name(peer_cert):
     except x509.ExtensionNotFound:
         # No such extension, return the empty list.
         return []
-    except (x509.DuplicateExtension, x509.UnsupportedExtension,
+    except (x509.DuplicateExtension, UnsupportedExtension,
             x509.UnsupportedGeneralNameType, UnicodeError) as e:
         # A problem has been found with the quality of the certificate. Assume
         # no SAN field is present.
@@ -267,8 +273,7 @@ class WrappedSocket(object):
             else:
                 raise
         except OpenSSL.SSL.WantReadError:
-            rd = util.wait_for_read(self.socket, self.socket.gettimeout())
-            if not rd:
+            if not util.wait_for_read(self.socket, self.socket.gettimeout()):
                 raise timeout('The read operation timed out')
             else:
                 return self.recv(*args, **kwargs)
@@ -289,8 +294,7 @@ class WrappedSocket(object):
             else:
                 raise
         except OpenSSL.SSL.WantReadError:
-            rd = util.wait_for_read(self.socket, self.socket.gettimeout())
-            if not rd:
+            if not util.wait_for_read(self.socket, self.socket.gettimeout()):
                 raise timeout('The read operation timed out')
             else:
                 return self.recv_into(*args, **kwargs)
@@ -303,8 +307,7 @@ class WrappedSocket(object):
             try:
                 return self.connection.send(data)
             except OpenSSL.SSL.WantWriteError:
-                wr = util.wait_for_write(self.socket, self.socket.gettimeout())
-                if not wr:
+                if not util.wait_for_write(self.socket, self.socket.gettimeout()):
                     raise timeout()
                 continue
             except OpenSSL.SSL.SysCallError as e:
@@ -418,7 +421,7 @@ class PyOpenSSLContext(object):
             self._ctx.load_verify_locations(BytesIO(cadata))
 
     def load_cert_chain(self, certfile, keyfile=None, password=None):
-        self._ctx.use_certificate_file(certfile)
+        self._ctx.use_certificate_chain_file(certfile)
         if password is not None:
             self._ctx.set_passwd_cb(lambda max_length, prompt_twice, userdata: password)
         self._ctx.use_privatekey_file(keyfile or certfile)
@@ -440,8 +443,7 @@ class PyOpenSSLContext(object):
             try:
                 cnx.do_handshake()
             except OpenSSL.SSL.WantReadError:
-                rd = util.wait_for_read(sock, sock.gettimeout())
-                if not rd:
+                if not util.wait_for_read(sock, sock.gettimeout()):
                     raise timeout('select timed out')
                 continue
             except OpenSSL.SSL.Error as e:
diff --git a/pipenv/patched/notpip/_vendor/urllib3/contrib/securetransport.py b/pipenv/patched/notpip/_vendor/urllib3/contrib/securetransport.py
index 2cac70f7..77cb59ed 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/contrib/securetransport.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/contrib/securetransport.py
@@ -51,11 +51,6 @@ except ImportError:  # Platform-specific: Python 3
     _fileobject = None
     from ..packages.backports.makefile import backport_makefile
 
-try:
-    memoryview(b'')
-except NameError:
-    raise ImportError("SecureTransport only works on Pythons with memoryview")
-
 __all__ = ['inject_into_urllib3', 'extract_from_urllib3']
 
 # SNI always works
@@ -88,7 +83,7 @@ _connection_ref_lock = threading.Lock()
 SSL_WRITE_BLOCKSIZE = 16384
 
 # This is our equivalent of util.ssl_.DEFAULT_CIPHERS, but expanded out to
-# individual cipher suites. We need to do this becuase this is how
+# individual cipher suites. We need to do this because this is how
 # SecureTransport wants them.
 CIPHER_SUITES = [
     SecurityConst.TLS_AES_256_GCM_SHA384,
@@ -195,21 +190,18 @@ def _read_callback(connection_id, data_buffer, data_length_pointer):
         timeout = wrapped_socket.gettimeout()
         error = None
         read_count = 0
-        buffer = (ctypes.c_char * requested_length).from_address(data_buffer)
-        buffer_view = memoryview(buffer)
 
         try:
             while read_count < requested_length:
                 if timeout is None or timeout >= 0:
-                    readables = util.wait_for_read([base_socket], timeout)
-                    if not readables:
+                    if not util.wait_for_read(base_socket, timeout):
                         raise socket.error(errno.EAGAIN, 'timed out')
 
-                # We need to tell ctypes that we have a buffer that can be
-                # written to. Upsettingly, we do that like this:
-                chunk_size = base_socket.recv_into(
-                    buffer_view[read_count:requested_length]
+                remaining = requested_length - read_count
+                buffer = (ctypes.c_char * remaining).from_address(
+                    data_buffer + read_count
                 )
+                chunk_size = base_socket.recv_into(buffer, remaining)
                 read_count += chunk_size
                 if not chunk_size:
                     if not read_count:
@@ -219,7 +211,8 @@ def _read_callback(connection_id, data_buffer, data_length_pointer):
             error = e.errno
 
             if error is not None and error != errno.EAGAIN:
-                if error == errno.ECONNRESET:
+                data_length_pointer[0] = read_count
+                if error == errno.ECONNRESET or error == errno.EPIPE:
                     return SecurityConst.errSSLClosedAbort
                 raise
 
@@ -257,8 +250,7 @@ def _write_callback(connection_id, data_buffer, data_length_pointer):
         try:
             while sent < bytes_to_write:
                 if timeout is None or timeout >= 0:
-                    writables = util.wait_for_write([base_socket], timeout)
-                    if not writables:
+                    if not util.wait_for_write(base_socket, timeout):
                         raise socket.error(errno.EAGAIN, 'timed out')
                 chunk_sent = base_socket.send(data)
                 sent += chunk_sent
@@ -270,11 +262,13 @@ def _write_callback(connection_id, data_buffer, data_length_pointer):
             error = e.errno
 
             if error is not None and error != errno.EAGAIN:
-                if error == errno.ECONNRESET:
+                data_length_pointer[0] = sent
+                if error == errno.ECONNRESET or error == errno.EPIPE:
                     return SecurityConst.errSSLClosedAbort
                 raise
 
         data_length_pointer[0] = sent
+
         if sent != bytes_to_write:
             return SecurityConst.errSSLWouldBlock
 
@@ -399,7 +393,7 @@ class WrappedSocket(object):
             if trust:
                 CoreFoundation.CFRelease(trust)
 
-            if cert_array is None:
+            if cert_array is not None:
                 CoreFoundation.CFRelease(cert_array)
 
         # Ok, now we can look at what the result was.
diff --git a/pipenv/patched/notpip/_vendor/urllib3/contrib/socks.py b/pipenv/patched/notpip/_vendor/urllib3/contrib/socks.py
index 39e92fde..811e312e 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/contrib/socks.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/contrib/socks.py
@@ -152,6 +152,10 @@ class SOCKSProxyManager(PoolManager):
                  num_pools=10, headers=None, **connection_pool_kw):
         parsed = parse_url(proxy_url)
 
+        if username is None and password is None and parsed.auth is not None:
+            split = parsed.auth.split(':')
+            if len(split) == 2:
+                username, password = split
         if parsed.scheme == 'socks5':
             socks_version = socks.PROXY_TYPE_SOCKS5
             rdns = False
diff --git a/pipenv/patched/notpip/_vendor/urllib3/exceptions.py b/pipenv/patched/notpip/_vendor/urllib3/exceptions.py
index 6c4be581..7bbaa987 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/exceptions.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/exceptions.py
@@ -154,7 +154,7 @@ class ResponseError(HTTPError):
 
 
 class SecurityWarning(HTTPWarning):
-    "Warned when perfoming security reducing actions"
+    "Warned when performing security reducing actions"
     pass
 
 
diff --git a/pipenv/patched/notpip/_vendor/urllib3/fields.py b/pipenv/patched/notpip/_vendor/urllib3/fields.py
index 19b0ae0c..37fe64a3 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/fields.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/fields.py
@@ -121,7 +121,7 @@ class RequestField(object):
         'Content-Disposition' fields.
 
         :param header_parts:
-            A sequence of (k, v) typles or a :class:`dict` of (k, v) to format
+            A sequence of (k, v) tuples or a :class:`dict` of (k, v) to format
             as `k1="v1"; k2="v2"; ...`.
         """
         parts = []
diff --git a/pipenv/patched/notpip/_vendor/urllib3/filepost.py b/pipenv/patched/notpip/_vendor/urllib3/filepost.py
index cd11cee4..78f1e19b 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/filepost.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/filepost.py
@@ -1,7 +1,8 @@
 from __future__ import absolute_import
+import binascii
 import codecs
+import os
 
-from uuid import uuid4
 from io import BytesIO
 
 from .packages import six
@@ -15,7 +16,10 @@ def choose_boundary():
     """
     Our embarrassingly-simple replacement for mimetools.choose_boundary.
     """
-    return uuid4().hex
+    boundary = binascii.hexlify(os.urandom(16))
+    if six.PY3:
+        boundary = boundary.decode('ascii')
+    return boundary
 
 
 def iter_field_objects(fields):
@@ -65,7 +69,7 @@ def encode_multipart_formdata(fields, boundary=None):
 
     :param boundary:
         If not specified, then a random boundary will be generated using
-        :func:`mimetools.choose_boundary`.
+        :func:`urllib3.filepost.choose_boundary`.
     """
     body = BytesIO()
     if boundary is None:
diff --git a/pipenv/patched/notpip/_vendor/urllib3/poolmanager.py b/pipenv/patched/notpip/_vendor/urllib3/poolmanager.py
index 4ae91744..506a3c9b 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/poolmanager.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/poolmanager.py
@@ -312,8 +312,9 @@ class PoolManager(RequestMethods):
 
         kw['assert_same_host'] = False
         kw['redirect'] = False
+
         if 'headers' not in kw:
-            kw['headers'] = self.headers
+            kw['headers'] = self.headers.copy()
 
         if self.proxy is not None and u.scheme == "http":
             response = conn.urlopen(method, url, **kw)
@@ -335,6 +336,14 @@ class PoolManager(RequestMethods):
         if not isinstance(retries, Retry):
             retries = Retry.from_int(retries, redirect=redirect)
 
+        # Strip headers marked as unsafe to forward to the redirected location.
+        # Check remove_headers_on_redirect to avoid a potential network call within
+        # conn.is_same_host() which may use socket.gethostbyname() in the future.
+        if (retries.remove_headers_on_redirect
+                and not conn.is_same_host(redirect_location)):
+            for header in retries.remove_headers_on_redirect:
+                kw['headers'].pop(header, None)
+
         try:
             retries = retries.increment(method, url, response=response, _pool=conn)
         except MaxRetryError:
@@ -358,7 +367,7 @@ class ProxyManager(PoolManager):
         The URL of the proxy to be used.
 
     :param proxy_headers:
-        A dictionary contaning headers that will be sent to the proxy. In case
+        A dictionary containing headers that will be sent to the proxy. In case
         of HTTP they are being sent with each request, while in the
         HTTPS/CONNECT case they are sent only once. Could be used for proxy
         authentication.
diff --git a/pipenv/patched/notpip/_vendor/urllib3/request.py b/pipenv/patched/notpip/_vendor/urllib3/request.py
index c0fddff0..1be33341 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/request.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/request.py
@@ -44,8 +44,8 @@ class RequestMethods(object):
     def urlopen(self, method, url, body=None, headers=None,
                 encode_multipart=True, multipart_boundary=None,
                 **kw):  # Abstract
-        raise NotImplemented("Classes extending RequestMethods must implement "
-                             "their own ``urlopen`` method.")
+        raise NotImplementedError("Classes extending RequestMethods must implement "
+                                  "their own ``urlopen`` method.")
 
     def request(self, method, url, fields=None, headers=None, **urlopen_kw):
         """
@@ -60,6 +60,8 @@ class RequestMethods(object):
         """
         method = method.upper()
 
+        urlopen_kw['request_url'] = url
+
         if method in self._encode_url_methods:
             return self.request_encode_url(method, url, fields=fields,
                                            headers=headers,
@@ -117,7 +119,7 @@ class RequestMethods(object):
             }
 
         When uploading a file, providing a filename (the first parameter of the
-        tuple) is optional but recommended to best mimick behavior of browsers.
+        tuple) is optional but recommended to best mimic behavior of browsers.
 
         Note that if ``headers`` are supplied, the 'Content-Type' header will
         be overwritten because it depends on the dynamic random boundary string
diff --git a/pipenv/patched/notpip/_vendor/urllib3/response.py b/pipenv/patched/notpip/_vendor/urllib3/response.py
index d3e5a1e6..9873cb94 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/response.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/response.py
@@ -52,18 +52,42 @@ class DeflateDecoder(object):
                 self._data = None
 
 
+class GzipDecoderState(object):
+
+    FIRST_MEMBER = 0
+    OTHER_MEMBERS = 1
+    SWALLOW_DATA = 2
+
+
 class GzipDecoder(object):
 
     def __init__(self):
         self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS)
+        self._state = GzipDecoderState.FIRST_MEMBER
 
     def __getattr__(self, name):
         return getattr(self._obj, name)
 
     def decompress(self, data):
-        if not data:
-            return data
-        return self._obj.decompress(data)
+        ret = binary_type()
+        if self._state == GzipDecoderState.SWALLOW_DATA or not data:
+            return ret
+        while True:
+            try:
+                ret += self._obj.decompress(data)
+            except zlib.error:
+                previous_state = self._state
+                # Ignore data after the first error
+                self._state = GzipDecoderState.SWALLOW_DATA
+                if previous_state == GzipDecoderState.OTHER_MEMBERS:
+                    # Allow trailing garbage acceptable in other gzip clients
+                    return ret
+                raise
+            data = self._obj.unused_data
+            if not data:
+                return ret
+            self._state = GzipDecoderState.OTHER_MEMBERS
+            self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS)
 
 
 def _get_decoder(mode):
@@ -89,9 +113,8 @@ class HTTPResponse(io.IOBase):
         If True, the response's body will be preloaded during construction.
 
     :param decode_content:
-        If True, attempts to decode specific content-encoding's based on headers
-        (like 'gzip' and 'deflate') will be skipped and raw data will be used
-        instead.
+        If True, will attempt to decode the body based on the
+        'content-encoding' header.
 
     :param original_response:
         When this HTTPResponse wrapper is generated from an httplib.HTTPResponse
@@ -112,8 +135,9 @@ class HTTPResponse(io.IOBase):
 
     def __init__(self, body='', headers=None, status=0, version=0, reason=None,
                  strict=0, preload_content=True, decode_content=True,
-                 original_response=None, pool=None, connection=None,
-                 retries=None, enforce_content_length=False, request_method=None):
+                 original_response=None, pool=None, connection=None, msg=None,
+                 retries=None, enforce_content_length=False,
+                 request_method=None, request_url=None):
 
         if isinstance(headers, HTTPHeaderDict):
             self.headers = headers
@@ -132,6 +156,8 @@ class HTTPResponse(io.IOBase):
         self._fp = None
         self._original_response = original_response
         self._fp_bytes_read = 0
+        self.msg = msg
+        self._request_url = request_url
 
         if body and isinstance(body, (basestring, binary_type)):
             self._body = body
@@ -191,6 +217,9 @@ class HTTPResponse(io.IOBase):
     def connection(self):
         return self._connection
 
+    def isclosed(self):
+        return is_fp_closed(self._fp)
+
     def tell(self):
         """
         Obtain the number of bytes pulled over the wire so far. May differ from
@@ -205,18 +234,18 @@ class HTTPResponse(io.IOBase):
         """
         length = self.headers.get('content-length')
 
-        if length is not None and self.chunked:
-            # This Response will fail with an IncompleteRead if it can't be
-            # received as chunked. This method falls back to attempt reading
-            # the response before raising an exception.
-            log.warning("Received response with both Content-Length and "
-                        "Transfer-Encoding set. This is expressly forbidden "
-                        "by RFC 7230 sec 3.3.2. Ignoring Content-Length and "
-                        "attempting to process response as Transfer-Encoding: "
-                        "chunked.")
-            return None
+        if length is not None:
+            if self.chunked:
+                # This Response will fail with an IncompleteRead if it can't be
+                # received as chunked. This method falls back to attempt reading
+                # the response before raising an exception.
+                log.warning("Received response with both Content-Length and "
+                            "Transfer-Encoding set. This is expressly forbidden "
+                            "by RFC 7230 sec 3.3.2. Ignoring Content-Length and "
+                            "attempting to process response as Transfer-Encoding: "
+                            "chunked.")
+                return None
 
-        elif length is not None:
             try:
                 # RFC 7230 section 3.3.2 specifies multiple content lengths can
                 # be sent in a single Content-Length header
@@ -573,6 +602,11 @@ class HTTPResponse(io.IOBase):
         Similar to :meth:`HTTPResponse.read`, but with an additional
         parameter: ``decode_content``.
 
+        :param amt:
+            How much of the content to read. If specified, caching is skipped
+            because it doesn't make sense to cache partial content as the full
+            response.
+
         :param decode_content:
             If True, will attempt to decode the body based on the
             'content-encoding' header.
@@ -588,12 +622,17 @@ class HTTPResponse(io.IOBase):
                 "Body should be httplib.HTTPResponse like. "
                 "It should have have an fp attribute which returns raw chunks.")
 
-        # Don't bother reading the body of a HEAD request.
-        if self._original_response and is_response_to_head(self._original_response):
-            self._original_response.close()
-            return
-
         with self._error_catcher():
+            # Don't bother reading the body of a HEAD request.
+            if self._original_response and is_response_to_head(self._original_response):
+                self._original_response.close()
+                return
+
+            # If a response is already read and closed
+            # then return immediately.
+            if self._fp.fp is None:
+                return
+
             while True:
                 self._update_chunk_length()
                 if self.chunk_left == 0:
@@ -624,3 +663,14 @@ class HTTPResponse(io.IOBase):
             # We read everything; close the "file".
             if self._original_response:
                 self._original_response.close()
+
+    def geturl(self):
+        """
+        Returns the URL that was the source of this response.
+        If the request that generated this response redirected, this method
+        will return the final redirect location.
+        """
+        if self.retries is not None and len(self.retries.history):
+            return self.retries.history[-1].redirect_location
+        else:
+            return self._request_url
diff --git a/pipenv/patched/notpip/_vendor/urllib3/util/connection.py b/pipenv/patched/notpip/_vendor/urllib3/util/connection.py
index bf699cfd..5cf488f4 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/util/connection.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/util/connection.py
@@ -1,7 +1,6 @@
 from __future__ import absolute_import
 import socket
-from .wait import wait_for_read
-from .selectors import HAS_SELECT, SelectorError
+from .wait import NoWayToWaitForSocketError, wait_for_read
 
 
 def is_connection_dropped(conn):  # Platform-specific
@@ -19,14 +18,11 @@ def is_connection_dropped(conn):  # Platform-specific
         return False
     if sock is None:  # Connection already closed (such as by httplib).
         return True
-
-    if not HAS_SELECT:
-        return False
-
     try:
-        return bool(wait_for_read(sock, timeout=0.0))
-    except SelectorError:
-        return True
+        # Returns True if readable, which here means it's been dropped
+        return wait_for_read(sock, timeout=0.0)
+    except NoWayToWaitForSocketError:  # Platform-specific: AppEngine
+        return False
 
 
 # This function is copied from socket.py in the Python 2.7 standard
diff --git a/pipenv/patched/notpip/_vendor/urllib3/util/queue.py b/pipenv/patched/notpip/_vendor/urllib3/util/queue.py
new file mode 100644
index 00000000..d3d379a1
--- /dev/null
+++ b/pipenv/patched/notpip/_vendor/urllib3/util/queue.py
@@ -0,0 +1,21 @@
+import collections
+from ..packages import six
+from ..packages.six.moves import queue
+
+if six.PY2:
+    # Queue is imported for side effects on MS Windows. See issue #229.
+    import Queue as _unused_module_Queue  # noqa: F401
+
+
+class LifoQueue(queue.Queue):
+    def _init(self, _):
+        self.queue = collections.deque()
+
+    def _qsize(self, len=len):
+        return len(self.queue)
+
+    def _put(self, item):
+        self.queue.append(item)
+
+    def _get(self):
+        return self.queue.pop()
diff --git a/pipenv/patched/notpip/_vendor/urllib3/util/retry.py b/pipenv/patched/notpip/_vendor/urllib3/util/retry.py
index c603cb49..7ad3dc66 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/util/retry.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/util/retry.py
@@ -19,6 +19,7 @@ from ..packages import six
 
 log = logging.getLogger(__name__)
 
+
 # Data structure for representing the metadata of requests that result in a retry.
 RequestHistory = namedtuple('RequestHistory', ["method", "url", "error",
                                                "status", "redirect_location"])
@@ -139,6 +140,10 @@ class Retry(object):
         Whether to respect Retry-After header on status codes defined as
         :attr:`Retry.RETRY_AFTER_STATUS_CODES` or not.
 
+    :param iterable remove_headers_on_redirect:
+        Sequence of headers to remove from the request when a response
+        indicating a redirect is returned before firing off the redirected
+        request.
     """
 
     DEFAULT_METHOD_WHITELIST = frozenset([
@@ -146,13 +151,16 @@ class Retry(object):
 
     RETRY_AFTER_STATUS_CODES = frozenset([413, 429, 503])
 
+    DEFAULT_REDIRECT_HEADERS_BLACKLIST = frozenset(['Authorization'])
+
     #: Maximum backoff time.
     BACKOFF_MAX = 120
 
     def __init__(self, total=10, connect=None, read=None, redirect=None, status=None,
                  method_whitelist=DEFAULT_METHOD_WHITELIST, status_forcelist=None,
                  backoff_factor=0, raise_on_redirect=True, raise_on_status=True,
-                 history=None, respect_retry_after_header=True):
+                 history=None, respect_retry_after_header=True,
+                 remove_headers_on_redirect=DEFAULT_REDIRECT_HEADERS_BLACKLIST):
 
         self.total = total
         self.connect = connect
@@ -171,6 +179,7 @@ class Retry(object):
         self.raise_on_status = raise_on_status
         self.history = history or tuple()
         self.respect_retry_after_header = respect_retry_after_header
+        self.remove_headers_on_redirect = remove_headers_on_redirect
 
     def new(self, **kw):
         params = dict(
@@ -182,6 +191,7 @@ class Retry(object):
             raise_on_redirect=self.raise_on_redirect,
             raise_on_status=self.raise_on_status,
             history=self.history,
+            remove_headers_on_redirect=self.remove_headers_on_redirect
         )
         params.update(kw)
         return type(self)(**params)
diff --git a/pipenv/patched/notpip/_vendor/urllib3/util/selectors.py b/pipenv/patched/notpip/_vendor/urllib3/util/selectors.py
deleted file mode 100644
index d75cb266..00000000
--- a/pipenv/patched/notpip/_vendor/urllib3/util/selectors.py
+++ /dev/null
@@ -1,581 +0,0 @@
-# Backport of selectors.py from Python 3.5+ to support Python < 3.4
-# Also has the behavior specified in PEP 475 which is to retry syscalls
-# in the case of an EINTR error. This module is required because selectors34
-# does not follow this behavior and instead returns that no dile descriptor
-# events have occurred rather than retry the syscall. The decision to drop
-# support for select.devpoll is made to maintain 100% test coverage.
-
-import errno
-import math
-import select
-import socket
-import sys
-import time
-from collections import namedtuple, Mapping
-
-try:
-    monotonic = time.monotonic
-except (AttributeError, ImportError):  # Python 3.3<
-    monotonic = time.time
-
-EVENT_READ = (1 << 0)
-EVENT_WRITE = (1 << 1)
-
-HAS_SELECT = True  # Variable that shows whether the platform has a selector.
-_SYSCALL_SENTINEL = object()  # Sentinel in case a system call returns None.
-_DEFAULT_SELECTOR = None
-
-
-class SelectorError(Exception):
-    def __init__(self, errcode):
-        super(SelectorError, self).__init__()
-        self.errno = errcode
-
-    def __repr__(self):
-        return "<SelectorError errno={0}>".format(self.errno)
-
-    def __str__(self):
-        return self.__repr__()
-
-
-def _fileobj_to_fd(fileobj):
-    """ Return a file descriptor from a file object. If
-    given an integer will simply return that integer back. """
-    if isinstance(fileobj, int):
-        fd = fileobj
-    else:
-        try:
-            fd = int(fileobj.fileno())
-        except (AttributeError, TypeError, ValueError):
-            raise ValueError("Invalid file object: {0!r}".format(fileobj))
-    if fd < 0:
-        raise ValueError("Invalid file descriptor: {0}".format(fd))
-    return fd
-
-
-# Determine which function to use to wrap system calls because Python 3.5+
-# already handles the case when system calls are interrupted.
-if sys.version_info >= (3, 5):
-    def _syscall_wrapper(func, _, *args, **kwargs):
-        """ This is the short-circuit version of the below logic
-        because in Python 3.5+ all system calls automatically restart
-        and recalculate their timeouts. """
-        try:
-            return func(*args, **kwargs)
-        except (OSError, IOError, select.error) as e:
-            errcode = None
-            if hasattr(e, "errno"):
-                errcode = e.errno
-            raise SelectorError(errcode)
-else:
-    def _syscall_wrapper(func, recalc_timeout, *args, **kwargs):
-        """ Wrapper function for syscalls that could fail due to EINTR.
-        All functions should be retried if there is time left in the timeout
-        in accordance with PEP 475. """
-        timeout = kwargs.get("timeout", None)
-        if timeout is None:
-            expires = None
-            recalc_timeout = False
-        else:
-            timeout = float(timeout)
-            if timeout < 0.0:  # Timeout less than 0 treated as no timeout.
-                expires = None
-            else:
-                expires = monotonic() + timeout
-
-        args = list(args)
-        if recalc_timeout and "timeout" not in kwargs:
-            raise ValueError(
-                "Timeout must be in args or kwargs to be recalculated")
-
-        result = _SYSCALL_SENTINEL
-        while result is _SYSCALL_SENTINEL:
-            try:
-                result = func(*args, **kwargs)
-            # OSError is thrown by select.select
-            # IOError is thrown by select.epoll.poll
-            # select.error is thrown by select.poll.poll
-            # Aren't we thankful for Python 3.x rework for exceptions?
-            except (OSError, IOError, select.error) as e:
-                # select.error wasn't a subclass of OSError in the past.
-                errcode = None
-                if hasattr(e, "errno"):
-                    errcode = e.errno
-                elif hasattr(e, "args"):
-                    errcode = e.args[0]
-
-                # Also test for the Windows equivalent of EINTR.
-                is_interrupt = (errcode == errno.EINTR or (hasattr(errno, "WSAEINTR") and
-                                                           errcode == errno.WSAEINTR))
-
-                if is_interrupt:
-                    if expires is not None:
-                        current_time = monotonic()
-                        if current_time > expires:
-                            raise OSError(errno=errno.ETIMEDOUT)
-                        if recalc_timeout:
-                            if "timeout" in kwargs:
-                                kwargs["timeout"] = expires - current_time
-                    continue
-                if errcode:
-                    raise SelectorError(errcode)
-                else:
-                    raise
-        return result
-
-
-SelectorKey = namedtuple('SelectorKey', ['fileobj', 'fd', 'events', 'data'])
-
-
-class _SelectorMapping(Mapping):
-    """ Mapping of file objects to selector keys """
-
-    def __init__(self, selector):
-        self._selector = selector
-
-    def __len__(self):
-        return len(self._selector._fd_to_key)
-
-    def __getitem__(self, fileobj):
-        try:
-            fd = self._selector._fileobj_lookup(fileobj)
-            return self._selector._fd_to_key[fd]
-        except KeyError:
-            raise KeyError("{0!r} is not registered.".format(fileobj))
-
-    def __iter__(self):
-        return iter(self._selector._fd_to_key)
-
-
-class BaseSelector(object):
-    """ Abstract Selector class
-
-    A selector supports registering file objects to be monitored
-    for specific I/O events.
-
-    A file object is a file descriptor or any object with a
-    `fileno()` method. An arbitrary object can be attached to the
-    file object which can be used for example to store context info,
-    a callback, etc.
-
-    A selector can use various implementations (select(), poll(), epoll(),
-    and kqueue()) depending on the platform. The 'DefaultSelector' class uses
-    the most efficient implementation for the current platform.
-    """
-    def __init__(self):
-        # Maps file descriptors to keys.
-        self._fd_to_key = {}
-
-        # Read-only mapping returned by get_map()
-        self._map = _SelectorMapping(self)
-
-    def _fileobj_lookup(self, fileobj):
-        """ Return a file descriptor from a file object.
-        This wraps _fileobj_to_fd() to do an exhaustive
-        search in case the object is invalid but we still
-        have it in our map. Used by unregister() so we can
-        unregister an object that was previously registered
-        even if it is closed. It is also used by _SelectorMapping
-        """
-        try:
-            return _fileobj_to_fd(fileobj)
-        except ValueError:
-
-            # Search through all our mapped keys.
-            for key in self._fd_to_key.values():
-                if key.fileobj is fileobj:
-                    return key.fd
-
-            # Raise ValueError after all.
-            raise
-
-    def register(self, fileobj, events, data=None):
-        """ Register a file object for a set of events to monitor. """
-        if (not events) or (events & ~(EVENT_READ | EVENT_WRITE)):
-            raise ValueError("Invalid events: {0!r}".format(events))
-
-        key = SelectorKey(fileobj, self._fileobj_lookup(fileobj), events, data)
-
-        if key.fd in self._fd_to_key:
-            raise KeyError("{0!r} (FD {1}) is already registered"
-                           .format(fileobj, key.fd))
-
-        self._fd_to_key[key.fd] = key
-        return key
-
-    def unregister(self, fileobj):
-        """ Unregister a file object from being monitored. """
-        try:
-            key = self._fd_to_key.pop(self._fileobj_lookup(fileobj))
-        except KeyError:
-            raise KeyError("{0!r} is not registered".format(fileobj))
-
-        # Getting the fileno of a closed socket on Windows errors with EBADF.
-        except socket.error as e:  # Platform-specific: Windows.
-            if e.errno != errno.EBADF:
-                raise
-            else:
-                for key in self._fd_to_key.values():
-                    if key.fileobj is fileobj:
-                        self._fd_to_key.pop(key.fd)
-                        break
-                else:
-                    raise KeyError("{0!r} is not registered".format(fileobj))
-        return key
-
-    def modify(self, fileobj, events, data=None):
-        """ Change a registered file object monitored events and data. """
-        # NOTE: Some subclasses optimize this operation even further.
-        try:
-            key = self._fd_to_key[self._fileobj_lookup(fileobj)]
-        except KeyError:
-            raise KeyError("{0!r} is not registered".format(fileobj))
-
-        if events != key.events:
-            self.unregister(fileobj)
-            key = self.register(fileobj, events, data)
-
-        elif data != key.data:
-            # Use a shortcut to update the data.
-            key = key._replace(data=data)
-            self._fd_to_key[key.fd] = key
-
-        return key
-
-    def select(self, timeout=None):
-        """ Perform the actual selection until some monitored file objects
-        are ready or the timeout expires. """
-        raise NotImplementedError()
-
-    def close(self):
-        """ Close the selector. This must be called to ensure that all
-        underlying resources are freed. """
-        self._fd_to_key.clear()
-        self._map = None
-
-    def get_key(self, fileobj):
-        """ Return the key associated with a registered file object. """
-        mapping = self.get_map()
-        if mapping is None:
-            raise RuntimeError("Selector is closed")
-        try:
-            return mapping[fileobj]
-        except KeyError:
-            raise KeyError("{0!r} is not registered".format(fileobj))
-
-    def get_map(self):
-        """ Return a mapping of file objects to selector keys """
-        return self._map
-
-    def _key_from_fd(self, fd):
-        """ Return the key associated to a given file descriptor
-         Return None if it is not found. """
-        try:
-            return self._fd_to_key[fd]
-        except KeyError:
-            return None
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *args):
-        self.close()
-
-
-# Almost all platforms have select.select()
-if hasattr(select, "select"):
-    class SelectSelector(BaseSelector):
-        """ Select-based selector. """
-        def __init__(self):
-            super(SelectSelector, self).__init__()
-            self._readers = set()
-            self._writers = set()
-
-        def register(self, fileobj, events, data=None):
-            key = super(SelectSelector, self).register(fileobj, events, data)
-            if events & EVENT_READ:
-                self._readers.add(key.fd)
-            if events & EVENT_WRITE:
-                self._writers.add(key.fd)
-            return key
-
-        def unregister(self, fileobj):
-            key = super(SelectSelector, self).unregister(fileobj)
-            self._readers.discard(key.fd)
-            self._writers.discard(key.fd)
-            return key
-
-        def _select(self, r, w, timeout=None):
-            """ Wrapper for select.select because timeout is a positional arg """
-            return select.select(r, w, [], timeout)
-
-        def select(self, timeout=None):
-            # Selecting on empty lists on Windows errors out.
-            if not len(self._readers) and not len(self._writers):
-                return []
-
-            timeout = None if timeout is None else max(timeout, 0.0)
-            ready = []
-            r, w, _ = _syscall_wrapper(self._select, True, self._readers,
-                                       self._writers, timeout)
-            r = set(r)
-            w = set(w)
-            for fd in r | w:
-                events = 0
-                if fd in r:
-                    events |= EVENT_READ
-                if fd in w:
-                    events |= EVENT_WRITE
-
-                key = self._key_from_fd(fd)
-                if key:
-                    ready.append((key, events & key.events))
-            return ready
-
-
-if hasattr(select, "poll"):
-    class PollSelector(BaseSelector):
-        """ Poll-based selector """
-        def __init__(self):
-            super(PollSelector, self).__init__()
-            self._poll = select.poll()
-
-        def register(self, fileobj, events, data=None):
-            key = super(PollSelector, self).register(fileobj, events, data)
-            event_mask = 0
-            if events & EVENT_READ:
-                event_mask |= select.POLLIN
-            if events & EVENT_WRITE:
-                event_mask |= select.POLLOUT
-            self._poll.register(key.fd, event_mask)
-            return key
-
-        def unregister(self, fileobj):
-            key = super(PollSelector, self).unregister(fileobj)
-            self._poll.unregister(key.fd)
-            return key
-
-        def _wrap_poll(self, timeout=None):
-            """ Wrapper function for select.poll.poll() so that
-            _syscall_wrapper can work with only seconds. """
-            if timeout is not None:
-                if timeout <= 0:
-                    timeout = 0
-                else:
-                    # select.poll.poll() has a resolution of 1 millisecond,
-                    # round away from zero to wait *at least* timeout seconds.
-                    timeout = math.ceil(timeout * 1e3)
-
-            result = self._poll.poll(timeout)
-            return result
-
-        def select(self, timeout=None):
-            ready = []
-            fd_events = _syscall_wrapper(self._wrap_poll, True, timeout=timeout)
-            for fd, event_mask in fd_events:
-                events = 0
-                if event_mask & ~select.POLLIN:
-                    events |= EVENT_WRITE
-                if event_mask & ~select.POLLOUT:
-                    events |= EVENT_READ
-
-                key = self._key_from_fd(fd)
-                if key:
-                    ready.append((key, events & key.events))
-
-            return ready
-
-
-if hasattr(select, "epoll"):
-    class EpollSelector(BaseSelector):
-        """ Epoll-based selector """
-        def __init__(self):
-            super(EpollSelector, self).__init__()
-            self._epoll = select.epoll()
-
-        def fileno(self):
-            return self._epoll.fileno()
-
-        def register(self, fileobj, events, data=None):
-            key = super(EpollSelector, self).register(fileobj, events, data)
-            events_mask = 0
-            if events & EVENT_READ:
-                events_mask |= select.EPOLLIN
-            if events & EVENT_WRITE:
-                events_mask |= select.EPOLLOUT
-            _syscall_wrapper(self._epoll.register, False, key.fd, events_mask)
-            return key
-
-        def unregister(self, fileobj):
-            key = super(EpollSelector, self).unregister(fileobj)
-            try:
-                _syscall_wrapper(self._epoll.unregister, False, key.fd)
-            except SelectorError:
-                # This can occur when the fd was closed since registry.
-                pass
-            return key
-
-        def select(self, timeout=None):
-            if timeout is not None:
-                if timeout <= 0:
-                    timeout = 0.0
-                else:
-                    # select.epoll.poll() has a resolution of 1 millisecond
-                    # but luckily takes seconds so we don't need a wrapper
-                    # like PollSelector. Just for better rounding.
-                    timeout = math.ceil(timeout * 1e3) * 1e-3
-                timeout = float(timeout)
-            else:
-                timeout = -1.0  # epoll.poll() must have a float.
-
-            # We always want at least 1 to ensure that select can be called
-            # with no file descriptors registered. Otherwise will fail.
-            max_events = max(len(self._fd_to_key), 1)
-
-            ready = []
-            fd_events = _syscall_wrapper(self._epoll.poll, True,
-                                         timeout=timeout,
-                                         maxevents=max_events)
-            for fd, event_mask in fd_events:
-                events = 0
-                if event_mask & ~select.EPOLLIN:
-                    events |= EVENT_WRITE
-                if event_mask & ~select.EPOLLOUT:
-                    events |= EVENT_READ
-
-                key = self._key_from_fd(fd)
-                if key:
-                    ready.append((key, events & key.events))
-            return ready
-
-        def close(self):
-            self._epoll.close()
-            super(EpollSelector, self).close()
-
-
-if hasattr(select, "kqueue"):
-    class KqueueSelector(BaseSelector):
-        """ Kqueue / Kevent-based selector """
-        def __init__(self):
-            super(KqueueSelector, self).__init__()
-            self._kqueue = select.kqueue()
-
-        def fileno(self):
-            return self._kqueue.fileno()
-
-        def register(self, fileobj, events, data=None):
-            key = super(KqueueSelector, self).register(fileobj, events, data)
-            if events & EVENT_READ:
-                kevent = select.kevent(key.fd,
-                                       select.KQ_FILTER_READ,
-                                       select.KQ_EV_ADD)
-
-                _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
-
-            if events & EVENT_WRITE:
-                kevent = select.kevent(key.fd,
-                                       select.KQ_FILTER_WRITE,
-                                       select.KQ_EV_ADD)
-
-                _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
-
-            return key
-
-        def unregister(self, fileobj):
-            key = super(KqueueSelector, self).unregister(fileobj)
-            if key.events & EVENT_READ:
-                kevent = select.kevent(key.fd,
-                                       select.KQ_FILTER_READ,
-                                       select.KQ_EV_DELETE)
-                try:
-                    _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
-                except SelectorError:
-                    pass
-            if key.events & EVENT_WRITE:
-                kevent = select.kevent(key.fd,
-                                       select.KQ_FILTER_WRITE,
-                                       select.KQ_EV_DELETE)
-                try:
-                    _syscall_wrapper(self._kqueue.control, False, [kevent], 0, 0)
-                except SelectorError:
-                    pass
-
-            return key
-
-        def select(self, timeout=None):
-            if timeout is not None:
-                timeout = max(timeout, 0)
-
-            max_events = len(self._fd_to_key) * 2
-            ready_fds = {}
-
-            kevent_list = _syscall_wrapper(self._kqueue.control, True,
-                                           None, max_events, timeout)
-
-            for kevent in kevent_list:
-                fd = kevent.ident
-                event_mask = kevent.filter
-                events = 0
-                if event_mask == select.KQ_FILTER_READ:
-                    events |= EVENT_READ
-                if event_mask == select.KQ_FILTER_WRITE:
-                    events |= EVENT_WRITE
-
-                key = self._key_from_fd(fd)
-                if key:
-                    if key.fd not in ready_fds:
-                        ready_fds[key.fd] = (key, events & key.events)
-                    else:
-                        old_events = ready_fds[key.fd][1]
-                        ready_fds[key.fd] = (key, (events | old_events) & key.events)
-
-            return list(ready_fds.values())
-
-        def close(self):
-            self._kqueue.close()
-            super(KqueueSelector, self).close()
-
-
-if not hasattr(select, 'select'):  # Platform-specific: AppEngine
-    HAS_SELECT = False
-
-
-def _can_allocate(struct):
-    """ Checks that select structs can be allocated by the underlying
-    operating system, not just advertised by the select module. We don't
-    check select() because we'll be hopeful that most platforms that
-    don't have it available will not advertise it. (ie: GAE) """
-    try:
-        # select.poll() objects won't fail until used.
-        if struct == 'poll':
-            p = select.poll()
-            p.poll(0)
-
-        # All others will fail on allocation.
-        else:
-            getattr(select, struct)().close()
-        return True
-    except (OSError, AttributeError) as e:
-        return False
-
-
-# Choose the best implementation, roughly:
-# kqueue == epoll > poll > select. Devpoll not supported. (See above)
-# select() also can't accept a FD > FD_SETSIZE (usually around 1024)
-def DefaultSelector():
-    """ This function serves as a first call for DefaultSelector to
-    detect if the select module is being monkey-patched incorrectly
-    by eventlet, greenlet, and preserve proper behavior. """
-    global _DEFAULT_SELECTOR
-    if _DEFAULT_SELECTOR is None:
-        if _can_allocate('kqueue'):
-            _DEFAULT_SELECTOR = KqueueSelector
-        elif _can_allocate('epoll'):
-            _DEFAULT_SELECTOR = EpollSelector
-        elif _can_allocate('poll'):
-            _DEFAULT_SELECTOR = PollSelector
-        elif hasattr(select, 'select'):
-            _DEFAULT_SELECTOR = SelectSelector
-        else:  # Platform-specific: AppEngine
-            raise ValueError('Platform does not have a selector')
-    return _DEFAULT_SELECTOR()
diff --git a/pipenv/patched/notpip/_vendor/urllib3/util/ssl_.py b/pipenv/patched/notpip/_vendor/urllib3/util/ssl_.py
index 0d0799b9..a0868c22 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/util/ssl_.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/util/ssl_.py
@@ -2,11 +2,13 @@ from __future__ import absolute_import
 import errno
 import warnings
 import hmac
+import socket
 
 from binascii import hexlify, unhexlify
 from hashlib import md5, sha1, sha256
 
 from ..exceptions import SSLError, InsecurePlatformWarning, SNIMissingWarning
+from ..packages import six
 
 
 SSLContext = None
@@ -53,6 +55,27 @@ except ImportError:
     OP_NO_SSLv2, OP_NO_SSLv3 = 0x1000000, 0x2000000
     OP_NO_COMPRESSION = 0x20000
 
+
+# Python 2.7 and earlier didn't have inet_pton on non-Linux
+# so we fallback on inet_aton in those cases. This means that
+# we can only detect IPv4 addresses in this case.
+if hasattr(socket, 'inet_pton'):
+    inet_pton = socket.inet_pton
+else:
+    # Maybe we can use ipaddress if the user has urllib3[secure]?
+    try:
+        from pipenv.patched.notpip._vendor import ipaddress
+
+        def inet_pton(_, host):
+            if isinstance(host, six.binary_type):
+                host = host.decode('ascii')
+            return ipaddress.ip_address(host)
+
+    except ImportError:  # Platform-specific: Non-Linux
+        def inet_pton(_, host):
+            return socket.inet_aton(host)
+
+
 # A secure default.
 # Sources for more information on TLS ciphers:
 #
@@ -183,7 +206,7 @@ def resolve_cert_reqs(candidate):
     the wrap_socket function/method from the ssl module.
     Defaults to :data:`ssl.CERT_NONE`.
     If given a string it is assumed to be the name of the constant in the
-    :mod:`ssl` module or its abbrevation.
+    :mod:`ssl` module or its abbreviation.
     (So you can specify `REQUIRED` instead of `CERT_REQUIRED`.
     If it's neither `None` nor a string we assume it is already the numeric
     constant which can directly be passed to wrap_socket.
@@ -325,17 +348,49 @@ def ssl_wrap_socket(sock, keyfile=None, certfile=None, cert_reqs=None,
 
     if certfile:
         context.load_cert_chain(certfile, keyfile)
-    if HAS_SNI:  # Platform-specific: OpenSSL with enabled SNI
-        return context.wrap_socket(sock, server_hostname=server_hostname)
 
-    warnings.warn(
-        'An HTTPS request has been made, but the SNI (Subject Name '
-        'Indication) extension to TLS is not available on this platform. '
-        'This may cause the server to present an incorrect TLS '
-        'certificate, which can cause validation failures. You can upgrade to '
-        'a newer version of Python to solve this. For more information, see '
-        'https://urllib3.readthedocs.io/en/latest/advanced-usage.html'
-        '#ssl-warnings',
-        SNIMissingWarning
-    )
+    # If we detect server_hostname is an IP address then the SNI
+    # extension should not be used according to RFC3546 Section 3.1
+    # We shouldn't warn the user if SNI isn't available but we would
+    # not be using SNI anyways due to IP address for server_hostname.
+    if ((server_hostname is not None and not is_ipaddress(server_hostname))
+            or IS_SECURETRANSPORT):
+        if HAS_SNI and server_hostname is not None:
+            return context.wrap_socket(sock, server_hostname=server_hostname)
+
+        warnings.warn(
+            'An HTTPS request has been made, but the SNI (Server Name '
+            'Indication) extension to TLS is not available on this platform. '
+            'This may cause the server to present an incorrect TLS '
+            'certificate, which can cause validation failures. You can upgrade to '
+            'a newer version of Python to solve this. For more information, see '
+            'https://urllib3.readthedocs.io/en/latest/advanced-usage.html'
+            '#ssl-warnings',
+            SNIMissingWarning
+        )
+
     return context.wrap_socket(sock)
+
+
+def is_ipaddress(hostname):
+    """Detects whether the hostname given is an IP address.
+
+    :param str hostname: Hostname to examine.
+    :return: True if the hostname is an IP address, False otherwise.
+    """
+    if six.PY3 and isinstance(hostname, six.binary_type):
+        # IDN A-label bytes are ASCII compatible.
+        hostname = hostname.decode('ascii')
+
+    families = [socket.AF_INET]
+    if hasattr(socket, 'AF_INET6'):
+        families.append(socket.AF_INET6)
+
+    for af in families:
+        try:
+            inet_pton(af, hostname)
+        except (socket.error, ValueError, OSError):
+            pass
+        else:
+            return True
+    return False
diff --git a/pipenv/patched/notpip/_vendor/urllib3/util/wait.py b/pipenv/patched/notpip/_vendor/urllib3/util/wait.py
index cb396e50..fa686eff 100644
--- a/pipenv/patched/notpip/_vendor/urllib3/util/wait.py
+++ b/pipenv/patched/notpip/_vendor/urllib3/util/wait.py
@@ -1,40 +1,153 @@
-from .selectors import (
-    HAS_SELECT,
-    DefaultSelector,
-    EVENT_READ,
-    EVENT_WRITE
-)
+import errno
+from functools import partial
+import select
+import sys
+try:
+    from time import monotonic
+except ImportError:
+    from time import time as monotonic
+
+__all__ = ["NoWayToWaitForSocketError", "wait_for_read", "wait_for_write"]
 
 
-def _wait_for_io_events(socks, events, timeout=None):
-    """ Waits for IO events to be available from a list of sockets
-    or optionally a single socket if passed in. Returns a list of
-    sockets that can be interacted with immediately. """
-    if not HAS_SELECT:
-        raise ValueError('Platform does not have a selector')
-    if not isinstance(socks, list):
-        # Probably just a single socket.
-        if hasattr(socks, "fileno"):
-            socks = [socks]
-        # Otherwise it might be a non-list iterable.
+class NoWayToWaitForSocketError(Exception):
+    pass
+
+
+# How should we wait on sockets?
+#
+# There are two types of APIs you can use for waiting on sockets: the fancy
+# modern stateful APIs like epoll/kqueue, and the older stateless APIs like
+# select/poll. The stateful APIs are more efficient when you have a lots of
+# sockets to keep track of, because you can set them up once and then use them
+# lots of times. But we only ever want to wait on a single socket at a time
+# and don't want to keep track of state, so the stateless APIs are actually
+# more efficient. So we want to use select() or poll().
+#
+# Now, how do we choose between select() and poll()? On traditional Unixes,
+# select() has a strange calling convention that makes it slow, or fail
+# altogether, for high-numbered file descriptors. The point of poll() is to fix
+# that, so on Unixes, we prefer poll().
+#
+# On Windows, there is no poll() (or at least Python doesn't provide a wrapper
+# for it), but that's OK, because on Windows, select() doesn't have this
+# strange calling convention; plain select() works fine.
+#
+# So: on Windows we use select(), and everywhere else we use poll(). We also
+# fall back to select() in case poll() is somehow broken or missing.
+
+if sys.version_info >= (3, 5):
+    # Modern Python, that retries syscalls by default
+    def _retry_on_intr(fn, timeout):
+        return fn(timeout)
+else:
+    # Old and broken Pythons.
+    def _retry_on_intr(fn, timeout):
+        if timeout is not None and timeout <= 0:
+            return fn(timeout)
+
+        if timeout is None:
+            deadline = float("inf")
         else:
-            socks = list(socks)
-    with DefaultSelector() as selector:
-        for sock in socks:
-            selector.register(sock, events)
-        return [key[0].fileobj for key in
-                selector.select(timeout) if key[1] & events]
+            deadline = monotonic() + timeout
+
+        while True:
+            try:
+                return fn(timeout)
+            # OSError for 3 <= pyver < 3.5, select.error for pyver <= 2.7
+            except (OSError, select.error) as e:
+                # 'e.args[0]' incantation works for both OSError and select.error
+                if e.args[0] != errno.EINTR:
+                    raise
+                else:
+                    timeout = deadline - monotonic()
+                    if timeout < 0:
+                        timeout = 0
+                    if timeout == float("inf"):
+                        timeout = None
+                    continue
 
 
-def wait_for_read(socks, timeout=None):
-    """ Waits for reading to be available from a list of sockets
-    or optionally a single socket if passed in. Returns a list of
-    sockets that can be read from immediately. """
-    return _wait_for_io_events(socks, EVENT_READ, timeout)
+def select_wait_for_socket(sock, read=False, write=False, timeout=None):
+    if not read and not write:
+        raise RuntimeError("must specify at least one of read=True, write=True")
+    rcheck = []
+    wcheck = []
+    if read:
+        rcheck.append(sock)
+    if write:
+        wcheck.append(sock)
+    # When doing a non-blocking connect, most systems signal success by
+    # marking the socket writable. Windows, though, signals success by marked
+    # it as "exceptional". We paper over the difference by checking the write
+    # sockets for both conditions. (The stdlib selectors module does the same
+    # thing.)
+    fn = partial(select.select, rcheck, wcheck, wcheck)
+    rready, wready, xready = _retry_on_intr(fn, timeout)
+    return bool(rready or wready or xready)
 
 
-def wait_for_write(socks, timeout=None):
-    """ Waits for writing to be available from a list of sockets
-    or optionally a single socket if passed in. Returns a list of
-    sockets that can be written to immediately. """
-    return _wait_for_io_events(socks, EVENT_WRITE, timeout)
+def poll_wait_for_socket(sock, read=False, write=False, timeout=None):
+    if not read and not write:
+        raise RuntimeError("must specify at least one of read=True, write=True")
+    mask = 0
+    if read:
+        mask |= select.POLLIN
+    if write:
+        mask |= select.POLLOUT
+    poll_obj = select.poll()
+    poll_obj.register(sock, mask)
+
+    # For some reason, poll() takes timeout in milliseconds
+    def do_poll(t):
+        if t is not None:
+            t *= 1000
+        return poll_obj.poll(t)
+
+    return bool(_retry_on_intr(do_poll, timeout))
+
+
+def null_wait_for_socket(*args, **kwargs):
+    raise NoWayToWaitForSocketError("no select-equivalent available")
+
+
+def _have_working_poll():
+    # Apparently some systems have a select.poll that fails as soon as you try
+    # to use it, either due to strange configuration or broken monkeypatching
+    # from libraries like eventlet/greenlet.
+    try:
+        poll_obj = select.poll()
+        poll_obj.poll(0)
+    except (AttributeError, OSError):
+        return False
+    else:
+        return True
+
+
+def wait_for_socket(*args, **kwargs):
+    # We delay choosing which implementation to use until the first time we're
+    # called. We could do it at import time, but then we might make the wrong
+    # decision if someone goes wild with monkeypatching select.poll after
+    # we're imported.
+    global wait_for_socket
+    if _have_working_poll():
+        wait_for_socket = poll_wait_for_socket
+    elif hasattr(select, "select"):
+        wait_for_socket = select_wait_for_socket
+    else:  # Platform-specific: Appengine.
+        wait_for_socket = null_wait_for_socket
+    return wait_for_socket(*args, **kwargs)
+
+
+def wait_for_read(sock, timeout=None):
+    """ Waits for reading to be available on a given socket.
+    Returns True if the socket is readable, or False if the timeout expired.
+    """
+    return wait_for_socket(sock, read=True, timeout=timeout)
+
+
+def wait_for_write(sock, timeout=None):
+    """ Waits for writing to be available on a given socket.
+    Returns True if the socket is readable, or False if the timeout expired.
+    """
+    return wait_for_socket(sock, write=True, timeout=timeout)
diff --git a/pipenv/patched/notpip/_vendor/vendor.txt b/pipenv/patched/notpip/_vendor/vendor.txt
index 3994e709..9389dd94 100644
--- a/pipenv/patched/notpip/_vendor/vendor.txt
+++ b/pipenv/patched/notpip/_vendor/vendor.txt
@@ -1,22 +1,23 @@
 appdirs==1.4.3
 distlib==0.2.7
-distro==1.2.0
+distro==1.3.0
 html5lib==1.0.1
 six==1.11.0
 colorama==0.3.9
-CacheControl==0.12.4
+CacheControl==0.12.5
 msgpack-python==0.5.6
 lockfile==0.12.2
-progress==1.3
-ipaddress==1.0.19  # Only needed on 2.6 and 2.7
-packaging==17.1
-pyparsing==2.2.0
-pytoml==0.1.14
+progress==1.4
+ipaddress==1.0.22  # Only needed on 2.6 and 2.7
+packaging==18.0
+pep517==0.2
+pyparsing==2.2.1
+pytoml==0.1.19
 retrying==1.3.3
-requests==2.18.4
+requests==2.19.1
     chardet==3.0.4
-    idna==2.6
-    urllib3==1.22
-    certifi==2018.1.18
-setuptools==39.1.0
+    idna==2.7
+    urllib3==1.23
+    certifi==2018.8.24
+setuptools==40.4.3
 webencodings==0.5.1
diff --git a/pipenv/patched/patched.txt b/pipenv/patched/patched.txt
index f8bdb9e1..f73ed5a6 100644
--- a/pipenv/patched/patched.txt
+++ b/pipenv/patched/patched.txt
@@ -2,6 +2,6 @@ safety
 git+https://github.com/jumpscale7/python-consistent-toml.git#egg=contoml
 crayons==0.1.2
 pipfile==0.0.2
-git+https://github.com/jazzband/pip-tools.git@9cb41d828fcb0967a32cc140c1dcaca94e5f4daa#egg=piptools
+pip-tools==3.1.0
 prettytoml==0.3
-pip==10.0.1
+pip==18.1
diff --git a/pipenv/patched/piptools/_compat/__init__.py b/pipenv/patched/piptools/_compat/__init__.py
index feadad89..c0ecec8a 100644
--- a/pipenv/patched/piptools/_compat/__init__.py
+++ b/pipenv/patched/piptools/_compat/__init__.py
@@ -29,4 +29,6 @@ from .pip_compat import (
     PyPI,
     SafeFileCache,
     InstallationError,
+    install_req_from_line,
+    install_req_from_editable,
 )
diff --git a/pipenv/patched/piptools/_compat/pip_compat.py b/pipenv/patched/piptools/_compat/pip_compat.py
index 0a0d27dc..c466ef04 100644
--- a/pipenv/patched/piptools/_compat/pip_compat.py
+++ b/pipenv/patched/piptools/_compat/pip_compat.py
@@ -1,42 +1,55 @@
 # -*- coding=utf-8 -*-
-import importlib
 
+__all__ = [
+    "InstallRequirement",
+    "parse_requirements",
+    "RequirementSet",
+    "user_cache_dir",
+    "FAVORITE_HASH",
+    "is_file_url",
+    "url_to_path",
+    "PackageFinder",
+    "FormatControl",
+    "Wheel",
+    "Command",
+    "cmdoptions",
+    "get_installed_distributions",
+    "PyPI",
+    "SafeFileCache",
+    "InstallationError",
+    "parse_version",
+    "pip_version",
+    "install_req_from_editable",
+    "install_req_from_line",
+    "user_cache_dir"
+]
 
-def do_import(module_path, subimport=None, old_path=None, vendored_name=None):
-    internal = 'pip._internal.{0}'.format(module_path)
-    old_path = old_path or module_path
-    pip9 = 'pip.{0}'.format(old_path)
-    _tmp = None
-    if vendored_name:
-        vendor = '{0}._internal'.format(vendored_name)
-        vendor = '{0}.{1}'.format(vendor, old_path if old_path else module_path)
-        try:
-            _tmp = importlib.import_module(vendor)
-        except ImportError:
-            pass
-    if not _tmp:
-        try:
-            _tmp = importlib.import_module(internal)
-        except ImportError:
-            _tmp = importlib.import_module(pip9)
-    if subimport:
-        return getattr(_tmp, subimport, _tmp)
-    return _tmp
+from pipenv.vendor.appdirs import user_cache_dir
+from pip_shims.shims import (
+    InstallRequirement,
+    parse_requirements,
+    RequirementSet,
+    FAVORITE_HASH,
+    is_file_url,
+    url_to_path,
+    PackageFinder,
+    FormatControl,
+    Wheel,
+    Command,
+    cmdoptions,
+    get_installed_distributions,
+    PyPI,
+    SafeFileCache,
+    InstallationError,
+    parse_version,
+    pip_version,
+)
 
-
-InstallRequirement = do_import('req.req_install', 'InstallRequirement', vendored_name='notpip')
-parse_requirements = do_import('req.req_file', 'parse_requirements', vendored_name='notpip')
-RequirementSet = do_import('req.req_set', 'RequirementSet', vendored_name='notpip')
-user_cache_dir = do_import('utils.appdirs', 'user_cache_dir', vendored_name='notpip')
-FAVORITE_HASH = do_import('utils.hashes', 'FAVORITE_HASH', vendored_name='notpip')
-is_file_url = do_import('download', 'is_file_url', vendored_name='notpip')
-url_to_path = do_import('download', 'url_to_path', vendored_name='notpip')
-PackageFinder = do_import('index', 'PackageFinder', vendored_name='notpip')
-FormatControl = do_import('index', 'FormatControl', vendored_name='notpip')
-Wheel = do_import('wheel', 'Wheel', vendored_name='notpip')
-Command = do_import('basecommand', 'Command', vendored_name='notpip')
-cmdoptions = do_import('cmdoptions', vendored_name='notpip')
-get_installed_distributions = do_import('utils.misc', 'get_installed_distributions', old_path='utils', vendored_name='notpip')
-PyPI = do_import('models.index', 'PyPI', vendored_name='notpip')
-SafeFileCache = do_import('download', 'SafeFileCache', vendored_name='notpip')
-InstallationError = do_import('exceptions', 'InstallationError', vendored_name='notpip')
+# pip 18.1 has refactored InstallRequirement constructors use by pip-tools.
+if parse_version(pip_version) < parse_version('18.1'):
+    install_req_from_line = InstallRequirement.from_line
+    install_req_from_editable = InstallRequirement.from_editable
+else:
+    from pip_shims.shims import (
+        install_req_from_editable, install_req_from_line
+    )
diff --git a/pipenv/patched/piptools/io.py b/pipenv/patched/piptools/io.py
index e9526832..b6bca675 100644
--- a/pipenv/patched/piptools/io.py
+++ b/pipenv/patched/piptools/io.py
@@ -347,7 +347,7 @@ class AtomicSaver(object):
         writer at a time.
       * Optional recovery of partial data in failure cases.
 
-    .. _context manager: https://docs.python.org/2/reference/compound_stmts.html#with
+    .. _context manager: https://docs.python.org/3/reference/compound_stmts.html#with
     .. _umask: https://en.wikipedia.org/wiki/Umask
 
     """
diff --git a/pipenv/patched/piptools/locations.py b/pipenv/patched/piptools/locations.py
index fbc820ab..0d460f64 100644
--- a/pipenv/patched/piptools/locations.py
+++ b/pipenv/patched/piptools/locations.py
@@ -2,13 +2,10 @@ import os
 from shutil import rmtree
 
 from .click import secho
-# Patch by vphilippon 2017-11-22: Use pipenv cache path.
-# from ._compat import user_cache_dir
-from pipenv.environments import PIPENV_CACHE_DIR
+from ._compat import user_cache_dir
 
 # The user_cache_dir helper comes straight from pipenv.patched.notpip itself
-# CACHE_DIR = user_cache_dir(os.path.join('pip-tools'))
-CACHE_DIR = PIPENV_CACHE_DIR
+CACHE_DIR = user_cache_dir('pip-tools')
 
 # NOTE
 # We used to store the cache dir under ~/.pip-tools, which is not the
diff --git a/pipenv/patched/piptools/repositories/pypi.py b/pipenv/patched/piptools/repositories/pypi.py
index 9e741560..2a0743a3 100644
--- a/pipenv/patched/piptools/repositories/pypi.py
+++ b/pipenv/patched/piptools/repositories/pypi.py
@@ -4,7 +4,6 @@ from __future__ import (absolute_import, division, print_function,
 import copy
 import hashlib
 import os
-import sys
 from contextlib import contextmanager
 from shutil import rmtree
 
@@ -18,33 +17,28 @@ from .._compat import (
     TemporaryDirectory,
     PyPI,
     InstallRequirement,
-    SafeFileCache,
+    SafeFileCache
 )
+os.environ["PIP_SHIMS_BASE_MODULE"] = str("pipenv.patched.notpip")
+from pip_shims.shims import do_import, VcsSupport, WheelCache
+from packaging.requirements import Requirement
+from packaging.specifiers import SpecifierSet, Specifier
+InstallationError = do_import(("exceptions.InstallationError", "7.0", "9999"))
+from pipenv.patched.notpip._internal.resolve import Resolver as PipResolver
 
-from pipenv.patched.notpip._vendor.packaging.requirements import Requirement
-from pipenv.patched.notpip._vendor.packaging.specifiers import SpecifierSet, Specifier
-from pipenv.patched.notpip._vendor.packaging.markers import Op, Value, Variable
-from pipenv.patched.notpip._internal.exceptions import InstallationError
-from pipenv.patched.notpip._internal.vcs import VcsSupport
 
-from pipenv.environments import PIPENV_CACHE_DIR
+from pipenv.environments import PIPENV_CACHE_DIR as CACHE_DIR
 from ..exceptions import NoCandidateFound
-from ..utils import (fs_str, is_pinned_requirement, lookup_table,
-                     make_install_requirement, clean_requires_python)
-
+from ..utils import (fs_str, is_pinned_requirement, lookup_table, dedup,
+                        make_install_requirement, clean_requires_python)
 from .base import BaseRepository
 
-
 try:
-    from pipenv.patched.notpip._internal.operations.prepare import RequirementPreparer
-    from pipenv.patched.notpip._internal.resolve import Resolver as PipResolver
+    from pipenv.patched.notpip._internal.req.req_tracker import RequirementTracker
 except ImportError:
-    pass
-
-try:
-    from pipenv.patched.notpip._internal.cache import WheelCache
-except ImportError:
-    from pipenv.patched.notpip.wheel import WheelCache
+    @contextmanager
+    def RequirementTracker():
+        yield
 
 
 class HashCache(SafeFileCache):
@@ -56,7 +50,7 @@ class HashCache(SafeFileCache):
     def __init__(self, *args, **kwargs):
         session = kwargs.pop('session')
         self.session = session
-        kwargs.setdefault('directory', os.path.join(PIPENV_CACHE_DIR, 'hash-cache'))
+        kwargs.setdefault('directory', os.path.join(CACHE_DIR, 'hash-cache'))
         super(HashCache, self).__init__(*args, **kwargs)
 
     def get_hash(self, location):
@@ -73,10 +67,10 @@ class HashCache(SafeFileCache):
             hash_value = self.get(new_location.url)
         if not hash_value:
             hash_value = self._get_file_hash(new_location) if not new_location.url.startswith("ssh") else None
-            hash_value = hash_value.encode('utf8')
+            hash_value = hash_value.encode('utf8') if hash_value else None
         if can_hash:
             self.set(new_location.url, hash_value)
-        return hash_value.decode('utf8')
+        return hash_value.decode('utf8') if hash_value else None
 
     def _get_file_hash(self, location):
         h = hashlib.new(FAVORITE_HASH)
@@ -99,7 +93,6 @@ class PyPIRepository(BaseRepository):
         self.session = session
         self.use_json = use_json
         self.pip_options = pip_options
-        self.wheel_cache = WheelCache(PIPENV_CACHE_DIR, pip_options.format_control)
 
         index_urls = [pip_options.index_url] + pip_options.extra_index_urls
         if pip_options.no_index:
@@ -131,8 +124,8 @@ class PyPIRepository(BaseRepository):
 
         # Setup file paths
         self.freshen_build_caches()
-        self._download_dir = fs_str(os.path.join(PIPENV_CACHE_DIR, 'pkgs'))
-        self._wheel_download_dir = fs_str(os.path.join(PIPENV_CACHE_DIR, 'wheels'))
+        self._download_dir = fs_str(os.path.join(CACHE_DIR, 'pkgs'))
+        self._wheel_download_dir = fs_str(os.path.join(CACHE_DIR, 'wheels'))
 
     def freshen_build_caches(self):
         """
@@ -169,7 +162,6 @@ class PyPIRepository(BaseRepository):
             return ireq  # return itself as the best match
 
         all_candidates = clean_requires_python(self.find_all_candidates(ireq.name))
-
         candidates_by_version = lookup_table(all_candidates, key=lambda c: c.version, unique=True)
         try:
             matching_versions = ireq.specifier.filter((candidate.version for candidate in all_candidates),
@@ -184,14 +176,10 @@ class PyPIRepository(BaseRepository):
         best_candidate = max(matching_candidates, key=self.finder._candidate_sort_key)
 
         # Turn the candidate into a pinned InstallRequirement
-        new_req = make_install_requirement(
-            best_candidate.project, best_candidate.version, ireq.extras, ireq.markers, constraint=ireq.constraint
+        return make_install_requirement(
+            best_candidate.project, best_candidate.version, ireq.extras, ireq.markers,  constraint=ireq.constraint
          )
 
-        # KR TODO: Marker here?
-
-        return new_req
-
     def get_json_dependencies(self, ireq):
 
         if not (is_pinned_requirement(ireq)):
@@ -248,116 +236,100 @@ class PyPIRepository(BaseRepository):
 
         return json_results
 
-    def get_legacy_dependencies(self, ireq):
-        """
-        Given a pinned or an editable InstallRequirement, returns a set of
-        dependencies (also InstallRequirements, but not necessarily pinned).
-        They indicate the secondary dependencies for the given requirement.
-        """
-        if not (ireq.editable or is_pinned_requirement(ireq)):
-            raise TypeError('Expected pinned or editable InstallRequirement, got {}'.format(ireq))
+    def resolve_reqs(self, download_dir, ireq, wheel_cache, setup_requires={}, dist=None):
+        results = None
+        setup_requires = {}
+        dist = None
+        ireq.isolated = False
+        ireq._wheel_cache = wheel_cache
 
-        if ireq not in self._dependencies_cache:
-            if ireq.editable and (ireq.source_dir and os.path.exists(ireq.source_dir)):
-                # No download_dir for locally available editable requirements.
-                # If a download_dir is passed, pip will  unnecessarely
-                # archive the entire source directory
-                download_dir = None
-            elif ireq.link and not ireq.link.is_artifact:
-                # No download_dir for VCS sources.  This also works around pip
-                # using git-checkout-index, which gets rid of the .git dir.
-                download_dir = None
-            else:
-                download_dir = self._download_dir
-                if not os.path.isdir(download_dir):
-                    os.makedirs(download_dir)
-            if not os.path.isdir(self._wheel_download_dir):
-                os.makedirs(self._wheel_download_dir)
+        try:
+            from pipenv.patched.notpip._internal.operations.prepare import RequirementPreparer
+        except ImportError:
+                # Pip 9 and below
+            reqset = RequirementSet(
+                self.build_dir,
+                self.source_dir,
+                download_dir=download_dir,
+                wheel_download_dir=self._wheel_download_dir,
+                session=self.session,
+                ignore_installed=True,
+                ignore_compatibility=False,
+                wheel_cache=wheel_cache
+            )
+            results = reqset._prepare_file(self.finder, ireq, ignore_requires_python=True)
+        else:
+            # pip >= 10
+            preparer_kwargs = {
+                'build_dir': self.build_dir,
+                'src_dir': self.source_dir,
+                'download_dir': download_dir,
+                'wheel_download_dir': self._wheel_download_dir,
+                'progress_bar': 'off',
+                'build_isolation': False
+            }
+            resolver_kwargs = {
+                'finder': self.finder,
+                'session': self.session,
+                'upgrade_strategy': "to-satisfy-only",
+                'force_reinstall': True,
+                'ignore_dependencies': False,
+                'ignore_requires_python': True,
+                'ignore_installed': True,
+                'isolated': False,
+                'wheel_cache': wheel_cache,
+                'use_user_site': False,
+                'ignore_compatibility': False
+            }
+            resolver = None
+            preparer = None
+            with RequirementTracker() as req_tracker:
+                # Pip 18 uses a requirement tracker to prevent fork bombs
+                if req_tracker:
+                    preparer_kwargs['req_tracker'] = req_tracker
+                preparer = RequirementPreparer(**preparer_kwargs)
+                resolver_kwargs['preparer'] = preparer
+                reqset = RequirementSet()
+                ireq.is_direct = True
+                # reqset.add_requirement(ireq)
+                resolver = PipResolver(**resolver_kwargs)
+                resolver.require_hashes = False
+                results = resolver._resolve_one(reqset, ireq)
+
+        cleanup_fn = getattr(reqset, "cleanup_files", None)
+        if cleanup_fn is not None:
+            try:
+                cleanup_fn()
+            except OSError:
+                pass
+
+        if ireq.editable and (not ireq.source_dir or not os.path.exists(ireq.source_dir)):
+            if ireq.editable:
+                self._source_dir = TemporaryDirectory(fs_str("source"))
+                ireq.ensure_has_source_dir(self.source_dir)
+
+        if ireq.editable and (ireq.source_dir and os.path.exists(ireq.source_dir)):
             # Collect setup_requires info from local eggs.
             # Do this after we call the preparer on these reqs to make sure their
             # egg info has been created
-            setup_requires = {}
-            dist = None
-            if ireq.editable:
+            from pipenv.utils import chdir
+            with chdir(ireq.setup_py_dir):
                 try:
-                    from pipenv.utils import chdir
-                    with chdir(ireq.setup_py_dir):
-                        from setuptools.dist import distutils
-                        dist = distutils.core.run_setup(ireq.setup_py)
-                except (ImportError, InstallationError, TypeError, AttributeError):
-                    pass
-                try:
-                    dist = ireq.get_dist() if not dist else dist
+                    from setuptools.dist import distutils
+                    dist = distutils.core.run_setup(ireq.setup_py)
                 except InstallationError:
                     ireq.run_egg_info()
-                    dist = ireq.get_dist()
                 except (TypeError, ValueError, AttributeError):
                     pass
-                else:
-                    setup_requires = getattr(dist, "extras_require", None)
-                    if not setup_requires:
-                        setup_requires = {"setup_requires": getattr(dist, "setup_requires", None)}
-            try:
-                # Pip 9 and below
-                reqset = RequirementSet(
-                    self.build_dir,
-                    self.source_dir,
-                    download_dir=download_dir,
-                    wheel_download_dir=self._wheel_download_dir,
-                    session=self.session,
-                    ignore_installed=True,
-                    ignore_compatibility=False,
-                    wheel_cache=self.wheel_cache,
-                )
-                result = reqset._prepare_file(
-                    self.finder,
-                    ireq,
-                    ignore_requires_python=True
-                )
-            except TypeError:
-                # Pip >= 10 (new resolver!)
-                preparer = RequirementPreparer(
-                    build_dir=self.build_dir,
-                    src_dir=self.source_dir,
-                    download_dir=download_dir,
-                    wheel_download_dir=self._wheel_download_dir,
-                    progress_bar='off',
-                    build_isolation=False
-                )
-                reqset = RequirementSet()
-                ireq.is_direct = True
-                reqset.add_requirement(ireq)
-                self.resolver = PipResolver(
-                    preparer=preparer,
-                    finder=self.finder,
-                    session=self.session,
-                    upgrade_strategy="to-satisfy-only",
-                    force_reinstall=True,
-                    ignore_dependencies=False,
-                    ignore_requires_python=True,
-                    ignore_installed=True,
-                    isolated=False,
-                    wheel_cache=self.wheel_cache,
-                    use_user_site=False,
-                    ignore_compatibility=False
-                )
-                self.resolver.resolve(reqset)
-                result = set(reqset.requirements.values())
-
-            # HACK: Sometimes the InstallRequirement doesn't properly get
-            # these values set on it during the resolution process. It's
-            # difficult to pin down what is going wrong. This fixes things.
-            if not getattr(ireq, 'version', None):
-                try:
-                    dist = ireq.get_dist() if not dist else None
-                    ireq.version = ireq.get_dist().version
-                except (ValueError, OSError, TypeError, AttributeError) as e:
-                    pass
-            if not getattr(ireq, 'project_name', None):
-                try:
-                    ireq.project_name = dist.project_name if dist else None
-                except (ValueError, TypeError) as e:
-                    pass
+                if not dist:
+                    try:
+                        dist = ireq.get_dist()
+                    except (ImportError, ValueError, TypeError, AttributeError):
+                        pass
+        if ireq.editable and dist:
+            setup_requires = getattr(dist, "extras_require", None)
+            if not setup_requires:
+                setup_requires = {"setup_requires": getattr(dist, "setup_requires", None)}
             if not getattr(ireq, 'req', None):
                 try:
                     ireq.req = dist.as_requirement() if dist else None
@@ -385,14 +357,14 @@ class PyPIRepository(BaseRepository):
                         if ':' not in value:
                             try:
                                 if not not_python:
-                                    result = result + [InstallRequirement.from_line("{0}{1}".format(value, python_version).replace(':', ';'))]
+                                    results.add(InstallRequirement.from_line("{0}{1}".format(value, python_version).replace(':', ';')))
                             # Anything could go wrong here -- can't be too careful.
                             except Exception:
                                 pass
 
             # this section properly creates 'python_version' markers for cross-python
             # virtualenv creation and for multi-python compatibility.
-            requires_python = reqset.requires_python if hasattr(reqset, 'requires_python') else self.resolver.requires_python
+            requires_python = reqset.requires_python if hasattr(reqset, 'requires_python') else resolver.requires_python
             if requires_python:
                 marker_str = ''
                 # This corrects a logic error from the previous code which said that if
@@ -402,28 +374,68 @@ class PyPIRepository(BaseRepository):
                 if any(requires_python.startswith(op) for op in Specifier._operators.keys()):
                     # We are checking first if we have  leading specifier operator
                     # if not, we can assume we should be doing a == comparison
-                    specifierset = list(SpecifierSet(requires_python))
+                    specifierset = SpecifierSet(requires_python)
                     # for multiple specifiers, the correct way to represent that in
                     # a specifierset is `Requirement('fakepkg; python_version<"3.0,>=2.6"')`
-                    marker_key = Variable('python_version')
-                    markers = []
-                    for spec in specifierset:
-                        operator, val = spec._spec
-                        operator = Op(operator)
-                        val = Value(val)
-                        markers.append(''.join([marker_key.serialize(), operator.serialize(), val.serialize()]))
-                    marker_str = ' and '.join(markers)
+                    from passa.internals.specifiers import cleanup_pyspecs
+                    marker_str = str(Marker(" and ".join(dedup([
+                        "python_version {0[0]} '{0[1]}'".format(spec)
+                        for spec in cleanup_pyspecs(specifierset)
+                    ]))))
                 # The best way to add markers to a requirement is to make a separate requirement
                 # with only markers on it, and then to transfer the object istelf
                 marker_to_add = Requirement('fakepkg; {0}'.format(marker_str)).marker
-                result.remove(ireq)
+                if ireq in results:
+                    results.remove(ireq)
+                print(marker_to_add)
                 ireq.req.marker = marker_to_add
-                result.add(ireq)
 
-            self._dependencies_cache[ireq] = result
-            reqset.cleanup_files()
+        results = set(results) if results else set()
+        return results, ireq
 
-        return set(self._dependencies_cache[ireq])
+    def get_legacy_dependencies(self, ireq):
+        """
+        Given a pinned or an editable InstallRequirement, returns a set of
+        dependencies (also InstallRequirements, but not necessarily pinned).
+        They indicate the secondary dependencies for the given requirement.
+        """
+        if not (ireq.editable or is_pinned_requirement(ireq)):
+            raise TypeError('Expected pinned or editable InstallRequirement, got {}'.format(ireq))
+
+        if ireq not in self._dependencies_cache:
+            if ireq.editable and (ireq.source_dir and os.path.exists(ireq.source_dir)):
+                # No download_dir for locally available editable requirements.
+                # If a download_dir is passed, pip will  unnecessarely
+                # archive the entire source directory
+                download_dir = None
+
+            elif ireq.link and not ireq.link.is_artifact:
+                # No download_dir for VCS sources.  This also works around pip
+                # using git-checkout-index, which gets rid of the .git dir.
+                download_dir = None
+            else:
+                download_dir = self._download_dir
+                if not os.path.isdir(download_dir):
+                    os.makedirs(download_dir)
+            if not os.path.isdir(self._wheel_download_dir):
+                os.makedirs(self._wheel_download_dir)
+
+            wheel_cache = WheelCache(CACHE_DIR, self.pip_options.format_control)
+            prev_tracker = os.environ.get('PIP_REQ_TRACKER')
+            try:
+                results, ireq = self.resolve_reqs(download_dir, ireq, wheel_cache)
+                self._dependencies_cache[ireq] = results
+            finally:
+                if 'PIP_REQ_TRACKER' in os.environ:
+                    if prev_tracker:
+                        os.environ['PIP_REQ_TRACKER'] = prev_tracker
+                    else:
+                        del os.environ['PIP_REQ_TRACKER']
+                try:
+                    self.wheel_cache.cleanup()
+                except AttributeError:
+                    pass
+        return self._dependencies_cache[ireq]
 
     def get_hashes(self, ireq):
         """
@@ -457,8 +469,8 @@ class PyPIRepository(BaseRepository):
         # matching_candidates = candidates_by_version[matching_versions[0]]
 
         return {
-            self._hash_cache.get_hash(candidate.location)
-            for candidate in matching_candidates
+            h for h in map(lambda c: self._hash_cache.get_hash(c.location),
+                                matching_candidates) if h is not None
         }
 
     @contextmanager
diff --git a/pipenv/patched/piptools/resolver.py b/pipenv/patched/piptools/resolver.py
index 807cf518..1f3e18c1 100644
--- a/pipenv/patched/piptools/resolver.py
+++ b/pipenv/patched/piptools/resolver.py
@@ -7,9 +7,7 @@ from functools import partial
 from itertools import chain, count
 import os
 
-from first import first
-from pipenv.patched.notpip._vendor.packaging.markers import default_environment
-from ._compat import InstallRequirement
+from ._compat import install_req_from_line
 
 from . import click
 from .cache import DependencyCache
@@ -73,7 +71,7 @@ class Resolver(object):
         with self.repository.allow_all_wheels():
             return {ireq: self.repository.get_hashes(ireq) for ireq in ireqs}
 
-    def resolve(self, max_rounds=12):
+    def resolve(self, max_rounds=10):
         """
         Finds concrete package versions for all the given InstallRequirements
         and their recursive dependencies.  The end result is a flat list of
@@ -145,20 +143,18 @@ class Resolver(object):
         """
         for _, ireqs in full_groupby(constraints, key=key_from_ireq):
             ireqs = list(ireqs)
-            editable_ireq = first(ireqs, key=lambda ireq: ireq.editable)
+            editable_ireq = next((ireq for ireq in ireqs if ireq.editable), None)
             if editable_ireq:
                 yield editable_ireq  # ignore all the other specs: the editable one is the one that counts
                 continue
+
             ireqs = iter(ireqs)
             # deepcopy the accumulator so as to not modify the self.our_constraints invariant
             combined_ireq = copy.deepcopy(next(ireqs))
+            combined_ireq.comes_from = None
             for ireq in ireqs:
                 # NOTE we may be losing some info on dropped reqs here
-                try:
-                    combined_ireq.req.specifier &= ireq.req.specifier
-                except TypeError:
-                    if ireq.req.specifier._specs and not combined_ireq.req.specifier._specs:
-                        combined_ireq.req.specifier._specs = ireq.req.specifier._specs
+                combined_ireq.req.specifier &= ireq.req.specifier
                 combined_ireq.constraint &= ireq.constraint
                 if not combined_ireq.markers:
                     combined_ireq.markers = ireq.markers
@@ -166,6 +162,7 @@ class Resolver(object):
                     _markers = combined_ireq.markers._markers
                     if not isinstance(_markers[0], (tuple, list)):
                         combined_ireq.markers._markers = [_markers, 'and', ireq.markers._markers]
+
                 # Return a sorted, de-duped tuple of extras
                 combined_ireq.extras = tuple(sorted(set(tuple(combined_ireq.extras) + tuple(ireq.extras))))
             yield combined_ireq
@@ -286,11 +283,12 @@ class Resolver(object):
 
         # fix our malformed extras
         if ireq.extras:
-            if hasattr(ireq, 'extra'):
+            if getattr(ireq, "extra", None):
                 if ireq.extras:
                     ireq.extras.extend(ireq.extra)
                 else:
                     ireq.extras = ireq.extra
+
         elif not is_pinned_requirement(ireq):
             raise TypeError('Expected pinned or editable requirement, got {}'.format(ireq))
 
@@ -301,14 +299,14 @@ class Resolver(object):
         if ireq not in self.dependency_cache:
             log.debug('  {} not in cache, need to check index'.format(format_requirement(ireq)), fg='yellow')
             dependencies = self.repository.get_dependencies(ireq)
-            self.dependency_cache[ireq] = sorted(format_requirement(_ireq) for _ireq in dependencies)
+            self.dependency_cache[ireq] = sorted(set(format_requirement(ireq) for ireq in dependencies))
 
         # Example: ['Werkzeug>=0.9', 'Jinja2>=2.4']
         dependency_strings = self.dependency_cache[ireq]
         log.debug('  {:25} requires {}'.format(format_requirement(ireq),
                                                ', '.join(sorted(dependency_strings, key=lambda s: s.lower())) or '-'))
         for dependency_string in dependency_strings:
-                yield InstallRequirement.from_line(dependency_string, constraint=ireq.constraint)
+            yield install_req_from_line(dependency_string, constraint=ireq.constraint)
 
     def reverse_dependencies(self, ireqs):
         non_editable = [ireq for ireq in ireqs if not ireq.editable]
diff --git a/pipenv/patched/piptools/scripts/compile.py b/pipenv/patched/piptools/scripts/compile.py
index 484b710c..4625618a 100644
--- a/pipenv/patched/piptools/scripts/compile.py
+++ b/pipenv/patched/piptools/scripts/compile.py
@@ -8,7 +8,7 @@ import sys
 import tempfile
 
 from .._compat import (
-    InstallRequirement,
+    install_req_from_line,
     parse_requirements,
     cmdoptions,
     Command,
@@ -134,7 +134,7 @@ def cli(verbose, dry_run, pre, rebuild, find_links, index_url, extra_index_url,
     if not upgrade and os.path.exists(dst_file):
         ireqs = parse_requirements(dst_file, finder=repository.finder, session=repository.session, options=pip_options)
         # Exclude packages from --upgrade-package/-P from the existing pins: We want to upgrade.
-        upgrade_pkgs_key = {key_from_req(InstallRequirement.from_line(pkg).req) for pkg in upgrade_packages}
+        upgrade_pkgs_key = {key_from_req(install_req_from_line(pkg).req) for pkg in upgrade_packages}
         existing_pins = {key_from_req(ireq.req): ireq
                          for ireq in ireqs
                          if is_pinned_requirement(ireq) and key_from_req(ireq.req) not in upgrade_pkgs_key}
diff --git a/pipenv/patched/piptools/utils.py b/pipenv/patched/piptools/utils.py
index 2f389eec..6f62eb9d 100644
--- a/pipenv/patched/piptools/utils.py
+++ b/pipenv/patched/piptools/utils.py
@@ -2,20 +2,19 @@
 from __future__ import (absolute_import, division, print_function,
                         unicode_literals)
 
-import six
 import os
 import sys
+import six
 from itertools import chain, groupby
 from collections import OrderedDict
 from contextlib import contextmanager
 
-from ._compat import InstallRequirement
+from ._compat import install_req_from_line
 
-from first import first
+from .click import style
 from pipenv.patched.notpip._vendor.packaging.specifiers import SpecifierSet, InvalidSpecifier
 from pipenv.patched.notpip._vendor.packaging.version import Version, InvalidVersion, parse as parse_version
 from pipenv.patched.notpip._vendor.packaging.markers import Marker, Op, Value, Variable
-from .click import style
 
 
 UNSAFE_PACKAGES = {'setuptools', 'distribute', 'pip'}
@@ -58,7 +57,7 @@ def simplify_markers(ireq):
     marker_str = ' and '.join(list(dedup(tuple(marker_list,)))) if marker_list else ''
     new_markers = Marker(marker_str)
     ireq.markers = new_markers
-    new_ireq = InstallRequirement.from_line(format_requirement(ireq))
+    new_ireq = install_req_from_line(format_requirement(ireq))
     if ireq.constraint:
         new_ireq.constraint = ireq.constraint
     return new_ireq
@@ -118,11 +117,11 @@ def make_install_requirement(name, version, extras, markers, constraint=False):
         extras_string = "[{}]".format(",".join(sorted(extras)))
 
     if not markers:
-        return InstallRequirement.from_line(
+        return install_req_from_line(
             str('{}{}=={}'.format(name, extras_string, version)),
             constraint=constraint)
     else:
-        return InstallRequirement.from_line(
+        return install_req_from_line(
             str('{}{}=={}; {}'.format(name, extras_string, version, str(markers))),
             constraint=constraint)
 
@@ -158,10 +157,6 @@ def _requirement_to_str_lowercase_name(requirement):
 
 
 def format_requirement(ireq, marker=None):
-    """
-    Generic formatter for pretty printing InstallRequirements to the terminal
-    in a less verbose way than using its `__str__` method.
-    """
     if ireq.editable:
         line = '-e {}'.format(ireq.link)
     else:
@@ -207,7 +202,7 @@ def is_pinned_requirement(ireq):
     if len(ireq.specifier._specs) != 1:
         return False
 
-    op, version = first(ireq.specifier._specs)._spec
+    op, version = next(iter(ireq.specifier._specs))._spec
     return (op == '==' or op == '===') and not version.endswith('.*')
 
 
@@ -219,7 +214,7 @@ def as_tuple(ireq):
         raise TypeError('Expected a pinned InstallRequirement, got {}'.format(ireq))
 
     name = key_from_req(ireq.req)
-    version = first(ireq.specifier._specs)._spec[1]
+    version = next(iter(ireq.specifier._specs))._spec[1]
     extras = tuple(sorted(ireq.extras))
     return name, version, extras
 
diff --git a/pipenv/project.py b/pipenv/project.py
index f9decbf6..195448d9 100644
--- a/pipenv/project.py
+++ b/pipenv/project.py
@@ -4,22 +4,23 @@ import json
 import os
 import re
 import sys
+import glob
 import base64
+import itertools
 import fnmatch
 import hashlib
 import contoml
 from first import first
+from cached_property import cached_property
+import operator
 import pipfile
 import pipfile.api
 import six
+import vistir
 import toml
 
-from ._compat import Path
-
 from .cmdparse import Script
 from .utils import (
-    atomic_open_for_write,
-    mkdir_p,
     pep423_name,
     proper_case,
     find_requirements,
@@ -33,7 +34,8 @@ from .utils import (
     is_star,
     get_workon_home,
     is_virtual_environment,
-    looks_like_dir
+    looks_like_dir,
+    sys_version
 )
 from .environments import (
     PIPENV_MAX_DEPTH,
@@ -43,6 +45,7 @@ from .environments import (
     PIPENV_TEST_INDEX,
     PIPENV_PYTHON,
     PIPENV_DEFAULT_PYTHON_VERSION,
+    PIPENV_CACHE_DIR
 )
 from requirementslib.utils import is_vcs
 
@@ -50,15 +53,19 @@ from requirementslib.utils import is_vcs
 def _normalized(p):
     if p is None:
         return None
-    loc = Path(p)
-    if loc.is_absolute():
-        return normalize_drive(str(loc))
-    else:
+    loc = vistir.compat.Path(p)
+    if not loc.is_absolute():
         try:
             loc = loc.resolve()
         except OSError:
             loc = loc.absolute()
-        return normalize_drive(str(loc))
+    # Recase the path properly on Windows. From https://stackoverflow.com/a/35229734/5043728
+    if os.name == 'nt':
+        matches = glob.glob(re.sub(r'([^:/\\])(?=[/\\]|$)', r'[\1]', str(loc)))
+        path_str = matches and matches[0] or str(loc)
+    else:
+        path_str = str(loc)
+    return normalize_drive(path_str)
 
 
 DEFAULT_NEWLINES = u"\n"
@@ -73,15 +80,19 @@ class _LockFileEncoder(json.JSONEncoder):
     * PrettyTOML's container elements are seamlessly encodable.
     * The output is always UTF-8-encoded text, never binary, even on Python 2.
     """
+
     def __init__(self):
         super(_LockFileEncoder, self).__init__(
-            indent=4, separators=(",", ": "), sort_keys=True,
+            indent=4, separators=(",", ": "), sort_keys=True
         )
 
     def default(self, obj):
         from prettytoml.elements.common import ContainerElement, TokenElement
+
         if isinstance(obj, (ContainerElement, TokenElement)):
             return obj.primitive_value
+        elif isinstance(obj, vistir.compat.Path):
+            obj = obj.as_posix()
         return super(_LockFileEncoder, self).default(obj)
 
     def encode(self, obj):
@@ -144,7 +155,7 @@ class Project(object):
         self._lockfile_newlines = DEFAULT_NEWLINES
         self._requirements_location = None
         self._original_dir = os.path.abspath(os.curdir)
-        self.which = which
+        self._which = which
         self.python_version = python_version
         # Hack to skip this during pipenv run, or -r.
         if ("run" not in sys.argv) and chdir:
@@ -266,33 +277,141 @@ class Project(object):
         return False
 
     def get_location_for_virtualenv(self):
-        if self.is_venv_in_project():
-            return os.path.join(self.project_directory, ".venv")
+        # If there's no project yet, set location based on config.
+        if not self.project_directory:
+            if self.is_venv_in_project():
+                return os.path.abspath(".venv")
+            return str(get_workon_home().joinpath(self.virtualenv_name))
 
-        name = self.virtualenv_name
-        if self.project_directory:
-            venv_path = os.path.join(self.project_directory, ".venv")
-            if os.path.exists(venv_path) and not os.path.isdir(".venv"):
-                with io.open(venv_path, "r") as f:
-                    name = f.read().strip()
-                # Assume file's contents is a path if it contains slashes.
-                if looks_like_dir(name):
-                    return Path(name).absolute().as_posix()
+        dot_venv = os.path.join(self.project_directory, ".venv")
+
+        # If there's no .venv in project root, set location based on config.
+        if not os.path.exists(dot_venv):
+            if self.is_venv_in_project():
+                return dot_venv
+            return str(get_workon_home().joinpath(self.virtualenv_name))
+
+        # If .venv in project root is a directory, use it.
+        if os.path.isdir(dot_venv):
+            return dot_venv
+
+        # Now we assume .venv in project root is a file. Use its content.
+        with io.open(dot_venv) as f:
+            name = f.read().strip()
+
+        # If content looks like a path, use it as a relative path.
+        # Otherwise use directory named after content in WORKON_HOME.
+        if looks_like_dir(name):
+            path = vistir.compat.Path(self.project_directory, name)
+            return path.absolute().as_posix()
         return str(get_workon_home().joinpath(name))
 
+    @property
+    def working_set(self):
+        from .utils import load_path
+        sys_path = load_path(self.which("python"))
+        import pkg_resources
+        return pkg_resources.WorkingSet(sys_path)
+
+    def find_egg(self, egg_dist):
+        import site
+        from distutils import sysconfig as distutils_sysconfig
+        site_packages = distutils_sysconfig.get_python_lib()
+        search_filename = "{0}.egg-link".format(egg_dist.project_name)
+        try:
+            user_site = site.getusersitepackages()
+        except AttributeError:
+            user_site = site.USER_SITE
+        search_locations = [site_packages, user_site]
+        for site_directory in search_locations:
+            egg = os.path.join(site_directory, search_filename)
+            if os.path.isfile(egg):
+                return egg
+
+    def locate_dist(self, dist):
+        location = self.find_egg(dist)
+        if not location:
+            return dist.location
+
+    def dist_is_in_project(self, dist):
+        prefix = _normalized(self.env_paths["prefix"])
+        location = self.locate_dist(dist)
+        if not location:
+            return False
+        return _normalized(location).startswith(prefix)
+
     def get_installed_packages(self):
-        from . import PIPENV_ROOT, PIPENV_VENDOR, PIPENV_PATCHED
-        from .utils import temp_path, load_path, temp_environ
+        workingset = self.working_set
         if self.virtualenv_exists:
-            with temp_path(), temp_environ():
-                new_path = load_path(self.which("python"))
-                new_path = [new_path[0], PIPENV_ROOT, PIPENV_PATCHED, PIPENV_VENDOR] + new_path[1:]
-                sys.path = new_path
-                os.environ['VIRTUAL_ENV'] = self.virtualenv_location
-                from .vendor.pip_shims.shims import get_installed_distributions
-                return get_installed_distributions(local_only=True)
+            packages = [pkg for pkg in workingset if self.dist_is_in_project(pkg)]
         else:
-            return []
+            packages = [pkg for pkg in packages]
+        return packages
+
+    def get_package_info(self):
+        from .utils import prepare_pip_source_args
+        from .vendor.pip_shims import Command, cmdoptions, index_group, PackageFinder
+        index_urls = [source.get("url") for source in self.sources]
+
+        class PipCommand(Command):
+            name = "PipCommand"
+
+        dependency_links = []
+        packages = self.get_installed_packages()
+        # This code is borrowed from pip's current implementation
+        for dist in packages:
+            if dist.has_metadata('dependency_links.txt'):
+                dependency_links.extend(dist.get_metadata_lines('dependency_links.txt'))
+
+        pip_command = PipCommand()
+        index_opts = cmdoptions.make_option_group(
+            index_group, pip_command.parser
+        )
+        cmd_opts = pip_command.cmd_opts
+        pip_command.parser.insert_option_group(0, index_opts)
+        pip_command.parser.insert_option_group(0, cmd_opts)
+        pip_args = prepare_pip_source_args(self.sources, [])
+        pip_options, _ = pip_command.parser.parse_args(pip_args)
+        pip_options.cache_dir = PIPENV_CACHE_DIR
+        pip_options.pre = self.settings.get("pre", False)
+        with pip_command._build_session(pip_options) as session:
+            finder = PackageFinder(
+                find_links=pip_options.find_links,
+                index_urls=index_urls, allow_all_prereleases=pip_options.pre,
+                trusted_hosts=pip_options.trusted_hosts,
+                process_dependency_links=pip_options.process_dependency_links,
+                session=session
+            )
+            finder.add_dependency_links(dependency_links)
+
+            for dist in packages:
+                typ = 'unknown'
+                all_candidates = finder.find_all_candidates(dist.key)
+                if not pip_options.pre:
+                    # Remove prereleases
+                    all_candidates = [
+                        candidate for candidate in all_candidates
+                        if not candidate.version.is_prerelease
+                    ]
+
+                if not all_candidates:
+                    continue
+                best_candidate = max(all_candidates, key=finder._candidate_sort_key)
+                remote_version = best_candidate.version
+                if best_candidate.location.is_wheel:
+                    typ = 'wheel'
+                else:
+                    typ = 'sdist'
+                # This is dirty but makes the rest of the code much cleaner
+                dist.latest_version = remote_version
+                dist.latest_filetype = typ
+                yield dist
+
+    def get_outdated_packages(self):
+        return [
+            pkg for pkg in self.get_package_info()
+            if pkg.latest_version._version > pkg.parsed_version._version
+        ]
 
     @classmethod
     def _sanitize(cls, name):
@@ -330,7 +449,7 @@ class Project(object):
         #   In-project venv
         #   "Proper" path casing (on non-case-sensitive filesystems).
         if (
-            fnmatch.fnmatch('A', 'a')
+            fnmatch.fnmatch("A", "a")
             or self.is_venv_in_project()
             or get_workon_home().joinpath(venv_name).exists()
         ):
@@ -365,7 +484,7 @@ class Project(object):
         if PIPENV_VIRTUALENV:
             return PIPENV_VIRTUALENV
 
-        if not self._virtualenv_location:   # Use cached version, if available.
+        if not self._virtualenv_location:  # Use cached version, if available.
             assert self.project_directory, "project not created"
             self._virtualenv_location = self.get_location_for_virtualenv()
         return self._virtualenv_location
@@ -376,7 +495,7 @@ class Project(object):
             loc = os.sep.join([self.virtualenv_location, "src"])
         else:
             loc = os.sep.join([self.project_directory, "src"])
-        mkdir_p(loc)
+        vistir.path.mkdir_p(loc)
         return loc
 
     @property
@@ -385,13 +504,13 @@ class Project(object):
             loc = os.sep.join([self.virtualenv_location, "downloads"])
             self._download_location = loc
         # Create the directory, if it doesn't exist.
-        mkdir_p(self._download_location)
+        vistir.path.mkdir_p(self._download_location)
         return self._download_location
 
     @property
     def proper_names_db_path(self):
         if self._proper_names_db_path is None:
-            self._proper_names_db_path = Path(
+            self._proper_names_db_path = vistir.compat.Path(
                 self.virtualenv_location, "pipenv-proper-names.txt"
             )
         self._proper_names_db_path.touch()  # Ensure the file exists.
@@ -451,12 +570,6 @@ class Project(object):
 
         return contents
 
-    @property
-    def pased_pure_pipfile(self):
-        contents = self.read_pipfile()
-
-        return self._parse_pipfile(contents)
-
     def clear_pipfile_cache(self):
         """Clear pipfile cache (e.g., so we can mutate parsed pipfile)"""
         _pipfile_cache.clear()
@@ -471,14 +584,15 @@ class Project(object):
                     # Convert things to inline tables — fancy :)
                     if hasattr(data[section][package], "keys"):
                         _data = data[section][package]
-                        data[section][package] = toml._get_empty_inline_table(dict)
+                        data[section][package] = toml.TomlDecoder().get_empty_inline_table()
                         data[section][package].update(_data)
+            toml_encoder = toml.TomlEncoder(preserve=True)
             # We lose comments here, but it's for the best.)
             try:
-                return contoml.loads(toml.dumps(data, preserve=True))
+                return contoml.loads(toml.dumps(data, encoder=toml_encoder))
 
             except RuntimeError:
-                return toml.loads(toml.dumps(data, preserve=True))
+                return toml.loads(toml.dumps(data, encoder=toml_encoder))
 
         else:
             # Fallback to toml parser, for large files.
@@ -533,6 +647,12 @@ class Project(object):
                 lockfile[section][norm_key] = lock_section.pop(key)
         return lockfile
 
+    @property
+    def _pipfile(self):
+        from .vendor.requirementslib.models.pipfile import Pipfile as ReqLibPipfile
+        pf = ReqLibPipfile.load(self.pipfile_location)
+        return pf
+
     @property
     def lockfile_location(self):
         return "{0}.lock".format(self.pipfile_location)
@@ -615,8 +735,9 @@ class Project(object):
 
     def create_pipfile(self, python=None):
         """Creates the Pipfile, filled with juicy defaults."""
-        from .patched.notpip._internal import ConfigOptionParser
-        from .patched.notpip._internal.cmdoptions import make_option_group, index_group
+        from .vendor.pip_shims.shims import (
+            ConfigOptionParser, make_option_group, index_group
+        )
 
         config_parser = ConfigOptionParser(name=self.name)
         config_parser.add_option_group(make_option_group(index_group, config_parser))
@@ -655,6 +776,54 @@ class Project(object):
             data[u"requires"] = {"python_version": version[: len("2.7")]}
         self.write_toml(data, "Pipfile")
 
+    def get_or_create_lockfile(self):
+        from requirementslib.models.lockfile import Lockfile as Req_Lockfile
+        lockfile = None
+        try:
+            lockfile = Req_Lockfile.load(self.lockfile_location)
+        except OSError:
+            lockfile = Req_Lockfile(self.lockfile_content)
+            return lockfile
+        else:
+            if lockfile._lockfile is not None:
+                return lockfile
+            if self.lockfile_exists and self.lockfile_content:
+                from .vendor.plette.lockfiles import Lockfile
+                lockfile_dict = self.lockfile_content.copy()
+                sources = lockfile_dict["_meta"].get("sources", [])
+                if not sources:
+                    sources = self.pipfile_sources
+                elif not isinstance(sources, list):
+                    sources = [sources,]
+                lockfile_dict["_meta"]["sources"] = [
+                    {
+                        "name": s["name"],
+                        "url": s["url"],
+                        "verify_ssl": (
+                            s["verify_ssl"] if isinstance(s["verify_ssl"], bool) else (
+                                True if s["verify_ssl"].lower() == "true" else False
+                            )
+                        )
+                    } for s in sources
+                ]
+                _created_lockfile = Lockfile(lockfile_dict)
+                lockfile._lockfile = lockfile.projectfile.model = _created_lockfile
+                return lockfile
+            elif self.pipfile_exists:
+                from .vendor.plette.lockfiles import Lockfile, PIPFILE_SPEC_CURRENT
+                lockfile_dict = {
+                    "_meta": {
+                        "hash": {"sha256": self.calculate_pipfile_hash()},
+                        "pipfile-spec": PIPFILE_SPEC_CURRENT,
+                        "sources": self.pipfile_sources,
+                        "requires": self.parsed_pipfile.get("requires", {})
+                    },
+                    "default": self._lockfile["default"].copy(),
+                    "develop": self._lockfile["develop"].copy()
+                }
+                lockfile._lockfile = Lockfile(lockfile_dict)
+                return lockfile
+
     def write_toml(self, data, path=None):
         """Writes the given data structure out as TOML."""
         if path is None:
@@ -667,11 +836,14 @@ class Project(object):
                     # Convert things to inline tables — fancy :)
                     if hasattr(data[section][package], "keys"):
                         _data = data[section][package]
-                        data[section][package] = toml._get_empty_inline_table(dict)
+                        data[section][package] = toml.TomlDecoder().get_empty_inline_table()
                         data[section][package].update(_data)
             formatted_data = toml.dumps(data).rstrip()
 
-        if Path(path).absolute() == Path(self.pipfile_location).absolute():
+        if (
+            vistir.compat.Path(path).absolute()
+            == vistir.compat.Path(self.pipfile_location).absolute()
+        ):
             newlines = self._pipfile_newlines
         else:
             newlines = DEFAULT_NEWLINES
@@ -685,11 +857,10 @@ class Project(object):
         """Write out the lockfile.
         """
         s = self._lockfile_encoder.encode(content)
-        open_kwargs = {
-            'newline': self._lockfile_newlines,
-            'encoding': 'utf-8',
-        }
-        with atomic_open_for_write(self.lockfile_location, **open_kwargs) as f:
+        open_kwargs = {"newline": self._lockfile_newlines, "encoding": "utf-8"}
+        with vistir.contextmanagers.atomic_open_for_write(
+            self.lockfile_location, **open_kwargs
+        ) as f:
             f.write(s)
             # Write newline at end of document. GH-319.
             # Only need '\n' here; the file object handles the rest.
@@ -766,9 +937,50 @@ class Project(object):
         name = self.get_package_name_in_pipfile(package_name, dev)
         key = "dev-packages" if dev else "packages"
         p = self.parsed_pipfile
-        if name:
+        lines = [l for l in p[key].serialized().splitlines()]
+        if not any(line.startswith("#") for line in lines) and name:
             del p[key][name]
             self.write_toml(p)
+        else:
+            p = self._pipfile
+            del p[key][name]
+            p.write()
+
+    def remove_packages_from_pipfile(self, packages):
+        p = self._pipfile
+        parsed = self.parsed_pipfile
+        packages = [pep423_name(pkg) for pkg in packages]
+        deleted_pkgs = []
+        has_comments_as_lines = False
+        for section in ("dev-packages", "packages"):
+            pipfile_section = self.parsed_pipfile.get(section, {})
+            lines = [
+                l for l in parsed[section].serialized().splitlines()
+                if section in parsed.keys()
+            ]
+            pipfile_packages = [
+                pkg_name for pkg_name in pipfile_section.keys()
+                if pep423_name(pkg_name) in packages
+            ]
+            # The normal toml parser can't handle deleting packages with preceding newlines
+            is_dev = section == "dev-packages"
+            if any(line.startswith("#") for line in lines):
+                has_comments_as_lines = True
+                for pkg in pipfile_packages:
+                    pkg_name = self.get_package_name_in_pipfile(pkg, dev=is_dev)
+                    deleted_pkgs.append(pkg)
+                    del p.pipfile[section][pkg_name]
+            # However the alternative parser can't handle inline comment preservation
+            else:
+                for pkg in pipfile_packages:
+                    pkg_name = self.get_package_name_in_pipfile(pkg, dev=is_dev)
+                    deleted_pkgs.append(pkg)
+                    del parsed[section][pkg_name]
+        if deleted_pkgs:
+            if has_comments_as_lines:
+                p.write()
+            else:
+                self.write_toml(parsed)
 
     def add_package_to_pipfile(self, package, dev=False):
         from .vendor.requirementslib import Requirement
@@ -792,11 +1004,31 @@ class Project(object):
         # Write Pipfile.
         self.write_toml(p)
 
-    def add_index_to_pipfile(self, index):
+    def src_name_from_url(self, index_url):
+        name, _, tld_guess = six.moves.urllib.parse.urlsplit(index_url).netloc.rpartition(
+            "."
+        )
+        src_name = name.replace(".", "")
+        try:
+            self.get_source(name=src_name)
+        except SourceNotFound:
+            name = src_name
+        else:
+            from random import randint
+            name = "{0}-{1}".format(src_name, randint(1, 1000))
+        return name
+
+    def add_index_to_pipfile(self, index, verify_ssl=True):
         """Adds a given index to the Pipfile."""
         # Read and append Pipfile.
         p = self.parsed_pipfile
-        source = {"url": index, "verify_ssl": True}
+        try:
+            self.get_source(url=index)
+        except SourceNotFound:
+            source = {"url": index, "verify_ssl": verify_ssl}
+        else:
+            return
+        source["name"] = self.src_name_from_url(index)
         # Add the package to the group.
         if "source" not in p:
             p["source"] = [source]
@@ -810,7 +1042,7 @@ class Project(object):
             self.write_toml(self.parsed_pipfile)
 
     def load_lockfile(self, expand_env_vars=True):
-        with io.open(self.lockfile_location, encoding='utf-8') as lock:
+        with io.open(self.lockfile_location, encoding="utf-8") as lock:
             j = json.load(lock)
             self._lockfile_newlines = preferred_newlines(lock)
         # lockfile is just a string
@@ -877,3 +1109,91 @@ class Project(object):
                 del section[dep]
         # Return whether or not values have been changed.
         return changed_values
+
+    @property
+    def py_version(self):
+        py_path = self.which("python")
+        version = python_version(py_path)
+        return version
+
+    @property
+    def _pyversion(self):
+        include_dir = vistir.compat.Path(self.virtualenv_location) / "include"
+        python_path = next((x for x in include_dir.iterdir() if x.name.startswith("python")), None)
+        if python_path:
+            py_version = python_path.name.replace("python", "")
+            py_version_short, abiflags = py_version[:3], py_version[3:]
+            return {"py_version_short": py_version_short, "abiflags": abiflags}
+        return {}
+
+    @property
+    def env_paths(self):
+        location = self.virtualenv_location if self.virtualenv_location else sys.prefix
+        prefix = vistir.compat.Path(location)
+        import importlib
+        py_version = tuple([int(v) for v in self.py_version.split(".")])
+        try:
+            with sys_version(py_version):
+                _virtualenv = importlib.import_module("virtualenv")
+        except ImportError:
+            with vistir.contextmanagers.temp_path():
+                from string import Formatter
+                formatter = Formatter()
+                import sysconfig
+                if getattr(sys, "real_prefix", None):
+                    scheme = sysconfig._get_default_scheme()
+                    sysconfig._INSTALL_SCHEMES["posix_prefix"]["purelib"]
+                    if not scheme:
+                        scheme = "posix_prefix" if not sys.platform == "win32" else "nt"
+                    is_purelib = "purelib" in sysconfig._INSTALL_SCHEMES[scheme]
+                    lib_key = "purelib" if is_purelib else "platlib"
+                    lib = sysconfig._INSTALL_SCHEMES[scheme][lib_key]
+                    fields = [field for _, field, _, _ in formatter.parse() if field]
+                    config = {
+                        "py_version_short": self._pyversion,
+                    }
+                    for field in fields:
+                        if field not in config:
+                            config[field] = prefix
+                    sys.path = [
+                        os.path.join(sysconfig._INSTALL_SCHEMES[scheme][lib_key], "site-packages"),
+                    ] + sys.path
+                    with sys_version(py_version):
+                        six.reload_module(importlib)
+                        _virtualenv = importlib.import_module("virtualenv")
+        with sys_version(py_version):
+            home, lib, inc, bin_ = _virtualenv.path_locations(prefix.absolute().as_posix())
+        paths = {
+            "lib": lib,
+            "include": inc,
+            "scripts": bin_,
+            "purelib": lib,
+            "prefix": home,
+            "base": home
+        }
+        return paths
+
+    @cached_property
+    def finders(self):
+        from .vendor.pythonfinder import Finder
+        scripts_dirname = "Scripts" if os.name == "nt" else "bin"
+        scripts_dir = os.path.join(self.virtualenv_location, scripts_dirname)
+        finders = [
+            Finder(path=scripts_dir, global_search=gs, system=False)
+            for gs in (False, True)
+        ]
+        return finders
+
+    @property
+    def finder(self):
+        return next(iter(self.finders), None)
+
+    def which(self, search, as_path=True):
+        find = operator.methodcaller("which", search)
+        result = next(iter(filter(None, (find(finder) for finder in self.finders))), None)
+        if not result:
+            result = self._which(search)
+        else:
+            if as_path:
+                result = str(result.path)
+        return result
diff --git a/pipenv/resolver.py b/pipenv/resolver.py
index 6526d990..9ef46878 100644
--- a/pipenv/resolver.py
+++ b/pipenv/resolver.py
@@ -3,57 +3,52 @@ import sys
 import json
 import logging
 
-os.environ["PIP_PYTHON_PATH"] = sys.executable
+os.environ["PIP_PYTHON_PATH"] = str(sys.executable)
 
 
 def _patch_path():
+    import site
     pipenv_libdir = os.path.dirname(os.path.abspath(__file__))
+    pipenv_site_dir = os.path.dirname(pipenv_libdir)
+    site.addsitedir(pipenv_site_dir)
     for _dir in ("vendor", "patched"):
         sys.path.insert(0, os.path.join(pipenv_libdir, _dir))
-    site_packages_dir = os.path.dirname(pipenv_libdir)
-    if site_packages_dir not in sys.path:
-        sys.path.append(site_packages_dir)
+
+
+def get_parser():
+    from argparse import ArgumentParser
+    parser = ArgumentParser("pipenv-resolver")
+    parser.add_argument("--pre", action="store_true", default=False)
+    parser.add_argument("--clear", action="store_true", default=False)
+    parser.add_argument("--verbose", "-v", action="count", default=False)
+    parser.add_argument("--debug", action="store_true", default=False)
+    parser.add_argument("--system", action="store_true", default=False)
+    parser.add_argument("--requirements-dir", metavar="requirements_dir", action="store",
+                            default=os.environ.get("PIPENV_REQ_DIR"))
+    parser.add_argument("packages", nargs="*")
+    return parser
 
 
 def which(*args, **kwargs):
     return sys.executable
 
 
-def main():
-    do_pre = "--pre" in " ".join(sys.argv)
-    do_clear = "--clear" in " ".join(sys.argv)
-    is_verbose = "--verbose" in " ".join(sys.argv)
-    is_debug = "--debug" in " ".join(sys.argv)
-    system = "--system" in " ".join(sys.argv)
-    new_sys_argv = []
-    for v in sys.argv:
-        if v.startswith("--"):
-            continue
-
-        else:
-            new_sys_argv.append(v)
-    sys.argv = new_sys_argv
-
-    os.environ["PIP_PYTHON_VERSION"] = ".".join([str(s) for s in sys.version_info[:3]])
-    os.environ["PIP_PYTHON_PATH"] = sys.executable
-
-    verbosity = int(os.environ.get("PIPENV_VERBOSITY", 0))
-    if is_debug:
-        verbosity = max(verbosity, 2)
-    elif is_verbose:
-        verbosity = max(verbosity, 1)
-    if verbosity > 1:   # Shit's getting real at this point.
+def handle_parsed_args(parsed):
+    if parsed.debug:
+        parsed.verbose = max(parsed.verbose, 2)
+    if parsed.verbose > 1:
         logging.getLogger("notpip").setLevel(logging.DEBUG)
-    elif verbosity > 0:
+    elif parsed.verbose > 0:
         logging.getLogger("notpip").setLevel(logging.INFO)
-
     if "PIPENV_PACKAGES" in os.environ:
-        packages = os.environ["PIPENV_PACKAGES"].strip().split("\n")
-    else:
-        packages = sys.argv[1:]
-        for i, package in enumerate(packages):
-            if package.startswith("--"):
-                del packages[i]
+        parsed.packages += os.environ.get("PIPENV_PACKAGES", "").strip().split("\n")
+    return parsed
+
+
+def _main(pre, clear, verbose, system, requirements_dir, packages):
+    os.environ["PIP_PYTHON_VERSION"] = ".".join([str(s) for s in sys.version_info[:3]])
+    os.environ["PIP_PYTHON_PATH"] = str(sys.executable)
+
     from pipenv.utils import create_mirror_source, resolve_deps, replace_pypi_sources
 
     pypi_mirror_source = (
@@ -62,7 +57,7 @@ def main():
         else None
     )
 
-    def resolve(packages, pre, project, sources, clear, system):
+    def resolve(packages, pre, project, sources, clear, system, requirements_dir=None):
         return resolve_deps(
             packages,
             which,
@@ -71,23 +66,23 @@ def main():
             sources=sources,
             clear=clear,
             allow_global=system,
+            req_dir=requirements_dir
         )
 
     from pipenv.core import project
-
     sources = (
         replace_pypi_sources(project.pipfile_sources, pypi_mirror_source)
         if pypi_mirror_source
         else project.pipfile_sources
     )
-    print("using sources: %s" % sources)
     results = resolve(
         packages,
-        pre=do_pre,
+        pre=pre,
         project=project,
         sources=sources,
-        clear=do_clear,
+        clear=clear,
         system=system,
+        requirements_dir=requirements_dir,
     )
     print("RESULTS:")
     if results:
@@ -96,6 +91,31 @@ def main():
         print(json.dumps([]))
 
 
+def main():
+    _patch_path()
+    import warnings
+    from pipenv.vendor.vistir.compat import ResourceWarning
+    warnings.simplefilter("ignore", category=ResourceWarning)
+    import io
+    import six
+    if six.PY3:
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer,encoding='utf8')
+        sys.stderr = io.TextIOWrapper(sys.stderr.buffer,encoding='utf8')
+    else:
+        from pipenv._compat import force_encoding
+        force_encoding()
+    os.environ["PIP_DISABLE_PIP_VERSION_CHECK"] = str("1")
+    os.environ["PYTHONIOENCODING"] = str("utf-8")
+    parser = get_parser()
+    parsed, remaining = parser.parse_known_args()
+    # sys.argv = remaining
+    parsed = handle_parsed_args(parsed)
+    _main(parsed.pre, parsed.clear, parsed.verbose, parsed.system,
+             parsed.requirements_dir, parsed.packages)
+
+
 if __name__ == "__main__":
     _patch_path()
+    from pipenv.vendor import colorama
+    colorama.init()
     main()
diff --git a/pipenv/shells.py b/pipenv/shells.py
index 70b236ea..352c01f4 100644
--- a/pipenv/shells.py
+++ b/pipenv/shells.py
@@ -5,9 +5,9 @@ import signal
 import subprocess
 import sys
 
-from ._compat import get_terminal_size, Path
 from .environments import PIPENV_SHELL_EXPLICIT, PIPENV_SHELL, PIPENV_EMULATOR
-from .utils import temp_environ
+from .vendor.vistir.compat import get_terminal_size, Path
+from .vendor.vistir.contextmanagers import temp_environ
 from .vendor import shellingham
 
 
diff --git a/pipenv/test_script.py b/pipenv/test_script.py
new file mode 100644
index 00000000..d599ded6
--- /dev/null
+++ b/pipenv/test_script.py
@@ -0,0 +1,32 @@
+# -*- coding=utf-8 -*-
+
+import os
+import sys
+
+
+def _patch_path():
+    import site
+    pipenv_libdir = os.path.dirname(os.path.abspath(__file__))
+    pipenv_site_dir = os.path.dirname(pipenv_libdir)
+    site.addsitedir(pipenv_site_dir)
+    for _dir in ("vendor", "patched"):
+        sys.path.insert(0, os.path.join(pipenv_libdir, _dir))
+
+
+def test_install():
+    from pipenv.vendor.vistir.contextmanagers import cd
+    from pipenv.vendor.click.testing import CliRunner
+    runner = CliRunner()
+    with cd("/tmp/test"):
+        from pipenv.core import do_lock
+        locked = do_lock(system=False, clear=False, pre=False, keep_outdated=False,
+                            write=True, pypi_mirror=None)
+        # result = runner.invoke(cli, ["lock", "--verbose"])
+        # print(result.output)
+        # print(result.exit_code)
+        print(locked)
+
+
+if __name__ == "__main__":
+    _patch_path()
+    test_install()
diff --git a/pipenv/utils.py b/pipenv/utils.py
index b7295c29..33e930d6 100644
--- a/pipenv/utils.py
+++ b/pipenv/utils.py
@@ -14,6 +14,12 @@ import warnings
 
 from click import echo as click_echo
 from first import first
+from vistir.misc import fs_str
+
+six.add_move(six.MovedAttribute("Mapping", "collections", "collections.abc"))
+from six.moves import Mapping
+
+from vistir.compat import ResourceWarning
 
 try:
     from weakref import finalize
@@ -32,28 +38,13 @@ except ImportError:
 
 logging.basicConfig(level=logging.ERROR)
 
-from time import time
-
-try:
-    from urllib.parse import urlparse
-except ImportError:
-    from urlparse import urlparse
-
 from distutils.spawn import find_executable
 from contextlib import contextmanager
 from . import environments
 from .pep508checker import lookup
-from .environments import PIPENV_MAX_ROUNDS, PIPENV_CACHE_DIR, PIPENV_MAX_RETRIES
 
-try:
-    from collections.abc import Mapping
-except ImportError:
-    from collections import Mapping
-
-if six.PY2:
-
-    class ResourceWarning(Warning):
-        pass
+from six.moves.urllib.parse import urlparse
+from urllib3 import util as urllib3_util
 
 
 specifiers = [k for k in lookup.keys()]
@@ -71,7 +62,9 @@ def _get_requests_session():
     import requests
 
     requests_session = requests.Session()
-    adapter = requests.adapters.HTTPAdapter(max_retries=PIPENV_MAX_RETRIES)
+    adapter = requests.adapters.HTTPAdapter(
+        max_retries=environments.PIPENV_MAX_RETRIES
+    )
     requests_session.mount("https://pypi.org/pypi", adapter)
     return requests_session
 
@@ -133,20 +126,14 @@ def parse_python_version(output):
 
 
 def python_version(path_to_python):
-    import delegator
+    from .vendor.pythonfinder.utils import get_python_version
 
     if not path_to_python:
         return None
     try:
-        c = delegator.run([path_to_python, "--version"], block=False)
+        version = get_python_version(path_to_python)
     except Exception:
         return None
-    c.block()
-    version = parse_python_version(c.out.strip() or c.err.strip())
-    try:
-        version = u"{major}.{minor}.{micro}".format(**version)
-    except TypeError:
-        return None
     return version
 
 
@@ -200,7 +187,7 @@ def prepare_pip_source_args(sources, pip_args=None):
         # Trust the host if it's not verified.
         if not sources[0].get("verify_ssl", True):
             pip_args.extend(
-                ["--trusted-host", urlparse(sources[0]["url"]).hostname]
+                ["--trusted-host", urllib3_util.parse_url(sources[0]["url"]).host]
             )
         # Add additional sources as extra indexes.
         if len(sources) > 1:
@@ -209,7 +196,7 @@ def prepare_pip_source_args(sources, pip_args=None):
                 # Trust the host if it's not verified.
                 if not source.get("verify_ssl", True):
                     pip_args.extend(
-                        ["--trusted-host", urlparse(source["url"]).hostname]
+                        ["--trusted-host", urllib3_util.parse_url(source["url"]).host]
                     )
     return pip_args
 
@@ -224,34 +211,34 @@ def actually_resolve_deps(
     pre,
     req_dir=None,
 ):
-    from .patched.notpip._internal import basecommand
-    from .patched.notpip._internal.req import parse_requirements
-    from .patched.notpip._internal.exceptions import DistributionNotFound
-    from .patched.notpip._vendor.requests.exceptions import HTTPError
+    from .vendor.pip_shims.shims import (
+        Command, parse_requirements, DistributionNotFound
+    )
+    from .vendor.requests.exceptions import HTTPError
     from pipenv.patched.piptools.resolver import Resolver
     from pipenv.patched.piptools.repositories.pypi import PyPIRepository
     from pipenv.patched.piptools.scripts.compile import get_pip_command
     from pipenv.patched.piptools import logging as piptools_logging
     from pipenv.patched.piptools.exceptions import NoCandidateFound
-    from .vendor.requirementslib import Requirement
-    from ._compat import TemporaryDirectory, NamedTemporaryFile
+    from .vendor.requirementslib.models.requirements import Requirement
+    from .vendor.vistir.path import create_tracked_tempdir, create_tracked_tempfile
 
-    class PipCommand(basecommand.Command):
+    class PipCommand(Command):
         """Needed for pip-tools."""
 
         name = "PipCommand"
 
     constraints = []
-    cleanup_req_dir = False
     if not req_dir:
-        req_dir = TemporaryDirectory(suffix="-requirements", prefix="pipenv-")
-        cleanup_req_dir = True
+        req_dir = create_tracked_tempdir(suffix="-requirements", prefix="pipenv-")
     for dep in deps:
         if not dep:
             continue
         url = None
-        if " -i " in dep:
-            dep, url = dep.split(" -i ")
+        indexes, trusted_hosts, remainder = parse_indexes(dep)
+        if indexes:
+            url = indexes[0]
+        dep = " ".join(remainder)
         req = Requirement.from_line(dep)
 
         # extra_constraints = []
@@ -271,26 +258,26 @@ def actually_resolve_deps(
     if sources:
         pip_args = prepare_pip_source_args(sources, pip_args)
     if environments.is_verbose():
-        print("Using pip: {0}".format(" ".join(pip_args)))
-    with NamedTemporaryFile(
+        click_echo(crayons.blue("Using pip: {0}".format(" ".join(pip_args))), err=True)
+    constraints_file = create_tracked_tempfile(
         mode="w",
         prefix="pipenv-",
         suffix="-constraints.txt",
-        dir=req_dir.name,
+        dir=req_dir,
         delete=False,
-    ) as f:
-        if sources:
-            requirementstxt_sources = " ".join(pip_args) if pip_args else ""
-            requirementstxt_sources = requirementstxt_sources.replace(" --", "\n--")
-            f.write(u"{0}\n".format(requirementstxt_sources))
-        f.write(u"\n".join([_constraint for _constraint in constraints]))
-        constraints_file = f.name
+    )
+    if sources:
+        requirementstxt_sources = " ".join(pip_args) if pip_args else ""
+        requirementstxt_sources = requirementstxt_sources.replace(" --", "\n--")
+    constraints_file.write(u"{0}\n".format(requirementstxt_sources))
+    constraints_file.write(u"\n".join([_constraint for _constraint in constraints]))
+    constraints_file.close()
     pip_options, _ = pip_command.parser.parse_args(pip_args)
-    pip_options.cache_dir = PIPENV_CACHE_DIR
+    pip_options.cache_dir = environments.PIPENV_CACHE_DIR
     session = pip_command._build_session(pip_options)
     pypi = PyPIRepository(pip_options=pip_options, use_json=False, session=session)
     constraints = parse_requirements(
-        constraints_file, finder=pypi.finder, session=pypi.session, options=pip_options
+        constraints_file.name, finder=pypi.finder, session=pypi.session, options=pip_options
     )
     constraints = [c for c in constraints]
     if environments.is_verbose():
@@ -303,7 +290,7 @@ def actually_resolve_deps(
     # pre-resolve instead of iterating to avoid asking pypi for hashes of editable packages
     hashes = None
     try:
-        results = resolver.resolve(max_rounds=PIPENV_MAX_ROUNDS)
+        results = resolver.resolve(max_rounds=environments.PIPENV_MAX_ROUNDS)
         hashes = resolver.resolve_hashes(results)
         resolved_tree.update(results)
     except (NoCandidateFound, DistributionNotFound, HTTPError) as e:
@@ -328,13 +315,9 @@ def actually_resolve_deps(
             click_echo(
                 crayons.blue(
                     "Please check your version specifier and version number. See PEP440 for more information."
-                )
+                ), err=True
             )
-        if cleanup_req_dir:
-            req_dir.cleanup()
         raise RuntimeError
-    if cleanup_req_dir:
-        req_dir.cleanup()
     return (resolved_tree, hashes, markers_lookup, resolver)
 
 
@@ -347,42 +330,81 @@ def venv_resolve_deps(
     allow_global=False,
     pypi_mirror=None,
 ):
+    from .vendor.vistir.misc import fs_str
+    from .vendor.vistir.compat import Path, to_native_string, JSONDecodeError
+    from .vendor.vistir.path import create_tracked_tempdir
+    from .cmdparse import Script
+    from .core import spinner
+    from .vendor.pexpect.exceptions import EOF, TIMEOUT
     from .vendor import delegator
     from . import resolver
+    from ._compat import decode_output
     import json
 
     if not deps:
         return []
-    resolver = escape_grouped_arguments(resolver.__file__.rstrip("co"))
-    cmd = "{0} {1} {2} {3} {4}".format(
-        escape_grouped_arguments(which("python", allow_global=allow_global)),
-        resolver,
-        "--pre" if pre else "",
-        "--clear" if clear else "",
-        "--system" if allow_global else "",
-    )
+
+    req_dir = create_tracked_tempdir(prefix="pipenv", suffix="requirements")
+    cmd = [
+        which("python", allow_global=allow_global),
+        Path(resolver.__file__.rstrip("co")).as_posix()
+    ]
+    if pre:
+        cmd.append("--pre")
+    if clear:
+        cmd.append("--clear")
+    if allow_global:
+        cmd.append("--system")
     with temp_environ():
         os.environ = {fs_str(k): fs_str(val) for k, val in os.environ.items()}
         os.environ["PIPENV_PACKAGES"] = str("\n".join(deps))
         if pypi_mirror:
             os.environ["PIPENV_PYPI_MIRROR"] = str(pypi_mirror)
         os.environ["PIPENV_VERBOSITY"] = str(environments.PIPENV_VERBOSITY)
-        c = delegator.run(cmd, block=True)
-    try:
-        assert c.return_code == 0
-    except AssertionError:
-        if environments.is_verbose():
-            click_echo(c.out, err=True)
-            click_echo(c.err, err=True)
-        else:
-            click_echo(c.err[(int(len(c.err) / 2) - 1):], err=True)
-        sys.exit(c.return_code)
+        os.environ["PIPENV_REQ_DIR"] = fs_str(req_dir)
+        os.environ["PIP_NO_INPUT"] = fs_str("1")
+        out = to_native_string("")
+        EOF.__module__ = "pexpect.exceptions"
+        with spinner(text=fs_str("Locking..."), spinner_name=environments.PIPENV_SPINNER,
+                nospin=environments.PIPENV_NOSPIN) as sp:
+            c = delegator.run(Script.parse(cmd).cmdify(), block=False, env=os.environ.copy())
+            _out = decode_output("")
+            result = None
+            while True:
+                try:
+                    result = c.expect(u"\n", timeout=environments.PIPENV_TIMEOUT)
+                except (EOF, TIMEOUT):
+                    pass
+                if result is None:
+                    break
+                _out = c.subprocess.before
+                if _out is not None:
+                    _out = decode_output("{0}".format(_out))
+                    out += _out
+                    sp.text = to_native_string("{0}".format(_out[:100]))
+                if environments.is_verbose():
+                    if _out is not None:
+                        sp._hide_cursor()
+                        sp.write(_out.rstrip())
+                        sp._show_cursor()
+            c.block()
+            if c.return_code != 0:
+                sp.red.fail(environments.PIPENV_SPINNER_FAIL_TEXT.format(
+                    "Locking Failed!"
+                ))
+                click_echo(c.out.strip(), err=True)
+                click_echo(c.err.strip(), err=True)
+                sys.exit(c.return_code)
+            else:
+                sp.green.ok(environments.PIPENV_SPINNER_OK_TEXT.format("Success!"))
     if environments.is_verbose():
         click_echo(c.out.split("RESULTS:")[0], err=True)
     try:
         return json.loads(c.out.split("RESULTS:")[1].strip())
 
-    except IndexError:
+    except (IndexError, JSONDecodeError):
+        click_echo(c.out.strip(), err=True)
+        click_echo(c.err.strip(), err=True)
         raise RuntimeError("There was a problem with locking.")
 
 
@@ -395,22 +417,28 @@ def resolve_deps(
     clear=False,
     pre=False,
     allow_global=False,
+    req_dir=None
 ):
     """Given a list of dependencies, return a resolved list of dependencies,
     using pip-tools -- and their hashes, using the warehouse API / pip.
     """
-    from .patched.notpip._vendor.requests.exceptions import ConnectionError
-    from ._compat import TemporaryDirectory
+    from .vendor.requests.exceptions import ConnectionError
+    from .vendor.requirementslib.models.requirements import Requirement
 
     index_lookup = {}
     markers_lookup = {}
     python_path = which("python", allow_global=allow_global)
+    if not os.environ.get("PIP_SRC"):
+        os.environ["PIP_SRC"] = project.virtualenv_src_location
     backup_python_path = sys.executable
     results = []
     if not deps:
         return results
     # First (proper) attempt:
-    req_dir = TemporaryDirectory(prefix="pipenv-", suffix="-requirements")
+    req_dir = req_dir if req_dir else os.environ.get("req_dir", None)
+    if not req_dir:
+        from .vendor.vistir.path import create_tracked_tempdir
+        req_dir = create_tracked_tempdir(prefix="pipenv-", suffix="-requirements")
     with HackedPythonVersion(python_version=python, python_path=python_path):
         try:
             resolved_tree, hashes, markers_lookup, resolver = actually_resolve_deps(
@@ -446,21 +474,14 @@ def resolve_deps(
                     req_dir=req_dir,
                 )
             except RuntimeError:
-                req_dir.cleanup()
                 sys.exit(1)
     for result in resolved_tree:
         if not result.editable:
-            name = pep423_name(result.name)
-            version = clean_pkg_version(result.specifier)
+            req = Requirement.from_ireq(result)
+            name = pep423_name(req.name)
+            version = str(req.get_version())
             index = index_lookup.get(result.name)
-            if not markers_lookup.get(result.name):
-                markers = (
-                    str(result.markers)
-                    if result.markers and "extra" not in str(result.markers)
-                    else None
-                )
-            else:
-                markers = markers_lookup.get(result.name)
+            req.index = index
             collected_hashes = []
             if result in hashes:
                 collected_hashes = list(hashes.get(result))
@@ -486,7 +507,7 @@ def resolve_deps(
                         click_echo(
                             "{0}: Error generating hash for {1}".format(
                                 crayons.red("Warning", bold=True), name
-                            )
+                            ), err=True
                         )
             # # Collect un-collectable hashes (should work with devpi).
             # try:
@@ -496,14 +517,21 @@ def resolve_deps(
             # except (ValueError, KeyError, ConnectionError, IndexError):
             #     if verbose:
             #         print('Error generating hash for {}'.format(name))
-            collected_hashes = sorted(set(collected_hashes))
-            d = {"name": name, "version": version, "hashes": collected_hashes}
-            if index:
-                d.update({"index": index})
-            if markers:
-                d.update({"markers": markers.replace('"', "'")})
-            results.append(d)
-    req_dir.cleanup()
+            req.hashes = sorted(set(collected_hashes))
+            name, _entry = req.pipfile_entry
+            entry = {}
+            if isinstance(_entry, six.string_types):
+                entry["version"] = _entry.lstrip("=")
+            else:
+                entry.update(_entry)
+                entry["version"] = version
+            entry["name"] = name
+            # if index:
+            #     d.update({"index": index})
+            if markers_lookup.get(result.name):
+                entry.update({"markers": markers_lookup.get(result.name)})
+            entry = translate_markers(entry)
+            results.append(entry)
     return results
 
 
@@ -524,22 +552,24 @@ def is_pinned(val):
     return isinstance(val, six.string_types) and val.startswith("==")
 
 
-def convert_deps_to_pip(deps, project=None, r=True, include_index=False):
+def convert_deps_to_pip(deps, project=None, r=True, include_index=True):
     """"Converts a Pipfile-formatted dependency to a pip-formatted one."""
-    from ._compat import NamedTemporaryFile
-    from .vendor.requirementslib import Requirement
+    from .vendor.requirementslib.models.requirements import Requirement
 
     dependencies = []
     for dep_name, dep in deps.items():
-        indexes = project.sources if hasattr(project, "sources") else None
+        indexes = project.sources if hasattr(project, "sources") else []
         new_dep = Requirement.from_pipfile(dep_name, dep)
+        if new_dep.index:
+            include_index = True
         req = new_dep.as_line(sources=indexes if include_index else None).strip()
         dependencies.append(req)
     if not r:
         return dependencies
 
     # Write requirements.txt to tmp directory.
-    f = NamedTemporaryFile(suffix="-requirements.txt", delete=False)
+    from .vendor.vistir.path import create_tracked_tempfile
+    f = create_tracked_tempfile(suffix="-requirements.txt", delete=False)
     f.write("\n".join(dependencies).encode("utf-8"))
     f.close()
     return f.name
@@ -608,9 +638,8 @@ def is_editable(pipfile_entry):
 
 def is_installable_file(path):
     """Determine if a path can potentially be installed"""
-    from .patched.notpip._internal.utils.misc import is_installable_dir
+    from .vendor.pip_shims.shims import is_installable_dir, is_archive_file
     from .patched.notpip._internal.utils.packaging import specifiers
-    from .patched.notpip._internal.download import is_archive_file
     from ._compat import Path
 
     if hasattr(path, "keys") and any(
@@ -662,7 +691,7 @@ def is_file(package):
 
 def pep440_version(version):
     """Normalize version to PEP 440 standards"""
-    from .patched.notpip._internal.index import parse_version
+    from .vendor.pip_shims.shims import parse_version
 
     # Use pip built-in version parser.
     return str(parse_version(version))
@@ -974,32 +1003,6 @@ def download_file(url, filename):
         f.write(r.content)
 
 
-def need_update_check():
-    """Determines whether we need to check for updates."""
-    mkdir_p(PIPENV_CACHE_DIR)
-    p = os.sep.join((PIPENV_CACHE_DIR, ".pipenv_update_check"))
-    if not os.path.exists(p):
-        return True
-
-    out_of_date_time = time() - (24 * 60 * 60)
-    if os.path.isfile(p) and os.path.getmtime(p) <= out_of_date_time:
-        return True
-
-    else:
-        return False
-
-
-def touch_update_stamp():
-    """Touches PIPENV_CACHE_DIR/.pipenv_update_check"""
-    mkdir_p(PIPENV_CACHE_DIR)
-    p = os.sep.join((PIPENV_CACHE_DIR, ".pipenv_update_check"))
-    try:
-        os.utime(p, None)
-    except OSError:
-        with open(p, "w") as fh:
-            fh.write("")
-
-
 def normalize_drive(path):
     """Normalize drive in path so they stay consistent.
 
@@ -1072,52 +1075,10 @@ def handle_remove_readonly(func, path, exc):
     raise
 
 
-@contextmanager
-def atomic_open_for_write(target, binary=False, newline=None, encoding=None):
-    """Atomically open `target` for writing.
-
-    This is based on Lektor's `atomic_open()` utility, but simplified a lot
-    to handle only writing, and skip many multi-process/thread edge cases
-    handled by Werkzeug.
-
-    How this works:
-
-    * Create a temp file (in the same directory of the actual target), and
-      yield for surrounding code to write to it.
-    * If some thing goes wrong, try to remove the temp file. The actual target
-      is not touched whatsoever.
-    * If everything goes well, close the temp file, and replace the actual
-      target with this new file.
-    """
-    from ._compat import NamedTemporaryFile
-
-    mode = "w+b" if binary else "w"
-    f = NamedTemporaryFile(
-        dir=os.path.dirname(target),
-        prefix=".__atomic-write",
-        mode=mode,
-        encoding=encoding,
-        newline=newline,
-        delete=False,
-    )
-    # set permissions to 0644
-    os.chmod(f.name, stat.S_IWUSR | stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH)
-    try:
-        yield f
-    except BaseException:
-        f.close()
-        try:
-            os.remove(f.name)
-        except OSError:
-            pass
-        raise
-    else:
-        f.close()
-        try:
-            os.remove(target)  # This is needed on Windows.
-        except OSError:
-            pass
-        os.rename(f.name, target)  # No os.replace() on Python 2.
+def escape_cmd(cmd):
+    if any(special_char in cmd for special_char in ["<", ">", "&", ".", "^", "|", "?"]):
+        cmd = '\"{0}\"'.format(cmd)
+    return cmd
 
 
 def safe_expandvars(value):
@@ -1137,7 +1098,6 @@ def extract_uri_from_vcs_dep(dep):
 
 def get_vcs_deps(
     project,
-    pip_freeze=None,
     which=None,
     clear=False,
     pre=False,
@@ -1145,9 +1105,9 @@ def get_vcs_deps(
     dev=False,
     pypi_mirror=None,
 ):
-    from ._compat import TemporaryDirectory, Path
-    import atexit
-    from .vendor.requirementslib import Requirement
+    from .vendor.vistir.compat import Path
+    from .vendor.vistir.path import create_tracked_tempdir
+    from .vendor.requirementslib.models.requirements import Requirement
 
     section = "vcs_dev_packages" if dev else "vcs_packages"
     reqs = []
@@ -1156,24 +1116,19 @@ def get_vcs_deps(
         packages = getattr(project, section)
     except AttributeError:
         return [], []
-    if os.environ.get("PIP_SRC"):
-        src_dir = Path(
-            os.environ.get("PIP_SRC", os.path.join(project.virtualenv_location, "src"))
-        )
-        src_dir.mkdir(mode=0o775, exist_ok=True)
-    else:
-        src_dir = TemporaryDirectory(prefix="pipenv-lock-dir")
-        atexit.register(src_dir.cleanup)
     for pkg_name, pkg_pipfile in packages.items():
         requirement = Requirement.from_pipfile(pkg_name, pkg_pipfile)
         name = requirement.normalized_name
         commit_hash = None
         if requirement.is_vcs:
-            with requirement.req.locked_vcs_repo(src_dir=src_dir) as repo:
-                commit_hash = repo.get_commit_hash()
-                lockfile[name] = requirement.pipfile_entry[1]
-                lockfile[name]['ref'] = commit_hash
-        reqs.append(requirement)
+            try:
+                with locked_repository(requirement) as repo:
+                    commit_hash = repo.get_commit_hash()
+                    lockfile[name] = requirement.pipfile_entry[1]
+                    lockfile[name]['ref'] = commit_hash
+                reqs.append(requirement)
+            except OSError:
+                continue
     return reqs, lockfile
 
 
@@ -1190,7 +1145,7 @@ def translate_markers(pipfile_entry):
     """
     if not isinstance(pipfile_entry, Mapping):
         raise TypeError("Entry is not a pipfile formatted mapping.")
-    from notpip._vendor.distlib.markers import DEFAULT_CONTEXT as marker_context
+    from .vendor.distlib.markers import DEFAULT_CONTEXT as marker_context
     from .vendor.packaging.markers import Marker
     from .vendor.vistir.misc import dedup
 
@@ -1200,7 +1155,9 @@ def translate_markers(pipfile_entry):
     new_pipfile = dict(pipfile_entry).copy()
     marker_set = set()
     if "markers" in new_pipfile:
-        marker_set.add(str(Marker(new_pipfile.get("markers"))))
+        marker = str(Marker(new_pipfile.pop("markers")))
+        if 'extra' not in marker:
+            marker_set.add(marker)
     for m in pipfile_markers:
         entry = "{0}".format(pipfile_entry[m])
         if m != "markers":
@@ -1256,20 +1213,6 @@ def clean_resolved_dep(dep, is_top_level=False, pipfile_entry=None):
     return {name: lockfile}
 
 
-def fs_str(string):
-    """Encodes a string into the proper filesystem encoding
-
-    Borrowed from pip-tools
-    """
-    if isinstance(string, str):
-        return string
-    assert not isinstance(string, bytes)
-    return string.encode(_fs_encoding)
-
-
-_fs_encoding = sys.getfilesystemencoding() or sys.getdefaultencoding()
-
-
 def get_workon_home():
     from ._compat import Path
 
@@ -1281,7 +1224,10 @@ def get_workon_home():
             workon_home = os.path.join(
                 os.environ.get("XDG_DATA_HOME", "~/.local/share"), "virtualenvs"
             )
-    return Path(os.path.expandvars(workon_home)).expanduser()
+    # Create directory if it does not already exist
+    expanded_path = Path(os.path.expandvars(workon_home)).expanduser()
+    mkdir_p(str(expanded_path))
+    return expanded_path
 
 
 def is_virtual_environment(path):
@@ -1304,6 +1250,22 @@ def is_virtual_environment(path):
     return False
 
 
+@contextmanager
+def locked_repository(requirement):
+    from .vendor.vistir.path import create_tracked_tempdir
+    if not requirement.is_vcs:
+        return
+    original_base = os.environ.pop("PIP_SHIMS_BASE_MODULE", None)
+    os.environ["PIP_SHIMS_BASE_MODULE"] = fs_str("pipenv.patched.notpip")
+    src_dir = create_tracked_tempdir(prefix="pipenv-", suffix="-src")
+    try:
+        with requirement.req.locked_vcs_repo(src_dir=src_dir) as repo:
+            yield repo
+    finally:
+        if original_base:
+            os.environ["PIP_SHIMS_BASE_MODULE"] = original_base
+
+
 @contextmanager
 def chdir(path):
     """Context manager to change working directories."""
@@ -1323,3 +1285,73 @@ def chdir(path):
 def looks_like_dir(path):
     seps = (sep for sep in (os.path.sep, os.path.altsep) if sep is not None)
     return any(sep in path for sep in seps)
+
+
+def parse_indexes(line):
+    from argparse import ArgumentParser
+    parser = ArgumentParser("indexes")
+    parser.add_argument("--index", "-i", "--index-url", metavar="index_url",
+                                                            action="store", nargs="?",)
+    parser.add_argument("--extra-index-url", "--extra-index", metavar="extra_indexes",
+                                                            action="append")
+    parser.add_argument("--trusted-host", metavar="trusted_hosts", action="append")
+    args, remainder = parser.parse_known_args(line.split())
+    index = [] if not args.index else [args.index,]
+    extra_indexes = [] if not args.extra_index_url else args.extra_index_url
+    indexes = index + extra_indexes
+    trusted_hosts = args.trusted_host if args.trusted_host else []
+    return indexes, trusted_hosts, remainder
+
+
+def fix_venv_site(venv_lib_dir):
+    # From https://github.com/pypa/pip/blob/master/tests/lib/venv.py#L84
+    # Prevent accidental inclusions of site packages during virtualenv operations
+    from .vendor.vistir.compat import Path
+    import compileall
+    site_py = Path(venv_lib_dir).joinpath('site.py').as_posix()
+    with open(site_py) as fp:
+        site_contents = fp.read()
+    for pattern, replace in (
+        (
+            # Ensure enabling user site does not result in adding
+            # the real site-packages' directory to `sys.path`.
+            (
+                '\ndef virtual_addsitepackages(known_paths):\n'
+            ),
+            (
+                '\ndef virtual_addsitepackages(known_paths):\n'
+                '    return known_paths\n'
+            ),
+        ),
+        (
+            # Fix sites ordering: user site must be added before system.
+            (
+                '\n    paths_in_sys = addsitepackages(paths_in_sys)'
+                '\n    paths_in_sys = addusersitepackages(paths_in_sys)\n'
+            ),
+            (
+                '\n    paths_in_sys = addusersitepackages(paths_in_sys)'
+                '\n    paths_in_sys = addsitepackages(paths_in_sys)\n'
+            ),
+        ),
+    ):
+        if pattern in site_contents and replace not in site_contents:
+            site_contents = site_contents.replace(pattern, replace)
+    with open(site_py, 'w') as fp:
+        fp.write(site_contents)
+    # Make sure bytecode is up-to-date too.
+    assert compileall.compile_file(str(site_py), quiet=1, force=True)
+
+
+@contextmanager
+def sys_version(version_tuple):
+    """
+    Set a temporary sys.version_info tuple
+
+    :param version_tuple: a fake sys.version_info tuple
+    """
+
+    old_version = sys.version_info
+    sys.version_info = version_tuple
+    yield
+    sys.version_info = old_version
diff --git a/pipenv/vendor/attr/__init__.py b/pipenv/vendor/attr/__init__.py
index 13cb6298..debfd57b 100644
--- a/pipenv/vendor/attr/__init__.py
+++ b/pipenv/vendor/attr/__init__.py
@@ -6,16 +6,24 @@ from . import converters, exceptions, filters, validators
 from ._config import get_run_validators, set_run_validators
 from ._funcs import asdict, assoc, astuple, evolve, has
 from ._make import (
-    NOTHING, Attribute, Factory, attrib, attrs, fields, fields_dict,
-    make_class, validate
+    NOTHING,
+    Attribute,
+    Factory,
+    attrib,
+    attrs,
+    fields,
+    fields_dict,
+    make_class,
+    validate,
 )
 
 
-__version__ = "18.1.0"
+__version__ = "18.2.0"
 
 __title__ = "attrs"
 __description__ = "Classes Without Boilerplate"
-__uri__ = "http://www.attrs.org/"
+__url__ = "https://www.attrs.org/"
+__uri__ = __url__
 __doc__ = __description__ + " <" + __uri__ + ">"
 
 __author__ = "Hynek Schlawack"
diff --git a/pipenv/vendor/attr/__init__.pyi b/pipenv/vendor/attr/__init__.pyi
new file mode 100644
index 00000000..492fb85e
--- /dev/null
+++ b/pipenv/vendor/attr/__init__.pyi
@@ -0,0 +1,252 @@
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    Sequence,
+    Mapping,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+# `import X as X` is required to make these public
+from . import exceptions as exceptions
+from . import filters as filters
+from . import converters as converters
+from . import validators as validators
+
+_T = TypeVar("_T")
+_C = TypeVar("_C", bound=type)
+
+_ValidatorType = Callable[[Any, Attribute, _T], Any]
+_ConverterType = Callable[[Any], _T]
+_FilterType = Callable[[Attribute, Any], bool]
+# FIXME: in reality, if multiple validators are passed they must be in a list or tuple,
+# but those are invariant and so would prevent subtypes of _ValidatorType from working
+# when passed in a list or tuple.
+_ValidatorArgType = Union[_ValidatorType[_T], Sequence[_ValidatorType[_T]]]
+
+# _make --
+
+NOTHING: object
+
+# NOTE: Factory lies about its return type to make this possible: `x: List[int] = Factory(list)`
+# Work around mypy issue #4554 in the common case by using an overload.
+@overload
+def Factory(factory: Callable[[], _T]) -> _T: ...
+@overload
+def Factory(
+    factory: Union[Callable[[Any], _T], Callable[[], _T]],
+    takes_self: bool = ...,
+) -> _T: ...
+
+class Attribute(Generic[_T]):
+    name: str
+    default: Optional[_T]
+    validator: Optional[_ValidatorType[_T]]
+    repr: bool
+    cmp: bool
+    hash: Optional[bool]
+    init: bool
+    converter: Optional[_ConverterType[_T]]
+    metadata: Dict[Any, Any]
+    type: Optional[Type[_T]]
+    kw_only: bool
+    def __lt__(self, x: Attribute) -> bool: ...
+    def __le__(self, x: Attribute) -> bool: ...
+    def __gt__(self, x: Attribute) -> bool: ...
+    def __ge__(self, x: Attribute) -> bool: ...
+
+# NOTE: We had several choices for the annotation to use for type arg:
+# 1) Type[_T]
+#   - Pros: Handles simple cases correctly
+#   - Cons: Might produce less informative errors in the case of conflicting TypeVars
+#   e.g. `attr.ib(default='bad', type=int)`
+# 2) Callable[..., _T]
+#   - Pros: Better error messages than #1 for conflicting TypeVars
+#   - Cons: Terrible error messages for validator checks.
+#   e.g. attr.ib(type=int, validator=validate_str)
+#        -> error: Cannot infer function type argument
+# 3) type (and do all of the work in the mypy plugin)
+#   - Pros: Simple here, and we could customize the plugin with our own errors.
+#   - Cons: Would need to write mypy plugin code to handle all the cases.
+# We chose option #1.
+
+# `attr` lies about its return type to make the following possible:
+#     attr()    -> Any
+#     attr(8)   -> int
+#     attr(validator=<some callable>)  -> Whatever the callable expects.
+# This makes this type of assignments possible:
+#     x: int = attr(8)
+#
+# This form catches explicit None or no default but with no other arguments returns Any.
+@overload
+def attrib(
+    default: None = ...,
+    validator: None = ...,
+    repr: bool = ...,
+    cmp: bool = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    convert: None = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: None = ...,
+    converter: None = ...,
+    factory: None = ...,
+    kw_only: bool = ...,
+) -> Any: ...
+
+# This form catches an explicit None or no default and infers the type from the other arguments.
+@overload
+def attrib(
+    default: None = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: bool = ...,
+    cmp: bool = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    convert: Optional[_ConverterType[_T]] = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: Optional[Type[_T]] = ...,
+    converter: Optional[_ConverterType[_T]] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+) -> _T: ...
+
+# This form catches an explicit default argument.
+@overload
+def attrib(
+    default: _T,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: bool = ...,
+    cmp: bool = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    convert: Optional[_ConverterType[_T]] = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: Optional[Type[_T]] = ...,
+    converter: Optional[_ConverterType[_T]] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+) -> _T: ...
+
+# This form covers type=non-Type: e.g. forward references (str), Any
+@overload
+def attrib(
+    default: Optional[_T] = ...,
+    validator: Optional[_ValidatorArgType[_T]] = ...,
+    repr: bool = ...,
+    cmp: bool = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    convert: Optional[_ConverterType[_T]] = ...,
+    metadata: Optional[Mapping[Any, Any]] = ...,
+    type: object = ...,
+    converter: Optional[_ConverterType[_T]] = ...,
+    factory: Optional[Callable[[], _T]] = ...,
+    kw_only: bool = ...,
+) -> Any: ...
+@overload
+def attrs(
+    maybe_cls: _C,
+    these: Optional[Dict[str, Any]] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: bool = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+) -> _C: ...
+@overload
+def attrs(
+    maybe_cls: None = ...,
+    these: Optional[Dict[str, Any]] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: bool = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+) -> Callable[[_C], _C]: ...
+
+# TODO: add support for returning NamedTuple from the mypy plugin
+class _Fields(Tuple[Attribute, ...]):
+    def __getattr__(self, name: str) -> Attribute: ...
+
+def fields(cls: type) -> _Fields: ...
+def fields_dict(cls: type) -> Dict[str, Attribute]: ...
+def validate(inst: Any) -> None: ...
+
+# TODO: add support for returning a proper attrs class from the mypy plugin
+# we use Any instead of _CountingAttr so that e.g. `make_class('Foo', [attr.ib()])` is valid
+def make_class(
+    name: str,
+    attrs: Union[List[str], Tuple[str, ...], Dict[str, Any]],
+    bases: Tuple[type, ...] = ...,
+    repr_ns: Optional[str] = ...,
+    repr: bool = ...,
+    cmp: bool = ...,
+    hash: Optional[bool] = ...,
+    init: bool = ...,
+    slots: bool = ...,
+    frozen: bool = ...,
+    weakref_slot: bool = ...,
+    str: bool = ...,
+    auto_attribs: bool = ...,
+    kw_only: bool = ...,
+    cache_hash: bool = ...,
+) -> type: ...
+
+# _funcs --
+
+# TODO: add support for returning TypedDict from the mypy plugin
+# FIXME: asdict/astuple do not honor their factory args.  waiting on one of these:
+# https://github.com/python/mypy/issues/4236
+# https://github.com/python/typing/issues/253
+def asdict(
+    inst: Any,
+    recurse: bool = ...,
+    filter: Optional[_FilterType] = ...,
+    dict_factory: Type[Mapping[Any, Any]] = ...,
+    retain_collection_types: bool = ...,
+) -> Dict[str, Any]: ...
+
+# TODO: add support for returning NamedTuple from the mypy plugin
+def astuple(
+    inst: Any,
+    recurse: bool = ...,
+    filter: Optional[_FilterType] = ...,
+    tuple_factory: Type[Sequence] = ...,
+    retain_collection_types: bool = ...,
+) -> Tuple[Any, ...]: ...
+def has(cls: type) -> bool: ...
+def assoc(inst: _T, **changes: Any) -> _T: ...
+def evolve(inst: _T, **changes: Any) -> _T: ...
+
+# _config --
+
+def set_run_validators(run: bool) -> None: ...
+def get_run_validators() -> bool: ...
+
+# aliases --
+
+s = attributes = attrs
+ib = attr = attrib
+dataclass = attrs  # Technically, partial(attrs, auto_attribs=True) ;)
diff --git a/pipenv/vendor/attr/_compat.py b/pipenv/vendor/attr/_compat.py
index 42a91ee5..5bb06593 100644
--- a/pipenv/vendor/attr/_compat.py
+++ b/pipenv/vendor/attr/_compat.py
@@ -14,6 +14,7 @@ if PYPY or sys.version_info[:2] >= (3, 6):
     ordered_dict = dict
 else:
     from collections import OrderedDict
+
     ordered_dict = OrderedDict
 
 
@@ -39,38 +40,45 @@ if PY2:
 
         def __setitem__(self, key, val):
             # We gently pretend we're a Python 3 mappingproxy.
-            raise TypeError("'mappingproxy' object does not support item "
-                            "assignment")
+            raise TypeError(
+                "'mappingproxy' object does not support item assignment"
+            )
 
         def update(self, _):
             # We gently pretend we're a Python 3 mappingproxy.
-            raise AttributeError("'mappingproxy' object has no attribute "
-                                 "'update'")
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'update'"
+            )
 
         def __delitem__(self, _):
             # We gently pretend we're a Python 3 mappingproxy.
-            raise TypeError("'mappingproxy' object does not support item "
-                            "deletion")
+            raise TypeError(
+                "'mappingproxy' object does not support item deletion"
+            )
 
         def clear(self):
             # We gently pretend we're a Python 3 mappingproxy.
-            raise AttributeError("'mappingproxy' object has no attribute "
-                                 "'clear'")
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'clear'"
+            )
 
         def pop(self, key, default=None):
             # We gently pretend we're a Python 3 mappingproxy.
-            raise AttributeError("'mappingproxy' object has no attribute "
-                                 "'pop'")
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'pop'"
+            )
 
         def popitem(self):
             # We gently pretend we're a Python 3 mappingproxy.
-            raise AttributeError("'mappingproxy' object has no attribute "
-                                 "'popitem'")
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'popitem'"
+            )
 
         def setdefault(self, key, default=None):
             # We gently pretend we're a Python 3 mappingproxy.
-            raise AttributeError("'mappingproxy' object has no attribute "
-                                 "'setdefault'")
+            raise AttributeError(
+                "'mappingproxy' object has no attribute 'setdefault'"
+            )
 
         def __repr__(self):
             # Override to be identical to the Python 3 version.
@@ -81,7 +89,9 @@ if PY2:
         res.data.update(d)  # We blocked update, so we have to do it like this.
         return res
 
+
 else:
+
     def isclass(klass):
         return isinstance(klass, type)
 
@@ -99,10 +109,12 @@ def import_ctypes():
     Moved into a function for testability.
     """
     import ctypes
+
     return ctypes
 
 
 if not PY2:
+
     def just_warn(*args, **kw):
         """
         We only warn on Python 3 because we are not aware of any concrete
@@ -114,7 +126,10 @@ if not PY2:
             RuntimeWarning,
             stacklevel=2,
         )
+
+
 else:
+
     def just_warn(*args, **kw):  # pragma: nocover
         """
         We only warn on Python 3 because we are not aware of any concrete
@@ -127,8 +142,10 @@ def make_set_closure_cell():
     Moved into a function for testability.
     """
     if PYPY:  # pragma: no cover
+
         def set_closure_cell(cell, value):
             cell.__setstate__((value,))
+
     else:
         try:
             ctypes = import_ctypes()
diff --git a/pipenv/vendor/attr/_funcs.py b/pipenv/vendor/attr/_funcs.py
index 798043af..b61d2394 100644
--- a/pipenv/vendor/attr/_funcs.py
+++ b/pipenv/vendor/attr/_funcs.py
@@ -7,8 +7,13 @@ from ._make import NOTHING, _obj_setattr, fields
 from .exceptions import AttrsAttributeNotFoundError
 
 
-def asdict(inst, recurse=True, filter=None, dict_factory=dict,
-           retain_collection_types=False):
+def asdict(
+    inst,
+    recurse=True,
+    filter=None,
+    dict_factory=dict,
+    retain_collection_types=False,
+):
     """
     Return the ``attrs`` attribute values of *inst* as a dict.
 
@@ -44,22 +49,32 @@ def asdict(inst, recurse=True, filter=None, dict_factory=dict,
             continue
         if recurse is True:
             if has(v.__class__):
-                rv[a.name] = asdict(v, recurse=True, filter=filter,
-                                    dict_factory=dict_factory)
+                rv[a.name] = asdict(
+                    v, True, filter, dict_factory, retain_collection_types
+                )
             elif isinstance(v, (tuple, list, set)):
                 cf = v.__class__ if retain_collection_types is True else list
-                rv[a.name] = cf([
-                    asdict(i, recurse=True, filter=filter,
-                           dict_factory=dict_factory)
-                    if has(i.__class__) else i
-                    for i in v
-                ])
+                rv[a.name] = cf(
+                    [
+                        _asdict_anything(
+                            i, filter, dict_factory, retain_collection_types
+                        )
+                        for i in v
+                    ]
+                )
             elif isinstance(v, dict):
                 df = dict_factory
-                rv[a.name] = df((
-                    asdict(kk, dict_factory=df) if has(kk.__class__) else kk,
-                    asdict(vv, dict_factory=df) if has(vv.__class__) else vv)
-                    for kk, vv in iteritems(v))
+                rv[a.name] = df(
+                    (
+                        _asdict_anything(
+                            kk, filter, df, retain_collection_types
+                        ),
+                        _asdict_anything(
+                            vv, filter, df, retain_collection_types
+                        ),
+                    )
+                    for kk, vv in iteritems(v)
+                )
             else:
                 rv[a.name] = v
         else:
@@ -67,8 +82,44 @@ def asdict(inst, recurse=True, filter=None, dict_factory=dict,
     return rv
 
 
-def astuple(inst, recurse=True, filter=None, tuple_factory=tuple,
-            retain_collection_types=False):
+def _asdict_anything(val, filter, dict_factory, retain_collection_types):
+    """
+    ``asdict`` only works on attrs instances, this works on anything.
+    """
+    if getattr(val.__class__, "__attrs_attrs__", None) is not None:
+        # Attrs class.
+        rv = asdict(val, True, filter, dict_factory, retain_collection_types)
+    elif isinstance(val, (tuple, list, set)):
+        cf = val.__class__ if retain_collection_types is True else list
+        rv = cf(
+            [
+                _asdict_anything(
+                    i, filter, dict_factory, retain_collection_types
+                )
+                for i in val
+            ]
+        )
+    elif isinstance(val, dict):
+        df = dict_factory
+        rv = df(
+            (
+                _asdict_anything(kk, filter, df, retain_collection_types),
+                _asdict_anything(vv, filter, df, retain_collection_types),
+            )
+            for kk, vv in iteritems(val)
+        )
+    else:
+        rv = val
+    return rv
+
+
+def astuple(
+    inst,
+    recurse=True,
+    filter=None,
+    tuple_factory=tuple,
+    retain_collection_types=False,
+):
     """
     Return the ``attrs`` attribute values of *inst* as a tuple.
 
@@ -104,34 +155,56 @@ def astuple(inst, recurse=True, filter=None, tuple_factory=tuple,
             continue
         if recurse is True:
             if has(v.__class__):
-                rv.append(astuple(v, recurse=True, filter=filter,
-                                  tuple_factory=tuple_factory,
-                                  retain_collection_types=retain))
+                rv.append(
+                    astuple(
+                        v,
+                        recurse=True,
+                        filter=filter,
+                        tuple_factory=tuple_factory,
+                        retain_collection_types=retain,
+                    )
+                )
             elif isinstance(v, (tuple, list, set)):
                 cf = v.__class__ if retain is True else list
-                rv.append(cf([
-                    astuple(j, recurse=True, filter=filter,
-                            tuple_factory=tuple_factory,
-                            retain_collection_types=retain)
-                    if has(j.__class__) else j
-                    for j in v
-                ]))
+                rv.append(
+                    cf(
+                        [
+                            astuple(
+                                j,
+                                recurse=True,
+                                filter=filter,
+                                tuple_factory=tuple_factory,
+                                retain_collection_types=retain,
+                            )
+                            if has(j.__class__)
+                            else j
+                            for j in v
+                        ]
+                    )
+                )
             elif isinstance(v, dict):
                 df = v.__class__ if retain is True else dict
-                rv.append(df(
+                rv.append(
+                    df(
                         (
                             astuple(
                                 kk,
                                 tuple_factory=tuple_factory,
-                                retain_collection_types=retain
-                            ) if has(kk.__class__) else kk,
+                                retain_collection_types=retain,
+                            )
+                            if has(kk.__class__)
+                            else kk,
                             astuple(
                                 vv,
                                 tuple_factory=tuple_factory,
-                                retain_collection_types=retain
-                            ) if has(vv.__class__) else vv
+                                retain_collection_types=retain,
+                            )
+                            if has(vv.__class__)
+                            else vv,
                         )
-                        for kk, vv in iteritems(v)))
+                        for kk, vv in iteritems(v)
+                    )
+                )
             else:
                 rv.append(v)
         else:
@@ -169,16 +242,21 @@ def assoc(inst, **changes):
         Use :func:`evolve` instead.
     """
     import warnings
-    warnings.warn("assoc is deprecated and will be removed after 2018/01.",
-                  DeprecationWarning, stacklevel=2)
+
+    warnings.warn(
+        "assoc is deprecated and will be removed after 2018/01.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
     new = copy.copy(inst)
     attrs = fields(inst.__class__)
     for k, v in iteritems(changes):
         a = getattr(attrs, k, NOTHING)
         if a is NOTHING:
             raise AttrsAttributeNotFoundError(
-                "{k} is not an attrs attribute on {cl}."
-                .format(k=k, cl=new.__class__)
+                "{k} is not an attrs attribute on {cl}.".format(
+                    k=k, cl=new.__class__
+                )
             )
         _obj_setattr(new, k, v)
     return new
diff --git a/pipenv/vendor/attr/_make.py b/pipenv/vendor/attr/_make.py
index fc446115..f7fd05e7 100644
--- a/pipenv/vendor/attr/_make.py
+++ b/pipenv/vendor/attr/_make.py
@@ -1,5 +1,6 @@
 from __future__ import absolute_import, division, print_function
 
+import copy
 import hashlib
 import linecache
 import sys
@@ -10,11 +11,19 @@ from operator import itemgetter
 
 from . import _config
 from ._compat import (
-    PY2, isclass, iteritems, metadata_proxy, ordered_dict, set_closure_cell
+    PY2,
+    isclass,
+    iteritems,
+    metadata_proxy,
+    ordered_dict,
+    set_closure_cell,
 )
 from .exceptions import (
-    DefaultAlreadySetError, FrozenInstanceError, NotAnAttrsClassError,
-    UnannotatedAttributeError
+    DefaultAlreadySetError,
+    FrozenInstanceError,
+    NotAnAttrsClassError,
+    PythonTooOldError,
+    UnannotatedAttributeError,
 )
 
 
@@ -22,8 +31,14 @@ from .exceptions import (
 _obj_setattr = object.__setattr__
 _init_converter_pat = "__attr_converter_{}"
 _init_factory_pat = "__attr_factory_{}"
-_tuple_property_pat = "    {attr_name} = property(itemgetter({index}))"
+_tuple_property_pat = (
+    "    {attr_name} = _attrs_property(_attrs_itemgetter({index}))"
+)
 _classvar_prefixes = ("typing.ClassVar", "t.ClassVar", "ClassVar")
+# we don't use a double-underscore prefix because that triggers
+# name mangling when trying to create a slot for the field
+# (when slots=True)
+_hash_cache_field = "_attrs_cached_hash"
 
 _empty_metadata_singleton = metadata_proxy({})
 
@@ -32,26 +47,19 @@ class _Nothing(object):
     """
     Sentinel class to indicate the lack of a value when ``None`` is ambiguous.
 
-    All instances of `_Nothing` are equal.
+    ``_Nothing`` is a singleton. There is only ever one of it.
     """
-    def __copy__(self):
-        return self
 
-    def __deepcopy__(self, _):
-        return self
+    _singleton = None
 
-    def __eq__(self, other):
-        return other.__class__ == _Nothing
-
-    def __ne__(self, other):
-        return not self == other
+    def __new__(cls):
+        if _Nothing._singleton is None:
+            _Nothing._singleton = super(_Nothing, cls).__new__(cls)
+        return _Nothing._singleton
 
     def __repr__(self):
         return "NOTHING"
 
-    def __hash__(self):
-        return 0xc0ffee
-
 
 NOTHING = _Nothing()
 """
@@ -59,10 +67,20 @@ Sentinel to indicate the lack of a value when ``None`` is ambiguous.
 """
 
 
-def attrib(default=NOTHING, validator=None,
-           repr=True, cmp=True, hash=None, init=True,
-           convert=None, metadata=None, type=None, converter=None,
-           factory=None):
+def attrib(
+    default=NOTHING,
+    validator=None,
+    repr=True,
+    cmp=True,
+    hash=None,
+    init=True,
+    convert=None,
+    metadata=None,
+    type=None,
+    converter=None,
+    factory=None,
+    kw_only=False,
+):
     """
     Create a new attribute on a class.
 
@@ -135,6 +153,13 @@ def attrib(default=NOTHING, validator=None,
         Regardless of the approach used, the type will be stored on
         ``Attribute.type``.
 
+        Please note that ``attrs`` doesn't do anything with this metadata by
+        itself. You can use it as part of your own code or for
+        :doc:`static type checking <types>`.
+    :param kw_only: Make this attribute keyword-only (Python 3+)
+        in the generated ``__init__`` (if ``init`` is ``False``, this
+        parameter is ignored).
+
     .. versionadded:: 15.2.0 *convert*
     .. versionadded:: 16.3.0 *metadata*
     .. versionchanged:: 17.1.0 *validator* can be a ``list`` now.
@@ -146,6 +171,7 @@ def attrib(default=NOTHING, validator=None,
        *convert* to achieve consistency with other noun-based arguments.
     .. versionadded:: 18.1.0
        ``factory=f`` is syntactic sugar for ``default=attr.Factory(f)``.
+    .. versionadded:: 18.2.0 *kw_only*
     """
     if hash is not None and hash is not True and hash is not False:
         raise TypeError(
@@ -161,7 +187,8 @@ def attrib(default=NOTHING, validator=None,
         warnings.warn(
             "The `convert` argument is deprecated in favor of `converter`.  "
             "It will be removed after 2019/01.",
-            DeprecationWarning, stacklevel=2
+            DeprecationWarning,
+            stacklevel=2,
         )
         converter = convert
 
@@ -172,9 +199,7 @@ def attrib(default=NOTHING, validator=None,
                 "exclusive."
             )
         if not callable(factory):
-            raise ValueError(
-                "The `factory` argument must be a callable."
-            )
+            raise ValueError("The `factory` argument must be a callable.")
         default = Factory(factory)
 
     if metadata is None:
@@ -190,6 +215,7 @@ def attrib(default=NOTHING, validator=None,
         converter=converter,
         metadata=metadata,
         type=type,
+        kw_only=kw_only,
     )
 
 
@@ -210,24 +236,30 @@ def _make_attr_tuple_class(cls_name, attr_names):
     ]
     if attr_names:
         for i, attr_name in enumerate(attr_names):
-            attr_class_template.append(_tuple_property_pat.format(
-                index=i,
-                attr_name=attr_name,
-            ))
+            attr_class_template.append(
+                _tuple_property_pat.format(index=i, attr_name=attr_name)
+            )
     else:
         attr_class_template.append("    pass")
-    globs = {"itemgetter": itemgetter}
+    globs = {"_attrs_itemgetter": itemgetter, "_attrs_property": property}
     eval(compile("\n".join(attr_class_template), "", "exec"), globs)
+
     return globs[attr_class_name]
 
 
 # Tuple class for extracted attributes from a class definition.
-# `super_attrs` is a subset of `attrs`.
-_Attributes = _make_attr_tuple_class("_Attributes", [
-    "attrs",            # all attributes to build dunder methods for
-    "super_attrs",      # attributes that have been inherited
-    "super_attrs_map",  # map inherited attributes to their originating classes
-])
+# `base_attrs` is a subset of `attrs`.
+_Attributes = _make_attr_tuple_class(
+    "_Attributes",
+    [
+        # all attributes to build dunder methods for
+        "attrs",
+        # attributes that have been inherited
+        "base_attrs",
+        # map inherited attributes to their originating classes
+        "base_attrs_map",
+    ],
+)
 
 
 def _is_class_var(annot):
@@ -250,8 +282,8 @@ def _get_annotations(cls):
         return {}
 
     # Verify that the annotations aren't merely inherited.
-    for super_cls in cls.__mro__[1:]:
-        if anns is getattr(super_cls, "__annotations__", None):
+    for base_cls in cls.__mro__[1:]:
+        if anns is getattr(base_cls, "__annotations__", None):
             return {}
 
     return anns
@@ -264,7 +296,7 @@ def _counter_getter(e):
     return e[1].counter
 
 
-def _transform_attrs(cls, these, auto_attribs):
+def _transform_attrs(cls, these, auto_attribs, kw_only):
     """
     Transform all `_CountingAttr`s on a class into `Attribute`s.
 
@@ -276,19 +308,14 @@ def _transform_attrs(cls, these, auto_attribs):
     anns = _get_annotations(cls)
 
     if these is not None:
-        ca_list = [
-            (name, ca)
-            for name, ca
-            in iteritems(these)
-        ]
+        ca_list = [(name, ca) for name, ca in iteritems(these)]
 
         if not isinstance(these, ordered_dict):
             ca_list.sort(key=_counter_getter)
     elif auto_attribs is True:
         ca_names = {
             name
-            for name, attr
-            in cd.items()
+            for name, attr in cd.items()
             if isinstance(attr, _CountingAttr)
         }
         ca_list = []
@@ -308,77 +335,91 @@ def _transform_attrs(cls, these, auto_attribs):
         unannotated = ca_names - annot_names
         if len(unannotated) > 0:
             raise UnannotatedAttributeError(
-                "The following `attr.ib`s lack a type annotation: " +
-                ", ".join(sorted(
-                    unannotated,
-                    key=lambda n: cd.get(n).counter
-                )) + "."
+                "The following `attr.ib`s lack a type annotation: "
+                + ", ".join(
+                    sorted(unannotated, key=lambda n: cd.get(n).counter)
+                )
+                + "."
             )
     else:
-        ca_list = sorted((
-            (name, attr)
-            for name, attr
-            in cd.items()
-            if isinstance(attr, _CountingAttr)
-        ), key=lambda e: e[1].counter)
+        ca_list = sorted(
+            (
+                (name, attr)
+                for name, attr in cd.items()
+                if isinstance(attr, _CountingAttr)
+            ),
+            key=lambda e: e[1].counter,
+        )
 
     own_attrs = [
         Attribute.from_counting_attr(
-            name=attr_name,
-            ca=ca,
-            type=anns.get(attr_name),
+            name=attr_name, ca=ca, type=anns.get(attr_name)
         )
-        for attr_name, ca
-        in ca_list
+        for attr_name, ca in ca_list
     ]
 
-    super_attrs = []
-    super_attr_map = {}  # A dictionary of superattrs to their classes.
+    base_attrs = []
+    base_attr_map = {}  # A dictionary of base attrs to their classes.
     taken_attr_names = {a.name: a for a in own_attrs}
 
     # Traverse the MRO and collect attributes.
-    for super_cls in cls.__mro__[1:-1]:
-        sub_attrs = getattr(super_cls, "__attrs_attrs__", None)
+    for base_cls in cls.__mro__[1:-1]:
+        sub_attrs = getattr(base_cls, "__attrs_attrs__", None)
         if sub_attrs is not None:
             for a in sub_attrs:
                 prev_a = taken_attr_names.get(a.name)
                 # Only add an attribute if it hasn't been defined before.  This
                 # allows for overwriting attribute definitions by subclassing.
                 if prev_a is None:
-                    super_attrs.append(a)
+                    base_attrs.append(a)
                     taken_attr_names[a.name] = a
-                    super_attr_map[a.name] = super_cls
+                    base_attr_map[a.name] = base_cls
 
-    attr_names = [a.name for a in super_attrs + own_attrs]
+    attr_names = [a.name for a in base_attrs + own_attrs]
 
     AttrsClass = _make_attr_tuple_class(cls.__name__, attr_names)
 
-    attrs = AttrsClass(
-        super_attrs + [
-            Attribute.from_counting_attr(
-                name=attr_name,
-                ca=ca,
-                type=anns.get(attr_name)
-            )
-            for attr_name, ca
-            in ca_list
-        ]
-    )
+    if kw_only:
+        own_attrs = [a._assoc(kw_only=True) for a in own_attrs]
+        base_attrs = [a._assoc(kw_only=True) for a in base_attrs]
+
+    attrs = AttrsClass(base_attrs + own_attrs)
 
     had_default = False
+    was_kw_only = False
     for a in attrs:
-        if had_default is True and a.default is NOTHING and a.init is True:
+        if (
+            was_kw_only is False
+            and had_default is True
+            and a.default is NOTHING
+            and a.init is True
+            and a.kw_only is False
+        ):
             raise ValueError(
                 "No mandatory attributes allowed after an attribute with a "
-                "default value or factory.  Attribute in question: {a!r}"
-                .format(a=a)
+                "default value or factory.  Attribute in question: %r" % (a,)
             )
-        elif had_default is False and \
-                a.default is not NOTHING and \
-                a.init is not False:
+        elif (
+            had_default is False
+            and a.default is not NOTHING
+            and a.init is not False
+            and
+            # Keyword-only attributes without defaults can be specified
+            # after keyword-only attributes with defaults.
+            a.kw_only is False
+        ):
             had_default = True
+        if was_kw_only is True and a.kw_only is False:
+            raise ValueError(
+                "Non keyword-only attributes are not allowed after a "
+                "keyword-only attribute.  Attribute in question: {a!r}".format(
+                    a=a
+                )
+            )
+        if was_kw_only is False and a.init is True and a.kw_only is True:
+            was_kw_only = True
 
-    return _Attributes((attrs, super_attrs, super_attr_map))
+    return _Attributes((attrs, base_attrs, base_attr_map))
 
 
 def _frozen_setattrs(self, name, value):
@@ -399,24 +440,47 @@ class _ClassBuilder(object):
     """
     Iteratively build *one* class.
     """
+
     __slots__ = (
-        "_cls", "_cls_dict", "_attrs", "_super_names", "_attr_names", "_slots",
-        "_frozen", "_has_post_init", "_delete_attribs", "_super_attr_map",
+        "_cls",
+        "_cls_dict",
+        "_attrs",
+        "_base_names",
+        "_attr_names",
+        "_slots",
+        "_frozen",
+        "_weakref_slot",
+        "_cache_hash",
+        "_has_post_init",
+        "_delete_attribs",
+        "_base_attr_map",
     )
 
-    def __init__(self, cls, these, slots, frozen, auto_attribs):
-        attrs, super_attrs, super_map = _transform_attrs(
-            cls, these, auto_attribs
+    def __init__(
+        self,
+        cls,
+        these,
+        slots,
+        frozen,
+        weakref_slot,
+        auto_attribs,
+        kw_only,
+        cache_hash,
+    ):
+        attrs, base_attrs, base_map = _transform_attrs(
+            cls, these, auto_attribs, kw_only
         )
 
         self._cls = cls
         self._cls_dict = dict(cls.__dict__) if slots else {}
         self._attrs = attrs
-        self._super_names = set(a.name for a in super_attrs)
-        self._super_attr_map = super_map
+        self._base_names = set(a.name for a in base_attrs)
+        self._base_attr_map = base_map
         self._attr_names = tuple(a.name for a in attrs)
         self._slots = slots
-        self._frozen = frozen or _has_frozen_superclass(cls)
+        self._frozen = frozen or _has_frozen_base_class(cls)
+        self._weakref_slot = weakref_slot
+        self._cache_hash = cache_hash
         self._has_post_init = bool(getattr(cls, "__attrs_post_init__", False))
         self._delete_attribs = not bool(these)
 
@@ -433,7 +497,7 @@ class _ClassBuilder(object):
         """
         Finalize class based on the accumulated configuration.
 
-        Builder cannot be used anymore after calling this method.
+        Builder cannot be used after calling this method.
         """
         if self._slots is True:
             return self._create_slots_class()
@@ -445,14 +509,22 @@ class _ClassBuilder(object):
         Apply accumulated methods and return the class.
         """
         cls = self._cls
-        super_names = self._super_names
+        base_names = self._base_names
 
         # Clean class of attribute definitions (`attr.ib()`s).
         if self._delete_attribs:
             for name in self._attr_names:
-                if name not in super_names and \
-                        getattr(cls, name, None) is not None:
-                    delattr(cls, name)
+                if (
+                    name not in base_names
+                    and getattr(cls, name, None) is not None
+                ):
+                    try:
+                        delattr(cls, name)
+                    except AttributeError:
+                        # This can happen if a base class defines a class
+                        # variable and we want to set an attribute with the
+                        # same name by using only a type annotation.
+                        pass
 
         # Attach our dunder methods.
         for name, value in self._cls_dict.items():
@@ -464,20 +536,36 @@ class _ClassBuilder(object):
         """
         Build and return a new class with a `__slots__` attribute.
         """
-        super_names = self._super_names
+        base_names = self._base_names
         cd = {
             k: v
             for k, v in iteritems(self._cls_dict)
-            if k not in tuple(self._attr_names) + ("__dict__",)
+            if k not in tuple(self._attr_names) + ("__dict__", "__weakref__")
         }
 
+        weakref_inherited = False
+
+        # Traverse the MRO to check for an existing __weakref__.
+        for base_cls in self._cls.__mro__[1:-1]:
+            if "__weakref__" in getattr(base_cls, "__dict__", ()):
+                weakref_inherited = True
+                break
+
+        names = self._attr_names
+        if (
+            self._weakref_slot
+            and "__weakref__" not in getattr(self._cls, "__slots__", ())
+            and "__weakref__" not in names
+            and not weakref_inherited
+        ):
+            names += ("__weakref__",)
+
         # We only add the names of attributes that aren't inherited.
         # Settings __slots__ to inherited attributes wastes memory.
-        cd["__slots__"] = tuple(
-            name
-            for name in self._attr_names
-            if name not in super_names
-        )
+        slot_names = [name for name in names if name not in base_names]
+        if self._cache_hash:
+            slot_names.append(_hash_cache_field)
+        cd["__slots__"] = tuple(slot_names)
 
         qualname = getattr(self._cls, "__qualname__", None)
         if qualname is not None:
@@ -492,10 +580,7 @@ class _ClassBuilder(object):
             """
             Automatically created by attrs.
             """
-            return tuple(
-                getattr(self, name)
-                for name in state_attr_names
-            )
+            return tuple(getattr(self, name) for name in state_attr_names)
 
         def slots_setstate(self, state):
             """
@@ -510,11 +595,7 @@ class _ClassBuilder(object):
         cd["__setstate__"] = slots_setstate
 
         # Create new class based on old class and our methods.
-        cls = type(self._cls)(
-            self._cls.__name__,
-            self._cls.__bases__,
-            cd,
-        )
+        cls = type(self._cls)(self._cls.__name__, self._cls.__bases__, cd)
 
         # The following is a fix for
         # https://github.com/python-attrs/attrs/issues/102.  On Python 3,
@@ -563,7 +644,9 @@ class _ClassBuilder(object):
 
     def add_hash(self):
         self._cls_dict["__hash__"] = self._add_method_dunders(
-            _make_hash(self._attrs)
+            _make_hash(
+                self._attrs, frozen=self._frozen, cache_hash=self._cache_hash
+            )
         )
 
         return self
@@ -575,7 +658,8 @@ class _ClassBuilder(object):
                 self._has_post_init,
                 self._frozen,
                 self._slots,
-                self._super_attr_map,
+                self._cache_hash,
+                self._base_attr_map,
             )
         )
 
@@ -584,11 +668,11 @@ class _ClassBuilder(object):
     def add_cmp(self):
         cd = self._cls_dict
 
-        cd["__eq__"], cd["__ne__"], cd["__lt__"], cd["__le__"], cd["__gt__"], \
-            cd["__ge__"] = (
-                self._add_method_dunders(meth)
-                for meth in _make_cmp(self._attrs)
-            )
+        cd["__eq__"], cd["__ne__"], cd["__lt__"], cd["__le__"], cd[
+            "__gt__"
+        ], cd["__ge__"] = (
+            self._add_method_dunders(meth) for meth in _make_cmp(self._attrs)
+        )
 
         return self
 
@@ -603,7 +687,7 @@ class _ClassBuilder(object):
 
         try:
             method.__qualname__ = ".".join(
-                (self._cls.__qualname__, method.__name__,)
+                (self._cls.__qualname__, method.__name__)
             )
         except AttributeError:
             pass
@@ -611,9 +695,22 @@ class _ClassBuilder(object):
         return method
 
 
-def attrs(maybe_cls=None, these=None, repr_ns=None,
-          repr=True, cmp=True, hash=None, init=True,
-          slots=False, frozen=False, str=False, auto_attribs=False):
+def attrs(
+    maybe_cls=None,
+    these=None,
+    repr_ns=None,
+    repr=True,
+    cmp=True,
+    hash=None,
+    init=True,
+    slots=False,
+    frozen=False,
+    weakref_slot=True,
+    str=False,
+    auto_attribs=False,
+    kw_only=False,
+    cache_hash=False,
+):
     r"""
     A class decorator that adds `dunder
     <https://wiki.python.org/moin/DunderAlias>`_\ -methods according to the
@@ -645,7 +742,7 @@ def attrs(maybe_cls=None, these=None, repr_ns=None,
     :param bool cmp: Create ``__eq__``, ``__ne__``, ``__lt__``, ``__le__``,
         ``__gt__``, and ``__ge__`` methods that compare the class as if it were
         a tuple of its ``attrs`` attributes.  But the attributes are *only*
-        compared, if the type of both classes is *identical*!
+        compared, if the types of both classes are *identical*!
     :param hash: If ``None`` (default), the ``__hash__`` method is generated
         according how *cmp* and *frozen* are set.
 
@@ -653,7 +750,7 @@ def attrs(maybe_cls=None, these=None, repr_ns=None,
         2. If *cmp* is True and *frozen* is False, ``__hash__`` will be set to
            None, marking it unhashable (which it is).
         3. If *cmp* is False, ``__hash__`` will be left untouched meaning the
-           ``__hash__`` method of the superclass will be used (if superclass is
+           ``__hash__`` method of the base class will be used (if base class is
            ``object``, this means it will fall back to id-based hashing.).
 
         Although not recommended, you can decide for yourself and force
@@ -693,6 +790,8 @@ def attrs(maybe_cls=None, these=None, repr_ns=None,
                ``object.__setattr__(self, "attribute_name", value)``.
 
         ..  _slots: https://docs.python.org/3/reference/datamodel.html#slots
+    :param bool weakref_slot: Make instances weak-referenceable.  This has no
+        effect unless ``slots`` is also enabled.
     :param bool auto_attribs: If True, collect `PEP 526`_-annotated attributes
         (Python 3.6 and later only) from the class body.
 
@@ -710,6 +809,16 @@ def attrs(maybe_cls=None, these=None, repr_ns=None,
         Attributes annotated as :data:`typing.ClassVar` are **ignored**.
 
         .. _`PEP 526`: https://www.python.org/dev/peps/pep-0526/
+    :param bool kw_only: Make all attributes keyword-only (Python 3+)
+        in the generated ``__init__`` (if ``init`` is ``False``, this
+        parameter is ignored).
+    :param bool cache_hash: Ensure that the object's hash code is computed
+        only once and stored on the object.  If this is set to ``True``,
+        hashing must be either explicitly or implicitly enabled for this
+        class.  If the hash code is cached, then no attributes of this
+        class which participate in hash code computation may be mutated
+        after object creation.
+
 
     .. versionadded:: 16.0.0 *slots*
     .. versionadded:: 16.1.0 *frozen*
@@ -721,12 +830,30 @@ def attrs(maybe_cls=None, these=None, repr_ns=None,
     .. versionchanged:: 18.1.0
        If *these* is passed, no attributes are deleted from the class body.
     .. versionchanged:: 18.1.0 If *these* is ordered, the order is retained.
+    .. versionadded:: 18.2.0 *weakref_slot*
+    .. deprecated:: 18.2.0
+       ``__lt__``, ``__le__``, ``__gt__``, and ``__ge__`` now raise a
+       :class:`DeprecationWarning` if the classes compared are subclasses of
+       each other. ``__eq`` and ``__ne__`` never tried to compared subclasses
+       to each other.
+    .. versionadded:: 18.2.0 *kw_only*
+    .. versionadded:: 18.2.0 *cache_hash*
     """
+
     def wrap(cls):
         if getattr(cls, "__class__", None) is None:
             raise TypeError("attrs only works with new-style classes.")
 
-        builder = _ClassBuilder(cls, these, slots, frozen, auto_attribs)
+        builder = _ClassBuilder(
+            cls,
+            these,
+            slots,
+            frozen,
+            weakref_slot,
+            auto_attribs,
+            kw_only,
+            cache_hash,
+        )
 
         if repr is True:
             builder.add_repr(repr_ns)
@@ -741,14 +868,31 @@ def attrs(maybe_cls=None, these=None, repr_ns=None,
                 "Invalid value for hash.  Must be True, False, or None."
             )
         elif hash is False or (hash is None and cmp is False):
-            pass
+            if cache_hash:
+                raise TypeError(
+                    "Invalid value for cache_hash.  To use hash caching,"
+                    " hashing must be either explicitly or implicitly "
+                    "enabled."
+                )
         elif hash is True or (hash is None and cmp is True and frozen is True):
             builder.add_hash()
         else:
+            if cache_hash:
+                raise TypeError(
+                    "Invalid value for cache_hash.  To use hash caching,"
+                    " hashing must be either explicitly or implicitly "
+                    "enabled."
+                )
             builder.make_unhashable()
 
         if init is True:
             builder.add_init()
+        else:
+            if cache_hash:
+                raise TypeError(
+                    "Invalid value for cache_hash.  To use hash caching,"
+                    " init must be True."
+                )
 
         return builder.build_class()
 
@@ -768,19 +912,22 @@ Internal alias so we can use it in functions that take an argument called
 
 
 if PY2:
-    def _has_frozen_superclass(cls):
+
+    def _has_frozen_base_class(cls):
         """
         Check whether *cls* has a frozen ancestor by looking at its
         __setattr__.
         """
         return (
-            getattr(
-                cls.__setattr__, "__module__", None
-            ) == _frozen_setattrs.__module__ and
-            cls.__setattr__.__name__ == _frozen_setattrs.__name__
+            getattr(cls.__setattr__, "__module__", None)
+            == _frozen_setattrs.__module__
+            and cls.__setattr__.__name__ == _frozen_setattrs.__name__
         )
+
+
 else:
-    def _has_frozen_superclass(cls):
+
+    def _has_frozen_base_class(cls):
         """
         Check whether *cls* has a frozen ancestor by looking at its
         __setattr__.
@@ -795,29 +942,54 @@ def _attrs_to_tuple(obj, attrs):
     return tuple(getattr(obj, a.name) for a in attrs)
 
 
-def _make_hash(attrs):
+def _make_hash(attrs, frozen, cache_hash):
     attrs = tuple(
         a
         for a in attrs
         if a.hash is True or (a.hash is None and a.cmp is True)
     )
 
+    tab = "        "
+
     # We cache the generated hash methods for the same kinds of attributes.
     sha1 = hashlib.sha1()
     sha1.update(repr(attrs).encode("utf-8"))
     unique_filename = "<attrs generated hash %s>" % (sha1.hexdigest(),)
     type_hash = hash(unique_filename)
-    lines = [
-        "def __hash__(self):",
-        "    return hash((",
-        "        %d," % (type_hash,),
-    ]
-    for a in attrs:
-        lines.append("        self.%s," % (a.name))
 
-    lines.append("    ))")
+    method_lines = ["def __hash__(self):"]
 
-    script = "\n".join(lines)
+    def append_hash_computation_lines(prefix, indent):
+        """
+        Generate the code for actually computing the hash code.
+        Below this will either be returned directly or used to compute
+        a value which is then cached, depending on the value of cache_hash
+        """
+        method_lines.extend(
+            [indent + prefix + "hash((", indent + "        %d," % (type_hash,)]
+        )
+
+        for a in attrs:
+            method_lines.append(indent + "        self.%s," % a.name)
+
+        method_lines.append(indent + "    ))")
+
+    if cache_hash:
+        method_lines.append(tab + "if self.%s is None:" % _hash_cache_field)
+        if frozen:
+            append_hash_computation_lines(
+                "object.__setattr__(self, '%s', " % _hash_cache_field, tab * 2
+            )
+            method_lines.append(tab * 2 + ")")  # close __setattr__
+        else:
+            append_hash_computation_lines(
+                "self.%s = " % _hash_cache_field, tab * 2
+            )
+        method_lines.append(tab + "return self.%s" % _hash_cache_field)
+    else:
+        append_hash_computation_lines("return ", tab)
+
+    script = "\n".join(method_lines)
     globs = {}
     locs = {}
     bytecode = compile(script, unique_filename, "exec")
@@ -839,7 +1011,7 @@ def _add_hash(cls, attrs):
     """
     Add a hash method to *cls*.
     """
-    cls.__hash__ = _make_hash(attrs)
+    cls.__hash__ = _make_hash(attrs, frozen=False, cache_hash=False)
     return cls
 
 
@@ -855,6 +1027,12 @@ def __ne__(self, other):
     return not result
 
 
+WARNING_CMP_ISINSTANCE = (
+    "Comparision of subclasses using __%s__ is deprecated and will be removed "
+    "in 2019."
+)
+
+
 def _make_cmp(attrs):
     attrs = [a for a in attrs if a.cmp]
 
@@ -871,9 +1049,7 @@ def _make_cmp(attrs):
     # irregularities like nan == nan is false but (nan,) == (nan,) is true.
     if attrs:
         lines.append("    return  (")
-        others = [
-            "    ) == (",
-        ]
+        others = ["    ) == ("]
         for a in attrs:
             lines.append("        self.%s," % (a.name,))
             others.append("        other.%s," % (a.name,))
@@ -910,6 +1086,10 @@ def _make_cmp(attrs):
         Automatically created by attrs.
         """
         if isinstance(other, self.__class__):
+            if other.__class__ is not self.__class__:
+                warnings.warn(
+                    WARNING_CMP_ISINSTANCE % ("lt",), DeprecationWarning
+                )
             return attrs_to_tuple(self) < attrs_to_tuple(other)
         else:
             return NotImplemented
@@ -919,6 +1099,10 @@ def _make_cmp(attrs):
         Automatically created by attrs.
         """
         if isinstance(other, self.__class__):
+            if other.__class__ is not self.__class__:
+                warnings.warn(
+                    WARNING_CMP_ISINSTANCE % ("le",), DeprecationWarning
+                )
             return attrs_to_tuple(self) <= attrs_to_tuple(other)
         else:
             return NotImplemented
@@ -928,6 +1112,10 @@ def _make_cmp(attrs):
         Automatically created by attrs.
         """
         if isinstance(other, self.__class__):
+            if other.__class__ is not self.__class__:
+                warnings.warn(
+                    WARNING_CMP_ISINSTANCE % ("gt",), DeprecationWarning
+                )
             return attrs_to_tuple(self) > attrs_to_tuple(other)
         else:
             return NotImplemented
@@ -937,6 +1125,10 @@ def _make_cmp(attrs):
         Automatically created by attrs.
         """
         if isinstance(other, self.__class__):
+            if other.__class__ is not self.__class__:
+                warnings.warn(
+                    WARNING_CMP_ISINSTANCE % ("ge",), DeprecationWarning
+                )
             return attrs_to_tuple(self) >= attrs_to_tuple(other)
         else:
             return NotImplemented
@@ -951,8 +1143,9 @@ def _add_cmp(cls, attrs=None):
     if attrs is None:
         attrs = cls.__attrs_attrs__
 
-    cls.__eq__, cls.__ne__, cls.__lt__, cls.__le__, cls.__gt__, cls.__ge__ = \
-        _make_cmp(attrs)
+    cls.__eq__, cls.__ne__, cls.__lt__, cls.__le__, cls.__gt__, cls.__ge__ = _make_cmp(  # noqa
+        attrs
+    )
 
     return cls
 
@@ -964,11 +1157,7 @@ def _make_repr(attrs, ns):
     """
     Make a repr method for *attr_names* adding *ns* to the full name.
     """
-    attr_names = tuple(
-        a.name
-        for a in attrs
-        if a.repr
-    )
+    attr_names = tuple(a.name for a in attrs if a.repr)
 
     def __repr__(self):
         """
@@ -1009,6 +1198,7 @@ def _make_repr(attrs, ns):
             return "".join(result) + ")"
         finally:
             working_set.remove(id(self))
+
     return __repr__
 
 
@@ -1023,34 +1213,21 @@ def _add_repr(cls, ns=None, attrs=None):
     return cls
 
 
-def _make_init(attrs, post_init, frozen, slots, super_attr_map):
-    attrs = [
-        a
-        for a in attrs
-        if a.init or a.default is not NOTHING
-    ]
+def _make_init(attrs, post_init, frozen, slots, cache_hash, base_attr_map):
+    attrs = [a for a in attrs if a.init or a.default is not NOTHING]
 
     # We cache the generated init methods for the same kinds of attributes.
     sha1 = hashlib.sha1()
     sha1.update(repr(attrs).encode("utf-8"))
-    unique_filename = "<attrs generated init {0}>".format(
-        sha1.hexdigest()
-    )
+    unique_filename = "<attrs generated init {0}>".format(sha1.hexdigest())
 
     script, globs, annotations = _attrs_to_init_script(
-        attrs,
-        frozen,
-        slots,
-        post_init,
-        super_attr_map,
+        attrs, frozen, slots, post_init, cache_hash, base_attr_map
     )
     locs = {}
     bytecode = compile(script, unique_filename, "exec")
     attr_dict = dict((a.name, a) for a in attrs)
-    globs.update({
-        "NOTHING": NOTHING,
-        "attr_dict": attr_dict,
-    })
+    globs.update({"NOTHING": NOTHING, "attr_dict": attr_dict})
     if frozen is True:
         # Save the lookup overhead in __init__ if we need to circumvent
         # immutability.
@@ -1080,7 +1257,8 @@ def _add_init(cls, frozen):
         getattr(cls, "__attrs_post_init__", False),
         frozen,
         _is_slot_cls(cls),
-        {},
+        cache_hash=False,
+        base_attr_map={},
     )
     return cls
 
@@ -1162,14 +1340,16 @@ def _is_slot_cls(cls):
     return "__slots__" in cls.__dict__
 
 
-def _is_slot_attr(a_name, super_attr_map):
+def _is_slot_attr(a_name, base_attr_map):
     """
     Check if the attribute name comes from a slot class.
     """
-    return a_name in super_attr_map and _is_slot_cls(super_attr_map[a_name])
+    return a_name in base_attr_map and _is_slot_cls(base_attr_map[a_name])
 
 
-def _attrs_to_init_script(attrs, frozen, slots, post_init, super_attr_map):
+def _attrs_to_init_script(
+    attrs, frozen, slots, post_init, cache_hash, base_attr_map
+):
     """
     Return a script of an initializer for *attrs* and a dict of globals.
 
@@ -1180,14 +1360,14 @@ def _attrs_to_init_script(attrs, frozen, slots, post_init, super_attr_map):
     """
     lines = []
     any_slot_ancestors = any(
-        _is_slot_attr(a.name, super_attr_map)
-        for a in attrs
+        _is_slot_attr(a.name, base_attr_map) for a in attrs
     )
     if frozen is True:
         if slots is True:
             lines.append(
                 # Circumvent the __setattr__ descriptor to save one lookup per
                 # assignment.
+                # Note _setattr will be used again below if cache_hash is True
                 "_setattr = _cached_setattr.__get__(self, self.__class__)"
             )
 
@@ -1204,13 +1384,13 @@ def _attrs_to_init_script(attrs, frozen, slots, post_init, super_attr_map):
                     "value_var": value_var,
                     "conv": conv_name,
                 }
+
         else:
             # Dict frozen classes assign directly to __dict__.
             # But only if the attribute doesn't come from an ancestor slot
             # class.
-            lines.append(
-                "_inst_dict = self.__dict__"
-            )
+            # Note _inst_dict will be used again below if cache_hash is True
+            lines.append("_inst_dict = self.__dict__")
             if any_slot_ancestors:
                 lines.append(
                     # Circumvent the __setattr__ descriptor to save one lookup
@@ -1219,7 +1399,7 @@ def _attrs_to_init_script(attrs, frozen, slots, post_init, super_attr_map):
                 )
 
             def fmt_setter(attr_name, value_var):
-                if _is_slot_attr(attr_name, super_attr_map):
+                if _is_slot_attr(attr_name, base_attr_map):
                     res = "_setattr('%(attr_name)s', %(value_var)s)" % {
                         "attr_name": attr_name,
                         "value_var": value_var,
@@ -1233,7 +1413,7 @@ def _attrs_to_init_script(attrs, frozen, slots, post_init, super_attr_map):
 
             def fmt_setter_with_converter(attr_name, value_var):
                 conv_name = _init_converter_pat.format(attr_name)
-                if _is_slot_attr(attr_name, super_attr_map):
+                if _is_slot_attr(attr_name, base_attr_map):
                     tmpl = "_setattr('%(attr_name)s', %(c)s(%(value_var)s))"
                 else:
                     tmpl = "_inst_dict['%(attr_name)s'] = %(c)s(%(value_var)s)"
@@ -1242,6 +1422,7 @@ def _attrs_to_init_script(attrs, frozen, slots, post_init, super_attr_map):
                     "value_var": value_var,
                     "c": conv_name,
                 }
+
     else:
         # Not frozen.
         def fmt_setter(attr_name, value):
@@ -1259,12 +1440,13 @@ def _attrs_to_init_script(attrs, frozen, slots, post_init, super_attr_map):
             }
 
     args = []
+    kw_only_args = []
     attrs_to_validate = []
 
     # This is a dictionary of names to validator and converter callables.
     # Injecting this into __init__ globals lets us avoid lookups.
     names_for_globals = {}
-    annotations = {'return': None}
+    annotations = {"return": None}
 
     for a in attrs:
         if a.validator:
@@ -1280,78 +1462,104 @@ def _attrs_to_init_script(attrs, frozen, slots, post_init, super_attr_map):
             if has_factory:
                 init_factory_name = _init_factory_pat.format(a.name)
                 if a.converter is not None:
-                    lines.append(fmt_setter_with_converter(
-                        attr_name,
-                        init_factory_name + "({0})".format(maybe_self)))
+                    lines.append(
+                        fmt_setter_with_converter(
+                            attr_name,
+                            init_factory_name + "({0})".format(maybe_self),
+                        )
+                    )
                     conv_name = _init_converter_pat.format(a.name)
                     names_for_globals[conv_name] = a.converter
                 else:
-                    lines.append(fmt_setter(
-                        attr_name,
-                        init_factory_name + "({0})".format(maybe_self)
-                    ))
+                    lines.append(
+                        fmt_setter(
+                            attr_name,
+                            init_factory_name + "({0})".format(maybe_self),
+                        )
+                    )
                 names_for_globals[init_factory_name] = a.default.factory
             else:
                 if a.converter is not None:
-                    lines.append(fmt_setter_with_converter(
-                        attr_name,
-                        "attr_dict['{attr_name}'].default"
-                        .format(attr_name=attr_name)
-                    ))
+                    lines.append(
+                        fmt_setter_with_converter(
+                            attr_name,
+                            "attr_dict['{attr_name}'].default".format(
+                                attr_name=attr_name
+                            ),
+                        )
+                    )
                     conv_name = _init_converter_pat.format(a.name)
                     names_for_globals[conv_name] = a.converter
                 else:
-                    lines.append(fmt_setter(
-                        attr_name,
-                        "attr_dict['{attr_name}'].default"
-                        .format(attr_name=attr_name)
-                    ))
+                    lines.append(
+                        fmt_setter(
+                            attr_name,
+                            "attr_dict['{attr_name}'].default".format(
+                                attr_name=attr_name
+                            ),
+                        )
+                    )
         elif a.default is not NOTHING and not has_factory:
-            args.append(
-                "{arg_name}=attr_dict['{attr_name}'].default".format(
-                    arg_name=arg_name,
-                    attr_name=attr_name,
-                )
+            arg = "{arg_name}=attr_dict['{attr_name}'].default".format(
+                arg_name=arg_name, attr_name=attr_name
             )
+            if a.kw_only:
+                kw_only_args.append(arg)
+            else:
+                args.append(arg)
             if a.converter is not None:
                 lines.append(fmt_setter_with_converter(attr_name, arg_name))
-                names_for_globals[_init_converter_pat.format(a.name)] = (
-                    a.converter
-                )
+                names_for_globals[
+                    _init_converter_pat.format(a.name)
+                ] = a.converter
             else:
                 lines.append(fmt_setter(attr_name, arg_name))
         elif has_factory:
-            args.append("{arg_name}=NOTHING".format(arg_name=arg_name))
-            lines.append("if {arg_name} is not NOTHING:"
-                         .format(arg_name=arg_name))
+            arg = "{arg_name}=NOTHING".format(arg_name=arg_name)
+            if a.kw_only:
+                kw_only_args.append(arg)
+            else:
+                args.append(arg)
+            lines.append(
+                "if {arg_name} is not NOTHING:".format(arg_name=arg_name)
+            )
             init_factory_name = _init_factory_pat.format(a.name)
             if a.converter is not None:
-                lines.append("    " + fmt_setter_with_converter(
-                    attr_name, arg_name
-                ))
-                lines.append("else:")
-                lines.append("    " + fmt_setter_with_converter(
-                    attr_name,
-                    init_factory_name + "({0})".format(maybe_self)
-                ))
-                names_for_globals[_init_converter_pat.format(a.name)] = (
-                    a.converter
+                lines.append(
+                    "    " + fmt_setter_with_converter(attr_name, arg_name)
                 )
+                lines.append("else:")
+                lines.append(
+                    "    "
+                    + fmt_setter_with_converter(
+                        attr_name,
+                        init_factory_name + "({0})".format(maybe_self),
+                    )
+                )
+                names_for_globals[
+                    _init_converter_pat.format(a.name)
+                ] = a.converter
             else:
                 lines.append("    " + fmt_setter(attr_name, arg_name))
                 lines.append("else:")
-                lines.append("    " + fmt_setter(
-                    attr_name,
-                    init_factory_name + "({0})".format(maybe_self)
-                ))
+                lines.append(
+                    "    "
+                    + fmt_setter(
+                        attr_name,
+                        init_factory_name + "({0})".format(maybe_self),
+                    )
+                )
             names_for_globals[init_factory_name] = a.default.factory
         else:
-            args.append(arg_name)
+            if a.kw_only:
+                kw_only_args.append(arg_name)
+            else:
+                args.append(arg_name)
             if a.converter is not None:
                 lines.append(fmt_setter_with_converter(attr_name, arg_name))
-                names_for_globals[_init_converter_pat.format(a.name)] = (
-                    a.converter
-                )
+                names_for_globals[
+                    _init_converter_pat.format(a.name)
+                ] = a.converter
             else:
                 lines.append(fmt_setter(attr_name, arg_name))
 
@@ -1364,20 +1572,52 @@ def _attrs_to_init_script(attrs, frozen, slots, post_init, super_attr_map):
         for a in attrs_to_validate:
             val_name = "__attr_validator_{}".format(a.name)
             attr_name = "__attr_{}".format(a.name)
-            lines.append("    {}(self, {}, self.{})".format(
-                val_name, attr_name, a.name))
+            lines.append(
+                "    {}(self, {}, self.{})".format(val_name, attr_name, a.name)
+            )
             names_for_globals[val_name] = a.validator
             names_for_globals[attr_name] = a
     if post_init:
         lines.append("self.__attrs_post_init__()")
 
-    return """\
+    # because this is set only after __attrs_post_init is called, a crash
+    # will result if post-init tries to access the hash code.  This seemed
+    # preferable to setting this beforehand, in which case alteration to
+    # field values during post-init combined with post-init accessing the
+    # hash code would result in silent bugs.
+    if cache_hash:
+        if frozen:
+            if slots:
+                # if frozen and slots, then _setattr defined above
+                init_hash_cache = "_setattr('%s', %s)"
+            else:
+                # if frozen and not slots, then _inst_dict defined above
+                init_hash_cache = "_inst_dict['%s'] = %s"
+        else:
+            init_hash_cache = "self.%s = %s"
+        lines.append(init_hash_cache % (_hash_cache_field, "None"))
+
+    args = ", ".join(args)
+    if kw_only_args:
+        if PY2:
+            raise PythonTooOldError(
+                "Keyword-only arguments only work on Python 3 and later."
+            )
+
+        args += "{leading_comma}*, {kw_only_args}".format(
+            leading_comma=", " if args else "",
+            kw_only_args=", ".join(kw_only_args),
+        )
+    return (
+        """\
 def __init__(self, {args}):
     {lines}
 """.format(
-        args=", ".join(args),
-        lines="\n    ".join(lines) if lines else "pass",
-    ), names_for_globals, annotations
+            args=args, lines="\n    ".join(lines) if lines else "pass"
+        ),
+        names_for_globals,
+        annotations,
+    )
 
 
 class Attribute(object):
@@ -1390,13 +1630,36 @@ class Attribute(object):
 
     For the version history of the fields, see :func:`attr.ib`.
     """
+
     __slots__ = (
-        "name", "default", "validator", "repr", "cmp", "hash", "init",
-        "metadata", "type", "converter",
+        "name",
+        "default",
+        "validator",
+        "repr",
+        "cmp",
+        "hash",
+        "init",
+        "metadata",
+        "type",
+        "converter",
+        "kw_only",
     )
 
-    def __init__(self, name, default, validator, repr, cmp, hash, init,
-                 convert=None, metadata=None, type=None, converter=None):
+    def __init__(
+        self,
+        name,
+        default,
+        validator,
+        repr,
+        cmp,
+        hash,
+        init,
+        convert=None,
+        metadata=None,
+        type=None,
+        converter=None,
+        kw_only=False,
+    ):
         # Cache this descriptor here to speed things up later.
         bound_setattr = _obj_setattr.__get__(self, Attribute)
 
@@ -1411,7 +1674,8 @@ class Attribute(object):
             warnings.warn(
                 "The `convert` argument is deprecated in favor of `converter`."
                 "  It will be removed after 2019/01.",
-                DeprecationWarning, stacklevel=2
+                DeprecationWarning,
+                stacklevel=2,
             )
             converter = convert
 
@@ -1423,11 +1687,16 @@ class Attribute(object):
         bound_setattr("hash", hash)
         bound_setattr("init", init)
         bound_setattr("converter", converter)
-        bound_setattr("metadata", (
-            metadata_proxy(metadata) if metadata
-            else _empty_metadata_singleton
-        ))
+        bound_setattr(
+            "metadata",
+            (
+                metadata_proxy(metadata)
+                if metadata
+                else _empty_metadata_singleton
+            ),
+        )
         bound_setattr("type", type)
+        bound_setattr("kw_only", kw_only)
 
     def __setattr__(self, name, value):
         raise FrozenInstanceError()
@@ -1437,7 +1706,8 @@ class Attribute(object):
         warnings.warn(
             "The `convert` attribute is deprecated in favor of `converter`.  "
             "It will be removed after 2019/01.",
-            DeprecationWarning, stacklevel=2,
+            DeprecationWarning,
+            stacklevel=2,
         )
         return self.converter
 
@@ -1452,49 +1722,82 @@ class Attribute(object):
             )
         inst_dict = {
             k: getattr(ca, k)
-            for k
-            in Attribute.__slots__
-            if k not in (
-                "name", "validator", "default", "type", "convert",
+            for k in Attribute.__slots__
+            if k
+            not in (
+                "name",
+                "validator",
+                "default",
+                "type",
+                "convert",
             )  # exclude methods and deprecated alias
         }
         return cls(
-            name=name, validator=ca._validator, default=ca._default, type=type,
+            name=name,
+            validator=ca._validator,
+            default=ca._default,
+            type=type,
             **inst_dict
         )
 
+    # Don't use attr.assoc since fields(Attribute) doesn't work
+    def _assoc(self, **changes):
+        """
+        Copy *self* and apply *changes*.
+        """
+        new = copy.copy(self)
+
+        new._setattrs(changes.items())
+
+        return new
+
     # Don't use _add_pickle since fields(Attribute) doesn't work
     def __getstate__(self):
         """
         Play nice with pickle.
         """
-        return tuple(getattr(self, name) if name != "metadata"
-                     else dict(self.metadata)
-                     for name in self.__slots__)
+        return tuple(
+            getattr(self, name) if name != "metadata" else dict(self.metadata)
+            for name in self.__slots__
+        )
 
     def __setstate__(self, state):
         """
         Play nice with pickle.
         """
+        self._setattrs(zip(self.__slots__, state))
+
+    def _setattrs(self, name_values_pairs):
         bound_setattr = _obj_setattr.__get__(self, Attribute)
-        for name, value in zip(self.__slots__, state):
+        for name, value in name_values_pairs:
             if name != "metadata":
                 bound_setattr(name, value)
             else:
-                bound_setattr(name, metadata_proxy(value) if value else
-                              _empty_metadata_singleton)
+                bound_setattr(
+                    name,
+                    metadata_proxy(value)
+                    if value
+                    else _empty_metadata_singleton,
+                )
 
 
 _a = [
-    Attribute(name=name, default=NOTHING, validator=None,
-              repr=True, cmp=True, hash=(name != "metadata"), init=True)
+    Attribute(
+        name=name,
+        default=NOTHING,
+        validator=None,
+        repr=True,
+        cmp=True,
+        hash=(name != "metadata"),
+        init=True,
+    )
     for name in Attribute.__slots__
     if name != "convert"  # XXX: remove once `convert` is gone
 ]
 
 Attribute = _add_hash(
     _add_cmp(_add_repr(Attribute, attrs=_a), attrs=_a),
-    attrs=[a for a in _a if a.hash]
+    attrs=[a for a in _a if a.hash],
 )
 
 
@@ -1506,21 +1809,59 @@ class _CountingAttr(object):
     *Internal* data structure of the attrs library.  Running into is most
     likely the result of a bug like a forgotten `@attr.s` decorator.
     """
-    __slots__ = ("counter", "_default", "repr", "cmp", "hash", "init",
-                 "metadata", "_validator", "converter", "type")
+
+    __slots__ = (
+        "counter",
+        "_default",
+        "repr",
+        "cmp",
+        "hash",
+        "init",
+        "metadata",
+        "_validator",
+        "converter",
+        "type",
+        "kw_only",
+    )
     __attrs_attrs__ = tuple(
-        Attribute(name=name, default=NOTHING, validator=None,
-                  repr=True, cmp=True, hash=True, init=True)
-        for name
-        in ("counter", "_default", "repr", "cmp", "hash", "init",)
+        Attribute(
+            name=name,
+            default=NOTHING,
+            validator=None,
+            repr=True,
+            cmp=True,
+            hash=True,
+            init=True,
+            kw_only=False,
+        )
+        for name in ("counter", "_default", "repr", "cmp", "hash", "init")
     ) + (
-        Attribute(name="metadata", default=None, validator=None,
-                  repr=True, cmp=True, hash=False, init=True),
+        Attribute(
+            name="metadata",
+            default=None,
+            validator=None,
+            repr=True,
+            cmp=True,
+            hash=False,
+            init=True,
+            kw_only=False,
+        ),
     )
     cls_counter = 0
 
-    def __init__(self, default, validator, repr, cmp, hash, init, converter,
-                 metadata, type):
+    def __init__(
+        self,
+        default,
+        validator,
+        repr,
+        cmp,
+        hash,
+        init,
+        converter,
+        metadata,
+        type,
+        kw_only,
+    ):
         _CountingAttr.cls_counter += 1
         self.counter = _CountingAttr.cls_counter
         self._default = default
@@ -1536,6 +1877,7 @@ class _CountingAttr(object):
         self.converter = converter
         self.metadata = metadata
         self.type = type
+        self.kw_only = kw_only
 
     def validator(self, meth):
         """
@@ -1587,6 +1929,7 @@ class Factory(object):
 
     .. versionadded:: 17.1.0  *takes_self*
     """
+
     factory = attrib()
     takes_self = attrib()
 
@@ -1636,7 +1979,7 @@ def make_class(name, attrs, bases=(object,), **attributes_arguments):
     type_ = type(
         name,
         bases,
-        {} if post_init is None else {"__attrs_post_init__": post_init}
+        {} if post_init is None else {"__attrs_post_init__": post_init},
     )
     # For pickling to work, the __module__ variable needs to be set to the
     # frame where the class is created.  Bypass this step in environments where
@@ -1644,7 +1987,7 @@ def make_class(name, attrs, bases=(object,), **attributes_arguments):
     # defined for arguments greater than 0 (IronPython).
     try:
         type_.__module__ = sys._getframe(1).f_globals.get(
-            "__name__", "__main__",
+            "__name__", "__main__"
         )
     except (AttributeError, ValueError):
         pass
@@ -1661,6 +2004,7 @@ class _AndValidator(object):
     """
     Compose many validators to a single one.
     """
+
     _validators = attrib()
 
     def __call__(self, inst, attr, value):
@@ -1682,7 +2026,8 @@ def and_(*validators):
     vals = []
     for validator in validators:
         vals.extend(
-            validator._validators if isinstance(validator, _AndValidator)
+            validator._validators
+            if isinstance(validator, _AndValidator)
             else [validator]
         )
 
diff --git a/pipenv/vendor/attr/converters.py b/pipenv/vendor/attr/converters.py
index 3b3bac92..37c4a07a 100644
--- a/pipenv/vendor/attr/converters.py
+++ b/pipenv/vendor/attr/converters.py
@@ -4,6 +4,8 @@ Commonly useful converters.
 
 from __future__ import absolute_import, division, print_function
 
+from ._make import NOTHING, Factory
+
 
 def optional(converter):
     """
@@ -13,7 +15,7 @@ def optional(converter):
     :param callable converter: the converter that is used for non-``None``
         values.
 
-    ..  versionadded:: 17.1.0
+    .. versionadded:: 17.1.0
     """
 
     def optional_converter(val):
@@ -22,3 +24,55 @@ def optional(converter):
         return converter(val)
 
     return optional_converter
+
+
+def default_if_none(default=NOTHING, factory=None):
+    """
+    A converter that allows to replace ``None`` values by *default* or the
+    result of *factory*.
+
+    :param default: Value to be used if ``None`` is passed. Passing an instance
+       of :class:`attr.Factory` is supported, however the ``takes_self`` option
+       is *not*.
+    :param callable factory: A callable that takes not parameters whose result
+       is used if ``None`` is passed.
+
+    :raises TypeError: If **neither** *default* or *factory* is passed.
+    :raises TypeError: If **both** *default* and *factory* are passed.
+    :raises ValueError: If an instance of :class:`attr.Factory` is passed with
+       ``takes_self=True``.
+
+    .. versionadded:: 18.2.0
+    """
+    if default is NOTHING and factory is None:
+        raise TypeError("Must pass either `default` or `factory`.")
+
+    if default is not NOTHING and factory is not None:
+        raise TypeError(
+            "Must pass either `default` or `factory` but not both."
+        )
+
+    if factory is not None:
+        default = Factory(factory)
+
+    if isinstance(default, Factory):
+        if default.takes_self:
+            raise ValueError(
+                "`takes_self` is not supported by default_if_none."
+            )
+
+        def default_if_none_converter(val):
+            if val is not None:
+                return val
+
+            return default.factory()
+
+    else:
+
+        def default_if_none_converter(val):
+            if val is not None:
+                return val
+
+            return default
+
+    return default_if_none_converter
diff --git a/pipenv/vendor/attr/converters.pyi b/pipenv/vendor/attr/converters.pyi
new file mode 100644
index 00000000..63b2a386
--- /dev/null
+++ b/pipenv/vendor/attr/converters.pyi
@@ -0,0 +1,12 @@
+from typing import TypeVar, Optional, Callable, overload
+from . import _ConverterType
+
+_T = TypeVar("_T")
+
+def optional(
+    converter: _ConverterType[_T]
+) -> _ConverterType[Optional[_T]]: ...
+@overload
+def default_if_none(default: _T) -> _ConverterType[_T]: ...
+@overload
+def default_if_none(*, factory: Callable[[], _T]) -> _ConverterType[_T]: ...
diff --git a/pipenv/vendor/attr/exceptions.py b/pipenv/vendor/attr/exceptions.py
index f949f3c9..b12e41e9 100644
--- a/pipenv/vendor/attr/exceptions.py
+++ b/pipenv/vendor/attr/exceptions.py
@@ -10,6 +10,7 @@ class FrozenInstanceError(AttributeError):
 
     .. versionadded:: 16.1.0
     """
+
     msg = "can't set attribute"
     args = [msg]
 
@@ -46,3 +47,11 @@ class UnannotatedAttributeError(RuntimeError):
 
     .. versionadded:: 17.3.0
     """
+
+
+class PythonTooOldError(RuntimeError):
+    """
+    An ``attrs`` feature requiring a more recent python version has been used.
+
+    .. versionadded:: 18.2.0
+    """
diff --git a/pipenv/vendor/attr/exceptions.pyi b/pipenv/vendor/attr/exceptions.pyi
new file mode 100644
index 00000000..48fffcc1
--- /dev/null
+++ b/pipenv/vendor/attr/exceptions.pyi
@@ -0,0 +1,7 @@
+class FrozenInstanceError(AttributeError):
+    msg: str = ...
+
+class AttrsAttributeNotFoundError(ValueError): ...
+class NotAnAttrsClassError(ValueError): ...
+class DefaultAlreadySetError(RuntimeError): ...
+class UnannotatedAttributeError(RuntimeError): ...
diff --git a/pipenv/vendor/attr/filters.pyi b/pipenv/vendor/attr/filters.pyi
new file mode 100644
index 00000000..a618140c
--- /dev/null
+++ b/pipenv/vendor/attr/filters.pyi
@@ -0,0 +1,5 @@
+from typing import Union
+from . import Attribute, _FilterType
+
+def include(*what: Union[type, Attribute]) -> _FilterType: ...
+def exclude(*what: Union[type, Attribute]) -> _FilterType: ...
diff --git a/pipenv/vendor/attr/py.typed b/pipenv/vendor/attr/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/pipenv/vendor/attr/validators.py b/pipenv/vendor/attr/validators.py
index f8892fcd..f12d0aa5 100644
--- a/pipenv/vendor/attr/validators.py
+++ b/pipenv/vendor/attr/validators.py
@@ -7,13 +7,7 @@ from __future__ import absolute_import, division, print_function
 from ._make import _AndValidator, and_, attrib, attrs
 
 
-__all__ = [
-    "and_",
-    "in_",
-    "instance_of",
-    "optional",
-    "provides",
-]
+__all__ = ["and_", "in_", "instance_of", "optional", "provides"]
 
 
 @attrs(repr=False, slots=True, hash=True)
@@ -27,16 +21,20 @@ class _InstanceOfValidator(object):
         if not isinstance(value, self.type):
             raise TypeError(
                 "'{name}' must be {type!r} (got {value!r} that is a "
-                "{actual!r})."
-                .format(name=attr.name, type=self.type,
-                        actual=value.__class__, value=value),
-                attr, self.type, value,
+                "{actual!r}).".format(
+                    name=attr.name,
+                    type=self.type,
+                    actual=value.__class__,
+                    value=value,
+                ),
+                attr,
+                self.type,
+                value,
             )
 
     def __repr__(self):
-        return (
-            "<instance_of validator for type {type!r}>"
-            .format(type=self.type)
+        return "<instance_of validator for type {type!r}>".format(
+            type=self.type
         )
 
 
@@ -67,15 +65,17 @@ class _ProvidesValidator(object):
         if not self.interface.providedBy(value):
             raise TypeError(
                 "'{name}' must provide {interface!r} which {value!r} "
-                "doesn't."
-                .format(name=attr.name, interface=self.interface, value=value),
-                attr, self.interface, value,
+                "doesn't.".format(
+                    name=attr.name, interface=self.interface, value=value
+                ),
+                attr,
+                self.interface,
+                value,
             )
 
     def __repr__(self):
-        return (
-            "<provides validator for interface {interface!r}>"
-            .format(interface=self.interface)
+        return "<provides validator for interface {interface!r}>".format(
+            interface=self.interface
         )
 
 
@@ -106,9 +106,8 @@ class _OptionalValidator(object):
         self.validator(inst, attr, value)
 
     def __repr__(self):
-        return (
-            "<optional validator for {what} or None>"
-            .format(what=repr(self.validator))
+        return "<optional validator for {what} or None>".format(
+            what=repr(self.validator)
         )
 
 
@@ -135,16 +134,21 @@ class _InValidator(object):
     options = attrib()
 
     def __call__(self, inst, attr, value):
-        if value not in self.options:
+        try:
+            in_options = value in self.options
+        except TypeError as e:  # e.g. `1 in "abc"`
+            in_options = False
+
+        if not in_options:
             raise ValueError(
-                "'{name}' must be in {options!r} (got {value!r})"
-                .format(name=attr.name, options=self.options, value=value)
+                "'{name}' must be in {options!r} (got {value!r})".format(
+                    name=attr.name, options=self.options, value=value
+                )
             )
 
     def __repr__(self):
-        return (
-            "<in_ validator with options {options!r}>"
-            .format(options=self.options)
+        return "<in_ validator with options {options!r}>".format(
+            options=self.options
         )
 
 
diff --git a/pipenv/vendor/attr/validators.pyi b/pipenv/vendor/attr/validators.pyi
new file mode 100644
index 00000000..abbaedf1
--- /dev/null
+++ b/pipenv/vendor/attr/validators.pyi
@@ -0,0 +1,14 @@
+from typing import Container, List, Union, TypeVar, Type, Any, Optional, Tuple
+from . import _ValidatorType
+
+_T = TypeVar("_T")
+
+def instance_of(
+    type: Union[Tuple[Type[_T], ...], Type[_T]]
+) -> _ValidatorType[_T]: ...
+def provides(interface: Any) -> _ValidatorType[Any]: ...
+def optional(
+    validator: Union[_ValidatorType[_T], List[_ValidatorType[_T]]]
+) -> _ValidatorType[Optional[_T]]: ...
+def in_(options: Container[_T]) -> _ValidatorType[_T]: ...
+def and_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ...
diff --git a/pipenv/vendor/backports/__init__.py b/pipenv/vendor/backports/__init__.py
index 3cd30963..0c64b4c1 100644
--- a/pipenv/vendor/backports/__init__.py
+++ b/pipenv/vendor/backports/__init__.py
@@ -1,7 +1,5 @@
-# See https://pypi.python.org/pypi/backports
-
-from pkgutil import extend_path
-__path__ = extend_path(__path__, __name__)
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)
 from . import weakref
 from . import enum
 from . import shutil_get_terminal_size
+from . import functools_lru_cache
diff --git a/pipenv/vendor/backports/functools_lru_cache.LICENSE b/pipenv/vendor/backports/functools_lru_cache.LICENSE
new file mode 100644
index 00000000..5e795a61
--- /dev/null
+++ b/pipenv/vendor/backports/functools_lru_cache.LICENSE
@@ -0,0 +1,7 @@
+Copyright Jason R. Coombs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/pipenv/vendor/backports/functools_lru_cache.py b/pipenv/vendor/backports/functools_lru_cache.py
new file mode 100644
index 00000000..707c6c76
--- /dev/null
+++ b/pipenv/vendor/backports/functools_lru_cache.py
@@ -0,0 +1,184 @@
+from __future__ import absolute_import
+
+import functools
+from collections import namedtuple
+from threading import RLock
+
+_CacheInfo = namedtuple("CacheInfo", ["hits", "misses", "maxsize", "currsize"])
+
+
+@functools.wraps(functools.update_wrapper)
+def update_wrapper(wrapper,
+                   wrapped,
+                   assigned = functools.WRAPPER_ASSIGNMENTS,
+                   updated = functools.WRAPPER_UPDATES):
+    """
+    Patch two bugs in functools.update_wrapper.
+    """
+    # workaround for http://bugs.python.org/issue3445
+    assigned = tuple(attr for attr in assigned if hasattr(wrapped, attr))
+    wrapper = functools.update_wrapper(wrapper, wrapped, assigned, updated)
+    # workaround for https://bugs.python.org/issue17482
+    wrapper.__wrapped__ = wrapped
+    return wrapper
+
+
+class _HashedSeq(list):
+    __slots__ = 'hashvalue'
+
+    def __init__(self, tup, hash=hash):
+        self[:] = tup
+        self.hashvalue = hash(tup)
+
+    def __hash__(self):
+        return self.hashvalue
+
+
+def _make_key(args, kwds, typed,
+              kwd_mark=(object(),),
+              fasttypes=set([int, str, frozenset, type(None)]),
+              sorted=sorted, tuple=tuple, type=type, len=len):
+    'Make a cache key from optionally typed positional and keyword arguments'
+    key = args
+    if kwds:
+        sorted_items = sorted(kwds.items())
+        key += kwd_mark
+        for item in sorted_items:
+            key += item
+    if typed:
+        key += tuple(type(v) for v in args)
+        if kwds:
+            key += tuple(type(v) for k, v in sorted_items)
+    elif len(key) == 1 and type(key[0]) in fasttypes:
+        return key[0]
+    return _HashedSeq(key)
+
+
+def lru_cache(maxsize=100, typed=False):
+    """Least-recently-used cache decorator.
+
+    If *maxsize* is set to None, the LRU features are disabled and the cache
+    can grow without bound.
+
+    If *typed* is True, arguments of different types will be cached separately.
+    For example, f(3.0) and f(3) will be treated as distinct calls with
+    distinct results.
+
+    Arguments to the cached function must be hashable.
+
+    View the cache statistics named tuple (hits, misses, maxsize, currsize) with
+    f.cache_info().  Clear the cache and statistics with f.cache_clear().
+    Access the underlying function with f.__wrapped__.
+
+    See:  http://en.wikipedia.org/wiki/Cache_algorithms#Least_Recently_Used
+
+    """
+
+    # Users should only access the lru_cache through its public API:
+    #       cache_info, cache_clear, and f.__wrapped__
+    # The internals of the lru_cache are encapsulated for thread safety and
+    # to allow the implementation to change (including a possible C version).
+
+    def decorating_function(user_function):
+
+        cache = dict()
+        stats = [0, 0]                  # make statistics updateable non-locally
+        HITS, MISSES = 0, 1             # names for the stats fields
+        make_key = _make_key
+        cache_get = cache.get           # bound method to lookup key or return None
+        _len = len                      # localize the global len() function
+        lock = RLock()                  # because linkedlist updates aren't threadsafe
+        root = []                       # root of the circular doubly linked list
+        root[:] = [root, root, None, None]      # initialize by pointing to self
+        nonlocal_root = [root]                  # make updateable non-locally
+        PREV, NEXT, KEY, RESULT = 0, 1, 2, 3    # names for the link fields
+
+        if maxsize == 0:
+
+            def wrapper(*args, **kwds):
+                # no caching, just do a statistics update after a successful call
+                result = user_function(*args, **kwds)
+                stats[MISSES] += 1
+                return result
+
+        elif maxsize is None:
+
+            def wrapper(*args, **kwds):
+                # simple caching without ordering or size limit
+                key = make_key(args, kwds, typed)
+                result = cache_get(key, root)   # root used here as a unique not-found sentinel
+                if result is not root:
+                    stats[HITS] += 1
+                    return result
+                result = user_function(*args, **kwds)
+                cache[key] = result
+                stats[MISSES] += 1
+                return result
+
+        else:
+
+            def wrapper(*args, **kwds):
+                # size limited caching that tracks accesses by recency
+                key = make_key(args, kwds, typed) if kwds or typed else args
+                with lock:
+                    link = cache_get(key)
+                    if link is not None:
+                        # record recent use of the key by moving it to the front of the list
+                        root, = nonlocal_root
+                        link_prev, link_next, key, result = link
+                        link_prev[NEXT] = link_next
+                        link_next[PREV] = link_prev
+                        last = root[PREV]
+                        last[NEXT] = root[PREV] = link
+                        link[PREV] = last
+                        link[NEXT] = root
+                        stats[HITS] += 1
+                        return result
+                result = user_function(*args, **kwds)
+                with lock:
+                    root, = nonlocal_root
+                    if key in cache:
+                        # getting here means that this same key was added to the
+                        # cache while the lock was released.  since the link
+                        # update is already done, we need only return the
+                        # computed result and update the count of misses.
+                        pass
+                    elif _len(cache) >= maxsize:
+                        # use the old root to store the new key and result
+                        oldroot = root
+                        oldroot[KEY] = key
+                        oldroot[RESULT] = result
+                        # empty the oldest link and make it the new root
+                        root = nonlocal_root[0] = oldroot[NEXT]
+                        oldkey = root[KEY]
+                        root[KEY] = root[RESULT] = None
+                        # now update the cache dictionary for the new links
+                        del cache[oldkey]
+                        cache[key] = oldroot
+                    else:
+                        # put result in a new link at the front of the list
+                        last = root[PREV]
+                        link = [last, root, key, result]
+                        last[NEXT] = root[PREV] = cache[key] = link
+                    stats[MISSES] += 1
+                return result
+
+        def cache_info():
+            """Report cache statistics"""
+            with lock:
+                return _CacheInfo(stats[HITS], stats[MISSES], maxsize, len(cache))
+
+        def cache_clear():
+            """Clear the cache and cache statistics"""
+            with lock:
+                cache.clear()
+                root = nonlocal_root[0]
+                root[:] = [root, root, None, None]
+                stats[:] = [0, 0]
+
+        wrapper.__wrapped__ = user_function
+        wrapper.cache_info = cache_info
+        wrapper.cache_clear = cache_clear
+        return update_wrapper(wrapper, user_function)
+
+    return decorating_function
diff --git a/pipenv/vendor/backports/shutil_get_terminal_size/__init__.py b/pipenv/vendor/backports/shutil_get_terminal_size/__init__.py
index fa12816e..cfcbdf66 100644
--- a/pipenv/vendor/backports/shutil_get_terminal_size/__init__.py
+++ b/pipenv/vendor/backports/shutil_get_terminal_size/__init__.py
@@ -1,9 +1,11 @@
-__title__ = "shutil_backports"
-__version__ = "0.1.0"
+"""A backport of the get_terminal_size function from Python 3.3's shutil."""
+
+__title__ = "backports.shutil_get_terminal_size"
+__version__ = "1.0.0"
 __license__ = "MIT"
 __author__ = "Christopher Rosell"
 __copyright__ = "Copyright 2014 Christopher Rosell"
 
 __all__ = ["get_terminal_size"]
 
-from .get_terminal_size import *
+from .get_terminal_size import get_terminal_size
diff --git a/pipenv/vendor/backports/shutil_get_terminal_size/get_terminal_size.py b/pipenv/vendor/backports/shutil_get_terminal_size/get_terminal_size.py
index f1336e58..28c96da8 100644
--- a/pipenv/vendor/backports/shutil_get_terminal_size/get_terminal_size.py
+++ b/pipenv/vendor/backports/shutil_get_terminal_size/get_terminal_size.py
@@ -39,7 +39,7 @@ try:
         except Exception:
             pass
 
-        return columns, lines
+        return terminal_size(columns, lines)
 
 except ImportError:
     import fcntl
@@ -52,7 +52,7 @@ except ImportError:
         except Exception:
             columns = lines = 0
 
-        return columns, lines
+        return terminal_size(columns, lines)
 
 
 def get_terminal_size(fallback=(80, 24)):
@@ -74,7 +74,7 @@ def get_terminal_size(fallback=(80, 24)):
 
     The value returned is a named tuple of type os.terminal_size.
     """
-    # Attempt to use the environment first
+    # Try the environment first
     try:
         columns = int(os.environ["COLUMNS"])
     except (KeyError, ValueError):
@@ -88,13 +88,14 @@ def get_terminal_size(fallback=(80, 24)):
     # Only query if necessary
     if columns <= 0 or lines <= 0:
         try:
-            columns, lines = _get_terminal_size(sys.__stdout__.fileno())
+            size = _get_terminal_size(sys.__stdout__.fileno())
         except (NameError, OSError):
-            pass
+            size = terminal_size(*fallback)
 
-    # Use fallback as last resort
-    if columns <= 0 and lines <= 0:
-        columns, lines = fallback
+        if columns <= 0:
+            columns = size.columns
+        if lines <= 0:
+            lines = size.lines
 
     return terminal_size(columns, lines)
 
diff --git a/pipenv/vendor/cerberus/LICENSE b/pipenv/vendor/cerberus/LICENSE
new file mode 100644
index 00000000..2e0bcdd8
--- /dev/null
+++ b/pipenv/vendor/cerberus/LICENSE
@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2012-2016 Nicola Iarocci.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
diff --git a/pipenv/vendor/cerberus/__init__.py b/pipenv/vendor/cerberus/__init__.py
new file mode 100644
index 00000000..4b528cff
--- /dev/null
+++ b/pipenv/vendor/cerberus/__init__.py
@@ -0,0 +1,29 @@
+"""
+    Extensible validation for Python dictionaries.
+
+    :copyright: 2012-2016 by Nicola Iarocci.
+    :license: ISC, see LICENSE for more details.
+
+    Full documentation is available at http://python-cerberus.org/
+
+"""
+
+from __future__ import absolute_import
+
+from cerberus.validator import DocumentError, Validator
+from cerberus.schema import (rules_set_registry, schema_registry, Registry,
+                             SchemaError)
+from cerberus.utils import TypeDefinition
+
+
+__version__ = "1.2"
+
+__all__ = [
+    DocumentError.__name__,
+    Registry.__name__,
+    SchemaError.__name__,
+    TypeDefinition.__name__,
+    Validator.__name__,
+    'schema_registry',
+    'rules_set_registry'
+]
diff --git a/pipenv/vendor/cerberus/errors.py b/pipenv/vendor/cerberus/errors.py
new file mode 100644
index 00000000..4c497eeb
--- /dev/null
+++ b/pipenv/vendor/cerberus/errors.py
@@ -0,0 +1,626 @@
+# -*-: coding utf-8 -*-
+""" This module contains the error-related constants and classes. """
+
+from __future__ import absolute_import
+
+from collections import defaultdict, namedtuple, MutableMapping
+from copy import copy, deepcopy
+from functools import wraps
+from pprint import pformat
+
+from cerberus.platform import PYTHON_VERSION
+from cerberus.utils import compare_paths_lt, quote_string
+
+
+ErrorDefinition = namedtuple('ErrorDefinition', 'code, rule')
+"""
+This class is used to define possible errors. Each distinguishable error is
+defined by a *unique* error ``code`` as integer and the ``rule`` that can
+cause it as string.
+The instances' names do not contain a common prefix as they are supposed to be
+referenced within the module namespace, e.g. ``errors.CUSTOM``.
+"""
+
+
+# custom
+CUSTOM = ErrorDefinition(0x00, None)
+
+# existence
+DOCUMENT_MISSING = ErrorDefinition(0x01, None)  # issues/141
+DOCUMENT_MISSING = "document is missing"
+REQUIRED_FIELD = ErrorDefinition(0x02, 'required')
+UNKNOWN_FIELD = ErrorDefinition(0x03, None)
+DEPENDENCIES_FIELD = ErrorDefinition(0x04, 'dependencies')
+DEPENDENCIES_FIELD_VALUE = ErrorDefinition(0x05, 'dependencies')
+EXCLUDES_FIELD = ErrorDefinition(0x06, 'excludes')
+
+# shape
+DOCUMENT_FORMAT = ErrorDefinition(0x21, None)  # issues/141
+DOCUMENT_FORMAT = "'{0}' is not a document, must be a dict"
+EMPTY_NOT_ALLOWED = ErrorDefinition(0x22, 'empty')
+NOT_NULLABLE = ErrorDefinition(0x23, 'nullable')
+BAD_TYPE = ErrorDefinition(0x24, 'type')
+BAD_TYPE_FOR_SCHEMA = ErrorDefinition(0x25, 'schema')
+ITEMS_LENGTH = ErrorDefinition(0x26, 'items')
+MIN_LENGTH = ErrorDefinition(0x27, 'minlength')
+MAX_LENGTH = ErrorDefinition(0x28, 'maxlength')
+
+
+# color
+REGEX_MISMATCH = ErrorDefinition(0x41, 'regex')
+MIN_VALUE = ErrorDefinition(0x42, 'min')
+MAX_VALUE = ErrorDefinition(0x43, 'max')
+UNALLOWED_VALUE = ErrorDefinition(0x44, 'allowed')
+UNALLOWED_VALUES = ErrorDefinition(0x45, 'allowed')
+FORBIDDEN_VALUE = ErrorDefinition(0x46, 'forbidden')
+FORBIDDEN_VALUES = ErrorDefinition(0x47, 'forbidden')
+
+# other
+NORMALIZATION = ErrorDefinition(0x60, None)
+COERCION_FAILED = ErrorDefinition(0x61, 'coerce')
+RENAMING_FAILED = ErrorDefinition(0x62, 'rename_handler')
+READONLY_FIELD = ErrorDefinition(0x63, 'readonly')
+SETTING_DEFAULT_FAILED = ErrorDefinition(0x64, 'default_setter')
+
+# groups
+ERROR_GROUP = ErrorDefinition(0x80, None)
+MAPPING_SCHEMA = ErrorDefinition(0x81, 'schema')
+SEQUENCE_SCHEMA = ErrorDefinition(0x82, 'schema')
+KEYSCHEMA = ErrorDefinition(0x83, 'keyschema')
+VALUESCHEMA = ErrorDefinition(0x84, 'valueschema')
+BAD_ITEMS = ErrorDefinition(0x8f, 'items')
+
+LOGICAL = ErrorDefinition(0x90, None)
+NONEOF = ErrorDefinition(0x91, 'noneof')
+ONEOF = ErrorDefinition(0x92, 'oneof')
+ANYOF = ErrorDefinition(0x93, 'anyof')
+ALLOF = ErrorDefinition(0x94, 'allof')
+
+
+""" SchemaError messages """
+
+SCHEMA_ERROR_DEFINITION_TYPE = \
+    "schema definition for field '{0}' must be a dict"
+SCHEMA_ERROR_MISSING = "validation schema missing"
+
+
+""" Error representations """
+
+
+class ValidationError(object):
+    """ A simple class to store and query basic error information. """
+    def __init__(self, document_path, schema_path, code, rule, constraint,
+                 value, info):
+        self.document_path = document_path
+        """ The path to the field within the document that caused the error.
+            Type: :class:`tuple` """
+        self.schema_path = schema_path
+        """ The path to the rule within the schema that caused the error.
+            Type: :class:`tuple` """
+        self.code = code
+        """ The error's identifier code. Type: :class:`int` """
+        self.rule = rule
+        """ The rule that failed. Type: `string` """
+        self.constraint = constraint
+        """ The constraint that failed. """
+        self.value = value
+        """ The value that failed. """
+        self.info = info
+        """ May hold additional information about the error.
+            Type: :class:`tuple` """
+
+    def __eq__(self, other):
+        """ Assumes the errors relate to the same document and schema. """
+        return hash(self) == hash(other)
+
+    def __hash__(self):
+        """ Expects that all other properties are transitively determined. """
+        return hash(self.document_path) ^ hash(self.schema_path) \
+            ^ hash(self.code)
+
+    def __lt__(self, other):
+        if self.document_path != other.document_path:
+            return compare_paths_lt(self.document_path, other.document_path)
+        else:
+            return compare_paths_lt(self.schema_path, other.schema_path)
+
+    def __repr__(self):
+        return "{class_name} @ {memptr} ( " \
+               "document_path={document_path}," \
+               "schema_path={schema_path}," \
+               "code={code}," \
+               "constraint={constraint}," \
+               "value={value}," \
+               "info={info} )"\
+               .format(class_name=self.__class__.__name__, memptr=hex(id(self)),  # noqa: E501
+                       document_path=self.document_path,
+                       schema_path=self.schema_path,
+                       code=hex(self.code),
+                       constraint=quote_string(self.constraint),
+                       value=quote_string(self.value),
+                       info=self.info)
+
+    @property
+    def child_errors(self):
+        """
+        A list that contains the individual errors of a bulk validation error.
+        """
+        return self.info[0] if self.is_group_error else None
+
+    @property
+    def definitions_errors(self):
+        """ Dictionary with errors of an *of-rule mapped to the index of the
+            definition it occurred in. Returns :obj:`None` if not applicable.
+            """
+        if not self.is_logic_error:
+            return None
+
+        result = defaultdict(list)
+        for error in self.child_errors:
+            i = error.schema_path[len(self.schema_path)]
+            result[i].append(error)
+        return result
+
+    @property
+    def field(self):
+        """ Field of the contextual mapping, possibly :obj:`None`. """
+        if self.document_path:
+            return self.document_path[-1]
+        else:
+            return None
+
+    @property
+    def is_group_error(self):
+        """ ``True`` for errors of bulk validations. """
+        return bool(self.code & ERROR_GROUP.code)
+
+    @property
+    def is_logic_error(self):
+        """ ``True`` for validation errors against different schemas with
+            *of-rules. """
+        return bool(self.code & LOGICAL.code - ERROR_GROUP.code)
+
+    @property
+    def is_normalization_error(self):
+        """ ``True`` for normalization errors. """
+        return bool(self.code & NORMALIZATION.code)
+
+
+class ErrorList(list):
+    """ A list for :class:`~cerberus.errors.ValidationError` instances that
+        can be queried with the ``in`` keyword for a particular
+        :class:`~cerberus.errors.ErrorDefinition`. """
+    def __contains__(self, error_definition):
+        for code in (x.code for x in self):
+            if code == error_definition.code:
+                return True
+        return False
+
+
+class ErrorTreeNode(MutableMapping):
+    __slots__ = ('descendants', 'errors', 'parent_node', 'path', 'tree_root')
+
+    def __init__(self, path, parent_node):
+        self.parent_node = parent_node
+        self.tree_root = self.parent_node.tree_root
+        self.path = path[:self.parent_node.depth + 1]
+        self.errors = ErrorList()
+        self.descendants = {}
+
+    def __add__(self, error):
+        self.add(error)
+        return self
+
+    def __contains__(self, item):
+        if isinstance(item, ErrorDefinition):
+            return item in self.errors
+        else:
+            return item in self.descendants
+
+    def __delitem__(self, key):
+        del self.descendants[key]
+
+    def __iter__(self):
+        return iter(self.errors)
+
+    def __getitem__(self, item):
+        if isinstance(item, ErrorDefinition):
+            for error in self.errors:
+                if item.code == error.code:
+                    return error
+        else:
+            return self.descendants.get(item)
+
+    def __len__(self):
+        return len(self.errors)
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __setitem__(self, key, value):
+        self.descendants[key] = value
+
+    def __str__(self):
+        return str(self.errors) + ',' + str(self.descendants)
+
+    @property
+    def depth(self):
+        return len(self.path)
+
+    @property
+    def tree_type(self):
+        return self.tree_root.tree_type
+
+    def add(self, error):
+        error_path = self._path_of_(error)
+
+        key = error_path[self.depth]
+        if key not in self.descendants:
+            self[key] = ErrorTreeNode(error_path, self)
+
+        if len(error_path) == self.depth + 1:
+            self[key].errors.append(error)
+            self[key].errors.sort()
+            if error.is_group_error:
+                for child_error in error.child_errors:
+                    self.tree_root += child_error
+        else:
+            self[key] += error
+
+    def _path_of_(self, error):
+        return getattr(error, self.tree_type + '_path')
+
+
+class ErrorTree(ErrorTreeNode):
+    """ Base class for :class:`~cerberus.errors.DocumentErrorTree` and
+        :class:`~cerberus.errors.SchemaErrorTree`. """
+    def __init__(self, errors=[]):
+        self.parent_node = None
+        self.tree_root = self
+        self.path = ()
+        self.errors = ErrorList()
+        self.descendants = {}
+        for error in errors:
+            self += error
+
+    def add(self, error):
+        """ Add an error to the tree.
+
+        :param error: :class:`~cerberus.errors.ValidationError`
+        """
+        if not self._path_of_(error):
+            self.errors.append(error)
+            self.errors.sort()
+        else:
+            super(ErrorTree, self).add(error)
+
+    def fetch_errors_from(self, path):
+        """ Returns all errors for a particular path.
+
+        :param path: :class:`tuple` of :term:`hashable` s.
+        :rtype: :class:`~cerberus.errors.ErrorList`
+        """
+        node = self.fetch_node_from(path)
+        if node is not None:
+            return node.errors
+        else:
+            return ErrorList()
+
+    def fetch_node_from(self, path):
+        """ Returns a node for a path.
+
+        :param path: Tuple of :term:`hashable` s.
+        :rtype: :class:`~cerberus.errors.ErrorTreeNode` or :obj:`None`
+        """
+        context = self
+        for key in path:
+            context = context[key]
+            if context is None:
+                break
+        return context
+
+
+class DocumentErrorTree(ErrorTree):
+    """ Implements a dict-like class to query errors by indexes following the
+        structure of a validated document. """
+    tree_type = 'document'
+
+
+class SchemaErrorTree(ErrorTree):
+    """ Implements a dict-like class to query errors by indexes following the
+        structure of the used schema. """
+    tree_type = 'schema'
+
+
+class BaseErrorHandler(object):
+    """ Base class for all error handlers.
+        Subclasses are identified as error-handlers with an instance-test. """
+    def __init__(self, *args, **kwargs):
+        """ Optionally initialize a new instance. """
+        pass
+
+    def __call__(self, errors):
+        """ Returns errors in a handler-specific format.
+
+        :param errors: An object containing the errors.
+        :type errors: :term:`iterable` of
+                      :class:`~cerberus.errors.ValidationError` instances or a
+                      :class:`~cerberus.Validator` instance
+        """
+        raise NotImplementedError
+
+    def __iter__(self):
+        """ Be a superhero and implement an iterator over errors. """
+        raise NotImplementedError
+
+    def add(self, error):
+        """ Add an error to the errors' container object of a handler.
+
+        :param error: The error to add.
+        :type error: :class:`~cerberus.errors.ValidationError`
+        """
+        raise NotImplementedError
+
+    def emit(self, error):
+        """ Optionally emits an error in the handler's format to a stream.
+            Or light a LED, or even shut down a power plant.
+
+        :param error: The error to emit.
+        :type error: :class:`~cerberus.errors.ValidationError`
+        """
+        pass
+
+    def end(self, validator):
+        """ Gets called when a validation ends.
+
+        :param validator: The calling validator.
+        :type validator: :class:`~cerberus.Validator` """
+        pass
+
+    def extend(self, errors):
+        """ Adds all errors to the handler's container object.
+
+        :param errors: The errors to add.
+        :type errors: :term:`iterable` of
+                      :class:`~cerberus.errors.ValidationError` instances
+        """
+        for error in errors:
+            self.add(error)
+
+    def start(self, validator):
+        """ Gets called when a validation starts.
+
+        :param validator: The calling validator.
+        :type validator: :class:`~cerberus.Validator`
+        """
+        pass
+
+
+class ToyErrorHandler(BaseErrorHandler):
+    def __call__(self, *args, **kwargs):
+        raise RuntimeError('This is not supposed to happen.')
+
+    def clear(self):
+        pass
+
+
+def encode_unicode(f):
+    """Cerberus error messages expect regular binary strings.
+    If unicode is used in a ValidationError message can't be printed.
+
+    This decorator ensures that if legacy Python is used unicode
+    strings are encoded before passing to a function.
+    """
+    @wraps(f)
+    def wrapped(obj, error):
+
+        def _encode(value):
+            """Helper encoding unicode strings into binary utf-8"""
+            if isinstance(value, unicode):  # noqa: F821
+                return value.encode('utf-8')
+            return value
+
+        error = copy(error)
+        error.document_path = _encode(error.document_path)
+        error.schema_path = _encode(error.schema_path)
+        error.constraint = _encode(error.constraint)
+        error.value = _encode(error.value)
+        error.info = _encode(error.info)
+        return f(obj, error)
+
+    return wrapped if PYTHON_VERSION < 3 else f
+
+
+class BasicErrorHandler(BaseErrorHandler):
+    """ Models cerberus' legacy. Returns a :class:`dict`. When mangled
+        through :class:`str` a pretty-formatted representation of that
+        tree is returned.
+    """
+    messages = {0x00: "{0}",
+
+                0x01: "document is missing",
+                0x02: "required field",
+                0x03: "unknown field",
+                0x04: "field '{0}' is required",
+                0x05: "depends on these values: {constraint}",
+                0x06: "{0} must not be present with '{field}'",
+
+                0x21: "'{0}' is not a document, must be a dict",
+                0x22: "empty values not allowed",
+                0x23: "null value not allowed",
+                0x24: "must be of {constraint} type",
+                0x25: "must be of dict type",
+                0x26: "length of list should be {constraint}, it is {0}",
+                0x27: "min length is {constraint}",
+                0x28: "max length is {constraint}",
+
+                0x41: "value does not match regex '{constraint}'",
+                0x42: "min value is {constraint}",
+                0x43: "max value is {constraint}",
+                0x44: "unallowed value {value}",
+                0x45: "unallowed values {0}",
+                0x46: "unallowed value {value}",
+                0x47: "unallowed values {0}",
+
+                0x61: "field '{field}' cannot be coerced: {0}",
+                0x62: "field '{field}' cannot be renamed: {0}",
+                0x63: "field is read-only",
+                0x64: "default value for '{field}' cannot be set: {0}",
+
+                0x81: "mapping doesn't validate subschema: {0}",
+                0x82: "one or more sequence-items don't validate: {0}",
+                0x83: "one or more keys of a mapping  don't validate: {0}",
+                0x84: "one or more values in a mapping don't validate: {0}",
+                0x85: "one or more sequence-items don't validate: {0}",
+
+                0x91: "one or more definitions validate",
+                0x92: "none or more than one rule validate",
+                0x93: "no definitions validate",
+                0x94: "one or more definitions don't validate"
+                }
+
+    def __init__(self, tree=None):
+        self.tree = {} if tree is None else tree
+
+    def __call__(self, errors=None):
+        if errors is not None:
+            self.clear()
+            self.extend(errors)
+        return self.pretty_tree
+
+    def __str__(self):
+        return pformat(self.pretty_tree)
+
+    @property
+    def pretty_tree(self):
+        pretty = deepcopy(self.tree)
+        for field in pretty:
+            self._purge_empty_dicts(pretty[field])
+        return pretty
+
+    @encode_unicode
+    def add(self, error):
+        # Make sure the original error is not altered with
+        # error paths specific to the handler.
+        error = deepcopy(error)
+
+        self._rewrite_error_path(error)
+
+        if error.is_logic_error:
+            self._insert_logic_error(error)
+        elif error.is_group_error:
+            self._insert_group_error(error)
+        elif error.code in self.messages:
+            self._insert_error(error.document_path,
+                               self._format_message(error.field, error))
+
+    def clear(self):
+        self.tree = {}
+
+    def start(self, validator):
+        self.clear()
+
+    def _format_message(self, field, error):
+        return self.messages[error.code].format(
+            *error.info, constraint=error.constraint,
+            field=field, value=error.value)
+
+    def _insert_error(self, path, node):
+        """ Adds an error or sub-tree to :attr:tree.
+
+        :param path: Path to the error.
+        :type path: Tuple of strings and integers.
+        :param node: An error message or a sub-tree.
+        :type node: String or dictionary.
+        """
+        field = path[0]
+        if len(path) == 1:
+            if field in self.tree:
+                subtree = self.tree[field].pop()
+                self.tree[field] += [node, subtree]
+            else:
+                self.tree[field] = [node, {}]
+        elif len(path) >= 1:
+            if field not in self.tree:
+                self.tree[field] = [{}]
+            subtree = self.tree[field][-1]
+
+            if subtree:
+                new = self.__class__(tree=copy(subtree))
+            else:
+                new = self.__class__()
+            new._insert_error(path[1:], node)
+            subtree.update(new.tree)
+
+    def _insert_group_error(self, error):
+        for child_error in error.child_errors:
+            if child_error.is_logic_error:
+                self._insert_logic_error(child_error)
+            elif child_error.is_group_error:
+                self._insert_group_error(child_error)
+            else:
+                self._insert_error(child_error.document_path,
+                                   self._format_message(child_error.field,
+                                                        child_error))
+
+    def _insert_logic_error(self, error):
+        field = error.field
+        self._insert_error(error.document_path,
+                           self._format_message(field, error))
+
+        for definition_errors in error.definitions_errors.values():
+            for child_error in definition_errors:
+                if child_error.is_logic_error:
+                    self._insert_logic_error(child_error)
+                elif child_error.is_group_error:
+                    self._insert_group_error(child_error)
+                else:
+                    self._insert_error(child_error.document_path,
+                                       self._format_message(field, child_error))
+
+    def _purge_empty_dicts(self, error_list):
+        subtree = error_list[-1]
+        if not error_list[-1]:
+            error_list.pop()
+        else:
+            for key in subtree:
+                self._purge_empty_dicts(subtree[key])
+
+    def _rewrite_error_path(self, error, offset=0):
+        """
+        Recursively rewrites the error path to correctly represent logic errors
+        """
+        if error.is_logic_error:
+            self._rewrite_logic_error_path(error, offset)
+        elif error.is_group_error:
+            self._rewrite_group_error_path(error, offset)
+
+    def _rewrite_group_error_path(self, error, offset=0):
+        child_start = len(error.document_path) - offset
+
+        for child_error in error.child_errors:
+            relative_path = child_error.document_path[child_start:]
+            child_error.document_path = error.document_path + relative_path
+
+            self._rewrite_error_path(child_error, offset)
+
+    def _rewrite_logic_error_path(self, error, offset=0):
+        child_start = len(error.document_path) - offset
+
+        for i, definition_errors in error.definitions_errors.items():
+            if not definition_errors:
+                continue
+
+            nodename = '%s definition %s' % (error.rule, i)
+            path = error.document_path + (nodename,)
+
+            for child_error in definition_errors:
+                rel_path = child_error.document_path[child_start:]
+                child_error.document_path = path + rel_path
+
+                self._rewrite_error_path(child_error, offset + 1)
+
+
+class SchemaErrorHandler(BasicErrorHandler):
+    messages = BasicErrorHandler.messages.copy()
+    messages[0x03] = "unknown rule"
diff --git a/pipenv/vendor/cerberus/platform.py b/pipenv/vendor/cerberus/platform.py
new file mode 100644
index 00000000..eca9858d
--- /dev/null
+++ b/pipenv/vendor/cerberus/platform.py
@@ -0,0 +1,14 @@
+""" Platform-dependent objects """
+
+import sys
+
+
+PYTHON_VERSION = float(sys.version_info[0]) + float(sys.version_info[1]) / 10
+
+
+if PYTHON_VERSION < 3:
+    _str_type = basestring  # noqa: F821
+    _int_types = (int, long)  # noqa: F821
+else:
+    _str_type = str
+    _int_types = (int,)
diff --git a/pipenv/vendor/cerberus/schema.py b/pipenv/vendor/cerberus/schema.py
new file mode 100644
index 00000000..3ddce172
--- /dev/null
+++ b/pipenv/vendor/cerberus/schema.py
@@ -0,0 +1,482 @@
+from __future__ import absolute_import
+
+from collections import (Callable, Hashable, Iterable, Mapping,
+                         MutableMapping, Sequence)
+from copy import copy
+
+from cerberus import errors
+from cerberus.platform import _str_type
+from cerberus.utils import (get_Validator_class, validator_factory,
+                            mapping_hash, TypeDefinition)
+
+
+class _Abort(Exception):
+    pass
+
+
+class SchemaError(Exception):
+    """ Raised when the validation schema is missing, has the wrong format or
+        contains errors. """
+    pass
+
+
+class DefinitionSchema(MutableMapping):
+    """ A dict-subclass for caching of validated schemas. """
+
+    def __new__(cls, *args, **kwargs):
+        if 'SchemaValidator' not in globals():
+            global SchemaValidator
+            SchemaValidator = validator_factory('SchemaValidator',
+                                                SchemaValidatorMixin)
+            types_mapping = SchemaValidator.types_mapping.copy()
+            types_mapping.update({
+                'callable': TypeDefinition('callable', (Callable,), ()),
+                'hashable': TypeDefinition('hashable', (Hashable,), ())
+            })
+            SchemaValidator.types_mapping = types_mapping
+
+        return super(DefinitionSchema, cls).__new__(cls)
+
+    def __init__(self, validator, schema={}):
+        """
+        :param validator: An instance of Validator-(sub-)class that uses this
+                          schema.
+        :param schema: A definition-schema as ``dict``. Defaults to an empty
+                       one.
+        """
+        if not isinstance(validator, get_Validator_class()):
+            raise RuntimeError('validator argument must be a Validator-'
+                               'instance.')
+        self.validator = validator
+
+        if isinstance(schema, _str_type):
+            schema = validator.schema_registry.get(schema, schema)
+
+        if not isinstance(schema, Mapping):
+            try:
+                schema = dict(schema)
+            except Exception:
+                raise SchemaError(
+                    errors.SCHEMA_ERROR_DEFINITION_TYPE.format(schema))
+
+        self.validation_schema = SchemaValidationSchema(validator)
+        self.schema_validator = SchemaValidator(
+            None, allow_unknown=self.validation_schema,
+            error_handler=errors.SchemaErrorHandler,
+            target_schema=schema, target_validator=validator)
+
+        schema = self.expand(schema)
+        self.validate(schema)
+        self.schema = schema
+
+    def __delitem__(self, key):
+        _new_schema = self.schema.copy()
+        try:
+            del _new_schema[key]
+        except ValueError:
+            raise SchemaError("Schema has no field '%s' defined" % key)
+        except Exception as e:
+            raise e
+        else:
+            del self.schema[key]
+
+    def __getitem__(self, item):
+        return self.schema[item]
+
+    def __iter__(self):
+        return iter(self.schema)
+
+    def __len__(self):
+        return len(self.schema)
+
+    def __repr__(self):
+        return str(self)
+
+    def __setitem__(self, key, value):
+        value = self.expand({0: value})[0]
+        self.validate({key: value})
+        self.schema[key] = value
+
+    def __str__(self):
+        return str(self.schema)
+
+    def copy(self):
+        return self.__class__(self.validator, self.schema.copy())
+
+    @classmethod
+    def expand(cls, schema):
+        try:
+            schema = cls._expand_logical_shortcuts(schema)
+            schema = cls._expand_subschemas(schema)
+        except Exception:
+            pass
+        return schema
+
+    @classmethod
+    def _expand_logical_shortcuts(cls, schema):
+        """ Expand agglutinated rules in a definition-schema.
+
+        :param schema: The schema-definition to expand.
+        :return: The expanded schema-definition.
+        """
+        def is_of_rule(x):
+            return isinstance(x, _str_type) and \
+                x.startswith(('allof_', 'anyof_', 'noneof_', 'oneof_'))
+
+        for field in schema:
+            for of_rule in (x for x in schema[field] if is_of_rule(x)):
+                operator, rule = of_rule.split('_')
+                schema[field].update({operator: []})
+                for value in schema[field][of_rule]:
+                    schema[field][operator].append({rule: value})
+                del schema[field][of_rule]
+        return schema
+
+    @classmethod
+    def _expand_subschemas(cls, schema):
+        def has_schema_rule():
+            return isinstance(schema[field], Mapping) and \
+                'schema' in schema[field]
+
+        def has_mapping_schema():
+            """ Tries to determine heuristically if the schema-constraints are
+                aimed to mappings. """
+            try:
+                return all(isinstance(x, Mapping) for x
+                           in schema[field]['schema'].values())
+            except TypeError:
+                return False
+
+        for field in schema:
+            if not has_schema_rule():
+                pass
+            elif has_mapping_schema():
+                schema[field]['schema'] = cls.expand(schema[field]['schema'])
+            else:  # assumes schema-constraints for a sequence
+                schema[field]['schema'] = \
+                    cls.expand({0: schema[field]['schema']})[0]
+
+            for rule in ('keyschema', 'valueschema'):
+                if rule in schema[field]:
+                    schema[field][rule] = \
+                        cls.expand({0: schema[field][rule]})[0]
+
+            for rule in ('allof', 'anyof', 'items', 'noneof', 'oneof'):
+                if rule in schema[field]:
+                    if not isinstance(schema[field][rule], Sequence):
+                        continue
+                    new_rules_definition = []
+                    for item in schema[field][rule]:
+                        new_rules_definition.append(cls.expand({0: item})[0])
+                    schema[field][rule] = new_rules_definition
+        return schema
+
+    def update(self, schema):
+        try:
+            schema = self.expand(schema)
+            _new_schema = self.schema.copy()
+            _new_schema.update(schema)
+            self.validate(_new_schema)
+        except ValueError:
+            raise SchemaError(errors.SCHEMA_ERROR_DEFINITION_TYPE
+                              .format(schema))
+        except Exception as e:
+            raise e
+        else:
+            self.schema = _new_schema
+
+    def regenerate_validation_schema(self):
+        self.validation_schema = SchemaValidationSchema(self.validator)
+
+    def validate(self, schema=None):
+        if schema is None:
+            schema = self.schema
+        _hash = (mapping_hash(schema),
+                 mapping_hash(self.validator.types_mapping))
+        if _hash not in self.validator._valid_schemas:
+            self._validate(schema)
+            self.validator._valid_schemas.add(_hash)
+
+    def _validate(self, schema):
+        """ Validates a schema that defines rules against supported rules.
+
+        :param schema: The schema to be validated as a legal cerberus schema
+                       according to the rules of this Validator object.
+        """
+        if isinstance(schema, _str_type):
+            schema = self.validator.schema_registry.get(schema, schema)
+
+        if schema is None:
+            raise SchemaError(errors.SCHEMA_ERROR_MISSING)
+
+        schema = copy(schema)
+        for field in schema:
+            if isinstance(schema[field], _str_type):
+                schema[field] = rules_set_registry.get(schema[field],
+                                                       schema[field])
+
+        if not self.schema_validator(schema, normalize=False):
+            raise SchemaError(self.schema_validator.errors)
+
+
+class UnvalidatedSchema(DefinitionSchema):
+    def __init__(self, schema={}):
+        if not isinstance(schema, Mapping):
+            schema = dict(schema)
+        self.schema = schema
+
+    def validate(self, schema):
+        pass
+
+    def copy(self):
+        # Override ancestor's copy, because
+        # UnvalidatedSchema does not have .validator:
+        return self.__class__(self.schema.copy())
+
+
+class SchemaValidationSchema(UnvalidatedSchema):
+    def __init__(self, validator):
+        self.schema = {'allow_unknown': False,
+                       'schema': validator.rules,
+                       'type': 'dict'}
+
+
+class SchemaValidatorMixin(object):
+    """ This validator is extended to validate schemas passed to a Cerberus
+        validator. """
+    @property
+    def known_rules_set_refs(self):
+        """ The encountered references to rules set registry items. """
+        return self._config.get('known_rules_set_refs', ())
+
+    @known_rules_set_refs.setter
+    def known_rules_set_refs(self, value):
+        self._config['known_rules_set_refs'] = value
+
+    @property
+    def known_schema_refs(self):
+        """ The encountered references to schema registry items. """
+        return self._config.get('known_schema_refs', ())
+
+    @known_schema_refs.setter
+    def known_schema_refs(self, value):
+        self._config['known_schema_refs'] = value
+
+    @property
+    def target_schema(self):
+        """ The schema that is being validated. """
+        return self._config['target_schema']
+
+    @property
+    def target_validator(self):
+        """ The validator whose schema is being validated. """
+        return self._config['target_validator']
+
+    def _validate_logical(self, rule, field, value):
+        """ {'allowed': ('allof', 'anyof', 'noneof', 'oneof')} """
+        if not isinstance(value, Sequence):
+            self._error(field, errors.BAD_TYPE)
+            return
+
+        validator = self._get_child_validator(
+            document_crumb=rule, allow_unknown=False,
+            schema=self.target_validator.validation_rules)
+
+        for constraints in value:
+            _hash = (mapping_hash({'turing': constraints}),
+                     mapping_hash(self.target_validator.types_mapping))
+            if _hash in self.target_validator._valid_schemas:
+                continue
+
+            validator(constraints, normalize=False)
+            if validator._errors:
+                self._error(validator._errors)
+            else:
+                self.target_validator._valid_schemas.add(_hash)
+
+    def _validator_bulk_schema(self, field, value):
+        # resolve schema registry reference
+        if isinstance(value, _str_type):
+            if value in self.known_rules_set_refs:
+                return
+            else:
+                self.known_rules_set_refs += (value,)
+            definition = self.target_validator.rules_set_registry.get(value)
+            if definition is None:
+                self._error(field, 'Rules set definition %s not found.' % value)
+                return
+            else:
+                value = definition
+
+        _hash = (mapping_hash({'turing': value}),
+                 mapping_hash(self.target_validator.types_mapping))
+        if _hash in self.target_validator._valid_schemas:
+            return
+
+        validator = self._get_child_validator(
+            document_crumb=field, allow_unknown=False,
+            schema=self.target_validator.rules)
+        validator(value, normalize=False)
+        if validator._errors:
+            self._error(validator._errors)
+        else:
+            self.target_validator._valid_schemas.add(_hash)
+
+    def _validator_dependencies(self, field, value):
+        if isinstance(value, _str_type):
+            pass
+        elif isinstance(value, Mapping):
+            validator = self._get_child_validator(
+                document_crumb=field,
+                schema={'valueschema': {'type': 'list'}},
+                allow_unknown=True
+            )
+            if not validator(value, normalize=False):
+                self._error(validator._errors)
+        elif isinstance(value, Sequence):
+            if not all(isinstance(x, Hashable) for x in value):
+                path = self.document_path + (field,)
+                self._error(path, 'All dependencies must be a hashable type.')
+
+    def _validator_handler(self, field, value):
+        if isinstance(value, Callable):
+            return
+        if isinstance(value, _str_type):
+            if value not in self.target_validator.validators + \
+                    self.target_validator.coercers:
+                self._error(field, '%s is no valid coercer' % value)
+        elif isinstance(value, Iterable):
+            for handler in value:
+                self._validator_handler(field, handler)
+
+    def _validator_items(self, field, value):
+        for i, schema in enumerate(value):
+            self._validator_bulk_schema((field, i), schema)
+
+    def _validator_schema(self, field, value):
+        try:
+            value = self._handle_schema_reference_for_validator(field, value)
+        except _Abort:
+            return
+
+        _hash = (mapping_hash(value),
+                 mapping_hash(self.target_validator.types_mapping))
+        if _hash in self.target_validator._valid_schemas:
+            return
+
+        validator = self._get_child_validator(
+            document_crumb=field,
+            schema=None, allow_unknown=self.root_allow_unknown)
+        validator(self._expand_rules_set_refs(value), normalize=False)
+        if validator._errors:
+            self._error(validator._errors)
+        else:
+            self.target_validator._valid_schemas.add(_hash)
+
+    def _handle_schema_reference_for_validator(self, field, value):
+        if not isinstance(value, _str_type):
+            return value
+        if value in self.known_schema_refs:
+            raise _Abort
+
+        self.known_schema_refs += (value,)
+        definition = self.target_validator.schema_registry.get(value)
+        if definition is None:
+            path = self.document_path + (field,)
+            self._error(path, 'Schema definition {} not found.'.format(value))
+            raise _Abort
+        return definition
+
+    def _expand_rules_set_refs(self, schema):
+        result = {}
+        for k, v in schema.items():
+            if isinstance(v, _str_type):
+                result[k] = self.target_validator.rules_set_registry.get(v)
+            else:
+                result[k] = v
+        return result
+
+    def _validator_type(self, field, value):
+        value = (value,) if isinstance(value, _str_type) else value
+        invalid_constraints = ()
+        for constraint in value:
+            if constraint not in self.target_validator.types:
+                invalid_constraints += (constraint,)
+        if invalid_constraints:
+            path = self.document_path + (field,)
+            self._error(path, 'Unsupported types: %s' % invalid_constraints)
+
+####
+
+
+class Registry(object):
+    """ A registry to store and retrieve schemas and parts of it by a name
+    that can be used in validation schemas.
+
+    :param definitions: Optional, initial definitions.
+    :type definitions: any :term:`mapping` """
+
+    def __init__(self, definitions={}):
+        self._storage = {}
+        self.extend(definitions)
+
+    def add(self, name, definition):
+        """ Register a definition to the registry. Existing definitions are
+        replaced silently.
+
+        :param name: The name which can be used as reference in a validation
+                     schema.
+        :type name: :class:`str`
+        :param definition: The definition.
+        :type definition: any :term:`mapping` """
+        self._storage[name] = self._expand_definition(definition)
+
+    def all(self):
+        """ Returns a :class:`dict` with all registered definitions mapped to
+        their name. """
+        return self._storage
+
+    def clear(self):
+        """ Purge all definitions in the registry. """
+        self._storage.clear()
+
+    def extend(self, definitions):
+        """ Add several definitions at once. Existing definitions are
+        replaced silently.
+
+        :param definitions: The names and definitions.
+        :type definitions: a :term:`mapping` or an :term:`iterable` with
+                           two-value :class:`tuple` s """
+        for name, definition in dict(definitions).items():
+            self.add(name, definition)
+
+    def get(self, name, default=None):
+        """ Retrieve a definition from the registry.
+
+        :param name: The reference that points to the definition.
+        :type name: :class:`str`
+        :param default: Return value if the reference isn't registered. """
+        return self._storage.get(name, default)
+
+    def remove(self, *names):
+        """ Unregister definitions from the registry.
+
+        :param names: The names of the definitions that are to be
+                      unregistered. """
+        for name in names:
+            self._storage.pop(name, None)
+
+
+class SchemaRegistry(Registry):
+    @classmethod
+    def _expand_definition(cls, definition):
+        return DefinitionSchema.expand(definition)
+
+
+class RulesSetRegistry(Registry):
+    @classmethod
+    def _expand_definition(cls, definition):
+        return DefinitionSchema.expand({0: definition})[0]
+
+
+schema_registry, rules_set_registry = SchemaRegistry(), RulesSetRegistry()
diff --git a/pipenv/vendor/cerberus/tests/__init__.py b/pipenv/vendor/cerberus/tests/__init__.py
new file mode 100644
index 00000000..cc1c27dc
--- /dev/null
+++ b/pipenv/vendor/cerberus/tests/__init__.py
@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+
+from cerberus import errors, Validator, SchemaError, DocumentError
+from cerberus.tests.conftest import sample_schema
+
+
+def assert_exception(exception, document={}, schema=None, validator=None,
+                     msg=None):
+    """ Tests whether a specific exception is raised. Optionally also tests
+        whether the exception message is as expected. """
+    if validator is None:
+        validator = Validator()
+    if msg is None:
+        with pytest.raises(exception) as excinfo:
+            validator(document, schema)
+    else:
+        with pytest.raises(exception, message=msg) as excinfo:  # noqa: F841
+            validator(document, schema)
+
+
+def assert_schema_error(*args):
+    """ Tests whether a validation raises an exception due to a malformed
+        schema. """
+    assert_exception(SchemaError, *args)
+
+
+def assert_document_error(*args):
+    """ Tests whether a validation raises an exception due to a malformed
+        document. """
+    assert_exception(DocumentError, *args)
+
+
+def assert_fail(document, schema=None, validator=None, update=False,
+                error=None, errors=None, child_errors=None):
+    """ Tests whether a validation fails. """
+    if validator is None:
+        validator = Validator(sample_schema)
+    result = validator(document, schema, update)
+    assert isinstance(result, bool)
+    assert not result
+
+    actual_errors = validator._errors
+
+    assert not (error is not None and errors is not None)
+    assert not (errors is not None and child_errors is not None), (
+        'child_errors can only be tested in '
+        'conjunction with the error parameter'
+    )
+    assert not (child_errors is not None and error is None)
+    if error is not None:
+        assert len(actual_errors) == 1
+        assert_has_error(actual_errors, *error)
+
+        if child_errors is not None:
+            assert len(actual_errors[0].child_errors) == len(child_errors)
+            assert_has_errors(actual_errors[0].child_errors, child_errors)
+
+    elif errors is not None:
+        assert len(actual_errors) == len(errors)
+        assert_has_errors(actual_errors, errors)
+
+    return actual_errors
+
+
+def assert_success(document, schema=None, validator=None, update=False):
+    """ Tests whether a validation succeeds. """
+    if validator is None:
+        validator = Validator(sample_schema)
+    result = validator(document, schema, update)
+    assert isinstance(result, bool)
+    if not result:
+        raise AssertionError(validator.errors)
+
+
+def assert_has_error(_errors, d_path, s_path, error_def, constraint, info=()):
+    if not isinstance(d_path, tuple):
+        d_path = (d_path,)
+    if not isinstance(info, tuple):
+        info = (info,)
+
+    assert isinstance(_errors, errors.ErrorList)
+
+    for i, error in enumerate(_errors):
+        assert isinstance(error, errors.ValidationError)
+        try:
+            assert error.document_path == d_path
+            assert error.schema_path == s_path
+            assert error.code == error_def.code
+            assert error.rule == error_def.rule
+            assert error.constraint == constraint
+            if not error.is_group_error:
+                assert error.info == info
+        except AssertionError:
+            pass
+        except Exception:
+            raise
+        else:
+            break
+    else:
+        raise AssertionError("""
+        Error with properties:
+          document_path={doc_path}
+          schema_path={schema_path}
+          code={code}
+          constraint={constraint}
+          info={info}
+        not found in errors:
+        {errors}
+        """.format(doc_path=d_path, schema_path=s_path,
+                   code=hex(error.code), info=info,
+                   constraint=constraint, errors=_errors))
+    return i
+
+
+def assert_has_errors(_errors, _exp_errors):
+    assert isinstance(_exp_errors, list)
+    for error in _exp_errors:
+        assert isinstance(error, tuple)
+        assert_has_error(_errors, *error)
+
+
+def assert_not_has_error(_errors, *args, **kwargs):
+    try:
+        assert_has_error(_errors, *args, **kwargs)
+    except AssertionError:
+        pass
+    except Exception as e:
+        raise e
+    else:
+        raise AssertionError('An unexpected error occurred.')
+
+
+def assert_bad_type(field, data_type, value):
+    assert_fail({field: value},
+                error=(field, (field, 'type'), errors.BAD_TYPE, data_type))
+
+
+def assert_normalized(document, expected, schema=None, validator=None):
+    if validator is None:
+        validator = Validator(sample_schema)
+    assert_success(document, schema, validator)
+    assert validator.document == expected
diff --git a/pipenv/vendor/cerberus/tests/conftest.py b/pipenv/vendor/cerberus/tests/conftest.py
new file mode 100644
index 00000000..3b4395ea
--- /dev/null
+++ b/pipenv/vendor/cerberus/tests/conftest.py
@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+
+from copy import deepcopy
+
+import pytest
+
+from cerberus import Validator
+
+
+@pytest.fixture
+def document():
+    return deepcopy(sample_document)
+
+
+@pytest.fixture
+def schema():
+    return deepcopy(sample_schema)
+
+
+@pytest.fixture
+def validator():
+    return Validator(sample_schema)
+
+
+sample_schema = {
+    'a_string': {
+        'type': 'string',
+        'minlength': 2,
+        'maxlength': 10
+    },
+    'a_binary': {
+        'type': 'binary',
+        'minlength': 2,
+        'maxlength': 10
+    },
+    'a_nullable_integer': {
+        'type': 'integer',
+        'nullable': True
+    },
+    'an_integer': {
+        'type': 'integer',
+        'min': 1,
+        'max': 100,
+    },
+    'a_restricted_integer': {
+        'type': 'integer',
+        'allowed': [-1, 0, 1],
+    },
+    'a_boolean': {
+        'type': 'boolean',
+    },
+    'a_datetime': {
+        'type': 'datetime',
+    },
+    'a_float': {
+        'type': 'float',
+        'min': 1,
+        'max': 100,
+    },
+    'a_number': {
+        'type': 'number',
+        'min': 1,
+        'max': 100,
+    },
+    'a_set': {
+        'type': 'set',
+    },
+    'one_or_more_strings': {
+        'type': ['string', 'list'],
+        'schema': {'type': 'string'}
+    },
+    'a_regex_email': {
+        'type': 'string',
+        'regex': '^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
+    },
+    'a_readonly_string': {
+        'type': 'string',
+        'readonly': True,
+    },
+    'a_restricted_string': {
+        'type': 'string',
+        'allowed': ["agent", "client", "vendor"],
+    },
+    'an_array': {
+        'type': 'list',
+        'allowed': ["agent", "client", "vendor"],
+    },
+    'a_list_of_dicts': {
+        'type': 'list',
+        'schema': {
+            'type': 'dict',
+            'schema': {
+                'sku': {'type': 'string'},
+                'price': {'type': 'integer', 'required': True},
+            },
+        },
+    },
+    'a_list_of_values': {
+        'type': 'list',
+        'items': [{'type': 'string'}, {'type': 'integer'}, ]
+    },
+    'a_list_of_integers': {
+        'type': 'list',
+        'schema': {'type': 'integer'},
+    },
+    'a_dict': {
+        'type': 'dict',
+        'schema': {
+            'address': {'type': 'string'},
+            'city': {'type': 'string', 'required': True}
+        },
+    },
+    'a_dict_with_valueschema': {
+        'type': 'dict',
+        'valueschema': {'type': 'integer'}
+    },
+    'a_dict_with_keyschema': {
+        'type': 'dict',
+        'keyschema': {'type': 'string', 'regex': '[a-z]+'}
+    },
+    'a_list_length': {
+        'type': 'list',
+        'schema': {'type': 'integer'},
+        'minlength': 2,
+        'maxlength': 5,
+    },
+    'a_nullable_field_without_type': {
+        'nullable': True
+    },
+    'a_not_nullable_field_without_type': {
+    },
+}
+
+sample_document = {'name': 'john doe'}
diff --git a/pipenv/vendor/cerberus/tests/test_assorted.py b/pipenv/vendor/cerberus/tests/test_assorted.py
new file mode 100644
index 00000000..641adb7e
--- /dev/null
+++ b/pipenv/vendor/cerberus/tests/test_assorted.py
@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+
+from decimal import Decimal
+
+from pytest import mark
+
+from cerberus import TypeDefinition, Validator
+from cerberus.tests import assert_fail, assert_success
+from cerberus.utils import validator_factory
+from cerberus.validator import BareValidator
+
+
+def test_clear_cache(validator):
+    assert len(validator._valid_schemas) > 0
+    validator.clear_caches()
+    assert len(validator._valid_schemas) == 0
+
+
+def test_docstring(validator):
+    assert validator.__doc__
+
+
+# Test that testing with the sample schema works as expected
+# as there might be rules with side-effects in it
+
+@mark.parametrize('test,document', ((assert_fail, {'an_integer': 60}),
+                                    (assert_success, {'an_integer': 110})))
+def test_that_test_fails(test, document):
+    try:
+        test(document)
+    except AssertionError:
+        pass
+    else:
+        raise AssertionError("test didn't fail")
+
+
+def test_dynamic_types():
+    decimal_type = TypeDefinition('decimal', (Decimal,), ())
+    document = {'measurement': Decimal(0)}
+    schema = {'measurement': {'type': 'decimal'}}
+
+    validator = Validator()
+    validator.types_mapping['decimal'] = decimal_type
+    assert_success(document, schema, validator)
+
+    class MyValidator(Validator):
+        types_mapping = Validator.types_mapping.copy()
+        types_mapping['decimal'] = decimal_type
+    validator = MyValidator()
+    assert_success(document, schema, validator)
+
+
+def test_mro():
+    assert Validator.__mro__ == (Validator, BareValidator, object), \
+        Validator.__mro__
+
+
+def test_mixin_init():
+    class Mixin(object):
+        def __init__(self, *args, **kwargs):
+            kwargs['test'] = True
+            super(Mixin, self).__init__(*args, **kwargs)
+
+    MyValidator = validator_factory('MyValidator', Mixin)
+    validator = MyValidator()
+    assert validator._config['test']
+
+
+def test_sub_init():
+    class MyValidator(Validator):
+        def __init__(self, *args, **kwargs):
+            kwargs['test'] = True
+            super(MyValidator, self).__init__(*args, **kwargs)
+
+    validator = MyValidator()
+    assert validator._config['test']
diff --git a/pipenv/vendor/cerberus/tests/test_customization.py b/pipenv/vendor/cerberus/tests/test_customization.py
new file mode 100644
index 00000000..6055894d
--- /dev/null
+++ b/pipenv/vendor/cerberus/tests/test_customization.py
@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+
+import cerberus
+from cerberus.tests import assert_fail, assert_success
+from cerberus.tests.conftest import sample_schema
+
+
+def test_contextual_data_preservation():
+
+    class InheritedValidator(cerberus.Validator):
+        def __init__(self, *args, **kwargs):
+            if 'working_dir' in kwargs:
+                self.working_dir = kwargs['working_dir']
+            super(InheritedValidator, self).__init__(*args, **kwargs)
+
+        def _validate_type_test(self, value):
+            if self.working_dir:
+                return True
+
+    assert 'test' in InheritedValidator.types
+    v = InheritedValidator({'test': {'type': 'list',
+                                     'schema': {'type': 'test'}}},
+                           working_dir='/tmp')
+    assert_success({'test': ['foo']}, validator=v)
+
+
+def test_docstring_parsing():
+    class CustomValidator(cerberus.Validator):
+        def _validate_foo(self, argument, field, value):
+            """ {'type': 'zap'} """
+            pass
+
+        def _validate_bar(self, value):
+            """ Test the barreness of a value.
+
+            The rule's arguments are validated against this schema:
+                {'type': 'boolean'}
+            """
+            pass
+
+    assert 'foo' in CustomValidator.validation_rules
+    assert 'bar' in CustomValidator.validation_rules
+
+
+def test_issue_265():
+    class MyValidator(cerberus.Validator):
+        def _validator_oddity(self, field, value):
+            if not value & 1:
+                self._error(field, "Must be an odd number")
+
+    v = MyValidator(schema={'amount': {'validator': 'oddity'}})
+    assert_success(document={'amount': 1}, validator=v)
+    assert_fail(document={'amount': 2}, validator=v,
+                error=('amount', (), cerberus.errors.CUSTOM, None,
+                       ('Must be an odd number',)))
+
+
+def test_schema_validation_can_be_disabled_in_schema_setter():
+
+    class NonvalidatingValidator(cerberus.Validator):
+        """
+        Skips schema validation to speed up initialization
+        """
+        @cerberus.Validator.schema.setter
+        def schema(self, schema):
+            if schema is None:
+                self._schema = None
+            elif self.is_child:
+                self._schema = schema
+            elif isinstance(schema, cerberus.schema.DefinitionSchema):
+                self._schema = schema
+            else:
+                self._schema = cerberus.schema.UnvalidatedSchema(schema)
+
+    v = NonvalidatingValidator(schema=sample_schema)
+    assert v.validate(document={'an_integer': 1})
+    assert not v.validate(document={'an_integer': 'a'})
diff --git a/pipenv/vendor/cerberus/tests/test_errors.py b/pipenv/vendor/cerberus/tests/test_errors.py
new file mode 100644
index 00000000..df33964f
--- /dev/null
+++ b/pipenv/vendor/cerberus/tests/test_errors.py
@@ -0,0 +1,260 @@
+# -*- coding: utf-8 -*-
+
+from cerberus import Validator, errors
+from cerberus.tests import assert_fail
+
+
+ValidationError = errors.ValidationError
+
+
+def test__error_1():
+    v = Validator(schema={'foo': {'type': 'string'}})
+    v.document = {'foo': 42}
+    v._error('foo', errors.BAD_TYPE, 'string')
+    error = v._errors[0]
+    assert error.document_path == ('foo',)
+    assert error.schema_path == ('foo', 'type')
+    assert error.code == 0x24
+    assert error.rule == 'type'
+    assert error.constraint == 'string'
+    assert error.value == 42
+    assert error.info == ('string',)
+    assert not error.is_group_error
+    assert not error.is_logic_error
+
+
+def test__error_2():
+    v = Validator(schema={'foo': {'keyschema': {'type': 'integer'}}})
+    v.document = {'foo': {'0': 'bar'}}
+    v._error('foo', errors.KEYSCHEMA, ())
+    error = v._errors[0]
+    assert error.document_path == ('foo',)
+    assert error.schema_path == ('foo', 'keyschema')
+    assert error.code == 0x83
+    assert error.rule == 'keyschema'
+    assert error.constraint == {'type': 'integer'}
+    assert error.value == {'0': 'bar'}
+    assert error.info == ((),)
+    assert error.is_group_error
+    assert not error.is_logic_error
+
+
+def test__error_3():
+    valids = [{'type': 'string', 'regex': '0x[0-9a-f]{2}'},
+              {'type': 'integer', 'min': 0, 'max': 255}]
+    v = Validator(schema={'foo': {'oneof': valids}})
+    v.document = {'foo': '0x100'}
+    v._error('foo', errors.ONEOF, (), 0, 2)
+    error = v._errors[0]
+    assert error.document_path == ('foo',)
+    assert error.schema_path == ('foo', 'oneof')
+    assert error.code == 0x92
+    assert error.rule == 'oneof'
+    assert error.constraint == valids
+    assert error.value == '0x100'
+    assert error.info == ((), 0, 2)
+    assert error.is_group_error
+    assert error.is_logic_error
+
+
+def test_error_tree_from_subschema(validator):
+    schema = {'foo': {'schema': {'bar': {'type': 'string'}}}}
+    document = {'foo': {'bar': 0}}
+    assert_fail(document, schema, validator=validator)
+    d_error_tree = validator.document_error_tree
+    s_error_tree = validator.schema_error_tree
+
+    assert 'foo' in d_error_tree
+
+    assert len(d_error_tree['foo'].errors) == 1, d_error_tree['foo']
+    assert d_error_tree['foo'].errors[0].code == errors.MAPPING_SCHEMA.code
+    assert 'bar' in d_error_tree['foo']
+    assert d_error_tree['foo']['bar'].errors[0].value == 0
+    assert d_error_tree.fetch_errors_from(('foo', 'bar'))[0].value == 0
+
+    assert 'foo' in s_error_tree
+    assert 'schema' in s_error_tree['foo']
+    assert 'bar' in s_error_tree['foo']['schema']
+    assert 'type' in s_error_tree['foo']['schema']['bar']
+    assert s_error_tree['foo']['schema']['bar']['type'].errors[0].value == 0
+    assert s_error_tree.fetch_errors_from(
+        ('foo', 'schema', 'bar', 'type'))[0].value == 0
+
+
+def test_error_tree_from_anyof(validator):
+    schema = {'foo': {'anyof': [{'type': 'string'}, {'type': 'integer'}]}}
+    document = {'foo': []}
+    assert_fail(document, schema, validator=validator)
+    d_error_tree = validator.document_error_tree
+    s_error_tree = validator.schema_error_tree
+    assert 'foo' in d_error_tree
+    assert d_error_tree['foo'].errors[0].value == []
+    assert 'foo' in s_error_tree
+    assert 'anyof' in s_error_tree['foo']
+    assert 0 in s_error_tree['foo']['anyof']
+    assert 1 in s_error_tree['foo']['anyof']
+    assert 'type' in s_error_tree['foo']['anyof'][0]
+    assert s_error_tree['foo']['anyof'][0]['type'].errors[0].value == []
+
+
+def test_nested_error_paths(validator):
+    schema = {'a_dict': {'keyschema': {'type': 'integer'},
+                         'valueschema': {'regex': '[a-z]*'}},
+              'a_list': {'schema': {'type': 'string',
+                                    'oneof_regex': ['[a-z]*$', '[A-Z]*']}}}
+    document = {'a_dict': {0: 'abc', 'one': 'abc', 2: 'aBc', 'three': 'abC'},
+                'a_list': [0, 'abc', 'abC']}
+    assert_fail(document, schema, validator=validator)
+
+    _det = validator.document_error_tree
+    _set = validator.schema_error_tree
+
+    assert len(_det.errors) == 0
+    assert len(_set.errors) == 0
+
+    assert len(_det['a_dict'].errors) == 2
+    assert len(_set['a_dict'].errors) == 0
+
+    assert _det['a_dict'][0] is None
+    assert len(_det['a_dict']['one'].errors) == 1
+    assert len(_det['a_dict'][2].errors) == 1
+    assert len(_det['a_dict']['three'].errors) == 2
+
+    assert len(_set['a_dict']['keyschema'].errors) == 1
+    assert len(_set['a_dict']['valueschema'].errors) == 1
+
+    assert len(_set['a_dict']['keyschema']['type'].errors) == 2
+    assert len(_set['a_dict']['valueschema']['regex'].errors) == 2
+
+    _ref_err = ValidationError(
+        ('a_dict', 'one'), ('a_dict', 'keyschema', 'type'),
+        errors.BAD_TYPE.code, 'type', 'integer', 'one', ())
+    assert _det['a_dict']['one'].errors[0] == _ref_err
+    assert _set['a_dict']['keyschema']['type'].errors[0] == _ref_err
+
+    _ref_err = ValidationError(
+        ('a_dict', 2), ('a_dict', 'valueschema', 'regex'),
+        errors.REGEX_MISMATCH.code, 'regex', '[a-z]*$', 'aBc', ())
+    assert _det['a_dict'][2].errors[0] == _ref_err
+    assert _set['a_dict']['valueschema']['regex'].errors[0] == _ref_err
+
+    _ref_err = ValidationError(
+        ('a_dict', 'three'), ('a_dict', 'keyschema', 'type'),
+        errors.BAD_TYPE.code, 'type', 'integer', 'three', ())
+    assert _det['a_dict']['three'].errors[0] == _ref_err
+    assert _set['a_dict']['keyschema']['type'].errors[1] == _ref_err
+
+    _ref_err = ValidationError(
+        ('a_dict', 'three'), ('a_dict', 'valueschema', 'regex'),
+        errors.REGEX_MISMATCH.code, 'regex', '[a-z]*$', 'abC', ())
+    assert _det['a_dict']['three'].errors[1] == _ref_err
+    assert _set['a_dict']['valueschema']['regex'].errors[1] == _ref_err
+
+    assert len(_det['a_list'].errors) == 1
+    assert len(_det['a_list'][0].errors) == 1
+    assert _det['a_list'][1] is None
+    assert len(_det['a_list'][2].errors) == 3
+    assert len(_set['a_list'].errors) == 0
+    assert len(_set['a_list']['schema'].errors) == 1
+    assert len(_set['a_list']['schema']['type'].errors) == 1
+    assert len(_set['a_list']['schema']['oneof'][0]['regex'].errors) == 1
+    assert len(_set['a_list']['schema']['oneof'][1]['regex'].errors) == 1
+
+    _ref_err = ValidationError(
+        ('a_list', 0), ('a_list', 'schema', 'type'), errors.BAD_TYPE.code,
+        'type', 'string', 0, ())
+    assert _det['a_list'][0].errors[0] == _ref_err
+    assert _set['a_list']['schema']['type'].errors[0] == _ref_err
+
+    _ref_err = ValidationError(
+        ('a_list', 2), ('a_list', 'schema', 'oneof'), errors.ONEOF.code,
+        'oneof', 'irrelevant_at_this_point', 'abC', ())
+    assert _det['a_list'][2].errors[0] == _ref_err
+    assert _set['a_list']['schema']['oneof'].errors[0] == _ref_err
+
+    _ref_err = ValidationError(
+        ('a_list', 2), ('a_list', 'schema', 'oneof', 0, 'regex'),
+        errors.REGEX_MISMATCH.code, 'regex', '[a-z]*$', 'abC', ())
+    assert _det['a_list'][2].errors[1] == _ref_err
+    assert _set['a_list']['schema']['oneof'][0]['regex'].errors[0] == _ref_err
+
+    _ref_err = ValidationError(
+        ('a_list', 2), ('a_list', 'schema', 'oneof', 1, 'regex'),
+        errors.REGEX_MISMATCH.code, 'regex', '[a-z]*$', 'abC', ())
+    assert _det['a_list'][2].errors[2] == _ref_err
+    assert _set['a_list']['schema']['oneof'][1]['regex'].errors[0] == _ref_err
+
+
+def test_queries():
+    schema = {'foo': {'type': 'dict',
+                      'schema':
+                          {'bar': {'type': 'number'}}}}
+    document = {'foo': {'bar': 'zero'}}
+    validator = Validator(schema)
+    validator(document)
+
+    assert 'foo' in validator.document_error_tree
+    assert 'bar' in validator.document_error_tree['foo']
+    assert 'foo' in validator.schema_error_tree
+    assert 'schema' in validator.schema_error_tree['foo']
+
+    assert errors.MAPPING_SCHEMA in validator.document_error_tree['foo'].errors
+    assert errors.MAPPING_SCHEMA in validator.document_error_tree['foo']
+    assert errors.BAD_TYPE in validator.document_error_tree['foo']['bar']
+    assert errors.MAPPING_SCHEMA in validator.schema_error_tree['foo']['schema']
+    assert errors.BAD_TYPE in \
+        validator.schema_error_tree['foo']['schema']['bar']['type']
+
+    assert (validator.document_error_tree['foo'][errors.MAPPING_SCHEMA]
+            .child_errors[0].code == errors.BAD_TYPE.code)
+
+
+def test_basic_error_handler():
+    handler = errors.BasicErrorHandler()
+    _errors, ref = [], {}
+
+    _errors.append(ValidationError(
+        ['foo'], ['foo'], 0x63, 'readonly', True, None, ()))
+    ref.update({'foo': [handler.messages[0x63]]})
+    assert handler(_errors) == ref
+
+    _errors.append(ValidationError(
+        ['bar'], ['foo'], 0x42, 'min', 1, 2, ()))
+    ref.update({'bar': [handler.messages[0x42].format(constraint=1)]})
+    assert handler(_errors) == ref
+
+    _errors.append(ValidationError(
+        ['zap', 'foo'], ['zap', 'schema', 'foo'], 0x24, 'type', 'string',
+        True, ()))
+    ref.update({'zap': [{'foo': [handler.messages[0x24].format(
+        constraint='string')]}]})
+    assert handler(_errors) == ref
+
+    _errors.append(ValidationError(
+        ['zap', 'foo'], ['zap', 'schema', 'foo'], 0x41, 'regex',
+        '^p[äe]ng$', 'boom', ()))
+    ref['zap'][0]['foo'].append(
+        handler.messages[0x41].format(constraint='^p[äe]ng$'))
+    assert handler(_errors) == ref
+
+
+def test_basic_error_of_errors(validator):
+    schema = {'foo': {'oneof': [
+        {'type': 'integer'},
+        {'type': 'string'}
+    ]}}
+    document = {'foo': 23.42}
+    error = ('foo', ('foo', 'oneof'), errors.ONEOF,
+             schema['foo']['oneof'], ())
+    child_errors = [
+        (error[0], error[1] + (0, 'type'), errors.BAD_TYPE, 'integer'),
+        (error[0], error[1] + (1, 'type'), errors.BAD_TYPE, 'string')
+    ]
+    assert_fail(document, schema, validator=validator,
+                error=error, child_errors=child_errors)
+    assert validator.errors == {
+        'foo': [errors.BasicErrorHandler.messages[0x92],
+                {'oneof definition 0': ['must be of integer type'],
+                 'oneof definition 1': ['must be of string type']}
+                ]
+    }
diff --git a/pipenv/vendor/cerberus/tests/test_legacy.py b/pipenv/vendor/cerberus/tests/test_legacy.py
new file mode 100644
index 00000000..59bd7b84
--- /dev/null
+++ b/pipenv/vendor/cerberus/tests/test_legacy.py
@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+
+pass
diff --git a/pipenv/vendor/cerberus/tests/test_normalization.py b/pipenv/vendor/cerberus/tests/test_normalization.py
new file mode 100644
index 00000000..6e06f553
--- /dev/null
+++ b/pipenv/vendor/cerberus/tests/test_normalization.py
@@ -0,0 +1,485 @@
+# -*- coding: utf-8 -*-
+
+from tempfile import NamedTemporaryFile
+
+from cerberus import Validator, errors
+from cerberus.tests import (assert_fail, assert_has_error, assert_normalized,
+                            assert_success)
+
+
+def test_coerce():
+    schema = {'amount': {'coerce': int}}
+    document = {'amount': '1'}
+    expected = {'amount': 1}
+    assert_normalized(document, expected, schema)
+
+
+def test_coerce_in_dictschema():
+    schema = {'thing': {'type': 'dict',
+                        'schema': {'amount': {'coerce': int}}}}
+    document = {'thing': {'amount': '2'}}
+    expected = {'thing': {'amount': 2}}
+    assert_normalized(document, expected, schema)
+
+
+def test_coerce_in_listschema():
+    schema = {'things': {'type': 'list',
+                         'schema': {'coerce': int}}}
+    document = {'things': ['1', '2', '3']}
+    expected = {'things': [1, 2, 3]}
+    assert_normalized(document, expected, schema)
+
+
+def test_coerce_in_dictschema_in_listschema():
+    item_schema = {'type': 'dict', 'schema': {'amount': {'coerce': int}}}
+    schema = {'things': {'type': 'list', 'schema': item_schema}}
+    document = {'things': [{'amount': '2'}]}
+    expected = {'things': [{'amount': 2}]}
+    assert_normalized(document, expected, schema)
+
+
+def test_coerce_not_destructive():
+    schema = {
+        'amount': {'coerce': int}
+    }
+    v = Validator(schema)
+    doc = {'amount': '1'}
+    v.validate(doc)
+    assert v.document is not doc
+
+
+def test_coerce_catches_ValueError():
+    schema = {'amount': {'coerce': int}}
+    _errors = assert_fail({'amount': 'not_a_number'}, schema)
+    _errors[0].info = ()  # ignore exception message here
+    assert_has_error(_errors, 'amount', ('amount', 'coerce'),
+                     errors.COERCION_FAILED, int)
+
+
+def test_coerce_catches_TypeError():
+    schema = {'name': {'coerce': str.lower}}
+    _errors = assert_fail({'name': 1234}, schema)
+    _errors[0].info = ()  # ignore exception message here
+    assert_has_error(_errors, 'name', ('name', 'coerce'),
+                     errors.COERCION_FAILED, str.lower)
+
+
+def test_coerce_unknown():
+    schema = {'foo': {'schema': {}, 'allow_unknown': {'coerce': int}}}
+    document = {'foo': {'bar': '0'}}
+    expected = {'foo': {'bar': 0}}
+    assert_normalized(document, expected, schema)
+
+
+def test_custom_coerce_and_rename():
+    class MyNormalizer(Validator):
+        def __init__(self, multiplier, *args, **kwargs):
+            super(MyNormalizer, self).__init__(*args, **kwargs)
+            self.multiplier = multiplier
+
+        def _normalize_coerce_multiply(self, value):
+            return value * self.multiplier
+
+    v = MyNormalizer(2, {'foo': {'coerce': 'multiply'}})
+    assert v.normalized({'foo': 2})['foo'] == 4
+
+    v = MyNormalizer(3, allow_unknown={'rename_handler': 'multiply'})
+    assert v.normalized({3: None}) == {9: None}
+
+
+def test_coerce_chain():
+    drop_prefix = lambda x: x[2:]
+    upper = lambda x: x.upper()
+    schema = {'foo': {'coerce': [hex, drop_prefix, upper]}}
+    assert_normalized({'foo': 15}, {'foo': 'F'}, schema)
+
+
+def test_coerce_chain_aborts(validator):
+    def dont_do_me(value):
+        raise AssertionError('The coercion chain did not abort after an '
+                             'error.')
+    schema = {'foo': {'coerce': [hex, dont_do_me]}}
+    validator({'foo': '0'}, schema)
+    assert errors.COERCION_FAILED in validator._errors
+
+
+def test_coerce_non_digit_in_sequence(validator):
+    # https://github.com/pyeve/cerberus/issues/211
+    schema = {'data': {'type': 'list',
+                       'schema': {'type': 'integer', 'coerce': int}}}
+    document = {'data': ['q']}
+    assert validator.validated(document, schema) is None
+    assert (validator.validated(document, schema, always_return_document=True)
+            == document)  # noqa: W503
+
+
+def test_nullables_dont_fail_coerce():
+    schema = {'foo': {'coerce': int, 'nullable': True, 'type': 'integer'}}
+    document = {'foo': None}
+    assert_normalized(document, document, schema)
+
+
+def test_normalized():
+    schema = {'amount': {'coerce': int}}
+    document = {'amount': '2'}
+    expected = {'amount': 2}
+    assert_normalized(document, expected, schema)
+
+
+def test_rename(validator):
+    schema = {'foo': {'rename': 'bar'}}
+    document = {'foo': 0}
+    expected = {'bar': 0}
+    # We cannot use assertNormalized here since there is bug where
+    # Cerberus says that the renamed field is an unknown field:
+    # {'bar': 'unknown field'}
+    validator(document, schema, False)
+    assert validator.document == expected
+
+
+def test_rename_handler():
+    validator = Validator(allow_unknown={'rename_handler': int})
+    schema = {}
+    document = {'0': 'foo'}
+    expected = {0: 'foo'}
+    assert_normalized(document, expected, schema, validator)
+
+
+def test_purge_unknown():
+    validator = Validator(purge_unknown=True)
+    schema = {'foo': {'type': 'string'}}
+    document = {'bar': 'foo'}
+    expected = {}
+    assert_normalized(document, expected, schema, validator)
+
+
+def test_purge_unknown_in_subschema():
+    schema = {'foo': {'type': 'dict',
+                      'schema': {'foo': {'type': 'string'}},
+                      'purge_unknown': True}}
+    document = {'foo': {'bar': ''}}
+    expected = {'foo': {}}
+    assert_normalized(document, expected, schema)
+
+
+def test_issue_147_complex():
+    schema = {'revision': {'coerce': int}}
+    document = {'revision': '5', 'file': NamedTemporaryFile(mode='w+')}
+    document['file'].write(r'foobar')
+    document['file'].seek(0)
+    normalized = Validator(schema, allow_unknown=True).normalized(document)
+    assert normalized['revision'] == 5
+    assert normalized['file'].read() == 'foobar'
+    document['file'].close()
+    normalized['file'].close()
+
+
+def test_issue_147_nested_dict():
+    schema = {'thing': {'type': 'dict',
+                        'schema': {'amount': {'coerce': int}}}}
+    ref_obj = '2'
+    document = {'thing': {'amount': ref_obj}}
+    normalized = Validator(schema).normalized(document)
+    assert document is not normalized
+    assert normalized['thing']['amount'] == 2
+    assert ref_obj == '2'
+    assert document['thing']['amount'] is ref_obj
+
+
+def test_coerce_in_valueschema():
+    # https://github.com/pyeve/cerberus/issues/155
+    schema = {'thing': {'type': 'dict',
+                        'valueschema': {'coerce': int,
+                                        'type': 'integer'}}}
+    document = {'thing': {'amount': '2'}}
+    expected = {'thing': {'amount': 2}}
+    assert_normalized(document, expected, schema)
+
+
+def test_coerce_in_keyschema():
+    # https://github.com/pyeve/cerberus/issues/155
+    schema = {'thing': {'type': 'dict',
+                        'keyschema': {'coerce': int, 'type': 'integer'}}}
+    document = {'thing': {'5': 'foo'}}
+    expected = {'thing': {5: 'foo'}}
+    assert_normalized(document, expected, schema)
+
+
+def test_coercion_of_sequence_items(validator):
+    # https://github.com/pyeve/cerberus/issues/161
+    schema = {'a_list': {'type': 'list', 'schema': {'type': 'float',
+                                                    'coerce': float}}}
+    document = {'a_list': [3, 4, 5]}
+    expected = {'a_list': [3.0, 4.0, 5.0]}
+    assert_normalized(document, expected, schema, validator)
+    for x in validator.document['a_list']:
+        assert isinstance(x, float)
+
+
+def test_default_missing():
+    _test_default_missing({'default': 'bar_value'})
+
+
+def test_default_setter_missing():
+    _test_default_missing({'default_setter': lambda doc: 'bar_value'})
+
+
+def _test_default_missing(default):
+    bar_schema = {'type': 'string'}
+    bar_schema.update(default)
+    schema = {'foo': {'type': 'string'},
+              'bar': bar_schema}
+    document = {'foo': 'foo_value'}
+    expected = {'foo': 'foo_value', 'bar': 'bar_value'}
+    assert_normalized(document, expected, schema)
+
+
+def test_default_existent():
+    _test_default_existent({'default': 'bar_value'})
+
+
+def test_default_setter_existent():
+    def raise_error(doc):
+        raise RuntimeError('should not be called')
+    _test_default_existent({'default_setter': raise_error})
+
+
+def _test_default_existent(default):
+    bar_schema = {'type': 'string'}
+    bar_schema.update(default)
+    schema = {'foo': {'type': 'string'},
+              'bar': bar_schema}
+    document = {'foo': 'foo_value', 'bar': 'non_default'}
+    assert_normalized(document, document.copy(), schema)
+
+
+def test_default_none_nullable():
+    _test_default_none_nullable({'default': 'bar_value'})
+
+
+def test_default_setter_none_nullable():
+    def raise_error(doc):
+        raise RuntimeError('should not be called')
+    _test_default_none_nullable({'default_setter': raise_error})
+
+
+def _test_default_none_nullable(default):
+    bar_schema = {'type': 'string',
+                  'nullable': True}
+    bar_schema.update(default)
+    schema = {'foo': {'type': 'string'},
+              'bar': bar_schema}
+    document = {'foo': 'foo_value', 'bar': None}
+    assert_normalized(document, document.copy(), schema)
+
+
+def test_default_none_nonnullable():
+    _test_default_none_nullable({'default': 'bar_value'})
+
+
+def test_default_setter_none_nonnullable():
+    _test_default_none_nullable(
+        {'default_setter': lambda doc: 'bar_value'})
+
+
+def _test_default_none_nonnullable(default):
+    bar_schema = {'type': 'string',
+                  'nullable': False}
+    bar_schema.update(default)
+    schema = {'foo': {'type': 'string'},
+              'bar': bar_schema}
+    document = {'foo': 'foo_value', 'bar': 'bar_value'}
+    assert_normalized(document, document.copy(), schema)
+
+
+def test_default_none_default_value():
+    schema = {'foo': {'type': 'string'},
+              'bar': {'type': 'string',
+                      'nullable': True,
+                      'default': None}}
+    document = {'foo': 'foo_value'}
+    expected = {'foo': 'foo_value', 'bar': None}
+    assert_normalized(document, expected, schema)
+
+
+def test_default_missing_in_subschema():
+    _test_default_missing_in_subschema({'default': 'bar_value'})
+
+
+def test_default_setter_missing_in_subschema():
+    _test_default_missing_in_subschema(
+        {'default_setter': lambda doc: 'bar_value'})
+
+
+def _test_default_missing_in_subschema(default):
+    bar_schema = {'type': 'string'}
+    bar_schema.update(default)
+    schema = {'thing': {'type': 'dict',
+                        'schema': {'foo': {'type': 'string'},
+                                   'bar': bar_schema}}}
+    document = {'thing': {'foo': 'foo_value'}}
+    expected = {'thing': {'foo': 'foo_value',
+                          'bar': 'bar_value'}}
+    assert_normalized(document, expected, schema)
+
+
+def test_depending_default_setters():
+    schema = {
+        'a': {'type': 'integer'},
+        'b': {'type': 'integer', 'default_setter': lambda d: d['a'] + 1},
+        'c': {'type': 'integer', 'default_setter': lambda d: d['b'] * 2},
+        'd': {'type': 'integer',
+              'default_setter': lambda d: d['b'] + d['c']}
+    }
+    document = {'a': 1}
+    expected = {'a': 1, 'b': 2, 'c': 4, 'd': 6}
+    assert_normalized(document, expected, schema)
+
+
+def test_circular_depending_default_setters(validator):
+    schema = {
+        'a': {'type': 'integer', 'default_setter': lambda d: d['b'] + 1},
+        'b': {'type': 'integer', 'default_setter': lambda d: d['a'] + 1}
+    }
+    validator({}, schema)
+    assert errors.SETTING_DEFAULT_FAILED in validator._errors
+
+
+def test_issue_250():
+    # https://github.com/pyeve/cerberus/issues/250
+    schema = {
+        'list': {
+            'type': 'list',
+            'schema': {
+                'type': 'dict',
+                'allow_unknown': True,
+                'schema': {'a': {'type': 'string'}}
+            }
+        }
+    }
+    document = {'list': {'is_a': 'mapping'}}
+    assert_fail(document, schema,
+                error=('list', ('list', 'type'), errors.BAD_TYPE,
+                       schema['list']['type']))
+
+
+def test_issue_250_no_type_pass_on_list():
+    # https://github.com/pyeve/cerberus/issues/250
+    schema = {
+        'list': {
+            'schema': {
+                'allow_unknown': True,
+                'type': 'dict',
+                'schema': {'a': {'type': 'string'}}
+            }
+        }
+    }
+    document = {'list': [{'a': 'known', 'b': 'unknown'}]}
+    assert_normalized(document, document, schema)
+
+
+def test_issue_250_no_type_fail_on_dict():
+    # https://github.com/pyeve/cerberus/issues/250
+    schema = {
+        'list': {
+            'schema': {
+                'allow_unknown': True,
+                'schema': {'a': {'type': 'string'}}
+            }
+        }
+    }
+    document = {'list': {'a': {'a': 'known'}}}
+    assert_fail(document, schema,
+                error=('list', ('list', 'schema'), errors.BAD_TYPE_FOR_SCHEMA,
+                       schema['list']['schema']))
+
+
+def test_issue_250_no_type_fail_pass_on_other():
+    # https://github.com/pyeve/cerberus/issues/250
+    schema = {
+        'list': {
+            'schema': {
+                'allow_unknown': True,
+                'schema': {'a': {'type': 'string'}}
+            }
+        }
+    }
+    document = {'list': 1}
+    assert_normalized(document, document, schema)
+
+
+def test_allow_unknown_with_of_rules():
+    # https://github.com/pyeve/cerberus/issues/251
+    schema = {
+        'test': {
+            'oneof': [
+                {
+                    'type': 'dict',
+                    'allow_unknown': True,
+                    'schema': {'known': {'type': 'string'}}
+                },
+                {
+                    'type': 'dict',
+                    'schema': {'known': {'type': 'string'}}
+                },
+            ]
+        }
+    }
+    # check regression and that allow unknown does not cause any different
+    # than expected behaviour for one-of.
+    document = {'test': {'known': 's'}}
+    assert_fail(document, schema,
+                error=('test', ('test', 'oneof'),
+                       errors.ONEOF, schema['test']['oneof']))
+    # check that allow_unknown is actually applied
+    document = {'test': {'known': 's', 'unknown': 'asd'}}
+    assert_success(document, schema)
+
+
+def test_271_normalising_tuples():
+    # https://github.com/pyeve/cerberus/issues/271
+    schema = {
+        'my_field': {
+            'type': 'list',
+            'schema': {'type': ('string', 'number', 'dict')}
+        }
+    }
+    document = {'my_field': ('foo', 'bar', 42, 'albert',
+                             'kandinsky', {'items': 23})}
+    assert_success(document, schema)
+
+    normalized = Validator(schema).normalized(document)
+    assert normalized['my_field'] == ('foo', 'bar', 42, 'albert',
+                                      'kandinsky', {'items': 23})
+
+
+def test_allow_unknown_wo_schema():
+    # https://github.com/pyeve/cerberus/issues/302
+    v = Validator({'a': {'type': 'dict', 'allow_unknown': True}})
+    v({'a': {}})
+
+
+def test_allow_unknown_with_purge_unknown():
+    validator = Validator(purge_unknown=True)
+    schema = {'foo': {'type': 'dict', 'allow_unknown': True}}
+    document = {'foo': {'bar': True}, 'bar': 'foo'}
+    expected = {'foo': {'bar': True}}
+    assert_normalized(document, expected, schema, validator)
+
+
+def test_allow_unknown_with_purge_unknown_subdocument():
+    validator = Validator(purge_unknown=True)
+    schema = {
+        'foo': {
+            'type': 'dict',
+            'schema': {
+                'bar': {
+                    'type': 'string'
+                }
+            },
+            'allow_unknown': True
+        }
+    }
+    document = {'foo': {'bar': 'baz', 'corge': False}, 'thud': 'xyzzy'}
+    expected = {'foo': {'bar': 'baz', 'corge': False}}
+    assert_normalized(document, expected, schema, validator)
diff --git a/pipenv/vendor/cerberus/tests/test_registries.py b/pipenv/vendor/cerberus/tests/test_registries.py
new file mode 100644
index 00000000..05f01c52
--- /dev/null
+++ b/pipenv/vendor/cerberus/tests/test_registries.py
@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+
+from cerberus import schema_registry, rules_set_registry, Validator
+from cerberus.tests import (assert_fail, assert_normalized,
+                            assert_schema_error, assert_success)
+
+
+def test_schema_registry_simple():
+    schema_registry.add('foo', {'bar': {'type': 'string'}})
+    schema = {'a': {'schema': 'foo'},
+              'b': {'schema': 'foo'}}
+    document = {'a': {'bar': 'a'}, 'b': {'bar': 'b'}}
+    assert_success(document, schema)
+
+
+def test_top_level_reference():
+    schema_registry.add('peng', {'foo': {'type': 'integer'}})
+    document = {'foo': 42}
+    assert_success(document, 'peng')
+
+
+def test_rules_set_simple():
+    rules_set_registry.add('foo', {'type': 'integer'})
+    assert_success({'bar': 1}, {'bar': 'foo'})
+    assert_fail({'bar': 'one'}, {'bar': 'foo'})
+
+
+def test_allow_unknown_as_reference():
+    rules_set_registry.add('foo', {'type': 'number'})
+    v = Validator(allow_unknown='foo')
+    assert_success({0: 1}, {}, v)
+    assert_fail({0: 'one'}, {}, v)
+
+
+def test_recursion():
+    rules_set_registry.add('self',
+                           {'type': 'dict', 'allow_unknown': 'self'})
+    v = Validator(allow_unknown='self')
+    assert_success({0: {1: {2: {}}}}, {}, v)
+
+
+def test_references_remain_unresolved(validator):
+    rules_set_registry.extend((('boolean', {'type': 'boolean'}),
+                               ('booleans', {'valueschema': 'boolean'})))
+    validator.schema = {'foo': 'booleans'}
+    assert 'booleans' == validator.schema['foo']
+    assert 'boolean' == rules_set_registry._storage['booleans']['valueschema']
+
+
+def test_rules_registry_with_anyof_type():
+    rules_set_registry.add('string_or_integer',
+                           {'anyof_type': ['string', 'integer']})
+    schema = {'soi': 'string_or_integer'}
+    assert_success({'soi': 'hello'}, schema)
+
+
+def test_schema_registry_with_anyof_type():
+    schema_registry.add('soi_id', {'id': {'anyof_type': ['string', 'integer']}})
+    schema = {'soi': {'schema': 'soi_id'}}
+    assert_success({'soi': {'id': 'hello'}}, schema)
+
+
+def test_normalization_with_rules_set():
+    # https://github.com/pyeve/cerberus/issues/283
+    rules_set_registry.add('foo', {'default': 42})
+    assert_normalized({}, {'bar': 42}, {'bar': 'foo'})
+    rules_set_registry.add('foo', {'default_setter': lambda _: 42})
+    assert_normalized({}, {'bar': 42}, {'bar': 'foo'})
+    rules_set_registry.add('foo', {'type': 'integer', 'nullable': True})
+    assert_success({'bar': None}, {'bar': 'foo'})
+
+
+def test_rules_set_with_dict_field():
+    document = {'a_dict': {'foo': 1}}
+    schema = {'a_dict': {'type': 'dict', 'schema': {'foo': 'rule'}}}
+
+    # the schema's not yet added to the valid ones, so test the faulty first
+    rules_set_registry.add('rule', {'tüpe': 'integer'})
+    assert_schema_error(document, schema)
+
+    rules_set_registry.add('rule', {'type': 'integer'})
+    assert_success(document, schema)
diff --git a/pipenv/vendor/cerberus/tests/test_schema.py b/pipenv/vendor/cerberus/tests/test_schema.py
new file mode 100644
index 00000000..1776cae3
--- /dev/null
+++ b/pipenv/vendor/cerberus/tests/test_schema.py
@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+
+from cerberus import Validator, errors, SchemaError
+from cerberus.schema import UnvalidatedSchema
+from cerberus.tests import assert_schema_error
+
+
+def test_empty_schema():
+    validator = Validator()
+    with pytest.raises(SchemaError, message=errors.SCHEMA_ERROR_MISSING):
+        validator({}, schema=None)
+
+
+def test_bad_schema_type(validator):
+    schema = "this string should really be dict"
+    exp_msg = errors.SCHEMA_ERROR_DEFINITION_TYPE.format(schema)
+    with pytest.raises(SchemaError, message=exp_msg):
+        validator.schema = schema
+
+
+def test_bad_schema_type_field(validator):
+    field = 'foo'
+    schema = {field: {'schema': {'bar': {'type': 'strong'}}}}
+    with pytest.raises(SchemaError):
+        validator.schema = schema
+
+
+def test_unknown_rule(validator):
+    message = "{'foo': [{'unknown': ['unknown rule']}]}"
+    with pytest.raises(SchemaError, message=message):
+        validator.schema = {'foo': {'unknown': 'rule'}}
+
+
+def test_unknown_type(validator):
+    field = 'name'
+    value = 'catch_me'
+    message = str({field: [{'type': ['unallowed value %s' % value]}]})
+    with pytest.raises(SchemaError, message=message):
+        validator.schema = {'foo': {'unknown': 'rule'}}
+
+
+def test_bad_schema_definition(validator):
+    field = 'name'
+    message = str({field: ['must be of dict type']})
+    with pytest.raises(SchemaError, message=message):
+        validator.schema = {field: 'this should really be a dict'}
+
+
+def test_bad_of_rules():
+    schema = {'foo': {'anyof': {'type': 'string'}}}
+    assert_schema_error({}, schema)
+
+
+def test_normalization_rules_are_invalid_in_of_rules():
+    schema = {0: {'anyof': [{'coerce': lambda x: x}]}}
+    assert_schema_error({}, schema)
+
+
+def test_anyof_allof_schema_validate():
+    # make sure schema with 'anyof' and 'allof' constraints are checked
+    # correctly
+    schema = {'doc': {'type': 'dict',
+                      'anyof': [
+                          {'schema': [{'param': {'type': 'number'}}]}]}}
+    assert_schema_error({'doc': 'this is my document'}, schema)
+
+    schema = {'doc': {'type': 'dict',
+                      'allof': [
+                          {'schema': [{'param': {'type': 'number'}}]}]}}
+    assert_schema_error({'doc': 'this is my document'}, schema)
+
+
+def test_repr():
+    v = Validator({'foo': {'type': 'string'}})
+    assert repr(v.schema) == "{'foo': {'type': 'string'}}"
+
+
+def test_validated_schema_cache():
+    v = Validator({'foozifix': {'coerce': int}})
+    cache_size = len(v._valid_schemas)
+
+    v = Validator({'foozifix': {'type': 'integer'}})
+    cache_size += 1
+    assert len(v._valid_schemas) == cache_size
+
+    v = Validator({'foozifix': {'coerce': int}})
+    assert len(v._valid_schemas) == cache_size
+
+    max_cache_size = 147
+    assert cache_size <= max_cache_size, \
+        "There's an unexpected high amount (%s) of cached valid " \
+        "definition schemas. Unless you added further tests, " \
+        "there are good chances that something is wrong. " \
+        "If you added tests with new schemas, you can try to " \
+        "adjust the variable `max_cache_size` according to " \
+        "the added schemas." % cache_size
+
+
+def test_expansion_in_nested_schema():
+    schema = {'detroit': {'schema': {'anyof_regex': ['^Aladdin', 'Sane$']}}}
+    v = Validator(schema)
+    assert (v.schema['detroit']['schema'] ==
+            {'anyof': [{'regex': '^Aladdin'}, {'regex': 'Sane$'}]})
+
+
+def test_unvalidated_schema_can_be_copied():
+    schema = UnvalidatedSchema()
+    schema_copy = schema.copy()
+    assert schema_copy == schema
diff --git a/pipenv/vendor/cerberus/tests/test_validation.py b/pipenv/vendor/cerberus/tests/test_validation.py
new file mode 100644
index 00000000..1f828fac
--- /dev/null
+++ b/pipenv/vendor/cerberus/tests/test_validation.py
@@ -0,0 +1,1579 @@
+# -*- coding: utf-8 -*-
+
+import re
+import sys
+from datetime import datetime, date
+from random import choice
+from string import ascii_lowercase
+
+from pytest import mark
+
+from cerberus import errors, Validator
+from cerberus.tests import (
+    assert_bad_type, assert_document_error, assert_fail, assert_has_error,
+    assert_not_has_error, assert_success
+)
+from cerberus.tests.conftest import sample_schema
+
+
+def test_empty_document():
+    assert_document_error(None, sample_schema, None,
+                          errors.DOCUMENT_MISSING)
+
+
+def test_bad_document_type():
+    document = "not a dict"
+    assert_document_error(
+        document, sample_schema, None,
+        errors.DOCUMENT_FORMAT.format(document)
+    )
+
+
+def test_unknown_field(validator):
+    field = 'surname'
+    assert_fail({field: 'doe'}, validator=validator,
+                error=(field, (), errors.UNKNOWN_FIELD, None))
+    assert validator.errors == {field: ['unknown field']}
+
+
+def test_empty_field_definition(document):
+    field = 'name'
+    schema = {field: {}}
+    assert_success(document, schema)
+
+
+def test_required_field(schema):
+    field = 'a_required_string'
+    required_string_extension = {
+        'a_required_string': {'type': 'string',
+                              'minlength': 2,
+                              'maxlength': 10,
+                              'required': True}}
+    schema.update(required_string_extension)
+    assert_fail({'an_integer': 1}, schema,
+                error=(field, (field, 'required'), errors.REQUIRED_FIELD,
+                       True))
+
+
+def test_nullable_field():
+    assert_success({'a_nullable_integer': None})
+    assert_success({'a_nullable_integer': 3})
+    assert_success({'a_nullable_field_without_type': None})
+    assert_fail({'a_nullable_integer': "foo"})
+    assert_fail({'an_integer': None})
+    assert_fail({'a_not_nullable_field_without_type': None})
+
+
+def test_readonly_field():
+    field = 'a_readonly_string'
+    assert_fail({field: 'update me if you can'},
+                error=(field, (field, 'readonly'), errors.READONLY_FIELD, True))
+
+
+def test_readonly_field_first_rule():
+    # test that readonly rule is checked before any other rule, and blocks.
+    # See #63.
+    schema = {
+        'a_readonly_number': {
+            'type': 'integer',
+            'readonly': True,
+            'max': 1
+        }
+    }
+    v = Validator(schema)
+    v.validate({'a_readonly_number': 2})
+    # it would be a list if there's more than one error; we get a dict
+    # instead.
+    assert 'read-only' in v.errors['a_readonly_number'][0]
+
+
+def test_readonly_field_with_default_value():
+    schema = {
+        'created': {
+            'type': 'string',
+            'readonly': True,
+            'default': 'today'
+        },
+        'modified': {
+            'type': 'string',
+            'readonly': True,
+            'default_setter': lambda d: d['created']
+        }
+    }
+    assert_success({}, schema)
+    expected_errors = [('created', ('created', 'readonly'),
+                        errors.READONLY_FIELD,
+                        schema['created']['readonly']),
+                       ('modified', ('modified', 'readonly'),
+                        errors.READONLY_FIELD,
+                        schema['modified']['readonly'])]
+    assert_fail({'created': 'tomorrow', 'modified': 'today'},
+                schema, errors=expected_errors)
+    assert_fail({'created': 'today', 'modified': 'today'},
+                schema, errors=expected_errors)
+
+
+def test_nested_readonly_field_with_default_value():
+    schema = {
+        'some_field': {
+            'type': 'dict',
+            'schema': {
+                'created': {
+                    'type': 'string',
+                    'readonly': True,
+                    'default': 'today'
+                },
+                'modified': {
+                    'type': 'string',
+                    'readonly': True,
+                    'default_setter': lambda d: d['created']
+                }
+            }
+        }
+    }
+    assert_success({'some_field': {}}, schema)
+    expected_errors = [
+        (('some_field', 'created'),
+         ('some_field', 'schema', 'created', 'readonly'),
+         errors.READONLY_FIELD,
+         schema['some_field']['schema']['created']['readonly']),
+        (('some_field', 'modified'),
+         ('some_field', 'schema', 'modified', 'readonly'),
+         errors.READONLY_FIELD,
+         schema['some_field']['schema']['modified']['readonly'])]
+    assert_fail({'some_field': {'created': 'tomorrow', 'modified': 'now'}},
+                schema, errors=expected_errors)
+    assert_fail({'some_field': {'created': 'today', 'modified': 'today'}},
+                schema, errors=expected_errors)
+
+
+def test_repeated_readonly(validator):
+    # https://github.com/pyeve/cerberus/issues/311
+    validator.schema = {'id': {'readonly': True}}
+    assert_fail({'id': 0}, validator=validator)
+    assert_fail({'id': 0}, validator=validator)
+
+
+def test_not_a_string():
+    assert_bad_type('a_string', 'string', 1)
+
+
+def test_not_a_binary():
+    # 'u' literal prefix produces type `str` in Python 3
+    assert_bad_type('a_binary', 'binary', u"i'm not a binary")
+
+
+def test_not_a_integer():
+    assert_bad_type('an_integer', 'integer', "i'm not an integer")
+
+
+def test_not_a_boolean():
+    assert_bad_type('a_boolean', 'boolean', "i'm not a boolean")
+
+
+def test_not_a_datetime():
+    assert_bad_type('a_datetime', 'datetime', "i'm not a datetime")
+
+
+def test_not_a_float():
+    assert_bad_type('a_float', 'float', "i'm not a float")
+
+
+def test_not_a_number():
+    assert_bad_type('a_number', 'number', "i'm not a number")
+
+
+def test_not_a_list():
+    assert_bad_type('a_list_of_values', 'list', "i'm not a list")
+
+
+def test_not_a_dict():
+    assert_bad_type('a_dict', 'dict', "i'm not a dict")
+
+
+def test_bad_max_length(schema):
+    field = 'a_string'
+    max_length = schema[field]['maxlength']
+    value = "".join(choice(ascii_lowercase) for i in range(max_length + 1))
+    assert_fail({field: value},
+                error=(field, (field, 'maxlength'), errors.MAX_LENGTH,
+                       max_length, (len(value),)))
+
+
+def test_bad_max_length_binary(schema):
+    field = 'a_binary'
+    max_length = schema[field]['maxlength']
+    value = b'\x00' * (max_length + 1)
+    assert_fail({field: value},
+                error=(field, (field, 'maxlength'), errors.MAX_LENGTH,
+                       max_length, (len(value),)))
+
+
+def test_bad_min_length(schema):
+    field = 'a_string'
+    min_length = schema[field]['minlength']
+    value = "".join(choice(ascii_lowercase) for i in range(min_length - 1))
+    assert_fail({field: value},
+                error=(field, (field, 'minlength'), errors.MIN_LENGTH,
+                       min_length, (len(value),)))
+
+
+def test_bad_min_length_binary(schema):
+    field = 'a_binary'
+    min_length = schema[field]['minlength']
+    value = b'\x00' * (min_length - 1)
+    assert_fail({field: value},
+                error=(field, (field, 'minlength'), errors.MIN_LENGTH,
+                       min_length, (len(value),)))
+
+
+def test_bad_max_value(schema):
+    def assert_bad_max_value(field, inc):
+        max_value = schema[field]['max']
+        value = max_value + inc
+        assert_fail({field: value},
+                    error=(field, (field, 'max'), errors.MAX_VALUE, max_value))
+
+    field = 'an_integer'
+    assert_bad_max_value(field, 1)
+    field = 'a_float'
+    assert_bad_max_value(field, 1.0)
+    field = 'a_number'
+    assert_bad_max_value(field, 1)
+
+
+def test_bad_min_value(schema):
+    def assert_bad_min_value(field, inc):
+        min_value = schema[field]['min']
+        value = min_value - inc
+        assert_fail({field: value},
+                    error=(field, (field, 'min'),
+                           errors.MIN_VALUE, min_value))
+
+    field = 'an_integer'
+    assert_bad_min_value(field, 1)
+    field = 'a_float'
+    assert_bad_min_value(field, 1.0)
+    field = 'a_number'
+    assert_bad_min_value(field, 1)
+
+
+def test_bad_schema():
+    field = 'a_dict'
+    subschema_field = 'address'
+    schema = {field: {'type': 'dict',
+                      'schema': {subschema_field: {'type': 'string'},
+                                 'city': {'type': 'string', 'required': True}}
+                      }}
+    document = {field: {subschema_field: 34}}
+    validator = Validator(schema)
+
+    assert_fail(
+        document, validator=validator,
+        error=(field, (field, 'schema'), errors.MAPPING_SCHEMA,
+               validator.schema['a_dict']['schema']),
+        child_errors=[
+            ((field, subschema_field),
+             (field, 'schema', subschema_field, 'type'),
+             errors.BAD_TYPE, 'string'),
+            ((field, 'city'), (field, 'schema', 'city', 'required'),
+             errors.REQUIRED_FIELD, True)]
+    )
+
+    handler = errors.BasicErrorHandler
+    assert field in validator.errors
+    assert subschema_field in validator.errors[field][-1]
+    assert handler.messages[errors.BAD_TYPE.code].format(constraint='string') \
+        in validator.errors[field][-1][subschema_field]
+    assert 'city' in validator.errors[field][-1]
+    assert (handler.messages[errors.REQUIRED_FIELD.code]
+            in validator.errors[field][-1]['city'])
+
+
+def test_bad_valueschema():
+    field = 'a_dict_with_valueschema'
+    schema_field = 'a_string'
+    value = {schema_field: 'not an integer'}
+
+    exp_child_errors = [
+        ((field, schema_field), (field, 'valueschema', 'type'), errors.BAD_TYPE,
+         'integer')]
+    assert_fail({field: value},
+                error=(field, (field, 'valueschema'), errors.VALUESCHEMA,
+                       {'type': 'integer'}), child_errors=exp_child_errors)
+
+
+def test_bad_list_of_values(validator):
+    field = 'a_list_of_values'
+    value = ['a string', 'not an integer']
+    assert_fail({field: value}, validator=validator,
+                error=(field, (field, 'items'), errors.BAD_ITEMS,
+                       [{'type': 'string'}, {'type': 'integer'}]),
+                child_errors=[((field, 1), (field, 'items', 1, 'type'),
+                               errors.BAD_TYPE, 'integer')])
+
+    assert (errors.BasicErrorHandler.messages[errors.BAD_TYPE.code].
+            format(constraint='integer')
+            in validator.errors[field][-1][1])
+
+    value = ['a string', 10, 'an extra item']
+    assert_fail({field: value},
+                error=(field, (field, 'items'), errors.ITEMS_LENGTH,
+                       [{'type': 'string'}, {'type': 'integer'}], (2, 3)))
+
+
+def test_bad_list_of_integers():
+    field = 'a_list_of_integers'
+    value = [34, 'not an integer']
+    assert_fail({field: value})
+
+
+def test_bad_list_of_dicts():
+    field = 'a_list_of_dicts'
+    map_schema = {'sku': {'type': 'string'},
+                  'price': {'type': 'integer', 'required': True}}
+    seq_schema = {'type': 'dict', 'schema': map_schema}
+    schema = {field: {'type': 'list', 'schema': seq_schema}}
+    validator = Validator(schema)
+    value = [{'sku': 'KT123', 'price': '100'}]
+    document = {field: value}
+
+    assert_fail(document, validator=validator,
+                error=(field, (field, 'schema'), errors.SEQUENCE_SCHEMA,
+                       seq_schema),
+                child_errors=[((field, 0), (field, 'schema', 'schema'),
+                               errors.MAPPING_SCHEMA, map_schema)])
+
+    assert field in validator.errors
+    assert 0 in validator.errors[field][-1]
+    assert 'price' in validator.errors[field][-1][0][-1]
+    exp_msg = errors.BasicErrorHandler.messages[errors.BAD_TYPE.code] \
+        .format(constraint='integer')
+    assert exp_msg in validator.errors[field][-1][0][-1]['price']
+
+    value = ["not a dict"]
+    exp_child_errors = [((field, 0), (field, 'schema', 'type'),
+                         errors.BAD_TYPE, 'dict', ())]
+    assert_fail({field: value},
+                error=(field, (field, 'schema'), errors.SEQUENCE_SCHEMA,
+                       seq_schema),
+                child_errors=exp_child_errors)
+
+
+def test_array_unallowed():
+    field = 'an_array'
+    value = ['agent', 'client', 'profit']
+    assert_fail({field: value},
+                error=(field, (field, 'allowed'), errors.UNALLOWED_VALUES,
+                       ['agent', 'client', 'vendor'], ['profit']))
+
+
+def test_string_unallowed():
+    field = 'a_restricted_string'
+    value = 'profit'
+    assert_fail({field: value},
+                error=(field, (field, 'allowed'), errors.UNALLOWED_VALUE,
+                       ['agent', 'client', 'vendor'], value))
+
+
+def test_integer_unallowed():
+    field = 'a_restricted_integer'
+    value = 2
+    assert_fail({field: value},
+                error=(field, (field, 'allowed'), errors.UNALLOWED_VALUE,
+                       [-1, 0, 1], value))
+
+
+def test_integer_allowed():
+    assert_success({'a_restricted_integer': -1})
+
+
+def test_validate_update():
+    assert_success({'an_integer': 100,
+                    'a_dict': {'address': 'adr'},
+                    'a_list_of_dicts': [{'sku': 'let'}]
+                    }, update=True)
+
+
+def test_string():
+    assert_success({'a_string': 'john doe'})
+
+
+def test_string_allowed():
+    assert_success({'a_restricted_string': 'client'})
+
+
+def test_integer():
+    assert_success({'an_integer': 50})
+
+
+def test_boolean():
+    assert_success({'a_boolean': True})
+
+
+def test_datetime():
+    assert_success({'a_datetime': datetime.now()})
+
+
+def test_float():
+    assert_success({'a_float': 3.5})
+    assert_success({'a_float': 1})
+
+
+def test_number():
+    assert_success({'a_number': 3.5})
+    assert_success({'a_number': 3})
+
+
+def test_array():
+    assert_success({'an_array': ['agent', 'client']})
+
+
+def test_set():
+    assert_success({'a_set': set(['hello', 1])})
+
+
+def test_one_of_two_types(validator):
+    field = 'one_or_more_strings'
+    assert_success({field: 'foo'})
+    assert_success({field: ['foo', 'bar']})
+    exp_child_errors = [((field, 1), (field, 'schema', 'type'),
+                         errors.BAD_TYPE, 'string')]
+    assert_fail({field: ['foo', 23]}, validator=validator,
+                error=(field, (field, 'schema'), errors.SEQUENCE_SCHEMA,
+                       {'type': 'string'}),
+                child_errors=exp_child_errors)
+    assert_fail({field: 23},
+                error=((field,), (field, 'type'), errors.BAD_TYPE,
+                       ['string', 'list']))
+    assert validator.errors == {field: [{1: ['must be of string type']}]}
+
+
+def test_regex(validator):
+    field = 'a_regex_email'
+    assert_success({field: 'valid.email@gmail.com'}, validator=validator)
+    assert_fail({field: 'invalid'}, update=True,
+                error=(field, (field, 'regex'), errors.REGEX_MISMATCH,
+                       '^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'))
+
+
+def test_a_list_of_dicts():
+    assert_success(
+        {
+            'a_list_of_dicts': [
+                {'sku': 'AK345', 'price': 100},
+                {'sku': 'YZ069', 'price': 25}
+            ]
+        }
+    )
+
+
+def test_a_list_of_values():
+    assert_success({'a_list_of_values': ['hello', 100]})
+
+
+def test_a_list_of_integers():
+    assert_success({'a_list_of_integers': [99, 100]})
+
+
+def test_a_dict(schema):
+    assert_success({'a_dict': {'address': 'i live here',
+                               'city': 'in my own town'}})
+    assert_fail(
+        {'a_dict': {'address': 8545}},
+        error=('a_dict', ('a_dict', 'schema'), errors.MAPPING_SCHEMA,
+               schema['a_dict']['schema']),
+        child_errors=[(('a_dict', 'address'),
+                       ('a_dict', 'schema', 'address', 'type'),
+                       errors.BAD_TYPE, 'string'),
+                      (('a_dict', 'city'),
+                       ('a_dict', 'schema', 'city', 'required'),
+                       errors.REQUIRED_FIELD, True)]
+    )
+
+
+def test_a_dict_with_valueschema(validator):
+    assert_success({'a_dict_with_valueschema':
+                   {'an integer': 99, 'another integer': 100}})
+
+    error = (
+        'a_dict_with_valueschema', ('a_dict_with_valueschema', 'valueschema'),
+        errors.VALUESCHEMA, {'type': 'integer'})
+    child_errors = [
+        (('a_dict_with_valueschema', 'a string'),
+         ('a_dict_with_valueschema', 'valueschema', 'type'),
+         errors.BAD_TYPE, 'integer')]
+
+    assert_fail({'a_dict_with_valueschema': {'a string': '99'}},
+                validator=validator, error=error, child_errors=child_errors)
+
+    assert 'valueschema' in \
+           validator.schema_error_tree['a_dict_with_valueschema']
+    v = validator.schema_error_tree
+    assert len(v['a_dict_with_valueschema']['valueschema'].descendants) == 1
+
+
+def test_a_dict_with_keyschema():
+    assert_success({'a_dict_with_keyschema': {'key': 'value'}})
+    assert_fail({'a_dict_with_keyschema': {'KEY': 'value'}})
+
+
+def test_a_list_length(schema):
+    field = 'a_list_length'
+    min_length = schema[field]['minlength']
+    max_length = schema[field]['maxlength']
+
+    assert_fail({field: [1] * (min_length - 1)},
+                error=(field, (field, 'minlength'), errors.MIN_LENGTH,
+                       min_length, (min_length - 1,)))
+
+    for i in range(min_length, max_length):
+        value = [1] * i
+        assert_success({field: value})
+
+    assert_fail({field: [1] * (max_length + 1)},
+                error=(field, (field, 'maxlength'), errors.MAX_LENGTH,
+                       max_length, (max_length + 1,)))
+
+
+def test_custom_datatype():
+    class MyValidator(Validator):
+        def _validate_type_objectid(self, value):
+            if re.match('[a-f0-9]{24}', value):
+                return True
+
+    schema = {'test_field': {'type': 'objectid'}}
+    validator = MyValidator(schema)
+    assert_success({'test_field': '50ad188438345b1049c88a28'},
+                   validator=validator)
+    assert_fail({'test_field': 'hello'}, validator=validator,
+                error=('test_field', ('test_field', 'type'), errors.BAD_TYPE,
+                       'objectid'))
+
+
+def test_custom_datatype_rule():
+    class MyValidator(Validator):
+        def _validate_min_number(self, min_number, field, value):
+            """ {'type': 'number'} """
+            if value < min_number:
+                self._error(field, 'Below the min')
+
+        # TODO replace with TypeDefintion in next major release
+        def _validate_type_number(self, value):
+            if isinstance(value, int):
+                return True
+
+    schema = {'test_field': {'min_number': 1, 'type': 'number'}}
+    validator = MyValidator(schema)
+    assert_fail({'test_field': '0'}, validator=validator,
+                error=('test_field', ('test_field', 'type'), errors.BAD_TYPE,
+                       'number'))
+    assert_fail({'test_field': 0}, validator=validator,
+                error=('test_field', (), errors.CUSTOM, None,
+                       ('Below the min',)))
+    assert validator.errors == {'test_field': ['Below the min']}
+
+
+def test_custom_validator():
+    class MyValidator(Validator):
+        def _validate_isodd(self, isodd, field, value):
+            """ {'type': 'boolean'} """
+            if isodd and not bool(value & 1):
+                self._error(field, 'Not an odd number')
+
+    schema = {'test_field': {'isodd': True}}
+    validator = MyValidator(schema)
+    assert_success({'test_field': 7}, validator=validator)
+    assert_fail({'test_field': 6}, validator=validator,
+                error=('test_field', (), errors.CUSTOM, None,
+                       ('Not an odd number',)))
+    assert validator.errors == {'test_field': ['Not an odd number']}
+
+
+@mark.parametrize('value, _type',
+                  (('', 'string'), ((), 'list'), ({}, 'dict'), ([], 'list')))
+def test_empty_values(value, _type):
+    field = 'test'
+    schema = {field: {'type': _type}}
+    document = {field: value}
+
+    assert_success(document, schema)
+
+    schema[field]['empty'] = False
+    assert_fail(document, schema,
+                error=(field, (field, 'empty'),
+                       errors.EMPTY_NOT_ALLOWED, False))
+
+    schema[field]['empty'] = True
+    assert_success(document, schema)
+
+
+def test_empty_skips_regex(validator):
+    schema = {'foo': {'empty': True, 'regex': r'\d?\d\.\d\d',
+                      'type': 'string'}}
+    assert validator({'foo': ''}, schema)
+
+
+def test_ignore_none_values():
+    field = 'test'
+    schema = {field: {'type': 'string', 'empty': False, 'required': False}}
+    document = {field: None}
+
+    # Test normal behaviour
+    validator = Validator(schema, ignore_none_values=False)
+    assert_fail(document, validator=validator)
+    validator.schema[field]['required'] = True
+    validator.schema.validate()
+    _errors = assert_fail(document, validator=validator)
+    assert_not_has_error(_errors, field, (field, 'required'),
+                         errors.REQUIRED_FIELD, True)
+
+    # Test ignore None behaviour
+    validator = Validator(schema, ignore_none_values=True)
+    validator.schema[field]['required'] = False
+    validator.schema.validate()
+    assert_success(document, validator=validator)
+    validator.schema[field]['required'] = True
+    _errors = assert_fail(schema=schema, document=document, validator=validator)
+    assert_has_error(_errors, field, (field, 'required'), errors.REQUIRED_FIELD,
+                     True)
+    assert_not_has_error(_errors, field, (field, 'type'), errors.BAD_TYPE,
+                         'string')
+
+
+def test_unknown_keys():
+    schema = {}
+
+    # test that unknown fields are allowed when allow_unknown is True.
+    v = Validator(allow_unknown=True, schema=schema)
+    assert_success({"unknown1": True, "unknown2": "yes"}, validator=v)
+
+    # test that unknown fields are allowed only if they meet the
+    # allow_unknown schema when provided.
+    v.allow_unknown = {'type': 'string'}
+    assert_success(document={'name': 'mark'}, validator=v)
+    assert_fail({"name": 1}, validator=v)
+
+    # test that unknown fields are not allowed if allow_unknown is False
+    v.allow_unknown = False
+    assert_fail({'name': 'mark'}, validator=v)
+
+
+def test_unknown_key_dict(validator):
+    # https://github.com/pyeve/cerberus/issues/177
+    validator.allow_unknown = True
+    document = {'a_dict': {'foo': 'foo_value', 'bar': 25}}
+    assert_success(document, {}, validator=validator)
+
+
+def test_unknown_key_list(validator):
+    # https://github.com/pyeve/cerberus/issues/177
+    validator.allow_unknown = True
+    document = {'a_dict': ['foo', 'bar']}
+    assert_success(document, {}, validator=validator)
+
+
+def test_unknown_keys_list_of_dicts(validator):
+    # test that allow_unknown is honored even for subdicts in lists.
+    # https://github.com/pyeve/cerberus/issues/67.
+    validator.allow_unknown = True
+    document = {'a_list_of_dicts': [{'sku': 'YZ069', 'price': 25,
+                                     'extra': True}]}
+    assert_success(document, validator=validator)
+
+
+def test_unknown_keys_retain_custom_rules():
+    # test that allow_unknown schema respect custom validation rules.
+    # https://github.com/pyeve/cerberus/issues/#66.
+    class CustomValidator(Validator):
+        def _validate_type_foo(self, value):
+            if value == "foo":
+                return True
+
+    validator = CustomValidator({})
+    validator.allow_unknown = {"type": "foo"}
+    assert_success(document={"fred": "foo", "barney": "foo"},
+                   validator=validator)
+
+
+def test_nested_unknown_keys():
+    schema = {
+        'field1': {
+            'type': 'dict',
+            'allow_unknown': True,
+            'schema': {'nested1': {'type': 'string'}}
+        }
+    }
+    document = {
+        'field1': {
+            'nested1': 'foo',
+            'arb1': 'bar',
+            'arb2': 42
+        }
+    }
+    assert_success(document=document, schema=schema)
+
+    schema['field1']['allow_unknown'] = {'type': 'string'}
+    assert_fail(document=document, schema=schema)
+
+
+def test_novalidate_noerrors(validator):
+    """
+    In v0.1.0 and below `self.errors` raised an exception if no
+    validation had been performed yet.
+    """
+    assert validator.errors == {}
+
+
+def test_callable_validator():
+    """
+    Validator instance is callable, functions as a shorthand
+    passthrough to validate()
+    """
+    schema = {'test_field': {'type': 'string'}}
+    v = Validator(schema)
+    assert v.validate({'test_field': 'foo'})
+    assert v({'test_field': 'foo'})
+    assert not v.validate({'test_field': 1})
+    assert not v({'test_field': 1})
+
+
+def test_dependencies_field():
+    schema = {'test_field': {'dependencies': 'foo'},
+              'foo': {'type': 'string'}}
+    assert_success({'test_field': 'foobar', 'foo': 'bar'}, schema)
+    assert_fail({'test_field': 'foobar'}, schema)
+
+
+def test_dependencies_list():
+    schema = {
+        'test_field': {'dependencies': ['foo', 'bar']},
+        'foo': {'type': 'string'},
+        'bar': {'type': 'string'}
+    }
+    assert_success({'test_field': 'foobar', 'foo': 'bar', 'bar': 'foo'},
+                   schema)
+    assert_fail({'test_field': 'foobar', 'foo': 'bar'}, schema)
+
+
+def test_dependencies_list_with_required_field():
+    schema = {
+        'test_field': {'required': True, 'dependencies': ['foo', 'bar']},
+        'foo': {'type': 'string'},
+        'bar': {'type': 'string'}
+    }
+    # False: all dependencies missing
+    assert_fail({'test_field': 'foobar'}, schema)
+    # False: one of dependencies missing
+    assert_fail({'test_field': 'foobar', 'foo': 'bar'}, schema)
+    # False: one of dependencies missing
+    assert_fail({'test_field': 'foobar', 'bar': 'foo'}, schema)
+    # False: dependencies are validated and field is required
+    assert_fail({'foo': 'bar', 'bar': 'foo'}, schema)
+    # False: All dependencies are optional but field is still required
+    assert_fail({}, schema)
+    # True: dependency missing
+    assert_fail({'foo': 'bar'}, schema)
+    # True: dependencies are validated but field is not required
+    schema['test_field']['required'] = False
+    assert_success({'foo': 'bar', 'bar': 'foo'}, schema)
+
+
+def test_dependencies_list_with_subodcuments_fields():
+    schema = {
+        'test_field': {'dependencies': ['a_dict.foo', 'a_dict.bar']},
+        'a_dict': {
+            'type': 'dict',
+            'schema': {
+                'foo': {'type': 'string'},
+                'bar': {'type': 'string'}
+            }
+        }
+    }
+    assert_success({'test_field': 'foobar',
+                    'a_dict': {'foo': 'foo', 'bar': 'bar'}}, schema)
+    assert_fail({'test_field': 'foobar', 'a_dict': {}}, schema)
+    assert_fail({'test_field': 'foobar',
+                 'a_dict': {'foo': 'foo'}}, schema)
+
+
+def test_dependencies_dict():
+    schema = {
+        'test_field': {'dependencies': {'foo': 'foo', 'bar': 'bar'}},
+        'foo': {'type': 'string'},
+        'bar': {'type': 'string'}
+    }
+    assert_success({'test_field': 'foobar', 'foo': 'foo', 'bar': 'bar'},
+                   schema)
+    assert_fail({'test_field': 'foobar', 'foo': 'foo'}, schema)
+    assert_fail({'test_field': 'foobar', 'foo': 'bar'}, schema)
+    assert_fail({'test_field': 'foobar', 'bar': 'bar'}, schema)
+    assert_fail({'test_field': 'foobar', 'bar': 'foo'}, schema)
+    assert_fail({'test_field': 'foobar'}, schema)
+
+
+def test_dependencies_dict_with_required_field():
+    schema = {
+        'test_field': {
+            'required': True,
+            'dependencies': {'foo': 'foo', 'bar': 'bar'}
+        },
+        'foo': {'type': 'string'},
+        'bar': {'type': 'string'}
+    }
+    # False: all dependencies missing
+    assert_fail({'test_field': 'foobar'}, schema)
+    # False: one of dependencies missing
+    assert_fail({'test_field': 'foobar', 'foo': 'foo'}, schema)
+    assert_fail({'test_field': 'foobar', 'bar': 'bar'}, schema)
+    # False: dependencies are validated and field is required
+    assert_fail({'foo': 'foo', 'bar': 'bar'}, schema)
+    # False: All dependencies are optional, but field is still required
+    assert_fail({}, schema)
+    # False: dependency missing
+    assert_fail({'foo': 'bar'}, schema)
+
+    assert_success({'test_field': 'foobar', 'foo': 'foo', 'bar': 'bar'},
+                   schema)
+
+    # True: dependencies are validated but field is not required
+    schema['test_field']['required'] = False
+    assert_success({'foo': 'bar', 'bar': 'foo'}, schema)
+
+
+def test_dependencies_field_satisfy_nullable_field():
+    # https://github.com/pyeve/cerberus/issues/305
+    schema = {
+        'foo': {'nullable': True},
+        'bar': {'dependencies': 'foo'}
+    }
+
+    assert_success({'foo': None, 'bar': 1}, schema)
+    assert_success({'foo': None}, schema)
+    assert_fail({'bar': 1}, schema)
+
+
+def test_dependencies_field_with_mutually_dependent_nullable_fields():
+    # https://github.com/pyeve/cerberus/pull/306
+    schema = {
+        'foo': {'dependencies': 'bar', 'nullable': True},
+        'bar': {'dependencies': 'foo', 'nullable': True}
+    }
+    assert_success({'foo': None, 'bar': None}, schema)
+    assert_success({'foo': 1, 'bar': 1}, schema)
+    assert_success({'foo': None, 'bar': 1}, schema)
+    assert_fail({'foo': None}, schema)
+    assert_fail({'foo': 1}, schema)
+
+
+def test_dependencies_dict_with_subdocuments_fields():
+    schema = {
+        'test_field': {'dependencies': {'a_dict.foo': ['foo', 'bar'],
+                                        'a_dict.bar': 'bar'}},
+        'a_dict': {
+            'type': 'dict',
+            'schema': {
+                'foo': {'type': 'string'},
+                'bar': {'type': 'string'}
+            }
+        }
+    }
+    assert_success({'test_field': 'foobar',
+                    'a_dict': {'foo': 'foo', 'bar': 'bar'}}, schema)
+    assert_success({'test_field': 'foobar',
+                    'a_dict': {'foo': 'bar', 'bar': 'bar'}}, schema)
+    assert_fail({'test_field': 'foobar', 'a_dict': {}}, schema)
+    assert_fail({'test_field': 'foobar',
+                 'a_dict': {'foo': 'foo', 'bar': 'foo'}}, schema)
+    assert_fail({'test_field': 'foobar', 'a_dict': {'bar': 'foo'}},
+                schema)
+    assert_fail({'test_field': 'foobar', 'a_dict': {'bar': 'bar'}},
+                schema)
+
+
+def test_root_relative_dependencies():
+    # https://github.com/pyeve/cerberus/issues/288
+    subschema = {'version': {'dependencies': '^repo'}}
+    schema = {'package': {'allow_unknown': True, 'schema': subschema},
+              'repo': {}}
+    assert_fail(
+        {'package': {'repo': 'somewhere', 'version': 0}}, schema,
+        error=('package', ('package', 'schema'),
+               errors.MAPPING_SCHEMA, subschema),
+        child_errors=[(
+            ('package', 'version'),
+            ('package', 'schema', 'version', 'dependencies'),
+            errors.DEPENDENCIES_FIELD, '^repo', ('^repo',)
+        )]
+    )
+    assert_success({'repo': 'somewhere', 'package': {'version': 1}}, schema)
+
+
+def test_dependencies_errors():
+    v = Validator({'field1': {'required': False},
+                   'field2': {'required': True,
+                              'dependencies': {'field1': ['one', 'two']}}})
+    assert_fail({'field1': 'three', 'field2': 7}, validator=v,
+                error=('field2', ('field2', 'dependencies'),
+                       errors.DEPENDENCIES_FIELD_VALUE,
+                       {'field1': ['one', 'two']}, ({'field1': 'three'},)))
+
+
+def test_options_passed_to_nested_validators(validator):
+    validator.schema = {'sub_dict': {'type': 'dict',
+                                     'schema': {'foo': {'type': 'string'}}}}
+    validator.allow_unknown = True
+    assert_success({'sub_dict': {'foo': 'bar', 'unknown': True}},
+                   validator=validator)
+
+
+def test_self_root_document():
+    """ Make sure self.root_document is always the root document.
+    See:
+    * https://github.com/pyeve/cerberus/pull/42
+    * https://github.com/pyeve/eve/issues/295
+    """
+
+    class MyValidator(Validator):
+        def _validate_root_doc(self, root_doc, field, value):
+            """ {'type': 'boolean'} """
+            if ('sub' not in self.root_document or
+                    len(self.root_document['sub']) != 2):
+                self._error(field, 'self.context is not the root doc!')
+
+    schema = {
+        'sub': {
+            'type': 'list',
+            'root_doc': True,
+            'schema': {
+                'type': 'dict',
+                'schema': {
+                    'foo': {
+                        'type': 'string',
+                        'root_doc': True
+                    }
+                }
+            }
+        }
+    }
+    assert_success({'sub': [{'foo': 'bar'}, {'foo': 'baz'}]},
+                   validator=MyValidator(schema))
+
+
+def test_validator_rule(validator):
+    def validate_name(field, value, error):
+        if not value.islower():
+            error(field, 'must be lowercase')
+
+    validator.schema = {
+        'name': {'validator': validate_name},
+        'age': {'type': 'integer'}
+    }
+
+    assert_fail({'name': 'ItsMe', 'age': 2}, validator=validator,
+                error=('name', (), errors.CUSTOM, None, ('must be lowercase',)))
+    assert validator.errors == {'name': ['must be lowercase']}
+    assert_success({'name': 'itsme', 'age': 2}, validator=validator)
+
+
+def test_validated(validator):
+    validator.schema = {'property': {'type': 'string'}}
+    document = {'property': 'string'}
+    assert validator.validated(document) == document
+    document = {'property': 0}
+    assert validator.validated(document) is None
+
+
+def test_anyof():
+    # prop1 must be either a number between 0 and 10
+    schema = {'prop1': {'min': 0, 'max': 10}}
+    doc = {'prop1': 5}
+
+    assert_success(doc, schema)
+
+    # prop1 must be either a number between 0 and 10 or 100 and 110
+    schema = {'prop1': {'anyof':
+                        [{'min': 0, 'max': 10}, {'min': 100, 'max': 110}]}}
+    doc = {'prop1': 105}
+
+    assert_success(doc, schema)
+
+    # prop1 must be either a number between 0 and 10 or 100 and 110
+    schema = {'prop1': {'anyof':
+                        [{'min': 0, 'max': 10}, {'min': 100, 'max': 110}]}}
+    doc = {'prop1': 50}
+
+    assert_fail(doc, schema)
+
+    # prop1 must be an integer that is either be
+    # greater than or equal to 0, or greater than or equal to 10
+    schema = {'prop1': {'type': 'integer',
+                        'anyof': [{'min': 0}, {'min': 10}]}}
+    assert_success({'prop1': 10}, schema)
+    # test that intermediate schemas do not sustain
+    assert 'type' not in schema['prop1']['anyof'][0]
+    assert 'type' not in schema['prop1']['anyof'][1]
+    assert 'allow_unknown' not in schema['prop1']['anyof'][0]
+    assert 'allow_unknown' not in schema['prop1']['anyof'][1]
+    assert_success({'prop1': 5}, schema)
+
+    exp_child_errors = [
+        (('prop1',), ('prop1', 'anyof', 0, 'min'), errors.MIN_VALUE, 0),
+        (('prop1',), ('prop1', 'anyof', 1, 'min'), errors.MIN_VALUE, 10)
+    ]
+    assert_fail({'prop1': -1}, schema,
+                error=(('prop1',), ('prop1', 'anyof'), errors.ANYOF,
+                       [{'min': 0}, {'min': 10}]),
+                child_errors=exp_child_errors)
+    doc = {'prop1': 5.5}
+    assert_fail(doc, schema)
+    doc = {'prop1': '5.5'}
+    assert_fail(doc, schema)
+
+
+def test_allof():
+    # prop1 has to be a float between 0 and 10
+    schema = {'prop1': {'allof': [
+        {'type': 'float'}, {'min': 0}, {'max': 10}]}}
+    doc = {'prop1': -1}
+    assert_fail(doc, schema)
+    doc = {'prop1': 5}
+    assert_success(doc, schema)
+    doc = {'prop1': 11}
+    assert_fail(doc, schema)
+
+    # prop1 has to be a float and an integer
+    schema = {'prop1': {'allof': [{'type': 'float'}, {'type': 'integer'}]}}
+    doc = {'prop1': 11}
+    assert_success(doc, schema)
+    doc = {'prop1': 11.5}
+    assert_fail(doc, schema)
+    doc = {'prop1': '11'}
+    assert_fail(doc, schema)
+
+
+def test_unicode_allowed():
+    # issue 280
+    doc = {'letters': u'♄εℓł☺'}
+
+    schema = {'letters': {'type': 'string', 'allowed': ['a', 'b', 'c']}}
+    assert_fail(doc, schema)
+
+    schema = {'letters': {'type': 'string', 'allowed': [u'♄εℓł☺']}}
+    assert_success(doc, schema)
+
+    schema = {'letters': {'type': 'string', 'allowed': ['♄εℓł☺']}}
+    doc = {'letters': '♄εℓł☺'}
+    assert_success(doc, schema)
+
+
+@mark.skipif(sys.version_info[0] < 3,
+             reason='requires python 3.x')
+def test_unicode_allowed_py3():
+    """ All strings are unicode in Python 3.x. Input doc and schema
+    have equal strings and validation yield success."""
+
+    # issue 280
+    doc = {'letters': u'♄εℓł☺'}
+    schema = {'letters': {'type': 'string', 'allowed': ['♄εℓł☺']}}
+    assert_success(doc, schema)
+
+
+@mark.skipif(sys.version_info[0] > 2,
+             reason='requires python 2.x')
+def test_unicode_allowed_py2():
+    """ Python 2.x encodes value of allowed using default encoding if
+    the string includes characters outside ASCII range. Produced string
+    does not match input which is an unicode string."""
+
+    # issue 280
+    doc = {'letters': u'♄εℓł☺'}
+    schema = {'letters': {'type': 'string', 'allowed': ['♄εℓł☺']}}
+    assert_fail(doc, schema)
+
+
+def test_oneof():
+    # prop1 can only only be:
+    # - greater than 10
+    # - greater than 0
+    # - equal to -5, 5, or 15
+
+    schema = {'prop1': {'type': 'integer', 'oneof': [
+        {'min': 0},
+        {'min': 10},
+        {'allowed': [-5, 5, 15]}]}}
+
+    # document is not valid
+    # prop1 not greater than 0, 10 or equal to -5
+    doc = {'prop1': -1}
+    assert_fail(doc, schema)
+
+    # document is valid
+    # prop1 is less then 0, but is -5
+    doc = {'prop1': -5}
+    assert_success(doc, schema)
+
+    # document is valid
+    # prop1 greater than 0
+    doc = {'prop1': 1}
+    assert_success(doc, schema)
+
+    # document is not valid
+    # prop1 is greater than 0
+    # and equal to 5
+    doc = {'prop1': 5}
+    assert_fail(doc, schema)
+
+    # document is not valid
+    # prop1 is greater than 0
+    # and greater than 10
+    doc = {'prop1': 11}
+    assert_fail(doc, schema)
+
+    # document is not valid
+    # prop1 is greater than 0
+    # and greater than 10
+    # and equal to 15
+    doc = {'prop1': 15}
+    assert_fail(doc, schema)
+
+
+def test_noneof():
+    # prop1 can not be:
+    # - greater than 10
+    # - greater than 0
+    # - equal to -5, 5, or 15
+
+    schema = {'prop1': {'type': 'integer', 'noneof': [
+        {'min': 0},
+        {'min': 10},
+        {'allowed': [-5, 5, 15]}]}}
+
+    # document is valid
+    doc = {'prop1': -1}
+    assert_success(doc, schema)
+
+    # document is not valid
+    # prop1 is equal to -5
+    doc = {'prop1': -5}
+    assert_fail(doc, schema)
+
+    # document is not valid
+    # prop1 greater than 0
+    doc = {'prop1': 1}
+    assert_fail(doc, schema)
+
+    # document is not valid
+    doc = {'prop1': 5}
+    assert_fail(doc, schema)
+
+    # document is not valid
+    doc = {'prop1': 11}
+    assert_fail(doc, schema)
+
+    # document is not valid
+    # and equal to 15
+    doc = {'prop1': 15}
+    assert_fail(doc, schema)
+
+
+def test_anyof_allof():
+    # prop1 can be any number outside of [0-10]
+    schema = {'prop1': {'allof': [{'anyof': [{'type': 'float'},
+                                             {'type': 'integer'}]},
+                                  {'anyof': [{'min': 10},
+                                             {'max': 0}]}
+                                  ]}}
+
+    doc = {'prop1': 11}
+    assert_success(doc, schema)
+    doc = {'prop1': -1}
+    assert_success(doc, schema)
+    doc = {'prop1': 5}
+    assert_fail(doc, schema)
+
+    doc = {'prop1': 11.5}
+    assert_success(doc, schema)
+    doc = {'prop1': -1.5}
+    assert_success(doc, schema)
+    doc = {'prop1': 5.5}
+    assert_fail(doc, schema)
+
+    doc = {'prop1': '5.5'}
+    assert_fail(doc, schema)
+
+
+def test_anyof_schema(validator):
+    # test that a list of schemas can be specified.
+
+    valid_parts = [{'schema': {'model number': {'type': 'string'},
+                               'count': {'type': 'integer'}}},
+                   {'schema': {'serial number': {'type': 'string'},
+                               'count': {'type': 'integer'}}}]
+    valid_item = {'type': ['dict', 'string'], 'anyof': valid_parts}
+    schema = {'parts': {'type': 'list', 'schema': valid_item}}
+    document = {'parts': [{'model number': 'MX-009', 'count': 100},
+                          {'serial number': '898-001'},
+                          'misc']}
+
+    # document is valid. each entry in 'parts' matches a type or schema
+    assert_success(document, schema, validator=validator)
+
+    document['parts'].append({'product name': "Monitors", 'count': 18})
+    # document is invalid. 'product name' does not match any valid schemas
+    assert_fail(document, schema, validator=validator)
+
+    document['parts'].pop()
+    # document is valid again
+    assert_success(document, schema, validator=validator)
+
+    document['parts'].append({'product name': "Monitors", 'count': 18})
+    document['parts'].append(10)
+    # and invalid. numbers are not allowed.
+
+    exp_child_errors = [
+        (('parts', 3), ('parts', 'schema', 'anyof'), errors.ANYOF,
+         valid_parts),
+        (('parts', 4), ('parts', 'schema', 'type'), errors.BAD_TYPE,
+         ['dict', 'string'])
+    ]
+
+    _errors = assert_fail(document, schema, validator=validator,
+                          error=('parts', ('parts', 'schema'),
+                                 errors.SEQUENCE_SCHEMA, valid_item),
+                          child_errors=exp_child_errors)
+    assert_not_has_error(_errors, ('parts', 4), ('parts', 'schema', 'anyof'),
+                         errors.ANYOF, valid_parts)
+
+    # tests errors.BasicErrorHandler's tree representation
+    v_errors = validator.errors
+    assert 'parts' in v_errors
+    assert 3 in v_errors['parts'][-1]
+    assert v_errors['parts'][-1][3][0] == "no definitions validate"
+    scope = v_errors['parts'][-1][3][-1]
+    assert 'anyof definition 0' in scope
+    assert 'anyof definition 1' in scope
+    assert scope['anyof definition 0'] == [{"product name": ["unknown field"]}]
+    assert scope['anyof definition 1'] == [{"product name": ["unknown field"]}]
+    assert v_errors['parts'][-1][4] == ["must be of ['dict', 'string'] type"]
+
+
+def test_anyof_2():
+    # these two schema should be the same
+    schema1 = {'prop': {'anyof': [{'type': 'dict',
+                                   'schema': {
+                                       'val': {'type': 'integer'}}},
+                                  {'type': 'dict',
+                                   'schema': {
+                                       'val': {'type': 'string'}}}]}}
+    schema2 = {'prop': {'type': 'dict', 'anyof': [
+        {'schema': {'val': {'type': 'integer'}}},
+        {'schema': {'val': {'type': 'string'}}}]}}
+
+    doc = {'prop': {'val': 0}}
+    assert_success(doc, schema1)
+    assert_success(doc, schema2)
+
+    doc = {'prop': {'val': '0'}}
+    assert_success(doc, schema1)
+    assert_success(doc, schema2)
+
+    doc = {'prop': {'val': 1.1}}
+    assert_fail(doc, schema1)
+    assert_fail(doc, schema2)
+
+
+def test_anyof_type():
+    schema = {'anyof_type': {'anyof_type': ['string', 'integer']}}
+    assert_success({'anyof_type': 'bar'}, schema)
+    assert_success({'anyof_type': 23}, schema)
+
+
+def test_oneof_schema():
+    schema = {'oneof_schema': {'type': 'dict',
+                               'oneof_schema':
+                                   [{'digits': {'type': 'integer',
+                                                'min': 0, 'max': 99}},
+                                    {'text': {'type': 'string',
+                                              'regex': '^[0-9]{2}$'}}]}}
+    assert_success({'oneof_schema': {'digits': 19}}, schema)
+    assert_success({'oneof_schema': {'text': '84'}}, schema)
+    assert_fail({'oneof_schema': {'digits': 19, 'text': '84'}}, schema)
+
+
+def test_nested_oneof_type():
+    schema = {'nested_oneof_type':
+              {'valueschema': {'oneof_type': ['string', 'integer']}}}
+    assert_success({'nested_oneof_type': {'foo': 'a'}}, schema)
+    assert_success({'nested_oneof_type': {'bar': 3}}, schema)
+
+
+def test_nested_oneofs(validator):
+    validator.schema = {'abc': {
+        'type': 'dict',
+        'oneof_schema': [
+            {'foo': {
+                'type': 'dict',
+                'schema': {'bar': {'oneof_type': ['integer', 'float']}}
+            }},
+            {'baz': {'type': 'string'}}
+        ]}}
+
+    document = {'abc': {'foo': {'bar': 'bad'}}}
+
+    expected_errors = {
+        'abc': [
+            'none or more than one rule validate',
+            {'oneof definition 0': [
+                {'foo': [{'bar': [
+                    'none or more than one rule validate',
+                    {'oneof definition 0': ['must be of integer type'],
+                     'oneof definition 1': ['must be of float type']}
+                ]}]}],
+             'oneof definition 1': [{'foo': ['unknown field']}]}
+        ]
+    }
+
+    assert_fail(document, validator=validator)
+    assert validator.errors == expected_errors
+
+
+def test_no_of_validation_if_type_fails(validator):
+    valid_parts = [{'schema': {'model number': {'type': 'string'},
+                               'count': {'type': 'integer'}}},
+                   {'schema': {'serial number': {'type': 'string'},
+                               'count': {'type': 'integer'}}}]
+    validator.schema = {'part': {'type': ['dict', 'string'],
+                                 'anyof': valid_parts}}
+    document = {'part': 10}
+    _errors = assert_fail(document, validator=validator)
+    assert len(_errors) == 1
+
+
+def test_issue_107(validator):
+    schema = {'info': {'type': 'dict',
+                       'schema': {'name': {'type': 'string',
+                                           'required': True}}}}
+    document = {'info': {'name': 'my name'}}
+    assert_success(document, schema, validator=validator)
+
+    v = Validator(schema)
+    assert_success(document, schema, v)
+    # it once was observed that this behaves other than the previous line
+    assert v.validate(document)
+
+
+def test_dont_type_validate_nulled_values(validator):
+    assert_fail({'an_integer': None}, validator=validator)
+    assert validator.errors == {'an_integer': ['null value not allowed']}
+
+
+def test_dependencies_error(validator):
+    schema = {'field1': {'required': False},
+              'field2': {'required': True,
+                         'dependencies': {'field1': ['one', 'two']}}}
+    validator.validate({'field2': 7}, schema)
+    exp_msg = errors.BasicErrorHandler \
+        .messages[errors.DEPENDENCIES_FIELD_VALUE.code] \
+        .format(field='field2', constraint={'field1': ['one', 'two']})
+    assert validator.errors == {'field2': [exp_msg]}
+
+
+def test_dependencies_on_boolean_field_with_one_value():
+    # https://github.com/pyeve/cerberus/issues/138
+    schema = {'deleted': {'type': 'boolean'},
+              'text': {'dependencies': {'deleted': False}}}
+    try:
+        assert_success({'text': 'foo', 'deleted': False}, schema)
+        assert_fail({'text': 'foo', 'deleted': True}, schema)
+        assert_fail({'text': 'foo'}, schema)
+    except TypeError as e:
+        if str(e) == "argument of type 'bool' is not iterable":
+            raise AssertionError(
+                "Bug #138 still exists, couldn't use boolean in dependency "
+                "without putting it in a list.\n"
+                "'some_field': True vs 'some_field: [True]")
+        else:
+            raise
+
+
+def test_dependencies_on_boolean_field_with_value_in_list():
+    # https://github.com/pyeve/cerberus/issues/138
+    schema = {'deleted': {'type': 'boolean'},
+              'text': {'dependencies': {'deleted': [False]}}}
+
+    assert_success({'text': 'foo', 'deleted': False}, schema)
+    assert_fail({'text': 'foo', 'deleted': True}, schema)
+    assert_fail({'text': 'foo'}, schema)
+
+
+def test_document_path():
+    class DocumentPathTester(Validator):
+        def _validate_trail(self, constraint, field, value):
+            """ {'type': 'boolean'} """
+            test_doc = self.root_document
+            for crumb in self.document_path:
+                test_doc = test_doc[crumb]
+            assert test_doc == self.document
+
+    v = DocumentPathTester()
+    schema = {'foo': {'schema': {'bar': {'trail': True}}}}
+    document = {'foo': {'bar': {}}}
+    assert_success(document, schema, validator=v)
+
+
+def test_excludes():
+    schema = {'this_field': {'type': 'dict',
+                             'excludes': 'that_field'},
+              'that_field': {'type': 'dict'}}
+    assert_success({'this_field': {}}, schema)
+    assert_success({'that_field': {}}, schema)
+    assert_success({}, schema)
+    assert_fail({'that_field': {}, 'this_field': {}}, schema)
+
+
+def test_mutual_excludes():
+    schema = {'this_field': {'type': 'dict',
+                             'excludes': 'that_field'},
+              'that_field': {'type': 'dict',
+                             'excludes': 'this_field'}}
+    assert_success({'this_field': {}}, schema)
+    assert_success({'that_field': {}}, schema)
+    assert_success({}, schema)
+    assert_fail({'that_field': {}, 'this_field': {}}, schema)
+
+
+def test_required_excludes():
+    schema = {'this_field': {'type': 'dict',
+                             'excludes': 'that_field',
+                             'required': True},
+              'that_field': {'type': 'dict',
+                             'excludes': 'this_field',
+                             'required': True}}
+    assert_success({'this_field': {}}, schema, update=False)
+    assert_success({'that_field': {}}, schema, update=False)
+    assert_fail({}, schema)
+    assert_fail({'that_field': {}, 'this_field': {}}, schema)
+
+
+def test_multiples_exclusions():
+    schema = {'this_field': {'type': 'dict',
+                             'excludes': ['that_field', 'bazo_field']},
+              'that_field': {'type': 'dict',
+                             'excludes': 'this_field'},
+              'bazo_field': {'type': 'dict'}}
+    assert_success({'this_field': {}}, schema)
+    assert_success({'that_field': {}}, schema)
+    assert_fail({'this_field': {}, 'that_field': {}}, schema)
+    assert_fail({'this_field': {}, 'bazo_field': {}}, schema)
+    assert_fail({'that_field': {}, 'this_field': {}, 'bazo_field': {}}, schema)
+    assert_success({'that_field': {}, 'bazo_field': {}}, schema)
+
+
+def test_bad_excludes_fields(validator):
+    validator.schema = {'this_field': {'type': 'dict',
+                                       'excludes': ['that_field', 'bazo_field'],
+                                       'required': True},
+                        'that_field': {'type': 'dict',
+                                       'excludes': 'this_field',
+                                       'required': True}}
+    assert_fail({'that_field': {}, 'this_field': {}}, validator=validator)
+    handler = errors.BasicErrorHandler
+    assert (validator.errors ==
+            {'that_field':
+                [handler.messages[errors.EXCLUDES_FIELD.code].format(
+                    "'this_field'", field="that_field")],
+                'this_field':
+                    [handler.messages[errors.EXCLUDES_FIELD.code].format(
+                        "'that_field', 'bazo_field'", field="this_field")]})
+
+
+def test_boolean_is_not_a_number():
+    # https://github.com/pyeve/cerberus/issues/144
+    assert_fail({'value': True}, {'value': {'type': 'number'}})
+
+
+def test_min_max_date():
+    schema = {'date': {'min': date(1900, 1, 1), 'max': date(1999, 12, 31)}}
+    assert_success({'date': date(1945, 5, 8)}, schema)
+    assert_fail({'date': date(1871, 5, 10)}, schema)
+
+
+def test_dict_length():
+    schema = {'dict': {'minlength': 1}}
+    assert_fail({'dict': {}}, schema)
+    assert_success({'dict': {'foo': 'bar'}}, schema)
+
+
+def test_forbidden():
+    schema = {'user': {'forbidden': ['root', 'admin']}}
+    assert_fail({'user': 'admin'}, schema)
+    assert_success({'user': 'alice'}, schema)
+
+
+def test_mapping_with_sequence_schema():
+    schema = {'list': {'schema': {'allowed': ['a', 'b', 'c']}}}
+    document = {'list': {'is_a': 'mapping'}}
+    assert_fail(document, schema,
+                error=('list', ('list', 'schema'), errors.BAD_TYPE_FOR_SCHEMA,
+                       schema['list']['schema']))
+
+
+def test_sequence_with_mapping_schema():
+    schema = {'list': {'schema': {'foo': {'allowed': ['a', 'b', 'c']}},
+                       'type': 'dict'}}
+    document = {'list': ['a', 'b', 'c']}
+    assert_fail(document, schema)
+
+
+def test_type_error_aborts_validation():
+    schema = {'foo': {'type': 'string', 'allowed': ['a']}}
+    document = {'foo': 0}
+    assert_fail(document, schema,
+                error=('foo', ('foo', 'type'), errors.BAD_TYPE, 'string'))
+
+
+def test_dependencies_in_oneof():
+    # https://github.com/pyeve/cerberus/issues/241
+    schema = {'a': {'type': 'integer',
+                    'oneof': [
+                        {'allowed': [1], 'dependencies': 'b'},
+                        {'allowed': [2], 'dependencies': 'c'}
+                    ]},
+              'b': {},
+              'c': {}}
+    assert_success({'a': 1, 'b': 'foo'}, schema)
+    assert_success({'a': 2, 'c': 'bar'}, schema)
+    assert_fail({'a': 1, 'c': 'foo'}, schema)
+    assert_fail({'a': 2, 'b': 'bar'}, schema)
+
+
+def test_allow_unknown_with_oneof_rules(validator):
+    # https://github.com/pyeve/cerberus/issues/251
+    schema = {
+        'test': {
+            'oneof': [
+                {
+                    'type': 'dict',
+                    'allow_unknown': True,
+                    'schema': {'known': {'type': 'string'}}
+                },
+                {
+                    'type': 'dict',
+                    'schema': {'known': {'type': 'string'}}
+                },
+            ]
+        }
+    }
+    # check regression and that allow unknown does not cause any different
+    # than expected behaviour for one-of.
+    document = {'test': {'known': 's'}}
+    validator(document, schema)
+    _errors = validator._errors
+    assert len(_errors) == 1
+    assert_has_error(_errors, 'test', ('test', 'oneof'),
+                     errors.ONEOF, schema['test']['oneof'])
+    assert len(_errors[0].child_errors) == 0
+    # check that allow_unknown is actually applied
+    document = {'test': {'known': 's', 'unknown': 'asd'}}
+    assert_success(document, validator=validator)
diff --git a/pipenv/vendor/cerberus/utils.py b/pipenv/vendor/cerberus/utils.py
new file mode 100644
index 00000000..f10d3976
--- /dev/null
+++ b/pipenv/vendor/cerberus/utils.py
@@ -0,0 +1,119 @@
+from __future__ import absolute_import
+
+from collections import Mapping, namedtuple, Sequence
+
+from cerberus.platform import _int_types, _str_type
+
+
+TypeDefinition = namedtuple('TypeDefinition',
+                            'name,included_types,excluded_types')
+"""
+This class is used to define types that can be used as value in the
+:attr:`~cerberus.Validator.types_mapping` property.
+The ``name`` should be descriptive and match the key it is going to be assigned
+to.
+A value that is validated against such definition must be an instance of any of
+the types contained in ``included_types`` and must not match any of the types
+contained in ``excluded_types``.
+"""
+
+
+def compare_paths_lt(x, y):
+    for i in range(min(len(x), len(y))):
+        if isinstance(x[i], type(y[i])):
+            if x[i] != y[i]:
+                return x[i] < y[i]
+        elif isinstance(x[i], _int_types):
+            return True
+        elif isinstance(y[i], _int_types):
+            return False
+    return len(x) < len(y)
+
+
+def drop_item_from_tuple(t, i):
+    return t[:i] + t[i + 1:]
+
+
+def get_Validator_class():
+    global Validator
+    if 'Validator' not in globals():
+        from cerberus.validator import Validator
+    return Validator
+
+
+def mapping_hash(schema):
+    return hash(mapping_to_frozenset(schema))
+
+
+def mapping_to_frozenset(mapping):
+    """ Be aware that this treats any sequence type with the equal members as
+        equal. As it is used to identify equality of schemas, this can be
+        considered okay as definitions are semantically equal regardless the
+        container type. """
+    mapping = mapping.copy()
+    for key, value in mapping.items():
+        if isinstance(value, Mapping):
+            mapping[key] = mapping_to_frozenset(value)
+        elif isinstance(value, Sequence):
+            value = list(value)
+            for i, item in enumerate(value):
+                if isinstance(item, Mapping):
+                    value[i] = mapping_to_frozenset(item)
+            mapping[key] = tuple(value)
+    return frozenset(mapping.items())
+
+
+def isclass(obj):
+    try:
+        issubclass(obj, object)
+    except TypeError:
+        return False
+    else:
+        return True
+
+
+def quote_string(value):
+    if isinstance(value, _str_type):
+        return '"%s"' % value
+    else:
+        return value
+
+
+class readonly_classproperty(property):
+    def __get__(self, instance, owner):
+        return super(readonly_classproperty, self).__get__(owner)
+
+    def __set__(self, instance, value):
+        raise RuntimeError('This is a readonly class property.')
+
+    def __delete__(self, instance):
+        raise RuntimeError('This is a readonly class property.')
+
+
+def validator_factory(name, bases=None, namespace={}):
+    """ Dynamically create a :class:`~cerberus.Validator` subclass.
+        Docstrings of mixin-classes will be added to the resulting
+        class' one if ``__doc__`` is not in :obj:`namespace`.
+
+    :param name: The name of the new class.
+    :type name: :class:`str`
+    :param bases: Class(es) with additional and overriding attributes.
+    :type bases: :class:`tuple` of or a single :term:`class`
+    :param namespace: Attributes for the new class.
+    :type namespace: :class:`dict`
+    :return: The created class.
+    """
+    Validator = get_Validator_class()
+
+    if bases is None:
+        bases = (Validator,)
+    elif isinstance(bases, tuple):
+        bases += (Validator,)
+    else:
+        bases = (bases, Validator)
+
+    docstrings = [x.__doc__ for x in bases if x.__doc__]
+    if len(docstrings) > 1 and '__doc__' not in namespace:
+        namespace.update({'__doc__': '\n'.join(docstrings)})
+
+    return type(name, bases, namespace)
diff --git a/pipenv/vendor/cerberus/validator.py b/pipenv/vendor/cerberus/validator.py
new file mode 100644
index 00000000..27a29053
--- /dev/null
+++ b/pipenv/vendor/cerberus/validator.py
@@ -0,0 +1,1407 @@
+"""
+    Extensible validation for Python dictionaries.
+    This module implements Cerberus Validator class
+
+    :copyright: 2012-2016 by Nicola Iarocci.
+    :license: ISC, see LICENSE for more details.
+
+    Full documentation is available at http://python-cerberus.org
+"""
+
+from __future__ import absolute_import
+
+from ast import literal_eval
+from collections import Hashable, Iterable, Mapping, Sequence
+from copy import copy
+from datetime import date, datetime
+import re
+from warnings import warn
+
+from cerberus import errors
+from cerberus.platform import _int_types, _str_type
+from cerberus.schema import (schema_registry, rules_set_registry,
+                             DefinitionSchema, SchemaError)
+from cerberus.utils import (drop_item_from_tuple, isclass,
+                            readonly_classproperty, TypeDefinition)
+
+
+toy_error_handler = errors.ToyErrorHandler()
+
+
+def dummy_for_rule_validation(rule_constraints):
+    def dummy(self, constraint, field, value):
+        raise RuntimeError('Dummy method called. Its purpose is to hold just'
+                           'validation constraints for a rule in its '
+                           'docstring.')
+    f = dummy
+    f.__doc__ = rule_constraints
+    return f
+
+
+class DocumentError(Exception):
+    """ Raised when the target document is missing or has the wrong format """
+    pass
+
+
+class _SchemaRuleTypeError(Exception):
+    """ Raised when a schema (list) validation encounters a mapping.
+        Not supposed to be used outside this module. """
+    pass
+
+
+class BareValidator(object):
+    """ Validator class. Normalizes and/or validates any mapping against a
+    validation-schema which is provided as an argument at class instantiation
+    or upon calling the :meth:`~cerberus.Validator.validate`,
+    :meth:`~cerberus.Validator.validated` or
+    :meth:`~cerberus.Validator.normalized` method. An instance itself is
+    callable and executes a validation.
+
+    All instantiation parameters are optional.
+
+    There are the introspective properties :attr:`types`, :attr:`validators`,
+    :attr:`coercers`, :attr:`default_setters`, :attr:`rules`,
+    :attr:`normalization_rules` and :attr:`validation_rules`.
+
+    The attributes reflecting the available rules are assembled considering
+    constraints that are defined in the docstrings of rules' methods and is
+    effectively used as validation schema for :attr:`schema`.
+
+    :param schema: See :attr:`~cerberus.Validator.schema`.
+                   Defaults to :obj:`None`.
+    :type schema: any :term:`mapping`
+    :param ignore_none_values: See :attr:`~cerberus.Validator.ignore_none_values`.
+                               Defaults to ``False``.
+    :type ignore_none_values: :class:`bool`
+    :param allow_unknown: See :attr:`~cerberus.Validator.allow_unknown`.
+                          Defaults to ``False``.
+    :type allow_unknown: :class:`bool` or any :term:`mapping`
+    :param purge_unknown: See :attr:`~cerberus.Validator.purge_unknown`.
+                          Defaults to to ``False``.
+    :type purge_unknown: :class:`bool`
+    :param error_handler: The error handler that formats the result of
+                          :attr:`~cerberus.Validator.errors`.
+                          When given as two-value tuple with an error-handler
+                          class and a dictionary, the latter is passed to the
+                          initialization of the error handler.
+                          Default: :class:`~cerberus.errors.BasicErrorHandler`.
+    :type error_handler: class or instance based on
+                         :class:`~cerberus.errors.BaseErrorHandler` or
+                         :class:`tuple`
+    """  # noqa: E501
+
+    mandatory_validations = ('nullable',)
+    """ Rules that are evaluated on any field, regardless whether defined in
+        the schema or not.
+        Type: :class:`tuple` """
+    priority_validations = ('nullable', 'readonly', 'type', 'empty')
+    """ Rules that will be processed in that order before any other.
+        Type: :class:`tuple` """
+    types_mapping = {
+        'binary':
+            TypeDefinition('binary', (bytes, bytearray), ()),
+        'boolean':
+            TypeDefinition('boolean', (bool,), ()),
+        'date':
+            TypeDefinition('date', (date,), ()),
+        'datetime':
+            TypeDefinition('datetime', (datetime,), ()),
+        'dict':
+            TypeDefinition('dict', (Mapping,), ()),
+        'float':
+            TypeDefinition('float', (float, _int_types), ()),
+        'integer':
+            TypeDefinition('integer', (_int_types,), ()),
+        'list':
+            TypeDefinition('list', (Sequence,), (_str_type,)),
+        'number':
+            TypeDefinition('number', (_int_types, float), (bool,)),
+        'set':
+            TypeDefinition('set', (set,), ()),
+        'string':
+            TypeDefinition('string', (_str_type), ())
+    }
+    """ This mapping holds all available constraints for the type rule and
+        their assigned :class:`~cerberus.TypeDefinition`. """
+    _valid_schemas = set()
+    """ A :class:`set` of hashes derived from validation schemas that are
+        legit for a particular ``Validator`` class. """
+
+    def __init__(self, *args, **kwargs):
+        """ The arguments will be treated as with this signature:
+
+        __init__(self, schema=None, ignore_none_values=False,
+                 allow_unknown=False, purge_unknown=False,
+                 error_handler=errors.BasicErrorHandler)
+        """
+
+        self.document = None
+        """ The document that is or was recently processed.
+            Type: any :term:`mapping` """
+        self._errors = errors.ErrorList()
+        """ The list of errors that were encountered since the last document
+            processing was invoked.
+            Type: :class:`~cerberus.errors.ErrorList` """
+        self.recent_error = None
+        """ The last individual error that was submitted.
+            Type: :class:`~cerberus.errors.ValidationError` """
+        self.document_error_tree = errors.DocumentErrorTree()
+        """ A tree representiation of encountered errors following the
+            structure of the document.
+            Type: :class:`~cerberus.errors.DocumentErrorTree` """
+        self.schema_error_tree = errors.SchemaErrorTree()
+        """ A tree representiation of encountered errors following the
+            structure of the schema.
+            Type: :class:`~cerberus.errors.SchemaErrorTree` """
+        self.document_path = ()
+        """ The path within the document to the current sub-document.
+            Type: :class:`tuple` """
+        self.schema_path = ()
+        """ The path within the schema to the current sub-schema.
+            Type: :class:`tuple` """
+        self.update = False
+        self.error_handler = self.__init_error_handler(kwargs)
+        """ The error handler used to format :attr:`~cerberus.Validator.errors`
+            and process submitted errors with
+            :meth:`~cerberus.Validator._error`.
+            Type: :class:`~cerberus.errors.BaseErrorHandler` """
+        self.__store_config(args, kwargs)
+        self.schema = kwargs.get('schema', None)
+        self.allow_unknown = kwargs.get('allow_unknown', False)
+        self._remaining_rules = []
+        """ Keeps track of the rules that are next in line to be evaluated
+            during the validation of a field.
+            Type: :class:`list` """
+
+        super(BareValidator, self).__init__()
+
+    @staticmethod
+    def __init_error_handler(kwargs):
+        error_handler = kwargs.pop('error_handler', errors.BasicErrorHandler)
+        if isinstance(error_handler, tuple):
+            error_handler, eh_config = error_handler
+        else:
+            eh_config = {}
+        if isclass(error_handler) and \
+                issubclass(error_handler, errors.BaseErrorHandler):
+            return error_handler(**eh_config)
+        elif isinstance(error_handler, errors.BaseErrorHandler):
+            return error_handler
+        else:
+            raise RuntimeError('Invalid error_handler.')
+
+    def __store_config(self, args, kwargs):
+        """ Assign args to kwargs and store configuration. """
+        signature = ('schema', 'ignore_none_values', 'allow_unknown',
+                     'purge_unknown')
+        for i, p in enumerate(signature[:len(args)]):
+            if p in kwargs:
+                raise TypeError("__init__ got multiple values for argument "
+                                "'%s'" % p)
+            else:
+                kwargs[p] = args[i]
+        self._config = kwargs
+        """ This dictionary holds the configuration arguments that were used to
+            initialize the :class:`Validator` instance except the
+            ``error_handler``. """
+
+    @classmethod
+    def clear_caches(cls):
+        """ Purge the cache of known valid schemas. """
+        cls._valid_schemas.clear()
+
+    def _error(self, *args):
+        """ Creates and adds one or multiple errors.
+
+        :param args: Accepts different argument's signatures.
+
+                     *1. Bulk addition of errors:*
+
+                     - :term:`iterable` of
+                       :class:`~cerberus.errors.ValidationError`-instances
+
+                     The errors will be added to
+                     :attr:`~cerberus.Validator._errors`.
+
+                     *2. Custom error:*
+
+                     - the invalid field's name
+
+                     - the error message
+
+                     A custom error containing the message will be created and
+                     added to :attr:`~cerberus.Validator._errors`.
+                     There will however be fewer information contained in the
+                     error (no reference to the violated rule and its
+                     constraint).
+
+                     *3. Defined error:*
+
+                     - the invalid field's name
+
+                     - the error-reference, see :mod:`cerberus.errors`
+
+                     - arbitrary, supplemental information about the error
+
+                     A :class:`~cerberus.errors.ValidationError` instance will
+                     be created and added to
+                     :attr:`~cerberus.Validator._errors`.
+        """
+        if len(args) == 1:
+            self._errors.extend(args[0])
+            self._errors.sort()
+            for error in args[0]:
+                self.document_error_tree += error
+                self.schema_error_tree += error
+                self.error_handler.emit(error)
+        elif len(args) == 2 and isinstance(args[1], _str_type):
+            self._error(args[0], errors.CUSTOM, args[1])
+        elif len(args) >= 2:
+            field = args[0]
+            code = args[1].code
+            rule = args[1].rule
+            info = args[2:]
+
+            document_path = self.document_path + (field, )
+
+            schema_path = self.schema_path
+            if code != errors.UNKNOWN_FIELD.code and rule is not None:
+                schema_path += (field, rule)
+
+            if not rule:
+                constraint = None
+            else:
+                field_definitions = self._resolve_rules_set(self.schema[field])
+                if rule == 'nullable':
+                    constraint = field_definitions.get(rule, False)
+                else:
+                    constraint = field_definitions[rule]
+
+            value = self.document.get(field)
+
+            self.recent_error = errors.ValidationError(
+                document_path, schema_path, code, rule, constraint, value, info
+            )
+            self._error([self.recent_error])
+
+    def _get_child_validator(self, document_crumb=None, schema_crumb=None,
+                             **kwargs):
+        """ Creates a new instance of Validator-(sub-)class. All initial
+            parameters of the parent are passed to the initialization, unless
+            a parameter is given as an explicit *keyword*-parameter.
+
+        :param document_crumb: Extends the
+                               :attr:`~cerberus.Validator.document_path`
+                               of the child-validator.
+        :type document_crumb: :class:`tuple` or :term:`hashable`
+        :param schema_crumb: Extends the
+                             :attr:`~cerberus.Validator.schema_path`
+                             of the child-validator.
+        :type schema_crumb: :class:`tuple` or hashable
+        :param kwargs: Overriding keyword-arguments for initialization.
+        :type kwargs: :class:`dict`
+
+        :return: an instance of ``self.__class__``
+        """
+        child_config = self._config.copy()
+        child_config.update(kwargs)
+        if not self.is_child:
+            child_config['is_child'] = True
+            child_config['error_handler'] = toy_error_handler
+            child_config['root_allow_unknown'] = self.allow_unknown
+            child_config['root_document'] = self.document
+            child_config['root_schema'] = self.schema
+
+        child_validator = self.__class__(**child_config)
+
+        if document_crumb is None:
+            child_validator.document_path = self.document_path
+        else:
+            if not isinstance(document_crumb, tuple):
+                document_crumb = (document_crumb, )
+            child_validator.document_path = self.document_path + document_crumb
+
+        if schema_crumb is None:
+            child_validator.schema_path = self.schema_path
+        else:
+            if not isinstance(schema_crumb, tuple):
+                schema_crumb = (schema_crumb, )
+            child_validator.schema_path = self.schema_path + schema_crumb
+
+        return child_validator
+
+    def __get_rule_handler(self, domain, rule):
+        methodname = '_{0}_{1}'.format(domain, rule.replace(' ', '_'))
+        result = getattr(self, methodname, None)
+        if result is None:
+            raise RuntimeError("There's no handler for '{}' in the '{}' "
+                               "domain.".format(rule, domain))
+        return result
+
+    def _drop_nodes_from_errorpaths(self, _errors, dp_items, sp_items):
+        """ Removes nodes by index from an errorpath, relatively to the
+            basepaths of self.
+
+        :param errors: A list of :class:`errors.ValidationError` instances.
+        :param dp_items: A list of integers, pointing at the nodes to drop from
+                         the :attr:`document_path`.
+        :param sp_items: Alike ``dp_items``, but for :attr:`schema_path`.
+        """
+        dp_basedepth = len(self.document_path)
+        sp_basedepth = len(self.schema_path)
+        for error in _errors:
+            for i in sorted(dp_items, reverse=True):
+                error.document_path = \
+                    drop_item_from_tuple(error.document_path, dp_basedepth + i)
+            for i in sorted(sp_items, reverse=True):
+                error.schema_path = \
+                    drop_item_from_tuple(error.schema_path, sp_basedepth + i)
+            if error.child_errors:
+                self._drop_nodes_from_errorpaths(error.child_errors,
+                                                 dp_items, sp_items)
+
+    def _lookup_field(self, path):
+        """ Searches for a field as defined by path. This method is used by the
+            ``dependency`` evaluation logic.
+
+        :param path: Path elements are separated by a ``.``. A leading ``^``
+                     indicates that the path relates to the document root,
+                     otherwise it relates to the currently evaluated document,
+                     which is possibly a subdocument.
+                     The sequence ``^^`` at the start will be interpreted as a
+                     literal ``^``.
+        :type path: :class:`str`
+        :returns: Either the found field name and its value or :obj:`None` for
+                  both.
+        :rtype: A two-value :class:`tuple`.
+        """
+        if path.startswith('^'):
+            path = path[1:]
+            context = self.document if path.startswith('^') \
+                else self.root_document
+        else:
+            context = self.document
+
+        parts = path.split('.')
+        for part in parts:
+            if part not in context:
+                return None, None
+            context = context.get(part)
+
+        return parts[-1], context
+
+    def _resolve_rules_set(self, rules_set):
+        if isinstance(rules_set, Mapping):
+            return rules_set
+        elif isinstance(rules_set, _str_type):
+            return self.rules_set_registry.get(rules_set)
+        return None
+
+    def _resolve_schema(self, schema):
+        if isinstance(schema, Mapping):
+            return schema
+        elif isinstance(schema, _str_type):
+            return self.schema_registry.get(schema)
+        return None
+
+    # Properties
+
+    @property
+    def allow_unknown(self):
+        """ If ``True`` unknown fields that are not defined in the schema will
+            be ignored. If a mapping with a validation schema is given, any
+            undefined field will be validated against its rules.
+            Also see :ref:`allowing-the-unknown`.
+            Type: :class:`bool` or any :term:`mapping` """
+        return self._config.get('allow_unknown', False)
+
+    @allow_unknown.setter
+    def allow_unknown(self, value):
+        if not (self.is_child or isinstance(value, (bool, DefinitionSchema))):
+            DefinitionSchema(self, {'allow_unknown': value})
+        self._config['allow_unknown'] = value
+
+    @property
+    def errors(self):
+        """ The errors of the last processing formatted by the handler that is
+            bound to :attr:`~cerberus.Validator.error_handler`. """
+        return self.error_handler(self._errors)
+
+    @property
+    def ignore_none_values(self):
+        """ Whether to not process :obj:`None`-values in a document or not.
+            Type: :class:`bool` """
+        return self._config.get('ignore_none_values', False)
+
+    @ignore_none_values.setter
+    def ignore_none_values(self, value):
+        self._config['ignore_none_values'] = value
+
+    @property
+    def is_child(self):
+        """ ``True`` for child-validators obtained with
+        :meth:`~cerberus.Validator._get_child_validator`.
+        Type: :class:`bool` """
+        return self._config.get('is_child', False)
+
+    @property
+    def _is_normalized(self):
+        """ ``True`` if the document is already normalized. """
+        return self._config.get('_is_normalized', False)
+
+    @_is_normalized.setter
+    def _is_normalized(self, value):
+        self._config['_is_normalized'] = value
+
+    @property
+    def purge_unknown(self):
+        """ If ``True`` unknown fields will be deleted from the document
+            unless a validation is called with disabled normalization.
+            Also see :ref:`purging-unknown-fields`. Type: :class:`bool` """
+        return self._config.get('purge_unknown', False)
+
+    @purge_unknown.setter
+    def purge_unknown(self, value):
+        self._config['purge_unknown'] = value
+
+    @property
+    def root_allow_unknown(self):
+        """ The :attr:`~cerberus.Validator.allow_unknown` attribute of the
+            first level ancestor of a child validator. """
+        return self._config.get('root_allow_unknown', self.allow_unknown)
+
+    @property
+    def root_document(self):
+        """ The :attr:`~cerberus.Validator.document` attribute of the
+            first level ancestor of a child validator. """
+        return self._config.get('root_document', self.document)
+
+    @property
+    def rules_set_registry(self):
+        """ The registry that holds referenced rules sets.
+            Type: :class:`~cerberus.Registry` """
+        return self._config.get('rules_set_registry', rules_set_registry)
+
+    @rules_set_registry.setter
+    def rules_set_registry(self, registry):
+        self._config['rules_set_registry'] = registry
+
+    @property
+    def root_schema(self):
+        """ The :attr:`~cerberus.Validator.schema` attribute of the
+            first level ancestor of a child validator. """
+        return self._config.get('root_schema', self.schema)
+
+    @property
+    def schema(self):
+        """ The validation schema of a validator. When a schema is passed to
+            a method, it replaces this attribute.
+            Type: any :term:`mapping` or :obj:`None` """
+        return self._schema
+
+    @schema.setter
+    def schema(self, schema):
+        if schema is None:
+            self._schema = None
+        elif self.is_child or isinstance(schema, DefinitionSchema):
+            self._schema = schema
+        else:
+            self._schema = DefinitionSchema(self, schema)
+
+    @property
+    def schema_registry(self):
+        """ The registry that holds referenced schemas.
+            Type: :class:`~cerberus.Registry` """
+        return self._config.get('schema_registry', schema_registry)
+
+    @schema_registry.setter
+    def schema_registry(self, registry):
+        self._config['schema_registry'] = registry
+
+    # FIXME the returned method has the correct docstring, but doesn't appear
+    #       in the API docs
+    @readonly_classproperty
+    def types(cls):
+        """ The constraints that can be used for the 'type' rule.
+            Type: A tuple of strings. """
+        redundant_types = \
+            set(cls.types_mapping) & set(cls._types_from_methods)
+        if redundant_types:
+            warn("These types are defined both with a method and in the"
+                 "'types_mapping' property of this validator: %s"
+                 % redundant_types)
+
+        return tuple(cls.types_mapping) + cls._types_from_methods
+
+    # Document processing
+
+    def __init_processing(self, document, schema=None):
+        self._errors = errors.ErrorList()
+        self.recent_error = None
+        self.document_error_tree = errors.DocumentErrorTree()
+        self.schema_error_tree = errors.SchemaErrorTree()
+        self.document = copy(document)
+        if not self.is_child:
+            self._is_normalized = False
+
+        if schema is not None:
+            self.schema = DefinitionSchema(self, schema)
+        elif self.schema is None:
+            if isinstance(self.allow_unknown, Mapping):
+                self._schema = {}
+            else:
+                raise SchemaError(errors.SCHEMA_ERROR_MISSING)
+        if document is None:
+            raise DocumentError(errors.DOCUMENT_MISSING)
+        if not isinstance(document, Mapping):
+            raise DocumentError(
+                errors.DOCUMENT_FORMAT.format(document))
+        self.error_handler.start(self)
+
+    def _drop_remaining_rules(self, *rules):
+        """ Drops rules from the queue of the rules that still need to be
+            evaluated for the currently processed field.
+            If no arguments are given, the whole queue is emptied.
+        """
+        if rules:
+            for rule in rules:
+                try:
+                    self._remaining_rules.remove(rule)
+                except ValueError:
+                    pass
+        else:
+            self._remaining_rules = []
+
+    # # Normalizing
+
+    def normalized(self, document, schema=None, always_return_document=False):
+        """ Returns the document normalized according to the specified rules
+        of a schema.
+
+        :param document: The document to normalize.
+        :type document: any :term:`mapping`
+        :param schema: The validation schema. Defaults to :obj:`None`. If not
+                       provided here, the schema must have been provided at
+                       class instantiation.
+        :type schema: any :term:`mapping`
+        :param always_return_document: Return the document, even if an error
+                                       occurred. Defaults to: ``False``.
+        :type always_return_document: :class:`bool`
+        :return: A normalized copy of the provided mapping or :obj:`None` if an
+                 error occurred during normalization.
+        """
+        self.__init_processing(document, schema)
+        self.__normalize_mapping(self.document, self.schema)
+        self.error_handler.end(self)
+        if self._errors and not always_return_document:
+            return None
+        else:
+            return self.document
+
+    def __normalize_mapping(self, mapping, schema):
+        if isinstance(schema, _str_type):
+            schema = self._resolve_schema(schema)
+        schema = schema.copy()
+        for field in schema:
+            schema[field] = self._resolve_rules_set(schema[field])
+
+        self.__normalize_rename_fields(mapping, schema)
+        if self.purge_unknown and not self.allow_unknown:
+            self._normalize_purge_unknown(mapping, schema)
+        # Check `readonly` fields before applying default values because
+        # a field's schema definition might contain both `readonly` and
+        # `default`.
+        self.__validate_readonly_fields(mapping, schema)
+        self.__normalize_default_fields(mapping, schema)
+        self._normalize_coerce(mapping, schema)
+        self.__normalize_containers(mapping, schema)
+        self._is_normalized = True
+        return mapping
+
+    def _normalize_coerce(self, mapping, schema):
+        """ {'oneof': [
+                {'type': 'callable'},
+                {'type': 'list',
+                 'schema': {'oneof': [{'type': 'callable'},
+                                      {'type': 'string'}]}},
+                {'type': 'string'}
+                ]} """
+
+        error = errors.COERCION_FAILED
+        for field in mapping:
+            if field in schema and 'coerce' in schema[field]:
+                mapping[field] = self.__normalize_coerce(
+                    schema[field]['coerce'], field, mapping[field],
+                    schema[field].get('nullable', False), error)
+            elif isinstance(self.allow_unknown, Mapping) and \
+                    'coerce' in self.allow_unknown:
+                mapping[field] = self.__normalize_coerce(
+                    self.allow_unknown['coerce'], field, mapping[field],
+                    self.allow_unknown.get('nullable', False), error)
+
+    def __normalize_coerce(self, processor, field, value, nullable, error):
+        if isinstance(processor, _str_type):
+            processor = self.__get_rule_handler('normalize_coerce', processor)
+
+        elif isinstance(processor, Iterable):
+            result = value
+            for p in processor:
+                result = self.__normalize_coerce(p, field, result,
+                                                 nullable, error)
+                if errors.COERCION_FAILED in \
+                    self.document_error_tree.fetch_errors_from(
+                        self.document_path + (field,)):
+                    break
+            return result
+
+        try:
+            return processor(value)
+        except Exception as e:
+            if not nullable and e is not TypeError:
+                self._error(field, error, str(e))
+            return value
+
+    def __normalize_containers(self, mapping, schema):
+        for field in mapping:
+            if field not in schema:
+                continue
+            # TODO: This check conflates validation and normalization
+            if isinstance(mapping[field], Mapping):
+                if 'keyschema' in schema[field]:
+                    self.__normalize_mapping_per_keyschema(
+                        field, mapping, schema[field]['keyschema'])
+                if 'valueschema' in schema[field]:
+                    self.__normalize_mapping_per_valueschema(
+                        field, mapping, schema[field]['valueschema'])
+                if set(schema[field]) & set(('allow_unknown', 'purge_unknown',
+                                             'schema')):
+                    try:
+                        self.__normalize_mapping_per_schema(
+                            field, mapping, schema)
+                    except _SchemaRuleTypeError:
+                        pass
+            elif isinstance(mapping[field], _str_type):
+                continue
+            elif isinstance(mapping[field], Sequence) and \
+                    'schema' in schema[field]:
+                self.__normalize_sequence(field, mapping, schema)
+
+    def __normalize_mapping_per_keyschema(self, field, mapping, property_rules):
+        schema = dict(((k, property_rules) for k in mapping[field]))
+        document = dict(((k, k) for k in mapping[field]))
+        validator = self._get_child_validator(
+            document_crumb=field, schema_crumb=(field, 'keyschema'),
+            schema=schema)
+        result = validator.normalized(document, always_return_document=True)
+        if validator._errors:
+            self._drop_nodes_from_errorpaths(validator._errors, [], [2, 4])
+            self._error(validator._errors)
+        for k in result:
+            if k == result[k]:
+                continue
+            if result[k] in mapping[field]:
+                warn("Normalizing keys of {path}: {key} already exists, "
+                     "its value is replaced."
+                     .format(path='.'.join(self.document_path + (field,)),
+                             key=k))
+                mapping[field][result[k]] = mapping[field][k]
+            else:
+                mapping[field][result[k]] = mapping[field][k]
+                del mapping[field][k]
+
+    def __normalize_mapping_per_valueschema(self, field, mapping, value_rules):
+        schema = dict(((k, value_rules) for k in mapping[field]))
+        validator = self._get_child_validator(
+            document_crumb=field, schema_crumb=(field, 'valueschema'),
+            schema=schema)
+        mapping[field] = validator.normalized(mapping[field],
+                                              always_return_document=True)
+        if validator._errors:
+            self._drop_nodes_from_errorpaths(validator._errors, [], [2])
+            self._error(validator._errors)
+
+    def __normalize_mapping_per_schema(self, field, mapping, schema):
+        validator = self._get_child_validator(
+            document_crumb=field, schema_crumb=(field, 'schema'),
+            schema=schema[field].get('schema', {}),
+            allow_unknown=schema[field].get('allow_unknown', self.allow_unknown),  # noqa: E501
+            purge_unknown=schema[field].get('purge_unknown', self.purge_unknown))  # noqa: E501
+        value_type = type(mapping[field])
+        result_value = validator.normalized(mapping[field],
+                                            always_return_document=True)
+        mapping[field] = value_type(result_value)
+        if validator._errors:
+            self._error(validator._errors)
+
+    def __normalize_sequence(self, field, mapping, schema):
+        schema = dict(((k, schema[field]['schema'])
+                       for k in range(len(mapping[field]))))
+        document = dict((k, v) for k, v in enumerate(mapping[field]))
+        validator = self._get_child_validator(
+            document_crumb=field, schema_crumb=(field, 'schema'),
+            schema=schema)
+        value_type = type(mapping[field])
+        result = validator.normalized(document, always_return_document=True)
+        mapping[field] = value_type(result.values())
+        if validator._errors:
+            self._drop_nodes_from_errorpaths(validator._errors, [], [2])
+            self._error(validator._errors)
+
+    @staticmethod
+    def _normalize_purge_unknown(mapping, schema):
+        """ {'type': 'boolean'} """
+        for field in tuple(mapping):
+            if field not in schema:
+                del mapping[field]
+        return mapping
+
+    def __normalize_rename_fields(self, mapping, schema):
+        for field in tuple(mapping):
+            if field in schema:
+                self._normalize_rename(mapping, schema, field)
+                self._normalize_rename_handler(mapping, schema, field)
+            elif isinstance(self.allow_unknown, Mapping) and \
+                    'rename_handler' in self.allow_unknown:
+                self._normalize_rename_handler(
+                    mapping, {field: self.allow_unknown}, field)
+        return mapping
+
+    def _normalize_rename(self, mapping, schema, field):
+        """ {'type': 'hashable'} """
+        if 'rename' in schema[field]:
+            mapping[schema[field]['rename']] = mapping[field]
+            del mapping[field]
+
+    def _normalize_rename_handler(self, mapping, schema, field):
+        """ {'oneof': [
+                {'type': 'callable'},
+                {'type': 'list',
+                 'schema': {'oneof': [{'type': 'callable'},
+                                      {'type': 'string'}]}},
+                {'type': 'string'}
+                ]} """
+        if 'rename_handler' not in schema[field]:
+            return
+        new_name = self.__normalize_coerce(
+            schema[field]['rename_handler'], field, field,
+            False, errors.RENAMING_FAILED)
+        if new_name != field:
+            mapping[new_name] = mapping[field]
+            del mapping[field]
+
+    def __validate_readonly_fields(self, mapping, schema):
+        for field in (x for x in schema if x in mapping and
+                      self._resolve_rules_set(schema[x]).get('readonly')):
+            self._validate_readonly(schema[field]['readonly'], field,
+                                    mapping[field])
+
+    def __normalize_default_fields(self, mapping, schema):
+        fields = [x for x in schema if x not in mapping or
+                  mapping[x] is None and not schema[x].get('nullable', False)]
+        try:
+            fields_with_default = [x for x in fields if 'default' in schema[x]]
+        except TypeError:
+            raise _SchemaRuleTypeError
+        for field in fields_with_default:
+            self._normalize_default(mapping, schema, field)
+
+        known_fields_states = set()
+        fields = [x for x in fields if 'default_setter' in schema[x]]
+        while fields:
+            field = fields.pop(0)
+            try:
+                self._normalize_default_setter(mapping, schema, field)
+            except KeyError:
+                fields.append(field)
+            except Exception as e:
+                self._error(field, errors.SETTING_DEFAULT_FAILED, str(e))
+
+            fields_state = tuple(fields)
+            if fields_state in known_fields_states:
+                for field in fields:
+                    self._error(field, errors.SETTING_DEFAULT_FAILED,
+                                'Circular dependencies of default setters.')
+                break
+            else:
+                known_fields_states.add(fields_state)
+
+    def _normalize_default(self, mapping, schema, field):
+        """ {'nullable': True} """
+        mapping[field] = schema[field]['default']
+
+    def _normalize_default_setter(self, mapping, schema, field):
+        """ {'oneof': [
+                {'type': 'callable'},
+                {'type': 'string'}
+                ]} """
+        if 'default_setter' in schema[field]:
+            setter = schema[field]['default_setter']
+            if isinstance(setter, _str_type):
+                setter = self.__get_rule_handler('normalize_default_setter',
+                                                 setter)
+            mapping[field] = setter(mapping)
+
+    # # Validating
+
+    def validate(self, document, schema=None, update=False, normalize=True):
+        """ Normalizes and validates a mapping against a validation-schema of
+        defined rules.
+
+        :param document: The document to normalize.
+        :type document: any :term:`mapping`
+        :param schema: The validation schema. Defaults to :obj:`None`. If not
+                       provided here, the schema must have been provided at
+                       class instantiation.
+        :type schema: any :term:`mapping`
+        :param update: If ``True``, required fields won't be checked.
+        :type update: :class:`bool`
+        :param normalize: If ``True``, normalize the document before validation.
+        :type normalize: :class:`bool`
+
+        :return: ``True`` if validation succeeds, otherwise ``False``. Check
+                 the :func:`errors` property for a list of processing errors.
+        :rtype: :class:`bool`
+        """
+        self.update = update
+        self._unrequired_by_excludes = set()
+
+        self.__init_processing(document, schema)
+        if normalize:
+            self.__normalize_mapping(self.document, self.schema)
+
+        for field in self.document:
+            if self.ignore_none_values and self.document[field] is None:
+                continue
+            definitions = self.schema.get(field)
+            if definitions is not None:
+                self.__validate_definitions(definitions, field)
+            else:
+                self.__validate_unknown_fields(field)
+
+        if not self.update:
+            self.__validate_required_fields(self.document)
+
+        self.error_handler.end(self)
+
+        return not bool(self._errors)
+
+    __call__ = validate
+
+    def validated(self, *args, **kwargs):
+        """ Wrapper around :meth:`~cerberus.Validator.validate` that returns
+            the normalized and validated document or :obj:`None` if validation
+            failed. """
+        always_return_document = kwargs.pop('always_return_document', False)
+        self.validate(*args, **kwargs)
+        if self._errors and not always_return_document:
+            return None
+        else:
+            return self.document
+
+    def __validate_unknown_fields(self, field):
+        if self.allow_unknown:
+            value = self.document[field]
+            if isinstance(self.allow_unknown, (Mapping, _str_type)):
+                # validate that unknown fields matches the schema
+                # for unknown_fields
+                schema_crumb = 'allow_unknown' if self.is_child \
+                    else '__allow_unknown__'
+                validator = self._get_child_validator(
+                    schema_crumb=schema_crumb,
+                    schema={field: self.allow_unknown})
+                if not validator({field: value}, normalize=False):
+                    self._error(validator._errors)
+        else:
+            self._error(field, errors.UNKNOWN_FIELD)
+
+    def __validate_definitions(self, definitions, field):
+        """ Validate a field's value against its defined rules. """
+
+        def validate_rule(rule):
+            validator = self.__get_rule_handler('validate', rule)
+            return validator(definitions.get(rule, None), field, value)
+
+        definitions = self._resolve_rules_set(definitions)
+        value = self.document[field]
+
+        rules_queue = [x for x in self.priority_validations
+                       if x in definitions or x in self.mandatory_validations]
+        rules_queue.extend(x for x in self.mandatory_validations
+                           if x not in rules_queue)
+        rules_queue.extend(x for x in definitions
+                           if x not in rules_queue and
+                           x not in self.normalization_rules and
+                           x not in ('allow_unknown', 'required'))
+        self._remaining_rules = rules_queue
+
+        while self._remaining_rules:
+            rule = self._remaining_rules.pop(0)
+            try:
+                result = validate_rule(rule)
+                # TODO remove on next breaking release
+                if result:
+                    break
+            except _SchemaRuleTypeError:
+                break
+
+        self._drop_remaining_rules()
+
+    # Remember to keep the validation methods below this line
+    # sorted alphabetically
+
+    _validate_allow_unknown = dummy_for_rule_validation(
+        """ {'oneof': [{'type': 'boolean'},
+                       {'type': ['dict', 'string'],
+                        'validator': 'bulk_schema'}]} """)
+
+    def _validate_allowed(self, allowed_values, field, value):
+        """ {'type': 'list'} """
+        if isinstance(value, Iterable) and not isinstance(value, _str_type):
+            unallowed = set(value) - set(allowed_values)
+            if unallowed:
+                self._error(field, errors.UNALLOWED_VALUES, list(unallowed))
+        else:
+            if value not in allowed_values:
+                self._error(field, errors.UNALLOWED_VALUE, value)
+
+    def _validate_dependencies(self, dependencies, field, value):
+        """ {'type': ('dict', 'hashable', 'list'),
+             'validator': 'dependencies'} """
+        if isinstance(dependencies, _str_type):
+            dependencies = (dependencies,)
+
+        if isinstance(dependencies, Sequence):
+            self.__validate_dependencies_sequence(dependencies, field)
+        elif isinstance(dependencies, Mapping):
+            self.__validate_dependencies_mapping(dependencies, field)
+
+        if self.document_error_tree.fetch_node_from(
+                self.schema_path + (field, 'dependencies')) is not None:
+            return True
+
+    def __validate_dependencies_mapping(self, dependencies, field):
+        validated_dependencies_counter = 0
+        error_info = {}
+        for dependency_name, dependency_values in dependencies.items():
+            if (not isinstance(dependency_values, Sequence) or
+                    isinstance(dependency_values, _str_type)):
+                dependency_values = [dependency_values]
+
+            wanted_field, wanted_field_value = \
+                self._lookup_field(dependency_name)
+            if wanted_field_value in dependency_values:
+                validated_dependencies_counter += 1
+            else:
+                error_info.update({dependency_name: wanted_field_value})
+
+        if validated_dependencies_counter != len(dependencies):
+            self._error(field, errors.DEPENDENCIES_FIELD_VALUE, error_info)
+
+    def __validate_dependencies_sequence(self, dependencies, field):
+        for dependency in dependencies:
+            if self._lookup_field(dependency)[0] is None:
+                self._error(field, errors.DEPENDENCIES_FIELD, dependency)
+
+    def _validate_empty(self, empty, field, value):
+        """ {'type': 'boolean'} """
+        if isinstance(value, Iterable) and len(value) == 0:
+            self._drop_remaining_rules(
+                'allowed', 'forbidden', 'items', 'minlength', 'maxlength',
+                'regex', 'validator')
+            if not empty:
+                self._error(field, errors.EMPTY_NOT_ALLOWED)
+
+    def _validate_excludes(self, excludes, field, value):
+        """ {'type': ('hashable', 'list'),
+             'schema': {'type': 'hashable'}} """
+        if isinstance(excludes, Hashable):
+            excludes = [excludes]
+
+        # Save required field to be checked latter
+        if 'required' in self.schema[field] and self.schema[field]['required']:
+            self._unrequired_by_excludes.add(field)
+        for exclude in excludes:
+            if (exclude in self.schema and
+                'required' in self.schema[exclude] and
+                    self.schema[exclude]['required']):
+
+                self._unrequired_by_excludes.add(exclude)
+
+        if [True for key in excludes if key in self.document]:
+            # Wrap each field in `excludes` list between quotes
+            exclusion_str = ', '.join("'{0}'"
+                                      .format(word) for word in excludes)
+            self._error(field, errors.EXCLUDES_FIELD, exclusion_str)
+
+    def _validate_forbidden(self, forbidden_values, field, value):
+        """ {'type': 'list'} """
+        if isinstance(value, _str_type):
+            if value in forbidden_values:
+                self._error(field, errors.FORBIDDEN_VALUE, value)
+        elif isinstance(value, Sequence):
+            forbidden = set(value) & set(forbidden_values)
+            if forbidden:
+                self._error(field, errors.FORBIDDEN_VALUES, list(forbidden))
+        elif isinstance(value, int):
+            if value in forbidden_values:
+                self._error(field, errors.FORBIDDEN_VALUE, value)
+
+    def _validate_items(self, items, field, values):
+        """ {'type': 'list', 'validator': 'items'} """
+        if len(items) != len(values):
+            self._error(field, errors.ITEMS_LENGTH, len(items), len(values))
+        else:
+            schema = dict((i, definition) for i, definition in enumerate(items))  # noqa: E501
+            validator = self._get_child_validator(document_crumb=field,
+                                                  schema_crumb=(field, 'items'),  # noqa: E501
+                                                  schema=schema)
+            if not validator(dict((i, value) for i, value in enumerate(values)),
+                             update=self.update, normalize=False):
+                self._error(field, errors.BAD_ITEMS, validator._errors)
+
+    def __validate_logical(self, operator, definitions, field, value):
+        """ Validates value against all definitions and logs errors according
+            to the operator. """
+        valid_counter = 0
+        _errors = errors.ErrorList()
+
+        for i, definition in enumerate(definitions):
+            schema = {field: definition.copy()}
+            for rule in ('allow_unknown', 'type'):
+                if rule not in schema[field] and rule in self.schema[field]:
+                    schema[field][rule] = self.schema[field][rule]
+            if 'allow_unknown' not in schema[field]:
+                schema[field]['allow_unknown'] = self.allow_unknown
+
+            validator = self._get_child_validator(
+                schema_crumb=(field, operator, i),
+                schema=schema, allow_unknown=True)
+            if validator(self.document, update=self.update, normalize=False):
+                valid_counter += 1
+            else:
+                self._drop_nodes_from_errorpaths(validator._errors, [], [3])
+                _errors.extend(validator._errors)
+
+        return valid_counter, _errors
+
+    def _validate_anyof(self, definitions, field, value):
+        """ {'type': 'list', 'logical': 'anyof'} """
+        valids, _errors = \
+            self.__validate_logical('anyof', definitions, field, value)
+        if valids < 1:
+            self._error(field, errors.ANYOF, _errors,
+                        valids, len(definitions))
+
+    def _validate_allof(self, definitions, field, value):
+        """ {'type': 'list', 'logical': 'allof'} """
+        valids, _errors = \
+            self.__validate_logical('allof', definitions, field, value)
+        if valids < len(definitions):
+            self._error(field, errors.ALLOF, _errors,
+                        valids, len(definitions))
+
+    def _validate_noneof(self, definitions, field, value):
+        """ {'type': 'list', 'logical': 'noneof'} """
+        valids, _errors = \
+            self.__validate_logical('noneof', definitions, field, value)
+        if valids > 0:
+            self._error(field, errors.NONEOF, _errors,
+                        valids, len(definitions))
+
+    def _validate_oneof(self, definitions, field, value):
+        """ {'type': 'list', 'logical': 'oneof'} """
+        valids, _errors = \
+            self.__validate_logical('oneof', definitions, field, value)
+        if valids != 1:
+            self._error(field, errors.ONEOF, _errors,
+                        valids, len(definitions))
+
+    def _validate_max(self, max_value, field, value):
+        """ {'nullable': False } """
+        try:
+            if value > max_value:
+                self._error(field, errors.MAX_VALUE)
+        except TypeError:
+            pass
+
+    def _validate_min(self, min_value, field, value):
+        """ {'nullable': False } """
+        try:
+            if value < min_value:
+                self._error(field, errors.MIN_VALUE)
+        except TypeError:
+            pass
+
+    def _validate_maxlength(self, max_length, field, value):
+        """ {'type': 'integer'} """
+        if isinstance(value, Iterable) and len(value) > max_length:
+            self._error(field, errors.MAX_LENGTH, len(value))
+
+    def _validate_minlength(self, min_length, field, value):
+        """ {'type': 'integer'} """
+        if isinstance(value, Iterable) and len(value) < min_length:
+            self._error(field, errors.MIN_LENGTH, len(value))
+
+    def _validate_nullable(self, nullable, field, value):
+        """ {'type': 'boolean'} """
+        if value is None:
+            if not nullable:
+                self._error(field, errors.NOT_NULLABLE)
+            self._drop_remaining_rules(
+                'empty', 'forbidden', 'items', 'keyschema', 'min', 'max',
+                'minlength', 'maxlength', 'regex', 'schema', 'type',
+                'valueschema')
+
+    def _validate_keyschema(self, schema, field, value):
+        """ {'type': ['dict', 'string'], 'validator': 'bulk_schema',
+            'forbidden': ['rename', 'rename_handler']} """
+        if isinstance(value, Mapping):
+            validator = self._get_child_validator(
+                document_crumb=field,
+                schema_crumb=(field, 'keyschema'),
+                schema=dict(((k, schema) for k in value.keys())))
+            if not validator(dict(((k, k) for k in value.keys())),
+                             normalize=False):
+                self._drop_nodes_from_errorpaths(validator._errors,
+                                                 [], [2, 4])
+                self._error(field, errors.KEYSCHEMA, validator._errors)
+
+    def _validate_readonly(self, readonly, field, value):
+        """ {'type': 'boolean'} """
+        if readonly:
+            if not self._is_normalized:
+                self._error(field, errors.READONLY_FIELD)
+            # If the document was normalized (and therefore already been
+            # checked for readonly fields), we still have to return True
+            # if an error was filed.
+            has_error = errors.READONLY_FIELD in \
+                self.document_error_tree.fetch_errors_from(
+                    self.document_path + (field,))
+            if self._is_normalized and has_error:
+                self._drop_remaining_rules()
+
+    def _validate_regex(self, pattern, field, value):
+        """ {'type': 'string'} """
+        if not isinstance(value, _str_type):
+            return
+        if not pattern.endswith('$'):
+            pattern += '$'
+        re_obj = re.compile(pattern)
+        if not re_obj.match(value):
+            self._error(field, errors.REGEX_MISMATCH)
+
+    _validate_required = dummy_for_rule_validation(""" {'type': 'boolean'} """)
+
+    def __validate_required_fields(self, document):
+        """ Validates that required fields are not missing.
+
+        :param document: The document being validated.
+        """
+        try:
+            required = set(field for field, definition in self.schema.items()
+                           if self._resolve_rules_set(definition).
+                           get('required') is True)
+        except AttributeError:
+            if self.is_child and self.schema_path[-1] == 'schema':
+                raise _SchemaRuleTypeError
+            else:
+                raise
+        required -= self._unrequired_by_excludes
+        missing = required - set(field for field in document
+                                 if document.get(field) is not None or
+                                 not self.ignore_none_values)
+
+        for field in missing:
+            self._error(field, errors.REQUIRED_FIELD)
+
+        # At least on field from self._unrequired_by_excludes should be
+        # present in document
+        if self._unrequired_by_excludes:
+            fields = set(field for field in document
+                         if document.get(field) is not None)
+            if self._unrequired_by_excludes.isdisjoint(fields):
+                for field in self._unrequired_by_excludes - fields:
+                    self._error(field, errors.REQUIRED_FIELD)
+
+    def _validate_schema(self, schema, field, value):
+        """ {'type': ['dict', 'string'],
+             'anyof': [{'validator': 'schema'},
+                       {'validator': 'bulk_schema'}]} """
+        if schema is None:
+            return
+
+        if isinstance(value, Sequence) and not isinstance(value, _str_type):
+            self.__validate_schema_sequence(field, schema, value)
+        elif isinstance(value, Mapping):
+            self.__validate_schema_mapping(field, schema, value)
+
+    def __validate_schema_mapping(self, field, schema, value):
+        schema = self._resolve_schema(schema)
+        allow_unknown = self.schema[field].get('allow_unknown',
+                                               self.allow_unknown)
+        validator = self._get_child_validator(document_crumb=field,
+                                              schema_crumb=(field, 'schema'),
+                                              schema=schema,
+                                              allow_unknown=allow_unknown)
+        try:
+            if not validator(value, update=self.update, normalize=False):
+                self._error(field, errors.MAPPING_SCHEMA, validator._errors)
+        except _SchemaRuleTypeError:
+            self._error(field, errors.BAD_TYPE_FOR_SCHEMA)
+            raise
+
+    def __validate_schema_sequence(self, field, schema, value):
+        schema = dict(((i, schema) for i in range(len(value))))
+        validator = self._get_child_validator(
+            document_crumb=field, schema_crumb=(field, 'schema'),
+            schema=schema, allow_unknown=self.allow_unknown)
+        validator(dict(((i, v) for i, v in enumerate(value))),
+                  update=self.update, normalize=False)
+
+        if validator._errors:
+            self._drop_nodes_from_errorpaths(validator._errors, [], [2])
+            self._error(field, errors.SEQUENCE_SCHEMA, validator._errors)
+
+    def _validate_type(self, data_type, field, value):
+        """ {'type': ['string', 'list'],
+             'validator': 'type'} """
+        if not data_type:
+            return
+
+        types = (data_type,) if isinstance(data_type, _str_type) else data_type
+
+        for _type in types:
+            # TODO remove this block on next major release
+            # this implementation still supports custom type validation methods
+            type_definition = self.types_mapping.get(_type)
+            if type_definition is not None:
+                matched = isinstance(value, type_definition.included_types) \
+                    and not isinstance(value, type_definition.excluded_types)
+            else:
+                type_handler = self.__get_rule_handler('validate_type', _type)
+                matched = type_handler(value)
+            if matched:
+                return
+
+            # TODO uncomment this block on next major release
+            #      when _validate_type_* methods were deprecated:
+            # type_definition = self.types_mapping[_type]
+            # if isinstance(value, type_definition.included_types) \
+            #         and not isinstance(value, type_definition.excluded_types):  # noqa 501
+            #     return
+
+        self._error(field, errors.BAD_TYPE)
+        self._drop_remaining_rules()
+
+    def _validate_validator(self, validator, field, value):
+        """ {'oneof': [
+                {'type': 'callable'},
+                {'type': 'list',
+                 'schema': {'oneof': [{'type': 'callable'},
+                                      {'type': 'string'}]}},
+                {'type': 'string'}
+                ]} """
+        if isinstance(validator, _str_type):
+            validator = self.__get_rule_handler('validator', validator)
+            validator(field, value)
+        elif isinstance(validator, Iterable):
+            for v in validator:
+                self._validate_validator(v, field, value)
+        else:
+            validator(field, value, self._error)
+
+    def _validate_valueschema(self, schema, field, value):
+        """ {'type': ['dict', 'string'], 'validator': 'bulk_schema',
+            'forbidden': ['rename', 'rename_handler']} """
+        schema_crumb = (field, 'valueschema')
+        if isinstance(value, Mapping):
+            validator = self._get_child_validator(
+                document_crumb=field, schema_crumb=schema_crumb,
+                schema=dict((k, schema) for k in value))
+            validator(value, update=self.update, normalize=False)
+            if validator._errors:
+                self._drop_nodes_from_errorpaths(validator._errors, [], [2])
+                self._error(field, errors.VALUESCHEMA, validator._errors)
+
+
+RULE_SCHEMA_SEPARATOR = \
+    "The rule's arguments are validated against this schema:"
+
+
+class InspectedValidator(type):
+    """ Metaclass for all validators """
+    def __new__(cls, *args):
+        if '__doc__' not in args[2]:
+            args[2].update({'__doc__': args[1][0].__doc__})
+        return super(InspectedValidator, cls).__new__(cls, *args)
+
+    def __init__(cls, *args):
+        def attributes_with_prefix(prefix):
+            return tuple(x.split('_', 2)[-1] for x in dir(cls)
+                         if x.startswith('_' + prefix))
+
+        super(InspectedValidator, cls).__init__(*args)
+
+        cls._types_from_methods, cls.validation_rules = (), {}
+        for attribute in attributes_with_prefix('validate'):
+            # TODO remove inspection of type test methods in next major release
+            if attribute.startswith('type_'):
+                cls._types_from_methods += (attribute[len('type_'):],)
+            else:
+                cls.validation_rules[attribute] = \
+                    cls.__get_rule_schema('_validate_' + attribute)
+
+        # TODO remove on next major release
+        if cls._types_from_methods:
+            warn("Methods for type testing are deprecated, use TypeDefinition "
+                 "and the 'types_mapping'-property of a Validator-instance "
+                 "instead.", DeprecationWarning)
+
+        cls.validators = tuple(x for x in attributes_with_prefix('validator'))
+        x = cls.validation_rules['validator']['oneof']
+        x[1]['schema']['oneof'][1]['allowed'] = x[2]['allowed'] = cls.validators
+
+        for rule in (x for x in cls.mandatory_validations if x != 'nullable'):
+            cls.validation_rules[rule]['required'] = True
+
+        cls.coercers, cls.default_setters, cls.normalization_rules = (), (), {}
+        for attribute in attributes_with_prefix('normalize'):
+            if attribute.startswith('coerce_'):
+                cls.coercers += (attribute[len('coerce_'):],)
+            elif attribute.startswith('default_setter_'):
+                cls.default_setters += (attribute[len('default_setter_'):],)
+            else:
+                cls.normalization_rules[attribute] = \
+                    cls.__get_rule_schema('_normalize_' + attribute)
+
+        for rule in ('coerce', 'rename_handler'):
+            x = cls.normalization_rules[rule]['oneof']
+            x[1]['schema']['oneof'][1]['allowed'] = \
+                x[2]['allowed'] = cls.coercers
+        cls.normalization_rules['default_setter']['oneof'][1]['allowed'] = \
+            cls.default_setters
+
+        cls.rules = {}
+        cls.rules.update(cls.validation_rules)
+        cls.rules.update(cls.normalization_rules)
+
+    def __get_rule_schema(cls, method_name):
+        docstring = getattr(cls, method_name).__doc__
+        if docstring is None:
+            result = {}
+        else:
+            if RULE_SCHEMA_SEPARATOR in docstring:
+                docstring = docstring.split(RULE_SCHEMA_SEPARATOR)[1]
+            try:
+                result = literal_eval(docstring.strip())
+            except Exception:
+                result = {}
+
+        if not result:
+            warn("No validation schema is defined for the arguments of rule "
+                 "'%s'" % method_name.split('_', 2)[-1])
+
+        return result
+
+
+Validator = InspectedValidator('Validator', (BareValidator,), {})
diff --git a/pipenv/vendor/certifi/__init__.py b/pipenv/vendor/certifi/__init__.py
index aa329fbb..50f2e130 100644
--- a/pipenv/vendor/certifi/__init__.py
+++ b/pipenv/vendor/certifi/__init__.py
@@ -1,3 +1,3 @@
 from .core import where, old_where
 
-__version__ = "2018.08.24"
+__version__ = "2018.10.15"
diff --git a/pipenv/vendor/certifi/cacert.pem b/pipenv/vendor/certifi/cacert.pem
index 85de024e..e75d85b3 100644
--- a/pipenv/vendor/certifi/cacert.pem
+++ b/pipenv/vendor/certifi/cacert.pem
@@ -326,36 +326,6 @@ OCiNUW7dFGdTbHFcJoRNdVq2fmBWqU2t+5sel/MN2dKXVHfaPRK34B7vCAas+YWH
 QMAJKOSLakhT2+zNVVXxxvjpoixMptEmX36vWkzaH6byHCx+rgIW0lbQL1dTR+iS
 -----END CERTIFICATE-----
 
-# Issuer: CN=Visa eCommerce Root O=VISA OU=Visa International Service Association
-# Subject: CN=Visa eCommerce Root O=VISA OU=Visa International Service Association
-# Label: "Visa eCommerce Root"
-# Serial: 25952180776285836048024890241505565794
-# MD5 Fingerprint: fc:11:b8:d8:08:93:30:00:6d:23:f9:7e:eb:52:1e:02
-# SHA1 Fingerprint: 70:17:9b:86:8c:00:a4:fa:60:91:52:22:3f:9f:3e:32:bd:e0:05:62
-# SHA256 Fingerprint: 69:fa:c9:bd:55:fb:0a:c7:8d:53:bb:ee:5c:f1:d5:97:98:9f:d0:aa:ab:20:a2:51:51:bd:f1:73:3e:e7:d1:22
------BEGIN CERTIFICATE-----
-MIIDojCCAoqgAwIBAgIQE4Y1TR0/BvLB+WUF1ZAcYjANBgkqhkiG9w0BAQUFADBr
-MQswCQYDVQQGEwJVUzENMAsGA1UEChMEVklTQTEvMC0GA1UECxMmVmlzYSBJbnRl
-cm5hdGlvbmFsIFNlcnZpY2UgQXNzb2NpYXRpb24xHDAaBgNVBAMTE1Zpc2EgZUNv
-bW1lcmNlIFJvb3QwHhcNMDIwNjI2MDIxODM2WhcNMjIwNjI0MDAxNjEyWjBrMQsw
-CQYDVQQGEwJVUzENMAsGA1UEChMEVklTQTEvMC0GA1UECxMmVmlzYSBJbnRlcm5h
-dGlvbmFsIFNlcnZpY2UgQXNzb2NpYXRpb24xHDAaBgNVBAMTE1Zpc2EgZUNvbW1l
-cmNlIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvV95WHm6h
-2mCxlCfLF9sHP4CFT8icttD0b0/Pmdjh28JIXDqsOTPHH2qLJj0rNfVIsZHBAk4E
-lpF7sDPwsRROEW+1QK8bRaVK7362rPKgH1g/EkZgPI2h4H3PVz4zHvtH8aoVlwdV
-ZqW1LS7YgFmypw23RuwhY/81q6UCzyr0TP579ZRdhE2o8mCP2w4lPJ9zcc+U30rq
-299yOIzzlr3xF7zSujtFWsan9sYXiwGd/BmoKoMWuDpI/k4+oKsGGelT84ATB+0t
-vz8KPFUgOSwsAGl0lUq8ILKpeeUYiZGo3BxN77t+Nwtd/jmliFKMAGzsGHxBvfaL
-dXe6YJ2E5/4tAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD
-AgEGMB0GA1UdDgQWBBQVOIMPPyw/cDMezUb+B4wg4NfDtzANBgkqhkiG9w0BAQUF
-AAOCAQEAX/FBfXxcCLkr4NWSR/pnXKUTwwMhmytMiUbPWU3J/qVAtmPN3XEolWcR
-zCSs00Rsca4BIGsDoo8Ytyk6feUWYFN4PMCvFYP3j1IzJL1kk5fui/fbGKhtcbP3
-LBfQdCVp9/5rPJS+TUtBjE7ic9DjkCJzQ83z7+pzzkWKsKZJ/0x9nXGIxHYdkFsd
-7v3M9+79YKWxehZx0RbQfBI8bGmX265fOZpwLwU8GUYEmSA20GBuYQa7FkKMcPcw
-++DbZqMAAb3mLNqRX6BGi01qnD093QVG/na/oAo85ADmJ7f/hC3euiInlhBx6yLt
-398znM/jra6O1I7mT1GvFpLgXPYHDw==
------END CERTIFICATE-----
-
 # Issuer: CN=AAA Certificate Services O=Comodo CA Limited
 # Subject: CN=AAA Certificate Services O=Comodo CA Limited
 # Label: "Comodo AAA Services root"
diff --git a/pipenv/vendor/click/LICENSE b/pipenv/vendor/click/LICENSE
deleted file mode 100644
index 1704daa2..00000000
--- a/pipenv/vendor/click/LICENSE
+++ /dev/null
@@ -1,38 +0,0 @@
-Copyright (c) 2014 by Armin Ronacher.
-
-Click uses parts of optparse written by Gregory P. Ward and maintained by the
-Python software foundation.  This is limited to code in the parser.py
-module:
-
-Copyright (c) 2001-2006 Gregory P. Ward.  All rights reserved.
-Copyright (c) 2002-2006 Python Software Foundation.  All rights reserved.
-
-Some rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
-
-    * The names of the contributors may not be used to endorse or
-      promote products derived from this software without specific
-      prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/pipenv/vendor/click/LICENSE.rst b/pipenv/vendor/click/LICENSE.rst
new file mode 100644
index 00000000..87ce152a
--- /dev/null
+++ b/pipenv/vendor/click/LICENSE.rst
@@ -0,0 +1,39 @@
+Copyright © 2014 by the Pallets team.
+
+Some rights reserved.
+
+Redistribution and use in source and binary forms of the software as
+well as documentation, with or without modification, are permitted
+provided that the following conditions are met:
+
+-   Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+-   Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+-   Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+
+----
+
+Click uses parts of optparse written by Gregory P. Ward and maintained
+by the Python Software Foundation. This is limited to code in parser.py.
+
+Copyright © 2001-2006 Gregory P. Ward. All rights reserved.
+Copyright © 2002-2006 Python Software Foundation. All rights reserved.
diff --git a/pipenv/vendor/click/__init__.py b/pipenv/vendor/click/__init__.py
index 971e55d0..d3c33660 100644
--- a/pipenv/vendor/click/__init__.py
+++ b/pipenv/vendor/click/__init__.py
@@ -1,17 +1,15 @@
 # -*- coding: utf-8 -*-
 """
-    click
-    ~~~~~
+click
+~~~~~
 
-    Click is a simple Python module that wraps the stdlib's optparse to make
-    writing command line scripts fun.  Unlike other modules, it's based around
-    a simple API that does not come with too much magic and is composable.
+Click is a simple Python module inspired by the stdlib optparse to make
+writing command line scripts fun. Unlike other modules, it's based
+around a simple API that does not come with too much magic and is
+composable.
 
-    In case optparse ever gets removed from the stdlib, it will be shipped by
-    this module.
-
-    :copyright: (c) 2014 by Armin Ronacher.
-    :license: BSD, see LICENSE for more details.
+:copyright: © 2014 by the Pallets team.
+:license: BSD, see LICENSE.rst for more details.
 """
 
 # Core classes
@@ -28,7 +26,7 @@ from .decorators import pass_context, pass_obj, make_pass_decorator, \
 
 # Types
 from .types import ParamType, File, Path, Choice, IntRange, Tuple, \
-     STRING, INT, FLOAT, BOOL, UUID, UNPROCESSED
+     DateTime, STRING, INT, FLOAT, BOOL, UUID, UNPROCESSED, FloatRange
 
 # Utilities
 from .utils import echo, get_binary_stream, get_text_stream, open_file, \
@@ -65,8 +63,9 @@ __all__ = [
     'version_option', 'help_option',
 
     # Types
-    'ParamType', 'File', 'Path', 'Choice', 'IntRange', 'Tuple', 'STRING',
-    'INT', 'FLOAT', 'BOOL', 'UUID', 'UNPROCESSED',
+    'ParamType', 'File', 'Path', 'Choice', 'IntRange', 'Tuple',
+    'DateTime', 'STRING', 'INT', 'FLOAT', 'BOOL', 'UUID', 'UNPROCESSED',
+    'FloatRange',
 
     # Utilities
     'echo', 'get_binary_stream', 'get_text_stream', 'open_file',
@@ -95,4 +94,4 @@ __all__ = [
 disable_unicode_literals_warning = False
 
 
-__version__ = '6.7'
+__version__ = '7.0'
diff --git a/pipenv/vendor/click/_bashcomplete.py b/pipenv/vendor/click/_bashcomplete.py
index d9d26d28..a5f1084c 100644
--- a/pipenv/vendor/click/_bashcomplete.py
+++ b/pipenv/vendor/click/_bashcomplete.py
@@ -1,27 +1,81 @@
+import copy
 import os
 import re
+
 from .utils import echo
 from .parser import split_arg_string
-from .core import MultiCommand, Option
+from .core import MultiCommand, Option, Argument
+from .types import Choice
 
+try:
+    from collections import abc
+except ImportError:
+    import collections as abc
 
-COMPLETION_SCRIPT = '''
+WORDBREAK = '='
+
+# Note, only BASH version 4.4 and later have the nosort option.
+COMPLETION_SCRIPT_BASH = '''
 %(complete_func)s() {
+    local IFS=$'\n'
     COMPREPLY=( $( env COMP_WORDS="${COMP_WORDS[*]}" \\
                    COMP_CWORD=$COMP_CWORD \\
                    %(autocomplete_var)s=complete $1 ) )
     return 0
 }
 
-complete -F %(complete_func)s -o default %(script_names)s
+%(complete_func)setup() {
+    local COMPLETION_OPTIONS=""
+    local BASH_VERSION_ARR=(${BASH_VERSION//./ })
+    # Only BASH version 4.4 and later have the nosort option.
+    if [ ${BASH_VERSION_ARR[0]} -gt 4 ] || ([ ${BASH_VERSION_ARR[0]} -eq 4 ] && [ ${BASH_VERSION_ARR[1]} -ge 4 ]); then
+        COMPLETION_OPTIONS="-o nosort"
+    fi
+
+    complete $COMPLETION_OPTIONS -F %(complete_func)s %(script_names)s
+}
+
+%(complete_func)setup
+'''
+
+COMPLETION_SCRIPT_ZSH = '''
+%(complete_func)s() {
+    local -a completions
+    local -a completions_with_descriptions
+    local -a response
+    response=("${(@f)$( env COMP_WORDS=\"${words[*]}\" \\
+                        COMP_CWORD=$((CURRENT-1)) \\
+                        %(autocomplete_var)s=\"complete_zsh\" \\
+                        %(script_names)s )}")
+
+    for key descr in ${(kv)response}; do
+      if [[ "$descr" == "_" ]]; then
+          completions+=("$key")
+      else
+          completions_with_descriptions+=("$key":"$descr")
+      fi
+    done
+
+    if [ -n "$completions_with_descriptions" ]; then
+        _describe -V unsorted completions_with_descriptions -U -Q
+    fi
+
+    if [ -n "$completions" ]; then
+        compadd -U -V unsorted -Q -a completions
+    fi
+    compstate[insert]="automenu"
+}
+
+compdef %(complete_func)s %(script_names)s
 '''
 
 _invalid_ident_char_re = re.compile(r'[^a-zA-Z0-9_]')
 
 
-def get_completion_script(prog_name, complete_var):
+def get_completion_script(prog_name, complete_var, shell):
     cf_name = _invalid_ident_char_re.sub('', prog_name.replace('-', '_'))
-    return (COMPLETION_SCRIPT % {
+    script = COMPLETION_SCRIPT_ZSH if shell == 'zsh' else COMPLETION_SCRIPT_BASH
+    return (script % {
         'complete_func': '_%s_completion' % cf_name,
         'script_names': prog_name,
         'autocomplete_var': complete_var,
@@ -29,37 +83,189 @@ def get_completion_script(prog_name, complete_var):
 
 
 def resolve_ctx(cli, prog_name, args):
+    """
+    Parse into a hierarchy of contexts. Contexts are connected through the parent variable.
+    :param cli: command definition
+    :param prog_name: the program that is running
+    :param args: full list of args
+    :return: the final context/command parsed
+    """
     ctx = cli.make_context(prog_name, args, resilient_parsing=True)
-    while ctx.protected_args + ctx.args and isinstance(ctx.command, MultiCommand):
-        a = ctx.protected_args + ctx.args
-        cmd = ctx.command.get_command(ctx, a[0])
-        if cmd is None:
-            return None
-        ctx = cmd.make_context(a[0], a[1:], parent=ctx, resilient_parsing=True)
+    args = ctx.protected_args + ctx.args
+    while args:
+        if isinstance(ctx.command, MultiCommand):
+            if not ctx.command.chain:
+                cmd_name, cmd, args = ctx.command.resolve_command(ctx, args)
+                if cmd is None:
+                    return ctx
+                ctx = cmd.make_context(cmd_name, args, parent=ctx,
+                                       resilient_parsing=True)
+                args = ctx.protected_args + ctx.args
+            else:
+                # Walk chained subcommand contexts saving the last one.
+                while args:
+                    cmd_name, cmd, args = ctx.command.resolve_command(ctx, args)
+                    if cmd is None:
+                        return ctx
+                    sub_ctx = cmd.make_context(cmd_name, args, parent=ctx,
+                                               allow_extra_args=True,
+                                               allow_interspersed_args=False,
+                                               resilient_parsing=True)
+                    args = sub_ctx.args
+                ctx = sub_ctx
+                args = sub_ctx.protected_args + sub_ctx.args
+        else:
+            break
     return ctx
 
 
+def start_of_option(param_str):
+    """
+    :param param_str: param_str to check
+    :return: whether or not this is the start of an option declaration (i.e. starts "-" or "--")
+    """
+    return param_str and param_str[:1] == '-'
+
+
+def is_incomplete_option(all_args, cmd_param):
+    """
+    :param all_args: the full original list of args supplied
+    :param cmd_param: the current command paramter
+    :return: whether or not the last option declaration (i.e. starts "-" or "--") is incomplete and
+    corresponds to this cmd_param. In other words whether this cmd_param option can still accept
+    values
+    """
+    if not isinstance(cmd_param, Option):
+        return False
+    if cmd_param.is_flag:
+        return False
+    last_option = None
+    for index, arg_str in enumerate(reversed([arg for arg in all_args if arg != WORDBREAK])):
+        if index + 1 > cmd_param.nargs:
+            break
+        if start_of_option(arg_str):
+            last_option = arg_str
+
+    return True if last_option and last_option in cmd_param.opts else False
+
+
+def is_incomplete_argument(current_params, cmd_param):
+    """
+    :param current_params: the current params and values for this argument as already entered
+    :param cmd_param: the current command parameter
+    :return: whether or not the last argument is incomplete and corresponds to this cmd_param. In
+    other words whether or not the this cmd_param argument can still accept values
+    """
+    if not isinstance(cmd_param, Argument):
+        return False
+    current_param_values = current_params[cmd_param.name]
+    if current_param_values is None:
+        return True
+    if cmd_param.nargs == -1:
+        return True
+    if isinstance(current_param_values, abc.Iterable) \
+            and cmd_param.nargs > 1 and len(current_param_values) < cmd_param.nargs:
+        return True
+    return False
+
+
+def get_user_autocompletions(ctx, args, incomplete, cmd_param):
+    """
+    :param ctx: context associated with the parsed command
+    :param args: full list of args
+    :param incomplete: the incomplete text to autocomplete
+    :param cmd_param: command definition
+    :return: all the possible user-specified completions for the param
+    """
+    results = []
+    if isinstance(cmd_param.type, Choice):
+        # Choices don't support descriptions.
+        results = [(c, None)
+                   for c in cmd_param.type.choices if str(c).startswith(incomplete)]
+    elif cmd_param.autocompletion is not None:
+        dynamic_completions = cmd_param.autocompletion(ctx=ctx,
+                                                       args=args,
+                                                       incomplete=incomplete)
+        results = [c if isinstance(c, tuple) else (c, None)
+                   for c in dynamic_completions]
+    return results
+
+
+def get_visible_commands_starting_with(ctx, starts_with):
+    """
+    :param ctx: context associated with the parsed command
+    :starts_with: string that visible commands must start with.
+    :return: all visible (not hidden) commands that start with starts_with.
+    """
+    for c in ctx.command.list_commands(ctx):
+        if c.startswith(starts_with):
+            command = ctx.command.get_command(ctx, c)
+            if not command.hidden:
+                yield command
+
+
+def add_subcommand_completions(ctx, incomplete, completions_out):
+    # Add subcommand completions.
+    if isinstance(ctx.command, MultiCommand):
+        completions_out.extend(
+            [(c.name, c.get_short_help_str()) for c in get_visible_commands_starting_with(ctx, incomplete)])
+
+    # Walk up the context list and add any other completion possibilities from chained commands
+    while ctx.parent is not None:
+        ctx = ctx.parent
+        if isinstance(ctx.command, MultiCommand) and ctx.command.chain:
+            remaining_commands = [c for c in get_visible_commands_starting_with(ctx, incomplete)
+                                  if c.name not in ctx.protected_args]
+            completions_out.extend([(c.name, c.get_short_help_str()) for c in remaining_commands])
+
+
 def get_choices(cli, prog_name, args, incomplete):
+    """
+    :param cli: command definition
+    :param prog_name: the program that is running
+    :param args: full list of args
+    :param incomplete: the incomplete text to autocomplete
+    :return: all the possible completions for the incomplete
+    """
+    all_args = copy.deepcopy(args)
+
     ctx = resolve_ctx(cli, prog_name, args)
     if ctx is None:
-        return
+        return []
 
-    choices = []
-    if incomplete and not incomplete[:1].isalnum():
+    # In newer versions of bash long opts with '='s are partitioned, but it's easier to parse
+    # without the '='
+    if start_of_option(incomplete) and WORDBREAK in incomplete:
+        partition_incomplete = incomplete.partition(WORDBREAK)
+        all_args.append(partition_incomplete[0])
+        incomplete = partition_incomplete[2]
+    elif incomplete == WORDBREAK:
+        incomplete = ''
+
+    completions = []
+    if start_of_option(incomplete):
+        # completions for partial options
         for param in ctx.command.params:
-            if not isinstance(param, Option):
-                continue
-            choices.extend(param.opts)
-            choices.extend(param.secondary_opts)
-    elif isinstance(ctx.command, MultiCommand):
-        choices.extend(ctx.command.list_commands(ctx))
+            if isinstance(param, Option) and not param.hidden:
+                param_opts = [param_opt for param_opt in param.opts +
+                              param.secondary_opts if param_opt not in all_args or param.multiple]
+                completions.extend([(o, param.help) for o in param_opts if o.startswith(incomplete)])
+        return completions
+    # completion for option values from user supplied values
+    for param in ctx.command.params:
+        if is_incomplete_option(all_args, param):
+            return get_user_autocompletions(ctx, all_args, incomplete, param)
+    # completion for argument values from user supplied values
+    for param in ctx.command.params:
+        if is_incomplete_argument(ctx.params, param):
+            return get_user_autocompletions(ctx, all_args, incomplete, param)
 
-    for item in choices:
-        if item.startswith(incomplete):
-            yield item
+    add_subcommand_completions(ctx, incomplete, completions)
+    # Sort before returning so that proper ordering can be enforced in custom types.
+    return sorted(completions)
 
 
-def do_complete(cli, prog_name):
+def do_complete(cli, prog_name, include_descriptions):
     cwords = split_arg_string(os.environ['COMP_WORDS'])
     cword = int(os.environ['COMP_CWORD'])
     args = cwords[1:cword]
@@ -69,15 +275,19 @@ def do_complete(cli, prog_name):
         incomplete = ''
 
     for item in get_choices(cli, prog_name, args, incomplete):
-        echo(item)
+        echo(item[0])
+        if include_descriptions:
+            # ZSH has trouble dealing with empty array parameters when returned from commands, so use a well defined character '_' to indicate no description is present.
+            echo(item[1] if item[1] else '_')
 
     return True
 
 
 def bashcomplete(cli, prog_name, complete_var, complete_instr):
-    if complete_instr == 'source':
-        echo(get_completion_script(prog_name, complete_var))
+    if complete_instr.startswith('source'):
+        shell = 'zsh' if complete_instr == 'source_zsh' else 'bash'
+        echo(get_completion_script(prog_name, complete_var, shell))
         return True
-    elif complete_instr == 'complete':
-        return do_complete(cli, prog_name)
+    elif complete_instr == 'complete' or complete_instr == 'complete_zsh':
+        return do_complete(cli, prog_name, complete_instr == 'complete_zsh')
     return False
diff --git a/pipenv/vendor/click/_compat.py b/pipenv/vendor/click/_compat.py
index 2b43412c..937e2301 100644
--- a/pipenv/vendor/click/_compat.py
+++ b/pipenv/vendor/click/_compat.py
@@ -7,24 +7,31 @@ from weakref import WeakKeyDictionary
 
 
 PY2 = sys.version_info[0] == 2
-WIN = sys.platform.startswith('win')
+CYGWIN = sys.platform.startswith('cygwin')
+# Determine local App Engine environment, per Google's own suggestion
+APP_ENGINE = ('APPENGINE_RUNTIME' in os.environ and
+              'Development/' in os.environ['SERVER_SOFTWARE'])
+WIN = sys.platform.startswith('win') and not APP_ENGINE
 DEFAULT_COLUMNS = 80
 
 
-_ansi_re = re.compile('\033\[((?:\d|;)*)([a-zA-Z])')
+_ansi_re = re.compile(r'\033\[((?:\d|;)*)([a-zA-Z])')
 
 
 def get_filesystem_encoding():
     return sys.getfilesystemencoding() or sys.getdefaultencoding()
 
 
-def _make_text_stream(stream, encoding, errors):
+def _make_text_stream(stream, encoding, errors,
+                      force_readable=False, force_writable=False):
     if encoding is None:
         encoding = get_best_encoding(stream)
     if errors is None:
         errors = 'replace'
     return _NonClosingTextIOWrapper(stream, encoding, errors,
-                                    line_buffering=True)
+                                    line_buffering=True,
+                                    force_readable=force_readable,
+                                    force_writable=force_writable)
 
 
 def is_ascii_encoding(encoding):
@@ -45,8 +52,10 @@ def get_best_encoding(stream):
 
 class _NonClosingTextIOWrapper(io.TextIOWrapper):
 
-    def __init__(self, stream, encoding, errors, **extra):
-        self._stream = stream = _FixupStream(stream)
+    def __init__(self, stream, encoding, errors,
+                 force_readable=False, force_writable=False, **extra):
+        self._stream = stream = _FixupStream(stream, force_readable,
+                                             force_writable)
         io.TextIOWrapper.__init__(self, stream, encoding, errors, **extra)
 
     # The io module is a place where the Python 3 text behavior
@@ -81,10 +90,16 @@ class _FixupStream(object):
     """The new io interface needs more from streams than streams
     traditionally implement.  As such, this fix-up code is necessary in
     some circumstances.
+
+    The forcing of readable and writable flags are there because some tools
+    put badly patched objects on sys (one such offender are certain version
+    of jupyter notebook).
     """
 
-    def __init__(self, stream):
+    def __init__(self, stream, force_readable=False, force_writable=False):
         self._stream = stream
+        self._force_readable = force_readable
+        self._force_writable = force_writable
 
     def __getattr__(self, name):
         return getattr(self._stream, name)
@@ -101,6 +116,8 @@ class _FixupStream(object):
         return self._stream.read(size)
 
     def readable(self):
+        if self._force_readable:
+            return True
         x = getattr(self._stream, 'readable', None)
         if x is not None:
             return x()
@@ -111,6 +128,8 @@ class _FixupStream(object):
         return True
 
     def writable(self):
+        if self._force_writable:
+            return True
         x = getattr(self._stream, 'writable', None)
         if x is not None:
             return x()
@@ -139,6 +158,7 @@ if PY2:
     bytes = str
     raw_input = raw_input
     string_types = (str, unicode)
+    int_types = (int, long)
     iteritems = lambda x: x.iteritems()
     range_type = xrange
 
@@ -165,10 +185,13 @@ if PY2:
     # available (which is why we use try-catch instead of the WIN variable
     # here), such as the Google App Engine development server on Windows. In
     # those cases there is just nothing we can do.
+    def set_binary_mode(f):
+        return f
+
     try:
         import msvcrt
     except ImportError:
-        set_binary_mode = lambda x: x
+        pass
     else:
         def set_binary_mode(f):
             try:
@@ -179,6 +202,21 @@ if PY2:
                 msvcrt.setmode(fileno, os.O_BINARY)
             return f
 
+    try:
+        import fcntl
+    except ImportError:
+        pass
+    else:
+        def set_binary_mode(f):
+            try:
+                fileno = f.fileno()
+            except Exception:
+                pass
+            else:
+                flags = fcntl.fcntl(fileno, fcntl.F_GETFL)
+                fcntl.fcntl(fileno, fcntl.F_SETFL, flags & ~os.O_NONBLOCK)
+            return f
+
     def isidentifier(x):
         return _identifier_re.search(x) is not None
 
@@ -186,28 +224,35 @@ if PY2:
         return set_binary_mode(sys.stdin)
 
     def get_binary_stdout():
+        _wrap_std_stream('stdout')
         return set_binary_mode(sys.stdout)
 
     def get_binary_stderr():
+        _wrap_std_stream('stderr')
         return set_binary_mode(sys.stderr)
 
     def get_text_stdin(encoding=None, errors=None):
         rv = _get_windows_console_stream(sys.stdin, encoding, errors)
         if rv is not None:
             return rv
-        return _make_text_stream(sys.stdin, encoding, errors)
+        return _make_text_stream(sys.stdin, encoding, errors,
+                                 force_readable=True)
 
     def get_text_stdout(encoding=None, errors=None):
+        _wrap_std_stream('stdout')
         rv = _get_windows_console_stream(sys.stdout, encoding, errors)
         if rv is not None:
             return rv
-        return _make_text_stream(sys.stdout, encoding, errors)
+        return _make_text_stream(sys.stdout, encoding, errors,
+                                 force_writable=True)
 
     def get_text_stderr(encoding=None, errors=None):
+        _wrap_std_stream('stderr')
         rv = _get_windows_console_stream(sys.stderr, encoding, errors)
         if rv is not None:
             return rv
-        return _make_text_stream(sys.stderr, encoding, errors)
+        return _make_text_stream(sys.stderr, encoding, errors,
+                                 force_writable=True)
 
     def filename_to_ui(value):
         if isinstance(value, bytes):
@@ -218,6 +263,7 @@ else:
     text_type = str
     raw_input = input
     string_types = (str,)
+    int_types = (int,)
     range_type = range
     isidentifier = lambda x: x.isidentifier()
     iteritems = lambda x: iter(x.items())
@@ -298,7 +344,8 @@ else:
 
         return False
 
-    def _force_correct_text_reader(text_reader, encoding, errors):
+    def _force_correct_text_reader(text_reader, encoding, errors,
+                                   force_readable=False):
         if _is_binary_reader(text_reader, False):
             binary_reader = text_reader
         else:
@@ -324,9 +371,11 @@ else:
         # we're so fundamentally fucked that nothing can repair it.
         if errors is None:
             errors = 'replace'
-        return _make_text_stream(binary_reader, encoding, errors)
+        return _make_text_stream(binary_reader, encoding, errors,
+                                 force_readable=force_readable)
 
-    def _force_correct_text_writer(text_writer, encoding, errors):
+    def _force_correct_text_writer(text_writer, encoding, errors,
+                                   force_writable=False):
         if _is_binary_writer(text_writer, False):
             binary_writer = text_writer
         else:
@@ -352,7 +401,8 @@ else:
         # we're so fundamentally fucked that nothing can repair it.
         if errors is None:
             errors = 'replace'
-        return _make_text_stream(binary_writer, encoding, errors)
+        return _make_text_stream(binary_writer, encoding, errors,
+                                 force_writable=force_writable)
 
     def get_binary_stdin():
         reader = _find_binary_reader(sys.stdin)
@@ -379,19 +429,22 @@ else:
         rv = _get_windows_console_stream(sys.stdin, encoding, errors)
         if rv is not None:
             return rv
-        return _force_correct_text_reader(sys.stdin, encoding, errors)
+        return _force_correct_text_reader(sys.stdin, encoding, errors,
+                                          force_readable=True)
 
     def get_text_stdout(encoding=None, errors=None):
         rv = _get_windows_console_stream(sys.stdout, encoding, errors)
         if rv is not None:
             return rv
-        return _force_correct_text_writer(sys.stdout, encoding, errors)
+        return _force_correct_text_writer(sys.stdout, encoding, errors,
+                                          force_writable=True)
 
     def get_text_stderr(encoding=None, errors=None):
         rv = _get_windows_console_stream(sys.stderr, encoding, errors)
         if rv is not None:
             return rv
-        return _force_correct_text_writer(sys.stderr, encoding, errors)
+        return _force_correct_text_writer(sys.stderr, encoding, errors,
+                                          force_writable=True)
 
     def filename_to_ui(value):
         if isinstance(value, bytes):
@@ -420,7 +473,7 @@ def open_stream(filename, mode='r', encoding=None, errors='strict',
     # Standard streams first.  These are simple because they don't need
     # special handling for the atomic flag.  It's entirely ignored.
     if filename == '-':
-        if 'w' in mode:
+        if any(m in mode for m in ['w', 'a', 'x']):
             if 'b' in mode:
                 return get_binary_stdout(), False
             return get_text_stdout(encoding=encoding, errors=errors), False
@@ -460,7 +513,7 @@ def open_stream(filename, mode='r', encoding=None, errors='strict',
     else:
         f = os.fdopen(fd, mode)
 
-    return _AtomicFile(f, tmp_filename, filename), True
+    return _AtomicFile(f, tmp_filename, os.path.realpath(filename)), True
 
 
 # Used in a destructor call, needs extra protection from interpreter cleanup.
@@ -533,7 +586,7 @@ if WIN:
     # Windows has a smaller terminal
     DEFAULT_COLUMNS = 79
 
-    from ._winconsole import _get_windows_console_stream
+    from ._winconsole import _get_windows_console_stream, _wrap_std_stream
 
     def _get_argv_encoding():
         import locale
@@ -595,6 +648,7 @@ else:
         return getattr(sys.stdin, 'encoding', None) or get_filesystem_encoding()
 
     _get_windows_console_stream = lambda *x: None
+    _wrap_std_stream = lambda *x: None
 
 
 def term_len(x):
@@ -620,6 +674,7 @@ def _make_cached_stream_func(src_func, wrapper_func):
             return rv
         rv = wrapper_func()
         try:
+            stream = src_func()  # In case wrapper_func() modified the stream
             cache[stream] = rv
         except Exception:
             pass
diff --git a/pipenv/vendor/click/_termui_impl.py b/pipenv/vendor/click/_termui_impl.py
index 7cfd3d5c..00a8e5ef 100644
--- a/pipenv/vendor/click/_termui_impl.py
+++ b/pipenv/vendor/click/_termui_impl.py
@@ -1,20 +1,24 @@
+# -*- coding: utf-8 -*-
 """
-    click._termui_impl
-    ~~~~~~~~~~~~~~~~~~
+click._termui_impl
+~~~~~~~~~~~~~~~~~~
 
-    This module contains implementations for the termui module.  To keep the
-    import time of Click down, some infrequently used functionality is placed
-    in this module and only imported as needed.
+This module contains implementations for the termui module. To keep the
+import time of Click down, some infrequently used functionality is
+placed in this module and only imported as needed.
 
-    :copyright: (c) 2014 by Armin Ronacher.
-    :license: BSD, see LICENSE for more details.
+:copyright: © 2014 by the Pallets team.
+:license: BSD, see LICENSE.rst for more details.
 """
+
 import os
 import sys
 import time
 import math
+import contextlib
 from ._compat import _default_text_stdout, range_type, PY2, isatty, \
-     open_stream, strip_ansi, term_len, get_best_encoding, WIN
+     open_stream, strip_ansi, term_len, get_best_encoding, WIN, int_types, \
+     CYGWIN
 from .utils import echo
 from .exceptions import ClickException
 
@@ -41,7 +45,7 @@ def _length_hint(obj):
         except TypeError:
             return None
         if hint is NotImplemented or \
-           not isinstance(hint, (int, long)) or \
+           not isinstance(hint, int_types) or \
            hint < 0:
             return None
         return hint
@@ -88,6 +92,7 @@ class ProgressBar(object):
         self.current_item = None
         self.is_hidden = not isatty(self.file)
         self._last_line = None
+        self.short_limit = 0.5
 
     def __enter__(self):
         self.entered = True
@@ -101,10 +106,13 @@ class ProgressBar(object):
         if not self.entered:
             raise RuntimeError('You need to use progress bars in a with block.')
         self.render_progress()
-        return self
+        return self.generator()
+
+    def is_fast(self):
+        return time.time() - self.start <= self.short_limit
 
     def render_finish(self):
-        if self.is_hidden:
+        if self.is_hidden or self.is_fast():
             return
         self.file.write(AFTER_BAR)
         self.file.flush()
@@ -129,13 +137,13 @@ class ProgressBar(object):
 
     def format_eta(self):
         if self.eta_known:
-            t = self.eta + 1
+            t = int(self.eta)
             seconds = t % 60
-            t /= 60
+            t //= 60
             minutes = t % 60
-            t /= 60
+            t //= 60
             hours = t % 24
-            t /= 24
+            t //= 24
             if t > 0:
                 days = t
                 return '%dd %02d:%02d:%02d' % (days, hours, minutes, seconds)
@@ -152,25 +160,27 @@ class ProgressBar(object):
     def format_pct(self):
         return ('% 4d%%' % int(self.pct * 100))[1:]
 
-    def format_progress_line(self):
-        show_percent = self.show_percent
-
-        info_bits = []
+    def format_bar(self):
         if self.length_known:
             bar_length = int(self.pct * self.width)
             bar = self.fill_char * bar_length
             bar += self.empty_char * (self.width - bar_length)
-            if show_percent is None:
-                show_percent = not self.show_pos
+        elif self.finished:
+            bar = self.fill_char * self.width
         else:
-            if self.finished:
-                bar = self.fill_char * self.width
-            else:
-                bar = list(self.empty_char * (self.width or 1))
-                if self.time_per_iteration != 0:
-                    bar[int((math.cos(self.pos * self.time_per_iteration)
-                        / 2.0 + 0.5) * self.width)] = self.fill_char
-                bar = ''.join(bar)
+            bar = list(self.empty_char * (self.width or 1))
+            if self.time_per_iteration != 0:
+                bar[int((math.cos(self.pos * self.time_per_iteration)
+                    / 2.0 + 0.5) * self.width)] = self.fill_char
+            bar = ''.join(bar)
+        return bar
+
+    def format_progress_line(self):
+        show_percent = self.show_percent
+
+        info_bits = []
+        if self.length_known and show_percent is None:
+            show_percent = not self.show_pos
 
         if self.show_pos:
             info_bits.append(self.format_pos())
@@ -185,49 +195,47 @@ class ProgressBar(object):
 
         return (self.bar_template % {
             'label': self.label,
-            'bar': bar,
+            'bar': self.format_bar(),
             'info': self.info_sep.join(info_bits)
         }).rstrip()
 
     def render_progress(self):
         from .termui import get_terminal_size
-        nl = False
 
         if self.is_hidden:
-            buf = [self.label]
-            nl = True
-        else:
-            buf = []
-            # Update width in case the terminal has been resized
-            if self.autowidth:
-                old_width = self.width
-                self.width = 0
-                clutter_length = term_len(self.format_progress_line())
-                new_width = max(0, get_terminal_size()[0] - clutter_length)
-                if new_width < old_width:
-                    buf.append(BEFORE_BAR)
-                    buf.append(' ' * self.max_width)
-                    self.max_width = new_width
-                self.width = new_width
+            return
 
-            clear_width = self.width
-            if self.max_width is not None:
-                clear_width = self.max_width
+        buf = []
+        # Update width in case the terminal has been resized
+        if self.autowidth:
+            old_width = self.width
+            self.width = 0
+            clutter_length = term_len(self.format_progress_line())
+            new_width = max(0, get_terminal_size()[0] - clutter_length)
+            if new_width < old_width:
+                buf.append(BEFORE_BAR)
+                buf.append(' ' * self.max_width)
+                self.max_width = new_width
+            self.width = new_width
 
-            buf.append(BEFORE_BAR)
-            line = self.format_progress_line()
-            line_len = term_len(line)
-            if self.max_width is None or self.max_width < line_len:
-                self.max_width = line_len
-            buf.append(line)
+        clear_width = self.width
+        if self.max_width is not None:
+            clear_width = self.max_width
 
-            buf.append(' ' * (clear_width - line_len))
+        buf.append(BEFORE_BAR)
+        line = self.format_progress_line()
+        line_len = term_len(line)
+        if self.max_width is None or self.max_width < line_len:
+            self.max_width = line_len
+
+        buf.append(line)
+        buf.append(' ' * (clear_width - line_len))
         line = ''.join(buf)
-
         # Render the line only if it changed.
-        if line != self._last_line:
+
+        if line != self._last_line and not self.is_fast():
             self._last_line = line
-            echo(line, file=self.file, color=self.color, nl=nl)
+            echo(line, file=self.file, color=self.color, nl=False)
             self.file.flush()
 
     def make_step(self, n_steps):
@@ -239,7 +247,16 @@ class ProgressBar(object):
             return
 
         self.last_eta = time.time()
-        self.avg = self.avg[-6:] + [-(self.start - time.time()) / (self.pos)]
+
+        # self.avg is a rolling list of length <= 7 of steps where steps are
+        # defined as time elapsed divided by the total progress through
+        # self.length.
+        if self.pos:
+            step = (time.time() - self.start) / self.pos
+        else:
+            step = time.time() - self.start
+
+        self.avg = self.avg[-6:] + [step]
 
         self.eta_known = self.length_known
 
@@ -252,54 +269,56 @@ class ProgressBar(object):
         self.current_item = None
         self.finished = True
 
-    def next(self):
+    def generator(self):
+        """
+        Returns a generator which yields the items added to the bar during
+        construction, and updates the progress bar *after* the yielded block
+        returns.
+        """
+        if not self.entered:
+            raise RuntimeError('You need to use progress bars in a with block.')
+
         if self.is_hidden:
-            return next(self.iter)
-        try:
-            rv = next(self.iter)
-            self.current_item = rv
-        except StopIteration:
+            for rv in self.iter:
+                yield rv
+        else:
+            for rv in self.iter:
+                self.current_item = rv
+                yield rv
+                self.update(1)
             self.finish()
             self.render_progress()
-            raise StopIteration()
-        else:
-            self.update(1)
-            return rv
-
-    if not PY2:
-        __next__ = next
-        del next
 
 
-def pager(text, color=None):
+def pager(generator, color=None):
     """Decide what method to use for paging through text."""
     stdout = _default_text_stdout()
     if not isatty(sys.stdin) or not isatty(stdout):
-        return _nullpager(stdout, text, color)
+        return _nullpager(stdout, generator, color)
     pager_cmd = (os.environ.get('PAGER', None) or '').strip()
     if pager_cmd:
         if WIN:
-            return _tempfilepager(text, pager_cmd, color)
-        return _pipepager(text, pager_cmd, color)
+            return _tempfilepager(generator, pager_cmd, color)
+        return _pipepager(generator, pager_cmd, color)
     if os.environ.get('TERM') in ('dumb', 'emacs'):
-        return _nullpager(stdout, text, color)
+        return _nullpager(stdout, generator, color)
     if WIN or sys.platform.startswith('os2'):
-        return _tempfilepager(text, 'more <', color)
+        return _tempfilepager(generator, 'more <', color)
     if hasattr(os, 'system') and os.system('(less) 2>/dev/null') == 0:
-        return _pipepager(text, 'less', color)
+        return _pipepager(generator, 'less', color)
 
     import tempfile
     fd, filename = tempfile.mkstemp()
     os.close(fd)
     try:
         if hasattr(os, 'system') and os.system('more "%s"' % filename) == 0:
-            return _pipepager(text, 'more', color)
-        return _nullpager(stdout, text, color)
+            return _pipepager(generator, 'more', color)
+        return _nullpager(stdout, generator, color)
     finally:
         os.unlink(filename)
 
 
-def _pipepager(text, cmd, color):
+def _pipepager(generator, cmd, color):
     """Page through text by feeding it to another program.  Invoking a
     pager through this might support colors.
     """
@@ -317,17 +336,19 @@ def _pipepager(text, cmd, color):
         elif 'r' in less_flags or 'R' in less_flags:
             color = True
 
-    if not color:
-        text = strip_ansi(text)
-
     c = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,
                          env=env)
     encoding = get_best_encoding(c.stdin)
     try:
-        c.stdin.write(text.encode(encoding, 'replace'))
-        c.stdin.close()
+        for text in generator:
+            if not color:
+                text = strip_ansi(text)
+
+            c.stdin.write(text.encode(encoding, 'replace'))
     except (IOError, KeyboardInterrupt):
         pass
+    else:
+        c.stdin.close()
 
     # Less doesn't respect ^C, but catches it for its own UI purposes (aborting
     # search or other commands inside less).
@@ -346,10 +367,12 @@ def _pipepager(text, cmd, color):
             break
 
 
-def _tempfilepager(text, cmd, color):
+def _tempfilepager(generator, cmd, color):
     """Page through text by invoking a program on a temporary file."""
     import tempfile
     filename = tempfile.mktemp()
+    # TODO: This never terminates if the passed generator never terminates.
+    text = "".join(generator)
     if not color:
         text = strip_ansi(text)
     encoding = get_best_encoding(sys.stdout)
@@ -361,11 +384,12 @@ def _tempfilepager(text, cmd, color):
         os.unlink(filename)
 
 
-def _nullpager(stream, text, color):
+def _nullpager(stream, generator, color):
     """Simply print unformatted text.  This is the ultimate fallback."""
-    if not color:
-        text = strip_ansi(text)
-    stream.write(text)
+    for text in generator:
+        if not color:
+            text = strip_ansi(text)
+        stream.write(text)
 
 
 class Editor(object):
@@ -478,6 +502,14 @@ def open_url(url, wait=False, locate=False):
             args = 'start %s "" "%s"' % (
                 wait and '/WAIT' or '', url.replace('"', ''))
         return os.system(args)
+    elif CYGWIN:
+        if locate:
+            url = _unquote_file(url)
+            args = 'cygstart "%s"' % (os.path.dirname(url).replace('"', ''))
+        else:
+            args = 'cygstart %s "%s"' % (
+                wait and '-w' or '', url.replace('"', ''))
+        return os.system(args)
 
     try:
         if locate:
@@ -497,32 +529,69 @@ def open_url(url, wait=False, locate=False):
 
 
 def _translate_ch_to_exc(ch):
-    if ch == '\x03':
+    if ch == u'\x03':
         raise KeyboardInterrupt()
-    if ch == '\x04':
+    if ch == u'\x04' and not WIN:  # Unix-like, Ctrl+D
+        raise EOFError()
+    if ch == u'\x1a' and WIN:      # Windows, Ctrl+Z
         raise EOFError()
 
 
 if WIN:
     import msvcrt
 
+    @contextlib.contextmanager
+    def raw_terminal():
+        yield
+
     def getchar(echo):
-        rv = msvcrt.getch()
+        # The function `getch` will return a bytes object corresponding to
+        # the pressed character. Since Windows 10 build 1803, it will also
+        # return \x00 when called a second time after pressing a regular key.
+        #
+        # `getwch` does not share this probably-bugged behavior. Moreover, it
+        # returns a Unicode object by default, which is what we want.
+        #
+        # Either of these functions will return \x00 or \xe0 to indicate
+        # a special key, and you need to call the same function again to get
+        # the "rest" of the code. The fun part is that \u00e0 is
+        # "latin small letter a with grave", so if you type that on a French
+        # keyboard, you _also_ get a \xe0.
+        # E.g., consider the Up arrow. This returns \xe0 and then \x48. The
+        # resulting Unicode string reads as "a with grave" + "capital H".
+        # This is indistinguishable from when the user actually types
+        # "a with grave" and then "capital H".
+        #
+        # When \xe0 is returned, we assume it's part of a special-key sequence
+        # and call `getwch` again, but that means that when the user types
+        # the \u00e0 character, `getchar` doesn't return until a second
+        # character is typed.
+        # The alternative is returning immediately, but that would mess up
+        # cross-platform handling of arrow keys and others that start with
+        # \xe0. Another option is using `getch`, but then we can't reliably
+        # read non-ASCII characters, because return values of `getch` are
+        # limited to the current 8-bit codepage.
+        #
+        # Anyway, Click doesn't claim to do this Right(tm), and using `getwch`
+        # is doing the right thing in more situations than with `getch`.
         if echo:
-            msvcrt.putchar(rv)
+            func = msvcrt.getwche
+        else:
+            func = msvcrt.getwch
+
+        rv = func()
+        if rv in (u'\x00', u'\xe0'):
+            # \x00 and \xe0 are control characters that indicate special key,
+            # see above.
+            rv += func()
         _translate_ch_to_exc(rv)
-        if PY2:
-            enc = getattr(sys.stdin, 'encoding', None)
-            if enc is not None:
-                rv = rv.decode(enc, 'replace')
-            else:
-                rv = rv.decode('cp1252', 'replace')
         return rv
 else:
     import tty
     import termios
 
-    def getchar(echo):
+    @contextlib.contextmanager
+    def raw_terminal():
         if not isatty(sys.stdin):
             f = open('/dev/tty')
             fd = f.fileno()
@@ -533,9 +602,7 @@ else:
             old_settings = termios.tcgetattr(fd)
             try:
                 tty.setraw(fd)
-                ch = os.read(fd, 32)
-                if echo and isatty(sys.stdout):
-                    sys.stdout.write(ch)
+                yield fd
             finally:
                 termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
                 sys.stdout.flush()
@@ -543,5 +610,12 @@ else:
                     f.close()
         except termios.error:
             pass
-        _translate_ch_to_exc(ch)
-        return ch.decode(get_best_encoding(sys.stdin), 'replace')
+
+    def getchar(echo):
+        with raw_terminal() as fd:
+            ch = os.read(fd, 32)
+            ch = ch.decode(get_best_encoding(sys.stdin), 'replace')
+            if echo and isatty(sys.stdout):
+                sys.stdout.write(ch)
+            _translate_ch_to_exc(ch)
+            return ch
diff --git a/pipenv/vendor/click/_unicodefun.py b/pipenv/vendor/click/_unicodefun.py
index ff58c78b..620edff3 100644
--- a/pipenv/vendor/click/_unicodefun.py
+++ b/pipenv/vendor/click/_unicodefun.py
@@ -14,6 +14,8 @@ click = sys.modules[__name__.rsplit('.', 1)[0]]
 
 def _find_unicode_literals_frame():
     import __future__
+    if not hasattr(sys, '_getframe'):  # not all Python implementations have it
+        return 0
     frm = sys._getframe(1)
     idx = 1
     while frm is not None:
@@ -41,7 +43,7 @@ def _check_for_unicode_literals():
                  'because it can introduce subtle bugs in your '
                  'code.  You should instead use explicit u"" literals '
                  'for your unicode strings.  For more information see '
-                 'http://click.pocoo.org/python3/'),
+                 'https://click.palletsprojects.com/python3/'),
          stacklevel=bad_frame)
 
 
@@ -60,8 +62,11 @@ def _verify_python3_env():
     extra = ''
     if os.name == 'posix':
         import subprocess
-        rv = subprocess.Popen(['locale', '-a'], stdout=subprocess.PIPE,
-                              stderr=subprocess.PIPE).communicate()[0]
+        try:
+            rv = subprocess.Popen(['locale', '-a'], stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE).communicate()[0]
+        except OSError:
+            rv = b''
         good_locales = set()
         has_c_utf8 = False
 
@@ -94,7 +99,7 @@ def _verify_python3_env():
         else:
             extra += (
                 'This system lists a couple of UTF-8 supporting locales that\n'
-                'you can pick from.  The following suitable locales where\n'
+                'you can pick from.  The following suitable locales were\n'
                 'discovered: %s'
             ) % ', '.join(sorted(good_locales))
 
@@ -112,7 +117,9 @@ def _verify_python3_env():
                 'is not supported'
             ) % bad_locale
 
-    raise RuntimeError('Click will abort further execution because Python 3 '
-                       'was configured to use ASCII as encoding for the '
-                       'environment.  Consult http://click.pocoo.org/python3/ '
-                       'for mitigation steps.' + extra)
+    raise RuntimeError(
+        'Click will abort further execution because Python 3 was'
+        ' configured to use ASCII as encoding for the environment.'
+        ' Consult https://click.palletsprojects.com/en/7.x/python3/ for'
+        ' mitigation steps.' + extra
+    )
diff --git a/pipenv/vendor/click/_winconsole.py b/pipenv/vendor/click/_winconsole.py
index 9aed9421..bbb080dd 100644
--- a/pipenv/vendor/click/_winconsole.py
+++ b/pipenv/vendor/click/_winconsole.py
@@ -15,7 +15,7 @@ import zlib
 import time
 import ctypes
 import msvcrt
-from click._compat import _NonClosingTextIOWrapper, text_type, PY2
+from ._compat import _NonClosingTextIOWrapper, text_type, PY2
 from ctypes import byref, POINTER, c_int, c_char, c_char_p, \
      c_void_p, py_object, c_ssize_t, c_ulong, windll, WINFUNCTYPE
 try:
@@ -201,6 +201,40 @@ class ConsoleStream(object):
         )
 
 
+class WindowsChunkedWriter(object):
+    """
+    Wraps a stream (such as stdout), acting as a transparent proxy for all
+    attribute access apart from method 'write()' which we wrap to write in
+    limited chunks due to a Windows limitation on binary console streams.
+    """
+    def __init__(self, wrapped):
+        # double-underscore everything to prevent clashes with names of
+        # attributes on the wrapped stream object.
+        self.__wrapped = wrapped
+
+    def __getattr__(self, name):
+        return getattr(self.__wrapped, name)
+
+    def write(self, text):
+        total_to_write = len(text)
+        written = 0
+
+        while written < total_to_write:
+            to_write = min(total_to_write - written, MAX_BYTES_WRITTEN)
+            self.__wrapped.write(text[written:written+to_write])
+            written += to_write
+
+
+_wrapped_std_streams = set()
+
+
+def _wrap_std_stream(name):
+    # Python 2 & Windows 7 and below
+    if PY2 and sys.getwindowsversion()[:2] <= (6, 1) and name not in _wrapped_std_streams:
+        setattr(sys, name, WindowsChunkedWriter(getattr(sys, name)))
+        _wrapped_std_streams.add(name)
+
+
 def _get_text_stdin(buffer_stream):
     text_stream = _NonClosingTextIOWrapper(
         io.BufferedReader(_WindowsConsoleReader(STDIN_HANDLE)),
@@ -210,14 +244,14 @@ def _get_text_stdin(buffer_stream):
 
 def _get_text_stdout(buffer_stream):
     text_stream = _NonClosingTextIOWrapper(
-        _WindowsConsoleWriter(STDOUT_HANDLE),
+        io.BufferedWriter(_WindowsConsoleWriter(STDOUT_HANDLE)),
         'utf-16-le', 'strict', line_buffering=True)
     return ConsoleStream(text_stream, buffer_stream)
 
 
 def _get_text_stderr(buffer_stream):
     text_stream = _NonClosingTextIOWrapper(
-        _WindowsConsoleWriter(STDERR_HANDLE),
+        io.BufferedWriter(_WindowsConsoleWriter(STDERR_HANDLE)),
         'utf-16-le', 'strict', line_buffering=True)
     return ConsoleStream(text_stream, buffer_stream)
 
@@ -261,7 +295,7 @@ def _get_windows_console_stream(f, encoding, errors):
         func = _stream_factories.get(f.fileno())
         if func is not None:
             if not PY2:
-                f = getattr(f, 'buffer')
+                f = getattr(f, 'buffer', None)
                 if f is None:
                     return None
             else:
diff --git a/pipenv/vendor/click/core.py b/pipenv/vendor/click/core.py
index 74564514..7a1e3422 100644
--- a/pipenv/vendor/click/core.py
+++ b/pipenv/vendor/click/core.py
@@ -1,4 +1,5 @@
 import errno
+import inspect
 import os
 import sys
 from contextlib import contextmanager
@@ -6,15 +7,16 @@ from itertools import repeat
 from functools import update_wrapper
 
 from .types import convert_type, IntRange, BOOL
-from .utils import make_str, make_default_short_help, echo, get_os_args
+from .utils import PacifyFlushWrapper, make_str, make_default_short_help, \
+     echo, get_os_args
 from .exceptions import ClickException, UsageError, BadParameter, Abort, \
-     MissingParameter
-from .termui import prompt, confirm
+     MissingParameter, Exit
+from .termui import prompt, confirm, style
 from .formatting import HelpFormatter, join_options
 from .parser import OptionParser, split_opt
 from .globals import push_context, pop_context
 
-from ._compat import PY2, isidentifier, iteritems
+from ._compat import PY2, isidentifier, iteritems, string_types
 from ._unicodefun import _check_for_unicode_literals, _verify_python3_env
 
 
@@ -24,6 +26,24 @@ _missing = object()
 SUBCOMMAND_METAVAR = 'COMMAND [ARGS]...'
 SUBCOMMANDS_METAVAR = 'COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]...'
 
+DEPRECATED_HELP_NOTICE = ' (DEPRECATED)'
+DEPRECATED_INVOKE_NOTICE = 'DeprecationWarning: ' + \
+                           'The command %(name)s is deprecated.'
+
+
+def _maybe_show_deprecated_notice(cmd):
+    if cmd.deprecated:
+        echo(style(DEPRECATED_INVOKE_NOTICE % {'name': cmd.name}, fg='red'), err=True)
+
+
+def fast_exit(code):
+    """Exit without garbage collection, this speeds up exit by about 10ms for
+    things like bash completion.
+    """
+    sys.stdout.flush()
+    sys.stderr.flush()
+    os._exit(code)
+
 
 def _bashcomplete(cmd, prog_name, complete_var=None):
     """Internal handler for the bash completion support."""
@@ -35,7 +55,7 @@ def _bashcomplete(cmd, prog_name, complete_var=None):
 
     from ._bashcomplete import bashcomplete
     if bashcomplete(cmd, prog_name, complete_var, complete_instr):
-        sys.exit(1)
+        fast_exit(1)
 
 
 def _check_multicommand(base_command, cmd_name, cmd, register=False):
@@ -50,9 +70,7 @@ def _check_multicommand(base_command, cmd_name, cmd, register=False):
     raise RuntimeError('%s.  Command "%s" is set to chain and "%s" was '
                        'added as subcommand but it in itself is a '
                        'multi command.  ("%s" is a %s within a chained '
-                       '%s named "%s").  This restriction was supposed to '
-                       'be lifted in 6.0 but the fix was flawed.  This '
-                       'will be fixed in Click 7.0' % (
+                       '%s named "%s").' % (
                            hint, base_command.name, cmd_name,
                            cmd_name, cmd.__class__.__name__,
                            base_command.__class__.__name__,
@@ -165,7 +183,8 @@ class Context(object):
                               add some safety mapping on the right.
     :param resilient_parsing: if this flag is enabled then Click will
                               parse without any interactivity or callback
-                              invocation.  This is useful for implementing
+                              invocation.  Default values will also be
+                              ignored.  This is useful for implementing
                               things such as completion support.
     :param allow_extra_args: if this is set to `True` then extra arguments
                              at the end will not raise an error and will be
@@ -295,7 +314,8 @@ class Context(object):
         self.token_normalize_func = token_normalize_func
 
         #: Indicates if resilient parsing is enabled.  In that case Click
-        #: will do its best to not cause any failures.
+        #: will do its best to not cause any failures and default values
+        #: will be ignored. Useful for completion.
         self.resilient_parsing = resilient_parsing
 
         # If there is no envvar prefix yet, but the parent has one and
@@ -308,7 +328,7 @@ class Context(object):
                 auto_envvar_prefix = '%s_%s' % (parent.auto_envvar_prefix,
                                            self.info_name.upper())
         else:
-            self.auto_envvar_prefix = auto_envvar_prefix.upper()
+            auto_envvar_prefix = auto_envvar_prefix.upper()
         self.auto_envvar_prefix = auto_envvar_prefix
 
         if color is None and parent is not None:
@@ -372,7 +392,7 @@ class Context(object):
     @property
     def meta(self):
         """This is a dictionary which is shared with all the contexts
-        that are nested.  It exists so that click utiltiies can store some
+        that are nested.  It exists so that click utilities can store some
         state here if they need to.  It is however the responsibility of
         that code to manage this dictionary well.
 
@@ -481,7 +501,7 @@ class Context(object):
 
     def exit(self, code=0):
         """Exits the application with a given exit code."""
-        sys.exit(code)
+        raise Exit(code)
 
     def get_usage(self):
         """Helper method to get formatted usage string for the current
@@ -655,7 +675,7 @@ class BaseCommand(object):
                           name from ``sys.argv[0]``.
         :param complete_var: the environment variable that controls the
                              bash completion support.  The default is
-                             ``"_<prog_name>_COMPLETE"`` with prog name in
+                             ``"_<prog_name>_COMPLETE"`` with prog_name in
                              uppercase.
         :param standalone_mode: the default behavior is to invoke the script
                                 in standalone mode.  Click will then
@@ -670,7 +690,7 @@ class BaseCommand(object):
                       constructor.  See :class:`Context` for more information.
         """
         # If we are in Python 3, we will verify that the environment is
-        # sane at this point of reject further execution to avoid a
+        # sane at this point or reject further execution to avoid a
         # broken script.
         if not PY2:
             _verify_python3_env()
@@ -697,6 +717,13 @@ class BaseCommand(object):
                     rv = self.invoke(ctx)
                     if not standalone_mode:
                         return rv
+                    # it's not safe to `ctx.exit(rv)` here!
+                    # note that `rv` may actually contain data like "1" which
+                    # has obvious effects
+                    # more subtle case: `rv=[None, None]` can come out of
+                    # chained commands which all returned `None` -- so it's not
+                    # even always obvious that `rv` indicates success/failure
+                    # by its truthiness/falsiness
                     ctx.exit()
             except (EOFError, KeyboardInterrupt):
                 echo(file=sys.stderr)
@@ -708,9 +735,24 @@ class BaseCommand(object):
                 sys.exit(e.exit_code)
             except IOError as e:
                 if e.errno == errno.EPIPE:
+                    sys.stdout = PacifyFlushWrapper(sys.stdout)
+                    sys.stderr = PacifyFlushWrapper(sys.stderr)
                     sys.exit(1)
                 else:
                     raise
+        except Exit as e:
+            if standalone_mode:
+                sys.exit(e.exit_code)
+            else:
+                # in non-standalone mode, return the exit code
+                # note that this is only reached if `self.invoke` above raises
+                # an Exit explicitly -- thus bypassing the check there which
+                # would return its result
+                # the results of non-standalone execution may therefore be
+                # somewhat ambiguous: if there are codepaths which lead to
+                # `ctx.exit(1)` and to `return 1`, the caller won't be able to
+                # tell the difference between the two
+                return e.exit_code
         except Abort:
             if not standalone_mode:
                 raise
@@ -743,11 +785,16 @@ class Command(BaseCommand):
                        shown on the command listing of the parent command.
     :param add_help_option: by default each command registers a ``--help``
                             option.  This can be disabled by this parameter.
+    :param hidden: hide this command from help outputs.
+
+    :param deprecated: issues a message indicating that
+                             the command is deprecated.
     """
 
     def __init__(self, name, context_settings=None, callback=None,
                  params=None, help=None, epilog=None, short_help=None,
-                 options_metavar='[OPTIONS]', add_help_option=True):
+                 options_metavar='[OPTIONS]', add_help_option=True,
+                 hidden=False, deprecated=False):
         BaseCommand.__init__(self, name, context_settings)
         #: the callback to execute when the command fires.  This might be
         #: `None` in which case nothing happens.
@@ -756,13 +803,17 @@ class Command(BaseCommand):
         #: should show up in the help page and execute.  Eager parameters
         #: will automatically be handled before non eager ones.
         self.params = params or []
+        # if a form feed (page break) is found in the help text, truncate help
+        # text to the content preceding the first form feed
+        if help and '\f' in help:
+            help = help.split('\f', 1)[0]
         self.help = help
         self.epilog = epilog
         self.options_metavar = options_metavar
-        if short_help is None and help:
-            short_help = make_default_short_help(help)
         self.short_help = short_help
         self.add_help_option = add_help_option
+        self.hidden = hidden
+        self.deprecated = deprecated
 
     def get_usage(self, ctx):
         formatter = ctx.make_formatter()
@@ -816,8 +867,6 @@ class Command(BaseCommand):
     def make_parser(self, ctx):
         """Creates the underlying option parser for this command."""
         parser = OptionParser(ctx)
-        parser.allow_interspersed_args = ctx.allow_interspersed_args
-        parser.ignore_unknown_options = ctx.ignore_unknown_options
         for param in self.get_params(ctx):
             param.add_to_parser(parser, ctx)
         return parser
@@ -830,6 +879,10 @@ class Command(BaseCommand):
         self.format_help(ctx, formatter)
         return formatter.getvalue().rstrip('\n')
 
+    def get_short_help_str(self, limit=45):
+        """Gets short help for the command or makes it by shortening the long help string."""
+        return self.short_help or self.help and make_default_short_help(self.help, limit) or ''
+
     def format_help(self, ctx, formatter):
         """Writes the help into the formatter if it exists.
 
@@ -850,7 +903,14 @@ class Command(BaseCommand):
         if self.help:
             formatter.write_paragraph()
             with formatter.indentation():
-                formatter.write_text(self.help)
+                help_text = self.help
+                if self.deprecated:
+                    help_text += DEPRECATED_HELP_NOTICE
+                formatter.write_text(help_text)
+        elif self.deprecated:
+            formatter.write_paragraph()
+            with formatter.indentation():
+                formatter.write_text(DEPRECATED_HELP_NOTICE)
 
     def format_options(self, ctx, formatter):
         """Writes all the options into the formatter if they exist."""
@@ -891,6 +951,7 @@ class Command(BaseCommand):
         """Given a context, this invokes the attached callback (if it exists)
         in the right way.
         """
+        _maybe_show_deprecated_notice(self)
         if self.callback is not None:
             return ctx.invoke(self.callback, **ctx.params)
 
@@ -996,19 +1057,29 @@ class MultiCommand(Command):
         """Extra format methods for multi methods that adds all the commands
         after the options.
         """
-        rows = []
+        commands = []
         for subcommand in self.list_commands(ctx):
             cmd = self.get_command(ctx, subcommand)
             # What is this, the tool lied about a command.  Ignore it
             if cmd is None:
                 continue
+            if cmd.hidden:
+                continue
 
-            help = cmd.short_help or ''
-            rows.append((subcommand, help))
+            commands.append((subcommand, cmd))
 
-        if rows:
-            with formatter.section('Commands'):
-                formatter.write_dl(rows)
+        # allow for 3 times the default spacing
+        if len(commands):
+            limit = formatter.width - 6 - max(len(cmd[0]) for cmd in commands)
+
+            rows = []
+            for subcommand, cmd in commands:
+                help = cmd.get_short_help_str(limit)
+                rows.append((subcommand, help))
+
+            if rows:
+                with formatter.section('Commands'):
+                    formatter.write_dl(rows)
 
     def parse_args(self, ctx, args):
         if not args and self.no_args_is_help and not ctx.resilient_parsing:
@@ -1111,7 +1182,7 @@ class MultiCommand(Command):
         # an option we want to kick off parsing again for arguments to
         # resolve things like --help which now should go to the main
         # place.
-        if cmd is None:
+        if cmd is None and not ctx.resilient_parsing:
             if split_opt(cmd_name)[0]:
                 self.parse_args(ctx, ctx.args)
             ctx.fail('No such command "%s".' % original_cmd_name)
@@ -1216,7 +1287,7 @@ class CommandCollection(MultiCommand):
 
 
 class Parameter(object):
-    """A parameter to a command comes in two versions: they are either
+    r"""A parameter to a command comes in two versions: they are either
     :class:`Option`\s or :class:`Argument`\s.  Other subclasses are currently
     not supported by design as some of the internals for parsing are
     intentionally not finalized.
@@ -1261,7 +1332,8 @@ class Parameter(object):
 
     def __init__(self, param_decls=None, type=None, required=False,
                  default=None, callback=None, nargs=None, metavar=None,
-                 expose_value=True, is_eager=False, envvar=None):
+                 expose_value=True, is_eager=False, envvar=None,
+                 autocompletion=None):
         self.name, self.opts, self.secondary_opts = \
             self._parse_decls(param_decls or (), expose_value)
 
@@ -1284,6 +1356,7 @@ class Parameter(object):
         self.is_eager = is_eager
         self.metavar = metavar
         self.envvar = envvar
+        self.autocompletion = autocompletion
 
     @property
     def human_readable_name(self):
@@ -1316,10 +1389,10 @@ class Parameter(object):
 
     def consume_value(self, ctx, opts):
         value = opts.get(self.name)
-        if value is None:
-            value = ctx.lookup_default(self.name)
         if value is None:
             value = self.value_from_envvar(ctx)
+        if value is None:
+            value = ctx.lookup_default(self.name)
         return value
 
     def type_cast_value(self, ctx, value):
@@ -1364,7 +1437,7 @@ class Parameter(object):
     def full_process_value(self, ctx, value):
         value = self.process_value(ctx, value)
 
-        if value is None:
+        if value is None and not ctx.resilient_parsing:
             value = self.get_default(ctx)
 
         if self.required and self.value_is_missing(value):
@@ -1416,6 +1489,13 @@ class Parameter(object):
     def get_usage_pieces(self, ctx):
         return []
 
+    def get_error_hint(self, ctx):
+        """Get a stringified version of the param for use in error messages to
+        indicate which param caused the error.
+        """
+        hint_list = self.opts or [self.human_readable_name]
+        return ' / '.join('"%s"' % x for x in hint_list)
+
 
 class Option(Parameter):
     """Options are usually optional values on the command line and
@@ -1424,10 +1504,15 @@ class Option(Parameter):
     All other parameters are passed onwards to the parameter constructor.
 
     :param show_default: controls if the default value should be shown on the
-                         help page.  Normally, defaults are not shown.
-    :param prompt: if set to `True` or a non empty string then the user will
-                   be prompted for input if not set.  If set to `True` the
-                   prompt will be the option name capitalized.
+                         help page. Normally, defaults are not shown. If this
+                         value is a string, it shows the string instead of the
+                         value. This is particularly useful for dynamic options.
+    :param show_envvar: controls if an environment variable should be shown on
+                        the help page.  Normally, environment variables
+                        are not shown.
+    :param prompt: if set to `True` or a non empty string then the user will be
+                   prompted for input.  If set to `True` the prompt will be the
+                   option name capitalized.
     :param confirmation_prompt: if set then the value will need to be confirmed
                                 if it was prompted for.
     :param hide_input: if this is `True` then the input on the prompt will be
@@ -1448,6 +1533,7 @@ class Option(Parameter):
                                variable in case a prefix is defined on the
                                context.
     :param help: the help string.
+    :param hidden: hide this option from help outputs.
     """
     param_type_name = 'option'
 
@@ -1455,7 +1541,8 @@ class Option(Parameter):
                  prompt=False, confirmation_prompt=False,
                  hide_input=False, is_flag=None, flag_value=None,
                  multiple=False, count=False, allow_from_autoenv=True,
-                 type=None, help=None, **attrs):
+                 type=None, help=None, hidden=False, show_choices=True,
+                 show_envvar=False, **attrs):
         default_is_missing = attrs.get('default', _missing) is _missing
         Parameter.__init__(self, param_decls, type=type, **attrs)
 
@@ -1468,6 +1555,7 @@ class Option(Parameter):
         self.prompt = prompt_text
         self.confirmation_prompt = confirmation_prompt
         self.hide_input = hide_input
+        self.hidden = hidden
 
         # Flags
         if is_flag is None:
@@ -1500,6 +1588,8 @@ class Option(Parameter):
         self.allow_from_autoenv = allow_from_autoenv
         self.help = help
         self.show_default = show_default
+        self.show_choices = show_choices
+        self.show_envvar = show_envvar
 
         # Sanity check for stuff we don't support
         if __debug__:
@@ -1548,8 +1638,8 @@ class Option(Parameter):
                     opts.append(decl)
 
         if name is None and possible_names:
-            possible_names.sort(key=lambda x: len(x[0]))
-            name = possible_names[-1][1].replace('-', '_').lower()
+            possible_names.sort(key=lambda x: -len(x[0]))  # group long options first
+            name = possible_names[0][1].replace('-', '_').lower()
             if not isidentifier(name):
                 name = None
 
@@ -1595,6 +1685,8 @@ class Option(Parameter):
             parser.add_option(self.opts, **kwargs)
 
     def get_help_record(self, ctx):
+        if self.hidden:
+            return
         any_prefix_is_slash = []
 
         def _write_opts(opts):
@@ -1611,11 +1703,28 @@ class Option(Parameter):
 
         help = self.help or ''
         extra = []
+        if self.show_envvar:
+            envvar = self.envvar
+            if envvar is None:
+                if self.allow_from_autoenv and \
+                    ctx.auto_envvar_prefix is not None:
+                    envvar = '%s_%s' % (ctx.auto_envvar_prefix, self.name.upper())
+            if envvar is not None:
+              extra.append('env var: %s' % (
+                           ', '.join('%s' % d for d in envvar)
+                           if isinstance(envvar, (list, tuple))
+                           else envvar, ))
         if self.default is not None and self.show_default:
-            extra.append('default: %s' % (
-                         ', '.join('%s' % d for d in self.default)
-                         if isinstance(self.default, (list, tuple))
-                         else self.default, ))
+            if isinstance(self.show_default, string_types):
+                default_string = '({})'.format(self.show_default)
+            elif isinstance(self.default, (list, tuple)):
+                default_string = ', '.join('%s' % d for d in self.default)
+            elif inspect.isfunction(self.default):
+                default_string = "(dynamic)"
+            else:
+                default_string = self.default
+            extra.append('default: {}'.format(default_string))
+
         if self.required:
             extra.append('required')
         if extra:
@@ -1649,8 +1758,8 @@ class Option(Parameter):
         if self.is_bool_flag:
             return confirm(self.prompt, default)
 
-        return prompt(self.prompt, default=default,
-                      hide_input=self.hide_input,
+        return prompt(self.prompt, default=default, type=self.type,
+                      hide_input=self.hide_input, show_choices=self.show_choices,
                       confirmation_prompt=self.confirmation_prompt,
                       value_proc=lambda x: self.process_value(ctx, x))
 
@@ -1710,7 +1819,9 @@ class Argument(Parameter):
     def make_metavar(self):
         if self.metavar is not None:
             return self.metavar
-        var = self.name.upper()
+        var = self.type.get_metavar(self)
+        if not var:
+            var = self.name.upper()
         if not self.required:
             var = '[%s]' % var
         if self.nargs != 1:
@@ -1725,16 +1836,17 @@ class Argument(Parameter):
         if len(decls) == 1:
             name = arg = decls[0]
             name = name.replace('-', '_').lower()
-        elif len(decls) == 2:
-            name, arg = decls
         else:
-            raise TypeError('Arguments take exactly one or two '
-                            'parameter declarations, got %d' % len(decls))
+            raise TypeError('Arguments take exactly one '
+                            'parameter declaration, got %d' % len(decls))
         return name, [arg], []
 
     def get_usage_pieces(self, ctx):
         return [self.make_metavar()]
 
+    def get_error_hint(self, ctx):
+        return '"%s"' % self.make_metavar()
+
     def add_to_parser(self, parser, ctx):
         parser.add_argument(dest=self.name, nargs=self.nargs,
                             obj=self)
diff --git a/pipenv/vendor/click/decorators.py b/pipenv/vendor/click/decorators.py
index 98934526..c57c5308 100644
--- a/pipenv/vendor/click/decorators.py
+++ b/pipenv/vendor/click/decorators.py
@@ -61,7 +61,7 @@ def make_pass_decorator(object_type, ensure=False):
                 raise RuntimeError('Managed to invoke callback without a '
                                    'context object of type %r existing'
                                    % object_type.__name__)
-            return ctx.invoke(f, obj, *args[1:], **kwargs)
+            return ctx.invoke(f, obj, *args, **kwargs)
         return update_wrapper(new_func, f)
     return decorator
 
@@ -85,12 +85,12 @@ def _make_command(f, name, attrs, cls):
         help = inspect.cleandoc(help)
     attrs['help'] = help
     _check_for_unicode_literals()
-    return cls(name=name or f.__name__.lower(),
+    return cls(name=name or f.__name__.lower().replace('_', '-'),
                callback=f, params=params, **attrs)
 
 
 def command(name=None, cls=None, **attrs):
-    """Creates a new :class:`Command` and uses the decorated function as
+    r"""Creates a new :class:`Command` and uses the decorated function as
     callback.  This will also automatically attach all decorated
     :func:`option`\s and :func:`argument`\s as parameters to the command.
 
@@ -105,7 +105,7 @@ def command(name=None, cls=None, **attrs):
     command :class:`Group`.
 
     :param name: the name of the command.  This defaults to the function
-                 name.
+                 name with underscores replaced by dashes.
     :param cls: the command class to instantiate.  This defaults to
                 :class:`Command`.
     """
@@ -164,10 +164,13 @@ def option(*param_decls, **attrs):
                 :class:`Option`.
     """
     def decorator(f):
-        if 'help' in attrs:
-            attrs['help'] = inspect.cleandoc(attrs['help'])
-        OptionClass = attrs.pop('cls', Option)
-        _param_memo(f, OptionClass(param_decls, **attrs))
+        # Issue 926, copy attrs, so pre-defined options can re-use the same cls=
+        option_attrs = attrs.copy()
+
+        if 'help' in option_attrs:
+            option_attrs['help'] = inspect.cleandoc(option_attrs['help'])
+        OptionClass = option_attrs.pop('cls', Option)
+        _param_memo(f, OptionClass(param_decls, **option_attrs))
         return f
     return decorator
 
@@ -235,7 +238,11 @@ def version_option(version=None, *param_decls, **attrs):
     :param others: everything else is forwarded to :func:`option`.
     """
     if version is None:
-        module = sys._getframe(1).f_globals.get('__name__')
+        if hasattr(sys, '_getframe'):
+            module = sys._getframe(1).f_globals.get('__name__')
+        else:
+            module = ''
+
     def decorator(f):
         prog_name = attrs.pop('prog_name', None)
         message = attrs.pop('message', '%(prog)s, version %(version)s')
diff --git a/pipenv/vendor/click/exceptions.py b/pipenv/vendor/click/exceptions.py
index 74a4542b..6fa17658 100644
--- a/pipenv/vendor/click/exceptions.py
+++ b/pipenv/vendor/click/exceptions.py
@@ -2,6 +2,12 @@ from ._compat import PY2, filename_to_ui, get_text_stderr
 from .utils import echo
 
 
+def _join_param_hints(param_hint):
+    if isinstance(param_hint, (tuple, list)):
+        return ' / '.join('"%s"' % x for x in param_hint)
+    return param_hint
+
+
 class ClickException(Exception):
     """An exception that Click can handle and show to the user."""
 
@@ -9,15 +15,25 @@ class ClickException(Exception):
     exit_code = 1
 
     def __init__(self, message):
+        ctor_msg = message
         if PY2:
-            if message is not None:
-                message = message.encode('utf-8')
-        Exception.__init__(self, message)
+            if ctor_msg is not None:
+                ctor_msg = ctor_msg.encode('utf-8')
+        Exception.__init__(self, ctor_msg)
         self.message = message
 
     def format_message(self):
         return self.message
 
+    def __str__(self):
+        return self.message
+
+    if PY2:
+        __unicode__ = __str__
+
+        def __str__(self):
+            return self.message.encode('utf-8')
+
     def show(self, file=None):
         if file is None:
             file = get_text_stderr()
@@ -37,14 +53,20 @@ class UsageError(ClickException):
     def __init__(self, message, ctx=None):
         ClickException.__init__(self, message)
         self.ctx = ctx
+        self.cmd = self.ctx and self.ctx.command or None
 
     def show(self, file=None):
         if file is None:
             file = get_text_stderr()
         color = None
+        hint = ''
+        if (self.cmd is not None and
+                self.cmd.get_help_option(self.ctx) is not None):
+            hint = ('Try "%s %s" for help.\n'
+                    % (self.ctx.command_path, self.ctx.help_option_names[0]))
         if self.ctx is not None:
             color = self.ctx.color
-            echo(self.ctx.get_usage() + '\n', file=file, color=color)
+            echo(self.ctx.get_usage() + '\n%s' % hint, file=file, color=color)
         echo('Error: %s' % self.format_message(), file=file, color=color)
 
 
@@ -76,11 +98,11 @@ class BadParameter(UsageError):
         if self.param_hint is not None:
             param_hint = self.param_hint
         elif self.param is not None:
-            param_hint = self.param.opts or [self.param.human_readable_name]
+            param_hint = self.param.get_error_hint(self.ctx)
         else:
             return 'Invalid value: %s' % self.message
-        if isinstance(param_hint, (tuple, list)):
-            param_hint = ' / '.join('"%s"' % x for x in param_hint)
+        param_hint = _join_param_hints(param_hint)
+
         return 'Invalid value for %s: %s' % (param_hint, self.message)
 
 
@@ -105,11 +127,10 @@ class MissingParameter(BadParameter):
         if self.param_hint is not None:
             param_hint = self.param_hint
         elif self.param is not None:
-            param_hint = self.param.opts or [self.param.human_readable_name]
+            param_hint = self.param.get_error_hint(self.ctx)
         else:
             param_hint = None
-        if isinstance(param_hint, (tuple, list)):
-            param_hint = ' / '.join('"%s"' % x for x in param_hint)
+        param_hint = _join_param_hints(param_hint)
 
         param_type = self.param_type
         if param_type is None and self.param is not None:
@@ -164,10 +185,13 @@ class BadOptionUsage(UsageError):
     for an option is not correct.
 
     .. versionadded:: 4.0
+
+    :param option_name: the name of the option being used incorrectly.
     """
 
-    def __init__(self, message, ctx=None):
+    def __init__(self, option_name, message, ctx=None):
         UsageError.__init__(self, message, ctx)
+        self.option_name = option_name
 
 
 class BadArgumentUsage(UsageError):
@@ -199,3 +223,13 @@ class FileError(ClickException):
 
 class Abort(RuntimeError):
     """An internal signalling exception that signals Click to abort."""
+
+
+class Exit(RuntimeError):
+    """An exception that indicates that the application should exit with some
+    status code.
+
+    :param code: the status code to exit with.
+    """
+    def __init__(self, code=0):
+        self.exit_code = code
diff --git a/pipenv/vendor/click/globals.py b/pipenv/vendor/click/globals.py
index 14338e6b..843b594a 100644
--- a/pipenv/vendor/click/globals.py
+++ b/pipenv/vendor/click/globals.py
@@ -9,7 +9,7 @@ def get_current_context(silent=False):
     access the current context object from anywhere.  This is a more implicit
     alternative to the :func:`pass_context` decorator.  This function is
     primarily useful for helpers such as :func:`echo` which might be
-    interested in changing it's behavior based on the current context.
+    interested in changing its behavior based on the current context.
 
     To push the current context, :meth:`Context.scope` can be used.
 
diff --git a/pipenv/vendor/click/parser.py b/pipenv/vendor/click/parser.py
index 9775c9ff..1c3ae9c8 100644
--- a/pipenv/vendor/click/parser.py
+++ b/pipenv/vendor/click/parser.py
@@ -1,20 +1,21 @@
 # -*- coding: utf-8 -*-
 """
-    click.parser
-    ~~~~~~~~~~~~
+click.parser
+~~~~~~~~~~~~
 
-    This module started out as largely a copy paste from the stdlib's
-    optparse module with the features removed that we do not need from
-    optparse because we implement them in Click on a higher level (for
-    instance type handling, help formatting and a lot more).
+This module started out as largely a copy paste from the stdlib's
+optparse module with the features removed that we do not need from
+optparse because we implement them in Click on a higher level (for
+instance type handling, help formatting and a lot more).
 
-    The plan is to remove more and more from here over time.
+The plan is to remove more and more from here over time.
 
-    The reason this is a different module and not optparse from the stdlib
-    is that there are differences in 2.x and 3.x about the error messages
-    generated and optparse in the stdlib uses gettext for no good reason
-    and might cause us issues.
+The reason this is a different module and not optparse from the stdlib
+is that there are differences in 2.x and 3.x about the error messages
+generated and optparse in the stdlib uses gettext for no good reason
+and might cause us issues.
 """
+
 import re
 from collections import deque
 from .exceptions import UsageError, NoSuchOption, BadOptionUsage, \
@@ -74,8 +75,8 @@ def _unpack_args(args, nargs_spec):
 
 def _error_opt_args(nargs, opt):
     if nargs == 1:
-        raise BadOptionUsage('%s option requires an argument' % opt)
-    raise BadOptionUsage('%s option requires %d arguments' % (opt, nargs))
+        raise BadOptionUsage(opt, '%s option requires an argument' % opt)
+    raise BadOptionUsage(opt, '%s option requires %d arguments' % (opt, nargs))
 
 
 def split_opt(opt):
@@ -321,7 +322,7 @@ class OptionParser(object):
         if opt not in self._long_opt:
             possibilities = [word for word in self._long_opt
                              if word.startswith(opt)]
-            raise NoSuchOption(opt, possibilities=possibilities)
+            raise NoSuchOption(opt, possibilities=possibilities, ctx=self.ctx)
 
         option = self._long_opt[opt]
         if option.takes_value:
@@ -342,7 +343,7 @@ class OptionParser(object):
                 del state.rargs[:nargs]
 
         elif explicit_value is not None:
-            raise BadOptionUsage('%s option does not take a value' % opt)
+            raise BadOptionUsage(opt, '%s option does not take a value' % opt)
 
         else:
             value = None
@@ -364,7 +365,7 @@ class OptionParser(object):
                 if self.ignore_unknown_options:
                     unknown_options.append(ch)
                     continue
-                raise NoSuchOption(opt)
+                raise NoSuchOption(opt, ctx=self.ctx)
             if option.takes_value:
                 # Any characters left in arg?  Pretend they're the
                 # next arg, and stop consuming characters of arg.
diff --git a/pipenv/vendor/click/termui.py b/pipenv/vendor/click/termui.py
index d9fba523..bf9a3aa1 100644
--- a/pipenv/vendor/click/termui.py
+++ b/pipenv/vendor/click/termui.py
@@ -1,12 +1,14 @@
 import os
 import sys
 import struct
+import inspect
+import itertools
 
 from ._compat import raw_input, text_type, string_types, \
      isatty, strip_ansi, get_winterm_size, DEFAULT_COLUMNS, WIN
 from .utils import echo
 from .exceptions import Abort, UsageError
-from .types import convert_type
+from .types import convert_type, Choice, Path
 from .globals import resolve_color_default
 
 
@@ -14,8 +16,25 @@ from .globals import resolve_color_default
 # functions to customize how they work.
 visible_prompt_func = raw_input
 
-_ansi_colors = ('black', 'red', 'green', 'yellow', 'blue', 'magenta',
-                'cyan', 'white', 'reset')
+_ansi_colors = {
+    'black': 30,
+    'red': 31,
+    'green': 32,
+    'yellow': 33,
+    'blue': 34,
+    'magenta': 35,
+    'cyan': 36,
+    'white': 37,
+    'reset': 39,
+    'bright_black': 90,
+    'bright_red': 91,
+    'bright_green': 92,
+    'bright_yellow': 93,
+    'bright_blue': 94,
+    'bright_magenta': 95,
+    'bright_cyan': 96,
+    'bright_white': 97,
+}
 _ansi_reset_all = '\033[0m'
 
 
@@ -24,23 +43,27 @@ def hidden_prompt_func(prompt):
     return getpass.getpass(prompt)
 
 
-def _build_prompt(text, suffix, show_default=False, default=None):
+def _build_prompt(text, suffix, show_default=False, default=None, show_choices=True, type=None):
     prompt = text
+    if type is not None and show_choices and isinstance(type, Choice):
+        prompt += ' (' + ", ".join(map(str, type.choices)) + ')'
     if default is not None and show_default:
         prompt = '%s [%s]' % (prompt, default)
     return prompt + suffix
 
 
-def prompt(text, default=None, hide_input=False,
-           confirmation_prompt=False, type=None,
-           value_proc=None, prompt_suffix=': ',
-           show_default=True, err=False):
+def prompt(text, default=None, hide_input=False, confirmation_prompt=False,
+           type=None, value_proc=None, prompt_suffix=': ', show_default=True,
+           err=False, show_choices=True):
     """Prompts a user for input.  This is a convenience function that can
     be used to prompt a user for input later.
 
     If the user aborts the input by sending a interrupt signal, this
     function will catch it and raise a :exc:`Abort` exception.
 
+    .. versionadded:: 7.0
+       Added the show_choices parameter.
+
     .. versionadded:: 6.0
        Added unicode support for cmd.exe on Windows.
 
@@ -61,6 +84,10 @@ def prompt(text, default=None, hide_input=False,
     :param show_default: shows or hides the default value in the prompt.
     :param err: if set to true the file defaults to ``stderr`` instead of
                 ``stdout``, the same as with echo.
+    :param show_choices: Show or hide choices if the passed type is a Choice.
+                         For example if type is a Choice of either day or week,
+                         show_choices is true and text is "Group by" then the
+                         prompt will be "Group by (day, week): ".
     """
     result = None
 
@@ -82,17 +109,18 @@ def prompt(text, default=None, hide_input=False,
     if value_proc is None:
         value_proc = convert_type(type, default)
 
-    prompt = _build_prompt(text, prompt_suffix, show_default, default)
+    prompt = _build_prompt(text, prompt_suffix, show_default, default, show_choices, type)
 
     while 1:
         while 1:
             value = prompt_func(prompt)
             if value:
                 break
-            # If a default is set and used, then the confirmation
-            # prompt is always skipped because that's the only thing
-            # that really makes sense.
             elif default is not None:
+                if isinstance(value_proc, Path):
+                    # validate Path default value(exists, dir_okay etc.)
+                    value = default
+                    break
                 return default
         try:
             result = value_proc(value)
@@ -166,8 +194,14 @@ def get_terminal_size():
             sz = shutil_get_terminal_size()
             return sz.columns, sz.lines
 
+    # We provide a sensible default for get_winterm_size() when being invoked
+    # inside a subprocess. Without this, it would not provide a useful input.
     if get_winterm_size is not None:
-        return get_winterm_size()
+        size = get_winterm_size()
+        if size == (0, 0):
+            return (79, 24)
+        else:
+            return size
 
     def ioctl_gwinsz(fd):
         try:
@@ -195,22 +229,33 @@ def get_terminal_size():
     return int(cr[1]), int(cr[0])
 
 
-def echo_via_pager(text, color=None):
+def echo_via_pager(text_or_generator, color=None):
     """This function takes a text and shows it via an environment specific
     pager on stdout.
 
     .. versionchanged:: 3.0
        Added the `color` flag.
 
-    :param text: the text to page.
+    :param text_or_generator: the text to page, or alternatively, a
+                              generator emitting the text to page.
     :param color: controls if the pager supports ANSI colors or not.  The
                   default is autodetection.
     """
     color = resolve_color_default(color)
-    if not isinstance(text, string_types):
-        text = text_type(text)
+
+    if inspect.isgeneratorfunction(text_or_generator):
+        i = text_or_generator()
+    elif isinstance(text_or_generator, string_types):
+        i = [text_or_generator]
+    else:
+        i = iter(text_or_generator)
+
+    # convert every element of i to a text type if necessary
+    text_generator = (el if isinstance(el, string_types) else text_type(el)
+                      for el in i)
+
     from ._termui_impl import pager
-    return pager(text + '\n', color)
+    return pager(itertools.chain(text_generator, "\n"), color)
 
 
 def progressbar(iterable=None, length=None, label=None, show_eta=True,
@@ -347,10 +392,21 @@ def style(text, fg=None, bg=None, bold=None, dim=None, underline=None,
     * ``magenta``
     * ``cyan``
     * ``white`` (might be light gray)
+    * ``bright_black``
+    * ``bright_red``
+    * ``bright_green``
+    * ``bright_yellow``
+    * ``bright_blue``
+    * ``bright_magenta``
+    * ``bright_cyan``
+    * ``bright_white``
     * ``reset`` (reset the color code only)
 
     .. versionadded:: 2.0
 
+    .. versionadded:: 7.0
+       Added support for bright colors.
+
     :param text: the string to style with ansi codes.
     :param fg: if provided this will become the foreground color.
     :param bg: if provided this will become the background color.
@@ -369,13 +425,13 @@ def style(text, fg=None, bg=None, bold=None, dim=None, underline=None,
     bits = []
     if fg:
         try:
-            bits.append('\033[%dm' % (_ansi_colors.index(fg) + 30))
-        except ValueError:
+            bits.append('\033[%dm' % (_ansi_colors[fg]))
+        except KeyError:
             raise TypeError('Unknown color %r' % fg)
     if bg:
         try:
-            bits.append('\033[%dm' % (_ansi_colors.index(bg) + 40))
-        except ValueError:
+            bits.append('\033[%dm' % (_ansi_colors[bg] + 10))
+        except KeyError:
             raise TypeError('Unknown color %r' % bg)
     if bold is not None:
         bits.append('\033[%dm' % (1 if bold else 22))
@@ -405,7 +461,7 @@ def unstyle(text):
     return strip_ansi(text)
 
 
-def secho(text, file=None, nl=True, err=False, color=None, **styles):
+def secho(message=None, file=None, nl=True, err=False, color=None, **styles):
     """This function combines :func:`echo` and :func:`style` into one
     call.  As such the following two calls are the same::
 
@@ -417,7 +473,9 @@ def secho(text, file=None, nl=True, err=False, color=None, **styles):
 
     .. versionadded:: 2.0
     """
-    return echo(style(text, **styles), file=file, nl=nl, err=err, color=color)
+    if message is not None:
+        message = style(message, **styles)
+    return echo(message, file=file, nl=nl, err=err, color=color)
 
 
 def edit(text=None, editor=None, env=None, require_save=True,
@@ -466,7 +524,7 @@ def launch(url, wait=False, locate=False):
 
     Examples::
 
-        click.launch('http://click.pocoo.org/')
+        click.launch('https://click.palletsprojects.com/')
         click.launch('/my/downloaded/file', locate=True)
 
     .. versionadded:: 2.0
@@ -499,6 +557,10 @@ def getchar(echo=False):
     Note that this will always read from the terminal, even if something
     is piped into the standard input.
 
+    Note for Windows: in rare cases when typing non-ASCII characters, this
+    function might wait for a second character and then return both at once.
+    This is because certain Unicode characters look like special-key markers.
+
     .. versionadded:: 2.0
 
     :param echo: if set to `True`, the character read will also show up on
@@ -510,6 +572,11 @@ def getchar(echo=False):
     return f(echo)
 
 
+def raw_terminal():
+    from ._termui_impl import raw_terminal as f
+    return f()
+
+
 def pause(info='Press any key to continue ...', err=False):
     """This command stops execution and waits for the user to press any
     key to continue.  This is similar to the Windows batch "pause"
diff --git a/pipenv/vendor/click/testing.py b/pipenv/vendor/click/testing.py
index 4416c774..1b2924e0 100644
--- a/pipenv/vendor/click/testing.py
+++ b/pipenv/vendor/click/testing.py
@@ -3,8 +3,9 @@ import sys
 import shutil
 import tempfile
 import contextlib
+import shlex
 
-from ._compat import iteritems, PY2
+from ._compat import iteritems, PY2, string_types
 
 
 # If someone wants to vendor click, we want to ensure the
@@ -72,27 +73,44 @@ def make_input_stream(input, charset):
 class Result(object):
     """Holds the captured result of an invoked CLI script."""
 
-    def __init__(self, runner, output_bytes, exit_code, exception,
-                 exc_info=None):
+    def __init__(self, runner, stdout_bytes, stderr_bytes, exit_code,
+                 exception, exc_info=None):
         #: The runner that created the result
         self.runner = runner
-        #: The output as bytes.
-        self.output_bytes = output_bytes
+        #: The standard output as bytes.
+        self.stdout_bytes = stdout_bytes
+        #: The standard error as bytes, or False(y) if not available
+        self.stderr_bytes = stderr_bytes
         #: The exit code as integer.
         self.exit_code = exit_code
-        #: The exception that happend if one did.
+        #: The exception that happened if one did.
         self.exception = exception
         #: The traceback
         self.exc_info = exc_info
 
     @property
     def output(self):
-        """The output as unicode string."""
-        return self.output_bytes.decode(self.runner.charset, 'replace') \
+        """The (standard) output as unicode string."""
+        return self.stdout
+
+    @property
+    def stdout(self):
+        """The standard output as unicode string."""
+        return self.stdout_bytes.decode(self.runner.charset, 'replace') \
             .replace('\r\n', '\n')
 
+    @property
+    def stderr(self):
+        """The standard error as unicode string."""
+        if not self.stderr_bytes:
+            raise ValueError("stderr not separately captured")
+        return self.stderr_bytes.decode(self.runner.charset, 'replace') \
+            .replace('\r\n', '\n')
+
+
     def __repr__(self):
-        return '<Result %s>' % (
+        return '<%s %s>' % (
+            type(self).__name__,
             self.exception and repr(self.exception) or 'okay',
         )
 
@@ -111,14 +129,21 @@ class CliRunner(object):
                        to stdout.  This is useful for showing examples in
                        some circumstances.  Note that regular prompts
                        will automatically echo the input.
+    :param mix_stderr: if this is set to `False`, then stdout and stderr are
+                       preserved as independent streams.  This is useful for
+                       Unix-philosophy apps that have predictable stdout and
+                       noisy stderr, such that each may be measured
+                       independently
     """
 
-    def __init__(self, charset=None, env=None, echo_stdin=False):
+    def __init__(self, charset=None, env=None, echo_stdin=False,
+                 mix_stderr=True):
         if charset is None:
             charset = 'utf-8'
         self.charset = charset
         self.env = env or {}
         self.echo_stdin = echo_stdin
+        self.mix_stderr = mix_stderr
 
     def get_default_prog_name(self, cli):
         """Given a command object it will return the default program name
@@ -163,16 +188,27 @@ class CliRunner(object):
         env = self.make_env(env)
 
         if PY2:
-            sys.stdout = sys.stderr = bytes_output = StringIO()
+            bytes_output = StringIO()
             if self.echo_stdin:
                 input = EchoingStdin(input, bytes_output)
+            sys.stdout = bytes_output
+            if not self.mix_stderr:
+                bytes_error = StringIO()
+                sys.stderr = bytes_error
         else:
             bytes_output = io.BytesIO()
             if self.echo_stdin:
                 input = EchoingStdin(input, bytes_output)
             input = io.TextIOWrapper(input, encoding=self.charset)
-            sys.stdout = sys.stderr = io.TextIOWrapper(
+            sys.stdout = io.TextIOWrapper(
                 bytes_output, encoding=self.charset)
+            if not self.mix_stderr:
+                bytes_error = io.BytesIO()
+                sys.stderr = io.TextIOWrapper(
+                    bytes_error, encoding=self.charset)
+
+        if self.mix_stderr:
+            sys.stderr = sys.stdout
 
         sys.stdin = input
 
@@ -196,6 +232,7 @@ class CliRunner(object):
             return char
 
         default_color = color
+
         def should_strip_ansi(stream=None, color=None):
             if color is None:
                 return not default_color
@@ -221,7 +258,7 @@ class CliRunner(object):
                         pass
                 else:
                     os.environ[key] = value
-            yield bytes_output
+            yield (bytes_output, not self.mix_stderr and bytes_error)
         finally:
             for key, value in iteritems(old_env):
                 if value is None:
@@ -241,7 +278,7 @@ class CliRunner(object):
             clickpkg.formatting.FORCED_WIDTH = old_forced_width
 
     def invoke(self, cli, args=None, input=None, env=None,
-               catch_exceptions=True, color=False, **extra):
+               catch_exceptions=True, color=False, mix_stderr=False, **extra):
         """Invokes a command in an isolated environment.  The arguments are
         forwarded directly to the command line script, the `extra` keyword
         arguments are passed to the :meth:`~clickpkg.Command.main` function of
@@ -260,7 +297,10 @@ class CliRunner(object):
            The ``color`` parameter was added.
 
         :param cli: the command to invoke
-        :param args: the arguments to invoke
+        :param args: the arguments to invoke. It may be given as an iterable
+                     or a string. When given as string it will be interpreted
+                     as a Unix shell command. More details at
+                     :func:`shlex.split`.
         :param input: the input data for `sys.stdin`.
         :param env: the environment overrides.
         :param catch_exceptions: Whether to catch any other exceptions than
@@ -270,36 +310,48 @@ class CliRunner(object):
                       application can still override this explicitly.
         """
         exc_info = None
-        with self.isolation(input=input, env=env, color=color) as out:
+        with self.isolation(input=input, env=env, color=color) as outstreams:
             exception = None
             exit_code = 0
 
+            if isinstance(args, string_types):
+                args = shlex.split(args)
+
             try:
-                cli.main(args=args or (),
-                         prog_name=self.get_default_prog_name(cli), **extra)
+                prog_name = extra.pop("prog_name")
+            except KeyError:
+                prog_name = self.get_default_prog_name(cli)
+
+            try:
+                cli.main(args=args or (), prog_name=prog_name, **extra)
             except SystemExit as e:
-                if e.code != 0:
+                exc_info = sys.exc_info()
+                exit_code = e.code
+                if exit_code is None:
+                    exit_code = 0
+
+                if exit_code != 0:
                     exception = e
 
-                exc_info = sys.exc_info()
-
-                exit_code = e.code
                 if not isinstance(exit_code, int):
                     sys.stdout.write(str(exit_code))
                     sys.stdout.write('\n')
                     exit_code = 1
+
             except Exception as e:
                 if not catch_exceptions:
                     raise
                 exception = e
-                exit_code = -1
+                exit_code = 1
                 exc_info = sys.exc_info()
             finally:
                 sys.stdout.flush()
-                output = out.getvalue()
+                stdout = outstreams[0].getvalue()
+                stderr = outstreams[1] and outstreams[1].getvalue()
 
         return Result(runner=self,
-                      output_bytes=output,
+                      stdout_bytes=stdout,
+                      stderr_bytes=stderr,
                       exit_code=exit_code,
                       exception=exception,
                       exc_info=exc_info)
diff --git a/pipenv/vendor/click/types.py b/pipenv/vendor/click/types.py
index 36390026..1f88032f 100644
--- a/pipenv/vendor/click/types.py
+++ b/pipenv/vendor/click/types.py
@@ -1,5 +1,6 @@
 import os
 import stat
+from datetime import datetime
 
 from ._compat import open_stream, text_type, filename_to_ui, \
     get_filesystem_encoding, get_streerror, _get_argv_encoding, PY2
@@ -126,34 +127,54 @@ class StringParamType(ParamType):
 
 
 class Choice(ParamType):
-    """The choice type allows a value to be checked against a fixed set of
-    supported values.  All of these values have to be strings.
+    """The choice type allows a value to be checked against a fixed set
+    of supported values. All of these values have to be strings.
+
+    You should only pass a list or tuple of choices. Other iterables
+    (like generators) may lead to surprising results.
 
     See :ref:`choice-opts` for an example.
+
+    :param case_sensitive: Set to false to make choices case
+        insensitive. Defaults to true.
     """
+
     name = 'choice'
 
-    def __init__(self, choices):
+    def __init__(self, choices, case_sensitive=True):
         self.choices = choices
+        self.case_sensitive = case_sensitive
 
     def get_metavar(self, param):
         return '[%s]' % '|'.join(self.choices)
 
     def get_missing_message(self, param):
-        return 'Choose from %s.' % ', '.join(self.choices)
+        return 'Choose from:\n\t%s.' % ',\n\t'.join(self.choices)
 
     def convert(self, value, param, ctx):
         # Exact match
         if value in self.choices:
             return value
 
-        # Match through normalization
+        # Match through normalization and case sensitivity
+        # first do token_normalize_func, then lowercase
+        # preserve original `value` to produce an accurate message in
+        # `self.fail`
+        normed_value = value
+        normed_choices = self.choices
+
         if ctx is not None and \
            ctx.token_normalize_func is not None:
-            value = ctx.token_normalize_func(value)
-            for choice in self.choices:
-                if ctx.token_normalize_func(choice) == value:
-                    return choice
+            normed_value = ctx.token_normalize_func(value)
+            normed_choices = [ctx.token_normalize_func(choice) for choice in
+                              self.choices]
+
+        if not self.case_sensitive:
+            normed_value = normed_value.lower()
+            normed_choices = [choice.lower() for choice in normed_choices]
+
+        if normed_value in normed_choices:
+            return normed_value
 
         self.fail('invalid choice: %s. (choose from %s)' %
                   (value, ', '.join(self.choices)), param, ctx)
@@ -162,6 +183,59 @@ class Choice(ParamType):
         return 'Choice(%r)' % list(self.choices)
 
 
+class DateTime(ParamType):
+    """The DateTime type converts date strings into `datetime` objects.
+
+    The format strings which are checked are configurable, but default to some
+    common (non-timezone aware) ISO 8601 formats.
+
+    When specifying *DateTime* formats, you should only pass a list or a tuple.
+    Other iterables, like generators, may lead to surprising results.
+
+    The format strings are processed using ``datetime.strptime``, and this
+    consequently defines the format strings which are allowed.
+
+    Parsing is tried using each format, in order, and the first format which
+    parses successfully is used.
+
+    :param formats: A list or tuple of date format strings, in the order in
+                    which they should be tried. Defaults to
+                    ``'%Y-%m-%d'``, ``'%Y-%m-%dT%H:%M:%S'``,
+                    ``'%Y-%m-%d %H:%M:%S'``.
+    """
+    name = 'datetime'
+
+    def __init__(self, formats=None):
+        self.formats = formats or [
+            '%Y-%m-%d',
+            '%Y-%m-%dT%H:%M:%S',
+            '%Y-%m-%d %H:%M:%S'
+        ]
+
+    def get_metavar(self, param):
+        return '[{}]'.format('|'.join(self.formats))
+
+    def _try_to_convert_date(self, value, format):
+        try:
+            return datetime.strptime(value, format)
+        except ValueError:
+            return None
+
+    def convert(self, value, param, ctx):
+        # Exact match
+        for format in self.formats:
+            dtime = self._try_to_convert_date(value, format)
+            if dtime:
+                return dtime
+
+        self.fail(
+            'invalid datetime format: {}. (choose from {})'.format(
+                value, ', '.join(self.formats)))
+
+    def __repr__(self):
+        return 'DateTime'
+
+
 class IntParamType(ParamType):
     name = 'integer'
 
@@ -214,23 +288,6 @@ class IntRange(IntParamType):
         return 'IntRange(%r, %r)' % (self.min, self.max)
 
 
-class BoolParamType(ParamType):
-    name = 'boolean'
-
-    def convert(self, value, param, ctx):
-        if isinstance(value, bool):
-            return bool(value)
-        value = value.lower()
-        if value in ('true', '1', 'yes', 'y'):
-            return True
-        elif value in ('false', '0', 'no', 'n'):
-            return False
-        self.fail('%s is not a valid boolean' % value, param, ctx)
-
-    def __repr__(self):
-        return 'BOOL'
-
-
 class FloatParamType(ParamType):
     name = 'float'
 
@@ -245,6 +302,62 @@ class FloatParamType(ParamType):
         return 'FLOAT'
 
 
+class FloatRange(FloatParamType):
+    """A parameter that works similar to :data:`click.FLOAT` but restricts
+    the value to fit into a range.  The default behavior is to fail if the
+    value falls outside the range, but it can also be silently clamped
+    between the two edges.
+
+    See :ref:`ranges` for an example.
+    """
+    name = 'float range'
+
+    def __init__(self, min=None, max=None, clamp=False):
+        self.min = min
+        self.max = max
+        self.clamp = clamp
+
+    def convert(self, value, param, ctx):
+        rv = FloatParamType.convert(self, value, param, ctx)
+        if self.clamp:
+            if self.min is not None and rv < self.min:
+                return self.min
+            if self.max is not None and rv > self.max:
+                return self.max
+        if self.min is not None and rv < self.min or \
+           self.max is not None and rv > self.max:
+            if self.min is None:
+                self.fail('%s is bigger than the maximum valid value '
+                          '%s.' % (rv, self.max), param, ctx)
+            elif self.max is None:
+                self.fail('%s is smaller than the minimum valid value '
+                          '%s.' % (rv, self.min), param, ctx)
+            else:
+                self.fail('%s is not in the valid range of %s to %s.'
+                          % (rv, self.min, self.max), param, ctx)
+        return rv
+
+    def __repr__(self):
+        return 'FloatRange(%r, %r)' % (self.min, self.max)
+
+
+class BoolParamType(ParamType):
+    name = 'boolean'
+
+    def convert(self, value, param, ctx):
+        if isinstance(value, bool):
+            return bool(value)
+        value = value.lower()
+        if value in ('true', 't', '1', 'yes', 'y'):
+            return True
+        elif value in ('false', 'f', '0', 'no', 'n'):
+            return False
+        self.fail('%s is not a valid boolean' % value, param, ctx)
+
+    def __repr__(self):
+        return 'BOOL'
+
+
 class UUIDParameterType(ParamType):
     name = 'uuid'
 
@@ -273,9 +386,12 @@ class File(ParamType):
     opened in binary mode or for writing.  The encoding parameter can be used
     to force a specific encoding.
 
-    The `lazy` flag controls if the file should be opened immediately or
-    upon first IO.  The default is to be non lazy for standard input and
-    output streams as well as files opened for reading, lazy otherwise.
+    The `lazy` flag controls if the file should be opened immediately or upon
+    first IO. The default is to be non-lazy for standard input and output
+    streams as well as files opened for reading, `lazy` otherwise. When opening a
+    file lazily for reading, it is still opened temporarily for validation, but
+    will not be held open until first IO. lazy is mainly useful when opening
+    for writing to avoid creating the file until it is needed.
 
     Starting with Click 2.0, files can also be opened atomically in which
     case all writes go into a separate file in the same folder and upon
@@ -358,14 +474,16 @@ class Path(ParamType):
     :param readable: if true, a readable check is performed.
     :param resolve_path: if this is true, then the path is fully resolved
                          before the value is passed onwards.  This means
-                         that it's absolute and symlinks are resolved.
+                         that it's absolute and symlinks are resolved.  It
+                         will not expand a tilde-prefix, as this is
+                         supposed to be done by the shell only.
     :param allow_dash: If this is set to `True`, a single dash to indicate
                        standard streams is permitted.
-    :param type: optionally a string type that should be used to
-                 represent the path.  The default is `None` which
-                 means the return value will be either bytes or
-                 unicode depending on what makes most sense given the
-                 input data Click deals with.
+    :param path_type: optionally a string type that should be used to
+                      represent the path.  The default is `None` which
+                      means the return value will be either bytes or
+                      unicode depending on what makes most sense given the
+                      input data Click deals with.
     """
     envvar_list_splitter = os.path.pathsep
 
@@ -384,7 +502,7 @@ class Path(ParamType):
         if self.file_okay and not self.dir_okay:
             self.name = 'file'
             self.path_type = 'File'
-        if self.dir_okay and not self.file_okay:
+        elif self.dir_okay and not self.file_okay:
             self.name = 'directory'
             self.path_type = 'Directory'
         else:
diff --git a/pipenv/vendor/click/utils.py b/pipenv/vendor/click/utils.py
index eee626d3..fc84369f 100644
--- a/pipenv/vendor/click/utils.py
+++ b/pipenv/vendor/click/utils.py
@@ -43,6 +43,7 @@ def make_str(value):
 
 
 def make_default_short_help(help, max_length=45):
+    """Return a condensed version of help string."""
     words = help.split()
     total_length = 0
     result = []
@@ -171,7 +172,7 @@ def echo(message=None, file=None, nl=True, err=False, color=None):
 
     Primarily it means that you can print binary data as well as Unicode
     data on both 2.x and 3.x to the given file in the most appropriate way
-    possible.  This is a very carefree function as in that it will try its
+    possible.  This is a very carefree function in that it will try its
     best to not fail.  As of Click 6.0 this includes support for unicode
     output on the Windows console.
 
@@ -183,7 +184,7 @@ def echo(message=None, file=None, nl=True, err=False, color=None):
     -   hide ANSI codes automatically if the destination file is not a
         terminal.
 
-    .. _colorama: http://pypi.python.org/pypi/colorama
+    .. _colorama: https://pypi.org/project/colorama/
 
     .. versionchanged:: 6.0
        As of Click 6.0 the echo function will properly support unicode
@@ -413,3 +414,27 @@ def get_app_dir(app_name, roaming=True, force_posix=False):
     return os.path.join(
         os.environ.get('XDG_CONFIG_HOME', os.path.expanduser('~/.config')),
         _posixify(app_name))
+
+
+class PacifyFlushWrapper(object):
+    """This wrapper is used to catch and suppress BrokenPipeErrors resulting
+    from ``.flush()`` being called on broken pipe during the shutdown/final-GC
+    of the Python interpreter. Notably ``.flush()`` is always called on
+    ``sys.stdout`` and ``sys.stderr``. So as to have minimal impact on any
+    other cleanup code, and the case where the underlying file is not a broken
+    pipe, all calls and attributes are proxied.
+    """
+
+    def __init__(self, wrapped):
+        self.wrapped = wrapped
+
+    def flush(self):
+        try:
+            self.wrapped.flush()
+        except IOError as e:
+            import errno
+            if e.errno != errno.EPIPE:
+                raise
+
+    def __getattr__(self, attr):
+        return getattr(self.wrapped, attr)
diff --git a/pipenv/vendor/cursor/LICENSE b/pipenv/vendor/cursor/LICENSE
new file mode 100644
index 00000000..00023c80
--- /dev/null
+++ b/pipenv/vendor/cursor/LICENSE
@@ -0,0 +1,5 @@
+This work is licensed under the Creative Commons
+Attribution-ShareAlike 2.5 International License. To view a copy of 
+this license, visit http://creativecommons.org/licenses/by-sa/2.5/ or
+send a letter to Creative Commons, PO Box 1866, Mountain View, 
+CA 94042, USA.
diff --git a/pipenv/vendor/cursor/__init__.py b/pipenv/vendor/cursor/__init__.py
new file mode 100644
index 00000000..76a4f671
--- /dev/null
+++ b/pipenv/vendor/cursor/__init__.py
@@ -0,0 +1,4 @@
+from .cursor import hide, show, HiddenCursor
+
+__all__ = ["hide", "show", "HiddenCursor"]
+
diff --git a/pipenv/vendor/cursor/cursor.py b/pipenv/vendor/cursor/cursor.py
new file mode 100644
index 00000000..e4407c02
--- /dev/null
+++ b/pipenv/vendor/cursor/cursor.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+
+## Author:          James Spencer: http://stackoverflow.com/users/1375885/james-spencer
+## Packager:        Gijs TImmers:  https://github.com/GijsTimmers
+
+## Based on James Spencer's answer on StackOverflow: 
+## http://stackoverflow.com/questions/5174810/how-to-turn-off-blinking-cursor-in-command-window
+
+## Licence:         CC-BY-SA-2.5
+##                  http://creativecommons.org/licenses/by-sa/2.5/
+
+## This work is licensed under the Creative Commons
+## Attribution-ShareAlike 2.5 International License. To  view a copy of
+## this license, visit http://creativecommons.org/licenses/by-sa/2.5/ or
+## send a letter to Creative Commons, PO Box 1866, Mountain View,
+## CA 94042, USA.
+
+import sys
+import os
+
+if os.name == 'nt':
+    import ctypes
+
+    class _CursorInfo(ctypes.Structure):
+        _fields_ = [("size", ctypes.c_int),
+                    ("visible", ctypes.c_byte)]
+
+def hide(stream=sys.stdout):
+    if os.name == 'nt':
+        ci = _CursorInfo()
+        handle = ctypes.windll.kernel32.GetStdHandle(-11)
+        ctypes.windll.kernel32.GetConsoleCursorInfo(handle, ctypes.byref(ci))
+        ci.visible = False
+        ctypes.windll.kernel32.SetConsoleCursorInfo(handle, ctypes.byref(ci))
+    elif os.name == 'posix':
+        stream.write("\033[?25l")
+        stream.flush()
+
+def show(stream=sys.stdout):
+    if os.name == 'nt':
+        ci = _CursorInfo()
+        handle = ctypes.windll.kernel32.GetStdHandle(-11)
+        ctypes.windll.kernel32.GetConsoleCursorInfo(handle, ctypes.byref(ci))
+        ci.visible = True
+        ctypes.windll.kernel32.SetConsoleCursorInfo(handle, ctypes.byref(ci))
+    elif os.name == 'posix':
+        stream.write("\033[?25h")
+        stream.flush()
+        
+class HiddenCursor(object):
+    def __init__(self, stream=sys.stdout):
+        self._stream = stream
+    def __enter__(self):
+        hide(stream=self._stream)
+    def __exit__(self, type, value, traceback):
+        show(stream=self._stream)
\ No newline at end of file
diff --git a/pipenv/vendor/delegator.py b/pipenv/vendor/delegator.py
index 5820db7b..cf6f91c8 100644
--- a/pipenv/vendor/delegator.py
+++ b/pipenv/vendor/delegator.py
@@ -4,19 +4,50 @@ import shlex
 import signal
 import sys
 import locale
+import errno
 
 from pexpect.popen_spawn import PopenSpawn
+import pexpect
+pexpect.EOF.__module__ = "pexpect.exceptions"
 
 # Include `unicode` in STR_TYPES for Python 2.X
 try:
     STR_TYPES = (str, unicode)
 except NameError:
-    STR_TYPES = (str, )
+    STR_TYPES = (str,)
 
 TIMEOUT = 30
 
-class Command(object):
 
+def pid_exists(pid):
+    """Check whether pid exists in the current process table."""
+    if pid == 0:
+        # According to "man 2 kill" PID 0 has a special meaning:
+        # it refers to <<every process in the process group of the
+        # calling process>> so we don't want to go any further.
+        # If we get here it means this UNIX platform *does* have
+        # a process with id 0.
+        return True
+    try:
+        os.kill(pid, 0)
+    except OSError as err:
+        if err.errno == errno.ESRCH:
+            # ESRCH == No such process
+            return False
+        elif err.errno == errno.EPERM:
+            # EPERM clearly means there's a process to deny access to
+            return True
+        else:
+            # According to "man 2 kill" possible error values are
+            # (EINVAL, EPERM, ESRCH) therefore we should never get
+            # here. If we do let's be explicit in considering this
+            # an error.
+            raise err
+    else:
+        return True
+
+
+class Command(object):
     def __init__(self, cmd, timeout=TIMEOUT):
         super(Command, self).__init__()
         self.cmd = cmd
@@ -28,7 +59,7 @@ class Command(object):
         self.__err = None
 
     def __repr__(self):
-        return '<Command {!r}>'.format(self.cmd)
+        return "<Command {!r}>".format(self.cmd)
 
     @property
     def _popen_args(self):
@@ -37,27 +68,23 @@ class Command(object):
     @property
     def _default_popen_kwargs(self):
         return {
-            'env': os.environ.copy(),
-            'stdin': subprocess.PIPE,
-            'stdout': subprocess.PIPE,
-            'stderr': subprocess.PIPE,
-            'shell': True,
-            'universal_newlines': True,
-            'bufsize': 0
+            "env": os.environ.copy(),
+            "stdin": subprocess.PIPE,
+            "stdout": subprocess.PIPE,
+            "stderr": subprocess.PIPE,
+            "shell": True,
+            "universal_newlines": True,
+            "bufsize": 0,
         }
 
     @property
     def _default_pexpect_kwargs(self):
-        encoding = 'utf-8'
-        if sys.platform == 'win32':
+        encoding = "utf-8"
+        if sys.platform == "win32":
             default_encoding = locale.getdefaultlocale()[1]
             if default_encoding is not None:
                 encoding = default_encoding
-        return {
-            'env': os.environ.copy(),
-            'encoding': encoding,
-            'timeout': self.timeout
-        }
+        return {"env": os.environ.copy(), "encoding": encoding, "timeout": self.timeout}
 
     @property
     def _uses_subprocess(self):
@@ -71,18 +98,25 @@ class Command(object):
     def std_out(self):
         return self.subprocess.stdout
 
+    @property
+    def ok(self):
+        return self.return_code == 0
+
     @property
     def _pexpect_out(self):
         if self.subprocess.encoding:
-            result = ''
+            result = ""
         else:
-            result = b''
+            result = b""
 
         if self.subprocess.before:
             result += self.subprocess.before
 
-        if self.subprocess.after:
-            result += self.subprocess.after
+        if self.subprocess.after and self.subprocess.after is not pexpect.EOF:
+            try:
+                result += self.subprocess.after
+            except (pexpect.EOF, pexpect.TIMEOUT):
+                pass
 
         result += self.subprocess.read()
         return result
@@ -120,11 +154,16 @@ class Command(object):
     def pid(self):
         """The process' PID."""
         # Support for pexpect's functionality.
-        if hasattr(self.subprocess, 'proc'):
+        if hasattr(self.subprocess, "proc"):
             return self.subprocess.proc.pid
         # Standard subprocess method.
         return self.subprocess.pid
 
+    @property
+    def is_alive(self):
+        """Is the process alive?"""
+        return pid_exists(self.pid)
+
     @property
     def return_code(self):
         # Support for pexpect's functionality.
@@ -144,23 +183,24 @@ class Command(object):
         # Use subprocess.
         if self.blocking:
             popen_kwargs = self._default_popen_kwargs.copy()
-            popen_kwargs['universal_newlines'] = not binary
+            del popen_kwargs["stdin"]
+            popen_kwargs["universal_newlines"] = not binary
             if cwd:
-                popen_kwargs['cwd'] = cwd
+                popen_kwargs["cwd"] = cwd
             if env:
-                popen_kwargs['env'].update(env)
+                popen_kwargs["env"].update(env)
             s = subprocess.Popen(self._popen_args, **popen_kwargs)
         # Otherwise, use pexpect.
         else:
             pexpect_kwargs = self._default_pexpect_kwargs.copy()
             if binary:
-                pexpect_kwargs['encoding'] = None
+                pexpect_kwargs["encoding"] = None
             if cwd:
-                pexpect_kwargs['cwd'] = cwd
+                pexpect_kwargs["cwd"] = cwd
             if env:
-                pexpect_kwargs['env'].update(env)
+                pexpect_kwargs["env"].update(env)
             # Enable Python subprocesses to work with expect functionality.
-            pexpect_kwargs['env']['PYTHONUNBUFFERED'] = '1'
+            pexpect_kwargs["env"]["PYTHONUNBUFFERED"] = "1"
             s = PopenSpawn(self._popen_args, **pexpect_kwargs)
         self.subprocess = s
         self.was_run = True
@@ -169,15 +209,18 @@ class Command(object):
         """Waits on the given pattern to appear in std_out"""
 
         if self.blocking:
-            raise RuntimeError('expect can only be used on non-blocking commands.')
+            raise RuntimeError("expect can only be used on non-blocking commands.")
 
-        self.subprocess.expect(pattern=pattern, timeout=timeout)
+        try:
+            self.subprocess.expect(pattern=pattern, timeout=timeout)
+        except pexpect.EOF:
+            pass
 
     def send(self, s, end=os.linesep, signal=False):
         """Sends the given string or signal to std_in."""
 
         if self.blocking:
-            raise RuntimeError('send can only be used on non-blocking commands.')
+            raise RuntimeError("send can only be used on non-blocking commands.")
 
         if not signal:
             if self._uses_subprocess:
@@ -191,20 +234,34 @@ class Command(object):
         self.subprocess.terminate()
 
     def kill(self):
-        self.subprocess.kill(signal.SIGINT)
+        if self._uses_pexpect:
+            self.subprocess.kill(signal.SIGINT)
+        else:
+            self.subprocess.send_signal(signal.SIGINT)
 
     def block(self):
         """Blocks until process is complete."""
         if self._uses_subprocess:
             # consume stdout and stderr
-            try:
-                stdout, stderr = self.subprocess.communicate()
-                self.__out = stdout
-                self.__err = stderr
-            except ValueError:
-                pass  # Don't read from finished subprocesses.
+            if self.blocking:
+                try:
+                    stdout, stderr = self.subprocess.communicate()
+                    self.__out = stdout
+                    self.__err = stderr
+                except ValueError:
+                    pass  # Don't read from finished subprocesses.
+            else:
+                self.subprocess.stdin.close()
+                self.std_out.close()
+                self.std_err.close()
+                self.subprocess.wait()
         else:
-            self.subprocess.wait()
+            self.subprocess.sendeof()
+            try:
+                self.subprocess.wait()
+            finally:
+                if self.subprocess.proc.stdout:
+                    self.subprocess.proc.stdout.close()
 
     def pipe(self, command, timeout=None, cwd=None):
         """Runs the current command and passes its output to the next
@@ -226,7 +283,6 @@ class Command(object):
         c.run(block=False, cwd=cwd)
         if data:
             c.send(data)
-            c.subprocess.sendeof()
         c.block()
         return c
 
@@ -237,12 +293,12 @@ def _expand_args(command):
     # Prepare arguments.
     if isinstance(command, STR_TYPES):
         if sys.version_info[0] == 2:
-            splitter = shlex.shlex(command.encode('utf-8'))
+            splitter = shlex.shlex(command.encode("utf-8"))
         elif sys.version_info[0] == 3:
             splitter = shlex.shlex(command)
         else:
-            splitter = shlex.shlex(command.encode('utf-8'))
-        splitter.whitespace = '|'
+            splitter = shlex.shlex(command.encode("utf-8"))
+        splitter.whitespace = "|"
         splitter.whitespace_split = True
         command = []
 
@@ -283,4 +339,3 @@ def run(command, block=True, binary=False, timeout=TIMEOUT, cwd=None, env=None):
         c.block()
 
     return c
-
diff --git a/pipenv/vendor/distlib/__init__.py b/pipenv/vendor/distlib/__init__.py
index d4aab453..a786b4d3 100644
--- a/pipenv/vendor/distlib/__init__.py
+++ b/pipenv/vendor/distlib/__init__.py
@@ -6,7 +6,7 @@
 #
 import logging
 
-__version__ = '0.2.7'
+__version__ = '0.2.8'
 
 class DistlibException(Exception):
     pass
diff --git a/pipenv/vendor/distlib/database.py b/pipenv/vendor/distlib/database.py
index a19905e2..b13cdac9 100644
--- a/pipenv/vendor/distlib/database.py
+++ b/pipenv/vendor/distlib/database.py
@@ -20,7 +20,8 @@ import zipimport
 from . import DistlibException, resources
 from .compat import StringIO
 from .version import get_scheme, UnsupportedVersionError
-from .metadata import Metadata, METADATA_FILENAME, WHEEL_METADATA_FILENAME
+from .metadata import (Metadata, METADATA_FILENAME, WHEEL_METADATA_FILENAME,
+                       LEGACY_METADATA_FILENAME)
 from .util import (parse_requirement, cached_property, parse_name_and_version,
                    read_exports, write_exports, CSVReader, CSVWriter)
 
@@ -132,7 +133,9 @@ class DistributionPath(object):
                 if not r or r.path in seen:
                     continue
                 if self._include_dist and entry.endswith(DISTINFO_EXT):
-                    possible_filenames = [METADATA_FILENAME, WHEEL_METADATA_FILENAME]
+                    possible_filenames = [METADATA_FILENAME,
+                                          WHEEL_METADATA_FILENAME,
+                                          LEGACY_METADATA_FILENAME]
                     for metadata_filename in possible_filenames:
                         metadata_path = posixpath.join(entry, metadata_filename)
                         pydist = finder.find(metadata_path)
diff --git a/pipenv/vendor/distlib/locators.py b/pipenv/vendor/distlib/locators.py
index 11d26361..5c655c3e 100644
--- a/pipenv/vendor/distlib/locators.py
+++ b/pipenv/vendor/distlib/locators.py
@@ -255,7 +255,9 @@ class Locator(object):
         if path.endswith('.whl'):
             try:
                 wheel = Wheel(path)
-                if is_compatible(wheel, self.wheel_tags):
+                if not is_compatible(wheel, self.wheel_tags):
+                    logger.debug('Wheel not compatible: %s', path)
+                else:
                     if project_name is None:
                         include = True
                     else:
@@ -613,6 +615,7 @@ class SimpleScrapingLocator(Locator):
         # as it is for coordinating our internal threads - the ones created
         # in _prepare_threads.
         self._gplock = threading.RLock()
+        self.platform_check = False  # See issue #112
 
     def _prepare_threads(self):
         """
@@ -658,8 +661,8 @@ class SimpleScrapingLocator(Locator):
             del self.result
         return result
 
-    platform_dependent = re.compile(r'\b(linux-(i\d86|x86_64|arm\w+)|'
-                                    r'win(32|-amd64)|macosx-?\d+)\b', re.I)
+    platform_dependent = re.compile(r'\b(linux_(i\d86|x86_64|arm\w+)|'
+                                    r'win(32|_amd64)|macosx_?\d+)\b', re.I)
 
     def _is_platform_dependent(self, url):
         """
@@ -677,7 +680,7 @@ class SimpleScrapingLocator(Locator):
         Note that the return value isn't actually used other than as a boolean
         value.
         """
-        if self._is_platform_dependent(url):
+        if self.platform_check and self._is_platform_dependent(url):
             info = None
         else:
             info = self.convert_url_to_download_info(url, self.project_name)
diff --git a/pipenv/vendor/distlib/metadata.py b/pipenv/vendor/distlib/metadata.py
index 6d6470ff..77eed7f9 100644
--- a/pipenv/vendor/distlib/metadata.py
+++ b/pipenv/vendor/distlib/metadata.py
@@ -91,7 +91,9 @@ _426_FIELDS = ('Metadata-Version', 'Name', 'Version', 'Platform',
 _426_MARKERS = ('Private-Version', 'Provides-Extra', 'Obsoleted-By',
                 'Setup-Requires-Dist', 'Extension')
 
-_566_FIELDS = _426_FIELDS + ('Description-Content-Type',)
+# See issue #106: Sometimes 'Requires' occurs wrongly in the metadata. Include
+# it in the tuple literal below to allow it (for now)
+_566_FIELDS = _426_FIELDS + ('Description-Content-Type', 'Requires')
 
 _566_MARKERS = ('Description-Content-Type',)
 
@@ -377,8 +379,8 @@ class LegacyMetadata(object):
                 value = msg[field]
                 if value is not None and value != 'UNKNOWN':
                     self.set(field, value)
-        logger.debug('Attempting to set metadata for %s', self)
-        self.set_metadata_version()
+        # logger.debug('Attempting to set metadata for %s', self)
+        # self.set_metadata_version()
 
     def write(self, filepath, skip_unknown=False):
         """Write the metadata fields to filepath."""
@@ -648,6 +650,7 @@ class LegacyMetadata(object):
 
 METADATA_FILENAME = 'pydist.json'
 WHEEL_METADATA_FILENAME = 'metadata.json'
+LEGACY_METADATA_FILENAME = 'METADATA'
 
 
 class Metadata(object):
diff --git a/pipenv/vendor/distlib/scripts.py b/pipenv/vendor/distlib/scripts.py
index 0b7c3d0b..8e22cb91 100644
--- a/pipenv/vendor/distlib/scripts.py
+++ b/pipenv/vendor/distlib/scripts.py
@@ -236,8 +236,10 @@ class ScriptMaker(object):
     def _write_script(self, names, shebang, script_bytes, filenames, ext):
         use_launcher = self.add_launchers and self._is_nt
         linesep = os.linesep.encode('utf-8')
+        if not shebang.endswith(linesep):
+            shebang += linesep
         if not use_launcher:
-            script_bytes = shebang + linesep + script_bytes
+            script_bytes = shebang + script_bytes
         else:  # pragma: no cover
             if ext == 'py':
                 launcher = self._get_launcher('t')
@@ -247,7 +249,7 @@ class ScriptMaker(object):
             with ZipFile(stream, 'w') as zf:
                 zf.writestr('__main__.py', script_bytes)
             zip_data = stream.getvalue()
-            script_bytes = launcher + shebang + linesep + zip_data
+            script_bytes = launcher + shebang + zip_data
         for name in names:
             outname = os.path.join(self.target_dir, name)
             if use_launcher:  # pragma: no cover
diff --git a/pipenv/vendor/distlib/util.py b/pipenv/vendor/distlib/util.py
index 0b14a93b..9d4bfd3b 100644
--- a/pipenv/vendor/distlib/util.py
+++ b/pipenv/vendor/distlib/util.py
@@ -545,16 +545,14 @@ class FileOperator(object):
     def write_binary_file(self, path, data):
         self.ensure_dir(os.path.dirname(path))
         if not self.dry_run:
+            if os.path.exists(path):
+                os.remove(path)
             with open(path, 'wb') as f:
                 f.write(data)
         self.record_as_written(path)
 
     def write_text_file(self, path, data, encoding):
-        self.ensure_dir(os.path.dirname(path))
-        if not self.dry_run:
-            with open(path, 'wb') as f:
-                f.write(data.encode(encoding))
-        self.record_as_written(path)
+        self.write_binary_file(path, data.encode(encoding))
 
     def set_mode(self, bits, mask, files):
         if os.name == 'posix' or (os.name == 'java' and os._name == 'posix'):
@@ -582,7 +580,7 @@ class FileOperator(object):
             if self.record:
                 self.dirs_created.add(path)
 
-    def byte_compile(self, path, optimize=False, force=False, prefix=None):
+    def byte_compile(self, path, optimize=False, force=False, prefix=None, hashed_invalidation=False):
         dpath = cache_from_source(path, not optimize)
         logger.info('Byte-compiling %s to %s', path, dpath)
         if not self.dry_run:
@@ -592,7 +590,10 @@ class FileOperator(object):
                 else:
                     assert path.startswith(prefix)
                     diagpath = path[len(prefix):]
-            py_compile.compile(path, dpath, diagpath, True)     # raise error
+            compile_kwargs = {}
+            if hashed_invalidation and hasattr(py_compile, 'PycInvalidationMode'):
+                compile_kwargs['invalidation_mode'] = py_compile.PycInvalidationMode.CHECKED_HASH
+            py_compile.compile(path, dpath, diagpath, True, **compile_kwargs)     # raise error
         self.record_as_written(dpath)
         return dpath
 
diff --git a/pipenv/vendor/distlib/wheel.py b/pipenv/vendor/distlib/wheel.py
index 77372235..b04bfaef 100644
--- a/pipenv/vendor/distlib/wheel.py
+++ b/pipenv/vendor/distlib/wheel.py
@@ -442,7 +442,9 @@ class Wheel(object):
         This can be used to issue any warnings to raise any exceptions.
         If kwarg ``lib_only`` is True, only the purelib/platlib files are
         installed, and the headers, scripts, data and dist-info metadata are
-        not written.
+        not written. If kwarg ``bytecode_hashed_invalidation`` is True, written
+        bytecode will try to use file-hash based invalidation (PEP-552) on
+        supported interpreter versions (CPython 2.7+).
 
         The return value is a :class:`InstalledDistribution` instance unless
         ``options.lib_only`` is True, in which case the return value is ``None``.
@@ -451,6 +453,7 @@ class Wheel(object):
         dry_run = maker.dry_run
         warner = kwargs.get('warner')
         lib_only = kwargs.get('lib_only', False)
+        bc_hashed_invalidation = kwargs.get('bytecode_hashed_invalidation', False)
 
         pathname = os.path.join(self.dirname, self.filename)
         name_ver = '%s-%s' % (self.name, self.version)
@@ -557,7 +560,8 @@ class Wheel(object):
                                                            '%s' % outfile)
                         if bc and outfile.endswith('.py'):
                             try:
-                                pyc = fileop.byte_compile(outfile)
+                                pyc = fileop.byte_compile(outfile,
+                                                          hashed_invalidation=bc_hashed_invalidation)
                                 outfiles.append(pyc)
                             except Exception:
                                 # Don't give up if byte-compilation fails,
diff --git a/pipenv/vendor/modutil.LICENSE b/pipenv/vendor/modutil.LICENSE
deleted file mode 100644
index f680f071..00000000
--- a/pipenv/vendor/modutil.LICENSE
+++ /dev/null
@@ -1,29 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2018, Brett Cannon
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-* Neither the name of the copyright holder nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/pipenv/vendor/modutil.py b/pipenv/vendor/modutil.py
deleted file mode 100644
index d68f4851..00000000
--- a/pipenv/vendor/modutil.py
+++ /dev/null
@@ -1,145 +0,0 @@
-"""Help for working with modules."""
-__version__ = "2.0.0"
-
-import importlib
-import importlib.machinery
-import importlib.util
-import types
-
-
-STANDARD_MODULE_ATTRS = frozenset(['__all__', '__builtins__', '__cached__',
-                                   '__doc__', '__file__', '__loader__',
-                                   '__name__', '__package__', '__spec__',
-                                   '__getattr__'])
-
-
-class ModuleAttributeError(AttributeError):
-    """An AttributeError specifically for modules.
-
-    The module_name and 'attribute' attributes are set to strings representing
-    the module the attribute was searched on and the missing attribute,
-    respectively.
-
-    """
-
-    def __init__(self, module_name, attribute):
-        self.module_name = module_name
-        self.attribute = attribute
-        super().__init__(f"module {module_name!r} has no attribute {attribute!r}")
-
-
-
-def lazy_import(module_name, to_import):
-    """Return the importing module and a callable for lazy importing.
-
-    The module named by module_name represents the module performing the
-    import to help facilitate resolving relative imports.
-
-    to_import is an iterable of the modules to be potentially imported (absolute
-    or relative). The `as` form of importing is also supported,
-    e.g. `pkg.mod as spam`.
-
-    This function returns a tuple of two items. The first is the importer
-    module for easy reference within itself. The second item is a callable to be
-    set to `__getattr__`.
-    """
-    module = importlib.import_module(module_name)
-    import_mapping = {}
-    for name in to_import:
-        importing, _, binding = name.partition(' as ')
-        if not binding:
-            _, _, binding = importing.rpartition('.')
-        import_mapping[binding] = importing
-
-    def __getattr__(name):
-        if name not in import_mapping:
-            raise ModuleAttributeError(module_name, name)
-        importing = import_mapping[name]
-        # imortlib.import_module() implicitly sets submodules on this module as
-        # appropriate for direct imports.
-        imported = importlib.import_module(importing,
-                                           module.__spec__.parent)
-        setattr(module, name, imported)
-        return imported
-
-    return module, __getattr__
-
-
-def filtered_attrs(module, *, modules=False, private=False, dunder=False,
-                   common=False):
-    """Return a collection of attributes on 'module'.
-
-    If 'modules' is false then module instances are excluded. If 'private' is
-    false then attributes starting with, but not ending in, '_' will be
-    excluded. With 'dunder' set to false then attributes starting and ending
-    with '_' are left out. The 'common' argument controls whether attributes
-    found in STANDARD_MODULE_ATTRS are returned.
-
-    """
-    attr_names = set()
-    for name, value in module.__dict__.items():
-        if not common and name in STANDARD_MODULE_ATTRS:
-            continue
-        if name.startswith('_'):
-            if name.endswith('_'):
-                if not dunder:
-                    continue
-            elif not private:
-                continue
-        if not modules and isinstance(value, types.ModuleType):
-            continue
-        attr_names.add(name)
-    return frozenset(attr_names)
-
-
-def calc___all__(module_name, **kwargs):
-    """Return a sorted list of defined attributes on 'module_name'.
-
-    All values specified in **kwargs are directly passed to filtered_attrs().
-
-    """
-    module = importlib.import_module(module_name)
-    return sorted(filtered_attrs(module, **kwargs))
-
-
-def filtered_dir(module_name, *, additions={}, **kwargs):
-    """Return a callable appropriate for __dir__().
-
-    All values specified in **kwargs get passed directly to filtered_attrs().
-    The 'additions' argument should be an iterable which is added to the final
-    results.
-
-    """
-    module = importlib.import_module(module_name)
-
-    def __dir__():
-        attr_names = set(filtered_attrs(module, **kwargs))
-        attr_names.update(additions)
-        return sorted(attr_names)
-
-    return __dir__
-
-
-def chained___getattr__(module_name, *getattrs):
-    """Create a callable which calls each __getattr__ in sequence.
-
-    Any raised ModuleAttributeError which matches module_name and the
-    attribute being searched for will be caught and the search will continue.
-    All other exceptions will be allowed to propagate. If no callable
-    successfully returns a value, ModuleAttributeError will be raised.
-
-    """
-    def __getattr__(name):
-        """Call each __getattr__ function in sequence."""
-        for getattr_ in getattrs:
-            try:
-                return getattr_(name)
-            except ModuleAttributeError as exc:
-                if exc.module_name == module_name and exc.attribute == name:
-                    continue
-                else:
-                    raise
-        else:
-            raise ModuleAttributeError(module_name, name)
-
-    return __getattr__
diff --git a/pipenv/vendor/packaging/__about__.py b/pipenv/vendor/packaging/__about__.py
index 4255c5b5..21fc6ce3 100644
--- a/pipenv/vendor/packaging/__about__.py
+++ b/pipenv/vendor/packaging/__about__.py
@@ -12,10 +12,10 @@ __title__ = "packaging"
 __summary__ = "Core utilities for Python packages"
 __uri__ = "https://github.com/pypa/packaging"
 
-__version__ = "17.1"
+__version__ = "18.0"
 
 __author__ = "Donald Stufft and individual contributors"
 __email__ = "donald@stufft.io"
 
 __license__ = "BSD or Apache License, Version 2.0"
-__copyright__ = "Copyright 2014-2016 %s" % __author__
+__copyright__ = "Copyright 2014-2018 %s" % __author__
diff --git a/pipenv/vendor/packaging/requirements.py b/pipenv/vendor/packaging/requirements.py
index f87c57cc..e8008a6d 100644
--- a/pipenv/vendor/packaging/requirements.py
+++ b/pipenv/vendor/packaging/requirements.py
@@ -92,16 +92,16 @@ class Requirement(object):
         try:
             req = REQUIREMENT.parseString(requirement_string)
         except ParseException as e:
-            raise InvalidRequirement(
-                "Invalid requirement, parse error at \"{0!r}\"".format(
-                    requirement_string[e.loc:e.loc + 8]))
+            raise InvalidRequirement("Parse error at \"{0!r}\": {1}".format(
+                requirement_string[e.loc:e.loc + 8], e.msg
+            ))
 
         self.name = req.name
         if req.url:
             parsed_url = urlparse.urlparse(req.url)
             if not (parsed_url.scheme and parsed_url.netloc) or (
                     not parsed_url.scheme and not parsed_url.netloc):
-                raise InvalidRequirement("Invalid URL given")
+                raise InvalidRequirement("Invalid URL: {0}".format(req.url))
             self.url = req.url
         else:
             self.url = None
diff --git a/pipenv/vendor/packaging/specifiers.py b/pipenv/vendor/packaging/specifiers.py
index 9b6353f0..4c798999 100644
--- a/pipenv/vendor/packaging/specifiers.py
+++ b/pipenv/vendor/packaging/specifiers.py
@@ -503,7 +503,7 @@ class Specifier(_IndividualSpecifier):
                 return False
 
         # Ensure that we do not allow a local version of the version mentioned
-        # in the specifier, which is techincally greater than, to match.
+        # in the specifier, which is technically greater than, to match.
         if prospective.local is not None:
             if Version(prospective.base_version) == Version(spec.base_version):
                 return False
diff --git a/pipenv/vendor/parse.py b/pipenv/vendor/parse.py
index ba58decb..7f9f0786 100644
--- a/pipenv/vendor/parse.py
+++ b/pipenv/vendor/parse.py
@@ -186,6 +186,19 @@ And messing about with alignment:
 Note that the "center" alignment does not test to make sure the value is
 centered - it just strips leading and trailing whitespace.
 
+Width and precision may be used to restrict the size of matched text
+from the input. Width specifies a minimum size and precision specifies
+a maximum. For example:
+
+>>> parse('{:.2}{:.2}', 'look')           # specifying precision
+<Result ('lo', 'ok') {}>
+>>> parse('{:4}{:4}', 'look at that')     # specifying width
+<Result ('look', 'at that') {}>
+>>> parse('{:4}{:.4}', 'look at that')    # specifying both
+<Result ('look at ', 'that') {}>
+>>> parse('{:2d}{:2d}', '0440')           # parsing two contiguous numbers
+<Result (4, 40) {}>
+
 Some notes for the date and time types:
 
 - the presence of the time part is optional (including ISO 8601, starting
@@ -329,6 +342,9 @@ the pattern, the actual match represents the shortest successful match for
 
 **Version history (in brief)**:
 
+- 1.9.0 We now honor precision and width specifiers when parsing numbers
+  and strings, allowing parsing of concatenated elements of fixed width
+  (thanks Julia Signell)
 - 1.8.4 Add LICENSE file at request of packagers.
   Correct handling of AM/PM to follow most common interpretation.
   Correct parsing of hexadecimal that looks like a binary prefix.
@@ -389,7 +405,7 @@ See the end of the source file for the license of use.
 '''
 
 from __future__ import absolute_import
-__version__ = '1.8.4'
+__version__ = '1.9.0'
 
 # yes, I now have two problems
 import re
@@ -977,7 +993,11 @@ class Parser(object):
             self._group_index += 2
             self._type_conversions[group] = lambda s, m: float(s)
         elif type == 'd':
-            s = r'\d+|0[xX][0-9a-fA-F]+|0[bB][01]+|0[oO][0-7]+'
+            if format.get('width'):
+                width = '{1,%s}' % int(format['width'])
+            else:
+                width = '+'
+            s = '\\d{w}|0[xX][0-9a-fA-F]{w}|0[bB][01]{w}|0[oO][0-7]{w}'.format(w=width)
             self._type_conversions[group] = int_convert(10)
         elif type == 'ti':
             s = r'(\d{4}-\d\d-\d\d)((\s+|T)%s)?(Z|\s*[-+]\d\d:?\d\d)?' % \
@@ -1038,6 +1058,13 @@ class Parser(object):
 
         elif type:
             s = r'\%s+' % type
+        elif format.get('precision'):
+            if format.get('width'):
+                s = '.{%s,%s}?' % (format['width'], format['precision'])
+            else:
+                s = '.{1,%s}?' % format['precision']
+        elif format.get('width'):
+            s = '.{%s,}?' % format['width']
         else:
             s = '.+?'
 
@@ -1053,8 +1080,6 @@ class Parser(object):
                 if not fill:
                     fill = '0'
                 s = '%s*' % fill + s
-            elif format['zero']:
-                s = '0*' + s
 
             # allow numbers to be prefixed with a sign
             s = r'[-+ ]?' + s
diff --git a/pipenv/vendor/passa/LICENSE b/pipenv/vendor/passa/LICENSE
new file mode 100644
index 00000000..cd41e272
--- /dev/null
+++ b/pipenv/vendor/passa/LICENSE
@@ -0,0 +1,13 @@
+Copyright (c) 2018, Dan Ryan <dan@danryan.co> and Tzu-ping Chung <uranusjr@gmail.com>
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/pipenv/vendor/passa/__init__.py b/pipenv/vendor/passa/__init__.py
new file mode 100644
index 00000000..ea633f0a
--- /dev/null
+++ b/pipenv/vendor/passa/__init__.py
@@ -0,0 +1,7 @@
+# -*- coding=utf-8 -*-
+
+__all__ = [
+    '__version__'
+]
+
+__version__ = '0.3.1.dev0'
diff --git a/pipenv/vendor/passa/__main__.py b/pipenv/vendor/passa/__main__.py
new file mode 100644
index 00000000..76c2e6a6
--- /dev/null
+++ b/pipenv/vendor/passa/__main__.py
@@ -0,0 +1,6 @@
+# -*- coding=utf-8 -*-
+
+from .cli import main
+
+if __name__ == '__main__':
+    main()
diff --git a/pipenv/vendor/passa/actions/__init__.py b/pipenv/vendor/passa/actions/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/pipenv/vendor/passa/actions/add.py b/pipenv/vendor/passa/actions/add.py
new file mode 100644
index 00000000..63384667
--- /dev/null
+++ b/pipenv/vendor/passa/actions/add.py
@@ -0,0 +1,57 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+import itertools
+import sys
+
+
+def add_packages(packages=[], editables=[], project=None, dev=False, sync=False, clean=False):
+    from passa.models.lockers import PinReuseLocker
+    from passa.operations.lock import lock
+
+    lines = list(itertools.chain(
+        packages,
+        ("-e {}".format(e) for e in editables),
+    ))
+
+    project = project
+    for line in lines:
+        try:
+            project.add_line_to_pipfile(line, develop=dev)
+        except (TypeError, ValueError) as e:
+            print("Cannot add {line!r} to Pipfile: {error}".format(
+                line=line, error=str(e),
+            ), file=sys.stderr)
+            return 2
+
+    prev_lockfile = project.lockfile
+
+    locker = PinReuseLocker(project)
+    success = lock(locker)
+    if not success:
+        return 1
+
+    project._p.write()
+    project._l.write()
+    print("Written to project at", project.root)
+
+    if not sync:
+        return
+
+    from passa.models.synchronizers import Synchronizer
+    from passa.operations.sync import sync
+
+    lockfile_diff = project.difference_lockfile(prev_lockfile)
+    default = any(lockfile_diff.default)
+    develop = any(lockfile_diff.develop)
+
+    syncer = Synchronizer(
+        project, default=default, develop=develop,
+        clean_unneeded=clean,
+    )
+    success = sync(syncer)
+    if not success:
+        return 1
+
+    print("Synchronized project at", project.root)
diff --git a/pipenv/vendor/passa/actions/clean.py b/pipenv/vendor/passa/actions/clean.py
new file mode 100644
index 00000000..3570e4db
--- /dev/null
+++ b/pipenv/vendor/passa/actions/clean.py
@@ -0,0 +1,16 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+
+def clean(project, dev=False):
+    from passa.models.synchronizers import Cleaner
+    from passa.operations.sync import clean
+
+    cleaner = Cleaner(project, default=True, develop=dev)
+
+    success = clean(cleaner)
+    if not success:
+        return 1
+
+    print("Cleaned project at", project.root)
diff --git a/pipenv/vendor/passa/actions/freeze.py b/pipenv/vendor/passa/actions/freeze.py
new file mode 100644
index 00000000..ca4dbb2a
--- /dev/null
+++ b/pipenv/vendor/passa/actions/freeze.py
@@ -0,0 +1,93 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+import contextlib
+import io
+import itertools
+import sys
+
+import vistir.misc
+
+
+def _source_as_lines(source, extra):
+    url = source["url"]
+    if extra:
+        lines = ["--extra-index-url {}".format(url)]
+    else:
+        lines = ["--index-url {}".format(url)]
+    if not source.get("verify_ssl", True):
+        lines = ["--trusted-host {}".format(url)]
+    return lines
+
+
+def _requirement_as_line(requirement, sources, include_hashes):
+    if requirement.index:
+        sources = sources
+    else:
+        sources = None
+    line = vistir.misc.to_text(
+        requirement.as_line(sources=sources, include_hashes=include_hashes)
+    )
+    return line
+
+
+@contextlib.contextmanager
+def open_for_output(filename):
+    if filename is None:
+        yield sys.stdout
+        return
+    with io.open(filename, "w", encoding="utf-8", newline="\n") as f:
+        yield f
+
+
+def freeze(project=None, default=True, dev=True, include_hashes=None, target=None):
+    from requirementslib import Requirement
+
+    lockfile = project.lockfile
+    if not lockfile:
+        print("Pipfile.lock is required to export.", file=sys.stderr)
+        return 1
+
+    section_names = []
+    if default:
+        section_names.append("default")
+    if dev:
+        section_names.append("develop")
+    requirements = [
+        Requirement.from_pipfile(key, entry._data)
+        for key, entry in itertools.chain.from_iterable(
+            lockfile.get(name, {}).items()
+            for name in section_names
+        )
+    ]
+
+    if include_hashes is None:
+        include_hashes = all(r.is_named for r in requirements)
+
+    sources = lockfile.meta.sources._data
+
+    source_lines = list(vistir.misc.dedup(itertools.chain(
+        itertools.chain.from_iterable(
+            _source_as_lines(source, False)
+            for source in sources[:1]
+        ),
+        itertools.chain.from_iterable(
+            _source_as_lines(source, True)
+            for source in sources[1:]
+        ),
+    )))
+
+    requirement_lines = sorted(vistir.misc.dedup(
+        _requirement_as_line(requirement, sources, include_hashes)
+        for requirement in requirements
+    ))
+
+    with open_for_output(target) as f:
+        for line in source_lines:
+            f.write(line)
+            f.write("\n")
+        f.write("\n")
+        for line in requirement_lines:
+            f.write(line)
+            f.write("\n")
diff --git a/pipenv/vendor/passa/actions/init.py b/pipenv/vendor/passa/actions/init.py
new file mode 100644
index 00000000..1d9f5923
--- /dev/null
+++ b/pipenv/vendor/passa/actions/init.py
@@ -0,0 +1,59 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+import io
+import os
+from pip_shims import Command as PipCommand, cmdoptions
+import plette
+import six
+import vistir
+
+
+class PipCmd(PipCommand):
+    name = "PipCmd"
+
+
+def get_sources(urls, trusted_hosts):
+    trusted_hosts = [six.moves.urllib.parse.urlparse(url).netloc for url in trusted_hosts]
+    sources = []
+    for url in urls:
+        parsed_url = six.moves.urllib.parse.urlparse(url)
+        netloc = parsed_url.netloc
+        if '@' in netloc:
+            _, _, netloc = netloc.rpartition('@')
+        name, _, _ = netloc.partition('.')  # Just use the domain name as the source name
+        verify_ssl = True
+        if netloc in trusted_hosts:
+            verify_ssl = False
+        sources.append({"url": url, "name": name, "verify_ssl": verify_ssl})
+    return sources
+
+
+def init_project(root=None, python_version=None):
+    pipfile_path = os.path.join(root, "Pipfile")
+    if os.path.isfile(pipfile_path):
+        raise RuntimeError("{0!r} is already a Pipfile project".format(root))
+    if not os.path.exists(root):
+        vistir.path.mkdir_p(root, mode=0o755)
+    pip_command = PipCmd()
+    cmdoptions.make_option_group(cmdoptions.index_group, pip_command.parser)
+    parsed, _ = pip_command.parser.parse_args([])
+    index_urls = [parsed.index_url] + parsed.extra_index_urls
+    sources = get_sources(index_urls, parsed.trusted_hosts)
+    data = {
+        "sources": sources,
+        "packages": {},
+        "dev-packages": {},
+    }
+    if python_version:
+        data["requires"] = {"python_version": python_version}
+    return create_project(pipfile_path=pipfile_path, data=data)
+
+
+def create_project(pipfile_path, data={}):
+    pipfile = plette.pipfiles.Pipfile(data=data)
+    with io.open(pipfile_path, "w") as fh:
+        pipfile.dump(fh)
+    print("Successfully created new pipfile at {0!r}".format(pipfile_path))
+    return 0
diff --git a/pipenv/vendor/passa/actions/install.py b/pipenv/vendor/passa/actions/install.py
new file mode 100644
index 00000000..1728dae5
--- /dev/null
+++ b/pipenv/vendor/passa/actions/install.py
@@ -0,0 +1,32 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+
+def install(project=None, check=True, dev=False, clean=True):
+    from passa.models.lockers import BasicLocker
+    from passa.operations.lock import lock
+
+    project = project
+
+    if not check or not project.is_synced():
+        locker = BasicLocker(project)
+        success = lock(locker)
+        if not success:
+            return 1
+        project._l.write()
+        print("Written to project at", project.root)
+
+    from passa.models.synchronizers import Synchronizer
+    from passa.operations.sync import sync
+
+    syncer = Synchronizer(
+        project, default=True, develop=dev,
+        clean_unneeded=clean,
+    )
+
+    success = sync(syncer)
+    if not success:
+        return 1
+
+    print("Synchronized project at", project.root)
diff --git a/pipenv/vendor/passa/actions/lock.py b/pipenv/vendor/passa/actions/lock.py
new file mode 100644
index 00000000..7c094695
--- /dev/null
+++ b/pipenv/vendor/passa/actions/lock.py
@@ -0,0 +1,17 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+
+def lock(project=None):
+    from passa.models.lockers import BasicLocker
+    from passa.operations.lock import lock
+
+    project = project
+    locker = BasicLocker(project)
+    success = lock(locker)
+    if not success:
+        return
+
+    project._l.write()
+    print("Written to project at", project.root)
diff --git a/pipenv/vendor/passa/actions/remove.py b/pipenv/vendor/passa/actions/remove.py
new file mode 100644
index 00000000..158f5e69
--- /dev/null
+++ b/pipenv/vendor/passa/actions/remove.py
@@ -0,0 +1,38 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+
+def remove(project=None, only="default", packages=[], clean=True):
+    from passa.models.lockers import PinReuseLocker
+    from passa.operations.lock import lock
+
+    default = (only != "dev")
+    develop = (only != "default")
+
+    project = project
+    project.remove_keys_from_pipfile(
+        packages, default=default, develop=develop,
+    )
+
+    locker = PinReuseLocker(project)
+    success = lock(locker)
+    if not success:
+        return 1
+
+    project._p.write()
+    project._l.write()
+    print("Written to project at", project.root)
+
+    if not clean:
+        return
+
+    from passa.models.synchronizers import Cleaner
+    from passa.operations.sync import clean
+
+    cleaner = Cleaner(project, default=True, develop=True)
+    success = clean(cleaner)
+    if not success:
+        return 1
+
+    print("Cleaned project at", project.root)
diff --git a/pipenv/vendor/passa/actions/sync.py b/pipenv/vendor/passa/actions/sync.py
new file mode 100644
index 00000000..23e36eeb
--- /dev/null
+++ b/pipenv/vendor/passa/actions/sync.py
@@ -0,0 +1,20 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+
+def sync(project=None, dev=False, clean=True):
+    from passa.models.synchronizers import Synchronizer
+    from passa.operations.sync import sync
+
+    project = project
+    syncer = Synchronizer(
+        project, default=True, develop=dev,
+        clean_unneeded=clean,
+    )
+
+    success = sync(syncer)
+    if not success:
+        return 1
+
+    print("Synchronized project at", project.root)
diff --git a/pipenv/vendor/passa/actions/upgrade.py b/pipenv/vendor/passa/actions/upgrade.py
new file mode 100644
index 00000000..fb3ad7f5
--- /dev/null
+++ b/pipenv/vendor/passa/actions/upgrade.py
@@ -0,0 +1,52 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+import sys
+
+
+def upgrade(project=None, strategy="only-if-needed", sync=True, packages=[]):
+    from passa.models.lockers import EagerUpgradeLocker, PinReuseLocker
+    from passa.operations.lock import lock
+
+    for package in packages:
+        if not project.contains_key_in_pipfile(package):
+            print("{package!r} not found in Pipfile".format(
+                package=package,
+            ), file=sys.stderr)
+            return 2
+
+    project.remove_keys_from_lockfile(packages)
+
+    prev_lockfile = project.lockfile
+
+    if strategy == "eager":
+        locker = EagerUpgradeLocker(project, packages)
+    else:
+        locker = PinReuseLocker(project)
+    success = lock(locker)
+    if not success:
+        return 1
+
+    project._l.write()
+    print("Written to project at", project.root)
+
+    if not sync:
+        return
+
+    from passa.operations.sync import sync
+    from passa.models.synchronizers import Synchronizer
+
+    lockfile_diff = project.difference_lockfile(prev_lockfile)
+    default = bool(any(lockfile_diff.default))
+    develop = bool(any(lockfile_diff.develop))
+
+    syncer = Synchronizer(
+        project, default=default, develop=develop,
+        clean_unneeded=False,
+    )
+    success = sync(syncer)
+    if not success:
+        return 1
+
+    print("Synchronized project at", project.root)
diff --git a/pipenv/vendor/passa/cli/__init__.py b/pipenv/vendor/passa/cli/__init__.py
new file mode 100644
index 00000000..b6891d38
--- /dev/null
+++ b/pipenv/vendor/passa/cli/__init__.py
@@ -0,0 +1,49 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+import argparse
+import importlib
+import pkgutil
+import sys
+
+from passa import __version__
+
+
+CURRENT_MODULE_PATH = sys.modules[__name__].__path__
+
+
+def main(argv=None):
+    root_parser = argparse.ArgumentParser(
+        prog="passa",
+        description="Pipfile project management tool.",
+    )
+    root_parser.add_argument(
+        "--version",
+        action="version",
+        version="%(prog)s, version {}".format(__version__),
+        help="show the version and exit",
+    )
+
+    subparsers = root_parser.add_subparsers()
+    for _, name, _ in pkgutil.iter_modules(CURRENT_MODULE_PATH, "."):
+        module = importlib.import_module(name, __name__)
+        try:
+            klass = module.Command
+        except AttributeError:
+            continue
+        parser = subparsers.add_parser(klass.name, help=klass.description)
+        command = klass(parser)
+        parser.set_defaults(func=command.run)
+
+    options = root_parser.parse_args(argv)
+
+    try:
+        f = options.func
+    except AttributeError:
+        root_parser.print_help()
+        result = -1
+    else:
+        result = f(options)
+    if result is not None:
+        sys.exit(result)
diff --git a/pipenv/vendor/passa/cli/_base.py b/pipenv/vendor/passa/cli/_base.py
new file mode 100644
index 00000000..0ca48682
--- /dev/null
+++ b/pipenv/vendor/passa/cli/_base.py
@@ -0,0 +1,61 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+import argparse
+import os
+import sys
+
+from .options import project
+
+
+class BaseCommand(object):
+    """A CLI command.
+    """
+    name = None
+    description = None
+    default_arguments = [project]
+    arguments = []
+
+    def __init__(self, parser=None):
+        if not parser:
+            parser = argparse.ArgumentParser(
+                prog=os.path.basename(sys.argv[0]),
+                description="Base argument parser for passa"
+            )
+        self.parser = parser
+        self.add_arguments()
+
+    @classmethod
+    def build_parser(cls):
+        parser = argparse.ArgumentParser(
+            prog="passa {}".format(cls.name),
+            description=cls.description,
+        )
+        return cls(parser)
+
+    @classmethod
+    def run_parser(cls):
+        parser = cls.build_parser()
+        parser()
+
+    def __call__(self, argv=None):
+        options = self.parser.parse_args(argv)
+        result = self.main(options)
+        if result is not None:
+            sys.exit(result)
+
+    def add_default_arguments(self):
+        for arg in self.default_arguments:
+            arg.add_to_parser(self.parser)
+
+    def add_arguments(self):
+        self.add_default_arguments()
+        for arg in self.arguments:
+            arg.add_to_parser(self.parser)
+
+    def main(self, options):
+        return self.run(options)
+
+    def run(self, options):
+        raise NotImplementedError
diff --git a/pipenv/vendor/passa/cli/add.py b/pipenv/vendor/passa/cli/add.py
new file mode 100644
index 00000000..d5596cde
--- /dev/null
+++ b/pipenv/vendor/passa/cli/add.py
@@ -0,0 +1,28 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+from ..actions.add import add_packages
+from ._base import BaseCommand
+from .options import package_group
+
+
+class Command(BaseCommand):
+
+    name = "add"
+    description = "Add packages to project."
+    arguments = [package_group]
+
+    def run(self, options):
+        if not options.editables and not options.packages:
+            self.parser.error("Must supply either a requirement or --editable")
+        return add_packages(
+            packages=options.packages,
+            editables=options.editables,
+            project=options.project,
+            dev=options.dev
+        )
+
+
+if __name__ == "__main__":
+    Command.run_parser()
diff --git a/pipenv/vendor/passa/cli/clean.py b/pipenv/vendor/passa/cli/clean.py
new file mode 100644
index 00000000..e23d5ee5
--- /dev/null
+++ b/pipenv/vendor/passa/cli/clean.py
@@ -0,0 +1,21 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+from ..actions.clean import clean
+from ._base import BaseCommand
+from .options import dev, no_default
+
+
+class Command(BaseCommand):
+
+    name = "clean"
+    description = "Uninstall unlisted packages from the environment."
+    arguments = [dev, no_default]
+
+    def run(self, options):
+        return clean(project=options.project, default=options.default, dev=options.dev)
+
+
+if __name__ == "__main__":
+    Command.run_parser()
diff --git a/pipenv/vendor/passa/cli/freeze.py b/pipenv/vendor/passa/cli/freeze.py
new file mode 100644
index 00000000..053c7273
--- /dev/null
+++ b/pipenv/vendor/passa/cli/freeze.py
@@ -0,0 +1,24 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+from ..actions.freeze import freeze
+from ._base import BaseCommand
+from .options import dev, include_hashes_group, no_default, target
+
+
+class Command(BaseCommand):
+
+    name = "freeze"
+    description = "Export project depenencies to requirements.txt."
+    arguments = [dev, no_default, target, include_hashes_group]
+
+    def run(self, options):
+        return freeze(
+            project=options.project, default=options.default, dev=options.dev,
+            include_hashes=options.include_hashes
+        )
+
+
+if __name__ == "__main__":
+    Command.run_parser()
diff --git a/pipenv/vendor/passa/cli/init.py b/pipenv/vendor/passa/cli/init.py
new file mode 100644
index 00000000..95ce8d84
--- /dev/null
+++ b/pipenv/vendor/passa/cli/init.py
@@ -0,0 +1,32 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+import argparse
+import os
+
+from ..actions.init import init_project
+from ._base import BaseCommand
+from .options import new_project_group
+
+
+class Command(BaseCommand):
+
+    name = "init"
+    description = "Create a new project."
+    default_arguments = []
+    arguments = [new_project_group]
+
+    def run(self, options):
+        pipfile_path = os.path.join(options.project, "Pipfile")
+        if os.path.exists(pipfile_path):
+            raise argparse.ArgumentError(
+                "{0!r} is already a Pipfile project".format(options.project),
+            )
+        return init_project(
+            root=options.project, python_version=options.python_version
+        )
+
+
+if __name__ == "__main__":
+    Command.run_parser()
diff --git a/pipenv/vendor/passa/cli/install.py b/pipenv/vendor/passa/cli/install.py
new file mode 100644
index 00000000..1c0b4591
--- /dev/null
+++ b/pipenv/vendor/passa/cli/install.py
@@ -0,0 +1,22 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+from ..actions.install import install
+from ._base import BaseCommand
+from .options import dev, no_check, no_clean
+
+
+class Command(BaseCommand):
+
+    name = "install"
+    description = "Generate Pipfile.lock to synchronize the environment."
+    arguments = [no_check, dev, no_clean]
+
+    def run(self, options):
+        return install(project=options.project, check=options.check, dev=options.dev,
+                            clean=options.clean)
+
+
+if __name__ == "__main__":
+    Command.run_parser()
diff --git a/pipenv/vendor/passa/cli/lock.py b/pipenv/vendor/passa/cli/lock.py
new file mode 100644
index 00000000..9b0651a1
--- /dev/null
+++ b/pipenv/vendor/passa/cli/lock.py
@@ -0,0 +1,18 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+from ..actions.lock import lock
+from ._base import BaseCommand
+
+
+class Command(BaseCommand):
+    name = "lock"
+    description = "Generate Pipfile.lock."
+
+    def run(self, options):
+        return lock(project=options.project)
+
+
+if __name__ == "__main__":
+    Command.run_parser()
diff --git a/pipenv/vendor/passa/cli/options.py b/pipenv/vendor/passa/cli/options.py
new file mode 100644
index 00000000..da89a3b1
--- /dev/null
+++ b/pipenv/vendor/passa/cli/options.py
@@ -0,0 +1,153 @@
+# -*- coding=utf-8 -*-
+from __future__ import absolute_import
+
+import argparse
+import os
+import sys
+
+import tomlkit.exceptions
+
+import passa.models.projects
+import vistir
+
+
+PYTHON_VERSION = ".".join(str(v) for v in sys.version_info[:2])
+
+
+class Project(passa.models.projects.Project):
+    def __init__(self, root, *args, **kwargs):
+        root = vistir.compat.Path(root).absolute()
+        pipfile = root.joinpath("Pipfile")
+        if not pipfile.is_file():
+            raise argparse.ArgumentError(
+                "{0!r} is not a Pipfile project".format(root),
+            )
+        try:
+            super(Project, self).__init__(root.as_posix(), *args, **kwargs)
+        except tomlkit.exceptions.ParseError as e:
+            raise argparse.ArgumentError(
+                "failed to parse Pipfile: {0!r}".format(str(e)),
+            )
+
+    def __name__(self):
+        return "Project Root"
+
+
+class Option(object):
+    def __init__(self, *args, **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+
+    def add_to_parser(self, parser):
+        parser.add_argument(*self.args, **self.kwargs)
+
+    def add_to_group(self, group):
+        group.add_argument(*self.args, **self.kwargs)
+
+
+class ArgumentGroup(object):
+    def __init__(self, name, parser=None, is_mutually_exclusive=False, required=None, options=[]):
+        self.name = name
+        self.options = options
+        self.parser = parser
+        self.required = required
+        self.is_mutually_exclusive = is_mutually_exclusive
+        self.argument_group = None
+
+    def add_to_parser(self, parser):
+        group = None
+        if self.is_mutually_exclusive:
+            group = parser.add_mutually_exclusive_group(required=self.required)
+        else:
+            group = parser.add_argument_group()
+        for option in self.options:
+            option.add_to_group(group)
+        self.argument_group = group
+        self.parser = parser
+
+
+project = Option(
+    "--project", metavar="project", default=os.getcwd(), type=Project,
+    help="path to project root (directory containing Pipfile)",
+)
+
+new_project = Option(
+    "--project", metavar="project", default=os.getcwd(), type=str,
+    help="path to project root (directory containing Pipfile)",
+)
+
+python_version = Option(
+    "--py-version", "--python-version", "--requires-python", metavar="python-version",
+    dest="python_version", default=PYTHON_VERSION, type=str,
+    help="required minor python version for the project"
+)
+
+packages = Option(
+    "packages", metavar="package", nargs="*",
+    help="requirement to add (can be used multiple times)",
+)
+
+editable = Option(
+    '-e', '--editable', dest='editables', nargs="*", default=[], metavar='path/vcs',
+    help="editable requirement to add (can be used multiple times)",
+)
+
+dev = Option(
+    "--dev", action="store_true", default=False,
+    help="Use [dev-packages] for install/freeze/uninstall operations",
+)
+
+no_sync = Option(
+    "--no-sync", dest="sync", action="store_false", default=True,
+    help="do not synchronize the environment",
+)
+
+target = Option(
+    "-t", "--target", default=None,
+    help="file to export into (default is to print to stdout)"
+)
+
+no_default = Option(
+    "--no-default", dest="default", action="store_false", default=True,
+    help="do not include default packages when exporting, importing, or cleaning"
+)
+
+include_hashes = Option(
+    "--include-hashes", dest="include_hashes", action="store_true",
+    help="output hashes in requirements.txt (default is to guess)",
+)
+
+no_include_hashes = Option(
+    "--no-include-hashes", dest="include_hashes", action="store_false",
+    help="do not output hashes in requirements.txt (default is to guess)",
+)
+
+no_check = Option(
+    "--no-check", dest="check", action="store_false", default=True,
+    help="do not check if Pipfile.lock is up to date, always resolve",
+)
+
+no_clean = Option(
+    "--no-clean", dest="clean", action="store_false", default=True,
+    help="do not remove packages not specified in Pipfile.lock",
+)
+
+dev_only = Option(
+    "--dev", dest="only", action="store_const", const="dev",
+    help="only try to modify [dev-packages]",
+)
+
+default_only = Option(
+    "--default", dest="only", action="store_const", const="default",
+    help="only try to modify [default]",
+)
+
+strategy = Option(
+    "--strategy", choices=["eager", "only-if-needed"], default="only-if-needed",
+    help="how dependency upgrading is handled",
+)
+
+include_hashes_group = ArgumentGroup("include_hashes", is_mutually_exclusive=True, options=[include_hashes, no_include_hashes])
+dev_group = ArgumentGroup("dev", is_mutually_exclusive="True", options=[dev_only, default_only])
+package_group = ArgumentGroup("packages", options=[packages, editable, dev, no_sync])
+new_project_group = ArgumentGroup("new-project", options=[new_project, python_version])
diff --git a/pipenv/vendor/passa/cli/remove.py b/pipenv/vendor/passa/cli/remove.py
new file mode 100644
index 00000000..538acbf9
--- /dev/null
+++ b/pipenv/vendor/passa/cli/remove.py
@@ -0,0 +1,22 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+from ..actions.remove import remove
+from ._base import BaseCommand
+from .options import dev_group, no_clean, packages
+
+
+class Command(BaseCommand):
+
+    name = "remove"
+    description = "Remove packages from project."
+    arguments = [dev_group, no_clean, packages]
+
+    def run(self, options):
+        return remove(project=options.project, only=options.only,
+                        packages=options.packages, clean=options.clean)
+
+
+if __name__ == "__main__":
+    Command.run_parser()
diff --git a/pipenv/vendor/passa/cli/sync.py b/pipenv/vendor/passa/cli/sync.py
new file mode 100644
index 00000000..a09b7842
--- /dev/null
+++ b/pipenv/vendor/passa/cli/sync.py
@@ -0,0 +1,21 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+from ..actions.sync import sync
+from ._base import BaseCommand
+from .options import dev, no_clean
+
+
+class Command(BaseCommand):
+
+    name = "sync"
+    description = "Install Pipfile.lock into the environment."
+    arguments = [dev, no_clean]
+
+    def run(self, options):
+        return sync(project=options.project, dev=options.dev, clean=options.clean)
+
+
+if __name__ == "__main__":
+    Command.run_parser()
diff --git a/pipenv/vendor/passa/cli/upgrade.py b/pipenv/vendor/passa/cli/upgrade.py
new file mode 100644
index 00000000..cf7f5021
--- /dev/null
+++ b/pipenv/vendor/passa/cli/upgrade.py
@@ -0,0 +1,21 @@
+# -*- coding=utf-8 -*-
+from __future__ import absolute_import, print_function, unicode_literals
+
+from ..actions.upgrade import upgrade
+from ._base import BaseCommand
+from .options import no_clean, no_sync, packages, strategy
+
+
+class Command(BaseCommand):
+
+    name = "upgrade"
+    description = "Upgrade packages in project."
+    arguments = [packages, strategy, no_clean, no_sync]
+
+    def run(self, options):
+        return upgrade(project=options.project, strategy=options.strategy,
+                            sync=options.sync, packages=options.packages)
+
+
+if __name__ == "__main__":
+    Command.run_parser()
diff --git a/pipenv/vendor/passa/internals/__init__.py b/pipenv/vendor/passa/internals/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/pipenv/vendor/passa/internals/_pip.py b/pipenv/vendor/passa/internals/_pip.py
new file mode 100644
index 00000000..2aa143a2
--- /dev/null
+++ b/pipenv/vendor/passa/internals/_pip.py
@@ -0,0 +1,397 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+import contextlib
+import io
+import itertools
+import distutils.log
+import os
+
+import distlib.database
+import distlib.scripts
+import distlib.wheel
+import packaging.utils
+import pip_shims
+import setuptools.dist
+import six
+import vistir
+
+from ..models.caches import CACHE_DIR
+from ._pip_shims import VCS_SUPPORT, build_wheel as _build_wheel, unpack_url
+from .utils import filter_sources
+
+
+@vistir.path.ensure_mkdir_p(mode=0o775)
+def _get_src_dir():
+    src = os.environ.get("PIP_SRC")
+    if src:
+        return src
+    virtual_env = os.environ.get("VIRTUAL_ENV")
+    if virtual_env:
+        return os.path.join(virtual_env, "src")
+    return os.path.join(os.getcwd(), "src")     # Match pip's behavior.
+
+
+def _prepare_wheel_building_kwargs(ireq):
+    download_dir = os.path.join(CACHE_DIR, "pkgs")
+    vistir.mkdir_p(download_dir)
+
+    wheel_download_dir = os.path.join(CACHE_DIR, "wheels")
+    vistir.mkdir_p(wheel_download_dir)
+
+    if ireq.source_dir is not None:
+        src_dir = ireq.source_dir
+    elif ireq.editable:
+        src_dir = _get_src_dir()
+    else:
+        src_dir = vistir.path.create_tracked_tempdir(prefix='passa-src')
+
+    # This logic matches pip's behavior, although I don't fully understand the
+    # intention. I guess the idea is to build editables in-place, otherwise out
+    # of the source tree?
+    if ireq.editable:
+        build_dir = src_dir
+    else:
+        build_dir = vistir.path.create_tracked_tempdir(prefix="passa-build")
+
+    return {
+        "build_dir": build_dir,
+        "src_dir": src_dir,
+        "download_dir": download_dir,
+        "wheel_download_dir": wheel_download_dir,
+    }
+
+
+def _get_pip_index_urls(sources):
+    index_urls = []
+    trusted_hosts = []
+    for source in sources:
+        url = source.get("url")
+        if not url:
+            continue
+        index_urls.append(url)
+        if source.get("verify_ssl", True):
+            continue
+        host = six.moves.urllib.parse.urlparse(source["url"]).hostname
+        trusted_hosts.append(host)
+    return index_urls, trusted_hosts
+
+
+class _PipCommand(pip_shims.Command):
+    name = "PipCommand"
+
+
+def _get_pip_session(trusted_hosts):
+    cmd = _PipCommand()
+    options, _ = cmd.parser.parse_args([])
+    options.cache_dir = CACHE_DIR
+    options.trusted_hosts = trusted_hosts
+    session = cmd._build_session(options)
+    return session
+
+
+def _get_finder(sources):
+    index_urls, trusted_hosts = _get_pip_index_urls(sources)
+    session = _get_pip_session(trusted_hosts)
+    finder = pip_shims.PackageFinder(
+        find_links=[],
+        index_urls=index_urls,
+        trusted_hosts=trusted_hosts,
+        allow_all_prereleases=True,
+        session=session,
+    )
+    return finder
+
+
+def _get_wheel_cache():
+    format_control = pip_shims.FormatControl(set(), set())
+    wheel_cache = pip_shims.WheelCache(CACHE_DIR, format_control)
+    return wheel_cache
+
+
+def _convert_hashes(values):
+    """Convert Pipfile.lock hash lines into InstallRequirement option format.
+
+    The option format uses a str-list mapping. Keys are hash algorithms, and
+    the list contains all values of that algorithm.
+    """
+    hashes = {}
+    if not values:
+        return hashes
+    for value in values:
+        try:
+            name, value = value.split(":", 1)
+        except ValueError:
+            name = "sha256"
+        if name not in hashes:
+            hashes[name] = []
+        hashes[name].append(value)
+    return hashes
+
+
+class WheelBuildError(RuntimeError):
+    pass
+
+
+def build_wheel(ireq, sources, hashes=None):
+    """Build a wheel file for the InstallRequirement object.
+
+    An artifact is downloaded (or read from cache). If the artifact is not a
+    wheel, build one out of it. The dynamically built wheel is ephemeral; do
+    not depend on its existence after the returned wheel goes out of scope.
+
+    If `hashes` is truthy, it is assumed to be a list of hashes (as formatted
+    in Pipfile.lock) to be checked against the download.
+
+    Returns a `distlib.wheel.Wheel` instance. Raises a `WheelBuildError` (a
+    `RuntimeError` subclass) if the wheel cannot be built.
+    """
+    kwargs = _prepare_wheel_building_kwargs(ireq)
+    finder = _get_finder(sources)
+
+    # Not for upgrade, hash not required. Hashes are not required here even
+    # when we provide them, because pip skips local wheel cache if we set it
+    # to True. Hashes are checked later if we need to download the file.
+    ireq.populate_link(finder, False, False)
+
+    # Ensure ireq.source_dir is set.
+    # This is intentionally set to build_dir, not src_dir. Comments from pip:
+    #   [...] if filesystem packages are not marked editable in a req, a non
+    #   deterministic error occurs when the script attempts to unpack the
+    #   build directory.
+    # Also see comments in `_prepare_wheel_building_kwargs()` -- If the ireq
+    # is editable, build_dir is actually src_dir, making the build in-place.
+    ireq.ensure_has_source_dir(kwargs["build_dir"])
+
+    # Ensure the source is fetched. For wheels, it is enough to just download
+    # because we'll use them directly. For an sdist, we need to unpack so we
+    # can build it.
+    if not ireq.editable or not pip_shims.is_file_url(ireq.link):
+        if ireq.is_wheel:
+            only_download = True
+            download_dir = kwargs["wheel_download_dir"]
+        else:
+            only_download = False
+            download_dir = kwargs["download_dir"]
+        ireq.options["hashes"] = _convert_hashes(hashes)
+        unpack_url(
+            ireq.link, ireq.source_dir, download_dir,
+            only_download=only_download, session=finder.session,
+            hashes=ireq.hashes(False), progress_bar="off",
+        )
+
+    if ireq.is_wheel:
+        # If this is a wheel, use the downloaded thing.
+        output_dir = kwargs["wheel_download_dir"]
+        wheel_path = os.path.join(output_dir, ireq.link.filename)
+    else:
+        # Othereise we need to build an ephemeral wheel.
+        wheel_path = _build_wheel(
+            ireq, vistir.path.create_tracked_tempdir(prefix="ephem"),
+            finder, _get_wheel_cache(), kwargs,
+        )
+        if wheel_path is None or not os.path.exists(wheel_path):
+            raise WheelBuildError
+    return distlib.wheel.Wheel(wheel_path)
+
+
+def _obtrain_ref(vcs_obj, src_dir, name, rev=None):
+    target_dir = os.path.join(src_dir, name)
+    target_rev = vcs_obj.make_rev_options(rev)
+    if not os.path.exists(target_dir):
+        vcs_obj.obtain(target_dir)
+    if (not vcs_obj.is_commit_id_equal(target_dir, rev) and
+            not vcs_obj.is_commit_id_equal(target_dir, target_rev)):
+        vcs_obj.update(target_dir, target_rev)
+    return vcs_obj.get_revision(target_dir)
+
+
+def get_vcs_ref(requirement):
+    backend = VCS_SUPPORT.get_backend(requirement.vcs)
+    vcs = backend(url=requirement.req.vcs_uri)
+    src = _get_src_dir()
+    name = requirement.normalized_name
+    ref = _obtrain_ref(vcs, src, name, rev=requirement.req.ref)
+    return ref
+
+
+def find_installation_candidates(ireq, sources):
+    finder = _get_finder(sources)
+    return finder.find_all_candidates(ireq.name)
+
+
+class RequirementUninstaller(object):
+    """A context manager to remove a package for the inner block.
+
+    This uses `UninstallPathSet` to control the workflow. If the inner block
+    exits correctly, the uninstallation is committed, otherwise rolled back.
+    """
+    def __init__(self, ireq, auto_confirm, verbose):
+        self.ireq = ireq
+        self.pathset = None
+        self.auto_confirm = auto_confirm
+        self.verbose = verbose
+
+    def __enter__(self):
+        self.pathset = self.ireq.uninstall(
+            auto_confirm=self.auto_confirm,
+            verbose=self.verbose,
+        )
+        return self.pathset
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self.pathset is None:
+            return
+        if exc_type is None:
+            self.pathset.commit()
+        else:
+            self.pathset.rollback()
+
+
+def uninstall(name, **kwargs):
+    ireq = pip_shims.InstallRequirement.from_line(name)
+    return RequirementUninstaller(ireq, **kwargs)
+
+
+@contextlib.contextmanager
+def _suppress_distutils_logs():
+    """Hack to hide noise generated by `setup.py develop`.
+
+    There isn't a good way to suppress them now, so let's monky-patch.
+    See https://bugs.python.org/issue25392.
+    """
+    f = distutils.log.Log._log
+
+    def _log(log, level, msg, args):
+        if level >= distutils.log.ERROR:
+            f(log, level, msg, args)
+
+    distutils.log.Log._log = _log
+    yield
+    distutils.log.Log._log = f
+
+
+class NoopInstaller(object):
+    """An installer.
+
+    This class is not designed to be instantiated by itself, but used as a
+    common interface for subclassing.
+
+    An installer has two methods, `prepare()` and `install()`. Neither takes
+    arguments, and should be called in that order to prepare an installation
+    operation, and to actually install things.
+    """
+    def prepare(self):
+        pass
+
+    def install(self):
+        pass
+
+
+class EditableInstaller(NoopInstaller):
+    """Installer to handle editable.
+    """
+    def __init__(self, requirement):
+        ireq = requirement.as_ireq()
+        self.working_directory = ireq.setup_py_dir
+        self.setup_py = ireq.setup_py
+
+    def install(self):
+        with vistir.cd(self.working_directory), _suppress_distutils_logs():
+            # Access from Setuptools to ensure things are patched correctly.
+            setuptools.dist.distutils.core.run_setup(
+                self.setup_py, ["develop", "--no-deps"],
+            )
+
+
+class WheelInstaller(NoopInstaller):
+    """Installer by building a wheel.
+
+    The wheel is built during `prepare()`, and installed in `install()`.
+    """
+    def __init__(self, requirement, sources, paths):
+        self.ireq = requirement.as_ireq()
+        self.sources = filter_sources(requirement, sources)
+        self.hashes = requirement.hashes or None
+        self.paths = paths
+        self.wheel = None
+
+    def prepare(self):
+        self.wheel = build_wheel(self.ireq, self.sources, self.hashes)
+
+    def install(self):
+        self.wheel.install(self.paths, distlib.scripts.ScriptMaker(None, None))
+
+
+def _iter_egg_info_directories(root, name):
+    name = packaging.utils.canonicalize_name(name)
+    for parent, dirnames, filenames in os.walk(root):
+        matched_indexes = []
+        for i, dirname in enumerate(dirnames):
+            if not dirname.lower().endswith("egg-info"):
+                continue
+            egg_info_name = packaging.utils.canonicalize_name(dirname[:-9])
+            if egg_info_name != name:
+                continue
+            matched_indexes.append(i)
+            yield os.path.join(parent, dirname)
+
+        # Modify dirnames in-place to NOT look into egg-info directories.
+        # This is a documented behavior in stdlib.
+        for i in reversed(matched_indexes):
+            del dirnames[i]
+
+
+def _read_pkg_info(directory):
+    path = os.path.join(directory, "PKG-INFO")
+    try:
+        with io.open(path, encoding="utf-8", errors="replace") as f:
+            return f.read()
+    except (IOError, OSError):
+        return None
+
+
+def _find_egg_info(ireq):
+    """Find this package's .egg-info directory.
+
+    Due to how sdists are designed, the .egg-info directory cannot be reliably
+    found without running setup.py to aggregate all configurations. This
+    function instead uses some heuristics to locate the egg-info directory
+    that most likely represents this package.
+
+    The best .egg-info directory's path is returned as a string. None is
+    returned if no matches can be found.
+    """
+    root = ireq.setup_py_dir
+
+    directory_iterator = _iter_egg_info_directories(root, ireq.name)
+    try:
+        top_egg_info = next(directory_iterator)
+    except StopIteration:   # No egg-info found. Wat.
+        return None
+    directory_iterator = itertools.chain([top_egg_info], directory_iterator)
+
+    # Read the sdist's PKG-INFO to determine which egg_info is best.
+    pkg_info = _read_pkg_info(root)
+
+    # PKG-INFO not readable. Just return whatever comes first, I guess.
+    if pkg_info is None:
+        return top_egg_info
+
+    # Walk the sdist to find the egg-info with matching PKG-INFO.
+    for directory in directory_iterator:
+        egg_pkg_info = _read_pkg_info(directory)
+        if egg_pkg_info == pkg_info:
+            return directory
+
+    # Nothing matches...? Use the first one we found, I guess.
+    return top_egg_info
+
+
+def read_sdist_metadata(ireq):
+    egg_info_dir = _find_egg_info(ireq)
+    if not egg_info_dir:
+        return None
+    distribution = distlib.database.EggInfoDistribution(egg_info_dir)
+    return distribution.metadata
diff --git a/pipenv/vendor/passa/internals/_pip_shims.py b/pipenv/vendor/passa/internals/_pip_shims.py
new file mode 100644
index 00000000..b2c7b6ea
--- /dev/null
+++ b/pipenv/vendor/passa/internals/_pip_shims.py
@@ -0,0 +1,61 @@
+# -*- coding=utf-8 -*-
+
+"""Shims to make the pip interface more consistent accross versions.
+
+There are currently two members:
+
+* VCS_SUPPORT is an instance of VcsSupport.
+* build_wheel abstracts the process to build a wheel out of a bunch parameters.
+* unpack_url wraps the actual function in pip to accept modern parameters.
+"""
+
+from __future__ import absolute_import, unicode_literals
+
+import pip_shims
+
+
+def _build_wheel_pre10(ireq, output_dir, finder, wheel_cache, kwargs):
+    kwargs.update({"wheel_cache": wheel_cache, "session": finder.session})
+    reqset = pip_shims.RequirementSet(**kwargs)
+    builder = pip_shims.WheelBuilder(reqset, finder)
+    return builder._build_one(ireq, output_dir)
+
+
+def _build_wheel_modern(ireq, output_dir, finder, wheel_cache, kwargs):
+    """Build a wheel.
+
+    * ireq: The InstallRequirement object to build
+    * output_dir: The directory to build the wheel in.
+    * finder: pip's internal Finder object to find the source out of ireq.
+    * kwargs: Various keyword arguments from `_prepare_wheel_building_kwargs`.
+    """
+    kwargs.update({"progress_bar": "off", "build_isolation": False})
+    with pip_shims.RequirementTracker() as req_tracker:
+        if req_tracker:
+            kwargs["req_tracker"] = req_tracker
+        preparer = pip_shims.RequirementPreparer(**kwargs)
+        builder = pip_shims.WheelBuilder(finder, preparer, wheel_cache)
+        return builder._build_one(ireq, output_dir)
+
+
+def _unpack_url_pre10(*args, **kwargs):
+    """Shim for unpack_url in various pip versions.
+
+    pip before 10.0 does not accept `progress_bar` here. Simply drop it.
+    """
+    kwargs.pop("progress_bar", None)
+    return pip_shims.unpack_url(*args, **kwargs)
+
+
+PIP_VERSION = pip_shims.utils._parse(pip_shims.pip_version)
+VERSION_10 = pip_shims.utils._parse("10")
+
+
+VCS_SUPPORT = pip_shims.VcsSupport()
+
+build_wheel = _build_wheel_modern
+unpack_url = pip_shims.unpack_url
+
+if PIP_VERSION < VERSION_10:
+    build_wheel = _build_wheel_pre10
+    unpack_url = _unpack_url_pre10
diff --git a/pipenv/vendor/passa/internals/candidates.py b/pipenv/vendor/passa/internals/candidates.py
new file mode 100644
index 00000000..67b09049
--- /dev/null
+++ b/pipenv/vendor/passa/internals/candidates.py
@@ -0,0 +1,86 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+import packaging.specifiers
+import packaging.version
+import requirementslib
+
+from ._pip import find_installation_candidates, get_vcs_ref
+
+
+def _filter_matching_python_requirement(candidates, required_python):
+    # TODO: This should also takes the parent's python_version and
+    # python_full_version markers, and only return matches with valid
+    # intersections. For example, if parent requires `python_version >= '3.0'`,
+    # this should not return entries with "Requires-Python: <3".
+    for c in candidates:
+        try:
+            requires_python = c.requires_python
+        except AttributeError:
+            requires_python = c.location.requires_python
+        if required_python and requires_python:
+            # Old specifications had people setting this to single digits
+            # which is effectively the same as '>=digit,<digit+1'
+            if requires_python.isdigit():
+                requires_python = '>={0},<{1}'.format(
+                    requires_python, int(requires_python) + 1,
+                )
+            try:
+                specset = packaging.specifiers.SpecifierSet(requires_python)
+            except packaging.specifiers.InvalidSpecifier:
+                continue
+            if not specset.contains(required_python):
+                continue
+        yield c
+
+
+def _copy_requirement(requirement):
+    # Markers are intentionally dropped here. They will be added to candidates
+    # after resolution, so we can perform marker aggregation.
+    new = requirement.copy()
+    new.markers = None
+    return new
+
+
+def _requirement_from_metadata(name, version, extras, index):
+    # Markers are intentionally dropped here. They will be added to candidates
+    # after resolution, so we can perform marker aggregation.
+    r = requirementslib.Requirement.from_metadata(name, version, extras, None)
+    r.index = index
+    return r
+
+
+def find_candidates(requirement, sources, requires_python, allow_prereleases):
+    # A non-named requirement has exactly one candidate that is itself. For
+    # VCS, we also lock the requirement to an exact ref.
+    if not requirement.is_named:
+        candidate = _copy_requirement(requirement)
+        if candidate.is_vcs:
+            candidate.req.ref = get_vcs_ref(candidate)
+        return [candidate]
+
+    ireq = requirement.as_ireq()
+    icans = find_installation_candidates(ireq, sources)
+
+    if requires_python:
+        matching_icans = list(_filter_matching_python_requirement(
+            icans, packaging.version.parse(requires_python),
+        ))
+        icans = matching_icans or icans
+
+    versions = sorted(ireq.specifier.filter(
+        (c.version for c in icans), allow_prereleases,
+    ))
+    if not allow_prereleases and not versions:
+        versions = sorted(ireq.specifier.filter(
+            (c.version for c in icans), True,
+        ))
+
+    name = requirement.normalized_name
+    extras = requirement.extras
+    index = requirement.index
+    return [
+        _requirement_from_metadata(name, version, extras, index)
+        for version in versions
+    ]
diff --git a/pipenv/vendor/passa/internals/dependencies.py b/pipenv/vendor/passa/internals/dependencies.py
new file mode 100644
index 00000000..358cc33b
--- /dev/null
+++ b/pipenv/vendor/passa/internals/dependencies.py
@@ -0,0 +1,273 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+import functools
+import os
+import sys
+
+import packaging.specifiers
+import packaging.utils
+import packaging.version
+import requests
+import requirementslib
+import six
+
+from ..models.caches import DependencyCache, RequiresPythonCache
+from ._pip import WheelBuildError, build_wheel, read_sdist_metadata
+from .markers import contains_extra, get_contained_extras, get_without_extra
+from .utils import get_pinned_version, is_pinned
+
+
+DEPENDENCY_CACHE = DependencyCache()
+REQUIRES_PYTHON_CACHE = RequiresPythonCache()
+
+
+def _cached(f, **kwargs):
+
+    @functools.wraps(f)
+    def wrapped(ireq):
+        result = f(ireq, **kwargs)
+        if result is not None and is_pinned(ireq):
+            deps, requires_python = result
+            DEPENDENCY_CACHE[ireq] = deps
+            REQUIRES_PYTHON_CACHE[ireq] = requires_python
+        return result
+
+    return wrapped
+
+
+def _is_cache_broken(line, parent_name):
+    dep_req = requirementslib.Requirement.from_line(line)
+    if contains_extra(dep_req.markers):
+        return True     # The "extra =" marker breaks everything.
+    elif dep_req.normalized_name == parent_name:
+        return True     # A package cannot depend on itself.
+    return False
+
+
+def _get_dependencies_from_cache(ireq):
+    """Retrieves dependencies for the requirement from the dependency cache.
+    """
+    if os.environ.get("PASSA_IGNORE_LOCAL_CACHE"):
+        return
+    if ireq.editable:
+        return
+    try:
+        deps = DEPENDENCY_CACHE[ireq]
+        pyrq = REQUIRES_PYTHON_CACHE[ireq]
+    except KeyError:
+        return
+
+    # Preserving sanity: Run through the cache and make sure every entry if
+    # valid. If this fails, something is wrong with the cache. Drop it.
+    try:
+        packaging.specifiers.SpecifierSet(pyrq)
+        ireq_name = packaging.utils.canonicalize_name(ireq.name)
+        if any(_is_cache_broken(line, ireq_name) for line in deps):
+            broken = True
+        else:
+            broken = False
+    except Exception:
+        broken = True
+
+    if broken:
+        print("dropping broken cache for {0}".format(ireq.name))
+        del DEPENDENCY_CACHE[ireq]
+        del REQUIRES_PYTHON_CACHE[ireq]
+        return
+
+    return deps, pyrq
+
+
+def _get_dependencies_from_json_url(url, session):
+    response = session.get(url)
+    response.raise_for_status()
+    info = response.json()["info"]
+
+    requires_python = info["requires_python"] or ""
+    try:
+        requirement_lines = info["requires_dist"]
+    except KeyError:
+        requirement_lines = info["requires"]
+
+    # The JSON API returns null both when there are not requirements, or the
+    # requirement list cannot be retrieved. We can't safely assume, so it's
+    # better to drop it and fall back to downloading the package.
+    try:
+        dependency_requirements_iterator = (
+            requirementslib.Requirement.from_line(line)
+            for line in requirement_lines
+        )
+    except TypeError:
+        return
+
+    dependencies = [
+        dep_req.as_line(include_hashes=False)
+        for dep_req in dependency_requirements_iterator
+        if not contains_extra(dep_req.markers)
+    ]
+    return dependencies, requires_python
+
+
+def _get_dependencies_from_json(ireq, sources):
+    """Retrieves dependencies for the install requirement from the JSON API.
+
+    :param ireq: A single InstallRequirement
+    :type ireq: :class:`~pip._internal.req.req_install.InstallRequirement`
+    :return: A set of dependency lines for generating new InstallRequirements.
+    :rtype: set(str) or None
+    """
+    if os.environ.get("PASSA_IGNORE_JSON_API"):
+        return
+
+    # It is technically possible to parse extras out of the JSON API's
+    # requirement format, but it is such a chore let's just use the simple API.
+    if ireq.extras:
+        return
+
+    try:
+        version = get_pinned_version(ireq)
+    except ValueError:
+        return
+
+    url_prefixes = [
+        proc_url[:-7]   # Strip "/simple".
+        for proc_url in (
+            raw_url.rstrip("/")
+            for raw_url in (source.get("url", "") for source in sources)
+        )
+        if proc_url.endswith("/simple")
+    ]
+
+    session = requests.session()
+
+    for prefix in url_prefixes:
+        url = "{prefix}/pypi/{name}/{version}/json".format(
+            prefix=prefix,
+            name=packaging.utils.canonicalize_name(ireq.name),
+            version=version,
+        )
+        try:
+            dependencies = _get_dependencies_from_json_url(url, session)
+            if dependencies is not None:
+                return dependencies
+        except Exception as e:
+            print("unable to read dependencies via {0} ({1})".format(url, e))
+    session.close()
+    return
+
+
+def _read_requirements(metadata, extras):
+    """Read wheel metadata to know what it depends on.
+
+    The `run_requires` attribute contains a list of dict or str specifying
+    requirements. For dicts, it may contain an "extra" key to specify these
+    requirements are for a specific extra. Unfortunately, not all fields are
+    specificed like this (I don't know why); some are specified with markers.
+    So we jump though these terrible hoops to know exactly what we need.
+
+    The extra extraction is not comprehensive. Tt assumes the marker is NEVER
+    something like `extra == "foo" and extra == "bar"`. I guess this never
+    makes sense anyway? Markers are just terrible.
+    """
+    extras = extras or ()
+    requirements = []
+    for entry in metadata.run_requires:
+        if isinstance(entry, six.text_type):
+            entry = {"requires": [entry]}
+            extra = None
+        else:
+            extra = entry.get("extra")
+        if extra is not None and extra not in extras:
+            continue
+        for line in entry.get("requires", []):
+            r = requirementslib.Requirement.from_line(line)
+            if r.markers:
+                contained = get_contained_extras(r.markers)
+                if (contained and not any(e in contained for e in extras)):
+                    continue
+                marker = get_without_extra(r.markers)
+                r.markers = str(marker) if marker else None
+                line = r.as_line(include_hashes=False)
+            requirements.append(line)
+    return requirements
+
+
+def _read_requires_python(metadata):
+    """Read wheel metadata to know the value of Requires-Python.
+
+    This is surprisingly poorly supported in Distlib. This function tries
+    several ways to get this information:
+
+    * Metadata 2.0: metadata.dictionary.get("requires_python") is not None
+    * Metadata 2.1: metadata._legacy.get("Requires-Python") is not None
+    * Metadata 1.2: metadata._legacy.get("Requires-Python") != "UNKNOWN"
+    """
+    # TODO: Support more metadata formats.
+    value = metadata.dictionary.get("requires_python")
+    if value is not None:
+        return value
+    if metadata._legacy:
+        value = metadata._legacy.get("Requires-Python")
+        if value is not None and value != "UNKNOWN":
+            return value
+    return ""
+
+
+def _get_dependencies_from_pip(ireq, sources):
+    """Retrieves dependencies for the requirement from pipenv.patched.notpip internals.
+
+    The current strategy is to try the followings in order, returning the
+    first successful result.
+
+    1. Try to build a wheel out of the ireq, and read metadata out of it.
+    2. Read metadata out of the egg-info directory if it is present.
+    """
+    extras = ireq.extras or ()
+    try:
+        wheel = build_wheel(ireq, sources)
+    except WheelBuildError:
+        # XXX: This depends on a side effect of `build_wheel`. This block is
+        # reached when it fails to build an sdist, where the sdist would have
+        # been downloaded, extracted into `ireq.source_dir`, and partially
+        # built (hopefully containing .egg-info).
+        metadata = read_sdist_metadata(ireq)
+        if not metadata:
+            raise
+    else:
+        metadata = wheel.metadata
+    requirements = _read_requirements(metadata, extras)
+    requires_python = _read_requires_python(metadata)
+    return requirements, requires_python
+
+
+def get_dependencies(requirement, sources):
+    """Get all dependencies for a given install requirement.
+
+    :param requirement: A requirement
+    :param sources: Pipfile-formatted sources
+    :type sources: list[dict]
+    """
+    getters = [
+        _get_dependencies_from_cache,
+        _cached(_get_dependencies_from_json, sources=sources),
+        _cached(_get_dependencies_from_pip, sources=sources),
+    ]
+    ireq = requirement.as_ireq()
+    last_exc = None
+    for getter in getters:
+        try:
+            result = getter(ireq)
+        except Exception as e:
+            last_exc = sys.exc_info()
+            continue
+        if result is not None:
+            deps, pyreq = result
+            reqs = [requirementslib.Requirement.from_line(d) for d in deps]
+            return reqs, pyreq
+    if last_exc:
+        six.reraise(*last_exc)
+    raise RuntimeError("failed to get dependencies for {}".format(
+        requirement.as_line(),
+    ))
diff --git a/pipenv/vendor/passa/internals/hashes.py b/pipenv/vendor/passa/internals/hashes.py
new file mode 100644
index 00000000..fe049274
--- /dev/null
+++ b/pipenv/vendor/passa/internals/hashes.py
@@ -0,0 +1,61 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+import contextlib
+
+from pip_shims import Wheel
+
+
+def _wheel_supported(self, tags=None):
+    # Ignore current platform. Support everything.
+    return True
+
+
+def _wheel_support_index_min(self, tags=None):
+    # All wheels are equal priority for sorting.
+    return 0
+
+
+@contextlib.contextmanager
+def _allow_all_wheels():
+    """Monkey patch pip.Wheel to allow all wheels
+
+    The usual checks against platforms and Python versions are ignored to allow
+    fetching all available entries in PyPI. This also saves the candidate cache
+    and set a new one, or else the results from the previous non-patched calls
+    will interfere.
+    """
+    original_wheel_supported = Wheel.supported
+    original_support_index_min = Wheel.support_index_min
+
+    Wheel.supported = _wheel_supported
+    Wheel.support_index_min = _wheel_support_index_min
+    yield
+    Wheel.supported = original_wheel_supported
+    Wheel.support_index_min = original_support_index_min
+
+
+def get_hashes(cache, req):
+    if req.is_vcs:
+        return set()
+
+    ireq = req.as_ireq()
+
+    if ireq.editable:
+        return set()
+
+    if req.is_file_or_url:
+        # TODO: Get the hash of the linked artifact?
+        return set()
+
+    if not ireq.is_pinned:
+        return set()
+
+    with _allow_all_wheels():
+        matching_candidates = req.find_all_matches()
+
+    return {
+        cache.get_hash(candidate.location)
+        for candidate in matching_candidates
+    }
diff --git a/pipenv/vendor/passa/internals/markers.py b/pipenv/vendor/passa/internals/markers.py
new file mode 100644
index 00000000..95efab95
--- /dev/null
+++ b/pipenv/vendor/passa/internals/markers.py
@@ -0,0 +1,101 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+from packaging.markers import Marker
+
+
+def _strip_extra(elements):
+    """Remove the "extra == ..." operands from the list.
+
+    This is not a comprehensive implementation, but relies on an important
+    characteristic of metadata generation: The "extra == ..." operand is always
+    associated with an "and" operator. This means that we can simply remove the
+    operand and the "and" operator associated with it.
+    """
+    extra_indexes = []
+    for i, element in enumerate(elements):
+        if isinstance(element, list):
+            cancelled = _strip_extra(element)
+            if cancelled:
+                extra_indexes.append(i)
+        elif isinstance(element, tuple) and element[0].value == "extra":
+            extra_indexes.append(i)
+    for i in reversed(extra_indexes):
+        del elements[i]
+        if i > 0 and elements[i - 1] == "and":
+            # Remove the "and" before it.
+            del elements[i - 1]
+        elif elements:
+            # This shouldn't ever happen, but is included for completeness.
+            # If there is not an "and" before this element, try to remove the
+            # operator after it.
+            del elements[0]
+    return (not elements)
+
+
+def get_without_extra(marker):
+    """Build a new marker without the `extra == ...` part.
+
+    The implementation relies very deep into packaging's internals, but I don't
+    have a better way now (except implementing the whole thing myself).
+
+    This could return `None` if the `extra == ...` part is the only one in the
+    input marker.
+    """
+    # TODO: Why is this very deep in the internals? Why is a better solution
+    # implementing it yourself when someone is already maintaining a codebase
+    # for this? It's literally a grammar implementation that is required to
+    # meet the demands of a pep... -d
+    if not marker:
+        return None
+    marker = Marker(str(marker))
+    elements = marker._markers
+    _strip_extra(elements)
+    if elements:
+        return marker
+    return None
+
+
+def _markers_collect_extras(markers, collection):
+    # Optimization: the marker element is usually appended at the end.
+    for el in reversed(markers):
+        if (isinstance(el, tuple) and
+                el[0].value == "extra" and
+                el[1].value == "=="):
+            collection.add(el[2].value)
+        elif isinstance(el, list):
+            _markers_collect_extras(el, collection)
+
+
+def get_contained_extras(marker):
+    """Collect "extra == ..." operands from a marker.
+
+    Returns a list of str. Each str is a speficied extra in this marker.
+    """
+    if not marker:
+        return set()
+    marker = Marker(str(marker))
+    extras = set()
+    _markers_collect_extras(marker._markers, extras)
+    return extras
+
+
+def _markers_contains_extra(markers):
+    # Optimization: the marker element is usually appended at the end.
+    for element in reversed(markers):
+        if isinstance(element, tuple) and element[0].value == "extra":
+            return True
+        elif isinstance(element, list):
+            if _markers_contains_extra(element):
+                return True
+    return False
+
+
+def contains_extra(marker):
+    """Check whehter a marker contains an "extra == ..." operand.
+    """
+    if not marker:
+        return False
+    marker = Marker(str(marker))
+    return _markers_contains_extra(marker._markers)
diff --git a/pipenv/vendor/passa/internals/reporters.py b/pipenv/vendor/passa/internals/reporters.py
new file mode 100644
index 00000000..4fe6c0b8
--- /dev/null
+++ b/pipenv/vendor/passa/internals/reporters.py
@@ -0,0 +1,90 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+import resolvelib
+
+from .traces import trace_graph
+
+
+def print_title(text):
+    print('\n{:=^84}\n'.format(text))
+
+
+def print_requirement(r, end='\n'):
+    print('{:>40}'.format(r.as_line(include_hashes=False)), end=end)
+
+
+def print_dependency(state, key):
+    print_requirement(state.mapping[key], end='')
+    parents = sorted(
+        state.graph.iter_parents(key),
+        key=lambda n: (-1, '') if n is None else (ord(n[0].lower()), n),
+    )
+    for i, p in enumerate(parents):
+        if p is None:
+            line = '(user)'
+        else:
+            line = state.mapping[p].as_line(include_hashes=False)
+        if i == 0:
+            padding = ' <= '
+        else:
+            padding = ' ' * 44
+        print('{pad}{line}'.format(pad=padding, line=line))
+
+
+class StdOutReporter(resolvelib.BaseReporter):
+    """Simple reporter that prints things to stdout.
+    """
+    def __init__(self, requirements):
+        super(StdOutReporter, self).__init__()
+        self.requirements = requirements
+
+    def starting(self):
+        self._prev = None
+        print_title(' User requirements ')
+        for r in self.requirements:
+            print_requirement(r)
+
+    def ending_round(self, index, state):
+        print_title(' Round {} '.format(index))
+        mapping = state.mapping
+        if self._prev is None:
+            difference = set(mapping.keys())
+            changed = set()
+        else:
+            difference = set(mapping.keys()) - set(self._prev.keys())
+            changed = set(
+                k for k, v in mapping.items()
+                if k in self._prev and self._prev[k] != v
+            )
+        self._prev = mapping
+
+        if difference:
+            print('New pins: ')
+            for k in difference:
+                print_dependency(state, k)
+        print()
+
+        if changed:
+            print('Changed pins:')
+            for k in changed:
+                print_dependency(state, k)
+        print()
+
+    def ending(self, state):
+        print_title(" STABLE PINS ")
+        path_lists = trace_graph(state.graph)
+        for k in sorted(state.mapping):
+            print(state.mapping[k].as_line(include_hashes=False))
+            paths = path_lists[k]
+            for path in paths:
+                if path == [None]:
+                    print('    User requirement')
+                    continue
+                print('   ', end='')
+                for v in reversed(path[1:]):
+                    line = state.mapping[v].as_line(include_hashes=False)
+                    print(' <=', line, end='')
+                print()
+        print()
diff --git a/pipenv/vendor/passa/internals/specifiers.py b/pipenv/vendor/passa/internals/specifiers.py
new file mode 100644
index 00000000..75afb6ad
--- /dev/null
+++ b/pipenv/vendor/passa/internals/specifiers.py
@@ -0,0 +1,136 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+import itertools
+import operator
+
+from packaging.specifiers import SpecifierSet, Specifier
+from vistir.misc import dedup
+
+
+def _tuplize_version(version):
+    return tuple(int(x) for x in version.split("."))
+
+
+def _format_version(version):
+    return ".".join(str(i) for i in version)
+
+
+# Prefer [x,y) ranges.
+REPLACE_RANGES = {">": ">=", "<=": "<"}
+
+
+def _format_pyspec(specifier):
+    if isinstance(specifier, str):
+        if not any(op in specifier for op in Specifier._operators.keys()):
+            specifier = "=={0}".format(specifier)
+        specifier = Specifier(specifier)
+    if specifier.operator == "==" and specifier.version.endswith(".*"):
+        specifier = Specifier("=={0}".format(specifier.version[:-2]))
+    try:
+        op = REPLACE_RANGES[specifier.operator]
+    except KeyError:
+        return specifier
+    version = specifier.version.replace(".*", "")
+    curr_tuple = _tuplize_version(version)
+    try:
+        next_tuple = (curr_tuple[0], curr_tuple[1] + 1)
+    except IndexError:
+        next_tuple = (curr_tuple[0], 1)
+    specifier = Specifier("{0}{1}".format(op, _format_version(next_tuple)))
+    return specifier
+
+
+def _get_specs(specset):
+    if isinstance(specset, Specifier):
+        specset = str(specset)
+    if isinstance(specset, str):
+        specset = SpecifierSet(specset.replace(".*", ""))
+    return [
+        (spec._spec[0], _tuplize_version(spec._spec[1]))
+        for spec in getattr(specset, "_specs", [])
+    ]
+
+
+def _group_by_op(specs):
+    specs = [_get_specs(x) for x in list(specs)]
+    flattened = [(op, version) for spec in specs for op, version in spec]
+    specs = sorted(flattened, key=operator.itemgetter(1))
+    grouping = itertools.groupby(specs, key=operator.itemgetter(0))
+    return grouping
+
+
+def cleanup_pyspecs(specs, joiner="or"):
+    specs = {_format_pyspec(spec) for spec in specs}
+    # for != operator we want to group by version
+    # if all are consecutive, join as a list
+    results = set()
+    for op, versions in _group_by_op(specs):
+        versions = [version[1] for version in versions]
+        versions = sorted(dedup(versions))
+        # if we are doing an or operation, we need to use the min for >=
+        # this way OR(>=2.6, >=2.7, >=3.6) picks >=2.6
+        # if we do an AND operation we need to use MAX to be more selective
+        if op in (">", ">="):
+            if joiner == "or":
+                results.add((op, _format_version(min(versions))))
+            else:
+                results.add((op, _format_version(max(versions))))
+        # we use inverse logic here so we will take the max value if we are
+        # using OR but the min value if we are using AND
+        elif op in ("<=", "<"):
+            if joiner == "or":
+                results.add((op, _format_version(max(versions))))
+            else:
+                results.add((op, _format_version(min(versions))))
+        # leave these the same no matter what operator we use
+        elif op in ("!=", "==", "~="):
+            version_list = sorted(
+                "{0}".format(_format_version(version))
+                for version in versions
+            )
+            version = ", ".join(version_list)
+            if len(version_list) == 1:
+                results.add((op, version))
+            elif op == "!=":
+                results.add(("not in", version))
+            elif op == "==":
+                results.add(("in", version))
+            else:
+                specifier = SpecifierSet(",".join(sorted(
+                    "{0}".format(op, v) for v in version_list
+                )))._specs
+                for s in specifier:
+                    results &= (specifier._spec[0], specifier._spec[1])
+        else:
+            if len(version) == 1:
+                results.add((op, version))
+            else:
+                specifier = SpecifierSet("{0}".format(version))._specs
+                for s in specifier:
+                    results |= (specifier._spec[0], specifier._spec[1])
+    return results
+
+
+def pyspec_from_markers(marker):
+    if marker._markers[0][0] != 'python_version':
+        return
+    op = marker._markers[0][1].value
+    version = marker._markers[0][2].value
+    specset = set()
+    if op == "in":
+        specset.update(
+            Specifier("=={0}".format(v.strip()))
+            for v in version.split(",")
+        )
+    elif op == "not in":
+        specset.update(
+            Specifier("!={0}".format(v.strip()))
+            for v in version.split(",")
+        )
+    else:
+        specset.add(Specifier("".join([op, version])))
+    if specset:
+        return specset
+    return None
diff --git a/pipenv/vendor/passa/internals/traces.py b/pipenv/vendor/passa/internals/traces.py
new file mode 100644
index 00000000..9715db97
--- /dev/null
+++ b/pipenv/vendor/passa/internals/traces.py
@@ -0,0 +1,40 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+
+def _trace_visit_vertex(graph, current, target, visited, path, paths):
+    if current == target:
+        paths.append(path)
+        return
+    for v in graph.iter_children(current):
+        if v == current or v in visited:
+            continue
+        next_path = path + [current]
+        next_visited = visited | {current}
+        _trace_visit_vertex(graph, v, target, next_visited, next_path, paths)
+
+
+def trace_graph(graph):
+    """Build a collection of "traces" for each package.
+
+    A trace is a list of names that eventually leads to the package. For
+    example, if A and B are root dependencies, A depends on C and D, B
+    depends on C, and C depends on D, the return value would be like::
+
+        {
+            None: [],
+            "A": [None],
+            "B": [None],
+            "C": [[None, "A"], [None, "B"]],
+            "D": [[None, "B", "C"], [None, "A"]],
+        }
+    """
+    result = {None: []}
+    for vertex in graph:
+        result[vertex] = []
+        for root in graph.iter_children(None):
+            paths = []
+            _trace_visit_vertex(graph, root, vertex, {None}, [None], paths)
+            result[vertex].extend(paths)
+    return result
diff --git a/pipenv/vendor/passa/internals/utils.py b/pipenv/vendor/passa/internals/utils.py
new file mode 100644
index 00000000..8f8e6fd0
--- /dev/null
+++ b/pipenv/vendor/passa/internals/utils.py
@@ -0,0 +1,118 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+
+def identify_requirment(r):
+    """Produce an identifier for a requirement to use in the resolver.
+
+    Note that we are treating the same package with different extras as
+    distinct. This allows semantics like "I only want this extra in
+    development, not production".
+
+    This also makes the resolver's implementation much simpler, with the minor
+    costs of possibly needing a few extra resolution steps if we happen to have
+    the same package apprearing multiple times.
+    """
+    return "{0}{1}".format(r.normalized_name, r.extras_as_pip)
+
+
+def get_pinned_version(ireq):
+    """Get the pinned version of an InstallRequirement.
+
+    An InstallRequirement is considered pinned if:
+
+    - Is not editable
+    - It has exactly one specifier
+    - That specifier is "=="
+    - The version does not contain a wildcard
+
+    Examples:
+        django==1.8   # pinned
+        django>1.8    # NOT pinned
+        django~=1.8   # NOT pinned
+        django==1.*   # NOT pinned
+
+    Raises `TypeError` if the input is not a valid InstallRequirement, or
+    `ValueError` if the InstallRequirement is not pinned.
+    """
+    try:
+        specifier = ireq.specifier
+    except AttributeError:
+        raise TypeError("Expected InstallRequirement, not {}".format(
+            type(ireq).__name__,
+        ))
+
+    if ireq.editable:
+        raise ValueError("InstallRequirement is editable")
+    if not specifier:
+        raise ValueError("InstallRequirement has no version specification")
+    if len(specifier._specs) != 1:
+        raise ValueError("InstallRequirement has multiple specifications")
+
+    op, version = next(iter(specifier._specs))._spec
+    if op not in ('==', '===') or version.endswith('.*'):
+        raise ValueError("InstallRequirement not pinned (is {0!r})".format(
+            op + version,
+        ))
+
+    return version
+
+
+def is_pinned(ireq):
+    """Returns whether an InstallRequirement is a "pinned" requirement.
+
+    An InstallRequirement is considered pinned if:
+
+    - Is not editable
+    - It has exactly one specifier
+    - That specifier is "=="
+    - The version does not contain a wildcard
+
+    Examples:
+        django==1.8   # pinned
+        django>1.8    # NOT pinned
+        django~=1.8   # NOT pinned
+        django==1.*   # NOT pinned
+    """
+    try:
+        get_pinned_version(ireq)
+    except (TypeError, ValueError):
+        return False
+    return True
+
+
+def filter_sources(requirement, sources):
+    """Returns a filtered list of sources for this requirement.
+
+    This considers the index specified by the requirement, and returns only
+    matching source entries if there is at least one.
+    """
+    if not sources or not requirement.index:
+        return sources
+    filtered_sources = [
+        source for source in sources
+        if source.get("name") == requirement.index
+    ]
+    return filtered_sources or sources
+
+
+def get_allow_prereleases(requirement, global_setting):
+    # TODO: Implement per-package prereleases flag. (pypa/pipenv#1696)
+    return global_setting
+
+
+def are_requirements_equal(this, that):
+    return (
+        this.as_line(include_hashes=False) ==
+        that.as_line(include_hashes=False)
+    )
+
+
+def strip_extras(requirement):
+    """Returns a new requirement object with extras removed.
+    """
+    line = requirement.as_line()
+    new = type(requirement).from_line(line)
+    new.extras = None
+    return new
diff --git a/pipenv/vendor/passa/models/__init__.py b/pipenv/vendor/passa/models/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/pipenv/vendor/passa/models/caches.py b/pipenv/vendor/passa/models/caches.py
new file mode 100644
index 00000000..c6d29b5e
--- /dev/null
+++ b/pipenv/vendor/passa/models/caches.py
@@ -0,0 +1,214 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+import copy
+import hashlib
+import json
+import os
+import sys
+
+import appdirs
+import pip_shims
+import requests
+import vistir
+
+from ..internals._pip_shims import VCS_SUPPORT
+from ..internals.utils import get_pinned_version
+
+
+CACHE_DIR = os.environ.get("PASSA_CACHE_DIR", appdirs.user_cache_dir("passa"))
+
+
+class HashCache(pip_shims.SafeFileCache):
+    """Caches hashes of PyPI artifacts so we do not need to re-download them.
+
+    Hashes are only cached when the URL appears to contain a hash in it and the
+    cache key includes the hash value returned from the server). This ought to
+    avoid ssues where the location on the server changes.
+    """
+    def __init__(self, *args, **kwargs):
+        session = kwargs.pop('session', requests.session())
+        self.session = session
+        kwargs.setdefault('directory', os.path.join(CACHE_DIR, 'hash-cache'))
+        super(HashCache, self).__init__(*args, **kwargs)
+
+    def get_hash(self, location):
+        # If there is no location hash (i.e., md5, sha256, etc.), we don't want
+        # to store it.
+        hash_value = None
+        orig_scheme = location.scheme
+        new_location = copy.deepcopy(location)
+        if orig_scheme in VCS_SUPPORT.all_schemes:
+            new_location.url = new_location.url.split("+", 1)[-1]
+        can_hash = new_location.hash
+        if can_hash:
+            # hash url WITH fragment
+            hash_value = self.get(new_location.url)
+        if not hash_value:
+            hash_value = self._get_file_hash(new_location)
+            hash_value = hash_value.encode('utf8')
+        if can_hash:
+            self.set(new_location.url, hash_value)
+        return hash_value.decode('utf8')
+
+    def _get_file_hash(self, location):
+        h = hashlib.new(pip_shims.FAVORITE_HASH)
+        with vistir.open_file(location, self.session) as fp:
+            for chunk in iter(lambda: fp.read(8096), b""):
+                h.update(chunk)
+        return ":".join([h.name, h.hexdigest()])
+
+
+# pip-tools's dependency cache implementation.
+class CorruptCacheError(Exception):
+    def __init__(self, path):
+        self.path = path
+
+    def __str__(self):
+        lines = [
+            'The dependency cache seems to have been corrupted.',
+            'Inspect, or delete, the following file:',
+            '  {}'.format(self.path),
+        ]
+        return os.linesep.join(lines)
+
+
+def _key_from_req(req):
+    """Get an all-lowercase version of the requirement's name."""
+    if hasattr(req, 'key'):
+        # from pkg_resources, such as installed dists for pip-sync
+        key = req.key
+    else:
+        # from packaging, such as install requirements from requirements.txt
+        key = req.name
+
+    key = key.replace('_', '-').lower()
+    return key
+
+
+def _read_cache_file(cache_file_path):
+    with open(cache_file_path, 'r') as cache_file:
+        try:
+            doc = json.load(cache_file)
+        except ValueError:
+            raise CorruptCacheError(cache_file_path)
+
+        # Check version and load the contents
+        assert doc['__format__'] == 1, 'Unknown cache file format'
+        return doc['dependencies']
+
+
+class _JSONCache(object):
+    """A persistent cache backed by a JSON file.
+
+    The cache file is written to the appropriate user cache dir for the
+    current platform, i.e.
+
+        ~/.cache/pip-tools/depcache-pyX.Y.json
+
+    Where X.Y indicates the Python version.
+    """
+    filename_format = None
+
+    def __init__(self, cache_dir=CACHE_DIR):
+        vistir.mkdir_p(cache_dir)
+        python_version = ".".join(str(digit) for digit in sys.version_info[:2])
+        cache_filename = self.filename_format.format(
+            python_version=python_version,
+        )
+        self._cache_file = os.path.join(cache_dir, cache_filename)
+        self._cache = None
+
+    @property
+    def cache(self):
+        """The dictionary that is the actual in-memory cache.
+
+        This property lazily loads the cache from disk.
+        """
+        if self._cache is None:
+            self.read_cache()
+        return self._cache
+
+    def as_cache_key(self, ireq):
+        """Given a requirement, return its cache key.
+
+        This behavior is a little weird in order to allow backwards
+        compatibility with cache files. For a requirement without extras, this
+        will return, for example::
+
+            ("ipython", "2.1.0")
+
+        For a requirement with extras, the extras will be comma-separated and
+        appended to the version, inside brackets, like so::
+
+            ("ipython", "2.1.0[nbconvert,notebook]")
+        """
+        extras = tuple(sorted(ireq.extras))
+        if not extras:
+            extras_string = ""
+        else:
+            extras_string = "[{}]".format(",".join(extras))
+        name = _key_from_req(ireq.req)
+        version = get_pinned_version(ireq)
+        return name, "{}{}".format(version, extras_string)
+
+    def read_cache(self):
+        """Reads the cached contents into memory.
+        """
+        if os.path.exists(self._cache_file):
+            self._cache = _read_cache_file(self._cache_file)
+        else:
+            self._cache = {}
+
+    def write_cache(self):
+        """Writes the cache to disk as JSON.
+        """
+        doc = {
+            '__format__': 1,
+            'dependencies': self._cache,
+        }
+        with open(self._cache_file, 'w') as f:
+            json.dump(doc, f, sort_keys=True)
+
+    def clear(self):
+        self._cache = {}
+        self.write_cache()
+
+    def __contains__(self, ireq):
+        pkgname, pkgversion_and_extras = self.as_cache_key(ireq)
+        return pkgversion_and_extras in self.cache.get(pkgname, {})
+
+    def __getitem__(self, ireq):
+        pkgname, pkgversion_and_extras = self.as_cache_key(ireq)
+        return self.cache[pkgname][pkgversion_and_extras]
+
+    def __setitem__(self, ireq, values):
+        pkgname, pkgversion_and_extras = self.as_cache_key(ireq)
+        self.cache.setdefault(pkgname, {})
+        self.cache[pkgname][pkgversion_and_extras] = values
+        self.write_cache()
+
+    def __delitem__(self, ireq):
+        pkgname, pkgversion_and_extras = self.as_cache_key(ireq)
+        try:
+            del self.cache[pkgname][pkgversion_and_extras]
+        except KeyError:
+            return
+        self.write_cache()
+
+    def get(self, ireq, default=None):
+        pkgname, pkgversion_and_extras = self.as_cache_key(ireq)
+        return self.cache.get(pkgname, {}).get(pkgversion_and_extras, default)
+
+
+class DependencyCache(_JSONCache):
+    """Cache the dependency of cancidates.
+    """
+    filename_format = "depcache-py{python_version}.json"
+
+
+class RequiresPythonCache(_JSONCache):
+    """Cache a candidate's Requires-Python information.
+    """
+    filename_format = "pyreqcache-py{python_version}.json"
diff --git a/pipenv/vendor/passa/models/lockers.py b/pipenv/vendor/passa/models/lockers.py
new file mode 100644
index 00000000..c25ca60d
--- /dev/null
+++ b/pipenv/vendor/passa/models/lockers.py
@@ -0,0 +1,214 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+import itertools
+
+import resolvelib
+
+import plette
+import requirementslib
+import vistir
+
+from ..internals.hashes import get_hashes
+from ..internals.reporters import StdOutReporter
+from ..internals.traces import trace_graph
+from ..internals.utils import identify_requirment
+from .caches import HashCache
+from .metadata import set_metadata
+from .providers import BasicProvider, EagerUpgradeProvider, PinReuseProvider
+
+
+def _get_requirements(model, section_name):
+    """Produce a mapping of identifier: requirement from the section.
+    """
+    if not model:
+        return {}
+    return {identify_requirment(r): r for r in (
+        requirementslib.Requirement.from_pipfile(name, package._data)
+        for name, package in model.get(section_name, {}).items()
+    )}
+
+
+def _get_requires_python(pipfile):
+    try:
+        requires = pipfile.requires
+    except AttributeError:
+        return ""
+    try:
+        return requires.python_full_version
+    except AttributeError:
+        pass
+    try:
+        return requires.python_version
+    except AttributeError:
+        return ""
+
+
+def _collect_derived_entries(state, traces, identifiers):
+    """Produce a mapping containing all candidates derived from `identifiers`.
+
+    `identifiers` should provide a collection of requirement identifications
+    from a section (i.e. `packages` or `dev-packages`). This function uses
+    `trace` to filter out candidates in the state that are present because of
+    an entry in that collection.
+    """
+    identifiers = set(identifiers)
+    if not identifiers:
+        return {}
+
+    entries = {}
+    extras = {}
+    for identifier, requirement in state.mapping.items():
+        routes = {trace[1] for trace in traces[identifier] if len(trace) > 1}
+        if identifier not in identifiers and not (identifiers & routes):
+            continue
+        name = requirement.normalized_name
+        if requirement.extras:
+            # Aggregate extras from multiple routes so we can produce their
+            # union in the lock file. (sarugaku/passa#24)
+            try:
+                extras[name].extend(requirement.extras)
+            except KeyError:
+                extras[name] = list(requirement.extras)
+        entries[name] = next(iter(requirement.as_pipfile().values()))
+    for name, ext in extras.items():
+        entries[name]["extras"] = ext
+
+    return entries
+
+
+class AbstractLocker(object):
+    """Helper class to produce a new lock file for a project.
+
+    This is not intended for instantiation. You should use one of its concrete
+    subclasses instead. The class contains logic to:
+
+    * Prepare a project for locking
+    * Perform the actually resolver invocation
+    * Convert resolver output into lock file format
+    * Update the project to have the new lock file
+    """
+    def __init__(self, project):
+        self.project = project
+        self.default_requirements = _get_requirements(
+            project.pipfile, "packages",
+        )
+        self.develop_requirements = _get_requirements(
+            project.pipfile, "dev-packages",
+        )
+
+        # This comprehension dance ensures we merge packages from both
+        # sections, and definitions in the default section win.
+        self.requirements = {k: r for k, r in itertools.chain(
+            self.develop_requirements.items(),
+            self.default_requirements.items(),
+        )}.values()
+
+        self.sources = [s._data.copy() for s in project.pipfile.sources]
+        self.allow_prereleases = bool(
+            project.pipfile.get("pipenv", {}).get("allow_prereleases", False),
+        )
+        self.requires_python = _get_requires_python(project.pipfile)
+
+    def __repr__(self):
+        return "<{0} @ {1!r}>".format(type(self).__name__, self.project.root)
+
+    def get_provider(self):
+        raise NotImplementedError
+
+    def get_reporter(self):
+        # TODO: Build SpinnerReporter, and use this only in verbose mode.
+        return StdOutReporter(self.requirements)
+
+    def lock(self):
+        """Lock specified (abstract) requirements into (concrete) candidates.
+
+        The locking procedure consists of four stages:
+
+        * Resolve versions and dependency graph (powered by ResolveLib).
+        * Walk the graph to determine "why" each candidate came to be, i.e.
+          what top-level requirements result in a given candidate.
+        * Populate hashes for resolved candidates.
+        * Populate markers based on dependency specifications of each
+          candidate, and the dependency graph.
+        """
+        provider = self.get_provider()
+        reporter = self.get_reporter()
+        resolver = resolvelib.Resolver(provider, reporter)
+
+        with vistir.cd(self.project.root):
+            state = resolver.resolve(self.requirements)
+
+        traces = trace_graph(state.graph)
+
+        hash_cache = HashCache()
+        for r in state.mapping.values():
+            if not r.hashes:
+                r.hashes = get_hashes(hash_cache, r)
+
+        set_metadata(
+            state.mapping, traces,
+            provider.fetched_dependencies,
+            provider.collected_requires_pythons,
+        )
+
+        lockfile = plette.Lockfile.with_meta_from(self.project.pipfile)
+        lockfile["default"] = _collect_derived_entries(
+            state, traces, self.default_requirements,
+        )
+        lockfile["develop"] = _collect_derived_entries(
+            state, traces, self.develop_requirements,
+        )
+        self.project.lockfile = lockfile
+
+
+class BasicLocker(AbstractLocker):
+    """Basic concrete locker.
+
+    This takes a project, generates a lock file from its Pipfile, and sets
+    the lock file property to the project.
+    """
+    def get_provider(self):
+        return BasicProvider(
+            self.requirements, self.sources,
+            self.requires_python, self.allow_prereleases,
+        )
+
+
+class PinReuseLocker(AbstractLocker):
+    """A specialized locker to handle re-locking based on existing pins.
+
+    See :class:`.providers.PinReuseProvider` for more information.
+    """
+    def __init__(self, project):
+        super(PinReuseLocker, self).__init__(project)
+        pins = _get_requirements(project.lockfile, "develop")
+        pins.update(_get_requirements(project.lockfile, "default"))
+        for pin in pins.values():
+            pin.markers = None
+        self.preferred_pins = pins
+
+    def get_provider(self):
+        return PinReuseProvider(
+            self.preferred_pins, self.requirements, self.sources,
+            self.requires_python, self.allow_prereleases,
+        )
+
+
+class EagerUpgradeLocker(PinReuseLocker):
+    """A specialized locker to handle the "eager" upgrade strategy.
+
+    See :class:`.providers.EagerUpgradeProvider` for more
+    information.
+    """
+    def __init__(self, tracked_names, *args, **kwargs):
+        super(EagerUpgradeLocker, self).__init__(*args, **kwargs)
+        self.tracked_names = tracked_names
+
+    def get_provider(self):
+        return EagerUpgradeProvider(
+            self.tracked_names, self.preferred_pins,
+            self.requirements, self.sources,
+            self.requires_python, self.allow_prereleases,
+        )
diff --git a/pipenv/vendor/passa/models/metadata.py b/pipenv/vendor/passa/models/metadata.py
new file mode 100644
index 00000000..a949f1e9
--- /dev/null
+++ b/pipenv/vendor/passa/models/metadata.py
@@ -0,0 +1,169 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+import copy
+import itertools
+
+import packaging.markers
+import packaging.specifiers
+import vistir
+import vistir.misc
+
+from ..internals.markers import get_without_extra
+from ..internals.specifiers import cleanup_pyspecs, pyspec_from_markers
+
+
+def dedup_markers(s):
+    # TODO: Implement better logic.
+    deduped = sorted(vistir.misc.dedup(s))
+    return deduped
+
+
+class MetaSet(object):
+    """Representation of a "metadata set".
+
+    This holds multiple metadata representaions. Each metadata representation
+    includes a marker, and a specifier set of Python versions required.
+    """
+    def __init__(self):
+        self.markerset = frozenset()
+        self.pyspecset = packaging.specifiers.SpecifierSet()
+
+    def __repr__(self):
+        return "MetaSet(markerset={0!r}, pyspecset={1!r})".format(
+            ",".join(sorted(self.markerset)), str(self.pyspecset),
+        )
+
+    def __str__(self):
+        pyspecs = set()
+        markerset = set()
+        for m in self.markerset:
+            marker_specs = pyspec_from_markers(packaging.markers.Marker(m))
+            if marker_specs:
+                pyspecs.add(marker_specs)
+            else:
+                markerset.add(m)
+        if pyspecs:
+            self.pyspecset._specs &= pyspecs
+            self.markerset = frozenset(markerset)
+        return " and ".join(dedup_markers(itertools.chain(
+            # Make sure to always use the same quotes so we can dedup properly.
+            (
+                "{0}".format(ms) if " or " in ms else ms
+                for ms in (str(m).replace('"', "'") for m in self.markerset)
+            ),
+            (
+                "python_version {0[0]} '{0[1]}'".format(spec)
+                for spec in cleanup_pyspecs(self.pyspecset)
+            ),
+        )))
+
+    def __bool__(self):
+        return bool(self.markerset or self.pyspecset)
+
+    def __nonzero__(self):  # Python 2.
+        return self.__bool__()
+
+    def __or__(self, pair):
+        marker, specset = pair
+        markerset = set(self.markerset)
+        if marker:
+            marker_specs = pyspec_from_markers(marker)
+            if not marker_specs:
+                markerset.add(str(marker))
+            else:
+                specset._specs &= marker_specs
+        metaset = MetaSet()
+        metaset.markerset = frozenset(markerset)
+        # TODO: Implement some logic to clean up dups like '3.0.*' and '3.0'.
+        metaset.pyspecset &= self.pyspecset & specset
+        return metaset
+
+
+def _build_metasets(dependencies, pythons, key, trace, all_metasets):
+    all_parent_metasets = []
+    for route in trace:
+        parent = route[-1]
+        try:
+            parent_metasets = all_metasets[parent]
+        except KeyError:    # Parent not calculated yet. Wait for it.
+            return
+        all_parent_metasets.append((parent, parent_metasets))
+
+    metaset_iters = []
+    for parent, parent_metasets in all_parent_metasets:
+        r = dependencies[parent][key]
+        python = pythons[key]
+        metaset = (
+            get_without_extra(r.markers),
+            packaging.specifiers.SpecifierSet(python),
+        )
+        metaset_iters.append(
+            parent_metaset | metaset
+            for parent_metaset in parent_metasets
+        )
+    return list(itertools.chain.from_iterable(metaset_iters))
+
+
+def _calculate_metasets_mapping(dependencies, pythons, traces):
+    all_metasets = {None: [MetaSet()]}
+
+    del traces[None]
+    while traces:
+        new_metasets = {}
+        for key, trace in traces.items():
+            assert key not in all_metasets, key     # Sanity check for debug.
+            metasets = _build_metasets(
+                dependencies, pythons, key, trace, all_metasets,
+            )
+            if metasets is None:
+                continue
+            new_metasets[key] = metasets
+        if not new_metasets:
+            break   # No progress? Deadlocked. Give up.
+        all_metasets.update(new_metasets)
+        for key in new_metasets:
+            del traces[key]
+
+    return all_metasets
+
+
+def _format_metasets(metasets):
+    # If there is an unconditional route, this needs to be unconditional.
+    if not metasets or not all(metasets):
+        return None
+
+    # This extra str(Marker()) call helps simplify the expression.
+    return str(packaging.markers.Marker(" or ".join(
+        "{0}".format(s) if " and " in s else s
+        for s in dedup_markers(str(metaset) for metaset in metasets
+        if metaset)
+    )))
+
+
+def set_metadata(candidates, traces, dependencies, pythons):
+    """Add "metadata" to candidates based on the dependency tree.
+
+    Metadata for a candidate includes markers and a specifier for Python
+    version requirements.
+
+    :param candidates: A key-candidate mapping. Candidates in the mapping will
+        have their markers set.
+    :param traces: A graph trace (produced by `traces.trace_graph`) providing
+        information about dependency relationships between candidates.
+    :param dependencies: A key-collection mapping containing what dependencies
+        each candidate in `candidates` requested.
+    :param pythons: A key-str mapping containing Requires-Python information
+        of each candidate.
+
+    Keys in mappings and entries in the trace are identifiers of a package, as
+    implemented by the `identify` method of the resolver's provider.
+
+    The candidates are modified in-place.
+    """
+    metasets_mapping = _calculate_metasets_mapping(
+        dependencies, pythons, copy.deepcopy(traces),
+    )
+    for key, candidate in candidates.items():
+        candidate.markers = _format_metasets(metasets_mapping[key])
diff --git a/pipenv/vendor/passa/models/projects.py b/pipenv/vendor/passa/models/projects.py
new file mode 100644
index 00000000..f6e037d6
--- /dev/null
+++ b/pipenv/vendor/passa/models/projects.py
@@ -0,0 +1,241 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+import collections
+import io
+import os
+
+import attr
+import packaging.markers
+import packaging.utils
+import plette
+import plette.models
+import six
+import tomlkit
+
+
+SectionDifference = collections.namedtuple("SectionDifference", [
+    "inthis", "inthat",
+])
+FileDifference = collections.namedtuple("FileDifference", [
+    "default", "develop",
+])
+
+
+def _are_pipfile_entries_equal(a, b):
+    a = {k: v for k, v in a.items() if k not in ("markers", "hashes", "hash")}
+    b = {k: v for k, v in b.items() if k not in ("markers", "hashes", "hash")}
+    if a != b:
+        return False
+    try:
+        marker_eval_a = packaging.markers.Marker(a["markers"]).evaluate()
+    except (AttributeError, KeyError, TypeError, ValueError):
+        marker_eval_a = True
+    try:
+        marker_eval_b = packaging.markers.Marker(b["markers"]).evaluate()
+    except (AttributeError, KeyError, TypeError, ValueError):
+        marker_eval_b = True
+    return marker_eval_a == marker_eval_b
+
+
+DEFAULT_NEWLINES = "\n"
+
+
+def preferred_newlines(f):
+    if isinstance(f.newlines, six.text_type):
+        return f.newlines
+    return DEFAULT_NEWLINES
+
+
+@attr.s
+class ProjectFile(object):
+    """A file in the Pipfile project.
+    """
+    location = attr.ib()
+    line_ending = attr.ib()
+    model = attr.ib()
+
+    @classmethod
+    def read(cls, location, model_cls, invalid_ok=False):
+        try:
+            with io.open(location, encoding="utf-8") as f:
+                model = model_cls.load(f)
+                line_ending = preferred_newlines(f)
+        except Exception:
+            if not invalid_ok:
+                raise
+            model = None
+            line_ending = DEFAULT_NEWLINES
+        return cls(location=location, line_ending=line_ending, model=model)
+
+    def write(self):
+        kwargs = {"encoding": "utf-8", "newline": self.line_ending}
+        with io.open(self.location, "w", **kwargs) as f:
+            self.model.dump(f)
+
+    def dumps(self):
+        strio = six.StringIO()
+        self.model.dump(strio)
+        return strio.getvalue()
+
+
+@attr.s
+class Project(object):
+
+    root = attr.ib()
+    _p = attr.ib(init=False)
+    _l = attr.ib(init=False)
+
+    def __attrs_post_init__(self):
+        self.root = root = os.path.abspath(self.root)
+        self._p = ProjectFile.read(
+            os.path.join(root, "Pipfile"),
+            plette.Pipfile,
+        )
+        self._l = ProjectFile.read(
+            os.path.join(root, "Pipfile.lock"),
+            plette.Lockfile,
+            invalid_ok=True,
+        )
+
+    @property
+    def pipfile(self):
+        return self._p.model
+
+    @property
+    def pipfile_location(self):
+        return self._p.location
+
+    @property
+    def lockfile(self):
+        return self._l.model
+
+    @property
+    def lockfile_location(self):
+        return self._l.location
+
+    @lockfile.setter
+    def lockfile(self, new):
+        self._l.model = new
+
+    def is_synced(self):
+        return self.lockfile and self.lockfile.is_up_to_date(self.pipfile)
+
+    def _get_pipfile_section(self, develop, insert=True):
+        name = "dev-packages" if develop else "packages"
+        try:
+            section = self.pipfile[name]
+        except KeyError:
+            section = plette.models.PackageCollection(tomlkit.table())
+            if insert:
+                self.pipfile[name] = section
+        return section
+
+    def contains_key_in_pipfile(self, key):
+        sections = [
+            self._get_pipfile_section(develop=False, insert=False),
+            self._get_pipfile_section(develop=True, insert=False),
+        ]
+        return any(
+            (packaging.utils.canonicalize_name(name) ==
+             packaging.utils.canonicalize_name(key))
+            for section in sections
+            for name in section
+        )
+
+    def add_line_to_pipfile(self, line, develop):
+        from requirementslib import Requirement
+        requirement = Requirement.from_line(line)
+        section = self._get_pipfile_section(develop=develop)
+        key = requirement.normalized_name
+        entry = next(iter(requirement.as_pipfile().values()))
+        if isinstance(entry, dict):
+            # HACK: TOMLKit prefers to expand tables by default, but we
+            # always want inline tables here. Also tomlkit.inline_table
+            # does not have `update()`.
+            table = tomlkit.inline_table()
+            for k, v in entry.items():
+                table[k] = v
+            entry = table
+        section[key] = entry
+
+    def remove_keys_from_pipfile(self, keys, default, develop):
+        keys = {packaging.utils.canonicalize_name(key) for key in keys}
+        sections = []
+        if default:
+            sections.append(self._get_pipfile_section(
+                develop=False, insert=False,
+            ))
+        if develop:
+            sections.append(self._get_pipfile_section(
+                develop=True, insert=False,
+            ))
+        for section in sections:
+            removals = set()
+            for name in section:
+                if packaging.utils.canonicalize_name(name) in keys:
+                    removals.add(name)
+            for key in removals:
+                del section._data[key]
+
+    def remove_keys_from_lockfile(self, keys):
+        keys = {packaging.utils.canonicalize_name(key) for key in keys}
+        removed = False
+        for section_name in ("default", "develop"):
+            try:
+                section = self.lockfile[section_name]
+            except KeyError:
+                continue
+            removals = set()
+            for name in section:
+                if packaging.utils.canonicalize_name(name) in keys:
+                    removals.add(name)
+            removed = removed or bool(removals)
+            for key in removals:
+                del section._data[key]
+
+        if removed:
+            # HACK: The lock file no longer represents the Pipfile at this
+            # point. Set the hash to an arbitrary invalid value.
+            self.lockfile.meta.hash = plette.models.Hash({"__invalid__": ""})
+
+    def difference_lockfile(self, lockfile):
+        """Generate a difference between the current and given lockfiles.
+
+        Returns a 2-tuple containing differences in default in develop
+        sections.
+
+        Each element is a 2-tuple of dicts. The first, `inthis`, contains
+        entries only present in the current lockfile; the second, `inthat`,
+        contains entries only present in the given one.
+
+        If a key exists in both this and that, but the values differ, the key
+        is present in both dicts, pointing to values from each file.
+        """
+        diff_data = {
+            "default": SectionDifference({}, {}),
+            "develop": SectionDifference({}, {}),
+        }
+        for section_name, section_diff in diff_data.items():
+            try:
+                this = self.lockfile[section_name]._data
+            except (KeyError, TypeError):
+                this = {}
+            try:
+                that = lockfile[section_name]._data
+            except (KeyError, TypeError):
+                that = {}
+            for key, this_value in this.items():
+                try:
+                    that_value = that[key]
+                except KeyError:
+                    section_diff.inthis[key] = this_value
+                    continue
+                if not _are_pipfile_entries_equal(this_value, that_value):
+                    section_diff.inthis[key] = this_value
+                    section_diff.inthat[key] = that_value
+            for key, that_value in that.items():
+                if key not in this:
+                    section_diff.inthat[key] = that_value
+        return FileDifference(**diff_data)
diff --git a/pipenv/vendor/passa/models/providers.py b/pipenv/vendor/passa/models/providers.py
new file mode 100644
index 00000000..36b2f2ea
--- /dev/null
+++ b/pipenv/vendor/passa/models/providers.py
@@ -0,0 +1,198 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+import os
+
+import resolvelib
+
+from ..internals.candidates import find_candidates
+from ..internals.dependencies import get_dependencies
+from ..internals.utils import (
+    filter_sources, get_allow_prereleases, identify_requirment, strip_extras,
+)
+
+
+PROTECTED_PACKAGE_NAMES = {"pip", "setuptools"}
+
+
+class BasicProvider(resolvelib.AbstractProvider):
+    """Provider implementation to interface with `requirementslib.Requirement`.
+    """
+    def __init__(self, root_requirements, sources,
+                 requires_python, allow_prereleases):
+        self.sources = sources
+        self.requires_python = requires_python
+        self.allow_prereleases = bool(allow_prereleases)
+        self.invalid_candidates = set()
+
+        # Remember requirements of each pinned candidate. The resolver calls
+        # `get_dependencies()` only when it wants to repin, so the last time
+        # the dependencies we got when it is last called on a package, are
+        # the set used by the resolver. We use this later to trace how a given
+        # dependency is specified by a package.
+        self.fetched_dependencies = {None: {
+            self.identify(r): r for r in root_requirements
+        }}
+
+        # Should Pipfile's requires.python_[full_]version be included?
+        self.collected_requires_pythons = {None: ""}
+
+    def identify(self, dependency):
+        return identify_requirment(dependency)
+
+    def get_preference(self, resolution, candidates, information):
+        # TODO: Provide better sorting logic. This simply resolve the ones with
+        # less choices first. Not sophisticated, but sounds reasonable?
+        return len(candidates)
+
+    def find_matches(self, requirement):
+        sources = filter_sources(requirement, self.sources)
+        candidates = find_candidates(
+            requirement, sources, self.requires_python,
+            get_allow_prereleases(requirement, self.allow_prereleases),
+        )
+        return candidates
+
+    def is_satisfied_by(self, requirement, candidate):
+        # A non-named requirement has exactly one candidate, as implemented in
+        # `find_matches()`. Since pip does not yet implement URL based lookup
+        # (PEP 508) yet, it must match unless there are duplicated entries in
+        # Pipfile. If there is, the user takes the blame. (sarugaku/passa#34)
+        if not requirement.is_named:
+            return True
+
+        # A non-named candidate can only come from a non-named requirement,
+        # which, since pip does not implement URL based lookup (PEP 508) yet,
+        # can only come from Pipfile. Assume the user knows what they're doing,
+        # and use it without checking. (sarugaku/passa#34)
+        if not candidate.is_named:
+            return True
+
+        # Optimization: Everything matches if there are no specifiers.
+        if not requirement.specifiers:
+            return True
+
+        # We can't handle old version strings before PEP 440. Drop them all.
+        # Practically this shouldn't be a problem if the user is specifying a
+        # remotely reasonable dependency not from before 2013.
+        candidate_line = candidate.as_line(include_hashes=False)
+        if candidate_line in self.invalid_candidates:
+            return False
+        try:
+            version = candidate.get_specifier().version
+        except (TypeError, ValueError):
+            print('ignoring invalid version from {!r}'.format(candidate_line))
+            self.invalid_candidates.add(candidate_line)
+            return False
+
+        return requirement.as_ireq().specifier.contains(version)
+
+    def get_dependencies(self, candidate):
+        sources = filter_sources(candidate, self.sources)
+        try:
+            dependencies, requires_python = get_dependencies(
+                candidate, sources=sources,
+            )
+        except Exception as e:
+            if os.environ.get("PASSA_NO_SUPPRESS_EXCEPTIONS"):
+                raise
+            print("failed to get dependencies for {0!r}: {1}".format(
+                candidate.as_line(include_hashes=False), e,
+            ))
+            dependencies = []
+            requires_python = ""
+        # Exclude protected packages from the list. This prevents those
+        # packages from being locked, unless the user is actually working on
+        # them, and explicitly lists them as top-level requirements -- those
+        # packages are not added via this code path. (sarugaku/passa#15)
+        dependencies = [
+            dependency for dependency in dependencies
+            if dependency.normalized_name not in PROTECTED_PACKAGE_NAMES
+        ]
+        if candidate.extras:
+            # HACK: If this candidate has extras, add the original candidate
+            # (same pinned version, no extras) as its dependency. This ensures
+            # the same package with different extras (treated as distinct by
+            # the resolver) have the same version. (sarugaku/passa#4)
+            dependencies.append(strip_extras(candidate))
+        candidate_key = self.identify(candidate)
+        self.fetched_dependencies[candidate_key] = {
+            self.identify(r): r for r in dependencies
+        }
+        self.collected_requires_pythons[candidate_key] = requires_python
+        return dependencies
+
+
+class PinReuseProvider(BasicProvider):
+    """A provider that reuses preferred pins if possible.
+
+    This is used to implement "add", "remove", and "only-if-needed upgrade",
+    where already-pinned candidates in Pipfile.lock should be preferred.
+    """
+    def __init__(self, preferred_pins, *args, **kwargs):
+        super(PinReuseProvider, self).__init__(*args, **kwargs)
+        self.preferred_pins = preferred_pins
+
+    def find_matches(self, requirement):
+        candidates = super(PinReuseProvider, self).find_matches(requirement)
+        try:
+            # Add the preferred pin. Remember the resolve prefer candidates
+            # at the end of the list, so the most preferred should be last.
+            candidates.append(self.preferred_pins[self.identify(requirement)])
+        except KeyError:
+            pass
+        return candidates
+
+
+class EagerUpgradeProvider(PinReuseProvider):
+    """A specialized provider to handle an "eager" upgrade strategy.
+
+    An eager upgrade tries to upgrade not only packages specified, but also
+    their dependencies (recursively). This contrasts to the "only-if-needed"
+    default, which only promises to upgrade the specified package, and
+    prevents touching anything else if at all possible.
+
+    The provider is implemented as to keep track of all dependencies of the
+    specified packages to upgrade, and free their pins when it has a chance.
+    """
+    def __init__(self, tracked_names, *args, **kwargs):
+        super(EagerUpgradeProvider, self).__init__(*args, **kwargs)
+        self.tracked_names = set(tracked_names)
+        for name in tracked_names:
+            self.preferred_pins.pop(name, None)
+
+        # HACK: Set this special flag to distinguish preferred pins from
+        # regular, to tell the resolver to NOT use them for tracked packages.
+        for pin in self.preferred_pins.values():
+            pin._preferred_by_provider = True
+
+    def is_satisfied_by(self, requirement, candidate):
+        # If this is a tracking package, tell the resolver out of using the
+        # preferred pin, and into a "normal" candidate selection process.
+        if (self.identify(requirement) in self.tracked_names and
+                getattr(candidate, "_preferred_by_provider", False)):
+            return False
+        return super(EagerUpgradeProvider, self).is_satisfied_by(
+            requirement, candidate,
+        )
+
+    def get_dependencies(self, candidate):
+        # If this package is being tracked for upgrade, remove pins of its
+        # dependencies, and start tracking these new packages.
+        dependencies = super(EagerUpgradeProvider, self).get_dependencies(
+            candidate,
+        )
+        if self.identify(candidate) in self.tracked_names:
+            for dependency in dependencies:
+                name = self.identify(dependency)
+                self.tracked_names.add(name)
+                self.preferred_pins.pop(name, None)
+        return dependencies
+
+    def get_preference(self, resolution, candidates, information):
+        # Resolve tracking packages so we have a chance to unpin them first.
+        name = self.identify(candidates[0])
+        if name in self.tracked_names:
+            return -1
+        return len(candidates)
diff --git a/pipenv/vendor/passa/models/synchronizers.py b/pipenv/vendor/passa/models/synchronizers.py
new file mode 100644
index 00000000..bad49052
--- /dev/null
+++ b/pipenv/vendor/passa/models/synchronizers.py
@@ -0,0 +1,214 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+import collections
+import contextlib
+import os
+import sys
+import sysconfig
+
+import pkg_resources
+
+import packaging.markers
+import packaging.version
+import requirementslib
+
+from ..internals._pip import uninstall, EditableInstaller, WheelInstaller
+
+
+def _is_installation_local(name):
+    """Check whether the distribution is in the current Python installation.
+
+    This is used to distinguish packages seen by a virtual environment. A venv
+    may be able to see global packages, but we don't want to mess with them.
+    """
+    loc = os.path.normcase(pkg_resources.working_set.by_key[name].location)
+    pre = os.path.normcase(sys.prefix)
+    return os.path.commonprefix([loc, pre]) == pre
+
+
+def _is_up_to_date(distro, version):
+    # This is done in strings to avoid type mismatches caused by vendering.
+    return str(version) == str(packaging.version.parse(distro.version))
+
+
+GroupCollection = collections.namedtuple("GroupCollection", [
+    "uptodate", "outdated", "noremove", "unneeded",
+])
+
+
+def _group_installed_names(packages):
+    """Group locally installed packages based on given specifications.
+
+    `packages` is a name-package mapping that are used as baseline to
+    determine how the installed package should be grouped.
+
+    Returns a 3-tuple of disjoint sets, all containing names of installed
+    packages:
+
+    * `uptodate`: These match the specifications.
+    * `outdated`: These installations are specified, but don't match the
+        specifications in `packages`.
+    * `unneeded`: These are installed, but not specified in `packages`.
+    """
+    groupcoll = GroupCollection(set(), set(), set(), set())
+
+    for distro in pkg_resources.working_set:
+        name = distro.key
+        try:
+            package = packages[name]
+        except KeyError:
+            groupcoll.unneeded.add(name)
+            continue
+
+        r = requirementslib.Requirement.from_pipfile(name, package)
+        if not r.is_named:
+            # Always mark non-named. I think pip does something similar?
+            groupcoll.outdated.add(name)
+        elif not _is_up_to_date(distro, r.get_version()):
+            groupcoll.outdated.add(name)
+        else:
+            groupcoll.uptodate.add(name)
+
+    return groupcoll
+
+
+@contextlib.contextmanager
+def _remove_package(name):
+    if name is None or not _is_installation_local(name):
+        yield None
+        return
+    with uninstall(name, auto_confirm=True, verbose=False) as uninstaller:
+        yield uninstaller
+
+
+def _get_packages(lockfile, default, develop):
+    # Don't need to worry about duplicates because only extras can differ.
+    # Extras don't matter because they only affect dependencies, and we
+    # don't install dependencies anyway!
+    packages = {}
+    if default:
+        packages.update(lockfile.default._data)
+    if develop:
+        packages.update(lockfile.develop._data)
+    return packages
+
+
+def _build_paths():
+    """Prepare paths for distlib.wheel.Wheel to install into.
+    """
+    paths = sysconfig.get_paths()
+    return {
+        "prefix": sys.prefix,
+        "data": paths["data"],
+        "scripts": paths["scripts"],
+        "headers": paths["include"],
+        "purelib": paths["purelib"],
+        "platlib": paths["platlib"],
+    }
+
+
+PROTECTED_FROM_CLEAN = {"setuptools", "pip", "wheel"}
+
+
+def _clean(names):
+    cleaned = set()
+    for name in names:
+        if name in PROTECTED_FROM_CLEAN:
+            continue
+        with _remove_package(name) as uninst:
+            if uninst:
+                cleaned.add(name)
+    return cleaned
+
+
+class Synchronizer(object):
+    """Helper class to install packages from a project's lock file.
+    """
+    def __init__(self, project, default, develop, clean_unneeded):
+        self._root = project.root   # Only for repr.
+        self.packages = _get_packages(project.lockfile, default, develop)
+        self.sources = project.lockfile.meta.sources._data
+        self.paths = _build_paths()
+        self.clean_unneeded = clean_unneeded
+
+    def __repr__(self):
+        return "<{0} @ {1!r}>".format(type(self).__name__, self._root)
+
+    def sync(self):
+        groupcoll = _group_installed_names(self.packages)
+
+        installed = set()
+        updated = set()
+        cleaned = set()
+
+        # TODO: Show a prompt to confirm cleaning. We will need to implement a
+        # reporter pattern for this as well.
+        if self.clean_unneeded:
+            names = _clean(groupcoll.unneeded)
+            cleaned.update(names)
+
+        # TODO: Specify installation order? (pypa/pipenv#2274)
+        installers = []
+        for name, package in self.packages.items():
+            r = requirementslib.Requirement.from_pipfile(name, package)
+            name = r.normalized_name
+            if name in groupcoll.uptodate:
+                continue
+            markers = r.markers
+            if markers and not packaging.markers.Marker(markers).evaluate():
+                continue
+            r.markers = None
+            if r.editable:
+                installer = EditableInstaller(r)
+            else:
+                installer = WheelInstaller(r, self.sources, self.paths)
+            try:
+                installer.prepare()
+            except Exception as e:
+                if os.environ.get("PASSA_NO_SUPPRESS_EXCEPTIONS"):
+                    raise
+                print("failed to prepare {0!r}: {1}".format(
+                    r.as_line(include_hashes=False), e,
+                ))
+            else:
+                installers.append((name, installer))
+
+        for name, installer in installers:
+            if name in groupcoll.outdated:
+                name_to_remove = name
+            else:
+                name_to_remove = None
+            try:
+                with _remove_package(name_to_remove):
+                    installer.install()
+            except Exception as e:
+                if os.environ.get("PASSA_NO_SUPPRESS_EXCEPTIONS"):
+                    raise
+                print("failed to install {0!r}: {1}".format(
+                    r.as_line(include_hashes=False), e,
+                ))
+                continue
+            if name in groupcoll.outdated or name in groupcoll.noremove:
+                updated.add(name)
+            else:
+                installed.add(name)
+
+        return installed, updated, cleaned
+
+
+class Cleaner(object):
+    """Helper class to clean packages not in a project's lock file.
+    """
+    def __init__(self, project, default, develop):
+        self._root = project.root   # Only for repr.
+        self.packages = _get_packages(project.lockfile, default, develop)
+
+    def __repr__(self):
+        return "<{0} @ {1!r}>".format(type(self).__name__, self._root)
+
+    def clean(self):
+        groupcoll = _group_installed_names(self.packages)
+        cleaned = _clean(groupcoll.unneeded)
+        return cleaned
diff --git a/pipenv/vendor/passa/operations/__init__.py b/pipenv/vendor/passa/operations/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/pipenv/vendor/passa/operations/lock.py b/pipenv/vendor/passa/operations/lock.py
new file mode 100644
index 00000000..200735ac
--- /dev/null
+++ b/pipenv/vendor/passa/operations/lock.py
@@ -0,0 +1,28 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+from resolvelib import NoVersionsAvailable, ResolutionImpossible
+
+from passa.internals.reporters import print_requirement
+
+
+def lock(locker):
+    success = False
+    try:
+        locker.lock()
+    except NoVersionsAvailable as e:
+        print("\nCANNOT RESOLVE. NO CANDIDATES FOUND FOR:")
+        print("{:>40}".format(e.requirement.as_line(include_hashes=False)))
+        if e.parent:
+            line = e.parent.as_line(include_hashes=False)
+            print("{:>41}".format("(from {})".format(line)))
+        else:
+            print("{:>41}".format("(user)"))
+    except ResolutionImpossible as e:
+        print("\nCANNOT RESOLVE.\nOFFENDING REQUIREMENTS:")
+        for r in e.requirements:
+            print_requirement(r)
+    else:
+        success = True
+    return success
diff --git a/pipenv/vendor/passa/operations/sync.py b/pipenv/vendor/passa/operations/sync.py
new file mode 100644
index 00000000..3014e8d9
--- /dev/null
+++ b/pipenv/vendor/passa/operations/sync.py
@@ -0,0 +1,23 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+
+def sync(syncer):
+    print("Starting synchronization")
+    installed, updated, cleaned = syncer.sync()
+    if cleaned:
+        print("Uninstalled: {}".format(", ".join(sorted(cleaned))))
+    if installed:
+        print("Installed: {}".format(", ".join(sorted(installed))))
+    if updated:
+        print("Updated: {}".format(", ".join(sorted(updated))))
+    return True
+
+
+def clean(cleaner):
+    print("Cleaning")
+    cleaned = cleaner.clean()
+    if cleaned:
+        print("Uninstalled: {}".format(", ".join(sorted(cleaned))))
+    return True
diff --git a/pipenv/vendor/pip_shims/__init__.py b/pipenv/vendor/pip_shims/__init__.py
index acaeee25..22bf130f 100644
--- a/pipenv/vendor/pip_shims/__init__.py
+++ b/pipenv/vendor/pip_shims/__init__.py
@@ -1,79 +1,24 @@
 # -*- coding=utf-8 -*-
 from __future__ import absolute_import
 
-__version__ = '0.1.2'
+import sys
 
-__all__ = [
-    "__version__",
-    "_strip_extras",
-    "cmdoptions",
-    "Command",
-    "ConfigOptionParser",
-    "DistributionNotFound",
-    "FAVORITE_HASH",
-    "FormatControl",
-    "get_installed_distributions",
-    "index_group",
-    "InstallRequirement",
-    "is_archive_file",
-    "is_file_url",
-    "is_installable_dir",
-    "unpack_url",
-    "Link",
-    "make_abstract_dist",
-    "make_option_group",
-    "PackageFinder",
-    "parse_requirements",
-    "parse_version",
-    "path_to_url",
-    "pip_version",
-    "PipError",
-    "RequirementPreparer",
-    "RequirementSet",
-    "RequirementTracker",
-    "Resolver",
-    "SafeFileCache",
-    "url_to_path",
-    "USER_CACHE_DIR",
-    "VcsSupport",
-    "Wheel",
-    "WheelCache",
-    "WheelBuilder"
-]
+__version__ = '0.3.2'
 
-from .shims import (
-    _strip_extras,
-    cmdoptions,
-    Command,
-    ConfigOptionParser,
-    DistributionNotFound,
-    FAVORITE_HASH,
-    FormatControl,
-    get_installed_distributions,
-    index_group,
-    InstallRequirement,
-    is_archive_file,
-    is_file_url,
-    unpack_url,
-    is_installable_dir,
-    Link,
-    make_abstract_dist,
-    make_option_group,
-    PackageFinder,
-    parse_requirements,
-    parse_version,
-    path_to_url,
-    pip_version,
-    PipError,
-    RequirementPreparer,
-    RequirementSet,
-    RequirementTracker,
-    Resolver,
-    SafeFileCache,
-    url_to_path,
-    USER_CACHE_DIR,
-    VcsSupport,
-    Wheel,
-    WheelCache,
-    WheelBuilder,
-)
+from . import shims
+
+
+old_module = sys.modules[__name__]
+
+
+module = sys.modules[__name__] = shims._new()
+module.shims = shims
+module.__dict__.update({
+    '__file__': __file__,
+    '__package__': "pip_shims",
+    '__path__': __path__,
+    '__doc__': __doc__,
+    '__all__': module.__all__ + ['shims',],
+    '__version__': __version__,
+    '__name__': __name__
+})
diff --git a/pipenv/vendor/pip_shims/shims.py b/pipenv/vendor/pip_shims/shims.py
index 5fc58beb..34de6906 100644
--- a/pipenv/vendor/pip_shims/shims.py
+++ b/pipenv/vendor/pip_shims/shims.py
@@ -1,163 +1,341 @@
 # -*- coding=utf-8 -*-
 from collections import namedtuple
 from contextlib import contextmanager
-from .utils import _parse, get_package, STRING_TYPES
 import importlib
 import os
-from pipenv.patched.notpip import __version__ as pip_version
 import sys
 
 
-has_modutil = False
-if sys.version_info[:2] >= (3, 7):
-    try:
-        import modutil
-    except ImportError:
-        has_modutil = False
-    else:
-        has_modutil = True
+import six
+six.add_move(six.MovedAttribute("Callable", "collections", "collections.abc"))
+from six.moves import Callable
 
 
-BASE_IMPORT_PATH = os.environ.get("PIP_SHIMS_BASE_MODULE", "pip")
-path_info = namedtuple("PathInfo", "path start_version end_version")
-parsed_pip_version = _parse(pip_version)
+class _shims(object):
+    CURRENT_PIP_VERSION  = "18.1"
+    BASE_IMPORT_PATH = os.environ.get("PIP_SHIMS_BASE_MODULE", "pip")
+    path_info = namedtuple("PathInfo", "path start_version end_version")
 
+    def __dir__(self):
+        result = list(self._locations.keys()) + list(self.__dict__.keys())
+        result.extend(('__file__', '__doc__', '__all__',
+                       '__docformat__', '__name__', '__path__',
+                       '__package__', '__version__'))
+        return result
 
-def is_valid(path_info_tuple):
-    if (
-        path_info_tuple.start_version <= parsed_pip_version
-        and path_info_tuple.end_version >= parsed_pip_version
-    ):
-        return 1
-    return 0
+    @classmethod
+    def _new(cls):
+        return cls()
 
+    @property
+    def __all__(self):
+        return list(self._locations.keys())
 
-def get_ordered_paths(module_paths, base_path):
-    if not isinstance(module_paths, list):
-        module_paths = [module_paths]
-    prefix_order = [pth.format(base_path) for pth in ["{0}._internal", "{0}"]]
-    if _parse(pip_version) < _parse("10.0.0"):
-        prefix_order = reversed(prefix_order)
-    paths = sorted(module_paths, key=is_valid, reverse=True)
-    search_order = [
-        "{0}.{1}".format(p, pth.path)
-        for p in prefix_order
-        for pth in paths
-        if pth is not None
-    ]
-    return search_order
+    def __init__(self):
+        # from .utils import _parse, get_package, STRING_TYPES
+        from . import utils
+        self.utils = utils
+        self._parse = utils._parse
+        self.get_package = utils.get_package
+        self.STRING_TYPES = utils.STRING_TYPES
+        self._modules = {
+            "pip": importlib.import_module(self.BASE_IMPORT_PATH),
+            "pip_shims.utils": utils
+        }
+        self.pip_version = getattr(self._modules["pip"], "__version__")
+        version_types = ["post", "pre", "dev", "rc"]
+        if any(post in self.pip_version.rsplit(".")[-1] for post in version_types):
+            self.pip_version, _, _ = self.pip_version.rpartition(".")
+        self.parsed_pip_version = self._parse(self.pip_version)
+        self._contextmanagers = ("RequirementTracker",)
+        self._moves = {
+            "InstallRequirement": {
+                "from_editable": "install_req_from_editable",
+                "from_line": "install_req_from_line",
+            }
+        }
+        self._locations = {
+            "parse_version": ("index.parse_version", "7", "9999"),
+            "_strip_extras": (
+                ("req.req_install._strip_extras", "7", "18.0"),
+                ("req.constructors._strip_extras", "18.1", "9999"),
+            ),
+            "cmdoptions": (
+                ("cli.cmdoptions", "18.1", "9999"),
+                ("cmdoptions", "7.0.0", "18.0")
+            ),
+            "Command": (
+                ("cli.base_command.Command", "18.1", "9999"),
+                ("basecommand.Command", "7.0.0", "18.0")
+            ),
+            "ConfigOptionParser": (
+                ("cli.parser.ConfigOptionParser", "18.1", "9999"),
+                ("baseparser.ConfigOptionParser", "7.0.0", "18.0")
+            ),
+            "DistributionNotFound": ("exceptions.DistributionNotFound", "7.0.0", "9999"),
+            "FAVORITE_HASH": ("utils.hashes.FAVORITE_HASH", "7.0.0", "9999"),
+            "FormatControl": (
+                ("models.format_control.FormatControl", "18.1", "9999"),
+                ("index.FormatControl", "7.0.0", "18.0"),
+            ),
+            "FrozenRequirement": (
+                ("FrozenRequirement", "7.0.0", "9.0.3"),
+                ("operations.freeze.FrozenRequirement", "10.0.0", "9999")
+            ),
+            "get_installed_distributions": (
+                ("utils.misc.get_installed_distributions", "10", "9999"),
+                ("utils.get_installed_distributions", "7", "9.0.3")
+            ),
+            "index_group": (
+                ("cli.cmdoptions.index_group", "18.1", "9999"),
+                ("cmdoptions.index_group", "7.0.0", "18.0")
+            ),
+            "InstallRequirement": ("req.req_install.InstallRequirement", "7.0.0", "9999"),
+            "InstallationError": ("exceptions.InstallationError", "7.0.0", "9999"),
+            "UninstallationError": ("exceptions.UninstallationError", "7.0.0", "9999"),
+            "DistributionNotFound": ("exceptions.DistributionNotFound", "7.0.0", "9999"),
+            "RequirementsFileParseError": ("exceptions.RequirementsFileParseError", "7.0.0", "9999"),
+            "BestVersionAlreadyInstalled": ("exceptions.BestVersionAlreadyInstalled", "7.0.0", "9999"),
+            "BadCommand": ("exceptions.BadCommand", "7.0.0", "9999"),
+            "CommandError": ("exceptions.CommandError", "7.0.0", "9999"),
+            "PreviousBuildDirError": ("exceptions.PreviousBuildDirError", "7.0.0", "9999"),
+            "install_req_from_editable": (
+                ("req.constructors.install_req_from_editable", "18.1", "9999"),
+                ("req.req_install.InstallRequirement.from_editable", "7.0.0", "18.0")
+            ),
+            "install_req_from_line": (
+                ("req.constructors.install_req_from_line", "18.1", "9999"),
+                ("req.req_install.InstallRequirement.from_line", "7.0.0", "18.0")
+            ),
+            "is_archive_file": ("download.is_archive_file", "7.0.0", "9999"),
+            "is_file_url": ("download.is_file_url", "7.0.0", "9999"),
+            "unpack_url": ("download.unpack_url", "7.0.0", "9999"),
+            "is_installable_dir": (
+                ("utils.misc.is_installable_dir", "10.0.0", "9999"),
+                ("utils.is_installable_dir", "7.0.0", "9.0.3")
+            ),
+            "Link": ("index.Link", "7.0.0", "9999"),
+            "make_abstract_dist": (
+                ("operations.prepare.make_abstract_dist", "10.0.0", "9999"),
+                ("req.req_set.make_abstract_dist", "7.0.0", "9.0.3")
+            ),
+            "make_option_group": (
+                ("cli.cmdoptions.make_option_group", "18.1", "9999"),
+                ("cmdoptions.make_option_group", "7.0.0", "18.0")
+            ),
+            "PackageFinder": ("index.PackageFinder", "7.0.0", "9999"),
+            "parse_requirements": ("req.req_file.parse_requirements", "7.0.0", "9999"),
+            "parse_version": ("index.parse_version", "7.0.0", "9999"),
+            "path_to_url": ("download.path_to_url", "7.0.0", "9999"),
+            "PipError": ("exceptions.PipError", "7.0.0", "9999"),
+            "RequirementPreparer": ("operations.prepare.RequirementPreparer", "7", "9999"),
+            "RequirementSet": ("req.req_set.RequirementSet", "7.0.0", "9999"),
+            "RequirementTracker": ("req.req_tracker.RequirementTracker", "7.0.0", "9999"),
+            "Resolver": ("resolve.Resolver", "7.0.0", "9999"),
+            "SafeFileCache": ("download.SafeFileCache", "7.0.0", "9999"),
+            "UninstallPathSet": ("req.req_uninstall.UninstallPathSet", "7.0.0", "9999"),
+            "url_to_path": ("download.url_to_path", "7.0.0", "9999"),
+            "USER_CACHE_DIR": ("locations.USER_CACHE_DIR", "7.0.0", "9999"),
+            "VcsSupport": ("vcs.VcsSupport", "7.0.0", "9999"),
+            "Wheel": ("wheel.Wheel", "7.0.0", "9999"),
+            "WheelCache": (
+                ("cache.WheelCache", "10.0.0", "9999"),
+                ("wheel.WheelCache", "7", "9.0.3")
+            ),
+            "WheelBuilder": ("wheel.WheelBuilder", "7.0.0", "9999"),
+            "PyPI": ("models.index.PyPI", "7.0.0", "9999"),
+        }
 
+    def _ensure_methods(self, cls, classname, *methods):
+        method_names = [m[0] for m in methods]
+        if all(getattr(cls, m, None) for m in method_names):
+            return cls
+        new_functions = {}
+        class BaseFunc(Callable):
+            def __init__(self, func_base, name, *args, **kwargs):
+                self.func = func_base
+                self.__name__ = self.__qualname__ = name
 
-def do_import(module_paths, base_path=BASE_IMPORT_PATH):
-    search_order = get_ordered_paths(module_paths, base_path)
-    imported = None
-    if has_modutil:
-        pkgs = [get_package(pkg) for pkg in search_order]
-        imports = [
-            modutil.lazy_import(__name__, {to_import}) for to_import, pkg in pkgs
-        ]
-        imp_getattrs = [imp_getattr for mod, imp_getattr in imports]
-        chained = modutil.chained___getattr__(__name__, *imp_getattrs)
+            def __call__(self, cls, *args, **kwargs):
+                return self.func(*args, **kwargs)
+
+        for method_name, fn in methods:
+            new_functions[method_name] = classmethod(BaseFunc(fn, method_name))
+        if six.PY2:
+            classname = classname.encode(sys.getdefaultencoding())
+        type_ = type(
+            classname,
+            (cls,),
+            new_functions
+        )
+        return type_
+
+    def _get_module_paths(self, module, base_path=None):
+        if not base_path:
+            base_path = self.BASE_IMPORT_PATH
+        module = self._locations[module]
+        if not isinstance(next(iter(module)), (tuple, list)):
+            module_paths = self.get_pathinfo(module)
+        else:
+            module_paths = [self.get_pathinfo(pth) for pth in module]
+        return self.sort_paths(module_paths, base_path)
+
+    def _get_remapped_methods(self, moved_package):
+        original_base, original_target = moved_package
+        original_import = self._import(self._locations[original_target])
+        old_to_new = {}
+        new_to_old = {}
+        for method_name, new_method_name in self._moves.get(original_target, {}).items():
+            module_paths = self._get_module_paths(new_method_name)
+            target = next(iter(
+                sorted(set([
+                    tgt for mod, tgt in map(self.get_package, module_paths)
+                ]))), None
+            )
+            old_to_new[method_name] = {
+                "target": target,
+                "name": new_method_name,
+                "location": self._locations[new_method_name],
+                "module": self._import(self._locations[new_method_name])
+            }
+            new_to_old[new_method_name] = {
+                "target": original_target,
+                "name": method_name,
+                "location": self._locations[original_target],
+                "module": original_import
+            }
+        return (old_to_new, new_to_old)
+
+    def _import_moved_module(self, moved_package):
+        old_to_new, new_to_old = self._get_remapped_methods(moved_package)
         imported = None
-        for to_import, pkg in pkgs:
-            _, _, module_name = to_import.rpartition(".")
-            try:
-                imported = chained(module_name)
-            except (modutil.ModuleAttributeError, ImportError):
-                continue
+        method_map = []
+        new_target = None
+        for old_method, remapped in old_to_new.items():
+            new_name = remapped["name"]
+            new_target = new_to_old[new_name]["target"]
+            if not imported:
+                imported = self._modules[new_target] = new_to_old[new_name]["module"]
+            method_map.append((old_method, remapped["module"]))
+        if getattr(imported, "__class__", "") == type:
+            imported = self._ensure_methods(
+                imported, new_target, *method_map
+            )
+        self._modules[new_target] = imported
+        if imported:
+            return imported
+        return
+
+    def _check_moved_methods(self, search_pth, moves):
+        module_paths = [
+            self.get_package(pth) for pth in self._get_module_paths(search_pth)
+        ]
+        moved_methods = [
+            (base, target_cls) for base, target_cls
+            in module_paths if target_cls in moves
+        ]
+        return next(iter(moved_methods), None)
+
+    def __getattr__(self, *args, **kwargs):
+        locations = super(_shims, self).__getattribute__("_locations")
+        contextmanagers = super(_shims, self).__getattribute__("_contextmanagers")
+        moves = super(_shims, self).__getattribute__("_moves")
+        if args[0] in locations:
+            moved_package = self._check_moved_methods(args[0], moves)
+            if moved_package:
+                imported = self._import_moved_module(moved_package)
+                if imported:
+                    return imported
             else:
-                if not imported:
-                    continue
-                return getattr(imported, pkg)
-        if not imported:
-            return
-        return imported
-    for to_import in search_order:
-        to_import, package = get_package(to_import)
+                imported = self._import(locations[args[0]])
+                if not imported and args[0] in contextmanagers:
+                    return self.nullcontext
+                return imported
+        return super(_shims, self).__getattribute__(*args, **kwargs)
+
+    def is_valid(self, path_info_tuple):
+        if (
+            path_info_tuple.start_version <= self.parsed_pip_version
+            and path_info_tuple.end_version >= self.parsed_pip_version
+        ):
+            return 1
+        return 0
+
+    def sort_paths(self, module_paths, base_path):
+        if not isinstance(module_paths, list):
+            module_paths = [module_paths]
+        prefix_order = [pth.format(base_path) for pth in ["{0}._internal", "{0}"]]
+        # Pip 10 introduced the internal api division
+        if self._parse(self.pip_version) < self._parse("10.0.0"):
+            prefix_order = reversed(prefix_order)
+        paths = sorted(module_paths, key=self.is_valid, reverse=True)
+        search_order = [
+            "{0}.{1}".format(p, pth.path)
+            for p in prefix_order
+            for pth in paths
+            if pth is not None
+        ]
+        return search_order
+
+    def import_module(self, module):
+        if module in self._modules:
+            return self._modules[module]
         try:
-            imported = importlib.import_module(to_import)
+            imported = importlib.import_module(module)
         except ImportError:
-            continue
+            imported = None
         else:
-            return getattr(imported, package)
-    return imported
+            self._modules[module] = imported
+        return imported
 
+    def none_or_ctxmanager(self, pkg_name):
+        if pkg_name in self._contextmanagers:
+            return self.nullcontext
+        return None
 
-def pip_import(import_name, *module_paths):
-    paths = []
-    for pip_path in module_paths:
-        if not isinstance(pip_path, (list, tuple)):
-            module_path, start_version, end_version = module_paths
-            new_path = path_info(module_path, _parse(start_version), _parse(end_version))
-            paths.append(new_path)
-            break
+    def get_package_from_modules(self, modules):
+        modules = [
+            (package_name, self.import_module(m))
+            for m, package_name in map(self.get_package, modules)
+        ]
+        imports = [
+            getattr(m, pkg, self.none_or_ctxmanager(pkg)) for pkg, m in modules
+            if m is not None
+        ]
+        return next(iter(imports), None)
+
+    def _import(self, module_paths, base_path=None):
+        if not base_path:
+            base_path = self.BASE_IMPORT_PATH
+        if not isinstance(next(iter(module_paths)), (tuple, list)):
+            module_paths = self.get_pathinfo(module_paths)
         else:
-            module_path, start_version, end_version = pip_path
-            paths.append(path_info(module_path, _parse(start_version), _parse(end_version)))
-    return do_import(paths)
+            module_paths = [self.get_pathinfo(pth) for pth in module_paths]
+        search_order = self.sort_paths(module_paths, base_path)
+        return self.get_package_from_modules(search_order)
 
-
-parse_version = pip_import("parse_version", "index.parse_version", "7", "9999")
-_strip_extras = pip_import("_strip_extras", "req.req_install._strip_extras", "7", "9999")
-cmdoptions = pip_import(
-    "", ("cli.cmdoptions", "18.1", "9999"), ("cmdoptions", "7.0.0", "18.0"),
-)
-Command = pip_import("Command",
-    ("cli.base_command.Command", "18.1", "9999"),
-    ("basecommand.Command", "7.0.0", "18.0"),
-)
-ConfigOptionParser = pip_import("ConfigOptionParser",
-    ("cli.parser.ConfigOptionParser", "18.1", "9999"),
-    ("baseparser.ConfigOptionParser", "7.0.0", "18.0"),
-)
-DistributionNotFound = pip_import("DistributionNotFound", "exceptions.DistributionNotFound", "7.0.0", "9999")
-FAVORITE_HASH = pip_import("FAVORITE_HASH", "utils.hashes.FAVORITE_HASH", "7.0.0", "9999")
-FormatControl = pip_import("FormatControl", "index.FormatControl", "7.0.0", "9999")
-get_installed_distributions = pip_import("get_installed_distributions",
-    ("utils.misc.get_installed_distributions", "10", "9999"),
-    ("utils.get_installed_distributions", "7", "9.0.3")
-)
-index_group = pip_import("index_group",
-    ("cli.cmdoptions.index_group", "18.1", "9999"),
-    ("cmdoptions.index_group", "7.0.0", "18.0"),
-)
-InstallRequirement = pip_import("InstallRequirement", "req.req_install.InstallRequirement", "7.0.0", "9999")
-is_archive_file = pip_import("is_archive_file", "download.is_archive_file", "7.0.0", "9999")
-is_file_url = pip_import("is_file_url", "download.is_file_url", "7.0.0", "9999")
-unpack_url = pip_import("unpack_url", "download.unpack_url", "7.0.0", "9999")
-is_installable_dir = pip_import("is_installable_dir",
-    ("utils.misc.is_installable_dir", "10.0.0", "9999"),
-    ("utils.is_installable_dir", "7.0.0", "9.0.3"),
-)
-Link = pip_import("Link", "index.Link", "7.0.0", "9999")
-make_abstract_dist = pip_import("make_abstract_dist",
-    ("operations.prepare.make_abstract_dist", "10.0.0", "9999"),
-    ("req.req_set.make_abstract_dist", "7.0.0", "9.0.3"),
-)
-make_option_group = pip_import("make_option_group",
-    ("cli.cmdoptions.make_option_group", "18.1", "9999"),
-    ("cmdoptions.make_option_group", "7.0.0", "18.0"),
-)
-PackageFinder = pip_import("PackageFinder", "index.PackageFinder", "7.0.0", "9999")
-parse_requirements = pip_import("parse_requirements", "req.req_file.parse_requirements", "7.0.0", "9999")
-parse_version = pip_import("parse_version", "index.parse_version", "7.0.0", "9999")
-path_to_url = pip_import("path_to_url", "download.path_to_url", "7.0.0", "9999")
-PipError = pip_import("PipError", "exceptions.PipError", "7.0.0", "9999")
-RequirementPreparer = pip_import("RequirementPreparer", "operations.prepare.RequirementPreparer", "7", "9999")
-RequirementSet = pip_import("RequirementSet", "req.req_set.RequirementSet", "7.0.0", "9999")
-RequirementTracker = pip_import("RequirementTracker", "req.req_tracker.RequirementTracker", "7.0.0", "9999")
-Resolver = pip_import("Resolver", "resolve.Resolver", "7.0.0", "9999")
-SafeFileCache = pip_import("SafeFileCache", "download.SafeFileCache", "7.0.0", "9999")
-url_to_path = pip_import("url_to_path", "download.url_to_path", "7.0.0", "9999")
-USER_CACHE_DIR = pip_import("USER_CACHE_DIR", "locations.USER_CACHE_DIR", "7.0.0", "9999")
-VcsSupport = pip_import("VcsSupport", "vcs.VcsSupport", "7.0.0", "9999")
-Wheel = pip_import("Wheel", "wheel.Wheel", "7.0.0", "9999")
-WheelCache = pip_import("WheelCache", ("cache.WheelCache", "10.0.0", "9999"), ("wheel.WheelCache", "7", "9.0.3"))
-WheelBuilder = pip_import("WheelBuilder", "wheel.WheelBuilder", "7.0.0", "9999")
-
-
-if not RequirementTracker:
+    def do_import(self, *args, **kwargs):
+        return self._import(*args, **kwargs)
 
     @contextmanager
-    def RequirementTracker():
-        yield
+    def nullcontext(self, *args, **kwargs):
+        try:
+            yield
+        finally:
+            pass
+
+    def get_pathinfo(self, module_path):
+        assert isinstance(module_path, (list, tuple))
+        module_path, start_version, end_version = module_path
+        return self.path_info(module_path, self._parse(start_version), self._parse(end_version))
+
+
+old_module = sys.modules[__name__] if __name__ in sys.modules else None
+module = sys.modules[__name__] = _shims()
+module.__dict__.update({
+    '__file__': __file__,
+    '__package__': __package__,
+    '__doc__': __doc__,
+    '__all__': module.__all__,
+    '__name__': __name__,
+})
diff --git a/pipenv/vendor/pipdeptree.py b/pipenv/vendor/pipdeptree.py
index 7820aa5d..2082fc8a 100644
--- a/pipenv/vendor/pipdeptree.py
+++ b/pipenv/vendor/pipdeptree.py
@@ -13,11 +13,9 @@ try:
 except ImportError:
     from ordereddict import OrderedDict
 
-try:
-    from pip._internal import get_installed_distributions
-    from pip._internal.operations.freeze import FrozenRequirement
-except ImportError:
-    from pip import get_installed_distributions, FrozenRequirement
+pardir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.append(pardir)
+from pipenv.vendor.pip_shims import get_installed_distributions, FrozenRequirement
 
 import pkg_resources
 # inline:
diff --git a/pipenv/vendor/plette/__init__.py b/pipenv/vendor/plette/__init__.py
index c99c1bc1..8099f0b1 100644
--- a/pipenv/vendor/plette/__init__.py
+++ b/pipenv/vendor/plette/__init__.py
@@ -3,7 +3,7 @@ __all__ = [
     "Lockfile", "Pipfile",
 ]
 
-__version__ = '0.1.1'
+__version__ = '0.2.2'
 
 from .lockfiles import Lockfile
 from .pipfiles import Pipfile
diff --git a/pipenv/vendor/plette/lockfiles.py b/pipenv/vendor/plette/lockfiles.py
index fe97a521..10df07e1 100644
--- a/pipenv/vendor/plette/lockfiles.py
+++ b/pipenv/vendor/plette/lockfiles.py
@@ -1,6 +1,12 @@
 from __future__ import unicode_literals
 
 import json
+import numbers
+
+try:
+    import collections.abc as collections_abc
+except ImportError:
+    import collections as collections_abc
 
 import six
 
@@ -44,6 +50,20 @@ LOCKFILE_SECTIONS = {
 PIPFILE_SPEC_CURRENT = 6
 
 
+def _copy_jsonsafe(value):
+    """Deep-copy a value into JSON-safe types.
+    """
+    if isinstance(value, six.string_types + (numbers.Number,)):
+        return value
+    if isinstance(value, collections_abc.Mapping):
+        return {six.text_type(k): _copy_jsonsafe(v) for k, v in value.items()}
+    if isinstance(value, collections_abc.Iterable):
+        return [_copy_jsonsafe(v) for v in value]
+    if value is None:   # This doesn't happen often for us.
+        return None
+    return six.text_type(value)
+
+
 class Lockfile(DataView):
     """Representation of a Pipfile.lock.
     """
@@ -71,10 +91,10 @@ class Lockfile(DataView):
     def with_meta_from(cls, pipfile):
         data = {
             "_meta": {
-                "hash": pipfile.get_hash()._data,
+                "hash": _copy_jsonsafe(pipfile.get_hash()._data),
                 "pipfile-spec": PIPFILE_SPEC_CURRENT,
-                "requires": pipfile._data.get("requires", {}).copy(),
-                "sources": pipfile.sources._data.copy(),
+                "requires": _copy_jsonsafe(pipfile._data.get("requires", {})),
+                "sources": _copy_jsonsafe(pipfile.sources._data),
             },
             "default": {},
             "develop": {},
diff --git a/pipenv/vendor/plette/models/base.py b/pipenv/vendor/plette/models/base.py
index e8bbd4fa..d70752ee 100644
--- a/pipenv/vendor/plette/models/base.py
+++ b/pipenv/vendor/plette/models/base.py
@@ -31,8 +31,7 @@ class DataView(object):
     """A "view" to a data.
 
     Validates the input mapping on creation. A subclass is expected to
-    provide a `__SCHEMA__` class attribute specifying a validator schema,
-    or a concrete Cerberus validator object.
+    provide a `__SCHEMA__` class attribute specifying a validator schema.
     """
     def __init__(self, data):
         self.validate(data)
@@ -54,6 +53,9 @@ class DataView(object):
     def __setitem__(self, key, value):
         self._data[key] = value
 
+    def __delitem__(self, key):
+        del self._data[key]
+
     def get(self, key, default=None):
         try:
             return self[key]
@@ -66,11 +68,12 @@ class DataView(object):
 
 
 class DataViewCollection(DataView):
-    """A collection of dataview.
+    """A homogeneous collection of data views.
 
     Subclasses are expected to assign a class attribute `item_class` to specify
-    how items should be coerced when accessed. The item class should conform to
-    the `DataView` protocol.
+    the type of items it contains. This class will be used to coerce return
+    values when accessed. The item class should conform to the `DataView`
+    protocol.
 
     You should not instantiate an instance from this class, but from one of its
     subclasses instead.
@@ -87,7 +90,7 @@ class DataViewCollection(DataView):
         return self.item_class(self._data[key])
 
     def __setitem__(self, key, value):
-        if isinstance(value, self.item_class):
+        if isinstance(value, DataView):
             value = value._data
         self._data[key] = value
 
@@ -96,7 +99,7 @@ class DataViewCollection(DataView):
 
 
 class DataViewMapping(DataViewCollection):
-    """A mapping of dataview.
+    """A mapping of data views.
 
     The keys are primitive values, while values are instances of `item_class`.
     """
@@ -119,7 +122,7 @@ class DataViewMapping(DataViewCollection):
 
 
 class DataViewSequence(DataViewCollection):
-    """A sequence of dataview.
+    """A sequence of data views.
 
     Each entry is an instance of `item_class`.
     """
@@ -130,3 +133,13 @@ class DataViewSequence(DataViewCollection):
 
     def __iter__(self):
         return (self.item_class(d) for d in self._data)
+
+    def __getitem__(self, key):
+        if isinstance(key, slice):
+            return type(self)(self._data[key])
+        return super(DataViewSequence, self).__getitem__(key)
+
+    def append(self, value):
+        if isinstance(value, DataView):
+            value = value._data
+        self._data.append(value)
diff --git a/pipenv/vendor/pyparsing.py b/pipenv/vendor/pyparsing.py
index 69be39f6..cf38419b 100644
--- a/pipenv/vendor/pyparsing.py
+++ b/pipenv/vendor/pyparsing.py
@@ -1,6 +1,6 @@
 # module pyparsing.py
 #
-# Copyright (c) 2003-2016  Paul T. McGuire
+# Copyright (c) 2003-2018  Paul T. McGuire
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -25,6 +25,7 @@
 __doc__ = \
 """
 pyparsing module - Classes and methods to define and execute parsing grammars
+=============================================================================
 
 The pyparsing module is an alternative approach to creating and executing simple grammars,
 vs. the traditional lex/yacc approach, or the use of regular expressions.  With pyparsing, you
@@ -58,10 +59,23 @@ The pyparsing module handles some of the problems that are typically vexing when
  - extra or missing whitespace (the above program will also handle "Hello,World!", "Hello  ,  World  !", etc.)
  - quoted strings
  - embedded comments
+
+
+Getting Started -
+-----------------
+Visit the classes L{ParserElement} and L{ParseResults} to see the base classes that most other pyparsing
+classes inherit from. Use the docstrings for examples of how to:
+ - construct literal match expressions from L{Literal} and L{CaselessLiteral} classes
+ - construct character word-group expressions using the L{Word} class
+ - see how to create repetitive expressions using L{ZeroOrMore} and L{OneOrMore} classes
+ - use L{'+'<And>}, L{'|'<MatchFirst>}, L{'^'<Or>}, and L{'&'<Each>} operators to combine simple expressions into more complex ones
+ - associate names with your parsed results using L{ParserElement.setResultsName}
+ - find some helpful expression short-cuts like L{delimitedList} and L{oneOf}
+ - find more useful common expressions in the L{pyparsing_common} namespace class
 """
 
-__version__ = "2.2.0"
-__versionTime__ = "06 Mar 2017 02:06 UTC"
+__version__ = "2.2.2"
+__versionTime__ = "29 Sep 2018 15:58 UTC"
 __author__ = "Paul McGuire <ptmcg@users.sourceforge.net>"
 
 import string
@@ -82,6 +96,15 @@ try:
 except ImportError:
     from threading import RLock
 
+try:
+    # Python 3
+    from collections.abc import Iterable
+    from collections.abc import MutableMapping
+except ImportError:
+    # Python 2.7
+    from collections import Iterable
+    from collections import MutableMapping
+
 try:
     from collections import OrderedDict as _OrderedDict
 except ImportError:
@@ -940,7 +963,7 @@ class ParseResults(object):
     def __dir__(self):
         return (dir(type(self)) + list(self.keys()))
 
-collections.MutableMapping.register(ParseResults)
+MutableMapping.register(ParseResults)
 
 def col (loc,strg):
     """Returns current column within a string, counting newlines as line separators.
@@ -1025,11 +1048,11 @@ def _trim_arity(func, maxargs=2):
             # special handling for Python 3.5.0 - extra deep call stack by 1
             offset = -3 if system_version == (3,5,0) else -2
             frame_summary = traceback.extract_stack(limit=-offset+limit-1)[offset]
-            return [(frame_summary.filename, frame_summary.lineno)]
+            return [frame_summary[:2]]
         def extract_tb(tb, limit=0):
             frames = traceback.extract_tb(tb, limit=limit)
             frame_summary = frames[-1]
-            return [(frame_summary.filename, frame_summary.lineno)]
+            return [frame_summary[:2]]
     else:
         extract_stack = traceback.extract_stack
         extract_tb = traceback.extract_tb
@@ -1374,7 +1397,7 @@ class ParserElement(object):
             else:
                 preloc = loc
             tokensStart = preloc
-            if self.mayIndexError or loc >= len(instring):
+            if self.mayIndexError or preloc >= len(instring):
                 try:
                     loc,tokens = self.parseImpl( instring, preloc, doActions )
                 except IndexError:
@@ -1408,7 +1431,6 @@ class ParserElement(object):
                                                   self.resultsName,
                                                   asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
                                                   modal=self.modalResults )
-
         if debugging:
             #~ print ("Matched",self,"->",retTokens.asList())
             if (self.debugActions[1] ):
@@ -2754,7 +2776,7 @@ class Regex(Token):
         roman = Regex(r"M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})")
     """
     compiledREtype = type(re.compile("[A-Z]"))
-    def __init__( self, pattern, flags=0):
+    def __init__( self, pattern, flags=0, asGroupList=False, asMatch=False):
         """The parameters C{pattern} and C{flags} are passed to the C{re.compile()} function as-is. See the Python C{re} module for an explanation of the acceptable patterns and flags."""
         super(Regex,self).__init__()
 
@@ -2787,6 +2809,8 @@ class Regex(Token):
         self.errmsg = "Expected " + self.name
         self.mayIndexError = False
         self.mayReturnEmpty = True
+        self.asGroupList = asGroupList
+        self.asMatch = asMatch
 
     def parseImpl( self, instring, loc, doActions=True ):
         result = self.re.match(instring,loc)
@@ -2795,10 +2819,15 @@ class Regex(Token):
 
         loc = result.end()
         d = result.groupdict()
-        ret = ParseResults(result.group())
-        if d:
-            for k in d:
-                ret[k] = d[k]
+        if self.asMatch:
+            ret = result
+        elif self.asGroupList:
+            ret = result.groups()
+        else:
+            ret = ParseResults(result.group())
+            if d:
+                for k in d:
+                    ret[k] = d[k]
         return loc,ret
 
     def __str__( self ):
@@ -2812,6 +2841,28 @@ class Regex(Token):
 
         return self.strRepr
 
+    def sub(self, repl):
+        """
+        Return Regex with an attached parse action to transform the parsed
+        result as if called using C{re.sub(expr, repl, string)}.
+        """
+        if self.asGroupList:
+            warnings.warn("cannot use sub() with Regex(asGroupList=True)", 
+                           SyntaxWarning, stacklevel=2)
+            raise SyntaxError()
+
+        if self.asMatch and callable(repl):
+            warnings.warn("cannot use sub() with a callable with Regex(asMatch=True)", 
+                           SyntaxWarning, stacklevel=2)
+            raise SyntaxError()        
+
+        if self.asMatch:
+            def pa(tokens):
+                return tokens[0].expand(repl)
+        else:
+            def pa(tokens):
+                return self.re.sub(repl, tokens[0])
+        return self.addParseAction(pa)
 
 class QuotedString(Token):
     r"""
@@ -3242,7 +3293,7 @@ class ParseExpression(ParserElement):
 
         if isinstance( exprs, basestring ):
             self.exprs = [ ParserElement._literalStringClass( exprs ) ]
-        elif isinstance( exprs, collections.Iterable ):
+        elif isinstance( exprs, Iterable ):
             exprs = list(exprs)
             # if sequence of strings provided, wrap with Literal
             if all(isinstance(expr, basestring) for expr in exprs):
@@ -4062,7 +4113,7 @@ class SkipTo(ParseElementEnhance):
         self.mayReturnEmpty = True
         self.mayIndexError = False
         self.includeMatch = include
-        self.asList = False
+        self.saveAsList = False
         if isinstance(failOn, basestring):
             self.failOn = ParserElement._literalStringClass(failOn)
         else:
@@ -4393,7 +4444,7 @@ def traceParseAction(f):
 
         @traceParseAction
         def remove_duplicate_chars(tokens):
-            return ''.join(sorted(set(''.join(tokens)))
+            return ''.join(sorted(set(''.join(tokens))))
 
         wds = OneOrMore(wd).setParseAction(remove_duplicate_chars)
         print(wds.parseString("slkdjs sld sldd sdlf sdljf"))
@@ -4583,7 +4634,7 @@ def oneOf( strs, caseless=False, useRegex=True ):
     symbols = []
     if isinstance(strs,basestring):
         symbols = strs.split()
-    elif isinstance(strs, collections.Iterable):
+    elif isinstance(strs, Iterable):
         symbols = list(strs)
     else:
         warnings.warn("Invalid argument to oneOf, expected string or iterable",
@@ -4734,7 +4785,7 @@ stringEnd   = StringEnd().setName("stringEnd")
 _escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1])
 _escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0].lstrip(r'\0x'),16)))
 _escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],8)))
-_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | Word(printables, excludeChars=r'\]', exact=1) | Regex(r"\w", re.UNICODE)
+_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | CharsNotIn(r'\]', exact=1)
 _charRange = Group(_singleChar + Suppress("-") + _singleChar)
 _reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]"
 
diff --git a/pipenv/vendor/pythonfinder/__init__.py b/pipenv/vendor/pythonfinder/__init__.py
index f6ef476b..60192826 100644
--- a/pipenv/vendor/pythonfinder/__init__.py
+++ b/pipenv/vendor/pythonfinder/__init__.py
@@ -1,6 +1,14 @@
 from __future__ import print_function, absolute_import
 
-__version__ = '1.0.2'
+__version__ = '1.1.6'
+
+# Add NullHandler to "pythonfinder" logger, because Python2's default root
+# logger has no handler and warnings like this would be reported:
+#
+# > No handlers could be found for logger "pythonfinder.models.pyenv"
+import logging
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
 
 __all__ = ["Finder", "WindowsFinder", "SystemPath", "InvalidPythonVersion"]
 from .pythonfinder import Finder
diff --git a/pipenv/vendor/pythonfinder/cli.py b/pipenv/vendor/pythonfinder/cli.py
index d285fb29..6e7980fe 100644
--- a/pipenv/vendor/pythonfinder/cli.py
+++ b/pipenv/vendor/pythonfinder/cli.py
@@ -8,7 +8,6 @@ from . import __version__
 from .pythonfinder import Finder
 
 
-# @click.group(invoke_without_command=True, context_settings=CONTEXT_SETTINGS)
 @click.command()
 @click.option("--find", default=False, nargs=1, help="Find a specific python version.")
 @click.option("--which", default=False, nargs=1, help="Run the which command.")
@@ -18,9 +17,10 @@ from .pythonfinder import Finder
 @click.option(
     "--version", is_flag=True, default=False, help="Display PythonFinder version."
 )
-# @click.version_option(prog_name=crayons.normal('pyfinder', bold=True), version=__version__)
+@click.option("--ignore-unsupported/--no-unsupported", is_flag=True, default=True, envvar="PYTHONFINDER_IGNORE_UNSUPPORTED", help="Ignore unsupported python versions.")
+@click.version_option(prog_name='pyfinder', version=__version__)
 @click.pass_context
-def cli(ctx, find=False, which=False, findall=False, version=False):
+def cli(ctx, find=False, which=False, findall=False, version=False, ignore_unsupported=True):
     if version:
         click.echo(
             "{0} version {1}".format(
@@ -28,26 +28,46 @@ def cli(ctx, find=False, which=False, findall=False, version=False):
             )
         )
         sys.exit(0)
-    finder = Finder()
-    if find:
-
-        if any([find.startswith("{0}".format(n)) for n in range(10)]):
-            found = finder.find_python_version(find.strip())
-        else:
-            found = finder.system_path.python_executables
-        if found:
-            click.echo("Found Python Version: {0}".format(found), color="white")
+    finder = Finder(ignore_unsupported=ignore_unsupported)
+    if findall:
+        versions = [v for v in finder.find_all_python_versions()]
+        if versions:
+            click.secho("Found python at the following locations:", fg="green")
+            for v in versions:
+                py = v.py_version
+                comes_from = getattr(py, "comes_from", None)
+                if comes_from is not None:
+                    comes_from_path = getattr(comes_from, "path", v.path)
+                else:
+                    comes_from_path = v.path
+                click.secho(
+                    "{py.name!s}: {py.version!s} ({py.architecture!s}) @ {comes_from!s}".format(
+                        py=py, comes_from=comes_from_path
+                    ),
+                    fg="yellow",
+                )
             sys.exit(0)
         else:
-            click.echo("Failed to find matching executable...")
+            click.secho(
+                "ERROR: No valid python versions found! Check your path and try again.",
+                fg="red",
+            )
+    if find:
+        click.secho("Searching for python: {0!s}".format(find.strip()), fg="yellow")
+        found = finder.find_python_version(find.strip())
+        if found:
+            click.secho("Found python at the following locations:", fg="green")
+            sys.exit(0)
+        else:
+            click.secho("Failed to find matching executable...", fg="yellow")
             sys.exit(1)
     elif which:
         found = finder.system_path.which(which.strip())
         if found:
-            click.echo("Found Executable: {0}".format(found), color="white")
+            click.secho("Found Executable: {0}".format(found), fg="white")
             sys.exit(0)
         else:
-            click.echo("Failed to find matching executable...")
+            click.secho("Failed to find matching executable...", fg="yellow")
             sys.exit(1)
     else:
         click.echo("Please provide a command", color="red")
diff --git a/pipenv/vendor/pythonfinder/environment.py b/pipenv/vendor/pythonfinder/environment.py
index 2cdb5fd9..7c69b9fc 100644
--- a/pipenv/vendor/pythonfinder/environment.py
+++ b/pipenv/vendor/pythonfinder/environment.py
@@ -15,3 +15,6 @@ if sys.maxsize > 2 ** 32:
     IS_64BIT_OS = platform.machine() == "AMD64"
 else:
     IS_64BIT_OS = False
+
+
+IGNORE_UNSUPPORTED = bool(os.environ.get("PYTHONFINDER_IGNORE_UNSUPPORTED", False))
diff --git a/pipenv/vendor/pythonfinder/models/__init__.py b/pipenv/vendor/pythonfinder/models/__init__.py
index ef0ed368..e788c21c 100644
--- a/pipenv/vendor/pythonfinder/models/__init__.py
+++ b/pipenv/vendor/pythonfinder/models/__init__.py
@@ -12,22 +12,3 @@ from ..utils import KNOWN_EXTS, unnest
 from .path import SystemPath
 from .python import PythonVersion
 from .windows import WindowsFinder
-
-
-@six.add_metaclass(abc.ABCMeta)
-class BaseFinder(object):
-    def get_versions(self):
-        """Return the available versions from the finder"""
-        raise NotImplementedError
-
-    @classmethod
-    def create(cls):
-        raise NotImplementedError
-
-    @property
-    def version_paths(self):
-        return self.versions.values()
-
-    @property
-    def expanded_paths(self):
-        return (p.paths.values() for p in self.version_paths)
diff --git a/pipenv/vendor/pythonfinder/models/mixins.py b/pipenv/vendor/pythonfinder/models/mixins.py
index 8cbd45df..7d406548 100644
--- a/pipenv/vendor/pythonfinder/models/mixins.py
+++ b/pipenv/vendor/pythonfinder/models/mixins.py
@@ -2,12 +2,14 @@
 from __future__ import absolute_import, unicode_literals
 
 import abc
+import attr
 import operator
 import six
 
-from ..utils import KNOWN_EXTS, unnest
+from ..utils import ensure_path, KNOWN_EXTS, unnest
 
 
+@attr.s
 class BasePath(object):
     def which(self, name):
         """Search in this path for an executable.
@@ -33,7 +35,14 @@ class BasePath(object):
         return found
 
     def find_all_python_versions(
-        self, major=None, minor=None, patch=None, pre=None, dev=None, arch=None
+        self,
+        major=None,
+        minor=None,
+        patch=None,
+        pre=None,
+        dev=None,
+        arch=None,
+        name=None,
     ):
         """Search for a specific python version on the path. Return all copies
 
@@ -44,6 +53,7 @@ class BasePath(object):
         :param bool pre: Search for prereleases (default None) - prioritize releases if None
         :param bool dev: Search for devreleases (default None) - prioritize releases if None
         :param str arch: Architecture to include, e.g. '64bit', defaults to None
+        :param str name: The name of a python version, e.g. ``anaconda3-5.3.0``
         :return: A list of :class:`~pythonfinder.models.PathEntry` instances matching the version requested.
         :rtype: List[:class:`~pythonfinder.models.PathEntry`]
         """
@@ -52,7 +62,14 @@ class BasePath(object):
             "find_all_python_versions" if self.is_dir else "find_python_version"
         )
         sub_finder = operator.methodcaller(
-            call_method, major, minor=minor, patch=patch, pre=pre, dev=dev, arch=arch
+            call_method,
+            major=major,
+            minor=minor,
+            patch=patch,
+            pre=pre,
+            dev=dev,
+            arch=arch,
+            name=name,
         )
         if not self.is_dir:
             return sub_finder(self)
@@ -61,7 +78,14 @@ class BasePath(object):
         return [c for c in sorted(path_filter, key=version_sort, reverse=True)]
 
     def find_python_version(
-        self, major=None, minor=None, patch=None, pre=None, dev=None, arch=None
+        self,
+        major=None,
+        minor=None,
+        patch=None,
+        pre=None,
+        dev=None,
+        arch=None,
+        name=None,
     ):
         """Search or self for the specified Python version and return the first match.
 
@@ -72,6 +96,7 @@ class BasePath(object):
         :param bool pre: Search for prereleases (default None) - prioritize releases if None
         :param bool dev: Search for devreleases (default None) - prioritize releases if None
         :param str arch: Architecture to include, e.g. '64bit', defaults to None
+        :param str name: The name of a python version, e.g. ``anaconda3-5.3.0``
         :returns: A :class:`~pythonfinder.models.PathEntry` instance matching the version requested.
         """
 
@@ -83,12 +108,13 @@ class BasePath(object):
             pre=pre,
             dev=dev,
             arch=arch,
+            name=name,
         )
         is_py = operator.attrgetter("is_python")
         py_version = operator.attrgetter("as_python")
         if not self.is_dir:
-            if self.is_python and self.as_python and version_matcher(self.as_python):
-                return self
+            if self.is_python and self.as_python and version_matcher(self.py_version):
+                return attr.evolve(self)
             return
         finder = (
             (child, child.as_python)
diff --git a/pipenv/vendor/pythonfinder/models/path.py b/pipenv/vendor/pythonfinder/models/path.py
index 8e38aef3..20b2c196 100644
--- a/pipenv/vendor/pythonfinder/models/path.py
+++ b/pipenv/vendor/pythonfinder/models/path.py
@@ -10,6 +10,7 @@ from collections import defaultdict
 from itertools import chain
 
 import attr
+import six
 
 from cached_property import cached_property
 
@@ -19,8 +20,12 @@ from .mixins import BasePath
 from ..environment import PYENV_INSTALLED, PYENV_ROOT
 from ..exceptions import InvalidPythonVersion
 from ..utils import (
-    ensure_path, filter_pythons, looks_like_python, optional_instance_of,
-    path_is_known_executable, unnest
+    ensure_path,
+    filter_pythons,
+    looks_like_python,
+    optional_instance_of,
+    path_is_known_executable,
+    unnest,
 )
 from .python import PythonVersion
 
@@ -37,6 +42,7 @@ class SystemPath(object):
     pyenv_finder = attr.ib(default=None, validator=optional_instance_of("PyenvPath"))
     system = attr.ib(default=False)
     _version_dict = attr.ib(default=attr.Factory(defaultdict))
+    ignore_unsupported = attr.ib(default=False)
 
     __finders = attr.ib(default=attr.Factory(dict))
 
@@ -74,7 +80,7 @@ class SystemPath(object):
                     if entry not in self._version_dict[version]:
                         self._version_dict[version].append(entry)
                     continue
-                if isinstance(entry, VersionPath):
+                if type(entry).__name__ == "VersionPath":
                     for path in entry.paths.values():
                         if path not in self._version_dict[version] and path.is_python:
                             self._version_dict[version].append(path)
@@ -129,17 +135,16 @@ class SystemPath(object):
             pyenv_index = self.path_order.index(last_pyenv)
         except ValueError:
             return
-        self.pyenv_finder = PyenvFinder.create(root=PYENV_ROOT)
-        # paths = (v.paths.values() for v in self.pyenv_finder.versions.values())
-        root_paths = (
-            p for path in self.pyenv_finder.expanded_paths for p in path if p.is_root
+        self.pyenv_finder = PyenvFinder.create(
+            root=PYENV_ROOT, ignore_unsupported=self.ignore_unsupported
         )
+        root_paths = [p for p in self.pyenv_finder.roots]
         before_path = self.path_order[: pyenv_index + 1]
         after_path = self.path_order[pyenv_index + 2 :]
         self.path_order = (
-            before_path + [p.path.as_posix() for p in root_paths] + after_path
+            before_path + [p.as_posix() for p in root_paths] + after_path
         )
-        self.paths.update({p.path: p for p in root_paths})
+        self.paths.update(self.pyenv_finder.roots)
         self._register_finder("pyenv", self.pyenv_finder)
 
     def _setup_windows(self):
@@ -154,7 +159,9 @@ class SystemPath(object):
 
     def get_path(self, path):
         path = ensure_path(path)
-        _path = self.paths.get(path.as_posix())
+        _path = self.paths.get(path)
+        if not _path:
+            _path = self.paths.get(path.as_posix())
         if not _path and path.as_posix() in self.path_order:
             _path = PathEntry.create(
                 path=path.absolute(), is_root=True, only_python=self.only_python
@@ -162,6 +169,14 @@ class SystemPath(object):
             self.paths[path.as_posix()] = _path
         return _path
 
+    def _get_paths(self):
+        return (self.get_path(k) for k in self.path_order)
+
+    @cached_property
+    def path_entries(self):
+        paths = self._get_paths()
+        return paths
+
     def find_all(self, executable):
         """Search the path for an executable. Return all copies.
 
@@ -170,8 +185,8 @@ class SystemPath(object):
         :returns: List[PathEntry]
         """
         sub_which = operator.methodcaller("which", name=executable)
-        filtered = filter(None, (sub_which(self.get_path(k)) for k in self.path_order))
-        return [f for f in filtered]
+        filtered = (sub_which(self.get_path(k)) for k in self.path_order)
+        return list(filtered)
 
     def which(self, executable):
         """Search for an executable on the path.
@@ -181,11 +196,39 @@ class SystemPath(object):
         :returns: :class:`~pythonfinder.models.PathEntry` object.
         """
         sub_which = operator.methodcaller("which", name=executable)
-        filtered = filter(None, (sub_which(self.get_path(k)) for k in self.path_order))
-        return next((f for f in filtered), None)
+        filtered = (sub_which(self.get_path(k)) for k in self.path_order)
+        return next(iter(f for f in filtered if f is not None), None)
+
+    def _filter_paths(self, finder):
+        return (
+            pth for pth in unnest(finder(p) for p in self.path_entries if p is not None)
+            if pth is not None
+        )
+
+    def _get_all_pythons(self, finder):
+        paths = {p.path.as_posix(): p for p in self._filter_paths(finder)}
+        paths.update(self.python_executables)
+        return (p for p in paths.values() if p is not None)
+
+    def get_pythons(self, finder):
+        sort_key = operator.attrgetter("as_python.version_sort")
+        return (
+            k for k in sorted(
+                (p for p in self._filter_paths(finder) if p.is_python),
+                key=sort_key,
+                reverse=True
+            ) if k is not None
+        )
 
     def find_all_python_versions(
-        self, major=None, minor=None, patch=None, pre=None, dev=None, arch=None
+        self,
+        major=None,
+        minor=None,
+        patch=None,
+        pre=None,
+        dev=None,
+        arch=None,
+        name=None,
     ):
         """Search for a specific python version on the path. Return all copies
 
@@ -196,32 +239,46 @@ class SystemPath(object):
         :param bool pre: Search for prereleases (default None) - prioritize releases if None
         :param bool dev: Search for devreleases (default None) - prioritize releases if None
         :param str arch: Architecture to include, e.g. '64bit', defaults to None
+        :param str name: The name of a python version, e.g. ``anaconda3-5.3.0``
         :return: A list of :class:`~pythonfinder.models.PathEntry` instances matching the version requested.
         :rtype: List[:class:`~pythonfinder.models.PathEntry`]
         """
 
         sub_finder = operator.methodcaller(
             "find_all_python_versions",
-            major,
+            major=major,
             minor=minor,
             patch=patch,
             pre=pre,
             dev=dev,
             arch=arch,
+            name=name,
         )
+        alternate_sub_finder = None
+        if major and not (minor or patch or pre or dev or arch or name):
+            alternate_sub_finder = operator.methodcaller(
+                "find_all_python_versions",
+                major=None,
+                name=major
+            )
         if os.name == "nt" and self.windows_finder:
             windows_finder_version = sub_finder(self.windows_finder)
             if windows_finder_version:
                 return windows_finder_version
-        paths = (self.get_path(k) for k in self.path_order)
-        path_filter = filter(
-            None, unnest((sub_finder(p) for p in paths if p is not None))
-        )
-        version_sort = operator.attrgetter("as_python.version_sort")
-        return [c for c in sorted(path_filter, key=version_sort, reverse=True)]
+        values = list(self.get_pythons(sub_finder))
+        if not values and alternate_sub_finder is not None:
+            values = list(self.get_pythons(alternate_sub_finder))
+        return values
 
     def find_python_version(
-        self, major=None, minor=None, patch=None, pre=None, dev=None, arch=None
+        self,
+        major=None,
+        minor=None,
+        patch=None,
+        pre=None,
+        dev=None,
+        arch=None,
+        name=None,
     ):
         """Search for a specific python version on the path.
 
@@ -232,10 +289,24 @@ class SystemPath(object):
         :param bool pre: Search for prereleases (default None) - prioritize releases if None
         :param bool dev: Search for devreleases (default None) - prioritize releases if None
         :param str arch: Architecture to include, e.g. '64bit', defaults to None
+        :param str name: The name of a python version, e.g. ``anaconda3-5.3.0``
         :return: A :class:`~pythonfinder.models.PathEntry` instance matching the version requested.
         :rtype: :class:`~pythonfinder.models.PathEntry`
         """
 
+        if isinstance(major, six.string_types) and not minor and not patch:
+            # Only proceed if this is in the format "x.y.z" or similar
+            if major.count(".") > 0 and major[0].isdigit():
+                version = major.split(".", 2)
+                if len(version) > 3:
+                    major, minor, patch, rest = version
+                elif len(version) == 3:
+                    major, minor, patch = version
+                else:
+                    major, minor = version
+            else:
+                name = "{0!s}".format(major)
+                major = None
         sub_finder = operator.methodcaller(
             "find_python_version",
             major,
@@ -244,7 +315,15 @@ class SystemPath(object):
             pre=pre,
             dev=dev,
             arch=arch,
+            name=name,
         )
+        alternate_sub_finder = None
+        if major and not (minor or patch or pre or dev or arch or name):
+            alternate_sub_finder = operator.methodcaller(
+                "find_all_python_versions",
+                major=None,
+                name=major
+            )
         if major and minor and patch:
             _tuple_pre = pre if pre is not None else False
             _tuple_dev = dev if dev is not None else False
@@ -254,12 +333,9 @@ class SystemPath(object):
             windows_finder_version = sub_finder(self.windows_finder)
             if windows_finder_version:
                 return windows_finder_version
-        paths = (self.get_path(k) for k in self.path_order)
-        path_filter = filter(None, (sub_finder(p) for p in paths if p is not None))
-        version_sort = operator.attrgetter("as_python.version_sort")
-        ver = next(
-            (c for c in sorted(path_filter, key=version_sort, reverse=True)), None
-        )
+        ver = next(iter(self.get_pythons(sub_finder)), None)
+        if not ver and alternate_sub_finder is not None:
+            ver = next(iter(self.get_pythons(alternate_sub_finder)), None)
         if ver:
             if ver.as_python.version_tuple[:5] in self.python_version_dict:
                 self.python_version_dict[ver.as_python.version_tuple[:5]].append(ver)
@@ -268,21 +344,29 @@ class SystemPath(object):
         return ver
 
     @classmethod
-    def create(cls, path=None, system=False, only_python=False, global_search=True):
+    def create(
+        cls,
+        path=None,
+        system=False,
+        only_python=False,
+        global_search=True,
+        ignore_unsupported=True,
+    ):
         """Create a new :class:`pythonfinder.models.SystemPath` instance.
 
         :param path: Search path to prepend when searching, defaults to None
         :param path: str, optional
-        :param system: Whether to use the running python by default instead of searching, defaults to False
-        :param system: bool, optional
-        :param only_python: Whether to search only for python executables, defaults to False
-        :param only_python: bool, optional
+        :param bool system: Whether to use the running python by default instead of searching, defaults to False
+        :param bool only_python: Whether to search only for python executables, defaults to False
+        :param bool ignore_unsupported: Whether to ignore unsupported python versions, if False, an error is raised, defaults to True
         :return: A new :class:`pythonfinder.models.SystemPath` instance.
         :rtype: :class:`pythonfinder.models.SystemPath`
         """
 
         path_entries = defaultdict(PathEntry)
         paths = []
+        if ignore_unsupported:
+            os.environ["PYTHONFINDER_IGNORE_UNSUPPORTED"] = fs_str("1")
         if global_search:
             paths = os.environ.get("PATH").split(os.pathsep)
         if path:
@@ -303,6 +387,7 @@ class SystemPath(object):
             only_python=only_python,
             system=system,
             global_search=global_search,
+            ignore_unsupported=ignore_unsupported,
         )
 
 
@@ -312,7 +397,8 @@ class PathEntry(BasePath):
     _children = attr.ib(default=attr.Factory(dict))
     is_root = attr.ib(default=True)
     only_python = attr.ib(default=False)
-    py_version = attr.ib(default=None)
+    name = attr.ib()
+    py_version = attr.ib()
     pythons = attr.ib()
 
     def __str__(self):
@@ -325,17 +411,46 @@ class PathEntry(BasePath):
             children = self.path.iterdir()
         return children
 
+    def _gen_children(self):
+        pass_name = self.name != self.path.name
+        pass_args = {"is_root": False, "only_python": self.only_python}
+        if pass_name:
+            pass_args["name"] = self.name
+
+        if not self.is_dir:
+            yield (self.path.as_posix(), copy.deepcopy(self))
+        elif self.is_root:
+            for child in self._filter_children():
+                yield (child.as_posix(), PathEntry.create(path=child, **pass_args))
+        return
+
     @cached_property
     def children(self):
-        if not self._children and self.is_dir and self.is_root:
-            self._children = {
-                child.as_posix(): PathEntry.create(path=child, is_root=False)
-                for child in self._filter_children()
-            }
-        elif not self.is_dir:
-            self._children = {self.path.as_posix(): self}
+        if not self._children:
+            children = {}
+            for child_key, child_val in self._gen_children():
+                children[child_key] = child_val
+            self._children = children
         return self._children
 
+    @name.default
+    def get_name(self):
+        return self.path.name
+
+    @py_version.default
+    def get_py_version(self):
+        from ..environment import IGNORE_UNSUPPORTED
+        if self.is_dir:
+            return None
+        if self.is_python:
+            from .python import PythonVersion
+            try:
+                py_version = PythonVersion.from_path(path=self, name=self.name)
+            except InvalidPythonVersion:
+                py_version = None
+            return py_version
+        return
+
     @pythons.default
     def get_pythons(self):
         pythons = defaultdict()
@@ -347,56 +462,62 @@ class PathEntry(BasePath):
         else:
             if self.is_python:
                 _path = ensure_path(self.path)
-                pythons[_path.as_posix()] = copy.deepcopy(self)
+                pythons[_path.as_posix()] = self
         return pythons
 
     @cached_property
     def as_python(self):
+        py_version = None
+        if self.py_version:
+            return self.py_version
         if not self.is_dir and self.is_python:
-            if not self.py_version:
-                try:
-                    from .python import PythonVersion
-
-                    self.py_version = PythonVersion.from_path(self.path)
-                except (ValueError, InvalidPythonVersion):
-                    self.py_version = None
-        return self.py_version
+            try:
+                from .python import PythonVersion
+                py_version = PythonVersion.from_path(path=attr.evolve(self), name=self.name)
+            except (ValueError, InvalidPythonVersion):
+                py_version = None
+        return py_version
 
     @classmethod
-    def create(cls, path, is_root=False, only_python=False, pythons=None):
+    def create(cls, path, is_root=False, only_python=False, pythons=None, name=None):
         """Helper method for creating new :class:`pythonfinder.models.PathEntry` instances.
 
-        :param path: Path to the specified location.
-        :type path: str
-        :param is_root: Whether this is a root from the environment PATH variable, defaults to False
-        :param is_root: bool, optional
-        :param only_python: Whether to search only for python executables, defaults to False
-        :param only_python: bool, optional
-        :param pythons: A dictionary of existing python objects (usually from a finder), defaults to None
-        :param pythons: dict, optional
+        :param str path: Path to the specified location.
+        :param bool is_root: Whether this is a root from the environment PATH variable, defaults to False
+        :param bool only_python: Whether to search only for python executables, defaults to False
+        :param dict pythons: A dictionary of existing python objects (usually from a finder), defaults to None
+        :param str name: Name of the python version, e.g. ``anaconda3-5.3.0``
         :return: A new instance of the class.
         :rtype: :class:`pythonfinder.models.PathEntry`
         """
 
         target = ensure_path(path)
-        creation_args = {"path": target, "is_root": is_root, "only_python": only_python}
+        guessed_name = False
+        if not name:
+            guessed_name = True
+            name = target.name
+        creation_args = {"path": target, "is_root": is_root, "only_python": only_python, "name": name}
         if pythons:
             creation_args["pythons"] = pythons
         _new = cls(**creation_args)
         if pythons and only_python:
             children = {}
+            child_creation_args = {
+                "is_root": False,
+                "only_python": only_python
+            }
+            if not guessed_name:
+                child_creation_args["name"] = name
             for pth, python in pythons.items():
                 pth = ensure_path(pth)
                 children[pth.as_posix()] = PathEntry(
-                    path=pth, is_root=False, only_python=only_python, py_version=python
+                    py_version=python,
+                    path=pth,
+                    **child_creation_args
                 )
             _new._children = children
         return _new
 
-    @cached_property
-    def name(self):
-        return self.path.name
-
     @cached_property
     def is_dir(self):
         try:
@@ -412,28 +533,5 @@ class PathEntry(BasePath):
     @cached_property
     def is_python(self):
         return self.is_executable and (
-            self.py_version or looks_like_python(self.path.name)
+            looks_like_python(self.path.name)
         )
-
-
-@attr.s
-class VersionPath(SystemPath):
-    base = attr.ib(default=None, validator=optional_instance_of(Path))
-
-    @classmethod
-    def create(cls, path, only_python=True, pythons=None):
-        """Accepts a path to a base python version directory.
-
-        Generates the pyenv version listings for it"""
-        path = ensure_path(path)
-        path_entries = defaultdict(PathEntry)
-        if not path.name.lower() in ["scripts", "bin"]:
-            bin_name = "Scripts" if os.name == "nt" else "bin"
-            bin_dir = path / bin_name
-        else:
-            bin_dir = path
-        current_entry = PathEntry.create(
-            bin_dir, is_root=True, only_python=True, pythons=pythons
-        )
-        path_entries[bin_dir.as_posix()] = current_entry
-        return cls(base=bin_dir, paths=path_entries)
diff --git a/pipenv/vendor/pythonfinder/models/pyenv.py b/pipenv/vendor/pythonfinder/models/pyenv.py
index 6df47179..1595a963 100644
--- a/pipenv/vendor/pythonfinder/models/pyenv.py
+++ b/pipenv/vendor/pythonfinder/models/pyenv.py
@@ -1,52 +1,224 @@
 # -*- coding=utf-8 -*-
 from __future__ import absolute_import, print_function
 
+import logging
+import operator
+
 from collections import defaultdict
 
 import attr
+import sysconfig
 
 from vistir.compat import Path
 
-from ..utils import ensure_path, optional_instance_of
-from .mixins import BaseFinder
-from .path import VersionPath
+from ..utils import (
+    ensure_path,
+    optional_instance_of,
+    get_python_version,
+    filter_pythons,
+    unnest,
+)
+from .mixins import BaseFinder, BasePath
+from .path import SystemPath, PathEntry
 from .python import PythonVersion
 
 
+logger = logging.getLogger(__name__)
+
+
 @attr.s
-class PyenvFinder(BaseFinder):
+class PyenvFinder(BaseFinder, BasePath):
     root = attr.ib(default=None, validator=optional_instance_of(Path))
+    #: ignore_unsupported should come before versions, because its value is used
+    #: in versions's default initializer.
+    ignore_unsupported = attr.ib(default=True)
+    paths = attr.ib(default=attr.Factory(list))
+    roots = attr.ib(default=attr.Factory(defaultdict))
     versions = attr.ib()
     pythons = attr.ib()
 
+    @property
+    def expanded_paths(self):
+        return (
+            path for path in unnest(p for p in self.versions.values())
+            if path is not None
+        )
+
+    @classmethod
+    def version_from_bin_dir(cls, base_dir, name=None):
+        py_version = None
+        version_path = PathEntry.create(
+            path=base_dir.absolute().as_posix(),
+            only_python=True,
+            name=base_dir.parent.name,
+        )
+        py_version = next(iter(version_path.find_all_python_versions()), None)
+        return py_version
+
     @versions.default
     def get_versions(self):
-        versions = defaultdict(VersionPath)
+        versions = defaultdict()
+        bin_ = sysconfig._INSTALL_SCHEMES[sysconfig._get_default_scheme()]["scripts"]
         for p in self.root.glob("versions/*"):
-            version = PythonVersion.parse(p.name)
+            if p.parent.name == "envs" or p.name == "envs":
+                continue
+            bin_dir = Path(bin_.format(base=p.as_posix()))
+            version_path = None
+            if bin_dir.exists():
+                version_path = PathEntry.create(
+                    path=bin_dir.absolute().as_posix(),
+                    only_python=False,
+                    name=p.name,
+                    is_root=True,
+                )
+            version = None
+            try:
+                version = PythonVersion.parse(p.name)
+            except ValueError:
+                entry = next(iter(version_path.find_all_python_versions()), None)
+                if not entry:
+                    if self.ignore_unsupported:
+                        continue
+                    raise
+                else:
+                    version = entry.py_version.as_dict()
+            except Exception:
+                if not self.ignore_unsupported:
+                    raise
+                logger.warning(
+                    "Unsupported Python version %r, ignoring...", p.name, exc_info=True
+                )
+                continue
+            if not version:
+                continue
             version_tuple = (
                 version.get("major"),
                 version.get("minor"),
                 version.get("patch"),
                 version.get("is_prerelease"),
                 version.get("is_devrelease"),
+                version.get("is_debug"),
             )
-            versions[version_tuple] = VersionPath.create(
-                path=p.resolve(), only_python=True
-            )
+            self.roots[p] = version_path
+            versions[version_tuple] = version_path
+            self.paths.append(version_path)
         return versions
 
     @pythons.default
     def get_pythons(self):
         pythons = defaultdict()
-        for v in self.versions.values():
-            for p in v.paths.values():
-                _path = ensure_path(p.path)
-                if p.is_python:
-                    pythons[_path] = p
+        for p in self.paths:
+            pythons.update(p.pythons)
         return pythons
 
     @classmethod
-    def create(cls, root):
+    def create(cls, root, ignore_unsupported=True):
         root = ensure_path(root)
-        return cls(root=root)
+        return cls(root=root, ignore_unsupported=ignore_unsupported)
+
+    def find_all_python_versions(
+        self,
+        major=None,
+        minor=None,
+        patch=None,
+        pre=None,
+        dev=None,
+        arch=None,
+        name=None,
+    ):
+        """Search for a specific python version on the path. Return all copies
+
+        :param major: Major python version to search for.
+        :type major: int
+        :param int minor: Minor python version to search for, defaults to None
+        :param int patch: Patch python version to search for, defaults to None
+        :param bool pre: Search for prereleases (default None) - prioritize releases if None
+        :param bool dev: Search for devreleases (default None) - prioritize releases if None
+        :param str arch: Architecture to include, e.g. '64bit', defaults to None
+        :param str name: The name of a python version, e.g. ``anaconda3-5.3.0``
+        :return: A list of :class:`~pythonfinder.models.PathEntry` instances matching the version requested.
+        :rtype: List[:class:`~pythonfinder.models.PathEntry`]
+        """
+
+        version_matcher = operator.methodcaller(
+            "matches",
+            major=major,
+            minor=minor,
+            patch=patch,
+            pre=pre,
+            dev=dev,
+            arch=arch,
+            name=name,
+        )
+        py = operator.attrgetter("as_python")
+        pythons = (
+            py_ver for py_ver in (py(p) for p in self.pythons.values() if p is not None)
+            if py_ver is not None
+        )
+        # pythons = filter(None, [p.as_python for p in self.pythons.values()])
+        matching_versions = filter(lambda py: version_matcher(py), pythons)
+        version_sort = operator.attrgetter("version_sort")
+        return sorted(matching_versions, key=version_sort, reverse=True)
+
+    def find_python_version(
+        self,
+        major=None,
+        minor=None,
+        patch=None,
+        pre=None,
+        dev=None,
+        arch=None,
+        name=None,
+    ):
+        """Search or self for the specified Python version and return the first match.
+
+        :param major: Major version number.
+        :type major: int
+        :param int minor: Minor python version to search for, defaults to None
+        :param int patch: Patch python version to search for, defaults to None
+        :param bool pre: Search for prereleases (default None) - prioritize releases if None
+        :param bool dev: Search for devreleases (default None) - prioritize releases if None
+        :param str arch: Architecture to include, e.g. '64bit', defaults to None
+        :param str name: The name of a python version, e.g. ``anaconda3-5.3.0``
+        :returns: A :class:`~pythonfinder.models.PathEntry` instance matching the version requested.
+        """
+
+        version_matcher = operator.methodcaller(
+            "matches",
+            major=major,
+            minor=minor,
+            patch=patch,
+            pre=pre,
+            dev=dev,
+            arch=arch,
+            name=name,
+        )
+        pythons = filter(None, [p.as_python for p in self.pythons.values()])
+        matching_versions = filter(lambda py: version_matcher(py), pythons)
+        version_sort = operator.attrgetter("version_sort")
+        return next(iter(c for c in sorted(matching_versions, key=version_sort, reverse=True)), None)
+
+
+@attr.s
+class VersionPath(SystemPath):
+    base = attr.ib(default=None, validator=optional_instance_of(Path))
+    name = attr.ib(default=None)
+
+    @classmethod
+    def create(cls, path, only_python=True, pythons=None, name=None):
+        """Accepts a path to a base python version directory.
+
+        Generates the pyenv version listings for it"""
+        path = ensure_path(path)
+        path_entries = defaultdict(PathEntry)
+        bin_ = sysconfig._INSTALL_SCHEMES[sysconfig._get_default_scheme()]["scripts"]
+        if path.as_posix().endswith(Path(bin_).name):
+            path = path.parent
+        bin_dir = ensure_path(bin_.format(base=path.as_posix()))
+        if not name:
+            name = path.name
+        current_entry = PathEntry.create(
+            bin_dir, is_root=True, only_python=True, pythons=pythons, name=name
+        )
+        path_entries[bin_dir.as_posix()] = current_entry
+        return cls(name=name, base=bin_dir, paths=path_entries)
diff --git a/pipenv/vendor/pythonfinder/models/python.py b/pipenv/vendor/pythonfinder/models/python.py
index 8a40e248..ec99afe7 100644
--- a/pipenv/vendor/pythonfinder/models/python.py
+++ b/pipenv/vendor/pythonfinder/models/python.py
@@ -8,14 +8,16 @@ from collections import defaultdict
 
 import attr
 
-from packaging.version import Version
+from packaging.version import Version, LegacyVersion
 from packaging.version import parse as parse_version
 
-from vistir.compat import Path
-
 from ..environment import SYSTEM_ARCH
 from ..utils import (
-    _filter_none, ensure_path, get_python_version, optional_instance_of
+    _filter_none,
+    ensure_path,
+    get_python_version,
+    optional_instance_of,
+    ensure_path,
 )
 
 
@@ -27,10 +29,12 @@ class PythonVersion(object):
     is_prerelease = attr.ib(default=False)
     is_postrelease = attr.ib(default=False)
     is_devrelease = attr.ib(default=False)
+    is_debug = attr.ib(default=False)
     version = attr.ib(default=None, validator=optional_instance_of(Version))
     architecture = attr.ib(default=None)
     comes_from = attr.ib(default=None)
     executable = attr.ib(default=None)
+    name = attr.ib(default=None)
 
     @property
     def version_sort(self):
@@ -48,6 +52,8 @@ class PythonVersion(object):
             release_sort = 1
         elif self.is_devrelease:
             release_sort = 0
+        elif self.is_debug:
+            release_sort = 1
         return (self.major, self.minor, self.patch if self.patch else 0, release_sort)
 
     @property
@@ -64,20 +70,37 @@ class PythonVersion(object):
             self.patch,
             self.is_prerelease,
             self.is_devrelease,
+            self.is_debug,
         )
 
     def matches(
-        self, major=None, minor=None, patch=None, pre=False, dev=False, arch=None
+        self,
+        major=None,
+        minor=None,
+        patch=None,
+        pre=False,
+        dev=False,
+        arch=None,
+        debug=False,
+        name=None,
     ):
-        if arch and arch.isdigit():
-            arch = "{0}bit".format(arch)
+        if arch:
+            own_arch = self.get_architecture()
+            if arch.isdigit():
+                arch = "{0}bit".format(arch)
         return (
             (major is None or self.major == major)
             and (minor is None or self.minor == minor)
             and (patch is None or self.patch == patch)
             and (pre is None or self.is_prerelease == pre)
             and (dev is None or self.is_devrelease == dev)
-            and (arch is None or self.architecture == arch)
+            and (arch is None or own_arch == arch)
+            and (debug is None or self.is_debug == debug)
+            and (
+                name is None
+                or (name and self.name)
+                and (self.name == name or self.name.startswith(name))
+            )
         )
 
     def as_major(self):
@@ -90,6 +113,18 @@ class PythonVersion(object):
         self_dict.update({"patch": None})
         return self.create(**self_dict)
 
+    def as_dict(self):
+        return {
+            "major": self.major,
+            "minor": self.minor,
+            "patch": self.patch,
+            "is_prerelease": self.is_prerelease,
+            "is_postrelease": self.is_postrelease,
+            "is_devrelease": self.is_devrelease,
+            "is_debug": self.is_debug,
+            "version": self.version,
+        }
+
     @classmethod
     def parse(cls, version):
         """Parse a valid version string into a dictionary
@@ -104,6 +139,10 @@ class PythonVersion(object):
         :rtype: dict.
         """
 
+        is_debug = False
+        if version.endswith("-debug"):
+            is_debug = True
+            version, _, _ = version.rpartition("-")
         try:
             version = parse_version(str(version))
         except TypeError:
@@ -127,11 +166,19 @@ class PythonVersion(object):
             "is_prerelease": version.is_prerelease,
             "is_postrelease": version.is_postrelease,
             "is_devrelease": version.is_devrelease,
+            "is_debug": is_debug,
             "version": version,
         }
 
+    def get_architecture(self):
+        if self.architecture:
+            return self.architecture
+        arch, _ = platform.architecture(path.path.as_posix())
+        self.architecture = arch
+        return self.architecture
+
     @classmethod
-    def from_path(cls, path):
+    def from_path(cls, path, name=None):
         """Parses a python version from a system path.
 
         Raises:
@@ -139,29 +186,33 @@ class PythonVersion(object):
 
         :param path: A string or :class:`~pythonfinder.models.path.PathEntry`
         :type path: str or :class:`~pythonfinder.models.path.PathEntry` instance
-        :param launcher_entry: A python launcher environment object.
+        :param str name: Name of the python distribution in question
         :return: An instance of a PythonVersion.
         :rtype: :class:`~pythonfinder.models.python.PythonVersion`
         """
 
         from .path import PathEntry
+        from ..environment import IGNORE_UNSUPPORTED
 
         if not isinstance(path, PathEntry):
-            path = PathEntry.create(path, is_root=False, only_python=True)
-        if not path.is_python:
+            path = PathEntry.create(path, is_root=False, only_python=True, name=name)
+        if not path.is_python and not IGNORE_UNSUPPORTED:
             raise ValueError("Not a valid python path: %s" % path.path)
             return
-        py_version = get_python_version(str(path.path))
+        py_version = get_python_version(path.path.as_posix())
         instance_dict = cls.parse(py_version)
-        if not isinstance(instance_dict.get("version"), Version):
+        if not isinstance(instance_dict.get("version"), Version) and not IGNORE_UNSUPPORTED:
             raise ValueError("Not a valid python path: %s" % path.path)
             return
-        architecture, _ = platform.architecture(path.path.as_posix())
-        instance_dict.update({"comes_from": path, "architecture": architecture})
+        if not name:
+            name = path.name
+        instance_dict.update(
+            {"comes_from": path, "name": name}
+        )
         return cls(**instance_dict)
 
     @classmethod
-    def from_windows_launcher(cls, launcher_entry):
+    def from_windows_launcher(cls, launcher_entry, name=None):
         """Create a new PythonVersion instance from a Windows Launcher Entry
 
         :param launcher_entry: A python launcher environment object.
@@ -185,12 +236,14 @@ class PythonVersion(object):
                     launcher_entry.info, "sys_architecture", SYSTEM_ARCH
                 ),
                 "executable": exe_path,
+                "name": name
             }
         )
         py_version = cls.create(**creation_dict)
-        comes_from = PathEntry.create(exe_path, only_python=True)
+        comes_from = PathEntry.create(exe_path, only_python=True, name=name)
         comes_from.py_version = copy.deepcopy(py_version)
         py_version.comes_from = comes_from
+        py_version.name = comes_from.name
         return py_version
 
     @classmethod
@@ -208,7 +261,7 @@ class VersionMap(object):
     def add_entry(self, entry):
         version = entry.as_python
         if version:
-            entries = versions[version.version_tuple]
+            entries = self.versions[version.version_tuple]
             paths = {p.path for p in self.versions.get(version.version_tuple, [])}
             if entry.path not in paths:
                 self.versions[version.version_tuple].append(entry)
diff --git a/pipenv/vendor/pythonfinder/models/windows.py b/pipenv/vendor/pythonfinder/models/windows.py
index 4f0b64d1..e47bcc2c 100644
--- a/pipenv/vendor/pythonfinder/models/windows.py
+++ b/pipenv/vendor/pythonfinder/models/windows.py
@@ -22,7 +22,14 @@ class WindowsFinder(BaseFinder):
     pythons = attr.ib()
 
     def find_all_python_versions(
-        self, major=None, minor=None, patch=None, pre=None, dev=None, arch=None
+        self,
+        major=None,
+        minor=None,
+        patch=None,
+        pre=None,
+        dev=None,
+        arch=None,
+        name=None,
     ):
         version_matcher = operator.methodcaller(
             "matches",
@@ -32,6 +39,7 @@ class WindowsFinder(BaseFinder):
             pre=pre,
             dev=dev,
             arch=arch,
+            name=name,
         )
         py_filter = filter(
             None, filter(lambda c: version_matcher(c), self.version_list)
@@ -40,13 +48,26 @@ class WindowsFinder(BaseFinder):
         return [c.comes_from for c in sorted(py_filter, key=version_sort, reverse=True)]
 
     def find_python_version(
-        self, major=None, minor=None, patch=None, pre=None, dev=None, arch=None
+        self,
+        major=None,
+        minor=None,
+        patch=None,
+        pre=None,
+        dev=None,
+        arch=None,
+        name=None,
     ):
         return next(
             (
                 v
                 for v in self.find_all_python_versions(
-                    major=major, minor=minor, patch=patch, pre=pre, dev=dev, arch=arch
+                    major=major,
+                    minor=minor,
+                    patch=patch,
+                    pre=pre,
+                    dev=dev,
+                    arch=arch,
+                    name=None,
                 )
             ),
             None,
@@ -60,7 +81,10 @@ class WindowsFinder(BaseFinder):
         env_versions = pep514env.findall()
         path = None
         for version_object in env_versions:
-            path = ensure_path(version_object.info.install_path.__getattr__(""))
+            install_path = getattr(version_object.info, "install_path", None)
+            if install_path is None:
+                continue
+            path = ensure_path(install_path.__getattr__(""))
             try:
                 py_version = PythonVersion.from_windows_launcher(version_object)
             except InvalidPythonVersion:
diff --git a/pipenv/vendor/pythonfinder/pythonfinder.py b/pipenv/vendor/pythonfinder/pythonfinder.py
index 035842e2..854cc8e7 100644
--- a/pipenv/vendor/pythonfinder/pythonfinder.py
+++ b/pipenv/vendor/pythonfinder/pythonfinder.py
@@ -4,33 +4,45 @@ import os
 import six
 import operator
 from .models import SystemPath
+from vistir.compat import lru_cache
 
 
 class Finder(object):
-    def __init__(self, path=None, system=False, global_search=True):
+    def __init__(self, path=None, system=False, global_search=True, ignore_unsupported=True):
         """Finder A cross-platform Finder for locating python and other executables.
-        
+
         Searches for python and other specified binaries starting in `path`, if supplied,
         but searching the bin path of `sys.executable` if `system=True`, and then
         searching in the `os.environ['PATH']` if `global_search=True`.  When `global_search`
-        is `False`, this search operation is restricted to the allowed locations of 
+        is `False`, this search operation is restricted to the allowed locations of
         `path` and `system`.
-        
+
         :param path: A bin-directory search location, defaults to None
         :param path: str, optional
         :param system: Whether to include the bin-dir of `sys.executable`, defaults to False
         :param system: bool, optional
         :param global_search: Whether to search the global path from os.environ, defaults to True
         :param global_search: bool, optional
+        :param ignore_unsupported: Whether to ignore unsupported python versions, if False, an error is raised, defaults to True
+        :param ignore_unsupported: bool, optional
         :returns: a :class:`~pythonfinder.pythonfinder.Finder` object.
         """
 
         self.path_prepend = path
         self.global_search = global_search
         self.system = system
+        self.ignore_unsupported = ignore_unsupported
         self._system_path = None
         self._windows_finder = None
 
+    def __hash__(self):
+        return hash(
+            (self.path_prepend, self.system, self.global_search, self.ignore_unsupported)
+        )
+
+    def __eq__(self, other):
+        return self.__hash__() == other.__hash__()
+
     @property
     def system_path(self):
         if not self._system_path:
@@ -38,6 +50,7 @@ class Finder(object):
                 path=self.path_prepend,
                 system=self.system,
                 global_search=self.global_search,
+                ignore_unsupported=self.ignore_unsupported,
             )
         return self._system_path
 
@@ -52,8 +65,9 @@ class Finder(object):
     def which(self, exe):
         return self.system_path.which(exe)
 
+    @lru_cache(maxsize=128)
     def find_python_version(
-        self, major, minor=None, patch=None, pre=None, dev=None, arch=None
+        self, major=None, minor=None, patch=None, pre=None, dev=None, arch=None, name=None
     ):
         from .models import PythonVersion
 
@@ -65,12 +79,24 @@ class Finder(object):
             and patch is None
         ):
             if arch is None and "-" in major:
-                major, arch = major.rsplit("-", 1)
-                if not arch.isdigit():
-                    major = "{0}-{1}".format(major, arch)
+                orig_string = "{0!s}".format(major)
+                major, _, arch = major.rpartition("-")
+                if arch.startswith("x"):
+                    arch = arch.lstrip("x")
+                if arch.lower().endswith("bit"):
+                    arch = arch.lower().replace("bit", "")
+                if not (arch.isdigit() and (int(arch) & int(arch) - 1) == 0):
+                    major = orig_string
+                    arch = None
                 else:
                     arch = "{0}bit".format(arch)
-            version_dict = PythonVersion.parse(major)
+            try:
+                version_dict = PythonVersion.parse(major)
+            except ValueError:
+                if name is None:
+                    name = "{0!s}".format(major)
+                    major = None
+                version_dict = {}
             major = version_dict.get("major", major)
             minor = version_dict.get("minor", minor)
             patch = version_dict.get("patch", patch)
@@ -79,16 +105,17 @@ class Finder(object):
             arch = version_dict.get("architecture", arch) if arch is None else arch
         if os.name == "nt":
             match = self.windows_finder.find_python_version(
-                major, minor=minor, patch=patch, pre=pre, dev=dev, arch=arch
+                major=major, minor=minor, patch=patch, pre=pre, dev=dev, arch=arch, name=name
             )
             if match:
                 return match
         return self.system_path.find_python_version(
-            major=major, minor=minor, patch=patch, pre=pre, dev=dev, arch=arch
+            major=major, minor=minor, patch=patch, pre=pre, dev=dev, arch=arch, name=name
         )
 
+    @lru_cache(maxsize=128)
     def find_all_python_versions(
-        self, major=None, minor=None, patch=None, pre=None, dev=None, arch=None
+        self, major=None, minor=None, patch=None, pre=None, dev=None, arch=None, name=None
     ):
         version_sort = operator.attrgetter("as_python.version_sort")
         python_version_dict = getattr(self.system_path, "python_version_dict")
@@ -105,7 +132,7 @@ class Finder(object):
             paths = sorted(paths, key=version_sort, reverse=True)
             return paths
         versions = self.system_path.find_all_python_versions(
-            major=major, minor=minor, patch=patch, pre=pre, dev=dev, arch=arch
+            major=major, minor=minor, patch=patch, pre=pre, dev=dev, arch=arch, name=name
         )
         if not isinstance(versions, list):
             versions = [versions]
diff --git a/pipenv/vendor/pythonfinder/utils.py b/pipenv/vendor/pythonfinder/utils.py
index 285e06be..ca07b42f 100644
--- a/pipenv/vendor/pythonfinder/utils.py
+++ b/pipenv/vendor/pythonfinder/utils.py
@@ -1,6 +1,7 @@
 # -*- coding=utf-8 -*-
 from __future__ import absolute_import, print_function
 
+import itertools
 import locale
 import os
 import subprocess
@@ -14,29 +15,51 @@ import six
 
 import vistir
 
-from vistir.compat import Path
-
 from .exceptions import InvalidPythonVersion
 
+try:
+    from functools import lru_cache
+except ImportError:
+    from backports.functools_lru_cache import lru_cache
 
-PYTHON_IMPLEMENTATIONS = ("python", "ironpython", "jython", "pypy")
+six.add_move(six.MovedAttribute("Iterable", "collections", "collections.abc"))
+from six.moves import Iterable
+
+
+PYTHON_IMPLEMENTATIONS = (
+    "python", "ironpython", "jython", "pypy", "anaconda", "miniconda",
+    "stackless", "activepython", "micropython"
+)
+RULES_BASE = ["*{0}", "*{0}?", "*{0}?.?", "*{0}?.?m"]
+RULES = [rule.format(impl) for impl in PYTHON_IMPLEMENTATIONS for rule in RULES_BASE]
 
 KNOWN_EXTS = {"exe", "py", "fish", "sh", ""}
 KNOWN_EXTS = KNOWN_EXTS | set(
     filter(None, os.environ.get("PATHEXT", "").split(os.pathsep))
 )
 
+MATCH_RULES = []
+for rule in RULES:
+    MATCH_RULES.extend(
+        [
+            "{0}.{1}".format(rule, ext) if ext else "{0}".format(rule)
+            for ext in KNOWN_EXTS
+        ]
+    )
 
+
+@lru_cache(maxsize=128)
 def get_python_version(path):
     """Get python version string using subprocess from a given path."""
     version_cmd = [path, "-c", "import sys; print(sys.version.split()[0])"]
     try:
-        out, _ = vistir.misc.run(version_cmd)
+        c = vistir.misc.run(version_cmd, block=True, nospin=True, return_object=True,
+                                combine_stderr=False)
     except OSError:
         raise InvalidPythonVersion("%s is not a valid python path" % path)
-    if not out:
+    if not c.out:
         raise InvalidPythonVersion("%s is not a valid python path" % path)
-    return out
+    return c.out.strip()
 
 
 def optional_instance_of(cls):
@@ -44,13 +67,14 @@ def optional_instance_of(cls):
 
 
 def path_and_exists(path):
-    return attr.validators.instance_of(Path) and path.exists()
+    return attr.validators.instance_of(vistir.compat.Path) and path.exists()
 
 
 def path_is_executable(path):
     return os.access(str(path), os.X_OK)
 
 
+@lru_cache(maxsize=1024)
 def path_is_known_executable(path):
     return (
         path_is_executable(path)
@@ -59,25 +83,19 @@ def path_is_known_executable(path):
     )
 
 
+@lru_cache(maxsize=1024)
 def looks_like_python(name):
-    rules = ["*python", "*python?", "*python?.?", "*python?.?m"]
-    match_rules = []
-    for rule in rules:
-        match_rules.extend(
-            [
-                "{0}.{1}".format(rule, ext) if ext else "{0}".format(rule)
-                for ext in KNOWN_EXTS
-            ]
-        )
     if not any(name.lower().startswith(py_name) for py_name in PYTHON_IMPLEMENTATIONS):
         return False
-    return any(fnmatch(name, rule) for rule in match_rules)
+    return any(fnmatch(name, rule) for rule in MATCH_RULES)
 
 
+@lru_cache(maxsize=128)
 def path_is_python(path):
     return path_is_executable(path) and looks_like_python(path.name)
 
 
+@lru_cache(maxsize=1024)
 def ensure_path(path):
     """Given a path (either a string or a Path object), expand variables and return a Path object.
 
@@ -87,14 +105,10 @@ def ensure_path(path):
     :rtype: :class:`~pathlib.Path`
     """
 
-    if isinstance(path, Path):
-        path = path.as_posix()
-    path = Path(os.path.expandvars(path))
-    try:
-        path = path.resolve()
-    except OSError:
-        path = path.absolute()
-    return path
+    if isinstance(path, vistir.compat.Path):
+        return path
+    path = vistir.compat.Path(os.path.expandvars(path))
+    return path.absolute()
 
 
 def _filter_none(k, v):
@@ -103,16 +117,31 @@ def _filter_none(k, v):
     return False
 
 
+@lru_cache(maxsize=128)
 def filter_pythons(path):
     """Return all valid pythons in a given path"""
-    if not isinstance(path, Path):
-        path = Path(str(path))
+    if not isinstance(path, vistir.compat.Path):
+        path = vistir.compat.Path(str(path))
     if not path.is_dir():
         return path if path_is_python(path) else None
     return filter(lambda x: path_is_python(x), path.iterdir())
 
 
+# def unnest(item):
+#     if isinstance(next((i for i in item), None), (list, tuple)):
+#         return chain(*filter(None, item))
+#     return chain(filter(None, item))
+
+
 def unnest(item):
-    if isinstance(next((i for i in item), None), (list, tuple)):
-        return chain(*filter(None, item))
-    return chain(filter(None, item))
+    if isinstance(item, Iterable) and not isinstance(item, six.string_types):
+        item, target = itertools.tee(item, 2)
+    else:
+        target = item
+    for el in target:
+        if isinstance(el, Iterable) and not isinstance(el, six.string_types):
+            el, el_copy = itertools.tee(el, 2)
+            for sub in unnest(el_copy):
+                yield sub
+        else:
+            yield el
diff --git a/pipenv/vendor/pytoml/parser.py b/pipenv/vendor/pytoml/parser.py
index e03a03fb..9f94e923 100644
--- a/pipenv/vendor/pytoml/parser.py
+++ b/pipenv/vendor/pytoml/parser.py
@@ -223,8 +223,8 @@ _float_re = re.compile(r'[+-]?(?:0|[1-9](?:_?\d)*)(?:\.\d(?:_?\d)*)?(?:[eE][+-]?
 _datetime_re = re.compile(r'(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d+)?(?:Z|([+-]\d{2}):(\d{2}))')
 
 _basicstr_ml_re = re.compile(r'(?:(?:|"|"")[^"\\\000-\011\013-\037])*')
-_litstr_re = re.compile(r"[^'\000-\037]*")
-_litstr_ml_re = re.compile(r"(?:(?:|'|'')(?:[^'\000-\011\013-\037]))*")
+_litstr_re = re.compile(r"[^'\000\010\012-\037]*")
+_litstr_ml_re = re.compile(r"(?:(?:|'|'')(?:[^'\000-\010\013-\037]))*")
 def _p_value(s, object_pairs_hook):
     pos = s.pos()
 
diff --git a/pipenv/vendor/requests/LICENSE b/pipenv/vendor/requests/LICENSE
index 2e68b82e..841c6023 100644
--- a/pipenv/vendor/requests/LICENSE
+++ b/pipenv/vendor/requests/LICENSE
@@ -4,7 +4,7 @@ Copyright 2018 Kenneth Reitz
    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,
diff --git a/pipenv/vendor/requests/__init__.py b/pipenv/vendor/requests/__init__.py
index a5b3c9c3..bc168ee5 100644
--- a/pipenv/vendor/requests/__init__.py
+++ b/pipenv/vendor/requests/__init__.py
@@ -22,7 +22,7 @@ usage:
 ... 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)
    {
      ...
@@ -57,10 +57,10 @@ def check_compatibility(urllib3_version, chardet_version):
     # Check urllib3 for compatibility.
     major, minor, patch = urllib3_version  # noqa: F811
     major, minor, patch = int(major), int(minor), int(patch)
-    # urllib3 >= 1.21.1, <= 1.23
+    # urllib3 >= 1.21.1, <= 1.24
     assert major == 1
     assert minor >= 21
-    assert minor <= 23
+    assert minor <= 24
 
     # Check chardet for compatibility.
     major, minor, patch = chardet_version.split('.')[:3]
@@ -79,14 +79,14 @@ def _check_cryptography(cryptography_version):
         return
 
     if cryptography_version < [1, 3, 4]:
-        warning = 'Old version of cryptography ({0}) may cause slowdown.'.format(cryptography_version)
+        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 "
+    warnings.warn("urllib3 ({}) or chardet ({}) doesn't match a supported "
                   "version!".format(urllib3.__version__, chardet.__version__),
                   RequestsDependencyWarning)
 
@@ -123,12 +123,7 @@ from .exceptions import (
 
 # Set default logging handler to avoid "No handler found" warnings.
 import logging
-try:  # Python 2.7+
-    from logging import NullHandler
-except ImportError:
-    class NullHandler(logging.Handler):
-        def emit(self, record):
-            pass
+from logging import NullHandler
 
 logging.getLogger(__name__).addHandler(NullHandler())
 
diff --git a/pipenv/vendor/requests/__version__.py b/pipenv/vendor/requests/__version__.py
index ef61ec0f..be8a45fe 100644
--- a/pipenv/vendor/requests/__version__.py
+++ b/pipenv/vendor/requests/__version__.py
@@ -5,8 +5,8 @@
 __title__ = 'requests'
 __description__ = 'Python HTTP for Humans.'
 __url__ = 'http://python-requests.org'
-__version__ = '2.19.1'
-__build__ = 0x021901
+__version__ = '2.20.0'
+__build__ = 0x022000
 __author__ = 'Kenneth Reitz'
 __author_email__ = 'me@kennethreitz.org'
 __license__ = 'Apache 2.0'
diff --git a/pipenv/vendor/requests/adapters.py b/pipenv/vendor/requests/adapters.py
index a4b02842..fa4d9b3c 100644
--- a/pipenv/vendor/requests/adapters.py
+++ b/pipenv/vendor/requests/adapters.py
@@ -26,6 +26,7 @@ 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 .compat import urlparse, basestring
@@ -35,7 +36,8 @@ from .utils import (DEFAULT_CA_BUNDLE_PATH, extract_zipped_paths,
 from .structures import CaseInsensitiveDict
 from .cookies import extract_cookies_to_jar
 from .exceptions import (ConnectionError, ConnectTimeout, ReadTimeout, SSLError,
-                         ProxyError, RetryError, InvalidSchema, InvalidProxyURL)
+                         ProxyError, RetryError, InvalidSchema, InvalidProxyURL,
+                         InvalidURL)
 from .auth import _basic_auth_str
 
 try:
@@ -127,8 +129,7 @@ class HTTPAdapter(BaseAdapter):
         self.init_poolmanager(pool_connections, pool_maxsize, block=pool_block)
 
     def __getstate__(self):
-        return dict((attr, getattr(self, attr, None)) for attr in
-                    self.__attrs__)
+        return {attr: getattr(self, attr, None) for attr in self.__attrs__}
 
     def __setstate__(self, state):
         # Can't handle by adding 'proxy_manager' to self.__attrs__ because
@@ -224,7 +225,7 @@ class HTTPAdapter(BaseAdapter):
 
             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))
+                              "invalid path: {}".format(cert_loc))
 
             conn.cert_reqs = 'CERT_REQUIRED'
 
@@ -246,10 +247,10 @@ class HTTPAdapter(BaseAdapter):
                 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: {0}".format(conn.cert_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: {0}".format(conn.key_file))
+                              "invalid path: {}".format(conn.key_file))
 
     def build_response(self, req, resp):
         """Builds a :class:`Response <requests.Response>` object from a urllib3
@@ -378,7 +379,7 @@ 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 = {}
@@ -407,7 +408,10 @@ class HTTPAdapter(BaseAdapter):
         :rtype: requests.Response
         """
 
-        conn = self.get_connection(request.url, proxies)
+        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)
@@ -421,7 +425,7 @@ class HTTPAdapter(BaseAdapter):
                 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) "
+                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)
@@ -471,11 +475,10 @@ class HTTPAdapter(BaseAdapter):
 
                     # Receive the response from the server
                     try:
-                        # For Python 2.7+ versions, use buffering of HTTP
-                        # responses
+                        # For Python 2.7, use buffering of HTTP responses
                         r = low_conn.getresponse(buffering=True)
                     except TypeError:
-                        # For compatibility with Python 2.6 versions and back
+                        # For compatibility with Python 3.3+
                         r = low_conn.getresponse()
 
                     resp = HTTPResponse.from_httplib(
diff --git a/pipenv/vendor/requests/api.py b/pipenv/vendor/requests/api.py
index a2cc84d7..abada96d 100644
--- a/pipenv/vendor/requests/api.py
+++ b/pipenv/vendor/requests/api.py
@@ -18,8 +18,10 @@ def request(method, url, **kwargs):
 
     :param method: method for the new :class:`Request` object.
     :param url: URL for the new :class:`Request` object.
-    :param params: (optional) Dictionary or bytes to be sent in the query string for the :class:`Request`.
-    :param data: (optional) Dictionary or list of tuples ``[(key, value)]`` (will be form-encoded), bytes, or file-like object to send in the body of the :class:`Request`.
+    :param params: (optional) Dictionary, list of tuples or bytes 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) 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`.
@@ -47,7 +49,7 @@ def request(method, url, **kwargs):
     Usage::
 
       >>> import requests
-      >>> req = requests.request('GET', 'http://httpbin.org/get')
+      >>> req = requests.request('GET', 'https://httpbin.org/get')
       <Response [200]>
     """
 
@@ -62,7 +64,8 @@ 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 body of the :class:`Request`.
     :param \*\*kwargs: Optional arguments that ``request`` takes.
     :return: :class:`Response <Response>` object
     :rtype: requests.Response
@@ -102,7 +105,8 @@ 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
@@ -116,7 +120,8 @@ 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
@@ -130,7 +135,8 @@ 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
diff --git a/pipenv/vendor/requests/auth.py b/pipenv/vendor/requests/auth.py
index 4ae45947..bdde51c7 100644
--- a/pipenv/vendor/requests/auth.py
+++ b/pipenv/vendor/requests/auth.py
@@ -38,7 +38,7 @@ def _basic_auth_str(username, password):
     if not isinstance(username, basestring):
         warnings.warn(
             "Non-string usernames will no longer be supported in Requests "
-            "3.0.0. Please convert the object you've passed in ({0!r}) to "
+            "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,
@@ -48,7 +48,7 @@ def _basic_auth_str(username, password):
     if not isinstance(password, basestring):
         warnings.warn(
             "Non-string passwords will no longer be supported in Requests "
-            "3.0.0. Please convert the object you've passed in ({0!r}) to "
+            "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(password),
             category=DeprecationWarning,
diff --git a/pipenv/vendor/requests/compat.py b/pipenv/vendor/requests/compat.py
index 6b9c6fac..c44b35ef 100644
--- a/pipenv/vendor/requests/compat.py
+++ b/pipenv/vendor/requests/compat.py
@@ -43,9 +43,8 @@ if is_py2:
     import cookielib
     from Cookie import Morsel
     from StringIO import StringIO
-    from collections import Callable, Mapping, MutableMapping
+    from collections import Callable, Mapping, MutableMapping, OrderedDict
 
-    from urllib3.packages.ordered_dict import OrderedDict
 
     builtin_str = str
     bytes = str
diff --git a/pipenv/vendor/requests/cookies.py b/pipenv/vendor/requests/cookies.py
index 50883a84..56fccd9c 100644
--- a/pipenv/vendor/requests/cookies.py
+++ b/pipenv/vendor/requests/cookies.py
@@ -444,20 +444,21 @@ def create_cookie(name, value, **kwargs):
     By default, the pair of `name` and `value` will be set for the domain ''
     and sent on every request (this is sometimes called a "supercookie").
     """
-    result = dict(
-        version=0,
-        name=name,
-        value=value,
-        port=None,
-        domain='',
-        path='/',
-        secure=False,
-        expires=None,
-        discard=True,
-        comment=None,
-        comment_url=None,
-        rest={'HttpOnly': None},
-        rfc2109=False,)
+    result = {
+        'version': 0,
+        'name': name,
+        'value': value,
+        'port': None,
+        'domain': '',
+        'path': '/',
+        'secure': False,
+        'expires': None,
+        'discard': True,
+        'comment': None,
+        'comment_url': None,
+        'rest': {'HttpOnly': None},
+        'rfc2109': False,
+    }
 
     badargs = set(kwargs) - set(result)
     if badargs:
@@ -511,6 +512,7 @@ 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()
@@ -529,6 +531,7 @@ 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')
diff --git a/pipenv/vendor/requests/help.py b/pipenv/vendor/requests/help.py
index 06e06b2a..e53d35ef 100644
--- a/pipenv/vendor/requests/help.py
+++ b/pipenv/vendor/requests/help.py
@@ -89,8 +89,7 @@ def 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)
+    system_ssl = ssl.OPENSSL_VERSION_NUMBER
     system_ssl_info = {
         'version': '%x' % system_ssl if system_ssl is not None else ''
     }
diff --git a/pipenv/vendor/requests/hooks.py b/pipenv/vendor/requests/hooks.py
index 32b32de7..7a51f212 100644
--- a/pipenv/vendor/requests/hooks.py
+++ b/pipenv/vendor/requests/hooks.py
@@ -15,14 +15,14 @@ HOOKS = ['response']
 
 
 def default_hooks():
-    return dict((event, []) for event in 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 dict()
+    hooks = hooks or {}
     hooks = hooks.get(key)
     if hooks:
         if hasattr(hooks, '__call__'):
diff --git a/pipenv/vendor/requests/models.py b/pipenv/vendor/requests/models.py
index 3d0e1f42..3dded57e 100644
--- a/pipenv/vendor/requests/models.py
+++ b/pipenv/vendor/requests/models.py
@@ -204,9 +204,13 @@ class Request(RequestHooksMixin):
     :param url: URL to send.
     :param headers: dictionary of headers to send.
     :param files: dictionary of {filename: fileobject} files to multipart upload.
-    :param data: the body to attach to the request. If a dictionary is provided, form-encoding will take place.
+    :param data: the body to attach to the request. If a dictionary or
+        list of tuples ``[(key, value)]`` is provided, form-encoding will
+        take place.
     :param json: json for the body to attach to the request (if files or data is not specified).
-    :param params: dictionary of URL parameters to append to the URL.
+    :param params: URL parameters to append to the URL. If a dictionary or
+        list of tuples ``[(key, value)]`` is provided, form-encoding will
+        take place.
     :param auth: Auth handler or (user, pass) tuple.
     :param cookies: dictionary or CookieJar of cookies to attach to this request.
     :param hooks: dictionary of callback hooks, for internal usage.
@@ -214,7 +218,7 @@ class Request(RequestHooksMixin):
     Usage::
 
       >>> import requests
-      >>> req = requests.Request('GET', 'http://httpbin.org/get')
+      >>> req = requests.Request('GET', 'https://httpbin.org/get')
       >>> req.prepare()
       <PreparedRequest [GET]>
     """
@@ -274,7 +278,7 @@ class PreparedRequest(RequestEncodingMixin, RequestHooksMixin):
     Usage::
 
       >>> import requests
-      >>> req = requests.Request('GET', 'http://httpbin.org/get')
+      >>> req = requests.Request('GET', 'https://httpbin.org/get')
       >>> r = req.prepare()
       <PreparedRequest [GET]>
 
@@ -648,10 +652,7 @@ class Response(object):
         if not self._content_consumed:
             self.content
 
-        return dict(
-            (attr, getattr(self, attr, None))
-            for attr in self.__attrs__
-        )
+        return {attr: getattr(self, attr, None) for attr in self.__attrs__}
 
     def __setstate__(self, state):
         for name, value in state.items():
diff --git a/pipenv/vendor/requests/sessions.py b/pipenv/vendor/requests/sessions.py
index ba135268..a448bd83 100644
--- a/pipenv/vendor/requests/sessions.py
+++ b/pipenv/vendor/requests/sessions.py
@@ -115,6 +115,22 @@ class SessionRedirectMixin(object):
             return to_native_string(location, 'utf8')
         return None
 
+    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
+        # Standard case: root URI must match
+        return old_parsed.port != new_parsed.port or old_parsed.scheme != new_parsed.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."""
@@ -236,14 +252,10 @@ class SessionRedirectMixin(object):
         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
@@ -299,7 +311,7 @@ class SessionRedirectMixin(object):
         """
         method = prepared_request.method
 
-        # http://tools.ietf.org/html/rfc7231#section-6.4.4
+        # https://tools.ietf.org/html/rfc7231#section-6.4.4
         if response.status_code == codes.see_other and method != 'HEAD':
             method = 'GET'
 
@@ -325,13 +337,13 @@ 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]>
     """
 
@@ -453,8 +465,8 @@ class Session(SessionRedirectMixin):
         :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
@@ -550,7 +562,8 @@ 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
@@ -562,7 +575,8 @@ class Session(SessionRedirectMixin):
         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
         """
@@ -573,7 +587,8 @@ class Session(SessionRedirectMixin):
         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
         """
@@ -723,7 +738,7 @@ class Session(SessionRedirectMixin):
             self.adapters[key] = self.adapters.pop(key)
 
     def __getstate__(self):
-        state = dict((attr, getattr(self, attr, None)) for attr in self.__attrs__)
+        state = {attr: getattr(self, attr, None) for attr in self.__attrs__}
         return state
 
     def __setstate__(self, state):
@@ -735,7 +750,12 @@ 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()
diff --git a/pipenv/vendor/requests/status_codes.py b/pipenv/vendor/requests/status_codes.py
index ff462c6c..813e8c4e 100644
--- a/pipenv/vendor/requests/status_codes.py
+++ b/pipenv/vendor/requests/status_codes.py
@@ -1,6 +1,6 @@
 # -*- 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.
diff --git a/pipenv/vendor/requests/utils.py b/pipenv/vendor/requests/utils.py
index 431f6be0..0ce7fe11 100644
--- a/pipenv/vendor/requests/utils.py
+++ b/pipenv/vendor/requests/utils.py
@@ -173,10 +173,10 @@ def get_netrc_auth(url, raise_errors=False):
 
         for f in NETRC_FILES:
             try:
-                loc = os.path.expanduser('~/{0}'.format(f))
+                loc = os.path.expanduser('~/{}'.format(f))
             except KeyError:
                 # os.path.expanduser can fail when $HOME is undefined and
-                # getpwuid fails. See http://bugs.python.org/issue20164 &
+                # getpwuid fails. See https://bugs.python.org/issue20164 &
                 # https://github.com/requests/requests/issues/1846
                 return
 
@@ -466,7 +466,7 @@ def _parse_content_type_header(header):
             if index_of_equals != -1:
                 key = param[:index_of_equals].strip(items_to_strip)
                 value = param[index_of_equals + 1:].strip(items_to_strip)
-            params_dict[key] = value
+            params_dict[key.lower()] = value
     return content_type, params_dict
 
 
@@ -706,6 +706,10 @@ def should_bypass_proxies(url, no_proxy):
         no_proxy = get_proxy('no_proxy')
     parsed = urlparse(url)
 
+    if parsed.hostname is None:
+        # URLs don't always have hostnames, e.g. file:/// urls.
+        return True
+
     if no_proxy:
         # We need to check whether we match here. We need to see if we match
         # the end of the hostname, both with and without the port.
@@ -725,7 +729,7 @@ def should_bypass_proxies(url, no_proxy):
         else:
             host_with_port = parsed.hostname
             if parsed.port:
-                host_with_port += ':{0}'.format(parsed.port)
+                host_with_port += ':{}'.format(parsed.port)
 
             for host in no_proxy:
                 if parsed.hostname.endswith(host) or host_with_port.endswith(host):
@@ -733,13 +737,8 @@ def should_bypass_proxies(url, no_proxy):
                     # to apply the proxies on this URL.
                     return True
 
-    # If the system proxy settings indicate that this URL should be bypassed,
-    # don't proxy.
-    # The proxy_bypass function is incredibly buggy on OS X in early versions
-    # of Python 2.6, so allow this call to fail. Only catch the specific
-    # exceptions we've seen, though: this call failing in other ways can reveal
-    # legitimate problems.
     with set_environ('no_proxy', no_proxy_arg):
+        # parsed.hostname can be `None` in cases such as a file URI.
         try:
             bypass = proxy_bypass(parsed.hostname)
         except (TypeError, socket.gaierror):
diff --git a/pipenv/vendor/requirementslib/__init__.py b/pipenv/vendor/requirementslib/__init__.py
index 0faea40b..bcbff09e 100644
--- a/pipenv/vendor/requirementslib/__init__.py
+++ b/pipenv/vendor/requirementslib/__init__.py
@@ -1,6 +1,13 @@
 # -*- coding=utf-8 -*-
-__version__ = '1.1.7.dev0'
+__version__ = '1.2.3'
 
+import logging
 
-from .exceptions import RequirementError
-from .models import Requirement, Lockfile, Pipfile
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+from .models.requirements import Requirement
+from .models.lockfile import Lockfile
+from .models.pipfile import Pipfile
+
+__all__ = ["Lockfile", "Pipfile", "Requirement"]
diff --git a/pipenv/vendor/requirementslib/exceptions.py b/pipenv/vendor/requirementslib/exceptions.py
index 82578624..de8bf8ef 100644
--- a/pipenv/vendor/requirementslib/exceptions.py
+++ b/pipenv/vendor/requirementslib/exceptions.py
@@ -9,6 +9,8 @@ if six.PY2:
         def __init__(self, *args, **kwargs):
             self.errno = errno.EEXIST
             super(FileExistsError, self).__init__(*args, **kwargs)
+else:
+    from six.moves.builtins import FileExistsError
 
 
 class RequirementError(Exception):
diff --git a/pipenv/vendor/requirementslib/models/__init__.py b/pipenv/vendor/requirementslib/models/__init__.py
index 8d12da45..99e519d6 100644
--- a/pipenv/vendor/requirementslib/models/__init__.py
+++ b/pipenv/vendor/requirementslib/models/__init__.py
@@ -2,10 +2,9 @@
 from __future__ import absolute_import
 
 
-__all__ = ["Requirement", "Lockfile", "Pipfile", "DependencyResolver"]
+__all__ = ["Requirement", "Lockfile", "Pipfile"]
 
 
 from .requirements import Requirement
 from .lockfile import Lockfile
 from .pipfile import Pipfile
-from .resolvers import DependencyResolver
diff --git a/pipenv/vendor/requirementslib/models/cache.py b/pipenv/vendor/requirementslib/models/cache.py
index 16fc4ba8..71701090 100644
--- a/pipenv/vendor/requirementslib/models/cache.py
+++ b/pipenv/vendor/requirementslib/models/cache.py
@@ -5,21 +5,19 @@ import copy
 import hashlib
 import json
 import os
-import six
 import sys
 
 import requests
-import pip_shims
 import vistir
 
 from appdirs import user_cache_dir
+from pip_shims.shims import FAVORITE_HASH, SafeFileCache
 from packaging.requirements import Requirement
 
 from .utils import as_tuple, key_from_req, lookup_table, get_pinned_version
 
-
-if six.PY2:
-    from ..exceptions import FileExistsError
+from ..exceptions import FileExistsError
+from ..utils import VCS_SUPPORT
 
 
 CACHE_DIR = os.environ.get("PIPENV_CACHE_DIR", user_cache_dir("pipenv"))
@@ -189,7 +187,7 @@ class DependencyCache(object):
                             for dep_name in self.cache[name][version_and_extras])
 
 
-class HashCache(pip_shims.SafeFileCache):
+class HashCache(SafeFileCache):
     """Caches hashes of PyPI artifacts so we do not need to re-download them.
 
     Hashes are only cached when the URL appears to contain a hash in it and the
@@ -206,7 +204,7 @@ class HashCache(pip_shims.SafeFileCache):
     def get_hash(self, location):
         # if there is no location hash (i.e., md5 / sha256 / etc) we on't want to store it
         hash_value = None
-        vcs = pip_shims.VcsSupport()
+        vcs = VCS_SUPPORT
         orig_scheme = location.scheme
         new_location = copy.deepcopy(location)
         if orig_scheme in vcs.all_schemes:
@@ -223,11 +221,11 @@ class HashCache(pip_shims.SafeFileCache):
         return hash_value.decode('utf8')
 
     def _get_file_hash(self, location):
-        h = hashlib.new(pip_shims.FAVORITE_HASH)
+        h = hashlib.new(FAVORITE_HASH)
         with vistir.contextmanagers.open_file(location, self.session) as fp:
             for chunk in iter(lambda: fp.read(8096), b""):
                 h.update(chunk)
-        return ":".join([pip_shims.FAVORITE_HASH, h.hexdigest()])
+        return ":".join([FAVORITE_HASH, h.hexdigest()])
 
 
 class _JSONCache(object):
diff --git a/pipenv/vendor/requirementslib/models/dependencies.py b/pipenv/vendor/requirementslib/models/dependencies.py
index 90678344..c3df222f 100644
--- a/pipenv/vendor/requirementslib/models/dependencies.py
+++ b/pipenv/vendor/requirementslib/models/dependencies.py
@@ -9,6 +9,7 @@ import attr
 import packaging.markers
 import packaging.version
 import requests
+import warnings
 
 from first import first
 from packaging.utils import canonicalize_name
@@ -17,9 +18,10 @@ from pip_shims import (
     FormatControl, InstallRequirement, PackageFinder, RequirementPreparer,
     RequirementSet, RequirementTracker, Resolver, WheelCache, pip_version
 )
-from vistir.compat import JSONDecodeError, TemporaryDirectory, fs_str
+from vistir.compat import JSONDecodeError, fs_str, ResourceWarning
 from vistir.contextmanagers import cd, temp_environ
 from vistir.misc import partialclass
+from vistir.path import create_tracked_tempdir
 
 from ..utils import get_pip_command, prepare_pip_source_args, _ensure_dir
 from .cache import CACHE_DIR, DependencyCache
@@ -52,6 +54,8 @@ def find_all_matches(finder, ireq, pre=False):
     :return: A list of matching candidates.
     :rtype: list[:class:`~pip._internal.index.InstallationCandidate`]
     """
+
+
     candidates = clean_requires_python(finder.find_all_candidates(ireq.name))
     versions = {candidate.version for candidate in candidates}
     allowed_versions = _get_filtered_versions(ireq, versions, pre)
@@ -274,8 +278,11 @@ def get_dependencies(ireq, sources=None, parent=None):
             ireq, "project_name",
             getattr(ireq, "project", ireq.name),
         )
-        version = getattr(ireq, "version")
-        ireq = InstallRequirement.from_line("{0}=={1}".format(name, version))
+        version = getattr(ireq, "version", None)
+        if not version:
+            ireq = InstallRequirement.from_line("{0}".format(name))
+        else:
+            ireq = InstallRequirement.from_line("{0}=={1}".format(name, version))
     pip_options = get_pip_options(sources=sources)
     getters = [
         get_dependencies_from_cache,
@@ -337,9 +344,12 @@ def get_dependencies_from_json(ireq):
 
     def gen(ireq):
         info = None
-        info = session.get(
-            "https://pypi.org/pypi/{0}/{1}/json".format(ireq.req.name, version)
-        ).json()["info"]
+        try:
+            info = session.get(
+                "https://pypi.org/pypi/{0}/{1}/json".format(ireq.req.name, version)
+            ).json()["info"]
+        finally:
+            session.close()
         requires_dist = info.get("requires_dist", info.get("requires"))
         if not requires_dist:   # The API can return None for this.
             return
@@ -577,12 +587,12 @@ def start_resolver(finder=None, wheel_cache=None):
     download_dir = PKGS_DOWNLOAD_DIR
     _ensure_dir(download_dir)
 
-    _build_dir = TemporaryDirectory(fs_str("build"))
-    _source_dir = TemporaryDirectory(fs_str("source"))
+    _build_dir = create_tracked_tempdir(fs_str("build"))
+    _source_dir = create_tracked_tempdir(fs_str("source"))
     preparer = partialclass(
         RequirementPreparer,
-        build_dir=_build_dir.name,
-        src_dir=_source_dir.name,
+        build_dir=_build_dir,
+        src_dir=_source_dir,
         download_dir=download_dir,
         wheel_download_dir=WHEEL_DOWNLOAD_DIR,
         progress_bar="off",
@@ -601,13 +611,16 @@ def start_resolver(finder=None, wheel_cache=None):
         wheel_cache=wheel_cache,
         use_user_site=False,
     )
-    if packaging.version.parse(pip_version) >= packaging.version.parse('18'):
-        with RequirementTracker() as req_tracker:
-            preparer = preparer(req_tracker=req_tracker)
+    try:
+        if packaging.version.parse(pip_version) >= packaging.version.parse('18'):
+            with RequirementTracker() as req_tracker:
+                preparer = preparer(req_tracker=req_tracker)
+                yield resolver(preparer=preparer)
+        else:
+            preparer = preparer()
             yield resolver(preparer=preparer)
-    else:
-        preparer = preparer()
-        yield resolver(preparer=preparer)
+    finally:
+        finder.session.close()
 
 
 def get_grouped_dependencies(constraints):
diff --git a/pipenv/vendor/requirementslib/models/lockfile.py b/pipenv/vendor/requirementslib/models/lockfile.py
index f9ca97b8..3e482813 100644
--- a/pipenv/vendor/requirementslib/models/lockfile.py
+++ b/pipenv/vendor/requirementslib/models/lockfile.py
@@ -1,17 +1,21 @@
 # -*- coding: utf-8 -*-
 from __future__ import absolute_import
 
-import json
+import copy
 import os
 
+import attr
+import itertools
 import plette.lockfiles
 import six
 
-from vistir.compat import Path
-from vistir.contextmanagers import atomic_open_for_write
+from vistir.compat import Path, FileNotFoundError
 
+from .project import ProjectFile
 from .requirements import Requirement
 
+from .utils import optional_instance_of
+from ..utils import is_vcs, is_editable, merge_items
 
 DEFAULT_NEWLINES = u"\n"
 
@@ -22,83 +26,218 @@ def preferred_newlines(f):
     return DEFAULT_NEWLINES
 
 
-class Lockfile(plette.lockfiles.Lockfile):
-    def __init__(self, *args, **kwargs):
-        path = kwargs.pop("path", None)
-        self._requirements = kwargs.pop("requirements", [])
-        self._dev_requirements = kwargs.pop("dev_requirements", [])
-        self.path = Path(path) if path else None
-        self.newlines = u"\n"
-        super(Lockfile, self).__init__(*args, **kwargs)
+is_lockfile = optional_instance_of(plette.lockfiles.Lockfile)
+is_projectfile = optional_instance_of(ProjectFile)
+
+
+@attr.s(slots=True)
+class Lockfile(object):
+    path = attr.ib(validator=optional_instance_of(Path), type=Path)
+    _requirements = attr.ib(default=attr.Factory(list), type=list)
+    _dev_requirements = attr.ib(default=attr.Factory(list), type=list)
+    projectfile = attr.ib(validator=is_projectfile, type=ProjectFile)
+    _lockfile = attr.ib(validator=is_lockfile, type=plette.lockfiles.Lockfile)
+    newlines = attr.ib(default=DEFAULT_NEWLINES, type=six.text_type)
+
+    @path.default
+    def _get_path(self):
+        return Path(os.curdir).absolute()
+
+    @projectfile.default
+    def _get_projectfile(self):
+        return self.load_projectfile(self.path)
+
+    @_lockfile.default
+    def _get_lockfile(self):
+        return self.projectfile.lockfile
+
+    @property
+    def lockfile(self):
+        return self._lockfile
+
+    @property
+    def section_keys(self):
+        return ["default", "develop"]
+
+    @property
+    def extended_keys(self):
+        return [k for k in itertools.product(self.section_keys, ["", "vcs", "editable"])]
+
+    def get(self, k):
+        return self.__getitem__(k)
+
+    def __contains__(self, k):
+        check_lockfile = k in self.extended_keys or self.lockfile.__contains__(k)
+        if check_lockfile:
+            return True
+        return super(Lockfile, self).__contains__(k)
+
+    def __setitem__(self, k, v):
+        lockfile = self._lockfile
+        lockfile.__setitem__(k, v)
+
+    def __getitem__(self, k, *args, **kwargs):
+        retval = None
+        lockfile = self._lockfile
+        section = None
+        pkg_type = None
+        try:
+            retval = lockfile[k]
+        except KeyError:
+            if "-" in k:
+                section, _, pkg_type = k.rpartition("-")
+                vals = getattr(lockfile.get(section, {}), "_data", {})
+                if pkg_type == "vcs":
+                    retval = {k: v for k, v in vals.items() if is_vcs(v)}
+                elif pkg_type == "editable":
+                    retval = {k: v for k, v in vals.items() if is_editable(v)}
+            if retval is None:
+                raise
+        else:
+            retval = getattr(retval, "_data", retval)
+        return retval
+
+    def __getattr__(self, k, *args, **kwargs):
+        retval = None
+        lockfile = super(Lockfile, self).__getattribute__("_lockfile")
+        try:
+            return super(Lockfile, self).__getattribute__(k)
+        except AttributeError:
+            retval = getattr(lockfile, k, None)
+        if retval is not None:
+            return retval
+        return super(Lockfile, self).__getattribute__(k, *args, **kwargs)
+
+    def get_deps(self, dev=False, only=True):
+        deps = {}
+        if dev:
+            deps.update(self.develop._data)
+            if only:
+                return deps
+        deps = merge_items([deps, self.default._data])
+        return deps
 
     @classmethod
-    def load(cls, path):
+    def read_projectfile(cls, path):
+        """Read the specified project file and provide an interface for writing/updating.
+
+        :param str path: Path to the target file.
+        :return: A project file with the model and location for interaction
+        :rtype: :class:`~requirementslib.models.project.ProjectFile`
+        """
+
+        pf = ProjectFile.read(
+            path,
+            plette.lockfiles.Lockfile,
+            invalid_ok=True
+        )
+        return pf
+
+    @classmethod
+    def load_projectfile(cls, path, create=True):
+        """Given a path, load or create the necessary lockfile.
+
+        :param str path: Path to the project root or lockfile
+        :param bool create: Whether to create the lockfile if not found, defaults to True
+        :raises OSError: Thrown if the project root directory doesn't exist
+        :raises FileNotFoundError: Thrown if the lockfile doesn't exist and ``create=False``
+        :return: A project file instance for the supplied project
+        :rtype: :class:`~requirementslib.models.project.ProjectFile`
+        """
+
         if not path:
             path = os.curdir
         path = Path(path).absolute()
-        if path.is_dir():
-            path = path / "Pipfile.lock"
-        elif path.name == "Pipfile":
-            path = path.parent / "Pipfile.lock"
-        if not path.exists():
-            raise OSError("Path does not exist: %s" % path)
-        return cls.create(path.parent, lockfile_name=path.name)
+        project_path = path if path.is_dir() else path.parent
+        lockfile_path = project_path / "Pipfile.lock"
+        if not project_path.exists():
+            raise OSError("Project does not exist: %s" % project_path.as_posix())
+        elif not lockfile_path.exists() and not create:
+            raise FileNotFoundError("Lockfile does not exist: %s" % lockfile_path.as_posix())
+        projectfile = cls.read_projectfile(lockfile_path.as_posix())
+        return projectfile
 
     @classmethod
-    def create(cls, project_path, lockfile_name="Pipfile.lock"):
-        """Create a new lockfile instance
+    def load(cls, path, create=True):
+        """Create a new lockfile instance.
 
         :param project_path: Path to  project root
-        :type project_path: str or :class:`~pathlib.Path`
-        :returns: List[:class:`~requirementslib.Requirement`] objects
+        :type project_path: str or :class:`pathlib.Path`
+        :param str lockfile_name: Name of the lockfile in the project root directory
+        :param pipfile_path: Path to the project pipfile
+        :type pipfile_path: :class:`pathlib.Path`
+        :returns: A new lockfile representing the supplied project paths
+        :rtype: :class:`~requirementslib.models.lockfile.Lockfile`
         """
 
-        if not isinstance(project_path, Path):
-            project_path = Path(project_path)
-        lockfile_path = project_path / lockfile_name
-        with lockfile_path.open(encoding="utf-8") as f:
-            lockfile = super(Lockfile, cls).load(f)
-            lockfile.newlines = preferred_newlines(f)
-        lockfile.path = lockfile_path
-        return lockfile
+        projectfile = cls.load_projectfile(path, create=create)
+        lockfile_path = Path(projectfile.location)
+        creation_args = {
+            "projectfile": projectfile,
+            "lockfile": projectfile.model,
+            "newlines": projectfile.line_ending,
+            "path": lockfile_path
+        }
+        return cls(**creation_args)
 
-    def get_requirements(self, dev=False):
-        section = self.develop if dev else self.default
-        for k in section.keys():
-            yield Requirement.from_pipfile(k, section[k]._data)
+    @classmethod
+    def create(cls, path, create=True):
+        return cls.load(path, create=create)
+
+    @property
+    def develop(self):
+        return self._lockfile.develop
+
+    @property
+    def default(self):
+        return self._lockfile.default
+
+    def get_requirements(self, dev=True, only=False):
+        """Produces a generator which generates requirements from the desired section.
+
+        :param bool dev: Indicates whether to use dev requirements, defaults to False
+        :return: Requirements from the relevant the relevant pipfile
+        :rtype: :class:`~requirementslib.models.requirements.Requirement`
+        """
+
+        deps = self.get_deps(dev=dev, only=only)
+        for k, v in deps.items():
+            yield Requirement.from_pipfile(k, v)
 
     @property
     def dev_requirements(self):
         if not self._dev_requirements:
-            self._dev_requirements = list(self.get_requirements(dev=True))
+            self._dev_requirements = list(self.get_requirements(dev=True, only=True))
         return self._dev_requirements
 
     @property
     def requirements(self):
         if not self._requirements:
-            self._requirements = list(self.get_requirements(dev=False))
+            self._requirements = list(self.get_requirements(dev=False, only=True))
         return self._requirements
 
     @property
     def dev_requirements_list(self):
-        return [{name: entry._data} for name, entry in self.develop.items()]
+        return [{name: entry._data} for name, entry in self._lockfile.develop.items()]
 
     @property
     def requirements_list(self):
-        return [{name: entry._data} for name, entry in self.develop.items()]
+        return [{name: entry._data} for name, entry in self._lockfile.default.items()]
 
     def write(self):
-        open_kwargs = {"newline": self.newlines}
-        with atomic_open_for_write(self.path.as_posix(), **open_kwargs) as f:
-            super(Lockfile, self).dump(f, encoding="utf-8")
+        self.projectfile.model = copy.deepcopy(self._lockfile)
+        self.projectfile.write()
 
     def as_requirements(self, include_hashes=False, dev=False):
         """Returns a list of requirements in pip-style format"""
         lines = []
         section = self.dev_requirements if dev else self.requirements
         for req in section:
-            r = req.as_line()
-            if not include_hashes:
-                r = r.split("--hash", 1)[0]
+            kwargs = {
+                "include_hashes": include_hashes,
+            }
+            if req.editable:
+                kwargs["include_markers"] = False
+            r = req.as_line(**kwargs)
             lines.append(r.strip())
         return lines
diff --git a/pipenv/vendor/requirementslib/models/pipfile.py b/pipenv/vendor/requirementslib/models/pipfile.py
index 3a6f5b1e..fe7743c2 100644
--- a/pipenv/vendor/requirementslib/models/pipfile.py
+++ b/pipenv/vendor/requirementslib/models/pipfile.py
@@ -1,64 +1,214 @@
 # -*- coding: utf-8 -*-
-from vistir.compat import Path
+
+from __future__ import absolute_import, unicode_literals, print_function
+
+import attr
+import copy
+import os
+
+import tomlkit
+
+from vistir.compat import Path, FileNotFoundError
 
 from .requirements import Requirement
+from .project import ProjectFile
+from .utils import optional_instance_of
 from ..exceptions import RequirementError
+from ..utils import is_vcs, is_editable, merge_items
 import plette.pipfiles
 
 
-class Pipfile(plette.pipfiles.Pipfile):
+is_pipfile = optional_instance_of(plette.pipfiles.Pipfile)
+is_path = optional_instance_of(Path)
+is_projectfile = optional_instance_of(ProjectFile)
+
+
+class PipfileLoader(plette.pipfiles.Pipfile):
+    @classmethod
+    def validate(cls, data):
+        for key, klass in plette.pipfiles.PIPFILE_SECTIONS.items():
+            if key not in data or key == "source":
+                continue
+            klass.validate(data[key])
+
+    @classmethod
+    def load(cls, f, encoding=None):
+        content = f.read()
+        if encoding is not None:
+            content = content.decode(encoding)
+        _data = tomlkit.loads(content)
+        if "source" not in _data:
+            # HACK: There is no good way to prepend a section to an existing
+            # TOML document, but there's no good way to copy non-structural
+            # content from one TOML document to another either. Modify the
+            # TOML content directly, and load the new in-memory document.
+            sep = "" if content.startswith("\n") else "\n"
+            content = plette.pipfiles.DEFAULT_SOURCE_TOML + sep + content
+        data = tomlkit.loads(content)
+        return cls(data)
+
+
+@attr.s(slots=True)
+class Pipfile(object):
+    path = attr.ib(validator=is_path, type=Path)
+    projectfile = attr.ib(validator=is_projectfile, type=ProjectFile)
+    _pipfile = attr.ib(type=plette.pipfiles.Pipfile)
+    requirements = attr.ib(default=attr.Factory(list), type=list)
+    dev_requirements = attr.ib(default=attr.Factory(list), type=list)
+
+    @path.default
+    def _get_path(self):
+        return Path(os.curdir).absolute()
+
+    @projectfile.default
+    def _get_projectfile(self):
+        return self.load_projectfile(os.curdir, create=False)
+
+    @_pipfile.default
+    def _get_pipfile(self):
+        return self.projectfile.model
+
+    @property
+    def pipfile(self):
+        return self._pipfile
+
+    def get_deps(self, dev=False, only=True):
+        deps = {}
+        if dev:
+            deps.update(self.pipfile._data["dev-packages"])
+            if only:
+                return deps
+        return merge_items([deps, self.pipfile._data["packages"]])
+
+    def get(self, k):
+        return self.__getitem__(k)
+
+    def __contains__(self, k):
+        check_pipfile = k in self.extended_keys or self.pipfile.__contains__(k)
+        if check_pipfile:
+            return True
+        return super(Pipfile, self).__contains__(k)
+
+    def __getitem__(self, k, *args, **kwargs):
+        retval = None
+        pipfile = self._pipfile
+        section = None
+        pkg_type = None
+        try:
+            retval = pipfile[k]
+        except KeyError:
+            if "-" in k:
+                section, _, pkg_type = k.rpartition("-")
+                vals = getattr(pipfile.get(section, {}), "_data", {})
+                if pkg_type == "vcs":
+                    retval = {k: v for k, v in vals.items() if is_vcs(v)}
+                elif pkg_type == "editable":
+                    retval = {k: v for k, v in vals.items() if is_editable(v)}
+            if retval is None:
+                raise
+        else:
+            retval = getattr(retval, "_data", retval)
+        return retval
+
+    def __getattr__(self, k, *args, **kwargs):
+        retval = None
+        pipfile = super(Pipfile, self).__getattribute__("_pipfile")
+        try:
+            retval = super(Pipfile, self).__getattribute__(k)
+        except AttributeError:
+            retval = getattr(pipfile, k, None)
+        if retval is not None:
+            return retval
+        return super(Pipfile, self).__getattribute__(k, *args, **kwargs)
 
     @property
     def requires_python(self):
-        return self.requires.requires_python
+        return self._pipfile.requires.requires_python
 
     @property
     def allow_prereleases(self):
-        return self.get("pipenv", {}).get("allow_prereleases", False)
+        return self._pipfile.get("pipenv", {}).get("allow_prereleases", False)
 
     @classmethod
-    def load(cls, path):
+    def read_projectfile(cls, path):
+        """Read the specified project file and provide an interface for writing/updating.
+
+        :param str path: Path to the target file.
+        :return: A project file with the model and location for interaction
+        :rtype: :class:`~requirementslib.models.project.ProjectFile`
+        """
+        pf = ProjectFile.read(
+            path,
+            PipfileLoader,
+            invalid_ok=True
+        )
+        return pf
+
+    @classmethod
+    def load_projectfile(cls, path, create=False):
+        """Given a path, load or create the necessary pipfile.
+
+        :param str path: Path to the project root or pipfile
+        :param bool create: Whether to create the pipfile if not found, defaults to True
+        :raises OSError: Thrown if the project root directory doesn't exist
+        :raises FileNotFoundError: Thrown if the pipfile doesn't exist and ``create=False``
+        :return: A project file instance for the supplied project
+        :rtype: :class:`~requirementslib.models.project.ProjectFile`
+        """
+        if not path:
+            raise RuntimeError("Must pass a path to classmethod 'Pipfile.load'")
         if not isinstance(path, Path):
-            path = Path(path)
-        pipfile_path = path / "Pipfile"
-        if not path.exists():
+            path = Path(path).absolute()
+        pipfile_path = path if path.name == "Pipfile" else path.joinpath("Pipfile")
+        project_path = pipfile_path.parent
+        if not project_path.exists():
             raise FileNotFoundError("%s is not a valid project path!" % path)
         elif not pipfile_path.exists() or not pipfile_path.is_file():
-            raise RequirementError("%s is not a valid Pipfile" % pipfile_path)
-        with pipfile_path.open(encoding="utf-8") as fp:
-            pipfile = super(Pipfile, cls).load(fp)
-        pipfile.dev_requirements = [
-            Requirement.from_pipfile(k, v) for k, v in pipfile.get("dev-packages", {}).items()
-        ]
-        pipfile.requirements = [
-            Requirement.from_pipfile(k, v) for k, v in pipfile.get("packages", {}).items()
-        ]
-        pipfile.path = pipfile_path
-        return pipfile
+            if not create:
+                raise RequirementError("%s is not a valid Pipfile" % pipfile_path)
+        return cls.read_projectfile(pipfile_path.as_posix())
 
-    # def resolve(self):
-    # It would be nice to still use this api someday
-    #     option_sources = [s.expanded for s in self.sources]
-    #     pip_args = []
-    #     if self.pipenv.allow_prereleases:
-    #         pip_args.append('--pre')
-    #     pip_options = get_pip_options(pip_args, sources=option_sources)
-    #     finder = get_finder(sources=option_sources, pip_options=pip_options)
-    #     resolver = DependencyResolver.create(finder=finder, allow_prereleases=self.pipenv.allow_prereleases)
-    #     pkg_dict = {}
-    #     for pkg in self.dev_packages.requirements + self.packages.requirements:
-    #         pkg_dict[pkg.name] = pkg
-    #     resolver.resolve(list(pkg_dict.values()))
-    #     return resolver
+    @classmethod
+    def load(cls, path, create=False):
+        """Given a path, load or create the necessary pipfile.
+
+        :param str path: Path to the project root or pipfile
+        :param bool create: Whether to create the pipfile if not found, defaults to True
+        :raises OSError: Thrown if the project root directory doesn't exist
+        :raises FileNotFoundError: Thrown if the pipfile doesn't exist and ``create=False``
+        :return: A pipfile instance pointing at the supplied project
+        :rtype:: class:`~requirementslib.models.pipfile.Pipfile`
+        """
+
+        projectfile = cls.load_projectfile(path, create=create)
+        pipfile = projectfile.model
+        dev_requirements = [
+            Requirement.from_pipfile(k, getattr(v, "_data", v)) for k, v in pipfile.get("dev-packages", {}).items()
+        ]
+        requirements = [
+            Requirement.from_pipfile(k, getattr(v, "_data", v)) for k, v in pipfile.get("packages", {}).items()
+        ]
+        creation_args = {
+            "projectfile": projectfile,
+            "pipfile": pipfile,
+            "dev_requirements": dev_requirements,
+            "requirements": requirements,
+            "path": Path(projectfile.location)
+        }
+        return cls(**creation_args)
+
+    def write(self):
+        self.projectfile.model = copy.deepcopy(self._pipfile)
+        self.projectfile.write()
 
     @property
     def dev_packages(self, as_requirements=True):
         if as_requirements:
             return self.dev_requirements
-        return self.get('dev-packages', {})
+        return self._pipfile.get('dev-packages', {})
 
     @property
     def packages(self, as_requirements=True):
         if as_requirements:
             return self.requirements
-        return self.get('packages', {})
+        return self._pipfile.get('packages', {})
diff --git a/pipenv/vendor/requirementslib/models/project.py b/pipenv/vendor/requirementslib/models/project.py
new file mode 100644
index 00000000..f6e037d6
--- /dev/null
+++ b/pipenv/vendor/requirementslib/models/project.py
@@ -0,0 +1,241 @@
+# -*- coding=utf-8 -*-
+
+from __future__ import absolute_import, unicode_literals
+
+import collections
+import io
+import os
+
+import attr
+import packaging.markers
+import packaging.utils
+import plette
+import plette.models
+import six
+import tomlkit
+
+
+SectionDifference = collections.namedtuple("SectionDifference", [
+    "inthis", "inthat",
+])
+FileDifference = collections.namedtuple("FileDifference", [
+    "default", "develop",
+])
+
+
+def _are_pipfile_entries_equal(a, b):
+    a = {k: v for k, v in a.items() if k not in ("markers", "hashes", "hash")}
+    b = {k: v for k, v in b.items() if k not in ("markers", "hashes", "hash")}
+    if a != b:
+        return False
+    try:
+        marker_eval_a = packaging.markers.Marker(a["markers"]).evaluate()
+    except (AttributeError, KeyError, TypeError, ValueError):
+        marker_eval_a = True
+    try:
+        marker_eval_b = packaging.markers.Marker(b["markers"]).evaluate()
+    except (AttributeError, KeyError, TypeError, ValueError):
+        marker_eval_b = True
+    return marker_eval_a == marker_eval_b
+
+
+DEFAULT_NEWLINES = "\n"
+
+
+def preferred_newlines(f):
+    if isinstance(f.newlines, six.text_type):
+        return f.newlines
+    return DEFAULT_NEWLINES
+
+
+@attr.s
+class ProjectFile(object):
+    """A file in the Pipfile project.
+    """
+    location = attr.ib()
+    line_ending = attr.ib()
+    model = attr.ib()
+
+    @classmethod
+    def read(cls, location, model_cls, invalid_ok=False):
+        try:
+            with io.open(location, encoding="utf-8") as f:
+                model = model_cls.load(f)
+                line_ending = preferred_newlines(f)
+        except Exception:
+            if not invalid_ok:
+                raise
+            model = None
+            line_ending = DEFAULT_NEWLINES
+        return cls(location=location, line_ending=line_ending, model=model)
+
+    def write(self):
+        kwargs = {"encoding": "utf-8", "newline": self.line_ending}
+        with io.open(self.location, "w", **kwargs) as f:
+            self.model.dump(f)
+
+    def dumps(self):
+        strio = six.StringIO()
+        self.model.dump(strio)
+        return strio.getvalue()
+
+
+@attr.s
+class Project(object):
+
+    root = attr.ib()
+    _p = attr.ib(init=False)
+    _l = attr.ib(init=False)
+
+    def __attrs_post_init__(self):
+        self.root = root = os.path.abspath(self.root)
+        self._p = ProjectFile.read(
+            os.path.join(root, "Pipfile"),
+            plette.Pipfile,
+        )
+        self._l = ProjectFile.read(
+            os.path.join(root, "Pipfile.lock"),
+            plette.Lockfile,
+            invalid_ok=True,
+        )
+
+    @property
+    def pipfile(self):
+        return self._p.model
+
+    @property
+    def pipfile_location(self):
+        return self._p.location
+
+    @property
+    def lockfile(self):
+        return self._l.model
+
+    @property
+    def lockfile_location(self):
+        return self._l.location
+
+    @lockfile.setter
+    def lockfile(self, new):
+        self._l.model = new
+
+    def is_synced(self):
+        return self.lockfile and self.lockfile.is_up_to_date(self.pipfile)
+
+    def _get_pipfile_section(self, develop, insert=True):
+        name = "dev-packages" if develop else "packages"
+        try:
+            section = self.pipfile[name]
+        except KeyError:
+            section = plette.models.PackageCollection(tomlkit.table())
+            if insert:
+                self.pipfile[name] = section
+        return section
+
+    def contains_key_in_pipfile(self, key):
+        sections = [
+            self._get_pipfile_section(develop=False, insert=False),
+            self._get_pipfile_section(develop=True, insert=False),
+        ]
+        return any(
+            (packaging.utils.canonicalize_name(name) ==
+             packaging.utils.canonicalize_name(key))
+            for section in sections
+            for name in section
+        )
+
+    def add_line_to_pipfile(self, line, develop):
+        from requirementslib import Requirement
+        requirement = Requirement.from_line(line)
+        section = self._get_pipfile_section(develop=develop)
+        key = requirement.normalized_name
+        entry = next(iter(requirement.as_pipfile().values()))
+        if isinstance(entry, dict):
+            # HACK: TOMLKit prefers to expand tables by default, but we
+            # always want inline tables here. Also tomlkit.inline_table
+            # does not have `update()`.
+            table = tomlkit.inline_table()
+            for k, v in entry.items():
+                table[k] = v
+            entry = table
+        section[key] = entry
+
+    def remove_keys_from_pipfile(self, keys, default, develop):
+        keys = {packaging.utils.canonicalize_name(key) for key in keys}
+        sections = []
+        if default:
+            sections.append(self._get_pipfile_section(
+                develop=False, insert=False,
+            ))
+        if develop:
+            sections.append(self._get_pipfile_section(
+                develop=True, insert=False,
+            ))
+        for section in sections:
+            removals = set()
+            for name in section:
+                if packaging.utils.canonicalize_name(name) in keys:
+                    removals.add(name)
+            for key in removals:
+                del section._data[key]
+
+    def remove_keys_from_lockfile(self, keys):
+        keys = {packaging.utils.canonicalize_name(key) for key in keys}
+        removed = False
+        for section_name in ("default", "develop"):
+            try:
+                section = self.lockfile[section_name]
+            except KeyError:
+                continue
+            removals = set()
+            for name in section:
+                if packaging.utils.canonicalize_name(name) in keys:
+                    removals.add(name)
+            removed = removed or bool(removals)
+            for key in removals:
+                del section._data[key]
+
+        if removed:
+            # HACK: The lock file no longer represents the Pipfile at this
+            # point. Set the hash to an arbitrary invalid value.
+            self.lockfile.meta.hash = plette.models.Hash({"__invalid__": ""})
+
+    def difference_lockfile(self, lockfile):
+        """Generate a difference between the current and given lockfiles.
+
+        Returns a 2-tuple containing differences in default in develop
+        sections.
+
+        Each element is a 2-tuple of dicts. The first, `inthis`, contains
+        entries only present in the current lockfile; the second, `inthat`,
+        contains entries only present in the given one.
+
+        If a key exists in both this and that, but the values differ, the key
+        is present in both dicts, pointing to values from each file.
+        """
+        diff_data = {
+            "default": SectionDifference({}, {}),
+            "develop": SectionDifference({}, {}),
+        }
+        for section_name, section_diff in diff_data.items():
+            try:
+                this = self.lockfile[section_name]._data
+            except (KeyError, TypeError):
+                this = {}
+            try:
+                that = lockfile[section_name]._data
+            except (KeyError, TypeError):
+                that = {}
+            for key, this_value in this.items():
+                try:
+                    that_value = that[key]
+                except KeyError:
+                    section_diff.inthis[key] = this_value
+                    continue
+                if not _are_pipfile_entries_equal(this_value, that_value):
+                    section_diff.inthis[key] = this_value
+                    section_diff.inthat[key] = that_value
+            for key, that_value in that.items():
+                if key not in this:
+                    section_diff.inthat[key] = that_value
+        return FileDifference(**diff_data)
diff --git a/pipenv/vendor/requirementslib/models/requirements.py b/pipenv/vendor/requirementslib/models/requirements.py
index 13a3a60e..112791ab 100644
--- a/pipenv/vendor/requirementslib/models/requirements.py
+++ b/pipenv/vendor/requirementslib/models/requirements.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
+
 from __future__ import absolute_import
 
-import atexit
 import collections
 import hashlib
 import os
@@ -9,49 +9,43 @@ import os
 from contextlib import contextmanager
 
 import attr
+import six
 
 from first import first
 from packaging.markers import Marker
 from packaging.requirements import Requirement as PackagingRequirement
 from packaging.specifiers import Specifier, SpecifierSet
 from packaging.utils import canonicalize_name
-from pip_shims.shims import (
-    InstallRequirement, Link, Wheel, _strip_extras, parse_version, path_to_url,
-    url_to_path
-)
+from pip_shims.shims import _strip_extras, parse_version, path_to_url, url_to_path, Link
 from six.moves.urllib import parse as urllib_parse
 from six.moves.urllib.parse import unquote
-from vistir.compat import FileNotFoundError, Path, TemporaryDirectory
+from vistir.compat import FileNotFoundError, Path
 from vistir.misc import dedup
 from vistir.path import (
     create_tracked_tempdir, get_converted_relative_path, is_file_url,
-    is_valid_url, mkdir_p
+    is_valid_url
 )
 
 from ..exceptions import RequirementError
-from ..utils import VCS_LIST, is_installable_file, is_vcs
+from ..utils import VCS_LIST, is_installable_file, is_vcs, ensure_setup_py
 from .baserequirement import BaseRequirement
-from .dependencies import (
-    AbstractDependency, find_all_matches, get_abstract_dependencies,
-    get_dependencies, get_finder
-)
 from .markers import PipenvMarkers
 from .utils import (
     HASH_STRING, add_ssh_scheme_to_git_uri, build_vcs_link, extras_to_string,
     filter_none, format_requirement, get_version, init_requirement,
-    is_pinned_requirement, make_install_requirement, optional_instance_of,
-    parse_extras, specs_to_string, split_markers_from_line,
+    is_pinned_requirement, make_install_requirement, optional_instance_of, parse_extras,
+    specs_to_string, split_markers_from_line, ireq_from_editable, ireq_from_line,
     split_vcs_method_from_uri, strip_ssh_from_git_uri, validate_path,
-    validate_specifiers, validate_vcs
+    validate_specifiers, validate_vcs, normalize_name, create_link,
+    Requirement as PkgResourcesRequirement
 )
-from .vcs import VCSRepository
 
 
-@attr.s
+@attr.s(slots=True)
 class NamedRequirement(BaseRequirement):
     name = attr.ib()
     version = attr.ib(validator=attr.validators.optional(validate_specifiers))
-    req = attr.ib()
+    req = attr.ib(type=PkgResourcesRequirement)
     extras = attr.ib(default=attr.Factory(list))
     editable = attr.ib(default=False)
 
@@ -96,7 +90,10 @@ class NamedRequirement(BaseRequirement):
 
     @property
     def line_part(self):
-        return "{0}".format(canonicalize_name(self.name))
+        # FIXME: This should actually be canonicalized but for now we have to
+        # simply lowercase it and replace underscores, since full canonicalization
+        # also replaces dots and that doesn't actually work when querying the index
+        return "{0}".format(normalize_name(self.name))
 
     @property
     def pipfile_part(self):
@@ -112,21 +109,28 @@ LinkInfo = collections.namedtuple(
 )
 
 
-@attr.s
+@attr.s(slots=True)
 class FileRequirement(BaseRequirement):
     """File requirements for tar.gz installable files or wheels or setup.py
     containing directories."""
 
+    #: Path to the relevant `setup.py` location
     setup_path = attr.ib(default=None)
+    #: path to hit - without any of the VCS prefixes (like git+ / http+ / etc)
     path = attr.ib(default=None, validator=attr.validators.optional(validate_path))
-    # : path to hit - without any of the VCS prefixes (like git+ / http+ / etc)
-    editable = attr.ib(default=None)
+    #: Whether the package is editable
+    editable = attr.ib(default=False)
+    #: Extras if applicable
     extras = attr.ib(default=attr.Factory(list))
+    #: URI of the package
     uri = attr.ib()
+    #: Link object representing the package to clone
     link = attr.ib()
+    _has_hashed_name = attr.ib(default=False)
+    #: Package name
     name = attr.ib()
+    #: A :class:`~pkg_resources.Requirement` isntance
     req = attr.ib()
-    _has_hashed_name = False
     _uri_scheme = attr.ib(default=None)
 
     @classmethod
@@ -161,6 +165,7 @@ class FileRequirement(BaseRequirement):
 
         See `https://bugs.python.org/issue23505#msg277350`.
         """
+
         # Git allows `git@github.com...` lines that are not really URIs.
         # Add "ssh://" so we can parse correctly, and restore afterwards.
         fixed_line = add_ssh_scheme_to_git_uri(line)
@@ -171,7 +176,7 @@ class FileRequirement(BaseRequirement):
             p = Path(fixed_line).absolute()
             path = p.as_posix()
             uri = p.as_uri()
-            link = Link(uri)
+            link = create_link(uri)
             try:
                 relpath = get_converted_relative_path(path)
             except ValueError:
@@ -220,7 +225,7 @@ class FileRequirement(BaseRequirement):
             uri = strip_ssh_from_git_uri(original_uri)
 
         # Re-attach VCS prefix to build a Link.
-        link = Link(
+        link = create_link(
             urllib_parse.urlunsplit(parsed_url._replace(scheme=original_scheme))
         )
 
@@ -241,6 +246,7 @@ class FileRequirement(BaseRequirement):
         if self.link and self.link.egg_fragment:
             return self.link.egg_fragment
         elif self.link and self.link.is_wheel:
+            from pip_shims import Wheel
             return Wheel(self.link.filename).name
         if (
             self._uri_scheme != "uri"
@@ -258,7 +264,7 @@ class FileRequirement(BaseRequirement):
             except (FileNotFoundError, IOError) as e:
                 dist = None
             except Exception as e:
-                from pip_shims.shims import InstallRequirement, make_abstract_dist
+                from pip_shims.shims import make_abstract_dist
 
                 try:
                     if not isinstance(Path, self.path):
@@ -266,9 +272,9 @@ class FileRequirement(BaseRequirement):
                     else:
                         _path = self.path
                     if self.editable:
-                        _ireq = InstallRequirement.from_editable(_path.as_uri())
+                        _ireq = ireq_from_editable(_path.as_uri())
                     else:
-                        _ireq = InstallRequirement.from_line(_path.as_posix())
+                        _ireq = ireq_from_line(_path.as_posix())
                     dist = make_abstract_dist(_ireq).get_dist()
                     name = dist.project_name
                 except (TypeError, ValueError, AttributeError) as e:
@@ -281,7 +287,7 @@ class FileRequirement(BaseRequirement):
             self._has_hashed_name = True
             name = hashed_name
         if self.link and not self._has_hashed_name:
-            self.link = Link("{0}#egg={1}".format(self.link.url, name))
+            self.link = create_link("{0}#egg={1}".format(self.link.url, name))
         return name
 
     @link.default
@@ -289,12 +295,12 @@ class FileRequirement(BaseRequirement):
         target = "{0}".format(self.uri)
         if hasattr(self, "name"):
             target = "{0}#egg={1}".format(target, self.name)
-        link = Link(target)
+        link = create_link(target)
         return link
 
     @req.default
     def get_requirement(self):
-        req = init_requirement(canonicalize_name(self.name))
+        req = init_requirement(normalize_name(self.name))
         req.editable = False
         req.line = self.link.url_without_fragment
         if self.path and self.link and self.link.scheme.startswith("file"):
@@ -354,6 +360,7 @@ class FileRequirement(BaseRequirement):
             "uri_scheme": prefer,
         }
         if link and link.is_wheel:
+            from pip_shims import Wheel
             arg_dict["name"] = Wheel(link.filename).name
         elif link.egg_fragment:
             arg_dict["name"] = link.egg_fragment
@@ -393,7 +400,7 @@ class FileRequirement(BaseRequirement):
 
         if not uri:
             uri = path_to_url(path)
-        link = Link(uri)
+        link = create_link(uri)
 
         arg_dict = {
             "name": name,
@@ -423,12 +430,12 @@ class FileRequirement(BaseRequirement):
 
     @property
     def pipfile_part(self):
-        pipfile_dict = attr.asdict(self, filter=filter_none).copy()
+        excludes = ["_base_line", "_has_hashed_name", "setup_path"]
+        filter_func = lambda k, v: bool(v) is True and k.name not in excludes
+        pipfile_dict = attr.asdict(self, filter=filter_func).copy()
         name = pipfile_dict.pop("name")
         if "_uri_scheme" in pipfile_dict:
             pipfile_dict.pop("_uri_scheme")
-        if "setup_path" in pipfile_dict:
-            pipfile_dict.pop("setup_path")
         # For local paths and remote installable artifacts (zipfiles, etc)
         collision_keys = {"file", "uri", "path"}
         if self._uri_scheme:
@@ -470,16 +477,22 @@ class FileRequirement(BaseRequirement):
         return {name: pipfile_dict}
 
 
-@attr.s
+@attr.s(slots=True)
 class VCSRequirement(FileRequirement):
+    #: Whether the repository is editable
     editable = attr.ib(default=None)
+    #: URI for the repository
     uri = attr.ib(default=None)
+    #: path to the repository, if it's local
     path = attr.ib(default=None, validator=attr.validators.optional(validate_path))
+    #: vcs type, i.e. git/hg/svn
     vcs = attr.ib(validator=attr.validators.optional(validate_vcs), default=None)
-    # : vcs reference name (branch / commit / tag)
+    #: vcs reference name (branch / commit / tag)
     ref = attr.ib(default=None)
+    #: Subdirectory to use for installation if applicable
     subdirectory = attr.ib(default=None)
     _repo = attr.ib(default=None)
+    _base_line = attr.ib(default=None)
     name = attr.ib()
     link = attr.ib()
     req = attr.ib()
@@ -582,17 +595,30 @@ class VCSRequirement(FileRequirement):
         return os.path.join(create_tracked_tempdir(prefix="requirementslib"), self.name)
 
     def get_vcs_repo(self, src_dir=None):
+        from .vcs import VCSRepository
         checkout_dir = self.get_checkout_dir(src_dir=src_dir)
-        url = "{0}#egg={1}".format(self.vcs_uri, self.name)
+        link = build_vcs_link(
+            self.vcs,
+            self.uri,
+            name=self.name,
+            ref=self.ref,
+            subdirectory=self.subdirectory,
+            extras=self.extras
+        )
         vcsrepo = VCSRepository(
-            url=url,
+            url=link.url,
             name=self.name,
             ref=self.ref if self.ref else None,
             checkout_directory=checkout_dir,
-            vcs_type=self.vcs
+            vcs_type=self.vcs,
+            subdirectory=self.subdirectory
         )
         if not self.is_local:
             vcsrepo.obtain()
+        if self.subdirectory:
+            self.setup_path = os.path.join(checkout_dir, self.subdirectory, "setup.py")
+        else:
+            self.setup_path = os.path.join(checkout_dir, "setup.py")
         return vcsrepo
 
     def get_commit_hash(self):
@@ -610,15 +636,23 @@ class VCSRequirement(FileRequirement):
         if not self.is_local and ref is not None:
             self.repo.checkout_ref(ref)
         repo_hash = self.repo.get_commit_hash()
+        self.req.revision = repo_hash
         return repo_hash
 
     @contextmanager
     def locked_vcs_repo(self, src_dir=None):
+        if not src_dir:
+            src_dir = create_tracked_tempdir(prefix="requirementslib-", suffix="-src")
         vcsrepo = self.get_vcs_repo(src_dir=src_dir)
-        if self.ref and not self.is_local:
-            vcsrepo.checkout_ref(self.ref)
-        self.ref = self.get_commit_hash()
-        self.req.revision = self.ref
+        self.req.revision = vcsrepo.get_commit_hash()
+
+        # Remove potential ref in the end of uri after ref is parsed
+        if "@" in self.link.show_url and "@" in self.uri:
+            uri, ref = self.uri.rsplit("@", 1)
+            checkout = self.req.revision
+            if checkout and ref in checkout:
+                self.uri = uri
+
         yield vcsrepo
         self._repo = vcsrepo
 
@@ -681,6 +715,7 @@ class VCSRequirement(FileRequirement):
             editable=editable,
             uri=uri,
             extras=extras,
+            base_line=line
         )
 
     @property
@@ -692,8 +727,10 @@ class VCSRequirement(FileRequirement):
                 base_link = self.get_link()
             final_format = "{{0}}#egg={0}".format(base_link.egg_fragment) if base_link.egg_fragment else "{0}"
             base = final_format.format(self.vcs_uri)
-        elif self.req:
-            base = self.req.line
+        elif self._base_line:
+            base = self._base_line
+        else:
+            base = self.link.url
         if base and self.extras and not extras_to_string(self.extras) in base:
             if self.subdirectory:
                 base = "{0}".format(self.get_link().url)
@@ -717,7 +754,9 @@ class VCSRequirement(FileRequirement):
 
     @property
     def pipfile_part(self):
-        pipfile_dict = attr.asdict(self, filter=lambda k, v: bool(v) is True and k.name != '_repo').copy()
+        excludes = ["_repo", "_base_line", "setup_path", "_has_hashed_name"]
+        filter_func = lambda k, v: bool(v) is True and k.name not in excludes
+        pipfile_dict = attr.asdict(self, filter=filter_func).copy()
         if "vcs" in pipfile_dict:
             pipfile_dict = self._choose_vcs_source(pipfile_dict)
         name, _ = _strip_extras(pipfile_dict.pop("name"))
@@ -760,7 +799,7 @@ class Requirement(object):
     @property
     def markers_as_pip(self):
         if self.markers:
-            return "; {0}".format(self.markers).replace('"', "'")
+            return " ; {0}".format(self.markers).replace('"', "'")
 
         return ""
 
@@ -807,6 +846,7 @@ class Requirement(object):
 
     @classmethod
     def from_line(cls, line):
+        from pip_shims import InstallRequirement
         if isinstance(line, InstallRequirement):
             line = format_requirement(line)
         hashes = None
@@ -932,7 +972,8 @@ class Requirement(object):
             cls_inst.req.req.line = cls_inst.as_line()
         return cls_inst
 
-    def as_line(self, sources=None, include_hashes=True, include_extras=True, as_list=False):
+    def as_line(self, sources=None, include_hashes=True, include_extras=True,
+                                                    include_markers=True, as_list=False):
         """Format this requirement as a line in requirements.txt.
 
         If ``sources`` provided, it should be an sequence of mappings, containing
@@ -951,7 +992,7 @@ class Requirement(object):
             self.req.line_part,
             self.extras_as_pip if include_extras else "",
             self.specifiers if include_specifiers else "",
-            self.markers_as_pip,
+            self.markers_as_pip if include_markers else "",
         ]
         if as_list:
             # This is used for passing to a subprocess call
@@ -1054,9 +1095,10 @@ class Requirement(object):
         if self.editable or self.req.editable:
             if ireq_line.startswith("-e "):
                 ireq_line = ireq_line[len("-e "):]
-            ireq = InstallRequirement.from_editable(ireq_line)
+            with ensure_setup_py(self.req.setup_path):
+                ireq = ireq_from_editable(ireq_line)
         else:
-            ireq = InstallRequirement.from_line(ireq_line)
+            ireq = ireq_from_line(ireq_line)
         if not getattr(ireq, "req", None):
             ireq.req = self.req.req
         else:
@@ -1083,6 +1125,8 @@ class Requirement(object):
         :return: A set of requirement strings of the dependencies of this requirement.
         :rtype: set(str)
         """
+
+        from .dependencies import get_dependencies
         if not sources:
             sources = [{
                 'name': 'pypi',
@@ -1102,6 +1146,7 @@ class Requirement(object):
         :rtype: list[ :class:`~requirementslib.models.dependency.AbstractDependency` ]
         """
 
+        from .dependencies import AbstractDependency, get_dependencies, get_abstract_dependencies
         if not self.abstract_dep:
             parent = getattr(self, 'parent', None)
             self.abstract_dep = AbstractDependency.from_requirement(self, parent=parent)
@@ -1124,6 +1169,8 @@ class Requirement(object):
         :return: A list of Installation Candidates
         :rtype: list[ :class:`~pip._internal.index.InstallationCandidate` ]
         """
+
+        from .dependencies import get_finder, find_all_matches
         if not finder:
             finder = get_finder(sources=sources)
         return find_all_matches(finder, self.as_ireq())
diff --git a/pipenv/vendor/requirementslib/models/resolvers.py b/pipenv/vendor/requirementslib/models/resolvers.py
index da6d0dda..1a239390 100644
--- a/pipenv/vendor/requirementslib/models/resolvers.py
+++ b/pipenv/vendor/requirementslib/models/resolvers.py
@@ -4,11 +4,10 @@ from contextlib import contextmanager
 import attr
 import six
 
-from pip_shims.shims import VcsSupport, Wheel
+from pip_shims.shims import Wheel
 
-from ..utils import log
+from ..utils import log, VCS_SUPPORT
 from .cache import HashCache
-from .dependencies import AbstractDependency, find_all_matches, get_finder
 from .utils import format_requirement, is_pinned_requirement, version_from_ireq
 
 
@@ -41,6 +40,7 @@ class DependencyResolver(object):
     @classmethod
     def create(cls, finder=None, allow_prereleases=False, get_all_hashes=True):
         if not finder:
+            from .dependencies import get_finder
             finder_args = []
             if allow_prereleases:
                 finder_args.append('--pre')
@@ -140,6 +140,7 @@ class DependencyResolver(object):
 
         # Coerce input into AbstractDependency instances.
         # We accept str, Requirement, and AbstractDependency as input.
+        from .dependencies import AbstractDependency
         for dep in root_nodes:
             if isinstance(dep, six.string_types):
                 dep = AbstractDependency.from_string(dep)
@@ -183,6 +184,7 @@ class DependencyResolver(object):
 
     def get_hashes_for_one(self, ireq):
         if not self.finder:
+            from .dependencies import get_finder
             finder_args = []
             if self.allow_prereleases:
                 finder_args.append('--pre')
@@ -191,7 +193,7 @@ class DependencyResolver(object):
         if ireq.editable:
             return set()
 
-        vcs = VcsSupport()
+        vcs = VCS_SUPPORT
         if ireq.link and ireq.link.scheme in vcs.all_schemes and 'ssh' in ireq.link.scheme:
             return set()
 
@@ -201,6 +203,7 @@ class DependencyResolver(object):
 
         matching_candidates = set()
         with self.allow_all_wheels():
+            from .dependencies import find_all_matches
             matching_candidates = (
                 find_all_matches(self.finder, ireq, pre=self.allow_prereleases)
             )
diff --git a/pipenv/vendor/requirementslib/models/utils.py b/pipenv/vendor/requirementslib/models/utils.py
index 6320236e..d72542c4 100644
--- a/pipenv/vendor/requirementslib/models/utils.py
+++ b/pipenv/vendor/requirementslib/models/utils.py
@@ -19,7 +19,7 @@ from packaging.requirements import Requirement as PackagingRequirement
 from pkg_resources import Requirement
 
 from vistir.misc import dedup
-from pip_shims.shims import InstallRequirement, Link
+
 
 from ..utils import SCHEME_LIST, VCS_LIST, is_star
 
@@ -37,6 +37,21 @@ def optional_instance_of(cls):
     return validators.optional(validators.instance_of(cls))
 
 
+def create_link(link):
+    from pip_shims import Link
+    return Link(link)
+
+
+def ireq_from_line(ireq):
+    from pip_shims import InstallRequirement
+    return InstallRequirement.from_line(ireq)
+
+
+def ireq_from_editable(ireq):
+    from pip_shims import InstallRequirement
+    return InstallRequirement.from_editable(ireq)
+
+
 def init_requirement(name):
     req = Requirement.parse(name)
     req.vcs = None
@@ -92,7 +107,7 @@ def build_vcs_link(vcs, uri, name=None, ref=None, subdirectory=None, extras=None
             uri = "{0}{1}".format(uri, extras)
     if subdirectory:
         uri = "{0}&subdirectory={1}".format(uri, subdirectory)
-    return Link(uri)
+    return create_link(uri)
 
 
 def get_version(pipfile_entry):
@@ -117,7 +132,7 @@ def strip_ssh_from_git_uri(uri):
 
 
 def add_ssh_scheme_to_git_uri(uri):
-    """Cleans VCS uris from pip format"""
+    """Cleans VCS uris from pipenv.patched.notpip format"""
     if isinstance(uri, six.string_types):
         # Add scheme for parsing purposes, this is also what pip does
         if uri.startswith("git+") and "://" not in uri:
@@ -443,11 +458,11 @@ def make_install_requirement(name, version, extras, markers, constraint=False):
         extras_string = "[{}]".format(",".join(sorted(extras)))
 
     if not markers:
-        return InstallRequirement.from_line(
+        return ireq_from_line(
             str('{}{}=={}'.format(name, extras_string, version)),
             constraint=constraint)
     else:
-        return InstallRequirement.from_line(
+        return ireq_from_line(
             str('{}{}=={}; {}'.format(name, extras_string, version, str(markers))),
             constraint=constraint)
 
@@ -510,3 +525,13 @@ def fix_requires_python_marker(requires_python):
     return marker_to_add
 
 
+def normalize_name(pkg):
+    """Given a package name, return its normalized, non-canonicalized form.
+
+    :param str pkg: The name of a package
+    :return: A normalized package name
+    :rtype: str
+    """
+
+    assert isinstance(pkg, six.string_types)
+    return pkg.replace("_", "-").lower()
diff --git a/pipenv/vendor/requirementslib/models/vcs.py b/pipenv/vendor/requirementslib/models/vcs.py
index 5d3ec08f..4efb9bd3 100644
--- a/pipenv/vendor/requirementslib/models/vcs.py
+++ b/pipenv/vendor/requirementslib/models/vcs.py
@@ -1,7 +1,6 @@
 # -*- coding=utf-8 -*-
 import attr
 from pip_shims import VcsSupport, parse_version, pip_version
-import vistir
 import os
 
 
@@ -14,6 +13,7 @@ class VCSRepository(object):
     name = attr.ib()
     checkout_directory = attr.ib()
     vcs_type = attr.ib()
+    subdirectory = attr.ib(default=None)
     commit_sha = attr.ib(default=None)
     ref = attr.ib(default=None)
     repo_instance = attr.ib()
@@ -31,35 +31,31 @@ class VCSRepository(object):
         return url.startswith("file")
 
     def obtain(self):
-        if not os.path.exists(self.checkout_directory):
+        if (os.path.exists(self.checkout_directory) and not
+                    self.repo_instance.is_repository_directory(self.checkout_directory)):
+            self.repo_instance.unpack(self.checkout_directory)
+        elif not os.path.exists(self.checkout_directory):
             self.repo_instance.obtain(self.checkout_directory)
-        if self.ref:
-            self.checkout_ref(self.ref)
-            self.commit_sha = self.get_commit_hash(self.ref)
         else:
-            if not self.commit_sha:
-                self.commit_sha = self.get_commit_hash()
+            if self.ref:
+                self.checkout_ref(self.ref)
+        if not self.commit_sha:
+            self.commit_sha = self.get_commit_hash()
 
     def checkout_ref(self, ref):
         if not self.repo_instance.is_commit_id_equal(
-            self.checkout_directory, self.get_commit_hash(ref)
+            self.checkout_directory, self.get_commit_hash()
         ) and not self.repo_instance.is_commit_id_equal(self.checkout_directory, ref):
             if not self.is_local:
                 self.update(ref)
 
     def update(self, ref):
         target_ref = self.repo_instance.make_rev_options(ref)
-        sha = self.repo_instance.get_revision_sha(self.checkout_directory, target_ref.arg_rev)
-        target_rev = target_ref.make_new(sha)
         if parse_version(pip_version) > parse_version("18.0"):
-            self.repo_instance.update(self.checkout_directory, self.url, target_rev)
+            self.repo_instance.update(self.checkout_directory, self.url, target_ref)
         else:
             self.repo_instance.update(self.checkout_directory, target_ref)
-        self.commit_hash = self.get_commit_hash(ref)
+        self.commit_sha = self.get_commit_hash()
 
     def get_commit_hash(self, ref=None):
-        if ref:
-            target_ref = self.repo_instance.make_rev_options(ref)
-            return self.repo_instance.get_revision_sha(self.checkout_directory, target_ref.arg_rev)
-            # return self.repo_instance.get_revision(self.checkout_directory)
         return self.repo_instance.get_revision(self.checkout_directory)
diff --git a/pipenv/vendor/requirementslib/utils.py b/pipenv/vendor/requirementslib/utils.py
index c41f9675..75a05ce0 100644
--- a/pipenv/vendor/requirementslib/utils.py
+++ b/pipenv/vendor/requirementslib/utils.py
@@ -1,33 +1,43 @@
 # -*- coding=utf-8 -*-
 from __future__ import absolute_import
 
+import contextlib
 import logging
 import os
 
 import six
+import sys
+import tomlkit
 
+six.add_move(six.MovedAttribute("Mapping", "collections", "collections.abc"))
+six.add_move(six.MovedAttribute("Sequence", "collections", "collections.abc"))
+six.add_move(six.MovedAttribute("Set", "collections", "collections.abc"))
+six.add_move(six.MovedAttribute("ItemsView", "collections", "collections.abc"))
+from six.moves import Mapping, Sequence, Set, ItemsView
 from six.moves.urllib.parse import urlparse, urlsplit
 
-from pip_shims import (
-    Command, VcsSupport, cmdoptions, is_archive_file, is_installable_dir
+from pip_shims.shims import (
+    Command, VcsSupport, cmdoptions, is_archive_file,
+    is_installable_dir as _is_installable_dir
 )
 from vistir.compat import Path
-from vistir.path import is_valid_url, ensure_mkdir_p
+from vistir.path import is_valid_url, ensure_mkdir_p, create_tracked_tempdir
 
 
-VCS_ACCESS = VcsSupport()
 VCS_LIST = ("git", "svn", "hg", "bzr")
 VCS_SCHEMES = []
 SCHEME_LIST = ("http://", "https://", "ftp://", "ftps://", "file://")
 
+VCS_SUPPORT = VcsSupport()
+
 if not VCS_SCHEMES:
-    VCS_SCHEMES = VcsSupport().all_schemes
+    VCS_SCHEMES = VCS_SUPPORT.all_schemes
 
 
 def setup_logger():
     logger = logging.getLogger("requirementslib")
     loglevel = logging.DEBUG
-    handler = logging.StreamHandler()
+    handler = logging.StreamHandler(stream=sys.stderr)
     handler.setLevel(loglevel)
     logger.addHandler(handler)
     logger.setLevel(loglevel)
@@ -37,6 +47,19 @@ def setup_logger():
 log = setup_logger()
 
 
+def is_installable_dir(path):
+    if _is_installable_dir(path):
+        return True
+    path = Path(path)
+    pyproject = path.joinpath("pyproject.toml")
+    if pyproject.exists():
+        pyproject_toml = tomlkit.loads(pyproject.read_text())
+        build_system = pyproject_toml.get("build-system", {}).get("build-backend", "")
+        if build_system:
+            return True
+    return False
+
+
 def is_vcs(pipfile_entry):
     """Determine if dictionary entry from Pipfile is for a vcs dependency."""
     if hasattr(pipfile_entry, "keys"):
@@ -51,6 +74,12 @@ def is_vcs(pipfile_entry):
     return False
 
 
+def is_editable(pipfile_entry):
+    if isinstance(pipfile_entry, Mapping):
+        return pipfile_entry.get("editable", False) is True
+    return False
+
+
 def multi_split(s, split):
     """Splits on multiple given separators."""
     for r in split:
@@ -150,3 +179,383 @@ def get_pip_command():
 @ensure_mkdir_p(mode=0o777)
 def _ensure_dir(path):
     return path
+
+
+@contextlib.contextmanager
+def ensure_setup_py(base_dir):
+    if not base_dir:
+        base_dir = create_tracked_tempdir(prefix="requirementslib-setup")
+    base_dir = Path(base_dir)
+    setup_py = base_dir.joinpath("setup.py")
+    is_new = False if setup_py.exists() else True
+    if not setup_py.exists():
+        setup_py.write_text(u"")
+    try:
+        yield
+    finally:
+        if is_new:
+            setup_py.unlink()
+
+
+
+_UNSET = object()
+_REMAP_EXIT = object()
+
+
+# The following functionality is either borrowed or modified from the itertools module
+# in the boltons library by Mahmoud Hashemi and distributed under the BSD license
+# the text of which is included below:
+
+# (original text from https://github.com/mahmoud/boltons/blob/master/LICENSE)
+#   Copyright (c) 2013, Mahmoud Hashemi
+#
+#   Redistribution and use in source and binary forms, with or without
+#   modification, are permitted provided that the following conditions are
+#   met:
+#
+#       * Redistributions of source code must retain the above copyright
+#         notice, this list of conditions and the following disclaimer.
+#
+#       * Redistributions in binary form must reproduce the above
+#         copyright notice, this list of conditions and the following
+#         disclaimer in the documentation and/or other materials provided
+#         with the distribution.
+#
+#       * The names of the contributors may not be used to endorse or
+#         promote products derived from this software without specific
+#         prior written permission.
+#
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+#   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+#   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+#   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+#   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+#   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+#   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+#   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+#   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+#   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+class PathAccessError(KeyError, IndexError, TypeError):
+    """An amalgamation of KeyError, IndexError, and TypeError,
+    representing what can occur when looking up a path in a nested
+    object.
+    """
+    def __init__(self, exc, seg, path):
+        self.exc = exc
+        self.seg = seg
+        self.path = path
+
+    def __repr__(self):
+        cn = self.__class__.__name__
+        return '%s(%r, %r, %r)' % (cn, self.exc, self.seg, self.path)
+
+    def __str__(self):
+        return ('could not access %r from path %r, got error: %r'
+                % (self.seg, self.path, self.exc))
+
+
+def get_path(root, path, default=_UNSET):
+    """Retrieve a value from a nested object via a tuple representing the
+    lookup path.
+    >>> root = {'a': {'b': {'c': [[1], [2], [3]]}}}
+    >>> get_path(root, ('a', 'b', 'c', 2, 0))
+    3
+    The path format is intentionally consistent with that of
+    :func:`remap`.
+    One of get_path's chief aims is improved error messaging. EAFP is
+    great, but the error messages are not.
+    For instance, ``root['a']['b']['c'][2][1]`` gives back
+    ``IndexError: list index out of range``
+    What went out of range where? get_path currently raises
+    ``PathAccessError: could not access 2 from path ('a', 'b', 'c', 2,
+    1), got error: IndexError('list index out of range',)``, a
+    subclass of IndexError and KeyError.
+    You can also pass a default that covers the entire operation,
+    should the lookup fail at any level.
+    Args:
+       root: The target nesting of dictionaries, lists, or other
+          objects supporting ``__getitem__``.
+       path (tuple): A list of strings and integers to be successively
+          looked up within *root*.
+       default: The value to be returned should any
+          ``PathAccessError`` exceptions be raised.
+    """
+    if isinstance(path, six.string_types):
+        path = path.split('.')
+    cur = root
+    try:
+        for seg in path:
+            try:
+                cur = cur[seg]
+            except (KeyError, IndexError) as exc:
+                raise PathAccessError(exc, seg, path)
+            except TypeError as exc:
+                # either string index in a list, or a parent that
+                # doesn't support indexing
+                try:
+                    seg = int(seg)
+                    cur = cur[seg]
+                except (ValueError, KeyError, IndexError, TypeError):
+                    if not getattr(cur, "__iter__", None):
+                        exc = TypeError('%r object is not indexable'
+                                        % type(cur).__name__)
+                    raise PathAccessError(exc, seg, path)
+    except PathAccessError:
+        if default is _UNSET:
+            raise
+        return default
+    return cur
+
+
+def default_visit(path, key, value):
+    return key, value
+
+
+_orig_default_visit = default_visit
+
+
+# Modified from https://github.com/mahmoud/boltons/blob/master/boltons/iterutils.py
+def dict_path_enter(path, key, value):
+    if isinstance(value, six.string_types):
+        return value, False
+    elif isinstance(value, (Mapping, dict)):
+        return value.__class__(), ItemsView(value)
+    elif isinstance(value, tomlkit.items.Array):
+        return value.__class__([], value.trivia), enumerate(value)
+    elif isinstance(value, (Sequence, list)):
+        return value.__class__(), enumerate(value)
+    elif isinstance(value, (Set, set)):
+        return value.__class__(), enumerate(value)
+    else:
+        return value, False
+
+
+def dict_path_exit(path, key, old_parent, new_parent, new_items):
+    ret = new_parent
+    if isinstance(new_parent, (Mapping, dict)):
+        vals = dict(new_items)
+        try:
+            new_parent.update(new_items)
+        except AttributeError:
+            # Handle toml containers specifically
+            try:
+                new_parent.update(vals)
+            # Now use default fallback if needed
+            except AttributeError:
+                ret = new_parent.__class__(vals)
+    elif isinstance(new_parent, tomlkit.items.Array):
+        vals = tomlkit.items.item([v for i, v in new_items])
+        try:
+            new_parent._value.extend(vals._value)
+        except AttributeError:
+            ret = tomlkit.items.item(vals)
+    elif isinstance(new_parent, (Sequence, list)):
+        vals = [v for i, v in new_items]
+        try:
+            new_parent.extend(vals)
+        except AttributeError:
+            ret = new_parent.__class__(vals)  # tuples
+    elif isinstance(new_parent, (Set, set)):
+        vals = [v for i, v in new_items]
+        try:
+            new_parent.update(vals)
+        except AttributeError:
+            ret = new_parent.__class__(vals)  # frozensets
+    else:
+        raise RuntimeError('unexpected iterable type: %r' % type(new_parent))
+    return ret
+
+
+def remap(root, visit=default_visit, enter=dict_path_enter, exit=dict_path_exit,
+          **kwargs):
+    """The remap ("recursive map") function is used to traverse and
+    transform nested structures. Lists, tuples, sets, and dictionaries
+    are just a few of the data structures nested into heterogenous
+    tree-like structures that are so common in programming.
+    Unfortunately, Python's built-in ways to manipulate collections
+    are almost all flat. List comprehensions may be fast and succinct,
+    but they do not recurse, making it tedious to apply quick changes
+    or complex transforms to real-world data.
+    remap goes where list comprehensions cannot.
+    Here's an example of removing all Nones from some data:
+    >>> from pprint import pprint
+    >>> reviews = {'Star Trek': {'TNG': 10, 'DS9': 8.5, 'ENT': None},
+    ...            'Babylon 5': 6, 'Dr. Who': None}
+    >>> pprint(remap(reviews, lambda p, k, v: v is not None))
+    {'Babylon 5': 6, 'Star Trek': {'DS9': 8.5, 'TNG': 10}}
+    Notice how both Nones have been removed despite the nesting in the
+    dictionary. Not bad for a one-liner, and that's just the beginning.
+    See `this remap cookbook`_ for more delicious recipes.
+    .. _this remap cookbook: http://sedimental.org/remap.html
+    remap takes four main arguments: the object to traverse and three
+    optional callables which determine how the remapped object will be
+    created.
+    Args:
+        root: The target object to traverse. By default, remap
+            supports iterables like :class:`list`, :class:`tuple`,
+            :class:`dict`, and :class:`set`, but any object traversable by
+            *enter* will work.
+        visit (callable): This function is called on every item in
+            *root*. It must accept three positional arguments, *path*,
+            *key*, and *value*. *path* is simply a tuple of parents'
+            keys. *visit* should return the new key-value pair. It may
+            also return ``True`` as shorthand to keep the old item
+            unmodified, or ``False`` to drop the item from the new
+            structure. *visit* is called after *enter*, on the new parent.
+            The *visit* function is called for every item in root,
+            including duplicate items. For traversable values, it is
+            called on the new parent object, after all its children
+            have been visited. The default visit behavior simply
+            returns the key-value pair unmodified.
+        enter (callable): This function controls which items in *root*
+            are traversed. It accepts the same arguments as *visit*: the
+            path, the key, and the value of the current item. It returns a
+            pair of the blank new parent, and an iterator over the items
+            which should be visited. If ``False`` is returned instead of
+            an iterator, the value will not be traversed.
+            The *enter* function is only called once per unique value. The
+            default enter behavior support mappings, sequences, and
+            sets. Strings and all other iterables will not be traversed.
+        exit (callable): This function determines how to handle items
+            once they have been visited. It gets the same three
+            arguments as the other functions -- *path*, *key*, *value*
+            -- plus two more: the blank new parent object returned
+            from *enter*, and a list of the new items, as remapped by
+            *visit*.
+            Like *enter*, the *exit* function is only called once per
+            unique value. The default exit behavior is to simply add
+            all new items to the new parent, e.g., using
+            :meth:`list.extend` and :meth:`dict.update` to add to the
+            new parent. Immutable objects, such as a :class:`tuple` or
+            :class:`namedtuple`, must be recreated from scratch, but
+            use the same type as the new parent passed back from the
+            *enter* function.
+        reraise_visit (bool): A pragmatic convenience for the *visit*
+            callable. When set to ``False``, remap ignores any errors
+            raised by the *visit* callback. Items causing exceptions
+            are kept. See examples for more details.
+    remap is designed to cover the majority of cases with just the
+    *visit* callable. While passing in multiple callables is very
+    empowering, remap is designed so very few cases should require
+    passing more than one function.
+    When passing *enter* and *exit*, it's common and easiest to build
+    on the default behavior. Simply add ``from boltons.iterutils import
+    default_enter`` (or ``default_exit``), and have your enter/exit
+    function call the default behavior before or after your custom
+    logic. See `this example`_.
+    Duplicate and self-referential objects (aka reference loops) are
+    automatically handled internally, `as shown here`_.
+    .. _this example: http://sedimental.org/remap.html#sort_all_lists
+    .. _as shown here: http://sedimental.org/remap.html#corner_cases
+    """
+    # TODO: improve argument formatting in sphinx doc
+    # TODO: enter() return (False, items) to continue traverse but cancel copy?
+    if not callable(visit):
+        raise TypeError('visit expected callable, not: %r' % visit)
+    if not callable(enter):
+        raise TypeError('enter expected callable, not: %r' % enter)
+    if not callable(exit):
+        raise TypeError('exit expected callable, not: %r' % exit)
+    reraise_visit = kwargs.pop('reraise_visit', True)
+    if kwargs:
+        raise TypeError('unexpected keyword arguments: %r' % kwargs.keys())
+
+    path, registry, stack = (), {}, [(None, root)]
+    new_items_stack = []
+    while stack:
+        key, value = stack.pop()
+        id_value = id(value)
+        if key is _REMAP_EXIT:
+            key, new_parent, old_parent = value
+            id_value = id(old_parent)
+            path, new_items = new_items_stack.pop()
+            value = exit(path, key, old_parent, new_parent, new_items)
+            registry[id_value] = value
+            if not new_items_stack:
+                continue
+        elif id_value in registry:
+            value = registry[id_value]
+        else:
+            res = enter(path, key, value)
+            try:
+                new_parent, new_items = res
+            except TypeError:
+                # TODO: handle False?
+                raise TypeError('enter should return a tuple of (new_parent,'
+                                ' items_iterator), not: %r' % res)
+            if new_items is not False:
+                # traverse unless False is explicitly passed
+                registry[id_value] = new_parent
+                new_items_stack.append((path, []))
+                if value is not root:
+                    path += (key,)
+                stack.append((_REMAP_EXIT, (key, new_parent, value)))
+                if new_items:
+                    stack.extend(reversed(list(new_items)))
+                continue
+        if visit is _orig_default_visit:
+            # avoid function call overhead by inlining identity operation
+            visited_item = (key, value)
+        else:
+            try:
+                visited_item = visit(path, key, value)
+            except Exception:
+                if reraise_visit:
+                    raise
+                visited_item = True
+            if visited_item is False:
+                continue  # drop
+            elif visited_item is True:
+                visited_item = (key, value)
+            # TODO: typecheck?
+            #    raise TypeError('expected (key, value) from visit(),'
+            #                    ' not: %r' % visited_item)
+        try:
+            new_items_stack[-1][1].append(visited_item)
+        except IndexError:
+            raise TypeError('expected remappable root, not: %r' % root)
+    return value
+
+
+def merge_items(target_list, sourced=False):
+    if not sourced:
+        target_list = [(id(t), t) for t in target_list]
+
+    ret = None
+    source_map = {}
+
+    def remerge_enter(path, key, value):
+        new_parent, new_items = dict_path_enter(path, key, value)
+        if ret and not path and key is None:
+            new_parent = ret
+
+        try:
+            cur_val = get_path(ret, path + (key,))
+        except KeyError as ke:
+            pass
+        else:
+            new_parent = cur_val
+
+        return new_parent, new_items
+
+    def remerge_exit(path, key, old_parent, new_parent, new_items):
+        return dict_path_exit(path, key, old_parent, new_parent, new_items)
+
+    for t_name, target in target_list:
+        if sourced:
+            def remerge_visit(path, key, value):
+                source_map[path + (key,)] = t_name
+                return True
+        else:
+            remerge_visit = default_visit
+
+        ret = remap(target, enter=remerge_enter, visit=remerge_visit,
+                    exit=remerge_exit)
+
+    if not sourced:
+        return ret
+    return ret, source_map
diff --git a/pipenv/vendor/resolvelib/LICENSE b/pipenv/vendor/resolvelib/LICENSE
new file mode 100644
index 00000000..b9077766
--- /dev/null
+++ b/pipenv/vendor/resolvelib/LICENSE
@@ -0,0 +1,13 @@
+Copyright (c) 2018, Tzu-ping Chung <uranusjr@gmail.com>
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/pipenv/vendor/resolvelib/__init__.py b/pipenv/vendor/resolvelib/__init__.py
new file mode 100644
index 00000000..e0e37434
--- /dev/null
+++ b/pipenv/vendor/resolvelib/__init__.py
@@ -0,0 +1,16 @@
+__all__ = [
+    '__version__',
+    'AbstractProvider', 'BaseReporter', 'Resolver',
+    'NoVersionsAvailable', 'RequirementsConflicted',
+    'ResolutionError', 'ResolutionImpossible', 'ResolutionTooDeep',
+]
+
+__version__ = '0.2.2'
+
+
+from .providers import AbstractProvider
+from .reporters import BaseReporter
+from .resolvers import (
+    NoVersionsAvailable, RequirementsConflicted,
+    Resolver, ResolutionError, ResolutionImpossible, ResolutionTooDeep,
+)
diff --git a/pipenv/vendor/resolvelib/providers.py b/pipenv/vendor/resolvelib/providers.py
new file mode 100644
index 00000000..515c0db4
--- /dev/null
+++ b/pipenv/vendor/resolvelib/providers.py
@@ -0,0 +1,78 @@
+class AbstractProvider(object):
+    """Delegate class to provide requirment interface for the resolver.
+    """
+    def identify(self, dependency):
+        """Given a dependency, return an identifier for it.
+
+        This is used in many places to identify the dependency, e.g. whether
+        two requirements should have their specifier parts merged, whether
+        two specifications would conflict with each other (because they the
+        same name but different versions).
+        """
+        raise NotImplementedError
+
+    def get_preference(self, resolution, candidates, information):
+        """Produce a sort key for given specification based on preference.
+
+        The preference is defined as "I think this requirement should be
+        resolved first". The lower the return value is, the more preferred
+        this group of arguments is.
+
+        :param resolution: Currently pinned candidate, or `None`.
+        :param candidates: A list of possible candidates.
+        :param information: A list of requirement information.
+
+        Each information instance is a named tuple with two entries:
+
+        * `requirement` specifies a requirement contributing to the current
+          candidate list
+        * `parent` specifies the candidate that provids (dependend on) the
+          requirement, or `None` to indicate a root requirement.
+
+        The preference could depend on a various of issues, including (not
+        necessarily in this order):
+
+        * Is this package pinned in the current resolution result?
+        * How relaxed is the requirement? Stricter ones should probably be
+          worked on first? (I don't know, actually.)
+        * How many possibilities are there to satisfy this requirement? Those
+          with few left should likely be worked on first, I guess?
+        * Are there any known conflicts for this requirement? We should
+          probably work on those with the most known conflicts.
+
+        A sortable value should be returned (this will be used as the `key`
+        parameter of the built-in sorting function). The smaller the value is,
+        the more preferred this specification is (i.e. the sorting function
+        is called with `reverse=False`).
+        """
+        raise NotImplementedError
+
+    def find_matches(self, requirement):
+        """Find all possible candidates that satisfy a requirement.
+
+        This should try to get candidates based on the requirement's type.
+        For VCS, local, and archive requirements, the one-and-only match is
+        returned, and for a "named" requirement, the index(es) should be
+        consulted to find concrete candidates for this requirement.
+
+        The returned candidates should be sorted by reversed preference, e.g.
+        the latest should be LAST. This is done so list-popping can be as
+        efficient as possible.
+        """
+        raise NotImplementedError
+
+    def is_satisfied_by(self, requirement, candidate):
+        """Whether the given requirement can be satisfied by a candidate.
+
+        A boolean should be retuened to indicate whether `candidate` is a
+        viable solution to the requirement.
+        """
+        raise NotImplementedError
+
+    def get_dependencies(self, candidate):
+        """Get dependencies of a candidate.
+
+        This should return a collection of requirements that `candidate`
+        specifies as its dependencies.
+        """
+        raise NotImplementedError
diff --git a/pipenv/vendor/resolvelib/reporters.py b/pipenv/vendor/resolvelib/reporters.py
new file mode 100644
index 00000000..c723031f
--- /dev/null
+++ b/pipenv/vendor/resolvelib/reporters.py
@@ -0,0 +1,23 @@
+class BaseReporter(object):
+    """Delegate class to provider progress reporting for the resolver.
+    """
+    def starting(self):
+        """Called before the resolution actually starts.
+        """
+
+    def starting_round(self, index):
+        """Called before each round of resolution starts.
+
+        The index is zero-based.
+        """
+
+    def ending_round(self, index, state):
+        """Called before each round of resolution ends.
+
+        This is NOT called if the resolution ends at this round. Use `ending`
+        if you want to report finalization. The index is zero-based.
+        """
+
+    def ending(self, state):
+        """Called before the resolution ends successfully.
+        """
diff --git a/pipenv/vendor/resolvelib/resolvers.py b/pipenv/vendor/resolvelib/resolvers.py
new file mode 100644
index 00000000..9c69628e
--- /dev/null
+++ b/pipenv/vendor/resolvelib/resolvers.py
@@ -0,0 +1,287 @@
+import collections
+
+from .structs import DirectedGraph
+
+
+RequirementInformation = collections.namedtuple('RequirementInformation', [
+    'requirement', 'parent',
+])
+
+
+class NoVersionsAvailable(Exception):
+    def __init__(self, requirement, parent):
+        super(NoVersionsAvailable, self).__init__()
+        self.requirement = requirement
+        self.parent = parent
+
+
+class RequirementsConflicted(Exception):
+    def __init__(self, criterion):
+        super(RequirementsConflicted, self).__init__()
+        self.criterion = criterion
+
+
+class Criterion(object):
+    """Internal representation of possible resolution results of a package.
+
+    This holds two attributes:
+
+    * `information` is a collection of `RequirementInformation` pairs. Each
+      pair is a requirement contributing to this criterion, and the candidate
+      that provides the requirement.
+    * `candidates` is a collection containing all possible candidates deducted
+      from the union of contributing requirements. It should never be empty.
+    """
+    def __init__(self, candidates, information):
+        self.candidates = candidates
+        self.information = information
+
+    @classmethod
+    def from_requirement(cls, provider, requirement, parent):
+        """Build an instance from a requirement.
+        """
+        candidates = provider.find_matches(requirement)
+        if not candidates:
+            raise NoVersionsAvailable(requirement, parent)
+        return cls(
+            candidates=candidates,
+            information=[RequirementInformation(requirement, parent)],
+        )
+
+    def iter_requirement(self):
+        return (i.requirement for i in self.information)
+
+    def iter_parent(self):
+        return (i.parent for i in self.information)
+
+    def merged_with(self, provider, requirement, parent):
+        """Build a new instance from this and a new requirement.
+        """
+        infos = list(self.information)
+        infos.append(RequirementInformation(requirement, parent))
+        candidates = [
+            c for c in self.candidates
+            if provider.is_satisfied_by(requirement, c)
+        ]
+        if not candidates:
+            raise RequirementsConflicted(self)
+        return type(self)(candidates, infos)
+
+
+class ResolutionError(Exception):
+    pass
+
+
+class ResolutionImpossible(ResolutionError):
+    def __init__(self, requirements):
+        super(ResolutionImpossible, self).__init__()
+        self.requirements = requirements
+
+
+class ResolutionTooDeep(ResolutionError):
+    def __init__(self, round_count):
+        super(ResolutionTooDeep, self).__init__(round_count)
+        self.round_count = round_count
+
+
+# Resolution state in a round.
+State = collections.namedtuple('State', 'mapping graph')
+
+
+class Resolution(object):
+    """Stateful resolution object.
+
+    This is designed as a one-off object that holds information to kick start
+    the resolution process, and holds the results afterwards.
+    """
+    def __init__(self, provider, reporter):
+        self._p = provider
+        self._r = reporter
+        self._criteria = {}
+        self._states = []
+
+    @property
+    def state(self):
+        try:
+            return self._states[-1]
+        except IndexError:
+            raise AttributeError('state')
+
+    def _push_new_state(self):
+        """Push a new state into history.
+
+        This new state will be used to hold resolution results of the next
+        coming round.
+        """
+        try:
+            base = self._states[-1]
+        except IndexError:
+            graph = DirectedGraph()
+            graph.add(None)     # Sentinel as root dependencies' parent.
+            state = State(mapping={}, graph=graph)
+        else:
+            state = State(
+                mapping=base.mapping.copy(),
+                graph=base.graph.copy(),
+            )
+        self._states.append(state)
+
+    def _contribute_to_criteria(self, name, requirement, parent):
+        try:
+            crit = self._criteria[name]
+        except KeyError:
+            crit = Criterion.from_requirement(self._p, requirement, parent)
+        else:
+            crit = crit.merged_with(self._p, requirement, parent)
+        self._criteria[name] = crit
+
+    def _get_criterion_item_preference(self, item):
+        name, criterion = item
+        try:
+            pinned = self.state.mapping[name]
+        except (IndexError, KeyError):
+            pinned = None
+        return self._p.get_preference(
+            pinned, criterion.candidates, criterion.information,
+        )
+
+    def _is_current_pin_satisfying(self, name, criterion):
+        try:
+            current_pin = self.state.mapping[name]
+        except KeyError:
+            return False
+        return all(
+            self._p.is_satisfied_by(r, current_pin)
+            for r in criterion.iter_requirement()
+        )
+
+    def _check_pinnability(self, candidate, dependencies):
+        backup = self._criteria.copy()
+        contributed = set()
+        try:
+            for subdep in dependencies:
+                key = self._p.identify(subdep)
+                self._contribute_to_criteria(key, subdep, parent=candidate)
+                contributed.add(key)
+        except RequirementsConflicted:
+            self._criteria = backup
+            return None
+        return contributed
+
+    def _pin_candidate(self, name, criterion, candidate, child_names):
+        try:
+            self.state.graph.remove(name)
+        except KeyError:
+            pass
+        self.state.mapping[name] = candidate
+        self.state.graph.add(name)
+        for parent in criterion.iter_parent():
+            parent_name = None if parent is None else self._p.identify(parent)
+            try:
+                self.state.graph.connect(parent_name, name)
+            except KeyError:
+                # Parent is not yet pinned. Skip now; this edge will be
+                # connected when the parent is being pinned.
+                pass
+        for child_name in child_names:
+            try:
+                self.state.graph.connect(name, child_name)
+            except KeyError:
+                # Child is not yet pinned. Skip now; this edge will be
+                # connected when the child is being pinned.
+                pass
+
+    def _pin_criteria(self):
+        criterion_names = [name for name, _ in sorted(
+            self._criteria.items(),
+            key=self._get_criterion_item_preference,
+        )]
+        for name in criterion_names:
+            # Any pin may modify any criterion during the loop. Criteria are
+            # replaced, not updated in-place, so we need to read this value
+            # in the loop instead of outside. (sarugaku/resolvelib#5)
+            criterion = self._criteria[name]
+
+            if self._is_current_pin_satisfying(name, criterion):
+                # If the current pin already works, just use it.
+                continue
+            candidates = list(criterion.candidates)
+            while candidates:
+                candidate = candidates.pop()
+                dependencies = self._p.get_dependencies(candidate)
+                child_names = self._check_pinnability(candidate, dependencies)
+                if child_names is None:
+                    continue
+                self._pin_candidate(name, criterion, candidate, child_names)
+                break
+            else:   # All candidates tried, nothing works. Give up. (?)
+                raise ResolutionImpossible(list(criterion.iter_requirement()))
+
+    def resolve(self, requirements, max_rounds):
+        if self._states:
+            raise RuntimeError('already resolved')
+
+        for requirement in requirements:
+            try:
+                name = self._p.identify(requirement)
+                self._contribute_to_criteria(name, requirement, parent=None)
+            except RequirementsConflicted as e:
+                # If initial requirements conflict, nothing would ever work.
+                raise ResolutionImpossible(e.requirements + [requirement])
+
+        last = None
+        self._r.starting()
+
+        for round_index in range(max_rounds):
+            self._r.starting_round(round_index)
+
+            self._push_new_state()
+            self._pin_criteria()
+
+            curr = self.state
+            if last is not None and len(curr.mapping) == len(last.mapping):
+                # Nothing new added. Done! Remove the duplicated entry.
+                del self._states[-1]
+                self._r.ending(last)
+                return
+            last = curr
+
+            self._r.ending_round(round_index, curr)
+
+        raise ResolutionTooDeep(max_rounds)
+
+
+class Resolver(object):
+    """The thing that performs the actual resolution work.
+    """
+    def __init__(self, provider, reporter):
+        self.provider = provider
+        self.reporter = reporter
+
+    def resolve(self, requirements, max_rounds=20):
+        """Take a collection of constraints, spit out the resolution result.
+
+        The return value is a representation to the final resolution result. It
+        is a tuple subclass with two public members:
+
+        * `mapping`: A dict of resolved candidates. Each key is an identifier
+            of a requirement (as returned by the provider's `identify` method),
+            and the value is the resolved candidate.
+        * `graph`: A `DirectedGraph` instance representing the dependency tree.
+            The vertices are keys of `mapping`, and each edge represents *why*
+            a particular package is included. A special vertex `None` is
+            included to represent parents of user-supplied requirements.
+
+        The following exceptions may be raised if a resolution cannot be found:
+
+        * `NoVersionsAvailable`: A requirement has no available candidates.
+        * `ResolutionImpossible`: A resolution cannot be found for the given
+            combination of requirements.
+        * `ResolutionTooDeep`: The dependency tree is too deeply nested and
+            the resolver gave up. This is usually caused by a circular
+            dependency, but you can try to resolve this by increasing the
+            `max_rounds` argument.
+        """
+        resolution = Resolution(self.provider, self.reporter)
+        resolution.resolve(requirements, max_rounds=max_rounds)
+        return resolution.state
diff --git a/pipenv/vendor/resolvelib/structs.py b/pipenv/vendor/resolvelib/structs.py
new file mode 100644
index 00000000..97bd0095
--- /dev/null
+++ b/pipenv/vendor/resolvelib/structs.py
@@ -0,0 +1,67 @@
+class DirectedGraph(object):
+    """A graph structure with directed edges.
+    """
+    def __init__(self):
+        self._vertices = set()
+        self._forwards = {}     # <key> -> Set[<key>]
+        self._backwards = {}    # <key> -> Set[<key>]
+
+    def __iter__(self):
+        return iter(self._vertices)
+
+    def __len__(self):
+        return len(self._vertices)
+
+    def __contains__(self, key):
+        return key in self._vertices
+
+    def copy(self):
+        """Return a shallow copy of this graph.
+        """
+        other = DirectedGraph()
+        other._vertices = set(self._vertices)
+        other._forwards = {k: set(v) for k, v in self._forwards.items()}
+        other._backwards = {k: set(v) for k, v in self._backwards.items()}
+        return other
+
+    def add(self, key):
+        """Add a new vertex to the graph.
+        """
+        if key in self._vertices:
+            raise ValueError('vertex exists')
+        self._vertices.add(key)
+        self._forwards[key] = set()
+        self._backwards[key] = set()
+
+    def remove(self, key):
+        """Remove a vertex from the graph, disconnecting all edges from/to it.
+        """
+        self._vertices.remove(key)
+        for f in self._forwards.pop(key):
+            self._backwards[f].remove(key)
+        for t in self._backwards.pop(key):
+            self._forwards[t].remove(key)
+
+    def connected(self, f, t):
+        return f in self._backwards[t] and t in self._forwards[f]
+
+    def connect(self, f, t):
+        """Connect two existing vertices.
+
+        Nothing happens if the vertices are already connected.
+        """
+        if t not in self._vertices:
+            raise KeyError(t)
+        self._forwards[f].add(t)
+        self._backwards[t].add(f)
+
+    def iter_edges(self):
+        for f, children in self._forwards.items():
+            for t in children:
+                yield f, t
+
+    def iter_children(self, key):
+        return iter(self._forwards[key])
+
+    def iter_parents(self, key):
+        return iter(self._backwards[key])
diff --git a/pipenv/vendor/shellingham/__init__.py b/pipenv/vendor/shellingham/__init__.py
index a415c4a9..576c4224 100644
--- a/pipenv/vendor/shellingham/__init__.py
+++ b/pipenv/vendor/shellingham/__init__.py
@@ -4,7 +4,7 @@ import os
 from ._core import ShellDetectionFailure
 
 
-__version__ = '1.2.4'
+__version__ = '1.2.7'
 
 
 def detect_shell(pid=None, max_depth=6):
diff --git a/pipenv/vendor/shellingham/posix.py b/pipenv/vendor/shellingham/posix.py
index b25dd874..0bbf988b 100644
--- a/pipenv/vendor/shellingham/posix.py
+++ b/pipenv/vendor/shellingham/posix.py
@@ -21,7 +21,7 @@ def _get_process_mapping():
     processes = {}
     for line in output.split('\n'):
         try:
-            pid, ppid, args = line.strip().split(maxsplit=2)
+            pid, ppid, args = line.strip().split(None, 2)
         except ValueError:
             continue
         processes[pid] = Process(
diff --git a/pipenv/vendor/shellingham/posix/_default.py b/pipenv/vendor/shellingham/posix/_default.py
deleted file mode 100644
index 86944276..00000000
--- a/pipenv/vendor/shellingham/posix/_default.py
+++ /dev/null
@@ -1,27 +0,0 @@
-import collections
-import shlex
-import subprocess
-import sys
-
-
-Process = collections.namedtuple('Process', 'args pid ppid')
-
-
-def get_process_mapping():
-    """Try to look up the process tree via the output of `ps`.
-    """
-    output = subprocess.check_output([
-        'ps', '-ww', '-o', 'pid=', '-o', 'ppid=', '-o', 'args=',
-    ])
-    if not isinstance(output, str):
-        output = output.decode(sys.stdout.encoding)
-    processes = {}
-    for line in output.split('\n'):
-        try:
-            pid, ppid, args = line.strip().split(None, 2)
-        except ValueError:
-            continue
-        processes[pid] = Process(
-            args=tuple(shlex.split(args)), pid=pid, ppid=ppid,
-        )
-    return processes
diff --git a/pipenv/vendor/shellingham/posix/_proc.py b/pipenv/vendor/shellingham/posix/_proc.py
index 921f2508..e3a6e46d 100644
--- a/pipenv/vendor/shellingham/posix/_proc.py
+++ b/pipenv/vendor/shellingham/posix/_proc.py
@@ -1,40 +1,34 @@
 import os
 import re
 
-from ._core import Process
+from ._default import Process
 
 
 STAT_PPID = 3
 STAT_TTY = 6
 
-STAT_PATTERN = re.compile(r'\(.+\)|\S+')
-
-
-def _get_stat(pid):
-    with open(os.path.join('/proc', str(pid), 'stat')) as f:
-        parts = STAT_PATTERN.findall(f.read())
-        return parts[STAT_TTY], parts[STAT_PPID]
-
-
-def _get_cmdline(pid):
-    with open(os.path.join('/proc', str(pid), 'cmdline')) as f:
-        return tuple(f.read().split('\0')[:-1])
-
 
 def get_process_mapping():
     """Try to look up the process tree via the /proc interface.
     """
-    self_tty = _get_stat(os.getpid())[0]
+    with open('/proc/{0}/stat'.format(os.getpid())) as f:
+        self_tty = f.read().split()[STAT_TTY]
     processes = {}
     for pid in os.listdir('/proc'):
         if not pid.isdigit():
             continue
         try:
-            tty, ppid = _get_stat(pid)
-            if tty != self_tty:
-                continue
-            args = _get_cmdline(pid)
-            processes[pid] = Process(args=args, pid=pid, ppid=ppid)
+            stat = '/proc/{0}/stat'.format(pid)
+            cmdline = '/proc/{0}/cmdline'.format(pid)
+            with open(stat) as fstat, open(cmdline) as fcmdline:
+                stat = re.findall(r'\(.+\)|\S+', fstat.read())
+                cmd = fcmdline.read().split('\x00')[:-1]
+            ppid = stat[STAT_PPID]
+            tty = stat[STAT_TTY]
+            if tty == self_tty:
+                processes[pid] = Process(
+                    args=tuple(cmd), pid=pid, ppid=ppid,
+                )
         except IOError:
             # Process has disappeared - just ignore it.
             continue
diff --git a/pipenv/vendor/shellingham/posix/_ps.py b/pipenv/vendor/shellingham/posix/_ps.py
index e96278cf..86944276 100644
--- a/pipenv/vendor/shellingham/posix/_ps.py
+++ b/pipenv/vendor/shellingham/posix/_ps.py
@@ -1,8 +1,10 @@
+import collections
 import shlex
 import subprocess
 import sys
 
-from ._core import Process
+
+Process = collections.namedtuple('Process', 'args pid ppid')
 
 
 def get_process_mapping():
diff --git a/pipenv/vendor/shellingham/posix/linux.py b/pipenv/vendor/shellingham/posix/linux.py
deleted file mode 100644
index 6db97834..00000000
--- a/pipenv/vendor/shellingham/posix/linux.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import os
-import re
-
-from ._default import Process
-
-
-STAT_PPID = 3
-STAT_TTY = 6
-
-
-def get_process_mapping():
-    """Try to look up the process tree via Linux's /proc
-    """
-    with open('/proc/{0}/stat'.format(os.getpid())) as f:
-        self_tty = f.read().split()[STAT_TTY]
-    processes = {}
-    for pid in os.listdir('/proc'):
-        if not pid.isdigit():
-            continue
-        try:
-            stat = '/proc/{0}/stat'.format(pid)
-            cmdline = '/proc/{0}/cmdline'.format(pid)
-            with open(stat) as fstat, open(cmdline) as fcmdline:
-                stat = re.findall(r'\(.+\)|\S+', fstat.read())
-                cmd = fcmdline.read().split('\x00')[:-1]
-            ppid = stat[STAT_PPID]
-            tty = stat[STAT_TTY]
-            if tty == self_tty:
-                processes[pid] = Process(
-                    args=tuple(cmd), pid=pid, ppid=ppid,
-                )
-        except IOError:
-            # Process has disappeared - just ignore it.
-            continue
-    return processes
diff --git a/pipenv/vendor/shellingham/posix/proc.py b/pipenv/vendor/shellingham/posix/proc.py
index e64a5fe2..89d6c8e9 100644
--- a/pipenv/vendor/shellingham/posix/proc.py
+++ b/pipenv/vendor/shellingham/posix/proc.py
@@ -1,5 +1,7 @@
+import io
 import os
 import re
+import sys
 
 from ._core import Process
 
@@ -27,13 +29,21 @@ def detect_proc():
 
 
 def _get_stat(pid, name):
-    with open(os.path.join('/proc', str(pid), name)) as f:
+    path = os.path.join('/proc', str(pid), name)
+    with io.open(path, encoding='ascii', errors='replace') as f:
+        # We only care about TTY and PPID -- all numbers.
         parts = STAT_PATTERN.findall(f.read())
         return parts[STAT_TTY], parts[STAT_PPID]
 
 
 def _get_cmdline(pid):
-    with open(os.path.join('/proc', str(pid), 'cmdline')) as f:
+    path = os.path.join('/proc', str(pid), 'cmdline')
+    encoding = sys.getfilesystemencoding() or 'utf-8'
+    with io.open(path, encoding=encoding, errors='replace') as f:
+        # XXX: Command line arguments can be arbitrary byte sequences, not
+        # necessarily decodable. For Shellingham's purpose, however, we don't
+        # care. (pypa/pipenv#2820)
+        # cmdline appends an extra NULL at the end, hence the [:-1].
         return tuple(f.read().split('\0')[:-1])
 
 
diff --git a/pipenv/vendor/shellingham/posix/ps.py b/pipenv/vendor/shellingham/posix/ps.py
index ab4c2a9e..4a155ed5 100644
--- a/pipenv/vendor/shellingham/posix/ps.py
+++ b/pipenv/vendor/shellingham/posix/ps.py
@@ -21,6 +21,12 @@ def get_process_mapping():
         if e.errno != errno.ENOENT:
             raise
         raise PsNotAvailable('ps not found')
+    except subprocess.CalledProcessError as e:
+        # `ps` can return 1 if the process list is completely empty.
+        # (sarugaku/shellingham#15)
+        if not e.output.strip():
+            return {}
+        raise
     if not isinstance(output, str):
         encoding = sys.getfilesystemencoding() or sys.getdefaultencoding()
         output = output.decode(encoding)
@@ -28,9 +34,9 @@ def get_process_mapping():
     for line in output.split('\n'):
         try:
             pid, ppid, args = line.strip().split(None, 2)
+            processes[pid] = Process(
+                args=tuple(shlex.split(args)), pid=pid, ppid=ppid,
+            )
         except ValueError:
             continue
-        processes[pid] = Process(
-            args=tuple(shlex.split(args)), pid=pid, ppid=ppid,
-        )
     return processes
diff --git a/pipenv/vendor/toml.py b/pipenv/vendor/toml.py
deleted file mode 100644
index 0bf04ae5..00000000
--- a/pipenv/vendor/toml.py
+++ /dev/null
@@ -1,922 +0,0 @@
-"""Python module which parses and emits TOML.
-
-Released under the MIT license.
-"""
-import re
-import io
-import datetime
-from os import linesep
-
-__version__ = "0.9.4"
-__spec__ = "0.4.0"
-
-
-class TomlDecodeError(Exception):
-    """Base toml Exception / Error."""
-    pass
-
-
-class TomlTz(datetime.tzinfo):
-    def __init__(self, toml_offset):
-        if toml_offset == "Z":
-            self._raw_offset = "+00:00"
-        else:
-            self._raw_offset = toml_offset
-        self._sign = -1 if self._raw_offset[0] == '-' else 1
-        self._hours = int(self._raw_offset[1:3])
-        self._minutes = int(self._raw_offset[4:6])
-
-    def tzname(self, dt):
-        return "UTC" + self._raw_offset
-
-    def utcoffset(self, dt):
-        return self._sign * datetime.timedelta(hours=self._hours,
-                                               minutes=self._minutes)
-
-    def dst(self, dt):
-        return datetime.timedelta(0)
-
-
-class InlineTableDict(object):
-    """Sentinel subclass of dict for inline tables."""
-
-
-def _get_empty_inline_table(_dict):
-    class DynamicInlineTableDict(_dict, InlineTableDict):
-        """Concrete sentinel subclass for inline tables.
-        It is a subclass of _dict which is passed in dynamically at load time
-        It is also a subclass of InlineTableDict
-        """
-
-    return DynamicInlineTableDict()
-
-
-try:
-    _range = xrange
-except NameError:
-    unicode = str
-    _range = range
-    basestring = str
-    unichr = chr
-
-try:
-    FNFError = FileNotFoundError
-except NameError:
-    FNFError = IOError
-
-
-def load(f, _dict=dict):
-    """Parses named file or files as toml and returns a dictionary
-
-    Args:
-        f: Path to the file to open, array of files to read into single dict
-           or a file descriptor
-        _dict: (optional) Specifies the class of the returned toml dictionary
-
-    Returns:
-        Parsed toml file represented as a dictionary
-
-    Raises:
-        TypeError -- When f is invalid type
-        TomlDecodeError: Error while decoding toml
-        IOError / FileNotFoundError -- When an array with no valid (existing)
-        (Python 2 / Python 3)          file paths is passed
-    """
-
-    if isinstance(f, basestring):
-        with io.open(f, encoding='utf-8') as ffile:
-            return loads(ffile.read(), _dict)
-    elif isinstance(f, list):
-        from os import path as op
-        from warnings import warn
-        if not [path for path in f if op.exists(path)]:
-            error_msg = "Load expects a list to contain filenames only."
-            error_msg += linesep
-            error_msg += ("The list needs to contain the path of at least one "
-                          "existing file.")
-            raise FNFError(error_msg)
-        d = _dict()
-        for l in f:
-            if op.exists(l):
-                d.update(load(l))
-            else:
-                warn("Non-existent filename in list with at least one valid "
-                     "filename")
-        return d
-    else:
-        try:
-            return loads(f.read(), _dict)
-        except AttributeError:
-            raise TypeError("You can only load a file descriptor, filename or "
-                            "list")
-
-
-_groupname_re = re.compile(r'^[A-Za-z0-9_-]+$')
-
-
-def loads(s, _dict=dict):
-    """Parses string as toml
-
-    Args:
-        s: String to be parsed
-        _dict: (optional) Specifies the class of the returned toml dictionary
-
-    Returns:
-        Parsed toml file represented as a dictionary
-
-    Raises:
-        TypeError: When a non-string is passed
-        TomlDecodeError: Error while decoding toml
-    """
-
-    implicitgroups = []
-    retval = _dict()
-    currentlevel = retval
-    if not isinstance(s, basestring):
-        raise TypeError("Expecting something like a string")
-
-    if not isinstance(s, unicode):
-        s = s.decode('utf8')
-
-    sl = list(s)
-    openarr = 0
-    openstring = False
-    openstrchar = ""
-    multilinestr = False
-    arrayoftables = False
-    beginline = True
-    keygroup = False
-    keyname = 0
-    for i, item in enumerate(sl):
-        if item == '\r' and sl[i + 1] == '\n':
-            sl[i] = ' '
-            continue
-        if keyname:
-            if item == '\n':
-                raise TomlDecodeError("Key name found without value."
-                                      " Reached end of line.")
-            if openstring:
-                if item == openstrchar:
-                    keyname = 2
-                    openstring = False
-                    openstrchar = ""
-                continue
-            elif keyname == 1:
-                if item.isspace():
-                    keyname = 2
-                    continue
-                elif item.isalnum() or item == '_' or item == '-':
-                    continue
-            elif keyname == 2 and item.isspace():
-                continue
-            if item == '=':
-                keyname = 0
-            else:
-                raise TomlDecodeError("Found invalid character in key name: '" +
-                                      item + "'. Try quoting the key name.")
-        if item == "'" and openstrchar != '"':
-            k = 1
-            try:
-                while sl[i - k] == "'":
-                    k += 1
-                    if k == 3:
-                        break
-            except IndexError:
-                pass
-            if k == 3:
-                multilinestr = not multilinestr
-                openstring = multilinestr
-            else:
-                openstring = not openstring
-            if openstring:
-                openstrchar = "'"
-            else:
-                openstrchar = ""
-        if item == '"' and openstrchar != "'":
-            oddbackslash = False
-            k = 1
-            tripquote = False
-            try:
-                while sl[i - k] == '"':
-                    k += 1
-                    if k == 3:
-                        tripquote = True
-                        break
-                if k == 1 or (k == 3 and tripquote):
-                    while sl[i - k] == '\\':
-                        oddbackslash = not oddbackslash
-                        k += 1
-            except IndexError:
-                pass
-            if not oddbackslash:
-                if tripquote:
-                    multilinestr = not multilinestr
-                    openstring = multilinestr
-                else:
-                    openstring = not openstring
-            if openstring:
-                openstrchar = '"'
-            else:
-                openstrchar = ""
-        if item == '#' and (not openstring and not keygroup and
-                            not arrayoftables):
-            j = i
-            try:
-                while sl[j] != '\n':
-                    sl[j] = ' '
-                    j += 1
-            except IndexError:
-                break
-        if item == '[' and (not openstring and not keygroup and
-                            not arrayoftables):
-            if beginline:
-                if sl[i + 1] == '[':
-                    arrayoftables = True
-                else:
-                    keygroup = True
-            else:
-                openarr += 1
-        if item == ']' and not openstring:
-            if keygroup:
-                keygroup = False
-            elif arrayoftables:
-                if sl[i - 1] == ']':
-                    arrayoftables = False
-            else:
-                openarr -= 1
-        if item == '\n':
-            if openstring or multilinestr:
-                if not multilinestr:
-                    raise TomlDecodeError("Unbalanced quotes")
-                if ((sl[i - 1] == "'" or sl[i - 1] == '"') and (
-                        sl[i - 2] == sl[i - 1])):
-                    sl[i] = sl[i - 1]
-                    if sl[i - 3] == sl[i - 1]:
-                        sl[i - 3] = ' '
-            elif openarr:
-                sl[i] = ' '
-            else:
-                beginline = True
-        elif beginline and sl[i] != ' ' and sl[i] != '\t':
-            beginline = False
-            if not keygroup and not arrayoftables:
-                if sl[i] == '=':
-                    raise TomlDecodeError("Found empty keyname. ")
-                keyname = 1
-    s = ''.join(sl)
-    s = s.split('\n')
-    multikey = None
-    multilinestr = ""
-    multibackslash = False
-    for line in s:
-        if not multilinestr or multibackslash or '\n' not in multilinestr:
-            line = line.strip()
-        if line == "" and (not multikey or multibackslash):
-            continue
-        if multikey:
-            if multibackslash:
-                multilinestr += line
-            else:
-                multilinestr += line
-            multibackslash = False
-            if len(line) > 2 and (line[-1] == multilinestr[0] and
-                                  line[-2] == multilinestr[0] and
-                                  line[-3] == multilinestr[0]):
-                value, vtype = _load_value(multilinestr, _dict)
-                currentlevel[multikey] = value
-                multikey = None
-                multilinestr = ""
-            else:
-                k = len(multilinestr) - 1
-                while k > -1 and multilinestr[k] == '\\':
-                    multibackslash = not multibackslash
-                    k -= 1
-                if multibackslash:
-                    multilinestr = multilinestr[:-1]
-                else:
-                    multilinestr += "\n"
-            continue
-        if line[0] == '[':
-            arrayoftables = False
-            if line[1] == '[':
-                arrayoftables = True
-                line = line[2:].split(']]', 1)
-            else:
-                line = line[1:].split(']', 1)
-            if line[1].strip() != "":
-                raise TomlDecodeError("Key group not on a line by itself.")
-            groups = line[0].split('.')
-            i = 0
-            while i < len(groups):
-                groups[i] = groups[i].strip()
-                if groups[i][0] == '"' or groups[i][0] == "'":
-                    groupstr = groups[i]
-                    j = i + 1
-                    while not groupstr[0] == groupstr[-1]:
-                        j += 1
-                        groupstr = '.'.join(groups[i:j])
-                    groups[i] = groupstr[1:-1]
-                    groups[i + 1:j] = []
-                else:
-                    if not _groupname_re.match(groups[i]):
-                        raise TomlDecodeError("Invalid group name '" +
-                                              groups[i] + "'. Try quoting it.")
-                i += 1
-            currentlevel = retval
-            for i in _range(len(groups)):
-                group = groups[i]
-                if group == "":
-                    raise TomlDecodeError("Can't have a keygroup with an empty "
-                                          "name")
-                try:
-                    currentlevel[group]
-                    if i == len(groups) - 1:
-                        if group in implicitgroups:
-                            implicitgroups.remove(group)
-                            if arrayoftables:
-                                raise TomlDecodeError("An implicitly defined "
-                                                      "table can't be an array")
-                        elif arrayoftables:
-                            currentlevel[group].append(_dict())
-                        else:
-                            raise TomlDecodeError("What? " + group +
-                                                  " already exists?" +
-                                                  str(currentlevel))
-                except TypeError:
-                    currentlevel = currentlevel[-1]
-                    try:
-                        currentlevel[group]
-                    except KeyError:
-                        currentlevel[group] = _dict()
-                        if i == len(groups) - 1 and arrayoftables:
-                            currentlevel[group] = [_dict()]
-                except KeyError:
-                    if i != len(groups) - 1:
-                        implicitgroups.append(group)
-                    currentlevel[group] = _dict()
-                    if i == len(groups) - 1 and arrayoftables:
-                        currentlevel[group] = [_dict()]
-                currentlevel = currentlevel[group]
-                if arrayoftables:
-                    try:
-                        currentlevel = currentlevel[-1]
-                    except KeyError:
-                        pass
-        elif line[0] == "{":
-            if line[-1] != "}":
-                raise TomlDecodeError("Line breaks are not allowed in inline"
-                                      "objects")
-            _load_inline_object(line, currentlevel, _dict, multikey,
-                                multibackslash)
-        elif "=" in line:
-            ret = _load_line(line, currentlevel, _dict, multikey,
-                             multibackslash)
-            if ret is not None:
-                multikey, multilinestr, multibackslash = ret
-    return retval
-
-
-def _load_inline_object(line, currentlevel, _dict, multikey=False,
-                        multibackslash=False):
-    candidate_groups = line[1:-1].split(",")
-    groups = []
-    if len(candidate_groups) == 1 and not candidate_groups[0].strip():
-        candidate_groups.pop()
-    while len(candidate_groups) > 0:
-        candidate_group = candidate_groups.pop(0)
-        try:
-            _, value = candidate_group.split('=', 1)
-        except ValueError:
-            raise TomlDecodeError("Invalid inline table encountered")
-        value = value.strip()
-        if ((value[0] == value[-1] and value[0] in ('"', "'")) or (
-                value[0] in '-0123456789' or
-                value in ('true', 'false') or
-                (value[0] == "[" and value[-1] == "]"))):
-            groups.append(candidate_group)
-        else:
-            candidate_groups[0] = candidate_group + "," + candidate_groups[0]
-    for group in groups:
-        status = _load_line(group, currentlevel, _dict, multikey,
-                            multibackslash)
-        if status is not None:
-            break
-
-
-# Matches a TOML number, which allows underscores for readability
-_number_with_underscores = re.compile('([0-9])(_([0-9]))*')
-
-
-def _strictly_valid_num(n):
-    n = n.strip()
-    if not n:
-        return False
-    if n[0] == '_':
-        return False
-    if n[-1] == '_':
-        return False
-    if "_." in n or "._" in n:
-        return False
-    if len(n) == 1:
-        return True
-    if n[0] == '0' and n[1] != '.':
-        return False
-    if n[0] == '+' or n[0] == '-':
-        n = n[1:]
-        if n[0] == '0' and n[1] != '.':
-            return False
-    if '__' in n:
-        return False
-    return True
-
-
-def _load_line(line, currentlevel, _dict, multikey, multibackslash):
-    i = 1
-    pair = line.split('=', i)
-    strictly_valid = _strictly_valid_num(pair[-1])
-    if _number_with_underscores.match(pair[-1]):
-        pair[-1] = pair[-1].replace('_', '')
-    while len(pair[-1]) and (pair[-1][0] != ' ' and pair[-1][0] != '\t' and
-                             pair[-1][0] != "'" and pair[-1][0] != '"' and
-                             pair[-1][0] != '[' and pair[-1][0] != '{' and
-                             pair[-1] != 'true' and pair[-1] != 'false'):
-        try:
-            float(pair[-1])
-            break
-        except ValueError:
-            pass
-        if _load_date(pair[-1]) is not None:
-            break
-        i += 1
-        prev_val = pair[-1]
-        pair = line.split('=', i)
-        if prev_val == pair[-1]:
-            raise TomlDecodeError("Invalid date or number")
-        if strictly_valid:
-            strictly_valid = _strictly_valid_num(pair[-1])
-    pair = ['='.join(pair[:-1]).strip(), pair[-1].strip()]
-    if (pair[0][0] == '"' or pair[0][0] == "'") and \
-            (pair[0][-1] == '"' or pair[0][-1] == "'"):
-        pair[0] = pair[0][1:-1]
-    if len(pair[1]) > 2 and ((pair[1][0] == '"' or pair[1][0] == "'") and
-                             pair[1][1] == pair[1][0] and
-                             pair[1][2] == pair[1][0] and
-                             not (len(pair[1]) > 5 and
-                                  pair[1][-1] == pair[1][0] and
-                                  pair[1][-2] == pair[1][0] and
-                                  pair[1][-3] == pair[1][0])):
-        k = len(pair[1]) - 1
-        while k > -1 and pair[1][k] == '\\':
-            multibackslash = not multibackslash
-            k -= 1
-        if multibackslash:
-            multilinestr = pair[1][:-1]
-        else:
-            multilinestr = pair[1] + "\n"
-        multikey = pair[0]
-    else:
-        value, vtype = _load_value(pair[1], _dict, strictly_valid)
-    try:
-        currentlevel[pair[0]]
-        raise TomlDecodeError("Duplicate keys!")
-    except KeyError:
-        if multikey:
-            return multikey, multilinestr, multibackslash
-        else:
-            currentlevel[pair[0]] = value
-
-
-def _load_date(val):
-    microsecond = 0
-    tz = None
-    try:
-        if len(val) > 19:
-            if val[19] == '.':
-                microsecond = int(val[20:26])
-                if len(val) > 26:
-                    tz = TomlTz(val[26:32])
-            else:
-                tz = TomlTz(val[19:25])
-    except ValueError:
-        tz = None
-    try:
-        d = datetime.datetime(
-            int(val[:4]), int(val[5:7]),
-            int(val[8:10]), int(val[11:13]),
-            int(val[14:16]), int(val[17:19]), microsecond, tz)
-    except ValueError:
-        return None
-    return d
-
-
-def _load_unicode_escapes(v, hexbytes, prefix):
-    hexchars = ['0', '1', '2', '3', '4', '5', '6', '7',
-                '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']
-    skip = False
-    i = len(v) - 1
-    while i > -1 and v[i] == '\\':
-        skip = not skip
-        i -= 1
-    for hx in hexbytes:
-        if skip:
-            skip = False
-            i = len(hx) - 1
-            while i > -1 and hx[i] == '\\':
-                skip = not skip
-                i -= 1
-            v += prefix
-            v += hx
-            continue
-        hxb = ""
-        i = 0
-        hxblen = 4
-        if prefix == "\\U":
-            hxblen = 8
-        while i < hxblen:
-            try:
-                if not hx[i].lower() in hexchars:
-                    raise IndexError("This is a hack")
-            except IndexError:
-                raise TomlDecodeError("Invalid escape sequence")
-            hxb += hx[i].lower()
-            i += 1
-        v += unichr(int(hxb, 16))
-        v += unicode(hx[len(hxb):])
-    return v
-
-
-# Unescape TOML string values.
-
-# content after the \
-_escapes = ['0', 'b', 'f', 'n', 'r', 't', '"']
-# What it should be replaced by
-_escapedchars = ['\0', '\b', '\f', '\n', '\r', '\t', '\"']
-# Used for substitution
-_escape_to_escapedchars = dict(zip(_escapes, _escapedchars))
-
-
-def _unescape(v):
-    """Unescape characters in a TOML string."""
-    i = 0
-    backslash = False
-    while i < len(v):
-        if backslash:
-            backslash = False
-            if v[i] in _escapes:
-                v = v[:i - 1] + _escape_to_escapedchars[v[i]] + v[i + 1:]
-            elif v[i] == '\\':
-                v = v[:i - 1] + v[i:]
-            elif v[i] == 'u' or v[i] == 'U':
-                i += 1
-            else:
-                raise TomlDecodeError("Reserved escape sequence used")
-            continue
-        elif v[i] == '\\':
-            backslash = True
-        i += 1
-    return v
-
-
-def _load_value(v, _dict, strictly_valid=True):
-    if not v:
-        raise TomlDecodeError("Empty value is invalid")
-    if v == 'true':
-        return (True, "bool")
-    elif v == 'false':
-        return (False, "bool")
-    elif v[0] == '"':
-        testv = v[1:].split('"')
-        if testv[0] == '' and testv[1] == '':
-            testv = testv[2:-2]
-        closed = False
-        for tv in testv:
-            if tv == '':
-                closed = True
-            else:
-                oddbackslash = False
-                try:
-                    i = -1
-                    j = tv[i]
-                    while j == '\\':
-                        oddbackslash = not oddbackslash
-                        i -= 1
-                        j = tv[i]
-                except IndexError:
-                    pass
-                if not oddbackslash:
-                    if closed:
-                        raise TomlDecodeError("Stuff after closed string. WTF?")
-                    else:
-                        closed = True
-        escapeseqs = v.split('\\')[1:]
-        backslash = False
-        for i in escapeseqs:
-            if i == '':
-                backslash = not backslash
-            else:
-                if i[0] not in _escapes and (i[0] != 'u' and i[0] != 'U' and
-                                             not backslash):
-                    raise TomlDecodeError("Reserved escape sequence used")
-                if backslash:
-                    backslash = False
-        for prefix in ["\\u", "\\U"]:
-            if prefix in v:
-                hexbytes = v.split(prefix)
-                v = _load_unicode_escapes(hexbytes[0], hexbytes[1:], prefix)
-        v = _unescape(v)
-        if v[1] == '"' and (len(v) < 3 or v[1] == v[2]):
-            v = v[2:-2]
-        return (v[1:-1], "str")
-    elif v[0] == "'":
-        if v[1] == "'" and (len(v) < 3 or v[1] == v[2]):
-            v = v[2:-2]
-        return (v[1:-1], "str")
-    elif v[0] == '[':
-        return (_load_array(v, _dict), "array")
-    elif v[0] == '{':
-        inline_object = _get_empty_inline_table(_dict)
-        _load_inline_object(v, inline_object, _dict)
-        return (inline_object, "inline_object")
-    else:
-        parsed_date = _load_date(v)
-        if parsed_date is not None:
-            return (parsed_date, "date")
-        if not strictly_valid:
-            raise TomlDecodeError("Weirdness with leading zeroes or underscores"
-                                  " in your number.")
-        itype = "int"
-        neg = False
-        if v[0] == '-':
-            neg = True
-            v = v[1:]
-        elif v[0] == '+':
-            v = v[1:]
-        v = v.replace('_', '')
-        if '.' in v or 'e' in v or 'E' in v:
-            if '.' in v and v.split('.', 1)[1] == '':
-                raise TomlDecodeError("This float is missing digits after "
-                                      "the point")
-            if v[0] not in '0123456789':
-                raise TomlDecodeError("This float doesn't have a leading digit")
-            v = float(v)
-            itype = "float"
-        else:
-            v = int(v)
-        if neg:
-            return (0 - v, itype)
-        return (v, itype)
-
-
-def _load_array(a, _dict):
-    atype = None
-    retval = []
-    a = a.strip()
-    if '[' not in a[1:-1] or "" != a[1:-1].split('[')[0].strip():
-        strarray = False
-        tmpa = a[1:-1].strip()
-        if tmpa != '' and (tmpa[0] == '"' or tmpa[0] == "'"):
-            strarray = True
-        if not a[1:-1].strip().startswith('{'):
-            a = a[1:-1].split(',')
-        else:
-            # a is an inline object, we must find the matching parenthesis
-            # to define groups
-            new_a = []
-            start_group_index = 1
-            end_group_index = 2
-            in_str = False
-            while end_group_index < len(a[1:]):
-                if a[end_group_index] == '"' or a[end_group_index] == "'":
-                    in_str = not in_str
-                if in_str or a[end_group_index] != '}':
-                    end_group_index += 1
-                    continue
-
-                # Increase end_group_index by 1 to get the closing bracket
-                end_group_index += 1
-                new_a.append(a[start_group_index:end_group_index])
-
-                # The next start index is at least after the closing bracket, a
-                # closing bracket can be followed by a comma since we are in
-                # an array.
-                start_group_index = end_group_index + 1
-                while (start_group_index < len(a[1:]) and
-                       a[start_group_index] != '{'):
-                    start_group_index += 1
-                end_group_index = start_group_index + 1
-            a = new_a
-        b = 0
-        if strarray:
-            while b < len(a) - 1:
-                ab = a[b].strip()
-                while ab[-1] != ab[0] or (len(ab) > 2 and
-                                          ab[0] == ab[1] == ab[2] and
-                                          ab[-2] != ab[0] and ab[-3] != ab[0]):
-                    a[b] = a[b] + ',' + a[b + 1]
-                    ab = a[b].strip()
-                    if b < len(a) - 2:
-                        a = a[:b + 1] + a[b + 2:]
-                    else:
-                        a = a[:b + 1]
-                b += 1
-    else:
-        al = list(a[1:-1])
-        a = []
-        openarr = 0
-        j = 0
-        for i in _range(len(al)):
-            if al[i] == '[':
-                openarr += 1
-            elif al[i] == ']':
-                openarr -= 1
-            elif al[i] == ',' and not openarr:
-                a.append(''.join(al[j:i]))
-                j = i + 1
-        a.append(''.join(al[j:]))
-    for i in _range(len(a)):
-        a[i] = a[i].strip()
-        if a[i] != '':
-            nval, ntype = _load_value(a[i], _dict)
-            if atype:
-                if ntype != atype:
-                    raise TomlDecodeError("Not a homogeneous array")
-            else:
-                atype = ntype
-            retval.append(nval)
-    return retval
-
-
-def dump(o, f):
-    """Writes out dict as toml to a file
-
-    Args:
-        o: Object to dump into toml
-        f: File descriptor where the toml should be stored
-
-    Returns:
-        String containing the toml corresponding to dictionary
-
-    Raises:
-        TypeError: When anything other than file descriptor is passed
-    """
-
-    if not f.write:
-        raise TypeError("You can only dump an object to a file descriptor")
-    d = dumps(o)
-    f.write(d)
-    return d
-
-
-def dumps(o, preserve=False):
-    """Stringifies input dict as toml
-
-    Args:
-        o: Object to dump into toml
-
-        preserve: Boolean parameter. If true, preserve inline tables.
-
-    Returns:
-        String containing the toml corresponding to dict
-    """
-
-    retval = ""
-    addtoretval, sections = _dump_sections(o, "")
-    retval += addtoretval
-    while sections != {}:
-        newsections = {}
-        for section in sections:
-            addtoretval, addtosections = _dump_sections(sections[section],
-                                                        section, preserve)
-            if addtoretval or (not addtoretval and not addtosections):
-                if retval and retval[-2:] != "\n\n":
-                    retval += "\n"
-                retval += "[" + section + "]\n"
-                if addtoretval:
-                    retval += addtoretval
-            for s in addtosections:
-                newsections[section + "." + s] = addtosections[s]
-        sections = newsections
-    return retval
-
-
-def _dump_sections(o, sup, preserve=False):
-    retstr = ""
-    if sup != "" and sup[-1] != ".":
-        sup += '.'
-    retdict = o.__class__()
-    arraystr = ""
-    for section in o:
-        section = unicode(section)
-        qsection = section
-        if not re.match(r'^[A-Za-z0-9_-]+$', section):
-            if '"' in section:
-                qsection = "'" + section + "'"
-            else:
-                qsection = '"' + section + '"'
-        if not isinstance(o[section], dict):
-            arrayoftables = False
-            if isinstance(o[section], list):
-                for a in o[section]:
-                    if isinstance(a, dict):
-                        arrayoftables = True
-            if arrayoftables:
-                for a in o[section]:
-                    arraytabstr = "\n"
-                    arraystr += "[[" + sup + qsection + "]]\n"
-                    s, d = _dump_sections(a, sup + qsection)
-                    if s:
-                        if s[0] == "[":
-                            arraytabstr += s
-                        else:
-                            arraystr += s
-                    while d != {}:
-                        newd = {}
-                        for dsec in d:
-                            s1, d1 = _dump_sections(d[dsec], sup + qsection +
-                                                    "." + dsec)
-                            if s1:
-                                arraytabstr += ("[" + sup + qsection + "." +
-                                                dsec + "]\n")
-                                arraytabstr += s1
-                            for s1 in d1:
-                                newd[dsec + "." + s1] = d1[s1]
-                        d = newd
-                    arraystr += arraytabstr
-            else:
-                if o[section] is not None:
-                    retstr += (qsection + " = " +
-                               unicode(_dump_value(o[section])) + '\n')
-        elif preserve and isinstance(o[section], InlineTableDict):
-            retstr += (qsection + " = " + _dump_inline_table(o[section]))
-        else:
-            retdict[qsection] = o[section]
-    retstr += arraystr
-    return (retstr, retdict)
-
-
-def _dump_inline_table(section):
-    """Preserve inline table in its compact syntax instead of expanding
-    into subsection.
-
-    https://github.com/toml-lang/toml#user-content-inline-table
-    """
-    retval = ""
-    if isinstance(section, dict):
-        val_list = []
-        for k, v in section.items():
-            val = _dump_inline_table(v)
-            val_list.append(k + " = " + val)
-        retval += "{ " + ", ".join(val_list) + " }\n"
-        return retval
-    else:
-        return unicode(_dump_value(section))
-
-
-def _dump_value(v):
-    dump_funcs = {
-        str: lambda: _dump_str(v),
-        unicode: lambda: _dump_str(v),
-        list: lambda: _dump_list(v),
-        bool: lambda: unicode(v).lower(),
-        float: lambda: _dump_float(v),
-        datetime.datetime: lambda: v.isoformat(),
-    }
-    # Lookup function corresponding to v's type
-    dump_fn = dump_funcs.get(type(v))
-    # Evaluate function (if it exists) else return v
-    return dump_fn() if dump_fn is not None else v
-
-
-def _dump_str(v):
-    v = "%r" % v
-    if v[0] == 'u':
-        v = v[1:]
-    singlequote = v.startswith("'")
-    v = v[1:-1]
-    if singlequote:
-        v = v.replace("\\'", "'")
-        v = v.replace('"', '\\"')
-    v = v.replace("\\x", "\\u00")
-    return unicode('"' + v + '"')
-
-
-def _dump_list(v):
-    t = []
-    retval = "["
-    for u in v:
-        t.append(_dump_value(u))
-    while t != []:
-        s = []
-        for u in t:
-            if isinstance(u, list):
-                for r in u:
-                    s.append(r)
-            else:
-                retval += " " + unicode(u) + ","
-        t = s
-    retval += "]"
-    return retval
-
-
-def _dump_float(v):
-    return "{0:.16}".format(v).replace("e+0", "e+").replace("e-0", "e-")
diff --git a/pipenv/vendor/toml.LICENSE b/pipenv/vendor/toml/LICENSE
similarity index 97%
rename from pipenv/vendor/toml.LICENSE
rename to pipenv/vendor/toml/LICENSE
index d8b406c9..08e981ff 100644
--- a/pipenv/vendor/toml.LICENSE
+++ b/pipenv/vendor/toml/LICENSE
@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright 2013-2017 Uiri Noyb
+Copyright 2013-2018 William Pearson
 Copyright 2015-2016 Julien Enselme
 Copyright 2016 Google Inc.
 Copyright 2017 Samuel Vasko
diff --git a/pipenv/vendor/toml/__init__.py b/pipenv/vendor/toml/__init__.py
new file mode 100644
index 00000000..e436b271
--- /dev/null
+++ b/pipenv/vendor/toml/__init__.py
@@ -0,0 +1,21 @@
+"""Python module which parses and emits TOML.
+
+Released under the MIT license.
+"""
+
+from toml import encoder
+from toml import decoder
+
+__version__ = "0.10.0"
+_spec_ = "0.5.0"
+
+load = decoder.load
+loads = decoder.loads
+TomlDecoder = decoder.TomlDecoder
+TomlDecodeError = decoder.TomlDecodeError
+
+dump = encoder.dump
+dumps = encoder.dumps
+TomlEncoder = encoder.TomlEncoder
+TomlArraySeparatorEncoder = encoder.TomlArraySeparatorEncoder
+TomlPreserveInlineDictEncoder = encoder.TomlPreserveInlineDictEncoder
diff --git a/pipenv/vendor/toml/decoder.py b/pipenv/vendor/toml/decoder.py
new file mode 100644
index 00000000..4d468dd4
--- /dev/null
+++ b/pipenv/vendor/toml/decoder.py
@@ -0,0 +1,945 @@
+import datetime
+import io
+from os import linesep
+import re
+import sys
+
+from toml.tz import TomlTz
+
+if sys.version_info < (3,):
+    _range = xrange  # noqa: F821
+else:
+    unicode = str
+    _range = range
+    basestring = str
+    unichr = chr
+
+
+def _detect_pathlib_path(p):
+    if (3, 4) <= sys.version_info:
+        import pathlib
+        if isinstance(p, pathlib.PurePath):
+            return True
+    return False
+
+
+def _ispath(p):
+    if isinstance(p, basestring):
+        return True
+    return _detect_pathlib_path(p)
+
+
+def _getpath(p):
+    if (3, 6) <= sys.version_info:
+        import os
+        return os.fspath(p)
+    if _detect_pathlib_path(p):
+        return str(p)
+    return p
+
+
+try:
+    FNFError = FileNotFoundError
+except NameError:
+    FNFError = IOError
+
+
+TIME_RE = re.compile("([0-9]{2}):([0-9]{2}):([0-9]{2})(\.([0-9]{3,6}))?")
+
+
+class TomlDecodeError(ValueError):
+    """Base toml Exception / Error."""
+
+    def __init__(self, msg, doc, pos):
+        lineno = doc.count('\n', 0, pos) + 1
+        colno = pos - doc.rfind('\n', 0, pos)
+        emsg = '{} (line {} column {} char {})'.format(msg, lineno, colno, pos)
+        ValueError.__init__(self, emsg)
+        self.msg = msg
+        self.doc = doc
+        self.pos = pos
+        self.lineno = lineno
+        self.colno = colno
+
+
+# Matches a TOML number, which allows underscores for readability
+_number_with_underscores = re.compile('([0-9])(_([0-9]))*')
+
+
+def _strictly_valid_num(n):
+    n = n.strip()
+    if not n:
+        return False
+    if n[0] == '_':
+        return False
+    if n[-1] == '_':
+        return False
+    if "_." in n or "._" in n:
+        return False
+    if len(n) == 1:
+        return True
+    if n[0] == '0' and n[1] not in ['.', 'o', 'b', 'x']:
+        return False
+    if n[0] == '+' or n[0] == '-':
+        n = n[1:]
+        if len(n) > 1 and n[0] == '0' and n[1] != '.':
+            return False
+    if '__' in n:
+        return False
+    return True
+
+
+def load(f, _dict=dict, decoder=None):
+    """Parses named file or files as toml and returns a dictionary
+
+    Args:
+        f: Path to the file to open, array of files to read into single dict
+           or a file descriptor
+        _dict: (optional) Specifies the class of the returned toml dictionary
+
+    Returns:
+        Parsed toml file represented as a dictionary
+
+    Raises:
+        TypeError -- When f is invalid type
+        TomlDecodeError: Error while decoding toml
+        IOError / FileNotFoundError -- When an array with no valid (existing)
+        (Python 2 / Python 3)          file paths is passed
+    """
+
+    if _ispath(f):
+        with io.open(_getpath(f), encoding='utf-8') as ffile:
+            return loads(ffile.read(), _dict, decoder)
+    elif isinstance(f, list):
+        from os import path as op
+        from warnings import warn
+        if not [path for path in f if op.exists(path)]:
+            error_msg = "Load expects a list to contain filenames only."
+            error_msg += linesep
+            error_msg += ("The list needs to contain the path of at least one "
+                          "existing file.")
+            raise FNFError(error_msg)
+        if decoder is None:
+            decoder = TomlDecoder()
+        d = decoder.get_empty_table()
+        for l in f:
+            if op.exists(l):
+                d.update(load(l, _dict, decoder))
+            else:
+                warn("Non-existent filename in list with at least one valid "
+                     "filename")
+        return d
+    else:
+        try:
+            return loads(f.read(), _dict, decoder)
+        except AttributeError:
+            raise TypeError("You can only load a file descriptor, filename or "
+                            "list")
+
+
+_groupname_re = re.compile(r'^[A-Za-z0-9_-]+$')
+
+
+def loads(s, _dict=dict, decoder=None):
+    """Parses string as toml
+
+    Args:
+        s: String to be parsed
+        _dict: (optional) Specifies the class of the returned toml dictionary
+
+    Returns:
+        Parsed toml file represented as a dictionary
+
+    Raises:
+        TypeError: When a non-string is passed
+        TomlDecodeError: Error while decoding toml
+    """
+
+    implicitgroups = []
+    if decoder is None:
+        decoder = TomlDecoder(_dict)
+    retval = decoder.get_empty_table()
+    currentlevel = retval
+    if not isinstance(s, basestring):
+        raise TypeError("Expecting something like a string")
+
+    if not isinstance(s, unicode):
+        s = s.decode('utf8')
+
+    original = s
+    sl = list(s)
+    openarr = 0
+    openstring = False
+    openstrchar = ""
+    multilinestr = False
+    arrayoftables = False
+    beginline = True
+    keygroup = False
+    dottedkey = False
+    keyname = 0
+    for i, item in enumerate(sl):
+        if item == '\r' and sl[i + 1] == '\n':
+            sl[i] = ' '
+            continue
+        if keyname:
+            if item == '\n':
+                raise TomlDecodeError("Key name found without value."
+                                      " Reached end of line.", original, i)
+            if openstring:
+                if item == openstrchar:
+                    keyname = 2
+                    openstring = False
+                    openstrchar = ""
+                continue
+            elif keyname == 1:
+                if item.isspace():
+                    keyname = 2
+                    continue
+                elif item == '.':
+                    dottedkey = True
+                    continue
+                elif item.isalnum() or item == '_' or item == '-':
+                    continue
+                elif (dottedkey and sl[i - 1] == '.' and
+                      (item == '"' or item == "'")):
+                    openstring = True
+                    openstrchar = item
+                    continue
+            elif keyname == 2:
+                if item.isspace():
+                    if dottedkey:
+                        nextitem = sl[i + 1]
+                        if not nextitem.isspace() and nextitem != '.':
+                            keyname = 1
+                    continue
+                if item == '.':
+                    dottedkey = True
+                    nextitem = sl[i + 1]
+                    if not nextitem.isspace() and nextitem != '.':
+                        keyname = 1
+                    continue
+            if item == '=':
+                keyname = 0
+                dottedkey = False
+            else:
+                raise TomlDecodeError("Found invalid character in key name: '" +
+                                      item + "'. Try quoting the key name.",
+                                      original, i)
+        if item == "'" and openstrchar != '"':
+            k = 1
+            try:
+                while sl[i - k] == "'":
+                    k += 1
+                    if k == 3:
+                        break
+            except IndexError:
+                pass
+            if k == 3:
+                multilinestr = not multilinestr
+                openstring = multilinestr
+            else:
+                openstring = not openstring
+            if openstring:
+                openstrchar = "'"
+            else:
+                openstrchar = ""
+        if item == '"' and openstrchar != "'":
+            oddbackslash = False
+            k = 1
+            tripquote = False
+            try:
+                while sl[i - k] == '"':
+                    k += 1
+                    if k == 3:
+                        tripquote = True
+                        break
+                if k == 1 or (k == 3 and tripquote):
+                    while sl[i - k] == '\\':
+                        oddbackslash = not oddbackslash
+                        k += 1
+            except IndexError:
+                pass
+            if not oddbackslash:
+                if tripquote:
+                    multilinestr = not multilinestr
+                    openstring = multilinestr
+                else:
+                    openstring = not openstring
+            if openstring:
+                openstrchar = '"'
+            else:
+                openstrchar = ""
+        if item == '#' and (not openstring and not keygroup and
+                            not arrayoftables):
+            j = i
+            try:
+                while sl[j] != '\n':
+                    sl[j] = ' '
+                    j += 1
+            except IndexError:
+                break
+        if item == '[' and (not openstring and not keygroup and
+                            not arrayoftables):
+            if beginline:
+                if len(sl) > i + 1 and sl[i + 1] == '[':
+                    arrayoftables = True
+                else:
+                    keygroup = True
+            else:
+                openarr += 1
+        if item == ']' and not openstring:
+            if keygroup:
+                keygroup = False
+            elif arrayoftables:
+                if sl[i - 1] == ']':
+                    arrayoftables = False
+            else:
+                openarr -= 1
+        if item == '\n':
+            if openstring or multilinestr:
+                if not multilinestr:
+                    raise TomlDecodeError("Unbalanced quotes", original, i)
+                if ((sl[i - 1] == "'" or sl[i - 1] == '"') and (
+                        sl[i - 2] == sl[i - 1])):
+                    sl[i] = sl[i - 1]
+                    if sl[i - 3] == sl[i - 1]:
+                        sl[i - 3] = ' '
+            elif openarr:
+                sl[i] = ' '
+            else:
+                beginline = True
+        elif beginline and sl[i] != ' ' and sl[i] != '\t':
+            beginline = False
+            if not keygroup and not arrayoftables:
+                if sl[i] == '=':
+                    raise TomlDecodeError("Found empty keyname. ", original, i)
+                keyname = 1
+    s = ''.join(sl)
+    s = s.split('\n')
+    multikey = None
+    multilinestr = ""
+    multibackslash = False
+    pos = 0
+    for idx, line in enumerate(s):
+        if idx > 0:
+            pos += len(s[idx - 1]) + 1
+        if not multilinestr or multibackslash or '\n' not in multilinestr:
+            line = line.strip()
+        if line == "" and (not multikey or multibackslash):
+            continue
+        if multikey:
+            if multibackslash:
+                multilinestr += line
+            else:
+                multilinestr += line
+            multibackslash = False
+            if len(line) > 2 and (line[-1] == multilinestr[0] and
+                                  line[-2] == multilinestr[0] and
+                                  line[-3] == multilinestr[0]):
+                try:
+                    value, vtype = decoder.load_value(multilinestr)
+                except ValueError as err:
+                    raise TomlDecodeError(str(err), original, pos)
+                currentlevel[multikey] = value
+                multikey = None
+                multilinestr = ""
+            else:
+                k = len(multilinestr) - 1
+                while k > -1 and multilinestr[k] == '\\':
+                    multibackslash = not multibackslash
+                    k -= 1
+                if multibackslash:
+                    multilinestr = multilinestr[:-1]
+                else:
+                    multilinestr += "\n"
+            continue
+        if line[0] == '[':
+            arrayoftables = False
+            if len(line) == 1:
+                raise TomlDecodeError("Opening key group bracket on line by "
+                                      "itself.", original, pos)
+            if line[1] == '[':
+                arrayoftables = True
+                line = line[2:]
+                splitstr = ']]'
+            else:
+                line = line[1:]
+                splitstr = ']'
+            i = 1
+            quotesplits = decoder._get_split_on_quotes(line)
+            quoted = False
+            for quotesplit in quotesplits:
+                if not quoted and splitstr in quotesplit:
+                    break
+                i += quotesplit.count(splitstr)
+                quoted = not quoted
+            line = line.split(splitstr, i)
+            if len(line) < i + 1 or line[-1].strip() != "":
+                raise TomlDecodeError("Key group not on a line by itself.",
+                                      original, pos)
+            groups = splitstr.join(line[:-1]).split('.')
+            i = 0
+            while i < len(groups):
+                groups[i] = groups[i].strip()
+                if len(groups[i]) > 0 and (groups[i][0] == '"' or
+                                           groups[i][0] == "'"):
+                    groupstr = groups[i]
+                    j = i + 1
+                    while not groupstr[0] == groupstr[-1]:
+                        j += 1
+                        if j > len(groups) + 2:
+                            raise TomlDecodeError("Invalid group name '" +
+                                                  groupstr + "' Something " +
+                                                  "went wrong.", original, pos)
+                        groupstr = '.'.join(groups[i:j]).strip()
+                    groups[i] = groupstr[1:-1]
+                    groups[i + 1:j] = []
+                else:
+                    if not _groupname_re.match(groups[i]):
+                        raise TomlDecodeError("Invalid group name '" +
+                                              groups[i] + "'. Try quoting it.",
+                                              original, pos)
+                i += 1
+            currentlevel = retval
+            for i in _range(len(groups)):
+                group = groups[i]
+                if group == "":
+                    raise TomlDecodeError("Can't have a keygroup with an empty "
+                                          "name", original, pos)
+                try:
+                    currentlevel[group]
+                    if i == len(groups) - 1:
+                        if group in implicitgroups:
+                            implicitgroups.remove(group)
+                            if arrayoftables:
+                                raise TomlDecodeError("An implicitly defined "
+                                                      "table can't be an array",
+                                                      original, pos)
+                        elif arrayoftables:
+                            currentlevel[group].append(decoder.get_empty_table()
+                                                       )
+                        else:
+                            raise TomlDecodeError("What? " + group +
+                                                  " already exists?" +
+                                                  str(currentlevel),
+                                                  original, pos)
+                except TypeError:
+                    currentlevel = currentlevel[-1]
+                    if group not in currentlevel:
+                        currentlevel[group] = decoder.get_empty_table()
+                        if i == len(groups) - 1 and arrayoftables:
+                            currentlevel[group] = [decoder.get_empty_table()]
+                except KeyError:
+                    if i != len(groups) - 1:
+                        implicitgroups.append(group)
+                    currentlevel[group] = decoder.get_empty_table()
+                    if i == len(groups) - 1 and arrayoftables:
+                        currentlevel[group] = [decoder.get_empty_table()]
+                currentlevel = currentlevel[group]
+                if arrayoftables:
+                    try:
+                        currentlevel = currentlevel[-1]
+                    except KeyError:
+                        pass
+        elif line[0] == "{":
+            if line[-1] != "}":
+                raise TomlDecodeError("Line breaks are not allowed in inline"
+                                      "objects", original, pos)
+            try:
+                decoder.load_inline_object(line, currentlevel, multikey,
+                                           multibackslash)
+            except ValueError as err:
+                raise TomlDecodeError(str(err), original, pos)
+        elif "=" in line:
+            try:
+                ret = decoder.load_line(line, currentlevel, multikey,
+                                        multibackslash)
+            except ValueError as err:
+                raise TomlDecodeError(str(err), original, pos)
+            if ret is not None:
+                multikey, multilinestr, multibackslash = ret
+    return retval
+
+
+def _load_date(val):
+    microsecond = 0
+    tz = None
+    try:
+        if len(val) > 19:
+            if val[19] == '.':
+                if val[-1].upper() == 'Z':
+                    subsecondval = val[20:-1]
+                    tzval = "Z"
+                else:
+                    subsecondvalandtz = val[20:]
+                    if '+' in subsecondvalandtz:
+                        splitpoint = subsecondvalandtz.index('+')
+                        subsecondval = subsecondvalandtz[:splitpoint]
+                        tzval = subsecondvalandtz[splitpoint:]
+                    elif '-' in subsecondvalandtz:
+                        splitpoint = subsecondvalandtz.index('-')
+                        subsecondval = subsecondvalandtz[:splitpoint]
+                        tzval = subsecondvalandtz[splitpoint:]
+                    else:
+                        tzval = None
+                        subsecondval = subsecondvalandtz
+                if tzval is not None:
+                    tz = TomlTz(tzval)
+                microsecond = int(int(subsecondval) *
+                                  (10 ** (6 - len(subsecondval))))
+            else:
+                tz = TomlTz(val[19:])
+    except ValueError:
+        tz = None
+    if "-" not in val[1:]:
+        return None
+    try:
+        if len(val) == 10:
+            d = datetime.date(
+                int(val[:4]), int(val[5:7]),
+                int(val[8:10]))
+        else:
+            d = datetime.datetime(
+                int(val[:4]), int(val[5:7]),
+                int(val[8:10]), int(val[11:13]),
+                int(val[14:16]), int(val[17:19]), microsecond, tz)
+    except ValueError:
+        return None
+    return d
+
+
+def _load_unicode_escapes(v, hexbytes, prefix):
+    skip = False
+    i = len(v) - 1
+    while i > -1 and v[i] == '\\':
+        skip = not skip
+        i -= 1
+    for hx in hexbytes:
+        if skip:
+            skip = False
+            i = len(hx) - 1
+            while i > -1 and hx[i] == '\\':
+                skip = not skip
+                i -= 1
+            v += prefix
+            v += hx
+            continue
+        hxb = ""
+        i = 0
+        hxblen = 4
+        if prefix == "\\U":
+            hxblen = 8
+        hxb = ''.join(hx[i:i + hxblen]).lower()
+        if hxb.strip('0123456789abcdef'):
+            raise ValueError("Invalid escape sequence: " + hxb)
+        if hxb[0] == "d" and hxb[1].strip('01234567'):
+            raise ValueError("Invalid escape sequence: " + hxb +
+                             ". Only scalar unicode points are allowed.")
+        v += unichr(int(hxb, 16))
+        v += unicode(hx[len(hxb):])
+    return v
+
+
+# Unescape TOML string values.
+
+# content after the \
+_escapes = ['0', 'b', 'f', 'n', 'r', 't', '"']
+# What it should be replaced by
+_escapedchars = ['\0', '\b', '\f', '\n', '\r', '\t', '\"']
+# Used for substitution
+_escape_to_escapedchars = dict(zip(_escapes, _escapedchars))
+
+
+def _unescape(v):
+    """Unescape characters in a TOML string."""
+    i = 0
+    backslash = False
+    while i < len(v):
+        if backslash:
+            backslash = False
+            if v[i] in _escapes:
+                v = v[:i - 1] + _escape_to_escapedchars[v[i]] + v[i + 1:]
+            elif v[i] == '\\':
+                v = v[:i - 1] + v[i:]
+            elif v[i] == 'u' or v[i] == 'U':
+                i += 1
+            else:
+                raise ValueError("Reserved escape sequence used")
+            continue
+        elif v[i] == '\\':
+            backslash = True
+        i += 1
+    return v
+
+
+class InlineTableDict(object):
+    """Sentinel subclass of dict for inline tables."""
+
+
+class TomlDecoder(object):
+
+    def __init__(self, _dict=dict):
+        self._dict = _dict
+
+    def get_empty_table(self):
+        return self._dict()
+
+    def get_empty_inline_table(self):
+        class DynamicInlineTableDict(self._dict, InlineTableDict):
+            """Concrete sentinel subclass for inline tables.
+            It is a subclass of _dict which is passed in dynamically at load
+            time
+
+            It is also a subclass of InlineTableDict
+            """
+
+        return DynamicInlineTableDict()
+
+    def load_inline_object(self, line, currentlevel, multikey=False,
+                           multibackslash=False):
+        candidate_groups = line[1:-1].split(",")
+        groups = []
+        if len(candidate_groups) == 1 and not candidate_groups[0].strip():
+            candidate_groups.pop()
+        while len(candidate_groups) > 0:
+            candidate_group = candidate_groups.pop(0)
+            try:
+                _, value = candidate_group.split('=', 1)
+            except ValueError:
+                raise ValueError("Invalid inline table encountered")
+            value = value.strip()
+            if ((value[0] == value[-1] and value[0] in ('"', "'")) or (
+                    value[0] in '-0123456789' or
+                    value in ('true', 'false') or
+                    (value[0] == "[" and value[-1] == "]") or
+                    (value[0] == '{' and value[-1] == '}'))):
+                groups.append(candidate_group)
+            elif len(candidate_groups) > 0:
+                candidate_groups[0] = (candidate_group + "," +
+                                       candidate_groups[0])
+            else:
+                raise ValueError("Invalid inline table value encountered")
+        for group in groups:
+            status = self.load_line(group, currentlevel, multikey,
+                                    multibackslash)
+            if status is not None:
+                break
+
+    def _get_split_on_quotes(self, line):
+        doublequotesplits = line.split('"')
+        quoted = False
+        quotesplits = []
+        if len(doublequotesplits) > 1 and "'" in doublequotesplits[0]:
+            singlequotesplits = doublequotesplits[0].split("'")
+            doublequotesplits = doublequotesplits[1:]
+            while len(singlequotesplits) % 2 == 0 and len(doublequotesplits):
+                singlequotesplits[-1] += '"' + doublequotesplits[0]
+                doublequotesplits = doublequotesplits[1:]
+                if "'" in singlequotesplits[-1]:
+                    singlequotesplits = (singlequotesplits[:-1] +
+                                         singlequotesplits[-1].split("'"))
+            quotesplits += singlequotesplits
+        for doublequotesplit in doublequotesplits:
+            if quoted:
+                quotesplits.append(doublequotesplit)
+            else:
+                quotesplits += doublequotesplit.split("'")
+                quoted = not quoted
+        return quotesplits
+
+    def load_line(self, line, currentlevel, multikey, multibackslash):
+        i = 1
+        quotesplits = self._get_split_on_quotes(line)
+        quoted = False
+        for quotesplit in quotesplits:
+            if not quoted and '=' in quotesplit:
+                break
+            i += quotesplit.count('=')
+            quoted = not quoted
+        pair = line.split('=', i)
+        strictly_valid = _strictly_valid_num(pair[-1])
+        if _number_with_underscores.match(pair[-1]):
+            pair[-1] = pair[-1].replace('_', '')
+        while len(pair[-1]) and (pair[-1][0] != ' ' and pair[-1][0] != '\t' and
+                                 pair[-1][0] != "'" and pair[-1][0] != '"' and
+                                 pair[-1][0] != '[' and pair[-1][0] != '{' and
+                                 pair[-1] != 'true' and pair[-1] != 'false'):
+            try:
+                float(pair[-1])
+                break
+            except ValueError:
+                pass
+            if _load_date(pair[-1]) is not None:
+                break
+            i += 1
+            prev_val = pair[-1]
+            pair = line.split('=', i)
+            if prev_val == pair[-1]:
+                raise ValueError("Invalid date or number")
+            if strictly_valid:
+                strictly_valid = _strictly_valid_num(pair[-1])
+        pair = ['='.join(pair[:-1]).strip(), pair[-1].strip()]
+        if '.' in pair[0]:
+            if '"' in pair[0] or "'" in pair[0]:
+                quotesplits = self._get_split_on_quotes(pair[0])
+                quoted = False
+                levels = []
+                for quotesplit in quotesplits:
+                    if quoted:
+                        levels.append(quotesplit)
+                    else:
+                        levels += [level.strip() for level in
+                                   quotesplit.split('.')]
+                    quoted = not quoted
+            else:
+                levels = pair[0].split('.')
+            while levels[-1] == "":
+                levels = levels[:-1]
+            for level in levels[:-1]:
+                if level == "":
+                    continue
+                if level not in currentlevel:
+                    currentlevel[level] = self.get_empty_table()
+                currentlevel = currentlevel[level]
+            pair[0] = levels[-1].strip()
+        elif (pair[0][0] == '"' or pair[0][0] == "'") and \
+                (pair[0][-1] == pair[0][0]):
+            pair[0] = pair[0][1:-1]
+        if len(pair[1]) > 2 and ((pair[1][0] == '"' or pair[1][0] == "'") and
+                                 pair[1][1] == pair[1][0] and
+                                 pair[1][2] == pair[1][0] and
+                                 not (len(pair[1]) > 5 and
+                                      pair[1][-1] == pair[1][0] and
+                                      pair[1][-2] == pair[1][0] and
+                                      pair[1][-3] == pair[1][0])):
+            k = len(pair[1]) - 1
+            while k > -1 and pair[1][k] == '\\':
+                multibackslash = not multibackslash
+                k -= 1
+            if multibackslash:
+                multilinestr = pair[1][:-1]
+            else:
+                multilinestr = pair[1] + "\n"
+            multikey = pair[0]
+        else:
+            value, vtype = self.load_value(pair[1], strictly_valid)
+        try:
+            currentlevel[pair[0]]
+            raise ValueError("Duplicate keys!")
+        except TypeError:
+            raise ValueError("Duplicate keys!")
+        except KeyError:
+            if multikey:
+                return multikey, multilinestr, multibackslash
+            else:
+                currentlevel[pair[0]] = value
+
+    def load_value(self, v, strictly_valid=True):
+        if not v:
+            raise ValueError("Empty value is invalid")
+        if v == 'true':
+            return (True, "bool")
+        elif v == 'false':
+            return (False, "bool")
+        elif v[0] == '"' or v[0] == "'":
+            quotechar = v[0]
+            testv = v[1:].split(quotechar)
+            triplequote = False
+            triplequotecount = 0
+            if len(testv) > 1 and testv[0] == '' and testv[1] == '':
+                testv = testv[2:]
+                triplequote = True
+            closed = False
+            for tv in testv:
+                if tv == '':
+                    if triplequote:
+                        triplequotecount += 1
+                    else:
+                        closed = True
+                else:
+                    oddbackslash = False
+                    try:
+                        i = -1
+                        j = tv[i]
+                        while j == '\\':
+                            oddbackslash = not oddbackslash
+                            i -= 1
+                            j = tv[i]
+                    except IndexError:
+                        pass
+                    if not oddbackslash:
+                        if closed:
+                            raise ValueError("Stuff after closed string. WTF?")
+                        else:
+                            if not triplequote or triplequotecount > 1:
+                                closed = True
+                            else:
+                                triplequotecount = 0
+            if quotechar == '"':
+                escapeseqs = v.split('\\')[1:]
+                backslash = False
+                for i in escapeseqs:
+                    if i == '':
+                        backslash = not backslash
+                    else:
+                        if i[0] not in _escapes and (i[0] != 'u' and
+                                                     i[0] != 'U' and
+                                                     not backslash):
+                            raise ValueError("Reserved escape sequence used")
+                        if backslash:
+                            backslash = False
+                for prefix in ["\\u", "\\U"]:
+                    if prefix in v:
+                        hexbytes = v.split(prefix)
+                        v = _load_unicode_escapes(hexbytes[0], hexbytes[1:],
+                                                  prefix)
+                v = _unescape(v)
+            if len(v) > 1 and v[1] == quotechar and (len(v) < 3 or
+                                                     v[1] == v[2]):
+                v = v[2:-2]
+            return (v[1:-1], "str")
+        elif v[0] == '[':
+            return (self.load_array(v), "array")
+        elif v[0] == '{':
+            inline_object = self.get_empty_inline_table()
+            self.load_inline_object(v, inline_object)
+            return (inline_object, "inline_object")
+        elif TIME_RE.match(v):
+            h, m, s, _, ms = TIME_RE.match(v).groups()
+            time = datetime.time(int(h), int(m), int(s), int(ms) if ms else 0)
+            return (time, "time")
+        else:
+            parsed_date = _load_date(v)
+            if parsed_date is not None:
+                return (parsed_date, "date")
+            if not strictly_valid:
+                raise ValueError("Weirdness with leading zeroes or "
+                                 "underscores in your number.")
+            itype = "int"
+            neg = False
+            if v[0] == '-':
+                neg = True
+                v = v[1:]
+            elif v[0] == '+':
+                v = v[1:]
+            v = v.replace('_', '')
+            lowerv = v.lower()
+            if '.' in v or ('x' not in v and ('e' in v or 'E' in v)):
+                if '.' in v and v.split('.', 1)[1] == '':
+                    raise ValueError("This float is missing digits after "
+                                     "the point")
+                if v[0] not in '0123456789':
+                    raise ValueError("This float doesn't have a leading "
+                                     "digit")
+                v = float(v)
+                itype = "float"
+            elif len(lowerv) == 3 and (lowerv == 'inf' or lowerv == 'nan'):
+                v = float(v)
+                itype = "float"
+            if itype == "int":
+                v = int(v, 0)
+            if neg:
+                return (0 - v, itype)
+            return (v, itype)
+
+    def bounded_string(self, s):
+        if len(s) == 0:
+            return True
+        if s[-1] != s[0]:
+            return False
+        i = -2
+        backslash = False
+        while len(s) + i > 0:
+            if s[i] == "\\":
+                backslash = not backslash
+                i -= 1
+            else:
+                break
+        return not backslash
+
+    def load_array(self, a):
+        atype = None
+        retval = []
+        a = a.strip()
+        if '[' not in a[1:-1] or "" != a[1:-1].split('[')[0].strip():
+            strarray = False
+            tmpa = a[1:-1].strip()
+            if tmpa != '' and (tmpa[0] == '"' or tmpa[0] == "'"):
+                strarray = True
+            if not a[1:-1].strip().startswith('{'):
+                a = a[1:-1].split(',')
+            else:
+                # a is an inline object, we must find the matching parenthesis
+                # to define groups
+                new_a = []
+                start_group_index = 1
+                end_group_index = 2
+                in_str = False
+                while end_group_index < len(a[1:]):
+                    if a[end_group_index] == '"' or a[end_group_index] == "'":
+                        if in_str:
+                            backslash_index = end_group_index - 1
+                            while (backslash_index > -1 and
+                                   a[backslash_index] == '\\'):
+                                in_str = not in_str
+                                backslash_index -= 1
+                        in_str = not in_str
+                    if in_str or a[end_group_index] != '}':
+                        end_group_index += 1
+                        continue
+
+                    # Increase end_group_index by 1 to get the closing bracket
+                    end_group_index += 1
+
+                    new_a.append(a[start_group_index:end_group_index])
+
+                    # The next start index is at least after the closing
+                    # bracket, a closing bracket can be followed by a comma
+                    # since we are in an array.
+                    start_group_index = end_group_index + 1
+                    while (start_group_index < len(a[1:]) and
+                           a[start_group_index] != '{'):
+                        start_group_index += 1
+                    end_group_index = start_group_index + 1
+                a = new_a
+            b = 0
+            if strarray:
+                while b < len(a) - 1:
+                    ab = a[b].strip()
+                    while (not self.bounded_string(ab) or
+                           (len(ab) > 2 and
+                            ab[0] == ab[1] == ab[2] and
+                            ab[-2] != ab[0] and
+                            ab[-3] != ab[0])):
+                        a[b] = a[b] + ',' + a[b + 1]
+                        ab = a[b].strip()
+                        if b < len(a) - 2:
+                            a = a[:b + 1] + a[b + 2:]
+                        else:
+                            a = a[:b + 1]
+                    b += 1
+        else:
+            al = list(a[1:-1])
+            a = []
+            openarr = 0
+            j = 0
+            for i in _range(len(al)):
+                if al[i] == '[':
+                    openarr += 1
+                elif al[i] == ']':
+                    openarr -= 1
+                elif al[i] == ',' and not openarr:
+                    a.append(''.join(al[j:i]))
+                    j = i + 1
+            a.append(''.join(al[j:]))
+        for i in _range(len(a)):
+            a[i] = a[i].strip()
+            if a[i] != '':
+                nval, ntype = self.load_value(a[i])
+                if atype:
+                    if ntype != atype:
+                        raise ValueError("Not a homogeneous array")
+                else:
+                    atype = ntype
+                retval.append(nval)
+        return retval
diff --git a/pipenv/vendor/toml/encoder.py b/pipenv/vendor/toml/encoder.py
new file mode 100644
index 00000000..79bfd37b
--- /dev/null
+++ b/pipenv/vendor/toml/encoder.py
@@ -0,0 +1,250 @@
+import datetime
+import re
+import sys
+
+from toml.decoder import InlineTableDict
+
+if sys.version_info >= (3,):
+    unicode = str
+
+
+def dump(o, f):
+    """Writes out dict as toml to a file
+
+    Args:
+        o: Object to dump into toml
+        f: File descriptor where the toml should be stored
+
+    Returns:
+        String containing the toml corresponding to dictionary
+
+    Raises:
+        TypeError: When anything other than file descriptor is passed
+    """
+
+    if not f.write:
+        raise TypeError("You can only dump an object to a file descriptor")
+    d = dumps(o)
+    f.write(d)
+    return d
+
+
+def dumps(o, encoder=None):
+    """Stringifies input dict as toml
+
+    Args:
+        o: Object to dump into toml
+
+        preserve: Boolean parameter. If true, preserve inline tables.
+
+    Returns:
+        String containing the toml corresponding to dict
+    """
+
+    retval = ""
+    if encoder is None:
+        encoder = TomlEncoder(o.__class__)
+    addtoretval, sections = encoder.dump_sections(o, "")
+    retval += addtoretval
+    while sections:
+        newsections = encoder.get_empty_table()
+        for section in sections:
+            addtoretval, addtosections = encoder.dump_sections(
+                sections[section], section)
+
+            if addtoretval or (not addtoretval and not addtosections):
+                if retval and retval[-2:] != "\n\n":
+                    retval += "\n"
+                retval += "[" + section + "]\n"
+                if addtoretval:
+                    retval += addtoretval
+            for s in addtosections:
+                newsections[section + "." + s] = addtosections[s]
+        sections = newsections
+    return retval
+
+
+def _dump_str(v):
+    if sys.version_info < (3,) and hasattr(v, 'decode') and isinstance(v, str):
+        v = v.decode('utf-8')
+    v = "%r" % v
+    if v[0] == 'u':
+        v = v[1:]
+    singlequote = v.startswith("'")
+    if singlequote or v.startswith('"'):
+        v = v[1:-1]
+    if singlequote:
+        v = v.replace("\\'", "'")
+        v = v.replace('"', '\\"')
+    v = v.split("\\x")
+    while len(v) > 1:
+        i = -1
+        if not v[0]:
+            v = v[1:]
+        v[0] = v[0].replace("\\\\", "\\")
+        # No, I don't know why != works and == breaks
+        joinx = v[0][i] != "\\"
+        while v[0][:i] and v[0][i] == "\\":
+            joinx = not joinx
+            i -= 1
+        if joinx:
+            joiner = "x"
+        else:
+            joiner = "u00"
+        v = [v[0] + joiner + v[1]] + v[2:]
+    return unicode('"' + v[0] + '"')
+
+
+def _dump_float(v):
+    return "{0:.16}".format(v).replace("e+0", "e+").replace("e-0", "e-")
+
+
+def _dump_time(v):
+    utcoffset = v.utcoffset()
+    if utcoffset is None:
+        return v.isoformat()
+    # The TOML norm specifies that it's local time thus we drop the offset
+    return v.isoformat()[:-6]
+
+
+class TomlEncoder(object):
+
+    def __init__(self, _dict=dict, preserve=False):
+        self._dict = _dict
+        self.preserve = preserve
+        self.dump_funcs = {
+            str: _dump_str,
+            unicode: _dump_str,
+            list: self.dump_list,
+            bool: lambda v: unicode(v).lower(),
+            int: lambda v: v,
+            float: _dump_float,
+            datetime.datetime: lambda v: v.isoformat().replace('+00:00', 'Z'),
+            datetime.time: _dump_time,
+            datetime.date: lambda v: v.isoformat()
+        }
+
+    def get_empty_table(self):
+        return self._dict()
+
+    def dump_list(self, v):
+        retval = "["
+        for u in v:
+            retval += " " + unicode(self.dump_value(u)) + ","
+        retval += "]"
+        return retval
+
+    def dump_inline_table(self, section):
+        """Preserve inline table in its compact syntax instead of expanding
+        into subsection.
+
+        https://github.com/toml-lang/toml#user-content-inline-table
+        """
+        retval = ""
+        if isinstance(section, dict):
+            val_list = []
+            for k, v in section.items():
+                val = self.dump_inline_table(v)
+                val_list.append(k + " = " + val)
+            retval += "{ " + ", ".join(val_list) + " }\n"
+            return retval
+        else:
+            return unicode(self.dump_value(section))
+
+    def dump_value(self, v):
+        # Lookup function corresponding to v's type
+        dump_fn = self.dump_funcs.get(type(v))
+        if dump_fn is None and hasattr(v, '__iter__'):
+            dump_fn = self.dump_funcs[list]
+        # Evaluate function (if it exists) else return v
+        return dump_fn(v) if dump_fn is not None else self.dump_funcs[str](v)
+
+    def dump_sections(self, o, sup):
+        retstr = ""
+        if sup != "" and sup[-1] != ".":
+            sup += '.'
+        retdict = self._dict()
+        arraystr = ""
+        for section in o:
+            section = unicode(section)
+            qsection = section
+            if not re.match(r'^[A-Za-z0-9_-]+$', section):
+                if '"' in section:
+                    qsection = "'" + section + "'"
+                else:
+                    qsection = '"' + section + '"'
+            if not isinstance(o[section], dict):
+                arrayoftables = False
+                if isinstance(o[section], list):
+                    for a in o[section]:
+                        if isinstance(a, dict):
+                            arrayoftables = True
+                if arrayoftables:
+                    for a in o[section]:
+                        arraytabstr = "\n"
+                        arraystr += "[[" + sup + qsection + "]]\n"
+                        s, d = self.dump_sections(a, sup + qsection)
+                        if s:
+                            if s[0] == "[":
+                                arraytabstr += s
+                            else:
+                                arraystr += s
+                        while d:
+                            newd = self._dict()
+                            for dsec in d:
+                                s1, d1 = self.dump_sections(d[dsec], sup +
+                                                            qsection + "." +
+                                                            dsec)
+                                if s1:
+                                    arraytabstr += ("[" + sup + qsection +
+                                                    "." + dsec + "]\n")
+                                    arraytabstr += s1
+                                for s1 in d1:
+                                    newd[dsec + "." + s1] = d1[s1]
+                            d = newd
+                        arraystr += arraytabstr
+                else:
+                    if o[section] is not None:
+                        retstr += (qsection + " = " +
+                                   unicode(self.dump_value(o[section])) + '\n')
+            elif self.preserve and isinstance(o[section], InlineTableDict):
+                retstr += (qsection + " = " +
+                           self.dump_inline_table(o[section]))
+            else:
+                retdict[qsection] = o[section]
+        retstr += arraystr
+        return (retstr, retdict)
+
+
+class TomlPreserveInlineDictEncoder(TomlEncoder):
+
+    def __init__(self, _dict=dict):
+        super(TomlPreserveInlineDictEncoder, self).__init__(_dict, True)
+
+
+class TomlArraySeparatorEncoder(TomlEncoder):
+
+    def __init__(self, _dict=dict, preserve=False, separator=","):
+        super(TomlArraySeparatorEncoder, self).__init__(_dict, preserve)
+        if separator.strip() == "":
+            separator = "," + separator
+        elif separator.strip(' \t\n\r,'):
+            raise ValueError("Invalid separator for arrays")
+        self.separator = separator
+
+    def dump_list(self, v):
+        t = []
+        retval = "["
+        for u in v:
+            t.append(self.dump_value(u))
+        while t != []:
+            s = []
+            for u in t:
+                if isinstance(u, list):
+                    for r in u:
+                        s.append(r)
+                else:
+                    retval += " " + unicode(u) + self.separator
+            t = s
+        retval += "]"
+        return retval
diff --git a/pipenv/vendor/toml/ordered.py b/pipenv/vendor/toml/ordered.py
new file mode 100644
index 00000000..9c20c41a
--- /dev/null
+++ b/pipenv/vendor/toml/ordered.py
@@ -0,0 +1,15 @@
+from collections import OrderedDict
+from toml import TomlEncoder
+from toml import TomlDecoder
+
+
+class TomlOrderedDecoder(TomlDecoder):
+
+    def __init__(self):
+        super(self.__class__, self).__init__(_dict=OrderedDict)
+
+
+class TomlOrderedEncoder(TomlEncoder):
+
+    def __init__(self):
+        super(self.__class__, self).__init__(_dict=OrderedDict)
diff --git a/pipenv/vendor/toml/tz.py b/pipenv/vendor/toml/tz.py
new file mode 100644
index 00000000..93c3c8ad
--- /dev/null
+++ b/pipenv/vendor/toml/tz.py
@@ -0,0 +1,21 @@
+from datetime import tzinfo, timedelta
+
+
+class TomlTz(tzinfo):
+    def __init__(self, toml_offset):
+        if toml_offset == "Z":
+            self._raw_offset = "+00:00"
+        else:
+            self._raw_offset = toml_offset
+        self._sign = -1 if self._raw_offset[0] == '-' else 1
+        self._hours = int(self._raw_offset[1:3])
+        self._minutes = int(self._raw_offset[4:6])
+
+    def tzname(self, dt):
+        return "UTC" + self._raw_offset
+
+    def utcoffset(self, dt):
+        return self._sign * timedelta(hours=self._hours, minutes=self._minutes)
+
+    def dst(self, dt):
+        return timedelta(0)
diff --git a/pipenv/vendor/tomlkit/__init__.py b/pipenv/vendor/tomlkit/__init__.py
index 45de35fd..89e4cf59 100644
--- a/pipenv/vendor/tomlkit/__init__.py
+++ b/pipenv/vendor/tomlkit/__init__.py
@@ -22,4 +22,4 @@ from .api import value
 from .api import ws
 
 
-__version__ = "0.4.2"
+__version__ = "0.4.6"
diff --git a/pipenv/vendor/tomlkit/_compat.py b/pipenv/vendor/tomlkit/_compat.py
index 26296ff5..f94bb10e 100644
--- a/pipenv/vendor/tomlkit/_compat.py
+++ b/pipenv/vendor/tomlkit/_compat.py
@@ -162,16 +162,3 @@ def decode(string, encodings=None):
             pass
 
     return string.decode(encodings[0], errors="ignore")
-
-
-_escaped = {"b": "\b", "t": "\t", "n": "\n", "f": "\f", "r": "\r", '"': '"', "\\": "\\"}
-_escapable = re.compile(r"(?<!\\)([\n\b\t\f\r\\])")
-
-
-def string_escape(string):
-    if PY2:
-        return _escapable.sub(lambda m: m.group(1).encode("string_escape"), string)
-
-    return _escapable.sub(
-        lambda m: m.group(1).encode("unicode_escape").decode("utf-8"), string
-    )
diff --git a/pipenv/vendor/tomlkit/_utils.py b/pipenv/vendor/tomlkit/_utils.py
index 6f9fb055..f62a354a 100644
--- a/pipenv/vendor/tomlkit/_utils.py
+++ b/pipenv/vendor/tomlkit/_utils.py
@@ -6,6 +6,7 @@ from datetime import time
 from datetime import timedelta
 
 
+from ._compat import decode
 from ._compat import timezone
 
 RFC_3339_DATETIME = re.compile(
@@ -85,3 +86,35 @@ def parse_rfc3339(string):  # type: (str) -> Union[datetime, date, time]
         return time(hour, minute, second, microsecond)
 
     raise ValueError("Invalid RFC 339 string")
+
+
+_escaped = {"b": "\b", "t": "\t", "n": "\n", "f": "\f", "r": "\r", '"': '"', "\\": "\\"}
+_escapes = {v: k for k, v in _escaped.items()}
+
+
+def escape_string(s):
+    s = decode(s)
+
+    res = []
+    start = 0
+
+    def flush():
+        if start != i:
+            res.append(s[start:i])
+
+        return i + 1
+
+    i = 0
+    while i < len(s):
+        c = s[i]
+        if c in '"\\\n\r\t\b\f':
+            start = flush()
+            res.append("\\" + _escapes[c])
+        elif ord(c) < 0x20:
+            start = flush()
+            res.append("\\u%04x" % ord(c))
+        i += 1
+
+    flush()
+
+    return "".join(res)
diff --git a/pipenv/vendor/tomlkit/container.py b/pipenv/vendor/tomlkit/container.py
index a7876ff1..37014921 100644
--- a/pipenv/vendor/tomlkit/container.py
+++ b/pipenv/vendor/tomlkit/container.py
@@ -4,7 +4,6 @@ from ._compat import decode
 from .exceptions import KeyAlreadyPresent
 from .exceptions import NonExistentKey
 from .items import AoT
-from .items import Bool
 from .items import Comment
 from .items import Item
 from .items import Key
@@ -137,9 +136,9 @@ class Container(dict):
         is_table = isinstance(item, (Table, AoT))
         if key is not None and self._body and not self._parsed:
             # If there is already at least one table in the current container
-            # an the given item is not a table, we need to find the last
+            # and the given item is not a table, we need to find the last
             # item that is not a table and insert after it
-            # If not such item exists, insert at the top of the table
+            # If no such item exists, insert at the top of the table
             key_after = None
             idx = 0
             for k, v in self._body:
@@ -333,7 +332,7 @@ class Container(dict):
             if table.is_aot_element():
                 open_, close = "[[", "]]"
 
-            cur += "{}{}{}{}{}{}{}".format(
+            cur += "{}{}{}{}{}{}{}{}".format(
                 table.trivia.indent,
                 open_,
                 decode(_key),
@@ -341,6 +340,7 @@ class Container(dict):
                 table.trivia.comment_ws,
                 decode(table.trivia.comment),
                 table.trivia.trail,
+                "\n" if "\n" not in table.trivia.trail and len(table.value) > 0 else "",
             )
 
         for k, v in table.value.body:
@@ -450,6 +450,10 @@ class Container(dict):
 
             yield k, v
 
+    def update(self, other):  # type: (Dict) -> None
+        for k, v in other.items():
+            self[k] = v
+
     def __contains__(self, key):  # type: (Union[Key, str]) -> bool
         if not isinstance(key, Key):
             key = Key(key)
@@ -520,3 +524,21 @@ class Container(dict):
             return NotImplemented
 
         return self.value == other
+
+    def _getstate(self, protocol):
+        return (self._parsed,)
+
+    def __reduce__(self):
+        return self.__reduce_ex__(2)
+
+    def __reduce_ex__(self, protocol):
+        return (
+            self.__class__,
+            self._getstate(protocol),
+            (self._map, self._body, self._parsed),
+        )
+
+    def __setstate__(self, state):
+        self._map = state[0]
+        self._body = state[1]
+        self._parsed = state[2]
diff --git a/pipenv/vendor/tomlkit/exceptions.py b/pipenv/vendor/tomlkit/exceptions.py
index d889a924..46ee938b 100644
--- a/pipenv/vendor/tomlkit/exceptions.py
+++ b/pipenv/vendor/tomlkit/exceptions.py
@@ -85,7 +85,7 @@ class InvalidCharInStringError(ParseError):
     """
 
     def __init__(self, line, col, char):  # type: (int, int, str) -> None
-        message = "Invalid character '{}' in string".format(char)
+        message = "Invalid character {} in string".format(repr(char))
 
         super(InvalidCharInStringError, self).__init__(line, col, message=message)
 
diff --git a/pipenv/vendor/tomlkit/items.py b/pipenv/vendor/tomlkit/items.py
index 8807f4b3..781e2e98 100644
--- a/pipenv/vendor/tomlkit/items.py
+++ b/pipenv/vendor/tomlkit/items.py
@@ -15,6 +15,12 @@ else:
 from ._compat import PY2
 from ._compat import decode
 from ._compat import unicode
+from ._utils import escape_string
+
+if PY2:
+    from pipenv.vendor.backports.functools_lru_cache import lru_cache
+else:
+    from functools import lru_cache
 
 
 def item(value, _parent=None):
@@ -60,7 +66,7 @@ def item(value, _parent=None):
 
         return a
     elif isinstance(value, (str, unicode)):
-        escaped = decode(value).replace('"', '\\"').replace("\\\\", "\\")
+        escaped = escape_string(value)
 
         return String(StringType.SLB, value, escaped, Trivia())
     elif isinstance(value, datetime):
@@ -74,18 +80,45 @@ def item(value, _parent=None):
 
 
 class StringType(Enum):
-
+    # Single Line Basic
     SLB = '"'
+    # Multi Line Basic
     MLB = '"""'
+    # Single Line Literal
     SLL = "'"
+    # Multi Line Literal
     MLL = "'''"
 
+    @property
+    @lru_cache(maxsize=None)
+    def unit(self):  # type: () -> str
+        return self.value[0]
+
+    @lru_cache(maxsize=None)
+    def is_basic(self):  # type: () -> bool
+        return self in {StringType.SLB, StringType.MLB}
+
+    @lru_cache(maxsize=None)
     def is_literal(self):  # type: () -> bool
         return self in {StringType.SLL, StringType.MLL}
 
+    @lru_cache(maxsize=None)
+    def is_singleline(self):  # type: () -> bool
+        return self in {StringType.SLB, StringType.SLL}
+
+    @lru_cache(maxsize=None)
     def is_multiline(self):  # type: () -> bool
         return self in {StringType.MLB, StringType.MLL}
 
+    @lru_cache(maxsize=None)
+    def toggle(self):  # type: () -> StringType
+        return {
+            StringType.SLB: StringType.MLB,
+            StringType.MLB: StringType.SLB,
+            StringType.SLL: StringType.MLL,
+            StringType.MLL: StringType.SLL,
+        }[self]
+
 
 class Trivia:
     """
@@ -157,7 +190,10 @@ class Key:
         return hash(self.key)
 
     def __eq__(self, other):  # type: (Key) -> bool
-        return self.key == other.key
+        if isinstance(other, Key):
+            return self.key == other.key
+
+        return self.key == other
 
     def __str__(self):  # type: () -> str
         return self.as_string()
@@ -204,6 +240,15 @@ class Item(object):
 
         return self
 
+    def _getstate(self, protocol=3):
+        return (self._trivia,)
+
+    def __reduce__(self):
+        return self.__reduce_ex__(2)
+
+    def __reduce_ex__(self, protocol):
+        return self.__class__, self._getstate(protocol)
+
 
 class Whitespace(Item):
     """
@@ -239,6 +284,9 @@ class Whitespace(Item):
     def __repr__(self):  # type: () -> str
         return "<{} {}>".format(self.__class__.__name__, repr(self._s))
 
+    def _getstate(self, protocol=3):
+        return self._s, self._fixed
+
 
 class Comment(Item):
     """
@@ -272,7 +320,7 @@ class Integer(int, Item):
         self._raw = raw
         self._sign = False
 
-        if re.match("^[+\-]\d+$", raw):
+        if re.match(r"^[+\-]\d+$", raw):
             self._sign = True
 
     @property
@@ -321,6 +369,9 @@ class Integer(int, Item):
 
         return Integer(result, self._trivia, raw)
 
+    def _getstate(self, protocol=3):
+        return int(self), self._trivia, self._raw
+
 
 class Float(float, Item):
     """
@@ -336,7 +387,7 @@ class Float(float, Item):
         self._raw = raw
         self._sign = False
 
-        if re.match("^[+\-].+$", raw):
+        if re.match(r"^[+\-].+$", raw):
             self._sign = True
 
     @property
@@ -385,6 +436,9 @@ class Float(float, Item):
 
         return Float(result, self._trivia, raw)
 
+    def _getstate(self, protocol=3):
+        return float(self), self._trivia, self._raw
+
 
 class Bool(Item):
     """
@@ -407,13 +461,16 @@ class Bool(Item):
     def as_string(self):  # type: () -> str
         return str(self._value).lower()
 
+    def _getstate(self, protocol=3):
+        return self._value, self._trivia
 
-class DateTime(datetime, Item):
+
+class DateTime(Item, datetime):
     """
     A datetime literal.
     """
 
-    def __new__(cls, value, *_):  # type: (datetime, ...) -> datetime
+    def __new__(cls, value, *_):  # type: (..., datetime, ...) -> datetime
         return datetime.__new__(
             cls,
             value.year,
@@ -457,13 +514,29 @@ class DateTime(datetime, Item):
 
         return DateTime(result, self._trivia, raw)
 
+    def _getstate(self, protocol=3):
+        return (
+            datetime(
+                self.year,
+                self.month,
+                self.day,
+                self.hour,
+                self.minute,
+                self.second,
+                self.microsecond,
+                self.tzinfo,
+            ),
+            self._trivia,
+            self._raw,
+        )
 
-class Date(date, Item):
+
+class Date(Item, date):
     """
     A date literal.
     """
 
-    def __new__(cls, value, *_):  # type: (date, ...) -> date
+    def __new__(cls, value, *_):  # type: (..., date, ...) -> date
         return date.__new__(cls, value.year, value.month, value.day)
 
     def __init__(self, _, trivia, raw):  # type: (date, Trivia, str) -> None
@@ -497,8 +570,11 @@ class Date(date, Item):
 
         return Date(result, self._trivia, raw)
 
+    def _getstate(self, protocol=3):
+        return (datetime(self.year, self.month, self.day), self._trivia, self._raw)
 
-class Time(time, Item):
+
+class Time(Item, time):
     """
     A time literal.
     """
@@ -524,6 +600,13 @@ class Time(time, Item):
     def as_string(self):  # type: () -> str
         return self._raw
 
+    def _getstate(self, protocol=3):
+        return (
+            time(self.hour, self.minute, self.second, self.microsecond, self.tzinfo),
+            self._trivia,
+            self._raw,
+        )
+
 
 class Array(Item, list):
     """
@@ -622,6 +705,9 @@ class Array(Item, list):
     def __repr__(self):
         return str(self)
 
+    def _getstate(self, protocol=3):
+        return self._value, self._trivia
+
 
 class Table(Item, dict):
     """
@@ -636,7 +722,7 @@ class Table(Item, dict):
         is_super_table=False,
         name=None,
         display_name=None,
-    ):  # type: (tomlkit.container.Container, Trivia, bool) -> None
+    ):  # type: (tomlkit.container.Container, Trivia, bool, ...) -> None
         super(Table, self).__init__(trivia)
 
         self.name = name
@@ -751,6 +837,10 @@ class Table(Item, dict):
         for k, v in self._value.items():
             yield k, v
 
+    def update(self, other):  # type: (Dict) -> None
+        for k, v in other.items():
+            self[k] = v
+
     def __contains__(self, key):  # type: (Union[Key, str]) -> bool
         return key in self._value
 
@@ -758,7 +848,26 @@ class Table(Item, dict):
         return self._value[key]
 
     def __setitem__(self, key, value):  # type: (Union[Key, str], Any) -> None
-        self.append(key, value)
+        if not isinstance(value, Item):
+            value = item(value)
+
+        self._value[key] = value
+
+        if key is not None:
+            super(Table, self).__setitem__(key, value)
+
+        m = re.match("(?s)^[^ ]*([ ]+).*$", self._trivia.indent)
+        if not m:
+            return
+
+        indent = m.group(1)
+
+        if not isinstance(value, Whitespace):
+            m = re.match("(?s)^([^ ]*)(.*)$", value.trivia.indent)
+            if not m:
+                value.trivia.indent = indent
+            else:
+                value.trivia.indent = m.group(1) + indent + m.group(2)
 
     def __delitem__(self, key):  # type: (Union[Key, str]) -> None
         self.remove(key)
@@ -766,6 +875,16 @@ class Table(Item, dict):
     def __repr__(self):
         return super(Table, self).__repr__()
 
+    def _getstate(self, protocol=3):
+        return (
+            self._value,
+            self._trivia,
+            self._is_aot_element,
+            self._is_super_table,
+            self.name,
+            self.display_name,
+        )
+
 
 class InlineTable(Item, dict):
     """
@@ -862,6 +981,10 @@ class InlineTable(Item, dict):
         for k, v in self._value.items():
             yield k, v
 
+    def update(self, other):  # type: (Dict) -> None
+        for k, v in other.items():
+            self[k] = v
+
     def __contains__(self, key):  # type: (Union[Key, str]) -> bool
         return key in self._value
 
@@ -869,7 +992,26 @@ class InlineTable(Item, dict):
         return self._value[key]
 
     def __setitem__(self, key, value):  # type: (Union[Key, str], Any) -> None
-        self.append(key, value)
+        if not isinstance(value, Item):
+            value = item(value)
+
+        self._value[key] = value
+
+        if key is not None:
+            super(InlineTable, self).__setitem__(key, value)
+
+        m = re.match("(?s)^[^ ]*([ ]+).*$", self._trivia.indent)
+        if not m:
+            return
+
+        indent = m.group(1)
+
+        if not isinstance(value, Whitespace):
+            m = re.match("(?s)^([^ ]*)(.*)$", value.trivia.indent)
+            if not m:
+                value.trivia.indent = indent
+            else:
+                value.trivia.indent = m.group(1) + indent + m.group(2)
 
     def __delitem__(self, key):  # type: (Union[Key, str]) -> None
         self.remove(key)
@@ -877,6 +1019,9 @@ class InlineTable(Item, dict):
     def __repr__(self):
         return super(InlineTable, self).__repr__()
 
+    def _getstate(self, protocol=3):
+        return (self._value, self._trivia)
+
 
 class String(unicode, Item):
     """
@@ -918,6 +1063,9 @@ class String(unicode, Item):
     def _new(self, result):
         return String(self._t, result, result, self._trivia)
 
+    def _getstate(self, protocol=3):
+        return self._t, unicode(self), self._original, self._trivia
+
 
 class AoT(Item, list):
     """
@@ -927,7 +1075,7 @@ class AoT(Item, list):
     def __init__(
         self, body, name=None, parsed=False
     ):  # type: (List[Table], Optional[str]) -> None
-        self.name = None
+        self.name = name
         self._body = []
         self._parsed = parsed
 
@@ -978,6 +1126,9 @@ class AoT(Item, list):
     def __repr__(self):  # type: () -> str
         return "<AoT {}>".format(self.value)
 
+    def _getstate(self, protocol=3):
+        return self._body, self.name, self._parsed
+
 
 class Null(Item):
     """
@@ -997,3 +1148,6 @@ class Null(Item):
 
     def as_string(self):  # type: () -> str
         return ""
+
+    def _getstate(self, protocol=3):
+        return tuple()
diff --git a/pipenv/vendor/tomlkit/parser.py b/pipenv/vendor/tomlkit/parser.py
index 3d4984d1..7971d9a2 100644
--- a/pipenv/vendor/tomlkit/parser.py
+++ b/pipenv/vendor/tomlkit/parser.py
@@ -11,6 +11,7 @@ from copy import copy
 from ._compat import PY2
 from ._compat import chr
 from ._compat import decode
+from ._utils import _escaped
 from ._utils import parse_rfc3339
 from .container import Container
 from .exceptions import EmptyKeyError
@@ -74,7 +75,7 @@ class Parser:
         else:
             return self._src[self._marker : self._idx]
 
-    def inc(self):  # type: () -> bool
+    def inc(self, exception=None):  # type: () -> bool
         """
         Increments the parser if the end of the input has not been reached.
         Returns whether or not it was able to advance.
@@ -87,15 +88,17 @@ class Parser:
             self._idx = len(self._src)
             self._current = TOMLChar("\0")
 
-            return False
+            if not exception:
+                return False
+            raise exception
 
-    def inc_n(self, n):  # type: (int) -> bool
+    def inc_n(self, n, exception=None):  # type: (int) -> bool
         """
         Increments the parser by n characters
         if the end of the input has not been reached.
         """
         for _ in range(n):
-            if not self.inc():
+            if not self.inc(exception=exception):
                 return False
 
         return True
@@ -286,19 +289,20 @@ class Parser:
 
     def _save_idx(self):  # type: () -> Tuple[Iterator, int, str]
         if PY2:
-            return itertools.tee(self._chars)[1], self._idx, self._current
+            # Python 2.7 does not allow to directly copy
+            # an iterator, so we have to make tees of the original
+            # chars iterator.
+            chars1, chars2 = itertools.tee(self._chars)
+
+            # We can no longer use the original chars iterator.
+            self._chars = chars1
+
+            return chars2, self._idx, self._current
 
         return copy(self._chars), self._idx, self._current
 
     def _restore_idx(self, chars, idx, current):  # type: (Iterator, int, str) -> None
-        if PY2:
-            self._chars = iter(
-                [(i + idx, TOMLChar(c)) for i, c in enumerate(self._src[idx:])]
-            )
-            next(self._chars)
-        else:
-            self._chars = chars
-
+        self._chars = chars
         self._idx = idx
         self._current = current
 
@@ -334,7 +338,7 @@ class Parser:
                 self.mark()
 
                 break
-            elif c in " \t\r,":
+            elif c in " \t\r":
                 self.inc()
             else:
                 raise self.parse_error(UnexpectedCharError, (c))
@@ -667,149 +671,143 @@ class Parser:
                 return
 
     def _parse_literal_string(self):  # type: () -> Item
-        return self._parse_string("'")
+        return self._parse_string(StringType.SLL)
 
     def _parse_basic_string(self):  # type: () -> Item
-        return self._parse_string('"')
+        return self._parse_string(StringType.SLB)
+
+    def _parse_escaped_char(self, multiline):
+        if multiline and self._current.is_ws():
+            # When the last non-whitespace character on a line is
+            # a \, it will be trimmed along with all whitespace
+            # (including newlines) up to the next non-whitespace
+            # character or closing delimiter.
+            # """\
+            #     hello \
+            #     world"""
+            tmp = ""
+            while self._current.is_ws():
+                tmp += self._current
+                # consume the whitespace, EOF here is an issue
+                # (middle of string)
+                self.inc(exception=UnexpectedEofError)
+                continue
+
+            # the escape followed by whitespace must have a newline
+            # before any other chars
+            if "\n" not in tmp:
+                raise self.parse_error(InvalidCharInStringError, (self._current,))
+
+            return ""
+
+        if self._current in _escaped:
+            c = _escaped[self._current]
+
+            # consume this char, EOF here is an issue (middle of string)
+            self.inc(exception=UnexpectedEofError)
+
+            return c
+
+        if self._current in {"u", "U"}:
+            # this needs to be a unicode
+            u, ue = self._peek_unicode(self._current == "U")
+            if u is not None:
+                # consume the U char and the unicode value
+                self.inc_n(len(ue) + 1)
+
+                return u
+
+        raise self.parse_error(InvalidCharInStringError, (self._current,))
 
     def _parse_string(self, delim):  # type: (str) -> Item
-        multiline = False
+        delim = StringType(delim)
+        assert delim.is_singleline()
+
+        # only keep parsing for string if the current character matches the delim
+        if self._current != delim.unit:
+            raise ValueError("Expecting a {!r} character".format(delim))
+
+        # consume the opening/first delim, EOF here is an issue
+        # (middle of string or middle of delim)
+        self.inc(exception=UnexpectedEofError)
+
+        if self._current == delim.unit:
+            # consume the closing/second delim, we do not care if EOF occurs as
+            # that would simply imply an empty single line string
+            if not self.inc() or self._current != delim.unit:
+                # Empty string
+                return String(delim, "", "", Trivia())
+
+            # consume the third delim, EOF here is an issue (middle of string)
+            self.inc(exception=UnexpectedEofError)
+
+            delim = delim.toggle()  # convert delim to multi delim
+
+        self.mark()  # to extract the original string with whitespace and all
         value = ""
 
-        if delim == "'":
-            str_type = StringType.SLL
-        else:
-            str_type = StringType.SLB
+        # A newline immediately following the opening delimiter will be trimmed.
+        if delim.is_multiline() and self._current == "\n":
+            # consume the newline, EOF here is an issue (middle of string)
+            self.inc(exception=UnexpectedEofError)
 
-        # Skip opening delim
-        if not self.inc():
-            return self.parse_error(UnexpectedEofError)
-
-        if self._current == delim:
-            self.inc()
-
-            if self._current == delim:
-                multiline = True
-                if delim == "'":
-                    str_type = StringType.MLL
-                else:
-                    str_type = StringType.MLB
-
-                if not self.inc():
-                    return self.parse_error(UnexpectedEofError)
-            else:
-                # Empty string
-                return String(str_type, "", "", Trivia())
-
-        self.mark()
-        if self._current == "\n":
-            # The first new line should be discarded
-            self.inc()
-
-        previous = None
-        escaped = False
+        escaped = False  # whether the previous key was ESCAPE
         while True:
-            if (
-                previous != "\\"
-                or previous == "\\"
-                and (escaped or str_type.is_literal())
-            ) and self._current == delim:
-                val = self.extract()
+            if delim.is_singleline() and self._current.is_nl():
+                # single line cannot have actual newline characters
+                raise self.parse_error(InvalidCharInStringError, (self._current,))
+            elif not escaped and self._current == delim.unit:
+                # try to process current as a closing delim
+                original = self.extract()
 
-                if multiline:
-                    stop = True
-                    for _ in range(3):
-                        if self._current != delim:
+                close = ""
+                if delim.is_multiline():
+                    # try consuming three delims as this would mean the end of
+                    # the string
+                    for last in [False, False, True]:
+                        if self._current != delim.unit:
                             # Not a triple quote, leave in result as-is.
-                            stop = False
-
-                            # Adding back the quote character
-                            value += delim
+                            # Adding back the characters we already consumed
+                            value += close
+                            close = ""  # clear the close
                             break
 
-                        self.inc()  # TODO: Handle EOF
+                        close += delim.unit
 
-                    if not stop:
+                        # consume this delim, EOF here is only an issue if this
+                        # is not the third (last) delim character
+                        self.inc(exception=UnexpectedEofError if not last else None)
+
+                    if not close:  # if there is no close characters, keep parsing
                         continue
                 else:
+                    close = delim.unit
+
+                    # consume the closing delim, we do not care if EOF occurs as
+                    # that would simply imply the end of self._src
                     self.inc()
 
-                return String(str_type, value, val, Trivia())
+                return String(delim, value, original, Trivia())
+            elif delim.is_basic() and escaped:
+                # attempt to parse the current char as an escaped value, an exception
+                # is raised if this fails
+                value += self._parse_escaped_char(delim.is_multiline())
+
+                # no longer escaped
+                escaped = False
+            elif delim.is_basic() and self._current == "\\":
+                # the next char is being escaped
+                escaped = True
+
+                # consume this char, EOF here is an issue (middle of string)
+                self.inc(exception=UnexpectedEofError)
             else:
-                escape_vals = {
-                    "b": "\b",
-                    "t": "\t",
-                    "n": "\n",
-                    "f": "\f",
-                    "r": "\r",
-                    "\\": "\\",
-                    '"': '"',
-                }
-                if previous == "\\" and self._current.is_ws() and multiline:
-                    while self._current.is_ws():
-                        previous = self._current
+                # this is either a literal string where we keep everything as is,
+                # or this is not a special escaped char in a basic string
+                value += self._current
 
-                        self.inc()
-                        continue
-
-                    if self._current == delim:
-                        continue
-
-                if previous == "\\":
-                    if self._current == "\\" and not escaped:
-                        if not str_type.is_literal():
-                            escaped = True
-                        else:
-                            value += self._current
-
-                        previous = self._current
-
-                        if not self.inc():
-                            raise self.parse_error(UnexpectedEofError)
-
-                        continue
-                    elif self._current in escape_vals and not escaped:
-                        if not str_type.is_literal():
-                            value = value[:-1]
-                            value += escape_vals[self._current]
-                        else:
-                            value += self._current
-                    elif self._current in {"u", "U"} and not escaped:
-                        # Maybe unicode
-                        u, ue = self._peek_unicode(self._current == "U")
-                        if u is not None:
-                            value = value[:-1]
-                            value += u
-                            self.inc_n(len(ue))
-                        else:
-                            if not escaped and not str_type.is_literal():
-                                raise self.parse_error(
-                                    InvalidCharInStringError, (self._current,)
-                                )
-
-                            value += self._current
-                    else:
-                        if not escaped and not str_type.is_literal():
-                            raise self.parse_error(
-                                InvalidCharInStringError, (self._current,)
-                            )
-
-                        value += self._current
-
-                    if self._current.is_ws() and multiline and not escaped:
-                        continue
-                else:
-                    value += self._current
-
-                if escaped:
-                    escaped = False
-
-                previous = self._current
-                if not self.inc():
-                    raise self.parse_error(UnexpectedEofError)
-
-                if previous == "\\" and self._current.is_ws() and multiline:
-                    value = value[:-1]
+                # consume this char, EOF here is an issue (middle of string)
+                self.inc(exception=UnexpectedEofError)
 
     def _parse_table(
         self, parent_name=None
diff --git a/pipenv/vendor/tomlkit/toml_char.py b/pipenv/vendor/tomlkit/toml_char.py
index 8a3bf9e1..5164ea8b 100644
--- a/pipenv/vendor/tomlkit/toml_char.py
+++ b/pipenv/vendor/tomlkit/toml_char.py
@@ -1,7 +1,13 @@
 import string
 
+from ._compat import PY2
 from ._compat import unicode
 
+if PY2:
+    from pipenv.vendor.backports.functools_lru_cache import lru_cache
+else:
+    from functools import lru_cache
+
 
 class TOMLChar(unicode):
     def __init__(self, c):
@@ -10,36 +16,42 @@ class TOMLChar(unicode):
         if len(self) > 1:
             raise ValueError("A TOML character must be of length 1")
 
+    @lru_cache(maxsize=None)
     def is_bare_key_char(self):  # type: () -> bool
         """
         Whether the character is a valid bare key name or not.
         """
         return self in string.ascii_letters + string.digits + "-" + "_"
 
+    @lru_cache(maxsize=None)
     def is_kv_sep(self):  # type: () -> bool
         """
         Whether the character is a valid key/value separator ot not.
         """
         return self in "= \t"
 
+    @lru_cache(maxsize=None)
     def is_int_float_char(self):  # type: () -> bool
         """
         Whether the character if a valid integer or float value character or not.
         """
         return self in string.digits + "+" + "-" + "_" + "." + "e"
 
+    @lru_cache(maxsize=None)
     def is_ws(self):  # type: () -> bool
         """
         Whether the character is a whitespace character or not.
         """
         return self in " \t\r\n"
 
+    @lru_cache(maxsize=None)
     def is_nl(self):  # type: () -> bool
         """
         Whether the character is a new line character or not.
         """
         return self in "\n\r"
 
+    @lru_cache(maxsize=None)
     def is_spaces(self):  # type: () -> bool
         """
         Whether the character is a space or not
diff --git a/pipenv/vendor/urllib3/__init__.py b/pipenv/vendor/urllib3/__init__.py
old mode 100755
new mode 100644
index 4bd533b5..75725167
--- a/pipenv/vendor/urllib3/__init__.py
+++ b/pipenv/vendor/urllib3/__init__.py
@@ -23,16 +23,11 @@ from .util.retry import Retry
 
 # Set default logging handler to avoid "No handler found" warnings.
 import logging
-try:  # Python 2.7+
-    from logging import NullHandler
-except ImportError:
-    class NullHandler(logging.Handler):
-        def emit(self, record):
-            pass
+from logging import NullHandler
 
 __author__ = 'Andrey Petrov (andrey.petrov@shazow.net)'
 __license__ = 'MIT'
-__version__ = '1.23'
+__version__ = '1.24'
 
 __all__ = (
     'HTTPConnectionPool',
diff --git a/pipenv/vendor/urllib3/_collections.py b/pipenv/vendor/urllib3/_collections.py
old mode 100755
new mode 100644
index 6e36b84e..34f23811
--- a/pipenv/vendor/urllib3/_collections.py
+++ b/pipenv/vendor/urllib3/_collections.py
@@ -14,10 +14,7 @@ except ImportError:  # Platform-specific: No threads available
             pass
 
 
-try:  # Python 2.7+
-    from collections import OrderedDict
-except ImportError:
-    from .packages.ordered_dict import OrderedDict
+from collections import OrderedDict
 from .exceptions import InvalidHeader
 from .packages.six import iterkeys, itervalues, PY3
 
diff --git a/pipenv/vendor/urllib3/connection.py b/pipenv/vendor/urllib3/connection.py
old mode 100755
new mode 100644
index a03b573f..02b36654
--- a/pipenv/vendor/urllib3/connection.py
+++ b/pipenv/vendor/urllib3/connection.py
@@ -2,7 +2,6 @@ from __future__ import absolute_import
 import datetime
 import logging
 import os
-import sys
 import socket
 from socket import error as SocketError, timeout as SocketTimeout
 import warnings
@@ -78,9 +77,6 @@ class HTTPConnection(_HTTPConnection, object):
 
       - ``strict``: See the documentation on :class:`urllib3.connectionpool.HTTPConnectionPool`
       - ``source_address``: Set the source address for the current connection.
-
-        .. note:: This is ignored for Python 2.6. It is only applied for 2.7 and 3.x
-
       - ``socket_options``: Set specific options on the underlying socket. If not specified, then
         defaults are loaded from ``HTTPConnection.default_socket_options`` which includes disabling
         Nagle's algorithm (sets TCP_NODELAY to 1) unless the connection is behind a proxy.
@@ -108,21 +104,13 @@ class HTTPConnection(_HTTPConnection, object):
         if six.PY3:  # Python 3
             kw.pop('strict', None)
 
-        # Pre-set source_address in case we have an older Python like 2.6.
+        # Pre-set source_address.
         self.source_address = kw.get('source_address')
 
-        if sys.version_info < (2, 7):  # Python 2.6
-            # _HTTPConnection on Python 2.6 will balk at this keyword arg, but
-            # not newer versions. We can still use it when creating a
-            # connection though, so we pop it *after* we have saved it as
-            # self.source_address.
-            kw.pop('source_address', None)
-
         #: The socket options provided by the user. If no options are
         #: provided, we use the default options.
         self.socket_options = kw.pop('socket_options', self.default_socket_options)
 
-        # Superclass also sets self.source_address in Python 2.7+.
         _HTTPConnection.__init__(self, *args, **kw)
 
     @property
@@ -183,10 +171,7 @@ class HTTPConnection(_HTTPConnection, object):
 
     def _prepare_conn(self, conn):
         self.sock = conn
-        # the _tunnel_host attribute was added in python 2.6.3 (via
-        # http://hg.python.org/cpython/rev/0f57b30a152f) so pythons 2.6(0-2) do
-        # not have them.
-        if getattr(self, '_tunnel_host', None):
+        if self._tunnel_host:
             # TODO: Fix tunnel so it doesn't depend on self.sock state.
             self._tunnel()
             # Mark this connection as not reusable
@@ -217,13 +202,13 @@ class HTTPConnection(_HTTPConnection, object):
         self.endheaders()
 
         if body is not None:
-            stringish_types = six.string_types + (six.binary_type,)
+            stringish_types = six.string_types + (bytes,)
             if isinstance(body, stringish_types):
                 body = (body,)
             for chunk in body:
                 if not chunk:
                     continue
-                if not isinstance(chunk, six.binary_type):
+                if not isinstance(chunk, bytes):
                     chunk = chunk.encode('utf8')
                 len_str = hex(len(chunk))[2:]
                 self.send(len_str.encode('utf-8'))
@@ -242,7 +227,7 @@ class HTTPSConnection(HTTPConnection):
 
     def __init__(self, host, port=None, key_file=None, cert_file=None,
                  strict=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
-                 ssl_context=None, **kw):
+                 ssl_context=None, server_hostname=None, **kw):
 
         HTTPConnection.__init__(self, host, port, strict=strict,
                                 timeout=timeout, **kw)
@@ -250,6 +235,7 @@ class HTTPSConnection(HTTPConnection):
         self.key_file = key_file
         self.cert_file = cert_file
         self.ssl_context = ssl_context
+        self.server_hostname = server_hostname
 
         # Required property for Google AppEngine 1.9.0 which otherwise causes
         # HTTPS requests to go out as HTTP. (See Issue #356)
@@ -270,6 +256,7 @@ class HTTPSConnection(HTTPConnection):
             keyfile=self.key_file,
             certfile=self.cert_file,
             ssl_context=self.ssl_context,
+            server_hostname=self.server_hostname
         )
 
 
@@ -312,12 +299,9 @@ class VerifiedHTTPSConnection(HTTPSConnection):
     def connect(self):
         # Add certificate verification
         conn = self._new_conn()
-
         hostname = self.host
-        if getattr(self, '_tunnel_host', None):
-            # _tunnel_host was added in Python 2.6.3
-            # (See: http://hg.python.org/cpython/rev/0f57b30a152f)
 
+        if self._tunnel_host:
             self.sock = conn
             # Calls self._set_hostport(), so self.host is
             # self._tunnel_host below.
@@ -328,6 +312,10 @@ class VerifiedHTTPSConnection(HTTPSConnection):
             # Override the host with the one we're requesting data from.
             hostname = self._tunnel_host
 
+        server_hostname = hostname
+        if self.server_hostname is not None:
+            server_hostname = self.server_hostname
+
         is_time_off = datetime.date.today() < RECENT_DATE
         if is_time_off:
             warnings.warn((
@@ -352,7 +340,7 @@ class VerifiedHTTPSConnection(HTTPSConnection):
             certfile=self.cert_file,
             ca_certs=self.ca_certs,
             ca_cert_dir=self.ca_cert_dir,
-            server_hostname=hostname,
+            server_hostname=server_hostname,
             ssl_context=context)
 
         if self.assert_fingerprint:
@@ -373,7 +361,7 @@ class VerifiedHTTPSConnection(HTTPSConnection):
                     'for details.)'.format(hostname)),
                     SubjectAltNameWarning
                 )
-            _match_hostname(cert, self.assert_hostname or hostname)
+            _match_hostname(cert, self.assert_hostname or server_hostname)
 
         self.is_verified = (
             context.verify_mode == ssl.CERT_REQUIRED or
diff --git a/pipenv/vendor/urllib3/connectionpool.py b/pipenv/vendor/urllib3/connectionpool.py
old mode 100755
new mode 100644
index 8fcb0bce..f7a8f193
--- a/pipenv/vendor/urllib3/connectionpool.py
+++ b/pipenv/vendor/urllib3/connectionpool.py
@@ -89,7 +89,7 @@ class ConnectionPool(object):
 
 
 # This is taken from http://hg.python.org/cpython/file/7aaba721ebc0/Lib/socket.py#l252
-_blocking_errnos = set([errno.EAGAIN, errno.EWOULDBLOCK])
+_blocking_errnos = {errno.EAGAIN, errno.EWOULDBLOCK}
 
 
 class HTTPConnectionPool(ConnectionPool, RequestMethods):
@@ -313,7 +313,7 @@ class HTTPConnectionPool(ConnectionPool, RequestMethods):
         # Catch possible read timeouts thrown as SSL errors. If not the
         # case, rethrow the original. We need to do this because of:
         # http://bugs.python.org/issue10272
-        if 'timed out' in str(err) or 'did not complete (read)' in str(err):  # Python 2.6
+        if 'timed out' in str(err) or 'did not complete (read)' in str(err):  # Python < 2.7.4
             raise ReadTimeoutError(self, url, "Read timed out. (read timeout=%s)" % timeout_value)
 
     def _make_request(self, conn, method, url, timeout=_Default, chunked=False,
@@ -375,7 +375,7 @@ class HTTPConnectionPool(ConnectionPool, RequestMethods):
         try:
             try:  # Python 2.7, use buffering of HTTP responses
                 httplib_response = conn.getresponse(buffering=True)
-            except TypeError:  # Python 2.6 and older, Python 3
+            except TypeError:  # Python 3
                 try:
                     httplib_response = conn.getresponse()
                 except Exception as e:
@@ -801,17 +801,7 @@ class HTTPSConnectionPool(HTTPConnectionPool):
         Establish tunnel connection early, because otherwise httplib
         would improperly set Host: header to proxy's IP:port.
         """
-        # Python 2.7+
-        try:
-            set_tunnel = conn.set_tunnel
-        except AttributeError:  # Platform-specific: Python 2.6
-            set_tunnel = conn._set_tunnel
-
-        if sys.version_info <= (2, 6, 4) and not self.proxy_headers:  # Python 2.6.4 and older
-            set_tunnel(self._proxy_host, self.port)
-        else:
-            set_tunnel(self._proxy_host, self.port, self.proxy_headers)
-
+        conn.set_tunnel(self._proxy_host, self.port, self.proxy_headers)
         conn.connect()
 
     def _new_conn(self):
diff --git a/pipenv/vendor/urllib3/contrib/__init__.py b/pipenv/vendor/urllib3/contrib/__init__.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/contrib/_appengine_environ.py b/pipenv/vendor/urllib3/contrib/_appengine_environ.py
new file mode 100644
index 00000000..f3e00942
--- /dev/null
+++ b/pipenv/vendor/urllib3/contrib/_appengine_environ.py
@@ -0,0 +1,30 @@
+"""
+This module provides means to detect the App Engine environment.
+"""
+
+import os
+
+
+def is_appengine():
+    return (is_local_appengine() or
+            is_prod_appengine() or
+            is_prod_appengine_mvms())
+
+
+def is_appengine_sandbox():
+    return is_appengine() and not is_prod_appengine_mvms()
+
+
+def is_local_appengine():
+    return ('APPENGINE_RUNTIME' in os.environ and
+            'Development/' in os.environ['SERVER_SOFTWARE'])
+
+
+def is_prod_appengine():
+    return ('APPENGINE_RUNTIME' in os.environ and
+            'Google App Engine/' in os.environ['SERVER_SOFTWARE'] and
+            not is_prod_appengine_mvms())
+
+
+def is_prod_appengine_mvms():
+    return os.environ.get('GAE_VM', False) == 'true'
diff --git a/pipenv/vendor/urllib3/contrib/_securetransport/__init__.py b/pipenv/vendor/urllib3/contrib/_securetransport/__init__.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/contrib/_securetransport/bindings.py b/pipenv/vendor/urllib3/contrib/_securetransport/bindings.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/contrib/_securetransport/low_level.py b/pipenv/vendor/urllib3/contrib/_securetransport/low_level.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/contrib/appengine.py b/pipenv/vendor/urllib3/contrib/appengine.py
old mode 100755
new mode 100644
index 66922e06..2952f114
--- a/pipenv/vendor/urllib3/contrib/appengine.py
+++ b/pipenv/vendor/urllib3/contrib/appengine.py
@@ -39,8 +39,8 @@ urllib3 on Google App Engine:
 """
 
 from __future__ import absolute_import
+import io
 import logging
-import os
 import warnings
 from ..packages.six.moves.urllib.parse import urljoin
 
@@ -53,11 +53,11 @@ from ..exceptions import (
     SSLError
 )
 
-from ..packages.six import BytesIO
 from ..request import RequestMethods
 from ..response import HTTPResponse
 from ..util.timeout import Timeout
 from ..util.retry import Retry
+from . import _appengine_environ
 
 try:
     from google.appengine.api import urlfetch
@@ -239,7 +239,7 @@ class AppEngineManager(RequestMethods):
         original_response = HTTPResponse(
             # In order for decoding to work, we must present the content as
             # a file-like object.
-            body=BytesIO(urlfetch_resp.content),
+            body=io.BytesIO(urlfetch_resp.content),
             msg=urlfetch_resp.header_msg,
             headers=urlfetch_resp.headers,
             status=urlfetch_resp.status_code,
@@ -247,7 +247,7 @@ class AppEngineManager(RequestMethods):
         )
 
         return HTTPResponse(
-            body=BytesIO(urlfetch_resp.content),
+            body=io.BytesIO(urlfetch_resp.content),
             headers=urlfetch_resp.headers,
             status=urlfetch_resp.status_code,
             original_response=original_response,
@@ -280,26 +280,10 @@ class AppEngineManager(RequestMethods):
         return retries
 
 
-def is_appengine():
-    return (is_local_appengine() or
-            is_prod_appengine() or
-            is_prod_appengine_mvms())
+# Alias methods from _appengine_environ to maintain public API interface.
 
-
-def is_appengine_sandbox():
-    return is_appengine() and not is_prod_appengine_mvms()
-
-
-def is_local_appengine():
-    return ('APPENGINE_RUNTIME' in os.environ and
-            'Development/' in os.environ['SERVER_SOFTWARE'])
-
-
-def is_prod_appengine():
-    return ('APPENGINE_RUNTIME' in os.environ and
-            'Google App Engine/' in os.environ['SERVER_SOFTWARE'] and
-            not is_prod_appengine_mvms())
-
-
-def is_prod_appengine_mvms():
-    return os.environ.get('GAE_VM', False) == 'true'
+is_appengine = _appengine_environ.is_appengine
+is_appengine_sandbox = _appengine_environ.is_appengine_sandbox
+is_local_appengine = _appengine_environ.is_local_appengine
+is_prod_appengine = _appengine_environ.is_prod_appengine
+is_prod_appengine_mvms = _appengine_environ.is_prod_appengine_mvms
diff --git a/pipenv/vendor/urllib3/contrib/ntlmpool.py b/pipenv/vendor/urllib3/contrib/ntlmpool.py
old mode 100755
new mode 100644
index 642e99ed..8ea127c5
--- a/pipenv/vendor/urllib3/contrib/ntlmpool.py
+++ b/pipenv/vendor/urllib3/contrib/ntlmpool.py
@@ -43,8 +43,7 @@ class NTLMConnectionPool(HTTPSConnectionPool):
         log.debug('Starting NTLM HTTPS connection no. %d: https://%s%s',
                   self.num_connections, self.host, self.authurl)
 
-        headers = {}
-        headers['Connection'] = 'Keep-Alive'
+        headers = {'Connection': 'Keep-Alive'}
         req_header = 'Authorization'
         resp_header = 'www-authenticate'
 
diff --git a/pipenv/vendor/urllib3/contrib/pyopenssl.py b/pipenv/vendor/urllib3/contrib/pyopenssl.py
old mode 100755
new mode 100644
index 4d4b1aff..7c0e9465
--- a/pipenv/vendor/urllib3/contrib/pyopenssl.py
+++ b/pipenv/vendor/urllib3/contrib/pyopenssl.py
@@ -163,6 +163,9 @@ def _dnsname_to_stdlib(name):
     from ASCII bytes. We need to idna-encode that string to get it back, and
     then on Python 3 we also need to convert to unicode via UTF-8 (the stdlib
     uses PyUnicode_FromStringAndSize on it, which decodes via UTF-8).
+
+    If the name cannot be idna-encoded then we return None signalling that
+    the name given should be skipped.
     """
     def idna_encode(name):
         """
@@ -172,14 +175,19 @@ def _dnsname_to_stdlib(name):
         """
         import idna
 
-        for prefix in [u'*.', u'.']:
-            if name.startswith(prefix):
-                name = name[len(prefix):]
-                return prefix.encode('ascii') + idna.encode(name)
-        return idna.encode(name)
+        try:
+            for prefix in [u'*.', u'.']:
+                if name.startswith(prefix):
+                    name = name[len(prefix):]
+                    return prefix.encode('ascii') + idna.encode(name)
+            return idna.encode(name)
+        except idna.core.IDNAError:
+            return None
 
     name = idna_encode(name)
-    if sys.version_info >= (3, 0):
+    if name is None:
+        return None
+    elif sys.version_info >= (3, 0):
         name = name.decode('utf-8')
     return name
 
@@ -223,9 +231,10 @@ def get_subj_alt_name(peer_cert):
     # Sadly the DNS names need to be idna encoded and then, on Python 3, UTF-8
     # decoded. This is pretty frustrating, but that's what the standard library
     # does with certificates, and so we need to attempt to do the same.
+    # We also want to skip over names which cannot be idna encoded.
     names = [
-        ('DNS', _dnsname_to_stdlib(name))
-        for name in ext.get_values_for_type(x509.DNSName)
+        ('DNS', name) for name in map(_dnsname_to_stdlib, ext.get_values_for_type(x509.DNSName))
+        if name is not None
     ]
     names.extend(
         ('IP Address', str(name))
diff --git a/pipenv/vendor/urllib3/contrib/securetransport.py b/pipenv/vendor/urllib3/contrib/securetransport.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/contrib/socks.py b/pipenv/vendor/urllib3/contrib/socks.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/exceptions.py b/pipenv/vendor/urllib3/exceptions.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/fields.py b/pipenv/vendor/urllib3/fields.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/filepost.py b/pipenv/vendor/urllib3/filepost.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/packages/__init__.py b/pipenv/vendor/urllib3/packages/__init__.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/packages/backports/__init__.py b/pipenv/vendor/urllib3/packages/backports/__init__.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/packages/backports/makefile.py b/pipenv/vendor/urllib3/packages/backports/makefile.py
old mode 100755
new mode 100644
index 75b80dcf..740db377
--- a/pipenv/vendor/urllib3/packages/backports/makefile.py
+++ b/pipenv/vendor/urllib3/packages/backports/makefile.py
@@ -16,7 +16,7 @@ def backport_makefile(self, mode="r", buffering=None, encoding=None,
     """
     Backport of ``socket.makefile`` from Python 3.5.
     """
-    if not set(mode) <= set(["r", "w", "b"]):
+    if not set(mode) <= {"r", "w", "b"}:
         raise ValueError(
             "invalid mode %r (only r, w, b allowed)" % (mode,)
         )
diff --git a/pipenv/vendor/urllib3/packages/ordered_dict.py b/pipenv/vendor/urllib3/packages/ordered_dict.py
deleted file mode 100755
index 4479363c..00000000
--- a/pipenv/vendor/urllib3/packages/ordered_dict.py
+++ /dev/null
@@ -1,259 +0,0 @@
-# Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy.
-# Passes Python2.7's test suite and incorporates all the latest updates.
-# Copyright 2009 Raymond Hettinger, released under the MIT License.
-# http://code.activestate.com/recipes/576693/
-try:
-    from thread import get_ident as _get_ident
-except ImportError:
-    from dummy_thread import get_ident as _get_ident
-
-try:
-    from _abcoll import KeysView, ValuesView, ItemsView
-except ImportError:
-    pass
-
-
-class OrderedDict(dict):
-    'Dictionary that remembers insertion order'
-    # An inherited dict maps keys to values.
-    # The inherited dict provides __getitem__, __len__, __contains__, and get.
-    # The remaining methods are order-aware.
-    # Big-O running times for all methods are the same as for regular dictionaries.
-
-    # The internal self.__map dictionary maps keys to links in a doubly linked list.
-    # The circular doubly linked list starts and ends with a sentinel element.
-    # The sentinel element never gets deleted (this simplifies the algorithm).
-    # Each link is stored as a list of length three:  [PREV, NEXT, KEY].
-
-    def __init__(self, *args, **kwds):
-        '''Initialize an ordered dictionary.  Signature is the same as for
-        regular dictionaries, but keyword arguments are not recommended
-        because their insertion order is arbitrary.
-
-        '''
-        if len(args) > 1:
-            raise TypeError('expected at most 1 arguments, got %d' % len(args))
-        try:
-            self.__root
-        except AttributeError:
-            self.__root = root = []                     # sentinel node
-            root[:] = [root, root, None]
-            self.__map = {}
-        self.__update(*args, **kwds)
-
-    def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
-        'od.__setitem__(i, y) <==> od[i]=y'
-        # Setting a new item creates a new link which goes at the end of the linked
-        # list, and the inherited dictionary is updated with the new key/value pair.
-        if key not in self:
-            root = self.__root
-            last = root[0]
-            last[1] = root[0] = self.__map[key] = [last, root, key]
-        dict_setitem(self, key, value)
-
-    def __delitem__(self, key, dict_delitem=dict.__delitem__):
-        'od.__delitem__(y) <==> del od[y]'
-        # Deleting an existing item uses self.__map to find the link which is
-        # then removed by updating the links in the predecessor and successor nodes.
-        dict_delitem(self, key)
-        link_prev, link_next, key = self.__map.pop(key)
-        link_prev[1] = link_next
-        link_next[0] = link_prev
-
-    def __iter__(self):
-        'od.__iter__() <==> iter(od)'
-        root = self.__root
-        curr = root[1]
-        while curr is not root:
-            yield curr[2]
-            curr = curr[1]
-
-    def __reversed__(self):
-        'od.__reversed__() <==> reversed(od)'
-        root = self.__root
-        curr = root[0]
-        while curr is not root:
-            yield curr[2]
-            curr = curr[0]
-
-    def clear(self):
-        'od.clear() -> None.  Remove all items from od.'
-        try:
-            for node in self.__map.itervalues():
-                del node[:]
-            root = self.__root
-            root[:] = [root, root, None]
-            self.__map.clear()
-        except AttributeError:
-            pass
-        dict.clear(self)
-
-    def popitem(self, last=True):
-        '''od.popitem() -> (k, v), return and remove a (key, value) pair.
-        Pairs are returned in LIFO order if last is true or FIFO order if false.
-
-        '''
-        if not self:
-            raise KeyError('dictionary is empty')
-        root = self.__root
-        if last:
-            link = root[0]
-            link_prev = link[0]
-            link_prev[1] = root
-            root[0] = link_prev
-        else:
-            link = root[1]
-            link_next = link[1]
-            root[1] = link_next
-            link_next[0] = root
-        key = link[2]
-        del self.__map[key]
-        value = dict.pop(self, key)
-        return key, value
-
-    # -- the following methods do not depend on the internal structure --
-
-    def keys(self):
-        'od.keys() -> list of keys in od'
-        return list(self)
-
-    def values(self):
-        'od.values() -> list of values in od'
-        return [self[key] for key in self]
-
-    def items(self):
-        'od.items() -> list of (key, value) pairs in od'
-        return [(key, self[key]) for key in self]
-
-    def iterkeys(self):
-        'od.iterkeys() -> an iterator over the keys in od'
-        return iter(self)
-
-    def itervalues(self):
-        'od.itervalues -> an iterator over the values in od'
-        for k in self:
-            yield self[k]
-
-    def iteritems(self):
-        'od.iteritems -> an iterator over the (key, value) items in od'
-        for k in self:
-            yield (k, self[k])
-
-    def update(*args, **kwds):
-        '''od.update(E, **F) -> None.  Update od from dict/iterable E and F.
-
-        If E is a dict instance, does:           for k in E: od[k] = E[k]
-        If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]
-        Or if E is an iterable of items, does:   for k, v in E: od[k] = v
-        In either case, this is followed by:     for k, v in F.items(): od[k] = v
-
-        '''
-        if len(args) > 2:
-            raise TypeError('update() takes at most 2 positional '
-                            'arguments (%d given)' % (len(args),))
-        elif not args:
-            raise TypeError('update() takes at least 1 argument (0 given)')
-        self = args[0]
-        # Make progressively weaker assumptions about "other"
-        other = ()
-        if len(args) == 2:
-            other = args[1]
-        if isinstance(other, dict):
-            for key in other:
-                self[key] = other[key]
-        elif hasattr(other, 'keys'):
-            for key in other.keys():
-                self[key] = other[key]
-        else:
-            for key, value in other:
-                self[key] = value
-        for key, value in kwds.items():
-            self[key] = value
-
-    __update = update  # let subclasses override update without breaking __init__
-
-    __marker = object()
-
-    def pop(self, key, default=__marker):
-        '''od.pop(k[,d]) -> v, remove specified key and return the corresponding value.
-        If key is not found, d is returned if given, otherwise KeyError is raised.
-
-        '''
-        if key in self:
-            result = self[key]
-            del self[key]
-            return result
-        if default is self.__marker:
-            raise KeyError(key)
-        return default
-
-    def setdefault(self, key, default=None):
-        'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
-        if key in self:
-            return self[key]
-        self[key] = default
-        return default
-
-    def __repr__(self, _repr_running={}):
-        'od.__repr__() <==> repr(od)'
-        call_key = id(self), _get_ident()
-        if call_key in _repr_running:
-            return '...'
-        _repr_running[call_key] = 1
-        try:
-            if not self:
-                return '%s()' % (self.__class__.__name__,)
-            return '%s(%r)' % (self.__class__.__name__, self.items())
-        finally:
-            del _repr_running[call_key]
-
-    def __reduce__(self):
-        'Return state information for pickling'
-        items = [[k, self[k]] for k in self]
-        inst_dict = vars(self).copy()
-        for k in vars(OrderedDict()):
-            inst_dict.pop(k, None)
-        if inst_dict:
-            return (self.__class__, (items,), inst_dict)
-        return self.__class__, (items,)
-
-    def copy(self):
-        'od.copy() -> a shallow copy of od'
-        return self.__class__(self)
-
-    @classmethod
-    def fromkeys(cls, iterable, value=None):
-        '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
-        and values equal to v (which defaults to None).
-
-        '''
-        d = cls()
-        for key in iterable:
-            d[key] = value
-        return d
-
-    def __eq__(self, other):
-        '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
-        while comparison to a regular mapping is order-insensitive.
-
-        '''
-        if isinstance(other, OrderedDict):
-            return len(self)==len(other) and self.items() == other.items()
-        return dict.__eq__(self, other)
-
-    def __ne__(self, other):
-        return not self == other
-
-    # -- the following methods are only used in Python 2.7 --
-
-    def viewkeys(self):
-        "od.viewkeys() -> a set-like object providing a view on od's keys"
-        return KeysView(self)
-
-    def viewvalues(self):
-        "od.viewvalues() -> an object providing a view on od's values"
-        return ValuesView(self)
-
-    def viewitems(self):
-        "od.viewitems() -> a set-like object providing a view on od's items"
-        return ItemsView(self)
diff --git a/pipenv/vendor/urllib3/packages/six.py b/pipenv/vendor/urllib3/packages/six.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/packages/ssl_match_hostname/__init__.py b/pipenv/vendor/urllib3/packages/ssl_match_hostname/__init__.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/packages/ssl_match_hostname/_implementation.py b/pipenv/vendor/urllib3/packages/ssl_match_hostname/_implementation.py
old mode 100755
new mode 100644
index 1fd42f38..d6e66c01
--- a/pipenv/vendor/urllib3/packages/ssl_match_hostname/_implementation.py
+++ b/pipenv/vendor/urllib3/packages/ssl_match_hostname/_implementation.py
@@ -9,8 +9,7 @@ import sys
 # ipaddress has been backported to 2.6+ in pypi.  If it is installed on the
 # system, use it to handle IPAddress ServerAltnames (this was added in
 # python-3.5) otherwise only do DNS matching.  This allows
-# backports.ssl_match_hostname to continue to be used all the way back to
-# python-2.4.
+# backports.ssl_match_hostname to continue to be used in Python 2.7.
 try:
     import ipaddress
 except ImportError:
diff --git a/pipenv/vendor/urllib3/poolmanager.py b/pipenv/vendor/urllib3/poolmanager.py
old mode 100755
new mode 100644
index 506a3c9b..fe5491cf
--- a/pipenv/vendor/urllib3/poolmanager.py
+++ b/pipenv/vendor/urllib3/poolmanager.py
@@ -47,6 +47,7 @@ _key_fields = (
     'key__socks_options',  # dict
     'key_assert_hostname',  # bool or string
     'key_assert_fingerprint',  # str
+    'key_server_hostname', #str
 )
 
 #: The namedtuple class used to construct keys for the connection pool.
diff --git a/pipenv/vendor/urllib3/request.py b/pipenv/vendor/urllib3/request.py
old mode 100755
new mode 100644
index 1be33341..8f2f44bb
--- a/pipenv/vendor/urllib3/request.py
+++ b/pipenv/vendor/urllib3/request.py
@@ -36,7 +36,7 @@ class RequestMethods(object):
         explicitly.
     """
 
-    _encode_url_methods = set(['DELETE', 'GET', 'HEAD', 'OPTIONS'])
+    _encode_url_methods = {'DELETE', 'GET', 'HEAD', 'OPTIONS'}
 
     def __init__(self, headers=None):
         self.headers = headers or {}
diff --git a/pipenv/vendor/urllib3/response.py b/pipenv/vendor/urllib3/response.py
old mode 100755
new mode 100644
index 9873cb94..f0cfbb54
--- a/pipenv/vendor/urllib3/response.py
+++ b/pipenv/vendor/urllib3/response.py
@@ -11,7 +11,7 @@ from .exceptions import (
     BodyNotHttplibCompatible, ProtocolError, DecodeError, ReadTimeoutError,
     ResponseNotChunked, IncompleteRead, InvalidHeader
 )
-from .packages.six import string_types as basestring, binary_type, PY3
+from .packages.six import string_types as basestring, PY3
 from .packages.six.moves import http_client as httplib
 from .connection import HTTPException, BaseSSLError
 from .util.response import is_fp_closed, is_response_to_head
@@ -23,7 +23,7 @@ class DeflateDecoder(object):
 
     def __init__(self):
         self._first_try = True
-        self._data = binary_type()
+        self._data = b''
         self._obj = zlib.decompressobj()
 
     def __getattr__(self, name):
@@ -69,7 +69,7 @@ class GzipDecoder(object):
         return getattr(self._obj, name)
 
     def decompress(self, data):
-        ret = binary_type()
+        ret = b''
         if self._state == GzipDecoderState.SWALLOW_DATA or not data:
             return ret
         while True:
@@ -90,7 +90,31 @@ class GzipDecoder(object):
             self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS)
 
 
+class MultiDecoder(object):
+    """
+    From RFC7231:
+        If one or more encodings have been applied to a representation, the
+        sender that applied the encodings MUST generate a Content-Encoding
+        header field that lists the content codings in the order in which
+        they were applied.
+    """
+
+    def __init__(self, modes):
+        self._decoders = [_get_decoder(m.strip()) for m in modes.split(',')]
+
+    def flush(self):
+        return self._decoders[0].flush()
+
+    def decompress(self, data):
+        for d in reversed(self._decoders):
+            data = d.decompress(data)
+        return data
+
+
 def _get_decoder(mode):
+    if ',' in mode:
+        return MultiDecoder(mode)
+
     if mode == 'gzip':
         return GzipDecoder()
 
@@ -159,7 +183,7 @@ class HTTPResponse(io.IOBase):
         self.msg = msg
         self._request_url = request_url
 
-        if body and isinstance(body, (basestring, binary_type)):
+        if body and isinstance(body, (basestring, bytes)):
             self._body = body
 
         self._pool = pool
@@ -283,8 +307,13 @@ class HTTPResponse(io.IOBase):
         # Note: content-encoding value should be case-insensitive, per RFC 7230
         # Section 3.2
         content_encoding = self.headers.get('content-encoding', '').lower()
-        if self._decoder is None and content_encoding in self.CONTENT_DECODERS:
-            self._decoder = _get_decoder(content_encoding)
+        if self._decoder is None:
+            if content_encoding in self.CONTENT_DECODERS:
+                self._decoder = _get_decoder(content_encoding)
+            elif ',' in content_encoding:
+                encodings = [e.strip() for e in content_encoding.split(',') if e.strip() in self.CONTENT_DECODERS]
+                if len(encodings):
+                    self._decoder = _get_decoder(content_encoding)
 
     def _decode(self, data, decode_content, flush_decoder):
         """
diff --git a/pipenv/vendor/urllib3/util/__init__.py b/pipenv/vendor/urllib3/util/__init__.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/util/connection.py b/pipenv/vendor/urllib3/util/connection.py
old mode 100755
new mode 100644
index 5cf488f4..5ad70b2f
--- a/pipenv/vendor/urllib3/util/connection.py
+++ b/pipenv/vendor/urllib3/util/connection.py
@@ -1,6 +1,7 @@
 from __future__ import absolute_import
 import socket
 from .wait import NoWayToWaitForSocketError, wait_for_read
+from ..contrib import _appengine_environ
 
 
 def is_connection_dropped(conn):  # Platform-specific
@@ -105,6 +106,13 @@ def _has_ipv6(host):
     sock = None
     has_ipv6 = False
 
+    # App Engine doesn't support IPV6 sockets and actually has a quota on the
+    # number of sockets that can be used, so just early out here instead of
+    # creating a socket needlessly.
+    # See https://github.com/urllib3/urllib3/issues/1446
+    if _appengine_environ.is_appengine_sandbox():
+        return False
+
     if socket.has_ipv6:
         # has_ipv6 returns true if cPython was compiled with IPv6 support.
         # It does not tell us if the system has IPv6 support enabled. To
diff --git a/pipenv/vendor/urllib3/util/queue.py b/pipenv/vendor/urllib3/util/queue.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/util/request.py b/pipenv/vendor/urllib3/util/request.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/util/response.py b/pipenv/vendor/urllib3/util/response.py
old mode 100755
new mode 100644
index 67cf730a..3d548648
--- a/pipenv/vendor/urllib3/util/response.py
+++ b/pipenv/vendor/urllib3/util/response.py
@@ -59,8 +59,14 @@ def assert_header_parsing(headers):
     get_payload = getattr(headers, 'get_payload', None)
 
     unparsed_data = None
-    if get_payload:  # Platform-specific: Python 3.
-        unparsed_data = get_payload()
+    if get_payload:
+        # get_payload is actually email.message.Message.get_payload;
+        # we're only interested in the result if it's not a multipart message
+        if not headers.is_multipart():
+            payload = get_payload()
+
+            if isinstance(payload, (bytes, str)):
+                unparsed_data = payload
 
     if defects or unparsed_data:
         raise HeaderParsingError(defects=defects, unparsed_data=unparsed_data)
diff --git a/pipenv/vendor/urllib3/util/retry.py b/pipenv/vendor/urllib3/util/retry.py
old mode 100755
new mode 100644
index 7ad3dc66..e7d0abd6
--- a/pipenv/vendor/urllib3/util/retry.py
+++ b/pipenv/vendor/urllib3/util/retry.py
@@ -115,7 +115,7 @@ class Retry(object):
         (most errors are resolved immediately by a second try without a
         delay). urllib3 will sleep for::
 
-            {backoff factor} * (2 ^ ({number of total retries} - 1))
+            {backoff factor} * (2 ** ({number of total retries} - 1))
 
         seconds. If the backoff_factor is 0.1, then :func:`.sleep` will sleep
         for [0.0s, 0.2s, 0.4s, ...] between retries. It will never be longer
diff --git a/pipenv/vendor/urllib3/util/ssl_.py b/pipenv/vendor/urllib3/util/ssl_.py
old mode 100755
new mode 100644
index 2893752a..24ee26d6
--- a/pipenv/vendor/urllib3/util/ssl_.py
+++ b/pipenv/vendor/urllib3/util/ssl_.py
@@ -56,9 +56,8 @@ except ImportError:
     OP_NO_COMPRESSION = 0x20000
 
 
-# Python 2.7 and earlier didn't have inet_pton on non-Linux
-# so we fallback on inet_aton in those cases. This means that
-# we can only detect IPv4 addresses in this case.
+# Python 2.7 doesn't have inet_pton on non-Linux so we fallback on inet_aton in
+# those cases. This means that we can only detect IPv4 addresses in this case.
 if hasattr(socket, 'inet_pton'):
     inet_pton = socket.inet_pton
 else:
@@ -67,7 +66,7 @@ else:
         import ipaddress
 
         def inet_pton(_, host):
-            if isinstance(host, six.binary_type):
+            if isinstance(host, bytes):
                 host = host.decode('ascii')
             return ipaddress.ip_address(host)
 
@@ -115,10 +114,7 @@ try:
 except ImportError:
     import sys
 
-    class SSLContext(object):  # Platform-specific: Python 2 & 3.1
-        supports_set_ciphers = ((2, 7) <= sys.version_info < (3,) or
-                                (3, 2) <= sys.version_info)
-
+    class SSLContext(object):  # Platform-specific: Python 2
         def __init__(self, protocol_version):
             self.protocol = protocol_version
             # Use default values from a real SSLContext
@@ -141,12 +137,6 @@ except ImportError:
                 raise SSLError("CA directories not supported in older Pythons")
 
         def set_ciphers(self, cipher_suite):
-            if not self.supports_set_ciphers:
-                raise TypeError(
-                    'Your version of Python does not support setting '
-                    'a custom cipher suite. Please upgrade to Python '
-                    '2.7, 3.2, or later if you need this functionality.'
-                )
             self.ciphers = cipher_suite
 
         def wrap_socket(self, socket, server_hostname=None, server_side=False):
@@ -167,10 +157,7 @@ except ImportError:
                 'ssl_version': self.protocol,
                 'server_side': server_side,
             }
-            if self.supports_set_ciphers:  # Platform-specific: Python 2.7+
-                return wrap_socket(socket, ciphers=self.ciphers, **kwargs)
-            else:  # Platform-specific: Python 2.6
-                return wrap_socket(socket, **kwargs)
+            return wrap_socket(socket, ciphers=self.ciphers, **kwargs)
 
 
 def assert_fingerprint(cert, fingerprint):
@@ -291,9 +278,6 @@ def create_urllib3_context(ssl_version=None, cert_reqs=None,
 
     context.options |= options
 
-    if getattr(context, 'supports_set_ciphers', True):  # Platform-specific: Python 2.6
-        context.set_ciphers(ciphers or DEFAULT_CIPHERS)
-
     context.verify_mode = cert_reqs
     if getattr(context, 'check_hostname', None) is not None:  # Platform-specific: Python 3.2
         # We do our own verification, including fingerprints and alternative
@@ -316,8 +300,7 @@ def ssl_wrap_socket(sock, keyfile=None, certfile=None, cert_reqs=None,
         A pre-made :class:`SSLContext` object. If none is provided, one will
         be created using :func:`create_urllib3_context`.
     :param ciphers:
-        A string of ciphers we wish the client to support. This is not
-        supported on Python 2.6 as the ssl module does not support it.
+        A string of ciphers we wish the client to support.
     :param ca_cert_dir:
         A directory containing CA certificates in multiple separate files, as
         supported by OpenSSL's -CApath flag or the capath argument to
@@ -334,7 +317,7 @@ def ssl_wrap_socket(sock, keyfile=None, certfile=None, cert_reqs=None,
     if ca_certs or ca_cert_dir:
         try:
             context.load_verify_locations(ca_certs, ca_cert_dir)
-        except IOError as e:  # Platform-specific: Python 2.6, 2.7, 3.2
+        except IOError as e:  # Platform-specific: Python 2.7
             raise SSLError(e)
         # Py33 raises FileNotFoundError which subclasses OSError
         # These are not equivalent unless we check the errno attribute
@@ -378,7 +361,7 @@ def is_ipaddress(hostname):
     :param str hostname: Hostname to examine.
     :return: True if the hostname is an IP address, False otherwise.
     """
-    if six.PY3 and isinstance(hostname, six.binary_type):
+    if six.PY3 and isinstance(hostname, bytes):
         # IDN A-label bytes are ASCII compatible.
         hostname = hostname.decode('ascii')
 
diff --git a/pipenv/vendor/urllib3/util/timeout.py b/pipenv/vendor/urllib3/util/timeout.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/util/url.py b/pipenv/vendor/urllib3/util/url.py
old mode 100755
new mode 100644
diff --git a/pipenv/vendor/urllib3/util/wait.py b/pipenv/vendor/urllib3/util/wait.py
old mode 100755
new mode 100644
index fa686eff..4db71baf
--- a/pipenv/vendor/urllib3/util/wait.py
+++ b/pipenv/vendor/urllib3/util/wait.py
@@ -43,9 +43,6 @@ if sys.version_info >= (3, 5):
 else:
     # Old and broken Pythons.
     def _retry_on_intr(fn, timeout):
-        if timeout is not None and timeout <= 0:
-            return fn(timeout)
-
         if timeout is None:
             deadline = float("inf")
         else:
@@ -117,7 +114,7 @@ def _have_working_poll():
     # from libraries like eventlet/greenlet.
     try:
         poll_obj = select.poll()
-        poll_obj.poll(0)
+        _retry_on_intr(poll_obj.poll, 0)
     except (AttributeError, OSError):
         return False
     else:
diff --git a/pipenv/vendor/vendor.txt b/pipenv/vendor/vendor.txt
index d1667eeb..2e00af0c 100644
--- a/pipenv/vendor/vendor.txt
+++ b/pipenv/vendor/vendor.txt
@@ -2,11 +2,11 @@ appdirs==1.4.3
 backports.shutil_get_terminal_size==1.0.0
 backports.weakref==1.0.post1
 blindspin==2.0.1
-click==6.7
+click==7.0
 click-completion==0.4.1
 click-didyoumean==0.0.3
 colorama==0.3.9
-delegator.py==0.1.0
+delegator.py==0.1.1
     pexpect==4.6.0
         ptyprocess==0.6.0
 python-dotenv==0.9.1
@@ -14,35 +14,40 @@ first==2.0.1
 iso8601==0.1.12
 jinja2==2.10
 markupsafe==1.0
-parse==1.8.4
+parse==1.9.0
 pathlib2==2.3.2
     scandir==1.9
 pipdeptree==0.13.0
 pipreqs==0.4.9
     docopt==0.6.2
     yarg==0.1.9
-pythonfinder==1.0.2
-requests==2.19.1
+pythonfinder==1.1.6
+requests==2.20.0
     chardet==3.0.4
     idna==2.7
-    urllib3==1.23
-    certifi==2018.8.24
-requirementslib==1.1.6
-    attrs==18.1.0
-    distlib==0.2.7
-    packaging==17.1
-    pyparsing==2.2.0
-    pytoml==0.1.18
-    plette==0.1.1
-        tomlkit==0.4.2
-shellingham==1.2.4
+    urllib3==1.24
+    certifi==2018.10.15
+requirementslib==1.2.3
+    attrs==18.2.0
+    distlib==0.2.8
+    packaging==18.0
+    pyparsing==2.2.2
+    pytoml==0.1.19
+    plette==0.2.2
+        tomlkit==0.4.6
+shellingham==1.2.7
 six==1.11.0
 semver==2.8.1
 shutilwhich==1.1.0
-toml==0.9.4
+toml==0.10.0
 cached-property==1.4.3
-vistir==0.1.4
-pip-shims==0.1.2
-    modutil==2.0.0
+vistir==0.2.2
+pip-shims==0.3.2
 ptyprocess==0.6.0
 enum34==1.1.6
+yaspin==0.14.0
+cerberus==1.2
+git+https://github.com/sarugaku/passa.git@master#egg=passa
+cursor==1.2.0
+resolvelib==0.2.2
+backports.functools_lru_cache==1.5
diff --git a/pipenv/vendor/vendor_pip.txt b/pipenv/vendor/vendor_pip.txt
index 3994e709..9389dd94 100644
--- a/pipenv/vendor/vendor_pip.txt
+++ b/pipenv/vendor/vendor_pip.txt
@@ -1,22 +1,23 @@
 appdirs==1.4.3
 distlib==0.2.7
-distro==1.2.0
+distro==1.3.0
 html5lib==1.0.1
 six==1.11.0
 colorama==0.3.9
-CacheControl==0.12.4
+CacheControl==0.12.5
 msgpack-python==0.5.6
 lockfile==0.12.2
-progress==1.3
-ipaddress==1.0.19  # Only needed on 2.6 and 2.7
-packaging==17.1
-pyparsing==2.2.0
-pytoml==0.1.14
+progress==1.4
+ipaddress==1.0.22  # Only needed on 2.6 and 2.7
+packaging==18.0
+pep517==0.2
+pyparsing==2.2.1
+pytoml==0.1.19
 retrying==1.3.3
-requests==2.18.4
+requests==2.19.1
     chardet==3.0.4
-    idna==2.6
-    urllib3==1.22
-    certifi==2018.1.18
-setuptools==39.1.0
+    idna==2.7
+    urllib3==1.23
+    certifi==2018.8.24
+setuptools==40.4.3
 webencodings==0.5.1
diff --git a/pipenv/vendor/vistir/__init__.py b/pipenv/vendor/vistir/__init__.py
index eeb8344c..c8a995fa 100644
--- a/pipenv/vendor/vistir/__init__.py
+++ b/pipenv/vendor/vistir/__init__.py
@@ -1,19 +1,37 @@
 # -*- coding=utf-8 -*-
 from __future__ import absolute_import, unicode_literals
 
-from .compat import NamedTemporaryFile, TemporaryDirectory, partialmethod
+from .compat import (
+    NamedTemporaryFile,
+    TemporaryDirectory,
+    partialmethod,
+    to_native_string,
+)
 from .contextmanagers import (
     atomic_open_for_write,
     cd,
     open_file,
     temp_environ,
     temp_path,
+    spinner,
 )
-from .misc import load_path, partialclass, run, shell_escape
-from .path import mkdir_p, rmtree
+from .misc import (
+    load_path,
+    partialclass,
+    run,
+    shell_escape,
+    decode_for_output,
+    to_text,
+    to_bytes,
+    take,
+    chunked,
+    divide,
+)
+from .path import mkdir_p, rmtree, create_tracked_tempdir, create_tracked_tempfile
+from .spin import VistirSpinner, create_spinner
 
 
-__version__ = '0.1.4'
+__version__ = "0.2.3"
 
 
 __all__ = [
@@ -31,4 +49,16 @@ __all__ = [
     "TemporaryDirectory",
     "NamedTemporaryFile",
     "partialmethod",
+    "spinner",
+    "VistirSpinner",
+    "create_spinner",
+    "create_tracked_tempdir",
+    "create_tracked_tempfile",
+    "to_native_string",
+    "decode_for_output",
+    "to_text",
+    "to_bytes",
+    "take",
+    "chunked",
+    "divide",
 ]
diff --git a/pipenv/vendor/vistir/backports/tempfile.py b/pipenv/vendor/vistir/backports/tempfile.py
index 483a479a..fb044acf 100644
--- a/pipenv/vendor/vistir/backports/tempfile.py
+++ b/pipenv/vendor/vistir/backports/tempfile.py
@@ -13,7 +13,7 @@ import six
 try:
     from weakref import finalize
 except ImportError:
-    from backports.weakref import finalize
+    from pipenv.vendor.backports.weakref import finalize
 
 
 __all__ = ["finalize", "NamedTemporaryFile"]
@@ -175,6 +175,7 @@ def NamedTemporaryFile(
     prefix=None,
     dir=None,
     delete=True,
+    wrapper_class_override=None
 ):
     """Create and return a temporary file.
     Arguments:
@@ -193,6 +194,8 @@ def NamedTemporaryFile(
     flags = _bin_openflags
     # Setting O_TEMPORARY in the flags causes the OS to delete
     # the file when it is closed.  This is only supported by Windows.
+    if not wrapper_class_override:
+        wrapper_class_override = _TemporaryFileWrapper
     if os.name == "nt" and delete:
         flags |= os.O_TEMPORARY
     if sys.version_info < (3, 5):
@@ -203,7 +206,12 @@ def NamedTemporaryFile(
         file = io.open(
             fd, mode, buffering=buffering, newline=newline, encoding=encoding
         )
-        return _TemporaryFileWrapper(file, name, delete)
+        if wrapper_class_override is not None:
+            return type(
+                str("_TempFileWrapper"), (wrapper_class_override, object), {}
+            )(file, name, delete)
+        else:
+            return _TemporaryFileWrapper(file, name, delete)
 
     except BaseException:
         os.unlink(name)
diff --git a/pipenv/vendor/vistir/compat.py b/pipenv/vendor/vistir/compat.py
index 1f1b7a96..d6e8578a 100644
--- a/pipenv/vendor/vistir/compat.py
+++ b/pipenv/vendor/vistir/compat.py
@@ -1,6 +1,7 @@
 # -*- coding=utf-8 -*-
 from __future__ import absolute_import, unicode_literals
 
+import errno
 import os
 import sys
 import warnings
@@ -16,22 +17,27 @@ __all__ = [
     "finalize",
     "partialmethod",
     "JSONDecodeError",
+    "FileNotFoundError",
     "ResourceWarning",
     "FileNotFoundError",
     "fs_str",
+    "lru_cache",
     "TemporaryDirectory",
     "NamedTemporaryFile",
+    "to_native_string",
 ]
 
 if sys.version_info >= (3, 5):
     from pathlib import Path
-
+    from functools import lru_cache
 else:
     from pathlib2 import Path
+    from pipenv.vendor.backports.functools_lru_cache import lru_cache
 
+from .backports.tempfile import NamedTemporaryFile as _NamedTemporaryFile
 if sys.version_info < (3, 3):
-    from backports.shutil_get_terminal_size import get_terminal_size
-    from .backports.tempfile import NamedTemporaryFile
+    from pipenv.vendor.backports.shutil_get_terminal_size import get_terminal_size
+    NamedTemporaryFile = _NamedTemporaryFile
 else:
     from tempfile import NamedTemporaryFile
     from shutil import get_terminal_size
@@ -39,7 +45,7 @@ else:
 try:
     from weakref import finalize
 except ImportError:
-    from backports.weakref import finalize
+    from pipenv.vendor.backports.weakref import finalize
 
 try:
     from functools import partialmethod
@@ -57,16 +63,18 @@ if six.PY2:
         pass
 
     class FileNotFoundError(IOError):
-        pass
+        """No such file or directory"""
+
+        def __init__(self, *args, **kwargs):
+            self.errno = errno.ENOENT
+            super(FileNotFoundError, self).__init__(*args, **kwargs)
 
 else:
     from builtins import ResourceWarning, FileNotFoundError
 
-    class ResourceWarning(ResourceWarning):
-        pass
 
-    class FileNotFoundError(FileNotFoundError):
-        pass
+if not sys.warnoptions:
+    warnings.simplefilter("default", ResourceWarning)
 
 
 class TemporaryDirectory(object):
@@ -135,3 +143,10 @@ def fs_str(string):
 
 
 _fs_encoding = sys.getfilesystemencoding() or sys.getdefaultencoding()
+
+
+def to_native_string(string):
+    from .misc import to_text, to_bytes
+    if six.PY2:
+        return to_bytes(string)
+    return to_text(string)
diff --git a/pipenv/vendor/vistir/contextmanagers.py b/pipenv/vendor/vistir/contextmanagers.py
index 80f1f897..59b97ca0 100644
--- a/pipenv/vendor/vistir/contextmanagers.py
+++ b/pipenv/vendor/vistir/contextmanagers.py
@@ -1,6 +1,7 @@
 # -*- coding=utf-8 -*-
 from __future__ import absolute_import, unicode_literals
 
+import io
 import os
 import stat
 import sys
@@ -13,7 +14,9 @@ from .compat import NamedTemporaryFile, Path
 from .path import is_file_url, is_valid_url, path_to_url, url_to_path
 
 
-__all__ = ["temp_environ", "temp_path", "cd", "atomic_open_for_write", "open_file"]
+__all__ = [
+    "temp_environ", "temp_path", "cd", "atomic_open_for_write", "open_file", "spinner"
+]
 
 
 # Borrowed from Pew.
@@ -77,6 +80,70 @@ def cd(path):
         os.chdir(prev_cwd)
 
 
+@contextmanager
+def dummy_spinner(spin_type, text, **kwargs):
+    class FakeClass(object):
+        def __init__(self, text=""):
+            self.text = text
+
+        def fail(self, exitcode=1, text=None):
+            if text:
+                print(text)
+            raise SystemExit(exitcode, text)
+
+        def ok(self, text):
+            print(text)
+            return 0
+
+        def write(self, text):
+            print(text)
+
+    myobj = FakeClass(text)
+    yield myobj
+
+
+@contextmanager
+def spinner(spinner_name=None, start_text=None, handler_map=None, nospin=False):
+    """Get a spinner object or a dummy spinner to wrap a context.
+
+    :param str spinner_name: A spinner type e.g. "dots" or "bouncingBar" (default: {"bouncingBar"})
+    :param str start_text: Text to start off the spinner with (default: {None})
+    :param dict handler_map: Handler map for signals to be handled gracefully (default: {None})
+    :param bool nospin: If true, use the dummy spinner (default: {False})
+    :return: A spinner object which can be manipulated while alive
+    :rtype: :class:`~vistir.spin.VistirSpinner`
+
+    Raises:
+        RuntimeError -- Raised if the spinner extra is not installed
+    """
+
+    from .spin import create_spinner
+    has_yaspin = False
+    try:
+        import yaspin
+    except ImportError:
+        if not nospin:
+            raise RuntimeError(
+                "Failed to import spinner! Reinstall vistir with command:"
+                " pip install --upgrade vistir[spinner]"
+            )
+        else:
+            spinner_name = ""
+    else:
+        has_yaspin = True
+        spinner_name = ""
+    if not start_text and nospin is False:
+        start_text = "Running..."
+    with create_spinner(
+        spinner_name=spinner_name,
+        text=start_text,
+        handler_map=handler_map,
+        nospin=nospin,
+        use_yaspin=has_yaspin
+    ) as _spinner:
+        yield _spinner
+
+
 @contextmanager
 def atomic_open_for_write(target, binary=False, newline=None, encoding=None):
     """Atomically open `target` for writing.
@@ -168,12 +235,13 @@ def atomic_open_for_write(target, binary=False, newline=None, encoding=None):
 
 
 @contextmanager
-def open_file(link, session=None):
+def open_file(link, session=None, stream=True):
     """
     Open local or remote file for reading.
 
     :type link: pip._internal.index.Link or str
     :type session: requests.Session
+    :param bool stream: Try to stream if remote, default True
     :raises ValueError: If link points to a local directory.
     :return: a context manager to the opened file-like object
     """
@@ -192,8 +260,8 @@ def open_file(link, session=None):
         if os.path.isdir(local_path):
             raise ValueError("Cannot open directory for read: {}".format(link))
         else:
-            with open(local_path, "rb") as local_file:
-                yield local_file
+                with io.open(local_path, "rb") as local_file:
+                    yield local_file
     else:
         # Remote URL
         headers = {"Accept-Encoding": "identity"}
@@ -201,8 +269,14 @@ def open_file(link, session=None):
             from requests import Session
 
             session = Session()
-        response = session.get(link, headers=headers, stream=True)
-        try:
-            yield response.raw
-        finally:
-            response.close()
+        with session.get(link, headers=headers, stream=stream) as resp:
+            try:
+                raw = getattr(resp, "raw", None)
+                result = raw if raw else resp
+                yield result
+            finally:
+                if raw:
+                    conn = getattr(raw, "_connection")
+                    if conn is not None:
+                        conn.close()
+                result.close()
diff --git a/pipenv/vendor/vistir/misc.py b/pipenv/vendor/vistir/misc.py
index 82bdf5ed..7342bc97 100644
--- a/pipenv/vendor/vistir/misc.py
+++ b/pipenv/vendor/vistir/misc.py
@@ -2,6 +2,7 @@
 from __future__ import absolute_import, unicode_literals
 
 import json
+import logging
 import locale
 import os
 import subprocess
@@ -9,19 +10,51 @@ import sys
 
 from collections import OrderedDict
 from functools import partial
+from itertools import islice
 
 import six
 
 from .cmdparse import Script
-from .compat import Path, fs_str, partialmethod
+from .compat import Path, fs_str, partialmethod, to_native_string
+from .contextmanagers import spinner as spinner
+
+if os.name != "nt":
+    class WindowsError(OSError):
+        pass
 
 
 __all__ = [
-    "shell_escape", "unnest", "dedup", "run", "load_path", "partialclass", "to_text",
-    "to_bytes", "locale_encoding"
+    "shell_escape",
+    "unnest",
+    "dedup",
+    "run",
+    "load_path",
+    "partialclass",
+    "to_text",
+    "to_bytes",
+    "locale_encoding",
+    "chunked",
+    "take",
+    "divide"
 ]
 
 
+def _get_logger(name=None, level="ERROR"):
+    if not name:
+        name = __name__
+    if isinstance(level, six.string_types):
+        level = getattr(logging, level.upper())
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    formatter = logging.Formatter(
+        "%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s"
+    )
+    handler = logging.StreamHandler(stream=sys.stderr)
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    return logger
+
+
 def shell_escape(cmd):
     """Escape strings for use in :func:`~subprocess.Popen` and :func:`run`.
 
@@ -67,38 +100,181 @@ def dedup(iterable):
     return iter(OrderedDict.fromkeys(iterable))
 
 
-def _spawn_subprocess(script, env={}):
+def _spawn_subprocess(script, env=None, block=True, cwd=None, combine_stderr=True):
     from distutils.spawn import find_executable
+
+    if not env:
+        env = {}
     command = find_executable(script.command)
     options = {
         "env": env,
         "universal_newlines": True,
         "stdout": subprocess.PIPE,
-        "stderr": subprocess.PIPE,
+        "stderr": subprocess.PIPE if not combine_stderr else subprocess.STDOUT,
+        "shell": False,
     }
+    if not block:
+        options["stdin"] = subprocess.PIPE
+    if cwd:
+        options["cwd"] = cwd
     # Command not found, maybe this is a shell built-in?
+    cmd = [command] + script.args
     if not command:  # Try to use CreateProcess directly if possible.
-        return subprocess.Popen(script.cmdify(), shell=True, **options)
+        cmd = script.cmdify()
+        options["shell"] = True
+
     # Try to use CreateProcess directly if possible. Specifically catch
     # Windows error 193 "Command is not a valid Win32 application" to handle
     # a "command" that is non-executable. See pypa/pipenv#2727.
     try:
-        return subprocess.Popen([command] + script.args, **options)
+        return subprocess.Popen(cmd, **options)
     except WindowsError as e:
-        if e.winerror != 193:
+        if getattr(e, "winerror", 9999) != 193:
             raise
+    options["shell"] = True
     # Try shell mode to use Windows's file association for file launch.
-    return subprocess.Popen(script.cmdify(), shell=True, **options)
+    return subprocess.Popen(script.cmdify(), **options)
 
 
-def run(cmd, env={}, return_object=False):
+def _create_subprocess(
+    cmd,
+    env=None,
+    block=True,
+    return_object=False,
+    cwd=os.curdir,
+    verbose=False,
+    spinner=None,
+    combine_stderr=False,
+    display_limit=200,
+    start_text=""
+):
+    if not env:
+        env = {}
+    try:
+        c = _spawn_subprocess(cmd, env=env, block=block, cwd=cwd,
+                                                    combine_stderr=combine_stderr)
+    except Exception as exc:
+        print("Error %s while executing command %s", exc, " ".join(cmd._parts))
+        raise
+    if not block:
+        c.stdin.close()
+        output = []
+        err = []
+        spinner_orig_text = None
+        if spinner:
+            spinner_orig_text = getattr(spinner, "text", None)
+        if spinner_orig_text is None:
+            spinner_orig_text = start_text if start_text is not None else ""
+        streams = {
+            "stdout": c.stdout,
+            "stderr": c.stderr
+        }
+        while True:
+            stdout_line = None
+            stderr_line = None
+            for outstream in streams.keys():
+                stream = streams[outstream]
+                if not stream:
+                    continue
+                line = to_text(stream.readline())
+                if not line:
+                    continue
+                line = to_text("{0}".format(line.rstrip()))
+                if outstream == "stderr":
+                    stderr_line = line
+                else:
+                    stdout_line = line
+            if not (stdout_line or stderr_line):
+                break
+            if stderr_line is not None:
+                err.append(stderr_line)
+                err_line = fs_str("{0}".format(stderr_line))
+                if verbose and err_line is not None:
+                    if spinner:
+                        spinner._hide_cursor()
+                        spinner.write_err(err_line)
+                        spinner._show_cursor()
+                    else:
+                        sys.stderr.write(err_line)
+                        sys.stderr.flush()
+            if stdout_line is not None:
+                output.append(stdout_line)
+                display_line = fs_str("{0}".format(stdout_line))
+                if len(stdout_line) > display_limit:
+                    display_line = "{0}...".format(stdout_line[:display_limit])
+                if verbose and display_line is not None:
+                    if spinner:
+                        spinner._hide_cursor()
+                        spinner.write_err(display_line)
+                        spinner._show_cursor()
+                    else:
+                        sys.stderr.write(display_line)
+                        sys.stderr.flush()
+                if spinner:
+                    spinner.text = to_native_string("{0} {1}".format(spinner_orig_text, display_line))
+                continue
+        try:
+            c.wait()
+        finally:
+            if c.stdout:
+                c.stdout.close()
+            if c.stderr:
+                c.stderr.close()
+        if spinner:
+            if c.returncode > 0:
+                spinner.fail(to_native_string("Failed...cleaning up..."))
+            if not os.name == "nt":
+                spinner.ok(to_native_string("✔ Complete"))
+            else:
+                spinner.ok(to_native_string("Complete"))
+        c.out = "\n".join(output) if output else ""
+        c.err = "\n".join(err) if err else ""
+    else:
+        c.out, c.err = c.communicate()
+    if not block:
+        c.wait()
+    c.out = to_text("{0}".format(c.out)) if c.out else fs_str("")
+    c.err = to_text("{0}".format(c.err)) if c.err else fs_str("")
+    if not return_object:
+        return c.out.strip(), c.err.strip()
+    return c
+
+
+def run(
+    cmd,
+    env=None,
+    return_object=False,
+    block=True,
+    cwd=None,
+    verbose=False,
+    nospin=False,
+    spinner_name=None,
+    combine_stderr=True,
+    display_limit=200
+):
     """Use `subprocess.Popen` to get the output of a command and decode it.
 
     :param list cmd: A list representing the command you want to run.
     :param dict env: Additional environment settings to pass through to the subprocess.
     :param bool return_object: When True, returns the whole subprocess instance
-    :returns: A 2-tuple of (output, error)
+    :param bool block: When False, returns a potentially still-running :class:`subprocess.Popen` instance
+    :param str cwd: Current working directory contect to use for spawning the subprocess.
+    :param bool verbose: Whether to print stdout in real time when non-blocking.
+    :param bool nospin: Whether to disable the cli spinner.
+    :param str spinner_name: The name of the spinner to use if enabled, defaults to bouncingBar
+    :param bool combine_stderr: Optionally merge stdout and stderr in the subprocess, false if nonblocking.
+    :param int dispay_limit: The max width of output lines to display when using a spinner.
+    :returns: A 2-tuple of (output, error) or a :class:`subprocess.Popen` object.
+
+    .. Warning:: Merging standard out and standarad error in a nonblocking subprocess
+        can cause errors in some cases and may not be ideal. Consider disabling
+        this functionality.
     """
+
+    _env = os.environ.copy()
+    if env:
+        _env.update(env)
+    env = _env
     if six.PY2:
         fs_encode = partial(to_bytes, encoding=locale_encoding)
         _env = {fs_encode(k): fs_encode(v) for k, v in os.environ.items()}
@@ -106,6 +282,8 @@ def run(cmd, env={}, return_object=False):
             _env[fs_encode(key)] = fs_encode(val)
     else:
         _env = {k: fs_str(v) for k, v in os.environ.items()}
+    if not spinner_name:
+        spinner_name = "bouncingBar"
     if six.PY2:
         if isinstance(cmd, six.string_types):
             cmd = cmd.encode("utf-8")
@@ -113,11 +291,21 @@ def run(cmd, env={}, return_object=False):
             cmd = [c.encode("utf-8") for c in cmd]
     if not isinstance(cmd, Script):
         cmd = Script.parse(cmd)
-    c = _spawn_subprocess(cmd, env=_env)
-    out, err = c.communicate()
-    if not return_object:
-        return out.strip(), err.strip()
-    return c
+    if block or not return_object:
+        combine_stderr = False
+    start_text = ""
+    with spinner(spinner_name=spinner_name, start_text=start_text, nospin=nospin) as sp:
+        return _create_subprocess(
+            cmd,
+            env=_env,
+            return_object=return_object,
+            block=block,
+            cwd=cwd,
+            verbose=verbose,
+            spinner=sp,
+            combine_stderr=combine_stderr,
+            start_text=start_text
+        )
 
 
 def load_path(python):
@@ -132,7 +320,8 @@ def load_path(python):
     """
 
     python = Path(python).as_posix()
-    out, err = run([python, "-c", "import json, sys; print(json.dumps(sys.path))"])
+    out, err = run([python, "-c", "import json, sys; print(json.dumps(sys.path))"],
+                        nospin=True)
     if out:
         return json.loads(out)
     else:
@@ -158,20 +347,18 @@ def partialclass(cls, *args, **kwargs):
     {'url': 'https://pypi.org/simple', 'verify_ssl': True, 'name': 'pypi'}
     """
 
-    name_attrs = [n for n in (getattr(cls, name, str(cls)) for name in ("__name__", "__qualname__")) if n is not None]
+    name_attrs = [
+        n
+        for n in (getattr(cls, name, str(cls)) for name in ("__name__", "__qualname__"))
+        if n is not None
+    ]
     name_attrs = name_attrs[0]
     type_ = type(
-        name_attrs,
-        (cls,),
-        {
-            "__init__": partialmethod(cls.__init__, *args, **kwargs),
-        }
+        name_attrs, (cls,), {"__init__": partialmethod(cls.__init__, *args, **kwargs)}
     )
     # Swiped from attrs.make_class
     try:
-        type_.__module__ = sys._getframe(1).f_globals.get(
-            "__name__", "__main__",
-        )
+        type_.__module__ = sys._getframe(1).f_globals.get("__name__", "__main__")
     except (AttributeError, ValueError):
         pass
     return type_
@@ -199,7 +386,7 @@ def to_bytes(string, encoding="utf-8", errors="ignore"):
         if encoding.lower() == "utf-8":
             return string
         else:
-            return string.decode('utf-8').encode(encoding, errors)
+            return string.decode("utf-8").encode(encoding, errors)
     elif isinstance(string, memoryview):
         return bytes(string)
     elif not isinstance(string, six.string_types):
@@ -210,7 +397,7 @@ def to_bytes(string, encoding="utf-8", errors="ignore"):
                 return bytes(string)
         except UnicodeEncodeError:
             if isinstance(string, Exception):
-                return b' '.join(to_bytes(arg, encoding, errors) for arg in string)
+                return b" ".join(to_bytes(arg, encoding, errors) for arg in string)
             return six.text_type(string).encode(encoding, errors)
     else:
         return string.encode(encoding, errors)
@@ -241,18 +428,97 @@ def to_text(string, encoding="utf-8", errors=None):
                     string = six.text_type(string, encoding, errors)
                 else:
                     string = six.text_type(string)
-            elif hasattr(string, '__unicode__'):
+            elif hasattr(string, "__unicode__"):
                 string = six.text_type(string)
             else:
                 string = six.text_type(bytes(string), encoding, errors)
         else:
             string = string.decode(encoding, errors)
     except UnicodeDecodeError as e:
-            string = ' '.join(to_text(arg, encoding, errors) for arg in string)
+        string = " ".join(to_text(arg, encoding, errors) for arg in string)
     return string
 
 
+def divide(n, iterable):
+    """
+    split an iterable into n groups, per https://more-itertools.readthedocs.io/en/latest/api.html#grouping
+
+    :param int n: Number of unique groups
+    :param iter iterable: An iterable to split up
+    :return: a list of new iterables derived from the original iterable
+    :rtype: list
+    """
+
+    seq = tuple(iterable)
+    q, r = divmod(len(seq), n)
+
+    ret = []
+    for i in range(n):
+        start = (i * q) + (i if i < r else r)
+        stop = ((i + 1) * q) + (i + 1 if i + 1 < r else r)
+        ret.append(iter(seq[start:stop]))
+
+    return ret
+
+
+def take(n, iterable):
+    """Take n elements from the supplied iterable without consuming it.
+
+    :param int n: Number of unique groups
+    :param iter iterable: An iterable to split up
+
+    from https://github.com/erikrose/more-itertools/blob/master/more_itertools/recipes.py
+    """
+
+    return list(islice(iterable, n))
+
+
+def chunked(n, iterable):
+    """Split an iterable into lists of length *n*.
+
+    :param int n: Number of unique groups
+    :param iter iterable: An iterable to split up
+
+    from https://github.com/erikrose/more-itertools/blob/master/more_itertools/more.py
+    """
+
+    return iter(partial(take, n, iter(iterable)), [])
+
+
 try:
-    locale_encoding = locale.getdefaultencoding()[1] or 'ascii'
+    locale_encoding = locale.getdefaultencoding()[1] or "ascii"
 except Exception:
-    locale_encoding = 'ascii'
+    locale_encoding = "ascii"
+
+
+def getpreferredencoding():
+    import locale
+    # Borrowed from Invoke
+    # (see https://github.com/pyinvoke/invoke/blob/93af29d/invoke/runners.py#L881)
+    _encoding = locale.getpreferredencoding(False)
+    if six.PY2 and not sys.platform == "win32":
+        _default_encoding = locale.getdefaultlocale()[1]
+        if _default_encoding is not None:
+            _encoding = _default_encoding
+    return _encoding
+
+
+PREFERRED_ENCODING = getpreferredencoding()
+
+
+def decode_for_output(output):
+    """Given a string, decode it for output to a terminal
+
+    :param str output: A string to print to a terminal
+    :return: A re-encoded string using the preferred encoding
+    :rtype: str
+    """
+
+    if not isinstance(output, six.string_types):
+        return output
+    try:
+        output = output.encode(PREFERRED_ENCODING)
+    except AttributeError:
+        pass
+    output = output.decode(PREFERRED_ENCODING)
+    return output
diff --git a/pipenv/vendor/vistir/path.py b/pipenv/vendor/vistir/path.py
index 166282e8..ba008159 100644
--- a/pipenv/vendor/vistir/path.py
+++ b/pipenv/vendor/vistir/path.py
@@ -8,6 +8,7 @@ import os
 import posixpath
 import shutil
 import stat
+import sys
 import warnings
 
 import six
@@ -15,8 +16,15 @@ import six
 from six.moves import urllib_parse
 from six.moves.urllib import request as urllib_request
 
-from .compat import Path, _fs_encoding, TemporaryDirectory
-from .misc import locale_encoding, to_bytes, to_text
+from .backports.tempfile import _TemporaryFileWrapper
+from .compat import (
+    _NamedTemporaryFile,
+    Path,
+    ResourceWarning,
+    TemporaryDirectory,
+    _fs_encoding,
+    finalize,
+)
 
 
 __all__ = [
@@ -29,6 +37,7 @@ __all__ = [
     "mkdir_p",
     "ensure_mkdir_p",
     "create_tracked_tempdir",
+    "create_tracked_tempfile",
     "path_to_url",
     "rmtree",
     "safe_expandvars",
@@ -38,6 +47,10 @@ __all__ = [
 ]
 
 
+if os.name == "nt":
+    warnings.filterwarnings("ignore", category=DeprecationWarning, message="The Windows bytes API has been deprecated.*")
+
+
 def unicode_path(path):
     # Paths are supposed to be represented as unicode here
     if six.PY2 and not isinstance(path, six.text_type):
@@ -53,9 +66,10 @@ def native_path(path):
 
 # once again thank you django...
 # https://github.com/django/django/blob/fc6b90b/django/utils/_os.py
-if six.PY3 or os.name == 'nt':
+if six.PY3 or os.name == "nt":
     abspathu = os.path.abspath
 else:
+
     def abspathu(path):
         """
         Version of os.path.abspath that uses the unicode representation
@@ -74,6 +88,8 @@ def normalize_drive(path):
     identified with either upper or lower cased drive names. The case is
     always converted to uppercase because it seems to be preferred.
     """
+    from .misc import to_text
+
     if os.name != "nt" or not isinstance(path, six.string_types):
         return path
 
@@ -95,6 +111,7 @@ def path_to_url(path):
     >>> path_to_url("/home/user/code/myrepo/myfile.zip")
     'file:///home/user/code/myrepo/myfile.zip'
     """
+    from .misc import to_text, to_bytes
 
     if not path:
         return path
@@ -108,6 +125,8 @@ def url_to_path(url):
 
     Follows logic taken from pip's equivalent function
     """
+    from .misc import to_bytes
+
     assert is_file_url(url), "Only file: urls can be converted to local paths"
     _, netloc, path, _, _ = urllib_parse.urlsplit(url)
     # Netlocs are UNC paths
@@ -120,14 +139,18 @@ def url_to_path(url):
 
 def is_valid_url(url):
     """Checks if a given string is an url"""
+    from .misc import to_text
+
     if not url:
         return url
-    pieces = urllib_parse.urlparse(url)
+    pieces = urllib_parse.urlparse(to_text(url))
     return all([pieces.scheme, pieces.netloc])
 
 
 def is_file_url(url):
     """Returns true if the given url is a file url"""
+    from .misc import to_text
+
     if not url:
         return False
     if not isinstance(url, six.string_types):
@@ -144,9 +167,12 @@ def is_readonly_path(fn):
 
     Permissions check is `bool(path.stat & stat.S_IREAD)` or `not os.access(path, os.W_OK)`
     """
-    fn = to_bytes(fn, encoding="utf-8")
+    from .compat import to_native_string
+
+    fn = to_native_string(fn)
     if os.path.exists(fn):
-        return bool(os.stat(fn).st_mode & stat.S_IREAD) and not os.access(fn, os.W_OK)
+        file_stat = os.stat(fn).st_mode
+        return not bool(file_stat & stat.S_IWRITE) or not os.access(fn, os.W_OK)
     return False
 
 
@@ -158,7 +184,10 @@ def mkdir_p(newdir, mode=0o777):
     :raises: OSError if a file is encountered along the way
     """
     # http://code.activestate.com/recipes/82465-a-friendly-mkdir/
-    newdir = abspathu(to_bytes(newdir, "utf-8"))
+    from .misc import to_text
+    from .compat import to_native_string
+
+    newdir = to_native_string(newdir)
     if os.path.exists(newdir):
         if not os.path.isdir(newdir):
             raise OSError(
@@ -166,17 +195,19 @@ def mkdir_p(newdir, mode=0o777):
                     newdir
                 )
             )
-        pass
     else:
         head, tail = os.path.split(newdir)
         # Make sure the tail doesn't point to the asame place as the head
-        tail_and_head_match = os.path.relpath(tail, start=os.path.basename(head)) == "."
+        curdir = to_native_string(".")
+        tail_and_head_match = (
+            os.path.relpath(tail, start=os.path.basename(head)) == curdir
+        )
         if tail and not tail_and_head_match and not os.path.isdir(newdir):
             target = os.path.join(head, tail)
             if os.path.exists(target) and os.path.isfile(target):
                 raise OSError(
                    "A file with the same name as the desired dir, '{0}', already exists.".format(
-                        newdir
+                        to_text(newdir, encoding="utf-8")
                     )
                 )
             os.makedirs(os.path.join(head, tail), mode)
@@ -185,8 +216,8 @@ def mkdir_p(newdir, mode=0o777):
 def ensure_mkdir_p(mode=0o777):
     """Decorator to ensure `mkdir_p` is called to the function's return value.
     """
-    def decorator(f):
 
+    def decorator(f):
         @functools.wraps(f)
         def decorated(*args, **kwargs):
             path = f(*args, **kwargs)
@@ -210,12 +241,27 @@ def create_tracked_tempdir(*args, **kwargs):
 
     The return value is the path to the created directory.
     """
+
     tempdir = TemporaryDirectory(*args, **kwargs)
     TRACKED_TEMPORARY_DIRECTORIES.append(tempdir)
     atexit.register(tempdir.cleanup)
+    warnings.simplefilter("ignore", ResourceWarning)
     return tempdir.name
 
 
+def create_tracked_tempfile(*args, **kwargs):
+    """Create a tracked temporary file.
+
+    This uses the `NamedTemporaryFile` construct, but does not remove the file
+    until the interpreter exits.
+
+    The return value is the file object.
+    """
+
+    kwargs["wrapper_class_override"] = _TrackedTempfileWrapper
+    return _NamedTemporaryFile(*args, **kwargs)
+
+
 def set_write_bit(fn):
     """Set read-write permissions for the current user on the target path.  Fail silently
     if the path doesn't exist.
@@ -223,10 +269,20 @@ def set_write_bit(fn):
     :param str fn: The target filename or path
     """
 
-    fn = to_bytes(fn, encoding=locale_encoding)
+    from .compat import to_native_string
+
+    fn = to_native_string(fn)
     if not os.path.exists(fn):
         return
-    os.chmod(fn, stat.S_IWRITE | stat.S_IWUSR | stat.S_IRUSR)
+    file_stat = os.stat(fn).st_mode
+    os.chmod(fn, file_stat | stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
+    if not os.path.isdir(fn):
+        return
+    for root, dirs, files in os.walk(fn, topdown=False):
+        for dir_ in [os.path.join(root,d) for d in dirs]:
+            set_write_bit(dir_)
+        for file_ in [os.path.join(root, f) for f in files]:
+            set_write_bit(file_)
 
 
 def rmtree(directory, ignore_errors=False):
@@ -243,10 +299,18 @@ def rmtree(directory, ignore_errors=False):
        Setting `ignore_errors=True` may cause this to silently fail to delete the path
     """
 
-    directory = to_bytes(directory, encoding=locale_encoding)
-    shutil.rmtree(
-        directory, ignore_errors=ignore_errors, onerror=handle_remove_readonly
-    )
+    from .compat import to_native_string
+
+    directory = to_native_string(directory)
+    try:
+        shutil.rmtree(
+            directory, ignore_errors=ignore_errors, onerror=handle_remove_readonly
+        )
+    except (IOError, OSError, FileNotFoundError) as exc:
+        # Ignore removal failures where the file doesn't exist
+        if exc.errno == errno.ENOENT:
+            pass
+        raise
 
 
 def handle_remove_readonly(func, path, exc):
@@ -263,35 +327,45 @@ def handle_remove_readonly(func, path, exc):
     :func:`set_write_bit` on the target path and try again.
     """
     # Check for read-only attribute
-    from .compat import ResourceWarning
+    from .compat import ResourceWarning, FileNotFoundError, to_native_string
+
+    PERM_ERRORS = (errno.EACCES, errno.EPERM, errno.ENOENT)
     default_warning_message = (
         "Unable to remove file due to permissions restriction: {!r}"
     )
     # split the initial exception out into its type, exception, and traceback
     exc_type, exc_exception, exc_tb = exc
-    path = to_bytes(path)
+    path = to_native_string(path)
     if is_readonly_path(path):
         # Apply write permission and call original function
         set_write_bit(path)
         try:
             func(path)
-        except (OSError, IOError) as e:
-            if e.errno in [errno.EACCES, errno.EPERM]:
-                warnings.warn(
-                    default_warning_message.format(
-                        to_text(path, encoding=locale_encoding)
-                    ), ResourceWarning
-                )
+        except (OSError, IOError, FileNotFoundError) as e:
+            if e.errno == errno.ENOENT:
+                return
+            elif e.errno in PERM_ERRORS:
+                warnings.warn(default_warning_message.format(path), ResourceWarning)
                 return
 
-    if exc_exception.errno in [errno.EACCES, errno.EPERM]:
-        warnings.warn(
-            default_warning_message.format(to_text(path)),
-            ResourceWarning
-        )
-        return
-
-    raise
+    if exc_exception.errno in PERM_ERRORS:
+        set_write_bit(path)
+        try:
+            func(path)
+        except (OSError, IOError, FileNotFoundError) as e:
+            if e.errno in PERM_ERRORS:
+                warnings.warn(default_warning_message.format(path), ResourceWarning)
+                pass
+            elif e.errno == errno.ENOENT:  # File already gone
+                pass
+            else:
+                raise
+        else:
+            return
+    elif exc_exception.errno == errno.ENOENT:
+        pass
+    else:
+        raise exc_exception
 
 
 def walk_up(bottom):
@@ -356,6 +430,7 @@ def get_converted_relative_path(path, relative_to=None):
     >>> vistir.path.get_converted_relative_path('/home/user/code/myrepo/myfolder')
     '.'
     """
+    from .misc import to_text, to_bytes  # noqa
 
     if not relative_to:
         relative_to = os.getcwdu() if six.PY2 else os.getcwd()
@@ -395,3 +470,28 @@ def safe_expandvars(value):
     if isinstance(value, six.string_types):
         return os.path.expandvars(value)
     return value
+
+
+class _TrackedTempfileWrapper(_TemporaryFileWrapper, object):
+    def __init__(self, *args, **kwargs):
+        super(_TrackedTempfileWrapper, self).__init__(*args, **kwargs)
+        self._finalizer = finalize(self, self.cleanup)
+
+    @classmethod
+    def _cleanup(cls, fileobj):
+        try:
+            fileobj.close()
+        finally:
+            os.unlink(fileobj.name)
+
+    def cleanup(self):
+        if self._finalizer.detach():
+            try:
+                self.close()
+            finally:
+                os.unlink(self.name)
+        else:
+            try:
+                self.close()
+            except OSError:
+                pass
diff --git a/pipenv/vendor/vistir/spin.py b/pipenv/vendor/vistir/spin.py
new file mode 100644
index 00000000..20587d9d
--- /dev/null
+++ b/pipenv/vendor/vistir/spin.py
@@ -0,0 +1,291 @@
+# -*- coding=utf-8 -*-
+
+import functools
+import os
+import signal
+import sys
+
+import colorama
+import cursor
+import six
+
+from .compat import to_native_string
+from .termcolors import COLOR_MAP, COLORS, colored
+from io import StringIO
+
+try:
+    import yaspin
+except ImportError:
+    yaspin = None
+    Spinners = None
+else:
+    from yaspin.spinners import Spinners
+
+handler = None
+if yaspin and os.name == "nt":
+    handler = yaspin.signal_handlers.default_handler
+elif yaspin and os.name != "nt":
+    handler = yaspin.signal_handlers.fancy_handler
+
+CLEAR_LINE = chr(27) + "[K"
+
+
+class DummySpinner(object):
+    def __init__(self, text="", **kwargs):
+        colorama.init()
+        from .misc import decode_for_output
+        self.text = to_native_string(decode_for_output(text))
+        self.stdout = kwargs.get("stdout", sys.stdout)
+        self.stderr = kwargs.get("stderr", sys.stderr)
+        self.out_buff = StringIO()
+
+    def __enter__(self):
+        if self.text and self.text != "None":
+            self.write_err(self.text)
+        return self
+
+    def __exit__(self, exc_type, exc_val, traceback):
+        if exc_type:
+            import traceback
+            from .misc import decode_for_output
+            self.write_err(decode_for_output(traceback.format_exception(*sys.exc_info())))
+        self._close_output_buffer()
+        return False
+
+    def __getattr__(self, k):
+        try:
+            retval = super(DummySpinner, self).__getattribute__(k)
+        except AttributeError:
+            if k in COLOR_MAP.keys() or k.upper() in COLORS:
+                return self
+            raise
+        else:
+            return retval
+
+    def _close_output_buffer(self):
+        if self.out_buff and not self.out_buff.closed:
+            try:
+                self.out_buff.close()
+            except Exception:
+                pass
+
+    def fail(self, exitcode=1, text="FAIL"):
+        from .misc import decode_for_output
+        if text and text != "None":
+            self.write_err(decode_for_output(text))
+        self._close_output_buffer()
+
+    def ok(self, text="OK"):
+        if text and text != "None":
+            self.stderr.write(self.text)
+        self._close_output_buffer()
+        return 0
+
+    def write(self, text=None):
+        from .misc import decode_for_output
+        if text is None or isinstance(text, six.string_types) and text == "None":
+            pass
+        text = decode_for_output(text)
+        self.stdout.write(decode_for_output("\r"))
+        line = decode_for_output("{0}\n".format(text))
+        self.stdout.write(line)
+        self.stdout.write(CLEAR_LINE)
+
+    def write_err(self, text=None):
+        from .misc import decode_for_output
+        if text is None or isinstance(text, six.string_types) and text == "None":
+            pass
+        text = decode_for_output(text)
+        self.stderr.write(decode_for_output("\r"))
+        line = decode_for_output("{0}\n".format(text))
+        self.stderr.write(line)
+        self.stderr.write(CLEAR_LINE)
+
+    @staticmethod
+    def _hide_cursor():
+        pass
+
+    @staticmethod
+    def _show_cursor():
+        pass
+
+
+base_obj = yaspin.core.Yaspin if yaspin is not None else DummySpinner
+
+
+class VistirSpinner(base_obj):
+    def __init__(self, *args, **kwargs):
+        """Get a spinner object or a dummy spinner to wrap a context.
+
+        Keyword Arguments:
+        :param str spinner_name: A spinner type e.g. "dots" or "bouncingBar" (default: {"bouncingBar"})
+        :param str start_text: Text to start off the spinner with (default: {None})
+        :param dict handler_map: Handler map for signals to be handled gracefully (default: {None})
+        :param bool nospin: If true, use the dummy spinner (default: {False})
+        """
+
+        self.handler = handler
+        colorama.init()
+        sigmap = {}
+        if handler:
+            sigmap.update({
+                signal.SIGINT: handler,
+                signal.SIGTERM: handler
+            })
+        handler_map = kwargs.pop("handler_map", {})
+        if os.name == "nt":
+            sigmap[signal.SIGBREAK] = handler
+        else:
+            sigmap[signal.SIGALRM] = handler
+        if handler_map:
+            sigmap.update(handler_map)
+        spinner_name = kwargs.pop("spinner_name", "bouncingBar")
+        start_text = kwargs.pop("start_text", None)
+        _text = kwargs.pop("text", "Running...")
+        kwargs["text"] = start_text if start_text is not None else _text
+        kwargs["sigmap"] = sigmap
+        kwargs["spinner"] = getattr(Spinners, spinner_name, "")
+        self.stdout = kwargs.pop("stdout", sys.stdout)
+        self.stderr = kwargs.pop("stderr", sys.stderr)
+        self.out_buff = StringIO()
+        super(VistirSpinner, self).__init__(*args, **kwargs)
+        self.is_dummy = bool(yaspin is None)
+
+    def ok(self, text="OK"):
+        """Set Ok (success) finalizer to a spinner."""
+        _text = text if text else "OK"
+        self._freeze(_text)
+
+    def fail(self, text="FAIL"):
+        """Set fail finalizer to a spinner."""
+        _text = text if text else "FAIL"
+        self._freeze(_text)
+
+    def write(self, text):
+        from .misc import to_text
+        sys.stdout.write("\r")
+        self.stdout.write(CLEAR_LINE)
+        if text is None:
+            text = ""
+        text = to_native_string("{0}\n".format(text))
+        sys.stdout.write(text)
+        self.out_buff.write(to_text(text))
+
+    def write_err(self, text):
+        """Write error text in the terminal without breaking the spinner."""
+        from .misc import to_text
+
+        self.stderr.write("\r")
+        self.stderr.write(CLEAR_LINE)
+        if text is None:
+            text = ""
+        text = to_native_string("{0}\n".format(text))
+        self.stderr.write(text)
+        self.out_buff.write(to_text(text))
+
+    def _freeze(self, final_text):
+        """Stop spinner, compose last frame and 'freeze' it."""
+        if not final_text:
+            final_text = ""
+        text = to_native_string(final_text)
+        self._last_frame = self._compose_out(text, mode="last")
+
+        # Should be stopped here, otherwise prints after
+        # self._freeze call will mess up the spinner
+        self.stop()
+        self.stdout.write(self._last_frame)
+
+    def stop(self, *args, **kwargs):
+        if self.stderr and self.stderr != sys.stderr:
+            self.stderr.close()
+        if self.stdout and self.stdout != sys.stdout:
+            self.stdout.close()
+        self.out_buff.close()
+        super(VistirSpinner, self).stop(*args, **kwargs)
+
+    def _compose_color_func(self):
+        fn = functools.partial(
+            colored,
+            color=self._color,
+            on_color=self._on_color,
+            attrs=list(self._attrs),
+        )
+        return fn
+
+    def _compose_out(self, frame, mode=None):
+        # Ensure Unicode input
+
+        frame = to_native_string(frame)
+        if self._text is None:
+            self._text = ""
+        text = to_native_string(self._text)
+        if self._color_func is not None:
+            frame = self._color_func(frame)
+        if self._side == "right":
+            frame, text = text, frame
+        # Mode
+        if not mode:
+            out = to_native_string("\r{0} {1}".format(frame, text))
+        else:
+            out = to_native_string("{0} {1}\n".format(frame, text))
+        return out
+
+    def _register_signal_handlers(self):
+        # SIGKILL cannot be caught or ignored, and the receiving
+        # process cannot perform any clean-up upon receiving this
+        # signal.
+        try:
+            if signal.SIGKILL in self._sigmap.keys():
+                raise ValueError(
+                    "Trying to set handler for SIGKILL signal. "
+                    "SIGKILL cannot be cought or ignored in POSIX systems."
+                )
+        except AttributeError:
+            pass
+
+        for sig, sig_handler in self._sigmap.items():
+            # A handler for a particular signal, once set, remains
+            # installed until it is explicitly reset. Store default
+            # signal handlers for subsequent reset at cleanup phase.
+            dfl_handler = signal.getsignal(sig)
+            self._dfl_sigmap[sig] = dfl_handler
+
+            # ``signal.SIG_DFL`` and ``signal.SIG_IGN`` are also valid
+            # signal handlers and are not callables.
+            if callable(sig_handler):
+                # ``signal.signal`` accepts handler function which is
+                # called with two arguments: signal number and the
+                # interrupted stack frame. ``functools.partial`` solves
+                # the problem of passing spinner instance into the handler
+                # function.
+                sig_handler = functools.partial(sig_handler, spinner=self)
+
+            signal.signal(sig, sig_handler)
+
+    def _reset_signal_handlers(self):
+        for sig, sig_handler in self._dfl_sigmap.items():
+            signal.signal(sig, sig_handler)
+
+    @staticmethod
+    def _hide_cursor():
+        cursor.hide()
+
+    @staticmethod
+    def _show_cursor():
+        cursor.show()
+
+    @staticmethod
+    def _clear_err():
+        sys.stderr.write(CLEAR_LINE)
+
+    @staticmethod
+    def _clear_line():
+        sys.stdout.write(CLEAR_LINE)
+
+
+def create_spinner(*args, **kwargs):
+    nospin = kwargs.pop("nospin", False)
+    use_yaspin = kwargs.pop("use_yaspin", nospin)
+    if nospin:
+        return DummySpinner(*args, **kwargs)
+    return VistirSpinner(*args, **kwargs)
diff --git a/pipenv/vendor/vistir/termcolors.py b/pipenv/vendor/vistir/termcolors.py
new file mode 100644
index 00000000..8395d97d
--- /dev/null
+++ b/pipenv/vendor/vistir/termcolors.py
@@ -0,0 +1,146 @@
+# -*- coding=utf-8 -*-
+from __future__ import absolute_import, print_function, unicode_literals
+import colorama
+import os
+from .compat import to_native_string
+
+
+ATTRIBUTES = dict(
+        list(zip([
+            'bold',
+            'dark',
+            '',
+            'underline',
+            'blink',
+            '',
+            'reverse',
+            'concealed'
+            ],
+            list(range(1, 9))
+            ))
+        )
+del ATTRIBUTES['']
+
+
+HIGHLIGHTS = dict(
+        list(zip([
+            'on_grey',
+            'on_red',
+            'on_green',
+            'on_yellow',
+            'on_blue',
+            'on_magenta',
+            'on_cyan',
+            'on_white'
+            ],
+            list(range(40, 48))
+            ))
+        )
+
+
+COLORS = dict(
+        list(zip([
+            'grey',
+            'red',
+            'green',
+            'yellow',
+            'blue',
+            'magenta',
+            'cyan',
+            'white',
+            ],
+            list(range(30, 38))
+            ))
+        )
+
+
+COLOR_MAP = {
+    # name: type
+    "blink": "attrs",
+    "bold": "attrs",
+    "concealed": "attrs",
+    "dark": "attrs",
+    "reverse": "attrs",
+    "underline": "attrs",
+    "blue": "color",
+    "cyan": "color",
+    "green": "color",
+    "magenta": "color",
+    "red": "color",
+    "white": "color",
+    "yellow": "color",
+    "on_blue": "on_color",
+    "on_cyan": "on_color",
+    "on_green": "on_color",
+    "on_grey": "on_color",
+    "on_magenta": "on_color",
+    "on_red": "on_color",
+    "on_white": "on_color",
+    "on_yellow": "on_color",
+}
+COLOR_ATTRS = COLOR_MAP.keys()
+
+
+RESET = colorama.Style.RESET_ALL
+
+
+def colored(text, color=None, on_color=None, attrs=None):
+    """Colorize text using a reimplementation of the colorizer from
+    https://github.com/pavdmyt/yaspin so that it works on windows.
+
+    Available text colors:
+        red, green, yellow, blue, magenta, cyan, white.
+
+    Available text highlights:
+        on_red, on_green, on_yellow, on_blue, on_magenta, on_cyan, on_white.
+
+    Available attributes:
+        bold, dark, underline, blink, reverse, concealed.
+
+    Example:
+        colored('Hello, World!', 'red', 'on_grey', ['blue', 'blink'])
+        colored('Hello, World!', 'green')
+    """
+    if os.getenv('ANSI_COLORS_DISABLED') is None:
+        style = "NORMAL"
+        if 'bold' in attrs:
+            style = "BRIGHT"
+            attrs.remove('bold')
+        if color is not None:
+            color = color.upper()
+            text = to_native_string("%s%s%s%s%s") % (
+                to_native_string(getattr(colorama.Fore, color)),
+                to_native_string(getattr(colorama.Style, style)),
+                to_native_string(text),
+                to_native_string(colorama.Fore.RESET),
+                to_native_string(colorama.Style.NORMAL),
+            )
+
+        if on_color is not None:
+            on_color = on_color.upper()
+            text = to_native_string("%s%s%s%s") % (
+                to_native_string(getattr(colorama.Back, on_color)),
+                to_native_string(text),
+                to_native_string(colorama.Back.RESET),
+                to_native_string(colorama.Style.NORMAL),
+            )
+
+        if attrs is not None:
+            fmt_str = to_native_string("%s[%%dm%%s%s[9m") % (
+                chr(27),
+                chr(27)
+            )
+            for attr in attrs:
+                text = fmt_str % (ATTRIBUTES[attr], text)
+
+        text += RESET
+    return text
+
+
+def cprint(text, color=None, on_color=None, attrs=None, **kwargs):
+    """Print colorize text.
+
+    It accepts arguments of print function.
+    """
+
+    print((colored(text, color, on_color, attrs)), **kwargs)
diff --git a/pipenv/vendor/pathlib2.LICENSE.rst b/pipenv/vendor/yaspin/LICENSE
similarity index 89%
rename from pipenv/vendor/pathlib2.LICENSE.rst
rename to pipenv/vendor/yaspin/LICENSE
index ddb51b8a..2458104e 100644
--- a/pipenv/vendor/pathlib2.LICENSE.rst
+++ b/pipenv/vendor/yaspin/LICENSE
@@ -1,7 +1,6 @@
-The MIT License (MIT)
+MIT License
 
-Copyright (c) 2014 Matthias C. M. Troffaes
-Copyright (c) 2012-2014 Antoine Pitrou and contributors
+Copyright (c) 2018 Pavlo Dmytrenko
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -20,4 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-
diff --git a/pipenv/vendor/yaspin/__init__.py b/pipenv/vendor/yaspin/__init__.py
new file mode 100644
index 00000000..57853a13
--- /dev/null
+++ b/pipenv/vendor/yaspin/__init__.py
@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+
+from .__version__ import __version__  # noqa
+from .api import kbi_safe_yaspin, yaspin
+from .base_spinner import Spinner
+
+
+__all__ = ("yaspin", "kbi_safe_yaspin", "Spinner")
diff --git a/pipenv/vendor/yaspin/__version__.py b/pipenv/vendor/yaspin/__version__.py
new file mode 100644
index 00000000..9e78220f
--- /dev/null
+++ b/pipenv/vendor/yaspin/__version__.py
@@ -0,0 +1 @@
+__version__ = "0.14.0"
diff --git a/pipenv/vendor/yaspin/api.py b/pipenv/vendor/yaspin/api.py
new file mode 100644
index 00000000..156630db
--- /dev/null
+++ b/pipenv/vendor/yaspin/api.py
@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+
+"""
+yaspin.api
+~~~~~~~~~~
+
+This module implements the Yaspin API.
+
+:copyright: (c) 2018 by Pavlo Dmytrenko.
+:license: MIT, see LICENSE for more details.
+"""
+
+import signal
+
+from .core import Yaspin
+from .signal_handlers import default_handler
+
+
+def yaspin(*args, **kwargs):
+    """Display spinner in stdout.
+
+    Can be used as a context manager or as a function decorator.
+
+    Arguments:
+        spinner (base_spinner.Spinner, optional): Spinner object to use.
+        text (str, optional): Text to show along with spinner.
+        color (str, optional): Spinner color.
+        on_color (str, optional): Color highlight for the spinner.
+        attrs (list, optional): Color attributes for the spinner.
+        reversal (bool, optional): Reverse spin direction.
+        side (str, optional): Place spinner to the right or left end
+            of the text string.
+        sigmap (dict, optional): Maps POSIX signals to their respective
+            handlers.
+
+    Returns:
+        core.Yaspin: instance of the Yaspin class.
+
+    Raises:
+        ValueError: If unsupported ``color`` is specified.
+        ValueError: If unsupported ``on_color`` is specified.
+        ValueError: If unsupported color attribute in ``attrs``
+            is specified.
+        ValueError: If trying to register handler for SIGKILL signal.
+        ValueError: If unsupported ``side`` is specified.
+
+    Available text colors:
+        red, green, yellow, blue, magenta, cyan, white.
+
+    Available text highlights:
+        on_red, on_green, on_yellow, on_blue, on_magenta, on_cyan,
+        on_white, on_grey.
+
+    Available attributes:
+        bold, dark, underline, blink, reverse, concealed.
+
+    Example::
+
+        # Use as a context manager
+        with yaspin():
+            some_operations()
+
+        # Context manager with text
+        with yaspin(text="Processing..."):
+            some_operations()
+
+        # Context manager with custom sequence
+        with yaspin(Spinner('-\\|/', 150)):
+            some_operations()
+
+        # As decorator
+        @yaspin(text="Loading...")
+        def foo():
+            time.sleep(5)
+
+        foo()
+
+    """
+    return Yaspin(*args, **kwargs)
+
+
+def kbi_safe_yaspin(*args, **kwargs):
+    kwargs["sigmap"] = {signal.SIGINT: default_handler}
+    return Yaspin(*args, **kwargs)
+
+
+_kbi_safe_doc = yaspin.__doc__.replace("yaspin", "kbi_safe_yaspin")
+kbi_safe_yaspin.__doc__ = _kbi_safe_doc
diff --git a/pipenv/vendor/yaspin/base_spinner.py b/pipenv/vendor/yaspin/base_spinner.py
new file mode 100644
index 00000000..537ff799
--- /dev/null
+++ b/pipenv/vendor/yaspin/base_spinner.py
@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+"""
+yaspin.base_spinner
+~~~~~~~~~~~~~~~~~~~
+
+Spinner class, used to construct other spinners.
+"""
+
+from __future__ import absolute_import
+
+from collections import namedtuple
+
+
+Spinner = namedtuple("Spinner", "frames interval")
+default_spinner = Spinner("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏", 80)
diff --git a/pipenv/vendor/yaspin/compat.py b/pipenv/vendor/yaspin/compat.py
new file mode 100644
index 00000000..744de5a1
--- /dev/null
+++ b/pipenv/vendor/yaspin/compat.py
@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+
+"""
+yaspin.compat
+~~~~~~~~~~~~~
+
+Compatibility layer.
+"""
+
+import sys
+
+
+PY2 = sys.version_info[0] == 2
+
+
+if PY2:
+    builtin_str = str
+    bytes = str
+    str = unicode  # noqa
+    basestring = basestring  # noqa
+
+    def iteritems(dct):
+        return dct.iteritems()
+
+
+else:
+    builtin_str = str
+    bytes = bytes
+    str = str
+    basestring = (str, bytes)
+
+    def iteritems(dct):
+        return dct.items()
diff --git a/pipenv/vendor/yaspin/constants.py b/pipenv/vendor/yaspin/constants.py
new file mode 100644
index 00000000..b26baabe
--- /dev/null
+++ b/pipenv/vendor/yaspin/constants.py
@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+
+"""
+yaspin.constants
+~~~~~~~~~~~~~~~~
+
+Some setups.
+"""
+
+
+ENCODING = "utf-8"
+COLOR_MAP = {
+    # name: type
+    "blink": "attrs",
+    "bold": "attrs",
+    "concealed": "attrs",
+    "dark": "attrs",
+    "reverse": "attrs",
+    "underline": "attrs",
+    "blue": "color",
+    "cyan": "color",
+    "green": "color",
+    "magenta": "color",
+    "red": "color",
+    "white": "color",
+    "yellow": "color",
+    "on_blue": "on_color",
+    "on_cyan": "on_color",
+    "on_green": "on_color",
+    "on_grey": "on_color",
+    "on_magenta": "on_color",
+    "on_red": "on_color",
+    "on_white": "on_color",
+    "on_yellow": "on_color",
+}
+COLOR_ATTRS = COLOR_MAP.keys()
+
+# Get spinner names:
+# $ < yaspin/data/spinners.json | jq '. | keys'
+SPINNER_ATTRS = [
+    "arc",
+    "arrow",
+    "arrow2",
+    "arrow3",
+    "balloon",
+    "balloon2",
+    "bounce",
+    "bouncingBall",
+    "bouncingBar",
+    "boxBounce",
+    "boxBounce2",
+    "christmas",
+    "circle",
+    "circleHalves",
+    "circleQuarters",
+    "clock",
+    "dots",
+    "dots10",
+    "dots11",
+    "dots12",
+    "dots2",
+    "dots3",
+    "dots4",
+    "dots5",
+    "dots6",
+    "dots7",
+    "dots8",
+    "dots9",
+    "dqpb",
+    "earth",
+    "flip",
+    "grenade",
+    "growHorizontal",
+    "growVertical",
+    "hamburger",
+    "hearts",
+    "layer",
+    "line",
+    "line2",
+    "monkey",
+    "moon",
+    "noise",
+    "pipe",
+    "point",
+    "pong",
+    "runner",
+    "shark",
+    "simpleDots",
+    "simpleDotsScrolling",
+    "smiley",
+    "squareCorners",
+    "squish",
+    "star",
+    "star2",
+    "toggle",
+    "toggle10",
+    "toggle11",
+    "toggle12",
+    "toggle13",
+    "toggle2",
+    "toggle3",
+    "toggle4",
+    "toggle5",
+    "toggle6",
+    "toggle7",
+    "toggle8",
+    "toggle9",
+    "triangle",
+    "weather",
+]
diff --git a/pipenv/vendor/yaspin/core.py b/pipenv/vendor/yaspin/core.py
new file mode 100644
index 00000000..06b8b621
--- /dev/null
+++ b/pipenv/vendor/yaspin/core.py
@@ -0,0 +1,541 @@
+# -*- coding: utf-8 -*-
+
+"""
+yaspin.yaspin
+~~~~~~~~~~~~~
+
+A lightweight terminal spinner.
+"""
+
+from __future__ import absolute_import
+
+import functools
+import itertools
+import signal
+import sys
+import threading
+import time
+
+import colorama
+import cursor
+
+from .base_spinner import default_spinner
+from .compat import PY2, basestring, builtin_str, bytes, iteritems, str
+from .constants import COLOR_ATTRS, COLOR_MAP, ENCODING, SPINNER_ATTRS
+from .helpers import to_unicode
+from .termcolor import colored
+
+
+colorama.init()
+
+
+class Yaspin(object):
+    """Implements a context manager that spawns a thread
+    to write spinner frames into a tty (stdout) during
+    context execution.
+    """
+
+    # When Python finds its output attached to a terminal,
+    # it sets the sys.stdout.encoding attribute to the terminal's encoding.
+    # The print statement's handler will automatically encode unicode
+    # arguments into bytes.
+    #
+    # In Py2 when piping or redirecting output, Python does not detect
+    # the desired character set of the output, it sets sys.stdout.encoding
+    # to None, and print will invoke the default "ascii" codec.
+    #
+    # Py3 invokes "UTF-8" codec by default.
+    #
+    # Thats why in Py2, output should be encoded manually with desired
+    # encoding in order to support pipes and redirects.
+
+    def __init__(
+        self,
+        spinner=None,
+        text="",
+        color=None,
+        on_color=None,
+        attrs=None,
+        reversal=False,
+        side="left",
+        sigmap=None,
+    ):
+        # Spinner
+        self._spinner = self._set_spinner(spinner)
+        self._frames = self._set_frames(self._spinner, reversal)
+        self._interval = self._set_interval(self._spinner)
+        self._cycle = self._set_cycle(self._frames)
+
+        # Color Specification
+        self._color = self._set_color(color) if color else color
+        self._on_color = self._set_on_color(on_color) if on_color else on_color
+        self._attrs = self._set_attrs(attrs) if attrs else set()
+        self._color_func = self._compose_color_func()
+
+        # Other
+        self._text = self._set_text(text)
+        self._side = self._set_side(side)
+        self._reversal = reversal
+
+        # Helper flags
+        self._stop_spin = None
+        self._hide_spin = None
+        self._spin_thread = None
+        self._last_frame = None
+
+        # Signals
+
+        # In Python 2 signal.SIG* are of type int.
+        # In Python 3 signal.SIG* are enums.
+        #
+        # Signal     = Union[enum.Enum, int]
+        # SigHandler = Union[enum.Enum, Callable]
+        self._sigmap = sigmap if sigmap else {}  # Dict[Signal, SigHandler]
+        # Maps signals to their default handlers in order to reset
+        # custom handlers set by ``sigmap`` at the cleanup phase.
+        self._dfl_sigmap = {}  # Dict[Signal, SigHandler]
+
+    #
+    # Dunders
+    #
+    def __repr__(self):
+        repr_ = u"<Yaspin frames={0!s}>".format(self._frames)
+        if PY2:
+            return repr_.encode(ENCODING)
+        return repr_
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, traceback):
+        # Avoid stop() execution for the 2nd time
+        if self._spin_thread.is_alive():
+            self.stop()
+        return False  # nothing is handled
+
+    def __call__(self, fn):
+        @functools.wraps(fn)
+        def inner(*args, **kwargs):
+            with self:
+                return fn(*args, **kwargs)
+
+        return inner
+
+    def __getattr__(self, name):
+        # CLI spinners
+        if name in SPINNER_ATTRS:
+            from .spinners import Spinners
+
+            sp = getattr(Spinners, name)
+            self.spinner = sp
+        # Color Attributes: "color", "on_color", "attrs"
+        elif name in COLOR_ATTRS:
+            attr_type = COLOR_MAP[name]
+            # Call appropriate property setters;
+            # _color_func is updated automatically by setters.
+            if attr_type == "attrs":
+                self.attrs = [name]  # calls property setter
+            if attr_type in ("color", "on_color"):
+                setattr(self, attr_type, name)  # calls property setter
+        # Side: "left" or "right"
+        elif name in ("left", "right"):
+            self.side = name  # calls property setter
+        # Common error for unsupported attributes
+        else:
+            raise AttributeError(
+                "'{0}' object has no attribute: '{1}'".format(
+                    self.__class__.__name__, name
+                )
+            )
+        return self
+
+    #
+    # Properties
+    #
+    @property
+    def spinner(self):
+        return self._spinner
+
+    @spinner.setter
+    def spinner(self, sp):
+        self._spinner = self._set_spinner(sp)
+        self._frames = self._set_frames(self._spinner, self._reversal)
+        self._interval = self._set_interval(self._spinner)
+        self._cycle = self._set_cycle(self._frames)
+
+    @property
+    def text(self):
+        return self._text
+
+    @text.setter
+    def text(self, txt):
+        self._text = self._set_text(txt)
+
+    @property
+    def color(self):
+        return self._color
+
+    @color.setter
+    def color(self, value):
+        self._color = self._set_color(value) if value else value
+        self._color_func = self._compose_color_func()  # update
+
+    @property
+    def on_color(self):
+        return self._on_color
+
+    @on_color.setter
+    def on_color(self, value):
+        self._on_color = self._set_on_color(value) if value else value
+        self._color_func = self._compose_color_func()  # update
+
+    @property
+    def attrs(self):
+        return list(self._attrs)
+
+    @attrs.setter
+    def attrs(self, value):
+        new_attrs = self._set_attrs(value) if value else set()
+        self._attrs = self._attrs.union(new_attrs)
+        self._color_func = self._compose_color_func()  # update
+
+    @property
+    def side(self):
+        return self._side
+
+    @side.setter
+    def side(self, value):
+        self._side = self._set_side(value)
+
+    @property
+    def reversal(self):
+        return self._reversal
+
+    @reversal.setter
+    def reversal(self, value):
+        self._reversal = value
+        self._frames = self._set_frames(self._spinner, self._reversal)
+        self._cycle = self._set_cycle(self._frames)
+
+    #
+    # Public
+    #
+    def start(self):
+        if self._sigmap:
+            self._register_signal_handlers()
+
+        if sys.stdout.isatty():
+            self._hide_cursor()
+
+        self._stop_spin = threading.Event()
+        self._hide_spin = threading.Event()
+        self._spin_thread = threading.Thread(target=self._spin)
+        self._spin_thread.start()
+
+    def stop(self):
+        if self._dfl_sigmap:
+            # Reset registered signal handlers to default ones
+            self._reset_signal_handlers()
+
+        if self._spin_thread:
+            self._stop_spin.set()
+            self._spin_thread.join()
+
+        sys.stdout.write("\r")
+        self._clear_line()
+
+        if sys.stdout.isatty():
+            self._show_cursor()
+
+    def hide(self):
+        """Hide the spinner to allow for custom writing to the terminal."""
+        thr_is_alive = self._spin_thread and self._spin_thread.is_alive()
+
+        if thr_is_alive and not self._hide_spin.is_set():
+            # set the hidden spinner flag
+            self._hide_spin.set()
+
+            # clear the current line
+            sys.stdout.write("\r")
+            self._clear_line()
+
+            # flush the stdout buffer so the current line can be rewritten to
+            sys.stdout.flush()
+
+    def show(self):
+        """Show the hidden spinner."""
+        thr_is_alive = self._spin_thread and self._spin_thread.is_alive()
+
+        if thr_is_alive and self._hide_spin.is_set():
+            # clear the hidden spinner flag
+            self._hide_spin.clear()
+
+            # clear the current line so the spinner is not appended to it
+            sys.stdout.write("\r")
+            self._clear_line()
+
+    def write(self, text):
+        """Write text in the terminal without breaking the spinner."""
+        # similar to tqdm.write()
+        # https://pypi.python.org/pypi/tqdm#writing-messages
+        sys.stdout.write("\r")
+        self._clear_line()
+
+        _text = to_unicode(text)
+        if PY2:
+            _text = _text.encode(ENCODING)
+
+        # Ensure output is bytes for Py2 and Unicode for Py3
+        assert isinstance(_text, builtin_str)
+
+        sys.stdout.write("{0}\n".format(_text))
+
+    def ok(self, text="OK"):
+        """Set Ok (success) finalizer to a spinner."""
+        _text = text if text else "OK"
+        self._freeze(_text)
+
+    def fail(self, text="FAIL"):
+        """Set fail finalizer to a spinner."""
+        _text = text if text else "FAIL"
+        self._freeze(_text)
+
+    #
+    # Protected
+    #
+    def _freeze(self, final_text):
+        """Stop spinner, compose last frame and 'freeze' it."""
+        text = to_unicode(final_text)
+        self._last_frame = self._compose_out(text, mode="last")
+
+        # Should be stopped here, otherwise prints after
+        # self._freeze call will mess up the spinner
+        self.stop()
+        sys.stdout.write(self._last_frame)
+
+    def _spin(self):
+        while not self._stop_spin.is_set():
+
+            if self._hide_spin.is_set():
+                # Wait a bit to avoid wasting cycles
+                time.sleep(self._interval)
+                continue
+
+            # Compose output
+            spin_phase = next(self._cycle)
+            out = self._compose_out(spin_phase)
+
+            # Write
+            sys.stdout.write(out)
+            self._clear_line()
+            sys.stdout.flush()
+
+            # Wait
+            time.sleep(self._interval)
+            sys.stdout.write("\b")
+
+    def _compose_color_func(self):
+        fn = functools.partial(
+            colored,
+            color=self._color,
+            on_color=self._on_color,
+            attrs=list(self._attrs),
+        )
+        return fn
+
+    def _compose_out(self, frame, mode=None):
+        # Ensure Unicode input
+        assert isinstance(frame, str)
+        assert isinstance(self._text, str)
+
+        frame = frame.encode(ENCODING) if PY2 else frame
+        text = self._text.encode(ENCODING) if PY2 else self._text
+
+        # Colors
+        if self._color_func is not None:
+            frame = self._color_func(frame)
+
+        # Position
+        if self._side == "right":
+            frame, text = text, frame
+
+        # Mode
+        if not mode:
+            out = "\r{0} {1}".format(frame, text)
+        else:
+            out = "{0} {1}\n".format(frame, text)
+
+        # Ensure output is bytes for Py2 and Unicode for Py3
+        assert isinstance(out, builtin_str)
+
+        return out
+
+    def _register_signal_handlers(self):
+        # SIGKILL cannot be caught or ignored, and the receiving
+        # process cannot perform any clean-up upon receiving this
+        # signal.
+        try:
+            if signal.SIGKILL in self._sigmap.keys():
+                raise ValueError(
+                    "Trying to set handler for SIGKILL signal. "
+                    "SIGKILL cannot be cought or ignored in POSIX systems."
+                )
+        except AttributeError:
+            pass
+
+        for sig, sig_handler in iteritems(self._sigmap):
+            # A handler for a particular signal, once set, remains
+            # installed until it is explicitly reset. Store default
+            # signal handlers for subsequent reset at cleanup phase.
+            dfl_handler = signal.getsignal(sig)
+            self._dfl_sigmap[sig] = dfl_handler
+
+            # ``signal.SIG_DFL`` and ``signal.SIG_IGN`` are also valid
+            # signal handlers and are not callables.
+            if callable(sig_handler):
+                # ``signal.signal`` accepts handler function which is
+                # called with two arguments: signal number and the
+                # interrupted stack frame. ``functools.partial`` solves
+                # the problem of passing spinner instance into the handler
+                # function.
+                sig_handler = functools.partial(sig_handler, spinner=self)
+
+            signal.signal(sig, sig_handler)
+
+    def _reset_signal_handlers(self):
+        for sig, sig_handler in iteritems(self._dfl_sigmap):
+            signal.signal(sig, sig_handler)
+
+    #
+    # Static
+    #
+    @staticmethod
+    def _set_color(value):
+        # type: (str) -> str
+        available_values = [k for k, v in iteritems(COLOR_MAP) if v == "color"]
+
+        if value not in available_values:
+            raise ValueError(
+                "'{0}': unsupported color value. Use one of the: {1}".format(
+                    value, ", ".join(available_values)
+                )
+            )
+        return value
+
+    @staticmethod
+    def _set_on_color(value):
+        # type: (str) -> str
+        available_values = [
+            k for k, v in iteritems(COLOR_MAP) if v == "on_color"
+        ]
+        if value not in available_values:
+            raise ValueError(
+                "'{0}': unsupported on_color value. "
+                "Use one of the: {1}".format(
+                    value, ", ".join(available_values)
+                )
+            )
+        return value
+
+    @staticmethod
+    def _set_attrs(attrs):
+        # type: (List[str]) -> Set[str]
+        available_values = [k for k, v in iteritems(COLOR_MAP) if v == "attrs"]
+
+        for attr in attrs:
+            if attr not in available_values:
+                raise ValueError(
+                    "'{0}': unsupported attribute value. "
+                    "Use one of the: {1}".format(
+                        attr, ", ".join(available_values)
+                    )
+                )
+        return set(attrs)
+
+    @staticmethod
+    def _set_spinner(spinner):
+        if not spinner:
+            sp = default_spinner
+
+        if hasattr(spinner, "frames") and hasattr(spinner, "interval"):
+            if not spinner.frames or not spinner.interval:
+                sp = default_spinner
+            else:
+                sp = spinner
+        else:
+            sp = default_spinner
+
+        return sp
+
+    @staticmethod
+    def _set_side(side):
+        # type: (str) -> str
+        if side not in ("left", "right"):
+            raise ValueError(
+                "'{0}': unsupported side value. "
+                "Use either 'left' or 'right'."
+            )
+        return side
+
+    @staticmethod
+    def _set_frames(spinner, reversal):
+        # type: (base_spinner.Spinner, bool) -> Union[str, List]
+        uframes = None  # unicode frames
+        uframes_seq = None  # sequence of unicode frames
+
+        if isinstance(spinner.frames, basestring):
+            uframes = to_unicode(spinner.frames) if PY2 else spinner.frames
+
+        # TODO (pavdmyt): support any type that implements iterable
+        if isinstance(spinner.frames, (list, tuple)):
+
+            # Empty ``spinner.frames`` is handled by ``Yaspin._set_spinner``
+            if spinner.frames and isinstance(spinner.frames[0], bytes):
+                uframes_seq = [to_unicode(frame) for frame in spinner.frames]
+            else:
+                uframes_seq = spinner.frames
+
+        _frames = uframes or uframes_seq
+        if not _frames:
+            # Empty ``spinner.frames`` is handled by ``Yaspin._set_spinner``.
+            # This code is very unlikely to be executed. However, it's still
+            # here to be on a safe side.
+            raise ValueError(
+                "{0!r}: no frames found in spinner".format(spinner)
+            )
+
+        # Builtin ``reversed`` returns reverse iterator,
+        # which adds unnecessary difficulty for returning
+        # unicode value;
+        # Hence using [::-1] syntax
+        frames = _frames[::-1] if reversal else _frames
+
+        return frames
+
+    @staticmethod
+    def _set_interval(spinner):
+        # Milliseconds to Seconds
+        return spinner.interval * 0.001
+
+    @staticmethod
+    def _set_cycle(frames):
+        return itertools.cycle(frames)
+
+    @staticmethod
+    def _set_text(text):
+        if PY2:
+            return to_unicode(text)
+        return text
+
+    @staticmethod
+    def _hide_cursor():
+        cursor.hide()
+
+    @staticmethod
+    def _show_cursor():
+        cursor.show()
+
+    @staticmethod
+    def _clear_line():
+        sys.stdout.write(chr(27) + "[K")
diff --git a/pipenv/vendor/yaspin/data/spinners.json b/pipenv/vendor/yaspin/data/spinners.json
new file mode 100644
index 00000000..b388b2a5
--- /dev/null
+++ b/pipenv/vendor/yaspin/data/spinners.json
@@ -0,0 +1,912 @@
+{
+	"dots": {
+		"interval": 80,
+		"frames": [
+			"⠋",
+			"⠙",
+			"⠹",
+			"⠸",
+			"⠼",
+			"⠴",
+			"⠦",
+			"⠧",
+			"⠇",
+			"⠏"
+		]
+	},
+	"dots2": {
+		"interval": 80,
+		"frames": [
+			"⣾",
+			"⣽",
+			"⣻",
+			"⢿",
+			"⡿",
+			"⣟",
+			"⣯",
+			"⣷"
+		]
+	},
+	"dots3": {
+		"interval": 80,
+		"frames": [
+			"⠋",
+			"⠙",
+			"⠚",
+			"⠞",
+			"⠖",
+			"⠦",
+			"⠴",
+			"⠲",
+			"⠳",
+			"⠓"
+		]
+	},
+	"dots4": {
+		"interval": 80,
+		"frames": [
+			"⠄",
+			"⠆",
+			"⠇",
+			"⠋",
+			"⠙",
+			"⠸",
+			"⠰",
+			"⠠",
+			"⠰",
+			"⠸",
+			"⠙",
+			"⠋",
+			"⠇",
+			"⠆"
+		]
+	},
+	"dots5": {
+		"interval": 80,
+		"frames": [
+			"⠋",
+			"⠙",
+			"⠚",
+			"⠒",
+			"⠂",
+			"⠂",
+			"⠒",
+			"⠲",
+			"⠴",
+			"⠦",
+			"⠖",
+			"⠒",
+			"⠐",
+			"⠐",
+			"⠒",
+			"⠓",
+			"⠋"
+		]
+	},
+	"dots6": {
+		"interval": 80,
+		"frames": [
+			"⠁",
+			"⠉",
+			"⠙",
+			"⠚",
+			"⠒",
+			"⠂",
+			"⠂",
+			"⠒",
+			"⠲",
+			"⠴",
+			"⠤",
+			"⠄",
+			"⠄",
+			"⠤",
+			"⠴",
+			"⠲",
+			"⠒",
+			"⠂",
+			"⠂",
+			"⠒",
+			"⠚",
+			"⠙",
+			"⠉",
+			"⠁"
+		]
+	},
+	"dots7": {
+		"interval": 80,
+		"frames": [
+			"⠈",
+			"⠉",
+			"⠋",
+			"⠓",
+			"⠒",
+			"⠐",
+			"⠐",
+			"⠒",
+			"⠖",
+			"⠦",
+			"⠤",
+			"⠠",
+			"⠠",
+			"⠤",
+			"⠦",
+			"⠖",
+			"⠒",
+			"⠐",
+			"⠐",
+			"⠒",
+			"⠓",
+			"⠋",
+			"⠉",
+			"⠈"
+		]
+	},
+	"dots8": {
+		"interval": 80,
+		"frames": [
+			"⠁",
+			"⠁",
+			"⠉",
+			"⠙",
+			"⠚",
+			"⠒",
+			"⠂",
+			"⠂",
+			"⠒",
+			"⠲",
+			"⠴",
+			"⠤",
+			"⠄",
+			"⠄",
+			"⠤",
+			"⠠",
+			"⠠",
+			"⠤",
+			"⠦",
+			"⠖",
+			"⠒",
+			"⠐",
+			"⠐",
+			"⠒",
+			"⠓",
+			"⠋",
+			"⠉",
+			"⠈",
+			"⠈"
+		]
+	},
+	"dots9": {
+		"interval": 80,
+		"frames": [
+			"⢹",
+			"⢺",
+			"⢼",
+			"⣸",
+			"⣇",
+			"⡧",
+			"⡗",
+			"⡏"
+		]
+	},
+	"dots10": {
+		"interval": 80,
+		"frames": [
+			"⢄",
+			"⢂",
+			"⢁",
+			"⡁",
+			"⡈",
+			"⡐",
+			"⡠"
+		]
+	},
+	"dots11": {
+		"interval": 100,
+		"frames": [
+			"⠁",
+			"⠂",
+			"⠄",
+			"⡀",
+			"⢀",
+			"⠠",
+			"⠐",
+			"⠈"
+		]
+	},
+	"dots12": {
+		"interval": 80,
+		"frames": [
+			"⢀⠀",
+			"⡀⠀",
+			"⠄⠀",
+			"⢂⠀",
+			"⡂⠀",
+			"⠅⠀",
+			"⢃⠀",
+			"⡃⠀",
+			"⠍⠀",
+			"⢋⠀",
+			"⡋⠀",
+			"⠍⠁",
+			"⢋⠁",
+			"⡋⠁",
+			"⠍⠉",
+			"⠋⠉",
+			"⠋⠉",
+			"⠉⠙",
+			"⠉⠙",
+			"⠉⠩",
+			"⠈⢙",
+			"⠈⡙",
+			"⢈⠩",
+			"⡀⢙",
+			"⠄⡙",
+			"⢂⠩",
+			"⡂⢘",
+			"⠅⡘",
+			"⢃⠨",
+			"⡃⢐",
+			"⠍⡐",
+			"⢋⠠",
+			"⡋⢀",
+			"⠍⡁",
+			"⢋⠁",
+			"⡋⠁",
+			"⠍⠉",
+			"⠋⠉",
+			"⠋⠉",
+			"⠉⠙",
+			"⠉⠙",
+			"⠉⠩",
+			"⠈⢙",
+			"⠈⡙",
+			"⠈⠩",
+			"⠀⢙",
+			"⠀⡙",
+			"⠀⠩",
+			"⠀⢘",
+			"⠀⡘",
+			"⠀⠨",
+			"⠀⢐",
+			"⠀⡐",
+			"⠀⠠",
+			"⠀⢀",
+			"⠀⡀"
+		]
+	},
+	"line": {
+		"interval": 130,
+		"frames": [
+			"-",
+			"\\",
+			"|",
+			"/"
+		]
+	},
+	"line2": {
+		"interval": 100,
+		"frames": [
+			"⠂",
+			"-",
+			"–",
+			"—",
+			"–",
+			"-"
+		]
+	},
+	"pipe": {
+		"interval": 100,
+		"frames": [
+			"┤",
+			"┘",
+			"┴",
+			"└",
+			"├",
+			"┌",
+			"┬",
+			"┐"
+		]
+	},
+	"simpleDots": {
+		"interval": 400,
+		"frames": [
+			".  ",
+			".. ",
+			"...",
+			"   "
+		]
+	},
+	"simpleDotsScrolling": {
+		"interval": 200,
+		"frames": [
+			".  ",
+			".. ",
+			"...",
+			" ..",
+			"  .",
+			"   "
+		]
+	},
+	"star": {
+		"interval": 70,
+		"frames": [
+			"✶",
+			"✸",
+			"✹",
+			"✺",
+			"✹",
+			"✷"
+		]
+	},
+	"star2": {
+		"interval": 80,
+		"frames": [
+			"+",
+			"x",
+			"*"
+		]
+	},
+	"flip": {
+		"interval": 70,
+		"frames": [
+			"_",
+			"_",
+			"_",
+			"-",
+			"`",
+			"`",
+			"'",
+			"´",
+			"-",
+			"_",
+			"_",
+			"_"
+		]
+	},
+	"hamburger": {
+		"interval": 100,
+		"frames": [
+			"☱",
+			"☲",
+			"☴"
+		]
+	},
+	"growVertical": {
+		"interval": 120,
+		"frames": [
+			"▁",
+			"▃",
+			"▄",
+			"▅",
+			"▆",
+			"▇",
+			"▆",
+			"▅",
+			"▄",
+			"▃"
+		]
+	},
+	"growHorizontal": {
+		"interval": 120,
+		"frames": [
+			"▏",
+			"▎",
+			"▍",
+			"▌",
+			"▋",
+			"▊",
+			"▉",
+			"▊",
+			"▋",
+			"▌",
+			"▍",
+			"▎"
+		]
+	},
+	"balloon": {
+		"interval": 140,
+		"frames": [
+			" ",
+			".",
+			"o",
+			"O",
+			"@",
+			"*",
+			" "
+		]
+	},
+	"balloon2": {
+		"interval": 120,
+		"frames": [
+			".",
+			"o",
+			"O",
+			"°",
+			"O",
+			"o",
+			"."
+		]
+	},
+	"noise": {
+		"interval": 100,
+		"frames": [
+			"▓",
+			"▒",
+			"░"
+		]
+	},
+	"bounce": {
+		"interval": 120,
+		"frames": [
+			"⠁",
+			"⠂",
+			"⠄",
+			"⠂"
+		]
+	},
+	"boxBounce": {
+		"interval": 120,
+		"frames": [
+			"▖",
+			"▘",
+			"▝",
+			"▗"
+		]
+	},
+	"boxBounce2": {
+		"interval": 100,
+		"frames": [
+			"▌",
+			"▀",
+			"▐",
+			"▄"
+		]
+	},
+	"triangle": {
+		"interval": 50,
+		"frames": [
+			"◢",
+			"◣",
+			"◤",
+			"◥"
+		]
+	},
+	"arc": {
+		"interval": 100,
+		"frames": [
+			"◜",
+			"◠",
+			"◝",
+			"◞",
+			"◡",
+			"◟"
+		]
+	},
+	"circle": {
+		"interval": 120,
+		"frames": [
+			"◡",
+			"⊙",
+			"◠"
+		]
+	},
+	"squareCorners": {
+		"interval": 180,
+		"frames": [
+			"◰",
+			"◳",
+			"◲",
+			"◱"
+		]
+	},
+	"circleQuarters": {
+		"interval": 120,
+		"frames": [
+			"◴",
+			"◷",
+			"◶",
+			"◵"
+		]
+	},
+	"circleHalves": {
+		"interval": 50,
+		"frames": [
+			"◐",
+			"◓",
+			"◑",
+			"◒"
+		]
+	},
+	"squish": {
+		"interval": 100,
+		"frames": [
+			"╫",
+			"╪"
+		]
+	},
+	"toggle": {
+		"interval": 250,
+		"frames": [
+			"⊶",
+			"⊷"
+		]
+	},
+	"toggle2": {
+		"interval": 80,
+		"frames": [
+			"▫",
+			"▪"
+		]
+	},
+	"toggle3": {
+		"interval": 120,
+		"frames": [
+			"□",
+			"■"
+		]
+	},
+	"toggle4": {
+		"interval": 100,
+		"frames": [
+			"■",
+			"□",
+			"▪",
+			"▫"
+		]
+	},
+	"toggle5": {
+		"interval": 100,
+		"frames": [
+			"▮",
+			"▯"
+		]
+	},
+	"toggle6": {
+		"interval": 300,
+		"frames": [
+			"ဝ",
+			"၀"
+		]
+	},
+	"toggle7": {
+		"interval": 80,
+		"frames": [
+			"⦾",
+			"⦿"
+		]
+	},
+	"toggle8": {
+		"interval": 100,
+		"frames": [
+			"◍",
+			"◌"
+		]
+	},
+	"toggle9": {
+		"interval": 100,
+		"frames": [
+			"◉",
+			"◎"
+		]
+	},
+	"toggle10": {
+		"interval": 100,
+		"frames": [
+			"㊂",
+			"㊀",
+			"㊁"
+		]
+	},
+	"toggle11": {
+		"interval": 50,
+		"frames": [
+			"⧇",
+			"⧆"
+		]
+	},
+	"toggle12": {
+		"interval": 120,
+		"frames": [
+			"☗",
+			"☖"
+		]
+	},
+	"toggle13": {
+		"interval": 80,
+		"frames": [
+			"=",
+			"*",
+			"-"
+		]
+	},
+	"arrow": {
+		"interval": 100,
+		"frames": [
+			"←",
+			"↖",
+			"↑",
+			"↗",
+			"→",
+			"↘",
+			"↓",
+			"↙"
+		]
+	},
+	"arrow2": {
+		"interval": 80,
+		"frames": [
+			"⬆️ ",
+			"↗️ ",
+			"➡️ ",
+			"↘️ ",
+			"⬇️ ",
+			"↙️ ",
+			"⬅️ ",
+			"↖️ "
+		]
+	},
+	"arrow3": {
+		"interval": 120,
+		"frames": [
+			"▹▹▹▹▹",
+			"▸▹▹▹▹",
+			"▹▸▹▹▹",
+			"▹▹▸▹▹",
+			"▹▹▹▸▹",
+			"▹▹▹▹▸"
+		]
+	},
+	"bouncingBar": {
+		"interval": 80,
+		"frames": [
+			"[    ]",
+			"[=   ]",
+			"[==  ]",
+			"[=== ]",
+			"[ ===]",
+			"[  ==]",
+			"[   =]",
+			"[    ]",
+			"[   =]",
+			"[  ==]",
+			"[ ===]",
+			"[====]",
+			"[=== ]",
+			"[==  ]",
+			"[=   ]"
+		]
+	},
+	"bouncingBall": {
+		"interval": 80,
+		"frames": [
+			"( ●    )",
+			"(  ●   )",
+			"(   ●  )",
+			"(    ● )",
+			"(     ●)",
+			"(    ● )",
+			"(   ●  )",
+			"(  ●   )",
+			"( ●    )",
+			"(●     )"
+		]
+	},
+	"smiley": {
+		"interval": 200,
+		"frames": [
+			"😄 ",
+			"😝 "
+		]
+	},
+	"monkey": {
+		"interval": 300,
+		"frames": [
+			"🙈 ",
+			"🙈 ",
+			"🙉 ",
+			"🙊 "
+		]
+	},
+	"hearts": {
+		"interval": 100,
+		"frames": [
+			"💛 ",
+			"💙 ",
+			"💜 ",
+			"💚 ",
+			"❤️ "
+		]
+	},
+	"clock": {
+		"interval": 100,
+		"frames": [
+			"🕛 ",
+			"🕐 ",
+			"🕑 ",
+			"🕒 ",
+			"🕓 ",
+			"🕔 ",
+			"🕕 ",
+			"🕖 ",
+			"🕗 ",
+			"🕘 ",
+			"🕙 ",
+			"🕚 "
+		]
+	},
+	"earth": {
+		"interval": 180,
+		"frames": [
+			"🌍 ",
+			"🌎 ",
+			"🌏 "
+		]
+	},
+	"moon": {
+		"interval": 80,
+		"frames": [
+			"🌑 ",
+			"🌒 ",
+			"🌓 ",
+			"🌔 ",
+			"🌕 ",
+			"🌖 ",
+			"🌗 ",
+			"🌘 "
+		]
+	},
+	"runner": {
+		"interval": 140,
+		"frames": [
+			"🚶 ",
+			"🏃 "
+		]
+	},
+	"pong": {
+		"interval": 80,
+		"frames": [
+			"▐⠂       ▌",
+			"▐⠈       ▌",
+			"▐ ⠂      ▌",
+			"▐ ⠠      ▌",
+			"▐  ⡀     ▌",
+			"▐  ⠠     ▌",
+			"▐   ⠂    ▌",
+			"▐   ⠈    ▌",
+			"▐    ⠂   ▌",
+			"▐    ⠠   ▌",
+			"▐     ⡀  ▌",
+			"▐     ⠠  ▌",
+			"▐      ⠂ ▌",
+			"▐      ⠈ ▌",
+			"▐       ⠂▌",
+			"▐       ⠠▌",
+			"▐       ⡀▌",
+			"▐      ⠠ ▌",
+			"▐      ⠂ ▌",
+			"▐     ⠈  ▌",
+			"▐     ⠂  ▌",
+			"▐    ⠠   ▌",
+			"▐    ⡀   ▌",
+			"▐   ⠠    ▌",
+			"▐   ⠂    ▌",
+			"▐  ⠈     ▌",
+			"▐  ⠂     ▌",
+			"▐ ⠠      ▌",
+			"▐ ⡀      ▌",
+			"▐⠠       ▌"
+		]
+	},
+	"shark": {
+		"interval": 120,
+		"frames": [
+			"▐|\\____________▌",
+			"▐_|\\___________▌",
+			"▐__|\\__________▌",
+			"▐___|\\_________▌",
+			"▐____|\\________▌",
+			"▐_____|\\_______▌",
+			"▐______|\\______▌",
+			"▐_______|\\_____▌",
+			"▐________|\\____▌",
+			"▐_________|\\___▌",
+			"▐__________|\\__▌",
+			"▐___________|\\_▌",
+			"▐____________|\\▌",
+			"▐____________/|▌",
+			"▐___________/|_▌",
+			"▐__________/|__▌",
+			"▐_________/|___▌",
+			"▐________/|____▌",
+			"▐_______/|_____▌",
+			"▐______/|______▌",
+			"▐_____/|_______▌",
+			"▐____/|________▌",
+			"▐___/|_________▌",
+			"▐__/|__________▌",
+			"▐_/|___________▌",
+			"▐/|____________▌"
+		]
+	},
+	"dqpb": {
+		"interval": 100,
+		"frames": [
+			"d",
+			"q",
+			"p",
+			"b"
+		]
+	},
+	"weather": {
+		"interval": 100,
+		"frames": [
+			"☀️ ",
+			"☀️ ",
+			"☀️ ",
+			"🌤 ",
+			"⛅️ ",
+			"🌥 ",
+			"☁️ ",
+			"🌧 ",
+			"🌨 ",
+			"🌧 ",
+			"🌨 ",
+			"🌧 ",
+			"🌨 ",
+			"⛈ ",
+			"🌨 ",
+			"🌧 ",
+			"🌨 ",
+			"☁️ ",
+			"🌥 ",
+			"⛅️ ",
+			"🌤 ",
+			"☀️ ",
+			"☀️ "
+		]
+	},
+	"christmas": {
+		"interval": 400,
+		"frames": [
+			"🌲",
+			"🎄"
+		]
+	},
+	"grenade": {
+		"interval": 80,
+		"frames": [
+			"،   ",
+			"′   ",
+			" ´ ",
+			" ‾ ",
+			"  ⸌",
+			"  ⸊",
+			"  |",
+			"  ⁎",
+			"  ⁕",
+			" ෴ ",
+			"  ⁓",
+			"   ",
+			"   ",
+			"   "
+		]
+	},
+	"point": {
+		"interval": 125,
+		"frames": [
+			"∙∙∙",
+			"●∙∙",
+			"∙●∙",
+			"∙∙●",
+			"∙∙∙"
+		]
+	},
+	"layer": {
+		"interval": 150,
+		"frames": [
+			"-",
+			"=",
+			"≡"
+		]
+	}
+}
diff --git a/pipenv/vendor/yaspin/helpers.py b/pipenv/vendor/yaspin/helpers.py
new file mode 100644
index 00000000..49ce0d06
--- /dev/null
+++ b/pipenv/vendor/yaspin/helpers.py
@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+"""
+yaspin.helpers
+~~~~~~~~~~~~~~
+
+Helper functions.
+"""
+
+from __future__ import absolute_import
+
+from .compat import bytes
+from .constants import ENCODING
+
+
+def to_unicode(text_type, encoding=ENCODING):
+    if isinstance(text_type, bytes):
+        return text_type.decode(encoding)
+    return text_type
diff --git a/pipenv/vendor/yaspin/signal_handlers.py b/pipenv/vendor/yaspin/signal_handlers.py
new file mode 100644
index 00000000..f38f5d6b
--- /dev/null
+++ b/pipenv/vendor/yaspin/signal_handlers.py
@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+
+"""
+yaspin.signal_handlers
+~~~~~~~~~~~~~~~~~~~~~~
+
+Callback functions or "signal handlers", that are invoked
+when the signal occurs.
+"""
+
+import sys
+
+
+def default_handler(signum, frame, spinner):
+    """Signal handler, used to gracefully shut down the ``spinner`` instance
+    when specified signal is received by the process running the ``spinner``.
+
+    ``signum`` and ``frame`` are mandatory arguments. Check ``signal.signal``
+    function for more details.
+    """
+    spinner.fail()
+    spinner.stop()
+    sys.exit(0)
+
+
+def fancy_handler(signum, frame, spinner):
+    """Signal handler, used to gracefully shut down the ``spinner`` instance
+    when specified signal is received by the process running the ``spinner``.
+
+    ``signum`` and ``frame`` are mandatory arguments. Check ``signal.signal``
+    function for more details.
+    """
+    spinner.red.fail("✘")
+    spinner.stop()
+    sys.exit(0)
diff --git a/pipenv/vendor/yaspin/spinners.py b/pipenv/vendor/yaspin/spinners.py
new file mode 100644
index 00000000..9c3fa7b8
--- /dev/null
+++ b/pipenv/vendor/yaspin/spinners.py
@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+"""
+yaspin.spinners
+~~~~~~~~~~~~~~~
+
+A collection of cli spinners.
+"""
+
+import codecs
+import os
+from collections import namedtuple
+
+try:
+    import simplejson as json
+except ImportError:
+    import json
+
+
+THIS_DIR = os.path.dirname(os.path.realpath(__file__))
+SPINNERS_PATH = os.path.join(THIS_DIR, "data/spinners.json")
+
+
+def _hook(dct):
+    return namedtuple("Spinner", dct.keys())(*dct.values())
+
+
+with codecs.open(SPINNERS_PATH, encoding="utf-8") as f:
+    Spinners = json.load(f, object_hook=_hook)
diff --git a/pipenv/vendor/yaspin/termcolor.py b/pipenv/vendor/yaspin/termcolor.py
new file mode 100644
index 00000000..f11b824b
--- /dev/null
+++ b/pipenv/vendor/yaspin/termcolor.py
@@ -0,0 +1,168 @@
+# coding: utf-8
+# Copyright (c) 2008-2011 Volvox Development Team
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Author: Konstantin Lepa <konstantin.lepa@gmail.com>
+
+"""ANSII Color formatting for output in terminal."""
+
+from __future__ import print_function
+import os
+
+
+__ALL__ = [ 'colored', 'cprint' ]
+
+VERSION = (1, 1, 0)
+
+ATTRIBUTES = dict(
+        list(zip([
+            'bold',
+            'dark',
+            '',
+            'underline',
+            'blink',
+            '',
+            'reverse',
+            'concealed'
+            ],
+            list(range(1, 9))
+            ))
+        )
+del ATTRIBUTES['']
+
+
+HIGHLIGHTS = dict(
+        list(zip([
+            'on_grey',
+            'on_red',
+            'on_green',
+            'on_yellow',
+            'on_blue',
+            'on_magenta',
+            'on_cyan',
+            'on_white'
+            ],
+            list(range(40, 48))
+            ))
+        )
+
+
+COLORS = dict(
+        list(zip([
+            'grey',
+            'red',
+            'green',
+            'yellow',
+            'blue',
+            'magenta',
+            'cyan',
+            'white',
+            ],
+            list(range(30, 38))
+            ))
+        )
+
+
+RESET = '\033[0m'
+
+
+def colored(text, color=None, on_color=None, attrs=None):
+    """Colorize text.
+
+    Available text colors:
+        red, green, yellow, blue, magenta, cyan, white.
+
+    Available text highlights:
+        on_red, on_green, on_yellow, on_blue, on_magenta, on_cyan, on_white.
+
+    Available attributes:
+        bold, dark, underline, blink, reverse, concealed.
+
+    Example:
+        colored('Hello, World!', 'red', 'on_grey', ['blue', 'blink'])
+        colored('Hello, World!', 'green')
+    """
+    if os.getenv('ANSI_COLORS_DISABLED') is None:
+        fmt_str = '\033[%dm%s'
+        if color is not None:
+            text = fmt_str % (COLORS[color], text)
+
+        if on_color is not None:
+            text = fmt_str % (HIGHLIGHTS[on_color], text)
+
+        if attrs is not None:
+            for attr in attrs:
+                text = fmt_str % (ATTRIBUTES[attr], text)
+
+        text += RESET
+    return text
+
+
+def cprint(text, color=None, on_color=None, attrs=None, **kwargs):
+    """Print colorize text.
+
+    It accepts arguments of print function.
+    """
+
+    print((colored(text, color, on_color, attrs)), **kwargs)
+
+
+if __name__ == '__main__':
+    print('Current terminal type: %s' % os.getenv('TERM'))
+    print('Test basic colors:')
+    cprint('Grey color', 'grey')
+    cprint('Red color', 'red')
+    cprint('Green color', 'green')
+    cprint('Yellow color', 'yellow')
+    cprint('Blue color', 'blue')
+    cprint('Magenta color', 'magenta')
+    cprint('Cyan color', 'cyan')
+    cprint('White color', 'white')
+    print(('-' * 78))
+
+    print('Test highlights:')
+    cprint('On grey color', on_color='on_grey')
+    cprint('On red color', on_color='on_red')
+    cprint('On green color', on_color='on_green')
+    cprint('On yellow color', on_color='on_yellow')
+    cprint('On blue color', on_color='on_blue')
+    cprint('On magenta color', on_color='on_magenta')
+    cprint('On cyan color', on_color='on_cyan')
+    cprint('On white color', color='grey', on_color='on_white')
+    print('-' * 78)
+
+    print('Test attributes:')
+    cprint('Bold grey color', 'grey', attrs=['bold'])
+    cprint('Dark red color', 'red', attrs=['dark'])
+    cprint('Underline green color', 'green', attrs=['underline'])
+    cprint('Blink yellow color', 'yellow', attrs=['blink'])
+    cprint('Reversed blue color', 'blue', attrs=['reverse'])
+    cprint('Concealed Magenta color', 'magenta', attrs=['concealed'])
+    cprint('Bold underline reverse cyan color', 'cyan',
+            attrs=['bold', 'underline', 'reverse'])
+    cprint('Dark blink concealed white color', 'white',
+            attrs=['dark', 'blink', 'concealed'])
+    print(('-' * 78))
+
+    print('Test mixing:')
+    cprint('Underline red on grey color', 'red', 'on_grey',
+            ['underline'])
+    cprint('Reversed green on red color', 'green', 'on_red', ['reverse'])
+
diff --git a/pytest.ini b/pytest.ini
index eee579da..2bfca079 100644
--- a/pytest.ini
+++ b/pytest.ini
@@ -1,5 +1,8 @@
 [pytest]
 addopts = -ra -n auto
-testpaths = tests/
+testpaths = tests
 ; Add vendor and patched in addition to the default list of ignored dirs
 norecursedirs = .* build dist CVS _darcs {arch} *.egg vendor patched news tasks docs
+filterwarnings =
+    ignore::DeprecationWarning
+    ignore::PendingDeprecationWarning
diff --git a/tasks/__init__.py b/tasks/__init__.py
index 581f5076..6896edb6 100644
--- a/tasks/__init__.py
+++ b/tasks/__init__.py
@@ -2,7 +2,21 @@
 # Copyied from pip's vendoring process
 # see https://github.com/pypa/pip/blob/95bcf8c5f6394298035a7332c441868f3b0169f4/tasks/__init__.py
 import invoke
+import re
 
 from . import vendoring, release
+from .vendoring import vendor_passa
+from pathlib import Path
 
-ns = invoke.Collection(vendoring, release)
+ROOT = Path(".").parent.parent.absolute()
+
+
+@invoke.task
+def clean_mdchangelog(ctx):
+    changelog = ROOT / "CHANGELOG.md"
+    content = changelog.read_text()
+    content = re.sub(r"([^\n]+)\n?\s+\[[\\]+(#\d+)\]\(https://github\.com/pypa/[\w\-]+/issues/\d+\)", r"\1 \2", content, flags=re.MULTILINE)
+    changelog.write_text(content)
+
+
+ns = invoke.Collection(vendoring, release, clean_mdchangelog, vendor_passa.vendor_passa)
diff --git a/tasks/vendoring/__init__.py b/tasks/vendoring/__init__.py
index 9e36723b..ea0d038c 100644
--- a/tasks/vendoring/__init__.py
+++ b/tasks/vendoring/__init__.py
@@ -20,6 +20,7 @@ LIBRARY_DIRNAMES = {
     'requirements-parser': 'requirements',
     'backports.shutil_get_terminal_size': 'backports/shutil_get_terminal_size',
     'backports.weakref': 'backports/weakref',
+    'backports.functools_lru_cache': 'backports/functools_lru_cache',
     'shutil_backports': 'backports/shutil_get_terminal_size',
     'python-dotenv': 'dotenv',
     'pip-tools': 'piptools',
@@ -34,6 +35,7 @@ PY2_DOWNLOAD = ['enum34',]
 # from time to time, remove the no longer needed ones
 HARDCODED_LICENSE_URLS = {
     'pytoml': 'https://github.com/avakar/pytoml/raw/master/LICENSE',
+    'cursor': 'https://raw.githubusercontent.com/GijsTimmers/cursor/master/LICENSE',
     'delegator.py': 'https://raw.githubusercontent.com/kennethreitz/delegator.py/master/LICENSE',
     'click-didyoumean': 'https://raw.githubusercontent.com/click-contrib/click-didyoumean/master/LICENSE',
     'click-completion': 'https://raw.githubusercontent.com/click-contrib/click-completion/master/LICENSE',
@@ -48,7 +50,9 @@ HARDCODED_LICENSE_URLS = {
                     'master/LICENSE',
     'requirementslib': 'https://github.com/techalchemy/requirementslib/raw/master/LICENSE',
     'distlib': 'https://github.com/vsajip/distlib/raw/master/LICENSE.txt',
-    'pythonfinder': 'https://raw.githubusercontent.com/techalchemy/pythonfinder/master/LICENSE.txt'
+    'pythonfinder': 'https://raw.githubusercontent.com/techalchemy/pythonfinder/master/LICENSE.txt',
+    'pyparsing': 'https://raw.githubusercontent.com/pyparsing/pyparsing/master/LICENSE',
+    'resolvelib': 'https://raw.githubusercontent.com/sarugaku/resolvelib/master/LICENSE'
 }
 
 FILE_WHITE_LIST = (
@@ -70,13 +74,14 @@ PATCHED_RENAMES = {
 
 LIBRARY_RENAMES = {
     'pip': 'pipenv.patched.notpip',
+    "functools32": "pipenv.vendor.backports.functools_lru_cache",
     'enum34': 'enum',
 }
 
 
 def drop_dir(path):
     if path.exists() and path.is_dir():
-        shutil.rmtree(str(path))
+        shutil.rmtree(str(path), ignore_errors=True)
 
 
 def remove_all(paths):
@@ -110,8 +115,6 @@ def clean_vendor(ctx, vendor_dir):
     for item in vendor_dir.iterdir():
         if item.is_dir():
             shutil.rmtree(str(item))
-        elif "LICENSE" in item.name or "COPYING" in item.name:
-            continue
         elif item.name not in FILE_WHITE_LIST:
             item.unlink()
         else:
@@ -306,7 +309,6 @@ def _ensure_package_in_requirements(ctx, requirements_file, package):
     return requirement
 
 
-
 def install(ctx, vendor_dir, package=None):
     requirements_file = vendor_dir / "{0}.txt".format(vendor_dir.name)
     requirement = "-r {0}".format(requirements_file.as_posix())
@@ -331,6 +333,7 @@ def post_install_cleanup(ctx, vendor_dir):
     # Cleanup setuptools unneeded parts
     drop_dir(vendor_dir / 'bin')
     drop_dir(vendor_dir / 'tests')
+    remove_all(vendor_dir.glob('toml.py'))
 
 
 def vendor(ctx, vendor_dir, package=None, rewrite=True):
@@ -354,6 +357,10 @@ def vendor(ctx, vendor_dir, package=None, rewrite=True):
 
     log("Removing scandir library files...")
     remove_all(vendor_dir.glob('*.so'))
+    drop_dir(vendor_dir / 'setuptools')
+    drop_dir(vendor_dir / 'pkg_resources' / '_vendor')
+    drop_dir(vendor_dir / 'pkg_resources' / 'extern')
+    drop_dir(vendor_dir / 'bin')
 
     # Global import rewrites
     log('Renaming specified libs...')
@@ -628,5 +635,8 @@ def main(ctx, package=None):
         vendor_file = _vendor_dir / 'vendor.txt'
         vendor_file.write_bytes(vendor_src_file.read_bytes())
         download_licenses(ctx, _vendor_dir)
+    # from .vendor_passa import vendor_passa
+    # log("Vendoring passa...")
+    # vendor_passa(ctx)
     # update_safety(ctx)
     log('Revendoring complete')
diff --git a/tasks/vendoring/patches/patched/_post-pip-update-pep425tags.patch b/tasks/vendoring/patches/patched/_post-pip-update-pep425tags.patch
index 654a3da9..fce6ae89 100644
--- a/tasks/vendoring/patches/patched/_post-pip-update-pep425tags.patch
+++ b/tasks/vendoring/patches/patched/_post-pip-update-pep425tags.patch
@@ -1,20 +1,8 @@
 diff --git a/pipenv/patched/notpip/_internal/pep425tags.py b/pipenv/patched/notpip/_internal/pep425tags.py
-index c9804ab5..89c95c45 100644
+index f3b9b5b4..182c1c88 100644
 --- a/pipenv/patched/notpip/_internal/pep425tags.py
 +++ b/pipenv/patched/notpip/_internal/pep425tags.py
-@@ -10,10 +10,7 @@ import sysconfig
- import warnings
- from collections import OrderedDict
- 
--try:
--    import pipenv.patched.notpip._internal.utils.glibc
--except ImportError:
--    import pipenv.patched.notpip.utils.glibc
-+import pipenv.patched.notpip._internal.utils.glibc
- 
- logger = logging.getLogger(__name__)
- 
-@@ -157,7 +154,7 @@ def is_manylinux1_compatible():
+@@ -159,7 +159,7 @@ def is_manylinux1_compatible():
          pass
  
      # Check glibc version. CentOS 5 uses glibc 2.5.
diff --git a/tasks/vendoring/patches/patched/crayons.patch b/tasks/vendoring/patches/patched/crayons.patch
index b9e3b1d0..d7fa3d40 100644
--- a/tasks/vendoring/patches/patched/crayons.patch
+++ b/tasks/vendoring/patches/patched/crayons.patch
@@ -1,8 +1,8 @@
 diff --git a/pipenv/patched/crayons.py b/pipenv/patched/crayons.py
-index 455d3e90..bb4b3d97 100644
+index 455d3e90..de735daf 100644
 --- a/pipenv/patched/crayons.py
 +++ b/pipenv/patched/crayons.py
-@@ -12,21 +12,45 @@ import os
+@@ -12,41 +12,72 @@ import os
  import re
  import sys
  
@@ -41,6 +41,7 @@ index 455d3e90..bb4b3d97 100644
 +    os.environ.get("CMDER_ROOT")
 +    or os.environ.get("VSCODE_PID")
 +    or os.environ.get("TERM_PROGRAM") == "Hyper"
++    or "VSCODE_CWD" in os.environ
 +):
 +    is_native_powershell = False
 +else:
@@ -51,12 +52,19 @@ index 455d3e90..bb4b3d97 100644
 +except shellingham.ShellDetectionFailure:
 +    is_powershell = False
 +
-+if is_ipython or (is_powershell and is_native_powershell):
++DISABLE_COLOR = False
++REPLACE_BLUE = False
++if is_ipython:
 +    """when ipython is fired lot of variables like _oh, etc are used.
         There are so many ways to find current python interpreter is ipython.
         get_ipython is easiest is most appealing for readers to understand.
      """
-@@ -37,16 +61,17 @@ else:
+     DISABLE_COLOR = True
+-else:
+-    DISABLE_COLOR = False
++elif is_powershell and is_native_powershell:
++    REPLACE_BLUE = True
+ 
  
  class ColoredString(object):
      """Enhanced string for __len__ operations on Colored output."""
@@ -68,6 +76,9 @@ index 455d3e90..bb4b3d97 100644
 +            self.s = s.encode("utf-8")
          else:
              self.s = s
++
++        if color == "BLUE" and REPLACE_BLUE:
++            color = "MAGENTA"
          self.color = color
          self.always_color = always_color
          self.bold = bold
@@ -76,7 +87,7 @@ index 455d3e90..bb4b3d97 100644
              self.always_color = True
  
      def __getattr__(self, att):
-@@ -62,12 +87,19 @@ class ColoredString(object):
+@@ -62,12 +93,19 @@ class ColoredString(object):
                  return [self._new(x) for x in result]
              else:
                  return result
@@ -98,7 +109,7 @@ index 455d3e90..bb4b3d97 100644
  
          if self.always_color:
              return c
-@@ -76,7 +108,6 @@ class ColoredString(object):
+@@ -76,7 +114,6 @@ class ColoredString(object):
          else:
              return self.s
  
@@ -106,7 +117,7 @@ index 455d3e90..bb4b3d97 100644
      def __len__(self):
          return len(self.s)
  
-@@ -86,12 +117,13 @@ class ColoredString(object):
+@@ -86,12 +123,13 @@ class ColoredString(object):
      def __unicode__(self):
          value = self.color_str
          if isinstance(value, bytes):
@@ -121,7 +132,7 @@ index 455d3e90..bb4b3d97 100644
          def __str__(self):
              return self.color_str
  
-@@ -105,45 +137,60 @@ class ColoredString(object):
+@@ -105,45 +143,60 @@ class ColoredString(object):
          return str(other) + str(self.color_str)
  
      def __mul__(self, other):
diff --git a/tasks/vendoring/patches/patched/pip10.patch b/tasks/vendoring/patches/patched/pip18.patch
similarity index 61%
rename from tasks/vendoring/patches/patched/pip10.patch
rename to tasks/vendoring/patches/patched/pip18.patch
index 92e87e60..f4e607c1 100644
--- a/tasks/vendoring/patches/patched/pip10.patch
+++ b/tasks/vendoring/patches/patched/pip18.patch
@@ -1,5 +1,5 @@
 diff --git a/pipenv/patched/pip/_internal/download.py b/pipenv/patched/pip/_internal/download.py
-index 06d72019..c3501bbf 100644
+index 96f3b65c..cc5b3d15 100644
 --- a/pipenv/patched/pip/_internal/download.py
 +++ b/pipenv/patched/pip/_internal/download.py
 @@ -19,6 +19,7 @@ from pip._vendor.lockfile import LockError
@@ -10,7 +10,7 @@ index 06d72019..c3501bbf 100644
  from pip._vendor.requests.structures import CaseInsensitiveDict
  from pip._vendor.requests.utils import get_netrc_auth
  # NOTE: XMLRPC Client is not annotated in typeshed as on 2017-07-17, which is
-@@ -70,7 +71,7 @@ def user_agent():
+@@ -69,7 +70,7 @@ def user_agent():
      Return a string representing the user agent.
      """
      data = {
@@ -19,53 +19,88 @@ index 06d72019..c3501bbf 100644
          "python": platform.python_version(),
          "implementation": {
              "name": platform.python_implementation(),
-@@ -323,7 +324,7 @@ class InsecureHTTPAdapter(HTTPAdapter):
-         conn.ca_certs = None
+diff --git a/pipenv/patched/pip/_internal/utils/temp_dir.py b/pipenv/patched/pip/_internal/utils/temp_dir.py
+index edc506bf..84d57dac 100644
+--- a/pipenv/patched/pip/_internal/utils/temp_dir.py
++++ b/pipenv/patched/pip/_internal/utils/temp_dir.py
+@@ -3,8 +3,10 @@ from __future__ import absolute_import
+ import logging
+ import os.path
+ import tempfile
++import warnings
  
+ from pip._internal.utils.misc import rmtree
++from pipenv.vendor.vistir.compat import finalize, ResourceWarning
  
--class PipSession(requests.Session):
-+class PipSession(Session):
+ logger = logging.getLogger(__name__)
  
-     timeout = None
- 
-@@ -753,7 +754,7 @@ def _copy_dist_from_dir(link_path, location):
- 
-     # build an sdist
-     setup_py = 'setup.py'
--    sdist_args = [sys.executable]
-+    sdist_args = [os.environ.get('PIP_PYTHON_PATH', sys.executable)]
-     sdist_args.append('-c')
-     sdist_args.append(SETUPTOOLS_SHIM % setup_py)
-     sdist_args.append('sdist')
-diff --git a/pipenv/patched/pip/_internal/index.py b/pipenv/patched/pip/_internal/index.py
-index 3c3a92b7..fad6a623 100644
---- a/pipenv/patched/pip/_internal/index.py
-+++ b/pipenv/patched/pip/_internal/index.py
-@@ -59,11 +59,12 @@ logger = logging.getLogger(__name__)
- 
- class InstallationCandidate(object):
- 
--    def __init__(self, project, version, location):
-+    def __init__(self, project, version, location, requires_python=''):
-         self.project = project
-         self.version = parse_version(version)
-         self.location = location
-         self._key = (self.project, self.version, self.location)
-+        self.requires_python = requires_python
+@@ -45,6 +47,20 @@ class TempDirectory(object):
+         self.path = path
+         self.delete = delete
+         self.kind = kind
++        self._finalizer = None
++        if path:
++            self._register_finalizer()
++
++    def _register_finalizer(self):
++        if self.delete and self.path:
++            self._finalizer = finalize(
++                self,
++                self._cleanup,
++                self.path,
++                warn_message=None
++            )
++        else:
++            self._finalizer = None
  
      def __repr__(self):
-         return "<InstallationCandidate({!r}, {!r}, {!r})>".format(
-@@ -168,6 +169,9 @@ class PackageFinder(object):
+         return "<{} {!r}>".format(self.__class__.__name__, self.path)
+@@ -72,11 +88,27 @@ class TempDirectory(object):
+         self.path = os.path.realpath(
+             tempfile.mkdtemp(prefix="pip-{}-".format(self.kind))
+         )
++        self._register_finalizer()
+         logger.debug("Created temporary directory: {}".format(self.path))
+ 
++    @classmethod
++    def _cleanup(cls, name, warn_message=None):
++        try:
++            rmtree(name)
++        except OSError:
++            pass
++        else:
++            if warn_message:
++                warnings.warn(warn_message, ResourceWarning)
++
+     def cleanup(self):
+         """Remove the temporary directory created and reset state
+         """
+-        if self.path is not None and os.path.exists(self.path):
+-            rmtree(self.path)
+-        self.path = None
++        if getattr(self._finalizer, "detach", None) and self._finalizer.detach():
++            if os.path.exists(self.path):
++                try:
++                    rmtree(self.path)
++                except OSError:
++                    pass
++                else:
++                    self.path = None
+diff --git a/pipenv/patched/pip/_internal/index.py b/pipenv/patched/pip/_internal/index.py
+index 8c2f24f1..cdd48874 100644
+--- a/pipenv/patched/pip/_internal/index.py
++++ b/pipenv/patched/pip/_internal/index.py
+@@ -246,6 +246,9 @@ class PackageFinder(object):
          # The Session we'll use to make requests
          self.session = session
  
-+        # Kenneth's Hack.
++        # Kenneth's Hack
 +        self.extra = None
 +
          # The valid tags to check potential found wheel candidates against
          self.valid_tags = get_supported(
              versions=versions,
-@@ -214,6 +218,24 @@ class PackageFinder(object):
+@@ -298,6 +301,25 @@ class PackageFinder(object):
              )
              self.dependency_links.extend(links)
  
@@ -86,11 +121,12 @@ index 3c3a92b7..fad6a623 100644
 +                current_list.append(link)
 +
 +        return extras
++
 +
      @staticmethod
      def _sort_locations(locations, expand_dir=False):
          """
-@@ -266,7 +288,7 @@ class PackageFinder(object):
+@@ -350,7 +372,7 @@ class PackageFinder(object):
  
          return files, urls
  
@@ -99,7 +135,7 @@ index 3c3a92b7..fad6a623 100644
          """
          Function used to generate link sort key for link tuples.
          The greater the return value, the more preferred it is.
-@@ -284,12 +306,18 @@ class PackageFinder(object):
+@@ -370,14 +392,19 @@ class PackageFinder(object):
          if candidate.location.is_wheel:
              # can raise InvalidWheelFilename
              wheel = Wheel(candidate.location.filename)
@@ -109,8 +145,9 @@ index 3c3a92b7..fad6a623 100644
                      "%s is not a supported wheel for this platform. It "
                      "can't be sorted." % wheel.filename
                  )
+             if self.prefer_binary:
+                 binary_preference = 1
 -            pri = -(wheel.support_index_min(self.valid_tags))
-+
 +            tags = self.valid_tags if not ignore_compatibility else None
 +            try:
 +                pri = -(wheel.support_index_min(tags=tags))
@@ -120,7 +157,19 @@ index 3c3a92b7..fad6a623 100644
              if wheel.build_tag is not None:
                  match = re.match(r'^(\d+)(.*)$', wheel.build_tag)
                  build_tag_groups = match.groups()
-@@ -474,7 +502,7 @@ class PackageFinder(object):
+@@ -528,7 +555,10 @@ class PackageFinder(object):
+ 
+         page_versions = []
+         for page in self._get_pages(url_locations, project_name):
+-            logger.debug('Analyzing links from page %s', page.url)
++            try:
++                logger.debug('Analyzing links from page %s', page.url)
++            except AttributeError:
++                continue
+             with indent_log():
+                 page_versions.extend(
+                     self._package_versions(page.iter_links(), search)
+@@ -562,7 +592,7 @@ class PackageFinder(object):
              dependency_versions
          )
  
@@ -129,60 +178,19 @@ index 3c3a92b7..fad6a623 100644
          """Try to find a Link matching req
  
          Expects req, an InstallRequirement and upgrade, a boolean
-@@ -484,22 +512,25 @@ class PackageFinder(object):
-         all_candidates = self.find_all_candidates(req.name)
- 
-         # Filter out anything which doesn't match our specifier
--        compatible_versions = set(
--            req.specifier.filter(
--                # We turn the version object into a str here because otherwise
--                # when we're debundled but setuptools isn't, Python will see
--                # packaging.version.Version and
--                # pkg_resources._vendor.packaging.version.Version as different
--                # types. This way we'll use a str as a common data interchange
--                # format. If we stop using the pkg_resources provided specifier
--                # and start using our own, we can drop the cast to str().
--                [str(c.version) for c in all_candidates],
--                prereleases=(
--                    self.allow_all_prereleases
--                    if self.allow_all_prereleases else None
--                ),
-+        if not ignore_compatibility:
-+            compatible_versions = set(
-+                req.specifier.filter(
-+                    # We turn the version object into a str here because otherwise
-+                    # when we're debundled but setuptools isn't, Python will see
-+                    # packaging.version.Version and
-+                    # pkg_resources._vendor.packaging.version.Version as different
-+                    # types. This way we'll use a str as a common data interchange
-+                    # format. If we stop using the pkg_resources provided specifier
-+                    # and start using our own, we can drop the cast to str().
-+                    [str(c.version) for c in all_candidates],
-+                    prereleases=(
-+                        self.allow_all_prereleases
-+                        if self.allow_all_prereleases else None
-+                    ),
-+                )
-             )
--        )
-+        else:
-+            compatible_versions = [str(c.version) for c in all_candidates]
-         applicable_candidates = [
-             # Again, converting to str to deal with debundling.
-             c for c in all_candidates if str(c.version) in compatible_versions
-@@ -584,7 +615,10 @@ class PackageFinder(object):
+@@ -672,7 +702,10 @@ class PackageFinder(object):
                  continue
              seen.add(location)
  
 -            page = self._get_page(location)
 +            try:
 +                page = self._get_page(location)
-+            except requests.HTTPError as e:
-+                page = None
++            except requests.HTTPError:
++                continue
              if page is None:
                  continue
  
-@@ -621,7 +655,7 @@ class PackageFinder(object):
+@@ -709,7 +742,7 @@ class PackageFinder(object):
              logger.debug('Skipping link %s; %s', link, reason)
              self.logged_links.add(link)
  
@@ -191,13 +199,7 @@ index 3c3a92b7..fad6a623 100644
          """Return an InstallationCandidate or None"""
          version = None
          if link.egg_fragment:
-@@ -632,17 +666,18 @@ class PackageFinder(object):
-             if not ext:
-                 self._log_skipped_link(link, 'not a file')
-                 return
-+            # Always ignore unsupported extensions even when we ignore compatibility
-             if ext not in SUPPORTED_EXTENSIONS:
-                 self._log_skipped_link(
+@@ -725,12 +758,12 @@ class PackageFinder(object):
                      link, 'unsupported archive format: %s' % ext,
                  )
                  return
@@ -212,7 +214,7 @@ index 3c3a92b7..fad6a623 100644
                  self._log_skipped_link(link, 'macosx10 one')
                  return
              if ext == wheel_ext:
-@@ -656,7 +691,7 @@ class PackageFinder(object):
+@@ -744,7 +777,7 @@ class PackageFinder(object):
                          link, 'wrong project name (not %s)' % search.supplied)
                      return
  
@@ -221,7 +223,7 @@ index 3c3a92b7..fad6a623 100644
                      self._log_skipped_link(
                          link, 'it is not compatible with this Python')
                      return
-@@ -692,14 +727,14 @@ class PackageFinder(object):
+@@ -780,14 +813,14 @@ class PackageFinder(object):
                           link.filename, link.requires_python)
              support_this_python = True
  
@@ -237,84 +239,158 @@ index 3c3a92b7..fad6a623 100644
 +        return InstallationCandidate(search.supplied, version, link, link.requires_python)
  
      def _get_page(self, link):
-         return HTMLPage.get_page(link, session=self.session)
+         return _get_html_page(link, session=self.session)
+diff --git a/pipenv/patched/pip/_internal/models/candidate.py b/pipenv/patched/pip/_internal/models/candidate.py
+index c736de6c..a78566c1 100644
+--- a/pipenv/patched/pip/_internal/models/candidate.py
++++ b/pipenv/patched/pip/_internal/models/candidate.py
+@@ -7,10 +7,11 @@ class InstallationCandidate(KeyBasedCompareMixin):
+     """Represents a potential "candidate" for installation.
+     """
+ 
+-    def __init__(self, project, version, location):
++    def __init__(self, project, version, location, requires_python=None):
+         self.project = project
+         self.version = parse_version(version)
+         self.location = location
++        self.requires_python = requires_python
+ 
+         super(InstallationCandidate, self).__init__(
+             key=(self.project, self.version, self.location),
+diff --git a/pipenv/patched/pip/_internal/operations/prepare.py b/pipenv/patched/pip/_internal/operations/prepare.py
+index 104bea33..ecf78b9a 100644
+--- a/pipenv/patched/pip/_internal/operations/prepare.py
++++ b/pipenv/patched/pip/_internal/operations/prepare.py
+@@ -17,7 +17,7 @@ from pip._internal.exceptions import (
+ from pip._internal.utils.compat import expanduser
+ from pip._internal.utils.hashes import MissingHashes
+ from pip._internal.utils.logging import indent_log
+-from pip._internal.utils.misc import display_path, normalize_path
++from pip._internal.utils.misc import display_path, normalize_path, rmtree
+ from pip._internal.vcs import vcs
+ 
+ logger = logging.getLogger(__name__)
+@@ -123,7 +123,11 @@ class IsSDist(DistAbstraction):
+                     " and ".join(map(repr, sorted(missing)))
+                 )
+ 
+-        self.req.run_egg_info()
++        try:
++            self.req.run_egg_info()
++        except (OSError, TypeError):
++            self.req._correct_build_location()
++            self.req.run_egg_info()
+         self.req.assert_source_matches_version()
+ 
+ 
+@@ -205,16 +209,8 @@ class RequirementPreparer(object):
+             # installation.
+             # FIXME: this won't upgrade when there's an existing
+             # package unpacked in `req.source_dir`
+-            # package unpacked in `req.source_dir`
+             if os.path.exists(os.path.join(req.source_dir, 'setup.py')):
+-                raise PreviousBuildDirError(
+-                    "pip can't proceed with requirements '%s' due to a"
+-                    " pre-existing build directory (%s). This is "
+-                    "likely due to a previous installation that failed"
+-                    ". pip is being responsible and not assuming it "
+-                    "can delete this. Please delete it and try again."
+-                    % (req, req.source_dir)
+-                )
++                rmtree(req.source_dir)
+             req.populate_link(finder, upgrade_allowed, require_hashes)
+ 
+             # We can't hit this spot and have populate_link return None.
+diff --git a/pipenv/patched/pip/_internal/pep425tags.py b/pipenv/patched/pip/_internal/pep425tags.py
+index ab1a0298..763c0a24 100644
+--- a/pipenv/patched/pip/_internal/pep425tags.py
++++ b/pipenv/patched/pip/_internal/pep425tags.py
+@@ -10,7 +10,11 @@ import sysconfig
+ import warnings
+ from collections import OrderedDict
+ 
+-import pip._internal.utils.glibc
++try:
++    import pip._internal.utils.glibc
++except ImportError:
++    import pip.utils.glibc
++
+ from pip._internal.utils.compat import get_extension_suffixes
+ 
+ logger = logging.getLogger(__name__)
 diff --git a/pipenv/patched/pip/_internal/req/req_install.py b/pipenv/patched/pip/_internal/req/req_install.py
-index ddd167c6..344bce5b 100644
+index c2624fee..ee75acd6 100644
 --- a/pipenv/patched/pip/_internal/req/req_install.py
 +++ b/pipenv/patched/pip/_internal/req/req_install.py
-@@ -465,7 +465,7 @@ class InstallRequirement(object):
+@@ -452,7 +452,8 @@ class InstallRequirement(object):
  
          with indent_log():
              script = SETUPTOOLS_SHIM % self.setup_py
 -            base_cmd = [sys.executable, '-c', script]
-+            base_cmd = [os.environ.get('PIP_PYTHON_PATH', sys.executable), '-c', script]
++            sys_executable = os.environ.get('PIP_PYTHON_PATH', sys.executable)
++            base_cmd = [sys_executable, '-c', script]
              if self.isolated:
                  base_cmd += ["--no-user-cfg"]
              egg_info_cmd = base_cmd + ['egg_info']
-@@ -836,7 +836,7 @@ class InstallRequirement(object):
+@@ -613,10 +614,11 @@ class InstallRequirement(object):
  
-     def get_install_args(self, global_options, record_filename, root, prefix,
-                          pycompile):
--        install_args = [sys.executable, "-u"]
-+        install_args = [os.environ.get('PIP_PYTHON_PATH', sys.executable), "-u"]
-         install_args.append('-c')
-         install_args.append(SETUPTOOLS_SHIM % self.setup_py)
-         install_args += list(global_options) + \
-@@ -888,7 +888,7 @@ class InstallRequirement(object):
+         with indent_log():
+             # FIXME: should we do --install-headers here too?
++            sys_executable = os.environ.get('PIP_PYTHON_PATH', sys.executable)
              with self.build_env:
                  call_subprocess(
                      [
 -                        sys.executable,
-+                        os.environ.get('PIP_PYTHON_PATH', sys.executable),
++                        sys_executable,
                          '-c',
                          SETUPTOOLS_SHIM % self.setup_py
                      ] +
+@@ -834,7 +836,8 @@ class InstallRequirement(object):
  
+     def get_install_args(self, global_options, record_filename, root, prefix,
+                          pycompile):
+-        install_args = [sys.executable, "-u"]
++        sys_executable = os.environ.get('PIP_PYTHON_PATH', sys.executable)
++        install_args = [sys_executable, "-u"]
+         install_args.append('-c')
+         install_args.append(SETUPTOOLS_SHIM % self.setup_py)
+         install_args += list(global_options) + \
 diff --git a/pipenv/patched/pip/_internal/req/req_set.py b/pipenv/patched/pip/_internal/req/req_set.py
-index b2b55f89..50b5e2df 100644
+index b1983171..0bab231d 100644
 --- a/pipenv/patched/pip/_internal/req/req_set.py
 +++ b/pipenv/patched/pip/_internal/req/req_set.py
-@@ -12,7 +12,7 @@ logger = logging.getLogger(__name__)
+@@ -12,13 +12,16 @@ logger = logging.getLogger(__name__)
  
  class RequirementSet(object):
  
--    def __init__(self, require_hashes=False):
-+    def __init__(self, require_hashes=False, ignore_compatibility=True):
+-    def __init__(self, require_hashes=False, check_supported_wheels=True):
++    def __init__(self, require_hashes=False, check_supported_wheels=True, ignore_compatibility=True):
          """Create a RequirementSet.
+         """
  
-         :param wheel_cache: The pip wheel cache, for passing to
-@@ -27,6 +27,7 @@ class RequirementSet(object):
-         self.unnamed_requirements = []
-         self.successfully_downloaded = []
-         self.reqs_to_cleanup = []
-+        self.ignore_compatibility = ignore_compatibility
+         self.requirements = OrderedDict()
+         self.require_hashes = require_hashes
+         self.check_supported_wheels = check_supported_wheels
++        if ignore_compatibility:
++            self.check_supported_wheels = False
++        self.ignore_compatibility = True if (check_supported_wheels is False or ignore_compatibility is True) else False
  
-     def __str__(self):
-         reqs = [req for req in self.requirements.values()
-@@ -68,7 +69,7 @@ class RequirementSet(object):
-         # environment markers.
-         if install_req.link and install_req.link.is_wheel:
-             wheel = Wheel(install_req.link.filename)
--            if not wheel.supported():
-+            if not wheel.supported() and not self.ignore_compatibility:
-                 raise InstallationError(
-                     "%s is not a supported wheel on this platform." %
-                     wheel.filename
-@@ -154,7 +155,7 @@ class RequirementSet(object):
+         # Mapping of alias: real_name
+         self.requirement_aliases = {}
+@@ -171,7 +174,7 @@ class RequirementSet(object):
                  return self.requirements[name]
              if name in self.requirement_aliases:
                  return self.requirements[self.requirement_aliases[name]]
 -        raise KeyError("No project with the name %r" % project_name)
-+        # raise KeyError("No project with the name %r" % project_name)
++        pass
  
      def cleanup_files(self):
          """Clean up files, remove builds."""
- 
 diff --git a/pipenv/patched/pip/_internal/resolve.py b/pipenv/patched/pip/_internal/resolve.py
-index 3200fca8..14e3d298 100644
+index 2d9f1c56..bedc2582 100644
 --- a/pipenv/patched/pip/_internal/resolve.py
 +++ b/pipenv/patched/pip/_internal/resolve.py
-@@ -36,7 +36,7 @@ class Resolver(object):
+@@ -35,7 +35,7 @@ class Resolver(object):
  
      def __init__(self, preparer, session, finder, wheel_cache, use_user_site,
                   ignore_dependencies, ignore_installed, ignore_requires_python,
@@ -323,7 +399,7 @@ index 3200fca8..14e3d298 100644
          super(Resolver, self).__init__()
          assert upgrade_strategy in self._allowed_strategies
  
-@@ -56,7 +56,11 @@ class Resolver(object):
+@@ -55,7 +55,11 @@ class Resolver(object):
          self.ignore_dependencies = ignore_dependencies
          self.ignore_installed = ignore_installed
          self.ignore_requires_python = ignore_requires_python
@@ -335,7 +411,7 @@ index 3200fca8..14e3d298 100644
  
          self._discovered_dependencies = defaultdict(list)
  
-@@ -238,7 +242,7 @@ class Resolver(object):
+@@ -237,7 +241,7 @@ class Resolver(object):
  
          return abstract_dist
  
@@ -344,22 +420,12 @@ index 3200fca8..14e3d298 100644
          """Prepare a single requirements file.
  
          :return: A list of additional InstallRequirements to also install.
-@@ -246,6 +250,9 @@ class Resolver(object):
-         # Tell user what we are doing for this requirement:
-         # obtain (editable), skipping, processing (local url), collecting
-         # (remote url or package name)
-+        if ignore_requires_python or self.ignore_requires_python:
-+            self.ignore_compatibility = True
-+
-         if req_to_install.constraint or req_to_install.prepared:
-             return []
- 
-@@ -261,11 +268,17 @@ class Resolver(object):
+@@ -260,11 +264,17 @@ class Resolver(object):
          try:
              check_dist_requires_python(dist)
          except UnsupportedPythonVersion as err:
 -            if self.ignore_requires_python:
-+            if self.ignore_compatibility:
++            if self.ignore_requires_python or self.ignore_compatibility:
                  logger.warning(err.args[0])
              else:
                  raise
@@ -373,14 +439,13 @@ index 3200fca8..14e3d298 100644
          more_reqs = []
  
          def add_req(subreq, extras_requested):
-@@ -291,10 +304,14 @@ class Resolver(object):
-             # We add req_to_install before its dependencies, so that we
+@@ -291,9 +301,13 @@ class Resolver(object):
              # can refer to it when adding dependencies.
              if not requirement_set.has_requirement(req_to_install.name):
+                 # 'unnamed' requirements will get added here
 +                available_requested = sorted(
 +                    set(dist.extras) & set(req_to_install.extras)
 +                )
-                 # 'unnamed' requirements will get added here
                  req_to_install.is_direct = True
                  requirement_set.add_requirement(
                      req_to_install, parent_req_name=None,
@@ -388,7 +453,7 @@ index 3200fca8..14e3d298 100644
                  )
  
              if not self.ignore_dependencies:
-@@ -318,6 +335,19 @@ class Resolver(object):
+@@ -317,6 +331,19 @@ class Resolver(object):
                  for subreq in dist.requires(available_requested):
                      add_req(subreq, extras_requested=available_requested)
  
@@ -396,7 +461,7 @@ index 3200fca8..14e3d298 100644
 +                for available in available_requested:
 +                    if hasattr(dist, '_DistInfoDistribution__dep_map'):
 +                        for req in dist._DistInfoDistribution__dep_map[available]:
-+                            req = InstallRequirement.from_req(
++                            req = install_req_from_req(
 +                                str(req),
 +                                req_to_install,
 +                                isolated=self.isolated,
@@ -408,33 +473,11 @@ index 3200fca8..14e3d298 100644
              if not req_to_install.editable and not req_to_install.satisfied_by:
                  # XXX: --no-install leads this to report 'Successfully
                  # downloaded' for only non-editable reqs, even though we took
-diff --git a/pipenv/patched/pip/_internal/utils/misc.py b/pipenv/patched/pip/_internal/utils/misc.py
-index 9d4c9b16..d0c8e437 100644
---- a/pipenv/patched/pip/_internal/utils/misc.py
-+++ b/pipenv/patched/pip/_internal/utils/misc.py
-@@ -93,7 +93,7 @@ def get_prog():
-     try:
-         prog = os.path.basename(sys.argv[0])
-         if prog in ('__main__.py', '-c'):
--            return "%s -m pip" % sys.executable
-+            return "%s -m pip" % os.environ.get('PIP_PYTHON_PATH', sys.executable)
-         else:
-             return prog
-     except (AttributeError, TypeError, IndexError):
- 
 diff --git a/pipenv/patched/pip/_internal/utils/packaging.py b/pipenv/patched/pip/_internal/utils/packaging.py
-index 5f9bb93d..83edd874 100644
+index c43142f0..f241cce0 100644
 --- a/pipenv/patched/pip/_internal/utils/packaging.py
 +++ b/pipenv/patched/pip/_internal/utils/packaging.py
-@@ -1,6 +1,7 @@
- from __future__ import absolute_import
- 
- import logging
-+import os
- import sys
- from email.parser import FeedParser  # type: ignore
- 
-@@ -28,7 +29,7 @@ def check_requires_python(requires_python):
+@@ -29,7 +29,7 @@ def check_requires_python(requires_python):
      requires_python_specifier = specifiers.SpecifierSet(requires_python)
  
      # We only use major.minor.micro
@@ -443,43 +486,24 @@ index 5f9bb93d..83edd874 100644
      return python_version in requires_python_specifier
  
  
-@@ -40,20 +41,23 @@ def get_metadata(dist):
-         return dist.get_metadata('PKG-INFO')
+@@ -48,9 +48,11 @@ def get_metadata(dist):
+     return feed_parser.close()
  
  
 -def check_dist_requires_python(dist):
 +def check_dist_requires_python(dist, absorb=True):
-     metadata = get_metadata(dist)
-     feed_parser = FeedParser()
-     feed_parser.feed(metadata)
-     pkg_info_dict = feed_parser.close()
+     pkg_info_dict = get_metadata(dist)
      requires_python = pkg_info_dict.get('Requires-Python')
-+    if not absorb:
++    if absorb:
 +        return requires_python
      try:
          if not check_requires_python(requires_python):
--            raise exceptions.UnsupportedPythonVersion(
--                "%s requires Python '%s' but the running Python is %s" % (
--                    dist.project_name,
--                    requires_python,
--                    '.'.join(map(str, sys.version_info[:3])),)
--            )
-+            # raise exceptions.UnsupportedPythonVersion(
-+            #     "%s requires Python '%s' but the running Python is %s" % (
-+            #         dist.project_name,
-+            #         requires_python,
-+            #         '.'.join(map(str, sys.version_info[:3])),)
-+            # )
-+            return
-     except specifiers.InvalidSpecifier as e:
-         logger.warning(
-             "Package %s has an invalid Requires-Python entry %s - %s",
- 
+             raise exceptions.UnsupportedPythonVersion(
 diff --git a/pipenv/patched/pip/_internal/wheel.py b/pipenv/patched/pip/_internal/wheel.py
-index c71f17d2..3e29a49d 100644
+index 5ce890eb..46c0181c 100644
 --- a/pipenv/patched/pip/_internal/wheel.py
 +++ b/pipenv/patched/pip/_internal/wheel.py
-@@ -85,7 +85,7 @@ def fix_script(path):
+@@ -83,7 +83,7 @@ def fix_script(path):
              firstline = script.readline()
              if not firstline.startswith(b'#!python'):
                  return False
@@ -488,70 +512,24 @@ index c71f17d2..3e29a49d 100644
              firstline = b'#!' + exename + os.linesep.encode("ascii")
              rest = script.read()
          with open(path, 'wb') as script:
-@@ -655,7 +655,7 @@ class WheelBuilder(object):
+@@ -167,7 +167,8 @@ def message_about_scripts_not_on_PATH(scripts):
+     ]
+     # If an executable sits with sys.executable, we don't warn for it.
+     #     This covers the case of venv invocations without activating the venv.
+-    not_warn_dirs.append(os.path.normcase(os.path.dirname(sys.executable)))
++    executable_loc = os.environ.get("PIP_PYTHON_PATH", sys.executable)
++    not_warn_dirs.append(os.path.normcase(os.path.dirname(executable_loc)))
+     warn_for = {
+         parent_dir: scripts for parent_dir, scripts in grouped_by_dir.items()
+         if os.path.normcase(parent_dir) not in not_warn_dirs
+@@ -667,8 +668,9 @@ class WheelBuilder(object):
+         # isolating. Currently, it breaks Python in virtualenvs, because it
          # relies on site.py to find parts of the standard library outside the
          # virtualenv.
++        executable_loc = os.environ.get('PIP_PYTHON_PATH', sys.executable)
          return [
 -            sys.executable, '-u', '-c',
-+            os.environ.get('PIP_PYTHON_PATH', sys.executable), '-u', '-c',
++            executable_loc, '-u', '-c',
              SETUPTOOLS_SHIM % req.setup_py
          ] + list(self.global_options)
  
-diff --git a/pipenv/patched/pip/_internal/operations/prepare.py b/pipenv/patched/pip/_internal/operations/prepare.py
-index 27e3a5dd..4d120faa 100644
---- a/pipenv/patched/pip/_internal/operations/prepare.py
-+++ b/pipenv/patched/pip/_internal/operations/prepare.py
-@@ -151,7 +151,11 @@ class IsSDist(DistAbstraction):
-         else:
-             self.req.build_env = NoOpBuildEnvironment(no_clean=False)
- 
--        self.req.run_egg_info()
-+        try:
-+            self.req.run_egg_info()
-+        except (OSError, TypeError):
-+            self.req._correct_build_location()
-+            self.req.run_egg_info()
-         self.req.assert_source_matches_version()
- 
- 
-@@ -233,15 +237,15 @@ class RequirementPreparer(object):
-             # FIXME: this won't upgrade when there's an existing
-             # package unpacked in `req.source_dir`
-             # package unpacked in `req.source_dir`
--            if os.path.exists(os.path.join(req.source_dir, 'setup.py')):
--                raise PreviousBuildDirError(
--                    "pip can't proceed with requirements '%s' due to a"
--                    " pre-existing build directory (%s). This is "
--                    "likely due to a previous installation that failed"
--                    ". pip is being responsible and not assuming it "
--                    "can delete this. Please delete it and try again."
--                    % (req, req.source_dir)
--                )
-+            # if os.path.exists(os.path.join(req.source_dir, 'setup.py')):
-+            #     raise PreviousBuildDirError(
-+            #         "pip can't proceed with requirements '%s' due to a"
-+            #         " pre-existing build directory (%s). This is "
-+            #         "likely due to a previous installation that failed"
-+            #         ". pip is being responsible and not assuming it "
-+            #         "can delete this. Please delete it and try again."
-+            #         % (req, req.source_dir)
-+            #     )
-             req.populate_link(finder, upgrade_allowed, require_hashes)
- 
-             # We can't hit this spot and have populate_link return None.
-diff --git a/pipenv/patched/pip/_internal/pep425tags.py b/pipenv/patched/pip/_internal/pep425tags.py
-index c2290ab9..bea31585 100644
---- a/pipenv/patched/pip/_internal/pep425tags.py
-+++ b/pipenv/patched/pip/_internal/pep425tags.py
-@@ -10,7 +10,10 @@ import sysconfig
- import warnings
- from collections import OrderedDict
- 
--import pip._internal.utils.glibc
-+try:
-+    import pip._internal.utils.glibc
-+except ImportError:
-+    import pip.utils.glibc
- 
- logger = logging.getLogger(__name__)
- 
diff --git a/tasks/vendoring/patches/patched/piptools.patch b/tasks/vendoring/patches/patched/piptools.patch
index 6dff468a..3799ccf4 100644
--- a/tasks/vendoring/patches/patched/piptools.patch
+++ b/tasks/vendoring/patches/patched/piptools.patch
@@ -1,28 +1,131 @@
-diff --git a/pipenv/patched/piptools/locations.py b/pipenv/patched/piptools/locations.py
-index 4e6174c..75f9b49 100644
---- a/pipenv/patched/piptools/locations.py
-+++ b/pipenv/patched/piptools/locations.py
-@@ -2,10 +2,13 @@ import os
- from shutil import rmtree
-
- from .click import secho
--from ._compat import user_cache_dir
-+# Patch by vphilippon 2017-11-22: Use pipenv cache path.
-+# from ._compat import user_cache_dir
-+from pipenv.environments import PIPENV_CACHE_DIR
-
- # The user_cache_dir helper comes straight from pip itself
--CACHE_DIR = user_cache_dir('pip-tools')
-+# CACHE_DIR = user_cache_dir(os.path.join('pip-tools'))
-+CACHE_DIR = PIPENV_CACHE_DIR
-
- # NOTE
- # We used to store the cache dir under ~/.pip-tools, which is not the
+diff --git a/pipenv/patched/piptools/_compat/__init__.py b/pipenv/patched/piptools/_compat/__init__.py
+index 1fa3805..c0ecec8 100644
+--- a/pipenv/patched/piptools/_compat/__init__.py
++++ b/pipenv/patched/piptools/_compat/__init__.py
+@@ -27,6 +27,8 @@ from .pip_compat import (
+     cmdoptions,
+     get_installed_distributions,
+     PyPI,
++    SafeFileCache,
++    InstallationError,
+     install_req_from_line,
+     install_req_from_editable,
+ )
+diff --git a/pipenv/patched/piptools/_compat/pip_compat.py b/pipenv/patched/piptools/_compat/pip_compat.py
+index 28da51f..c466ef0 100644
+--- a/pipenv/patched/piptools/_compat/pip_compat.py
++++ b/pipenv/patched/piptools/_compat/pip_compat.py
+@@ -1,45 +1,55 @@
+ # -*- coding=utf-8 -*-
+-import importlib
+ 
+-import pip
+-import pkg_resources
++__all__ = [
++    "InstallRequirement",
++    "parse_requirements",
++    "RequirementSet",
++    "user_cache_dir",
++    "FAVORITE_HASH",
++    "is_file_url",
++    "url_to_path",
++    "PackageFinder",
++    "FormatControl",
++    "Wheel",
++    "Command",
++    "cmdoptions",
++    "get_installed_distributions",
++    "PyPI",
++    "SafeFileCache",
++    "InstallationError",
++    "parse_version",
++    "pip_version",
++    "install_req_from_editable",
++    "install_req_from_line",
++    "user_cache_dir"
++]
+ 
+-def do_import(module_path, subimport=None, old_path=None):
+-    old_path = old_path or module_path
+-    prefixes = ["pip._internal", "pip"]
+-    paths = [module_path, old_path]
+-    search_order = ["{0}.{1}".format(p, pth) for p in prefixes for pth in paths if pth is not None]
+-    package = subimport if subimport else None
+-    for to_import in search_order:
+-        if not subimport:
+-            to_import, _, package = to_import.rpartition(".")
+-        try:
+-            imported = importlib.import_module(to_import)
+-        except ImportError:
+-            continue
+-        else:
+-            return getattr(imported, package)
+-
+-
+-InstallRequirement = do_import('req.req_install', 'InstallRequirement')
+-parse_requirements = do_import('req.req_file', 'parse_requirements')
+-RequirementSet = do_import('req.req_set', 'RequirementSet')
+-user_cache_dir = do_import('utils.appdirs', 'user_cache_dir')
+-FAVORITE_HASH = do_import('utils.hashes', 'FAVORITE_HASH')
+-is_file_url = do_import('download', 'is_file_url')
+-url_to_path = do_import('download', 'url_to_path')
+-PackageFinder = do_import('index', 'PackageFinder')
+-FormatControl = do_import('index', 'FormatControl')
+-Wheel = do_import('wheel', 'Wheel')
+-Command = do_import('cli.base_command', 'Command', old_path='basecommand')
+-cmdoptions = do_import('cli.cmdoptions', old_path='cmdoptions')
+-get_installed_distributions = do_import('utils.misc', 'get_installed_distributions', old_path='utils')
+-PyPI = do_import('models.index', 'PyPI')
++from pipenv.vendor.appdirs import user_cache_dir
++from pip_shims.shims import (
++    InstallRequirement,
++    parse_requirements,
++    RequirementSet,
++    FAVORITE_HASH,
++    is_file_url,
++    url_to_path,
++    PackageFinder,
++    FormatControl,
++    Wheel,
++    Command,
++    cmdoptions,
++    get_installed_distributions,
++    PyPI,
++    SafeFileCache,
++    InstallationError,
++    parse_version,
++    pip_version,
++)
+ 
+ # pip 18.1 has refactored InstallRequirement constructors use by pip-tools.
+-if pkg_resources.parse_version(pip.__version__) < pkg_resources.parse_version('18.1'):
++if parse_version(pip_version) < parse_version('18.1'):
+     install_req_from_line = InstallRequirement.from_line
+     install_req_from_editable = InstallRequirement.from_editable
+ else:
+-    install_req_from_line = do_import('req.constructors', 'install_req_from_line')
+-    install_req_from_editable = do_import('req.constructors', 'install_req_from_editable')
++    from pip_shims.shims import (
++        install_req_from_editable, install_req_from_line
++    )
+diff --git a/pipenv/patched/piptools/repositories/local.py b/pipenv/patched/piptools/repositories/local.py
+index 08dabe1..480ad1e 100644
+--- a/pipenv/patched/piptools/repositories/local.py
++++ b/pipenv/patched/piptools/repositories/local.py
+@@ -56,7 +56,7 @@ class LocalRequirementsRepository(BaseRepository):
+         if existing_pin and ireq_satisfied_by_existing_pin(ireq, existing_pin):
+             project, version, _ = as_tuple(existing_pin)
+             return make_install_requirement(
+-                project, version, ireq.extras, constraint=ireq.constraint
++                project, version, ireq.extras, constraint=ireq.constraint, markers=ireq.markers
+             )
+         else:
+             return self.repository.find_best_match(ireq, prereleases)
 diff --git a/pipenv/patched/piptools/repositories/pypi.py b/pipenv/patched/piptools/repositories/pypi.py
-index 1c4b943..84077f0 100644
+index bf69803..31b85b9 100644
 --- a/pipenv/patched/piptools/repositories/pypi.py
 +++ b/pipenv/patched/piptools/repositories/pypi.py
-@@ -1,9 +1,10 @@
+@@ -1,7 +1,7 @@
  # coding: utf-8
  from __future__ import (absolute_import, division, print_function,
                          unicode_literals)
@@ -30,40 +133,43 @@ index 1c4b943..84077f0 100644
 +import copy
  import hashlib
  import os
-+import sys
  from contextlib import contextmanager
- from shutil import rmtree
- 
-@@ -15,13 +16,22 @@ from .._compat import (
+@@ -15,13 +15,22 @@ from .._compat import (
      Wheel,
      FAVORITE_HASH,
      TemporaryDirectory,
 -    PyPI
 +    PyPI,
 +    InstallRequirement,
-+    SafeFileCache,
++    SafeFileCache
  )
++os.environ["PIP_SHIMS_BASE_MODULE"] = str("pip")
++from pip_shims.shims import do_import, VcsSupport, WheelCache
++from packaging.requirements import Requirement
++from packaging.specifiers import SpecifierSet, Specifier
++InstallationError = do_import(("exceptions.InstallationError", "7.0", "9999"))
++from pip._internal.resolve import Resolver as PipResolver
++
  
 -from ..cache import CACHE_DIR
-+from pip._vendor.packaging.requirements import Requirement
-+from pip._vendor.packaging.specifiers import SpecifierSet, Specifier
-+from pip._vendor.packaging.markers import Op, Value, Variable
-+from pip._internal.exceptions import InstallationError
-+from pip._internal.vcs import VcsSupport
-+
-+from pipenv.environments import PIPENV_CACHE_DIR
++from pipenv.environments import PIPENV_CACHE_DIR as CACHE_DIR
  from ..exceptions import NoCandidateFound
- from ..utils import (fs_str, is_pinned_requirement, lookup_table,
+-from ..utils import (fs_str, is_pinned_requirement, lookup_table,
 -                     make_install_requirement)
-+                     make_install_requirement, clean_requires_python)
-+
++from ..utils import (fs_str, is_pinned_requirement, lookup_table, dedup,
++                        make_install_requirement, clean_requires_python)
  from .base import BaseRepository
  
+ try:
+@@ -31,10 +40,44 @@ except ImportError:
+     def RequirementTracker():
+         yield
  
-@@ -37,6 +47,45 @@ except ImportError:
-     from pip.wheel import WheelCache
- 
- 
+-try:
+-    from pip._internal.cache import WheelCache
+-except ImportError:
+-    from pip.wheel import WheelCache
++
 +class HashCache(SafeFileCache):
 +    """Caches hashes of PyPI artifacts so we do not need to re-download them
 +
@@ -73,7 +179,7 @@ index 1c4b943..84077f0 100644
 +    def __init__(self, *args, **kwargs):
 +        session = kwargs.pop('session')
 +        self.session = session
-+        kwargs.setdefault('directory', os.path.join(PIPENV_CACHE_DIR, 'hash-cache'))
++        kwargs.setdefault('directory', os.path.join(CACHE_DIR, 'hash-cache'))
 +        super(HashCache, self).__init__(*args, **kwargs)
 +
 +    def get_hash(self, location):
@@ -90,10 +196,10 @@ index 1c4b943..84077f0 100644
 +            hash_value = self.get(new_location.url)
 +        if not hash_value:
 +            hash_value = self._get_file_hash(new_location) if not new_location.url.startswith("ssh") else None
-+            hash_value = hash_value.encode('utf8')
++            hash_value = hash_value.encode('utf8') if hash_value else None
 +        if can_hash:
 +            self.set(new_location.url, hash_value)
-+        return hash_value.decode('utf8')
++        return hash_value.decode('utf8') if hash_value else None
 +
 +    def _get_file_hash(self, location):
 +        h = hashlib.new(FAVORITE_HASH)
@@ -101,12 +207,10 @@ index 1c4b943..84077f0 100644
 +            for chunk in iter(lambda: fp.read(8096), b""):
 +                h.update(chunk)
 +        return ":".join([FAVORITE_HASH, h.hexdigest()])
-+
-+
- class PyPIRepository(BaseRepository):
-     DEFAULT_INDEX_URL = PyPI.simple_url
  
-@@ -46,10 +95,11 @@ class PyPIRepository(BaseRepository):
+ 
+ class PyPIRepository(BaseRepository):
+@@ -46,8 +89,9 @@ class PyPIRepository(BaseRepository):
      config), but any other PyPI mirror can be used if index_urls is
      changed/configured on the Finder.
      """
@@ -115,12 +219,9 @@ index 1c4b943..84077f0 100644
          self.session = session
 +        self.use_json = use_json
          self.pip_options = pip_options
--        self.wheel_cache = WheelCache(CACHE_DIR, pip_options.format_control)
-+        self.wheel_cache = WheelCache(PIPENV_CACHE_DIR, pip_options.format_control)
  
          index_urls = [pip_options.index_url] + pip_options.extra_index_urls
-         if pip_options.no_index:
-@@ -74,11 +124,15 @@ class PyPIRepository(BaseRepository):
+@@ -73,6 +117,10 @@ class PyPIRepository(BaseRepository):
          # of all secondary dependencies for the given requirement, so we
          # only have to go to disk once for each requirement
          self._dependencies_cache = {}
@@ -131,20 +232,12 @@ index 1c4b943..84077f0 100644
  
          # Setup file paths
          self.freshen_build_caches()
--        self._download_dir = fs_str(os.path.join(CACHE_DIR, 'pkgs'))
--        self._wheel_download_dir = fs_str(os.path.join(CACHE_DIR, 'wheels'))
-+        self._download_dir = fs_str(os.path.join(PIPENV_CACHE_DIR, 'pkgs'))
-+        self._wheel_download_dir = fs_str(os.path.join(PIPENV_CACHE_DIR, 'wheels'))
- 
-     def freshen_build_caches(self):
-         """
-@@ -114,10 +168,14 @@ class PyPIRepository(BaseRepository):
+@@ -113,10 +161,13 @@ class PyPIRepository(BaseRepository):
          if ireq.editable:
              return ireq  # return itself as the best match
  
 -        all_candidates = self.find_all_candidates(ireq.name)
 +        all_candidates = clean_requires_python(self.find_all_candidates(ireq.name))
-+
          candidates_by_version = lookup_table(all_candidates, key=lambda c: c.version, unique=True)
 -        matching_versions = ireq.specifier.filter((candidate.version for candidate in all_candidates),
 +        try:
@@ -155,21 +248,15 @@ index 1c4b943..84077f0 100644
  
          # Reuses pip's internal candidate sort key to sort
          matching_candidates = [candidates_by_version[ver] for ver in matching_versions]
-@@ -126,11 +184,71 @@ class PyPIRepository(BaseRepository):
-         best_candidate = max(matching_candidates, key=self.finder._candidate_sort_key)
+@@ -126,25 +177,87 @@ class PyPIRepository(BaseRepository):
  
          # Turn the candidate into a pinned InstallRequirement
--        return make_install_requirement(
+         return make_install_requirement(
 -            best_candidate.project, best_candidate.version, ireq.extras, constraint=ireq.constraint
 -        )
-+        new_req = make_install_requirement(
-+            best_candidate.project, best_candidate.version, ireq.extras, ireq.markers, constraint=ireq.constraint
++            best_candidate.project, best_candidate.version, ireq.extras, ireq.markers,  constraint=ireq.constraint
 +         )
 +
-+        # KR TODO: Marker here?
-+
-+        return new_req
-+
 +    def get_json_dependencies(self, ireq):
 +
 +        if not (is_pinned_requirement(ireq)):
@@ -207,12 +294,13 @@ index 1c4b943..84077f0 100644
 +        try:
 +            if ireq not in self._json_dep_cache:
 +                self._json_dep_cache[ireq] = [g for g in gen(ireq)]
-+
+ 
+-    def resolve_reqs(self, download_dir, ireq, wheel_cache):
 +            return set(self._json_dep_cache[ireq])
 +        except Exception:
 +            return set()
- 
-     def get_dependencies(self, ireq):
++
++    def get_dependencies(self, ireq):
 +        json_results = set()
 +
 +        if self.use_json:
@@ -226,100 +314,105 @@ index 1c4b943..84077f0 100644
 +
 +        return json_results
 +
-+    def get_legacy_dependencies(self, ireq):
-         """
-         Given a pinned or an editable InstallRequirement, returns a set of
-         dependencies (also InstallRequirements, but not necessarily pinned).
-@@ -155,20 +273,46 @@ class PyPIRepository(BaseRepository):
-                     os.makedirs(download_dir)
-             if not os.path.isdir(self._wheel_download_dir):
-                 os.makedirs(self._wheel_download_dir)
--
++    def resolve_reqs(self, download_dir, ireq, wheel_cache, setup_requires={}, dist=None):
+         results = None
++        setup_requires = {}
++        dist = None
++        ireq.isolated = False
++        ireq._wheel_cache = wheel_cache
++
+         try:
+             from pip._internal.operations.prepare import RequirementPreparer
+-            from pip._internal.resolve import Resolver as PipResolver
+         except ImportError:
+-            # Pip 9 and below
++                # Pip 9 and below
+             reqset = RequirementSet(
+                 self.build_dir,
+                 self.source_dir,
+                 download_dir=download_dir,
+                 wheel_download_dir=self._wheel_download_dir,
+                 session=self.session,
++                ignore_installed=True,
++                ignore_compatibility=False,
+                 wheel_cache=wheel_cache
+             )
+-            results = reqset._prepare_file(self.finder, ireq)
++            results = reqset._prepare_file(self.finder, ireq, ignore_requires_python=True)
+         else:
+             # pip >= 10
+             preparer_kwargs = {
+@@ -159,13 +272,14 @@ class PyPIRepository(BaseRepository):
+                 'finder': self.finder,
+                 'session': self.session,
+                 'upgrade_strategy': "to-satisfy-only",
+-                'force_reinstall': False,
++                'force_reinstall': True,
+                 'ignore_dependencies': False,
+-                'ignore_requires_python': False,
++                'ignore_requires_python': True,
+                 'ignore_installed': True,
+                 'isolated': False,
+                 'wheel_cache': wheel_cache,
+-                'use_user_site': False
++                'use_user_site': False,
++                'ignore_compatibility': False
+             }
+             resolver = None
+             preparer = None
+@@ -177,15 +291,109 @@ class PyPIRepository(BaseRepository):
+                 resolver_kwargs['preparer'] = preparer
+                 reqset = RequirementSet()
+                 ireq.is_direct = True
+-                reqset.add_requirement(ireq)
++                # reqset.add_requirement(ireq)
+                 resolver = PipResolver(**resolver_kwargs)
+                 resolver.require_hashes = False
+                 results = resolver._resolve_one(reqset, ireq)
+-                reqset.cleanup_files()
+ 
+-        return set(results)
++        cleanup_fn = getattr(reqset, "cleanup_files", None)
++        if cleanup_fn is not None:
++            try:
++                cleanup_fn()
++            except OSError:
++                pass
++
++        if ireq.editable and (not ireq.source_dir or not os.path.exists(ireq.source_dir)):
++            if ireq.editable:
++                self._source_dir = TemporaryDirectory(fs_str("source"))
++                ireq.ensure_has_source_dir(self.source_dir)
++
++        if ireq.editable and (ireq.source_dir and os.path.exists(ireq.source_dir)):
 +            # Collect setup_requires info from local eggs.
 +            # Do this after we call the preparer on these reqs to make sure their
 +            # egg info has been created
-+            setup_requires = {}
-+            dist = None
-+            if ireq.editable:
++            from pipenv.utils import chdir
++            with chdir(ireq.setup_py_dir):
 +                try:
-+                    from pipenv.utils import chdir
-+                    with chdir(ireq.setup_py_dir):
-+                        from setuptools.dist import distutils
-+                        dist = distutils.core.run_setup(ireq.setup_py)
-+                except (ImportError, InstallationError, TypeError, AttributeError):
-+                    pass
-+                try:
-+                    dist = ireq.get_dist() if not dist else dist
++                    from setuptools.dist import distutils
++                    dist = distutils.core.run_setup(ireq.setup_py)
 +                except InstallationError:
 +                    ireq.run_egg_info()
-+                    dist = ireq.get_dist()
 +                except (TypeError, ValueError, AttributeError):
 +                    pass
-+                else:
-+                    setup_requires = getattr(dist, "extras_require", None)
-+                    if not setup_requires:
-+                        setup_requires = {"setup_requires": getattr(dist, "setup_requires", None)}
-             try:
--                # Pip < 9 and below
-+                # Pip 9 and below
-                 reqset = RequirementSet(
-                     self.build_dir,
-                     self.source_dir,
-                     download_dir=download_dir,
-                     wheel_download_dir=self._wheel_download_dir,
-                     session=self.session,
-+                    ignore_installed=True,
-+                    ignore_compatibility=False,
-                     wheel_cache=self.wheel_cache,
-                 )
--                self._dependencies_cache[ireq] = reqset._prepare_file(
-+                result = reqset._prepare_file(
-                     self.finder,
--                    ireq
-+                    ireq,
-+                    ignore_requires_python=True
-                 )
-             except TypeError:
-                 # Pip >= 10 (new resolver!)
-@@ -188,17 +332,97 @@ class PyPIRepository(BaseRepository):
-                     finder=self.finder,
-                     session=self.session,
-                     upgrade_strategy="to-satisfy-only",
--                    force_reinstall=False,
-+                    force_reinstall=True,
-                     ignore_dependencies=False,
--                    ignore_requires_python=False,
-+                    ignore_requires_python=True,
-                     ignore_installed=True,
-                     isolated=False,
-                     wheel_cache=self.wheel_cache,
-                     use_user_site=False,
-+                    ignore_compatibility=False
-                 )
-                 self.resolver.resolve(reqset)
--                self._dependencies_cache[ireq] = reqset.requirements.values()
-+                result = set(reqset.requirements.values())
-+
-+            # HACK: Sometimes the InstallRequirement doesn't properly get
-+            # these values set on it during the resolution process. It's
-+            # difficult to pin down what is going wrong. This fixes things.
-+            if not getattr(ireq, 'version', None):
-+                try:
-+                    dist = ireq.get_dist() if not dist else None
-+                    ireq.version = ireq.get_dist().version
-+                except (ValueError, OSError, TypeError, AttributeError) as e:
-+                    pass
-+            if not getattr(ireq, 'project_name', None):
-+                try:
-+                    ireq.project_name = dist.project_name if dist else None
-+                except (ValueError, TypeError) as e:
-+                    pass
++                if not dist:
++                    try:
++                        dist = ireq.get_dist()
++                    except (ImportError, ValueError, TypeError, AttributeError):
++                        pass
++        if ireq.editable and dist:
++            setup_requires = getattr(dist, "extras_require", None)
++            if not setup_requires:
++                setup_requires = {"setup_requires": getattr(dist, "setup_requires", None)}
 +            if not getattr(ireq, 'req', None):
 +                try:
 +                    ireq.req = dist.as_requirement() if dist else None
 +                except (ValueError, TypeError) as e:
 +                    pass
-+
+ 
+-    def get_dependencies(self, ireq):
 +            # Convert setup_requires dict into a somewhat usable form.
 +            if setup_requires:
 +                for section in setup_requires:
@@ -341,14 +434,14 @@ index 1c4b943..84077f0 100644
 +                        if ':' not in value:
 +                            try:
 +                                if not not_python:
-+                                    result = result + [InstallRequirement.from_line("{0}{1}".format(value, python_version).replace(':', ';'))]
++                                    results.add(InstallRequirement.from_line("{0}{1}".format(value, python_version).replace(':', ';')))
 +                            # Anything could go wrong here -- can't be too careful.
 +                            except Exception:
 +                                pass
 +
 +            # this section properly creates 'python_version' markers for cross-python
 +            # virtualenv creation and for multi-python compatibility.
-+            requires_python = reqset.requires_python if hasattr(reqset, 'requires_python') else self.resolver.requires_python
++            requires_python = reqset.requires_python if hasattr(reqset, 'requires_python') else resolver.requires_python
 +            if requires_python:
 +                marker_str = ''
 +                # This corrects a logic error from the previous code which said that if
@@ -358,31 +451,48 @@ index 1c4b943..84077f0 100644
 +                if any(requires_python.startswith(op) for op in Specifier._operators.keys()):
 +                    # We are checking first if we have  leading specifier operator
 +                    # if not, we can assume we should be doing a == comparison
-+                    specifierset = list(SpecifierSet(requires_python))
++                    specifierset = SpecifierSet(requires_python)
 +                    # for multiple specifiers, the correct way to represent that in
 +                    # a specifierset is `Requirement('fakepkg; python_version<"3.0,>=2.6"')`
-+                    marker_key = Variable('python_version')
-+                    markers = []
-+                    for spec in specifierset:
-+                        operator, val = spec._spec
-+                        operator = Op(operator)
-+                        val = Value(val)
-+                        markers.append(''.join([marker_key.serialize(), operator.serialize(), val.serialize()]))
-+                    marker_str = ' and '.join(markers)
++                    from passa.internals.specifiers import cleanup_pyspecs
++                    marker_str = str(Marker(" and ".join(dedup([
++                        "python_version {0[0]} '{0[1]}'".format(spec)
++                        for spec in cleanup_pyspecs(specifierset)
++                    ]))))
 +                # The best way to add markers to a requirement is to make a separate requirement
 +                # with only markers on it, and then to transfer the object istelf
 +                marker_to_add = Requirement('fakepkg; {0}'.format(marker_str)).marker
-+                result.remove(ireq)
++                if ireq in results:
++                    results.remove(ireq)
++                print(marker_to_add)
 +                ireq.req.marker = marker_to_add
-+                result.add(ireq)
 +
-+            self._dependencies_cache[ireq] = result
-             reqset.cleanup_files()
++        results = set(results) if results else set()
++        return results, ireq
 +
-         return set(self._dependencies_cache[ireq])
- 
-     def get_hashes(self, ireq):
-@@ -210,6 +434,10 @@ class PyPIRepository(BaseRepository):
++    def get_legacy_dependencies(self, ireq):
+         """
+         Given a pinned or an editable InstallRequirement, returns a set of
+         dependencies (also InstallRequirements, but not necessarily pinned).
+@@ -200,6 +408,7 @@ class PyPIRepository(BaseRepository):
+                 # If a download_dir is passed, pip will  unnecessarely
+                 # archive the entire source directory
+                 download_dir = None
++
+             elif ireq.link and not ireq.link.is_artifact:
+                 # No download_dir for VCS sources.  This also works around pip
+                 # using git-checkout-index, which gets rid of the .git dir.
+@@ -214,7 +423,8 @@ class PyPIRepository(BaseRepository):
+             wheel_cache = WheelCache(CACHE_DIR, self.pip_options.format_control)
+             prev_tracker = os.environ.get('PIP_REQ_TRACKER')
+             try:
+-                self._dependencies_cache[ireq] = self.resolve_reqs(download_dir, ireq, wheel_cache)
++                results, ireq = self.resolve_reqs(download_dir, ireq, wheel_cache)
++                self._dependencies_cache[ireq] = results
+             finally:
+                 if 'PIP_REQ_TRACKER' in os.environ:
+                     if prev_tracker:
+@@ -236,6 +446,10 @@ class PyPIRepository(BaseRepository):
          if ireq.editable:
              return set()
  
@@ -393,7 +503,7 @@ index 1c4b943..84077f0 100644
          if not is_pinned_requirement(ireq):
              raise TypeError(
                  "Expected pinned requirement, got {}".format(ireq))
-@@ -217,24 +445,22 @@ class PyPIRepository(BaseRepository):
+@@ -243,24 +457,22 @@ class PyPIRepository(BaseRepository):
          # We need to get all of the candidates that match our current version
          # pin, these will represent all of the files that could possibly
          # satisfy this constraint.
@@ -415,8 +525,9 @@ index 1c4b943..84077f0 100644
  
          return {
 -            self._get_file_hash(candidate.location)
-+            self._hash_cache.get_hash(candidate.location)
-             for candidate in matching_candidates
+-            for candidate in matching_candidates
++            h for h in map(lambda c: self._hash_cache.get_hash(c.location),
++                                matching_candidates) if h is not None
          }
  
 -    def _get_file_hash(self, location):
@@ -430,43 +541,27 @@ index 1c4b943..84077f0 100644
      def allow_all_wheels(self):
          """
 diff --git a/pipenv/patched/piptools/resolver.py b/pipenv/patched/piptools/resolver.py
-index 05ec8fd..2f94f6b 100644
+index c2d323c..d5a471d 100644
 --- a/pipenv/patched/piptools/resolver.py
 +++ b/pipenv/patched/piptools/resolver.py
-@@ -8,13 +8,14 @@ from itertools import chain, count
- import os
-
- from first import first
-+from pip._vendor.packaging.markers import default_environment
- from ._compat import InstallRequirement
-
- from . import click
+@@ -13,7 +13,7 @@ from . import click
  from .cache import DependencyCache
  from .exceptions import UnsupportedConstraint
  from .logging import log
 -from .utils import (format_requirement, format_specifier, full_groupby,
 +from .utils import (format_requirement, format_specifier, full_groupby, dedup, simplify_markers,
                      is_pinned_requirement, key_from_ireq, key_from_req, UNSAFE_PACKAGES)
-
+ 
  green = partial(click.style, fg='green')
-@@ -28,6 +29,7 @@ class RequirementSummary(object):
+@@ -27,6 +27,7 @@ class RequirementSummary(object):
      def __init__(self, ireq):
          self.req = ireq.req
          self.key = key_from_req(ireq.req)
 +        self.markers = ireq.markers
          self.extras = str(sorted(ireq.extras))
          self.specifier = str(ireq.specifier)
-
-@@ -71,7 +73,7 @@ class Resolver(object):
-         with self.repository.allow_all_wheels():
-             return {ireq: self.repository.get_hashes(ireq) for ireq in ireqs}
-
--    def resolve(self, max_rounds=10):
-+    def resolve(self, max_rounds=12):
-         """
-         Finds concrete package versions for all the given InstallRequirements
-         and their recursive dependencies.  The end result is a flat list of
-@@ -120,7 +122,7 @@ class Resolver(object):
+ 
+@@ -119,7 +120,7 @@ class Resolver(object):
      @staticmethod
      def check_constraints(constraints):
          for constraint in constraints:
@@ -475,23 +570,9 @@ index 05ec8fd..2f94f6b 100644
                  msg = ('pip-compile does not support URLs as packages, unless they are editable. '
                         'Perhaps add -e option?')
                  raise UnsupportedConstraint(msg, constraint)
-@@ -147,15 +149,23 @@ class Resolver(object):
-             if editable_ireq:
-                 yield editable_ireq  # ignore all the other specs: the editable one is the one that counts
-                 continue
--
-             ireqs = iter(ireqs)
-             # deepcopy the accumulator so as to not modify the self.our_constraints invariant
-             combined_ireq = copy.deepcopy(next(ireqs))
--            combined_ireq.comes_from = None
-             for ireq in ireqs:
+@@ -155,6 +156,13 @@ class Resolver(object):
                  # NOTE we may be losing some info on dropped reqs here
--                combined_ireq.req.specifier &= ireq.req.specifier
-+                try:
-+                    combined_ireq.req.specifier &= ireq.req.specifier
-+                except TypeError:
-+                    if ireq.req.specifier._specs and not combined_ireq.req.specifier._specs:
-+                        combined_ireq.req.specifier._specs = ireq.req.specifier._specs
+                 combined_ireq.req.specifier &= ireq.req.specifier
                  combined_ireq.constraint &= ireq.constraint
 +                if not combined_ireq.markers:
 +                    combined_ireq.markers = ireq.markers
@@ -499,80 +580,59 @@ index 05ec8fd..2f94f6b 100644
 +                    _markers = combined_ireq.markers._markers
 +                    if not isinstance(_markers[0], (tuple, list)):
 +                        combined_ireq.markers._markers = [_markers, 'and', ireq.markers._markers]
++
                  # Return a sorted, de-duped tuple of extras
                  combined_ireq.extras = tuple(sorted(set(tuple(combined_ireq.extras) + tuple(ireq.extras))))
              yield combined_ireq
-@@ -273,6 +283,14 @@ class Resolver(object):
+@@ -272,6 +280,15 @@ class Resolver(object):
              for dependency in self.repository.get_dependencies(ireq):
                  yield dependency
              return
 +
 +        # fix our malformed extras
 +        if ireq.extras:
-+            if hasattr(ireq, 'extra'):
++            if getattr(ireq, "extra", None):
 +                if ireq.extras:
 +                    ireq.extras.extend(ireq.extra)
 +                else:
 +                    ireq.extras = ireq.extra
++
          elif not is_pinned_requirement(ireq):
              raise TypeError('Expected pinned or editable requirement, got {}'.format(ireq))
-
-@@ -283,14 +301,14 @@ class Resolver(object):
+ 
+@@ -282,7 +299,7 @@ class Resolver(object):
          if ireq not in self.dependency_cache:
              log.debug('  {} not in cache, need to check index'.format(format_requirement(ireq)), fg='yellow')
              dependencies = self.repository.get_dependencies(ireq)
 -            self.dependency_cache[ireq] = sorted(str(ireq.req) for ireq in dependencies)
-+            self.dependency_cache[ireq] = sorted(format_requirement(_ireq) for _ireq in dependencies)
-
++            self.dependency_cache[ireq] = sorted(set(format_requirement(ireq) for ireq in dependencies))
+ 
          # Example: ['Werkzeug>=0.9', 'Jinja2>=2.4']
          dependency_strings = self.dependency_cache[ireq]
-         log.debug('  {:25} requires {}'.format(format_requirement(ireq),
-                                                ', '.join(sorted(dependency_strings, key=lambda s: s.lower())) or '-'))
-         for dependency_string in dependency_strings:
--            yield InstallRequirement.from_line(dependency_string, constraint=ireq.constraint)
-+                yield InstallRequirement.from_line(dependency_string, constraint=ireq.constraint)
-
-     def reverse_dependencies(self, ireqs):
-         non_editable = [ireq for ireq in ireqs if not ireq.editable]
-diff --git a/pipenv/patched/piptools/repositories/local.py b/pipenv/patched/piptools/repositories/local.py
-index 08dabe1..480ad1e 100644
---- a/pipenv/patched/piptools/repositories/local.py
-+++ b/pipenv/patched/piptools/repositories/local.py
-@@ -56,7 +56,7 @@ class LocalRequirementsRepository(BaseRepository):
-         if existing_pin and ireq_satisfied_by_existing_pin(ireq, existing_pin):
-             project, version, _ = as_tuple(existing_pin)
-             return make_install_requirement(
--                project, version, ireq.extras, constraint=ireq.constraint
-+                project, version, ireq.extras, constraint=ireq.constraint, markers=ireq.markers
-             )
-         else:
-             return self.repository.find_best_match(ireq, prereleases)
 diff --git a/pipenv/patched/piptools/utils.py b/pipenv/patched/piptools/utils.py
-index fde5816..23a05f2 100644
+index 2360a04..6f62eb9 100644
 --- a/pipenv/patched/piptools/utils.py
 +++ b/pipenv/patched/piptools/utils.py
-@@ -2,6 +2,7 @@
- from __future__ import (absolute_import, division, print_function,
-                         unicode_literals)
-
-+import six
+@@ -4,6 +4,7 @@ from __future__ import (absolute_import, division, print_function,
+ 
  import os
  import sys
++import six
  from itertools import chain, groupby
-@@ -11,13 +12,79 @@ from contextlib import contextmanager
- from ._compat import InstallRequirement
-
- from first import first
--
-+from pip._vendor.packaging.specifiers import SpecifierSet, InvalidSpecifier
-+from pip._vendor.packaging.version import Version, InvalidVersion, parse as parse_version
-+from pip._vendor.packaging.markers import Marker, Op, Value, Variable
+ from collections import OrderedDict
+ from contextlib import contextmanager
+@@ -11,11 +12,78 @@ from contextlib import contextmanager
+ from ._compat import install_req_from_line
+ 
  from .click import style
-
-
++from pipenv.patched.notpip._vendor.packaging.specifiers import SpecifierSet, InvalidSpecifier
++from pipenv.patched.notpip._vendor.packaging.version import Version, InvalidVersion, parse as parse_version
++from pipenv.patched.notpip._vendor.packaging.markers import Marker, Op, Value, Variable
+ 
+ 
  UNSAFE_PACKAGES = {'setuptools', 'distribute', 'pip'}
-
-
+ 
+ 
 +def simplify_markers(ireq):
 +    """simplify_markers "This code cleans up markers for a specific :class:`~InstallRequirement`"
 +
@@ -610,7 +670,7 @@ index fde5816..23a05f2 100644
 +    marker_str = ' and '.join(list(dedup(tuple(marker_list,)))) if marker_list else ''
 +    new_markers = Marker(marker_str)
 +    ireq.markers = new_markers
-+    new_ireq = InstallRequirement.from_line(format_requirement(ireq))
++    new_ireq = install_req_from_line(format_requirement(ireq))
 +    if ireq.constraint:
 +        new_ireq.constraint = ireq.constraint
 +    return new_ireq
@@ -640,10 +700,10 @@ index fde5816..23a05f2 100644
  def key_from_ireq(ireq):
      """Get a standardized key for an InstallRequirement."""
      if ireq.req is None and ireq.link is not None:
-@@ -43,16 +110,51 @@ def comment(text):
+@@ -41,30 +109,61 @@ def comment(text):
      return style(text, fg='green')
-
-
+ 
+ 
 -def make_install_requirement(name, version, extras, constraint=False):
 +def make_install_requirement(name, version, extras, markers, constraint=False):
      # If no extras are specified, the extras string is blank
@@ -651,22 +711,25 @@ index fde5816..23a05f2 100644
      if extras:
          # Sort extras for stability
          extras_string = "[{}]".format(",".join(sorted(extras)))
-
--    return InstallRequirement.from_line(
+ 
+-    return install_req_from_line(
 -        str('{}{}=={}'.format(name, extras_string, version)),
 -        constraint=constraint)
 +    if not markers:
-+        return InstallRequirement.from_line(
++        return install_req_from_line(
 +            str('{}{}=={}'.format(name, extras_string, version)),
 +            constraint=constraint)
 +    else:
-+        return InstallRequirement.from_line(
++        return install_req_from_line(
 +            str('{}{}=={}; {}'.format(name, extras_string, version, str(markers))),
 +            constraint=constraint)
-+
-+
+ 
+ 
+-def format_requirement(ireq, marker=None):
 +def _requirement_to_str_lowercase_name(requirement):
-+    """
+     """
+-    Generic formatter for pretty printing InstallRequirements to the terminal
+-    in a less verbose way than using its `__str__` method.
 +    Formats a packaging.requirements.Requirement with a lowercase name.
 +
 +    This is simply a copy of
@@ -677,7 +740,7 @@ index fde5816..23a05f2 100644
 +    lowercasing the entire result, which would lowercase the name, *and* other,
 +    important stuff that should not be lowercased (such as the marker). See
 +    this issue for more information: https://github.com/pypa/pipenv/issues/2113.
-+    """
+     """
 +    parts = [requirement.name.lower()]
 +
 +    if requirement.extras:
@@ -693,108 +756,19 @@ index fde5816..23a05f2 100644
 +        parts.append("; {0}".format(requirement.marker))
 +
 +    return "".join(parts)
-
-
- def format_requirement(ireq, marker=None):
-@@ -63,10 +165,10 @@ def format_requirement(ireq, marker=None):
++
++
++def format_requirement(ireq, marker=None):
      if ireq.editable:
          line = '-e {}'.format(ireq.link)
      else:
 -        line = str(ireq.req).lower()
 +        line = _requirement_to_str_lowercase_name(ireq.req)
-
+ 
 -    if marker:
 -        line = '{} ; {}'.format(line, marker)
 +    if marker and ';' not in line:
 +        line = '{}; {}'.format(line, marker)
-
+ 
      return line
-
-diff --git a/pipenv/patched/piptools/_compat/pip_compat.py b/pipenv/patched/piptools/_compat/pip_compat.py
-index 7e8cdf3..0a0d27d 100644
---- a/pipenv/patched/piptools/_compat/pip_compat.py
-+++ b/pipenv/patched/piptools/_compat/pip_compat.py
-@@ -1,30 +1,42 @@
- # -*- coding=utf-8 -*-
- import importlib
  
--def do_import(module_path, subimport=None, old_path=None):
-+
-+def do_import(module_path, subimport=None, old_path=None, vendored_name=None):
-     internal = 'pip._internal.{0}'.format(module_path)
-     old_path = old_path or module_path
-     pip9 = 'pip.{0}'.format(old_path)
--    try:
--        _tmp = importlib.import_module(internal)
--    except ImportError:
--        _tmp = importlib.import_module(pip9)
-+    _tmp = None
-+    if vendored_name:
-+        vendor = '{0}._internal'.format(vendored_name)
-+        vendor = '{0}.{1}'.format(vendor, old_path if old_path else module_path)
-+        try:
-+            _tmp = importlib.import_module(vendor)
-+        except ImportError:
-+            pass
-+    if not _tmp:
-+        try:
-+            _tmp = importlib.import_module(internal)
-+        except ImportError:
-+            _tmp = importlib.import_module(pip9)
-     if subimport:
-         return getattr(_tmp, subimport, _tmp)
-     return _tmp
--    
- 
--InstallRequirement = do_import('req.req_install', 'InstallRequirement')
--parse_requirements = do_import('req.req_file', 'parse_requirements')
--RequirementSet = do_import('req.req_set', 'RequirementSet')
--user_cache_dir = do_import('utils.appdirs', 'user_cache_dir')
--FAVORITE_HASH = do_import('utils.hashes', 'FAVORITE_HASH')
--is_file_url = do_import('download', 'is_file_url')
--url_to_path = do_import('download', 'url_to_path')
--PackageFinder = do_import('index', 'PackageFinder')
--FormatControl = do_import('index', 'FormatControl')
--Wheel = do_import('wheel', 'Wheel')
--Command = do_import('basecommand', 'Command')
--cmdoptions = do_import('cmdoptions')
--get_installed_distributions = do_import('utils.misc', 'get_installed_distributions', old_path='utils')
--PyPI = do_import('models.index', 'PyPI')
-+
-+InstallRequirement = do_import('req.req_install', 'InstallRequirement', vendored_name='notpip')
-+parse_requirements = do_import('req.req_file', 'parse_requirements', vendored_name='notpip')
-+RequirementSet = do_import('req.req_set', 'RequirementSet', vendored_name='notpip')
-+user_cache_dir = do_import('utils.appdirs', 'user_cache_dir', vendored_name='notpip')
-+FAVORITE_HASH = do_import('utils.hashes', 'FAVORITE_HASH', vendored_name='notpip')
-+is_file_url = do_import('download', 'is_file_url', vendored_name='notpip')
-+url_to_path = do_import('download', 'url_to_path', vendored_name='notpip')
-+PackageFinder = do_import('index', 'PackageFinder', vendored_name='notpip')
-+FormatControl = do_import('index', 'FormatControl', vendored_name='notpip')
-+Wheel = do_import('wheel', 'Wheel', vendored_name='notpip')
-+Command = do_import('basecommand', 'Command', vendored_name='notpip')
-+cmdoptions = do_import('cmdoptions', vendored_name='notpip')
-+get_installed_distributions = do_import('utils.misc', 'get_installed_distributions', old_path='utils', vendored_name='notpip')
-+PyPI = do_import('models.index', 'PyPI', vendored_name='notpip')
-+SafeFileCache = do_import('download', 'SafeFileCache', vendored_name='notpip')
-+InstallationError = do_import('exceptions', 'InstallationError', vendored_name='notpip')
-diff --git a/pipenv/patched/piptools/_compat/__init__.py b/pipenv/patched/piptools/_compat/__init__.py
-index 674674a..feadad8 100644
---- a/pipenv/patched/piptools/_compat/__init__.py
-+++ b/pipenv/patched/piptools/_compat/__init__.py
-@@ -27,4 +27,6 @@ from .pip_compat import (
-     cmdoptions,
-     get_installed_distributions,
-     PyPI,
-+    SafeFileCache,
-+    InstallationError,
- )
-diff --git a/pipenv/patched/pip/_vendor/__init__.py b/pipenv/patched/pip/_vendor/__init__.py
-index 774f1bf3..40ce7a01 100644
---- a/pipenv/patched/pip/_vendor/__init__.py
-+++ b/pipenv/patched/pip/_vendor/__init__.py
-@@ -107,3 +107,5 @@ if DEBUNDLED:
-     vendored("requests.packages.urllib3.util.ssl_")
-     vendored("requests.packages.urllib3.util.timeout")
-     vendored("requests.packages.urllib3.util.url")
-+
-+import requests
diff --git a/tasks/vendoring/patches/vendor/delegator-close-filehandles.patch b/tasks/vendoring/patches/vendor/delegator-close-filehandles.patch
new file mode 100644
index 00000000..7e42237f
--- /dev/null
+++ b/tasks/vendoring/patches/vendor/delegator-close-filehandles.patch
@@ -0,0 +1,88 @@
+diff --git a/pipenv/vendor/delegator.py b/pipenv/vendor/delegator.py
+index d15aeb97..cf6f91c8 100644
+--- a/pipenv/vendor/delegator.py
++++ b/pipenv/vendor/delegator.py
+@@ -7,6 +7,8 @@ import locale
+ import errno
+ 
+ from pexpect.popen_spawn import PopenSpawn
++import pexpect
++pexpect.EOF.__module__ = "pexpect.exceptions"
+ 
+ # Include `unicode` in STR_TYPES for Python 2.X
+ try:
+@@ -110,8 +112,11 @@ class Command(object):
+         if self.subprocess.before:
+             result += self.subprocess.before
+ 
+-        if self.subprocess.after:
+-            result += self.subprocess.after
++        if self.subprocess.after and self.subprocess.after is not pexpect.EOF:
++            try:
++                result += self.subprocess.after
++            except (pexpect.EOF, pexpect.TIMEOUT):
++                pass
+ 
+         result += self.subprocess.read()
+         return result
+@@ -178,6 +183,7 @@ class Command(object):
+         # Use subprocess.
+         if self.blocking:
+             popen_kwargs = self._default_popen_kwargs.copy()
++            del popen_kwargs["stdin"]
+             popen_kwargs["universal_newlines"] = not binary
+             if cwd:
+                 popen_kwargs["cwd"] = cwd
+@@ -205,7 +211,10 @@ class Command(object):
+         if self.blocking:
+             raise RuntimeError("expect can only be used on non-blocking commands.")
+ 
+-        self.subprocess.expect(pattern=pattern, timeout=timeout)
++        try:
++            self.subprocess.expect(pattern=pattern, timeout=timeout)
++        except pexpect.EOF:
++            pass
+ 
+     def send(self, s, end=os.linesep, signal=False):
+         """Sends the given string or signal to std_in."""
+@@ -234,14 +243,25 @@ class Command(object):
+         """Blocks until process is complete."""
+         if self._uses_subprocess:
+             # consume stdout and stderr
+-            try:
+-                stdout, stderr = self.subprocess.communicate()
+-                self.__out = stdout
+-                self.__err = stderr
+-            except ValueError:
+-                pass  # Don't read from finished subprocesses.
++            if self.blocking:
++                try:
++                    stdout, stderr = self.subprocess.communicate()
++                    self.__out = stdout
++                    self.__err = stderr
++                except ValueError:
++                    pass  # Don't read from finished subprocesses.
++            else:
++                self.subprocess.stdin.close()
++                self.std_out.close()
++                self.std_err.close()
++                self.subprocess.wait()
+         else:
+-            self.subprocess.wait()
++            self.subprocess.sendeof()
++            try:
++                self.subprocess.wait()
++            finally:
++                if self.subprocess.proc.stdout:
++                    self.subprocess.proc.stdout.close()
+ 
+     def pipe(self, command, timeout=None, cwd=None):
+         """Runs the current command and passes its output to the next
+@@ -263,7 +283,6 @@ class Command(object):
+         c.run(block=False, cwd=cwd)
+         if data:
+             c.send(data)
+-            c.subprocess.sendeof()
+         c.block()
+         return c
+ 
diff --git a/tasks/vendoring/patches/vendor/passa-close-session.patch b/tasks/vendoring/patches/vendor/passa-close-session.patch
new file mode 100644
index 00000000..38846bef
--- /dev/null
+++ b/tasks/vendoring/patches/vendor/passa-close-session.patch
@@ -0,0 +1,12 @@
+diff --git a/pipenv/vendor/passa/internals/dependencies.py b/pipenv/vendor/passa/internals/dependencies.py
+index 53b19b17..358cc33b 100644
+--- a/pipenv/vendor/passa/internals/dependencies.py
++++ b/pipenv/vendor/passa/internals/dependencies.py
+@@ -154,6 +154,7 @@ def _get_dependencies_from_json(ireq, sources):
+                 return dependencies
+         except Exception as e:
+             print("unable to read dependencies via {0} ({1})".format(url, e))
++    session.close()
+     return
+ 
+ 
diff --git a/tasks/vendoring/patches/vendor/pip_shims_module_names.patch b/tasks/vendoring/patches/vendor/pip_shims_module_names.patch
new file mode 100644
index 00000000..8658dcaa
--- /dev/null
+++ b/tasks/vendoring/patches/vendor/pip_shims_module_names.patch
@@ -0,0 +1,17 @@
+diff --git a/pipenv/vendor/pip_shims/__init__.py b/pipenv/vendor/pip_shims/__init__.py
+index 1342f793..70fb0d58 100644
+--- a/pipenv/vendor/pip_shims/__init__.py
++++ b/pipenv/vendor/pip_shims/__init__.py
+@@ -8,10 +8,10 @@ __version__ = '0.3.1'
+ from . import shims
+ 
+ 
+-old_module = sys.modules["pip_shims"]
++old_module = sys.modules[__name__]
+ 
+ 
+-module = sys.modules["pip_shims"] = shims._new()
++module = sys.modules[__name__] = shims._new()
+ module.shims = shims
+ module.__dict__.update({
+     '__file__': __file__,
diff --git a/tasks/vendoring/patches/vendor/pipdeptree-local-pip.patch b/tasks/vendoring/patches/vendor/pipdeptree-updated-pip18.patch
similarity index 63%
rename from tasks/vendoring/patches/vendor/pipdeptree-local-pip.patch
rename to tasks/vendoring/patches/vendor/pipdeptree-updated-pip18.patch
index a3210177..d479ebfa 100644
--- a/tasks/vendoring/patches/vendor/pipdeptree-local-pip.patch
+++ b/tasks/vendoring/patches/vendor/pipdeptree-updated-pip18.patch
@@ -1,18 +1,19 @@
 diff --git a/pipenv/vendor/pipdeptree.py b/pipenv/vendor/pipdeptree.py
-index a62badf7..a2ea83fd 100644
+index 7820aa5..2082fc8 100644
 --- a/pipenv/vendor/pipdeptree.py
 +++ b/pipenv/vendor/pipdeptree.py
-@@ -14,10 +14,10 @@ except ImportError:
+@@ -13,11 +13,9 @@ try:
+ except ImportError:
      from ordereddict import OrderedDict
  
- try:
+-try:
 -    from pipenv.patched.notpip._internal import get_installed_distributions
 -    from pipenv.patched.notpip._internal.operations.freeze import FrozenRequirement
-+    from pip._internal import get_installed_distributions
-+    from pip._internal.operations.freeze import FrozenRequirement
- except ImportError:
+-except ImportError:
 -    from pipenv.patched.notpip import get_installed_distributions, FrozenRequirement
-+    from pip import get_installed_distributions, FrozenRequirement
++pardir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
++sys.path.append(pardir)
++from pipenv.vendor.pip_shims import get_installed_distributions, FrozenRequirement
  
  import pkg_resources
  # inline:
diff --git a/tasks/vendoring/patches/vendor/vistir-imports.patch b/tasks/vendoring/patches/vendor/vistir-imports.patch
new file mode 100644
index 00000000..673efad8
--- /dev/null
+++ b/tasks/vendoring/patches/vendor/vistir-imports.patch
@@ -0,0 +1,40 @@
+diff --git a/pipenv/vendor/vistir/backports/tempfile.py b/pipenv/vendor/vistir/backports/tempfile.py
+index 483a479a..43470a6e 100644
+--- a/pipenv/vendor/vistir/backports/tempfile.py
++++ b/pipenv/vendor/vistir/backports/tempfile.py
+@@ -13,7 +13,7 @@ import six
+ try:
+     from weakref import finalize
+ except ImportError:
+-    from backports.weakref import finalize
++    from pipenv.vendor.backports.weakref import finalize
+ 
+ 
+ __all__ = ["finalize", "NamedTemporaryFile"]
+diff --git a/pipenv/vendor/vistir/compat.py b/pipenv/vendor/vistir/compat.py
+index 9ae33fdc..ec3b65cb 100644
+--- a/pipenv/vendor/vistir/compat.py
++++ b/pipenv/vendor/vistir/compat.py
+@@ -31,11 +31,11 @@ if sys.version_info >= (3, 5):
+     from functools import lru_cache
+ else:
+     from pathlib2 import Path
+-    from backports.functools_lru_cache import lru_cache
++    from pipenv.vendor.backports.functools_lru_cache import lru_cache
+ 
+ from .backports.tempfile import NamedTemporaryFile as _NamedTemporaryFile
+ if sys.version_info < (3, 3):
+-    from backports.shutil_get_terminal_size import get_terminal_size
++    from pipenv.vendor.backports.shutil_get_terminal_size import get_terminal_size
+     NamedTemporaryFile = _NamedTemporaryFile
+ else:
+     from tempfile import NamedTemporaryFile
+@@ -44,7 +44,7 @@ else:
+ try:
+     from weakref import finalize
+ except ImportError:
+-    from backports.weakref import finalize
++    from pipenv.vendor.backports.weakref import finalize
+ 
+ try:
+     from functools import partialmethod
diff --git a/tasks/vendoring/patches/vendor/vistir-spin-colorama.patch b/tasks/vendoring/patches/vendor/vistir-spin-colorama.patch
new file mode 100644
index 00000000..69e4cac7
--- /dev/null
+++ b/tasks/vendoring/patches/vendor/vistir-spin-colorama.patch
@@ -0,0 +1,28 @@
+diff --git a/pipenv/vendor/vistir/spin.py b/pipenv/vendor/vistir/spin.py
+index 2a848922..57a90277 100644
+--- a/pipenv/vendor/vistir/spin.py
++++ b/pipenv/vendor/vistir/spin.py
+@@ -5,6 +5,7 @@ import os
+ import signal
+ import sys
+ 
++import colorama
+ import cursor
+ import six
+ 
+@@ -31,6 +32,7 @@ CLEAR_LINE = chr(27) + "[K"
+ 
+ class DummySpinner(object):
+     def __init__(self, text="", **kwargs):
++        colorama.init()
+         self.text = to_native_string(text)
+         self.stdout = kwargs.get("stdout", sys.stdout)
+         self.stderr = kwargs.get("stderr", sys.stderr)
+@@ -112,7 +114,6 @@ class VistirSpinner(base_obj):
+         """
+ 
+         self.handler = handler
+-        import colorama
+         colorama.init()
+         sigmap = {}
+         if handler:
diff --git a/tasks/vendoring/patches/vendor/yaspin-signal-handling.patch b/tasks/vendoring/patches/vendor/yaspin-signal-handling.patch
new file mode 100644
index 00000000..a1d27cd3
--- /dev/null
+++ b/tasks/vendoring/patches/vendor/yaspin-signal-handling.patch
@@ -0,0 +1,62 @@
+diff --git a/pipenv/vendor/yaspin/core.py b/pipenv/vendor/yaspin/core.py
+index d01fb98e..06b8b621 100644
+--- a/pipenv/vendor/yaspin/core.py
++++ b/pipenv/vendor/yaspin/core.py
+@@ -16,6 +16,9 @@ import sys
+ import threading
+ import time
+ 
++import colorama
++import cursor
++
+ from .base_spinner import default_spinner
+ from .compat import PY2, basestring, builtin_str, bytes, iteritems, str
+ from .constants import COLOR_ATTRS, COLOR_MAP, ENCODING, SPINNER_ATTRS
+@@ -23,6 +26,9 @@ from .helpers import to_unicode
+ from .termcolor import colored
+ 
+ 
++colorama.init()
++
++
+ class Yaspin(object):
+     """Implements a context manager that spawns a thread
+     to write spinner frames into a tty (stdout) during
+@@ -369,11 +375,14 @@ class Yaspin(object):
+         # SIGKILL cannot be caught or ignored, and the receiving
+         # process cannot perform any clean-up upon receiving this
+         # signal.
+-        if signal.SIGKILL in self._sigmap.keys():
+-            raise ValueError(
+-                "Trying to set handler for SIGKILL signal. "
+-                "SIGKILL cannot be cought or ignored in POSIX systems."
+-            )
++        try:
++            if signal.SIGKILL in self._sigmap.keys():
++                raise ValueError(
++                    "Trying to set handler for SIGKILL signal. "
++                    "SIGKILL cannot be cought or ignored in POSIX systems."
++                )
++        except AttributeError:
++            pass
+ 
+         for sig, sig_handler in iteritems(self._sigmap):
+             # A handler for a particular signal, once set, remains
+@@ -521,14 +530,12 @@ class Yaspin(object):
+ 
+     @staticmethod
+     def _hide_cursor():
+-        sys.stdout.write("\033[?25l")
+-        sys.stdout.flush()
++        cursor.hide()
+ 
+     @staticmethod
+     def _show_cursor():
+-        sys.stdout.write("\033[?25h")
+-        sys.stdout.flush()
++        cursor.show()
+ 
+     @staticmethod
+     def _clear_line():
+-        sys.stdout.write("\033[K")
++        sys.stdout.write(chr(27) + "[K")
diff --git a/tasks/vendoring/vendor_passa.py b/tasks/vendoring/vendor_passa.py
new file mode 100644
index 00000000..ad179a10
--- /dev/null
+++ b/tasks/vendoring/vendor_passa.py
@@ -0,0 +1,20 @@
+from pipenv._compat import TemporaryDirectory
+import invoke
+
+
+from . import _get_git_root, _get_vendor_dir, log
+
+
+@invoke.task
+def vendor_passa(ctx):
+    with TemporaryDirectory(prefix='passa') as passa_dir:
+        vendor_dir = _get_vendor_dir(ctx).absolute().as_posix()
+        ctx.run("git clone https://github.com/sarugaku/passa.git {0}".format(passa_dir.name))
+        with ctx.cd("{0}".format(passa_dir.name)):
+            # ctx.run("git checkout 0.3.0")
+            ctx.run("pip install plette[validation] requirementslib distlib pip-shims -q --exists-action=i")
+            log("Packing Passa")
+            ctx.run("invoke pack")
+            log("Moving pack to vendor dir!")
+            ctx.run("mv pack/passa.zip {0}".format(vendor_dir))
+    log("Successfully vendored passa!")
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
index 76a429e0..0ab0ab22 100644
--- a/tests/integration/conftest.py
+++ b/tests/integration/conftest.py
@@ -1,5 +1,6 @@
 import json
 import os
+import sys
 import warnings
 
 import pytest
@@ -7,13 +8,13 @@ import pytest
 from pipenv._compat import TemporaryDirectory, Path
 from pipenv.vendor import delegator
 from pipenv.vendor import requests
-from pipenv.vendor import six
 from pipenv.vendor import toml
 from pytest_pypi.app import prepare_packages as prepare_pypi_packages
+from vistir.compat import ResourceWarning, fs_str
+from vistir.path import mkdir_p
 
-if six.PY2:
-    class ResourceWarning(Warning):
-        pass
+
+warnings.simplefilter("default", category=ResourceWarning)
 
 
 HAS_WARNED_GITHUB = False
@@ -25,8 +26,8 @@ def check_internet():
         resp = requests.get('http://httpbin.org/ip', timeout=1.0)
         resp.raise_for_status()
     except Exception:
-        warnings.warn('Cannot connect to HTTPBin...', ResourceWarning)
-        warnings.warn('Will skip tests requiring Internet', ResourceWarning)
+        warnings.warn('Cannot connect to HTTPBin...', RuntimeWarning)
+        warnings.warn('Will skip tests requiring Internet', RuntimeWarning)
         return False
     return True
 
@@ -46,18 +47,15 @@ def check_github_ssh():
     global HAS_WARNED_GITHUB
     if not res and not HAS_WARNED_GITHUB:
         warnings.warn(
-            'Cannot connect to GitHub via SSH', ResourceWarning
+            'Cannot connect to GitHub via SSH', RuntimeWarning
         )
         warnings.warn(
-            'Will skip tests requiring SSH access to GitHub', ResourceWarning
+            'Will skip tests requiring SSH access to GitHub', RuntimeWarning
         )
         HAS_WARNED_GITHUB = True
     return res
 
 
-WE_HAVE_INTERNET = check_internet()
-WE_HAVE_GITHUB_SSH_KEYS = check_github_ssh()
-
 TESTS_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 PYPI_VENDOR_DIR = os.path.join(TESTS_ROOT, 'pypi')
 prepare_pypi_packages(PYPI_VENDOR_DIR)
@@ -70,24 +68,71 @@ def pytest_runtest_setup(item):
         pytest.skip('requires github ssh')
 
 
+@pytest.fixture
+def pathlib_tmpdir(request, tmpdir):
+    yield Path(str(tmpdir))
+    try:
+        tmpdir.remove(ignore_errors=True)
+    except Exception:
+        pass
+
+
+# Borrowed from pip's test runner filesystem isolation
+@pytest.fixture(autouse=True)
+def isolate(pathlib_tmpdir):
+    """
+    Isolate our tests so that things like global configuration files and the
+    like do not affect our test results.
+    We use an autouse function scoped fixture because we want to ensure that
+    every test has it's own isolated home directory.
+    """
+
+    # Create a directory to use as our home location.
+    home_dir = os.path.join(str(pathlib_tmpdir), "home")
+    os.makedirs(home_dir)
+    mkdir_p(os.path.join(home_dir, ".config", "git"))
+    with open(os.path.join(home_dir, ".config", "git", "config"), "wb") as fp:
+        fp.write(
+            b"[user]\n\tname = pipenv\n\temail = pipenv@pipenv.org\n"
+        )
+    os.environ["GIT_CONFIG_NOSYSTEM"] = fs_str("1")
+    os.environ["GIT_AUTHOR_NAME"] = fs_str("pipenv")
+    os.environ["GIT_AUTHOR_EMAIL"] = fs_str("pipenv@pipenv.org")
+    mkdir_p(os.path.join(home_dir, ".virtualenvs"))
+    os.environ["WORKON_HOME"] = fs_str(os.path.join(home_dir, ".virtualenvs"))
+
+
+WE_HAVE_INTERNET = check_internet()
+WE_HAVE_GITHUB_SSH_KEYS = check_github_ssh()
+
+
 class _PipenvInstance(object):
     """An instance of a Pipenv Project..."""
-    def __init__(self, pypi=None, pipfile=True, chdir=False):
+    def __init__(self, pypi=None, pipfile=True, chdir=False, path=None, home_dir=None):
         self.pypi = pypi
         self.original_umask = os.umask(0o007)
         self.original_dir = os.path.abspath(os.curdir)
-        self._path = TemporaryDirectory(suffix='-project', prefix='pipenv-')
-        path = Path(self._path.name)
-        try:
-            self.path = str(path.resolve())
-        except OSError:
-            self.path = str(path.absolute())
+        os.environ["PIPENV_NOSPIN"] = fs_str("1")
+        os.environ["CI"] = fs_str("1")
+        warnings.simplefilter("ignore", category=ResourceWarning)
+        warnings.filterwarnings("ignore", category=ResourceWarning, message="unclosed.*<ssl.SSLSocket.*>")
+        path = os.environ.get("PIPENV_PROJECT_DIR", None)
+        if not path:
+            self._path = TemporaryDirectory(suffix='-project', prefix='pipenv-')
+            path = Path(self._path.name)
+            try:
+                self.path = str(path.resolve())
+            except OSError:
+                self.path = str(path.absolute())
+        else:
+            self._path = None
+            self.path = path
         # set file creation perms
         self.pipfile_path = None
         self.chdir = chdir
 
         if self.pypi:
-            os.environ['PIPENV_TEST_INDEX'] = '{0}/simple'.format(self.pypi.url)
+            os.environ['PIPENV_TEST_INDEX'] = fs_str('{0}/simple'.format(self.pypi.url))
 
         if pipfile:
             p_path = os.sep.join([self.path, 'Pipfile'])
@@ -98,9 +143,10 @@ class _PipenvInstance(object):
             self.pipfile_path = p_path
 
     def __enter__(self):
-        os.environ['PIPENV_DONT_USE_PYENV'] = '1'
-        os.environ['PIPENV_IGNORE_VIRTUALENVS'] = '1'
-        os.environ['PIPENV_VENV_IN_PROJECT'] = '1'
+        os.environ['PIPENV_DONT_USE_PYENV'] = fs_str('1')
+        os.environ['PIPENV_IGNORE_VIRTUALENVS'] = fs_str('1')
+        os.environ['PIPENV_VENV_IN_PROJECT'] = fs_str('1')
+        os.environ['PIPENV_NOSPIN'] = fs_str('1')
         if self.chdir:
             os.chdir(self.path)
         return self
@@ -110,20 +156,21 @@ class _PipenvInstance(object):
         if self.chdir:
             os.chdir(self.original_dir)
         self.path = None
-        try:
-            self._path.cleanup()
-        except OSError as e:
-            _warn_msg = warn_msg.format(e)
-            warnings.warn(_warn_msg, ResourceWarning)
-        finally:
-            os.umask(self.original_umask)
+        if self._path:
+            try:
+                self._path.cleanup()
+            except OSError as e:
+                _warn_msg = warn_msg.format(e)
+                warnings.warn(_warn_msg, ResourceWarning)
+        os.umask(self.original_umask)
 
     def pipenv(self, cmd, block=True):
         if self.pipfile_path:
-            os.environ['PIPENV_PIPFILE'] = self.pipfile_path
+            os.environ['PIPENV_PIPFILE'] = fs_str(self.pipfile_path)
+        # a bit of a hack to make sure the virtualenv is created
 
         with TemporaryDirectory(prefix='pipenv-', suffix='-cache') as tempdir:
-            os.environ['PIPENV_CACHE_DIR'] = tempdir.name
+            os.environ['PIPENV_CACHE_DIR'] = fs_str(tempdir.name)
             c = delegator.run('pipenv {0}'.format(cmd), block=block)
             if 'PIPENV_CACHE_DIR' in os.environ:
                 del os.environ['PIPENV_CACHE_DIR']
@@ -136,6 +183,8 @@ class _PipenvInstance(object):
             print('$ pipenv {0}'.format(cmd))
             print(c.out)
             print(c.err)
+            if c.return_code != 0:
+                print("Command failed...")
 
         # Where the action happens.
         return c
@@ -159,18 +208,16 @@ class _PipenvInstance(object):
 
 @pytest.fixture()
 def PipenvInstance():
-    return _PipenvInstance
+    yield _PipenvInstance
 
 
-@pytest.fixture(scope='module')
-def pip_src_dir(request):
+@pytest.fixture(autouse=True)
+def pip_src_dir(request, pathlib_tmpdir):
     old_src_dir = os.environ.get('PIP_SRC', '')
-    new_src_dir = TemporaryDirectory(prefix='pipenv-', suffix='-testsrc')
-    os.environ['PIP_SRC'] = new_src_dir.name
+    os.environ['PIP_SRC'] = pathlib_tmpdir.as_posix()
 
     def finalize():
-        new_src_dir.cleanup()
-        os.environ['PIP_SRC'] = old_src_dir
+        os.environ['PIP_SRC'] = fs_str(old_src_dir)
 
     request.addfinalizer(finalize)
     return request
diff --git a/tests/integration/test_cli.py b/tests/integration/test_cli.py
index a51095ce..7ebcee1d 100644
--- a/tests/integration/test_cli.py
+++ b/tests/integration/test_cli.py
@@ -12,56 +12,81 @@ from pipenv.utils import normalize_drive
 @pytest.mark.cli
 def test_pipenv_where(PipenvInstance, pypi_secure):
     with PipenvInstance(pypi=pypi_secure) as p:
-        assert normalize_drive(p.path) in p.pipenv('--where').out
+        c = p.pipenv("--where")
+        assert c.ok
+        assert normalize_drive(p.path) in c.out
 
 
 @pytest.mark.cli
 def test_pipenv_venv(PipenvInstance):
     with PipenvInstance() as p:
-        p.pipenv('--python python')
-        venv_path = p.pipenv('--venv').out.strip()
+        c = p.pipenv('--python python')
+        assert c.ok
+        c = p.pipenv('--venv')
+        assert c.ok
+        venv_path = c.out.strip()
         assert os.path.isdir(venv_path)
 
 
 @pytest.mark.cli
 def test_pipenv_py(PipenvInstance):
     with PipenvInstance() as p:
-        p.pipenv('--python python')
-        python = p.pipenv('--py').out.strip()
+        c = p.pipenv('--python python')
+        assert c.ok
+        c = p.pipenv('--py')
+        assert c.ok
+        python = c.out.strip()
         assert os.path.basename(python).startswith('python')
 
 
 @pytest.mark.cli
 def test_pipenv_support(PipenvInstance):
     with PipenvInstance() as p:
-        assert p.pipenv('--support').out
+        c = p.pipenv('--support')
+        assert c.ok
+        assert c.out
 
 
 @pytest.mark.cli
 def test_pipenv_rm(PipenvInstance):
     with PipenvInstance() as p:
-        p.pipenv('--python python')
-        venv_path = p.pipenv('--venv').out.strip()
+        c = p.pipenv('--python python')
+        assert c.ok
+        c = p.pipenv('--venv')
+        assert c.ok
+        venv_path = c.out.strip()
         assert os.path.isdir(venv_path)
 
-        assert p.pipenv('--rm').out
+        c = p.pipenv('--rm')
+        assert c.ok
+        assert c.out
         assert not os.path.isdir(venv_path)
 
 
 @pytest.mark.cli
 def test_pipenv_graph(PipenvInstance, pypi):
     with PipenvInstance(pypi=pypi) as p:
-        p.pipenv('install requests')
-        assert 'requests' in p.pipenv('graph').out
-        assert 'requests' in p.pipenv('graph --json').out
-        assert 'requests' in p.pipenv('graph --json-tree').out
+        c = p.pipenv('install requests')
+        assert c.ok
+        graph = p.pipenv("graph")
+        assert graph.ok
+        assert "requests" in graph.out
+        graph_json = p.pipenv("graph --json")
+        assert graph_json.ok
+        assert "requests" in graph_json.out
+        graph_json_tree = p.pipenv("graph --json-tree")
+        assert graph_json_tree.ok
+        assert "requests" in graph_json_tree.out
 
 
 @pytest.mark.cli
 def test_pipenv_graph_reverse(PipenvInstance, pypi):
     with PipenvInstance(pypi=pypi) as p:
-        p.pipenv('install requests==2.18.4')
-        output = p.pipenv('graph --reverse').out
+        c = p.pipenv('install requests==2.18.4')
+        assert c.ok
+        c = p.pipenv('graph --reverse')
+        assert c.ok
+        output = c.out
 
         requests_dependency = [
             ('certifi', 'certifi>=2017.4.17'),
@@ -91,8 +116,10 @@ def test_pipenv_check(PipenvInstance, pypi):
         c = p.pipenv('check')
         assert c.return_code != 0
         assert 'requests' in c.out
-        p.pipenv('uninstall requests')
-        p.pipenv('install six')
+        c = p.pipenv('uninstall requests')
+        assert c.ok
+        c = p.pipenv('install six')
+        assert c.ok
         c = p.pipenv('check --ignore 35015')
         assert c.return_code == 0
         assert 'Ignoring' in c.err
@@ -103,8 +130,13 @@ def test_pipenv_clean_pip_no_warnings(PipenvInstance):
     with PipenvInstance(chdir=True) as p:
         with open('setup.py', 'w') as f:
             f.write('from setuptools import setup; setup(name="empty")')
-        p.pipenv('run pip install -e .')
-        assert p.pipenv('clean').out
+        c = p.pipenv('install -e .')
+        assert c.return_code == 0
+        c = p.pipenv('run pip install pytz')
+        assert c.return_code == 0
+        c = p.pipenv('clean')
+        assert c.return_code == 0
+        assert c.out, "{0} -- STDERR: {1}".format(c.out, c.err)
 
 
 @pytest.mark.cli
@@ -114,8 +146,11 @@ def test_pipenv_clean_pip_warnings(PipenvInstance):
             f.write('from setuptools import setup; setup(name="empty")')
         # create a fake git repo to trigger a pip freeze warning
         os.mkdir('.git')
-        p.pipenv('run pip install -e .')
-        assert p.pipenv('clean').out
+        c = p.pipenv("run pip install -e .")
+        assert c.return_code == 0
+        c = p.pipenv('clean')
+        assert c.return_code == 0
+        assert c.err
 
 
 @pytest.mark.cli
diff --git a/tests/integration/test_install_basic.py b/tests/integration/test_install_basic.py
index 9fad7d47..c49a9368 100644
--- a/tests/integration/test_install_basic.py
+++ b/tests/integration/test_install_basic.py
@@ -232,6 +232,31 @@ requests = {version = "*"}
         assert c.return_code == 0
 
 
+@pytest.mark.run
+@pytest.mark.alt
+@flaky
+def test_outline_table_specifier(PipenvInstance, pypi):
+    with PipenvInstance(pypi=pypi) as p:
+        with open(p.pipfile_path, "w") as f:
+            contents = """
+[packages.requests]
+version = "*"
+            """.strip()
+            f.write(contents)
+
+        c = p.pipenv("install")
+        assert c.return_code == 0
+
+        assert "requests" in p.lockfile["default"]
+        assert "idna" in p.lockfile["default"]
+        assert "urllib3" in p.lockfile["default"]
+        assert "certifi" in p.lockfile["default"]
+        assert "chardet" in p.lockfile["default"]
+
+        c = p.pipenv('run python -c "import requests; import idna; import certifi;"')
+        assert c.return_code == 0
+
+
 @pytest.mark.bad
 @pytest.mark.install
 def test_bad_packages(PipenvInstance, pypi):
diff --git a/tests/integration/test_lock.py b/tests/integration/test_lock.py
index 23d75f8e..2b520808 100644
--- a/tests/integration/test_lock.py
+++ b/tests/integration/test_lock.py
@@ -37,9 +37,9 @@ flask = "==0.12.2"
             """.strip()
             f.write(contents)
 
-        req_list = ("requests==2.14.0")
+        req_list = ("requests==2.14.0",)
 
-        dev_req_list = ("flask==0.12.2")
+        dev_req_list = ("flask==0.12.2",)
 
         c = p.pipenv('lock -r')
         d = p.pipenv('lock -r -d')
@@ -167,6 +167,28 @@ maya = "*"
         assert c.return_code == 0
 
 
+@pytest.mark.extras
+@pytest.mark.lock
+def test_lock_extras_without_install(PipenvInstance, pypi):
+    with PipenvInstance(pypi=pypi) as p:
+        with open(p.pipfile_path, 'w') as f:
+            contents = """
+[packages]
+requests = {version = "*", extras = ["socks"]}
+            """.strip()
+            f.write(contents)
+
+        c = p.pipenv('lock')
+        assert c.return_code == 0
+        assert "requests" in p.lockfile["default"]
+        assert "pysocks" in p.lockfile["default"]
+        assert "markers" not in p.lockfile["default"]['pysocks']
+
+        c = p.pipenv('lock -r')
+        assert c.return_code == 0
+        assert "extra == 'socks'" not in c.out.strip()
+
+
 @pytest.mark.extras
 @pytest.mark.lock
 @pytest.mark.complex
@@ -347,6 +369,42 @@ requests = {git = "https://github.com/requests/requests.git", ref = "master", ed
         assert c.return_code == 0
 
 
+@pytest.mark.lock
+@pytest.mark.vcs
+@pytest.mark.needs_internet
+def test_lock_editable_vcs_with_ref_in_git(PipenvInstance, pypi):
+    with PipenvInstance(pypi=pypi, chdir=True) as p:
+        with open(p.pipfile_path, 'w') as f:
+            f.write("""
+[packages]
+requests = {git = "https://github.com/requests/requests.git@883caaf", editable = true}
+            """.strip())
+        c = p.pipenv('lock')
+        assert c.return_code == 0
+        assert p.lockfile['default']['requests']['git'] == 'https://github.com/requests/requests.git'
+        assert p.lockfile['default']['requests']['ref'] == '883caaf145fbe93bd0d208a6b864de9146087312'
+        c = p.pipenv('install')
+        assert c.return_code == 0
+
+
+@pytest.mark.lock
+@pytest.mark.vcs
+@pytest.mark.needs_internet
+def test_lock_editable_vcs_with_ref(PipenvInstance, pypi):
+    with PipenvInstance(pypi=pypi, chdir=True) as p:
+        with open(p.pipfile_path, 'w') as f:
+            f.write("""
+[packages]
+requests = {git = "https://github.com/requests/requests.git", ref = "883caaf", editable = true}
+            """.strip())
+        c = p.pipenv('lock')
+        assert c.return_code == 0
+        assert p.lockfile['default']['requests']['git'] == 'https://github.com/requests/requests.git'
+        assert p.lockfile['default']['requests']['ref'] == '883caaf145fbe93bd0d208a6b864de9146087312'
+        c = p.pipenv('install')
+        assert c.return_code == 0
+
+
 @pytest.mark.extras
 @pytest.mark.lock
 @pytest.mark.vcs
@@ -368,6 +426,25 @@ requests = {git = "https://github.com/requests/requests.git", editable = true, e
         assert c.return_code == 0
 
 
+@pytest.mark.lock
+@pytest.mark.vcs
+@pytest.mark.needs_internet
+def test_lock_editable_vcs_with_markers_without_install(PipenvInstance, pypi):
+    with PipenvInstance(pypi=pypi, chdir=True) as p:
+        with open(p.pipfile_path, 'w') as f:
+            f.write("""
+[packages]
+requests = {git = "https://github.com/requests/requests.git", ref = "master", editable = true, markers = "python_version >= '2.6'"}
+            """.strip())
+        c = p.pipenv('lock')
+        assert c.return_code == 0
+        assert 'requests' in p.lockfile['default']
+        assert 'idna' in p.lockfile['default']
+        assert 'chardet' in p.lockfile['default']
+        c = p.pipenv('install')
+        assert c.return_code == 0
+
+
 @pytest.mark.lock
 @pytest.mark.skip(reason="This doesn't work for some reason.")
 def test_lock_respecting_python_version(PipenvInstance, pypi):
diff --git a/tests/integration/test_sync.py b/tests/integration/test_sync.py
index c50e259b..2ef06ddc 100644
--- a/tests/integration/test_sync.py
+++ b/tests/integration/test_sync.py
@@ -15,7 +15,7 @@ def test_sync_error_without_lockfile(PipenvInstance, pypi):
 
         c = p.pipenv('sync')
         assert c.return_code != 0
-        assert 'Pipfile.lock is missing!' in c.err
+        assert 'Pipfile.lock not found!' in c.err
 
 
 @pytest.mark.sync
diff --git a/tests/integration/test_windows.py b/tests/integration/test_windows.py
index 128a6b5d..da138f7a 100644
--- a/tests/integration/test_windows.py
+++ b/tests/integration/test_windows.py
@@ -65,3 +65,16 @@ def test_local_path_windows_forward_slash(PipenvInstance, pypi):
     with PipenvInstance(pypi=pypi, chdir=True) as p:
         c = p.pipenv('install "{0}"'.format(whl.as_posix()))
         assert c.return_code == 0
+
+
+@pytest.mark.cli
+def test_pipenv_clean_windows(PipenvInstance, pypi):
+    with PipenvInstance(pypi=pypi, chdir=True) as p:
+        c = p.pipenv('install requests')
+        assert c.return_code == 0
+        c = p.pipenv('run pip install click')
+        assert c.return_code == 0
+
+        c = p.pipenv('clean --dry-run')
+        assert c.return_code == 0
+        assert 'click' in c.out.strip()
diff --git a/tests/unit/test_utils.py b/tests/unit/test_utils.py
index 98c85602..40977ede 100644
--- a/tests/unit/test_utils.py
+++ b/tests/unit/test_utils.py
@@ -4,6 +4,7 @@ import pytest
 from mock import patch, Mock
 from first import first
 import pipenv.utils
+import pythonfinder.utils
 
 
 # Pipfile format <-> requirements.txt format.
@@ -215,13 +216,13 @@ class TestUtils:
             ),
         ],
     )
-    @patch("delegator.run")
+    # @patch(".vendor.pythonfinder.utils.get_python_version")
     def test_python_version_output_variants(
-        self, mocked_delegator, version_output, version
+        self, monkeypatch, version_output, version
     ):
-        run_ret = Mock()
-        run_ret.out = version_output
-        mocked_delegator.return_value = run_ret
+        def mock_version(path):
+            return version_output.split()[1]
+        monkeypatch.setattr("pipenv.vendor.pythonfinder.utils.get_python_version", mock_version)
         assert pipenv.utils.python_version("some/path") == version
 
     @pytest.mark.utils