本文整理汇总了Python中outils.Outils类的典型用法代码示例。如果您正苦于以下问题：Python Outils类的具体用法？Python Outils怎么用？Python Outils使用的例子？那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了Outils类的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: livraisons_pour_projet_par_categorie
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示例2: calcul_montants
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示例3: verification_date
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示例4: somme_par_categorie
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)示例5: calcul_montants
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示例6: creation_annexes
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)示例7: somme_par_compte
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)示例8: obtenir_comptes
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示例9: somme_par_categorie
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)示例10: obtenir_codes
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示例11: est_coherent
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"
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示例12: obtenir_noms_categories
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]示例13: ligne_facture
def ligne_facture(generaux, article, poste, net, rabais, op_centre, consommateur, edition):
"""
retourne une ligne de facturation formatée
:param generaux: paramètres généraux
:param article: Une instance de la classe generaux.Article
:param poste: indice de poste
:param net: montant net
:param rabais: rabais sur le montant
:param op_centre: centre d'opération
:param consommateur: consommateur
:param edition: paramètres d'édition
:return: ligne de facturation formatée
"""
net = "%.2f" % net
rabais = "%.2f" % rabais
if rabais == 0:
rabais = ""
code_op = generaux.code_t + op_centre + article.code_d
date_livraison = str(edition.annee) + Outils.mois_string(edition.mois) + str(edition.dernier_jour)
return [poste, "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", article.code_sap, "", article.quantite,
article.unite, article.type_prix, net,
article.type_rabais, rabais, date_livraison, generaux.centre_financier, "",
generaux.fonds, "", "", code_op, "", "", "", article.texte_sap,
consommateur]示例14: ligne_tableau
def ligne_tableau(article, poste, net, rabais, consommateur, edition):
"""
retourne une ligne de tableau html
:param article: Une instance de la classe generaux.Article
:param poste: indice de poste
:param net: montant net
:param rabais: rabais sur le montant
:param consommateur: consommateur
:param edition: paramètres d'édition
:return: ligne de tableau html
"""
montant = net - rabais
date_livraison = str(edition.dernier_jour) + "." + Outils.mois_string(edition.mois) + "." + str(edition.annee)
description = article.code_d + " : " + article.code_sap
dico_tab = {'poste': poste, 'date': date_livraison, 'descr': description,
'texte': article.texte_sap, 'nom': Latex.echappe_caracteres(consommateur),
'unit': article.unite, 'quantity': article.quantite,
'unit_p': "%.2f" % net, 'discount': "%.2f" % rabais, 'net': "%.2f" % montant}
ligne = r'''<tr>
<td> %(poste)s </td><td> %(date)s </td><td> %(nom)s </td><td> %(descr)s <br /> %(texte)s </td>
<td> %(unit)s </td><td id="toright"> %(quantity)s </td><td id="toright"> %(unit_p)s </td>
<td id="toright"> %(discount)s </td><td id="toright"> %(net)s </td>
</tr>
''' % dico_tab
return ligne示例15: extraction_ligne
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