Python course ยท Module 5: Flask and Web Apps

Flask-Login - user authentication

7 min read ยท
In this lesson12

Welcome again! Darwin here with the last lesson before deployment - user authentication with Flask-Login!

Safari Analogy: Authentication is like passes for tourists - only people with valid tickets can enter the park, observe animals, and use exclusive trails! Without authentication anyone could enter and edit your database!

Why authentication?

Problem: Without authentication anyone can:

  • Add/delete species
  • Edit data
  • Access sensitive information
  • No personalization

Solution: Login/registration system with Flask-Login!

Flask-Login - session management

Flask-Login is an extension for managing user sessions:

Login/logout users Remember sessions (cookies) Route protection (@login_required) Access to current_user "Remember me" functionality

Installation

pip install Flask-Login

User Model

Flask-Login requires a User class with specific methods. The easiest way is to use UserMixin:

# models.py
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash

class User(UserMixin):
    def __init__(self, id, username, email, password_hash):
        self.id = id
        self.username = username
        self.email = email
        self.password_hash = password_hash

    def set_password(self, password):
        """Hash the password"""
        self.password_hash = generate_password_hash(password)

    def check_password(self, password):
        """Verify the password"""
        return check_password_hash(self.password_hash, password)

    def __repr__(self):
        return f'<User {self.username}>'

UserMixin provides:

  • is_authenticated - is logged in
  • is_active - is active
  • is_anonymous - is anonymous
  • get_id() - returns ID as string

Flask-Login configuration

# app.py
from flask import Flask
from flask_login import LoginManager

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key-123'

# Initialize LoginManager
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'  # Redirect for unauthenticated users
login_manager.login_message = 'Please log in to access this page.'

# User database (in production: SQLite/PostgreSQL)
users_db = {}
next_user_id = 1

# User loader - required by Flask-Login
@login_manager.user_loader
def load_user(user_id):
    """Load user by ID"""
    return users_db.get(int(user_id))

@login_manager.user_loader - Flask-Login calls this function to load a user from the session.

User registration

forms.py - registration form

from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, Email, EqualTo, Length

class RegistrationForm(FlaskForm):
    username = StringField('Username',
                          validators=[DataRequired(), Length(min=4, max=20)])

    email = StringField('Email',
                       validators=[DataRequired(), Email()])

    password = PasswordField('Password',
                            validators=[DataRequired(), Length(min=8)])

    confirm_password = PasswordField('Confirm password',
                                    validators=[DataRequired(),
                                               EqualTo('password', message='Passwords must match')])

    submit = SubmitField('Register')

app.py - registration route

from flask import render_template, redirect, url_for, flash
from flask_login import login_user
from models import User
from forms import RegistrationForm

@app.route('/register', methods=['GET', 'POST'])
def register():
    form = RegistrationForm()

    if form.validate_on_submit():
        global next_user_id

        # Check if username/email already exists
        for user in users_db.values():
            if user.username == form.username.data:
                flash('Username already taken!', 'error')
                return render_template('register.html', form=form)

            if user.email == form.email.data:
                flash('Email already registered!', 'error')
                return render_template('register.html', form=form)

        # Create new user
        user = User(
            id=next_user_id,
            username=form.username.data,
            email=form.email.data,
            password_hash=None
        )
        user.set_password(form.password.data)  # Hash password

        users_db[next_user_id] = user
        next_user_id += 1

        flash(f'Account {user.username} created! You can now log in.', 'success')
        return redirect(url_for('login'))

    return render_template('register.html', form=form)

User login

forms.py - login form

class LoginForm(FlaskForm):
    username = StringField('Username', validators=[DataRequired()])
    password = PasswordField('Password', validators=[DataRequired()])
    remember = BooleanField('Remember me')
    submit = SubmitField('Log in')

app.py - login route

from flask_login import login_user, current_user, logout_user

@app.route('/login', methods=['GET', 'POST'])
def login():
    # If already logged in, redirect
    if current_user.is_authenticated:
        return redirect(url_for('home'))

    form = LoginForm()

    if form.validate_on_submit():
        # Find user
        user = None
        for u in users_db.values():
            if u.username == form.username.data:
                user = u
                break

        # Check password
        if user and user.check_password(form.password.data):
            login_user(user, remember=form.remember.data)
            flash(f'Welcome back, {user.username}!', 'success')

            # Redirect to next_page or home
            next_page = request.args.get('next')
            return redirect(next_page) if next_page else redirect(url_for('home'))
        else:
            flash('Invalid username or password!', 'error')

    return render_template('login.html', form=form)

login_user(user, remember=True) - log in the user and create a session.

Logout

@app.route('/logout')
def logout():
    logout_user()
    flash('You have been logged out.', 'info')
    return redirect(url_for('home'))

logout_user() - log out the user and destroy the session.

@login_required - protecting routes

The @login_required decorator protects routes from unauthenticated users:

from flask_login import login_required, current_user

@app.route('/species/add', methods=['GET', 'POST'])
@login_required  # Only logged in users
def add_species():
    form = AddSpeciesForm()

    if form.validate_on_submit():
        # ... add species ...
        flash(f'Species added by {current_user.username}!', 'success')
        return redirect(url_for('list_species'))

    return render_template('add_species.html', form=form)

@app.route('/profile')
@login_required
def profile():
    return render_template('profile.html', user=current_user)

If an unauthenticated user visits /species/add:

  1. They'll be redirected to /login
  2. After logging in they'll return to /species/add

current_user - current user

current_user is a proxy to the logged-in user:

from flask_login import current_user

@app.route('/')
def home():
    if current_user.is_authenticated:
        return render_template('home.html',
                             username=current_user.username,
                             species_count=len(species_db))
    else:
        return render_template('home.html',
                             username=None,
                             species_count=len(species_db))

In templates

{% if current_user.is_authenticated %}
    <p>Logged in as: <strong>{{ current_user.username }}</strong></p>
    <a href="{{ url_for('logout') }}">Log out</a>
{% else %}
    <a href="{{ url_for('login') }}">Log in</a> |
    <a href="{{ url_for('register') }}">Register</a>
{% endif %}

Password hashing - security

NEVER store passwords in plain text! Use hashing:

from werkzeug.security import generate_password_hash, check_password_hash

# Registration - hash password
password_hash = generate_password_hash('SecretPassword123')
# Output: 'pbkdf2:sha256:260000$...'

# Login - verify password
is_correct = check_password_hash(password_hash, 'SecretPassword123')
# Output: True

generate_password_hash() uses PBKDF2 with salt and multiple iterations - secure!

Complete application with authentication

models.py

from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash

class User(UserMixin):
    def __init__(self, id, username, email, password_hash):
        self.id = id
        self.username = username
        self.email = email
        self.password_hash = password_hash

    def set_password(self, password):
        self.password_hash = generate_password_hash(password)

    def check_password(self, password):
        return check_password_hash(self.password_hash, password)

forms.py

from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, BooleanField, SubmitField
from wtforms.validators import DataRequired, Email, EqualTo, Length

class RegistrationForm(FlaskForm):
    username = StringField('Username', validators=[DataRequired(), Length(min=4, max=20)])
    email = StringField('Email', validators=[DataRequired(), Email()])
    password = PasswordField('Password', validators=[DataRequired(), Length(min=8)])
    confirm_password = PasswordField('Confirm password',
                                    validators=[DataRequired(), EqualTo('password')])
    submit = SubmitField('Register')

class LoginForm(FlaskForm):
    username = StringField('Username', validators=[DataRequired()])
    password = PasswordField('Password', validators=[DataRequired()])
    remember = BooleanField('Remember me')
    submit = SubmitField('Log in')

app.py

from flask import Flask, render_template, redirect, url_for, flash, request
from flask_login import LoginManager, login_user, logout_user, login_required, current_user
from models import User
from forms import RegistrationForm, LoginForm, AddSpeciesForm

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key-123'

# Flask-Login
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'

# Databases (in-memory)
users_db = {}
next_user_id = 1

species_db = {}
next_species_id = 1

@login_manager.user_loader
def load_user(user_id):
    return users_db.get(int(user_id))

@app.route('/')
def home():
    return render_template('home.html',
                         species_count=len(species_db))

@app.route('/register', methods=['GET', 'POST'])
def register():
    if current_user.is_authenticated:
        return redirect(url_for('home'))

    form = RegistrationForm()

    if form.validate_on_submit():
        global next_user_id

        # Check duplicates
        for user in users_db.values():
            if user.username == form.username.data:
                flash('Username already taken!', 'error')
                return render_template('register.html', form=form)

        # Create user
        user = User(next_user_id, form.username.data, form.email.data, None)
        user.set_password(form.password.data)
        users_db[next_user_id] = user
        next_user_id += 1

        flash(f'Account created! Please log in.', 'success')
        return redirect(url_for('login'))

    return render_template('register.html', form=form)

@app.route('/login', methods=['GET', 'POST'])
def login():
    if current_user.is_authenticated:
        return redirect(url_for('home'))

    form = LoginForm()

    if form.validate_on_submit():
        user = None
        for u in users_db.values():
            if u.username == form.username.data:
                user = u
                break

        if user and user.check_password(form.password.data):
            login_user(user, remember=form.remember.data)
            flash(f'Welcome, {user.username}!', 'success')

            next_page = request.args.get('next')
            return redirect(next_page) if next_page else redirect(url_for('home'))
        else:
            flash('Invalid username or password!', 'error')

    return render_template('login.html', form=form)

@app.route('/logout')
@login_required
def logout():
    logout_user()
    flash('Logged out.', 'info')
    return redirect(url_for('home'))

@app.route('/species/add', methods=['GET', 'POST'])
@login_required
def add_species():
    form = AddSpeciesForm()

    if form.validate_on_submit():
        global next_species_id

        new_species = {
            'id': next_species_id,
            'name': form.name.data,
            'added_by': current_user.username
        }

        species_db[next_species_id] = new_species
        next_species_id += 1

        flash(f'Species added by {current_user.username}!', 'success')
        return redirect(url_for('list_species'))

    return render_template('add_species.html', form=form)

if __name__ == '__main__':
    app.run(debug=True)

templates/base.html - navigation with auth

<nav>
    <a href="{{ url_for('home') }}">Home</a>
    <a href="{{ url_for('list_species') }}">Species</a>

    {% if current_user.is_authenticated %}
        <a href="{{ url_for('add_species') }}">Add species</a>
        <a href="{{ url_for('profile') }}">Profile ({{ current_user.username }})</a>
        <a href="{{ url_for('logout') }}">Log out</a>
    {% else %}
        <a href="{{ url_for('login') }}">Log in</a>
        <a href="{{ url_for('register') }}">Register</a>
    {% endif %}
</nav>

Summary

In this lesson you learned:

  • Why authentication in web applications
  • Flask-Login - session management
  • User model with UserMixin
  • User registration
  • Login/logout
  • @login_required - route protection
  • current_user - access to logged-in user
  • Password hashing (werkzeug.security)
  • Complete Safari Database application with auth

Final Safari Analogy: Flask-Login is like a safari pass system - only tourists with valid tickets (current_user.is_authenticated) can enter the protected trail zone (@login_required), and each tourist has their unique identifier (user.id) and password (hashed)!

Next lesson: Darwin will show you deployment - publishing your Flask application on the internet (Gunicorn, Render, Railway)!

Docs entries used in this lesson

Spotted a mistake in this lesson?

Check yourself

Answer the questions from this lesson. Pick an answer to see right away whether it is correct.

  1. 1. What does the current_user object represent in Flask-Login?

  2. 2. How do you install Flask-Login?

These are 2 of 4 questions for this lesson. Solve the rest in the game.

Hands-on tasks in the game

  • Vertical ordering

    Arrange the definition of a User model with Flask-Login:

  • Click in order

    Arrange the login_user function call:

  • Code editor

    Write a /dashboard view with the @login_required decorator that displays a greeting for current_user.

  1. Questioncurrent_user
  2. QuestionInstalling Flask-Login
  3. Put in orderUser Model
  4. QuestionUserMixin
  5. QuestionThe login_required decorator
  6. Click in orderLogging in a user
  7. Coding taskProtected view

Useful articles