{"id":13469287,"url":"https://github.com/meeb/django-distill","last_synced_at":"2025-10-07T11:22:53.225Z","repository":{"id":30813176,"uuid":"34370345","full_name":"meeb/django-distill","owner":"meeb","description":"Minimal configuration static site generator for Django","archived":false,"fork":false,"pushed_at":"2024-08-30T14:07:59.000Z","size":276,"stargazers_count":495,"open_issues_count":0,"forks_count":37,"subscribers_count":9,"default_branch":"master","last_synced_at":"2025-05-10T14:05:12.666Z","etag":null,"topics":["django","django-distill","jamstack","static-site","static-site-generator"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/meeb.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":"CONTRIBUTING.md","funding":".github/FUNDING.yml","license":"LICENSE","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":"SECURITY.md","support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null},"funding":{"github":["meeb"]}},"created_at":"2015-04-22T05:17:49.000Z","updated_at":"2025-05-10T11:35:42.000Z","dependencies_parsed_at":"2023-12-30T05:20:04.450Z","dependency_job_id":"0b3d693f-beaf-436a-9965-0c13ce7b3476","html_url":"https://github.com/meeb/django-distill","commit_stats":{"total_commits":201,"total_committers":14,"mean_commits":"14.357142857142858","dds":"0.13432835820895528","last_synced_commit":"47a21b4a447fa339292c7eff64239b3db7dcd66e"},"previous_names":[],"tags_count":18,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/meeb%2Fdjango-distill","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/meeb%2Fdjango-distill/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/meeb%2Fdjango-distill/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/meeb%2Fdjango-distill/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/meeb","download_url":"https://codeload.github.com/meeb/django-distill/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":254448579,"owners_count":22072764,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["django","django-distill","jamstack","static-site","static-site-generator"],"created_at":"2024-07-31T15:01:32.041Z","updated_at":"2025-10-07T11:22:48.158Z","avatar_url":"https://github.com/meeb.png","language":"Python","funding_links":["https://github.com/sponsors/meeb"],"categories":["Python","django"],"sub_categories":[],"readme":"# django-distill\n\n`django-distill` now has a website. Read more at:\n\n## :link: https://django-distill.com/\n\n`django-distill` is a minimal configuration static site generator and publisher\nfor Django. Most Django versions are supported, however up to date versions are\nadvised including the Django 3.x releases. `django-distill` as of the 1.7 release\nonly supports Python 3. Python 2 support has been dropped. If you require Python 2\nsupport please pin `django-distill` to version 1.6 in your requirements.txt or\nPipfile. Python 3.6 or above is advised.\n\n`django-distill` extends existing Django sites with the ability to export\nfully functional static sites. It is suitable for sites such as blogs that have\na mostly static front end but you still want to use a CMS to manage the\ncontent.\n\n`django-distill` iterates over URLs in your Django project using easy to write\niterable functions to yield the parameters for whatever pages you want to save\nas static HTML. These static files can be automatically uploaded to a bucket-style\nremote container such as Amazon S3, Googe Cloud Files, Microsoft Azure Storage,\nor, written to a local directory as a fully working local static version of\nyour project. The site generation, or distillation process, can be easily\nintegrated into CI/CD workflows to auto-deploy static sites on commit.\n`django-distill` can be defined as an extension to Django to make Django\nprojects compatible with \"Jamstack\"-style site architecture.\n\n`django-distill` plugs directly into the existing Django framework without the\nneed to write custom renderers or other more verbose code. You can also integrate\n`django-distill` with existing dynamic sites and just generate static pages for\na small subsection of pages rather than the entire site.\n\nFor static files on CDNs you can use the following 'cache buster' library to\nallow for fast static media updates when pushing changes:\n\n[:link: meeb/django-cachekiller](https://github.com/meeb/django-cachekiller)\n\nThere is a complete example site that creates a static blog and uses\n`django-distill` with `django-cachekiller` via continuous deployment on Netlify\navailable here:\n\n[:link: meeb/django-distill-example](https://github.com/meeb/django-distill-example)\n\n\n# Installation\n\nInstall from pip:\n\n```bash\n$ pip install django-distill\n```\n\nAdd `django_distill` to your `INSTALLED_APPS` in your `settings.py`:\n\n```python\nINSTALLED_APPS = [\n    # ... other apps here ...\n    'django_distill',\n]\n```\n\nThat's it.\n\n\n# Limitations\n\n`django-distill` generates static pages and therefore only views which allow\n`GET` requests that return an `HTTP 200` status code are supported.\n\nIt is assumed you are using URI parameters such as `/blog/123-abc` and not\nquerystring parameters such as `/blog?post_id=123\u0026title=abc`. Querystring\nparameters do not make sense for static page generation for obvious reasons.\n\nStatic media files such as images and style sheets are copied from your static\nmedia directory defined in `STATIC_ROOT`. This means that you will want to run\n`./manage.py collectstatic` **before** you run `./manage.py distill-local`\nif you have made changes to static media. `django-distill` doesn't chain this\nrequest by design, however you can enable it with the `--collectstatic`\nargument.\n\n\n# Usage\n\nAssuming you have an existing Django project, edit a `urls.py` to include the\n`distill_path` function which replaces Django's standard `path` function and\nsupports the new keyword arguments `distill_func` and `distill_file`.\n\nThe `distill_func` argument should be provided with a function or callable\nclass that returns an iterable or `None`.\n\nThe `distill_file` argument is entirely optional and allows you to override the\nURL that would otherwise be generated from the reverse of the URL regex. This\nallows you to rename URLs like `/example` to any other name like\n`example.html`. As of v0.8 any URIs ending in a slash `/` are automatically\nmodified to end in `/index.html`. You can use format string parameters in the\n`distill_file` to customise the file name, arg values from the URL will be\nsubstituted in, for example `{}` for positional args or `{param_name}` for\nnamed args.\n\nAn example distill setup for a theoretical blogging app would be:\n\n```python\n# Replaces the standard django.conf.path, identical syntax\nfrom django_distill import distill_path\n\n# Views and models from a theoretical blogging app\nfrom blog.views import PostIndex, PostView, PostYear\nfrom blog.models import Post\n\ndef get_index():\n    # The index URI path, '', contains no parameters, named or otherwise.\n    # You can simply just return nothing here.\n    return None\n\ndef get_all_blogposts():\n    # This function needs to return an iterable of dictionaries. Dictionaries\n    # are required as the URL this distill function is for has named parameters.\n    # You can just export a small subset of values here if you wish to\n    # limit what pages will be generated.\n    for post in Post.objects.all():\n        yield {'blog_id': post.id, 'blog_title': post.title}\n\ndef get_years():\n    # You can also just return an iterable containing static strings if the\n    # URL only has one argument and you are using positional URL parameters:\n    return (2014, 2015)\n    # This is really just shorthand for ((2014,), (2015,))\n\nurlpatterns = (\n    # e.g. / the blog index\n    distill_path('',\n                 PostIndex.as_view(),\n                 name='blog-index',\n                 # Note that for paths which have no paramters\n                 # distill_func is optional\n                 distill_func=get_index,\n                 # '' is not a valid file name! override it to index.html\n                 distill_file='index.html'),\n    # e.g. /post/123-some-post-title using named parameters\n    distill_path('post/\u003cint:blog_id\u003e-\u003cslug:blog_title\u003e.html',\n                 PostView.as_view(),\n                 name='blog-post',\n                 distill_func=get_all_blogposts),\n    # e.g. /posts-by-year/2015 using positional parameters\n    # url ends in / so file path will have /index.html appended\n    distill_path('posts-by-year/\u003cint:year\u003e/',\n                 PostYear.as_view(),\n                 name='blog-year',\n                 distill_func=get_years),\n)\n```\n\nYour site will still function identically with the above changes. Internally\nthe `distill_func` and `distill_file` parameters are removed and the URL is\npassed back to Django for normal processing. This has no runtime performance\nimpact as this happens only once upon starting the application.\n\nIf your path has no URI paramters, such as `/` or `/some-static-url` you do\nnot have to specify the `distill_func` parameter if you don't want to. As for\npaths with no parameters the `distill_func` always returns `None`, this is set\nas the default behaviour for `distill_func`s.\n\nYou can use the `distill_re_path` function as well, which replaces the default\n`django.urls.re_path` function. Its usage is identical to the above:\n\n```python\nfrom django_distill import distill_re_path\n\nurlpatterns = (\n    distill_re_path(r'some/regex'\n                    SomeOtherView.as_view(),\n                    name='url-other-view',\n                    distill_func=some_other_func),\n)\n\n```\n\nIf you are using an older version of Django in the 1.x series you can use the\n`distill_url` function instead which replaces the `django.conf.urls.url` or\n`django.urls.url` functions. Its usage is identical to the above:\n\n```python\nfrom django_distill import distill_url\n\nurlpatterns = (\n    distill_url(r'some/regex'\n                SomeView.as_view(),\n                name='url-view',\n                distill_func=some_func),\n)\n```\n\n### Parameters in file names\n\nYou can use standard Python string formatting in `distill_file` as well to enable\nyou to change the output file path for a file if you wish. Note this does not\nupdate the URL used by Django so if you use this make sure your `path` pattern\nmatches the `distill_file` pattern or your links might not work in Django. An\nexample:\n\n```python\n# Override file path with parameters. Values are taken from the URL pattern\nurlpatterns = (\n    distill_path('post/\u003cint:blog_id\u003e-\u003cslug:blog_title\u003e.html',\n                 PostView.as_view(),\n                 name='blog-post',\n                 distill_func=get_all_blogposts,\n                 distill_file=\"post/{blog_id}-{blog_title}.html\"\n)\n```\n\n### Non-standard status codes\n\nAll views rendered by `django-distill` into static pages must return an HTTP 200 status\ncode. If for any reason you need to render a view which does not return an HTTP 200\nstatus code, for example you also want to statically generate a 404 page which has a\nview which (correctly) returns an HTTP 404 status code you can use the\n`distill_status_codes` optional argument to a view. For example:\n\n```python\nfrom django_distill import distill_url\n\nurlpatterns = (\n    distill_url(r'some/regex'\n                SomeView.as_view(),\n                name='url-view',\n                distill_status_codes=(200, 404),\n                distill_func=some_func),\n)\n```\n\nThe optional `distill_status_codes` argument accepts a tuple of status codes as integers\nwhich are permitted for the view to return without raising an error. By default this is\nset to `(200,)` but you can override it if you need to for your site.\n\n### Tracking Django's URL function support\n\n`django-distill` will mirror whatever your installed version of Django supports,\ntherefore at some point the `distill_url` function will cease working in the future\nwhen Django 2.x itself depreciates the `django.conf.urls.url` and `django.urls.url`\nfunctions. You can use `distill_re_path` as a drop-in replacement. It is advisable to\nuse `distill_path` or `distill_re_path` if you're building a new site now.\n\n\n### Internationalization\n\nInternationalization is only supported for URLs, page content is unable to be\ndynamically translated. By default your site will be generated using the\n`LANGUAGE_CODE` value in your `settings.py`. If you also set `settings.USE_I18N` to\n`True` then set other language codes in your `settings.DISTILL_LANGUAGES` value and register\nURLs with `i18n_patterns(...)` then your site will be generated in multiple languges.\nThis assumes your multi-language site works as expected before adding `django-distill`.\n\nFor example if you set `settings.LANGUAGE_CODE = 'en'` your site will be\ngenerated in one language.\n\nIf you have something like this in your `settings.py` instead:\n\n```python\nUSE_I18N = True\n\nDISTILL_LANGUAGES = [\n    'en',\n    'fr',\n    'de',\n]\n```\n\nWhile also using `i18n_patterns`in your `urls.py` like so:\n\n```python\nfrom django.conf.urls.i18n import i18n_patterns\nfrom django_distill import distill_path\n\nurlpatterns = i18n_patterns(\n    distill_path('some-file.html',\n                 SomeView.as_view(),\n                 name='i18n-view',\n                 distill_func=some_func\n    )\n)\n```\n\nThen your views will be generaged as `/en/some-file.html`, `/fr/some-file.html`\nand `/de/some-file.html`. These URLs should work (and be translated) by your\nsite already. `django-distill` doesn't do any translation magic, it just\ncalls the URLs with the language code prefix.\n\n**Note** While the default suggested method is to use `settings.DISTILL_LANGUAGES`\nto keep things seperate `django-distill` will also check `settings.LANGUAGES` for\nlanguage codes.\n\n\n### Sitemaps\n\nYou may need to generate a list of all the URLs registered with `django-distill`.\nFor example, you have a statically generated blog with a few hundred pages and\nyou want to list all of the URLs easily in a `sitemap.xml` or other similar list\nof all URLs. You could wrap your sitemap view in `distill_path` then replicate\nall of your URL generation logic by importing your views `distill_func`s from\nyour `urls.py` and generating these all manually, but given this is quite a hassle\nthere's a built-in helper to generate all your URLs that will be distilled for you.\n\n```python\nfrom django_distill import distilled_urls\n\nfor uri, file_name in distilled_urls():\n    # URI is the generated, complete URI for the page\n    print(uri)        # for example: /blog/my-post-123/\n    # file_name is the actual file name on disk, this may be None or a string\n    print(file_name)  # for example: /blog/my-post-123/index.html\n```\n\n**Note** that `distilled_urls()` will only return URLs after all of your URLs\nin `urls.py` have been loaded with `distill_path(...)`.\n\n\n# The `distill-local` command\n\nOnce you have wrapped the URLs you want to generate statically you can now\ngenerate a complete functioning static site with:\n\n```bash\n$ ./manage.py distill-local [optional /path/to/export/directory]\n```\n\nUnder the hood this simply iterates all URLs registered with `distill_url` and\ngenerates the pages for them using parts of the Django testing framework to\nspoof requests. Once the site pages have been rendered then files from the\n`STATIC_ROOT` are copied over. Existing files with the same name are replaced in\nthe target directory and orphan files are deleted.\n\n`distill-local` supports the following optional arguments:\n\n`--collectstatic`: Automatically run `collectstatic` on your site before\nrendering, this is just a shortcut to save you typing an extra command.\n\n`--quiet`: Disable all output other than asking confirmation questions.\n\n`--force`: Assume 'yes' to all confirmation questions.\n\n`--exclude-staticfiles`: Do not copy any static files at all, only render output from\nDjango views.\n\n`--parallel-render [number of threads]`: Render files in parallel on multiple\nthreads, this can speed up rendering. Defaults to `1` thread.\n\n`--generate-redirects`: Attempt to generate static redirects stored in the\n`django.contrib.redirects` app. If you have a redirect from `/old/` to `/new/` using\nthis flag will create a static HTML `\u003cmeta http-equiv=\"refresh\" content=\"...\"\u003e`\nstyle redirect at `/old/index.html` to `/new/`.\n\n**Note** If any of your views contain a Python error then rendering will fail\nthen the stack trace will be printed to the terminal and the rendering command\nwill exit with a status code of 1.\n\n\n# The `distill-publish` command\n\n```bash\n$ ./manage.py distill-publish [optional destination here]\n```\n\nIf you have configured at least one publishing destination (see below) you can\nuse the `distill-publish` command to publish the site to a remote location.\n\nThis will perform a full synchronisation, removing any remote files that are no\nlonger present in the generated static site and uploading any new or changed\nfiles. The site will be built into a temporary directory locally first when\npublishing which is deleted once the site has been published. Each file will be\nchecked that it has been published correctly by requesting it via the\n`PUBLIC_URL`.\n\n`distill-publish` supports the following optional arguments:\n\n`--collectstatic`: Automatically run `collectstatic` on your site before\nrendering, this is just a shortcut to save you typing an extra command.\n\n`--quiet`: Disable all output other than asking confirmation questions.\n\n`--force`: Assume 'yes' to all confirmation questions.\n\n`--exclude-staticfiles`: Do not copy any static files at all, only render output from\nDjango views.\n\n`--skip-verify`: Do not test if files are correctly uploaded on the server.\n\n`--ignore-remote-content`: Do not fetch the list of remote files. It means that all\nfiles will be uploaded, and no existing remote file will be  deleted. This can be\nuseful if you have a lot of files on the remote server, and you know that you want\nto update most of them, and you don't care if old files remain on the server.\n\n`--parallel-publish [number of threads]`: Publish files in parallel on multiple\nthreads, this can speed up publishing. Defaults to `1` thread.\n\n`--parallel-render [number of threads]`: Render files in parallel on multiple\nthreads, this can speed up rendering. Defaults to `1` thread.\n\n`--generate-redirects`: Attempt to generate static redirects stored in the\n`django.contrib.redirects` app. If you have a redirect from `/old/` to `/new/` using\nthis flag will create a static HTML `\u003cmeta http-equiv=\"refresh\" content=\"...\"\u003e`\nstyle redirect at `/old/index.html` to `/new/`.\n\n**Note** that this means if you use `--force` and `--quiet` that the output\ndirectory will have all files not part of the site export deleted without any\nconfirmation.\n\n**Note**  If any of your views contain a Python error then rendering will fail\nthen the stack trace will be printed to the terminal and the rendering command\nwill exit with a status code of 1.\n\n\n# The `distill-test-publish` command\n\n```bash\n$ ./manage.py distill-test-publish [optional destination here]\n```\n\nThis will connect to your publishing target, authenticate to it, upload a\nrandomly named file, verify it exists on the `PUBLIC_URL` and then delete it\nagain. Use this to check your publishing settings are correct.\n\n`distill-test-publish` has no arguments.\n\n\n# Optional configuration settings\n\nYou can set the following optional `settings.py` variables:\n\n**DISTILL_DIR**: string, default directory to export to:\n\n```python\nDISTILL_DIR = '/path/to/export/directory'\n```\n\n**DISTILL_PUBLISH**: dictionary, like Django's `settings.DATABASES`, supports\n`default`:\n\n```python\nDISTILL_PUBLISH = {\n    'default': {\n        ... options ...\n    },\n    'some-other-target': {\n        ... options ...\n    },\n}\n```\n\n**DISTILL_SKIP_ADMIN_DIRS**: bool, defaults to `True`\n\n```python\nDISTILL_SKIP_ADMIN_DIRS = True\n```\n\nSet `DISTILL_SKIP_ADMIN_DIRS` to `False` if you want `django-distill` to also copy over\nstatic files in the `static/admin` directory. Usually, these are not required or\ndesired for statically generated sites. The default behaviour is to skip static admin\nfiles.\n\n\n**DISTILL_SKIP_STATICFILES_DIRS**: list, defaults to `[]`\n\n```python\nDISTILL_SKIP_STATICFILES_DIRS = ['some_dir']\n```\n\nSet `DISTILL_SKIP_STATICFILES_DIRS` to a list of directory names you want `django-distill`\nto ignore directories in your defined `static/` directory. You can use this to ignore\ncopying directories containing files from apps you're not using that get bundled into your\n`static/` directory by `collect-static`. For example if you set `DISTILL_SKIP_STATICFILES_DIRS`\nto `['some_dir']` the static files directory `static/some_dir` would be skipped.\n\n\n**DISTILL_LANGUAGES**: list, defaults to `[]`\n\n```python\nDISTILL_LANGUAGES = [\n    'en',\n    'fr',\n    'de',\n]\n```\n\nSet `DISTILL_LANGUAGES` to a list of language codes to attempt to render URLs with.\nSee the \"Internationalization\" section for more details.\n\n\n# Developing locally with HTTPS\n\nIf you are using a local development environment which has HTTPS support you may need\nto add `SECURE_SSL_REDIRECT = False` to your `settings.py` to prevent a `CommandError`\nbeing raised when a request returns a 301 redirect instead of the expected HTTP/200\nresponse code.\n\n\n# Writing single files\n\nAs of `django-distill` version `3.0.0` you can use the\n`django_distill.renderer.render_single_file` method to write out a single file\nto disk using `django_distill`. This is useful for writing out single files to disk,\nfor example, you have a Django site which has some static files in a directory\nwritten by `django_distill` but the rest of the site is a normal dynamic Django site.\nYou can update a static HTML file every time a model instance is saved. You can\nuse single file writing with signals to achieve this. For example:\n\n```python\n# in models.py\nfrom django.db.models.signals import post_save\nfrom django.dispatch import receiver\nfrom django_distill.renderer import render_single_file\n\n@receiver(post_save, sender=SomeBlogPostModel)\ndef write_blog_post_static_file_post_save(sender, **kwargs):\n    render_single_file(\n        '/path/to/output/directory',\n        'blog-post-view-name',\n        blog_id=sender.pk,\n        blog_slug=sender.slug\n    )\n```\n\nThe syntax for `render_single_file` is similar to Django's `url.reverse`. The full\nusage interface is:\n\n```python\nrender_single_file(\n    '/path/to/output/directory',\n    'view-name-set-in-urls-py',\n    *view_args,\n    **view_kwargs\n)\n```\n\nFor example, if you had a blog post URL defined as:\n\n```python\n    # in urls.py\n    distill_path('post/\u003cint:blog_id\u003e_\u003cslug:blog_slug\u003e.html',\n                 PostView.as_view(),\n                 name='blog-post',\n                 distill_func=get_all_blogposts),\n```\n\nYour usage would be:\n\n```python\nrender_single_file(\n    '/path/to/output/directory',\n    'blog-post',\n    blog_id=123,\n    blog_slug='blog-title-slug',\n)\n```\n\nwhich would write out the contents of `/post/123_blog-title-slug.html` into\n`/path/to/output/directory` as the file\n`/path/to/output/directory/post/123_blog-title-slug.html`. Note any required\nsub-directories (`/path/to/output/directory/post` in this example) will be\nautomatically created if they don't already exist. All `django-distill` rules\napply, such as URLs ending in `/` will be saved as `/index.html` to make sense\nfor a physical file on disk.\n\nAlso note that `render_single_file` can only be imported and used into an\ninitialised Django project.\n\n\n# Publishing targets\n\nYou can automatically publish sites to various supported remote targets through\nbackends just like how you can use MySQL, SQLite, PostgreSQL etc. with\nDjango by changing the backend database engine. Currently the engines supported\nby `django-distill` are:\n\n**django_distill.backends.amazon_s3**: Publish to an Amazon S3 bucket. Requires\n  the Python library `boto3` (`$ pip install django-distill[amazon]`). The bucket\n  must already exist (use the AWS control panel). Options:\n\n```python\n'some-s3-container': {\n    'ENGINE': 'django_distill.backends.amazon_s3',\n    'PUBLIC_URL': 'http://.../',\n    'ACCESS_KEY_ID': '...',\n    'SECRET_ACCESS_KEY': '...',\n    'BUCKET': '...',\n    'ENDPOINT_URL': 'https://.../',  # Optional, set to use a different S3 endpoint\n    'DEFAULT_CONTENT_TYPE': 'application/octet-stream',  # Optional\n},\n```\n\n**django_distill.backends.google_storage**: Publish to a Google Cloud Storage\n  bucket. Requires the Python libraries `google-api-python-client` and\n  `google-cloud-storage`\n  (`$ pip install django-distill[google]`). The bucket\n  must already exist and be set up to host a public static website (use the\n  Google Cloud control panel). Options:\n\n```python\n'some-google-storage-bucket': {\n    'ENGINE': 'django_distill.backends.google_storage',\n    'PUBLIC_URL': 'https://storage.googleapis.com/[bucket.name.here]/',\n    'BUCKET': '[bucket.name.here]',\n    'JSON_CREDENTIALS': '/path/to/some/credentials.json',\n},\n```\n\nNote that `JSON_CREDENTIALS` is optional; if it is not specified, the google libraries\nwill try other authentication methods, in the search order described here:\nhttps://cloud.google.com/docs/authentication/application-default-credentials (e.g. the\n`GOOGLE_APPLICATION_CREDENTIALS` environment variable, attached service account, etc).\n\n\n**django_distill.backends.microsoft_azure_storage**: Publish to a Microsoft\n  Azure Blob Storage container. Requires the Python library\n  `azure-storage-blob` (`$ pip install django-distill[microsoft]`). The storage\n  account must already exist and be set up to host a public static website\n  (use the Microsoft Azure control panel). Options:\n\n```python\n'some-microsoft-storage-account': {\n    'ENGINE': 'django_distill.backends.microsoft_azure_storage',\n    'PUBLIC_URL': 'https://[storage-account-name]...windows.net/',\n    'CONNECTION_STRING': '...',\n},\n```\n\nNote that each Azure storage account supports one static website using the\nmagic container `$web` which is where `django-distill` will attempt to\npublish your site.\n\n\n# Tests\n\nThere is a minimal test suite, you can run it by cloing this repository,\ninstalling the required dependancies in `requirements.txt` then execuiting:\n\n```bash\n# ./run-tests.py\n```\n\n\n# Contributing\n\nAll properly formatted and sensible pull requests, issues and comments are\nwelcome.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmeeb%2Fdjango-distill","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmeeb%2Fdjango-distill","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmeeb%2Fdjango-distill/lists"}