Skip Navigation
Show nav
Heroku Dev Center
  • Get Started
  • Documentation
  • Changelog
  • Search
  • Get Started
    • Node.js
    • Ruby on Rails
    • Ruby
    • Python
    • Java
    • PHP
    • Go
    • Scala
    • Clojure
  • Documentation
  • Changelog
  • More
    Additional Resources
    • Home
    • Elements
    • Products
    • Pricing
    • Careers
    • Help
    • Status
    • Events
    • Podcasts
    • Compliance Center
    Heroku Blog

    Heroku Blog

    Find out what's new with Heroku on our blog.

    Visit Blog
  • Log inorSign up
View categories

Categories

  • Heroku Architecture
    • Dynos (app containers)
    • Stacks (operating system images)
    • Networking & DNS
    • Platform Policies
    • Platform Principles
  • Command Line
  • Deployment
    • Deploying with Git
    • Deploying with Docker
    • Deployment Integrations
  • Continuous Delivery
    • Continuous Integration
  • Language Support
    • Node.js
    • Ruby
      • Rails Support
      • Working with Bundler
    • Python
      • Background Jobs in Python
      • Working with Django
    • Java
      • Working with Maven
      • Java Database Operations
      • Working with the Play Framework
      • Working with Spring Boot
      • Java Advanced Topics
    • PHP
    • Go
      • Go Dependency Management
    • Scala
    • Clojure
  • Databases & Data Management
    • Heroku Postgres
      • Postgres Basics
      • Postgres Getting Started
      • Postgres Performance
      • Postgres Data Transfer & Preservation
      • Postgres Availability
      • Postgres Special Topics
    • Heroku Data For Redis
    • Apache Kafka on Heroku
    • Other Data Stores
  • Monitoring & Metrics
    • Logging
  • App Performance
  • Add-ons
    • All Add-ons
  • Collaboration
  • Security
    • App Security
    • Identities & Authentication
    • Compliance
  • Heroku Enterprise
    • Private Spaces
      • Infrastructure Networking
    • Enterprise Accounts
    • Enterprise Teams
    • Heroku Connect (Salesforce sync)
      • Heroku Connect Administration
      • Heroku Connect Reference
      • Heroku Connect Troubleshooting
    • Single Sign-on (SSO)
  • Patterns & Best Practices
  • Extending Heroku
    • Platform API
    • App Webhooks
    • Heroku Labs
    • Building Add-ons
      • Add-on Development Tasks
      • Add-on APIs
      • Add-on Guidelines & Requirements
    • Building CLI Plugins
    • Developing Buildpacks
    • Dev Center
  • Accounts & Billing
  • Troubleshooting & Support
  • Integrating with Salesforce
  • Language Support
  • Python
  • Python Dependencies via Pip

Python Dependencies via Pip

English — 日本語に切り替える

Last updated November 11, 2022

Table of Contents

  • The basics
  • Best practices
  • Git-backed distributions
  • Remote file-backed distributions
  • Local file-backed distributions
  • Private indexes
  • Cascading requirements files
  • Traditional distributions

This guide outlines how to fully utilize Heroku’s support for specifying dependencies for your Python application via pip.

Heroku’s pip support is very transparent. Any requirements that install locally with the following command will behave as expected on Heroku:

$ pip install -r requirements.txt

The basics

To specify Python package dependencies on Heroku via pip, add a pip requirements file named requirements.txt to the root of your repository.

Example requirements.txt:

Flask==0.8
Jinja2==2.6
Werkzeug==0.8.3
certifi==0.0.8
chardet==1.0.1
distribute==0.6.24
gunicorn==0.14.2
requests==0.11.1

Best practices

If you follow these simple recommendations, your application builds will be deterministic:

  • All package versions should be explicitly specified.
  • All secondary dependencies should be explicitly specified.

This will ensure consistent build behavior when newer package versions are released.

Git-backed distributions

Anything that works with a standard pip requirements file will work as expected on Heroku.

Thanks to pip’s Git support, you can install a Python package that is hosted on a remote Git repository.

For example:

git+https://github.com/certifi/python-certifi

If your package is hosted in a private Git repository, you can use HTTP Basic Authentication:

git+https://user:password@github.com/nsa/secret.git

You can also specify any Git reference (e.g. branch, tag, or commit) by appending an @ to your URL:

git+https://github.com/certifi/python-certifi@develop

Optionally, you can install a dependency in “editable” mode, which will link to a full clone of the repository. This is recommended for Git-backed distributions that rely on upstream changes, as well as larger repositories.

The egg fragment is only valid with editable requirements.

-e git+https://github.com/django/django.git#egg=django

Remote file-backed distributions

You can also install packages from remote archives.

For example:

https://site.org/files/package.zip

This can be useful in many situations. For example, you can utilize GitHub’s tarball generation for repositories with large histories:

https://github.com/django/django/tarball/master

Local file-backed distributions

Pip can also install a dependency from your local codebase. This is useful with making custom tweaks to an existing package.

You can use Git Submodules to maintain separate repositories for your File-backed dependencies. Git modules will automatically be resolved when you push your code to Heroku.

To add a local dependency in requirements.txt, specify the relative path to the directory containing setup.py:

./path/to/distribution

If you make changes to the library without bumping the required version number, however, the changes will not be updated at runtime. You can get around this by installing the package in editable mode:

-e ./path/to/distribution

Private indexes

In order to minimize points of failure, it is considered best practice within the Python community for development shops to host their own instances of the “Cheeseshop” containing their dependencies.

To point to a custom Cheeseshop’s index, you can add the following to the top of your requirements file:

-i https://pypi.python.org/simple/

All dependencies specified in that requirements file will resolve against that index.

Cascading requirements files

If you would like to utilize multiple requirements files in your codebase, you can include the contents of another requirements file with pip:

-r ./path/to/prod-requirements.txt

We do not recommend this approach, but it is available to you.

Traditional distributions

Heroku also supports traditional Python package distribution, powered by setup.py.

If your Python application contains a setup.py file but excludes a requirements.txt file, python setup.py develop will be used to install your package and resolve your dependencies.

This works best with setuptools. Projects that use distutils directly will be installed, but not linked. The module won’t get updated until there’s a version bump.

If you already have a requirements file, but would like to utilize this feature, you can add the following to your requirements file:

-e .

This causes pip to run python setup.py develop on your application.

Keep reading

  • Python

Feedback

Log in to submit feedback.

Specifying a Python Runtime Scaling a Flask Application with Memcache

Information & Support

  • Getting Started
  • Documentation
  • Changelog
  • Compliance Center
  • Training & Education
  • Blog
  • Podcasts
  • Support Channels
  • Status

Language Reference

  • Node.js
  • Ruby
  • Java
  • PHP
  • Python
  • Go
  • Scala
  • Clojure

Other Resources

  • Careers
  • Elements
  • Products
  • Pricing

Subscribe to our monthly newsletter

Your email address:

  • RSS
    • Dev Center Articles
    • Dev Center Changelog
    • Heroku Blog
    • Heroku News Blog
    • Heroku Engineering Blog
  • Heroku Podcasts
  • Twitter
    • Dev Center Articles
    • Dev Center Changelog
    • Heroku
    • Heroku Status
  • Facebook
  • Instagram
  • Github
  • LinkedIn
  • YouTube
Heroku is acompany

 © Salesforce.com

  • heroku.com
  • Terms of Service
  • Privacy
  • Cookies
  • Cookie Preferences