Using third-party libraries

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.

Homebrew issues

If you are using Homebrew
Python on OS X, 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.cfg file
in your home directory with the following:

[install]
prefix=

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.py in the same folder as your
app.yaml file.

Edit the appengine_config.py file and provide your library directory to the
vendor.add() method.

The appengine_config.py file 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 explicitly pass in the full path to the lib folder using:

Using 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 version:

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
to the -t lib flag:

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. However, the following built-in
libraries must be installed locally before you can use them with the
local development server:

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 OS X, 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

Warning: Support for Django versions 1.2 and 1.3 is deprecated
and will 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 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
'google.appengine.ext.ndb.django_middleware.NdbDjangoMiddleware',
to the MIDDLEWARE_CLASSES entry in your Django
settings.py file.
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
project documentation.

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

Using matplotlib in the local development server

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
pyplot.show()
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. For more information,
see the app.yaml
reference.

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.

Because there is no caching, it is not possible to call
[matplotlib.cbook.get_sample_data](http://matplotlib.org/api/cbook_api.html#matplotlib.cbook.get_sample_data) with asfileobj=False unless examples.download is set to False.

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.

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.