7

I want to define a url rule with three variable components, like:

@app.route('/<var_1>/<var_2>/<var3>/')

But I find that the development server evaluates such rules before trying to match for static files. So anything like:

/static/images/img.jpg

will be caught by my url rule, rather than being forwarded to the built-in static file handler. Is there a way to force the development server to match for static files first?

P.S. This is only an issue if the rule has more than two variable components.

petrus-jvrensburg
  • 1,353
  • 15
  • 19
  • A couple of interesting reads: [Flask routing system](http://flask.pocoo.org/docs/design/#the-routing-system) and [Werkzeug routing](http://werkzeug.pocoo.org/docs/routing/#module-werkzeug.routing). Might also like to explore using [Blueprints](http://flask.pocoo.org/docs/blueprints/) – Alex L Jun 17 '13 at 05:11

4 Answers4

18

This is werkzeug route optimization feature. See Map.add, Map.update and Rule.match_compare_key:

def match_compare_key(self):
    """The match compare key for sorting.

    Current implementation:

    1. rules without any arguments come first for performance
    reasons only as we expect them to match faster and some
    common ones usually don't have any arguments (index pages etc.)
    2. The more complex rules come first so the second argument is the
    negative length of the number of weights.
    3. lastly we order by the actual weights.

    :internal:
    """
    return bool(self.arguments), -len(self._weights), self._weights

There are self.arguments - current arguments, self._weights - path depth.

For '/<var_1>/<var_2>/<var3>/' we have (True, -3, [(1, 100), (1, 100), (1, 100)]). There are (1, 100) - default string argument with max length 100.

For '/static/<path:filename>' we have (True, -2, [(0, -6), (1, 200)]). There are (0, 1) - path non argument string length static, (1, 200) - path string argument max length 200.

So I don't find any beautiful way to set own Map implementation for Flask.url_map or set priority for map rule. Solutions:

  1. Setup Flask application as app = Flask(static_path='static', static_url_path='/more/then/your/max/variables/path/depth/static').
  2. Change @app.route('/<var_1>/<var_2>/<var3>/') to @app.route('/prefix/<var_1>/<var_2>/<var3>/').
  3. Add own converter and use as @app.route('/<no_static:var_1>/<var_2>/<var3>/').
  4. Import werkzeug.routing, create own map implementation, change werkzeug.routing.Map to own implementation, import flask.
  5. Use server as on production.
tbicr
  • 24,790
  • 12
  • 81
  • 106
  • Okay cool, I misunderstood your answer at first. So with option 1, you change the url at which static files are served, and you add enough "dummy" sub-directories to that url so that it cannot possibly clash with any existing url rules that are made up from variable components. So, for my example, the `static_url_path` would need to be changed to something like: `/static/static/static/static` and then it would no longer be caught by `@app.route('////')` – petrus-jvrensburg Jun 18 '13 at 13:00
  • I used option 1. I don't know why but it would not work when I had the static_path argument but worked when I removed it. I ended up using: `app = Flask(__name__, static_url_path='/r/s/static')` – trevor Sep 18 '17 at 03:31
7

So, as tbicr pointed out, this behavior is set deep within Werkzeug, and there's not really an elegant way to handle it from Flask. The best workaround I could come up with is:

Define a complementary static file handler like:

@app.route('/static/<subdir>/<path:filename>/')
def static_subdir(subdir=None, filename=None):

    directory = app.config['STATIC_FOLDER'] + subdir
    return send_from_directory(directory, filename)

Here, app.config['STATIC_FOLDER'] is the full path to the static folder on the machine running the application.

Now, this handler catches things like /static/images/img.jpg, leaving my view with the three variable components alone.

petrus-jvrensburg
  • 1,353
  • 15
  • 19
  • It's good idea, but you don't need add own handler because you can do this with `Flask` application settings. See my answer solution 1: setup Flask application as `app = Flask(static_path='static', static_url_path='/more/then/your/max/variables/path/depth/static')` but it's will change static url path (no problem for `url_for('static', filename='images/img.jpg'`). – tbicr Jun 17 '13 at 14:10
  • IMO your solution is the best mentioned here, petrus. introducing dummy subdirectories is certainly uglier than explicitly catching it in a URL rule. – Michel Müller Aug 22 '13 at 18:23
3

One way to go around this is to cheat the rules sorting algorithm by spoofing the registered rule's match_compare_key() method. Note that this hack only works with routes that have been registered directly with app.route() (the Flask object), not with Blueprints. Blueprints' routes are added to the global url Map only upon blueprint's registration on the main app, making it challenging to modify the generated rules.

# an ordinary route
@app.route('/<var1>/<var2>/<var3>')
def some_view(var1, var2, var3):
    pass

# let's find the rule that was just generated
rule = app.url_map._rules[-1]

# we create some comparison keys:
# increase probability that the rule will be near or at the top
top_compare_key = False, -100, [(-2, 0)]
# increase probability that the rule will be near or at the bottom 
bottom_compare_key = True, 100, [(2, 0)]

# rig rule.match_compare_key() to return the spoofed compare_key
rule.match_compare_key = lambda: top_compare_key

Note that in this case the resulting spoofed function is not bound to the rule object. Therefore upon calling rule.match_compare_key(), the function does not receive a self argument. If you want to bind the function properly, do this instead:

spoof = lambda self: top_compare_key
rule.match_compare_key = spoof.__get__(rule, type(rule))

We can generalize the above with a decorator

def weighted_route(*args, **kwargs):
    def decorator(view_func):
        compare_key = kwargs.pop('compare_key', None)
        # register view_func with route
        app.route(*args, **kwargs)(view_func)

        if compare_key is not None:
            rule = app.url_map._rules[-1]
            rule.match_compare_key = lambda: compare_key

        return view_func
    return decorator

# can be used like @app.route(). To weight the rule, just provide
# the `compare_key` param.
@weighted_route('/<var1>/<var2>/<var3>', compare_key=bottom_compare_key)
def some_view(var1, var2, var3):
    pass

The same hack implemented as a context manager.

import contextlib

@contextlib.contextmanager
def weighted_route(compare_key=None):
    yield
    if compare_key is not None:
        rule = app.url_map._rules[-1]
        rule.match_compare_key = lambda: compare_key

# and to use

with weighted_route(compare_key):
    @app.route('/<var1>/<var2>/<var3>')
    def some_view(var1, var2, var3):
        pass
Michael Ekoka
  • 19,050
  • 12
  • 78
  • 79
0

I wanted to provide an answer inspired by @tbicr (suggestion #3) that seems to be a bit cleaner than some of the other solutions:

from werkzeug.routing import BaseConverter
class NoStaticConverter(BaseConverter):
    regex = '[^/]+(?<!/static)'
app.url_map.converters['nostatic'] = NoStaticConverter
app.add_url_rule('/<nostatic:page>/<page2>/<page3>/<page4>/',view_func=Main.as_view('level4'),methods=["GET"])

Where page, page2, page3, and page4 are passed to the class Main (not shown, which I use to render templates).

One thing to note, this doesn't seem to work for URLs of the form http://127.0.0.1:5000/a/b/c// with an extra slash. This is a malformed URL that I would have thought that flask would auto re-write it to remove the extra slash, but it doesn't. Although this doesn't seem to be an issue specific to conflicts with static files, I thought it was worth mentioning.

user1748155
  • 1,345
  • 1
  • 9
  • 17