frozen_flask-1.0.2/docs/conf.py 0000644 0000000 0000000 00000005636 13615410400 013356 0 ustar 00 from datetime import datetime
from pathlib import Path
from re import search
# -- General configuration ----------------------------------------------------
# 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.autodoc',
'sphinx.ext.intersphinx',
'pallets_sphinx_themes',
]
intersphinx_mapping = {
'python': ('https://docs.python.org/3/', None),
'flask': ('https://flask.palletsprojects.com/', None),
'click': ('https://click.palletsprojects.com/', None),
}
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = 'Frozen-Flask'
copyright = f'2010-{datetime.now().year}, Simon Sapin'
# 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 full version, including alpha/beta/rc tags.
_init = Path(__file__).parent.parent / 'flask_frozen' / '__init__.py'
release = search("VERSION = '([^']+)'", _init.read_text()).group(1)
# The short X.Y version.
version = release
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
# Create table of contents entries for domain objects (e.g. functions, classes,
# attributes, etc.). Default is True.
toc_object_entries = False
# -- Options for HTML output --------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'flask'
# A list of CSS files. The entry must be a filename string or a tuple
# containing the filename string and the attributes dictionary. The filename
# must be relative to the html_static_path, or a full URI with scheme like
# https://example.org/style.css. The attributes is used for attributes of
# tag.
html_css_files = ['style.css']
# 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']
# Custom sidebar templates, maps document names to template names.
html_sidebars = {'**': ['sidebarintro.html', 'localtoc.html']}
# Output file base name for HTML help builder.
htmlhelp_basename = 'Frozen-Flask-doc'
# -- Options for manual page output -------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
('index', 'frozen-flask', 'Frozen-Flask Documentation', ['Simon Sapin'], 1)
]
frozen_flask-1.0.2/docs/index.rst 0000644 0000000 0000000 00000050043 13615410400 013710 0 ustar 00 Frozen-Flask
============
.. module:: flask_frozen
Frozen-Flask freezes a `Flask`_ application into a set of static files.
The result can be hosted without any server-side software other than a
traditional web server.
.. _Flask: https://palletsprojects.com/p/flask/
Installation
------------
Install the extension with::
$ pip install Frozen-Flask
or you can get the `source code from GitHub
`_.
Context
-------
This documentation assumes that you already have a working `Flask`_
application. You can run it and test it with the development server::
from myapplication import app
app.run(debug=True)
Frozen-Flask is only about deployment: instead of installing Python,
a WGSI server and Flask on your server, you can use Frozen-Flask to *freeze*
your application and only have static HTML files on your server.
Getting started
---------------
Create a :class:`Freezer` instance with your ``app`` object and call its
:meth:`Freezer.freeze` method. Put that in a ``freeze.py`` script
(or call it whatever you like)::
from flask_frozen import Freezer
from myapplication import app
freezer = Freezer(app)
if __name__ == '__main__':
freezer.freeze()
This will create a ``build`` directory next to your application’s ``static``
and ``templates`` directories, with your application’s content frozen into
static files.
.. note::
Frozen-Flask considers it “owns” its build directory.
By default, it will **silently overwrite** files in that directory,
and **remove** those it did not create.
The `configuration`_ allows you to change the destination directory,
or control what files are removed if at all.
This build will most likely be partial since Frozen-Flask can only guess so
much about your application.
Finding URLs
------------
Frozen-Flask works by simulating requests at the WSGI level and writing the
responses to aptly named files. So it needs to find out which URLs exist
in your application.
The following URLs can be found automatically:
* Static files handled by Flask for your application or any of its
`blueprints `_.
* Views with no variable parts in the URL, if they accept the ``GET`` method.
* *New in version 0.6:* Results of calls to :func:`flask.url_for` made by your
application in the request for another URL.
In other words, if you use :func:`flask.url_for` to create links in your
application, these links will be “followed”.
This means that if your application has an index page at the URL ``/``
(without parameters) and every other page can be found from there by
recursively following links built with :func:`flask.url_for`, then
Frozen-Flask can discover all URLs automatically and you’re done.
Otherwise, you may need to write URL generators.
URL generators
--------------
Let’s say that your application looks like this::
@app.route('/')
def products_list():
return render_template('index.html', products=models.Product.all())
@app.route('/product_/')
def product_details(product_id):
product = models.Product.get_or_404(id=product_id)
return render_template('product.html', product=product)
If, for some reason, some products pages are not linked from another page
(or these links are not built by :func:`flask.url_for`), Frozen-Flask will
not find them.
To tell Frozen-Flask about them, write a URL generator and put it after
creating your :class:`Freezer` instance and before calling
:meth:`Freezer.freeze`::
@freezer.register_generator
def product_details():
for product in models.Product.all():
yield {'product_id': product.id}
Frozen-Flask will find the URL by calling ``url_for(endpoint, **values)`` where
``endpoint`` is the name of the generator function and ``values`` is each
dict yielded by the function.
You can specify a different endpoint by yielding a ``(endpoint, values)``
tuple instead of just ``values``, or you can by-pass ``url_for`` and simply
yield URLs as strings.
You can avoid re-freezing URLs by yielding a tuple ``(endpoint, values, time)``,
where ``time`` is a ``datetime.datetime`` object. The URL will only be frozen
if the corresponding output file doesn't exist, or was last modified earlier
than ``time``.
Also, generator functions do not have to be `Python generators
`_ using ``yield``,
they can be any callable and return any iterable object.
All of these are thus equivalent::
@freezer.register_generator
def product_details(): # endpoint defaults to the function name
# `values` dicts
yield {'product_id': '1'}
yield {'product_id': '2'}
@freezer.register_generator
def product_url_generator(): # Some other function name
# `(endpoint, values)` tuples
yield 'product_details', {'product_id': '1'}
yield 'product_details', {'product_id': '2'}
@freezer.register_generator
def product_url_generator():
# URLs as strings
yield '/product_1/'
yield '/product_2/'
@freezer.register_generator
def product_url_generator():
# Return a list. (Any iterable type will do.)
return [
'/product_1/',
# Mixing forms works too.
('product_details', {'product_id': '2'}),
]
Generating the same URL more than once is okay, Frozen-Flask will build it
only once. Having different functions with the same name is generally a bad
practice, but still work here as they are only used by their decorators.
In practice you will probably have a module for your views and another one
for the freezer and URL generators, so having the same name is not a problem.
Testing URL generators
----------------------
The idea behind Frozen-Flask is that you can `use Flask directly
<#context>`_ to develop and test your application. However, it is
also useful to test your *URL generators* and see that nothing is missing,
before deploying to a production server.
You can open the newly generated static HTML files in a web browser, but
links probably won’t work. The ``FREEZER_RELATIVE_URLS`` `configuration`_
can fix this, but adds a visible ``index.html`` to the links.
Alternatively, use the :meth:`Freezer.run`
method to start an HTTP server on the build result,
so you can check that everything is fine before uploading::
if __name__ == '__main__':
freezer.run(debug=True)
:meth:`Freezer.run` will freeze your application before serving and when
the reloader kicks in. But the reloader only watches Python files, not
templates or static files. Because of that, you probably want to use
:meth:`Freezer.run` only for testing the URL generators. For everything
else use the usual :meth:`app.run() `.
`Flask-Script `_ may come in handy
here.
Controlling What Is Followed
----------------------------
Frozen-Flask follows links automatically or with some help from URL generators.
If you want to control what gets followed, then URL generators should be used
with the Freezer's ``with_no_argument_rules`` and ``log_url_for`` flags.
Disabling these flags will force Frozen-Flask to use URL generators only. The
combination of these three elements determines how much Frozen-Flask will
follow.
Configuration
-------------
Frozen-Flask can be configured using Flask’s `configuration system
`_. The following configuration values
are accepted:
``FREEZER_BASE_URL``
Full URL your application is supposed to be installed at. This affects
the output of :func:`flask.url_for` for absolute URLs (with
``_external=True``) or if your application is not at the root of its
domain name.
Defaults to ``'http://localhost/'``.
``FREEZER_RELATIVE_URLS``
If set to ``True``, Frozen-Flask will patch the Jinja environment so that
``url_for()`` returns relative URLs. Defaults to ``False``.
Python code is not affected unless you use :func:`relative_url_for`
explicitly. This enables the frozen site to be browsed without a web server
(opening the files directly in a browser) but appends a visible
``index.html`` to URLs that would otherwise end with ``/``.
.. versionadded:: 0.10
``FREEZER_DEFAULT_MIMETYPE``
The MIME type that is assumed when it can not be determined from the
filename extension. If you’re using the Apache web server, this should
match the ``DefaultType`` value of Apache’s configuration.
Defaults to ``application/octet-stream``.
.. versionadded:: 0.7
``FREEZER_IGNORE_MIMETYPE_WARNINGS``
If set to ``True``, Frozen-Flask won't show warnings if the MIME type
returned from the server doesn't match the MIME type derived from the
filename extension. Defaults to ``False``.
.. versionadded:: 0.8
``FREEZER_DESTINATION``
Path to the directory where to put the generated static site. If relative,
interpreted as relative to the application root, next to the ``static`` and
``templates`` directories. Defaults to ``build``.
``FREEZER_REMOVE_EXTRA_FILES``
If set to ``True`` (the default),
Frozen-Flask will remove files in the destination directory
that were not built during the current freeze.
This is intended to clean up files
generated by a previous call to :meth:`Freezer.freeze`
that are no longer needed.
Setting this to ``False`` is equivalent to
setting ``FREEZER_DESTINATION_IGNORE`` to ``['*']``.
.. versionadded:: 0.5
``FREEZER_DESTINATION_IGNORE``
A list (defaults empty) of :mod:`fnmatch` patterns.
Files or directories in the destination that match any of the patterns
are not removed,
even if ``FREEZER_REMOVE_EXTRA_FILES`` is true.
As in ``.gitignore`` files,
patterns apply to the whole path if they contain a slash ``/``,
to each slash-separated part otherwise.
For example, this could be set to ``['.git*']``
if the destination is a git repository.
.. versionadded:: 0.10
``FREEZER_STATIC_IGNORE``
A list (defaults empty) of :mod:`fnmatch` patterns.
Files served by send_static_file that match any of the patterns
are not copied to the build directory.
As in ``.gitignore`` files,
patterns apply to the whole path if they contain a slash ``/``,
to each slash-separated part otherwise.
For example, this could be set to ``['*.scss']``
to stop all SASS files from being frozen.
.. versionadded:: 0.12
``FREEZER_IGNORE_404_NOT_FOUND``
If set to ``True`` (defaults ``False``), Frozen-Flask won't stop freezing
when a 404 error is returned by your application.
In this case, a warning will be printed on stdout and the static page will
be generated using your 404 error page handler or flask's default one.
This can be useful during development phase if you have already referenced
pages which aren't written yet.
.. versionadded:: 0.12
``FREEZER_REDIRECT_POLICY``
The policy for handling redirects. This can be:
* ``'follow'`` (default): when a redirect response is encountered,
Frozen-Flask will follow it to get the content from the redirected
location. Note that redirects to external pages are not supported.
* ``'ignore'``: freezing will continue, but no content will appear in the
redirecting location.
* ``'error'`` : raise an exception if a redirect is encountered.
.. versionadded:: 0.13
``FREEZER_SKIP_EXISTING``
If set to ``True`` (defaults ``False``), Frozen-Flask will skip the
generation of files that already exist in the build directory, even if the
contents would have been different. If set to a function that takes two
arguments ``url`` and ``filename`` and returns a ``bool``, a file is
skipped only if the return value of the function is ``True`` when passed
the URL and on-disk path of the file. Useful if your generation takes up a
very long time and you want to skip some or all of the existing files.
.. versionadded:: 0.14
.. versionadded:: 0.16
``FREEZER_SKIP_EXISTING`` now accepts function values.
.. _mime-types:
Filenames and MIME types
------------------------
For each generated URL, Frozen-Flask simulates a request and saves the content
in a file in the ``FREEZER_DESTINATION`` directory. The filename is
built from the URL. URLs with a trailing slash are interpreted as a directory
name and the content is saved in ``index.html``.
Query strings are removed from URLs to build filenames. For example,
``/lorem/?page=ipsum`` is saved to ``lorem/index.html``. URLs that are only
different by their query strings are considered the same, and they should
return the same response. Otherwise, the behavior is undefined.
Additionally, the extension checks that the filename has an extension that
matches the MIME type given in the ``Content-Type`` HTTP response header.
In case of mismatch, the Content-Type that a static web server will send
will probably not be the one you expect, so Frozen-Flask issues a warning.
For example, the following views are both wrong::
@app.route('/lipsum')
def lipsum():
return '
Lorem ipsum, ...
'
@app.route('/style.css')
def compressed_css():
return '/* ... */'
as the default ``Content-Type`` in Flask is ``text/html; charset=utf-8``, but
the MIME types guessed by the Frozen-Flask as well as most web servers from the
filenames are ``application/octet-stream`` and ``text/css``.
This can be fixed by adding a trailing slash to the URL or serving with the
right ``Content-Type``::
# Saved as `lipsum/index.html` matches the 'text/html' MIME type.
@app.route('/lipsum/')
def lipsum():
return '
frozen_flask-1.0.2/flask_frozen/__init__.py 0000644 0000000 0000000 00000054206 13615410400 015720 0 ustar 00 """
flask_frozen
~~~~~~~~~~~~
Frozen-Flask freezes a Flask application into a set of static files.
The result can be hosted without any server-side software other than a
traditional web server.
:copyright: (c) 2010-2012 by Simon Sapin.
:license: BSD, see LICENSE for more details.
"""
__all__ = ['Freezer', 'walk_directory', 'relative_url_for']
import collections
import datetime
import mimetypes
import os
import posixpath
import warnings
from collections import namedtuple
from collections.abc import Mapping
from contextlib import contextmanager, suppress
from fnmatch import fnmatch
from pathlib import Path
from threading import Lock
from unicodedata import normalize
from urllib.parse import unquote, urlsplit
from flask import (Blueprint, Flask, redirect, request, send_from_directory,
url_for)
VERSION = '1.0.2'
class FrozenFlaskWarning(Warning):
pass
class MissingURLGeneratorWarning(FrozenFlaskWarning):
pass
class MimetypeMismatchWarning(FrozenFlaskWarning):
pass
class NotFoundWarning(FrozenFlaskWarning):
pass
class RedirectWarning(FrozenFlaskWarning):
pass
Page = namedtuple('Page', 'url path')
class Freezer:
"""Flask app freezer.
:param app: your application or None if you use :meth:`init_app`
:type app: :class:`flask.Flask`
:param bool with_static_files: Whether to automatically generate URLs for
static files.
:param bool with_no_argument_rules: Whether to automatically generate URLs
for URL rules that take no arguments.
:param bool log_url_for: Whether to log calls your app makes to
:func:`flask.url_for` and generate URLs from that.
.. versionadded:: 0.6
"""
def __init__(self, app=None, with_static_files=True,
with_no_argument_rules=True, log_url_for=True):
self.url_generators = []
self.log_url_for = log_url_for
if with_static_files:
self.register_generator(self.static_files_urls)
if with_no_argument_rules:
self.register_generator(self.no_argument_rules_urls)
self.init_app(app)
def init_app(self, app):
"""Allow to register an app after the Freezer initialization.
:param app: your Flask application
"""
self.app = app
if app:
self.url_for_logger = UrlForLogger(app)
app.config.setdefault('FREEZER_DESTINATION', 'build')
app.config.setdefault('FREEZER_DESTINATION_IGNORE', [])
app.config.setdefault('FREEZER_STATIC_IGNORE', [])
app.config.setdefault('FREEZER_BASE_URL', None)
app.config.setdefault('FREEZER_REMOVE_EXTRA_FILES', True)
app.config.setdefault('FREEZER_DEFAULT_MIMETYPE',
'application/octet-stream')
app.config.setdefault('FREEZER_IGNORE_MIMETYPE_WARNINGS', False)
app.config.setdefault('FREEZER_RELATIVE_URLS', False)
app.config.setdefault('FREEZER_IGNORE_404_NOT_FOUND', False)
app.config.setdefault('FREEZER_REDIRECT_POLICY', 'follow')
app.config.setdefault('FREEZER_SKIP_EXISTING', False)
def register_generator(self, function):
"""Register a function as an URL generator.
The function should return an iterable of URL paths or
``(endpoint, values)`` tuples to be used as
``url_for(endpoint, **values)``.
:Returns: the function, so that it can be used as a decorator
"""
self.url_generators.append(function)
# Allow use as a decorator
return function
@property
def root(self):
"""Absolute path to the directory Frozen-Flask writes to.
Resolved value for the ``FREEZER_DESTINATION`` configuration_.
"""
root = Path(self.app.root_path)
return root / self.app.config['FREEZER_DESTINATION']
def freeze_yield(self):
"""Like :meth:`freeze` but yields info while processing pages.
Yields :func:`namedtuples `
``(url, path)``. This can be used to display progress information,
such as printing the information to standard output, or even more
sophisticated, e.g. with a :func:`progressbar `::
import click
with click.progressbar(
freezer.freeze_yield(),
item_show_func=lambda p: p.url if p else 'Done!') as urls:
for url in urls:
# everything is already happening, just pass
pass
"""
remove_extra = self.app.config['FREEZER_REMOVE_EXTRA_FILES']
self.root.mkdir(parents=True, exist_ok=True)
seen_urls = set()
seen_endpoints = set()
built_paths = set()
for url, endpoint, last_modified in self._generate_all_urls():
seen_endpoints.add(endpoint)
if url in seen_urls:
# Don't build the same URL more than once
continue
seen_urls.add(url)
new_path = self._build_one(url, last_modified)
built_paths.add(new_path)
yield Page(url, new_path.relative_to(self.root))
self._check_endpoints(seen_endpoints)
if remove_extra:
# Remove files from the previous build that are not here anymore.
ignore = self.app.config['FREEZER_DESTINATION_IGNORE']
previous_paths = set(
Path(self.root / name) for name in
walk_directory(self.root, ignore=ignore))
for extra_path in previous_paths - built_paths:
extra_path.unlink()
with suppress(OSError):
extra_path.parent.rmdir()
def freeze(self):
"""Clean the destination and build all URLs from generators."""
return set(page.url for page in self.freeze_yield())
def all_urls(self):
"""Run all generators and yield URLs relative to the app root.
May be useful for testing URL generators.
.. note::
This does not generate any page, so URLs that are normally
generated from :func:`flask.url_for` calls will not be included
here.
"""
for url, _, _ in self._generate_all_urls():
yield url
def _script_name(self):
"""Return the path part of FREEZER_BASE_URL, without trailing slash."""
base_url = self.app.config['FREEZER_BASE_URL']
return urlsplit(base_url or '').path.rstrip('/')
def _generate_all_urls(self):
"""Run all generators and yield (url, endpoint) tuples."""
script_name = self._script_name()
# Charset is always set to UTF-8 since Werkzeug 2.3.0
url_encoding = getattr(self.app.url_map, 'charset', 'utf-8')
url_generators = list(self.url_generators)
url_generators += [self.url_for_logger.iter_calls]
# A request context is required to use url_for
with self.app.test_request_context(base_url=script_name or None):
for generator in url_generators:
for generated in generator():
if isinstance(generated, str):
url = generated
endpoint = None
last_modified = None
else:
if isinstance(generated, Mapping):
values = generated
# The endpoint defaults to the name of the
# generator function, just like with Flask views.
endpoint = generator.__name__
last_modified = None
else:
# Assume a tuple.
if len(generated) == 2:
endpoint, values = generated
last_modified = None
else:
endpoint, values, last_modified = generated
url = url_for(endpoint, **values)
assert url.startswith(script_name), (
f'url_for returned an URL {url} not starting with '
f'script_name {script_name!r}. Bug in Werkzeug?'
)
url = url[len(script_name):]
# flask.url_for "quotes" URLs, eg. a space becomes %20
url = unquote(url)
parsed_url = urlsplit(url)
if parsed_url.scheme or parsed_url.netloc:
raise ValueError(f'External URLs not supported: {url}')
# Remove any query string and fragment:
url = parsed_url.path
if not isinstance(url, str):
url = url.decode(url_encoding)
yield url, endpoint, last_modified
def _check_endpoints(self, seen_endpoints):
"""Warn if some of the app's endpoints are not in seen_endpoints."""
get_endpoints = set(
rule.endpoint for rule in self.app.url_map.iter_rules()
if 'GET' in rule.methods)
not_generated_endpoints = get_endpoints - seen_endpoints
if self.static_files_urls in self.url_generators:
# Special case: do not warn when there is no static file
not_generated_endpoints -= set(self._static_rules_endpoints())
if not_generated_endpoints:
endpoints = ', '.join(str(e) for e in not_generated_endpoints)
warnings.warn(
f'Nothing frozen for endpoints {endpoints}. '
'Did you forget a URL generator?',
MissingURLGeneratorWarning,
stacklevel=3)
def _build_one(self, url, last_modified=None):
"""Get the given ``url`` from the app and write the matching file."""
client = self.app.test_client()
base_url = self.app.config['FREEZER_BASE_URL']
redirect_policy = self.app.config['FREEZER_REDIRECT_POLICY']
follow_redirects = redirect_policy == 'follow'
ignore_redirect = redirect_policy == 'ignore'
destination_path = normalize('NFC', self.urlpath_to_filepath(url))
path = self.root / destination_path
skip = self.app.config['FREEZER_SKIP_EXISTING']
if callable(skip):
skip = skip(url, str(path))
if path.is_file():
mtime = datetime.datetime.fromtimestamp(path.stat().st_mtime)
if (last_modified is not None and mtime >= last_modified) or skip:
return path
with conditional_context(self.url_for_logger, self.log_url_for):
with conditional_context(patch_url_for(self.app),
self.app.config['FREEZER_RELATIVE_URLS']):
response = client.get(url, follow_redirects=follow_redirects,
base_url=base_url)
# The client follows redirects by itself
# Any other status code is probably an error
# except we explicitly want 404 errors to be skipped
# (eg. while application is in development)
ignore_404 = self.app.config['FREEZER_IGNORE_404_NOT_FOUND']
if response.status_code != 200:
if response.status_code == 404 and ignore_404:
warnings.warn(f'Ignored {response.status!r} on URL {url}',
NotFoundWarning,
stacklevel=3)
elif response.status_code in (301, 302) and ignore_redirect:
warnings.warn(f'Ignored {response.status!r} on URL {url}',
RedirectWarning,
stacklevel=3)
else:
raise ValueError(
f'Unexpected status {response.status!r} on URL {url}')
if not self.app.config['FREEZER_IGNORE_MIMETYPE_WARNINGS']:
# Most web servers guess the mime type of static files by their
# filename. Check that this guess is consistent with the actual
# Content-Type header we got from the app.
guessed_type, guessed_encoding = mimetypes.guess_type(path.name)
if not guessed_type:
# Used by most server when they can not determine the type
guessed_type = self.app.config['FREEZER_DEFAULT_MIMETYPE']
if not guessed_type == response.mimetype:
warnings.warn(
f'Filename extension of {path.name!r} '
f'(type {guessed_type}) does not match '
f'Content-Type: {response.content_type}',
MimetypeMismatchWarning,
stacklevel=3)
# Create directories as needed
path.parent.mkdir(parents=True, exist_ok=True)
# Write the file, but only if its content has changed
content = response.data
previous_content = path.read_bytes() if path.is_file() else None
if content != previous_content:
# Do not overwrite when content hasn't changed to help rsync
# by keeping the modification date.
path.write_bytes(content)
response.close()
return path
def urlpath_to_filepath(self, path):
"""Convert URL path like /admin/ to file path like admin/index.html."""
if path.endswith('/'):
path += 'index.html'
# Remove the initial slash that should always be there
assert path.startswith('/')
return path[1:]
def serve(self, **options):
"""Run an HTTP server on the result of the build.
:param options: passed to :meth:`flask.Flask.run`.
"""
app = self.make_static_app()
script_name = self._script_name()
app.wsgi_app = script_name_middleware(app.wsgi_app, script_name)
app.run(**options)
def run(self, **options):
"""Same as :meth:`serve` but calls :meth:`freeze` before serving."""
self.freeze()
self.serve(**options)
def make_static_app(self):
"""Return a Flask application serving the build destination."""
def dispatch_request():
filename = self.urlpath_to_filepath(request.path)
# Override the default mimeype from settings
guessed_type, _ = mimetypes.guess_type(filename)
if not guessed_type:
guessed_type = self.app.config['FREEZER_DEFAULT_MIMETYPE']
return send_from_directory(
self.root, filename, mimetype=guessed_type)
app = Flask(__name__)
# Do not use the URL map
app.dispatch_request = dispatch_request
return app
def _static_rules_endpoints(self):
"""Yield the 'static' URL rules for the app and all blueprints."""
send_static_file_functions = (
unwrap_method(Flask.send_static_file),
unwrap_method(Blueprint.send_static_file))
for rule in self.app.url_map.iter_rules():
view = self.app.view_functions[rule.endpoint]
if unwrap_method(view) in send_static_file_functions:
yield rule.endpoint
# Flask has historically always used the literal string 'static' to
# refer to the static file serving endpoint. Arguably this could
# be considered fragile; equally it is unlikely to change. See
# https://github.com/pallets/flask/discussions/4136 for some
# related discussion.
elif rule.endpoint == 'static':
yield rule.endpoint
def static_files_urls(self):
"""URL generator for static files for app and all its blueprints."""
for endpoint in self._static_rules_endpoints():
view = self.app.view_functions[endpoint]
app_or_blueprint = method_self(view) or self.app
root = app_or_blueprint.static_folder
ignore = self.app.config['FREEZER_STATIC_IGNORE']
if root is None or not Path(root).is_dir():
# No 'static' directory for this app/blueprint.
continue
for filename in walk_directory(root, ignore=ignore):
yield endpoint, {'filename': filename}
def no_argument_rules_urls(self):
"""URL generator for URL rules that take no arguments."""
for rule in self.app.url_map.iter_rules():
if not rule.arguments and 'GET' in rule.methods:
yield rule.endpoint, {}
def walk_directory(root, ignore=()):
"""Walk the `root` folder and yield slash-separated paths relative to root.
Used to implement the URL generator for static files.
:param ignore:
A list of :mod:`fnmatch` patterns.
As in ``.gitignore`` files,
patterns that contain a slash are matched against the whole path,
others against individual slash-separated parts.
"""
for dir, dirs, filenames in os.walk(root):
relative_dir = Path(dir).relative_to(root)
dir_path = str(relative_dir)
# Filter ignored directories
patterns = [
full_pattern for pattern in ignore for full_pattern in (
pattern.rstrip('/'),
f'{pattern}*',
f'*/{pattern.rstrip("/")}',
f'*/{pattern}*',
)
]
if any(fnmatch(dir_path, pattern) for pattern in patterns):
continue
# Filter ignored filenames
for filename in filenames:
path = str(relative_dir / filename)
if os.sep != '/':
path = path.replace(os.sep, '/')
for pattern in ignore:
if '/' in pattern.rstrip('/'):
if fnmatch(path, f'{pattern.lstrip("/")}*'):
break
elif not pattern.endswith('/'):
if fnmatch(filename, pattern):
break
else:
# See https://github.com/SimonSapin/Frozen-Flask/issues/5
yield normalize('NFC', path)
@contextmanager
def patch_url_for(app):
"""Patches ``url_for`` in Jinja globals to use :func:`relative_url_for`.
This is a context manager, to be used in a ``with`` statement.
"""
previous_url_for = app.jinja_env.globals['url_for']
app.jinja_env.globals['url_for'] = relative_url_for
try:
yield
finally:
app.jinja_env.globals['url_for'] = previous_url_for
def relative_url_for(endpoint, **values):
"""Like :func:`flask.url_for`, but returns relative URLs if possible.
Absolute URLs (with ``_external=True`` or to a different subdomain) are
unchanged, but eg. ``/foo/bar`` becomes ``../bar``, depending on the
current request context's path. (This, of course, requires a Flask
:doc:`request context `.)
URLs that would otherwise end with ``/`` get ``index.html`` appended,
as Frozen-Flask does in filenames. Because of this behavior, this function
should only be used with Frozen-Flask, not when running the application in
:meth:`app.run() ` or another WSGI sever.
If the ``FREEZER_RELATIVE_URLS`` `configuration`_ is True, Frozen-Flask
will automatically patch the application's Jinja environment so that
``url_for`` in templates is this function.
"""
url = url_for(endpoint, **values)
# absolute URLs in http://... (with subdomains or _external=True)
if not url.startswith('/'):
return url
url, fragment_sep, fragment = url.partition('#')
url, query_sep, query = url.partition('?')
if url.endswith('/'):
url += 'index.html'
url += query_sep + query + fragment_sep + fragment
request_path = request.path
if not request_path.endswith('/'):
request_path = posixpath.dirname(request_path)
return posixpath.relpath(url, request_path)
def unwrap_method(method):
"""Return the function object for the given method object."""
return getattr(method, '__func__', method)
def method_self(method):
"""Return the instance a bound method is attached to."""
return getattr(method, '__self__', None)
@contextmanager
def conditional_context(context, condition):
"""Wrap a context manager but only enter/exit it if condition is true."""
if condition:
with context:
yield
else:
yield
class UrlForLogger:
"""Log all calls to url_for() for this app made inside the with block.
Use this object as a context manager in a with block to enable logging.
"""
def __init__(self, app):
self.app = app
self.logged_calls = collections.deque()
self._enabled = False
self._lock = Lock()
def logger(endpoint, values):
# Make a copy of values as other @app.url_defaults functions are
# meant to mutate this dict.
if self._enabled:
self.logged_calls.append((endpoint, values.copy()))
# Do not use app.url_defaults() as we want to insert at the front
# of the list to get unmodified values.
self.app.url_default_functions.setdefault(None, []).insert(0, logger)
def __enter__(self):
self._lock.acquire()
self._enabled = True
def __exit__(self, exc_type, exc_value, traceback):
self._enabled = False
self._lock.release()
def iter_calls(self):
"""Yield logged calls of endpoints.
Return an iterable of (endpoint, values_dict) tuples, one for each call
that was made while the logger was enabled.
"""
# "Iterate" on the call deque while it is still being appended to.
while self.logged_calls:
yield self.logged_calls.popleft()
def script_name_middleware(application, script_name):
"""Wrap a WSGI app in a middleware to handle custom base URL.
The middleware moves ``script_name`` from the environ's PATH_INFO to
SCRIPT_NAME if it is there, and redirect to ``script_name`` otherwise.
"""
def new_application(environ, start_response):
path_info = environ['PATH_INFO']
if path_info.startswith(script_name):
environ['SCRIPT_NAME'] += script_name
environ['PATH_INFO'] = path_info[len(script_name):]
next = application
else:
next = redirect(script_name + '/')
return next(environ, start_response)
return new_application
frozen_flask-1.0.2/tests/test_frozen_flask.py 0000644 0000000 0000000 00000044772 13615410400 016371 0 ustar 00 """
Automated test suite for Frozen-Flask.
Run with pytest.
:copyright: (c) 2010-2012 by Simon Sapin.
:license: BSD, see LICENSE for more details.
"""
import sys
import time
import warnings
from datetime import datetime
from pathlib import Path
from subprocess import STDOUT, check_output
from unicodedata import normalize
import flask_frozen
from flask import redirect
from flask_frozen import (Freezer, FrozenFlaskWarning, MimetypeMismatchWarning,
MissingURLGeneratorWarning, NotFoundWarning,
RedirectWarning, walk_directory)
from pytest import raises, warns
import test_app
def read_all(directory):
return {
filename: (Path(directory) / filename).read_bytes()
for filename in walk_directory(directory)}
def normalize_set(set):
# Fix for https://github.com/SimonSapin/Frozen-Flask/issues/5
return {normalize('NFC', name) for name in set}
def test_walk_directory():
directory = Path(test_app.__file__).parent
paths = {
'__init__.py', 'static/favicon.ico', 'static/main.js',
'admin/__init__.py', 'admin/templates/admin.html'}
ignore_patterns = (
('*.pyc', '*.pyo', '*.css'),
('*.py?', '*/*/*.css', '*/*.css'),
('*.py?', '*.css', '/templates'),
('*.py?', '*.css', '/templates/*'),
('*.py?', '*.css', 'templates/*'),
('*.py?', '*.css', 'templates/admin.html'),
('*.py?', '*.css', 'tem*es/*'),
('*.py?', '*.css', '__init__.py/'),
('*.py?', '*.css', '/__init__.py/'),
)
for ignore in ignore_patterns:
assert set(walk_directory(directory, ignore)) == paths
assert {
filename for filename in walk_directory(directory)
if not filename.endswith(('.pyc', '.pyo', '.css'))} == paths
paths = {path for path in paths if not path.startswith('admin/')}
ignore_patterns = (
('*.py?', '*.css', '/admin'),
('*.py?', '*.css', 'admin/'),
('*.py?', '*.css', '/admin/'),
('*.py?', '*.css', '/a*n/'),
('*.py?', '*.css', 'admin/*'),
('*.py?', '*.css', 'admin*'),
('*.py?', '*.css', 'admin'),
('*.py?', '*.css', 'admin/__init__.py', 'templates'),
('*.py?', '*.css', 'admin/__init__.py', 'templates/'),
)
for ignore in ignore_patterns:
assert set(walk_directory(directory, ignore)) == paths
def test_warnings_share_common_superclass():
with warns() as logged_warnings:
# ignore all warnings:
warnings.simplefilter('ignore')
# but don't ignore FrozenFlaskWarning
warnings.filterwarnings('always', category=FrozenFlaskWarning)
# warn each of our warnings:
warnings_frozen_flask = (MissingURLGeneratorWarning,
MimetypeMismatchWarning,
NotFoundWarning,
RedirectWarning)
for warning in warnings_frozen_flask:
warnings.warn('test', warning)
# warn something different:
warnings.warn('test', PendingDeprecationWarning)
assert len(logged_warnings) == len(warnings_frozen_flask)
def test_importing_collections():
flask_script_path = flask_frozen.__file__
ps = check_output([sys.executable, flask_script_path], stderr=STDOUT)
stderr = ps.decode().lower()
assert 'deprecationwarning' not in stderr
assert 'using or importing the abcs' not in stderr
class TestFreezer:
# URL -> expected bytes content of the generated file
expected_output = {
'/': b'Main index /product_5/?revision=b12ef20',
'/redirect/': b'Main index /product_5/?revision=b12ef20',
'/admin/': (
b'Admin index\n'
b'Unicode test\n'
b''
b'URL parsing test'),
'/robots.txt': b'User-agent: *\nDisallow: /',
'/favicon.ico': Path(test_app.FAVICON).read_bytes(),
'/product_0/': b'Product num 0',
'/product_1/': b'Product num 1',
'/product_2/': b'Product num 2',
'/product_3/': b'Product num 3',
'/product_4/': b'Product num 4',
'/product_5/': b'Product num 5',
'/static/favicon.ico': Path(test_app.FAVICON).read_bytes(),
'/static/style.css': b'/* Main CSS */',
'/static/main.js': b'/* Main JS */',
'/admin/css/style.css': b'/* Admin CSS */',
'/where_am_i/': b'/where_am_i/ http://localhost/where_am_i/',
'/page/foo/': 'Hello\xa0World! foo'.encode(),
'/page/I løvë Unicode/':
'Hello\xa0World! I løvë Unicode'.encode(),
'/page/octothorp/':
'Hello\xa0World! octothorp'.encode(),
}
# URL -> path to the generated file, relative to the build destination root
filenames = {
'/': 'index.html',
'/redirect/': 'redirect/index.html',
'/admin/': 'admin/index.html',
'/robots.txt': 'robots.txt',
'/favicon.ico': 'favicon.ico',
'/product_0/': 'product_0/index.html',
'/product_1/': 'product_1/index.html',
'/product_2/': 'product_2/index.html',
'/product_3/': 'product_3/index.html',
'/product_4/': 'product_4/index.html',
'/product_5/': 'product_5/index.html',
'/static/style.css': 'static/style.css',
'/static/main.js': 'static/main.js',
'/static/favicon.ico': 'static/favicon.ico',
'/admin/css/style.css': 'admin/css/style.css',
'/where_am_i/': 'where_am_i/index.html',
'/page/foo/': 'page/foo/index.html',
'/page/I løvë Unicode/': 'page/I løvë Unicode/index.html',
'/page/octothorp/': 'page/octothorp/index.html',
}
assert set(expected_output.keys()) == set(filenames.keys())
generated_by_url_for = ['/product_3/', '/product_4/', '/product_5/',
'/page/I løvë Unicode/',
'/page/octothorp/']
defer_init_app = True
freezer_kwargs = None
with_404 = False
def make_app(self, tmp_path, with_404=False):
app, freezer = test_app.create_app(
self.defer_init_app, self.freezer_kwargs)
app.config['FREEZER_DESTINATION'] = tmp_path
app.debug = True
self.do_extra_config(app, freezer)
if with_404:
@freezer.register_generator
def non_existent_url():
yield '/404/'
return app, freezer
def freeze_app(self, tmp_path):
app, freezer = self.make_app(tmp_path)
return app, freezer, freezer.freeze()
def do_extra_config(self, app, freezer):
pass # To be overridden
def test_without_app(self):
freezer = Freezer()
with raises(Exception):
freezer.freeze()
def test_all_urls_method(self, tmp_path):
app, freezer, urls = self.freeze_app(tmp_path)
expected = sorted(self.expected_output)
# url_for() calls are not logged when just calling .all_urls()
for url in self.generated_by_url_for:
if url in expected:
expected.remove(url)
# Do not use set() here: also test that URLs are not duplicated.
assert sorted(freezer.all_urls()) == expected
def test_built_urls(self, tmp_path):
app, freezer, urls = self.freeze_app(tmp_path)
assert set(urls) == set(self.expected_output)
# Make sure it was not accidentally used as a destination
default = Path(__file__).parent / 'build'
assert not default.exists()
def test_contents(self, tmp_path):
app, freezer, urls = self.freeze_app(tmp_path)
for url, filename in self.filenames.items():
content = (freezer.root / filename).read_bytes()
assert content == self.expected_output[url]
def test_nothing_else_matters(self, tmp_path):
self._extra_files(tmp_path, removed=True)
def test_something_else_matters(self, tmp_path):
self._extra_files(tmp_path, remove_extra=False, removed=False)
def test_ignore_pattern(self, tmp_path):
self._extra_files(tmp_path, ignore=['extro'], removed=True) # No match
self._extra_files(tmp_path, ignore=['extr*'], removed=False) # Match
def _extra_files(self, tmp_path, removed, remove_extra=True, ignore=()):
app, freezer, urls = self.freeze_app(tmp_path)
app.config['FREEZER_REMOVE_EXTRA_FILES'] = remove_extra
app.config['FREEZER_DESTINATION_IGNORE'] = ignore
dest = Path(app.config['FREEZER_DESTINATION'])
expected_files = normalize_set(set(self.filenames.values()))
# No other files
assert normalize_set(walk_directory(dest)) == expected_files
# Create an empty file
(dest / 'extra').mkdir()
(dest / 'extra' / 'extra.txt').touch()
# Verify that files in destination persist
freezer.freeze()
if removed:
assert not (dest / 'extra').exists()
else:
assert (dest / 'extra').exists()
expected_files.add('extra/extra.txt')
assert normalize_set(walk_directory(dest)) == expected_files
def test_transitivity(self, tmp_path_factory):
tmp_path_1 = tmp_path_factory.mktemp('tmp1')
app, freezer, urls = self.freeze_app(tmp_path_1)
destination = app.config['FREEZER_DESTINATION']
# Run the freezer on its own output
tmp_path_2 = tmp_path_factory.mktemp('tmp2')
app2 = freezer.make_static_app()
app2.config['FREEZER_DESTINATION'] = tmp_path_2
app2.debug = True
freezer2 = Freezer(app2)
freezer2.register_generator(self.filenames.keys)
freezer2.freeze()
assert read_all(destination) == read_all(tmp_path_2)
def test_error_on_external_url(self, tmp_path):
urls = ('http://example.com/foo', '//example.com/foo', 'file:///foo')
for url in urls:
app, freezer = self.make_app(tmp_path)
@freezer.register_generator
def external_url():
yield url
try:
freezer.freeze()
except ValueError as error:
assert 'External URLs not supported' in error.args[0]
else:
assert False, 'Expected ValueError'
def test_error_on_internal_404(self, tmp_path):
app, freezer = self.make_app(tmp_path, with_404=True)
# Test standard behaviour with 404 errors (freeze failure)
try:
freezer.freeze()
except ValueError as e:
error_msg = "Unexpected status '404 NOT FOUND' on URL /404/"
assert error_msg in e.args[0]
else:
assert False, 'Expected ValueError'
def test_warn_on_internal_404(self, tmp_path):
app, freezer = self.make_app(tmp_path, with_404=True)
# Enable 404 errors ignoring
app.config['FREEZER_IGNORE_404_NOT_FOUND'] = True
# Test warning with 404 errors when we choose to ignore them
with warns(NotFoundWarning) as logged_warnings:
warnings.simplefilter('always')
freezer.freeze()
assert len(logged_warnings) == 1
def test_error_on_redirect(self, tmp_path):
app, freezer = self.make_app(tmp_path)
# Enable errors on redirects.
app.config['FREEZER_REDIRECT_POLICY'] = 'error'
try:
freezer.freeze()
except ValueError as e:
error_msg = "Unexpected status '302 FOUND' on URL /redirect/"
assert error_msg in e.args[0]
else:
assert False, 'Expected ValueError'
def test_warn_on_redirect(self, tmp_path):
app, freezer = self.make_app(tmp_path)
# Enable ignoring redirects.
app.config['FREEZER_REDIRECT_POLICY'] = 'ignore'
# Test warning with 302 errors when we choose to ignore them
with warns(RedirectWarning) as logged_warnings:
warnings.simplefilter('always')
freezer.freeze()
assert len(logged_warnings) == 1
def test_warn_on_missing_generator(self, tmp_path):
app, freezer = self.make_app(tmp_path)
# Add a new endpoint without URL generator
@app.route('/extra/')
def external_url(some_argument):
return some_argument
with warns(MissingURLGeneratorWarning) as logged_warnings:
warnings.simplefilter('always')
freezer.freeze()
assert len(logged_warnings) == 1
def test_wrong_default_mimetype(self, tmp_path):
app, freezer = self.make_app(tmp_path)
@app.route('/no-file-extension')
def no_extension():
return '42', 200, {'Content-Type': 'image/png'}
with warns(MimetypeMismatchWarning) as logged_warnings:
warnings.simplefilter('always')
freezer.freeze()
assert len(logged_warnings) == 1
def test_default_mimetype(self, tmp_path):
app, freezer = self.make_app(tmp_path)
@app.route('/no-file-extension')
def no_extension():
return '42', 200, {'Content-Type': 'application/octet-stream'}
freezer.freeze()
def test_unknown_extension(self, tmp_path):
app, freezer = self.make_app(tmp_path)
@app.route('/unknown-extension.fuu')
def no_extension():
return '42', 200, {'Content-Type': 'application/octet-stream'}
freezer.freeze()
def test_configured_default_mimetype(self, tmp_path):
app, freezer = self.make_app(tmp_path)
app.config['FREEZER_DEFAULT_MIMETYPE'] = 'image/png'
@app.route('/no-file-extension')
def no_extension():
return '42', 200, {'Content-Type': 'image/png'}
freezer.freeze()
def test_wrong_configured_mimetype(self, tmp_path):
app, freezer = self.make_app(tmp_path)
app.config['FREEZER_DEFAULT_MIMETYPE'] = 'image/png'
@app.route('/no-file-extension')
def no_extension():
return '42', 200, {'Content-Type': 'application/octet-stream'}
with warns(MimetypeMismatchWarning) as logged_warnings:
warnings.simplefilter('always')
freezer.freeze()
assert len(logged_warnings) == 1
def test_skip_existing_files(self, tmp_path):
app, freezer = self.make_app(tmp_path)
app.config['FREEZER_SKIP_EXISTING'] = True
(tmp_path / 'skipped.html').write_text("6*9")
@app.route('/skipped.html')
def skipped():
return '42'
freezer.freeze()
assert (tmp_path / 'skipped.html').read_text() == "6*9"
def test_error_external_redirect(self, tmp_path):
app, freezer = self.make_app(tmp_path)
app.config['FREEZER_REDIRECT_POLICY'] = 'follow'
# Add a new endpoint with external redirect
@app.route('/redirect/ext/')
def external_redirected_page():
return redirect('https://github.com/Frozen-Flask/Frozen-Flask')
with raises(RuntimeError):
freezer.freeze()
class TestInitApp(TestFreezer):
defer_init_app = True
class TestBaseURL(TestFreezer):
expected_output = TestFreezer.expected_output.copy()
expected_output['/'] = b'Main index /myapp/product_5/?revision=b12ef20'
expected_output['/where_am_i/'] = \
b'/myapp/where_am_i/ http://example/myapp/where_am_i/'
expected_output['/admin/'] = (
b'Admin index\n'
b''
b'Unicode test\n'
b''
b'URL parsing test')
def do_extra_config(self, app, freezer):
app.config['FREEZER_BASE_URL'] = 'http://example/myapp/'
class TestNonexsistentDestination(TestFreezer):
def do_extra_config(self, app, freezer):
# frozen/htdocs does not exist in the newly created temp directory,
# the Freezer has to create it.
dest = Path(app.config['FREEZER_DESTINATION'])
app.config['FREEZER_DESTINATION'] = str(dest / 'frozen' / 'htdocs')
class TestServerName(TestFreezer):
def do_extra_config(self, app, freezer):
app.config['SERVER_NAME'] = 'example.net'
expected_output = TestFreezer.expected_output.copy()
expected_output['/where_am_i/'] = (
b'/where_am_i/ http://example.net/where_am_i/')
class TestWithoutUrlForLog(TestFreezer):
freezer_kwargs = {'log_url_for': False}
expected_output = TestFreezer.expected_output.copy()
filenames = TestFreezer.filenames.copy()
for url in TestFreezer.generated_by_url_for:
del expected_output[url]
del filenames[url]
class TestRelativeUrlFor(TestFreezer):
def do_extra_config(self, app, freezer):
app.config['FREEZER_RELATIVE_URLS'] = True
expected_output = TestFreezer.expected_output.copy()
expected_output['/admin/'] = (
b'Admin index\n'
b''
b'Unicode test\n'
b''
b'URL parsing test')
class TestStaticIgnore(TestFreezer):
def do_extra_config(self, app, freezer):
app.config['FREEZER_STATIC_IGNORE'] = ['*.js']
expected_output = TestFreezer.expected_output.copy()
filenames = TestFreezer.filenames.copy()
del expected_output['/static/main.js']
del filenames['/static/main.js']
class TestLastModifiedGenerator(TestFreezer):
def test_generate_last_modified(self, tmp_path):
# Yield two pages. One is last_modified in the past, and one is
# last_modified now. The first page should only be written on the first
# run. The second page should be written on both runs.
app, freezer = self.make_app(tmp_path)
@app.route('/time//')
def show_time(when):
return when + datetime.now().strftime('%Y-%m-%d %H:%M:%S')
@freezer.register_generator
def view_post():
timestamp, now = datetime.fromtimestamp(100000), datetime.now()
yield 'show_time', {'when': 'epoch'}, timestamp
yield 'show_time', {'when': 'now'}, now
freezer.freeze()
first_mtimes = {
key: (tmp_path / 'time' / key / 'index.html').stat().st_mtime
for key in ('epoch', 'now')}
time.sleep(2)
freezer.freeze()
second_mtimes = {
key: (tmp_path / 'time' / key / 'index.html').stat().st_mtime
for key in ('epoch', 'now')}
assert first_mtimes['epoch'] == second_mtimes['epoch']
assert first_mtimes['now'] != second_mtimes['now']
# with_no_argument_rules=False and with_static_files=False are
# not tested as they produce (expected!) warnings
frozen_flask-1.0.2/tests/test_app/__init__.py 0000644 0000000 0000000 00000004672 13615410400 016220 0 ustar 00 """
flask_frozen.test_app
~~~~~~~~~~~~~~~~~~~~~
Test application Frozen-Flask
:copyright: (c) 2010-2012 by Simon Sapin.
:license: BSD, see LICENSE for more details.
"""
import os.path
from functools import partial
from flask import Flask, redirect, url_for
from flask_frozen import Freezer
from .admin import admin_blueprint
FAVICON = os.path.join(os.path.dirname(__file__), 'static', 'favicon.ico')
def create_app(defer_init_app=False, freezer_kwargs=None):
app = Flask(__name__)
app.register_blueprint(admin_blueprint, url_prefix='/admin')
if not freezer_kwargs:
freezer_kwargs = {}
if defer_init_app:
freezer = Freezer(**freezer_kwargs)
else:
freezer = Freezer(app, **freezer_kwargs)
@app.route('/')
def index():
return ('Main index ' +
url_for('product', product_id='5', revision='b12ef20'))
@app.route('/redirect/')
def redirected_page():
return redirect('/')
@app.route('/page//')
def page(name):
url_for('product', product_id='3') # Pretend we’re adding a link
url_for('product', product_id='4') # Another link
return u'Hello\xa0World! ' + name
@app.route('/where_am_i/')
def where_am_i():
return (url_for('where_am_i') + ' ' +
url_for('where_am_i', _external=True))
@app.route('/robots.txt')
def robots_txt():
content = 'User-agent: *\nDisallow: /'
return app.response_class(content, mimetype='text/plain')
for asset in ("favicon.ico",):
url = "/" + asset
name = asset.replace(".", "_")
app.add_url_rule(url, name,
partial(app.send_static_file, filename=asset))
@app.route('/product_/')
def product(product_id):
return 'Product num %i' % product_id
@app.route('/add/', methods=['POST'])
def add_something(product_id):
return 'This view should be ignored as it does not accept GET.'
@freezer.register_generator
def product(): # noqa: F811
# endpoint, values
yield 'product', {'product_id': 0}
yield 'page', {'name': 'foo'}
# Just a `values` dict. The endpoint defaults to the name of the
# generator function, just like with Flask views
yield {'product_id': 1}
# single string: url
yield '/product_2/'
if defer_init_app:
freezer.init_app(app)
return app, freezer
frozen_flask-1.0.2/tests/test_app/admin/__init__.py 0000644 0000000 0000000 00000000732 13615410400 017301 0 ustar 00 """
flask_frozen.test_app.admin
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Test application Frozen-Flask
:copyright: (c) 2010-2012 by Simon Sapin.
:license: BSD, see LICENSE for more details.
"""
from flask import Blueprint, render_template
admin_blueprint = Blueprint(
'admin', __name__, static_folder='admin_static', static_url_path='/css',
template_folder='templates')
@admin_blueprint.route('/')
def index():
return render_template('admin.html')
frozen_flask-1.0.2/tests/test_app/admin/admin_static/style.css 0000644 0000000 0000000 00000000017 13615410400 021475 0 ustar 00 /* Admin CSS */ frozen_flask-1.0.2/tests/test_app/admin/templates/admin.html 0000644 0000000 0000000 00000000306 13615410400 021141 0 ustar 00 Admin index
Unicode testURL parsing test
frozen_flask-1.0.2/tests/test_app/static/favicon.ico 0000644 0000000 0000000 00000040576 13615410400 017522 0 ustar 00 ;@ (= & @@ 0 N= ( ; E D ? O C C b j Y F & " 5 S X ' C Z D , + & I N X [ ! * r k 5 7 , . 8 3 A + = ( ] : ! $ 5 k o ; " - E U
" 0 7
. . ( O w Z 2
! P \ ( & F ; % / i X * < L ( "
? 4 a 7
J V > ' J 8 u O R Q ' : - & . , % . ' a / C 7 " V s ] H 2 2 . q ` 2 J o W 5 3 8 K @ G | o <
" < " - A u ? * : 9 )
= " D @ a n / . 8 , ' b G E a < > J - 3
8 b < M * * - = ? J # $ $ 9 : A $ 6
F W - 3 $ + P c # % / 1 T a # $ T
7 e cE = ` [ r G
# H 2 \ _ " & x Q " M y > * 3 ) & e
0
% ~ + > M
F W & ? i 3 d g sWw 6
! ) X u R
$ > 4 b + K p Z n 2 l s k # m 1 / ; i z v @ 7 > u ] 8 j 4 % ; -
S [ p ? 0 & D t , Y ! 9 D 5 Z U m j " M 2 " W 0 ] ( O F # 5 : 6 k U ; + F - $ 6 > j t X ! m / - W j ~ * A 6 G . . d # * i Z ( Z U r 3 ` T < i J
I ? O 1 7 4 D A J + r 7 ( 0 2 7 G 2 ' : @ i 9
2 3 V R 4 y A # h C p q M _ 2 2 ? ? 4 , ' G Y 8 M / B 0 [ 0 ~ O . D ' ] D C " \ q
X g @ * } - L ! n N 9 h ] k < F 0 < A ( D 7 4 0 : 1 > : ; - . T J , % ' Z q i A \ I ` P G # 5 @ = . B D , * | * x `
/ 7 H F ) ) % ' ( + , n i > p H F G S C
2 + 6 ) / | R ; 9 ? n 6 ; @ 1 ' 0 M ; Q R - 3 a 9 X
+ B ~ 9 4 " < Y C / % & 7
, a ; H 4 2 / W = 6 ! & 0 G L D 0 : 7 :
" a { ! ' ' ( ) z O + ( ! & G W E : - Y Z F
F m 3 & < o M z ? P v [ S K 1 # 3 4 M h 4 < Z ( # / > c > ) > / * F g c~ b % 0 @ 0 P I G 9 + $ 1 @ . @ . " & U A ' < : i t ; @ ;; # B " ; n P - e Y @ _ : - 5 T > ' '
q " # U 0 ' % E 8 ; I ) 9 P E h ; ' ! Q g > < D $ < 0 : ' G J F *
: < 2 $ j v & 4 $ . . %U & #
" : 0 ! 8 ( 2 + > ' k y A A ! ? ? 3 + H G r g : G
< Y <
, ? B J * l J N z & C Q ( 4 E @ H @ ( " s < # B T ) ? 2 < A E _ N / c % 5 ' 8
> S S I - - J 4 (
J u ^ Z Q 2
) 1 - V N , X N
* I _ ) 1 W R k X 0 0 & < [ 9 {g ;? A ?( @ frozen_flask-1.0.2/tests/test_app/static/main.js 0000644 0000000 0000000 00000000015 13615410400 016643 0 ustar 00 /* Main JS */ frozen_flask-1.0.2/tests/test_app/static/style.css 0000644 0000000 0000000 00000000016 13615410400 017234 0 ustar 00 /* Main CSS */ frozen_flask-1.0.2/.gitignore 0000644 0000000 0000000 00000000064 13615410400 013105 0 ustar 00 *.py[co]
*.egg-info
/env*
/build
/dist
/docs/_build
frozen_flask-1.0.2/LICENSE 0000644 0000000 0000000 00000003006 13615410400 012121 0 ustar 00 Copyright (c) 2010-2012 by Simon Sapin and contributors. See AUTHORS
for more details.
Some rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* The names of the contributors may not be used to endorse or
promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
frozen_flask-1.0.2/README.rst 0000644 0000000 0000000 00000003145 13615410400 012607 0 ustar 00 Frozen-Flask
============
Freezes a Flask application into a set of static files. The result can be hosted
without any server-side software other than a traditional web server.
See documentation: https://frozen-flask.readthedocs.io/
Contributing
------------
* Fork the upstream repository and clone your fork
* Create a feature branch for the thing you want to work on
* Create a virtual environment and activate it
* Run ``pip install -e .[doc,test,check]`` to install dependencies
* Add your changes
* Make sure tests pass with ``pytest``
* Make sure you followed the style guide with ``flake8`` and ``isort``
* Send a pull request to the upstream repository
You can also use `Hatch `_ to automatically install
dependencies, launch tests, check style and build documentation::
$ hatch run test:run
$ hatch run check:run
$ hatch run doc:build
Status
------
This project is currently maintained by
`CourtBouillon `_.
It’s been previously maintained by
`@honzajavorek `_ and
`@tswast `_,
and has been originally created by
`@SimonSapin `_.
License
-------
Frozen-Flask uses a BSD 3-clause license. See LICENSE.
Copyrights are retained by their contributors, no copyright assignment is
required to contribute to Frozen-Flask. Unless explicitly stated otherwise, any
contribution intentionally submitted for inclusion is licensed under the BSD
3-clause license, without any additional terms or conditions. For full
authorship information, see the version control history.
frozen_flask-1.0.2/pyproject.toml 0000644 0000000 0000000 00000004474 13615410400 014042 0 ustar 00 [build-system]
requires = ['hatchling']
build-backend = 'hatchling.build'
[project]
name = 'Frozen-Flask'
description = 'Freezes a Flask application into a set of static files.'
keywords = ['flask', 'static']
authors = [{name = 'Simon Sapin', email = 'simon.sapin@exyr.org'}]
requires-python = '>=3.8'
readme = {file = 'README.rst', content-type = 'text/x-rst'}
license = {file = 'LICENSE'}
dependencies = ['Flask >=2.0.0']
classifiers = [
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3 :: Only',
'Programming Language :: Python :: 3.8',
'Programming Language :: Python :: 3.9',
'Programming Language :: Python :: 3.10',
'Programming Language :: Python :: 3.11',
'Programming Language :: Python :: 3.12',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules',
]
dynamic = ['version']
[project.optional-dependencies]
check = ['isort', 'flake8']
doc = ['sphinx', 'pallets_sphinx_themes']
test = ['pytest']
[project.urls]
Homepage = 'https://github.com/Frozen-Flask/Frozen-Flask/'
Documentation = 'https://frozen-flask.readthedocs.io/'
Code = 'https://github.com/Frozen-Flask/Frozen-Flask/'
Issues = 'https://github.com/Frozen-Flask/Frozen-Flask/issues'
Changelog = 'https://frozen-flask.readthedocs.io/#changelog'
[tool.isort]
known_first_party = ['test_app']
known_third_party = ['flask_frozen']
[tool.hatch.version]
path = 'flask_frozen/__init__.py'
[tool.hatch.build]
exclude = ['.*']
[tool.hatch.build.targets.wheel]
packages = ['flask_frozen']
[tool.hatch.envs.doc]
features = ['doc']
[tool.hatch.envs.doc.scripts]
build = 'sphinx-build docs docs/_build -a -n'
[tool.hatch.envs.test]
features = ['test']
[tool.hatch.envs.test.scripts]
run = 'pytest'
[tool.hatch.envs.check]
features = ['check']
[tool.hatch.envs.check.scripts]
run = [
'python -m flake8 docs tests flask_frozen',
'python -m isort docs tests flask_frozen --check --diff',
]
[[tool.hatch.envs.test.matrix]]
python = ['3.8', '3.9', '3.10', '3.11', '3.12']
flask-version = ['2', '3']
[tool.hatch.envs.test.overrides]
name.'-2$'.dependencies = ['flask==2.0.0', 'werkzeug==2.0.0']
frozen_flask-1.0.2/PKG-INFO 0000644 0000000 0000000 00000011722 13615410400 012215 0 ustar 00 Metadata-Version: 2.1
Name: Frozen-Flask
Version: 1.0.2
Summary: Freezes a Flask application into a set of static files.
Project-URL: Homepage, https://github.com/Frozen-Flask/Frozen-Flask/
Project-URL: Documentation, https://frozen-flask.readthedocs.io/
Project-URL: Code, https://github.com/Frozen-Flask/Frozen-Flask/
Project-URL: Issues, https://github.com/Frozen-Flask/Frozen-Flask/issues
Project-URL: Changelog, https://frozen-flask.readthedocs.io/#changelog
Author-email: Simon Sapin
License: Copyright (c) 2010-2012 by Simon Sapin and contributors. See AUTHORS
for more details.
Some rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* The names of the contributors may not be used to endorse or
promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
License-File: LICENSE
Keywords: flask,static
Classifier: Environment :: Web Environment
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Requires-Python: >=3.8
Requires-Dist: flask>=2.0.0
Provides-Extra: check
Requires-Dist: flake8; extra == 'check'
Requires-Dist: isort; extra == 'check'
Provides-Extra: doc
Requires-Dist: pallets-sphinx-themes; extra == 'doc'
Requires-Dist: sphinx; extra == 'doc'
Provides-Extra: test
Requires-Dist: pytest; extra == 'test'
Description-Content-Type: text/x-rst
Frozen-Flask
============
Freezes a Flask application into a set of static files. The result can be hosted
without any server-side software other than a traditional web server.
See documentation: https://frozen-flask.readthedocs.io/
Contributing
------------
* Fork the upstream repository and clone your fork
* Create a feature branch for the thing you want to work on
* Create a virtual environment and activate it
* Run ``pip install -e .[doc,test,check]`` to install dependencies
* Add your changes
* Make sure tests pass with ``pytest``
* Make sure you followed the style guide with ``flake8`` and ``isort``
* Send a pull request to the upstream repository
You can also use `Hatch `_ to automatically install
dependencies, launch tests, check style and build documentation::
$ hatch run test:run
$ hatch run check:run
$ hatch run doc:build
Status
------
This project is currently maintained by
`CourtBouillon `_.
It’s been previously maintained by
`@honzajavorek `_ and
`@tswast `_,
and has been originally created by
`@SimonSapin `_.
License
-------
Frozen-Flask uses a BSD 3-clause license. See LICENSE.
Copyrights are retained by their contributors, no copyright assignment is
required to contribute to Frozen-Flask. Unless explicitly stated otherwise, any
contribution intentionally submitted for inclusion is licensed under the BSD
3-clause license, without any additional terms or conditions. For full
authorship information, see the version control history.