Python Outils.affiche_message方法代码示例

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
    def calcul_montants(self, prestations, coefprests, comptes, clients, verification):
        """
        calcule le 'montant' et le 'rabais_r' et les ajoute aux données
        :param prestations: prestations importées et vérifiées
        :param coefprests: coefficients prestations importés et vérifiés
        :param comptes: comptes importés et vérifiés
        :param clients: clients importés et vérifiés
        :param verification: pour vérifier si les dates et les cohérences sont correctes
        """
        if verification.a_verifier != 0:
            info = self.libelle + ". vous devez faire les vérifications avant de calculer les montants"
            print(info)
            Outils.affiche_message(info)
            return

        donnees_list = []
        for donnee in self.donnees:
            prestation = prestations.donnees[donnee['id_prestation']]
            compte = comptes.donnees[donnee['id_compte']]
            client = clients.donnees[compte['code_client']]
            coefprest = coefprests.donnees[client['id_classe_tarif'] + prestation['categorie']]
            donnee['prix_unit_client'] = round(prestation['prix_unit'] * coefprest['coefficient'], 2)
            donnee['montant'] = round(donnee['quantite'] * donnee['prix_unit_client'], 2)
            donnee['rabais_r'] = round(donnee['rabais'], 2)
            donnees_list.append(donnee)
        self.donnees = donnees_list

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
    def livraisons_pour_projet_par_categorie(self, num_projet, id_compte, code_client, prestations):
        """
        retourne les livraisons pour un projet donné, pour une catégorie de prestations donnée
        :param num_projet: lenuméro de projet
        :param id_compte: l'id du compte
        :param code_client: le code du client
        :param prestations: prestations importées et vérifiées
        :return: les livraisons pour le projet donné, pour une catégorie de prestations donnée
        """

        if prestations.verifie_coherence == 0:
            info = self.libelle + ". vous devez vérifier la cohérence des prestations avant de pouvvoir sélectionner " \
                                  "les livraisons par catégorie"
            print(info)
            Outils.affiche_message(info)
            return {}

        donnees_dico = {}
        for donnee in self.donnees:
            if (donnee['id_compte'] == id_compte) and (donnee['code_client'] == code_client) \
                    and (donnee['num_projet'] == num_projet):
                categorie = prestations.donnees[donnee['id_prestation']]['categorie']
                if categorie not in donnees_dico:
                    donnees_dico[categorie] = []
                liste = donnees_dico[categorie]
                liste.append(donnee)
        return donnees_dico

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
    def est_coherent(self, comptes, machines):
        """
        vérifie que les données du fichier importé sont cohérentes (id compte parmi comptes,
        id machine parmi machines), et efface les colonnes mois et année
        :param comptes: comptes importés
        :param machines: machines importées
        :return: 1 s'il y a une erreur, 0 sinon
        """
        if self.verifie_date == 0:
            info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
            print(info)
            Outils.affiche_message(info)
            return 1

        if self.verifie_coherence == 1:
            print(self.libelle + ": cohérence déjà vérifiée")
            return 0

        msg = ""
        ligne = 1
        donnees_list = []

        for donnee in self.donnees:
            if donnee['id_compte'] == "":
                msg += "le compte id de la ligne " + str(ligne) + " ne peut être vide\n"
            elif comptes.contient_id(donnee['id_compte']) == 0:
                msg += "le compte id '" + donnee['id_compte'] + "' de la ligne " + str(ligne) + " n'est pas référencé\n"
            elif donnee['code_client'] not in self.comptes:
                self.comptes[donnee['code_client']] = [donnee['id_compte']]
            elif donnee['id_compte'] not in self.comptes[donnee['code_client']]:
                self.comptes[donnee['code_client']].append(donnee['id_compte'])

            if donnee['id_machine'] == "":
                msg += "le machine id de la ligne " + str(ligne) + " ne peut être vide\n"
            elif machines.contient_id(donnee['id_machine']) == 0:
                msg += "le machine id '" + donnee['id_machine'] + "' de la ligne " + str(ligne) \
                       + " n'est pas référencé\n"

            donnee['duree_hp'], info = Outils.est_un_nombre(donnee['duree_hp'], "la durée réservée HP", ligne)
            msg += info
            donnee['duree_hc'], info = Outils.est_un_nombre(donnee['duree_hc'], "la durée réservée HC", ligne)
            msg += info
            donnee['duree_ouvree'], info = Outils.est_un_nombre(donnee['duree_ouvree'], "la durée ouvrée", ligne)
            msg += info

            del donnee['annee']
            del donnee['mois']
            donnees_list.append(donnee)

            ligne += 1

        self.donnees = donnees_list
        self.verifie_coherence = 1

        if msg != "":
            msg = self.libelle + "\n" + msg
            print("msg : " + msg)
            Outils.affiche_message(msg)
            return 1
        return 0

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
    def est_coherent(self, comptes_actifs):
        """
        vérifie que les données du fichier importé sont cohérentes (code client dans clients,
        ou alors absent des clients actifs, id compte unique), et efface les colonnes mois et année
        :param comptes_actifs: codes des clients présents dans accès, réservations et livraisons
        :return: 1 s'il y a une erreur, 0 sinon
        """
        if self.verifie_date == 0:
            info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
            print(info)
            Outils.affiche_message(info)
            return 1

        if self.verifie_coherence == 1:
            print(self.libelle + ": cohérence déjà vérifiée")
            return 0

        msg = ""
        ligne = 1
        ids = []
        donnees_dict = {}

        for donnee in self.donnees:
            if donnee['code_client'] == "":
                if donnee['id_compte'] in comptes_actifs:
                    print("code client du compte vide")
                    msg += "le code client de la ligne " + str(ligne) + " ne peut être vide si le compte est utilisé\n"
                continue

            if donnee['id_compte'] == "":
                msg += "le compte id de la ligne " + str(ligne) + " ne peut être vide\n"
            elif donnee['id_compte'] not in ids:
                ids.append(donnee['id_compte'])
                del donnee['annee']
                del donnee['mois']
                donnees_dict[donnee['id_compte']] = donnee
            else:
                msg += "l'id compte '" + donnee['id_compte'] + "' de la ligne " + str(ligne) +\
                       " n'est pas unique\n"

            donnee['seuil'], info = Outils.est_un_nombre(donnee['seuil'], "le seuil", ligne)
            if info != "":
                print(info)
                msg += info
            donnee['pourcent'], info = Outils.est_un_nombre(donnee['pourcent'], "le pourcent après seuil", ligne)
            if info != "":
                print(info)
                msg += info

            ligne += 1

        self.donnees = donnees_dict
        self.verifie_coherence = 1

        if msg != "":
            msg = self.libelle + "\n" + msg
            print("msg : " + msg)
            Outils.affiche_message(msg)
            return 1
        return 0

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
    def verification_date(self, annee, mois):
        """
        vérifie que le mois et l'année présents sur la ligne sont bien ceux espérés
        :param annee: année selon paramètres d'édition
        :param mois: mois selon paramètres d'édition
        :return: 0 si ok, 1 sinon
        """
        if self.verifie_date == 1:
            print(self.libelle + ": date déjà vérifiée")
            return 0

        msg = ""
        position = 1
        for donnee in self.donnees:
            try:
                if (int(donnee["mois"]) != mois) or (int(donnee["annee"]) != annee):
                    msg += "date incorrect ligne " + str(position) + "\n"
            except ValueError:
                msg += "année ou mois n'est pas valable" + str(position) + "\n"
            position += 1

        del self.donnees[0]
        self.verifie_date = 1

        if msg != "":
            msg = self.libelle + "\n" + msg
            print("msg : " + msg)
            Outils.affiche_message(msg)
            return 1
        return 0

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
    def somme_par_categorie(self, comptes):
        """
        calcule les sommes par catégories sous forme de dictionnaire : client->catégorie->clés_sommes
        :param comptes: comptes importés et vérifiés
        """

        if self.verification.a_verifier != 0:
            info = "Sommes :  vous devez faire les vérifications avant de calculer les sommes"
            print(info)
            Outils.affiche_message(info)
            return

        if self.sco != 0:
            spca = {}
            for code_client, spco_cl in self.sommes_comptes.items():
                if code_client not in spca:
                    spca[code_client] = {}
                spca_cl = spca[code_client]
                for id_compte, spco_co in spco_cl.items():
                    cat = comptes.donnees[id_compte]['categorie']
                    if cat not in spca_cl:
                        spca_cl[cat] = self.nouveau_somme(Sommes.cles_somme_categorie)
                    somme = spca_cl[cat]

                    somme['somme_k_ai'] += spco_co['somme_j_ai']
                    somme['somme_k_bi'] += spco_co['somme_j_bi']
                    somme['somme_k_ci'] += spco_co['somme_j_ci']
                    somme['somme_k_oi'] += spco_co['somme_j_oi']
                    somme['somme_k_mai'] += spco_co['somme_j_mai']
                    somme['somme_k_moi'] += spco_co['somme_j_moi']
                    somme['somme_k_dsi'] += spco_co['somme_j_dsi']
                    somme['somme_k_dhi'] += spco_co['somme_j_dhi']
                    somme['somme_k_mm'] += spco_co['somme_j_mm']
                    somme['somme_k_mr'] += spco_co['somme_j_mr']
                    somme['mk'] += spco_co['mj']

                    for categorie in self.categories:
                        somme['sommes_cat_m'][categorie] += spco_co['sommes_cat_m'][categorie]
                        somme['sommes_cat_r'][categorie] += spco_co['sommes_cat_r'][categorie]
                        somme['tot_cat'][categorie] += spco_co['tot_cat'][categorie]

            # print("")
            # print("spca")
            # for code in spca:
            #     if code != "220208":
            #         continue
            #     print(code)
            #     spca_cl = spca[code]
            #     for cat in spca_cl:
            #         somme = spca_cl[cat]
            #         print("   ", cat, somme['somme_k_mai'])

            self.sca = 1
            self.sommes_categories = spca

        else:
            info = "Vous devez d'abord faire la somme par compte, avant la somme par catégorie"
            print(info)
            Outils.affiche_message(info)

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
    def calcul_montants(self, machines, coefmachines, comptes, clients, verification):
        """
        calcule les montants 'pv' et 'qv' et les ajoute aux données
        :param machines: machines importées et vérifiées
        :param coefmachines: coefficients machines importés et vérifiés
        :param comptes: comptes importés et vérifiés
        :param clients: clients importés et vérifiés
        :param verification: pour vérifier si les dates et les cohérences sont correctes
        """
        if verification.a_verifier != 0:
            info = self.libelle + ". vous devez faire les vérifications avant de calculer les montants"
            print(info)
            Outils.affiche_message(info)
            return

        donnees_list = []
        for donnee in self.donnees:

            id_compte = donnee['id_compte']
            compte = comptes.donnees[id_compte]
            code_client = compte['code_client']
            id_machine = donnee['id_machine']
            machine = machines.donnees[id_machine]
            client = clients.donnees[code_client]
            coefmachine = coefmachines.donnees[client['id_classe_tarif'] + machine['categorie']]
            duree_fact_hp, duree_fact_hc = Rabais.rabais_reservation(machine['delai_sans_frais'],
                                                                     donnee['duree_ouvree'],
                                                                     donnee['duree_hp'],
                                                                     donnee['duree_hc'])

            if code_client not in self.sommes:
                self.sommes[code_client] = {'comptes': {}, 'machines': {}}
            scl = self.sommes[code_client]
            if id_compte not in scl['comptes']:
                scl['comptes'][id_compte] = {}
            sco = scl['comptes'][id_compte]
            if id_machine not in sco:
                sco[id_machine] = {'res_hp': 0, 'ann_hp': 0,
                                'res_hc': 0, 'ann_hc': 0}

            if donnee['si_supprime'] == 'OUI':
                sco[id_machine]['ann_hp'] += duree_fact_hp
                sco[id_machine]['ann_hc'] += duree_fact_hc
            else:
                sco[id_machine]['res_hp'] += duree_fact_hp
                sco[id_machine]['res_hc'] += duree_fact_hc

            if id_machine not in scl['machines']:
                pu_hp = round(coefmachine['coef_r'] * machine['t_h_reservation_hp'], 2)
                pu_hc = round(coefmachine['coef_r'] * machine['t_h_reservation_hc'], 2)
                scl['machines'][id_machine] = {'pu_hp': pu_hp, 'pu_hc': pu_hc}

            donnee['duree_fact_hp'] = duree_fact_hp
            donnee['duree_fact_hc'] = duree_fact_hc

            donnees_list.append(donnee)

        self.donnees = donnees_list

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
    def creation_annexes(sommes, clients, edition, livraisons, acces, machines, reservations, prestations, comptes,
                         dossier_annexe, plateforme, prefixe, coefprests, coefmachines, generaux, garde):
        """
        création des annexes techniques
        :param sommes: sommes calculées
        :param clients: clients importés
        :param edition: paramètres d'édition
        :param livraisons: livraisons importées
        :param acces: accès importés
        :param machines: machines importées
        :param reservations: réservations importées
        :param prestations: prestations importées
        :param comptes: comptes importés
        :param dossier_annexe: nom du dossier dans lequel enregistrer les annexes
        :param plateforme: OS utilisé
        :param prefixe: prefixe de nom des annexes
        :param coefprests: coefficients prestations importés
        :param coefmachines: coefficients machines importés
        :param generaux: paramètres généraux
        :param garde: titre page de garde
        """

        if sommes.calculees == 0:
            info = "Vous devez d'abord faire toutes les sommes avant de pouvoir créer les annexes"
            print(info)
            Outils.affiche_message(info)
            return

        for code_client in sommes.sommes_clients.keys():
            contenu = Latex.entete(plateforme)
            contenu += r'''\usepackage[margin=10mm, includefoot]{geometry}
                \usepackage{multirow}
                \usepackage{longtable}
                \usepackage{dcolumn}
                \usepackage{changepage}
                \usepackage[scriptsize]{caption}

                \begin{document}
                \renewcommand{\arraystretch}{1.5}
                '''
            contenu += r'''
                \vspace*{8cm}
                \begin{adjustwidth}{5cm}{}
                \Large\textsc{''' + garde + r'''}\newline\newline'''
            nom = Latex.echappe_caracteres(clients.donnees[code_client]['abrev_labo'])
            code_sap = clients.donnees[code_client]['code_sap']

            contenu += code_client + " - " + code_sap + " - " + nom + r'''\newpage
                \end{adjustwidth}'''
            contenu += Annexes.contenu_client(sommes, clients, code_client, edition, livraisons, acces, machines,
                                              reservations, prestations, comptes, coefprests, coefmachines, generaux)
            contenu += r'''\end{document}'''

            nom = prefixe + str(edition.annee) + "_" + Outils.mois_string(edition.mois) + "_" + \
                  str(edition.version) + "_" + code_client

            Latex.creer_latex_pdf(nom, contenu, dossier_annexe)

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
    def somme_par_compte(self, comptes):
        """
        calcule les sommes par comptes sous forme de dictionnaire : client->compte->clés_sommes
        :param comptes: comptes importés et vérifiés
        """

        if self.sp != 0:
            spc = {}
            for code_client, client in self.sommes_projets.items():
                if code_client not in spc:
                    spc[code_client] = {}
                cl = spc[code_client]
                for id_compte, compte in client.items():
                    cc = comptes.donnees[id_compte]
                    cl[id_compte] = self.nouveau_somme(Sommes.cles_somme_compte)
                    somme = cl[id_compte]
                    for num_projet, projet in compte.items():
                        somme["somme_j_pu"] += projet["somme_p_pu"]
                        somme["somme_j_pv"] += projet["somme_p_pv"]
                        somme["somme_j_pm"] += projet["somme_p_pm"]
                        somme["somme_j_qu"] += projet["somme_p_qu"]
                        somme["somme_j_qv"] += projet["somme_p_qv"]
                        somme["somme_j_qm"] += projet["somme_p_qm"]
                        somme["somme_j_om"] += projet["somme_p_om"]
                        somme["somme_j_nm"] += projet["somme_p_nm"]

                        for categorie in self.categories:
                            somme["sommes_cat_m"][categorie] += projet["sommes_cat_m"][categorie]
                            somme["sommes_cat_r"][categorie] += projet["sommes_cat_r"][categorie]
                            somme["tot_cat"][categorie] += projet["tot_cat"][categorie]

                    somme["prj"], somme["qrj"], somme["orj"] = Rabais.rabais_plafonnement(
                        somme["somme_j_pm"], cc["seuil"], cc["pourcent"]
                    )

                    somme["pj"] = somme["somme_j_pm"] - somme["prj"]
                    somme["qj"] = somme["somme_j_qm"] - somme["qrj"]
                    somme["oj"] = somme["somme_j_om"] - somme["orj"]

                    somme["nrj"] = somme["qrj"] + somme["orj"]
                    somme["nj"] = somme["somme_j_nm"] - somme["nrj"]

                    tot = somme["somme_j_pm"] + somme["somme_j_qm"] + somme["somme_j_om"]
                    for categorie in self.categories:
                        tot += somme["sommes_cat_m"][categorie]
                    if tot > 0:
                        somme["si_facture"] = 1

                    self.sco = 1
                    self.sommes_comptes = spc

        else:
            info = "Vous devez d'abord faire la somme par projet, avant la somme par compte"
            print(info)
            Outils.affiche_message(info)

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
 def obtenir_comptes(self):
     """
     retourne la liste de tous les comptes clients
     :return: liste des comptes clients présents dans les données livraisons importées
     """
     if self.verifie_coherence == 0:
         info = self.libelle + ". vous devez vérifier la cohérence avant de pouvoir obtenir les comptes"
         print(info)
         Outils.affiche_message(info)
         return []
     return self.comptes

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
 def obtenir_codes(self):
     """
     retourne les codes de tous les clients
     :return: codes de tous les clients
     """
     if self.verifie_coherence == 0:
         info = self.libelle + ". vous devez vérifier la cohérence avant de pouvoir obtenir les codes"
         print(info)
         Outils.affiche_message(info)
         return []
     return self.codes

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
    def somme_par_categorie(self, comptes):
        """
        calcule les sommes par catégories sous forme de dictionnaire : client->catégorie->clés_sommes
        :param comptes: comptes importés et vérifiés
        """

        if self.verification.a_verifier != 0:
            info = "Sommes :  vous devez faire les vérifications avant de calculer les sommes"
            print(info)
            Outils.affiche_message(info)
            return

        if self.sco != 0:
            spc = {}
            for code_client, client in self.sommes_comptes.items():
                if code_client not in spc:
                    spc[code_client] = {}
                cl = spc[code_client]
                for id_compte, compte in client.items():
                    co = comptes.donnees[id_compte]
                    cat = co["categorie"]
                    if cat not in cl:
                        cl[cat] = self.nouveau_somme(Sommes.cles_somme_categorie)
                    somme = cl[cat]

                    somme["somme_k_pu"] += compte["somme_j_pu"]
                    somme["somme_k_pv"] += compte["somme_j_pv"]
                    somme["somme_k_pm"] += compte["somme_j_pm"]
                    somme["somme_k_prj"] += compte["prj"]
                    somme["pk"] += compte["pj"]
                    somme["somme_k_qu"] += compte["somme_j_qu"]
                    somme["somme_k_qv"] += compte["somme_j_qv"]
                    somme["somme_k_qm"] += compte["somme_j_qm"]
                    somme["somme_k_qrj"] += compte["qrj"]
                    somme["qk"] += compte["qj"]
                    somme["somme_k_om"] += compte["somme_j_om"]
                    somme["somme_k_orj"] += compte["orj"]
                    somme["ok"] += compte["oj"]
                    somme["somme_k_nm"] += compte["somme_j_nm"]
                    somme["somme_k_nrj"] += compte["nrj"]
                    somme["nk"] += compte["nj"]

                    for categorie in self.categories:
                        somme["sommes_cat_m"][categorie] += compte["sommes_cat_m"][categorie]
                        somme["sommes_cat_r"][categorie] += compte["sommes_cat_r"][categorie]
                        somme["tot_cat"][categorie] += compte["tot_cat"][categorie]

                    self.sca = 1
                    self.sommes_categories = spc

        else:
            info = "Vous devez d'abord faire la somme par compte, avant la somme par catégorie"
            print(info)
            Outils.affiche_message(info)

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
 def obtenir_noms_categories(self, categorie):
     """
     retourne le nom lié à une catégorie
     :return: nom lié à une catégorie
     """
     if self.verifie_coherence == 0:
         info = self.libelle + ". vous devez vérifier la cohérence avant de pouvoir obtenir les catégories"
         print(info)
         Outils.affiche_message(info)
         return []
     if categorie not in self.noms_cat:
         return categorie
     else:
         return self.noms_cat[categorie]

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
 def extraction_ligne(self, ligne):
     """
     extracte une ligne de données du csv
     :param ligne: ligne lue du fichier
     :return: tableau représentant la ligne, indexé par les clés
     """
     num = len(self.cles)
     if len(ligne) != num:
         info = self.libelle + ": nombre de colonnes incorrect : " + str(len(ligne)) + ", attendu : " + str(num)
         print(info)
         Outils.affiche_message(info)
         sys.exit("Erreur de consistance")
     donnees_ligne = {}
     for xx in range(0, num):
         donnees_ligne[self.cles[xx]] = ligne[xx]
     return donnees_ligne

# 需要导入模块: from outils import Outils [as 别名]
# 或者: from outils.Outils import affiche_message [as 别名]
    def calcul_montants(self, machines, coefmachines, comptes, clients, verification):
        """
        calcule les montants 'pu', 'qu' et 'mo' et les ajoute aux données
        :param machines: machines importées
        :param coefmachines: coefficients machines importés et vérifiés
        :param comptes: comptes importés et vérifiés
        :param clients: clients importés et vérifiés
        :param verification: pour vérifier si les dates et les cohérences sont correctes

        """
        if verification.a_verifier != 0:
            info = self.libelle + ". vous devez faire les vérifications avant de calculer les montants"
            print(info)
            Outils.affiche_message(info)
            return

        donnees_list = []
        for donnee in self.donnees:
            compte = comptes.donnees[donnee['id_compte']]
            machine = machines.donnees[donnee['id_machine']]
            client = clients.donnees[compte['code_client']]
            coefmachine = coefmachines.donnees[client['id_classe_tarif'] + machine['categorie']]

            donnee['pu'] = round(donnee['duree_machine_hp'] / 60 * round(machine['t_h_machine_hp_p'] *
                                                                         coefmachine['coef_p'], 2) +
                                 donnee['duree_machine_hc'] / 60 * round(machine['t_h_machine_hc_p'] *
                                                                         coefmachine['coef_p']), 2)

            donnee['qu'] = round(donnee['duree_machine_hp'] / 60 * round(machine['t_h_machine_hp_np'] *
                                                                         coefmachine['coef_np'], 2) +
                                 donnee['duree_machine_hc'] / 60 * round(machine['t_h_machine_hc_np'] *
                                                                         coefmachine['coef_np']), 2)

            donnee['om'] = round(donnee['duree_operateur_hp'] / 60 *
                                 round(machine['t_h_operateur_hp_mo'] * coefmachine['coef_mo'], 2) +
                                 donnee['duree_operateur_hc'] / 60 *
                                 round(machine['t_h_operateur_hc_mo'] * coefmachine['coef_mo']), 2)

            donnees_list.append(donnee)
        self.donnees = donnees_list