2012-06-09T06:44:24Z

The Flask Mega-Tutorial, Part V: User Logins

(Great news! There is a new version of this tutorial!)

This is the fifth article in the series in which I document my experience writing web applications in Python using the Flask microframework.

The goal of the tutorial series is to develop a decently featured microblogging application that demonstrating total lack of originality I have decided to call microblog.

NOTE: This article was revised in September 2014 to be in sync with current versions of Python and Flask.

Here is an index of all the articles in the series that have been published to date:

Recap

In the previous chapter of the series we created our database and learned how to populate it with users and posts, but we haven't hooked up any of that into our app yet. And two chapters ago we've seen how to create web forms and left with a fully implemented login form.

In this article we are going to build on what we learned about web forms and databases and write our user login system. At the end of this tutorial our little application will register new users and log them in and out.

To follow this chapter along you need to have the microblog app as we left it at the end of the previous chapter. Please make sure the app is installed and running.

An Update Regarding the State of OpenID

It's been more than three years ago that I wrote this article. Back then OpenID seemed like a nice authentication method that was gaining a lot of traction, but in 2015 there are better alternatives, and OpenID is not as widely deployed as it used to be.

I do not have plans to update this tutorial in the near future, as I have written extensively about other authentication methods elsewhere. When you follow this tutorial keep in mind that Google, which was the most prominent OpenID provider in 2012, has dropped support for this protocol completely. My recommendation is to use a Yahoo account to test OpenID in this tutorial. I have a few personal projects that still use OpenID and I use Yahoo as a provider with good results.

As far as real-world authentication, I do not think it is a good idea to use OpenID, given the lack of support. I have a few resources for you that can help you create a more modern authentication experience:

  • My Flask book covers a traditional username and password implementation, complete with user registration, password reminders and resets.
  • My OAuth Authentication with Flask blog article describes in detail how to implement OAuth authentication, which has much wider support than OpenID. With this method you can implement "Login with Facebook" type functionality. The article demonstrates how to login with Facebook and Twitter. Others, such as Google, LinkedIn, etc. can be implemented easily with the same technique.

Configuration

As in previous chapters, we start by configuring the Flask extensions that we will use. For the login system we will use two extensions, Flask-Login and Flask-OpenID. Flask-Login will handle our users logged in state, while Flask-OpenID will provide authentication. These extensions are configured as follows (file app/__init__.py):

import os
from flask_login import LoginManager
from flask_openid import OpenID
from config import basedir

lm = LoginManager()
lm.init_app(app)
oid = OpenID(app, os.path.join(basedir, 'tmp'))

The Flask-OpenID extension requires a path to a temp folder where files can be stored. For this we provide the location of our tmp folder.

Python 3 Compatiblity

Unfortunately version 1.2.1 of Flask-OpenID (the current official version) does not work well with Python 3. Check what version you have by running the following command:

$ flask/bin/pip freeze

If you have a version newer than 1.2.1 then the problem is likely resolved, but if you have 1.2.1 and are following this tutorial on Python 3 then you have to install the development version from GitHub:

$ flask/bin/pip uninstall flask-openid
$ flask/bin/pip install git+git://github.com/mitsuhiko/flask-openid.git

Note that you need to have git installed for this to work.

Revisiting our User model

The Flask-Login extension expects certain properties and methods to be implemented in our User class. Outside of these there are no requirements for how the class has to be implemented.

Below is our Flask-Login friendly User class (file app/models.py):

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    nickname = db.Column(db.String(64), index=True, unique=True)
    email = db.Column(db.String(120), index=True, unique=True)
    posts = db.relationship('Post', backref='author', lazy='dynamic')

    @property
    def is_authenticated(self):
        return True

    @property
    def is_active(self):
        return True

    @property
    def is_anonymous(self):
        return False

    def get_id(self):
        try:
            return unicode(self.id)  # python 2
        except NameError:
            return str(self.id)  # python 3

    def __repr__(self):
        return '<User %r>' % (self.nickname)

The is_authenticated property has a misleading name. In general this method should just return True unless the object represents a user that should not be allowed to authenticate for some reason.

The is_active property should return True for users unless they are inactive, for example because they have been banned.

The is_anonymous property should return True only for fake users that are not supposed to log in to the system.

Finally, the get_id method should return a unique identifier for the user, in unicode format. We use the unique id generated by the database layer for this. Note that due to the differences in unicode handling between Python 2 and 3 we have to provide two alternative versions of this method.

User loader callback

Now we are ready to start implementing the login system using the Flask-Login and Flask-OpenID extensions.

First, we have to write a function that loads a user from the database. This function will be used by Flask-Login (file app/views.py):

@lm.user_loader
def load_user(id):
    return User.query.get(int(id))

Note how this function is registered with Flask-Login through the lm.user_loader decorator. Also remember that user ids in Flask-Login are always unicode strings, so a conversion to an integer is necessary before we can send the id to Flask-SQLAlchemy.

The login view function

Next let's update our login view function (file app/views.py):

from flask import render_template, flash, redirect, session, url_for, request, g
from flask_login import login_user, logout_user, current_user, login_required
from app import app, db, lm, oid
from .forms import LoginForm
from .models import User

@app.route('/login', methods=['GET', 'POST'])
@oid.loginhandler
def login():
    if g.user is not None and g.user.is_authenticated:
        return redirect(url_for('index'))
    form = LoginForm()
    if form.validate_on_submit():
        session['remember_me'] = form.remember_me.data
        return oid.try_login(form.openid.data, ask_for=['nickname', 'email'])
    return render_template('login.html', 
                           title='Sign In',
                           form=form,
                           providers=app.config['OPENID_PROVIDERS'])

Notice we have imported several new modules, some of which we will use later.

The changes from our previous version are very small. We have added a new decorator to our view function. The oid.loginhandler tells Flask-OpenID that this is our login view function.

At the top of the function body we check if g.user is set to an authenticated user, and in that case we redirect to the index page. The idea here is that if there is a logged in user already we will not do a second login on top.

The g global is setup by Flask as a place to store and share data during the life of a request. As I'm sure you guessed by now, we will be storing the logged in user here.

The url_for function that we used in the redirect call is defined by Flask as a clean way to obtain the URL for a given view function. If you want to redirect to the index page you may very well use redirect('/index'), but there are very good reasons to let Flask build URLs for you.

The code that runs when we get a data back from the login form is also new. Here we do two things. First we store the value of the remember_me boolean in the flask session, not to be confused with the db.session from Flask-SQLAlchemy. We've seen that the flask.g object stores and shares data though the life of a request. The flask.session provides a much more complex service along those lines. Once data is stored in the session object it will be available during that request and any future requests made by the same client. Data remains in the session until explicitly removed. To be able to do this, Flask keeps a different session container for each client of our application.

The oid.try_login call in the following line is the call that triggers the user authentication through Flask-OpenID. The function takes two arguments, the openid given by the user in the web form and a list of data items that we want from the OpenID provider. Since we defined our User class to include nickname and email, those are the items we are going to ask for.

The OpenID authentication happens asynchronously. Flask-OpenID will call a function that is registered with the oid.after_login decorator if the authentication is successful. If the authentication fails the user will be taken back to the login page.

The Flask-OpenID login callback

Here is our implementation of the after_login function (file app/views.py):

@oid.after_login
def after_login(resp):
    if resp.email is None or resp.email == "":
        flash('Invalid login. Please try again.')
        return redirect(url_for('login'))
    user = User.query.filter_by(email=resp.email).first()
    if user is None:
        nickname = resp.nickname
        if nickname is None or nickname == "":
            nickname = resp.email.split('@')[0]
        user = User(nickname=nickname, email=resp.email)
        db.session.add(user)
        db.session.commit()
    remember_me = False
    if 'remember_me' in session:
        remember_me = session['remember_me']
        session.pop('remember_me', None)
    login_user(user, remember = remember_me)
    return redirect(request.args.get('next') or url_for('index'))

The resp argument passed to the after_login function contains information returned by the OpenID provider.

The first if statement is just for validation. We require a valid email, so if an email was not provided we cannot log the user in.

Next, we search our database for the email provided. If the email is not found we consider this a new user, so we add a new user to our database, pretty much as we have learned in the previous chapter. Note that we handle the case of a missing nickname, since some OpenID providers may not have that information.

After that we load the remember_me value from the Flask session, this is the boolean that we stored in the login view function, if it is available.

Then we call Flask-Login's login_user function, to register this is a valid login.

Finally, in the last line we redirect to the next page, or the index page if a next page was not provided in the request.

The concept of the next page is simple. Let's say you navigate to a page that requires you to be logged in, but you aren't just yet. In Flask-Login you can protect views against non logged in users by adding the login_required decorator. If the user tries to access one of the affected URLs then it will be redirected to the login page automatically. Flask-Login will store the original URL as the next page, and it is up to us to return the user to this page once the login process completed.

For this to work Flask-Login needs to know what view logs users in. We can configure this in the app's module initializer (file app/__init__.py):

lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'

The g.user global

If you were paying attention, you will remember that in the login view function we check g.user to determine if a user is already logged in. To implement this we will use the before_request event from Flask. Any functions that are decorated with before_request will run before the view function each time a request is received. So this is the right place to setup our g.user variable (file app/views.py):

@app.before_request
def before_request():
    g.user = current_user

This is all it takes. The current_user global is set by Flask-Login, so we just put a copy in the g object to have better access to it. With this, all requests will have access to the logged in user, even inside templates.

The index view

In a previous chapter we left our index view function using fake objects, because at the time we did not have users or posts in our system. Well, we have users now, so let's hook that up:

@app.route('/')
@app.route('/index')
@login_required
def index():
    user = g.user
    posts = [
        { 
            'author': {'nickname': 'John'}, 
            'body': 'Beautiful day in Portland!' 
        },
        { 
            'author': {'nickname': 'Susan'}, 
            'body': 'The Avengers movie was so cool!' 
        }
    ]
    return render_template('index.html',
                           title='Home',
                           user=user,
                           posts=posts)

There are only two changes to this function. First, we have added the login_required decorator. This will ensure that this page is only seen by logged in users.

The other change is that we pass g.user down to the template, instead of the fake object we used in the past.

This is a good time to run the application.

When you navigate to http://localhost:5000 you will instead get the login page. Keep in mind that to login with OpenID you have to use the OpenID URL from your provider. You can use one of the OpenID provider links below the URL text field to generate the correct URL for you.

As part of the login process you will be redirected to your provider's web site, where you will authenticate and authorize the sharing of some information with our application (just the email and nickname that we requested, no passwords or other personal information will be exposed).

Once the login is complete you will be taken to the index page, this time as a logged in user.

Feel free to try the remember_me checkbox. With this option enabled you can close and reopen your web browser and will continue to be logged in.

Logging out

We have implemented the log in, now it's time to add the log out.

The view function for logging out is extremely simple (file app/views.py):

@app.route('/logout')
def logout():
    logout_user()
    return redirect(url_for('index'))

But we are also missing a link to logout in the template. We are going to put this link in the top navigation bar which is in the base layout (file app/templates/base.html):

<html>
  <head>
    {% if title %}
    <title>{{ title }} - microblog</title>
    {% else %}
    <title>microblog</title>
    {% endif %}
  </head>
  <body>
    <div>Microblog:
        <a href="{{ url_for('index') }}">Home</a>
        {% if g.user.is_authenticated %}
        | <a href="{{ url_for('logout') }}">Logout</a>
        {% endif %}
    </div>
    <hr>
    {% with messages = get_flashed_messages() %}
    {% if messages %}
    <ul>
    {% for message in messages %}
        <li>{{ message }} </li>
    {% endfor %}
    </ul>
    {% endif %}
    {% endwith %}
    {% block content %}{% endblock %}
  </body>
</html>

Note how easy it is to do this. We just needed to check if we have a valid user set in g.user and if we do we just add the logout link. We have also used the opportunity to use url_for in our template.

Final words

We now have a fully functioning user login system. In the next chapter we will be creating the user profile page and will be displaying user avatars on them.

In the meantime, here is the updated application code including all the changes in this article:

Download microblog-0.5.zip.

See you next time!

Miguel

217 comments

  • #201 Luis O said 2015-04-30T07:34:07Z

    Hi Miguel,

    Thanks again for your excellent contributions. My app implements a shopping cart in which anonymous users can fill the cart with products. User Login is required only before payment. How would you recommend us to implement it?

    The main challenge is that flask must keep track of the user (even if anonymous) and their orders. Our approach is to leverage the object that is assigned to current_user. The assumption is that current_user will not change throughout the session. However, we noticed that a new object is assigned to current_user, for example, upon every browser page refresh. Notice that this does not happen if a user is authenticated.

    Any suggestions on how to circumvent this?

    Thanks!, -luis

  • #202 Miguel Grinberg said 2015-04-30T17:30:36Z

    @Luis: very interesting problem. What I would do is generate an anonymous user id, and store that in a long lived cookie. You can write the cart data to your database all referencing this unique id. Once the user is ready to submit the order you will get the user information, so at that point you can associate the id with the user details.

  • #203 Luis O said 2015-05-02T08:12:21Z

    Many thanks for your help, Miguel. The long-lived cookie is a good idea. Would you recommend us to save the cookie in the session itself? (e.g. session['anon_id']).

    There is an additional challenge: a cron-job will be sweeping the database removing invalid shopping carts. With this approach the daemon might not be able to determine if a cart is valid or not (i.e. if the user has a session or not).

    FYI: To avoid polluting your website I have created https://stackoverflow.com/questions/29961898/how-to-track-anonymous-users-with-flask#

  • #204 Miguel Grinberg said 2015-05-02T23:53:52Z

    @Luis: added an answer to your question on stack overflow.

  • #205 Vikas said 2015-05-08T07:20:47Z

    Hi Miguel, First of all, thanks for the tutorials. They are awesome. I am getting a problem while following this part of tutorial.

    The console says the following log:

    vikas@v1k45:~/prog/python/flask/microblog$ ./run.py * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit) * Restarting with stat 127.0.0.1 - - [08/May/2015 12:40:09] "GET / HTTP/1.1" 302 - 127.0.0.1 - - [08/May/2015 12:40:09] "GET /login?next=%2F HTTP/1.1" 200 - 127.0.0.1 - - [08/May/2015 12:40:10] "GET /favicon.ico HTTP/1.1" 404 - 127.0.0.1 - - [08/May/2015 12:40:10] "GET /favicon.ico HTTP/1.1" 404 - Missing required parameter in response from http://www.blogger.com/openid-server.g: (u'http://specs.openid.net/auth/2.0', 'assoc_type') Generated checkid_setup request to http://www.blogger.com/openid-server.g using stateless mode. 127.0.0.1 - - [08/May/2015 12:40:44] "POST /login?next=%2F HTTP/1.1" 302 -

    I am using blogger as an OpenID authenticator. When i click on "Allow" a page appears, saying : Thats an error.

    Screenshots: http://i.imgur.com/LJ9wHks.png http://i.imgur.com/hSTg6ih.png

    Sorry for bumping this thread after so many years ;)

  • #206 Miguel Grinberg said 2015-05-08T14:24:58Z

    @Vikas: Google decided to stop supporting OpenID, so I wouldn't be surprised if the Blogger OpenIDs are also affected by that decision. Try a different provider. Yahoo works fine as far as I know.

  • #207 Mike said 2015-05-15T14:22:10Z

    For all those who has issue: ImportError: cannot import name lm Pay attention in app__init__.py line with import "from app import views, models" should follow after position where lm object is being created and all operation with it accomplished I've placed "from app import views, models" as last line, and that fixed the problem.

    p.s. Awesome tut! Thanks Miguel

    I saw this comment at #166. Andrii,thank you.

  • #208 Michael said 2015-05-15T16:48:54Z

    Hi,

    I am sorry to say but this OpenID thing annoys me such much that I am going to stop with this tutorial (after 7 hours). It was nice so far but I am not able to built a work around with classic user/password login, yet.

    I would be really happy, if you would provide a tutorial without OpenID. Thank you very much.

  • #209 Miguel Grinberg said 2015-05-16T00:46:10Z

    @Michael: Sorry about that. I don't know if you noticed that I wrote this page on June 8, 2012. It's almost three years old! Back then OpenID was on the rise. I agree that it isn't relevant anymore, but that fact is that there are still several OpenID providers that work. I personally test with a Yahoo OpenID and never have any issues.

    In any case, I have writte extensively about other authentication solutions. My O-Reilly book covers username/password authentication in detail, and you can also find an OAuth solution as a stand-alone article here in my blog.

  • #210 Andrei Levin said 2015-05-17T22:21:04Z

    Fantastica tutorial! Exactly what I was looking for. Please update it to use OpenID Connectc instead of OpebID 2.0

  • #211 Mark G said 2015-05-21T12:05:01Z

    Miguel, Thank you very much for the excellent tutorial. I have read all the comments on this tutorial because I am rather shocked at how many times you are asked the same question, and don't want to waste anyone's time. That having been said, I hope I don't touch on something you've already answered!

    I am having the same problem as many of not receiving a response to the 'oid.try_login()' process. My browser (chrome) shows no errors, and I am redirected consistently to the login page. I am aware of the deprecation of OpenID and have created a Yahoo ID (and activated it for OpenID) just for this case. I wanted you to know, I cleared the cookies, and I made sure the tmp folder was clean, but I just can't get anything to work. The google link will work, but is no longer supported. I also tried downgrading to Flask 0.9, to no avail. I have also downloaded your code and compared to mine side-by-side - no discrepancies. Any thoughts/suggestions? I know this tut is 3 years old, I'm just going crazy trying to troubleshoot this.

    I am planning to set up an extremely simple user/pw db just so I can finish your fine tutorial. A few questions: are the functions "before_request", "login", "after_login", "logout", all applicable if I were to remove OpenID from the equation? Would I basically just remove oid.try_login, and all the references to the service providers, as well as the js in the template?

    Also, just so you know, in your code for this section, you have:

    "CSRF_ENABLED" as opposed to what you mention in the post: "WTF_CSRF_ENABLED"

    Thanks for your time! MG

  • #212 Miguel Grinberg said 2015-05-23T23:45:48Z

    @Mark: when you say "I'm redirected consistently to the login page". Do you mean microblog's login page or Yahoo's? You are expected to be redirected to Yahoo's page, where you would login and give microblog permission to access your identity information.

    To use a username/password login things simplify a little bit, since you can authorize the user directly on the POST request that includes the form data. So the login and after_login functions can be collapsed into one. The rest stays more or less the same. Note that the complication with password authentication is in storing the passwords securely. I have written about that in my book, and also in my PyCon 2014 talk on REST APIs.

    Also, you are correct on CSRF_ENABLED, the name changed at some point. The default for WTF_CSRF_ENABLED is True, so the bad setting name does not affect the application.

  • #213 Don Dwiggins said 2015-06-09T20:06:34Z

    I struggled with one little thing for a while, before solving it. In init.py, the code app.config.from_object('config') was failing. I tried all sorts of other things before figuring out that all I had to do was delete the quotes.

    That aside, thanks for a worthwhile exercise!

  • #214 Matt said 2015-06-25T14:14:23Z

    Going through the tutorial and this is working great but realized it's kind of out dated OpenID for google uses OpenID 2.0 doen't work any more any suggestions on how to fix it?

  • #215 Ankit Kumar said 2015-06-28T21:42:48Z

    Hi Miguel,

    Great tutorials. Thank you! Is there a way to continue the tutorials by using OpenID Connect as opposed to OpenID 2.0

    Can you update the tutorials to reflect this standardization?

  • #216 Miguel Grinberg said 2015-07-01T18:55:10Z

    @Matt: Use a different OpenID provider. Yahoo works fine for me.

  • #217 Miguel Grinberg said 2015-07-01T19:11:50Z

    @Ankit: as I mentioned several times in previous comments, I do not have immediate plans to update this tutorial. OpenID Connect is very different to OpenID, it is not just a version upgrade. And in my opinion it isn't as widely available as other authentication mechanisms (OAuth, for example), so I'm not sure it would be my first choice anyway. I have written about OAuth in this blog, you can use that if you don't want to continue with OpenID (which still has some providers, it's not completely gone).