Bottle – micro-framework Python pour API REST

Bottle : Guide complet du micro-framework Python

Introduction à Bottle

Bottle est un micro-framework minimaliste en Python pour créer des applications web et des API REST. L'ensemble du framework tient dans un seul fichier de moins de 100 Ko, ce qui en fait la solution idéale pour les petits projets, les prototypes, les systèmes embarqués et les microservices. Bottle fournit tous les composants nécessaires pour lancer une application web complète sans dépendances externes.

Fonctionnalités et avantages de Bottle

Légèreté et simplicité

Bottle ne nécessite aucune dépendance externe et s'installe en une seule commande. Le framework tient dans un seul fichier, ce qui simplifie le déploiement et la compréhension du code.

Fonctionnalités intégrées

• Serveur HTTP intégré pour le développement
• Moteur de templates SimpleTemplate Engine intégré
• Support WSGI pour le déploiement en production
• Détection automatique des types de paramètres de route
• Gestion du JSON, des formulaires, des fichiers et des cookies

Flexibilité architecturale

Bottle est compatible avec toutes les bibliothèques Python pour les bases de données, les moteurs de templates et les serveurs WSGI. Cela permet de l'intégrer facilement dans des systèmes existants.

Installation et configuration de base

Installation de Bottle

pip install bottle

Création de votre première application

Créez un fichier app.py :

from bottle import route, run

@route('/')
def index():
    return "Bonjour de Bottle !"

@route('/hello/<name>')
def greet(name):
    return f"Bonjour, {name} !"

if __name__ == "__main__":
    run(host='localhost', port=8080, debug=True)

Lancement de l'application

python app.py

L'application sera accessible à l'adresse http://localhost:8080

Routage et gestion des requêtes

Routes de base

from bottle import route, get, post, put, delete

@route('/')
def home():
    return "Page d'accueil"

@get('/users')
def get_users():
    return "Liste des utilisateurs"

@post('/users')
def create_user():
    return "Création d'un utilisateur"

@put('/users/<id:int>')
def update_user(id):
    return f"Mise à jour de l'utilisateur {id}"

@delete('/users/<id:int>')
def delete_user(id):
    return f"Suppression de l'utilisateur {id}"

Paramètres de route

Bottle prend en charge différents types de paramètres :

@route('/user/<id:int>')
def user_by_id(id):
    return f"Utilisateur ID : {id}"

@route('/article/<slug:path>')
def article_by_slug(slug):
    return f"Article : {slug}"

@route('/price/<amount:float>')
def price(amount):
    return f"Prix : {amount}"

@route('/profile/<username:re:[a-zA-Z0-9_]+>')
def profile(username):
    return f"Profil : {username}"

Gestion des paramètres de requête (query)

from bottle import request

@route('/search')
def search():
    query = request.query.get('q', '')
    category = request.query.get('category', 'all')
    return f"Recherche '{query}' dans la catégorie '{category}'"

Gestion des données de requête

Traitement des formulaires

from bottle import request, post

@post('/submit')
def submit_form():
    name = request.forms.get('name')
    email = request.forms.get('email')
    age = request.forms.get('age', type=int)
    
    return f"Données reçues : {name}, {email}, {age}"

Gestion du JSON

from bottle import request, response

@post('/api/data')
def handle_json():
    data = request.json
    
    # Traitement des données
    result = {
        'status': 'success',
        'received': data,
        'message': 'Données reçues avec succès'
    }
    
    response.content_type = 'application/json'
    return result

Téléchargement de fichiers

from bottle import request, post

@post('/upload')
def upload_file():
    uploaded_file = request.files.get('file')
    if uploaded_file:
        file_path = f"./uploads/{uploaded_file.filename}"
        uploaded_file.save(file_path)
        return f"Fichier téléchargé : {uploaded_file.filename}"
    return "Aucun fichier reçu"

Utilisation des templates

Template simple

from bottle import route, view

@route('/hello/<name>')
@view('hello_template')
def hello(name):
    return dict(name=name)

Créez un fichier views/hello_template.tpl :

<!DOCTYPE html>
<html>
<head>
    <title>Bonjour {{name}}</title>
</head>
<body>
    <h1>Bonjour, {{name}} !</h1>
</body>
</html>

Déploiement en production

Avec Gunicorn

pip install gunicorn
gunicorn -w 4 -b 0.0.0.0:8080 app:app

Avec uWSGI

pip install uwsgi
uwsgi --http :8080 --wsgi-file app.py --callable app

Conclusion

Bottle est un micro-framework Python puissant et léger, parfait pour les projets rapides, les prototypes et les microservices. Sa simplicité d'utilisation et sa flexibilité en font un excellent choix pour les développeurs de tous niveaux. Que vous construisiez une API REST, une application web simple ou un service embarqué, Bottle vous offre les outils nécessaires sans complexité inutile.