1. Installation de Pyramid

Pour commencer avec Pyramid, vous devez d'abord l'installer. Voici les étapes à suivre :

•                 1️⃣ Assurez-vous d'avoir Python installé (version 3.6 ou supérieure).
•                 2️⃣ Ouvrez votre terminal (ou invite de commandes).
•                 3️⃣ Installez Pyramid en exécutant la commande suivante :

                pip install "pyramid"

•                 Pour créer un nouveau projet, utilisez le cookiecutter :

                cookiecutter gh:Pylons/pyramid-cookiecutter-starter

2. Création d'un projet Pyramid

Une fois l'installation terminée, vous pouvez créer votre projet Pyramid. Suivez ces étapes :

•                 1️⃣ Exécutez la commande suivante pour créer un nouveau projet :

                                cookiecutter gh:Pylons/pyramid-cookiecutter-starter

•                 2️⃣ Lorsque vous y êtes invité, entrez le nom de votre projet et les autres options de configuration.
•                 3️⃣ Accédez au répertoire de votre projet :

                                cd nom_du_projet

•                 4️⃣ Installez les dépendances requises avec :

                                pip install -e .

3. Configuration des routes

Les routes définissent comment Pyramid gère les requêtes. Voici comment configurer les routes dans votre projet :

•                 1️⃣ Ouvrez le fichier __init__.py de votre projet.
•                 2️⃣ Ajoutez le code suivant pour définir une route :

                                config.add_route('home', '/')

•                 3️⃣ Vous pouvez également définir d'autres routes, par exemple :

                                config.add_route('about', '/about')

Ces lignes indiquent à Pyramid d'associer les URL à des vues spécifiques.

4. Création de vues

Les vues sont les fonctions qui traitent les requêtes et renvoient des réponses. Voici comment créer une vue :

•                 1️⃣ Dans le fichier views.py, créez une fonction :

                                from pyramid.view import view_config

                                @view_config(route_name='home', renderer='json')
                                def home_view(request):
                                    return {'message': 'Welcome to Pyramid!'}

•                 2️⃣ Assurez-vous que la vue est liée à une route que vous avez configurée précédemment.
•                 3️⃣ Pour tester, lancez votre application avec :

                                pserve development.ini

Visitez http://localhost:6543/ pour voir le message de bienvenue.

5. Conclusion

Ce tutoriel a présenté les étapes fondamentales pour créer une application web avec Pyramid. Vous avez appris à installer le framework, à créer un projet, à configurer des routes et à créer des vues. Pyramid est un outil puissant qui offre une flexibilité et une extensibilité pour le développement d'applications web. Pour aller plus loin, explorez la documentation officielle de Pyramid pour découvrir des fonctionnalités avancées et des meilleures pratiques.

Activité 1 - Site Statique

1. Objectif de l'Activité

L'objectif de cette activité est de créer un site statique simple en utilisant le framework Pyramid. Vous apprendrez à configurer les routes, à créer des vues et à servir des fichiers HTML statiques. À l'issue de cette activité, vous aurez acquis des compétences essentielles pour le développement d'applications web avec Pyramid.

2. Étapes de Création

Suivez les étapes ci-dessous pour créer votre site statique :

1. Installation de Pyramid : Si ce n'est pas déjà fait, installez Pyramid en suivant les instructions d'installation.
2. Création d'un Nouveau Projet : Utilisez la commande suivante :

   cookiecutter gh:Pylons/pyramid-cookiecutter-starter

Ensuite, suivez les instructions :
3. Accédez au Répertoire de Votre Projet :

   cd nom_du_projet

4. Installez les dépendances requises avec :

pip install -e .

5. Pour tester, lancez votre application avec :

pserve development.ini


Dans le navigateur, vous devriez voir :

3. Explication des Étapes

Voici une explication des étapes que vous avez suivies :

1. Commande de Cookiecutter : Cette commande utilise cookiecutter pour créer un nouveau projet à partir du modèle pyramid-cookiecutter-starter hébergé sur GitHub.
2. Confirmation de Réutilisation : Vous avez déjà téléchargé ce modèle. Le système vous demande si vous souhaitez le supprimer et le télécharger à nouveau. Vous avez choisi de conserver l'existant.
3. Saisie des Informations du Projet : Vous avez entré m2c comme nom de projet, choisi jinja2 comme moteur de templates, et sqlalchemy comme backend.
4. Messages de Bienvenue : Le système vous fournit des liens vers la documentation, des tutoriels et des ressources de support pour Pyramid.
5. Instructions pour la Suite : Vous êtes guidé à travers les étapes pour créer un environnement virtuel, installer les dépendances, initialiser la base de données, exécuter des tests et lancer votre projet.

4. Structure du Projet

Votre projet devrait avoir la structure suivante :

Contenu du Fichier '__init__.py'

Après la création d'un nouveau projet Pyramid, le fichier __init__.py contient le code suivant :

from pyramid.config import Configurator

def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application. """
    with Configurator(settings=settings) as config:
        config.include('pyramid_jinja2')
        config.include('.routes')
        config.include('.models')
        config.scan()
    return config.make_wsgi_app()

Explication du Code

Ce code définit la fonction main, qui retourne une application WSGI pour Pyramid. Voici une explication des composants clés :

• 1️⃣ from pyramid.config import Configurator : Cette ligne importe la classe Configurator utilisée pour configurer l'application Pyramid.
• 2️⃣ def main(global_config, **settings) : La fonction main prend des paramètres globaux et des paramètres de configuration supplémentaires. Elle est le point d'entrée de l'application.
• 3️⃣ with Configurator(settings=settings) as config : Cela crée un nouvel objet Configurator avec les paramètres fournis.
• 4️⃣ config.include('pyramid_jinja2') : Cette ligne inclut le package pyramid_jinja2, permettant d'utiliser Jinja2 pour rendre des vues.
• 5️⃣ config.include('.routes') : Cela inclut le module routes, où les routes de l'application sont définies.
• 6️⃣ config.include('.models') : Cette ligne inclut le module models, qui gère la logique de données de l'application.
• 7️⃣ config.scan() : Cette méthode recherche et enregistre les vues et autres composants définis dans le code.
• 8️⃣ return config.make_wsgi_app() : Enfin, cette ligne crée et retourne l'application WSGI, prête à être servie par un serveur compatible.

5. Ajouter une Route "Home" et une Vue Jinja2

Pour ajouter une route "home" et une vue associée au format Jinja2 dans votre projet Pyramid, suivez ces étapes :

1. Contenu de routes.py

Le fichier routes.py par défaut contient le code suivant :

def includeme(config):
    config.add_static_view('static', 'static', cache_max_age=3600)
    config.add_route('home', '/')

Ici, nous ajoutons la route 'home' qui pointe vers la racine de l'application.

2. Créer la Vue Associée

Comme vous n'avez pas encore de fichier views.py, vous pouvez le créer. Ajoutez une vue qui utilisera un template Jinja2. Voici comment faire :

from pyramid.config import Configurator
from pyramid.renderers import render_to_response

# Remarque : commentez la ligne suivante dans le dossier views/default.py pour éviter un conflit
# @view_config(route_name='home', renderer='m2c:templates/mytemplate.jinja2')
def home_view(request):
    message = "Welcome to the home page!"  # Définir la variable message
    return render_to_response('home.jinja2', {'message': message}, request=request)  # Passer la variable message

def main(global_config, **settings):
    """ Cette fonction retourne une application WSGI Pyramid. """
    with Configurator(settings=settings) as config:
        config.include('pyramid_jinja2')
        config.add_jinja2_renderer('.html')  # Configurer le moteur de rendu
        config.add_jinja2_search_path('templates')  # Ajouter le chemin des templates
        config.include('.routes')

        config.add_route('home', '/')
        config.add_view(home_view, route_name='home')

        config.scan()
    return config.make_wsgi_app()

3. Créer le Template Jinja2

Créez un fichier nommé home.jinja2 dans le dossier templates de votre projet avec le contenu suivant :

<!DOCTYPE html>
<html>
<head>
    <title>Home</title>
</head>
<body>
    <h1>{{ message }}</h1>  <!-- Cela affichera le message -->
</body>
</html>

4. Exécution

Pour tester, lancez votre application avec :

pserve development.ini

Résumé

Vous avez ajouté une route "home" qui pointe vers la racine de l'application. Vous avez créé une vue qui renvoie un message à afficher dans le template Jinja2. Ce dernier affiche le message lorsqu'un utilisateur accède à la page d'accueil.

6. Conclusion

Dans cette activité, vous avez appris à créer un site statique simple avec Pyramid. Vous avez configuré les routes, créé des vues, et servi des fichiers HTML et CSS. Ces compétences sont fondamentales pour le développement d'applications web plus complexes. N'hésitez pas à explorer davantage les fonctionnalités de Pyramid pour enrichir votre site avec des éléments dynamiques.

Activité 2 - Site dynamique

1. Objectif de l'activité

L'objectif de cette activité est de créer un site dynamique en utilisant le framework Pyramid. Vous allez inclure un formulaire d'inscription qui permettra aux utilisateurs de s'enregistrer. À la fin de cette activité, vous aurez appris à gérer les formulaires et à traiter les données utilisateur.

2. Étapes de création

Suivez les étapes ci-dessous pour créer votre site dynamique :

•                 1️⃣ Installation de Pyramid : Assurez-vous d'avoir Pyramid installé. Si ce n'est pas le cas, suivez les instructions d'installation.
•                 2️⃣ Création d'un nouveau projet : Utilisez la commande suivante :                 

  cookiecutter gh:Pylons/pyramid-cookiecutter-starter

•                 3️⃣ Accédez au répertoire de votre projet :

  cd nom_du_projet

3. Structure du projet

Votre projet devrait avoir la structure suivante :

    nom_du_projet/
    ├── __init__.py
    ├── views.py
    ├── templates/
    │   └── registration.html
    └── development.ini
    

Créez un dossier templates pour stocker le fichier HTML du formulaire.

4. Gestion du formulaire

Dans le fichier registration.html, ajoutez le code suivant pour créer un formulaire d'inscription :

                <!DOCTYPE html>
                <html lang="fr">
                <head>
                    <meta charset="UTF-8">
                    <meta name="viewport" content="width=device-width, initial-scale=1.0">
                    <title>Formulaire d'inscription</title>
                </head>
                <body>
                    <h1>Inscription</h1>
                    <form action="/register" method="post">
                        <label for="username">Nom d'utilisateur:</label>
                        <input type="text" id="username" name="username" required>
                       <br>
                        <label for="email">Email:</label>
                        <input type="email" id="email" name="email" required>
                        <br>
                        <input type="submit" value="S'inscrire">
                    </form>
                </body>
                </html>

Ce formulaire envoie une requête POST à l'URL /register.

5. Test de l'application

Pour tester votre application :

•                 1️⃣ Ouvrez le fichier __init__.py et configurez la route pour le formulaire :

                config.add_route('register', '/register')

•                 2️⃣ Ajoutez une vue pour traiter le formulaire :

                from pyramid.view import view_config
                from pyramid.response import Response

                @view_config(route_name='register', renderer='templates/registration.html')
                def registration_view(request):
                    if request.method == 'POST':
                        username = request.POST.get('username')
                        email = request.POST.get('email')
                        return Response(f'Inscription réussie pour {username} avec l\'email {email}!')
                    return {}  # Renvoie le formulaire si ce n'est pas une requête POST

•                 3️⃣ Exécutez votre application avec :

                pserve development.ini

•                 Visitez http://localhost:6543/register dans votre navigateur pour voir le formulaire d'inscription.

6. Conclusion

Dans cette activité, vous avez appris à créer un site dynamique avec Pyramid, incluant un formulaire d'inscription. Vous avez configuré les routes, créé des vues pour traiter les données du formulaire, et géré les requêtes POST. Ces compétences sont essentielles pour le développement d'applications web interactives. N'hésitez pas à explorer davantage les fonctionnalités de Pyramid pour ajouter des éléments plus complexes à votre site.