Pourquoi utiliser Python dans Grist ?

Grist est déjà puissant avec ses formules standards, mais Python le propulse vers de nouveaux sommets. Que vous soyez débutant ou développeur confirmé, Python dans Grist vous permet de créer des automatisations complexes, des calculs avancés et des visualisations personnalisées.

Les avantages de Python dans Grist

  • Puissance de calcul : Accédez à des bibliothèques mathématiques et statistiques avancées
  • Flexibilité totale : Écrivez des logiques conditionnelles complexes impossibles avec les formules standards
  • Widgets personnalisés : Créez des visualisations sur mesure pour vos données
  • Intégrations : Connectez Grist à des API externes et des services tiers
  • Automatisations : Déclenchez des actions basées sur des conditions précises

Où écrire du code Python dans Grist ?

Dans Grist, vous pouvez utiliser Python à deux endroits principaux :

1. Les colonnes calculées

Les colonnes calculées vous permettent de créer des formules Python qui s'exécutent automatiquement pour chaque ligne. Parfait pour :

  • Calculer des valeurs dérivées
  • Formater des données
  • Créer des logiques conditionnelles
  • Manipuler des dates et du texte

2. Les widgets personnalisés

Les widgets personnalisés offrent encore plus de possibilités :

  • Créer des visualisations avancées
  • Afficher des données agrégées
  • Intégrer des composants interactifs
  • Connecter des API externes

Les bases de Python dans Grist

Syntaxe de base

Dans une colonne calculée, vous accédez aux valeurs d'autres colonnes directement par leur nom :

# Exemple simple : concaténer prénom et nom
$Prenom + " " + $Nom

# Calculer un âge à partir d'une date de naissance
from datetime import date
aujourd_hui = date.today()
age = aujourd_hui.year - $Date_de_naissance.year
if (aujourd_hui.month, aujourd_hui.day) < ($Date_de_naissance.month, $Date_de_naissance.day):
    age -= 1
return age

Fonctions disponibles

Grist met à votre disposition plusieurs fonctions utiles :

  • lookupRecords() : Rechercher des enregistrements dans une autre table
  • rec : Accéder à l'enregistrement courant
  • table : Accéder à la table courante
  • user : Informations sur l'utilisateur connecté

Colonnes calculées avec Python : Exemples pratiques

Exemple 1 : Calculer un statut basé sur une date

from datetime import datetime, timedelta

if $Date_echeance:
    jours_restants = ($Date_echeance - datetime.now()).days
    if jours_restants < 0:
        return "En retard"
    elif jours_restants <= 7:
        return "Urgent"
    else:
        return "À jour"
return "Non défini"

Exemple 2 : Formater un montant avec devise

if $Montant:
    return f"{$Montant:,.2f} €".replace(",", " ")
return "—"

Exemple 3 : Compter les jours ouvrés

from datetime import timedelta

def compter_jours_ouvres(debut, fin):
    jours = 0
    date_actuelle = debut
    while date_actuelle <= fin:
        if date_actuelle.weekday() < 5:  # 0-4 = Lundi-Vendredi
            jours += 1
        date_actuelle += timedelta(days=1)
    return jours

if $Date_debut and $Date_fin:
    return compter_jours_ouvres($Date_debut, $Date_fin)
return None

Créer des widgets personnalisés avec Python

Structure d'un widget personnalisé

Un widget personnalisé est un mini-programme Python qui s'exécute dans Grist. Voici la structure de base :

from grist import Widget

class MonWidget(Widget):
    def __init__(self):
        super().__init__()
    
    def render(self):
        # Votre code ici
        data = self.get_data()
        return f"Données : {len(data)} lignes"

Exemple : Widget de statistiques

from grist import Widget
import statistics

class StatsWidget(Widget):
    def render(self):
        valeurs = [r.Montant for r in self.get_data() if r.Montant]
        
        if not valeurs:
            return "Aucune donnée"
        
        moyenne = statistics.mean(valeurs)
        mediane = statistics.median(valeurs)
        total = sum(valeurs)
        
        return f"""
        
            Statistiques
            Total : {total:,.2f} €
            Moyenne : {moyenne:,.2f} €
            Médiane : {mediane:,.2f} €
            Nombre : {len(valeurs)}
        
        """

Fonctions avancées

Accéder à l'API REST depuis Python

Vous pouvez interagir avec l'API Grist directement depuis vos widgets :

import requests

API_KEY = "votre_cle_api"
DOC_ID = "votre_document_id"

def ajouter_ligne(table, donnees):
    url = f"https://docs.getgrist.com/api/docs/{DOC_ID}/tables/{table}/records"
    headers = {"Authorization": f"Bearer {API_KEY}"}
    response = requests.post(url, headers=headers, json={"records": [{"fields": donnees}]})
    return response.json()

Interactions entre tables

# Récupérer des données d'une table liée
clients = lookupRecords(Clients, id=$Client_ID)
if clients:
    client = clients[0]
    return f"{client.Nom} - {client.Email}"
return "Client non trouvé"

Bibliothèque de snippets Python pour Grist

Manipulation de dates

# Ajouter des jours ouvrés
from datetime import timedelta

def ajouter_jours_ouvres(date_debut, nb_jours):
    date_actuelle = date_debut
    jours_ajoutes = 0
    while jours_ajoutes < nb_jours:
        date_actuelle += timedelta(days=1)
        if date_actuelle.weekday() < 5:
            jours_ajoutes += 1
    return date_actuelle

# Calculer le trimestre
if $Date:
    return ($Date.month - 1) // 3 + 1
return None

Manipulation de texte

# Extraire les initiales
if $Nom:
    mots = $Nom.split()
    initiales = "".join([m[0].upper() for m in mots if m])
    return initiales
return ""

# Générer un slug
if $Titre:
    return $Titre.lower().replace(" ", "-").replace("'", "")
return ""

Calculs financiers

# Calculer un TTC
if $Montant_HT and $Taux_TVA:
    return $Montant_HT * (1 + $Taux_TVA / 100)
return None

# Calculer un prorata
from datetime import date

def prorata_mois(date_debut, date_fin, montant_total):
    if not date_debut or not date_fin:
        return None
    jours_total = (date_fin - date_debut).days + 1
    jours_mois = min(jours_total, 30)  # Base 30 jours
    return (montant_total / 30) * jours_mois

Ressources complémentaires

Pour aller plus loin dans votre maîtrise de Python dans Grist :

Articles de la série Python

Documentation officielle

Besoin d'aide pour votre projet Python dans Grist ?

La création de widgets personnalisés et l'automatisation avancée demandent une expertise technique. En tant qu'expert Grist certifié, je peux vous accompagner sur :

  • Le développement de widgets sur mesure
  • L'intégration d'API externes
  • L'automatisation de vos processus métier
  • La formation de vos équipes

Découvrir mes prestations →

FAQ Python dans Grist

Faut-il savoir programmer pour utiliser Python dans Grist ?

Non ! Les bases sont accessibles à tous. Ce guide vous accompagne depuis les premiers pas jusqu'aux fonctions avancées.

Quelle version de Python utilise Grist ?

Grist utilise Python 3. La plupart des bibliothèques standard sont disponibles.

Peut-on importer des bibliothèques externes ?

Dans les widgets personnalisés, oui (avec certaines limitations). En colonnes calculées, vous êtes limité aux bibliothèques intégrées.

Les formules Python sont-elles rétroactives ?

Oui ! Lorsque vous modifiez une formule, elle s'applique automatiquement à toutes les lignes existantes.