def test_controleSeriesOK(courbesTest):
"""
teste selection des courbes : valeurs OK
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
# Grandeurs calculées
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, True,
False)
# Test calcul des valeurs
nbCourbeOrig = len(courbesTest)
anneesOK = genCodeGraphiques.controleSeries(dictAllGrandeur, courbesTest,
listAnnees, True)
assert anneesOK == sorted(listAnnees)
assert nbCourbeOrig == len(courbesTest)
# Fermeture base
database.closeDatabase(connDB, True)
def test_calculeGrandeur(isWikicode):
"""
teste le calcule de grandeurs agglomérées
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany("""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
)
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376']
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V',
ville[0], True)
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V', ville[0], True)
assert len(listAnnees) == 3
# Test calcul des valeurs
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, isWikicode, True)
for grandeur in ["tendance ratio", "ratio dette / caf", "ratio n"]:
assert grandeur in dictAllGrandeur
# Fermeture base
database.closeDatabase(connDB, True)
def test_getTendanceRatioDetteCAF():
""" Test calcule de tendance du rapport dette/CAF """
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Recup chemin base de test et ménage
databasePathDir = config.get('Test', 'database.testDir')
databasePath = os.path.join(databasePathDir, config.get('Test', 'database.testName'))
if not os.path.isdir(databasePathDir):
os.mkdir(databasePathDir)
if os.path.isfile(databasePath):
os.remove(databasePath)
# Création base vide
connDB = database.createDatabase(config, databasePath, False)
assert os.path.isfile(databasePath)
assert connDB
# Insertion données dette et CAF pour une commune
codeDette = config['cleFi3Valeurs']["clefi.encours de la dette au 31 12 n"]
codeCAF = config['cleFi3Valeurs']["clefi.capacité autofinancement caf"]
connDB.executemany("""
INSERT INTO dataFi(codeCommune, annee, codeCle, valeur)
VALUES (?, ?, ?, ?)
""",
(
('001008', 2000, codeCAF, 1), ('001008', 2001, codeCAF, 1),
('001008', 2002, codeCAF, 1),
('001008', 2000, codeDette, 25), ('001008', 2001, codeDette, 23),
('001008', 2002, codeDette, 24)
))
connDB.commit()
# Récupère toutes les données concernant cette ville
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V',
'001008', False)
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V',
'001008', False)
# Test
tendanceRatio, dicoRatio = ratioTendance.getTendanceRatioDetteCAF(config, dictAllGrandeur,
True, True)
assert "est constant et élevé (supérieur à" in tendanceRatio
database.closeDatabase(connDB, True)
def test_genereTableauTaux(isWikicode, isComplet):
"""
teste la génération des données tableau des taux
pour 1 ville : Wittenheim 68)
Wittenheim et les années 2013 à 2015 pour comparaison avec
http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
nomTableau = "TAXES"
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
nbAnneesTableau = min(
int(config.get('GenWIkiCode', 'gen.nbLignesTableauxEuros')),
len(listAnnees))
couleurStrate = config.get('Tableaux', 'tableaux.couleurStrate')
couleurTitres = config.get('Tableaux', 'tableaux.couleurTitres')
couleurTaxeHabitation = config.get('Tableaux',
'tableaux.couleurTaxeHabitation')
couleurTaxeFonciereBati = config.get('Tableaux',
'tableaux.couleurTaxeFonciereBati')
couleurTaxeFonciereNonBati = config.get(
'Tableaux', 'tableaux.couleurTaxeFonciereNonBati')
verbose = False
listeValeurs = [
[
"taux taxe habitation", "taux taxe d'habitation",
couleurTaxeHabitation
],
[
"taux taxe foncière bâti", "taux foncier bâti",
couleurTaxeFonciereBati
],
[
"taux taxe foncière non bâti", "taux foncier non bâti",
couleurTaxeFonciereNonBati
],
]
# Récupère toutes les valeurs pour cette ville pour les grandeurs demandées
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], verbose)
# Test de la generation tableau
if isWikicode:
ligne = genWikiCodeTableaux.genereTableauTaux(
nomTableau, listAnnees, nbAnneesTableau, listeValeurs,
dictAllGrandeur, couleurTitres, couleurStrate, isComplet, verbose)
else:
ligne = genHTMLCodeTableaux.genereTableauTaux(
nomTableau, listAnnees, nbAnneesTableau, listeValeurs,
dictAllGrandeur, couleurTitres, couleurStrate, isComplet, verbose)
print("ligne=", ligne)
# Test valeur taux taxe d'habitation en 2015
# (cle tth) : 10.11
assert "10.11" in ligne
if isComplet:
# Test valeur taux taxe d'habitation pour la strate en 2015
# (cle tmth) : 15.98
assert "15.68" in ligne
def test_genCodeTableauxPicto(isComplet, isWikicode):
"""
teste la génération de tous les tableau pour 1 ville : Wittenheim 68)
Wittenheim et les années 2013 à 2015 pour comparaison avec
http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany("""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
)
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
listeVilleWalheim = [ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376']
ville = listeVilleWalheim[0]
# Recup des données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V',
ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V',
ville[0], False)
assert len(listAnnees) == 3
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur,
listAnnees, isWikicode, False)
# Lecture du modèle de test reduit au tableau picto
nomBaseModele = config.get('Test', 'genCodeTableauxPicto.ficModele')
typeSortie = ""
if isWikicode:
typeSortie = "wikicode"
else:
typeSortie = "HTML"
modele = nomBaseModele + '_' + typeSortie + '.txt'
textSection = utilitaires.lectureFiltreModele(modele, isComplet, False)
isGroupement = False
print("textSection AVANT genCodeTableauxPicto=", textSection)
# Définit le contenu des tableaux picto
grandeursAnalyse = genCodeTableaux.defTableauxPicto(config,
dictAllGrandeur, listAnnees,
isWikicode, False)
textSection = genCodeCommon.genCodeTableauxPicto(config,
dictAllGrandeur,
grandeursAnalyse,
textSection,
listAnnees, isComplet,
isWikicode,
True,
isGroupement,
False)
# Test Résultat comptable en 2015
# (cle fres1) : 12.94
print("textSection APRES genCodeTableauxPicto=", textSection)
assert "13" in textSection
# Test valeur des Charges de personnels par habitant en 2015
# (cle fperso) : 470.19
assert "470" in textSection
if isComplet:
# Test valeur des charges de la strate en 2015
# (cle mres1) : 131.95
assert "132" in textSection
# Test valeur taux taxe d'habitation en 2015
# (cle tth) : 10.11
assert "10" in textSection
if isComplet:
# Test valeur taux taxe d'habitation pour la strate en 2015
# (cle tmth) : 15.98
assert "16" in textSection
database.closeDatabase(connDB, True)
def test_getValeursDict(avecStrate):
""" Teste la fonction getValeursDict """
isWikicode = False
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany("""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
)
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
listeVilleWalheim = [ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376']
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V',
ville[0], False)
assert len(listAnnees) == 3
verbose = True
grandeursAnalyse = []
couleurDettesCAF = config.get('Tableaux', 'tableaux.couleurDettesCAF')
dictEncoursDette = \
{
"l'encours de la dette" :
{
'libellePicto' : 'Encours de la dette',
'cle' : 'encours de la dette au 31 12 n',
'note' : "",
'noteHtml' : '',
'nul' : "pas d'encours pour la dette"
}
}
grandeursAnalyse.append([dictEncoursDette, 0, "ENCOURS_DETTE", couleurDettesCAF])
dictAnnuiteDette = \
{
"l'annuité de la dette" :
{
'libellePicto' : 'annuité de la dette',
'cle' : "annuité de la dette",
'note' : "",
'noteHtml' : '',
'nul' : 'aucune annuité pour la dette'
}
}
grandeursAnalyse.append([dictAnnuiteDette, 0, "ANNUITE_DETTE", couleurDettesCAF])
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V', ville[0], verbose)
nbAnneesTendance = int(config.get('GenWIkiCode', 'gen.nbAnneesTendance'))
listeAnneesTendance = sorted(listAnnees[:nbAnneesTendance])
for grandeurs in grandeursAnalyse:
genCodeCommon.getValeursDict(dictAllGrandeur,
listeAnneesTendance, listAnnees[0],
grandeurs[0], avecStrate,
verbose)
print(grandeurs[0], "=", grandeurs[0])
assert grandeurs[0]["l'encours de la dette"]['Valeur totale'] == 10817
assert grandeurs[0]["l'encours de la dette"]['Par habitant'] == 734
if avecStrate:
assert grandeurs[0]["l'encours de la dette"]['En moyenne pour la strate'] == 944
else:
assert not 'En moyenne pour la strate' in grandeurs[0]["l'encours de la dette"]
assert grandeurs[0]["l'encours de la dette"]['dictAnneesValeur'][2013] == pytest.approx(479.18)
assert grandeurs[0]["l'encours de la dette"]['dictAnneesValeur'][2014] == pytest.approx(671.41)
assert grandeurs[0]["l'encours de la dette"]['dictAnneesValeur'][2015] == pytest.approx(733.67)
break
def test_calculeGrandeurCleBesoin():
"""
teste le calcule de grandeurs agglomérées
"""
isWikicode = True
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany("""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
)
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376']
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V',
ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
# Appel fonction à tester pour un ville
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, isWikicode, False)
print("Avant Suppression")
print("Valeur totale=", dictAllGrandeur['Valeur totale'].keys())
print("Par habitant=", dictAllGrandeur['Par habitant'].keys())
# Test valeur présente pour une ville et svg valeurs
cleManquante = "besoin ou capacité de financement de la section investissement"
cleManquanteHab = "besoin ou capacité de financement de la section investissement par habitant"
assert cleManquante in dictAllGrandeur['Valeur totale']
assert cleManquanteHab in dictAllGrandeur['Par habitant']
ValeursTotale = dictAllGrandeur['Valeur totale'][cleManquante]
ValeursHab = dictAllGrandeur['Par habitant'][cleManquanteHab]
cleRessourceInv = "total des ressources d'investissement"
assert cleRessourceInv in dictAllGrandeur['Valeur totale']
# Suppresion de la clé pour se mettre dans la situation d'un groupement de commune
del dictAllGrandeur['Valeur totale'][cleManquante]
del dictAllGrandeur['Par habitant'][cleManquanteHab]
assert cleManquante not in dictAllGrandeur['Valeur totale']
assert cleManquanteHab not in dictAllGrandeur['Par habitant']
# Appel fonction à tester pour un ville
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, isWikicode, False)
# Test valeur présente à nouveau pour une ville et controle valeurs
assert cleManquante in dictAllGrandeur['Valeur totale']
assert cleManquanteHab in dictAllGrandeur['Par habitant']
ValeursTotaleNew = dictAllGrandeur['Valeur totale'][cleManquante]
ValeursHabNew = dictAllGrandeur['Par habitant'][cleManquanteHab]
# Comparaison à un chouia près : 1e-3
assert ValeursTotale == pytest.approx(ValeursTotaleNew, rel=1e-3)
assert ValeursHab == pytest.approx(ValeursHabNew, rel=1e-3)
# Fermeture base
database.closeDatabase(connDB, True)
def test_genCodeGroupementTexte_func(typeCode):
"""
test la génération des données texte pour un groupement de commune :
ARDON)
Choisir Wittenheim et les années 2013 à 2015 pour comparaison avec
http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
verbose = True
# récup données de test
pathDatabaseMini = config.get('Test', 'updateDataMinFiGroupement.pathDatabaseMini')
pathCSVMini = config.get('Test', 'updateDataMinFiGroupement.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des numéros de siren à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
# ARDON : CC Portes de Sologne présente dans fichier CSV, doit apparaitre
connDB.executemany("""
INSERT INTO villes(codeCommune, nomMinFi, sirenGroupement)
VALUES (?, ?, ?)
""", (('045006', 'ARDON', '200005932'),))
connDB.executemany("""
INSERT INTO groupementCommunes(sirenGroupement, nomArticleCC, nom,
région, département, forme, siège,
logo, siteWeb)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
""", (('200005932', 'CC des Portes de Sologne',
'Communauté de communes des Portes de Sologne',
'Centre-Val de Loire', 'Loiret',
'Communauté de communes', 'La Ferté-Saint-Aubin',
'Logo_EPCI_Portes_de_Sologne.png',
'http://www.cc-lafertesaintaubin.fr'),))
connDB.commit()
# Appel programme
param = ['updateDataMinFiGroupementCommunes.py',
pathDatabaseMini, pathCSVMini]
updateDataMinFiGroupementCommunes.main(param)
assert os.path.isfile(pathDatabaseMini)
if typeCode == "wikicode":
isWikicode = True
else:
isWikicode = False
modele = 'modele_groupement_' + typeCode + '.txt'
isComplet = True
# Récupération du groupement de commune de la base
listGroupements = database.getListeGroupements(connDB, verbose)
assert len(listGroupements) == 1
groupement = listGroupements[0]
# Lecture et filtrage du fichier modèle
modele = 'modele_groupement_' + typeCode + '.txt'
with open(modele, 'r') as modelefile:
textSection = modelefile.read()
# Récupère toutes les données concernant ce groupement
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, "GC",
groupement[0],
verbose)
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'GC',
groupement[0],
verbose)
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur,
listAnnees, isWikicode,
verbose)
# Modification des valeurs simples
textSection = genCodeGroupementTexte.genTexte(config, dictAllGrandeur,
modele, textSection,
groupement, listAnnees,
"test_genCodeGroupementTexte",
isWikicode, verbose)
assert textSection
assert "Communauté de communes des Portes de Sologne" in textSection
if typeCode == "wikicode":
# Vérification sources WEB dans texte généré
urlMinFi = config.get('Extraction', 'dataGouvFr.Comptes')
assert urlMinFi in textSection
urlMinFiGroupements = config.get('Extraction', 'dataGouvFr.ComptesGroupements')
assert urlMinFiGroupements in textSection
if typeCode != "wikicode":
assert "CC des Portes de Sologne" in textSection
assert '200005932' in textSection
assert "4831000" in textSection # charges de fonctionnement
assert "1727000" in textSection # emplois d'investissement
database.closeDatabase(connDB, False)
def test_genCodeGraphiques_OK(isComplet, isWikicode):
""" Test la génération de tous les graphiques """
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Création répertoire de sortie des graphiques
repOutGraphique = config.get('Test',
'genHTMLCodeGraphiques.pathOutputTest')
if not os.path.isdir(repOutGraphique):
os.mkdir(repOutGraphique)
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("Destruction de la base de test :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, True,
False)
# Lecture du modèle
nomBaseModele = config.get('Modele', 'modele.nomBaseModele')
typeSortie = config.get('GenCode', 'gen.idFicDetail')
modele = nomBaseModele + '_' + typeSortie + '.txt'
textSection = utilitaires.lectureFiltreModele(modele, isComplet, False)
# Generation des graphiques pour une ville
textSection = genCodeGraphiques.genCodeGraphiques(config, repOutGraphique,
dictAllGrandeur,
textSection, ville[1],
listAnnees, isComplet,
isWikicode, True, True)
# Test des valeurs générées
if isWikicode:
assert "Graphique polygonal" in textSection
else:
assert ".svg" in textSection
def test_controleSeriesSupprAll():
"""
teste selection des courbes :
suppression de toutes les courbes d'un graphique :
doit lever une exception ValueError
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
# Les courbee de clé "inconnue*" devront être supprimees
# et une exception levee
courbesTest = [
{
'cle': "inconnue1",
'sousCle': "Valeur totale",
},
{
'cle': "inconnue2",
'sousCle': "Valeur totale",
},
]
# Test calcul des valeurs
with pytest.raises(ValueError,
match=r'.*pas de courbe pour le graphique.*'):
genCodeGraphiques.controleSeries(dictAllGrandeur, courbesTest,
listAnnees, True)
# Fermeture base
database.closeDatabase(connDB, True)
def test_genGraphique(courbesTest, nomGraphique, titreGrahique):
"""
teste generation de courbes pour sortie HTML
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Création répertoire de sortie des graphiques
repOutGraphique = config.get('Test', 'genHTMLCodeGraphiques.pathOutputTest')
if not os.path.isdir(repOutGraphique):
os.mkdir(repOutGraphique)
# Suppression fichier existant
nomImage = nomGraphique + '.svg'
cheminImage = os.path.join(repOutGraphique, nomImage)
if os.path.isfile(cheminImage):
print("Image précédente :", cheminImage)
os.remove(cheminImage)
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("Destruction de la base de test :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany("""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
)
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376']
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V',
ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V',
ville[0], False)
assert len(listAnnees) == 3
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur,
listAnnees, True, False)
# Test calcul des valeurs
nbCourbeOrig = len(courbesTest)
anneesOK = genCodeGraphiques.controleSeries(dictAllGrandeur, courbesTest,
listAnnees, False)
# Détermination de l'arrondi à utiliser et à afficher
listeCles = [courbe['cle']
for courbe in courbesTest
if courbe['sousCle'] == "Valeur totale"]
if listeCles:
arrondi, arrondiStr, arrondiStrAffiche = \
utilitaires.setArrondi(dictAllGrandeur["Valeur totale"], anneesOK,
1000.0, listeCles, False)
else:
arrondi = 1.0
arrondiStr = "%"
arrondiStrAffiche = arrondiStr
# Generation des graphiques HTML
textLien = \
genHTMLCodeGraphiques.genGraphique(repOutGraphique, dictAllGrandeur,
nomGraphique, titreGrahique, ville[1],
anneesOK, courbesTest,
arrondi, arrondiStrAffiche,
True)
assert nomGraphique in textLien
assert os.path.isfile(cheminImage)
# Fermeture base
database.closeDatabase(connDB, True)
def test_genCodeTexte_func(typeCode):
"""
test la génération des données texte pour 1 ville : Wittenheim 68)
Choisir Wittenheim et les années 2013 à 2015 pour comparaison avec
http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
print("pathDatabaseMini =", pathDatabaseMini)
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
print("pathCSVMini =", pathCSVMini)
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lecture et filtrage du fichier modèle
nomBaseModele = config.get('Modele', 'modele.nomBaseModele')
numVersion = config.get('Version', 'version.number')
cle = ''
isWikicode = True
if typeCode == "wikiArticle":
cle = 'gen.idFicDetail'
isWikicode = True
elif typeCode == "HTML":
cle = 'gen.idFicHTML'
isWikicode = False
typeSortie = config.get('GenCode', cle)
modele = nomBaseModele + '_' + typeSortie + '.txt'
isComplet = (config.get('Modele', 'modele.type') == 'complet')
textSection = utilitaires.lectureFiltreModele(modele, isComplet, False)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales pour WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], True)
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], True)
print("listAnnees =", listAnnees)
assert len(listAnnees) == 3
infosGroupement = ('200066041', 'Communauté de communes Sundgau',
'CC du Sundgau')
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees,
isWikicode, False)
# Test de la generation du texte
textSection = genCodeTexte.genTexte(config, dictAllGrandeur,
infosGroupement, modele, textSection,
ville, listAnnees, "test_genCodeTexte",
isWikicode, True)
assert "21547710" in textSection
if isWikicode:
# Vérification sources WEB dans texte généré
urlMinFi = config.get('Extraction', 'dataGouvFr.Comptes')
assert urlMinFi in textSection
urlMinFiVilles = config.get('Extraction', 'dataGouvFr.ComptesVilles')
assert urlMinFiVilles in textSection
if not isWikicode:
assert "Sundgau" in textSection
database.closeDatabase(connDB, False)
def test_genCodeTableauxWikicode(isComplet):
"""
teste la génération de tous les tableaux pour 1 ville : Wittenheim 68)
Wittenheim et les années 2013 à 2015 pour comparaison avec
http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
"""
isWikicode = True
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany("""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
)
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
listeVilleWalheim = [ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376']
ville = listeVilleWalheim[0]
# Recup des données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V', ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V',
ville[0], False)
assert len(listAnnees) == 3
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur,
listAnnees, isWikicode, False)
verbose = True
# Lecture du modèle
nomBaseModele = config.get('Modele', 'modele.nomBaseModele')
typeSortie = config.get('GenCode', 'gen.idFicDetail')
modele = nomBaseModele + '_' + typeSortie + '.txt'
textSection = utilitaires.lectureFiltreModele(modele, isComplet, verbose)
textSection = genCodeTableaux.genCodeTableaux(config, dictAllGrandeur,
textSection,
listAnnees, isComplet,
isWikicode, verbose)
# Test valeur des charges en 2015
# (cle charge) : 12659.65
assert "12660" in textSection
# Test valeur des charges par habitant en 2015
# (cle fcharge) : 858.63
assert "859" in textSection
if isComplet:
# Test valeur des charges de la strate en 2015
# (cle mcharge) : 1223.21
assert "1223" in textSection
# Test valeur taux taxe d'habitation en 2015
# (cle tth) : 10.11
assert "10" in textSection
if isComplet:
# Test valeur taux taxe d'habitation pour la strate en 2015
# (cle tmth) : 15.98
assert "16" in textSection
database.closeDatabase(connDB, True)
def test_genGraphique(courbesTest):
"""
teste generation de courbe
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, True,
False)
# Test calcul des valeurs
nbCourbeOrig = len(courbesTest)
anneesOK = genCodeGraphiques.controleSeries(dictAllGrandeur, courbesTest,
listAnnees, False)
# Détermination de l'arrondi à utiliser et à afficher
listeCles = [
courbe['cle'] for courbe in courbesTest
if courbe['sousCle'] == "Valeur totale"
]
if listeCles:
arrondi, arrondiStr, arrondiStrAffiche = \
utilitaires.setArrondi(dictAllGrandeur["Valeur totale"], anneesOK,
1000.0, listeCles, False)
else:
arrondi = 1.0
arrondiStr = "%"
arrondiStrAffiche = arrondiStr
# Generation des graphiques
graphiqueWiki, legendeVille, legendeStrate = \
genWikiCodeGraphiques.genGraphique(config, dictAllGrandeur,
ville[1], anneesOK,
courbesTest,
'graph.largeurPage',
arrondi,
arrondiStrAffiche,
True)
for annee in anneesOK:
assert str(annee) in graphiqueWiki
for courbe in courbesTest:
assert courbe['libelle'] in legendeVille
for courbe in courbesTest:
for annee in anneesOK:
if courbe['cle'].startswith('Taux'):
valeurData = \
round(dictAllGrandeur['Taux'][courbe['cle']][annee])
elif courbe['sousCle'] == "":
valeurData = round(dictAllGrandeur[courbe['cle']][annee])
else:
valeurData = round(
dictAllGrandeur[courbe['sousCle']][courbe['cle']][annee] *
arrondi)
assert str(valeurData) in graphiqueWiki
# Fermeture base
database.closeDatabase(connDB, True)
def test_genereTableau(isWikicode, isComplet):
"""
teste la génération des données tableau pour 1 ville : Wittenheim 68)
Wittenheim et les années 2013 à 2015 pour comparaison avec
http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
nomTableau = "PRINCIPAL"
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
nbAnneesTableau = min(
int(config.get('GenWIkiCode', 'gen.nbLignesTableauxEuros')),
len(listAnnees))
couleurStrate = config.get('Tableaux', 'tableaux.couleurStrate')
couleurTitres = config.get('Tableaux', 'tableaux.couleurTitres')
couleurSolde = config.get('Tableaux', 'tableaux.couleurSolde')
couleurRecettes = config.get('Tableaux', 'tableaux.couleurRecettes')
couleurCharges = config.get('Tableaux', 'tableaux.couleurCharges')
couleurDettesCAF = config.get('Tableaux', 'tableaux.couleurDettesCAF')
couleurEmploisInvest = config.get('Tableaux',
'tableaux.couleurEmploisInvest')
couleurRessourcesInvest = config.get('Tableaux',
'tableaux.couleurRessourcesInvest')
verbose = True
listeValeurs = [
[
"total des produits de fonctionnement",
genCodeCommon.genLien(
config, ["Recettes publiques", "Produits de fonctionnement"],
isWikicode, verbose), couleurRecettes
],
[
"total des charges de fonctionnement",
genCodeCommon.genLien(
config, ["Dépenses publiques", "Charges de fonctionnement"],
isWikicode, verbose), couleurCharges
],
[
"resultat comptable",
genCodeCommon.genLien(config, [
"Résultat fiscal en France",
"Solde de la section de fonctionnement"
], isWikicode, verbose), couleurSolde
],
[
"total des emplois investissement",
genCodeCommon.genLien(config,
["Investissement", "Emplois investissement"],
isWikicode, verbose), couleurEmploisInvest
],
[
"total des ressources d'investissement",
genCodeCommon.genLien(
config, ["Investissement", "Ressources d'investissement"],
isWikicode, verbose), couleurRessourcesInvest
],
[
"besoin ou capacité de financement de la section investissement",
genCodeCommon.genLien(config, [
"Résultat fiscal en France",
"Solde de la section d'investissement"
], isWikicode, verbose), couleurSolde
],
]
# Récupère toutes les valeurs pour cette ville pour les grandeurs demandées
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], verbose)
# Test de la generation tableau
if isWikicode:
ligne = genWikiCodeTableaux.genereTableau(
nomTableau, listAnnees, nbAnneesTableau, listeValeurs,
dictAllGrandeur, couleurTitres, couleurStrate, isComplet, verbose)
else:
ligne = genHTMLCodeTableaux.genereTableau(
nomTableau, listAnnees, nbAnneesTableau, listeValeurs,
dictAllGrandeur, couleurTitres, couleurStrate, isComplet, verbose)
# Test valeur des charges en 2015
# (cle charge) : 12659.65
assert "12660" in ligne
# Test valeur des charges par habitant en 2015
# (cle fcharge) : 858.63
assert "859" in ligne
if isComplet:
# Test valeur des charges de la strate en 2015
# (cle mcharge) : 1223.21
assert "1223" in ligne
def genereCode1Ville(config, connDB, repVille, ville, nomProg, typeCode,
isMatplotlibOk, verbose):
""" Génère le Wikicode pour une ville """
if verbose:
print("Entree dans genereWikicode1Ville")
print("repVille=", repVille)
print('ville =', ville)
print('typeCode =', typeCode)
print('isMatplotlibOk', isMatplotlibOk)
nomBaseModele = config.get('Modele', 'modele.nomBaseModele')
if typeCode == "wikiArticle":
cle = 'gen.idFicDetail'
isWikicode = True
elif typeCode == "wikiSection":
cle = 'gen.idFicSection'
isWikicode = True
else:
cle = 'gen.idFicHTML'
isWikicode = False
typeSortie = config.get('GenCode', cle)
modele = nomBaseModele + '_' + typeSortie + '.txt'
# v2.1.0 : pour cas particulier Paris : Strate = Ville -> pas de strate dans les sorties
if ville[1] == 'Paris':
isComplet = False
else:
isComplet = (config.get('Modele', 'modele.type') == 'complet')
isGroupement = False
# Lecture et filtrage du fichier modèle
textSection = utilitaires.lectureFiltreModele(modele, isComplet, verbose)
# Récupère toutes les données concernant cette ville
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, "V", ville[0], verbose)
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], verbose)
infosGroupement = database.getListeVilleGroupement(connDB, ville[0],
verbose)
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees,
isWikicode, verbose)
# Modification des valeurs simples
textSection = genCodeTexte.genTexte(config, dictAllGrandeur,
infosGroupement, modele, textSection,
ville, listAnnees, nomProg, isWikicode,
verbose)
# Définit le contenu des tableaux picto
grandeursAnalyse = genCodeTableaux.defTableauxPicto(
config, dictAllGrandeur, listAnnees, isWikicode, verbose)
# Génération des tableaux pictogrammes
textSection = genCodeCommon.genCodeTableauxPicto(
config, dictAllGrandeur, grandeursAnalyse, textSection, listAnnees,
isComplet, isWikicode, True, isGroupement, verbose)
# Génération des tableaux
textSection = genCodeTableaux.genCodeTableaux(config, dictAllGrandeur,
textSection, listAnnees,
isComplet, isWikicode,
verbose)
# Generation des graphiques
textSection = genCodeGraphiques.genCodeGraphiques(
config, repVille, dictAllGrandeur, textSection, ville[1], listAnnees,
isComplet, isWikicode, isMatplotlibOk, verbose)
if verbose:
print("Sortie de genereCode1Ville")
return textSection
def genereCode1Groupement(config, connDB, repGroupement, groupement, nomProg,
typeCode, isMatplotlibOk, verbose):
""" Génère le Wikicode pour un groupement """
if verbose:
print("Entree dans genereWikicode1Groupement")
print("repGroupement=", repGroupement)
print("typeCode=", typeCode)
print('groupement =', groupement)
print('isMatplotlibOk', isMatplotlibOk)
isWikicode = (typeCode == "wikicode")
modele = 'modele_groupement_' + typeCode + '.txt'
isComplet = False
isGroupement = True
# Lecture du fichier modèle
with open(modele, 'r', encoding='utf-8') as modelefile:
textSection = modelefile.read()
# Récupère toutes les données concernant ce groupement
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, "GC", groupement[0], verbose)
# On ne génère pas les communauté de communes sans donnée MinFi
if "Valeur totale" in dictAllGrandeur:
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'GC', groupement[0], verbose)
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees,
isWikicode, verbose)
# Modification des valeurs simples
textSection = genCodeGroupementTexte.genTexte(
config, dictAllGrandeur, modele, textSection, groupement,
listAnnees, nomProg, isWikicode, verbose)
# Définit le contenu des tableaux picto
grandeursAnalyse = genCodeGroupementTableaux.defTableauxGroupementPicto(
config, dictAllGrandeur, listAnnees, isWikicode, verbose)
# Génération des tableaux pictogrammes
textSection = genCodeCommon.genCodeTableauxPicto(
config, dictAllGrandeur, grandeursAnalyse, textSection,
listAnnees, isComplet, isWikicode, False, isGroupement,
verbose)
# Génération des tableaux
textSection = genCodeTableaux.genCodeTableaux(
config, dictAllGrandeur, textSection, listAnnees, False,
isWikicode, verbose)
# Generation des graphiques
textSection = genCodeGraphiques.genCodeGraphiques(
config, repGroupement, dictAllGrandeur, textSection,
groupement[2], listAnnees, False, isWikicode, isMatplotlibOk,
verbose)
# Suppression chaine ratio dont je ne trouve pas l'origine
textSection = textSection.replace(', ratio ', '')
if verbose:
print("Sortie de genereCode1Groupement")
return textSection
