gestion_donnees.py

   1 #!/usr/bin/env python3
   2 # -*- coding: utf-8 -*-
   3
   4 from configuration import CONFIG,DEFAUT
   5 from gestion_erreurs import debug, warning, erreur, initialise_erreurs
   6 from gestion_couleurs import rgb_vers_tuple, tuple_vers_rgb
   7 from gestion_unites import choix_unite
   8 import datetime
   9 import json
  10 import unidecode
  11 import copy
  12
  13 ### Les données "tournent" selon :
  14 ### python -> json -> (export/import) -> formulaire HTML -> données POST -> python etc
  15
  16 ############ Fonctions de conversion
  17
  18 def convertit_jours_vers_python(chaine,liste_err):
  19     """ convertit une chaine de type 1a 3m 1s 10j en jours
  20     Renvoie un nombre de jours en float
  21     Si un des caractères n'est ni un nombre, ni une lettre "autorisée" ni une espace,
  22     on affiche un warning et on ignore ce caractère
  23     """
  24 #    debug("conversion de "+chaine+" vers un nb de jours",liste_err)
  25     chainenombre = ""
  26     agejours = 0.
  27     for lettre in chaine:
  28         if lettre.isdigit():
  29             chainenombre += lettre
  30         else:
  31             if lettre == 'a' or lettre == 'A':
  32                 # On a trouvé l'année, on ajoute tout ce qui est trouvé jusque là
  33                 agejours += int(chainenombre)*CONFIG["jours_dans_annee"]
  34                 chainenombre = ""
  35             elif lettre == 'm' or lettre == 'M':
  36                 # On a trouvé le mois
  37                 agejours += int(chainenombre)*CONFIG["jours_dans_mois"]
  38                 chainenombre = ""
  39             elif lettre == 's' or lettre == 'S':
  40                 # la semaine
  41                 agejours += int(chainenombre)*CONFIG["jours_dans_semaine"]
  42                 chainenombre = ""
  43             elif lettre == 'j' or lettre == 'J':
  44                 # On a trouvé le jour
  45                 agejours += int(chainenombre)
  46                 chainenombre = ""
  47             elif lettre != ' ':
  48                 # autre caractère : bizarre ?
  49                 warning("problème à la conversion de "+chaine+". Caractère invalide : "+lettre,liste_err)
  50     # à la fin s'il reste qqch on le garde dans les jours
  51     if chainenombre != "":
  52         agejours += int(chainenombre)
  53     if agejours<0:
  54         warning("L'âge est négatif !",liste_err)
  55         agejours = 0
  56 #    debug("On a convertit ! Résultat : "+str(agejours),liste_err)
  57     return agejours
  58
  59 # python -> json
  60 def convertit_age_vers_texte(nombre):
  61     """ convertit un nombre de jours en un truc plus lisible en mois, années, jours
  62     et renvoie une chaîne sous la forme 3a2m1j par exemple"""
  63     annees = int(nombre / CONFIG["jours_dans_annee"])
  64     restant = nombre - annees*CONFIG["jours_dans_annee"]
  65     mois = int(restant/CONFIG["jours_dans_mois"])
  66     jours= round(nombre - mois*CONFIG["jours_dans_mois"] - annees*CONFIG["jours_dans_annee"])
  67
  68     chaine = ""
  69     if annees >0:
  70         chaine += str(annees)+"a"
  71     if mois >0:
  72         chaine += str(mois)+"m"
  73     if jours>0 or  nombre ==0: # si c'est la naissance, faut beien écrire 0j quand même
  74         chaine += str(jours)+"j"
  75     return chaine
  76
  77 ##########################
  78
  79 # fonction qui calcule "auto" le maxi du graphique en fonction du max
  80 def calcule_max_graphique(l_jours):
  81     """ calcule l'age maxi sur le graphique"""
  82     if l_jours == []:
  83         return CONFIG["jours_defaut_donneesvides"]
  84     else:
  85         jour_maxi = max(l_jours)# pas la peine d'aller très au delà du jour max
  86         jour_maxi = int(jour_maxi* 1.2)+3 # on rajoute un peu
  87         return jour_maxi
  88
  89
  90 def simplifie_nom(chaine):
  91     """ simplifie le nom chaine afin d'en faire une extension
  92     pour le nom du fichier. Met tout en minuscules et vire les caractères spéciaux
  93     et max 15 caractères"""
  94     chaine2 = ""
  95     for l in chaine:
  96         if l.isalpha():
  97             chaine2+=l
  98     chaine2 =  unidecode.unidecode(chaine2)
  99     return chaine2[:15]
 100
 101 def convertit_donnee_vers_python(chaine,typedonnee,liste_err):
 102     """ convertit une chaine vers un float qui est le type donnee voulu.
 103     La virgule peut être . ou , et on vire d'éventuels espaces.
 104     Taille invalide : on renvoie 0 avec un warning.
 105     Si la chaine est en fait déjà au format float, on laisse tel quel"""
 106     if type(chaine) == float:
 107         return chaine
 108     chaine2 = chaine.replace(",",".")
 109     chaine2 = chaine2.replace(" ","")
 110
 111
 112     try:
 113         donnee = float(chaine2)
 114     except:
 115         warning(typedonnee+" impossible à lire : "+chaine,liste_err)
 116         donnee = 0
 117
 118     # Pour le poids, un cas particulier
 119     if typedonnee == "poids" and donnee > CONFIG["poids_maxi_conversion"]:
 120         donnee = donnee/1000 # conversion en grammes
 121     if not( 0<=donnee<CONFIG[typedonnee+"_maxi"]):
 122         warning(typedonnee+" incohérent(e) : "+str(donnee),liste_err)
 123         donnee = 0
 124     return donnee
 125
 126
 127 #########################
 128
 129 # web -> python
 130 def convertit_date_vers_python(chaine,liste_err):
 131     """ prend une chaine comme renvoyée par un champ de formulaire date
 132     aaaa-mm-jj et en fait une date python
 133     renvoie "" si ne marche pas.
 134     Si jamais la date est au format avec des / ça devrait passer aussi."""
 135     if "/" in chaine:
 136         liste = chaine.split("/")
 137     else:
 138         liste = chaine.split("-")
 139     if len(liste) != 3:
 140         warning("La date : "+chaine+" est invalide !",liste_err)
 141         return ""
 142     else:
 143         debug("Conversion de la date "+chaine+". Découpage : "+str(liste),liste_err)
 144         try:
 145             date = datetime.date(int(liste[0]),int(liste[1]),int(liste[2]))
 146         except:
 147             date = ""
 148             warning("Impossible de lire la date "+chaine+". Format accepté : aaaa-mm-jj",liste_err)
 149         return date
 150
 151 # python -> json
 152 def convertit_date_vers_texte(date):
 153     """ convertit une date python en format texte aaaa-mm-jj"""
 154     if date == "":
 155         return ""
 156     else:
 157         #return (str(date.year)+"-"+str(date.month)+"-"+str(date.day))
 158         return str(date)
 159
 160 def delta_date(date1,datenaissance):
 161     """ renvoie le nombre de jours (entier) entre date1 et datenaissance format "datetime"
 162     datenaissance est supposée antérieure. Erreur sinon."""
 163     d = date1 - datenaissance
 164     jours = d.days
 165     if jours<0:
 166         warning("La différence entre les dates est négative... :/")
 167         return -1
 168     return jours
 169
 170
 171
 172 ################### On regroupe tout ce qui gère les données en une fonction
 173
 174 def web_vers_python(data,liste_err, court=False):
 175     """ prend en argument le dictionnaire de requête et renvoie la config, et les
 176     tableaux de données
 177     court : si True est précisé, on ne met que le nom dans la config (enfant
 178     additionnel)"""
 179
 180     # Régler la configuration
 181     config = gere_configuration(data,liste_err, court)
 182
 183     # récupérer les données
 184     listes_jours = {}
 185     listes_donnees = {}
 186     for typed in CONFIG["liste_typedonnees"]:
 187         listes_jours[typed],listes_donnees[typed] = gere_donnees(data,config["naissance"],typed,liste_err)
 188
 189     # Si on veut extrapoler au-delà du jour maxi, on adapte
 190
 191     # Si on a choisi la même échelle de données
 192     if config.get("memechelle") == "oui":
 193         config["non_sauve"]["maxi"] = calcule_max_graphique([j for lj in listes_jours.values() for j in lj])
 194         # En cas d'extrapolation, on prend le maxi
 195         if config["non_sauve"]["calculextradata_type"] !="" and config["non_sauve"]["calculextradata_age"]>config["non_sauve"]["maxi"]:
 196             config["non_sauve"]["maxi"] = int(config["non_sauve"]["calculextradata_age"]) +1
 197         config["non_sauve"]["unite"] = choix_unite(config["non_sauve"]["maxi"])
 198
 199     return (config,listes_jours,listes_donnees)
 200
 201
 202
 203 ########### Fonctions qui gèretn les données web vers python
 204
 205 def gere_checkbox(chaine):
 206     """ prend en arg une chaine, et renvoie "oui" si c'est "on" (sortie de la checkbox)
 207     et chaîne vide si n'importe quoi d'autre"""
 208     if chaine == "on":
 209         return "oui"
 210     else:
 211         return ""
 212
 213 def gere_symbole(chaine):
 214     """ prend en arg une chaîne genre "o", ">" et vérifie si c'est un symbole valide.
 215     Renvoie ce symbole-là ou le défaut"""
 216     if chaine in CONFIG["liste_symboles"]:
 217         return chaine
 218     else:
 219         return DEFAUT["symbole"]
 220
 221 def gere_configuration(data,liste_err, court=False):
 222     """ prend en argument le dictionnaire de requête (configuration imparfaite), et
 223     construit le dictionnaire de configuration qui va bien.
 224     Vérifie que chaque entrée est cohérente évidemment.
 225     court : si mis à True, on ne met que le nom dans la configuraion,
 226     ainsi que la date de naissance et le sexe"""
 227     # Initialisation
 228     configuration = {"non_sauve": {}}
 229
 230     # Pour le nom, osef qu'il soit vide
 231     nom = data.get("nom","")
 232     # Par contre s'il est trop long on le tronque
 233     configuration["nom"] = nom[:CONFIG["longueur_max_nom_bebe"]]
 234
 235     naissance = data.get("naissance","")
 236     if naissance !="":
 237         naissance = convertit_date_vers_python(naissance,liste_err)
 238     configuration["naissance"] = naissance
 239
 240     sexe = data.get("sexe","")
 241     if not (sexe in ["F","M","N"]):
 242         warning("Le sexe de l'enfant est invalide ! "+sexe,liste_err)
 243         sexe = "N"
 244     configuration["sexe"] = sexe
 245
 246     if not(court):
 247
 248         prematurite = data.get("prematurite","")
 249         j = convertit_jours_vers_python(prematurite,liste_err)
 250         configuration["prematurite"] = convertit_age_vers_texte(j)
 251
 252         configuration["agecorrige"] = gere_checkbox(data.get("agecorrige",""))
 253
 254         # Type de courbe. Au pire on met P
 255         tyc = data.get("typecourbe","")
 256         if not (tyc in ["P","Z"]):
 257             tyc = "P"
 258         configuration["typecourbe"] = tyc
 259
 260         # unité
 261         unite = data.get("unite","")
 262         if not (unite in CONFIG["liste_unites"]):
 263             unite = ""
 264             #warning("L'unité "+unite+" n'est pas reconnue !",liste_err)
 265         configuration["unite"] = unite
 266
 267         # grille
 268         configuration["grille"] = gere_checkbox(data.get("grille",""))
 269
 270         # tracer ou non les courbes vides
 271         configuration["tracevide"] = gere_checkbox(data.get("tracevide",""))
 272
 273         # Même échelle sur tous les graphiques
 274         configuration["memechelle"] = gere_checkbox(data.get("memechelle",""))
 275
 276
 277         # maxi. 0 signifie qu'on veut pas de maxi
 278         maxi = data.get("maxi","")
 279         if maxi == "":
 280             configuration["maxi"] = 0
 281         else:
 282             configuration["maxi"] = int(convertit_jours_vers_python(maxi,liste_err))
 283
 284         # dimensions du graphique
 285         largeur = data.get("largeur","")
 286         if largeur == "":
 287             largeur = DEFAUT["largeur_graphique"]
 288         else:
 289             try:
 290                 largeur = int(largeur)
 291             except:
 292                 warning("La largeur "+largeur+"est invalide !",liste_err)
 293                 largeur = DEFAUT["largeur_graphique"]
 294             if largeur > CONFIG["largeur_graphique_max"]:
 295                 largeur = CONFIG["largeur_graphique_max"]
 296                 warning("Largeur du graphique trop grande !",liste_err)
 297             elif largeur < CONFIG["largeur_graphique_min"]:
 298                 largeur = CONFIG["largeur_graphique_min"]
 299                 warning("Largeur du graphique trop petite !",liste_err)
 300         configuration["largeur"] = largeur
 301
 302         hauteur = data.get("hauteur","")
 303         if hauteur == "":
 304             hauteur = DEFAUT["hauteur_graphique"]
 305         else:
 306             try:
 307                 hauteur = int(hauteur)
 308             except:
 309                 warning("La hauteur "+hauteur+"est invalide !",liste_err)
 310                 hauteur = DEFAUT["hauteur_graphique"]
 311             if hauteur > CONFIG["hauteur_graphique_max"]:
 312                 hauteur = CONFIG["hauteur_graphique_max"]
 313                 warning("Hauteur du graphique trop grande !",liste_err)
 314             elif hauteur < CONFIG["hauteur_graphique_min"]:
 315                 hauteur = CONFIG["hauteur_graphique_min"]
 316                 warning("Hauteur du graphique trop petite !",liste_err)
 317         configuration["hauteur"] = hauteur
 318
 319         # existence et position de la légende
 320         configuration["legende"] = gere_checkbox(data.get("legende",""))
 321
 322         positionlegende = data.get("positionlegende","")
 323         if not(positionlegende in ['upper left','upper right','lower left','lower right']):
 324             positionlegende = "upper left"
 325         configuration["positionlegende"] = positionlegende
 326
 327         configuration["couleurs"] = {}
 328         # gérer les couleurs
 329         for clecouleur in DEFAUT["couleurs"]:
 330             coul = rgb_vers_tuple(data.get("couleur_"+clecouleur,""),DEFAUT["couleurs"].get(clecouleur, ""),liste_err)
 331             configuration["couleurs"][clecouleur] = coul
 332
 333         # symbole
 334         configuration["symbole"] = gere_symbole( data.get("symbole", ""))
 335
 336         configuration["non_sauve"]["grilleamelio"] = gere_checkbox(data.get("grilleamelio",""))
 337
 338
 339         #### La partie extrapolation n'a pas besoin d'être sauvée
 340         configuration["non_sauve"]["prolongercourbes"] = gere_checkbox(data.get("prolongercourbes",""))
 341
 342         # Valeur par défaut : 1
 343         debug(data.get("nbextradata", "aaargh"), liste_err)
 344         nbextradata = data.get("nbextradata",1)
 345         try:
 346             nbextradata = int(nbextradata)
 347         except:
 348             warning("Le nombre de données sur lequel on extrapole est invalide : "+nbextradata, liste_err)
 349             nbextradata = 1
 350         configuration["non_sauve"]["nbextradata"] = nbextradata
 351
 352         if data.get("calculextradata_type","") in CONFIG["liste_typedonnees"]:
 353             configuration["non_sauve"]["calculextradata_type"] = data.get("calculextradata_type","")
 354             configuration["non_sauve"]["calculextradata_age"] = convertit_jours_vers_python(data.get("calculextradata_age","0j"),liste_err)
 355         else:
 356             configuration["non_sauve"]["calculextradata_type"] = ""
 357             # On ne met rien dans l'âge, pas la peine
 358
 359         ctyped = data.get("calculextratemps_type","")
 360         if ctyped in CONFIG["liste_typedonnees"]:
 361             configuration["non_sauve"]["calculextratemps_type"] = ctyped
 362             configuration["non_sauve"]["calculextratemps_val"] = convertit_donnee_vers_python(data.get("calculextratemps_val",""), ctyped, liste_err)
 363         else:
 364             configuration["non_sauve"]["calculextratemps_type"] = ""
 365
 366         # Tracer les calculs sur la grille
 367         configuration["non_sauve"]["calculextradata_trace"] = gere_checkbox(data.get("calculextradata_trace"))
 368         configuration["non_sauve"]["calculextratemps_trace"] = gere_checkbox(data.get("calculextratemps_trace"))
 369
 370
 371     return configuration
 372
 373
 374
 375 ## web vers python : données
 376 def gere_donnees(data,naissance,typedonnee,liste_err):
 377     """ prend en argument le dictionnaire de requête, et la date de
 378     naissance (éventuellement vide), et construit deux listes :
 379     l_jours et l_data correspondantes.
 380     Il faut donner en argument le type de données : voir
 381     CONFIG["liste_typedonnees"]"""
 382     if typedonnee not in CONFIG["liste_typedonnees"]:
 383         warning("gere_donnees : le type de données : "+typedonnee+" est invalide !! Types acceptés : "+str(CONFIG["liste_typedonnees"]),liste_err)
 384         return ([],[])
 385
 386     # On construit une liste de couples d'abord
 387     liste_donnees = []
 388
 389     i = 0
 390     # On va chercher si y'a des données à donnee_i
 391     while "age_"+str(i) in data.keys():
 392         if data.get(typedonnee+"_"+str(i), "") != "": # si la donne de ce type existe
 393             donnee = convertit_donnee_vers_python(data[typedonnee+"_"+str(i)],typedonnee,liste_err)
 394             age = data.get("age_"+str(i),"")
 395             if age !="":
 396                 age = convertit_jours_vers_python(age,liste_err)
 397                 liste_donnees.append((age,donnee))
 398             else:
 399                 date = data.get("date_"+str(i),"")
 400                 datep = convertit_date_vers_python(date,liste_err)
 401                 # on vérifie la date
 402                 if naissance == "":
 403                     warning("La date de naissance n'a pas été précisée. Du coup on ne peut pas calculer l'âge de l'enfant le "+date,liste_err)
 404                 elif datep != "":  # la date est valide et on a une date de naissance
 405                     age = delta_date(datep,naissance)
 406                     liste_donnees.append((age,donnee))
 407         i+=1
 408
 409     # Trier la liste
 410     liste_donnees.sort(key=lambda x : x[0])
 411
 412     # splitter la liste
 413     l_jours = [x[0] for x in liste_donnees]
 414     l_donnee = [x[1] for x in liste_donnees]
 415
 416     return (l_jours,l_donnee)
 417
 418
 419 # python vers Json
 420 #### export vers json
 421
 422 def donnees_vers_json(l_jours,l_poids,l_jourst,l_taille,config):
 423     """ retourne le json à renvoyer"""
 424     gros_dico = copy.deepcopy(config)
 425     gros_dico["version"] = CONFIG["version"]
 426     l_jours2 = [convertit_age_vers_texte(d) for d in l_jours]
 427     l_jourst2 = [convertit_age_vers_texte(d) for d in l_jourst]
 428     gros_dico["data_j"] = l_jours2
 429     gros_dico["data_p"] = l_poids
 430     gros_dico["data_jours_taille"] = l_jourst2
 431     gros_dico["data_taille"] = l_taille
 432     # gérer la date de naissance
 433     if gros_dico.get("naissance","") != "":
 434         gros_dico["naissance"] = convertit_date_vers_texte(gros_dico["naissance"])
 435         # Calcul de toutes les dates de données
 436         l_dates_poids = [convertit_date_vers_texte( config["naissance"] + datetime.timedelta(days=jours) ) for jours in l_jours]
 437         l_dates_taille = [convertit_date_vers_texte( config["naissance"] + datetime.timedelta(days=jours) ) for jours in l_jourst]
 438         gros_dico["data_dates_poids"]= l_dates_poids
 439         gros_dico["data_dates_taille"] = l_dates_taille
 440
 441
 442     # gérer l'age maxi
 443     gros_dico["maxi"] = convertit_age_vers_texte(gros_dico["maxi"])
 444     # gérer les couleurs
 445     for clecouleur in DEFAUT["couleurs"]:
 446         gros_dico["couleurs"][clecouleur] = tuple_vers_rgb(gros_dico["couleurs"][clecouleur])
 447
 448     # Enlever ce qui ne se sauvegarde pas si y'a
 449     if "non_sauve" in gros_dico:
 450         del gros_dico["non_sauve"]
 451
 452     return json.dumps(gros_dico, indent=2,ensure_ascii=False )
 453
 454 def fusionne_donnees(listes_jours,listes_donnees, listes_dates):
 455     """ prend en argument deux dicos de listes. Chaque liste de jours est associée à une liste
 456     de données (par la même clé de type de données). Il faut les fusionner pour avoir une liste de dictionnaires, de type
 457     {"age":truc, "donnee1":truc, "donnee2":truc, ...} triée par ordre de jours. Si jamais une des données est vide,
 458     le champ du dictionnaire n'est pas rempli
 459     Le troisième paquet de listes (les dates) peut être vide ou bien simiaire : même clés."""
 460
 461     def fini(lj):
 462         """ teste si les listes sont toutes vides """
 463         for l in lj.values():
 464             if l!=[]:
 465                 return False
 466         return True
 467
 468     def mini(lj):
 469         """ renvoie la clé de la liste où il y a le min """
 470         cle_mini = CONFIG["liste_typedonnees"][0]
 471         for (cle,liste) in lj.items():
 472             if lj[cle_mini]== []:
 473                 cle_mini = cle
 474             elif lj[cle] != []:
 475                 if convertit_jours_vers_python(lj[cle][0],initialise_erreurs())<convertit_jours_vers_python(lj[cle_mini][0],initialise_erreurs()):
 476                     cle_mini = cle
 477         return cle_mini
 478
 479     liste_f = []
 480     while not(fini(listes_jours)):
 481         typedonnee = mini(listes_jours)
 482         # On extrait les données dans les deux listes (jours et données)
 483         jour = listes_jours[typedonnee].pop(0)
 484         donnee = listes_donnees[typedonnee].pop(0)
 485
 486         if liste_f == [] or jour != liste_f[-1]["age"]: # Si le jour est un "nouveau" jour
 487             liste_f.append({"age":jour})
 488         # On met à jour l'élément (ou on l'ajoute)
 489         liste_f[-1][typedonnee] = donnee
 490
 491         # Si il y a une date associée, on la met !
 492         if listes_dates[typedonnee] != []:
 493             date = listes_dates[typedonnee].pop(0)
 494             liste_f[-1]["date"] = convertit_date_vers_texte(date)
 495
 496
 497     return liste_f
 498
 499
 500 ### COnversion json vers formulaire
 501 # Json -> formulaire HTML
 502 def fichier_json_vers_configdonnees(chaine,liste_err):
 503     """ prend le json importé (chaine) et l'exporte vers les valeurs du formulaire
 504     Renvoyé sous forme de dictionnaire (mais adapté au formulaire web)"""
 505     debug("json vers config : Prêt à interpréter le json",liste_err)
 506     try:
 507         valform = json.loads(chaine)
 508     except :
 509         erreur("Impossible de lire le fichier json !",liste_err)
 510         return {}
 511     # Il faut maintenant récupérer les l_jours et l_poids puis les remettre
 512     # sous forme de age_i et poids_i
 513
 514     listes_jours = {}
 515     listes_donnees = {}
 516     listes_dates = {}
 517     for typed in CONFIG["liste_typedonnees"]:
 518         if typed == "poids": # pour la rétrocompatibilité
 519             listes_jours[typed] = valform.get("data_j",[])
 520             listes_donnees[typed] = valform.get("data_p",[])
 521             listes_dates[typed] = valform.get("data_dates_"+typed,[])
 522         else:
 523             listes_jours[typed] = valform.get("data_jours_"+typed,[])
 524             listes_donnees[typed] = valform.get("data_"+typed,[])
 525             listes_dates[typed] = valform.get("data_dates_"+typed,[])
 526
 527
 528     debug("Avant fusion : listes jours "+str(listes_jours),liste_err)
 529     liste_donnees = fusionne_donnees(listes_jours,listes_donnees, listes_dates)
 530     debug("Fusion de listes ok. Liste moche : "+str(liste_donnees),liste_err)
 531     for i in range(len(liste_donnees)):
 532         for (cle,val) in liste_donnees[i].items():
 533             valform[cle+"_"+str(i)] = val
 534
 535     valform["nb_data"] = max(len(liste_donnees) +2,DEFAUT["nb_data"])
 536
 537     return valform
 538
 539
 540
 541 #### Pour l'insertion d'une 2e (ou plus) courbe sur le graphique, ue fonction qui sépare tout ça
 542 def eclate_donnees_additionnelles(conf, ljours, ldonnees, symb, couleur):
 543     """ conf est la config (on ne garde que le nom) pour un enfant additionnel,
 544     ljours et ldonnees les dictionnaires de listes contenant les données.
 545     symb est le symbole choisi pour cette courbe additionnelle (déjà vérifié)
 546     On fabrique un joli dictionnaire typed -> (conf lj, ldonnee) avec le nom de l'enfant,
 547     et les données pour chaque typed"""
 548     print("test conf avant "+str(ldonnees)+str(ljours))
 549
 550     retour = {}
 551     conf["symbole"] = symb # On ajoute le symbole additionnel
 552     conf["couleurcourbe"] = couleur # la couleur
 553     for typed in CONFIG["liste_typedonnees"]:
 554         retour[typed] = (conf, ljours[typed], ldonnees[typed])
 555
 556     print("test "+str(retour))
 557     return retour