Pour refuser les clés dupliquées d’un JSON en Python, contrôlez les paires pendant le décodage avec object_pairs_hook. Après un simple json.loads, un dictionnaire peut déjà avoir remplacé une valeur par la suivante. Un schéma appliqué ensuite ne retrouvera pas l’information disparue. Vérifiez aussi les nombres non finis et la taille de l’entrée avant de transmettre l’objet au reste du workflow.
Je pars d’une fiche entièrement fictive destinée à préparer un affichage : un repère de lot, un seuil et une liste de mesures. Elle ne déclenche aucune opération. Le problème apparaît quand deux composants prétendent lire la même fiche, alors que leur façon d’interpréter un nom répété peut donner des résultats différents.
Réponse en bref
Recevez des octets, imposez une enveloppe courte, décodez en UTF-8 et construisez chaque objet à partir de paires dont les noms sont uniques. Refusez séparément NaN, les deux infinis et les nombres dont la conversion en flottant produit un infini. Passez seulement l’objet accepté à la validation de schéma, puis aux règles métier.
Votre prochaine action : exécutez le code ci-dessous avec une clé répétée au premier niveau, une autre dans un objet imbriqué et une troisième écrite avec un échappement. Les trois entrées doivent être refusées, sans en supprimer une partie pour les faire passer. Ajoutez ensuite ces cas à l’endroit exact où votre application reçoit encore le texte original.
Le seuil qui change avant même la validation
Imaginons cette entrée fictive :
{"lot":"demo-cobalt","seuil":12,"seuil":28}
Un contrôle placé sur le dictionnaire final peut voir un seul champ seuil, contenant un entier admissible. Il pourrait donc approuver la fiche sans savoir que deux propositions figuraient dans le document reçu. Demander au modèle de respecter une seule occurrence ne remplace pas le contrôle à cette frontière.
Choisir systématiquement la première valeur ne résoudrait pas le désaccord : un autre lecteur pourrait garder la dernière. Même deux occurrences égales méritent un refus dans notre profil. Leur égalité actuelle ne justifie pas une convention implicite qui deviendra dangereuse lorsqu’elles différeront.
La correction attendue est une nouvelle fiche à sens unique, produite à la source. Le parseur n’est pas chargé de choisir le seuil supposé correct. Cette séparation est particulièrement utile quand un assistant assemble des éléments issus de plusieurs passages et peut conserver deux versions d’un même champ.
Écrire un profil d’entrée avant de coder
Le standard et le contrat de votre application n’ont pas le même rôle. La RFC 8259 recommande l’unicité des noms dans chaque objet et décrit des comportements divergents lorsqu’ils se répètent. Elle interdit les littéraux numériques NaN et Infinity, tout en laissant les implémentations borner les nombres et les ressources acceptées.
Pour cet exercice, je choisis les conventions suivantes. Les valeurs de plafond sont pédagogiques ; elles doivent être adaptées à la tâche réelle.
| Élément reçu | Convention de l’exercice | Conséquence du refus |
|---|---|---|
| enveloppe | au plus 16 384 octets déjà reçus | demander une entrée plus courte |
| encodage | UTF-8, sans marque initiale BOM | corriger le producteur du document |
| racine | un objet JSON | refuser tableaux et valeurs seules |
| noms | une occurrence par objet après décodage | renvoyer une ambiguïté de structure |
| entiers | au plus 64 chiffres, signe exclu | revoir la représentation attendue |
| décimaux et exposants | écriture de 80 caractères au maximum, résultat fini | refuser la conversion hors profil |
Un tableau à la racine reste possible dans le format JSON. Il est seulement hors de ce contrat. De même, un entier de 65 chiffres ne devient pas une erreur universelle : notre récepteur choisit de ne pas le traiter. Donnez ces conventions au producteur et au consommateur pour qu’une différence de paramétrage soit visible.
Le contrôle de taille intervient ici après la réception des octets, mais avant leur décodage et leur analyse. Une application réseau doit aussi limiter ce qu’elle lit depuis le flux. Charger un fichier immense en mémoire avant d’appeler cette fonction déplacerait simplement le problème en amont.
Installer les contrôles au moment de la conversion
La documentation du module json décrit trois réglages utiles : object_pairs_hook reçoit les paires de chaque objet, parse_constant traite les constantes numériques particulières et parse_float permet de choisir la conversion des nombres comportant une fraction ou un exposant. Le comportement par défaut conserve la dernière occurrence d’un nom répété et accepte certaines constantes extérieures au standard.
Le programme suivant utilise uniquement la bibliothèque standard. Il travaille sur des octets pour rendre la borne d’entrée non ambiguë. Les messages d’erreur restent des codes courts : ils ne recopient ni les clés reçues ni le contenu de la fiche.
import json
import math
MAX_BYTES = 16_384
MAX_INT_DIGITS = 64
MAX_FLOAT_CHARS = 80
class RefusJSON(ValueError):
pass
def objet_sans_doublon(paires):
resultat = {}
for nom, valeur in paires:
if nom in resultat:
raise RefusJSON("cle_repetee")
resultat[nom] = valeur
return resultat
def constante_refusee(texte):
raise RefusJSON("constante_non_finie")
def entier_borne(texte):
if len(texte.lstrip("-")) > MAX_INT_DIGITS:
raise RefusJSON("entier_trop_long")
return int(texte)
def flottant_fini(texte):
if len(texte) > MAX_FLOAT_CHARS:
raise RefusJSON("nombre_trop_long")
valeur = float(texte)
if not math.isfinite(valeur):
raise RefusJSON("flottant_non_fini")
return valeur
def lire_fiche(brut):
if type(brut) is not bytes:
raise RefusJSON("octets_requis")
if len(brut) > MAX_BYTES:
raise RefusJSON("taille")
try:
texte = brut.decode("utf-8", errors="strict")
except UnicodeDecodeError:
raise RefusJSON("encodage") from None
try:
fiche = json.loads(
texte,
object_pairs_hook=objet_sans_doublon,
parse_constant=constante_refusee,
parse_int=entier_borne,
parse_float=flottant_fini,
)
except json.JSONDecodeError:
raise RefusJSON("syntaxe") from None
except RecursionError:
raise RefusJSON("imbrication") from None
if type(fiche) is not dict:
raise RefusJSON("objet_racine_requis")
return fiche
assert lire_fiche(b'{"lot":"demo-cobalt","seuil":12.5}') == {
"lot": "demo-cobalt", "seuil": 12.5
}
for brut, attendu in [
(b'{"seuil":12,"seuil":28}', "cle_repetee"),
(b'{"x":{"seuil":12,"seuil":12}}', "cle_repetee"),
(b'{"seuil":12,"s\\u0065uil":28}', "cle_repetee"),
(b'{"seuil":NaN}', "constante_non_finie"),
(b'{"seuil":1e400}', "flottant_non_fini"),
(b'[]', "objet_racine_requis"),
]:
try:
lire_fiche(brut)
except RefusJSON as erreur:
assert str(erreur) == attendu
else:
raise AssertionError("Une fiche aurait dû être refusée")
print("Contrôles de démonstration : OK")
Copiez ce bloc dans un fichier local vide et exécutez-le avec Python. Sur CPython 3.14.3, il affiche le message final après les assertions. La documentation consultée pour la branche 3.14 affiche la version 3.14.10 : version du manuel et version exécutée sont donc deux repères différents.
Vérifier ce que signifie le réglage « strict »
Le nom strict peut prêter à confusion. Dans JSONDecoder, il concerne l’admission de caractères de contrôle dans les chaînes. Laisser sa valeur par défaut ne décide donc pas de notre politique sur les noms répétés ou les nombres non finis. Les fonctions explicites du programme rendent ces décisions vérifiables.
Évitez de nommer le résultat json_totalement_sur ou donnees_fiables. Un nom comme fiche_decodee décrit mieux ce qui vient de se passer. Une chaîne contenue dans cette fiche peut toujours comporter une instruction trompeuse, un lien indésirable ou une information fausse. Son analyse syntaxique ne lui donne aucun droit supplémentaire.
Pour la même raison, gardez une frontière d’interface claire : la fonction reçoit des octets et retourne un objet ou un refus. Elle ne lit aucun fichier, n’appelle aucun modèle et ne modifie aucun système. Vous pouvez ainsi contrôler son comportement séparément des effets que l’application autorisera plus tard.
Comprendre ce que révèle la liste de paires
L’unicité s’applique à chaque objet, pas au document entier. Une fiche contenant deux mesures, chacune avec sa propriété valeur, est parfaitement compatible avec notre profil. En revanche, une mesure qui déclare deux fois valeur est refusée, même si les autres éléments sont corrects.
La portée locale vient de la création d’un nouveau dictionnaire à chaque appel de objet_sans_doublon. Ne déplacez pas l’ensemble des noms déjà vus dans une variable globale. Vous refuseriez alors des structures normales et risqueriez de mélanger les entrées de plusieurs traitements.
Les échappements sont interprétés avant le contrôle des noms. Dans l’exemple du programme, s\u0065uil désigne le même nom que seuil. Une recherche textuelle naïve des occurrences de "seuil" manquerait cette répétition. Elle se tromperait aussi sur un mot placé dans une simple valeur textuelle.
Le code du décodeur CPython permet de suivre cette étape : les chaînes des noms sont lues, les paires sont réunies, puis le traitement personnalisé peut remplacer la construction ordinaire. Un traitement sur le dictionnaire déjà construit arrive plus tard dans ce parcours.
Deux noms qui paraissent identiques à l’œil ne sont pas nécessairement la même chaîne. Notre fonction compare leur valeur Python sans normalisation supplémentaire. Si votre application prévoit de modifier ensuite leur casse ou leur forme Unicode, le contrôle des collisions d’identifiants intervient à cette autre frontière.
Séparer constante interdite et dépassement de représentation
NaN et 1e400 ne suivent pas le même chemin. Le premier est une constante reconnue par l’extension du décodeur. Le second possède une écriture numérique JSON ordinaire, mais sa conversion en flottant dépasse la plage disponible dans l’environnement de démonstration. Interdire seulement les constantes laisse donc passer cette deuxième famille.
Le contrôle math.isfinite répond à une question limitée : le résultat est-il différent de l’infini et de NaN ? Il ne garantit pas que la conversion préserve toutes les décimales. C’est pourquoi le profil indique explicitement un résultat flottant, et non une mesure exacte.
Par exemple, notre fonction accepte 1e-400 et produit 0.0 sur l’environnement testé. Le résultat est fini, mais la valeur mathématique non nulle a été perdue. Ce cas est volontairement présent dans le banc de vérification pour empêcher de confondre finitude et fidélité numérique. Si cette distinction change la décision métier, ce profil ne convient pas.
Pour des montants, des identifiants numériques longs ou des mesures très petites, choisissez une représentation appropriée avant d’adapter le code. Le guide sur les calculs monétaires et les arrondis traite notamment la conservation d’une saisie décimale. Ajouter une tolérance après une conversion destructrice ne reconstitue pas automatiquement l’information initiale.
Construire un banc qui résiste aux faux positifs
Préparez une table de décisions attendues avant de lancer les variantes. Chaque refus doit correspondre à une règle précise. Un programme qui rejette toutes les fiches ne réussit pas l’exercice ; il doit aussi préserver les objets admissibles et leurs types.
| Variante du support fictif | Verdict attendu | Point observé |
|---|---|---|
deux objets distincts avec un nom valeur chacun | accepté | portée locale de l’unicité |
| nom répété avec deux nombres différents | refus cle_repetee | ambiguïté visible |
| nom répété avec la même valeur | refus cle_repetee | règle indépendante du contenu |
| répétition dans une liste de mesures | refus cle_repetee | objets imbriqués contrôlés |
| nom répété à travers un échappement | refus cle_repetee | comparaison après décodage |
| mot « seuil » dans une valeur textuelle | accepté | pas de recherche lexicale approximative |
Infinity ou -Infinity | refus constante_non_finie | extensions exclues |
| exposant positif trop grand | refus flottant_non_fini | résultat de conversion contrôlé |
| entier de 64 puis 65 chiffres | accepté puis refus | frontière numérique choisie |
| objet complété d’espaces à 16 384 puis 16 385 octets | accepté puis refus | frontière d’enveloppe exacte |
Complétez ce tableau par un UTF-8 invalide, une BOM initiale, une virgule finale et deux objets successifs. Aucun de ces documents ne doit être réparé automatiquement. Un json.loads attend un document complet ; traiter la première partie puis ignorer la fin changerait notre contrat sans l’annoncer.
Pour vérifier le contrôle des doublons indépendamment de son message d’erreur, lisez une fixture avec object_pairs_hook=list dans un petit programme de diagnostic. Vous pourrez voir les deux paires sans appliquer notre fonction. Cette observation ne doit pas devenir le chemin de production : elle sert seulement à confirmer que le défaut construit existe réellement.
Rendre un refus exploitable sans transformer la fiche
Un rejet doit arrêter la transmission vers le consommateur. Évitez de capturer toute exception pour retourner un dictionnaire vide : ce résultat ressemble à une fiche réellement vide et peut prendre une valeur métier inattendue. Conservez un état de refus distinct de l’objet accepté.
N’enlevez pas non plus les champs répétés à l’aide d’une nouvelle génération. L’assistant pourrait choisir une occurrence, fusionner des informations ou ajouter une justification. Si une correction est utile, elle produit une nouvelle entrée qui reprend tout le parcours et dont l’origine reste identifiable dans votre application.
Le code d’erreur peut orienter la réponse : réduire le document après taille, corriger l’encodage après encodage, ou faire clarifier la fiche après cle_repetee. Il ne désigne pas nécessairement un défaut unique. Un document peut cumuler plusieurs problèmes ; le premier rencontré dépend de l’étape où la lecture s’arrête.
Gardez également les journaux sobres. Le repère du traitement, la taille et le code de refus suffisent souvent à compter les incidents. Le diagnostic détaillé doit suivre les règles d’accès de votre système. Copier toute la réponse dans un message destiné à l’utilisateur peut divulguer bien davantage que l’erreur à résoudre.
Transmettre seulement ensuite au contrat métier
Après lire_fiche, il reste à décider si seuil est obligatoire, si une valeur négative est permise et si lot appartient au dossier attendu. La fonction accepte par exemple un objet vide et une propriété inconnue. Ces choix doivent être traités au niveau suivant.
Le parcours sur les sorties structurées et JSON Schema aide à définir ces propriétés. Le présent contrôle se place avant cette validation, tant que les paires originales sont accessibles. Les deux étapes peuvent avoir des erreurs séparées pour que l’on sache s’il faut corriger le document ou revoir sa conformité au contrat.
Dans un projet d’automatisation IA et Python, localisez donc la première conversion en dictionnaire. Une bibliothèque intermédiaire peut l’avoir déjà effectuée avant votre propre code. Ajouter le contrôle uniquement à la dernière fonction ne protège pas une frontière dont le texte brut a disparu.
Limites
Cette fonction définit un profil pour de petits objets et des nombres flottants finis. Elle ne vérifie ni le schéma ni les faits du document. Elle n’applique pas de politique complète aux séquences Unicode échappées, et ne constitue pas un validateur exhaustif de toutes les exigences d’interopérabilité JSON.
La borne en octets ne plafonne pas à elle seule le temps processeur, l’allocation totale ou la profondeur avant analyse. L’interception d’une RecursionError donne un refus lisible, sans remplacer une limite d’imbrication en amont ni l’isolation d’un traitement exposé à des entrées hostiles. Le seuil d’erreur dépend de l’interpréteur et de son contexte.
La conversion flottante peut arrondir ou produire zéro pour une valeur trop petite. Les grands entiers acceptés peuvent aussi dépasser la précision du logiciel suivant. Si ces pertes changent votre décision, revoyez la représentation et testez le destinataire réel avant d’utiliser ce profil.
Historique des mises à jour
- 2 novembre 2026 : publication du parseur, des cas de refus et des frontières de taille, avec distinction entre valeur finie et valeur exacte.
Sources vérifiées
- json : JSON encoder and decoder, Python 3.14 , consultée le 2 novembre 2026
- RFC 8259 : The JavaScript Object Notation Data Interchange Format , consultée le 2 novembre 2026
- CPython 3.14 : Lib/json/decoder.py , consultée le 2 novembre 2026
- math.isfinite, Python 3.14 , consultée le 2 novembre 2026