# Django 1.8.18.dev20170123152445 documentation

# The staticfiles app

`django.contrib.staticfiles` collects static files from each of your applications (and any other places you specify) into a single location that can easily be served in production.

See also

For an introduction to the static files app and some usage examples, see Managing static files (e.g. images, JavaScript, CSS). For guidelines on deploying static files, see Deploying static files.

## Settings

See staticfiles settings for details on the following settings:

- `STATIC_ROOT`
- `STATIC_URL`
- `STATICFILES_DIRS`
- `STATICFILES_STORAGE`
- `STATICFILES_FINDERS`

## Management Commands

`django.contrib.staticfiles` exposes three management commands.

### collectstatic

`django-admin collectstatic`

Collects the static files into `STATIC_ROOT`.

Duplicate file names are by default resolved in a similar way to how template resolution works: the file that is first found in one of the specified locations will be used. If you’re confused, the `findstatic` command can help show you which files are found.

On subsequent `collectstatic` runs (if `STATIC_ROOT` isn’t empty), files are copied only if they have a modified timestamp greater than the timestamp of the file in `STATIC_ROOT`. Therefore if you remove an application from `INSTALLED_APPS`, it’s a good idea to use the `--clear` option in order to remove stale static files.

Files are searched by using the `enabled finders`. The default is to look in all locations defined in `STATICFILES_DIRS` and in the `'static'` directory of apps specified by the `INSTALLED_APPS` setting.

The `collectstatic` management command calls the `post_process()` method of the `STATICFILES_STORAGE` after each run and passes a list of paths that have been found by the management command. It also receives all command line options of `collectstatic`. This is used by the `CachedStaticFilesStorage` by default.

By default, collected files receive permissions from `FILE_UPLOAD_PERMISSIONS` and collected directories receive permissions from `FILE_UPLOAD_DIRECTORY_PERMISSIONS`. If you would like different permissions for these files and/or directories, you can subclass either of the static files storage classes and specify the `file_permissions_mode` and/or `directory_permissions_mode` parameters, respectively. For example:

    from django.contrib.staticfiles import storage

    class MyStaticFilesStorage(storage.StaticFilesStorage):
        def __init__(self, *args, **kwargs):
            kwargs['file_permissions_mode'] = 0o640
            kwargs['directory_permissions_mode'] = 0o760
            super(MyStaticFilesStorage, self).__init__(*args, **kwargs)

Then set the `STATICFILES_STORAGE` setting to `'path.to.MyStaticFilesStorage'`.

The ability to override `file_permissions_mode` and `directory_permissions_mode` is new in Django 1.7. Previously the file permissions always used `FILE_UPLOAD_PERMISSIONS` and the directory permissions always used `FILE_UPLOAD_DIRECTORY_PERMISSIONS`.

Some commonly used options are:

`--noinput```

  Do NOT prompt the user for input of any kind.

`-i``<pattern>`

`--ignore``<pattern>`

  Ignore files or directories matching this glob-style pattern. Use multiple times to ignore more.

`-n```

`--dry-run```

  Do everything except modify the filesystem.

`-c```

`--clear```

  Clear the existing files before trying to copy or link the original file.

`-l```

`--link```

  Create a symbolic link to each file instead of copying.

`--no-post-process```

  Don’t call the `post_process()` method of the configured `STATICFILES_STORAGE` storage backend.

`--no-default-ignore```

  Don’t ignore the common private glob-style patterns `'CVS'`, `'.*'` and `'*~'`.

For a full list of options, refer to the commands own help by running:

    $ python manage.py collectstatic --help

### findstatic

`django-admin findstatic`

Searches for one or more relative paths with the enabled finders.

For example:

    $ python manage.py findstatic css/base.css admin/js/core.js
    Found 'css/base.css' here:
      /home/special.polls.com/core/static/css/base.css
      /home/polls.com/core/static/css/base.css
    Found 'admin/js/core.js' here:
      /home/polls.com/src/django/contrib/admin/media/js/core.js

By default, all matching locations are found. To only return the first match for each relative path, use the `--first` option:

    $ python manage.py findstatic css/base.css --first
    Found 'css/base.css' here:
      /home/special.polls.com/core/static/css/base.css

This is a debugging aid; it’ll show you exactly which static file will be collected for a given path.

By setting the `--verbosity` flag to 0, you can suppress the extra output and just get the path names:

    $ python manage.py findstatic css/base.css --verbosity 0
    /home/special.polls.com/core/static/css/base.css
    /home/polls.com/core/static/css/base.css

On the other hand, by setting the `--verbosity` flag to 2, you can get all the directories which were searched:

    $ python manage.py findstatic css/base.css --verbosity 2
    Found 'css/base.css' here:
      /home/special.polls.com/core/static/css/base.css
      /home/polls.com/core/static/css/base.css
    Looking in the following locations:
      /home/special.polls.com/core/static
      /home/polls.com/core/static
      /some/other/path/static

The additional output of which directories were searched was added.

### runserver

`django-admin runserver`

Overrides the core `runserver` command if the `staticfiles` app is `installed` and adds automatic serving of static files and the following new options.

`--nostatic```

Use the `--nostatic` option to disable serving of static files with the staticfiles app entirely. This option is only available if the staticfiles app is in your project’s `INSTALLED_APPS` setting.

Example usage:

    django-admin runserver --nostatic

`--insecure```

Use the `--insecure` option to force serving of static files with the staticfiles app even if the `DEBUG` setting is `False`. By using this you acknowledge the fact that it’s grossly inefficient and probably insecure. This is only intended for local development, should never be used in production and is only available if the staticfiles app is in your project’s `INSTALLED_APPS` setting. `runserver` `--insecure` doesn’t work with `CachedStaticFilesStorage`.

Example usage:

    django-admin runserver --insecure

## Storages

### StaticFilesStorage

class `storage.``StaticFilesStorage`

A subclass of the `FileSystemStorage` storage backend that uses the `STATIC_ROOT` setting as the base file system location and the `STATIC_URL` setting respectively as the base URL.

`storage.StaticFilesStorage.``post_process`(paths, **options)

This method is called by the `collectstatic` management command after each run and gets passed the local storages and paths of found files as a dictionary, as well as the command line options.

The `CachedStaticFilesStorage` uses this behind the scenes to replace the paths with their hashed counterparts and update the cache appropriately.

### ManifestStaticFilesStorage

class `storage.``ManifestStaticFilesStorage`

A subclass of the `StaticFilesStorage` storage backend which stores the file names it handles by appending the MD5 hash of the file’s content to the filename. For example, the file `css/styles.css` would also be saved as `css/styles.55e7cbb9ba48.css`.

The purpose of this storage is to keep serving the old files in case some pages still refer to those files, e.g. because they are cached by you or a 3rd party proxy server. Additionally, it’s very helpful if you want to apply far future Expires headers to the deployed files to speed up the load time for subsequent page visits.

The storage backend automatically replaces the paths found in the saved files matching other saved files with the path of the cached copy (using the `post_process()` method). The regular expressions used to find those paths (`django.contrib.staticfiles.storage.HashedFilesMixin.patterns`) by default covers the @import rule and url() statement of Cascading Style Sheets. For example, the `'css/styles.css'` file with the content

    @import url("../admin/css/base.css");

would be replaced by calling the `url()` method of the `ManifestStaticFilesStorage` storage backend, ultimately saving a `'css/styles.55e7cbb9ba48.css'` file with the following content:

    @import url("../admin/css/base.27e20196a850.css");

To enable the `ManifestStaticFilesStorage` you have to make sure the following requirements are met:

- the `STATICFILES_STORAGE` setting is set to `'django.contrib.staticfiles.storage.ManifestStaticFilesStorage'`
- the `DEBUG` setting is set to `False`
- you use the `staticfiles` `static` template tag to refer to your static files in your templates
- you’ve collected all your static files by using the `collectstatic` management command

Since creating the MD5 hash can be a performance burden to your website during runtime, `staticfiles` will automatically store the mapping with hashed names for all processed files in a file called `staticfiles.json`. This happens once when you run the `collectstatic` management command.

Due to the requirement of running `collectstatic`, this storage typically shouldn’t be used when running tests as `collectstatic` isn’t run as part of the normal test setup. During testing, ensure that the `STATICFILES_STORAGE` setting is set to something else like `'django.contrib.staticfiles.storage.StaticFilesStorage'` (the default).

`storage.ManifestStaticFilesStorage.``file_hash`(name, content=None)

The method that is used when creating the hashed name of a file. Needs to return a hash for the given file name and content. By default it calculates a MD5 hash from the content’s chunks as mentioned above. Feel free to override this method to use your own hashing algorithm.

### CachedStaticFilesStorage

class `storage.``CachedStaticFilesStorage`

`CachedStaticFilesStorage` is a similar class like the `ManifestStaticFilesStorage` class but uses Django’s caching framework for storing the hashed names of processed files instead of a static manifest file called `staticfiles.json`. This is mostly useful for situations in which you don’t have access to the file system.

If you want to override certain options of the cache backend the storage uses, simply specify a custom entry in the `CACHES` setting named `'staticfiles'`. It falls back to using the `'default'` cache backend.

## Template tags

### static

Uses the configured `STATICFILES_STORAGE` storage to create the full URL for the given relative path, e.g.:

    {% load static from staticfiles %}
    <img src="{% static "images/hi.jpg" %}" alt="Hi!" />

The previous example is equal to calling the `url` method of an instance of `STATICFILES_STORAGE` with `"images/hi.jpg"`. This is especially useful when using a non-local storage backend to deploy files as documented in Serving static files from a cloud service or CDN.

If you’d like to retrieve a static URL without displaying it, you can use a slightly different call:

    {% load static from staticfiles %}
    {% static "images/hi.jpg" as myphoto %}
    <img src="{{ myphoto }}" alt="Hi!" />

Using Jinja2 templates?

See `django.template.backends.jinja2.Jinja2` for information on using the `static` tag with Jinja2.

## Finders Module

`staticfiles` finders has a `searched_locations` attribute which is a list of directory paths in which the finders searched. Example usage:

    from django.contrib.staticfiles import finders

    result = finders.find('css/base.css')
    searched_locations = finders.searched_locations

The `searched_locations` attribute was added.

## Other Helpers

There are a few other helpers outside of the `staticfiles` app to work with static files:

- The `django.template.context_processors.static()` context processor which adds `STATIC_URL` to every template context rendered with `RequestContext` contexts.
- The builtin template tag `static` which takes a path and urljoins it with the static prefix `STATIC_URL`.
- The builtin template tag `get_static_prefix` which populates a template variable with the static prefix `STATIC_URL` to be used as a variable or directly.
- The similar template tag `get_media_prefix` which works like `get_static_prefix` but uses `MEDIA_URL`.

### Static file development view

The static files tools are mostly designed to help with getting static files successfully deployed into production. This usually means a separate, dedicated static file server, which is a lot of overhead to mess with when developing locally. Thus, the `staticfiles` app ships with a quick and dirty helper view that you can use to serve files locally in development.

`views.``serve`(request, path)

This view function serves static files in development.

Warning

This view will only work if `DEBUG` is `True`.

That’s because this view is grossly inefficient and probably insecure. This is only intended for local development, and should never be used in production.

This view will now raise an `Http404` exception instead of `ImproperlyConfigured` when `DEBUG` is `False`.

Note

To guess the served files’ content types, this view relies on the `mimetypes` module from the Python standard library, which itself relies on the underlying platform’s map files. If you find that this view doesn’t return proper content types for certain files, it is most likely that the platform’s map files need to be updated. This can be achieved, for example, by installing or updating the `mailcap` package on a Red Hat distribution, or `mime-support` on a Debian distribution.

This view is automatically enabled by `runserver` (with a `DEBUG` setting set to `True`). To use the view with a different local development server, add the following snippet to the end of your primary URL configuration:

    from django.conf import settings
    from django.contrib.staticfiles import views

    if settings.DEBUG:
        urlpatterns += [
            url(r'^static/(?P<path>.*)$', views.serve),
        ]

Note, the beginning of the pattern (`r'^static/'`) should be your `STATIC_URL` setting.

Since this is a bit finicky, there’s also a helper function that’ll do this for you:

`urls.``staticfiles_urlpatterns`()

This will return the proper URL pattern for serving static files to your already defined pattern list. Use it like this:

    from django.contrib.staticfiles.urls import staticfiles_urlpatterns

    # ... the rest of your URLconf here ...

    urlpatterns += staticfiles_urlpatterns()

This will inspect your `STATIC_URL` setting and wire up the view to serve static files accordingly. Don’t forget to set the `STATICFILES_DIRS` setting appropriately to let `django.contrib.staticfiles` know where to look for files in addition to files in app directories.

Warning

This helper function will only work if `DEBUG` is `True` and your `STATIC_URL` setting is neither empty nor a full URL such as `http://static.example.com/`.

That’s because this view is grossly inefficient and probably insecure. This is only intended for local development, and should never be used in production.

### Specialized test case to support ‘live testing’

class `testing.``StaticLiveServerTestCase`

This unittest TestCase subclass extends `django.test.LiveServerTestCase`.

Just like its parent, you can use it to write tests that involve running the code under test and consuming it with testing tools through HTTP (e.g. Selenium, PhantomJS, etc.), because of which it’s needed that the static assets are also published.

But given the fact that it makes use of the `django.contrib.staticfiles.views.serve()` view described above, it can transparently overlay at test execution-time the assets provided by the `staticfiles` finders. This means you don’t need to run `collectstatic` before or as a part of your tests setup.

`StaticLiveServerTestCase` is new in Django 1.7. Previously its functionality was provided by `django.test.LiveServerTestCase`.