possibilité de tracer les repères
[perso/Denise/oms.git] / 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 ### Gestion des repères additionnels
372 configuration["liste_reperes"] = []
373 i=0
374 while "repere_texte_"+str(i) in data: # Tant qu'il y a des trucs définis
375 debug("Repère trouvé", liste_err)
376 age=data.get("repere_age_"+str(i), "")
377 trace=gere_checkbox(data.get("repere_trace_"+str(i), ""))
378 if age !="":
379 agec=convertit_jours_vers_python(age, liste_err)
380 texte = data.get("repere_texte_"+str(i), "") # Même si le texte est vide, osef
381 configuration["liste_reperes"].append({"typed": "age", "donnee": agec, "texte": texte, "trace": trace})
382 i+=1
383
384 return configuration
385
386
387
388 ## web vers python : données
389 def gere_donnees(data,naissance,typedonnee,liste_err):
390 """ prend en argument le dictionnaire de requête, et la date de
391 naissance (éventuellement vide), et construit deux listes :
392 l_jours et l_data correspondantes.
393 Il faut donner en argument le type de données : voir
394 CONFIG["liste_typedonnees"]"""
395 if typedonnee not in CONFIG["liste_typedonnees"]:
396 warning("gere_donnees : le type de données : "+typedonnee+" est invalide !! Types acceptés : "+str(CONFIG["liste_typedonnees"]),liste_err)
397 return ([],[])
398
399 # On construit une liste de couples d'abord
400 liste_donnees = []
401
402 i = 0
403 # On va chercher si y'a des données à donnee_i
404 while "age_"+str(i) in data.keys():
405 if data.get(typedonnee+"_"+str(i), "") != "": # si la donne de ce type existe
406 donnee = convertit_donnee_vers_python(data[typedonnee+"_"+str(i)],typedonnee,liste_err)
407 age = data.get("age_"+str(i),"")
408 if age !="":
409 age = convertit_jours_vers_python(age,liste_err)
410 liste_donnees.append((age,donnee))
411 else:
412 date = data.get("date_"+str(i),"")
413 datep = convertit_date_vers_python(date,liste_err)
414 # on vérifie la date
415 if naissance == "":
416 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)
417 elif datep != "": # la date est valide et on a une date de naissance
418 age = delta_date(datep,naissance)
419 liste_donnees.append((age,donnee))
420 i+=1
421
422 # Trier la liste
423 liste_donnees.sort(key=lambda x : x[0])
424
425 # splitter la liste
426 l_jours = [x[0] for x in liste_donnees]
427 l_donnee = [x[1] for x in liste_donnees]
428
429 return (l_jours,l_donnee)
430
431
432 # python vers Json
433 #### export vers json
434
435 def donnees_vers_json(l_jours,l_poids,l_jourst,l_taille,config):
436 """ retourne le json à renvoyer"""
437 gros_dico = copy.deepcopy(config)
438 gros_dico["version"] = CONFIG["version"]
439 l_jours2 = [convertit_age_vers_texte(d) for d in l_jours]
440 l_jourst2 = [convertit_age_vers_texte(d) for d in l_jourst]
441 gros_dico["data_j"] = l_jours2
442 gros_dico["data_p"] = l_poids
443 gros_dico["data_jours_taille"] = l_jourst2
444 gros_dico["data_taille"] = l_taille
445 # gérer la date de naissance
446 if gros_dico.get("naissance","") != "":
447 gros_dico["naissance"] = convertit_date_vers_texte(gros_dico["naissance"])
448 # Calcul de toutes les dates de données
449 l_dates_poids = [convertit_date_vers_texte( config["naissance"] + datetime.timedelta(days=jours) ) for jours in l_jours]
450 l_dates_taille = [convertit_date_vers_texte( config["naissance"] + datetime.timedelta(days=jours) ) for jours in l_jourst]
451 gros_dico["data_dates_poids"]= l_dates_poids
452 gros_dico["data_dates_taille"] = l_dates_taille
453
454
455 # gérer l'age maxi
456 gros_dico["maxi"] = convertit_age_vers_texte(gros_dico["maxi"])
457 # Gérer les repères
458 for i in range(len(gros_dico["liste_reperes"])):
459 gros_dico["liste_reperes"][i]["donnee"] = convertit_age_vers_texte(gros_dico["liste_reperes"][i]["donnee"])
460 # gérer les couleurs
461 for clecouleur in DEFAUT["couleurs"]:
462 gros_dico["couleurs"][clecouleur] = tuple_vers_rgb(gros_dico["couleurs"][clecouleur])
463
464 # Enlever ce qui ne se sauvegarde pas si y'a
465 if "non_sauve" in gros_dico:
466 del gros_dico["non_sauve"]
467
468 return json.dumps(gros_dico, indent=2,ensure_ascii=False )
469
470 def fusionne_donnees(listes_jours,listes_donnees, listes_dates):
471 """ prend en argument deux dicos de listes. Chaque liste de jours est associée à une liste
472 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
473 {"age":truc, "donnee1":truc, "donnee2":truc, ...} triée par ordre de jours. Si jamais une des données est vide,
474 le champ du dictionnaire n'est pas rempli
475 Le troisième paquet de listes (les dates) peut être vide ou bien simiaire : même clés."""
476
477 def fini(lj):
478 """ teste si les listes sont toutes vides """
479 for l in lj.values():
480 if l!=[]:
481 return False
482 return True
483
484 def mini(lj):
485 """ renvoie la clé de la liste où il y a le min """
486 cle_mini = CONFIG["liste_typedonnees"][0]
487 for (cle,liste) in lj.items():
488 if lj[cle_mini]== []:
489 cle_mini = cle
490 elif lj[cle] != []:
491 if convertit_jours_vers_python(lj[cle][0],initialise_erreurs())<convertit_jours_vers_python(lj[cle_mini][0],initialise_erreurs()):
492 cle_mini = cle
493 return cle_mini
494
495 liste_f = []
496 while not(fini(listes_jours)):
497 typedonnee = mini(listes_jours)
498 # On extrait les données dans les deux listes (jours et données)
499 jour = listes_jours[typedonnee].pop(0)
500 donnee = listes_donnees[typedonnee].pop(0)
501
502 if liste_f == [] or jour != liste_f[-1]["age"]: # Si le jour est un "nouveau" jour
503 liste_f.append({"age":jour})
504 # On met à jour l'élément (ou on l'ajoute)
505 liste_f[-1][typedonnee] = donnee
506
507 # Si il y a une date associée, on la met !
508 if listes_dates[typedonnee] != []:
509 date = listes_dates[typedonnee].pop(0)
510 liste_f[-1]["date"] = convertit_date_vers_texte(date)
511
512
513 return liste_f
514
515
516 ### COnversion json vers formulaire
517 # Json -> formulaire HTML
518 def fichier_json_vers_configdonnees(chaine,liste_err):
519 """ prend le json importé (chaine) et l'exporte vers les valeurs du formulaire
520 Renvoyé sous forme de dictionnaire (mais adapté au formulaire web)"""
521 debug("json vers config : Prêt à interpréter le json",liste_err)
522 try:
523 valform = json.loads(chaine)
524 except :
525 erreur("Impossible de lire le fichier json !",liste_err)
526 return {}
527 # Il faut maintenant récupérer les l_jours et l_poids puis les remettre
528 # sous forme de age_i et poids_i
529
530 listes_jours = {}
531 listes_donnees = {}
532 listes_dates = {}
533 for typed in CONFIG["liste_typedonnees"]:
534 if typed == "poids": # pour la rétrocompatibilité
535 listes_jours[typed] = valform.get("data_j",[])
536 listes_donnees[typed] = valform.get("data_p",[])
537 listes_dates[typed] = valform.get("data_dates_"+typed,[])
538 else:
539 listes_jours[typed] = valform.get("data_jours_"+typed,[])
540 listes_donnees[typed] = valform.get("data_"+typed,[])
541 listes_dates[typed] = valform.get("data_dates_"+typed,[])
542
543
544 debug("Avant fusion : listes jours "+str(listes_jours),liste_err)
545 liste_donnees = fusionne_donnees(listes_jours,listes_donnees, listes_dates)
546 debug("Fusion de listes ok. Liste moche : "+str(liste_donnees),liste_err)
547 for i in range(len(liste_donnees)):
548 for (cle,val) in liste_donnees[i].items():
549 valform[cle+"_"+str(i)] = val
550
551 valform["nb_data"] = max(len(liste_donnees) +2,DEFAUT["nb_data"])
552
553 return valform
554
555
556
557 #### Pour l'insertion d'une 2e (ou plus) courbe sur le graphique, ue fonction qui sépare tout ça
558 def eclate_donnees_additionnelles(conf, ljours, ldonnees, symb, couleur):
559 """ conf est la config (on ne garde que le nom) pour un enfant additionnel,
560 ljours et ldonnees les dictionnaires de listes contenant les données.
561 symb est le symbole choisi pour cette courbe additionnelle (déjà vérifié)
562 On fabrique un joli dictionnaire typed -> (conf lj, ldonnee) avec le nom de l'enfant,
563 et les données pour chaque typed"""
564 print("test conf avant "+str(ldonnees)+str(ljours))
565
566 retour = {}
567 conf["symbole"] = symb # On ajoute le symbole additionnel
568 conf["couleurcourbe"] = couleur # la couleur
569 for typed in CONFIG["liste_typedonnees"]:
570 retour[typed] = (conf, ljours[typed], ldonnees[typed])
571
572 print("test "+str(retour))
573 return retour