Google Cloud Platform

Libraries in Python 2.7

By default, the App Engine Python 2.7 runtime environment includes the Python standard library, the App Engine libraries, and a few bundled third-party packages. You can add third-party libraries to your app in one of two ways:

  • Request the library using the libraries: directive in app.yaml.
  • Install the library into a folder in your project's source directory.
    • The library must be implemented as pure Python code (no C extensions).
    • The code is uploaded to App Engine with your application code, and counts toward file quotas.
    • Use pip to install the library and the vendor module to enable importing packages from the third-party library directory


Runtime-Provided Libraries

The App Engine python runtime can provide your application with the following third-party libraries:

NameDefault versionSupported versionsDescription
django (None) "1.2"
"1.5" (alpha)
A full-featured web application framework for Python.
endpoints (None) "1.0"
Libraries for building APIs in an App Engine application.
jinja2 (None) "2.6"
A modern and designer friendly templating language for Python.
lxml (None) "2.3"
"2.3.5" (alpha)
A Pythonic binding for the C libraries libxml2 and libxslt.
markupsafe (None) "0.15"
A XML/HTML/XHTML markup safe string for Python.
matplotlib (None) "1.2.0"
A 2D plotting library which produces publication-quality figures.
MySQLdb (None) "1.2.4b4" (alpha)
"1.2.4" (alpha)
"1.2.5" (alpha)
A Python DB API v2.0 compatible interface to MySQL.
numpy (None) "1.6.1"
A general-purpose library for array-processing.
PIL (None) "1.1.7"
A library for creating and transforming images.
protorpc "1.0" "1.0"
A framework for implementing HTTP-based remote procedure call (RPC) services.
crcmod (None) "1.7"
A library for generating Cyclic Redundancy Checks (CRC).
PyAMF (None) "0.6.1"
"0.7.2" (alpha)
A library that provides (AMF) Action Message Format functionality.
pycrypto (None) "2.3"
A library of cryptography functions such as random number generation.
setuptools (None) "0.6c11"
A library that provides package and module discovery capabilities.
ssl (None) "2.7"
The SSL socket wrapper built-in module.
webapp2 "2.3" "2.3" (deprecated)
A lightweight Python web framework.
webob "1.1.1" "1.1.1"
A library that provides wrappers around the WSGI request environment.
yaml "3.10" "3.10"
A library for YAML serialization and deserialization.

You request a library using the libraries section of app.yaml:

- name: PIL
  version: "1.1.7"
- name: webob
  version: "1.1.1"

Using Runtime-Provided Libraries with the Local Development Server

While several of the runtime-provided libraries are available to your local development environment via the App Engine SDK, the following libraries are platform-dependent and must be installed locally before you can use them with the development server:

The pip command can be used to install all of these packages from the Python package index (PyPI).

$ sudo pip install lxml==2.3.5

Depending on your platform, you may need to install build support tools and python sources to install these libraries. On Linux, the package manager can provide these prerequisites and can often provide a pre-built version of the library. On Windows, installers for pre-built versions are usually available. On OS X, the Xcode Command Line Tools are required to build some packages.

Note: the development server will use the package version you have installed locally regardless of the version specified in app.yaml. If desired, you can set up a virtualenv for your project to provide the exact package version. Note that the virtualenv is only used for these binary packages locally and will not be made available to your application once deployed. To add additional third-party libraries, use vendoring.

Adding Third-party Packages to the Application

You can add any third-party library to your application, as long as it is implemented in "pure Python" (no C extensions) and otherwise functions in the App Engine runtime environment. The easiest way to manage this is with a ./lib directory.

Create a directory named lib in your application root directory:

mkdir lib

To tell your app how to find libraries in this directory, create (or modify) a file named in the root of your project, then add these lines:

from google.appengine.ext import vendor

# Add any libraries installed in the "lib" folder.

Use pip with the -t lib flag to install libraries in this directory:

$ pip install -t lib gcloud

Note: pip version 6.0.0 or higher is required for vendor to work properly.

Tip: the above assumes that the current working directory is where the lib folder is located. In some cases, such as unit tests, the current working directory can be different. To avoid errors, you can explicity pass in the full path to the lib folder using vendor.add(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'lib'))

Using pip Requirements Files

pip can read a list of libraries to install from a file, known as a requirements file. Requirements files make it easy to set up a new development environment for your app, and upgrade to new versions of libraries.

A requirements file is a text file with one line per library, listing the package name and version:


To install the libraries from a requirements file, use the -r flag in addition to the -t lib flag:

$ pip install -t lib -r requirements.txt

Django Notes

Warning: Support for Django versions 1.2 and 1.3 has been deprecated and is going to be removed. See the Django 1.2, 1.3 Turndown document for details and timetable.

Django is a full-featured web application framework for Python. It provides a full stack of interchangable components, including dispatch, views, middleware, and templating components, and many others.

The Django data modeling interface is not compatible with the App Engine datastore. You can use the App Engine data modeling libraries (db or ndb) in your Django applications. However, third-party Django applications that use the Django data modeling interface—most notably Django's Admin application—may not work with App Engine directly.

To use Django with the NDB storage API, add 'google.appengine.ext.ndb.django_middleware.NdbDjangoMiddleware', to the MIDDLEWARE_CLASSES entry in your Django file. It's best to insert it in front of any other middleware classes, since some other middleware may make datastore calls and those won't be handled properly if that middleware is invoked before this middleware. (You can learn more about Django middleware.)

To use Django, specify the WSGI application and Django library in app.yaml:

- url: /.*
  script:  # a WSGI application in the main module's global scope

- name: django
  version: "1.4"

The DJANGO_SETTINGS_MODULE environment variable must be set to the name of your Django settings module, typically 'settings', before packages are imported.

If your Django settings module is something other than, set the DJANGO_SETTINGS_MODULE environment variable accordingly either in your app.yaml file:

  DJANGO_SETTINGS_MODULE: 'myapp.settings'

or in your Python code:

import os
# specify the name of your settings module
os.environ['DJANGO_SETTINGS_MODULE'] = 'myapp.settings'

import django.core.handlers.wsgi
app = django.core.handlers.wsgi.WSGIHandler()

Matplotlib Notes

Note: The experimental release of matplotlib is not supported on the development server. You can still add matplotlib to the libraries list, but it will raise an ImportError exception when imported.

Matplotlib is a plotting library that produces graphs and figures in a variety of image formats. On App Engine, the interactive modes of matplotlib are not supported, and a number of other features are also unavailable. This means you cannot use as many matplotlib tutorials suggest. Instead, you should use pyplot.savefig() to write image data to the output stream, a cStringIO.StringIO instance, or the Google Cloud Storage using the Cloud Storage Client Library.

Matplotlib allows extensive customization through the use of the matplotlibrc configuration file, which should be placed in the application's top-level directory. Alternatively, you can set the MATPLOTLIBRC environment variable to a path relative to your application's directory.

The default backend is AGG, which allows writing files of all supported formats: PNG (the default format), RAW, PS, PDF, SVG and SVGZ. If you make the PIL library available by adding PIL to the libraries section of app.yaml, then the AGG backend will automatically support writing JPEG and TIFF image formats as well.

Matplotlib comes with a number of fonts which are automatically available. You can use custom fonts by uploading them (in TTF format) along with your application, and setting the TTFPATH environment variable to the path where they are located, relative to your application's directory. (See Defining Environment Variables.)

A number of matplotlib features are not supported on App Engine. In particular:

  • There is no ~/.matplotlib directory (however, there are alternative locations to place the matplotlibrc configuration file, as described above).
  • Interactive backends and GUI elements are not supported.
  • The EMF, Cairo and GDK backends are not supported.
  • There is no caching, and therefore a number of mechanisms will re-calculate or re-download data that would normally be cached. Specific caching mechanisms that have been disabled include font data (calculated by matplotlib.font_manager.FontManager.findfont), sample data (downloaded by matplotlib.cbook.get_sample_data) and financial data (downloaded by
  • All features that invoke external commands have been disabled.
    • Use of fontconfig has been disabled. Fonts are found through the mechanism described above.
    • Use of LaTeX for text rendering is not supported. Setting text.usetex to True will not work.
    • Use of an external PostScript distiller program is not supported. Setting ps.usedistiller to ghostscript or xpdf will not work.
    • Use of an external video encoding program is not supported. The method will not work, and therefore, the matplotlib.animation package is not useful.
    • The matplotlib.cbook.report_memory function and matplotlib.cbook.MemoryMonitor class are not supported.
  • The matplotlib.test function has been disabled.

Note: The pylab and matplotlib.pyplot modules are stateful and not thread-safe. If you use them on App Engine, you must set threadsafe: false in app.yaml, and be aware that the plotter state will be preserved between requests on the same instance. For example, you will need to call pyplot.clf() at the beginning of each request to ensure that previous plots are not visible. It is recommended that you use the thread-safe object-oriented API instead of the stateful pyplot API.