Pour intégrer fontawesome sur votre site internet, vous pouvez vous y prendre de différentes manières.

Appeler les bibliothèques d'icônes de fontawesome dans le header par des liens link href :

 < link href="/your-path-to-fontawesome/css/fontawesome.css" rel="stylesheet" >
 < link href="/your-path-to-fontawesome/css/brand.css" rel="stylesheet" >
 < link href="/your-path-to-fontawesome/css/solid.css" rel="stylesheet" >

Ce n'est pas l'option que je trouve la plus élégante, d'autant que si l'on travaille avec sass, il y a une manière d'encapsuler fontawesome directement dans app.scss.

Intégrer les bibliothèques d'icônes dans app.scss

 La méthode que je préfère est d'utiliser sass pour intégrer les packs d'icônes directement dans les css au moment du build des feuilles de styles. Cela permet d'une part de ne pas surcharger inutilement les déclarations dans la balise head et d'autre part de tout gérer dans le app.scss.

La méthode est simple.

Dans un premier temps, il faut télécharger le zip de fontawesome pour scss, il contient deux répertoires, un qui s'appelle scss sur lequel nous allons faire les déclarations voulues et l'autre webfonts contenant les polices proprement dites en svg.

 Déclarer les chemins des bibliothèques de polices.

Ensuite nous allons nous placer dans notre fichier de configuration app.scss, ou nous allons déclarer dans l'import les fichiers scss dont nous aurons besoin.

Enfin, dans le fichier variables.scss, nous allons déclarer la variable $fa-font-path avec la valeur du chemin du répertoire webfonts.

Ce qui se résume si l'on mets toutes ces déclarations dans le fichier app.scss à cela.

@import "./fontawesome/scss/fontawesome";
 @import "./fontawesome/scss/solid";
 

 $fa-font-path: '../webfonts';

Il ne vous reste plus qu'à lancer un watch ou un build sur votre sass préféré.

 Gestion des relations one to many et many to many avec SQL Alchemy

Introduction : 

Pour ceux qui ne connaissent pas, SQLAlchemy est un ORM basique standard de la librairie de python. Dans la nouvelle version on utilise les annotations pour définir les types de données et la fonction mapped pour les créer.

Exemple:

    Relation one to many

        Pour un utilisateur ayant plusieurs posts 

from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
from sqlalchemy import ForeignKey
from typing import List
class Base(DeclarativeBase):
    pass



class User(Base):
    __tablename__ = "users"
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str]
    posts: Mapped[List["Post"]] = relationship(
        back_populates="author",
        cascade="all,
        delete-orphan"
 
class Post(Base):
    __tablename__ = "posts"
    id: Mapped[int] = mapped_column(primary_key=True)
    title: Mapped[str]
    user_id: Mapped[int] = mapped_column(ForeignKey("users.id"))
    author: Mapped["User"] = relationship(back_populates="posts")

 Sur le côté gérant la relation plusieurs on doit placer le mot clé ForeignKey, la méthode relationship() doit figurer des deux côtés pour créer la relation.
backpopulates permet de synchroniser les données dans la relation et cascade permet la suppression en cascade si l'utilisateur est supprimé.

Pour utiliser le code on utilise les mots clé add et append :

user = User(name="Alice")
post = Post(title="Hello")
user.posts.append(post)
session.add(user)
session.commit()

Relation many to many

On commence par créer une table intermédiaire qui permet d'associer les diffèrentes clés des éléments.Dans l'exemple on associera les tags aux posts:

from sqlalchemy import Table, Column, ForeignKey
post_tag = Table(
 "post_tag",
 Base.metadata,
 Column("post_id", ForeignKey("posts.id"), primary_key=True),
 Column("tag_id", ForeignKey("tags.id"), primary_key=True),
)

Ensuite on va modifier les modeles :

from typing import List
class Post(Base):
     __tablename__ = "posts"
     id: Mapped[int] = mapped_column(primary_key=True)
     title: Mapped[str]
     tags: Mapped[List["Tag"]] = relationship(
    secondary=post_tag,
    back_populates="posts" )
 
class Tag(Base):
     __tablename__ = "tags"
     id: Mapped[int] = mapped_column(primary_key=True)
     name: Mapped[str]
     posts: Mapped[List["Post"]] = relationship(
    secondary=post_tag,
    back_populates="tags" )

Son utilisation se fait de la manière suivante

post = Post(title="SQLAlchemy Tips")
tag1 = Tag(name="python")
tag2 = Tag(name="orm")
 
post.tags.extend([tag1, tag2])
session.add(post)
session.commit()

Relation many to many avec données supplémentaires

l'astuce est d'utiliser un modèle d'association à la place d'une simple table d'association.

Dans l'exemple ci-dessous au lieu de la table que nous avons utilisé au dessus, nous utilisons un modèle :

class PostTag(Base):
    __tablename__ = "post_tag"
    post_id: Mapped[int] = mapped_column(ForeignKey("posts.id"), primary_key=True)
    tag_id: Mapped[int] = mapped_column(ForeignKey("tags.id"), primary_key=True)
    extra_data: Mapped[str]
    post: Mapped["Post"] = relationship(back_populates="post_tags")
    tag: Mapped["Tag"] = relationship(back_populates="post_tags")

puis: 

class Post(Base):
    ...
    post_tags: Mapped[List["PostTag"]] = relationship(back_populates="post")