Retrieval / comparison of Flask application static content endpoint(s)

[jayaddison]

Hi folks,

The Frozen-Flask project provides a way to snapshot the dynamic content produced by a Flask web application so that it can be served up by simple web servers that don't have any caching infrastructure of their own. Frozen-Flask does this by retrieving a list of URL paths from the application, and then requesting and saving them as if it was a web client.

With the upgrade to Flask 2.x, issue Frozen-Flask/Frozen-Flask#113 has appeared, and relates to content registered as static files in Flask applications going missing from snapshots.

In some more detail, the cause seems to be a combination of:

1. Frozen-Flask performing a comparison to check whether each view function method is the same as the the Flask send_static_file method
2. An update in Flask 2.x pull request Breaking a ref cycle created by default in Flask() #3762 that introduces a lambda method indirection for the static file URL rule

Since the lambda function isn't the same method as the send_static_file method, the comparisons fail and the issue appears when users upgrade to Flask 2.x

Can anyone suggest a fix or improvement to the current equality comparison? (it doesn't seem straightforward for external Python libraries to inspect or compare the contents of a lambda function, so I thought asking in the context of Flask project internals could be helpful)

Alternatively, perhaps Flask-Frozen could migrate to use another approach altogether if there's a more architecturally sound way to achieve the same result?

Thanks!

[tachyondecay]

I've played around with your _static_rules_endpoint function and made some discoveries that will hopefully help.

There's good news! Your approach seems to work fine for Blueprint static folders and additional URL rules that point to send_static_file. To me, this seems to indicate the only thing you need to account for is a built-in static endpoint registered to the static_url_path on an app object.

TL;DR My Suggested Solution

You can do this by changing line 439 to

if rule.endpoint == 'static' or unwrap_method(view) is send_static_file:

Initial Test Code

Here's my test code:

from flask import Flask, Blueprint

app = Flask(__name__)

@app.shell_context_processor
def inject():
	return {'find_static': _static_rules_endpoints}


# Register a non-static endpoint to make sure it isn't mistakenly
# identified as static
@app.route("/")
def not_static():
	return "I am not a static teapot"


# Register an additional static endpoint
app.add_url_rule("/static_2", endpoint="static_2", view_func=Flask.send_static_file)

# Register a blueprint with its own static folder
blue = Blueprint('blueprint', __name__, static_folder='blue_static')
app.register_blueprint(blue)


def unwrap_method(method):
    """Return the function object for the given method object."""
    try:
        # Python 2
        return method.im_func
    except AttributeError:
        try:
            # Python 3
            return method.__func__
        except AttributeError:
            # Not a method.
            return method


def _static_rules_endpoints(app):
    """
    Yield the 'static' URL rules for the app and all blueprints.
    """
    send_static_file = unwrap_method(Flask.send_static_file)
    # Assumption about a Flask internal detail:
    # Flask and Blueprint inherit the same method.
    # This will break loudly if the assumption isn't valid anymore in
    # a future version of Flask
    assert unwrap_method(Blueprint.send_static_file) is send_static_file

    static_rules = []
    for rule in app.url_map.iter_rules():
        view = app.view_functions[rule.endpoint]
        if unwrap_method(view) is send_static_file:
            static_rules.append(rule.endpoint)

    return static_rules

Now if you run flask shell and then call find_static(app) you get the following output:

>>> find_static(app)
['static_2', 'blueprint.static']

Reasoning Behind Solution

If you refer to

flask/src/flask/app.py

Lines 515 to 520 in 63893a4

	self.add_url_rule(
	f"{self.static_url_path}/<path:filename>",
	endpoint="static",
	host=static_host,
	view_func=lambda **kw: self_ref().send_static_file(**kw), # type: ignore # noqa: B950
	)

you'll see that the name of the endpoint is hardcoded as "static". So adjusting the _static_rules_endpoint loop as follows seems to work:

    for rule in app.url_map.iter_rules():
        view = app.view_functions[rule.endpoint]
        if rule.endpoint == 'static' or unwrap_method(view) is send_static_file:
            static_rules.append(rule.endpoint)

Now when I run find_static(app) in shell mode, I get this output:

>>> find_static(app)
['static_2', 'blueprint.static', 'static']

Caveats

• I haven't tested with nested blueprints that might have static endpoints
• I haven't tested with host matching enabled
• Obviously this will break if Flask ever changes the name of its built-in static endpoint

I hope that this helps, or at least gets you thinking about an approach that works for Frozen Flask!

[jayaddison]

Thank you very much @tachyondecay for the analysis - that appears to address the issue exactly, and your suggested solution looks like a good one. I've opened a potential fix following that in Frozen-Flask/Frozen-Flask#115, including a comment sharing your note regarding the possibility that future internal Flask changes could affect this.

It feels like this takes on a small amount of extra technical debt and fragiliity in the Flask-Frozen codebase, but it feels manageable (note that I'm not a major contributor there, just a supportive community user of that project). I'd like to register that debt tradeoff with the Flask project, perhaps to be balanced against the value of #3762. Perhaps there'd be a solution which could address both use cases and also reduce those concerns. For now though, I think this approach works well.

Thanks again for taking the time to look into this and respond.

[tachyondecay]

Arguably, this method is less reliant on internal details of Flask. The static endpoint has always been called "static," so I think the chances of that changing are negligible.

I'm glad you found this helpful!

[davidism]

Yeah, I'd suggest looking at what the configured static endpoint is (app and blueprint) instead of the view function. Not sure how other views that call send_file are handled, but I'd guess you'd have a list of endpoints for those as well.