Basile Marchand | Articles et notes

Du pixel art avec Octave : des matrices, des couleurs et un peu de tramage

Sat, 14 Nov 2026 00:00:00 GMT

Pour me refaire un peu la main sur Octave, je me suis amusé à transformer une photo en pixel art. Le principe est assez simple : faire de gros pixels et réduire le nombre de couleurs. Et comme on est dans Octave, autant faire ça avec quelques produits de matrices 😎.

Voilà le genre de résultat que ça donne :

L’ensemble du code est disponible sur GitHub. Ici je vais surtout vous expliquer les quelques opérations derrière.

On commence par faire de gros pixels

Voici la photo de départ :

Une image RGB, c’est un tableau avec trois canaux : rouge, vert et bleu. On peut donc travailler sur chaque canal comme sur une matrice. Je commence par convertir l’image avec im2double, pour avoir des valeurs entre 0 et 1.

Ensuite, l’idée est de prendre des blocs de pixels et de remplacer chaque bloc par sa couleur moyenne. Si je prends des blocs de 15 × 15, mes 225 pixels deviennent un seul pixel. On perd les petits détails et on garde les grandes zones de couleur.

Pour faire ça, j’ai construit deux projecteurs avec un produit de Kronecker :

width_r = floor(width / ratio);
height_r = floor(height / ratio);

im_crop = im(1:height_r*ratio, 1:width_r*ratio, :);

projector_left = kron(speye(height_r), ones(1, ratio) / ratio);
projector_right = kron(speye(width_r), ones(1, ratio) / ratio);

for c = 1:channels
  im_r(:,:,c) = projector_left * im_crop(:,:,c) * projector_right';
endfor

Alors si kron ne vous parle pas, ici il sert à répéter le même petit bloc de moyenne le long de la matrice. speye nous donne une matrice identité creuse, et ones(1, ratio) / ratio fait la moyenne de ratio valeurs.

Le projecteur de gauche regroupe les lignes, celui de droite les colonnes. Avec les deux multiplications, on a donc notre moyenne sur chaque carré. On recadre juste l’image au début pour avoir un nombre entier de blocs.

Maintenant on réduit les couleurs

À ce stade on a une petite image, mais encore beaucoup de couleurs différentes. Pour obtenir une palette de 8, 16 ou 32 couleurs, j’utilise K-means.

On range les pixels dans une matrice où chaque ligne contient les trois valeurs RGB d’un pixel, puis on demande à K-means de les répartir en ncolors groupes :

X = reshape(im_r, [], 3);

[idx, palette] = kmeans(X, ncolors, ...
    "Start", "plus", ...
    "Replicates", 5);

Les centres des groupes nous donnent les couleurs de la palette. Donc pas besoin de choisir à la main les couleurs qui vont bien avec la photo, c’est le calcul qui s’en charge.

Pour voir ce que ça change, voilà le résultat avec des blocs de 15 × 15 :

2 couleurs	8 couleurs	32 couleurs

Avec deux couleurs on est assez radical ! En augmentant la palette on retrouve progressivement les nuances du ciel et des bâtiments.

Un peu de tramage

Une fois la palette calculée, on pourrait simplement remplacer chaque pixel par la couleur la plus proche. Mais dans les dégradés, notamment le ciel ici, on se retrouve vite avec de grandes bandes de couleur.

J’ai donc ajouté un tramage inspiré de Floyd–Steinberg. Le principe : quand on remplace un pixel par une couleur de la palette, on calcule l’écart et on en transmet une partie aux pixels voisins. Ils vont en tenir compte au moment de choisir leur propre couleur.

Pour choisir la couleur, on fait tout simplement une recherche du plus proche voisin dans notre palette RGB :

distances = sum((palette - pixel).^2, 2);
[~, k] = min(distances);
color = palette(k,:);

error = 0.3 * (pixel - color);

Dans cette version je diffuse 30 % de l’erreur, répartis entre le pixel de droite et les trois voisins de la ligne suivante :

À gauche	Même colonne	À droite
—	Pixel courant	7/16
3/16	5/16	1/16

On parcourt l’image de gauche à droite et de haut en bas. L’erreur est donc toujours envoyée à des pixels que l’on n’a pas encore traités. C’est ce qui donne les petits motifs visibles dans les transitions entre deux couleurs.

Et on remet tout ça à la bonne taille

Il reste à agrandir notre petite image. Ici on utilise le plus proche voisin pour garder des blocs bien nets :

im_pix = imresize(im_d, ratio, "nearest");

Chaque pixel redevient un carré de ratio × ratio pixels, avec la couleur choisie à l’étape précédente. Le tramage a été fait sur la petite image, donc ses motifs sont agrandis eux aussi.

Avec 16 couleurs, voilà ce que donne le changement de taille des blocs :

Blocs de 5 × 5	Blocs de 15 × 15	Blocs de 30 × 30

Pour jouer avec le code

Il vous faudra Octave et les paquets image et statistics. Le script main.m lit une photo RGB nommée image.jpg et génère les variantes dans outputs/.

Les deux boucles permettent de faire varier le nombre de couleurs et la taille des blocs :

for color = [2,4,8,16,32]
  for ratio = [5,10,15,20,25,30]
    im_pixel = pixel_art(im_int, ratio, color);
    output_filepath = fullfile(folder, ...
        sprintf("image_%d_%d.jpg", ratio, color));
    imwrite(im_pixel, output_filepath);
  endfor
endfor

Ça fait 30 variantes pour regarder tranquillement ce qui vous plaît. Vous pouvez aussi jouer avec le coefficient 0.3 dans floyd_steinberg.m pour changer la quantité d’erreur diffusée.

Le dépôt contient les images et les deux fonctions si vous voulez essayer avec vos propres photos 🤗.

Rendre un code scientifique reproductible : Git, tests et CI/CD

Sat, 23 May 2026 00:00:00 GMT

Le 23 mai 2026, j’ai eu le plaisir d’animer une session pour les jeunes chercheurs (doctorants, postdocs) lors du colloque CSMA Junior 2026 à Giens (Var). L’objectif de cette rencontre était de parler ouvertement d’un sujet parfois tabou mais pourtant si universel : l’organisation – ou plutôt le chaos – logiciel dans la recherche en calcul scientifique et mécanique numérique.

L’exposé original s’intitulait « De simulation_finale_v2_matin.zip à une industrialisation de ta recherche ». Ce titre, c’est un clin d’œil à nos pires travers en thèse ou en postdoc. On a tous un jour perdu une journée entière (voir beaucoup plus) à se demander : « Comment j’ai généré cette courbe dans mon papier de l’an dernier ? ».

Pourtant, sortir de ce chaos ne demande pas de se transformer en ingénieur système ou en gourou du DevOps du jour au lendemain. C’est une démarche progressive, pragmatique, qui tient en une échelle de maturité de six niveaux.

L’industrialisation logicielle d’un workflow scientifique n’est pas une corvée d’ingénieur ennuyeuse. C’est une part intrinsèque du métier de chercheur dès lors qu’un prototype produit des résultats que l’on veut conserver, partager, refaire ou publier.

Car en réalité : Ce n’est pas le ZIP. C’est ce qu’il cache.

Les conséquences du “Research Chaos”

Lorsqu’on développe dans l’urgence d’une publication ou d’un rendu de projet, la désorganisation s’installe vite. Ce désordre a deux types de conséquences symétriques :

Scientifiques : Perte de temps à refaire ce qui tournait déjà, perte de connaissance au départ d’un membre de l’équipe, manque de capitalisation et figures impossibles à régénérer.
Humaines : Frustration, colère devant le terminal qui renvoie des erreurs cryptiques, déprime de voir son travail s’évaporer.

Ranger son code et son workflow, ce n’est pas uniquement pour la rigueur scientifique de l’éditeur ou des relecteurs, c’est avant tout pour soi et pour son propre confort de recherche. Chaque pipeline propre construit aujourd’hui devient un actif précieux pour demain.

Les 6 niveaux de maturité logicielle en recherche

Pour progresser sans se décourager, voici une grille de lecture réaliste. Identifiez où vous vous situez actuellement, et visez simplement le niveau supérieur.

Niveau 1 : Ne pas perdre l’historique (Git et commits propres)

Le premier symptôme du chaos, c’est le dossier encombré de fichiers du type run_v1.py, run_v2_modifs.py, run_final.py, simulation_finale_v2_matin.zip. Le problème de cette méthode, c’est qu’elle n’offre aucun historique fiable ni repère temporel.

Adopter Git est la première étape indispensable. Non pas comme un outil complexe de gestion de versions, mais comme un véritable assistant à la réflexion scientifique.

Considérez chaque commit comme une note dans votre journal de bord de recherche. Un bon commit documente un changement d’hypothèse physique, une correction de formule ou un nouveau paramètre. Par exemple :

feat: Ajout de la loi de comportement hyperélastique pour la poutre
fix: Correction du facteur de conversion d'unités (Pa vers MPa)
test: Ajout du cas de comparaison analytique

Ces messages précis traduisent l’évolution de votre démarche scientifique et vous libèrent de la charge mentale d’avoir à vous souvenir de chaque ligne modifiée.

Niveau 2 : Pouvoir relancer (README et commandes claires)

Le signal d’alarme de ce niveau est simple : devoir expliquer de vive voix à un collègue (ou à soi-même six mois plus tard) les huit commandes manuelles à exécuter dans le bon ordre pour lancer le script de post-traitement.

Le remède ? Rendre explicite ce qui est dans votre tête.

Un fichier README.md minimal mais rigoureux à la racine de votre projet doit faire office de carte au trésor. Il doit décrire sans ambiguïté :

Comment installer rapidement le projet.
La commande exacte pour lancer un calcul de test.
La méthode pas à pas pour régénérer la figure principale de votre article.

Niveau 3 : Reproduire l’environnement (Gestion des dépendances)

La douleur associée ici est le fameux : « Ça marche uniquement sur ma machine ». En calcul scientifique, on dépend d’un écosystème fragile : versions de Python, de bibliothèques (NumPy, SciPy), de compilateurs (gfortran, GCC), de solveurs externes (comme code_aster) ou de modules installés sur un cluster HPC.

Il n’y a pas d’outil magique unique, mais plutôt une collection de solutions adaptées à chaque contexte :

En pur Python : Privilégiez des outils ultra-rapides et modernes comme uv (par Astral), combiné à un fichier standardisé pyproject.toml pour verrouiller vos versions de bibliothèques.
En Fortran/C++ scientifique : Tournez-vous vers Conda, Pixi ou Spack qui gèrent très bien les dépendances de bas niveau et les variantes de compilation.
Sur cluster ou pour diffusion : Les conteneurs comme Docker (pour votre machine) ou Apptainer / Singularity (très populaires en HPC pour s’affranchir des privilèges root) permettent d’embarquer tout votre système avec vous.

Niveau 4 : Vérifier (Les tests comme filet de sécurité)

C’est la peur de modifier le code de peur de « casser » un résultat obtenu il y a trois mois. Pour s’affranchir de cette angoisse, il faut poser des filets de sécurité automatique : les tests.

« On ne teste pas du code pour le plaisir de coder. On teste pour acheter de la confiance dans les résultats scientifiques. »

En calcul numérique, ces tests peuvent prendre des formes très élégantes et concrètes :

La solution analytique : Comparer votre sortie numérique à une solution exacte connue (par exemple sur un cas simple de poutre en traction élastique).
La non-régression : Sauvegarder les résultats d’une simulation stable dans un fichier de référence (reference.ref.csv). Votre test exécute le code, génère un nouveau CSV et compare les valeurs avec une tolérance numérique rigoureuse via np.testing.assert_allclose.
Les invariants physiques : Vérifier des ordres de grandeur ou des principes de conservation (conservation de la masse, énergie positive, etc.).

⚠️ Vérification ≠ Validation

C’est une distinction conceptuelle fondamentale en calcul scientifique :

La Vérification répond à la question : « Résout-on correctement les équations mathématiques ? ». C’est une affaire de bugs, d’implémentation et de convergence numérique. C’est l’objectif de vos tests unitaires et de non-régression.
La Validation répond à la question : « Le modèle mathématique choisi représente-t-il fidèlement la physique ? ». C’est une confrontation aux données expérimentales et aux domaines de validité.

Pour avancer sereinement, l’automatisation de la vérification est un prérequis non négociable. Des frameworks comme pytest se chargent de découvrir et d’exécuter ces vérifications de manière totalement transparente.

Niveau 5 : Orchestrer (L’automatisation avec des workflows)

À ce stade, vous commencez à réaliser des études paramétriques ou des étapes successives de pré-traitement, calcul et post-traitement. Lancer chaque étape à la main devient fastidieux et source d’erreurs d’inattention.

La solution consiste à utiliser un outil d’orchestration de tâches qui va matérialiser votre pipeline sous forme de DAG (Graphe Orienté Acyclique). Un outil comme Snakemake (très implanté en science) ou de simples fichiers GNU Make vous permettent de décrire les relations de cause à effet : « Pour produire cette figure, j’ai besoin de ce CSV d’agrégation, qui lui-même nécessite d’avoir lancé 10 simulations RVE avec différentes tailles de mailles ».

Grâce à un système intelligent de vérification des dates de modification des fichiers (timestamps), l’orchestrateur ne recalcule que ce qui a changé. Si vous modifiez uniquement le script de tracé, Snakemake ne relancera pas les 10 heures de calcul sous-jacentes, il régénérera instantanément la figure finale.

Niveau 6 : S’assurer que ça dure (L’intégration continue CI/CD)

Le niveau ultime consiste à déléguer complètement la surveillance à un serveur tiers. Grâce aux plateformes comme GitHub Actions ou GitLab CI, chaque fois que vous poussez votre code (git push), une machine virtuelle neutre s’initialise à la volée.

Elle installe votre environnement propre (uv sync), exécute l’intégralité de vos tests (pytest), et valide que vos pipelines de calcul (Snakemake) tournent sans erreur. Si vous avez introduit une régression par inadvertance, vous recevez immédiatement une alerte par mail.

Conclusion : Une marche après l’autre

L’industrialisation de votre recherche n’est pas un objectif où tout doit être parfait immédiatement. C’est un voyage progressif.

Si vous appliquez aujourd’hui de manière systématique Git (Niveau 1) et un README clair (Niveau 2), vous aurez déjà accompli 80% du chemin pour vous épargner des maux de tête et garantir la pérennité de vos travaux. Les outils modernes comme uv ou Snakemake sont là pour vous aider à automatiser le reste, libérant ainsi votre esprit pour ce qui compte vraiment : les idées.

Observable : un notebook interactif pour visualiser un sondage LinkedIn

Thu, 24 Jul 2025 00:00:00 GMT

Python 3.14 sans GIL : benchmarks du multithreading

Wed, 11 Jun 2025 00:00:00 GMT

Périmètre des mesures : ces benchmarks ont été réalisés avec Python 3.14b2 en juin 2025. Les résultats décrivent cette version bêta et les cas testés ; ils ne constituent pas une mesure des versions stables ultérieures. Le Dockerfile et les scripts sont accessibles dans le dépôt associé.

🧠 Un peu de contexte : le GIL, pourquoi et pour quoi faire ?

Le GIL (Global Interpreter Lock) est un mécanisme présent dans l’implémentation CPython depuis toujours. Il garantit qu’un seul et unique thread peut exécuter du bytecode Python à la fois. Ce mécanisme permet historiquement de grandement simplifier la gestion de la mémoire interne de l’interpréteur.

Néanmoins, ce verrou global a un effet de bord majeur : les programmes multi-threads ne scalent pas sur plusieurs cœurs pour des workloads CPU-bound.

➡️ En pratique, threading.Thread est donc surtout utilisé pour des I/O.

Depuis des années, la suppression du GIL était un sujet récurrent dans la communauté Python. Depuis Python 3.13, ça se concrétise !

🧪 Python 3.13 introduit un mode expérimental : `--disable-gil`

C’est l’objet de la PEP 703 – Making the Global Interpreter Lock Optional proposée par Sam Gross, qui a fait beaucoup parler d’elle. Depuis Python 3.13, il est possible de permettre la désactivation du GIL — pour cela, il faut que l’interpréteur Python soit compilé avec l’option --disable-gil.

Avec ce mode activé à la compilation, le GIL est pilotable via la variable d’environnement PYTHON_GIL=0|1.

Par exemple, pour lancer un script en mode nogil, il suffit de faire :

PYTHON_GIL=0 python3 my_script.py

Quelques benchmarks existent en ligne, par exemple celui-ci. Mais j’ai voulu approfondir un peu le sujet et évaluer l’apport potentiel de cette révolution !

🔧 Setup pour les tests

Pour faire mes tests, j’ai mis en place une image Docker qui compile Python 3.14b2 avec l’option --disable-gil. Le Dockerfile et l’ensemble des cas de test sont disponibles

benchmark_python3.14_nogil

Python0

Pour construire le Docker :

$ docker build . -f Dockerfile-nogil -t python:nogil_3.14b2

⚙️ Benchmark #1 : Factorielle lourde en multi-thread

Pour le premier test, on fait tout bêtement un gros calcul de factorielle dans plusieurs threads.

import threading
import math
import time

def test_function(num_thread):
    thread_start_time = time.time()
    math.factorial(250000)
    thread_execution_time = time.time() - thread_start_time

start_time = time.time()

threads = []
for num_thread in range(5):
    thread = threading.Thread(target=test_function, args=(num_thread,))
    thread.start()
    threads.append(thread)

for thread in threads:
    thread.join()

execution_time = time.time() - start_time
print(f"     Elapsed time: {execution_time:.2f} seconds")

🧾 Résultats

Mode	Temps total
GIL ON	1.97 s
GIL OFF	0.56 s

✅ Gain ×3~4 : ici, --disable-gil permet une vraie parallélisation du calcul lourd avec un très bon scaling.

⚙️ Benchmark #2 : Calculs mathématiques modérés

Même idée que précédemment, mais avec une charge mathématique un peu plus variée.

import threading
import math
import time
import random

def stress_function(thread_id, complexity):
    result = 0
    for i in range(1, complexity):
        a = math.sqrt(i) + math.sin(i) ** 2
        b = math.log1p(i) * math.exp(-a)
        c = math.factorial(i % 500 + 500) % 10**8  # borné pour ne pas exploser la RAM
        result += a * b + c

def run_threads(num_threads=4, complexity=10_000):
    print(f"Launching {num_threads} threads with complexity {complexity}")
    threads = []

    start_time = time.time()
    for i in range(num_threads):
        t = threading.Thread(target=stress_function, args=(i, complexity))
        t.start()
        threads.append(t)

    for t in threads:
        t.join()
    total_time = time.time() - start_time
    print(f"   Elapsed time {total_time:.2f} seconds")

if __name__ == "__main__":
    run_threads(num_threads=5, complexity=20_000)

🧾 Résultats

Mode	Temps total
GIL ON	1.36 s
GIL OFF	0.41 s

✅ Gain ×3~4 à nouveau, scaling constant.

⚙️ Benchmark #3 : Accès concurrent partagé

On ajoute ici des écritures dans une variable partagée (une liste Python). Chaque thread écrit dans une case distincte.

def stress_function(thread_id, complexity, shared_data, lock):
    local_result = 0.0
    for i in range(1, complexity):
        a = math.sqrt(i) + math.sin(i) ** 2
        b = math.log1p(i) * math.exp(-a)
        c = math.factorial(i % 500 + 500) % 10**8
        local_result += a * b + c
    shared_data[thread_id] = local_result

def run_threads(num_threads=4, complexity=10_000):
    threads = []
    shared_data = [0.0] * num_threads
    lock = threading.Lock()

    start_time = time.time()
    for i in range(num_threads):
        t = threading.Thread(target=stress_function, args=(i, complexity, shared_data, lock))
        t.start()
        threads.append(t)

    for t in threads:
        t.join()

    total_time = time.time() - start_time
    total_sum = sum(shared_data)
    print(f"     Elapsed time: {total_time:.2f} seconds")
    print(f"        -> Global result: {total_sum % 1000:.2f}")

🧾 Résultats

Mode	Temps total
GIL ON	1.32 s
GIL OFF	0.43 s

🔒 Grâce à un découpage propre 😎 (pas de collision entre threads), nogil reste très efficace ici.

⚠️ Benchmark #4 : Recherche du plus proche voisin sur 10M points

Test plus réaliste : 10M de points 3D aléatoires, recherche du plus proche voisin en multithreading avec dictionnaire partagé.

import threading
import random
import time
from math import sqrt

def distance2(a, b):
    return (a[0]-b[0])**2 + (a[1]-b[1])**2 + (a[2]-b[2])**2


def find_closest_worker(points, query_point, start, end, shared_result, lock, tid):
    local_min_dist = float("inf")
    local_min_idx = -1

    for i in range(start, end):
        d = distance2(points[i], query_point)
        if d < local_min_dist:
            local_min_dist = d
            local_min_idx = i

    with lock:
        if local_min_dist < shared_result['min_dist']:
            shared_result['min_dist'] = local_min_dist
            shared_result['closest_idx'] = local_min_idx
            shared_result['owner'] = tid


def threaded_closest_point(points, query_point, num_threads=4):
    n = len(points)
    chunk_size = n // num_threads

    shared_result = {
        'min_dist': float("inf"),
        'closest_idx': -1,
        'owner': -1
    }
    lock = threading.Lock()
    threads = []

    for tid in range(num_threads):
        start = tid * chunk_size
        end = (tid + 1) * chunk_size if tid < num_threads - 1 else n
        t = threading.Thread(target=find_closest_worker,
                             args=(points, query_point, start, end, shared_result, lock, tid))
        t.start()
        threads.append(t)

    for t in threads:
        t.join()

    return shared_result['closest_idx'], sqrt(shared_result['min_dist']), shared_result['owner']

if __name__ == "__main__":
    N = 10_000_000
    num_threads = 4
    points = [[random.random(), random.random(), random.random()] for _ in range(N)]
    query_point = [random.random(), random.random(), random.random()]

    print(f"Launching threaded NN search with {num_threads} threads")
    t0 = time.time()
    idx, dist, owner = threaded_closest_point(points, query_point, num_threads)
    t1 = time.time()

    print(f"    Elapsed time: {t1 - t0:.2f} seconds")

🧾 Résultats

Mode	Temps total
GIL ON	2.38 s
GIL OFF	3.61 s ❗

❌ Et là, grosse surprise : activer nogil rend les choses plus lentes. Je n’ai pas vraiment d’explication certaine. Mais si je devais avancer une théorie je dirais que l’accès concurrent à la grosse liste Python entraine quelques limitations.

🔁 Bonus : version C++ équivalente + `nanobind`

J’ai aussi testé ce cas en C++ multithreadé natif, exposé à Python via nanobind. c’est surtout pour voir si en suivant exactement la même logique mais en changeant juste la stack technique on obtient des résultats différents. Et donc oui :

Implémentation	Temps total
Python GIL ON	2.38 s
Python GIL OFF	3.61 s ❗
C++ (threads)	0.88 s ✅

En version threads c++ on a bien un gros gain de performance. Donc la logique est bonne, pas trop mauvaise en tout cas, la limitation vient de Python 😿.

🔚 Conclusion

Python progresse — c’est indéniable et enthousiasmant. Mais pour des cas fortement concurrentiels, les implémentations natives (C/C++) gardent un net avantage.

✅ Python 3.14 --disable-gil offre des gains réels pour des tâches CPU-bound multithreadées
⚠️ Mais les performances ne sont pas systématiquement meilleures, notamment dès qu’il y a de gros volumes de données ou de la contention mémoire

📚 Pour aller plus loin

asyncssh : automatiser SSH et tunnels en Python

Sat, 10 May 2025 00:00:00 GMT

Introduction

Dans cet article je vais essayer d’illustrer simplement comment utiliser le module asyncssh de Python pour :

Scripter des actions distantes
Etablir un tunnel ssh permettant de faire du port forwarding

Alors si vous vous êtes déjà confronté à ces problématiques vous avez peut-être déjà croisé la route du module Python paramiko. Alors personellement je ne recommande pas l’usage de paramiko (en gros j’ai perdu un temps monstrueux avec paramiko, c’est peut-être ma faute attention, notamment lorsque je devais faire des portages d’application entre windows 7 / windows 10 et Linux) et du coup depuis ce jour je suis passé à asyncssh et ça fonctionne parfaitement.

La seule difficulté avec asyncssh vient du async … En effet c’est un module destiné à être utilisé dans un mode de programmation asynchrone avec asyncio il faut donc être un peu à l’aise avec les async/await dans Python 🤨 ! Si ce n’est pas le cas je vous invite à aller jeter un oeil sur le mooc Python 3 en semaine 8 vous avez une magnifique introduction à la programmation asynchrone.

Connection à un serveur

La première étape est bien évidemment la connection au serveur ssh. Pour cela on passe par la fonction connect de asyncssh qui prend entre autre arguments :

Un nom d’utilisateur username
Une authentification avec deux solutions possibles :
- mot de passe classique dans ce cas il suffit de spécifier l’argument password
- Clé ssh et dans ce cas il faut spécifier l’argument client_keys qui est une liste contenant la où les clés ssh ainsi que l’argument passphrase qui est donc la passphrase de la clé ssh.

client = await asyncssh.connect( server, username=username, password=password)

Une fois connecté, exécuter des commandes !

Une fois la connection avec notre serveur établie nous pouvons commencer à faire des choses intéressantes (enfin ça dépend de vous ça). Mais pour commencer la méthode essentielle à connaître est la méthode run qui comme son nom l’indique va nous permettre d’exécuter des commandes à distance. Dans sa version basique la méthode run prend une chaîne de caractère par exemple si je veux lancer la commande ls ~/Documents et bien c’est ce qu’on fait !

out = await client.run("ls ~/Documents")

Alors le out que l’on récupère est une instance de asyncssh.SSHCompletedProcess on s’en fout un peu tout ce qu’il faut savoir c’est qu’il y a dans ce truc 3 attributs qui sont utiles :

out.returncode si différent de 0 y a un truc qui a planté quelque part !
out.stdout la sortie standard
out.stderr la sortie d’erreur

Alors juste vous le savez peut-être mais suivant la commande que vous exécutez ne regardez pas que dans le stderr si vous avez des erreurs car il existe tout un tas de logiciels qui écrivent les erreurs dans le stdout et certain ont même le génie d’ecrire des infos dans le stderr …

Ou bien lire et écrire des fichiers

De la même manière il est possible une fois la connection établie de lire et/ou écrire des fichiers via sftp si vous voulez tout savoir. Pour cela il suffit de créer un client sftp à partir du client ssh une fois la connexion établie.

async with client.start_sftp_client() as sftp:
    ## Read, write file, create directory, ...
    ## all on remote file system
    pass

Une fois le client sftp créé nous pouvons utiliser tout une ribambelle (oui j’aime bien ce mot) de méthodes par exemple :

sftp.exists( remote_path )
sftp.mkdir( remote_path )
sftp.open( fname, mode)
sftp.chmod( remote_path, mode )
…

Pour la liste complète des méthodes RTFM

Et avec un petit rebond c’est tout aussi simple !

Alors le truc génial 🤩 de la fonction asyncssh.connect est qu’elle accepte un argument optionnel tunnel. Cet argument permet de spécifier un client ssh déjà connecté. En gros si pour accéder à la machine machine-C depuis machine-A on doit forcément passer par la machine machine-B et bien avec cet argument tunnel ce sera super simple il suffira de faire un truc du genre :

proxy = await asyncssh.connect( "machine-B", username=username, password=password)
client = await asyncssh.connect( "machine-C", username=username, password=password, tunnel=proxy)

Il existe également une version avec context manager qui prends la forme suivante :

async with asyncssh.connect( "machine-B", username=username, password=password) as proxy:
    async with asyncssh.connect( "machine-C", username=username, password=password, tunnel=proxy) as client:
        # do something crazy with my ssh client

Port forwarding et tunnel ssh

Pour finir je vais vous montrer l’autre truc super sympa de asyncssh à savoir que l’on peut depuis un boût de Python construire un tunnel ssh qui va nous permettre de faire du port forwarding. Deux trucs sympa :

Le même code va fonctionner sous Linux, Mac et Windows donc pas de prise de tête
On peut comme ça automatiser et surtout cacher plein d’opérations aux end-users. Car je sais pas vous mais moi si je demande aux gens de faire un tunnel ssh à la main avec OpenSSH ma boite mail va exploser avec les “ça marche pas” !!

async with asyncssh.connect(hostname, username=username) as client:
    listener = await client.forward_local_port("", local_port, remote_ip, remote_port)
    await listener.wait_closed()

Le Python précédent est équivalent à la commande OpenSSH suivante pour les connaisseurs :

ssh -L local_port:remote_ip:remote_port username@hostname

Bon alors par contre le code Python précédent est bloquant, c’est-à-dire qu’une fois le tunnel créé on ne peut rien faire d’autre ce qui peut s’avérer génant. Une solution assez simple pour ne pas se retrouver bloqué est simplement de déléguer la création du tunnel à un process séparé de notre process principal. Pour cela un petit coup de multiprocessing et ça roule !

import asyncio
import multiprocessing
import asyncssh

def standalone_tunnel(hostname, username, password, local_port, remote_port, remote_ip ):
    async def do_job(hostname, username, password, local_port, remote_port, remote_ip ):
        async with asyncssh.connect(hostname, username=username, password=password) as client:
            listener = await client.forward_local_port("", local_port, remote_ip, remote_port)
            await listener.wait_closed()
    try:
        asyncio.run(do_job(hostname, username, password, local_port, remote_port, remote_ip))
    except Exception as e:
        print("Port Forwarding Error : " + str(e))


# Sous Windows et macOS, protéger le démarrage du processus enfant.
if __name__ == "__main__":
    p = multiprocessing.Process(target=standalone_tunnel, args=(hostname, username, password, local_port, remote_port, remote_ip))
    p.start()

Conclusion

Je viens de vous montrer en mode express comment le module asyncssh de Python peut très facilement nous permettre de scripter des actions nécessitant des connections à des serveurs distants via ssh. Il y a évidemment plein d’applications possibles à cela mais je vais juste vous en présenter deux que j’ai eu à réaliser.

La première application a été la mise en place d’un outil pour faire de la visualisation distante. En effet à partir de Mars 2020 et une certaine pandémie mondiale il a fallu dans le labo où je suis que les utilisateurs puissent travailler à distance, notamment avec des softs disposant d’interface graphique un peu lourde. Pour cela j’ai développé une solution assez simple où chaque utilisateur lance sur un serveur du labo un serveur VNC et ensuite via un tunnel ssh (qui forward le port VNC de l’utilisateur vers un port local de son portable en faisant un rebond via la passerelle ssh) peut accéder à sa session graphique via le client VNC installé localement. Et bien évidemment si je demande aux utilisateurs de faire tout ça à la main 🤯 donc j’ai packagé tout ça dans une petite application Python à base de asyncssh et PyQt pour le graphique et en deux clics les utilisateurs peuvent se connecter !

La seconde application que j’ai pu avoir de asyncssh est le développement d’un utilitaire Python pour lancer un jupyter notebook sur un noeuds de calcul du cluster et faire le port forwarding qui va bien pour que l’utilisateur puisse ensuite ouvrir son notebook et travailler dans son navigateur en local. Pour cela le process est assez simple :

Connexion à la frontal du cluster (besoin de deux rebonds dans mon cas mais facile avec asyncssh 😜)
Ecriture sur le filesystem du cluster d’un script de soumission pour le gestionnaire de job (slurm)
Soumission du job slurm
Une fois le job slurm commencé, ouverture des fichiers de log du job pour récupérer le nom sur lequel le job est parti et le port sur lequel jupyter a démarré
Connexion ssh au noeud du cluster où mon job tourne
Création du tunnel ssh pour le port forwarding
C’est bon il n’y a plus qu’à ouvrir son navigateur 📓

Pour aller plus loin :

Tutoriel : Flask et Notion comme base de données

Fri, 23 Feb 2024 00:00:00 GMT

Introduction

Dans cet article, nous allons parcourir le processus de création d’une application web avec Flask, qui permet aux utilisateurs de saisir des informations via un formulaire et stocke ces données dans une base de données Notion. Nous couvrirons ensuite comment déployer gratuitement cette application sur Vercel !!

L’intégralité du code est disponible sur GitHub.

flask-notion-demo

Example of Python Flask App with Notion database storage

Python0

Prérequis

Pour suivre ce tutoriel, vous avez besoin des éléments suivants :

Connaissance de base en Python
Notions de base du développement web (HTML)
Compte Notion avec accès à l’API (si ça vous parle pas, pas de panique on va voir ça ensemble 🤗)

Étape 1️⃣ : Configuration de l’Environnement

Installez Flask, Flask-WTF, et Requests dans votre environnement Python :

install requirements

pip install Flask Flask-WTF requests

Étape 2️⃣ : Création de l’Application Flask

Structure de l’Application

app.py : Le fichier principal de l’application Flask.
templates/ : Un dossier contenant les templates HTML pour le formulaire et l’affichage des données.

Définition du Formulaire

On commence par définir la structure de notre formulaire en créant une classe qui hérite de FlaskForm. Chaque champ du formulaire est représenté par un objet (par exemple, StringField pour du texte, SelectField pour une liste déroulante) avec des validateurs pour imposer certaines règles (comme DataRequired pour les champs obligatoires, Email pour valider les adresses email).

from flask_wtf import FlaskForm
from wtforms import StringField, SelectField, SubmitField
from wtforms.validators import DataRequired, Email

class UserForm(FlaskForm):
    nom = StringField('Nom', validators=[DataRequired()])
    prenom = StringField('Prénom', validators=[DataRequired()])
    mail = StringField('Email', validators=[DataRequired(), Email()])
    humeur = SelectField('Humeur', choices=[("happy", "Happy"), ("sad", "Sad")], validators=[DataRequired()])
    submit = SubmitField('Envoyer')

Dans cet exemple, StringField et SelectField sont utilisés pour créer des champs de texte et une liste déroulante, respectivement. La liste des choix pour humeur est définie par un ensemble de tuples, où chaque tuple contient le code interne et l’affichage de l’option.

Intégration du formulaire dans une vue Flask

Après avoir défini la classe de formulaire, intégrez-la dans une vue Flask. Lorsque la route est sollicitée via GET, le formulaire est affiché à l’utilisateur. Si la méthode est POST et que le formulaire est validé, vous pouvez traiter les données.

@app.route('/', methods=['GET', 'POST'])
def home():
    form = UserForm()
    if form.validate_on_submit():
        # Traitement des données du formulaire
        nom = form.nom.data
        prenom = form.prenom.data
        mail = form.mail.data
        humeur = form.humeur.data
        # C'est ici qu'on va envoyer  les données à Notion
        # on voit ça un peu plus tard 🔥
        return redirect(url_for('home'))  # Redirection après le traitement
    return render_template('formulaire.html', form=form)

Rendu du formulaire dans un template HTML

Dans votre template HTML, utilisez les objets de formulaire passés depuis la vue pour générer le HTML du formulaire. Flask-WTF et WTForms facilitent cette tâche en offrant des méthodes pour rendre chaque champ ainsi que leurs labels et erreurs potentielles.

<form method="POST" action="">
  {{ form.hidden_tag() }}
  <p>{{ form.nom.label }} {{ form.nom() }}</p>
  <p>{{ form.prenom.label }} {{ form.prenom() }}</p>
  <p>{{ form.mail.label }} {{ form.mail() }}</p>
  <p>{{ form.humeur.label }} {{ form.humeur() }}</p>
  <p>{{ form.submit() }}</p>
</form>

{{ form.hidden_tag() }} est utilisé pour inclure un token CSRF, qui protège contre les attaques de type Cross-Site Request Forgery. Chaque champ est rendu avec son label ({{ form.nom.label }}) et le champ lui-même ({{ form.nom() }}).

On ajoute une route pour afficher les données

On ajoute simplement une route qui permet d’afficher les données stockées dans la base de données Notion.

@app.route('/database')
def voir_database():
    donnees = None
    # On récupère les données de la base de données Notion
    # On voit ça un peu plus tard 🔥
    return render_template('database.html', donnees=donnees)

Le template HTML associé est le suivant :

<!DOCTYPE html>
<html lang="fr">
  <head>
    <meta charset="UTF-8" />
    <title>Visualisation de la Base de Données</title>
  </head>
  <body>
    <h1>Données de la Base</h1>
    <table border="1">
      <thead>
        <tr>
          <th>Nom</th>
          <th>Prénom</th>
          <th>Email</th>
          <th>Humeur</th>
        </tr>
      </thead>
      <tbody>
        {% for item in donnees %}
        <tr>
          <td>{{ item['Nom'] }}</td>
          <td>{{ item['Prénom'] }}</td>
          <td>{{ item['Email'] }}</td>
          <td>{{ item['Humeur'] }}</td>
        </tr>
        {% endfor %}
      </tbody>
    </table>
  </body>
</html>

Étape 3️⃣ : Utilisation de Notion comme Base de Données

Configuration de l’API Notion

Pour interagir avec l’API Notion et automatiser des tâches telles que la création de pages ou la récupération de données depuis une base de données Notion, vous aurez besoin d’un token d’intégration. Ce token agit comme une clé d’API, vous permettant d’authentifier vos requêtes à l’API Notion. Voici comment vous pouvez générer ce token.

Création d’une Intégration

Accédez à votre compte Notion : Connectez-vous à votre compte Notion où vous souhaitez utiliser l’API.
Ouvrez les paramètres d’intégration : Dans le coin inférieur gauche de l’interface Notion, cliquez sur votre avatar ou initiales, puis sélectionnez “Paramètres & Membres”. Dans le menu latéral, choisissez l’onglet “Intégrations”.
Créez une nouvelle intégration : Cliquez sur le bouton “Nouvelle intégration”. Remplissez le formulaire avec les détails de votre intégration :
- Nom de l’intégration : Donnez un nom à votre intégration. Choisissez quelque chose de descriptif pour vous rappeler à quoi sert cette intégration.
- Capacités d’intégration : Laissez les options par défaut ou ajustez-les selon vos besoins.
- Associez à un espace de travail : Sélectionnez l’espace de travail Notion où vous souhaitez utiliser cette intégration.
Soumettez le formulaire : Après avoir rempli les détails, cliquez sur “Soumettre” pour créer l’intégration.

Récupérer le token d’intégration

Une fois l’intégration créée, Notion affichera un token d’intégration (aussi appelé “Secret interne”). Copiez ce token et gardez-le en sécurité ; vous en aurez besoin pour authentifier vos requêtes à l’API Notion. Ce token est sensible et doit être traité comme un mot de passe.

Partager une base de données avec l’intégration

Pour que votre intégration puisse accéder à une base de données Notion spécifique, vous devez partager cette base de données avec l’intégration.

Ouvrez la base de données dans Notion que vous souhaitez connecter à votre intégration.
Cliquez sur “Partager” dans le coin supérieur droit de la page de la base de données.
Ajoutez votre intégration : Dans le menu de partage, tapez le nom de l’intégration que vous avez créée et sélectionnez-la dans la liste. Cela donnera à l’intégration l’accès à la base de données.
Ajustez les permissions si nécessaire : Assurez-vous que l’intégration a les permissions adéquates pour réaliser les actions que vous prévoyez (lire, écrire, etc.).

Stocker le token d’intégration et l’ID de la base de données

Pour utiliser le token d’intégration et l’ID de la base de données dans votre application Flask, vous pouvez les stocker dans des variables d’environnement. Cela vous permet de garder ces informations sensibles en sécurité et de les utiliser dans votre application sans les exposer directement dans votre code.

import os

NOTION_API_KEY = os.environ.get("NOTION_API_KEY")
DATABASE_ID = os.environ.get("DATABASE_ID")

Vous pouvez également utiliser un fichier .env pour stocker ces variables d’environnement. Pour cela, vous pouvez utiliser la bibliothèque python-dotenv pour charger ces variables dans votre application Flask.

from dotenv import load_dotenv

load_dotenv()

⚠️ Pensez à ajouter le fichier .env à votre fichier .gitignore pour éviter de le partager publiquement.

Utilisation de l’API Notion

Pour interagir avec l’API Notion, on va utiliser la bibliothèque requests pour envoyer des requêtes HTTP à l’API Notion. Pour un usage avancé vous êtes invité à lire la documentation officielle de l’API Notion.

Pour l’exemple que l’on traite ici nous avons besoin de deux fonctions.

La première pour créer une nouvelle page dans une base de données Notion correspondant aux données saisies par l’utilisateur.
La seconde pour récupérer les données de la base de données Notion et les afficher dans la page database.html.

La première fonction peut donc ressembler à ceci (pour bien comprendre la structure il faut vraiment aller voir la documentation de l’API Notion) :

def push_to_notion(nom, prenom, mail, humeur):
    url = "https://api.notion.com/v1/pages"
    token = os.environ.get("NOTION_API_KEY")
    database_id = os.environ.get("DATABASE_ID")

    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
        "Notion-Version": "2022-06-28"
    }

    data = {
        "parent": {"database_id": database_id},
        "properties": {
            "Nom": {
                "title": [
                    {"text": {"content": nom}}
                ]
            },
            "Prénom": {
                "rich_text": [
                    {"text": {"content": prenom}}
                ]
            },
            "Email": {
                "email": mail
            },
            "Humeur": {
                "select": {"name": humeur}
            }
        }
    }

    response = requests.post(url, json=data, headers=headers)
    if response.status_code == 200:
        print("Data sent to Notion")
    else:
        print(f"Fail to sent data : {response.text}")

Pour visualiser les entrées existantes, c’est un peu plus simple. Il suffit d’envoyer une requête POST à l’endpoint /v1/databases/{database_id}/query de l’API Notion, en remplaçant {database_id} par l’ID de votre base de données. Cette requête ne nécessite pas de corps de requête pour récupérer toutes les entrées, mais peut être personnalisée pour filtrer les résultats si besoin.

def pull_from_notion():
    url = f"https://api.notion.com/v1/databases/{os.environ.get('DATABASE_ID')}/query"
    headers = {
        "Authorization": f"Bearer {os.environ.get('NOTION_API_KEY')}",
        "Notion-Version": "2022-06-28"
    }

    response = requests.post(url, headers=headers)
    if response.status_code == 200:
        entries = response.json()["results"]
        # Traitement des données, extraction et transformation selon les besoins
        return entries
    else:
        print(f"Erreur lors de la récupération des données : {response.text}")
        return []

Étape 4️⃣ : Déploiement de l’Application sur Vercel

Pour finir on va voir comment déployer gratuitement notre application en ligne. On va passer par le service de déploiement Vercel. Il en existe d’autre que vous pouvez utiliser comme Heroku par exemple. Tout d’abord il faut créer un compte sur Vercel.

Configuration de l’Environnement

Pour déployer votre application Flask sur Vercel, vous devez ajouter un fichier vercel.json à la racine de votre projet. Ce fichier contient des informations sur votre application, telles que les paramètres de déploiement, les variables d’environnement, etc.

{
  "version": 2,
  "builds": [
    {
      "src": "app.py",
      "use": "@vercel/python"
    }
  ],
  "routes": [{ "src": "/.*", "dest": "app.py" }]
}

Il faut également spécifier les dépendances de l’application dans un fichier requirements.txt à la racine de votre projet. Dans notre cas il s’agit de Flask, Flask-WTF, et requests.

Flask==2.0.1
Flask-WTF==0.15.1
requests==2.26.0

🔑 Pour spécifier à votre application les NOTION_API_KEY et DATABASE_ID il faut que vous passiez par le site de Vercel pour configurer des variables spécifiques à votre déploiement. Cela ne peut-être fait qu’une fois le projet connu de Vercel, ce que l’on voit juste en dessous.

Déploiement de l’Application

Pour déployer votre application sur Vercel, vous pouvez utiliser l’interface en ligne ou l’interface en ligne de commande. Pour l’interface en ligne, il suffit de suivre les étapes suivantes :

Connectez-vous à votre compte Vercel.
Cliquez sur “Nouveau Projet” pour importer votre application.
Suivez les étapes pour importer votre application depuis un dépôt Git (GitHub, GitLab, Bitbucket, etc.).

Pour l’interface en ligne de commande, vous pouvez utiliser la commande vercel pour déployer votre application. Assurez-vous d’avoir installé le CLI Vercel sur votre machine.

vercel

Suivez les étapes pour déployer votre application. Vous pouvez également spécifier des variables d’environnement pour votre application lors du déploiement.

Conclusion

Et voilà, vous avez maintenant une application Flask qui stocke les données dans une base de données Notion et qui est déployée gratuitement sur Vercel ! Vous pouvez maintenant partager votre application avec le monde entier 🚀

Pour aller plus loin :

Basile Marchand | Articles et notes

Du pixel art avec Octave : des matrices, des couleurs et un peu de tramage

On commence par faire de gros pixels

Maintenant on réduit les couleurs

Un peu de tramage

Et on remet tout ça à la bonne taille

Pour jouer avec le code

Rendre un code scientifique reproductible : Git, tests et CI/CD

Les conséquences du “Research Chaos”

Les 6 niveaux de maturité logicielle en recherche

Niveau 1 : Ne pas perdre l’historique (Git et commits propres)

Niveau 2 : Pouvoir relancer (README et commandes claires)

Niveau 3 : Reproduire l’environnement (Gestion des dépendances)

Niveau 4 : Vérifier (Les tests comme filet de sécurité)

⚠️ Vérification ≠ Validation

Niveau 5 : Orchestrer (L’automatisation avec des workflows)

Niveau 6 : S’assurer que ça dure (L’intégration continue CI/CD)

Conclusion : Une marche après l’autre

Observable : un notebook interactif pour visualiser un sondage LinkedIn

Python 3.14 sans GIL : benchmarks du multithreading

🧠 Un peu de contexte : le GIL, pourquoi et pour quoi faire ?

🧪 Python 3.13 introduit un mode expérimental : --disable-gil

🔧 Setup pour les tests

⚙️ Benchmark #1 : Factorielle lourde en multi-thread

🧾 Résultats

⚙️ Benchmark #2 : Calculs mathématiques modérés

🧾 Résultats

⚙️ Benchmark #3 : Accès concurrent partagé

🧾 Résultats

⚠️ Benchmark #4 : Recherche du plus proche voisin sur 10M points

🧾 Résultats

🔁 Bonus : version C++ équivalente + nanobind

🔚 Conclusion

📚 Pour aller plus loin

asyncssh : automatiser SSH et tunnels en Python

Introduction

Connection à un serveur

Une fois connecté, exécuter des commandes !

Ou bien lire et écrire des fichiers

Et avec un petit rebond c’est tout aussi simple !

Port forwarding et tunnel ssh

Conclusion

Tutoriel : Flask et Notion comme base de données

Introduction

Prérequis

Étape 1️⃣ : Configuration de l’Environnement

Étape 2️⃣ : Création de l’Application Flask

Structure de l’Application

Définition du Formulaire

Intégration du formulaire dans une vue Flask

Rendu du formulaire dans un template HTML

On ajoute une route pour afficher les données

Étape 3️⃣ : Utilisation de Notion comme Base de Données

Configuration de l’API Notion

Création d’une Intégration

Récupérer le token d’intégration

Partager une base de données avec l’intégration

Stocker le token d’intégration et l’ID de la base de données

Utilisation de l’API Notion

Étape 4️⃣ : Déploiement de l’Application sur Vercel

Configuration de l’Environnement

Déploiement de l’Application

Conclusion

🧪 Python 3.13 introduit un mode expérimental : `--disable-gil`

🔁 Bonus : version C++ équivalente + `nanobind`