whitenoise-3.2.2/0000775000175000017500000000000012772321741013564 5ustar davedave00000000000000whitenoise-3.2.2/docs/0000775000175000017500000000000012772321741014514 5ustar davedave00000000000000whitenoise-3.2.2/docs/Makefile0000664000175000017500000001271412202513152016144 0ustar davedave00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: -rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/WhiteNoise.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/WhiteNoise.qhc" devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/WhiteNoise" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/WhiteNoise" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." whitenoise-3.2.2/docs/base.rst0000664000175000017500000002154512670770251016170 0ustar davedave00000000000000Using WhiteNoise with any WSGI application ========================================== .. note:: These instructions apply to any WSGI application. However, for Django applications you would be better off using the :doc:`DjangoWhiteNoise ` class which makes integration easier. To enable WhiteNoise you need to wrap your existing WSGI application in a WhiteNoise instance and tell it where to find your static files. For example: .. code-block:: python from whitenoise import WhiteNoise from my_project import MyWSGIApp application = MyWSGIApp() application = WhiteNoise(application, root='/path/to/static/files') application.add_files('/path/to/more/static/files', prefix='more-files/') On initialization, WhiteNoise walks over all the files in the directories that have been added (descending into sub-directories) and builds a list of available static files. Any requests which match a static file get served by WhiteNoise, all others are passed through to the original WSGI application. See the sections on :ref:`compression ` and :ref:`caching ` for further details. WhiteNoise API -------------- .. class:: WhiteNoise(application, root=None, prefix=None, \**kwargs) :param callable application: Original WSGI application :param str root: If set, passed to ``add_files`` method :param str prefix: If set, passed to ``add_files`` method :param \**kwargs: Sets :ref:`configuration attributes ` for this instance .. method:: WhiteNoise.add_files(root, prefix=None, followlinks=False) :param str root: Absolute path to a directory of static files to be served :param str prefix: If set, the URL prefix under which the files will be served. Trailing slashes are automatically added. :param bool followlinks: Whether to follow directory symlinks when walking the directory tree to find files. Note that symlinks to files will always work. .. _compression: Compression Support ------------------- When WhiteNoise builds its list of available files it checks for corresponding files with a ``.gz`` and a ``.br`` suffix (e.g., ``scripts/app.js``, ``scripts/app.js.gz`` and ``scripts/app.js.br``). If it finds them, it will assume that they are (respectively) gzip and `brotli`_ compressed versions of the original file and it will serve them in preference to the uncompressed version where clients indicate that they that compression format (see note on Amazon S3 for why this behavour is important). .. _cli-utility: WhiteNoise comes with a command line utility which will generate compressed versions of your files for you. Note that in order for brotli compression to work the `brotlipy`_ Python package must be installed. .. _brotli: https://en.wikipedia.org/wiki/Brotli .. _brotlipy: http://brotlipy.readthedocs.org/en/latest/ Usage is simple: .. code-block:: console $ python -m whitenoise.compress --help usage: compress.py [-h] [-q] [--no-gzip] [--no-brotli] root [extensions [extensions ...]] Search for all files inside *not* matching and produce compressed versions with '.gz' and '.br' suffixes (as long as this results in a smaller file) positional arguments: root Path root from which to search for files extensions File extensions to exclude from compression (default: jpg, jpeg, png, gif, webp, zip, gz, tgz, bz2, tbz, swf, flv, woff, woff2) optional arguments: -h, --help show this help message and exit -q, --quiet Don't produce log output --no-gzip Don't produce gzip '.gz' files --no-brotli Don't produce brotli '.br' files You can either run this during development and commit your compressed files to your repository, or you can run this as part of your build and deploy processes. (Note that DjangoWhiteNoise handles this automatically, if you're using the custom storage backend.) .. _caching: Caching Headers --------------- By default, WhiteNoise sets a max-age header on all responses it sends. You can configure this by passing a ``max_age`` keyword argument. Most modern static asset build systems create uniquely named versions of each file. This results in files which are immutable (i.e., they can never change their contents) and can therefore by cached indefinitely. In order to take advantage of this, WhiteNoise needs to know which files are immutable. This can be done by sub-classing WhiteNoise and overriding the following method: .. code-block:: python def is_immutable_file(self, static_file, url): return False The exact details of how you implement this method will depend on your particular asset build system (see the source for DjangoWhiteNoise for inspiration). Once you have implemented this, any files which are flagged as immutable will have 'cache forever' headers set. Using a Content Distribution Network ------------------------------------ See the instructions for :ref:`using a CDN with Django ` . The same principles apply here although obviously the exact method for generating the URLs for your static files will depend on the libraries you're using. Redirecting to HTTPS -------------------- WhiteNoise does not handle redirection itself, but works well alongside `wsgi-sslify`_, which performs HTTP to HTTPS redirection as well as optionally setting an HSTS header. Simply wrap the WhiteNoise WSGI application with ``sslify()`` - see the `wsgi-sslify`_ documentation for more details. .. _wsgi-sslify: https://github.com/jacobian/wsgi-sslify .. _configuration: Configuration attributes ------------------------ These can be set by passing keyword arguments to the constructor, or by sub-classing WhiteNoise and setting the attributes directly. .. attribute:: autorefresh :default: ``False`` Recheck the filesystem to see if any files have changed before responding. This is designed to be used in development where it can be convenient to pick up changes to static files without restarting the server. For both performance and security reasons, this setting should not be used in production. .. attribute:: max_age :default: ``60`` Time (in seconds) for which browsers and proxies should cache files. The default is chosen to be short enough not to cause problems with stale versions but long enough that, if you're running WhiteNoise behind a CDN, the CDN will still take the majority of the strain during times of heavy load. .. attribute:: mimetypes :default: ``None`` A dictionary mapping file extensions (lowercase) to the mimetype for that extension. For example: :: {'.foo': 'application/x-foo'} Note that WhiteNoise ships with its own default set of mimetypes and does not use the system-supplied ones (e.g. ``/etc/mime.types``). This ensures that it behaves consistently regardless of the environment in which it's run. View the defaults in the :file:`media_types.py ` file. In addition to file extensions, mimetypes can be specifed by supplying the entire filename, for example: :: {'some-special-file': 'application/x-custom-type'} .. attribute:: charset :default: ``utf-8`` Charset to add as part of the ``Content-Type`` header for all files whose mimetype allows a charset. .. attribute:: allow_all_origins :default: ``True`` Toggles whether to send an ``Access-Control-Allow-Origin: *`` header for all static files. This allows cross-origin requests for static files which means your static files will continue to work as expected even if they are served via a CDN and therefore on a different domain. Without this your static files will *mostly* work, but you may have problems with fonts loading in Firefox, or accessing images in canvas elements, or other mysterious things. The W3C `explicitly state`__ that this behaviour is safe for publicly accessible files. .. __: http://www.w3.org/TR/cors/#security .. attribute:: add_headers_function :default: ``None`` Reference to a function which is passed the headers object for each static file, allowing it to modify them. For example: :: def force_download_pdfs(headers, path, url): if path.endswith('.pdf'): headers['Content-Disposition'] = 'attachment' application = WhiteNoise(application, add_headers_function=force_download_pdfs) The function is passed: headers A `wsgiref.headers`__ instance (which you can treat just as a dict) containing the headers for the current file path The absolute path to the local file url The host-relative URL of the file e.g. ``/static/styles/app.css`` The function should not return anything; changes should be made by modifying the headers dictionary directly. .. __: https://docs.python.org/3/library/wsgiref.html#module-wsgiref.headers whitenoise-3.2.2/docs/changelog.rst0000664000175000017500000001523112772321501017171 0ustar davedave00000000000000Change Log ========== v3.2.2 ------ * Convert any config values supplied as byte strings to text to avoid runtime encoding errors when encountering non-ASCII filenames. v3.2.1 ------ * Handle non-ASCII URLs correctly when using the ``wsgi.py`` integration. * Fix exception triggered when a static files "finder" returned a directory rather than a file. v3.2 ---- * Add support for the new-style middleware classes introduced in Django 1.10. The same WhiteNoiseMiddleware class can now be used in either the old ``MIDDLEWARE_CLASSES`` list or the new ``MIDDLEWARE`` list. * Fixed a bug where incorrect Content-Type headers were being sent on 304 Not Modified responses (thanks `@oppianmatt `_). * Return Vary and Cache-Control headers on 304 responses, as specified by the `RFC `_. v3.1 ---- * Add new :any:`WHITENOISE_STATIC_PREFIX` setting to give flexibility in supporting non-standard deployment configurations e.g. serving the application somewhere other than the domain root. * Fix bytes/unicode bug when running with Django 1.10 on Python 2.7 v3.0 ---- .. note:: The latest version of WhiteNoise contains some small **breaking changes**. Most users will be able to upgrade without any problems, but some less-used APIs have been modified: * The setting ``WHITENOISE_GZIP_EXCLUDE_EXTENSIONS`` has been renamed to ``WHITENOISE_SKIP_COMPRESS_EXTENSIONS``. * The CLI :ref:`compression utility ` has moved from ``python -m whitenoise.gzip`` to ``python -m whitenoise.compress``. * The now redundant ``gzipstatic`` management command has been removed. * WhiteNoise no longer uses the system mimetypes files, so if you are serving particularly obscure filetypes you may need to add their mimetypes explicitly using the new :any:`mimetypes ` setting. * Older versions of Django (1.4-1.7) and Python (2.6) are no longer supported. If you need support for these platforms you can continue to use `WhiteNoise 2.x`_. * The ``whitenoise.django.GzipManifestStaticFilesStorage`` storage backend has been moved to ``whitenoise.storage.CompressedManifestStaticFilesStorage``. The old import path **will continue to work** for now, but users are encouraged to update their code to use the new path. .. _WhiteNoise 2.x: http://whitenoise.evans.io/en/legacy-2.x/ Simpler, cleaner Django middleware integration ++++++++++++++++++++++++++++++++++++++++++++++ WhiteNoise can now integrate with Django by adding a single line to ``MIDDLEWARE_CLASSES`` without any need to edit ``wsgi.py``. This also means that WhiteNoise plays nicely with other middleware classes such as *SecurityMiddleware*, and that it is fully compatible with the new `Channels`_ system. See the :ref:`updated documentation ` for details. .. _Channels: https://channels.readthedocs.org/en/latest/ Brotli compression support ++++++++++++++++++++++++++ `Brotli`_ is the modern, more efficient alternative to gzip for HTTP compression. To benefit from smaller files and faster page loads, just install the `brotlipy`_ library, update your ``requirements.txt`` and WhiteNoise will take care of the rest. See the :ref:`documentation ` for details. .. _brotli: https://en.wikipedia.org/wiki/Brotli .. _brotlipy: http://brotlipy.readthedocs.org/en/latest/ Simpler customisation +++++++++++++++++++++ It's now possibe to add custom headers to WhiteNoise without needing to create a subclass, using the new :any:`add_headers_function ` setting. Use WhiteNoise in development with Django +++++++++++++++++++++++++++++++++++++++++ There's now an option to force Django to use WhiteNoise in development, rather than its own static file handling. This results in more consistent behaviour between development and production environments and fewer opportunities for bugs and surprises. See the :ref:`documentation ` for details. Improved mimetype handling ++++++++++++++++++++++++++ WhiteNoise now ships with its own mimetype definitions (based on those shipped with nginx) instead of relying on the system ones, which can vary between environments. There is a new :any:`mimetypes ` configuration option which makes it easy to add additional type definitions if needed. Thanks ++++++ A big thank-you to `Ed Morley `_ and `Tim Graham `_ for their contributions to this release. --------------------------- v2.0.6 ------ * Rebuild with latest version of `wheel` to get `extras_require` support. v2.0.5 ------ * Add missing argparse dependency for Python 2.6 (thanks @movermeyer)). v2.0.4 ------ * Report path on MissingFileError (thanks @ezheidtmann). v2.0.3 ------ * Add `__version__` attribute. v2.0.2 ------ * More helpful error message when STATIC_URL is set to the root of a domain (thanks @dominicrodger). v2.0.1 ------ * Add support for Python 2.6. * Add a more helpful error message when attempting to import DjangoWhiteNoise before `DJANGO_SETTINGS_MODULE` is defined. v2.0 ------ * Add an `autorefresh` mode which picks up changes to static files made after application startup (for use in development). * Add a `use_finders` mode for DjangoWhiteNoise which finds files in their original directories without needing them collected in `STATIC_ROOT` (for use in development). Note, this is only useful if you don't want to use Django's default runserver behaviour. * Remove the `follow_symlinks` argument from `add_files` and now always follow symlinks. * Support extra mimetypes which Python doesn't know about by default (including .woff2 format) * Some internal refactoring. Note, if you subclass WhiteNoise to add custom behaviour you may need to make some small changes to your code. v1.0.6 ------ * Fix unhelpful exception inside `make_helpful_exception` on Python 3 (thanks @abbottc). v1.0.5 ------ * Fix error when attempting to gzip empty files (thanks @ryanrhee). v1.0.4 ------ * Don't attempt to gzip ``.woff`` files as they're already compressed. * Base decision to gzip on compression ratio achieved, so we don't incur gzip overhead just to save a few bytes. * More helpful error message from ``collectstatic`` if CSS files reference missing assets. v1.0.3 ------ * Fix bug in Last Modified date handling (thanks to Atsushi Odagiri for spotting). v1.0.2 ------ * Set the default max_age parameter in base class to be what the docs claimed it was. v1.0.1 ------ * Fix path-to-URL conversion for Windows. * Remove cruft from packaging manifest. v1.0 ---- * First stable release. whitenoise-3.2.2/docs/conf.py0000664000175000017500000002062212671015411016005 0ustar davedave00000000000000# flake8: noqa # -*- coding: utf-8 -*- # # WhiteNoise documentation build configuration file, created by # sphinx-quickstart on Sun Aug 11 15:22:49 2013. # # This file is execfile()d with the current directory set to its containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import datetime, os # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. #sys.path.insert(0, os.path.abspath('.')) def get_version(): import ast, os, re filename = os.path.join( os.path.dirname(__file__), '../whitenoise/__init__.py') with open(filename, 'rb') as f: contents = f.read().decode('utf-8') version_string = re.search(r'__version__\s+=\s+(.*)', contents).group(1) return str(ast.literal_eval(version_string)) # -- General configuration ----------------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['sphinx.ext.extlinks'] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = u'WhiteNoise' copyright = u'2013-{}, David Evans'.format(datetime.datetime.today().year) # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = get_version() # The full version, including alpha/beta/rc tags. release = version # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['_build'] # The reST default role (used for this markup: `text`) to use for all documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. if os.environ.get('READTHEDOCS', None) == 'True': html_theme = 'default' else: import sphinx_rtd_theme html_theme = 'sphinx_rtd_theme' html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'WhiteNoisedoc' # -- Options for LaTeX output -------------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. #'preamble': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). latex_documents = [ ('index', 'WhiteNoise.tex', u'WhiteNoise Documentation', u'David Evans', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output -------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ('index', 'whitenoise', u'WhiteNoise Documentation', [u'David Evans'], 1) ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ------------------------------------------------ # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ('index', 'WhiteNoise', u'WhiteNoise Documentation', u'David Evans', 'WhiteNoise', 'One line description of project.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' git_tag = 'v{}'.format(version) if version != 'development' else 'master' github_base_url = 'https://github.com/evansd/whitenoise/blob/{}/'.format(git_tag) extlinks = {'file': (github_base_url + '%s', '')} whitenoise-3.2.2/docs/django.rst0000664000175000017500000004077412725103656016525 0ustar davedave00000000000000Using WhiteNoise with Django ============================ .. note:: To use WhiteNoise with a non-Django application see the :doc:`generic WSGI documentation `. This guide walks you through setting up a Django project with WhiteNoise. In most cases it shouldn't take more than a couple of lines of configuration. I mention Heroku in a few place as that was the initial use case which prompted me to create WhiteNoise, but there's nothing Heroku-specific about WhiteNoise and the instructions below should apply whatever your hosting platform. 1. Make sure *staticfiles* is configured correctly ---------------------------------------------------- If you're familiar with Django you'll know what to do. If you're just getting started with a new Django project then you'll need add the following to the bottom of your ``settings.py`` file: .. code-block:: python STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles') As part of deploying your application you'll need to run ``./manage.py collectstatic`` to put all your static files into ``STATIC_ROOT``. (If you're running on Heroku then this is done automatically for you.) In Django 1.9 and older, make sure you're using the static_ template tag to refer to your static files. For example: .. code-block:: html {% load static from staticfiles %} Hi! In Django 1.10 and later, you can use ``{% load static %}`` instead. .. _static: https://docs.djangoproject.com/en/1.9/ref/contrib/staticfiles/#std:templatetag-staticfiles-static .. _django-middleware: 2. Enable WhiteNoise -------------------- Edit your ``settings.py`` file and add WhiteNoise to the ``MIDDLEWARE_CLASSES`` list, above all other middleware apart from Django's `SecurityMiddleware `_: .. code-block:: python MIDDLEWARE_CLASSES = [ # 'django.middleware.security.SecurityMiddleware', 'whitenoise.middleware.WhiteNoiseMiddleware', # ... ] That's it -- WhiteNoise will now serve your static files. However, to get the best performance you should proceed to step 3 below and enable compression and caching. 3. Add compression and caching support -------------------------------------- WhiteNoise comes with a storage backend which automatically takes care of compressing your files and creating unique names for each version so they can safely be cached forever. To use it, just add this to your ``settings.py``: .. code-block:: python STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage' If you need to compress files outside of the static files storage system you can use the supplied :ref:`command line utility ` .. note:: If you are having problems after switching to the WhiteNoise storage backend please see the :ref:`troubleshooting guide `. .. _brotli-compression: Brotli compression ++++++++++++++++++ As well as the common gzip compression format, WhiteNoise supports the newer, more efficient `brotli`_ format. This helps reduce bandwidth and increase loading speed. To enable brotli compression you will need the `brotlipy`_ Python package installed, usually by running ``pip install brotlipy`` and updating your ``requirements.txt`` file. Brotli is supported by Firefox and will shortly be available in Chrome, and no doubt other browsers too. WhiteNoise will only serve brotli data to browsers which request it so there are no compatibility issues with enabling brotli support. Also note that browsers will only request brotli data over an HTTPS connection. .. _brotli: https://en.wikipedia.org/wiki/Brotli .. _brotlipy: http://brotlipy.readthedocs.org/en/latest/ .. _cdn: 4. Use a Content-Delivery Network --------------------------------- The above steps will get you decent performance on moderate traffic sites, however for higher traffic sites, or sites where performance is a concern you should look at using a CDN. Because WhiteNoise sends appropriate cache headers with your static content, the CDN will be able to cache your files and serve them without needing to contact your application again. Below are instruction for setting up WhiteNoise with Amazon CloudFront, a popular choice of CDN. The process for other CDNs should look very similar though. Instructions for Amazon CloudFront ++++++++++++++++++++++++++++++++++ Go to CloudFront section of the AWS Web Console, and click "Create Distribution". Put your application's domain (without the http prefix) in the "Origin Domain Name" field and leave the rest of the settings as they are. It might take a few minutes for your distribution to become active. Once it's ready, copy the distribution domain name into your ``settings.py`` file so it looks something like this: .. code-block:: python STATIC_HOST = 'https://d4663kmspf1sqa.cloudfront.net' if not DEBUG else '' STATIC_URL = STATIC_HOST + '/static/' Or, even better, you can avoid hardcoding your CDN into your settings by doing something like this: .. code-block:: python STATIC_HOST = os.environ.get('DJANGO_STATIC_HOST', '') STATIC_URL = STATIC_HOST + '/static/' This way you can configure your CDN just by setting an environment variable. For apps on Heroku, you'd run this command .. code-block:: bash heroku config:set DJANGO_STATIC_HOST=https://d4663kmspf1sqa.cloudfront.net .. note:: By default your entire site will be accessible via the CloudFront URL. It's possible that this can cause SEO problems if these URLs start showing up in search results. You can restrict CloudFront to only proxy your static files by following :ref:`these directions `. .. _runserver-nostatic: 5. Using WhiteNoise in development ---------------------------------- In development Django's ``runserver`` automatically takes over static file handling. In most cases this is fine, however this means that some of the improvements that WhiteNoise makes to static file handling won't be available in development and it opens up the possibility for differences in behaviour between development and production environments. For this reason it's a good idea to use WhiteNoise in development as well. You can disable Django's static file handling and allow WhiteNoise to take over simply by passing the ``--nostatic`` option to the ``runserver`` command, but you need to remember to add this option every time you call ``runserver``. An easier way is to edit your ``settings.py`` file and add ``whitenoise.runserver_nostatic`` immediately above ``django.contrib.staticfiles`` like so: .. code-block:: python INSTALLED_APPS = [ # ... 'whitenoise.runserver_nostatic', 'django.contrib.staticfiles', # ... ] Available Settings ------------------ The DjangoWhiteNoise class takes all the same configuration options as the WhiteNoise base class, but rather than accepting keyword arguments to its constructor it uses Django settings. The setting names are just the keyword arguments uppercased with a 'WHITENOISE\_' prefix. .. attribute:: WHITENOISE_ROOT :default: ``None`` Absolute path to a directory of files which will be served at the root of your application (ignored if not set). Don't use this for the bulk of your static files because you won't benefit from cache versioning, but it can be convenient for files like ``robots.txt`` or ``favicon.ico`` which you want to serve at a specific URL. .. attribute:: WHITENOISE_AUTOREFRESH :default: ``settings.DEBUG`` Recheck the filesystem to see if any files have changed before responding. This is designed to be used in development where it can be convenient to pick up changes to static files without restarting the server. For both performance and security reasons, this setting should not be used in production. .. attribute:: WHITENOISE_USE_FINDERS :default: ``settings.DEBUG`` Instead of only picking up files collected into ``STATIC_ROOT``, find and serve files in their original directories using Django's "finders" API. This is the same behaviour as ``runserver`` provides by default, and is only useful if you don't want to use the default ``runserver`` configuration in development. .. attribute:: WHITENOISE_MAX_AGE :default: ``60 if not settings.DEBUG else 0`` Time (in seconds) for which browsers and proxies should cache **non-versioned** files. Versioned files (i.e. files which have been given a unique name like *base.a4ef2389.css* by including a hash of their contents in the name) are detected automatically and set to be cached forever. The default is chosen to be short enough not to cause problems with stale versions but long enough that, if you're running WhiteNoise behind a CDN, the CDN will still take the majority of the strain during times of heavy load. .. attribute:: WHITENOISE_MIMETYPES :default: ``None`` A dictionary mapping file extensions (lowercase) to the mimetype for that extension. For example: :: {'.foo': 'application/x-foo'} Note that WhiteNoise ships with its own default set of mimetypes and does not use the system-supplied ones (e.g. ``/etc/mime.types``). This ensures that it behaves consistently regardless of the environment in which it's run. View the defaults in the :file:`media_types.py ` file. In addition to file extensions, mimetypes can be specifed by supplying the entire filename, for example: :: {'some-special-file': 'application/x-custom-type'} .. attribute:: WHITENOISE_CHARSET :default: ``settings.FILE_CHARSET`` (utf-8) Charset to add as part of the ``Content-Type`` header for all files whose mimetype allows a charset. .. attribute:: WHITENOISE_ALLOW_ALL_ORIGINS :default: ``True`` Toggles whether to send an ``Access-Control-Allow-Origin: *`` header for all static files. This allows cross-origin requests for static files which means your static files will continue to work as expected even if they are served via a CDN and therefore on a different domain. Without this your static files will *mostly* work, but you may have problems with fonts loading in Firefox, or accessing images in canvas elements, or other mysterious things. The W3C `explicitly state`__ that this behaviour is safe for publicly accessible files. .. __: http://www.w3.org/TR/cors/#security .. attribute:: WHITENOISE_SKIP_COMPRESS_EXTENSIONS :default: ``('jpg', 'jpeg', 'png', 'gif', 'webp','zip', 'gz', 'tgz', 'bz2', 'tbz', 'swf', 'flv', 'woff')`` File extensions to skip when compressing. Because the compression process will only create compressed files where this results in an actual size saving, it would be safe to leave this list empty and attempt to compress all files. However, for files which we're confident won't benefit from compression, it speeds up the process if we just skip over them. .. attribute:: WHITENOISE_ADD_HEADERS_FUNCTION :default: ``None`` Reference to a function which is passed the headers object for each static file, allowing it to modify them. For example: :: def force_download_pdfs(headers, path, url): if path.endswith('.pdf'): headers['Content-Disposition'] = 'attachment' WHITENOISE_ADD_HEADERS_FUNCTION = force_download_pdfs The function is passed: headers A `wsgiref.headers`__ instance (which you can treat just as a dict) containing the headers for the current file path The absolute path to the local file url The host-relative URL of the file e.g. ``/static/styles/app.css`` The function should not return anything; changes should be made by modifying the headers dictionary directly. .. __: https://docs.python.org/3/library/wsgiref.html#module-wsgiref.headers .. attribute:: WHITENOISE_STATIC_PREFIX :default: Path component of ``settings.STATIC_URL`` The URL prefix under which static files will be served. Usually this can be determined automatically by using the path component of ``STATIC_URL``. So if ``STATIC_URL`` is ``https://example.com/static/`` then ``WHITENOISE_STATIC_PREFIX`` will be ``/static/``. However there are cases where it's useful to set these independently, for instance if the application is not running at the root of the domain or if your CDN is doing path rewriting. Additional Notes ---------------- Django Compressor +++++++++++++++++ For performance and security reasons WhiteNoise does not check for new files after startup (unless using Django `DEBUG` mode). As such, all static files must be generated in advance. If you're using Django Compressor, this can be performed using its `offline compression`_ feature. .. _offline compression: https://django-compressor.readthedocs.org/en/latest/usage/#offline-compression -------------------------------------------------------------------------- Serving Media Files +++++++++++++++++++ WhiteNoise is not suitable for serving user-uploaded "media" files. For one thing, as described above, it only checks for static files at startup and so files added after the app starts won't be seen. More importantly though, serving user-uploaded files from the same domain as your main application is a security risk (this `blog post`_ from Google security describes the problem well). And in addition to that, using local disk to store and serve your user media makes it harder to scale your application across multiple machines. For all these reasons, it's much better to store files on a separate dedicated storage service and serve them to users from there. The `django-storages`_ library provides many options e.g. Amazon S3, Azure Storage, and Rackspace CloudFiles. .. _blog post: https://security.googleblog.com/2012/08/content-hosting-for-modern-web.html .. _django-storages: https://django-storages.readthedocs.org/en/latest/ -------------------------------------------------------------------------- .. _storage-troubleshoot: Troubleshooting the WhiteNoise Storage backend ++++++++++++++++++++++++++++++++++++++++++++++ If you're having problems with the WhiteNoise storage backend, the chances are they're due to the underlying Django storage engine. This is because WhiteNoise only adds a thin wrapper around Django's storage to add compression support, and because the compression code is very simple it generally doesn't cause problems. The most common issue is that there are CSS files which reference other files (usually images or fonts) which don't exist at that specified path. When Django attempts to rewrite these references it looks for the corresponding file and throws an error if it can't find it. To test whether the problems are due to WhiteNoise or not, try swapping the WhiteNoise storage backend for the Django one: .. code-block:: python STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.ManifestStaticFilesStorage' If the problems persist then your issue is with Django itself (try the docs_ or the `mailing list`_). If the problem only occurs with WhiteNoise then raise a ticket on the `issue tracker`_. .. _docs: https://docs.djangoproject.com/en/stable/ref/contrib/staticfiles/ .. _mailing list: https://groups.google.com/d/forum/django-users .. _issue tracker: https://github.com/evansd/whitenoise/issues -------------------------------------------------------------------------- .. _restricting-cloudfront: Restricting CloudFront to static files ++++++++++++++++++++++++++++++++++++++ The instructions for setting up CloudFront given above will result in the entire site being accessible via the CloudFront URL. It's possible that this can cause SEO problems if these URLs start showing up in search results. You can restrict CloudFront to only proxy your static files by following these directions: 1. Go to your newly created distribution and click "*Distribution Settings*", then the "*Behaviors*" tab, then "*Create Behavior*". Put ``static/*`` into the path pattern and click "*Create*" to save. 2. Now select the ``Default (*)`` behaviour and click "*Edit*". Set "*Restrict Viewer Access*" to "*Yes*" and then click "*Yes, Edit*" to save. 3. Check that the ``static/*`` pattern is first on the list, and the default one is second. This will ensure that requests for static files are passed through but all others are blocked. Using other storage backends ++++++++++++++++++++++++++++ WhiteNoise will only work with storage backends that stores their files on the local filesystem in ``STATIC_ROOT``. It will not work with backends that store files remotely, for instance on Amazon S3. whitenoise-3.2.2/docs/index.rst0000664000175000017500000001726012772265241016365 0ustar davedave00000000000000WhiteNoise ========== .. image:: https://img.shields.io/travis/evansd/whitenoise.svg :target: https://travis-ci.org/evansd/whitenoise :alt: Build Status .. image:: https://img.shields.io/pypi/v/whitenoise.svg :target: https://pypi.python.org/pypi/whitenoise :alt: Latest PyPI version .. image:: https://img.shields.io/github/stars/evansd/whitenoise.svg?style=social&label=Star :target: https://github.com/evansd/whitenoise :alt: GitHub project **Radically simplified static file serving for Python web apps** With a couple of lines of config WhiteNoise allows your web app to serve its own static files, making it a self-contained unit that can be deployed anywhere without relying on nginx, Amazon S3 or any other external service. (Especially useful on Heroku, OpenShift and other PaaS providers.) It's designed to work nicely with a CDN for high-traffic sites so you don't have to sacrifice performance to benefit from simplicity. WhiteNoise works with any WSGI-compatible app but has some special auto-configuration features for Django. WhiteNoise takes care of best-practices for you, for instance: * Serving compressed content (gzip and Brotli formats, handling Accept-Encoding and Vary headers correctly) * Setting far-future cache headers on content which won't change Worried that serving static files with Python is horribly inefficient? Still think you should be using Amazon S3? Have a look at the `Infrequently Asked Questions`_ below. QuickStart for Django apps -------------------------- Edit your ``settings.py`` file and add WhiteNoise to the ``MIDDLEWARE_CLASSES`` list, above all other middleware apart from Django's `SecurityMiddleware `_: .. code-block:: python MIDDLEWARE_CLASSES = [ # 'django.middleware.security.SecurityMiddleware', 'whitenoise.middleware.WhiteNoiseMiddleware', # ... ] That's it, you're ready to go. Want forever-cacheable files and compression support? Just add this to your ``settings.py``: .. code-block:: python STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage' For more details, including on setting up CloudFront and other CDNs see the :doc:`Using WhiteNoise with Django ` guide. QuickStart for other WSGI apps ------------------------------ To enable WhiteNoise you need to wrap your existing WSGI application in a WhiteNoise instance and tell it where to find your static files. For example: .. code-block:: python from whitenoise import WhiteNoise from my_project import MyWSGIApp application = MyWSGIApp() application = WhiteNoise(application, root='/path/to/static/files') application.add_files('/path/to/more/static/files', prefix='more-files/') And that's it, you're ready to go. For more details see the :doc:`full documentation `. Compatibility ------------- WhiteNoise works with any WSGI-compatible application and is tested on Python **2.7**, **3.3**, **3.4**, **3.5** and **PyPy**. DjangoWhiteNoise is tested with Django versions **1.8** --- **1.10** Endorsements ------------ WhiteNoise owes its initial popularity to the nice things that some of Django and pip's core developers said about it: `@jezdez `_: *[WhiteNoise] is really awesome and should be the standard for Django + Heroku* `@dstufft `_: *WhiteNoise looks pretty excellent.* `@idangazit `_ *Received a positive brainsmack from @_EvansD's WhiteNoise. Vastly smarter than S3 for static assets. What was I thinking before?* It's now being used by thousands of projects, including some high-profile sites such as `mozilla.org `_. Issues & Contributing --------------------- Raise an issue on the `GitHub project `_ or feel free to nudge `@_EvansD `_ on Twitter. Infrequently Asked Questions ---------------------------- Isn't serving static files from Python horribly inefficient? ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ The short answer to this is that if you care about performance and efficiency then you should be using WhiteNoise behind a CDN like CloudFront. If you're doing *that* then, because of the caching headers WhiteNoise sends, the vast majority of static requests will be served directly by the CDN without touching your application, so it really doesn't make much difference how efficient WhiteNoise is. That said, WhiteNoise is pretty efficient. Because it only has to serve a fixed set of files it does all the work of finding files and determining the correct headers upfront on initialization. Requests can then be served with little more than a dictionary lookup to find the appropriate response. Also, when used with gunicorn (and most other WSGI servers) the actual business of pushing the file down the network interface is handled by the kernel's very efficient ``sendfile`` syscall, not by Python. Shouldn't I be pushing my static files to S3 using something like Django-Storages? ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ No, you shouldn't. The main problem with this approach is that Amazon S3 cannot currently selectively serve compressed content to your users. Compression (using either the venerable gzip or the more modern brotli algorithms) can make dramatic reductions in the bandwidth required for your CSS and JavaScript. But in order to do this correctly the server needs to examine the ``Accept-Encoding`` header of the request to determine which compression formats are supported, and return an appropriate ``Vary`` header so that intermediate caches know to do the same. This is exactly what WhiteNoise does, but Amazon S3 currently provides no means of doing this. The second problem with a push-based approach to handling static files is that it adds complexity and fragility to your deployment process: extra libraries specific to your storage backend, extra configuration and authentication keys, and extra tasks that must be run at specific points in the deployment in order for everything to work. With the CDN-as-caching-proxy approach that WhiteNoise takes there are just two bits of configuration: your application needs the URL of the CDN, and the CDN needs the URL of your application. Everything else is just standard HTTP semantics. This makes your deployments simpler, your life easier, and you happier. What's the point in WhiteNoise when I can do the same thing in a few lines of Apache/nginx config? ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ There are two answers here. One is that WhiteNoise is designed to work in situations were Apache, nginx and the like aren't easily available. But more importantly, it's easy to underestimate what's involved in serving static files correctly. Does your few lines of nginx config distinguish between files which might change and files which will never change and set the cache headers appropriately? Did you add the right CORS headers so that your fonts load correctly when served via a CDN? Did you turn on the special nginx setting which allows it to send gzipped content in response to an ``HTTP/1.0`` request, which for some reason CloudFront still uses? Did you install the extension which alllows you to serve pre-compressed brotli-encoded content to modern browsers? None of this is rocket science, but it's fiddly and annoying and WhiteNoise takes care of all it for you. License ------- MIT Licensed .. toctree:: :hidden: self django base changelog whitenoise-3.2.2/whitenoise/0000775000175000017500000000000012772321741015742 5ustar davedave00000000000000whitenoise-3.2.2/whitenoise/runserver_nostatic/0000775000175000017500000000000012772321741021701 5ustar davedave00000000000000whitenoise-3.2.2/whitenoise/runserver_nostatic/management/0000775000175000017500000000000012772321741024015 5ustar davedave00000000000000whitenoise-3.2.2/whitenoise/runserver_nostatic/management/commands/0000775000175000017500000000000012772321741025616 5ustar davedave00000000000000whitenoise-3.2.2/whitenoise/runserver_nostatic/management/commands/__init__.py0000664000175000017500000000000012667605241027720 0ustar davedave00000000000000whitenoise-3.2.2/whitenoise/runserver_nostatic/management/commands/runserver.py0000664000175000017500000000040312670037113030212 0ustar davedave00000000000000""" This file exists solely to shadow the `runserver` command provided by `django.contrib.staticfiles` and restore the original `runserver` behaviour """ from django.core.management.commands.runserver import Command # Keep flake8 happy __all__ = ['Command'] whitenoise-3.2.2/whitenoise/runserver_nostatic/management/__init__.py0000664000175000017500000000000012667605235026122 0ustar davedave00000000000000whitenoise-3.2.2/whitenoise/runserver_nostatic/__init__.py0000664000175000017500000000000012667605227024007 0ustar davedave00000000000000whitenoise-3.2.2/whitenoise/__init__.py0000664000175000017500000000011612772321520020044 0ustar davedave00000000000000from .base import WhiteNoise __version__ = '3.2.2' __all__ = ['WhiteNoise'] whitenoise-3.2.2/whitenoise/base.py0000664000175000017500000001505312772277055017242 0ustar davedave00000000000000from email.utils import formatdate import os from posixpath import normpath from wsgiref.headers import Headers from wsgiref.util import FileWrapper from .media_types import MediaTypes from .static_file import StaticFile from .utils import (decode_if_byte_string, decode_path_info, ensure_leading_trailing_slash, MissingFileError, stat_regular_file) class WhiteNoise(object): # Ten years is what nginx sets a max age if you use 'expires max;' # so we'll follow its lead FOREVER = 10*365*24*60*60 # Attributes that can be set by keyword args in the constructor config_attrs = ('autorefresh', 'max_age', 'allow_all_origins', 'charset', 'mimetypes', 'add_headers_function') # Re-check the filesystem on every request so that any changes are # automatically picked up. NOTE: For use in development only, not supported # in production autorefresh = False max_age = 60 # Set 'Access-Control-Allow-Orign: *' header on all files. # As these are all public static files this is safe (See # http://www.w3.org/TR/cors/#security) and ensures that things (e.g # webfonts in Firefox) still work as expected when your static files are # served from a CDN, rather than your primary domain. allow_all_origins = True charset = 'utf-8' # Custom mime types mimetypes = None # Callback for adding custom logic when setting headers add_headers_function = None def __init__(self, application, root=None, prefix=None, **kwargs): for attr in self.config_attrs: try: value = kwargs.pop(attr) except KeyError: pass else: value = decode_if_byte_string(value) setattr(self, attr, value) if kwargs: raise TypeError("Unexpected keyword argument '{0}'".format( list(kwargs.keys())[0])) self.media_types = MediaTypes(extra_types=self.mimetypes) self.application = application self.files = {} self.directories = [] if root is not None: self.add_files(root, prefix) def __call__(self, environ, start_response): path = decode_path_info(environ['PATH_INFO']) if self.autorefresh: static_file = self.find_file(path) else: static_file = self.files.get(path) if static_file is None: return self.application(environ, start_response) else: return self.serve(static_file, environ, start_response) def serve(self, static_file, environ, start_response): response = static_file.get_response(environ['REQUEST_METHOD'], environ) status_line = '{} {}'.format(response.status, response.status.phrase) start_response(status_line, list(response.headers)) if response.file is not None: file_wrapper = environ.get('wsgi.file_wrapper', FileWrapper) return file_wrapper(response.file) else: return [] def add_files(self, root, prefix=None): root = decode_if_byte_string(root) prefix = decode_if_byte_string(prefix) prefix = ensure_leading_trailing_slash(prefix) if self.autorefresh: # Later calls to `add_files` overwrite earlier ones, hence we need # to store the list of directories in reverse order so later ones # match first when they're checked in "autorefresh" mode self.directories.insert(0, (root, prefix)) else: self.update_files_dictionary(root, prefix) def update_files_dictionary(self, root, prefix): for directory, _, filenames in os.walk(root, followlinks=True): for filename in filenames: path = os.path.join(directory, filename) url = prefix + os.path.relpath(path, root).replace('\\', '/') self.files[url] = self.get_static_file(path, url) def find_file(self, url): # Don't bother checking URLs which could only ever be directories if not url or url[-1] == '/': return # Attempt to mitigate path traversal attacks. Not sure if this is # sufficient, hence the warning that "autorefresh" is a development # only feature and not for production use if normpath(url) != url: return for root, prefix in self.directories: if url.startswith(prefix): path = os.path.join(root, url[len(prefix):]) try: return self.get_static_file(path, url) except MissingFileError: pass def get_static_file(self, path, url): headers = Headers([]) self.add_stat_headers(headers, path, url) self.add_mime_headers(headers, path, url) self.add_cache_headers(headers, path, url) self.add_cors_headers(headers, path, url) self.add_extra_headers(headers, path, url) if self.add_headers_function: self.add_headers_function(headers, path, url) return StaticFile(path, headers) def add_stat_headers(self, headers, path, url): file_stat = stat_regular_file(path) headers['Last-Modified'] = formatdate(file_stat.st_mtime, usegmt=True) headers['Content-Length'] = str(file_stat.st_size) def add_mime_headers(self, headers, path, url): media_type = self.media_types.get_type(path) charset = self.get_charset(media_type, path, url) params = {'charset': str(charset)} if charset else {} headers.add_header('Content-Type', str(media_type), **params) def get_charset(self, media_type, path, url): if (media_type.startswith('text/') or media_type == 'application/javascript'): return self.charset def add_cache_headers(self, headers, path, url): if self.is_immutable_file(path, url): max_age = self.FOREVER else: max_age = self.max_age if max_age is not None: cache_control = 'public, max-age={0}'.format(max_age) headers['Cache-Control'] = cache_control def is_immutable_file(self, path, url): """ This should be implemented by sub-classes (see e.g. DjangoWhiteNoise) """ return False def add_cors_headers(self, headers, path, url): if self.allow_all_origins: headers['Access-Control-Allow-Origin'] = '*' def add_extra_headers(self, headers, path, url): """ This is provided as a hook for sub-classes, by default a no-op """ pass whitenoise-3.2.2/whitenoise/byte_ranges.py0000664000175000017500000000216712703755217020627 0ustar davedave00000000000000STATUS_PARTIAL_CONTENT = 206 STATUS_NOT_SATISFIABLE = 416 Response = namedtuple('Response', ('status', 'headers', 'file')) class BadRange(Exception): pass def get_range_response(response, range_header): content_length = next(v for (k, v) in response.headers if k == 'Content-Length') size = int(content_length) try: start, end = self.get_byte_range(range_header, size) except BadRange: return Response(self.STATUS_NOT_SATISFIABLE, [('Content-Range', 'bytes */{}'.format(size))], None) headers = response.headers headers.append(('Content-Range', 'bytes {}-{}/{}'.format(start, end, size))) if response.file is not None: file_wrapper = self.wrap_file(response.file, start, end, size) else: file_wrapper = None return Response(self.STATUS_PARTIAL_CONTENT, headers, file_wrapper) def get_btye_range(self, range_header, size): raise BadRange() def wrap_file(self, file_handle, start, end, size): if start > 0: file_handle.seek(start) if end == size: return file_handle whitenoise-3.2.2/whitenoise/compress.py0000664000175000017500000001135512667514156020163 0ustar davedave00000000000000from __future__ import print_function, division, unicode_literals import gzip import os import re try: from io import BytesIO except ImportError: from cStringIO import StringIO as BytesIO try: import brotli brotli_installed = True except ImportError: brotli_installed = False class Compressor(object): # Extensions that it's not worth trying to compress SKIP_COMPRESS_EXTENSIONS = ( # Images 'jpg', 'jpeg', 'png', 'gif', 'webp', # Compressed files 'zip', 'gz', 'tgz', 'bz2', 'tbz', # Flash 'swf', 'flv', # Fonts 'woff', 'woff2') def __init__(self, extensions=None, use_gzip=True, use_brotli=True, log=print, quiet=False): if extensions is None: extensions = self.SKIP_COMPRESS_EXTENSIONS self.extension_re = self.get_extension_re(extensions) self.use_gzip = use_gzip self.use_brotli = use_brotli and brotli_installed if not quiet: self.log = log @staticmethod def get_extension_re(extensions): if not extensions: return re.compile('^$') else: return re.compile( r'\.({0})$'.format('|'.join(map(re.escape, extensions))), re.IGNORECASE) def should_compress(self, filename): return not self.extension_re.search(filename) def log(self, message): pass def compress(self, path): with open(path, 'rb') as f: data = f.read() size = len(data) if self.use_brotli: compressed = self.compress_brotli(data) success = self.write_data(compressed, size, path, '.br', 'Brotli') # If Brotli compression wasn't effective gzip won't be either if not success: return if self.use_gzip: compressed = self.compress_gzip(data) self.write_data(compressed, size, path, '.gz', 'Gzip') @staticmethod def compress_gzip(data): output = BytesIO() # Explicitly set mtime to 0 so gzip content is fully determined # by file content (0 = "no timestamp" according to gzip spec) with gzip.GzipFile(filename='', mode='wb', fileobj=output, compresslevel=9, mtime=0) as gz_file: gz_file.write(data) return output.getvalue() @staticmethod def compress_brotli(data): return brotli.compress(data) def write_data(self, data, orig_size, path, suffix, compression): compressed_size = len(data) if not self.compressed_effectively(orig_size, compressed_size): self.log('Skipping {0} ({1} compression not effective)'.format( path, compression)) return False else: self.log('{0} compressed {1} ({2}K -> {3}K)'.format( compression, path, orig_size // 1024, compressed_size // 1024)) with open(path + suffix, 'wb') as f: f.write(data) return True @staticmethod def compressed_effectively(orig_size, compressed_size): if orig_size == 0: return False ratio = compressed_size / orig_size return ratio <= 0.95 def main(root, **kwargs): compressor = Compressor(**kwargs) for dirpath, dirs, files in os.walk(root): for filename in files: if compressor.should_compress(filename): path = os.path.join(dirpath, filename) compressor.compress(path) if __name__ == '__main__': import argparse parser = argparse.ArgumentParser( description="Search for all files inside *not* matching " " and produce compressed versions with " "'.gz' and '.br' suffixes (as long as this results in a " "smaller file)") parser.add_argument('-q', '--quiet', help="Don't produce log output", action='store_true') parser.add_argument('--no-gzip', help="Don't produce gzip '.gz' files", action='store_false', dest='use_gzip') parser.add_argument('--no-brotli', help="Don't produce brotli '.br' files", action='store_false', dest='use_brotli') parser.add_argument('root', help='Path root from which to search for files') parser.add_argument('extensions', nargs='*', help='File extensions to exclude from compression ' '(default: {})'.format(', '.join( Compressor.SKIP_COMPRESS_EXTENSIONS)), default=Compressor.SKIP_COMPRESS_EXTENSIONS) args = parser.parse_args() main(**vars(args)) whitenoise-3.2.2/whitenoise/django.py0000664000175000017500000001103512772300042017545 0ustar davedave00000000000000from __future__ import absolute_import import os from django.conf import settings from django.core.exceptions import ImproperlyConfigured try: from django.contrib.staticfiles.storage import staticfiles_storage except ImproperlyConfigured: if not os.environ.get('DJANGO_SETTINGS_MODULE'): raise ImproperlyConfigured( "'DJANGO_SETTINGS_MODULE' environment variable must be set " "before importing 'whitenoise.django'") else: raise from django.contrib.staticfiles import finders from django.utils.six.moves.urllib.parse import urlparse from .base import WhiteNoise # Import here under an alias for backwards compatibility from .storage import (CompressedManifestStaticFilesStorage as GzipManifestStaticFilesStorage) from .utils import (decode_if_byte_string, ensure_leading_trailing_slash, IsDirectoryError) __all__ = ['DjangoWhiteNoise', 'GzipManifestStaticFilesStorage'] class DjangoWhiteNoise(WhiteNoise): config_attrs = WhiteNoise.config_attrs + ( 'root', 'use_finders', 'static_prefix') root = None use_finders = False static_prefix = None def __init__(self, application, settings=settings): self.configure_from_settings(settings) self.check_settings(settings) super(DjangoWhiteNoise, self).__init__(application) if self.static_root: self.add_files(self.static_root, prefix=self.static_prefix) if self.root: self.add_files(self.root) def configure_from_settings(self, settings): # Default configuration self.charset = settings.FILE_CHARSET self.autorefresh = settings.DEBUG self.use_finders = settings.DEBUG self.static_prefix = urlparse(settings.STATIC_URL or '').path if settings.DEBUG: self.max_age = 0 # Allow settings to override default attributes for attr in self.config_attrs: settings_key = 'WHITENOISE_{0}'.format(attr.upper()) try: value = getattr(settings, settings_key) except AttributeError: pass else: value = decode_if_byte_string(value) setattr(self, attr, value) self.static_prefix = ensure_leading_trailing_slash(self.static_prefix) self.static_root = decode_if_byte_string(settings.STATIC_ROOT) def check_settings(self, settings): if self.use_finders and not self.autorefresh: raise ImproperlyConfigured( 'WHITENOISE_USE_FINDERS can only be enabled in development ' 'when WHITENOISE_AUTOREFRESH is also enabled.' ) def find_file(self, url): if self.use_finders and url.startswith(self.static_prefix): path = finders.find(url[len(self.static_prefix):]) if path: try: return self.get_static_file(path, url) except IsDirectoryError: return None return super(DjangoWhiteNoise, self).find_file(url) def is_immutable_file(self, path, url): """ Determine whether given URL represents an immutable file (i.e. a file with a hash of its contents as part of its name) which can therefore be cached forever """ if not url.startswith(self.static_prefix): return False name = url[len(self.static_prefix):] name_without_hash = self.get_name_without_hash(name) if name == name_without_hash: return False static_url = self.get_static_url(name_without_hash) # If the static URL function maps the name without hash # back to the original URL, then we know we've got a # versioned filename if static_url and static_url.endswith(url): return True return False def get_name_without_hash(self, filename): """ Removes the version hash from a filename e.g, transforms 'css/application.f3ea4bcc2.css' into 'css/application.css' Note: this is specific to the naming scheme used by Django's CachedStaticFilesStorage. You may have to override this if you are using a different static files versioning system """ name_with_hash, ext = os.path.splitext(filename) name = os.path.splitext(name_with_hash)[0] return name + ext def get_static_url(self, name): try: return decode_if_byte_string(staticfiles_storage.url(name)) except ValueError: return None whitenoise-3.2.2/whitenoise/httpstatus_backport.py0000664000175000017500000000103112725767172022431 0ustar davedave00000000000000""" Very partial backport of the `http.HTTPStatus` enum from Python 3.5 This implements just enough of the interface for our purposes, it does not attempt to be a full implementation. """ class HTTPStatus(int): phrase = None def __new__(cls, code, phrase): instance = int.__new__(cls, code) instance.phrase = phrase return instance HTTPStatus.OK = HTTPStatus(200, 'OK') HTTPStatus.NOT_MODIFIED = HTTPStatus(304, 'Not Modified') HTTPStatus.METHOD_NOT_ALLOWED = HTTPStatus(405, 'Method Not Allowed') whitenoise-3.2.2/whitenoise/media_types.py0000664000175000017500000001077612666365234020641 0ustar davedave00000000000000import os class MediaTypes(object): def __init__(self, default='application/octet-stream', extra_types=None): self.types_map = default_types() self.default = default if extra_types: self.types_map.update(extra_types) def get_type(self, path): name = os.path.basename(path).lower() media_type = self.types_map.get(name) if media_type is not None: return media_type extension = os.path.splitext(name)[1] return self.types_map.get(extension, self.default) def default_types(): """ We use our own set of default media types rather than the system-supplied ones. This ensures consistent media type behaviour across varied environments. The defaults are based on those shipped with nginx, with some custom additions. """ return { '.3gp': 'video/3gpp', '.3gpp': 'video/3gpp', '.7z': 'application/x-7z-compressed', '.ai': 'application/postscript', '.asf': 'video/x-ms-asf', '.asx': 'video/x-ms-asf', '.atom': 'application/atom+xml', '.avi': 'video/x-msvideo', '.bmp': 'image/x-ms-bmp', '.cco': 'application/x-cocoa', '.crt': 'application/x-x509-ca-cert', '.css': 'text/css', '.der': 'application/x-x509-ca-cert', '.doc': 'application/msword', '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', '.ear': 'application/java-archive', '.eot': 'application/vnd.ms-fontobject', '.eps': 'application/postscript', '.flv': 'video/x-flv', '.gif': 'image/gif', '.hqx': 'application/mac-binhex40', '.htc': 'text/x-component', '.htm': 'text/html', '.html': 'text/html', '.ico': 'image/x-icon', '.jad': 'text/vnd.sun.j2me.app-descriptor', '.jar': 'application/java-archive', '.jardiff': 'application/x-java-archive-diff', '.jng': 'image/x-jng', '.jnlp': 'application/x-java-jnlp-file', '.jpeg': 'image/jpeg', '.jpg': 'image/jpeg', '.js': 'application/javascript', '.json': 'application/json', '.kar': 'audio/midi', '.kml': 'application/vnd.google-earth.kml+xml', '.kmz': 'application/vnd.google-earth.kmz', '.m3u8': 'application/vnd.apple.mpegurl', '.m4a': 'audio/x-m4a', '.m4v': 'video/x-m4v', '.mid': 'audio/midi', '.midi': 'audio/midi', '.mml': 'text/mathml', '.mng': 'video/x-mng', '.mov': 'video/quicktime', '.mp3': 'audio/mpeg', '.mp4': 'video/mp4', '.mpeg': 'video/mpeg', '.mpg': 'video/mpeg', '.ogg': 'audio/ogg', '.pdb': 'application/x-pilot', '.pdf': 'application/pdf', '.pem': 'application/x-x509-ca-cert', '.pl': 'application/x-perl', '.pm': 'application/x-perl', '.png': 'image/png', '.ppt': 'application/vnd.ms-powerpoint', '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation', '.prc': 'application/x-pilot', '.ps': 'application/postscript', '.ra': 'audio/x-realaudio', '.rar': 'application/x-rar-compressed', '.rpm': 'application/x-redhat-package-manager', '.rss': 'application/rss+xml', '.rtf': 'application/rtf', '.run': 'application/x-makeself', '.sea': 'application/x-sea', '.shtml': 'text/html', '.sit': 'application/x-stuffit', '.svg': 'image/svg+xml', '.svgz': 'image/svg+xml', '.swf': 'application/x-shockwave-flash', '.tcl': 'application/x-tcl', '.tif': 'image/tiff', '.tiff': 'image/tiff', '.tk': 'application/x-tcl', '.ts': 'video/mp2t', '.txt': 'text/plain', '.war': 'application/java-archive', '.wbmp': 'image/vnd.wap.wbmp', '.webm': 'video/webm', '.webp': 'image/webp', '.wml': 'text/vnd.wap.wml', '.wmlc': 'application/vnd.wap.wmlc', '.wmv': 'video/x-ms-wmv', '.woff': 'application/font-woff', '.woff2': 'font/woff2', '.xhtml': 'application/xhtml+xml', '.xls': 'application/vnd.ms-excel', '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', '.xml': 'text/xml', '.xpi': 'application/x-xpinstall', '.xspf': 'application/xspf+xml', '.zip': 'application/zip', 'apple-app-site-association': 'application/pkc7-mime' } whitenoise-3.2.2/whitenoise/middleware.py0000664000175000017500000000273512722056724020441 0ustar davedave00000000000000from __future__ import absolute_import from django.http import FileResponse from whitenoise.django import DjangoWhiteNoise class WhiteNoiseMiddleware(DjangoWhiteNoise): """ Wrap DjangoWhiteNoise to allow it to function as Django middleware, rather than WSGI middleware This functions as both old- and new-style middleware, so can be included in either MIDDLEWARE or MIDDLEWARE_CLASSES. """ def __init__(self, get_response=None): self.get_response = get_response # We pass None for `application` super(WhiteNoiseMiddleware, self).__init__(None) def __call__(self, request): response = self.process_request(request) if response is None: response = self.get_response(request) return response def process_request(self, request): if self.autorefresh: static_file = self.find_file(request.path_info) else: static_file = self.files.get(request.path_info) if static_file is not None: return self.serve(static_file, request) def serve(self, static_file, request): response = static_file.get_response(request.method, request.META) status = int(response.status) http_response = FileResponse(response.file or (), status=status) # Remove default content-type del http_response['content-type'] for key, value in response.headers: http_response[key] = value return http_response whitenoise-3.2.2/whitenoise/static_file.py0000664000175000017500000000711612716357460020614 0ustar davedave00000000000000from collections import namedtuple from email.utils import parsedate try: from http import HTTPStatus except ImportError: from .httpstatus_backport import HTTPStatus import re from wsgiref.headers import Headers from .utils import MissingFileError, stat_regular_file Response = namedtuple('Response', ('status', 'headers', 'file')) NOT_ALLOWED = Response(HTTPStatus.METHOD_NOT_ALLOWED, (('Allow', 'GET, HEAD'),), None) ACCEPT_GZIP_RE = re.compile(r'\bgzip\b') ACCEPT_BROTLI_RE = re.compile(r'\bbr\b') # Headers which should be returned with a 304 Not Modified response as # specified here: http://tools.ietf.org/html/rfc7232#section-4.1 NOT_MODIFIED_HEADERS = ('Cache-Control', 'Content-Location', 'Date', 'ETag', 'Expires', 'Vary') NOT_MODIFIED_HEADER_RE = re.compile('^({})$'.format( '|'.join(map(re.escape, NOT_MODIFIED_HEADERS))), re.IGNORECASE) class StaticFile(object): def __init__(self, path, headers): plain_file, gzip_file, brotli_file = get_alternatives(path, headers) self.plain_file = file_tuple(plain_file) self.gzip_file = file_tuple(gzip_file) self.brotli_file = file_tuple(brotli_file) self.last_modified = parsedate(headers['Last-Modified']) self.not_modified_response = get_not_modified_response(self.plain_file[1]) def get_response(self, method, request_headers): if method != 'GET' and method != 'HEAD': return NOT_ALLOWED elif self.file_not_modified(request_headers): return self.not_modified_response path, headers = self.get_path_and_headers(request_headers) if method != 'HEAD': file_handle = open(path, 'rb') else: file_handle = None return Response(HTTPStatus.OK, headers, file_handle) def get_path_and_headers(self, request_headers): accept_encoding = request_headers.get('HTTP_ACCEPT_ENCODING', '') if self.brotli_file and ACCEPT_BROTLI_RE.search(accept_encoding): return self.brotli_file if self.gzip_file and ACCEPT_GZIP_RE.search(accept_encoding): return self.gzip_file return self.plain_file def file_not_modified(self, request_headers): try: last_requested = request_headers['HTTP_IF_MODIFIED_SINCE'] except KeyError: return False return parsedate(last_requested) >= self.last_modified def get_alternatives(path, headers): gzip_file = get_alternative_encoding(path, headers, '.gz', 'gzip') brotli_file = get_alternative_encoding(path, headers, '.br', 'br') if gzip_file or brotli_file: headers['Vary'] = 'Accept-Encoding' plain_file = (path, headers) return plain_file, gzip_file, brotli_file def get_alternative_encoding(path, headers, suffix, encoding): alt_path = path + suffix try: alt_size = stat_regular_file(alt_path).st_size except MissingFileError: return None alt_headers = Headers(headers.items()) alt_headers['Vary'] = 'Accept-Encoding' alt_headers['Content-Encoding'] = encoding alt_headers['Content-Length'] = str(alt_size) return alt_path, alt_headers def file_tuple(path_and_headers): if path_and_headers is None: return None else: path, headers = path_and_headers return path, tuple(headers.items()) def get_not_modified_response(headers): not_modified_headers = tuple([ item for item in headers if NOT_MODIFIED_HEADER_RE.match(item[0])]) return Response(HTTPStatus.NOT_MODIFIED, not_modified_headers, None) whitenoise-3.2.2/whitenoise/storage.py0000664000175000017500000000647312667517414020001 0ustar davedave00000000000000from __future__ import absolute_import import os import re import textwrap from django.conf import settings from django.contrib.staticfiles.storage import ManifestStaticFilesStorage from .compress import Compressor class CompressedStaticFilesMixin(object): """ Wraps a StaticFilesStorage instance to create compressed versions of its output files """ def post_process(self, *args, **kwargs): files = super(CompressedStaticFilesMixin, self).post_process(*args, **kwargs) if not kwargs.get('dry_run'): files = self.post_process_with_compression(files) return files def post_process_with_compression(self, files): extensions = getattr(settings, 'WHITENOISE_SKIP_COMPRESS_EXTENSIONS', None) compressor = Compressor(extensions=extensions, quiet=True) for name, hashed_name, processed in files: if self.should_compress(compressor, name, processed): compressor.compress(self.path(name)) if hashed_name is not None: compressor.compress(self.path(hashed_name)) yield name, hashed_name, processed def should_compress(self, compressor, name, processed): if isinstance(processed, Exception): return False else: return compressor.should_compress(name) class HelpfulExceptionMixin(object): """ If a CSS file contains references to images, fonts etc that can't be found then Django's `post_process` blows up with a not particularly helpful ValueError that leads people to think WhiteNoise is broken. Here we attempt to intercept such errors and reformat them to be more helpful in revealing the source of the problem. """ ERROR_MSG_RE = re.compile("^The file '(.+)' could not be found") ERROR_MSG = textwrap.dedent(u"""\ {orig_message} The {ext} file '{filename}' references a file which could not be found: {missing} Please check the URL references in this {ext} file, particularly any relative paths which might be pointing to the wrong location. """) def post_process(self, *args, **kwargs): files = super(HelpfulExceptionMixin, self).post_process(*args, **kwargs) for name, hashed_name, processed in files: if isinstance(processed, Exception): processed = self.make_helpful_exception(processed, name) yield name, hashed_name, processed def make_helpful_exception(self, exception, name): if isinstance(exception, ValueError): message = exception.args[0] if len(exception.args) else '' # Stringly typed exceptions. Yay! match = self.ERROR_MSG_RE.search(message) if match: extension = os.path.splitext(name)[1].lstrip('.').upper() message = self.ERROR_MSG.format( orig_message=message, filename=name, missing=match.group(1), ext=extension) exception = MissingFileError(message) return exception class MissingFileError(ValueError): pass class CompressedManifestStaticFilesStorage( HelpfulExceptionMixin, CompressedStaticFilesMixin, ManifestStaticFilesStorage): pass whitenoise-3.2.2/whitenoise/utils.py0000664000175000017500000000301312772277075017463 0ustar davedave00000000000000import errno import os import stat import sys if sys.version_info[0] >= 3: BINARY_TYPE = bytes else: BINARY_TYPE = str class NotARegularFileError(Exception): pass class MissingFileError(NotARegularFileError): pass class IsDirectoryError(MissingFileError): pass def decode_if_byte_string(s): if isinstance(s, BINARY_TYPE): s = s.decode('utf-8') return s # Follow Django in treating URLs as UTF-8 encoded (which requires undoing the # implicit ISO-8859-1 decoding applied in Python 3). Strictly speaking, URLs # should only be ASCII anyway, but UTF-8 can be found in the wild. if sys.version_info[0] >= 3: def decode_path_info(path_info): return path_info.encode('iso-8859-1').decode('utf-8') else: def decode_path_info(path_info): return path_info.decode('utf-8') def stat_regular_file(path): """ Wrap os.stat to raise appropriate errors if `path` is not a regular file """ try: file_stat = os.stat(path) except OSError as e: if e.errno == errno.ENOENT: raise MissingFileError(path) else: raise if not stat.S_ISREG(file_stat.st_mode): if stat.S_ISDIR(file_stat.st_mode): raise IsDirectoryError(u'Path is a directory: {0}'.format(path)) else: raise NotARegularFileError(u'Not a regular file: {0}'.format(path)) return file_stat def ensure_leading_trailing_slash(path): path = (path or u'').strip(u'/') return u'/{0}/'.format(path) if path else u'/' whitenoise-3.2.2/whitenoise.egg-info/0000775000175000017500000000000012772321741017434 5ustar davedave00000000000000whitenoise-3.2.2/whitenoise.egg-info/PKG-INFO0000664000175000017500000000543012772321735020536 0ustar davedave00000000000000Metadata-Version: 1.1 Name: whitenoise Version: 3.2.2 Summary: Radically simplified static file serving for WSGI applications Home-page: http://whitenoise.evans.io Author: David Evans Author-email: d@evans.io License: MIT Description: WhiteNoise ========== .. image:: https://img.shields.io/travis/evansd/whitenoise.svg :target: https://travis-ci.org/evansd/whitenoise :alt: Build Status .. image:: https://img.shields.io/pypi/v/whitenoise.svg :target: https://pypi.python.org/pypi/whitenoise :alt: Latest PyPI version .. image:: https://img.shields.io/github/stars/evansd/whitenoise.svg?style=social&label=Star :target: https://github.com/evansd/whitenoise :alt: GitHub project **Radically simplified static file serving for Python web apps** With a couple of lines of config WhiteNoise allows your web app to serve its own static files, making it a self-contained unit that can be deployed anywhere without relying on nginx, Amazon S3 or any other external service. (Especially useful on Heroku, OpenShift and other PaaS providers.) It's designed to work nicely with a CDN for high-traffic sites so you don't have to sacrifice performance to benefit from simplicity. WhiteNoise works with any WSGI-compatible app but has some special auto-configuration features for Django. WhiteNoise takes care of best-practices for you, for instance: * Serving compressed content (gzip and Brotli formats, handling Accept-Encoding and Vary headers correctly) * Setting far-future cache headers on content which won't change Worried that serving static files with Python is horribly inefficient? Still think you should be using Amazon S3? Have a look at the `Infrequently Asked Questions`_. To get started, see the documentation_. .. _Infrequently Asked Questions: http://whitenoise.evans.io/en/stable/#infrequently-asked-questions .. _documentation: http://whitenoise.evans.io/en/stable/ Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware Classifier: Framework :: Django Classifier: Framework :: Django :: 1.8 Classifier: Framework :: Django :: 1.9 Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 whitenoise-3.2.2/whitenoise.egg-info/SOURCES.txt0000664000175000017500000000141712772321741021323 0ustar davedave00000000000000CHANGELOG.rst LICENSE MANIFEST.in README.rst setup.cfg setup.py tox.ini docs/Makefile docs/base.rst docs/changelog.rst docs/conf.py docs/django.rst docs/index.rst whitenoise/__init__.py whitenoise/base.py whitenoise/byte_ranges.py whitenoise/compress.py whitenoise/django.py whitenoise/httpstatus_backport.py whitenoise/media_types.py whitenoise/middleware.py whitenoise/static_file.py whitenoise/storage.py whitenoise/utils.py whitenoise.egg-info/PKG-INFO whitenoise.egg-info/SOURCES.txt whitenoise.egg-info/dependency_links.txt whitenoise.egg-info/top_level.txt whitenoise/runserver_nostatic/__init__.py whitenoise/runserver_nostatic/management/__init__.py whitenoise/runserver_nostatic/management/commands/__init__.py whitenoise/runserver_nostatic/management/commands/runserver.pywhitenoise-3.2.2/whitenoise.egg-info/dependency_links.txt0000664000175000017500000000000112772321735023505 0ustar davedave00000000000000 whitenoise-3.2.2/whitenoise.egg-info/top_level.txt0000664000175000017500000000001312772321735022163 0ustar davedave00000000000000whitenoise whitenoise-3.2.2/CHANGELOG.rst0000664000175000017500000000015612670367040015606 0ustar davedave00000000000000Change Log ========== Please see the `documentation `_. whitenoise-3.2.2/LICENSE0000664000175000017500000000206612200675367014577 0ustar davedave00000000000000The MIT License (MIT) Copyright (c) 2013 David Evans Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. whitenoise-3.2.2/MANIFEST.in0000664000175000017500000000027212670367121015322 0ustar davedave00000000000000include README.rst include LICENSE include tox.ini recursive-include whitenoise * recursive-include docs * recursive-exclude * __pycache__ recursive-exclude * *.py[co] prune docs/_build whitenoise-3.2.2/README.rst0000664000175000017500000000321612772265241015257 0ustar davedave00000000000000WhiteNoise ========== .. image:: https://img.shields.io/travis/evansd/whitenoise.svg :target: https://travis-ci.org/evansd/whitenoise :alt: Build Status .. image:: https://img.shields.io/pypi/v/whitenoise.svg :target: https://pypi.python.org/pypi/whitenoise :alt: Latest PyPI version .. image:: https://img.shields.io/github/stars/evansd/whitenoise.svg?style=social&label=Star :target: https://github.com/evansd/whitenoise :alt: GitHub project **Radically simplified static file serving for Python web apps** With a couple of lines of config WhiteNoise allows your web app to serve its own static files, making it a self-contained unit that can be deployed anywhere without relying on nginx, Amazon S3 or any other external service. (Especially useful on Heroku, OpenShift and other PaaS providers.) It's designed to work nicely with a CDN for high-traffic sites so you don't have to sacrifice performance to benefit from simplicity. WhiteNoise works with any WSGI-compatible app but has some special auto-configuration features for Django. WhiteNoise takes care of best-practices for you, for instance: * Serving compressed content (gzip and Brotli formats, handling Accept-Encoding and Vary headers correctly) * Setting far-future cache headers on content which won't change Worried that serving static files with Python is horribly inefficient? Still think you should be using Amazon S3? Have a look at the `Infrequently Asked Questions`_. To get started, see the documentation_. .. _Infrequently Asked Questions: http://whitenoise.evans.io/en/stable/#infrequently-asked-questions .. _documentation: http://whitenoise.evans.io/en/stable/ whitenoise-3.2.2/setup.py0000664000175000017500000000257512666365234015316 0ustar davedave00000000000000import ast import codecs import os import re from setuptools import setup, find_packages PROJECT_ROOT = os.path.abspath(os.path.dirname(__file__)) VERSION_RE = re.compile(r'__version__\s+=\s+(.*)') def read(*path): full_path = os.path.join(PROJECT_ROOT, *path) with codecs.open(full_path, 'r', encoding='utf-8') as f: return f.read() version_string = VERSION_RE.search(read('whitenoise/__init__.py')).group(1) version = str(ast.literal_eval(version_string)) setup( name='whitenoise', version=version, author='David Evans', author_email='d@evans.io', url='http://whitenoise.evans.io', packages=find_packages(exclude=['tests*']), license='MIT', description="Radically simplified static file serving for WSGI applications", long_description=read('README.rst'), classifiers=[ 'Development Status :: 5 - Production/Stable', 'Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware', 'Framework :: Django', 'Framework :: Django :: 1.8', 'Framework :: Django :: 1.9', 'Intended Audience :: Developers', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', ], ) whitenoise-3.2.2/tox.ini0000664000175000017500000000130412772265241015077 0ustar davedave00000000000000[tox] envlist = py27-lint, {py27,py34,py35,pypy}-django{18,19,110,master}, py33-django18, [testenv] basepython = py27: python2.7 py33: python3.3 py34: python3.4 py35: python3.5 pypy: pypy commands = coverage run --branch --include=whitenoise/* -m unittest discover coverage report setenv = PYTHONWARNINGS = all DJANGO_SETTINGS_MODULE = tests.django_settings COVERAGE_FILE = .coverage.{envname} deps = coverage>=4.2,<4.3 requests>=2.11,<2.12 django18: Django>=1.8,<1.9 django19: Django>=1.9,<1.10 django110: Django>=1.10,<1.11 djangomaster: https://github.com/django/django/archive/master.tar.gz [testenv:py27-lint] commands = flake8 --show-source deps = flake8==3.0.4 whitenoise-3.2.2/PKG-INFO0000664000175000017500000000543012772321741014663 0ustar davedave00000000000000Metadata-Version: 1.1 Name: whitenoise Version: 3.2.2 Summary: Radically simplified static file serving for WSGI applications Home-page: http://whitenoise.evans.io Author: David Evans Author-email: d@evans.io License: MIT Description: WhiteNoise ========== .. image:: https://img.shields.io/travis/evansd/whitenoise.svg :target: https://travis-ci.org/evansd/whitenoise :alt: Build Status .. image:: https://img.shields.io/pypi/v/whitenoise.svg :target: https://pypi.python.org/pypi/whitenoise :alt: Latest PyPI version .. image:: https://img.shields.io/github/stars/evansd/whitenoise.svg?style=social&label=Star :target: https://github.com/evansd/whitenoise :alt: GitHub project **Radically simplified static file serving for Python web apps** With a couple of lines of config WhiteNoise allows your web app to serve its own static files, making it a self-contained unit that can be deployed anywhere without relying on nginx, Amazon S3 or any other external service. (Especially useful on Heroku, OpenShift and other PaaS providers.) It's designed to work nicely with a CDN for high-traffic sites so you don't have to sacrifice performance to benefit from simplicity. WhiteNoise works with any WSGI-compatible app but has some special auto-configuration features for Django. WhiteNoise takes care of best-practices for you, for instance: * Serving compressed content (gzip and Brotli formats, handling Accept-Encoding and Vary headers correctly) * Setting far-future cache headers on content which won't change Worried that serving static files with Python is horribly inefficient? Still think you should be using Amazon S3? Have a look at the `Infrequently Asked Questions`_. To get started, see the documentation_. .. _Infrequently Asked Questions: http://whitenoise.evans.io/en/stable/#infrequently-asked-questions .. _documentation: http://whitenoise.evans.io/en/stable/ Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware Classifier: Framework :: Django Classifier: Framework :: Django :: 1.8 Classifier: Framework :: Django :: 1.9 Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 whitenoise-3.2.2/setup.cfg0000664000175000017500000000016212772321741015404 0ustar davedave00000000000000[wheel] universal = 1 [flake8] max-line-length = 100 [egg_info] tag_build = tag_date = 0 tag_svn_revision = 0