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)