Flask Cheatsheet
Table of Contents
- Installation and Setup
- Basic Application Structure
- Routing
- Request Handling
- Templates
- Forms
- Database Integration
- Authentication
- Error Handling
- Configuration
- Blueprints
- RESTful APIs
- Testing
- Deployment
Installation and Setup
Install Flask
pip install flask
Create a new Flask application
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello, World!'
if __name__ == '__main__':
app.run(debug=True)
Run the application
python app.py
Basic Application Structure
Minimal Flask application
from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return 'Index Page'
@app.route('/hello')
def hello():
return 'Hello, World'
if __name__ == '__main__':
app.run(debug=True)
Routing
Basic routing
@app.route('/')
def index():
return 'Index Page'
@app.route('/hello')
def hello():
return 'Hello, World'
Dynamic routing
@app.route('/user/<username>')
def show_user_profile(username):
return f'User {username}'
@app.route('/post/<int:post_id>')
def show_post(post_id):
return f'Post {post_id}'
HTTP methods
from flask import request
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
return do_the_login()
else:
return show_login_form()
Request Handling
Accessing request data
from flask import request
@app.route('/login', methods=['POST'])
def login():
username = request.form['username']
password = request.form['password']
# Process login
File uploads
from flask import request
@app.route('/upload', methods=['POST'])
def upload_file():
if 'file' not in request.files:
return 'No file part'
file = request.files['file']
if file.filename == '':
return 'No selected file'
if file:
file.save('/path/to/uploads/' + file.filename)
return 'File uploaded successfully'
Templates
Rendering templates
from flask import render_template
@app.route('/hello/<name>')
def hello(name=None):
return render_template('hello.html', name=name)
Template syntax (hello.html)
<!doctype html>
<title>Hello from Flask</title>
{% if name %}
<h1>Hello {{ name }}!</h1>
{% else %}
<h1>Hello, World!</h1>
{% endif %}
Template inheritance
<!-- base.html -->
<!doctype html>
<html>
<head>
{% block head %}
<title>{% block title %}{% endblock %} - My Website</title>
{% endblock %}
</head>
<body>
<div id="content">{% block content %}{% endblock %}</div>
</body>
</html>
<!-- child.html -->
{% extends "base.html" %}
{% block title %}Index{% endblock %}
{% block content %}
<h1>Index</h1>
<p>Welcome to my website.</p>
{% endblock %}
Forms
Using Flask-WTF for forms
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, Email
class LoginForm(FlaskForm):
email = StringField('Email', validators=[DataRequired(), Email()])
password = PasswordField('Password', validators=[DataRequired()])
submit = SubmitField('Log In')
@app.route('/login', methods=['GET', 'POST'])
def login():
form = LoginForm()
if form.validate_on_submit():
# Process login
return 'Logged in successfully'
return render_template('login.html', form=form)
Database Integration
Using Flask-SQLAlchemy
from flask_sqlalchemy import SQLAlchemy
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'
db = SQLAlchemy(app)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
return f'<User {self.username}>'
# Create tables
db.create_all()
# Add a new user
@app.route('/add_user/<username>/<email>')
def add_user(username, email):
user = User(username=username, email=email)
db.session.add(user)
db.session.commit()
return f'User {username} added to database'
Authentication
Using Flask-Login
from flask_login import LoginManager, UserMixin, login_user, login_required, logout_user, current_user
login_manager = LoginManager()
login_manager.init_app(app)
class User(UserMixin, db.Model):
# ... (User model definition)
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
user = User.query.filter_by(username=request.form['username']).first()
if user and user.check_password(request.form['password']):
login_user(user)
return 'Logged in successfully'
return render_template('login.html')
@app.route('/logout')
@login_required
def logout():
logout_user()
return 'Logged out successfully'
@app.route('/protected')
@login_required
def protected():
return f'Hello, {current_user.username}!'
Error Handling
Custom error pages
@app.errorhandler(404)
def page_not_found(error):
return render_template('404.html'), 404
@app.errorhandler(500)
def internal_server_error(error):
return render_template('500.html'), 500
Configuration
Configuration handling
# config.py
class Config:
DEBUG = False
TESTING = False
DATABASE_URI = 'sqlite:///:memory:'
class ProductionConfig(Config):
DATABASE_URI = 'mysql://user@localhost/foo'
class DevelopmentConfig(Config):
DEBUG = True
# app.py
app.config.from_object('config.DevelopmentConfig')
Blueprints
Using blueprints for modular applications
from flask import Blueprint, render_template
admin = Blueprint('admin', __name__, url_prefix='/admin')
@admin.route('/')
def admin_index():
return 'Admin Index Page'
@admin.route('/users')
def users():
return 'Admin Users Page'
# In your main app.py
from admin_blueprint import admin
app.register_blueprint(admin)
RESTful APIs
Creating a simple REST API
from flask import jsonify, request
@app.route('/api/users', methods=['GET'])
def get_users():
users = User.query.all()
return jsonify([user.to_dict() for user in users])
@app.route('/api/users', methods=['POST'])
def create_user():
data = request.get_json()
new_user = User(username=data['username'], email=data['email'])
db.session.add(new_user)
db.session.commit()
return jsonify(new_user.to_dict()), 201
Testing
Writing tests for Flask applications
import unittest
from app import app, db
class FlaskTestCase(unittest.TestCase):
def setUp(self):
app.config['TESTING'] = True
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
self.app = app.test_client()
db.create_all()
def tearDown(self):
db.session.remove()
db.drop_all()
def test_index(self):
response = self.app.get('/')
self.assertEqual(response.status_code, 200)
self.assertIn(b'Hello, World!', response.data)
if __name__ == '__main__':
unittest.main()
Deployment
Preparing for production
from werkzeug.middleware.proxy_fix import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app)
if __name__ == '__main__':
app.run()
Using Gunicorn for production
gunicorn -w 4 -b 127.0.0.1:5000 app:app
2024 © All rights reserved - buraxta.com