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