Python course ยท Module 5: Flask and Web Apps
Flask-Login - user authentication
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-LoginUser 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 inis_active- is activeis_anonymous- is anonymousget_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:
- They'll be redirected to
/login - 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: Truegenerate_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 protectioncurrent_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. What does the current_user object represent in Flask-Login?
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.