staticfiles appLink to this heading#django.contrib.staticfiles collects static files from each of your\napplications (and any other places you specify) into a single location that\ncan easily be served in production.
See staticfiles settings for details on the\nfollowing settings:
\n\ndjango.contrib.staticfiles exposes three management commands.
collectstaticLink to this heading#Collects the static files into STATIC_ROOT.
Duplicate file names are by default resolved in a similar way to how template\nresolution works: the file that is first found in one of the specified\nlocations will be used. If you’re confused, the findstatic command\ncan help show you which files are found.
On subsequent collectstatic runs (if STATIC_ROOT isn’t empty), files\nare copied only if they have a modified timestamp greater than the timestamp of\nthe file in STATIC_ROOT. Therefore if you remove an application from\nINSTALLED_APPS, it’s a good idea to use the collectstatic\n--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\nSTATICFILES_DIRS and in the 'static' directory of apps\nspecified by the INSTALLED_APPS setting.
The collectstatic management command calls the\npost_process()\nmethod of the STATICFILES_STORAGE after each run and passes\na list of paths that have been found by the management command. It also\nreceives all command line options of collectstatic. This is used\nby the ManifestStaticFilesStorage\nby default.
By default, collected files receive permissions from\nFILE_UPLOAD_PERMISSIONS and collected directories receive permissions\nfrom FILE_UPLOAD_DIRECTORY_PERMISSIONS. If you would like different\npermissions for these files and/or directories, you can subclass either of the\nstatic files storage classes and specify the\nfile_permissions_mode and/or directory_permissions_mode parameters,\nrespectively. For example:
from django.contrib.staticfiles import storage\n\nclass MyStaticFilesStorage(storage.StaticFilesStorage):\n def __init__(self, *args, **kwargs):\n kwargs['file_permissions_mode'] = 0o640\n kwargs['directory_permissions_mode'] = 0o760\n super().__init__(*args, **kwargs)\nThen set the STATICFILES_STORAGE setting to\n'path.to.MyStaticFilesStorage'.
Some commonly used options are:
\nDo NOT prompt the user for input of any kind.
\nIgnore files, directories, or paths matching this glob-style pattern. Use\nmultiple times to ignore more. When specifying a path, always use forward\nslashes, even on Windows.
\n\nDo everything except modify the filesystem.
\nClear the existing files before trying to copy or link the original file.
\nCreate a symbolic link to each file instead of copying.
\nDon’t call the\npost_process()\nmethod of the configured STATICFILES_STORAGE storage backend.
Don’t ignore the common private glob-style patterns 'CVS', '.*'\nand '*~'.
For a full list of options, refer to the commands own help by running:
\nLinux / macOS
$ python manage.py collectstatic --help\nWindows
...\\> py manage.py collectstatic --help\nThe default ignored pattern list, ['CVS', '.*', '*~'], can be customized in\na more persistent way than providing the --ignore command option at each\ncollectstatic invocation. Provide a custom AppConfig\nclass, override the ignore_patterns attribute of this class and replace\n'django.contrib.staticfiles' with that class path in your\nINSTALLED_APPS setting:
from django.contrib.staticfiles.apps import StaticFilesConfig\n\nclass MyStaticFilesConfig(StaticFilesConfig):\n ignore_patterns = [...] # your custom ignore list\nfindstaticLink to this heading#Searches for one or more relative paths with the enabled finders.
\nFor example:
\nLinux / macOS
$ python manage.py findstatic css/base.css admin/js/core.js\nFound 'css/base.css' here:\n /home/special.polls.com/core/static/css/base.css\n /home/polls.com/core/static/css/base.css\nFound 'admin/js/core.js' here:\n /home/polls.com/src/django/contrib/admin/media/js/core.js\nWindows
...\\> py manage.py findstatic css\\base.css admin\\js\\core.js\nFound 'css/base.css' here:\n /home/special.polls.com/core/static/css/base.css\n /home/polls.com/core/static/css/base.css\nFound 'admin/js/core.js' here:\n /home/polls.com/src/django/contrib/admin/media/js/core.js\nBy default, all matching locations are found. To only return the first match\nfor each relative path, use the --first option:
Linux / macOS
$ python manage.py findstatic css/base.css --first\nFound 'css/base.css' here:\n /home/special.polls.com/core/static/css/base.css\nWindows
...\\> py manage.py findstatic css\\base.css --first\nFound 'css/base.css' here:\n /home/special.polls.com/core/static/css/base.css\nThis is a debugging aid; it’ll show you exactly which static file will be\ncollected for a given path.
\nBy setting the --verbosity flag to 0, you can suppress the extra output and\njust get the path names:
Linux / macOS
$ python manage.py findstatic css/base.css --verbosity 0\n/home/special.polls.com/core/static/css/base.css\n/home/polls.com/core/static/css/base.css\nWindows
...\\> py manage.py findstatic css\\base.css --verbosity 0\n/home/special.polls.com/core/static/css/base.css\n/home/polls.com/core/static/css/base.css\nOn the other hand, by setting the --verbosity flag to 2, you can get all\nthe directories which were searched:
Linux / macOS
$ python manage.py findstatic css/base.css --verbosity 2\nFound 'css/base.css' here:\n /home/special.polls.com/core/static/css/base.css\n /home/polls.com/core/static/css/base.css\nLooking in the following locations:\n /home/special.polls.com/core/static\n /home/polls.com/core/static\n /some/other/path/static\nWindows
...\\> py manage.py findstatic css\\base.css --verbosity 2\nFound 'css/base.css' here:\n /home/special.polls.com/core/static/css/base.css\n /home/polls.com/core/static/css/base.css\nLooking in the following locations:\n /home/special.polls.com/core/static\n /home/polls.com/core/static\n /some/other/path/static\nrunserverLink to this heading#Overrides the core runserver command if the staticfiles app\nis installed and adds automatic serving of static\nfiles. File serving doesn’t run through MIDDLEWARE.
The command adds these options:
\nUse the --nostatic option to disable serving of static files with the\nstaticfiles app entirely. This option is\nonly available if the staticfiles app is\nin your project’s INSTALLED_APPS setting.
Example usage:
\nLinux / macOS
$ django-admin runserver --nostatic\nWindows
...\\> django-admin runserver --nostatic\nUse the --insecure option to force serving of static files with the\nstaticfiles app even if the DEBUG\nsetting is False. By using this you acknowledge the fact that it’s\ngrossly inefficient and probably insecure. This is only intended for\nlocal development, should never be used in production and is only\navailable if the staticfiles app is\nin your project’s INSTALLED_APPS setting.
--insecure doesn’t work with ManifestStaticFilesStorage.
Example usage:
\nLinux / macOS
$ django-admin runserver --insecure\nWindows
...\\> django-admin runserver --insecure\nStaticFilesStorageLink to this heading#A subclass of the FileSystemStorage\nstorage backend that uses the STATIC_ROOT setting as the base\nfile system location and the STATIC_URL setting respectively\nas the base URL.
If this method is defined on a storage, it’s called by the\ncollectstatic management command after each run and gets passed the\nlocal storages and paths of found files as a dictionary, as well as the command\nline options. It yields tuples of three values:\noriginal_path, processed_path, processed. The path values are strings and\nprocessed is a boolean indicating whether or not the value was\npost-processed, or an exception if post-processing failed.
The ManifestStaticFilesStorage\nuses this behind the scenes to replace the paths with their hashed\ncounterparts and update the cache appropriately.
ManifestStaticFilesStorageLink to this heading#A subclass of the StaticFilesStorage\nstorage backend which stores the file names it handles by appending the MD5\nhash of the file’s content to the filename. For example, the file\ncss/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\npages still refer to those files, e.g. because they are cached by you or\na 3rd party proxy server. Additionally, it’s very helpful if you want to\napply far future Expires headers to the deployed files to speed up the\nload time for subsequent page visits.
\nThe storage backend automatically replaces the paths found in the saved\nfiles matching other saved files with the path of the cached copy (using\nthe post_process()\nmethod). The regular expressions used to find those paths\n(django.contrib.staticfiles.storage.HashedFilesMixin.patterns)\nby default covers the @import rule and url() statement of Cascading\nStyle Sheets. For example, the 'css/styles.css' file with the\ncontent
@import url("../admin/css/base.css");\nwould be replaced by calling the url()\nmethod of the ManifestStaticFilesStorage storage backend, ultimately\nsaving a 'css/styles.55e7cbb9ba48.css' file with the following\ncontent:
@import url("../admin/css/base.27e20196a850.css");\nSince static files might reference other static files that need to have their\npaths replaced, multiple passes of replacing paths may be needed until the file\nhashes converge. To prevent an infinite loop due to hashes not converging (for\nexample, if 'foo.css' references 'bar.css' which references\n'foo.css') there is a maximum number of passes before post-processing is\nabandoned. In cases with a large number of references, a higher number of\npasses might be needed. Increase the maximum number of passes by subclassing\nManifestStaticFilesStorage and setting the max_post_process_passes\nattribute. It defaults to 5.
To enable the ManifestStaticFilesStorage you have to make sure the\nfollowing requirements are met:
the STATICFILES_STORAGE setting is set to\n'django.contrib.staticfiles.storage.ManifestStaticFilesStorage'
the DEBUG setting is set to False
you’ve collected all your static files by using the\ncollectstatic management command
Since creating the MD5 hash can be a performance burden to your website\nduring runtime, staticfiles will automatically store the mapping with\nhashed names for all processed files in a file called staticfiles.json.\nThis happens once when you run the collectstatic management\ncommand.
If a file isn’t found in the staticfiles.json manifest at runtime, a\nValueError is raised. This behavior can be disabled by subclassing\nManifestStaticFilesStorage and setting the manifest_strict attribute to\nFalse – nonexistent paths will remain unchanged.
Due to the requirement of running collectstatic, this storage\ntypically shouldn’t be used when running tests as collectstatic isn’t run\nas part of the normal test setup. During testing, ensure that the\nSTATICFILES_STORAGE setting is set to something else like\n'django.contrib.staticfiles.storage.StaticFilesStorage' (the default).
The method that is used when creating the hashed name of a file.\nNeeds to return a hash for the given file name and content.\nBy default it calculates a MD5 hash from the content’s chunks as\nmentioned above. Feel free to override this method to use your own\nhashing algorithm.
\nCachedStaticFilesStorageLink to this heading#CachedStaticFilesStorage is a similar class like the\nManifestStaticFilesStorage class\nbut uses Django’s caching framework for storing the\nhashed names of processed files instead of a static manifest file called\nstaticfiles.json. This is mostly useful for situations in which you don’t\nhave access to the file system.
If you want to override certain options of the cache backend the storage uses,\nspecify a custom entry in the CACHES setting named\n'staticfiles'. It falls back to using the 'default' cache backend.
ManifestFilesMixinLink to this heading#Use this mixin with a custom storage to append the MD5 hash of the file’s\ncontent to the filename as ManifestStaticFilesStorage does.
staticfiles finders has a searched_locations attribute which is a list\nof directory paths in which the finders searched. Example usage:
from django.contrib.staticfiles import finders\n\nresult = finders.find('css/base.css')\nsearched_locations = finders.searched_locations\nThere are a few other helpers outside of the\nstaticfiles app to work with static\nfiles:
The django.template.context_processors.static() context processor\nwhich adds STATIC_URL to every template context rendered\nwith RequestContext contexts.
The builtin template tag static which takes a path and urljoins it\nwith the static prefix STATIC_URL. If\ndjango.contrib.staticfiles is installed, the tag uses the url()\nmethod of the STATICFILES_STORAGE instead.
The builtin template tag get_static_prefix which populates a\ntemplate variable with the static prefix STATIC_URL to be\nused as a variable or directly.
The similar template tag get_media_prefix which works like\nget_static_prefix but uses MEDIA_URL.
The static files tools are mostly designed to help with getting static files\nsuccessfully deployed into production. This usually means a separate,\ndedicated static file server, which is a lot of overhead to mess with when\ndeveloping locally. Thus, the staticfiles app ships with a\nquick and dirty helper view that you can use to serve files locally in\ndevelopment.
This view function serves static files in development.
\n\n\nThis view is automatically enabled by runserver (with a\nDEBUG setting set to True). To use the view with a different\nlocal development server, add the following snippet to the end of your\nprimary URL configuration:
from django.conf import settings\nfrom django.contrib.staticfiles import views\nfrom django.urls import re_path\n\nif settings.DEBUG:\n urlpatterns += [\n re_path(r'^static/(?P<path>.*)$', views.serve),\n ]\nNote, the beginning of the pattern (r'^static/') should be your\nSTATIC_URL setting.
Since this is a bit finicky, there’s also a helper function that’ll do this for\nyou:
\nThis will return the proper URL pattern for serving static files to your\nalready defined pattern list. Use it like this:
\nfrom django.contrib.staticfiles.urls import staticfiles_urlpatterns\n\n# ... the rest of your URLconf here ...\n\nurlpatterns += staticfiles_urlpatterns()\nThis will inspect your STATIC_URL setting and wire up the view\nto serve static files accordingly. Don’t forget to set the\nSTATICFILES_DIRS setting appropriately to let\ndjango.contrib.staticfiles know where to look for files in addition to\nfiles in app directories.
This unittest TestCase subclass extends django.test.LiveServerTestCase.
Just like its parent, you can use it to write tests that involve running the\ncode under test and consuming it with testing tools through HTTP (e.g. Selenium,\nPhantomJS, etc.), because of which it’s needed that the static assets are also\npublished.
\nBut given the fact that it makes use of the\ndjango.contrib.staticfiles.views.serve() view described above, it can\ntransparently overlay at test execution-time the assets provided by the\nstaticfiles finders. This means you don’t need to run\ncollectstatic before or as a part of your tests setup.