Possibilité de prolonger la courbe
[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 *
6 from gestion_couleurs import *
7 from gestion_unites import *
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("convertit_jour_vers_python : 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 # fonction qui calcule "auto" le maxi du graphique en fonction du max
79 def calcule_max_graphique(l_jours):
80 """ calcule l'age maxi sur le graphique"""
81 if l_jours == []:
82 return CONFIG["jours_defaut_donneesvides"]
83 else:
84 jour_maxi = max(l_jours)# pas la peine d'aller très au delà du jour max
85 jour_maxi = int(jour_maxi* 1.2)+3 # on rajoute un peu
86 return jour_maxi
87
88
89 def simplifie_nom(chaine):
90 """ simplifie le nom chaine afin d'en faire une extension
91 pour le nom du fichier. Met tout en minuscules et vire les caractères spéciaux
92 et max 15 caractères"""
93 chaine2 = ""
94 for l in chaine:
95 if l.isalpha():
96 chaine2+=l
97 chaine2 = unidecode.unidecode(chaine2)
98 return chaine2[:15]
99
100 def convertit_donnee_vers_python(chaine,typedonnee,liste_err):
101 """ convertit une chaine vers un float qui est le type donnee voulu.
102 La virgule peut être . ou , et on vire d'éventuels espaces.
103 Taille invalide : on renvoie 0 avec un warning."""
104 chaine2 = chaine.replace(",",".")
105 chaine2 = chaine2.replace(" ","")
106
107 try:
108 donnee = float(chaine2)
109 except:
110 warning(typedonnee+" impossible à lire : "+chaine,liste_err)
111 donnee = 0
112 if not( 0<=donnee<CONFIG[typedonnee+"_maxi"]):
113 warning(typedonnee+"incohérent(e) : "+str(donnee),liste_err)
114 donnee = 0
115 return donnee
116
117
118 #########################
119
120 # web -> python
121 def convertit_date_vers_python(chaine,liste_err):
122 """ prend une chaine comme renvoyée par un champ de formulaire date
123 aaaa-mm-jj et en fait une date python
124 renvoie "" si ne marche pas"""
125 liste = chaine.split("-")
126 if len(liste) != 3:
127 warning("La date : "+chaine+" est invalide !",liste_err)
128 return ""
129 else:
130 debug("Conversion de la date "+chaine+". Découpage : "+str(liste),liste_err)
131 try:
132 date = datetime.date(int(liste[0]),int(liste[1]),int(liste[2]))
133 except:
134 date = ""
135 warning("Impossible de lire la date "+chaine+". Format accepté : aaaa-mm-jj",liste_err)
136 return date
137
138 # python -> json
139 def convertit_date_vers_texte(date):
140 """ convertit une date python en format texte aaaa-mm-jj"""
141 if date == "":
142 return ""
143 else:
144 return (str(date.year)+"-"+str(date.month)+"-"+str(date.day))
145
146
147 def delta_date(date1,datenaissance):
148 """ renvoie le nombre de jours (entier) entre date1 et datenaissance format "datetime"
149 datenaissance est supposée antérieure. Erreur sinon."""
150 d = date1 - datenaissance
151 jours = d.days
152 if jours<0:
153 erreur_continue("La différence entre les dates est négative... :/")
154 return -1
155 return jours
156
157
158 ################### On regroupe tout ce qui gère les données en une fonction
159
160 def web_vers_python(data,liste_err):
161 """ prend en argument le dictionnaire de requête et renvoie la config, et les
162 tableaux de donnée"""
163
164 # Régler la configuration
165 config = gere_configuration(data,liste_err)
166
167 # récupérer les données
168 listes_jours = {}
169 listes_donnees = {}
170 for typed in CONFIG["liste_typedonnees"]:
171 listes_jours[typed],listes_donnees[typed] = gere_donnees(data,config["naissance"],typed,liste_err)
172
173 # Si on a choisi la même échelle de données
174 if config["memechelle"] == "oui":
175 config["non_sauve"]["maxi"] = calcule_max_graphique([j for lj in listes_jours.values() for j in lj])
176 config["non_sauve"]["unite"] = choix_unite(config["non_sauve"]["maxi"])
177
178 return (config,listes_jours,listes_donnees)
179
180
181
182 ########### Fonctions qui gèretn les données
183
184 def gere_checkbox(chaine):
185 """ prend en arg une chaine, et renvoie "oui" si c'est "on" (sortie de la checkbox)
186 et chaîne vide si n'importe quoi d'autre"""
187 if chaine == "on":
188 return "oui"
189 else:
190 return ""
191
192 def gere_configuration(data,liste_err):
193 """ prend en argument le dictionnaire de requête (configuration imparfaite), et
194 construit le dictionnaire de configuration qui va bien.
195 Vérifie que chaque entrée est cohérente évidemment."""
196 configuration = {}
197
198 # Pour le nom, osef qu'il soit vide
199 nom = data.get("nom","")
200 # Par contre s'il est trop long on le tronque
201 configuration["nom"] = nom[:CONFIG["longueur_max_nom_bebe"]]
202
203 sexe = data.get("sexe","")
204 if not (sexe in ["F","M","N"]):
205 warning("Le sexe de l'enfant est invalide ! "+sexe,liste_err)
206 sexe = "N"
207 configuration["sexe"] = sexe
208
209 naissance = data.get("naissance","")
210 if naissance !="":
211 naissance = convertit_date_vers_python(naissance,liste_err)
212 configuration["naissance"] = naissance
213
214 prematurite = data.get("prematurite","")
215 j = convertit_jours_vers_python(prematurite,liste_err)
216 configuration["prematurite"] = convertit_age_vers_texte(j)
217
218 configuration["agecorrige"] = gere_checkbox(data.get("agecorrige",""))
219
220 # Type de courbe. Au pire on met P
221 tyc = data.get("typecourbe","")
222 if not (tyc in ["P","Z"]):
223 tyc = "P"
224 configuration["typecourbe"] = tyc
225
226 # unité
227 unite = data.get("unite","")
228 if not (unite in CONFIG["liste_unites"]):
229 unite = ""
230 #warning("L'unité "+unite+" n'est pas reconnue !",liste_err)
231 configuration["unite"] = unite
232
233 # grille
234 configuration["grille"] = gere_checkbox(data.get("grille",""))
235
236 # tracer ou non les courbes vides
237 configuration["tracevide"] = gere_checkbox(data.get("tracevide",""))
238
239 # Même échelle sur tous les graphiques
240 configuration["memechelle"] = gere_checkbox(data.get("memechelle",""))
241
242
243 # maxi. 0 signifie qu'on veut pas de maxi
244 maxi = data.get("maxi","")
245 if maxi == "":
246 configuration["maxi"] = 0
247 else:
248 configuration["maxi"] = int(convertit_jours_vers_python(maxi,liste_err))
249
250 # dimensions du graphique
251 largeur = data.get("largeur","")
252 if largeur == "":
253 largeur = DEFAUT["largeur_graphique"]
254 else:
255 try:
256 largeur = int(largeur)
257 except:
258 warning("La largeur "+largeur+"est invalide !",liste_err)
259 largeur = DEFAUT["largeur_graphique"]
260 if largeur > CONFIG["largeur_graphique_max"]:
261 largeur = CONFIG["largeur_graphique_max"]
262 warning("Largeur du graphique trop grande !",liste_err)
263 elif largeur < CONFIG["largeur_graphique_min"]:
264 largeur = CONFIG["largeur_graphique_min"]
265 warning("Largeur du graphique trop petite !",liste_err)
266 configuration["largeur"] = largeur
267
268 hauteur = data.get("hauteur","")
269 if hauteur == "":
270 hauteur = DEFAUT["hauteur_graphique"]
271 else:
272 try:
273 hauteur = int(hauteur)
274 except:
275 warning("La hauteur "+hauteur+"est invalide !",liste_err)
276 hauteur = DEFAUT["hauteur_graphique"]
277 if hauteur > CONFIG["hauteur_graphique_max"]:
278 hauteur = CONFIG["hauteur_graphique_max"]
279 warning("Hauteur du graphique trop grande !",liste_err)
280 elif hauteur < CONFIG["hauteur_graphique_min"]:
281 hauteur = CONFIG["hauteur_graphique_min"]
282 warning("Hauteur du graphique trop petite !",liste_err)
283 configuration["hauteur"] = hauteur
284
285 # existence et position de la légende
286 configuration["legende"] = gere_checkbox(data.get("legende",""))
287
288 positionlegende = data.get("positionlegende","")
289 if not(positionlegende in ['upper left','upper right','lower left','lower right']):
290 positionlegende = "upper left"
291 configuration["positionlegende"] = positionlegende
292
293 configuration["prolongercourbes"] = gere_checkbox(data.get("prolongercourbes",""))
294
295
296 configuration["couleurs"] = {}
297 # gérer les couleurs
298 for clecouleur in DEFAUT["couleurs"]:
299 coul = rgb_vers_tuple(data.get("couleur_"+clecouleur,""),CONFIG["couleurs"][clecouleur],liste_err)
300 configuration["couleurs"][clecouleur] = coul
301
302 # On y ajoute la partie "non sauvée" qui servira peut-être plus tard
303 configuration["non_sauve"] = {}
304
305 return configuration
306
307
308 def gere_donnees(data,naissance,typedonnee,liste_err):
309 """ prend en argument le dictionnaire de requête, et la date de
310 naissance (éventuellement vide), et construit deux listes :
311 l_jours et l_data correspondantes.
312 Il faut donner en argument le type de données : voir
313 CONFIG["liste_typedonnees"]"""
314 if typedonnee not in CONFIG["liste_typedonnees"]:
315 warning("gere_donnees : le type de données : "+typedonnee+" est invalide !! Types acceptés : "+str(CONFIG["liste_typedonnees"]),liste_err)
316 return ([],[])
317
318 # On construit une liste de couples d'abord
319 liste_donnees = []
320
321 i = 0
322 # On va chercher si y'a des données à donnee_i
323 while typedonnee+"_"+str(i) in data.keys():
324 if data[typedonnee+"_"+str(i)] != "":
325 donnee = convertit_donnee_vers_python(data[typedonnee+"_"+str(i)],typedonnee,liste_err)
326 age = data.get("age_"+str(i),"")
327 if age !="":
328 age = convertit_jours_vers_python(age,liste_err)
329 liste_donnees.append((age,donnee))
330 else:
331 date = data.get("date_"+str(i),"")
332 datep = convertit_date_vers_python(date,liste_err)
333 # on vérifie la date
334 if naissance == "":
335 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)
336 elif datep != "": # la date est valide et on a une date de naissance
337 age = delta_date(datep,naissance)
338 liste_donnees.append((age,donnee))
339 i+=1
340
341 # Trier la liste
342 liste_donnees.sort(key=lambda x : x[0])
343
344 # splitter la liste
345 l_jours = [x[0] for x in liste_donnees]
346 l_donnee = [x[1] for x in liste_donnees]
347
348 return (l_jours,l_donnee)
349
350
351 #### export vers json
352
353 def donnees_vers_json(l_jours,l_poids,l_jourst,l_taille,config):
354 """ retourne le json à renvoyer"""
355 gros_dico = copy.deepcopy(config)
356 l_jours2 = [convertit_age_vers_texte(d) for d in l_jours]
357 l_jourst2 = [convertit_age_vers_texte(d) for d in l_jourst]
358 gros_dico["data_j"] = l_jours2
359 gros_dico["data_p"] = l_poids
360 gros_dico["data_jours_taille"] = l_jourst2
361 gros_dico["data_taille"] = l_taille
362 # gérer la date de naissance
363 if gros_dico.get("naissance","") != "":
364 gros_dico["naissance"] = convertit_date_vers_texte(gros_dico["naissance"])
365 # gérer l'age maxi
366 gros_dico["maxi"] = convertit_age_vers_texte(gros_dico["maxi"])
367 # gérer les couleurs
368 for clecouleur in DEFAUT["couleurs"]:
369 gros_dico["couleurs"][clecouleur] = tuple_vers_rgb(gros_dico["couleurs"][clecouleur])
370
371 # Enlever ce qui ne se sauvegarde pas si y'a
372 if "non_sauve" in gros_dico:
373 del gros_dico["non_sauve"]
374
375 return json.dumps(gros_dico, indent=2,ensure_ascii=False )
376
377 def fusionne_donnees(listes_jours,listes_donnees):
378 """ prend en argument deux dicos de listes. Chaque liste de jours est associée à une liste
379 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
380 ("age":truc, "donnee1":truc, "donnee2":truc, ...) triée par ordre de jours. Si jamais une des données est vide,
381 le champ du dictionnaire n'est pas rempli"""
382 # nb_donnees = len(listes_jours)
383 def fini(lj):
384 """ teste si les listes sont toutes vides """
385 for l in lj.values():
386 if l!=[]:
387 return False
388 return True
389
390 def mini(lj):
391 """ renvoie la clé de la liste où il y a le min """
392 cle_mini = CONFIG["liste_typedonnees"][0]
393 for (cle,liste) in lj.items():
394 if lj[cle_mini]== []:
395 cle_mini = cle
396 elif lj[cle] != []:
397 if convertit_jours_vers_python(lj[cle][0],initialise_erreurs())<convertit_jours_vers_python(lj[cle_mini][0],initialise_erreurs()):
398 cle_mini = cle
399 return cle_mini
400
401 liste_f = []
402 while not(fini(listes_jours)):
403 typedonnee = mini(listes_jours)
404 # On extrait les données dans les deux listes (jours et données)
405 jour = listes_jours[typedonnee].pop(0)
406 donnee = listes_donnees[typedonnee].pop(0)
407 if liste_f == [] or jour != liste_f[-1]["age"]: # Si le jour est un "nouveau" jour
408 liste_f.append({"age":jour})
409 # On met à jour l'élément
410 liste_f[-1][typedonnee] = donnee
411
412 return liste_f
413
414
415
416 # Json -> formulaire HTML
417 def fichier_json_vers_configdonnees(chaine,liste_err):
418 """ prend le json importé (chaine) et l'exporte vers les valeurs du formulaire """
419 debug("json vers config : Prêt à interpréter le json",liste_err)
420 try:
421 valform = json.loads(chaine)
422 except :
423 erreur("Impossible de lire le fichier json !",liste_err)
424 return {}
425 # Il faut maintenant récupérer les l_jours et l_poids puis les remettre
426 # sous forme de age_i et poids_i
427
428 listes_jours = {}
429 listes_donnees = {}
430 for typed in CONFIG["liste_typedonnees"]:
431 if typed == "poids": # pour la rétrocompatibilité
432 listes_jours[typed] = valform.get("data_j",[])
433 listes_donnees[typed] = valform.get("data_p",[])
434 else:
435 listes_jours[typed] = valform.get("data_jours_"+typed,[])
436 listes_donnees[typed] = valform.get("data_"+typed,[])
437
438 debug("Avant fusion : listes jours "+str(listes_jours),liste_err)
439 liste_donnees = fusionne_donnees(listes_jours,listes_donnees)
440 debug("Fusion de listes ok. Liste moche : "+str(liste_donnees),liste_err)
441 for i in range(len(liste_donnees)):
442 for (cle,val) in liste_donnees[i].items():
443 valform[cle+"_"+str(i)] = val
444
445 valform["nb_data"] = max(len(liste_donnees) +2,DEFAUT["nb_data"])
446
447 return valform
448
449
450