You can use third-party libraries that are pure Python code with no C extensions, by copying the library into your application directory. If the third-party library is already built-in, bundled with the runtime, you can use the library without copying it into your app.
Third party libraries must be implemented as pure Python code with no C extensions. If copied to your application directory, they count towards file quotas because the library is uploaded to App Engine along with your application code.
Copying a third-party library
To use a third-party library that is not on the list of built-in libraries bundled with the runtime:
Create a directory to store your third-party libraries, such as
Use pip (version 6 or later) with the
-t <directory>flag to copy the libraries into the folder you created in the previous step. For example:
pip install -t lib/ <library_name>
If you are using Homebrew Python on macOS, you might encounter an exception when running
pip install -t. This problem is related to a known Homebrew installation issue (see
Note on pip install --user) with Homebrew's configuration of Python. To work around this issue, temporarily create a
~/.pydistutils.cfgfile in your home directory with the following:
Be sure to remove this file after installing packages for your App Engine application, as it will prevent you from being able to install packages outside of this context.
Create a file named
appengine_config.pyin the same folder as your
appengine_config.pyfile and provide your library directory to the
# appengine_config.py from google.appengine.ext import vendor # Add any libraries install in the "lib" folder. vendor.add('lib')
appengine_config.pyfile above assumes that the current working directory is where the
libfolder is located. In some cases, such as unit tests, the current working directory can be different. To avoid errors, you can explicitly pass in the full path to the
pip requirements files with copied libraries
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 optionally the version for the package (defaults to latest):
Flask==0.10 Markdown==2.5.2 google-api-python-client
To install the libraries from a requirements file, use the
-r flag in addition
-t lib flag:
pip install -t lib -r requirements.txt
Using a built-in third-party library bundled with the runtime
If the third-party library is on the list of
built-in libraries bundled with the App Engine Python runtime,
you only have to specify it under the
app.yaml, for example:
libraries: - name: PIL version: "1.1.7" - name: webob version: "1.1.1"
App Engine automatically provides the requested libraries during deployment.
Using built-in bundled libraries with the local development server
Many of the built-in libraries provided by the runtime are automatically
available to the local development server. In order to install some libraries
locally, you must run
gcloud components install app-engine-python-extras.
If the local development server detects that this component is needed, it will
prompt you to install it. The following built-in libraries must be installed
locally before you can use them with the local development server:
sudo pip install lxml==2.3.5
Depending on your platform, you might 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 macOS, the Xcode Command Line Tools are required to build some packages.
The development server uses the package version you have installed
locally regardless of the version specified in
app.yaml. If you want,
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
the method described in Installing a library.
Using Django in the local development server
Django is a full-featured web application framework for Python. It provides a full stack of interchangeable 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, might not directly work with App Engine.
The Datastore modeling library (DB) is the default. To use Django with the
NDB storage API instead, add
MIDDLEWARE_CLASSES entry in your Django
It's a good idea to insert it in front of any other middleware classes,
since some other middleware might 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 in the
To enable Django in your app, specify the WSGI application and Django library in
... handlers: - url: /.* script: main.app # a WSGI application in the main module's global scope libraries: - name: django version: "1.4"
DJANGO_SETTINGS_MODULE environment variable must be set to the name of
your Django settings module, typically
'settings', before packages are
If your Django settings module is something other than
settings.py, set the
DJANGO_SETTINGS_MODULE environment variable accordingly either in your
env_variables: 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 in the local development server
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
to write image data to the output stream, a
instance, or the Google Cloud Storage using the
Cloud Storage Client Library.
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
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
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. For more information,
A number of matplotlib features are not supported on App Engine. In particular:
- There is no
~/.matplotlibdirectory. However, there are alternative locations to place the
matplotlibrcconfiguration 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_dataand financial data downloaded by
- Because there is no caching, it is not possible to call
examples.downloadis set to
- Because there is no caching, it is not possible to call
- All features that invoke external commands have been disabled.
- Use of
fontconfighas been disabled. Fonts are found through the mechanism described above.
- Use of LaTeX for text rendering is not supported. Setting
Truewill not work.
- Use of an external PostScript distiller program is not supported. Setting
xpdfwill not work.
- Use of an external video encoding program is not supported. The
matplotlib.animation.Animation.savemethod will not work, and therefore, the
matplotlib.animationpackage is not useful.
matplotlib.cbook.MemoryMonitorclass are not supported.
- Use of
matplotlib.testfunction has been disabled.
- Learn more about the App Engine Python runtime environment.
- Review the built-in third-party libraries reference.