def test_analyseLigneVille_Manque_Champ():
""" Ligne de description d'une ville trop courte : 3 champs au lieu de 4
manque champ tmth """
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Recup chemin base de test
databasePathDir = config.get('Test', 'database.testDir')
databasePath = os.path.join(databasePathDir,
config.get('Test', 'database.testName'))
# Création base
connDB = database.createDatabase(config, databasePath, False)
dictPositionColumns, listMissingKeys = \
updateDataMinFiCommon.getColumnPosition('dep;icom;prod;fprod;mprod;tmth',
"V", connDB, False)
with pytest.raises(ValueError, match=r'manque clé tmth'):
dictValues = updateDataMinFi.analyseLigneVille(config,
'068;101;25.6;2.5;4.7',
dictPositionColumns,
True)
# Fermeture base
database.closeDatabase(connDB, True)
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_createDbDataMinFiGroupement():
"""
Test génération database avec un fichier groupement de communes
CSV réduit à 2 villes
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# 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)
# WALHEIM : CC SUNDGAU non présente dans fichier CSV, ne doit pas apparaitre dans résultats
# ARDON : CC Portes de Sologne présente dans fichier CSV, doit apparaitre
connDB.executemany("""
INSERT INTO villes(codeCommune, nomMinFi, sirenGroupement)
VALUES (?, ?, ?)
""", (('068356', 'WALHEIM', '200066041'), ('045006', 'ARDON', '200005932')))
connDB.executemany("""
INSERT INTO groupementCommunes(sirenGroupement, nom)
VALUES (?, ?)
""", (('200066041', 'Communauté de communes Sundgau'),
('200005932', 'Communauté de communes des Portes de Sologne')))
connDB.commit()
database.closeDatabase(connDB, True)
# Appel programme
param = ['updateDataMinFiGroupementCommunes.py', pathDatabaseMini, pathCSVMini]
updateDataMinFiGroupementCommunes.main(param)
assert os.path.isfile(pathDatabaseMini)
# Test info CC Portes de Sologne présentes dans dataFiGroupement
connDB = sqlite3.connect(pathDatabaseMini)
cursor = connDB.cursor()
cursor.execute("SELECT DISTINCT sirenGroupement, annee FROM dataFiGroupement")
listSirenAnnee = cursor.fetchall()
assert len(listSirenAnnee) == 1
assert listSirenAnnee[0] == ('200005932', 2018)
cursor.execute("SELECT sirenGroupement, annee, codeCle, valeur FROM dataFiGroupement")
listCleValeur = cursor.fetchall()
assert len(listCleValeur) > 1
assert ('200005932', 2018, 'pftot', '6526.0') in listCleValeur
assert ('200005932', 2018, 'pftothab', '417.0') in listCleValeur
cursor.close()
connDB.close()
def test_genereCode1Ville_OK(typeCode):
""" test génération des données pour une ville """
# Contournement OS X and Linux : invalide locale
if platform.system() in ('Darwin', 'Linux'):
locale.setlocale(locale.LC_ALL, os.getenv('LANG'))
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
nomProg = "test_genereCode1Ville"
# Création répertoire de sortie hebergeant les villes
repVilles = config.get('Test', 'genCode.pathVilles')
if not os.path.isdir(repVilles):
os.mkdir(repVilles)
# 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 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]
# Test fonction de génération
genereCode1Ville.genereCode1Ville(config, connDB, repVilles, ville,
nomProg, typeCode, True, True)
# Fermeture base
database.closeDatabase(connDB, False)
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 a_voir_test_genereCode1Ville_55(typeCode):
"""
test génération des données pour une ville du département 55
qui pose des problèmes au 21/11/2021 : donnees incompletes
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
nomProg = "test_genereCode1Ville"
# Création répertoire de sortie hebergeant les villes
repVilles = config.get('Test', 'genCode.pathVilles55')
if not os.path.isdir(repVilles):
os.mkdir(repVilles)
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini55')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini55')
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 (?, ?, ?, ?)
""", (('055039', 'BEAUMONT-EN-VERDUNOIS', 'Beaumont-en-Verdunois',
'Beaumont-en-Verdunois'), ))
connDB.commit()
# 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
listeVille = database.getListeVilles4Departement(connDB, '055', True)
ville = listeVille[0]
# Test fonction de génération
genereCode1Ville.genereCode1Ville(config, connDB, repVilles, ville,
nomProg, typeCode, True, True)
# Fermeture base
database.closeDatabase(connDB, False)
def test_createDbDataMinFi():
"""
Test génération database avec un fichier CSV réduit à 2 villes
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'updateDataMinFi.pathDatabaseMini')
pathCSVMini = config.get('Test', 'updateDataMinFi.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)
VALUES (?, ?)
""", (('068356', 'WALHEIM'), ('040281', 'ST PIERRE DU MONT')))
connDB.commit()
database.closeDatabase(connDB, True)
# Appel programme
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Test info ville 1
connDB = sqlite3.connect(pathDatabaseMini)
cursor = connDB.cursor()
cursor.execute(
"SELECT codeCommune, nomMinFi, nomStrate FROM villes ORDER BY codeCommune"
)
listVilles = cursor.fetchall()
assert len(listVilles) == 2
assert listVilles[0][0] == '040281'
assert listVilles[0][1] == 'ST PIERRE DU MONT'
assert listVilles[0][2] == "n'appartenant à aucun groupement fiscalisé"
assert listVilles[1][0] == '068356'
assert listVilles[1][1] == 'WALHEIM'
assert listVilles[1][2] == "n'appartenant à aucun groupement fiscalisé"
cursor.close()
connDB.close()
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_getColumnPosition_Pb():
""" Test cas d'erreur fonction de validation d'un répertoire contenant les données
issues du site gouvernemental
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Recup chemin base de test
databasePathDir = config.get('Test', 'database.testDir')
databasePath = os.path.join(databasePathDir, config.get('Test', 'database.testName'))
# Création base
connDB = database.createDatabase(config, databasePath, True)
with pytest.raises(ValueError,
match=r".*Entete CSV non valide.*"):
dictPositionColumns, listMissingKeys = \
updateDataMinFiCommon.getColumnPosition("Entete tout moisi",
"V", connDB, True)
database.closeDatabase(connDB, True)
def test_analyseLigneGroupement(ligneGroupement, header, dictVerif):
""" Récupération des valeurs dans une ligne de valeur pour une ville """
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Recup chemin base de test
databasePathDir = config.get('Test', 'database.testDir')
databasePath = os.path.join(databasePathDir, config.get('Test', 'database.testName'))
# Création base
connDB = database.createDatabase(config, databasePath, False)
dictPositionColumns, listMissingKeys = \
updateDataMinFiCommon.getColumnPosition(header, "GC", connDB, False)
dictValues = updateDataMinFiGroupementCommunes.analyseLigneGroupement(ligneGroupement,
dictPositionColumns,
True)
assert dictValues == dictVerif
# Fermeture base
database.closeDatabase(connDB, True)
def test_getColumnPosition(headerTest, dictKeyOk, missingKey):
""" Récupération position des mots clés de la table dans l'entête de test """
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Recup chemin base de test
databasePathDir = config.get('Test', 'database.testDir')
databasePath = os.path.join(databasePathDir, config.get('Test', 'database.testName'))
# Création base
connDB = database.createDatabase(config, databasePath, True)
dictPositionColumns, listMissingKeys = \
updateDataMinFiCommon.getColumnPosition(headerTest, "V", connDB, True)
# Controle des clés présentes et de leur position dans headerTest
for keyOk in dictKeyOk:
assert dictPositionColumns[keyOk] == dictKeyOk[keyOk]
if listMissingKeys:
assert missingKey in listMissingKeys
else:
assert not missingKey
database.closeDatabase(connDB, True)
displayMembers(userId, listName, memberNames, memberIds,
currentPage + 1)
if (userSelection == UserInput.scrollUpInput):
displayMembers(userId, listName, memberNames, memberIds,
currentPage - 1)
if (userSelection == 'back'):
displayYourLists(userId)
if (userSelection == 'delete'):
while (True):
selection = input(
"Which member (by number) would you like to delete? ")
if isInt(selection) is False:
print("Please input a number")
continue
elif (int(selection) <= (currentPage * 5) - 5
or int(selection) > currentPage * 5
or int(selection) > len(memberIds)):
print("Selection out of bounds")
continue
else:
print("User has been deleted")
database.deleteMember(listName, memberIds[int(selection) - 1])
break
displayMembers(userId, listName, memberNames, memberIds, currentPage)
# connect to the database, oracle id and pass should be specified in file
# called connection.info
welcomeScreen()
database.closeDatabase()
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_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_genCodeProg(verbose):
"""
Teste le programme de génération du code Wiki et HTML
sur base de test 1 ville et 3 années.
"""
# Contournement OS X and Linux : invalide locale
if platform.system() in ('Darwin', 'Linux'):
locale.setlocale(locale.LC_ALL, os.getenv('LANG'))
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Ménage répertoire de sortie
pathOutput = config.get('Test', 'genCode.pathOutput')
resultatsPath = pathOutput
print("resultatsPath =", resultatsPath)
if os.path.isdir(resultatsPath):
print("Effacement de :", resultatsPath)
shutil.rmtree(resultatsPath)
# 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 base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Test du programme genCode
if verbose:
param = ['genCode.py', '-v', pathDatabaseMini, resultatsPath]
else:
param = ['genCode.py', pathDatabaseMini, resultatsPath]
genCode.main(param)
# Vérif des résultats
assert os.path.isdir(resultatsPath)
assert os.path.isdir(os.path.join(resultatsPath, "Departement_068"))
assert os.path.isfile(
os.path.join(resultatsPath, "Departement_068", "index.html"))
assert os.path.isdir(
os.path.join(resultatsPath, "Departement_068", "Wittenheim"))
assert os.path.isfile(
os.path.join(resultatsPath, "Departement_068", "Wittenheim",
"Wittenheim.html"))
assert os.path.isfile(
os.path.join(resultatsPath, "Departement_068", "Wittenheim",
"Wittenheim_wikicode.html"))
assert os.path.isfile(
os.path.join(resultatsPath, "Departement_068", "Wittenheim",
"CHARGES_FINANCIERES_SUBVENTIONS_VERSEES.svg"))
# Fermeture base
database.closeDatabase(connDB, False)
def main(argv=None):
"""
Met à jour les données de groupement de communes de
la base de données du ministère des finances
à partir des fichiers .csv du répertoire passé en paramètres.
"""
# Valeur par défaut des options
verbose = False
# Lecture du fichier de propriétés
config = configparser.RawConfigParser()
ficProperties = 'FinancesLocales.properties'
config.read(ficProperties)
#############################
# Analyse des arguments reçus
#############################
if argv is None:
argv = sys.argv
nomProg = os.path.basename(argv[0])
# parse command line options
try:
opts, args = getopt.getopt(argv[1:], "huvV",
["help", "usage", "version", "verbose"])
except getopt.error as msg:
print(msg)
print("Pour avoir de l'aide : --help ou -h", file=sys.stderr)
sys.exit(1)
# process options
for opt in opts:
verboseOpt, sortiePgm = \
utilitaires.traiteOptionStd(config, opt[0], nomProg, __doc__, \
['database/minfi.db ../recup_data_gouv_fr_colectivite/comptes-groupements.csv'])
verbose = verbose or verboseOpt
if sortiePgm:
sys.exit(0)
utilitaires.checkPythonVersion(config, verbose)
# Récuperation et analyse des paramètres
if len(args) != 2:
msg = __doc__ + "\nDonnez au moins 2 paramètres :\n" + \
"chemin base .db et fichier .csv !" + \
"\nau lieu de : " + str(len(args))
print(msg, file=sys.stderr)
sys.exit(1)
# Vérifie et récupère le nom de la base à mettre à jour
databasePath = args[0]
if not databasePath.endswith(".db"):
msg = __doc__ + "Erreur : Le nom de la base de donnée doit se terminer par .db :\n" + \
databasePath
print(msg, file=sys.stderr)
sys.exit(2)
# Vérifie et récupère les noms des fichiers de données du ministère des finances
pathCSVDataGouvFr = args[1]
if not os.path.isfile(pathCSVDataGouvFr):
msg = __doc__ + "Erreur : paramètre fichier .csv !\n" + \
"Ce fichiers .csv doit être récupérés sur\n" + \
config.get('Extraction', 'dataGouvFr.ComptesComptesGroupements') + ":\n" + \
pathCSVDataGouvFr
print(msg, file=sys.stderr)
sys.exit(3)
print('Début de', nomProg)
# Crée la base de données si elle n'existe pas
connDB = database.createDatabase(config, databasePath, verbose)
# Récupère les numéros de SIREN des groupements dans la base
# ainsi que leurs noms et années des infos financières déjà enregistrées.
dictSirenInfos = database.getSirenInfosGroupementsAnnees(connDB, verbose)
if not dictSirenInfos:
msg = "Erreur : La base de données :\n" + databasePath + \
"\n ne contient aucun groupement de commune à extraire," +\
"lancer updateGroupementsCommunes"
print(msg, file=sys.stderr)
# Met à jour la base de données le fichier .CSV passé en paramètres
print("Traitement de :", pathCSVDataGouvFr, "...")
with open(pathCSVDataGouvFr,
mode='rt',
buffering=config.getint('Extraction',
'updateDataMinFi.bufferReadingSize'),
encoding='utf-8') as hFicMinFi:
# Analyse l'entête du fichier
header = hFicMinFi.readline().strip()
dictPositionColumns, listMissingKeys = \
updateDataMinFiCommon.getColumnPosition(header, "GC",
connDB, verbose)
# Print missing columns
if len(listMissingKeys) > 0:
print("Attention : les motcles suivants n'ont pas été trouvés :\n",
";".join(listMissingKeys))
# Enregistre si nécessaire chaque ligne du fichier
numLine = 1
numGroupement = 0
for ligneVille in hFicMinFi:
numLine += 1
dictValues = analyseLigneGroupement(ligneVille,
dictPositionColumns, verbose)
# Analyse et enregistre les valeurs de cette ligne
if "siren" in dictValues and dictValues["siren"].isdigit() and \
len(dictValues["siren"]) == 9 and \
"exer" in dictValues and dictValues["exer"].isdigit() and \
len(dictValues["exer"]) == 4 and \
dictValues["siren"] in dictSirenInfos and \
int(dictValues["exer"]) not in dictSirenInfos[dictValues["siren"]][2]:
numGroupement += 1
database.enregistreLigneGroupementMinFi(
dictValues, connDB, verbose)
print('.', end='', flush=True)
else:
print('X', end='', flush=True)
print("\n", numLine - 1, "lignes traitées,", numGroupement,
"groupements enregistrés")
# Ferme la base de données
database.closeDatabase(connDB, verbose)
def onClose(self):
db.closeDatabase()
def main(argv=None):
""" Génère le Wikicode et du HTML pour les villes d'un département """
# Valeur par défaut des options
verbose = False
# Lecture du fichier de propriétés
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
#############################
# Analyse des arguments reçus
#############################
if argv is None:
argv = sys.argv
nomProg = os.path.basename(argv[0])
# parse command line options
try:
opts, args = getopt.getopt(argv[1:], "huvV",
["help", "usage", "version", "verbose"])
except getopt.error as msg:
print(msg)
print("To get help use --help ou -h")
sys.exit(1)
# process options
for opt in opts:
verboseOpt, sortiePgm = \
utilitaires.traiteOptionStd(config, opt[0], nomProg, __doc__,
["../database/minfi.db ../Resultats",])
verbose = verbose or verboseOpt
if sortiePgm:
sys.exit(0)
utilitaires.checkPythonVersion(config, verbose)
isMatplotlibOk = utilitaires.checkMatplolibOK()
if len(args) != 2:
print(f'{__doc__}\nDonnez 2 paramètres :\n'
"chemin base .db et chemin des résultats !"
f"\nau lieu de : {len(args)}")
sys.exit(1)
databasePath = args[0]
if not os.path.isfile(databasePath):
raise ValueError(
f"Le fichier base de données {databasePath} n'existe pas !")
if not args[1]:
raise ValueError("Donnez un chemin de répertoire résultat !")
resultatsPath = os.path.normcase(args[1])
print('Début de', nomProg)
print("databasePath =", databasePath)
print("resultatsPath =", resultatsPath)
genCodeCommon.createResultDir(config, resultatsPath)
# Ouvre la base de données
connDB = database.createDatabase(config, databasePath, verbose)
# Récup et traitement des départements
traiteDepartement(config, nomProg, isMatplotlibOk, connDB, resultatsPath,
verbose)
# Ferme la base de données
database.closeDatabase(connDB, verbose)
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_updateGroupementsCommunesProg():
"""
Test le programme de mise à jour dans la base les groupements de
communes en recherchant leur information pour
chaque villes enregistrée dans Wikipedia FR
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseCC = os.path.join(config.get('Test', 'database.testDir'),
config.get('Test', 'database.testNameCC'))
print("\test_updateGroupementsCommunesProg : base =", pathDatabaseCC)
if os.path.isfile(pathDatabaseCC):
print("destruction de la base :", pathDatabaseCC)
os.remove(pathDatabaseCC)
# Insertion dans la table villes des villes existantes
# Création base
connDB = database.createDatabase(config, pathDatabaseCC, False)
# Villes dont il faut chercher les infos Siren + groupement de commune
listeCodenomWkpFrCommune = (
('040001',
"Aire-sur-l'Adour"), # Commune avec nom complexe dans l'infobox CC
('068376', 'Wittenheim'),
('046132', 'Issendolus'),
('046128', 'Gramat'),
('075056', 'Paris'), # Commune sans nom dans l'infobox CC
('012021', "La Bastide-l'Évêque") # Ancienne commune de France
)
connDB.executemany(
"INSERT INTO villes(codeCommune, nomWkpFr) VALUES (?, ?)",
listeCodenomWkpFrCommune)
# Groupement de commune déjà existant dans la base pour tester mise à jour
connDB.executemany(
"""
INSERT INTO groupementCommunes(nomArticleCC, nom, sirenGroupement)
VALUES (?, ?, ?)
""", (('Communauté_de_communes_Grand-Figeac_(nouvelle)',
'CC Grand Figeac', '200067361'), ))
connDB.commit()
# Test du programme updateGroupementsCommunes
param = ['updateGroupementsCommunes.py', '-v', pathDatabaseCC]
updateGroupementsCommunes.main(param)
# Contrôle des valeurs de la base
cursor = connDB.cursor()
cursor.execute("SELECT sirenGroupement FROM villes")
listSirenGroupement = cursor.fetchall()
assert len(listSirenGroupement) == len(listeCodenomWkpFrCommune)
listNumSiren = [numSiren[0] for numSiren in listSirenGroupement]
for numSirenOK in ('200030435', '200067361', '200066009', '200066371',
'200054781'):
assert numSirenOK in listNumSiren
cursor.execute("SELECT sirenGroupement, nom FROM groupementCommunes")
listResultat = cursor.fetchall()
for tupple in (('200030435', "Communauté de communes d'Aire-sur-l'Adour"),
('200067361',
"Communauté de communes Grand-Figeac (nouvelle)"),
('200066009', "Mulhouse Alsace Agglomération"),
('200066371',
"Communauté de communes Causses et Vallée de la Dordogne"),
('200054781', "Métropole du Grand Paris")):
assert tupple in listResultat
# Fermeture base
cursor.close()
database.closeDatabase(connDB, True)
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_genereCode1Goupement_OK(typeCode):
""" test génération des données pour un groupement """
# Contournement OS X and Linux : invalide locale
if platform.system() in ('Darwin', 'Linux'):
locale.setlocale(locale.LC_ALL, os.getenv('LANG'))
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
nomProg = "test_genereCode1Goupement"
# Création répertoire de production des Groupements de communes
repGroupements = config.get('Test', 'genCode.pathGroupements')
if not os.path.isdir(repGroupements):
os.mkdir(repGroupements)
# 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, True)
assert len(listGroupements) == 1
groupement = listGroupements[0]
# Création répertoire de sortie hebergeant les Groupements de communes
repGroupementsOutput = config.get('Test', 'genCode.pathGroupementsOutput')
if not os.path.isdir(repGroupementsOutput):
os.mkdir(repGroupementsOutput)
# Test fonction de génération
genereCode1Groupement.genereCode1Groupement(config, connDB,
repGroupementsOutput, groupement,
nomProg, typeCode,
True, True)
# Fermeture base
database.closeDatabase(connDB, False)
def test_genCodeGroupementProg(verbose):
"""
Teste le programme de génération du code Wiki et HTML
sur base de test 1 ville et 3 années.
"""
# Contournement OS X and Linux : invalide locale
if platform.system() in ('Darwin', 'Linux'):
locale.setlocale(locale.LC_ALL, os.getenv('LANG'))
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Ménage répertoire de sortie
resultatsPath = config.get('Test', 'genCode.pathGroupementsOutput')
print("resultatsPath =", resultatsPath)
if os.path.isdir(resultatsPath):
print("Effacement de :", resultatsPath)
shutil.rmtree(resultatsPath)
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()
assert os.path.isfile(pathDatabaseMini)
# Appel programme
param = ['updateDataMinFiGroupementCommunes.py',
pathDatabaseMini, pathCSVMini]
updateDataMinFiGroupementCommunes.main(param)
isComplet = True
# Test du programme genCode
if verbose:
param = ['genCodeGroupement.py', '-v', pathDatabaseMini, resultatsPath]
else:
param = ['genCodeGroupement.py', pathDatabaseMini, resultatsPath]
genCodeGroupement.main(param)
# Vérif des résultats
assert os.path.isdir(resultatsPath)
assert os.path.isdir(os.path.join(resultatsPath, "Groupements"))
assert os.path.isdir(os.path.join(resultatsPath,
"Groupements",
"Communaute_de_communes_des_Portes_de_Sologne"))
assert os.path.isfile(os.path.join(resultatsPath,
"Groupements",
"index_groupement.html"))
assert os.path.isfile(os.path.join(resultatsPath,
"Groupements",
"Communaute_de_communes_des_Portes_de_Sologne",
"Communaute_de_communes_des_Portes_de_Sologne_HTML.html"))
assert os.path.isfile(os.path.join(resultatsPath,
"Groupements",
"Communaute_de_communes_des_Portes_de_Sologne",
"Communaute_de_communes_des_Portes_de_Sologne_wikicode.html"))
# Fermeture base
database.closeDatabase(connDB, False)
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_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_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_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 main(argv=None):
"""
Met à jour la base de données du ministère des finances
à partir des fichiers .csv du répertoire passé en paramètres.
"""
# Valeur par défaut des options
verbose = False
# Lecture du fichier de propriétés
config = configparser.RawConfigParser()
ficProperties = 'FinancesLocales.properties'
config.read(ficProperties)
#############################
# Analyse des arguments reçus
#############################
if argv is None:
argv = sys.argv
nomProg = os.path.basename(argv[0])
# parse command line options
try:
opts, args = getopt.getopt(argv[1:], "huVv",
["help", "usage", "version", "verbose"])
except getopt.error as msg:
print(msg)
print("Pour avoir de l'aide : --help ou -h", file=sys.stderr)
sys.exit(1)
# process options
for option, arg in opts:
verboseOpt, sortiePgm = \
utilitaires.traiteOptionStd(config, option, nomProg, __doc__,
['database/minfi.db ../recup_data_gouv_fr'])
verbose = verbose or verboseOpt
if sortiePgm:
sys.exit(0)
utilitaires.checkPythonVersion(config, verbose)
# Récuperation et analyse des paramètres
if len(args) != 2:
msg = __doc__ + "\nDonnez au moins 2 paramètres :\n" + \
"chemin base .db et répertoire des .csv !" + \
"\nau lieu de : " + str(len(args))
print(msg, file=sys.stderr)
sys.exit(1)
# Vérifie et récupère le nom de la base à mettre à jour
databasePath = args[0]
if not databasePath.endswith(".db"):
msg = __doc__ + "Erreur : Le nom de la base de donnée doit se terminer par .db :\n" + \
databasePath
print(msg, file=sys.stderr)
sys.exit(2)
# Vérifie et récupère les noms des fichiers de données du ministère des finances
pathCSVDataGouvFr = args[1]
listFileCSVMinFi = []
try:
listFileCSVMinFi = checkPathCSVDataGouvFr(config, pathCSVDataGouvFr,
verbose)
except ValueError as exc:
msg = __doc__ + "Erreur : paramètre répertoire des .csv !\n" + \
"Ce repertoire doit contenir les fichiers .csv" + \
"de données récupérés sur\n" + \
config.get('Extraction', 'dataGouvFr.Comptes') + "\n" + \
str(exc)
print(msg, file=sys.stderr)
sys.exit(3)
print('Début de', nomProg)
# Crée la base de données si elle n'existe pas
connDB = database.createDatabase(config, databasePath, verbose)
# récupère la liste des villes et des années présentes dans la base
dictCodeCommuneAnnees = database.getDictCodeCommuneAnnees(connDB, verbose)
if not dictCodeCommuneAnnees:
msg = "Erreur : La base de données :\n" + databasePath + \
"\n ne contient aucune ville à extraire, lancer extractionWikipediaFr"
print(msg, file=sys.stderr)
# Met à jour la base de données avec chaque fichier .CSV trouvé
for fileCSVMinFi in listFileCSVMinFi:
print("Traitement de :", fileCSVMinFi, "...")
with open(fileCSVMinFi,
mode='rt',
buffering=config.getint('Extraction',
'updateDataMinFi.bufferReadingSize'),
encoding='utf-8') as hFicMinFi:
# Analyse l'entête du fichier
header = hFicMinFi.readline().strip()
dictPositionColumns, listMissingKeys = \
updateDataMinFiCommon.getColumnPosition(header, "V",
connDB, verbose)
# Print missing columns
if len(listMissingKeys) > 0:
print(
"Attention : les motcles suivants n'ont pas été trouvés :\n",
";".join(listMissingKeys))
# Enregistre si nécessaire chaque ligne du fichier
numLine = 1
for ligneVille in hFicMinFi:
numLine += 1
dictValues = analyseLigneVille(config, ligneVille,
dictPositionColumns, verbose)
if dictValues['codeCommune'] in dictCodeCommuneAnnees and \
int(dictValues[config.get("cleFi1Valeur", "clefi.annee")]) \
not in dictCodeCommuneAnnees[dictValues['codeCommune']]:
database.enregistreLigneVilleMinFi(config, dictValues,
connDB, verbose)
print(numLine - 1, "villes traitées.")
# Ferme la base de données
database.closeDatabase(connDB, verbose)
