Как установить requirements txt windows

Running pip¶

pip is a command line program. When you install pip, a pip command is added
to your system, which can be run from the command prompt as follows:

python -m pip <pip arguments>

py -m pip <pip arguments>

Installing Packages¶

pip supports installing from PyPI, version control, local projects, and
directly from distribution files.

The most common scenario is to install from PyPI using Requirement Specifiers

python -m pip install SomePackage            # latest version
python -m pip install SomePackage==1.0.4     # specific version
python -m pip install 'SomePackage>=1.0.4'     # minimum version

py -m pip install SomePackage            # latest version
py -m pip install SomePackage==1.0.4     # specific version
py -m pip install 'SomePackage>=1.0.4'   # minimum version

For more information and examples, see the pip install reference.

Basic Authentication Credentials

This is now covered in Authentication.

netrc Support

This is now covered in Authentication.

Keyring Support

This is now covered in Authentication.

Using a Proxy Server¶

When installing packages from PyPI, pip requires internet access, which
in many corporate environments requires an outbound HTTP proxy server.

pip can be configured to connect through a proxy server in various ways:

• using the --proxy command-line option to specify a proxy in the form
  scheme://[user:passwd@]proxy.server:port

• using proxy in a Configuration Files

• by setting the standard environment-variables http_proxy, https_proxy
  and no_proxy.

• using the environment variable PIP_USER_AGENT_USER_DATA to include
  a JSON-encoded string in the user-agent variable used in pip’s requests.

Requirements Files¶

“Requirements files” are files containing a list of items to be
installed using pip install like so:

python -m pip install -r requirements.txt

py -m pip install -r requirements.txt

Details on the format of the files are here: Requirements File Format.

Logically, a Requirements file is just a list of pip install arguments
placed in a file. Note that you should not rely on the items in the file being
installed by pip in any particular order.

Requirements files can also be served via a URL, e.g.
http://example.com/requirements.txt besides as local files, so that they can
be stored and served in a centralized place.

In practice, there are 4 common uses of Requirements files:

1. Requirements files are used to hold the result from pip freeze for the
   purpose of achieving Repeatable Installs. In
   this case, your requirement file contains a pinned version of everything that
   was installed when pip freeze was run.

   Unix/macOS

   python -m pip freeze > requirements.txt
   python -m pip install -r requirements.txt
   

   Windows

   py -m pip freeze > requirements.txt
   py -m pip install -r requirements.txt
   

2. Requirements files are used to force pip to properly resolve dependencies.
   pip 20.2 and earlier doesn’t have true dependency resolution, but instead simply uses the first
   specification it finds for a project. E.g. if pkg1 requires
   pkg3>=1.0 and pkg2 requires pkg3>=1.0,<=2.0, and if pkg1 is
   resolved first, pip will only use pkg3>=1.0, and could easily end up
   installing a version of pkg3 that conflicts with the needs of pkg2.
   To solve this problem, you can place pkg3>=1.0,<=2.0 (i.e. the correct
   specification) into your requirements file directly along with the other top
   level requirements. Like so:

   pkg1
   pkg2
   pkg3>=1.0,<=2.0
   

3. Requirements files are used to force pip to install an alternate version of a
   sub-dependency. For example, suppose ProjectA in your requirements file
   requires ProjectB, but the latest version (v1.3) has a bug, you can force
   pip to accept earlier versions like so:

4. Requirements files are used to override a dependency with a local patch that
   lives in version control. For example, suppose a dependency
   SomeDependency from PyPI has a bug, and you can’t wait for an upstream
   fix.
   You could clone/copy the src, make the fix, and place it in VCS with the tag
   sometag. You’d reference it in your requirements file with a line like
   so:

   git+https://myvcs.com/some_dependency@sometag#egg=SomeDependency
   

   If SomeDependency was previously a top-level requirement in your
   requirements file, then replace that line with the new line. If
   SomeDependency is a sub-dependency, then add the new line.

It’s important to be clear that pip determines package dependencies using
install_requires metadata,
not by discovering requirements.txt files embedded in projects.

See also:

• Requirements File Format

• pip freeze

• “setup.py vs requirements.txt” (an article by Donald Stufft)

Constraints Files¶

Constraints files are requirements files that only control which version of a
requirement is installed, not whether it is installed or not. Their syntax and
contents is a subset of Requirements Files, with several kinds of syntax
not allowed: constraints must have a name, they cannot be editable, and they
cannot specify extras. In terms of semantics, there is one key difference:
Including a package in a constraints file does not trigger installation of the
package.

Use a constraints file like so:

python -m pip install -c constraints.txt

py -m pip install -c constraints.txt

Constraints files are used for exactly the same reason as requirements files
when you don’t know exactly what things you want to install. For instance, say
that the “helloworld” package doesn’t work in your environment, so you have a
local patched version. Some things you install depend on “helloworld”, and some
don’t.

One way to ensure that the patched version is used consistently is to
manually audit the dependencies of everything you install, and if “helloworld”
is present, write a requirements file to use when installing that thing.

Constraints files offer a better way: write a single constraints file for your
organisation and use that everywhere. If the thing being installed requires
“helloworld” to be installed, your fixed version specified in your constraints
file will be used.

Constraints file support was added in pip 7.1. In Changes to the pip dependency resolver in 20.3 (2020) we did a fairly comprehensive overhaul, removing several
undocumented and unsupported quirks from the previous implementation,
and stripped constraints files down to being purely a way to specify
global (version) limits for packages.

Same as requirements files, constraints files can also be served via a URL,
e.g. http://example.com/constraints.txt, so that your organization can store and
serve them in a centralized place.

Dependency Groups¶

“Dependency Groups” are lists of items to be installed stored in a
pyproject.toml file.

A dependency group is logically just a list of requirements, similar to the
contents of Requirements Files. Unlike requirements files, dependency
groups cannot contain non-package arguments for pip install.

Groups can be declared like so:

# pyproject.toml
[dependency-groups]
groupA = [
    "pkg1",
    "pkg2",
]

and installed with pip install like so:

python -m pip install --group groupA

py -m pip install --group groupA

Full details on the contents of [dependency-groups] and more examples are
available in the specification documentation.

pip does not search projects or directories to discover pyproject.toml
files. The --group option is used to pass the path to the file,
and if the path is omitted, as in the example above, it defaults to
pyproject.toml in the current directory. Using explicit paths,
pip install can use a file from another directory. For example:

python -m pip install --group './project/subproject/pyproject.toml:groupA'

py -m pip install --group './project/subproject/pyproject.toml:groupA'

This also makes it possible to install groups from multiple different projects
at once. For example, with a directory structure like so:

+ project/
  + sub1/
    - pyproject.toml
  + sub2/
    - pyproject.toml

it is possible to install, from the project/ directory, groups from the
subprojects thusly:

python -m pip install --group './sub1/pyproject.toml:groupA' --group './sub2/pyproject.toml:groupB'

py -m pip install --group './sub1/pyproject.toml:groupA' --group './sub2/pyproject.toml:groupB'

Installing from Wheels¶

“Wheel” is a built, archive format that can greatly speed installation compared
to building and installing from source archives. For more information, see the
specification.

pip prefers Wheels where they are available. To disable this, use the
—no-binary flag for pip install.

If no satisfactory wheels are found, pip will default to finding source
archives.

To install directly from a wheel archive:

python -m pip install SomePackage-1.0-py2.py3-none-any.whl

py -m pip install SomePackage-1.0-py2.py3-none-any.whl

To include optional dependencies provided in the provides_extras
metadata in the wheel, you must add quotes around the install target
name:

python -m pip install './somepackage-1.0-py2.py3-none-any.whl[my-extras]'

py -m pip install './somepackage-1.0-py2.py3-none-any.whl[my-extras]'

For the cases where wheels are not available, pip offers pip wheel as a
convenience, to build wheels for all your requirements and dependencies.

pip wheel requires the wheel package to be installed, which provides the
“bdist_wheel” setuptools extension that it uses.

To build wheels for your requirements and all their dependencies to a local
directory:

python -m pip install wheel
python -m pip wheel --wheel-dir=/local/wheels -r requirements.txt

py -m pip install wheel
py -m pip wheel --wheel-dir=/local/wheels -r requirements.txt

And then to install those requirements just using your local directory of
wheels (and not from PyPI):

python -m pip install --no-index --find-links=/local/wheels -r requirements.txt

py -m pip install --no-index --find-links=/local/wheels -r requirements.txt

Uninstalling Packages¶

pip is able to uninstall most packages like so:

python -m pip uninstall SomePackage

py -m pip uninstall SomePackage

pip also performs an automatic uninstall of an old version of a package
before upgrading to a newer version.

For more information and examples, see the pip uninstall reference.

Listing Packages¶

To list installed packages:

$ python -m pip list
docutils (0.9.1)
Jinja2 (2.6)
Pygments (1.5)
Sphinx (1.1.2)

C:\> py -m pip list
docutils (0.9.1)
Jinja2 (2.6)
Pygments (1.5)
Sphinx (1.1.2)

To list outdated packages, and show the latest version available:

$ python -m pip list --outdated
docutils (Current: 0.9.1 Latest: 0.10)
Sphinx (Current: 1.1.2 Latest: 1.1.3)

C:\> py -m pip list --outdated
docutils (Current: 0.9.1 Latest: 0.10)
Sphinx (Current: 1.1.2 Latest: 1.1.3)

To show details about an installed package:

$ python -m pip show sphinx
---
Name: Sphinx
Version: 1.1.3
Location: /my/env/lib/pythonx.x/site-packages
Requires: Pygments, Jinja2, docutils

C:\> py -m pip show sphinx
---
Name: Sphinx
Version: 1.1.3
Location: /my/env/lib/pythonx.x/site-packages
Requires: Pygments, Jinja2, docutils

For more information and examples, see the pip list and pip show
reference pages.

Searching for Packages¶

pip can search PyPI for packages using the pip search
command:

python -m pip search "query"

The query will be used to search the names and summaries of all
packages.

For more information and examples, see the pip search reference.

Configuration

This is now covered in Configuration.

Config file

This is now covered in Configuration.

Environment Variables

This is now covered in Configuration.

Config Precedence

This is now covered in Configuration.

Command Completion¶

pip comes with support for command line completion in bash, zsh and fish.

To setup for bash:

python -m pip completion --bash >> ~/.profile

To setup for zsh:

python -m pip completion --zsh >> ~/.zprofile

To setup for fish:

python -m pip completion --fish > ~/.config/fish/completions/pip.fish

To setup for powershell:

python -m pip completion --powershell | Out-File -Encoding default -Append $PROFILE

Alternatively, you can use the result of the completion command directly
with the eval function of your shell, e.g. by adding the following to your
startup file:

eval "`pip completion --bash`"

Installing from local packages¶

In some cases, you may want to install from local packages only, with no traffic
to PyPI.

First, download the archives that fulfill your requirements:

python -m pip download --destination-directory DIR -r requirements.txt

py -m pip download --destination-directory DIR -r requirements.txt

Note that pip download will look in your wheel cache first, before
trying to download from PyPI. If you’ve never installed your requirements
before, you won’t have a wheel cache for those items. In that case, if some of
your requirements don’t come as wheels from PyPI, and you want wheels, then run
this instead:

python -m pip wheel --wheel-dir DIR -r requirements.txt

py -m pip wheel --wheel-dir DIR -r requirements.txt

Then, to install from local only, you’ll be using —find-links and —no-index like so:

python -m pip install --no-index --find-links=DIR -r requirements.txt

py -m pip install --no-index --find-links=DIR -r requirements.txt

“Only if needed” Recursive Upgrade¶

pip install --upgrade now has a --upgrade-strategy option which
controls how pip handles upgrading of dependencies. There are 2 upgrade
strategies supported:

• eager: upgrades all dependencies regardless of whether they still satisfy
  the new parent requirements

• only-if-needed: upgrades a dependency only if it does not satisfy the new
  parent requirements

The default strategy is only-if-needed. This was changed in pip 10.0 due to
the breaking nature of eager when upgrading conflicting dependencies.

It is important to note that --upgrade affects direct requirements (e.g.
those specified on the command-line or via a requirements file) while
--upgrade-strategy affects indirect requirements (dependencies of direct
requirements).

As an example, say SomePackage has a dependency, SomeDependency, and
both of them are already installed but are not the latest available versions:

• pip install SomePackage: will not upgrade the existing SomePackage or
  SomeDependency.

• pip install --upgrade SomePackage: will upgrade SomePackage, but not
  SomeDependency (unless a minimum requirement is not met).

• pip install --upgrade SomePackage --upgrade-strategy=eager: upgrades both
  SomePackage and SomeDependency.

As an historic note, an earlier “fix” for getting the only-if-needed
behaviour was:

python -m pip install --upgrade --no-deps SomePackage
python -m pip install SomePackage

py -m pip install --upgrade --no-deps SomePackage
py -m pip install SomePackage

A proposal for an upgrade-all command is being considered as a safer
alternative to the behaviour of eager upgrading.

User Installs¶

With Python 2.6 came the “user scheme” for installation,
which means that all Python distributions support an alternative install
location that is specific to a user. The default location for each OS is
explained in the python documentation for the site.USER_BASE variable.
This mode of installation can be turned on by specifying the —user option to pip install.

Moreover, the “user scheme” can be customized by setting the
PYTHONUSERBASE environment variable, which updates the value of
site.USER_BASE.

To install “SomePackage” into an environment with site.USER_BASE customized to
‘/myappenv’, do the following:

export PYTHONUSERBASE=/myappenv
python -m pip install --user SomePackage

set PYTHONUSERBASE=c:/myappenv
py -m pip install --user SomePackage

pip install --user follows four rules:

1. When globally installed packages are on the python path, and they conflict
   with the installation requirements, they are ignored, and not
   uninstalled.

2. When globally installed packages are on the python path, and they satisfy
   the installation requirements, pip does nothing, and reports that
   requirement is satisfied (similar to how global packages can satisfy
   requirements when installing packages in a --system-site-packages
   virtualenv).

3. pip will not perform a --user install in a --no-site-packages
   virtualenv (i.e. the default kind of virtualenv), due to the user site not
   being on the python path. The installation would be pointless.

4. In a --system-site-packages virtualenv, pip will not install a package
   that conflicts with a package in the virtualenv site-packages. The —user
   installation would lack sys.path precedence and be pointless.

To make the rules clearer, here are some examples:

From within a --no-site-packages virtualenv (i.e. the default kind):

$ python -m pip install --user SomePackage
Can not perform a '--user' install. User site-packages are not visible in this virtualenv.

C:\> py -m pip install --user SomePackage
Can not perform a '--user' install. User site-packages are not visible in this virtualenv.

From within a --system-site-packages virtualenv where SomePackage==0.3
is already installed in the virtualenv:

$ python -m pip install --user SomePackage==0.4
Will not install to the user site because it will lack sys.path precedence

C:\> py -m pip install --user SomePackage==0.4
Will not install to the user site because it will lack sys.path precedence

From within a real python, where SomePackage is not installed globally:

$ python -m pip install --user SomePackage
[...]
Successfully installed SomePackage

C:\> py -m pip install --user SomePackage
[...]
Successfully installed SomePackage

From within a real python, where SomePackage is installed globally, but
is not the latest version:

$ python -m pip install --user SomePackage
[...]
Requirement already satisfied (use --upgrade to upgrade)
$ python -m pip install --user --upgrade SomePackage
[...]
Successfully installed SomePackage

C:\> py -m pip install --user SomePackage
[...]
Requirement already satisfied (use --upgrade to upgrade)
C:\> py -m pip install --user --upgrade SomePackage
[...]
Successfully installed SomePackage

From within a real python, where SomePackage is installed globally, and
is the latest version:

$ python -m pip install --user SomePackage
[...]
Requirement already satisfied (use --upgrade to upgrade)
$ python -m pip install --user --upgrade SomePackage
[...]
Requirement already up-to-date: SomePackage
# force the install
$ python -m pip install --user --ignore-installed SomePackage
[...]
Successfully installed SomePackage

C:\> py -m pip install --user SomePackage
[...]
Requirement already satisfied (use --upgrade to upgrade)
C:\> py -m pip install --user --upgrade SomePackage
[...]
Requirement already up-to-date: SomePackage
# force the install
C:\> py -m pip install --user --ignore-installed SomePackage
[...]
Successfully installed SomePackage

Ensuring Repeatability

This is now covered in Repeatable Installs.

Fixing conflicting dependencies

This is now covered in Dependency Resolution.

Using pip from your program¶

As noted previously, pip is a command line program. While it is implemented in
Python, and so is available from your Python code via import pip, you must
not use pip’s internal APIs in this way. There are a number of reasons for this:

1. The pip code assumes that it is in sole control of the global state of the
   program.
   pip manages things like the logging system configuration, or the values of
   the standard IO streams, without considering the possibility that user code
   might be affected.

2. pip’s code is not thread safe. If you were to run pip in a thread, there
   is no guarantee that either your code or pip’s would work as you expect.

3. pip assumes that once it has finished its work, the process will terminate.
   It doesn’t need to handle the possibility that other code will continue to
   run after that point, so (for example) calling pip twice in the same process
   is likely to have issues.

This does not mean that the pip developers are opposed in principle to the idea
that pip could be used as a library — it’s just that this isn’t how it was
written, and it would be a lot of work to redesign the internals for use as a
library, handling all of the above issues, and designing a usable, robust and
stable API that we could guarantee would remain available across multiple
releases of pip. And we simply don’t currently have the resources to even
consider such a task.

What this means in practice is that everything inside of pip is considered an
implementation detail. Even the fact that the import name is pip is subject
to change without notice. While we do try not to break things as much as
possible, all the internal APIs can change at any time, for any reason. It also
means that we generally won’t fix issues that are a result of using pip in an
unsupported way.

It should also be noted that installing packages into sys.path in a running
Python process is something that should only be done with care. The import
system caches certain data, and installing new packages while a program is
running may not always behave as expected. In practice, there is rarely an
issue, but it is something to be aware of.

Having said all of the above, it is worth covering the options available if you
decide that you do want to run pip from within your program. The most reliable
approach, and the one that is fully supported, is to run pip in a subprocess.
This is easily done using the standard subprocess module:

subprocess.check_call([sys.executable, '-m', 'pip', 'install', 'my_package'])

If you want to process the output further, use one of the other APIs in the module.
We are using freeze here which outputs installed packages in requirements format.:

reqs = subprocess.check_output([sys.executable, '-m', 'pip', 'freeze'])

To programmatically monitor download progress use the --progress-bar=raw option.
This will print lines to stdout in the format Progress CURRENT of TOTAL, where
CURRENT and TOTAL are integers and the unit is bytes.
If the real total is unknown then TOTAL is set to 0. Be aware that the
specific formatting of pip’s outputs are not guaranteed to be the same in future versions.

If you don’t want to use pip’s command line functionality, but are rather
trying to implement code that works with Python packages, their metadata, or
PyPI, then you should consider other, supported, packages that offer this type
of ability. Some examples that you could consider include:

• packaging — Utilities to work with standard package metadata (versions,
  requirements, etc.)

• setuptools (specifically pkg_resources) — Functions for querying what
  packages the user has installed on their system.

• distlib — Packaging and distribution utilities (including functions for
  interacting with PyPI).

Changes to the pip dependency resolver in 20.3 (2020)¶

pip 20.3 has a new dependency resolver, on by default for Python 3
users. (pip 20.1 and 20.2 included pre-release versions of the new
dependency resolver, hidden behind optional user flags.) Read below
for a migration guide, how to invoke the legacy resolver, and the
deprecation timeline. We also made a two-minute video explanation
you can watch.

We will continue to improve the pip dependency resolver in response to
testers’ feedback. Please give us feedback through the resolver
testing survey.

Requirements for Installing Packages¶

This section describes the steps to follow before installing other Python
packages.

>>> python3 --version
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'python3' is not defined

In [1]: import sys
        !{sys.executable} --version
Python 3.6.3

python3 -m ensurepip --default-pip

py -m ensurepip --default-pip

python3 -m pip install --upgrade pip setuptools wheel

py -m pip install --upgrade pip setuptools wheel

python3 -m venv tutorial_env
source tutorial_env/bin/activate

py -m venv tutorial_env
tutorial_env\Scripts\activate

Creating Virtual Environments¶

Python “Virtual Environments” allow Python packages to be installed in an isolated location for a particular application,
rather than being installed globally. If you are looking to safely install
global command line tools,
see Installing stand alone command line tools.

Imagine you have an application that needs version 1 of LibFoo, but another
application requires version 2. How can you use both these applications? If you
install everything into /usr/lib/python3.6/site-packages (or whatever your
platform’s standard location is), it’s easy to end up in a situation where you
unintentionally upgrade an application that shouldn’t be upgraded.

Or more generally, what if you want to install an application and leave it be?
If an application works, any change in its libraries or the versions of those
libraries can break the application.

Also, what if you can’t install packages into the
global site-packages directory? For instance, on a shared host.

In all these cases, virtual environments can help you. They have their own
installation directories and they don’t share libraries with other virtual
environments.

Currently, there are two common tools for creating Python virtual environments:

• venv is available by default in Python 3.3 and later, and installs
  pip into created virtual environments in Python 3.4 and later
  (Python versions prior to 3.12 also installed Setuptools).

• virtualenv needs to be installed separately, but supports Python 2.7+
  and Python 3.3+, and pip, Setuptools and wheel are
  installed into created virtual environments by default. Note that setuptools is no longer
  included by default starting with Python 3.12 (and virtualenv follows this behavior).

The basic usage is like so:

Using venv:

python3 -m venv <DIR>
source <DIR>/bin/activate

py -m venv <DIR>
<DIR>\Scripts\activate

Using virtualenv:

python3 -m virtualenv <DIR>
source <DIR>/bin/activate

virtualenv <DIR>
<DIR>\Scripts\activate

For more information, see the venv docs or
the virtualenv docs.

The use of source under Unix shells ensures
that the virtual environment’s variables are set within the current
shell, and not in a subprocess (which then disappears, having no
useful effect).

In both of the above cases, Windows users should not use the
source command, but should rather run the activate
script directly from the command shell like so:

Managing multiple virtual environments directly can become tedious, so the
dependency management tutorial introduces a
higher level tool, Pipenv, that automatically manages a separate
virtual environment for each project and application that you work on.

Use pip for Installing¶

pip is the recommended installer. Below, we’ll cover the most common
usage scenarios. For more detail, see the pip docs,
which includes a complete Reference Guide.

Installing from PyPI¶

The most common usage of pip is to install from the Python Package
Index using a requirement specifier. Generally speaking, a requirement specifier is
composed of a project name followed by an optional version specifier. A full description of the supported specifiers can be
found in the Version specifier specification.
Below are some examples.

To install the latest version of “SomeProject”:

python3 -m pip install "SomeProject"

py -m pip install "SomeProject"

To install a specific version:

python3 -m pip install "SomeProject==1.4"

py -m pip install "SomeProject==1.4"

To install greater than or equal to one version and less than another:

python3 -m pip install "SomeProject>=1,<2"

py -m pip install "SomeProject>=1,<2"

To install a version that’s compatible
with a certain version: [4]

python3 -m pip install "SomeProject~=1.4.2"

py -m pip install "SomeProject~=1.4.2"

In this case, this means to install any version “==1.4.*” version that’s also
“>=1.4.2”.

Source Distributions vs Wheels¶

pip can install from either Source Distributions (sdist) or Wheels, but if both are present
on PyPI, pip will prefer a compatible wheel. You can override
pip`s default behavior by e.g. using its –no-binary option.

Wheels are a pre-built distribution format that provides faster installation compared to Source
Distributions (sdist), especially when a
project contains compiled extensions.

If pip does not find a wheel to install, it will locally build a wheel
and cache it for future installs, instead of rebuilding the source distribution
in the future.

Upgrading packages¶

Upgrade an already installed SomeProject to the latest from PyPI.

python3 -m pip install --upgrade SomeProject

py -m pip install --upgrade SomeProject

Installing to the User Site¶

To install packages that are isolated to the
current user, use the --user flag:

python3 -m pip install --user SomeProject

py -m pip install --user SomeProject

For more information see the User Installs section
from the pip docs.

Note that the --user flag has no effect when inside a virtual environment
— all installation commands will affect the virtual environment.

If SomeProject defines any command-line scripts or console entry points,
--user will cause them to be installed inside the user base’s binary
directory, which may or may not already be present in your shell’s
PATH. (Starting in version 10, pip displays a warning when
installing any scripts to a directory outside PATH.) If the scripts
are not available in your shell after installation, you’ll need to add the
directory to your PATH:

• On Linux and macOS you can find the user base binary directory by running
  python -m site --user-base and adding bin to the end. For example,
  this will typically print ~/.local (with ~ expanded to the absolute
  path to your home directory) so you’ll need to add ~/.local/bin to your
  PATH. You can set your PATH permanently by modifying ~/.profile.

• On Windows you can find the user base binary directory by running py -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
  C:\Users\Username\AppData\Roaming\Python36\Scripts. You can set your user
  PATH permanently in the Control Panel. You may need to log out for the
  PATH changes to take effect.

Requirements files¶

Install a list of requirements specified in a Requirements File.

python3 -m pip install -r requirements.txt

py -m pip install -r requirements.txt

Installing from VCS¶

Install a project from VCS in “editable” mode. For a full breakdown of the
syntax, see pip’s section on VCS Support.

python3 -m pip install -e SomeProject @ git+https://git.repo/some_pkg.git          # from git
python3 -m pip install -e SomeProject @ hg+https://hg.repo/some_pkg                # from mercurial
python3 -m pip install -e SomeProject @ svn+svn://svn.repo/some_pkg/trunk/         # from svn
python3 -m pip install -e SomeProject @ git+https://git.repo/some_pkg.git@feature  # from a branch

py -m pip install -e SomeProject @ git+https://git.repo/some_pkg.git          # from git
py -m pip install -e SomeProject @ hg+https://hg.repo/some_pkg                # from mercurial
py -m pip install -e SomeProject @ svn+svn://svn.repo/some_pkg/trunk/         # from svn
py -m pip install -e SomeProject @ git+https://git.repo/some_pkg.git@feature  # from a branch

Installing from other Indexes¶

Install from an alternate index

python3 -m pip install --index-url http://my.package.repo/simple/ SomeProject

py -m pip install --index-url http://my.package.repo/simple/ SomeProject

Search an additional index during install, in addition to PyPI

python3 -m pip install --extra-index-url http://my.package.repo/simple SomeProject

py -m pip install --extra-index-url http://my.package.repo/simple SomeProject

Installing from a local src tree¶

Installing from local src in
Development Mode,
i.e. in such a way that the project appears to be installed, but yet is
still editable from the src tree.

python3 -m pip install -e <path>

py -m pip install -e <path>

You can also install normally from src

python3 -m pip install <path>

Installing from local archives¶

Install a particular source archive file.

python3 -m pip install ./downloads/SomeProject-1.0.4.tar.gz

py -m pip install ./downloads/SomeProject-1.0.4.tar.gz

Install from a local directory containing archives (and don’t check PyPI)

python3 -m pip install --no-index --find-links=file:///local/dir/ SomeProject
python3 -m pip install --no-index --find-links=/local/dir/ SomeProject
python3 -m pip install --no-index --find-links=relative/dir/ SomeProject

py -m pip install --no-index --find-links=file:///local/dir/ SomeProject
py -m pip install --no-index --find-links=/local/dir/ SomeProject
py -m pip install --no-index --find-links=relative/dir/ SomeProject

Installing from other sources¶

To install from other data sources (for example Amazon S3 storage)
you can create a helper application that presents the data
in a format compliant with the simple repository API:,
and use the --extra-index-url flag to direct pip to use that index.

./s3helper --port=7777
python -m pip install --extra-index-url http://localhost:7777 SomeProject

Installing Prereleases¶

Find pre-release and development versions, in addition to stable versions. By
default, pip only finds stable versions.

python3 -m pip install --pre SomeProject

py -m pip install --pre SomeProject