Y a des petites choses qu'on peut coder soi-meme au lieu de payer un SaaS

LiMa, mode clair. 7 logiciels suivis, calcul automatique des jours restants. 100% local.

LiMa c'est un projet que j'ai codé il y a 2 ans. Je sais qu'aujourd'hui je le ferais autrement — PyQt6 au lieu de PyQt5, SQLAlchemy au lieu de sqlite3 brut, keyring pour les credentials SMTP. J'y reviens en fin d'article.

Mais le sujet c'est pas ma dette technique. Le sujet c'est qu'il y a des petites choses qu'on peut coder soi-meme au lieu de payer un abonnement annuel pour. LiMa en est un bon exemple.

Le scénario qui m'a poussé a le coder : ton DSI te forward le devis annuel d'un outil "Software Asset Management" pour suivre les dates d'expiration des licences logicielles. Tu ouvres le PDF. Plusieurs centaines d'euros par mois. Tu cliques sur la fiche fonctionnelle. Le truc fait : une table SQL avec des dates, un cron de notifs, un mail récap par mois. Voila.

C'est comme ca qu'est né LiMa (License Manager). Une app desktop PyQt5 qui tourne en local sur le poste de l'admin du parc, branchée sur un SQLite. Cet article te montre les 4 briques techniques avec le code réel — pas pour te convaincre que les SaaS c'est mal (parfois c'est le bon choix), mais pour montrer que pour ce genre de besoin, payer c'est presque de la flemme.

Brique 1 — SQLite + un calcul "jours restants" qui se met a jour tout seul

La table fait 2 colonnes. Pas 3. Pas 10. Deux.

self.c.execute('''CREATE TABLE licences
                  (nom_logiciel TEXT, date_expiration TEXT)''')

Le reste se calcule a la volée. Le nombre de jours restants est PAS stocké, il est dérivé en temps réel a chaque rafraichissement. Le stocker, c'est introduire un bug d'obsolescence dans ta DB.

date_expiration = datetime.strptime(date_expiration_str, "%Y-%m-%d")
jours_restants = (date_expiration - datetime.now()).days
self.tableau_licences.setItem(row, 2, QTableWidgetItem(str(jours_restants)))

Un QTimer rejoue la boucle :

self.timer = QTimer(self)
self.timer.timeout.connect(self.actualiser_tableau)
self.timer.start(60_000)  # 1 min — les dates ne bougent pas plus vite que ca

Petit aveu : dans le code original j'avais mis start(1000) (1 Hz). Un héritage de mes débuts ou je pensais qu'il fallait "rafraichir souvent". 60 secondes suffisent largement, et ca consomme beaucoup moins.

Du coup le tableau est vivant. Les lignes passent au rouge quand une licence approche, sans toucher a rien.

Brique 2 — Notifs natives multi-paliers avec plyer

La ou les SaaS te vendent du "smart alerting", LiMa fait ca :

if jours_restants <= 30 and jours_restants > 14:
    notification.notify(
        title="Licence sur le point d'expirer",
        message=f"La licence pour {nom_logiciel} expirera dans moins de 1 mois.",
        app_name="LiMa",
        timeout=3,
    )
elif jours_restants <= 14 and jours_restants > 7:
    # …pareil mais "moins de 2 semaines"
elif jours_restants <= 7 and jours_restants > 3:
    # …pareil mais "moins de 1 semaine"
elif jours_restants <= 3 and jours_restants > 1:
    # …pareil mais "moins de 3 jours"
elif jours_restants == 1:
    # "expire dans 1 jour"
elif jours_restants <= 0:
    # "expirée depuis X jours"

6 paliers. 6 notifs natives (centre de notif Windows, Notification Center macOS, libnotify Linux), géré par plyer qui te file une API uniforme cross-OS. Pas besoin de pop-up custom moche dans ta fenetre, c'est l'OS qui s'en charge avec son look natif et l'utilisateur les voit meme quand l'app est minimisée.

C'est typiquement le genre de feature ou Tkinter t'oblige a hacker une fenetre flottante en Toplevel. La avec PyQt5 + plyer c'est 5 lignes et c'est propre.

Brique 3 — Mail HTML auto avec graph en pièce jointe

La ca devient sérieux. A chaque cycle d'alerte, si des licences sont en zone rouge, l'app :

1. Génere un graph en secteurs (Matplotlib) "expirées vs non expirées"
2. Le sauvegarde en PNG
3. Envoie un mail HTML formaté avec le PNG attaché

def generer_graphique_pie(self):
    expirations1 = 0
    non_expirations1 = 0
    for row in range(self.tableau_licences.rowCount()):
        jours_restants = int(self.tableau_licences.item(row, 2).text())
        if jours_restants < 0:
            expirations1 += 1
        else:
            non_expirations1 += 1
    plt.pie([expirations1, non_expirations1],
            labels=["Licences expirées", "Licences non expirées"],
            colors=["red", "green"], autopct='%1.1f%%')
    plt.savefig("graphique_pie.png")

L'envoi avec smtplib :

email = MIMEMultipart()
email["From"] = smtp_user
email["To"] = destinataire
email['Cc'] = copy_mail
email["Subject"] = subject
email.attach(MIMEText(html_body, "html"))

with open(attachment_path, "rb") as attachment:
    part = MIMEBase("application", "octet-stream")
    part.set_payload(attachment.read())
encoders.encode_base64(part)
part.add_header("Content-Disposition", f"attachment; filename={attachment_path}")
email.attach(part)

server = smtplib.SMTP(smtp_server, smtp_port)
server.starttls()
server.login(smtp_user, smtp_password)
server.sendmail(smtp_user, [destinataire] + copy_mail.split(','), email.as_string())
server.quit()

Voila. Avec smtplib (stdlib), email.mime (stdlib) et matplotlib, t'as un systeme d'alerting mail qui tient la route face a n'importe quel produit cloud. Le destinataire recoit un mail propre avec un graph dedans. Aucune API tierce, aucun token a renouveler. Ton SMTP interne fait le job, ou Gmail si t'en as pas.

Le menu : l'app est finie, pas un POC

Avant de passer a la dernière brique, voila le menu déroulant pour que tu vois bien que c'est pas juste un script qui affiche un tableau :

Import/export CSV, impression QPrinter, tri A-Z et Z-A, toggle alertes, statistiques visuelles (Matplotlib), configuration SMTP, dark/light mode, "a propos". Tout ce qu'on attend d'un outil interne fini, pas d'un prototype. Et tout ca tient dans un seul lima.py.

Brique 4 — Le dark mode en PyQt5 sans librairie

PyQt5 expose des stylesheets façon CSS. Du coup le dark mode c'est juste un setStyleSheet a toggler :

def toggle_dark_mode(self):
    self.setStyleSheet("""
        QMainWindow {
            background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
                stop:0 #323232, stop:1 #1a1a1a);
            color: #FFFFFF;
        }
        QTableWidget {
            background-color: #202020;
            border: 1px solid #404040;
        }
        QHeaderView::section {
            background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
                stop:0 #404040, stop:1 #202020);
            color: #FFFFFF;
        }
    """)

Pas de qtdarkstyle, pas de moteur de theme externe. Tu écris tes 2 stylesheets, tu les switches au clic. C'est de la CSS Qt, point.

Tkinter a ttk.Style().theme_use(...), mais ca couvre que les widgets ttk et pas les widgets tk classiques. Pour un vrai dark mode en Tk il faut une lib tierce comme customtkinter ou sv-ttk. Avec PyQt5, c'est intégré via QSS.

*Mode sombre acti