DEV Community: Dev du Sud

Publier sur Dev.to depuis un serveur, avec 130 lignes de Python et zéro dépendance

Dev du Sud — Mon, 02 Nov 2026 07:40:55 +0000

Écrire dans un éditeur web, coller son markdown, choisir ses tags, cliquer sur publier :
quand on écrit une fois par mois, c'est très bien. Quand on écrit deux fois par semaine, ça
devient une corvée — et les corvées finissent par ne plus être faites.

Mon besoin était simple : j'écris un fichier .md dans un dossier, un job planifié le publie
le lendemain matin à 8 h 40. Pas d'interface, pas de SDK, pas de dépendance à installer sur un
serveur qui doit rester debout pendant des années.

Voici le pipeline complet, avec les erreurs que j'ai réellement rencontrées.

Ce dont l'API a besoin

Trois choses, et la troisième est celle qu'on oublie.

La clé API, dans l'en-tête api-key. Elle se génère dans les paramètres du compte Dev.to.
L'URL : https://dev.to/api/articles pour créer, https://dev.to/api/articles/<id> pour modifier.
Un en-tête User-Agent. Sans lui, vous prenez un 403 et vous cherchez pendant vingt minutes pourquoi votre clé « ne marche pas ».

La clé doit vivre dans un fichier d'environnement, jamais dans le script :

DEVTO_API_KEY=xxxxxxxxxxxxxxxxxxxxxxxx

def load_env(path):
    """Lit un .env minimaliste : KEY=VALUE, commentaires en #."""
    env = {}
    with open(path) as f:
        for line in f:
            line = line.strip()
            if not line or line.startswith("#") or "=" not in line:
                continue
            k, v = line.split("=", 1)
            env[k.strip()] = v.strip().strip('"').strip("'")
    return env

Étape 1 — lire le front-matter sans PyYAML

Un article, c'est un fichier markdown avec un en-tête entre deux ---. Pas besoin d'un
analyseur YAML complet : trois champs suffisent.

lines = open(fname).read().split("\n")
fm = {}
i = 1
while i < len(lines) and lines[i].strip() != "---":
    if ":" in lines[i]:
        k, v = lines[i].split(":", 1)
        fm[k.strip()] = v.strip()
    i += 1
body = "\n".join(lines[i + 1:]).strip()

Le fichier ressemble à ça :

---
title: Un titre qui donne envie de cliquer
description: "La phrase que Dev.to affichera dans les résultats."
tags: python,automation,tutorial
cover_image: https://exemple.fr/couverture.jpg
canonical_url: https://mon-site.fr/mon-article
---

Le corps, en markdown normal.

Étape 2 — le piège du titre vide

C'est l'erreur que j'ai réellement commise, et elle est publique : un fichier sans champ
title a été publié sous le titre « Sans titre ». Un fichier de brouillons de posts pour les
réseaux sociaux s'était retrouvé dans le dossier de la file, et le script l'a pris pour un
article.

Depuis, la validation se fait avant tout appel réseau :

if "title" not in fm or not fm["title"].strip().strip('"'):
    print(f"SAUTÉ (pas de titre): {fname}")
    return           # on ne publie pas, on passe au suivant

Deux lignes. Elles valent leur pesant de réputation.

Étape 3 — les tags valides, sinon 422

Dev.to n'accepte que des tags de sa liste. Un tag inconnu renvoie
422 — tag not found, et l'article n'est pas créé. Le plus simple est de filtrer contre une
liste blanche :

VALID_TAGS = {
    "python", "javascript", "productivity", "automation", "programming",
    "tutorial", "beginners", "webdev", "linux", "tools", "ai", "career",
    "opensource", "devops", "performance", "testing", "security", "data",
    "startup", "discuss", "showdev", "watercooler", "architecture",
    "codequality", "comparison",
}

tags = [t for t in tags if t in VALID_TAGS][:4]
if not tags:
    tags = ["discuss"]

Quatre tags maximum, c'est la limite de l'API. Les filtrer en silence vaut mieux qu'un échec
de publication pour une virgule de trop.

Étape 4 — créer en brouillon, puis publier

Publier directement, c'est un seul appel : POST avec "published": true. Ça marche… quand
l'API va bien. Aux heures de pointe, j'ai vu passer des 503 sur cet appel, et un 503 sur un
POST non idempotent laisse un doute désagréable : l'article a-t-il été créé, ou pas ?

Le pattern qui tient : créer le brouillon, récupérer son id, puis publier.

def api(method, url, payload=None, key=""):
    data = json.dumps(payload).encode() if payload is not None else None
    req = urllib.request.Request(url, data=data, method=method, headers={
        "Content-Type": "application/json",
        "api-key": key,
        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) MonBot/1.0",
    })
    with urllib.request.urlopen(req, timeout=40) as resp:
        return json.loads(resp.read())

# 1) brouillon
draft = api("POST", API, {"article": {
    "title": title, "body_markdown": body, "published": False, "tags": tags,
}}, key)
art_id = draft["id"]

# 2) publication, avec deux reprises sur 5xx
for attempt in range(3):
    try:
        api("PUT", f"{API}/{art_id}", {"article": {"published": True}}, key)
        break
    except urllib.error.HTTPError as e:
        if e.code in (502, 503, 504) and attempt < 2:
            time.sleep(8 * (attempt + 1))
            continue
        raise

Un PUT est idempotent : le rejouer ne crée rien en double. C'est toute la raison de cette
danse en deux temps.

Étape 5 — un fichier d'état, sinon vous publiez deux fois

Le job tourne une fois par jour, mais il peut tourner deux fois : un redémarrage, un
déclenchement manuel, une reprise après panne. Un petit JSON suffit à rendre le script
idempotent.

STATE = os.path.expanduser("~/.hermes/scripts/devto-publish-state.json")
state = json.load(open(STATE)) if os.path.exists(STATE) else {}

today = time.strftime("%Y-%m-%d")
if state.get("last") == today:
    print(f"déjà publié aujourd'hui ({today})")
    return

done = set(state.get("done", []))
todo = [f for f in files if f not in done]
fname = todo[0]                      # un article par jour, dans l'ordre alphabétique
# … publication …
done.add(fname)
state.update({"done": sorted(done), "last": today})
tmp = STATE + ".tmp"
json.dump(state, open(tmp, "w"))
os.replace(tmp, STATE)               # écriture atomique

os.replace plutôt qu'une écriture directe : si la machine s'éteint au mauvais moment, on
garde l'ancien état au lieu d'un fichier tronqué.

Le cron, et la seule ligne qui compte

40 8 * * * flock -n /tmp/devto.lock /usr/bin/python3 \
  /home/moi/.hermes/scripts/publish-devto.py >> /home/moi/logs/devto.log 2>&1

Une fois par jour, à heure fixe, avec un verrou. Et lisez ce log de temps en temps : c'est
tout l'objet de mon article précédent sur les crons qui meurent en silence.

Les quatre erreurs que j'ai vues en vrai

Code	Message	Cause réelle	Réaction
`403`	—	En-tête `User-Agent` absent	L'ajouter, toujours
`401`	`unauthorized`	Clé absente, expirée ou révoquée	Régénérer la clé
`422`	`tag not found`	Tag hors liste blanche	Filtrer les tags
`422`	`Title has already been used in the last five minutes`	Doublon de titre	Attendre, ou varier le titre
`503`	—	API surchargée	Réessayer avec un backoff

Le 422 sur le titre m'a coûté une soirée : mes deux tentatives de reprise ré-envoyaient le
même titre, donc échouaient de la même façon. Une reprise ne doit se déclencher que sur une
erreur transitoire — jamais sur une erreur de contrat.

Ce que ça donne à l'usage

J'écris un fichier markdown, je le nomme 11-mon-sujet.md, je le pose dans le dossier. Le
lendemain à 8 h 40 il est en ligne, avec ses tags et sa couverture. Le fichier est marqué
comme publié, et il ne repartira pas.

Cent trente lignes, zéro dépendance installée, et un pipeline que je peux encore lire dans
deux ans. C'est exactement ce que je demande à un outil interne.

Votre cron est mort depuis trois semaines et personne ne vous a rien dit

Dev du Sud — Sun, 01 Nov 2026 19:55:11 +0000

Un job planifié ne tombe pas en panne comme un site web. Un site web qui tombe, on le voit :
les visiteurs écrivent, les statistiques s'effondrent. Un cron qui tombe, lui, produit exactement
la même chose qu'un cron qui n'avait rien à faire : du silence.

Je l'ai découvert en ouvrant le fichier des tâches planifiées de ma machine. Une publication
automatique d'articles était en état « pause » depuis le 16 octobre à 14 h 26. Treize exécutions
consécutives en échec avant ça, du 4 au 16 octobre. Personne n'avait été prévenu — et surtout,
rien ne s'était arrêté : les autres jobs continuaient, la machine était en bonne santé, tout
avait l'air normal.

Pourquoi un job meurt sans bruit

Trois causes, et dans mon cas les trois en même temps.

1. La panne réseau. Les journaux montrent une résolution DNS impossible au moment du
déclenchement : URLError, puis Name or service not known. Le job a échoué treize fois
de suite, à la même heure, chaque matin.

2. L'ordonnanceur qui se protège. Après un certain nombre d'échecs consécutifs, un
scheduler correct met le job en pause. C'est la bonne décision : ça évite de marteler une API
morte. Mais la mise en pause n'est pas forcément visible pour un humain, et rien ne garantit
qu'on la remarque un jour.

3. La sortie que personne ne lit. Un script qui écrit dans un fichier de log ne prévient
personne. Un script qui sort en code 0 alors qu'il n'a rien fait prévient encore moins.

Il existe un quatrième cas, plus vicieux : le script tourne, sort en 0, et ne fait rien. Le
cas classique, c'est le dossier vide.

if not todo:
    print("file vide")
    sys.exit(0)          # ← le drame est ici

Tout va bien. Surtout pour le monitoring.

Garde-fou 1 — un battement de cœur horodaté

Un fichier, écrit uniquement en cas de succès réel, avec l'horodatage à l'intérieur.

from datetime import datetime, timezone
import pathlib

HEARTBEAT = pathlib.Path.home() / ".local/state/mon-job-last-success"

def marquer_succes(note: str = "") -> None:
    HEARTBEAT.parent.mkdir(parents=True, exist_ok=True)
    HEARTBEAT.write_text(f"{datetime.now(timezone.utc).isoformat()} {note}\n")

Règle : on écrit le heartbeat à la fin, après l'action réussie. Pas au début, pas « à peu
près », pas « si tout s'est bien passé jusqu'ici ». Si le script plante au milieu, aucun
heartbeat — et c'est précisément l'information qu'on veut.

Garde-fou 2 — le chien de garde qui surveille le chien de garde

Un second job, indépendant, qui ne fait qu'une chose : mesurer l'âge du heartbeat et crier
si l'âge dépasse le seuil.

#!/usr/bin/env bash
set -euo pipefail

HB="$HOME/.local/state/mon-job-last-success"
SEUIL_H=$(( 3 * 24 ))   # 3 jours pour une publication quotidienne

if [ ! -f "$HB" ]; then
  notify-send "Job: aucun heartbeat n'a jamais été écrit" || true
  exit 1
fi

AGE_H=$(( ( $(date +%s) - $(stat -c %Y "$HB") ) / 3600 ))

if [ "$AGE_H" -gt "$SEUIL_H" ]; then
  notify-send "Job muet depuis ${AGE_H} h (seuil ${SEUIL_H} h)"
  exit 1
fi

echo "ok — dernier succès il y a ${AGE_H} h"

Ce garde-fou ne répare rien : il révèle. Dans mon cas, il aurait parlé le 16 octobre au
soir au lieu du 24.

Le seuil est la seule décision qui compte. Trop court, on crie pour un job hebdomadaire
parfaitement normal ; trop long, on découvre la panne quand le stock est déjà épuisé. Pour une
publication quotidienne, trois jours laissent une marge honnête : un week-end de panne réseau
ne déclenche rien, trois jours de silence déclenchent tout.

Si vous ne voulez pas écrire ce garde-fou, les services de dead man's switch existent
(healthchecks.io, ou Uptime Kuma en auto-hébergé) : le job envoie un ping en cas de succès, le
service crie quand le ping manque. C'est la même idée, hébergée ailleurs — et c'est plus
robuste, puisque la surveillance ne meurt pas avec la machine surveillée.

Garde-fou 3 — distinguer « rien à faire » de « je n'ai pas pu faire »

C'est tout le piège du file vide. Un job qui n'avait rien à faire et un job cassé doivent
produire deux signaux différents.

if not todo:
    print("ALERTE file vide")
    sys.exit(3)          # ni succès, ni panne : problème de stock

Avec un code de sortie non nul, le scheduler marque l'exécution en échec et la remonte. Trois
codes suffisent pour se comprendre entre humains :

Code	Sens	Réaction attendue
`0`	Succès, quelque chose a été fait	Rien
`1`	Erreur technique (réseau, API, disque)	Regarder les logs, réessayer
`3`	Rien à faire, et c'est anormal	Recharger la file, réapprovisionner

La différence entre 1 et 3 est la plus utile du lot : elle dit si on doit réparer la
plomberie ou remplir le réservoir.

Garde-fou 4 — tester le contrat, pas seulement le script

Un script testé une fois en septembre ne dit rien de son comportement en novembre. Deux
vérifications automatiques, une fois par semaine :

# 1) le script est-il encore démarrable ?
python3 -m py_compile "$HOME/.hermes/scripts/mon-job.py"

# 2) a-t-il encore de quoi travailler ?
ls -1 "$HOME/devto-articles"/*.md 2>/dev/null | wc -l

Si le second nombre vaut zéro, le job va tourner pour rien. C'est exactement ce qui s'est
passé chez moi : les fichiers déjà publiés avaient été déplacés dans un sous-dossier
publies/, et le script ne regarde que la racine du dossier. Zéro candidat, tous les jours,
sans la moindre erreur.

Ajoutez flock pour éviter deux exécutions simultanées, et set -euo pipefail pour que
l'échec d'une commande intermédiaire ne soit pas avalée :

flock -n /tmp/mon-job.lock /usr/bin/python3 "$HOME/.hermes/scripts/mon-job.py"

Le détail qui m'a coûté le plus de temps

Deux runs sur treize ont échoué pour une raison différente du réseau :
422 — Title has already been used in the last five minutes. L'API refuse un titre identique
dans une fenêtre de cinq minutes, et mon script réessayait avec le même titre. Un type d'échec
sur deux est invisible dans un compteur global, et il suffit à casser un job.

Leçon : un échec n'est pas un échec. 503 (serveur fatigué), 422 (contrat violé), 401
(clé expirée) demandent trois réactions opposées — réessayer, corriger, réveiller un humain.
Les traiter pareil, c'est garantir qu'aucun des trois ne sera bien traité.

La checklist que j'applique maintenant

[ ] Un heartbeat écrit après le succès, jamais avant.
[ ] Un garde-fou indépendant qui mesure l'âge du heartbeat.
[ ] Trois codes de sortie : 0 succès, 1 panne, 3 stock vide.
[ ] Un test hebdomadaire du contrat : le script compile, la file n'est pas vide.
[ ] flock sur chaque job qui touche à un état partagé.
[ ] La sortie du job lue par quelque chose, jamais seulement écrite sur disque.
[ ] Un job mis en pause par le scheduler déclenche une alerte, pas un silence.

Ce que ça change

Rien de spectaculaire : un heartbeat, un chien de garde, trois codes de sortie, un test
hebdomadaire. Une quarantaine de lignes en tout. Mais depuis, le silence est devenu une
information.

Un job planifié n'est pas un service qui tourne. C'est une promesse renouvelée chaque nuit —
et une promesse non tenue ne fait aucun bruit. C'est à vous d'installer le bruit.

Sauvegarder ses fichiers importants automatiquement avec Python

Dev du Sud — Fri, 23 Oct 2026 09:00:00 +0000

Le jour où on regrette

On pense souvent aux sauvegardes trop tard. Le disque dur tombe en panne, l'ordinateur refuse de démarrer, un fichier est supprimé par erreur, ou un dossier client disparaît. À ce moment-là, on se dit : « j'aurais dû faire une copie ».

La bonne nouvelle, c'est qu'une sauvegarde simple n'a pas besoin d'être compliquée. Avec Python, on peut copier automatiquement un dossier important vers un autre emplacement : un disque externe, un dossier synchronisé, ou un NAS à la maison.

Ce tuto montre une sauvegarde basique, lisible, et adaptée aux débutants. Ce n'est pas une solution professionnelle complète, mais c'est déjà beaucoup mieux que rien.

La règle 3-2-1 en version simple

On entend souvent parler de la règle 3-2-1 : trois copies, sur deux supports différents, dont une hors de la maison ou de l'entreprise. Pour commencer, retenez surtout ceci : une seule copie sur le même ordinateur ne suffit pas.

Si votre dossier original et votre sauvegarde sont sur le même disque, une panne peut emporter les deux. L'idéal est de copier vers un support différent.

Le script Python

from pathlib import Path
import shutil
from datetime import datetime

SOURCE = Path("documents-importants")
DESTINATION = Path("sauvegardes")

horodatage = datetime.now().strftime("%Y-%m-%d_%H-%M")
dossier_backup = DESTINATION / f"backup_{horodatage}"

if not SOURCE.exists():
    raise SystemExit(f"Le dossier source n'existe pas : {SOURCE}")

shutil.copytree(SOURCE, dossier_backup)
print(f"Sauvegarde créée dans : {dossier_backup}")

Ce que fait ce script

Le dossier documents-importants est le dossier à protéger. Le dossier sauvegardes est l'endroit où Python va créer une copie. À chaque lancement, le script ajoute la date et l'heure dans le nom du dossier, par exemple backup_2026-10-11_18-30.

C'est très pratique, car on garde plusieurs versions. Si vous avez modifié un fichier hier et que vous regrettez aujourd'hui, vous pouvez retrouver une ancienne copie.

La fonction copytree copie tout le dossier. Elle est simple et efficace. Pour de très gros volumes, il existe des méthodes plus avancées qui ne copient que les fichiers modifiés. Mais pour apprendre et protéger un petit dossier, cette version est parfaite.

Comment l'adapter

Remplacez documents-importants par le chemin de votre vrai dossier. Par exemple, cela peut être un dossier Clients, Factures, Photos famille, ou Administratif. Remplacez aussi sauvegardes par votre disque externe si vous en avez un.

Sur Windows, un chemin peut ressembler à D:/Sauvegardes. Sur Linux ou Mac, il peut ressembler à /media/ludo/DisqueUSB/Sauvegardes. Le plus important est de tester avec un petit dossier avant de viser vos vrais fichiers.

Automatiser vraiment

Un script qu'on oublie de lancer ne sert pas à grand-chose. L'étape suivante consiste donc à le lancer automatiquement. Sur Windows, on peut utiliser le Planificateur de tâches. Sur Linux ou Mac, on peut utiliser cron ou un service équivalent.

Choisissez un rythme réaliste. Pour des fichiers très importants, une sauvegarde quotidienne peut être utile. Pour des documents moins actifs, une fois par semaine suffit peut-être.

Les erreurs fréquentes

Première erreur : ne jamais vérifier les sauvegardes. Une sauvegarde doit être testée. Ouvrez quelques fichiers copiés pour confirmer qu'ils sont lisibles.

Deuxième erreur : laisser le disque externe toujours branché. Si un ransomware chiffre vos fichiers, il peut aussi toucher le disque branché. Pour une vraie protection, branchez le disque, lancez ou laissez faire la sauvegarde, puis débranchez-le.

Troisième erreur : confondre synchronisation et sauvegarde. Un service cloud qui synchronise supprime parfois aussi le fichier partout si vous le supprimez par erreur. C'est pratique, mais ce n'est pas toujours une sauvegarde historique.

À retenir

Une sauvegarde simple aujourd'hui vaut mieux qu'un plan parfait jamais mis en place. Commencez avec un dossier important, une copie datée, et une vérification manuelle. Ensuite, vous pourrez automatiser le lancement.

Python ne rend pas vos données invincibles, mais il peut vous éviter le grand moment de solitude du fichier perdu.

Générer un PDF de rapport ou de facture sans acheter de logiciel

Dev du Sud — Wed, 21 Oct 2026 22:14:54 +0000

Pourquoi générer un PDF soi-même

Beaucoup de petites activités ont besoin de documents simples : une facture, un compte rendu d'intervention, un rapport de visite, un devis rapide, une fiche client. On peut le faire dans Word ou LibreOffice, bien sûr. Mais quand le même document revient souvent, remplir les mêmes lignes à la main devient vite pénible.

Python peut générer un PDF automatiquement à partir de quelques informations : nom du client, date, lignes de prestation, total. Pas besoin d'acheter un logiciel compliqué pour comprendre le principe.

Dans ce tuto, on va créer une mini facture très simple. Elle ne remplace pas un logiciel de comptabilité complet, surtout si vous avez des obligations légales précises. Mais elle montre comment produire un PDF propre, répétable, et facile à adapter.

L'outil utilisé

On va utiliser reportlab, une bibliothèque Python gratuite très connue pour créer des PDF. Si elle n'est pas installée, il faudra l'ajouter une fois sur votre ordinateur. Ensuite, le script pourra générer autant de PDF que vous voulez.

Le principe est très simple : on crée une page, on écrit du texte à des positions précises, puis on sauvegarde le fichier.

Le script Python

from reportlab.lib.pagesizes import A4
from reportlab.pdfgen import canvas
from reportlab.lib.units import cm

client = "Boulangerie du Port"
numero = "FAC-2026-001"
lignes = [
    ("Diagnostic ordinateur caisse", 1, 49.00),
    ("Sauvegarde des fichiers", 1, 39.00),
    ("Nettoyage logiciel", 1, 29.00),
]

fichier_pdf = "facture-exemple.pdf"
pdf = canvas.Canvas(fichier_pdf, pagesize=A4)
largeur, hauteur = A4

pdf.setFont("Helvetica-Bold", 18)
pdf.drawString(2 * cm, hauteur - 2 * cm, "Facture")

pdf.setFont("Helvetica", 11)
pdf.drawString(2 * cm, hauteur - 3 * cm, f"Numéro : {numero}")
pdf.drawString(2 * cm, hauteur - 3.7 * cm, f"Client : {client}")

pdf.line(2 * cm, hauteur - 4.5 * cm, largeur - 2 * cm, hauteur - 4.5 * cm)

y = hauteur - 5.5 * cm
total = 0
for description, quantite, prix in lignes:
    montant = quantite * prix
    total += montant
    pdf.drawString(2 * cm, y, description)
    pdf.drawRightString(15 * cm, y, f"{quantite} x {prix:.2f} €")
    pdf.drawRightString(19 * cm, y, f"{montant:.2f} €")
    y -= 0.8 * cm

pdf.line(12 * cm, y, largeur - 2 * cm, y)
y -= 0.8 * cm
pdf.setFont("Helvetica-Bold", 12)
pdf.drawRightString(19 * cm, y, f"Total : {total:.2f} €")

pdf.setFont("Helvetica", 9)
pdf.drawString(2 * cm, 2 * cm, "Document généré automatiquement avec Python.")
pdf.save()
print(f"PDF créé : {fichier_pdf}")

Ce que fait le script

La liste lignes contient les prestations. Chaque ligne a trois informations : le texte, la quantité, et le prix unitaire. Python calcule le total tout seul. Si vous ajoutez une prestation, le montant final change automatiquement.

Les coordonnées peuvent sembler étranges au début. Dans un PDF, on place les éléments sur une page, un peu comme sur une feuille avec une règle. 2 * cm signifie simplement « deux centimètres depuis le bord ». On n'a pas besoin de tout comprendre d'un coup : commencez par modifier les textes et les prix.

Comment l'utiliser au quotidien

Vous pouvez transformer ce script en modèle. Par exemple, un réparateur peut changer le nom du client et les prestations après chaque intervention. Une association peut générer un rapport mensuel. Un freelance peut produire un devis simple.

Le vrai intérêt arrive quand les données viennent d'un fichier. Imaginez un tableau avec tous les clients du mois. Python pourrait lire chaque ligne et générer un PDF par client. Là, le gain de temps devient énorme.

Attention aux obligations légales

Une facture réelle doit respecter des règles : identité de l'entreprise, numéro unique, dates, mentions, TVA selon votre situation, conditions de paiement, et parfois d'autres informations. Ce tuto ne donne pas un modèle légal complet. Il donne une base technique.

Si vous voulez l'utiliser pour une vraie activité, vérifiez les mentions obligatoires avec une source officielle ou votre comptable. L'automatisation ne dispense pas d'être carré.

À retenir

Créer un PDF avec Python, ce n'est pas réservé aux grosses entreprises. Pour des documents répétitifs, c'est même une excellente porte d'entrée dans l'automatisation. Vous commencez avec une facture simple, puis vous ajoutez petit à petit votre logo, vos couleurs, vos conditions, ou vos données clients.

Le but n'est pas de faire joli dès le premier jour. Le but est d'arrêter de recopier les mêmes informations à la main.

Trier et classer automatiquement ses photos et documents avec Python

Dev du Sud — Wed, 21 Oct 2026 22:14:44 +0000

Le grand dossier en vrac

Sur beaucoup d'ordinateurs, il existe un dossier qui fait peur. Il s'appelle souvent Téléchargements, Bureau, ou À trier. Dedans, on trouve des photos, des PDF, des captures d'écran, des factures, des fichiers Word, des archives ZIP, parfois même des choses qu'on ne reconnaît plus.

Ranger tout ça à la main prend du temps. Et comme ce n'est pas très amusant, on repousse. Résultat : le dossier grossit encore.

Python peut aider à faire un premier tri automatique. L'idée n'est pas de deviner parfaitement le contenu de chaque document. L'idée est plus simple : classer les fichiers par famille grâce à leur extension. Les .jpg vont dans Photos, les .pdf dans PDF, les .docx dans Documents, et ainsi de suite.

Pourquoi commencer par les extensions

L'extension, c'est la fin du nom du fichier : .jpg, .pdf, .xlsx, .png. Ce n'est pas parfait, mais c'est déjà très utile. Pour un premier rangement, on n'a pas besoin d'intelligence artificielle. Une règle claire suffit.

Avant de lancer le script sur votre vrai dossier Téléchargements, copiez quelques fichiers dans un dossier de test. C'est une bonne habitude : on teste petit, puis on applique plus grand.

Le script Python

from pathlib import Path
import shutil

DOSSIER_A_TRIER = Path("a-trier")
MODE_TEST = True

CATEGORIES = {
    "Photos": [".jpg", ".jpeg", ".png", ".gif", ".webp"],
    "PDF": [".pdf"],
    "Documents": [".doc", ".docx", ".odt", ".txt"],
    "Tableurs": [".xls", ".xlsx", ".csv"],
    "Archives": [".zip", ".rar", ".7z"],
}

def trouver_categorie(extension):
    for categorie, extensions in CATEGORIES.items():
        if extension in extensions:
            return categorie
    return "Autres"

for fichier in DOSSIER_A_TRIER.iterdir():
    if not fichier.is_file():
        continue

    categorie = trouver_categorie(fichier.suffix.lower())
    dossier_destination = DOSSIER_A_TRIER / categorie
    nouvelle_adresse = dossier_destination / fichier.name

    print(f"{fichier.name} -> {categorie}/")

    if not MODE_TEST:
        dossier_destination.mkdir(exist_ok=True)
        shutil.move(str(fichier), str(nouvelle_adresse))

Comment utiliser ce script

Créez un dossier a-trier, mettez une dizaine de fichiers dedans, puis lancez le script. Au départ, MODE_TEST est à True. Le script affiche ce qu'il ferait, mais ne déplace rien. C'est parfait pour vérifier que les catégories vous conviennent.

Quand le résultat affiché semble bon, passez MODE_TEST à False. Le script créera les dossiers nécessaires et déplacera les fichiers.

Si vous voulez ajouter une catégorie, modifiez simplement le dictionnaire CATEGORIES. Par exemple, vous pouvez créer une catégorie Images boutique pour les .jpg et .png, ou une catégorie Compta pour certains fichiers si vous adaptez ensuite la règle.

Les limites à connaître

Ce script ne lit pas le contenu des documents. Un PDF de facture et un PDF de menu restaurant iront tous les deux dans PDF. Pour faire mieux, il faudrait analyser le texte, les dates, ou les noms de fichiers. C'est possible, mais ce serait une étape suivante.

Autre limite : si un fichier du même nom existe déjà dans le dossier de destination, le déplacement peut poser problème. Pour un usage sérieux, on peut ajouter une règle qui renomme automatiquement le fichier en ajoutant un numéro. Pour débuter, gardons le script lisible.

Une bonne méthode de rangement

L'automatisation ne remplace pas une bonne logique. Avant de trier, demandez-vous quelles catégories vous voulez vraiment. Trop de dossiers, c'est aussi pénible que pas assez. Pour beaucoup de personnes, cinq ou six familles suffisent : Photos, PDF, Documents, Tableurs, Archives, Autres.

Ensuite, lancez ce script une fois par semaine. Votre dossier Téléchargements ne deviendra plus une décharge numérique.

Pourquoi c'est utile pour un non-développeur

Ce type de script donne une sensation très agréable : l'ordinateur fait enfin ce qu'on lui demande. Pas besoin de comprendre des concepts compliqués. On écrit une règle simple, puis Python l'applique sans se lasser.

Pour une petite entreprise, ce rangement peut éviter de perdre des factures, des photos produits ou des documents clients. Pour un particulier, ça rend juste l'ordinateur plus respirable.

À retenir

Un bon tri automatique commence petit. Une copie, quelques fichiers, un mode test, puis seulement après le vrai dossier. Avec cette méthode, vous avancez sans stress et vous gardez le contrôle.

Scraper une page web pour récupérer des infos en restant poli

Dev du Sud — Wed, 21 Oct 2026 21:18:58 +0000

Scraper, ça veut dire quoi ?

Scraper une page web, c'est demander à Python de lire une page internet et d'en extraire une information. Par exemple : le titre d'un article, le prix affiché sur une page produit, une liste d'horaires, ou les liens présents dans une page.

C'est pratique, mais ce n'est pas une excuse pour aspirer tout un site comme un sauvage. Derrière un site, il y a un serveur, une personne, une entreprise, parfois un petit commerçant. Un script mal réglé peut envoyer trop de requêtes et gêner le site.

Dans ce tuto, on va faire un exemple simple et poli : télécharger une seule page, annoncer qui on est avec un User-Agent, attendre entre les demandes si on en fait plusieurs, et ne pas contourner les protections.

Les règles de base

Avant de scraper, regardez si le site propose une API ou un fichier export. C'est souvent plus propre. Lisez aussi les conditions d'utilisation si les données sont sensibles ou commerciales.

Ne récupérez pas de données personnelles sans raison claire. Ne contournez pas un login, un paywall, un captcha ou une interdiction technique. Et si un site dit non dans son fichier robots.txt, respectez ce signal, surtout pour un projet automatisé.

Le scraping doit rester raisonnable : peu de pages, peu souvent, et avec un vrai besoin.

Le script Python

from html.parser import HTMLParser
from urllib.request import Request, urlopen
from time import sleep

class ExtracteurTitres(HTMLParser):
    def __init__(self):
        super().__init__()
        self.dans_h2 = False
        self.titres = []

    def handle_starttag(self, tag, attrs):
        if tag == "h2":
            self.dans_h2 = True

    def handle_endtag(self, tag):
        if tag == "h2":
            self.dans_h2 = False

    def handle_data(self, data):
        texte = data.strip()
        if self.dans_h2 and texte:
            self.titres.append(texte)

url = "https://example.com"
requete = Request(url, headers={"User-Agent": "DevDuSudBot/1.0 contact: contact@example.com"})

with urlopen(requete, timeout=10) as reponse:
    html = reponse.read().decode("utf-8", errors="ignore")

extracteur = ExtracteurTitres()
extracteur.feed(html)

for titre in extracteur.titres:
    print(titre)

sleep(2)

Ce que fait le script

Le script télécharge une page, lit son HTML, puis récupère le texte placé dans les balises h2. Sur certains sites, les titres sont dans des h1, h2, h3, ou dans des blocs plus complexes. Il faudra donc adapter selon la page.

Le User-Agent est une phrase d'identité. Au lieu de se cacher, votre script explique qui il est. Pour un vrai projet, mettez une adresse de contact valable. Cela montre que vous n'essayez pas de vous faire passer pour un navigateur humain.

Le sleep(2) marque une pause. Ici, on ne fait qu'une page, donc il ne sert pas beaucoup. Mais si vous parcourez plusieurs pages, cette pause évite de taper trop vite sur le serveur.

Un exemple utile et raisonnable

Imaginez un commerçant qui veut vérifier une fois par jour si ses horaires apparaissent correctement sur une page partenaire. Le script peut lire la page, chercher un texte, et alerter si l'information change. C'est un usage raisonnable.

À l'inverse, aspirer tout un catalogue concurrent toutes les dix secondes serait agressif. Même si c'est techniquement possible, ce n'est pas une bonne idée.

Les limites du scraping

Beaucoup de sites modernes chargent les informations avec JavaScript. Dans ce cas, le HTML reçu par Python peut être presque vide. Il faut alors utiliser d'autres outils, parfois plus lourds, ou chercher une API officielle.

Autre limite : la structure d'une page peut changer. Si le site remplace ses h2 par autre chose, votre script ne trouvera plus rien. Un scraper doit donc être surveillé et corrigé de temps en temps.

À retenir

Scraper, ce n'est pas voler ni spammer. C'est lire automatiquement une page publique, avec mesure et respect. La bonne attitude est simple : peu de requêtes, une identité claire, pas de contournement, pas de données sensibles inutiles.

Python donne le pouvoir de récupérer de l'information. La partie importante, c'est de l'utiliser proprement.

Une facture, un fichier HTML, zéro serveur : ce que j'ai appris en fabriquant mon outil de facturation

Dev du Sud — Wed, 21 Oct 2026 18:51:25 +0000

Je ne suis pas développeur. Je suis technicien IT, et je passe mes journées à réparer
les machines des autres. Comme beaucoup d'indépendants, je facturais mal : un tableur,
des numéros qui se perdent, des mentions légales que je recopiais d'une vieille facture.

Je voulais un outil de facturation qui :

fonctionne sans connexion (je travaille souvent dans des locaux sans wifi correct) ;
ne m'oblige pas à créer un compte chez quelqu'un ;
ne m'abonne pas à 12 € par mois pour sortir deux factures ;
tienne sur une clé USB, parce que je change souvent de machine.

La solution la plus simple que j'ai trouvée : une seule page HTML, du JavaScript,
et le stockage local du navigateur. Pas de serveur, pas de base de données, pas de
déploiement. On ouvre le fichier, on facture, on ferme. Les données ne quittent pas
la machine.

Trois choses que j'ai apprises en le construisant :

Le stockage local est plus fragile qu'on croit. Un nettoyage de navigateur, et tout disparaît. J'ai donc ajouté un export des données : ce n'est pas glamour, mais c'est la fonctionnalité la plus importante de l'outil.
Les mentions légales sont la vraie difficulté. Le code, c'est une journée. Savoir ce qu'une facture de micro-entreprise doit contenir, c'est le reste du travail.
Un outil qu'on n'ose pas ouvrir ne sert à rien. J'ai supprimé la moitié des champs que je trouvais « utiles ». Une facture doit se faire en deux minutes, pas en dix.

Je l'ai ensuite mis en PDF avec un mode d'emploi, parce que plusieurs collègues
artisans m'ont demandé le fichier. C'est ici, 19,90 €, paiement unique :
https://revedebiz.gumroad.com/l/ngseyv

Si vous bricolez le même genre d'outil, je suis preneur de vos retours — surtout
sur la partie sauvegarde, c'est là que je suis le moins sûr de moi.

3 erreurs qui font fuir tes clients

Dev du Sud — Sun, 18 Oct 2026 15:51:26 +0000

3 erreurs qui te coûtent des clients 💸

Ton site te vend... ou te dessert. Tu sais lequel ?

siteweb #clients #conversion #entrepreneur #conseils

Publier un site en 5 minutes

Dev du Sud — Sun, 18 Oct 2026 15:50:36 +0000

Un site en ligne en 5 minutes chrono ⚡

Pas besoin d'une semaine, ni de 200€ de budget. Juste une méthode. Sauvegarde, la démo arrive.

siteweb #créationsite #devweb #hébergement #tuto

Ton travail ou ton IA ?

Dev du Sud — Sun, 18 Oct 2026 15:50:35 +0000

Ton travail, ou celui de ton IA ? 🤖

La plupart des gens perdent 2h par jour sur des trucs qu'un agent ferait en 2 minutes. En 2026, ne pas automatiser, c'est choisir de perdre du temps.

IA #automatisation #agentIA #productivité #dev

Envoyer un email automatique pour rappeler les rendez-vous d'un commerçant

Dev du Sud — Thu, 15 Oct 2026 07:34:10 +0000

Le besoin très concret

Un salon de coiffure, un garage, une sophrologue, un réparateur informatique ou un cabinet de bien-être ont tous le même problème : les rendez-vous oubliés. Une personne ne vient pas, le créneau est perdu, et personne n'est content.

On peut payer un gros logiciel pour gérer ça. Mais pour comprendre le principe, un petit script Python suffit. Il lit une liste de rendez-vous, repère ceux qui arrivent bientôt, puis envoie un email de rappel.

Le but n'est pas de remplacer un vrai outil métier complet. Le but est de voir comment automatiser une tâche simple : « demain, pensez à votre rendez-vous ».

Ce qu'on va faire

On va imaginer un fichier de rendez-vous dans le script, pour rester simple. Dans la vraie vie, cette liste pourrait venir d'un fichier CSV, d'un agenda Google, ou d'un logiciel. Chaque rendez-vous contient un nom, une adresse email, une date et une heure.

Le script vérifie les rendez-vous prévus demain. S'il en trouve un, il prépare un message et l'envoie avec une boîte email classique.

Important : ne mettez jamais votre mot de passe directement dans le code. On utilise des variables d'environnement. C'est une façon plus propre de dire à Python : « va chercher le mot de passe ailleurs ».

Le script Python

import os
import smtplib
from datetime import date, timedelta
from email.message import EmailMessage

SMTP_SERVER = "smtp.gmail.com"
SMTP_PORT = 587
EMAIL_EXPEDITEUR = os.environ["EMAIL_EXPEDITEUR"]
MOT_DE_PASSE = os.environ["EMAIL_MOT_DE_PASSE"]

rendez_vous = [
    {"nom": "Nadia", "email": "nadia@example.com", "date": "2026-10-12", "heure": "14:30"},
    {"nom": "Karim", "email": "karim@example.com", "date": "2026-10-15", "heure": "09:00"},
]

demain = (date.today() + timedelta(days=1)).isoformat()

with smtplib.SMTP(SMTP_SERVER, SMTP_PORT) as serveur:
    serveur.starttls()
    serveur.login(EMAIL_EXPEDITEUR, MOT_DE_PASSE)

    for rdv in rendez_vous:
        if rdv["date"] != demain:
            continue

        message = EmailMessage()
        message["From"] = EMAIL_EXPEDITEUR
        message["To"] = rdv["email"]
        message["Subject"] = "Rappel de votre rendez-vous"
        message.set_content(
            f"Bonjour {rdv['nom']},

"
            f"Petit rappel : votre rendez-vous est prévu demain à {rdv['heure']}.
"
            "Si vous avez un empêchement, merci de nous prévenir.

"
            "Bonne journée !"
        )

        serveur.send_message(message)
        print(f"Rappel envoyé à {rdv['nom']}")

Comment l'adapter simplement

La partie rendez_vous est votre mini agenda. Pour tester, remplacez les emails d'exemple par une adresse à vous. Ne testez jamais directement sur de vrais clients au premier essai. Envoyez-vous le message, vérifiez le texte, puis seulement après utilisez une vraie liste.

Pour Gmail, il faut souvent créer un mot de passe d'application. Ce n'est pas votre mot de passe principal. C'est un mot de passe spécial pour les scripts. D'autres fournisseurs email ont un système équivalent.

Les variables EMAIL_EXPEDITEUR et EMAIL_MOT_DE_PASSE se configurent dans votre système. Sur Linux ou Mac, on peut les définir dans le terminal. Sur Windows, on peut les ajouter dans les variables d'environnement. L'idée est toujours la même : le code ne doit pas afficher le secret.

Ce qu'il ne faut pas faire

N'envoyez pas 500 emails d'un coup depuis une boîte personnelle. Les fournisseurs peuvent croire à du spam. Commencez petit, avec quelques messages, et gardez un ton utile. Un rappel de rendez-vous, c'est normal. Une pub répétée, c'est autre chose.

Ajoutez toujours une phrase humaine : comment annuler, comment prévenir, ou à quel numéro appeler. L'automatisation doit aider la relation client, pas donner l'impression qu'un robot froid parle à votre place.

Pourquoi c'est puissant

Un email automatique, ce n'est pas magique. C'est juste une règle répétée au bon moment. Mais pour un petit commerce, ça peut éviter des oublis, libérer du temps, et donner une image plus organisée.

Python devient ici un assistant discret. Il ne vend rien, il ne remplace pas le contact humain. Il pense juste à envoyer le rappel quand vous êtes occupé à autre chose.

À retenir

Commencez avec votre propre adresse email, testez, corrigez le message, puis seulement après utilisez de vrais rendez-vous. Un bon script professionnel est d'abord un script prudent.

Renommer 500 fichiers en 2 secondes avec Python

Dev du Sud — Wed, 14 Oct 2026 07:01:02 +0000

Le problème du dossier qui déborde

Vous avez peut-être déjà vécu ça : un dossier rempli de photos, de factures scannées ou de fichiers téléchargés avec des noms impossibles. Des IMG_4891.jpg, scan0007.pdf, nouveau_document_final_vrai_final.pdf. Quand il y en a 10, on peut s'en sortir à la main. Quand il y en a 500, c'est une punition.

L'idée de ce tuto est simple : demander à Python de parcourir un dossier et de renommer chaque fichier proprement. Pas besoin d'être développeur. On va préparer un petit script, le tester en mode prudent, puis le lancer pour de vrai.

Exemple concret : un commerçant reçoit chaque semaine des photos produits. Au lieu de garder DSC_001.jpg, il veut obtenir produit-001.jpg, produit-002.jpg, etc. C'est plus lisible, plus facile à envoyer, et beaucoup moins stressant.

Ce qu'il faut préparer

Avant de toucher aux fichiers, faites une copie du dossier. C'est la règle numéro 1. Un script peut aller très vite, donc on teste toujours sur une copie avant de l'utiliser sur les vrais documents.

Créez ensuite un dossier simple, par exemple a-renommer, et mettez quelques fichiers dedans. Le script ci-dessous va seulement renommer les fichiers, pas les sous-dossiers. C'est volontaire : pour débuter, on reste simple.

Le script Python

from pathlib import Path

DOSSIER = Path("a-renommer")
PREFIXE = "produit"
MODE_TEST = True  # Passez à False quand tout vous semble bon

fichiers = sorted([f for f in DOSSIER.iterdir() if f.is_file()])

for numero, fichier in enumerate(fichiers, start=1):
    extension = fichier.suffix.lower()
    nouveau_nom = f"{PREFIXE}-{numero:03d}{extension}"
    nouvelle_adresse = DOSSIER / nouveau_nom

    print(f"{fichier.name}  ->  {nouveau_nom}")

    if not MODE_TEST:
        fichier.rename(nouvelle_adresse)

print(f"Terminé : {len(fichiers)} fichier(s) traité(s).")

Comment le lire sans paniquer

Path("a-renommer") indique le dossier à traiter. Si votre dossier s'appelle autrement, changez seulement cette ligne. PREFIXE est le début du nouveau nom. Ici, tous les fichiers deviendront produit-001, produit-002, et ainsi de suite.

La ligne la plus importante est MODE_TEST = True. Tant qu'elle reste à True, Python affiche ce qu'il ferait, mais ne renomme rien. C'est comme une répétition générale. Vous pouvez vérifier tranquillement que le résultat vous plaît.

Quand vous êtes sûr, remplacez True par False, relancez le script, et les fichiers seront renommés.

Les petits pièges à connaître

Premier piège : deux fichiers ne peuvent pas avoir exactement le même nom dans le même dossier. Notre script évite ça grâce au numéro automatique. Deuxième piège : l'ordre. Ici, on utilise sorted, donc Python trie les fichiers par nom avant de les renommer. Si vous voulez un ordre par date de création ou de modification, c'est possible, mais on garde ça pour un tuto plus avancé.

Troisième piège : les extensions. Le script garde .jpg, .pdf, .png ou autre, en minuscules. C'est pratique pour éviter les mélanges entre .JPG et .jpg.

Pourquoi c'est utile dans la vraie vie

Ce petit script peut servir à un photographe, une boutique en ligne, une association, un artisan, ou juste à quelqu'un qui veut ranger son ordinateur. Le vrai gain n'est pas seulement de gagner deux minutes. C'est surtout d'éviter les erreurs répétitives.

Renommer 500 fichiers à la main, c'est fatigant. Et quand on est fatigué, on se trompe. Python, lui, répète la même règle sans râler. Vous décidez de la règle, il applique.

À retenir

Un bon automatisme ne doit pas être compliqué. Il doit être clair, testable, et réversible si possible. Ici, le mode test vous protège. La copie du dossier vous protège aussi. Avec ces deux habitudes, vous pouvez commencer à automatiser des tâches simples sans peur.

C'est exactement l'esprit Dev du Sud : utiliser Python comme un petit assistant de bureau, pas comme un truc réservé aux ingénieurs.