OpenAI Codex : 6 Exemples Concrets de Code (Python & JS) et Analyse de Fiabilité

Exemples concrets de code généré par OpenAI Codex (Python et JavaScript) et ce qu’il faut vérifier

OpenAI Codex a révolutionné la manière dont nous concevons le "boilerplate" et les scripts utilitaires. Cependant, passer de la génération à la production demande une lecture critique. Voici six cas d'usage typiques analysés sous l'angle de la fiabilité.

Exemple 1 — Python : parser un fichier CSV et normaliser des champs

Cas d’usage courant : ingestion d’un CSV “sale”, puis export normalisé. Codex est performant pour générer une logique lisible, mais attention aux hypothèses sur les formats de date.

import csv
import re
from datetime import datetime

DATE_FORMATS = ("%Y-%m-%d", "%d/%m/%Y", "%d-%m-%Y", "%Y/%m/%d")

def parse_date_to_iso(value: str) -> str:
    if not value: return ""
    value = value.strip()
    for fmt in DATE_FORMATS:
        try:
            return datetime.strptime(value, fmt).date().isoformat()
        except ValueError:
            pass
    return value

def normalize_phone(value: str) -> str:
    if not value: return ""
    digits = re.sub(r"\D+", "", value)
    if len(digits) == 10 and digits.startswith("0"):
        return "+33" + digits[1:]
    return value.strip()

def transform_csv(input_path: str, output_path: str) -> None:
    with open(input_path, "r", encoding="utf-8", newline="") as f_in:
        reader = csv.DictReader(f_in)
        fieldnames = reader.fieldnames or []
        if "date_iso" not in fieldnames: fieldnames.append("date_iso")
        
        with open(output_path, "w", encoding="utf-8", newline="") as f_out:
            writer = csv.DictWriter(f_out, fieldnames=fieldnames)
            writer.writeheader()
            for row in reader:
                row["date_iso"] = parse_date_to_iso(row.get("date", ""))
                writer.writerow(row)

Fiabilité : Bonne pour un pipeline standard. À corriger : La gestion des encodages non UTF-8 et les ambiguïtés de dates (ex: 01/02 peut être Janvier ou Février selon la locale).

Exemple 2 — JavaScript (Node.js) : endpoint Express avec validation

import express from "express";
const app = express();

function parseSort(sort) {
    const allowedFields = new Set(["createdAt", "email", "name"]);
    const [field, dir] = String(sort || "").split(":");
    const direction = (dir || "asc").toLowerCase() === "desc" ? "desc" : "asc";
    if (!allowedFields.has(field)) return { field: "createdAt", direction: "desc" };
    return { field, direction };
}

app.get("/users", async (req, res) => {
    const page = parseInt(req.query.page) || 1;
    const limit = Math.min(parseInt(req.query.limit) || 20, 100);
    const { field, direction } = parseSort(req.query.sort);
    
    // Logique de tri et pagination...
    res.json({ page, limit, items: [] });
});

Fiabilité : Très bonne pour "scaffolder". À corriger : Codex peut oublier les listes blanches (whitelist) pour le tri, ce qui expose à des erreurs SQL ou des fuites de données si le champ injecté est sensible.

Exemple 3 — Python : déduplication “fuzzy” (similarité Levenshtein)

Codex peut générer un dédoublonnage approximatif. Utile, mais attention à la performance sur gros volumes.

from difflib import SequenceMatcher

def similarity(a: str, b: str) -> float:
    return SequenceMatcher(None, a.lower().strip(), b.lower().strip()).ratio()

def dedupe_fuzzy(values, threshold=0.9):
    groups = []
    for v in values:
        placed = False
        for g in groups:
            if similarity(v, g[0]) >= threshold:
                g.append(v)
                placed = True
                break
        if not placed: groups.append([v])
    return groups

Fiabilité : Correcte pour un POC. À corriger : Complexité O(n²). Pour des listes de >1000 items, une stratégie d'indexation (blocking) est indispensable.

Exemple 4 — JavaScript : script de migration JSON

import fs from "node:fs/promises";

function migrateUser(u) {
    const out = { ...u };
    if (out.fullName && !out.name) out.name = out.fullName;
    delete out.fullName;
    return out;
}

async function run(inputPath, outputPath) {
    const data = JSON.parse(await fs.readFile(inputPath, "utf-8"));
    const migrated = data.map(migrateUser);
    await fs.writeFile(outputPath, JSON.stringify(migrated, null, 2));
}

Fiabilité : Excellente sur le transformationnel pur. Attention : Codex invente parfois des règles métier si la consigne est floue.

Exemple 5 — Python : client HTTP robuste (Retries & Backoff)

import time
import requests

class ApiClient:
    def _request(self, method, path, *, retries=3, backoff=0.5, **kwargs):
        for attempt in range(retries + 1):
            try:
                resp = self.session.request(method, url, timeout=10, **kwargs)
                if resp.status_code == 429 and attempt < retries:
                    time.sleep(backoff * (2 ** attempt))
                    continue
                return resp.json()
            except requests.RequestException:
                if attempt >= retries: raise
                time.sleep(backoff * (2 ** attempt))

Fiabilité : Bonne. À corriger : Ne pas faire de retry automatique sur des méthodes non idempotentes (POST de paiement par exemple) sans vérifier l'état côté serveur.

Exemple 6 — JavaScript : utilitaire de “safe access” (nullish coalescing)

// Piège fréquent : || vs ??
export function getOr(obj, path, defaultValue) {
    const parts = path.split(".");
    let cur = obj;
    for (const p of parts) {
        if (cur == null) return defaultValue;
        cur = cur[p];
    }
    return cur ?? defaultValue; // Préférer ?? pour garder 0 ou ""
}

Comparaison des forces de Codex par type de tâche

Fiabilité réelle : comment “s’y fier” en production ?

Codex excelle dans la production de code standardisé. La fiabilité est élevée tant que la spécification est explicite. En revanche, dès qu'il s'agit de sécurité (auth, permissions) ou de performances extrêmes, il doit être considéré comme un développeur junior : brillant pour la syntaxe, mais nécessitant une revue de code rigoureuse pour les cas limites.