Exemplo n.º 1
0
def test_controleSeriesOK(courbesTest):
    """
        teste selection des courbes : valeurs OK
    """

    config = configparser.RawConfigParser()
    config.read('FinancesLocales.properties')

    # récup données de test
    pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
    pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
    if os.path.isfile(pathDatabaseMini):
        print("destruction de la base :", pathDatabaseMini)
        os.remove(pathDatabaseMini)

    # Insertion dans la table ville des villes à traiter
    # Création base
    connDB = database.createDatabase(config, pathDatabaseMini, False)
    connDB.executemany(
        """
        INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
        VALUES (?, ?, ?, ?)
        """, (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
    connDB.commit()

    # Création de la création de la base de test
    param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
    updateDataMinFi.main(param)
    assert os.path.isfile(pathDatabaseMini)

    # Lit dans la base les infos concernant la ville à traiter
    listeVilleWalheim = [
        ville
        for ville in database.getListeVilles4Departement(connDB, '068', False)
        if ville[0] == '068376'
    ]
    ville = listeVilleWalheim[0]

    # Recup des annees de données fiscales por WALHEIN
    dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
        connDB, 'V', ville[0], False)
    listAnnees = database.getListeAnneesDataMinFi4Entite(
        connDB, 'V', ville[0], False)
    assert len(listAnnees) == 3

    # Grandeurs calculées
    genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, True,
                                  False)

    # Test calcul des valeurs
    nbCourbeOrig = len(courbesTest)
    anneesOK = genCodeGraphiques.controleSeries(dictAllGrandeur, courbesTest,
                                                listAnnees, True)
    assert anneesOK == sorted(listAnnees)
    assert nbCourbeOrig == len(courbesTest)

    # Fermeture base
    database.closeDatabase(connDB, True)
def test_calculeGrandeur(isWikicode):
    """
        teste le calcule de grandeurs agglomérées
    """

    config = configparser.RawConfigParser()
    config.read('FinancesLocales.properties')

    # récup données de test
    pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
    pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
    if os.path.isfile(pathDatabaseMini):
        print("destruction de la base :", pathDatabaseMini)
        os.remove(pathDatabaseMini)

    # Insertion dans la table ville des villes à traiter
    # Création base
    connDB = database.createDatabase(config, pathDatabaseMini, False)
    connDB.executemany("""
        INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
        VALUES (?, ?, ?, ?)
        """, (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
                       )
    connDB.commit()

    # Création de la création de la base de test
    param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
    updateDataMinFi.main(param)
    assert os.path.isfile(pathDatabaseMini)

    # Lit dans la base les infos concernant la ville à traiter
    listeVilleWalheim = [ville
                         for ville in database.getListeVilles4Departement(connDB, '068', False)
                         if ville[0] == '068376']
    ville = listeVilleWalheim[0]

    # Recup des annees de données fiscales por WALHEIN
    dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V',
                                                             ville[0], True)
    listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V', ville[0], True)
    assert len(listAnnees) == 3

    # Test calcul des valeurs
    genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, isWikicode, True)
    for grandeur in ["tendance ratio", "ratio dette / caf", "ratio n"]:
        assert grandeur in dictAllGrandeur

    # Fermeture base
    database.closeDatabase(connDB, True)
Exemplo n.º 3
0
def test_getTendanceRatioDetteCAF():
    """ Test calcule de tendance du rapport dette/CAF """
    
    config = configparser.RawConfigParser()
    config.read('FinancesLocales.properties')

    # Recup chemin base de test et ménage
    databasePathDir = config.get('Test', 'database.testDir')
    databasePath = os.path.join(databasePathDir, config.get('Test', 'database.testName'))
    if not os.path.isdir(databasePathDir):
        os.mkdir(databasePathDir)
    if os.path.isfile(databasePath):
        os.remove(databasePath)

    # Création base vide
    connDB = database.createDatabase(config, databasePath, False)
    assert os.path.isfile(databasePath)
    assert connDB

    # Insertion données dette et CAF pour une commune
    codeDette = config['cleFi3Valeurs']["clefi.encours de la dette au 31 12 n"]
    codeCAF = config['cleFi3Valeurs']["clefi.capacité autofinancement caf"]
    connDB.executemany("""
        INSERT INTO dataFi(codeCommune, annee, codeCle, valeur)
        VALUES (?, ?, ?, ?)
        """,
            (
                ('001008', 2000, codeCAF, 1), ('001008', 2001, codeCAF, 1),
                ('001008', 2002, codeCAF, 1),
                ('001008', 2000, codeDette, 25), ('001008', 2001, codeDette, 23),
                ('001008', 2002, codeDette, 24)
            ))
    connDB.commit()
    
    # Récupère toutes les données concernant cette ville
    dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V',
                                                             '001008', False)
    listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V',
                                                         '001008', False)

    # Test
    tendanceRatio, dicoRatio = ratioTendance.getTendanceRatioDetteCAF(config, dictAllGrandeur,
                                                                      True, True)
    assert "est constant et élevé (supérieur à" in tendanceRatio
    
    database.closeDatabase(connDB, True)
def test_genereTableauTaux(isWikicode, isComplet):
    """
        teste la génération des données tableau des taux
        pour 1 ville : Wittenheim 68)
        Wittenheim et les années 2013 à 2015 pour comparaison avec
        http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
    """

    config = configparser.RawConfigParser()
    config.read('FinancesLocales.properties')

    # récup données de test
    pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
    pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
    if os.path.isfile(pathDatabaseMini):
        print("destruction de la base :", pathDatabaseMini)
        os.remove(pathDatabaseMini)

    # Insertion dans la table ville des villes à traiter
    # Création base
    connDB = database.createDatabase(config, pathDatabaseMini, False)
    connDB.executemany(
        """
        INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
        VALUES (?, ?, ?, ?)
        """, (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
    connDB.commit()

    # Création de la création de la base de test
    param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
    updateDataMinFi.main(param)
    assert os.path.isfile(pathDatabaseMini)

    nomTableau = "TAXES"
    listeVilleWalheim = [
        ville
        for ville in database.getListeVilles4Departement(connDB, '068', False)
        if ville[0] == '068376'
    ]
    ville = listeVilleWalheim[0]
    # Recup des annees de données fiscales por WALHEIN
    listAnnees = database.getListeAnneesDataMinFi4Entite(
        connDB, 'V', ville[0], False)
    assert len(listAnnees) == 3
    nbAnneesTableau = min(
        int(config.get('GenWIkiCode', 'gen.nbLignesTableauxEuros')),
        len(listAnnees))

    couleurStrate = config.get('Tableaux', 'tableaux.couleurStrate')
    couleurTitres = config.get('Tableaux', 'tableaux.couleurTitres')
    couleurTaxeHabitation = config.get('Tableaux',
                                       'tableaux.couleurTaxeHabitation')
    couleurTaxeFonciereBati = config.get('Tableaux',
                                         'tableaux.couleurTaxeFonciereBati')
    couleurTaxeFonciereNonBati = config.get(
        'Tableaux', 'tableaux.couleurTaxeFonciereNonBati')

    verbose = False
    listeValeurs = [
        [
            "taux taxe habitation", "taux taxe d'habitation",
            couleurTaxeHabitation
        ],
        [
            "taux taxe foncière bâti", "taux foncier bâti",
            couleurTaxeFonciereBati
        ],
        [
            "taux taxe foncière non bâti", "taux foncier non bâti",
            couleurTaxeFonciereNonBati
        ],
    ]

    # Récupère toutes les valeurs pour cette ville pour les grandeurs demandées
    dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
        connDB, 'V', ville[0], verbose)

    # Test de la generation tableau
    if isWikicode:
        ligne = genWikiCodeTableaux.genereTableauTaux(
            nomTableau, listAnnees, nbAnneesTableau, listeValeurs,
            dictAllGrandeur, couleurTitres, couleurStrate, isComplet, verbose)
    else:
        ligne = genHTMLCodeTableaux.genereTableauTaux(
            nomTableau, listAnnees, nbAnneesTableau, listeValeurs,
            dictAllGrandeur, couleurTitres, couleurStrate, isComplet, verbose)

    print("ligne=", ligne)

    # Test valeur taux taxe d'habitation en 2015
    # (cle tth) : 10.11
    assert "10.11" in ligne

    if isComplet:
        # Test valeur taux taxe d'habitation pour la strate en 2015
        # (cle tmth) : 15.98
        assert "15.68" in ligne
def test_genCodeTableauxPicto(isComplet, isWikicode):
    """
        teste la génération de tous les tableau pour 1 ville : Wittenheim 68)
        Wittenheim et les années 2013 à 2015 pour comparaison avec
        http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
    """

    config = configparser.RawConfigParser()
    config.read('FinancesLocales.properties')

    # récup données de test
    pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
    pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
    if os.path.isfile(pathDatabaseMini):
        print("destruction de la base :", pathDatabaseMini)
        os.remove(pathDatabaseMini)

    # Insertion dans la table ville des villes à traiter
    # Création base
    connDB = database.createDatabase(config, pathDatabaseMini, False)
    connDB.executemany("""
        INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
        VALUES (?, ?, ?, ?)
        """, (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
                       )
    connDB.commit()

    # Création de la création de la base de test
    param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
    updateDataMinFi.main(param)
    assert os.path.isfile(pathDatabaseMini)

    listeVilleWalheim = [ville
                         for ville in database.getListeVilles4Departement(connDB, '068', False)
                         if ville[0] == '068376']
    ville = listeVilleWalheim[0]

    # Recup des données fiscales por WALHEIN
    dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V',
                                                             ville[0], False)
    listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V',
                                                         ville[0], False)
    assert len(listAnnees) == 3
    # Agglomère certaines grandeurs et complète dictAllGrandeur
    genCodeCommon.calculeGrandeur(config, dictAllGrandeur,
                            listAnnees, isWikicode, False)

    # Lecture du modèle de test reduit au tableau picto
    nomBaseModele = config.get('Test', 'genCodeTableauxPicto.ficModele')
    typeSortie = ""
    if isWikicode:
        typeSortie = "wikicode"
    else:
        typeSortie = "HTML"
    modele = nomBaseModele + '_' + typeSortie + '.txt'
    textSection = utilitaires.lectureFiltreModele(modele, isComplet, False)
    isGroupement = False

    print("textSection AVANT genCodeTableauxPicto=", textSection)
    
    # Définit le contenu des tableaux picto
    grandeursAnalyse = genCodeTableaux.defTableauxPicto(config,
                                        dictAllGrandeur, listAnnees,
                                        isWikicode, False)   
    textSection = genCodeCommon.genCodeTableauxPicto(config,
                                                       dictAllGrandeur,
                                                       grandeursAnalyse,
                                                       textSection,
                                                       listAnnees, isComplet,
                                                       isWikicode,
                                                     True,
                                                     isGroupement,
                                                     False)

    # Test Résultat comptable en 2015
    # (cle fres1) : 12.94
    print("textSection APRES genCodeTableauxPicto=", textSection)
    assert "13" in textSection

    # Test valeur des Charges de personnels par habitant en 2015
    # (cle fperso) : 470.19
    assert "470" in textSection

    if isComplet:
        # Test valeur des charges de la strate en 2015
        # (cle mres1) : 131.95
        assert "132" in textSection

    # Test valeur taux taxe d'habitation en 2015
    # (cle tth) : 10.11
    assert "10" in textSection

    if isComplet:
        # Test valeur taux taxe d'habitation pour la strate en 2015
        # (cle tmth) : 15.98
        assert "16" in textSection
    
    database.closeDatabase(connDB, True)
def test_getValeursDict(avecStrate):
    """ Teste la fonction getValeursDict """

    isWikicode = False
    config = configparser.RawConfigParser()
    config.read('FinancesLocales.properties')

    # récup données de test
    pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
    pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
    if os.path.isfile(pathDatabaseMini):
        print("destruction de la base :", pathDatabaseMini)
        os.remove(pathDatabaseMini)

    # Insertion dans la table ville des villes à traiter
    # Création base
    connDB = database.createDatabase(config, pathDatabaseMini, False)
    connDB.executemany("""
        INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
        VALUES (?, ?, ?, ?)
        """, (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
                       )
    connDB.commit()

    # Création de la création de la base de test
    param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
    updateDataMinFi.main(param)
    assert os.path.isfile(pathDatabaseMini)

    listeVilleWalheim = [ville
                         for ville in database.getListeVilles4Departement(connDB, '068', False)
                         if ville[0] == '068376']
    ville = listeVilleWalheim[0]

    # Recup des annees de données fiscales por WALHEIN
    listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V',
                                                         ville[0], False)
    assert len(listAnnees) == 3

    verbose = True
    grandeursAnalyse = []
    couleurDettesCAF = config.get('Tableaux', 'tableaux.couleurDettesCAF')
    dictEncoursDette = \
    {
        "l'encours de la dette" :
        {
            'libellePicto' : 'Encours de la dette',
            'cle' : 'encours de la dette au 31 12 n',
            'note' : "",
            'noteHtml' : '',
            'nul' : "pas d'encours pour la dette"
        }
    }
    grandeursAnalyse.append([dictEncoursDette, 0, "ENCOURS_DETTE", couleurDettesCAF])

    dictAnnuiteDette = \
    {
        "l'annuité de la dette" :
        {
            'libellePicto' : 'annuité de la dette',
            'cle' : "annuité de la dette",
            'note' : "",
            'noteHtml' : '',
            'nul' : 'aucune annuité pour la dette'
        }
    }
    grandeursAnalyse.append([dictAnnuiteDette, 0, "ANNUITE_DETTE", couleurDettesCAF])

    dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V', ville[0], verbose)
    
    nbAnneesTendance = int(config.get('GenWIkiCode', 'gen.nbAnneesTendance'))
    listeAnneesTendance = sorted(listAnnees[:nbAnneesTendance])


    for grandeurs in grandeursAnalyse:
        genCodeCommon.getValeursDict(dictAllGrandeur,
                   listeAnneesTendance, listAnnees[0],
                   grandeurs[0], avecStrate,
                   verbose)
        print(grandeurs[0], "=", grandeurs[0])
        assert grandeurs[0]["l'encours de la dette"]['Valeur totale'] == 10817
        assert grandeurs[0]["l'encours de la dette"]['Par habitant'] == 734
        if avecStrate:
            assert grandeurs[0]["l'encours de la dette"]['En moyenne pour la strate'] == 944
        else:
            assert not 'En moyenne pour la strate' in grandeurs[0]["l'encours de la dette"]
        assert grandeurs[0]["l'encours de la dette"]['dictAnneesValeur'][2013] == pytest.approx(479.18)
        assert grandeurs[0]["l'encours de la dette"]['dictAnneesValeur'][2014] == pytest.approx(671.41)
        assert grandeurs[0]["l'encours de la dette"]['dictAnneesValeur'][2015] == pytest.approx(733.67)
        break
def test_calculeGrandeurCleBesoin():
    """
        teste le calcule de grandeurs agglomérées
    """
    isWikicode = True
    config = configparser.RawConfigParser()
    config.read('FinancesLocales.properties')

    # récup données de test
    pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
    pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
    if os.path.isfile(pathDatabaseMini):
        print("destruction de la base :", pathDatabaseMini)
        os.remove(pathDatabaseMini)

    # Insertion dans la table ville des villes à traiter
    # Création base
    connDB = database.createDatabase(config, pathDatabaseMini, False)
    connDB.executemany("""
        INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
        VALUES (?, ?, ?, ?)
        """, (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'),)
                       )
    connDB.commit()

    # Création de la création de la base de test
    param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
    updateDataMinFi.main(param)
    assert os.path.isfile(pathDatabaseMini)

    # Lit dans la base les infos concernant la ville à traiter
    listeVilleWalheim = [ville
                         for ville in database.getListeVilles4Departement(connDB, '068', False)
                         if ville[0] == '068376']
    ville = listeVilleWalheim[0]

    # Recup des annees de données fiscales por WALHEIN
    dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V',
                                                             ville[0], False)
    listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V', ville[0], False)
    assert len(listAnnees) == 3

    # Appel fonction à tester pour un ville
    genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, isWikicode, False)
    print("Avant Suppression")
    print("Valeur totale=", dictAllGrandeur['Valeur totale'].keys())
    print("Par habitant=", dictAllGrandeur['Par habitant'].keys())

    # Test valeur présente pour une ville et svg valeurs
    cleManquante = "besoin ou capacité de financement de la section investissement"
    cleManquanteHab = "besoin ou capacité de financement de la section investissement par habitant"
    assert cleManquante in dictAllGrandeur['Valeur totale']
    assert cleManquanteHab in dictAllGrandeur['Par habitant']
    ValeursTotale = dictAllGrandeur['Valeur totale'][cleManquante]
    ValeursHab = dictAllGrandeur['Par habitant'][cleManquanteHab]

    cleRessourceInv = "total des ressources d'investissement"
    assert cleRessourceInv in dictAllGrandeur['Valeur totale']

    # Suppresion de la clé pour se mettre dans la situation d'un groupement de commune
    del dictAllGrandeur['Valeur totale'][cleManquante]
    del dictAllGrandeur['Par habitant'][cleManquanteHab]
    assert cleManquante not in dictAllGrandeur['Valeur totale']
    assert cleManquanteHab not in dictAllGrandeur['Par habitant']

    # Appel fonction à tester pour un ville
    genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, isWikicode, False)

    # Test valeur présente à nouveau pour une ville et controle valeurs
    assert cleManquante in dictAllGrandeur['Valeur totale']
    assert cleManquanteHab in dictAllGrandeur['Par habitant']
    ValeursTotaleNew = dictAllGrandeur['Valeur totale'][cleManquante]
    ValeursHabNew = dictAllGrandeur['Par habitant'][cleManquanteHab]

    # Comparaison à un chouia près : 1e-3
    assert ValeursTotale == pytest.approx(ValeursTotaleNew, rel=1e-3)
    assert ValeursHab == pytest.approx(ValeursHabNew, rel=1e-3)
    
    # Fermeture base
    database.closeDatabase(connDB, True)
def test_genCodeGroupementTexte_func(typeCode):
    """
        test la génération des données texte pour un groupement de commune :
        ARDON)
        Choisir Wittenheim et les années 2013 à 2015 pour comparaison avec
        http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
    """

    config = configparser.RawConfigParser()
    config.read('FinancesLocales.properties')
    verbose = True

    # récup données de test
    pathDatabaseMini = config.get('Test', 'updateDataMinFiGroupement.pathDatabaseMini')
    pathCSVMini = config.get('Test', 'updateDataMinFiGroupement.pathCSVMini')
    if os.path.isfile(pathDatabaseMini):
        print("destruction de la base :", pathDatabaseMini)
        os.remove(pathDatabaseMini)

    # Insertion dans la table ville des numéros de siren à traiter
    # Création base
    connDB = database.createDatabase(config, pathDatabaseMini, False)
    # ARDON : CC Portes de Sologne présente dans fichier CSV, doit apparaitre
    connDB.executemany("""
        INSERT INTO villes(codeCommune, nomMinFi, sirenGroupement)
        VALUES (?, ?, ?)
        """, (('045006', 'ARDON', '200005932'),))
    connDB.executemany("""
        INSERT INTO groupementCommunes(sirenGroupement, nomArticleCC, nom,
        région, département, forme, siège,
                            logo, siteWeb)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
        """, (('200005932', 'CC des Portes de Sologne',
               'Communauté de communes des Portes de Sologne',
               'Centre-Val de Loire', 'Loiret',
               'Communauté de communes', 'La Ferté-Saint-Aubin',
               'Logo_EPCI_Portes_de_Sologne.png',
               'http://www.cc-lafertesaintaubin.fr'),))
    connDB.commit()

    # Appel programme
    param = ['updateDataMinFiGroupementCommunes.py',
             pathDatabaseMini, pathCSVMini]
    updateDataMinFiGroupementCommunes.main(param)
    assert os.path.isfile(pathDatabaseMini)

    if typeCode == "wikicode":
        isWikicode = True
    else:
        isWikicode = False
    modele = 'modele_groupement_' + typeCode + '.txt'
    isComplet = True

    # Récupération du groupement de commune de la base
    listGroupements = database.getListeGroupements(connDB, verbose)
    assert len(listGroupements) == 1
    groupement = listGroupements[0]

    # Lecture et filtrage du fichier modèle
    modele = 'modele_groupement_' + typeCode + '.txt'
    with open(modele, 'r') as modelefile:
        textSection = modelefile.read()

         # Récupère toutes les données concernant ce groupement
        dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, "GC",
                                                                 groupement[0],
                                                                 verbose)
        listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'GC',
                                                             groupement[0],
                                                             verbose)

        # Agglomère certaines grandeurs et complète dictAllGrandeur
        genCodeCommon.calculeGrandeur(config, dictAllGrandeur,
                                      listAnnees, isWikicode,
                                      verbose)

        # Modification des valeurs simples
        textSection = genCodeGroupementTexte.genTexte(config, dictAllGrandeur,
                                        modele, textSection,
                                        groupement, listAnnees,
                                        "test_genCodeGroupementTexte",
                                        isWikicode, verbose)
        assert textSection
        
        assert "Communauté de communes des Portes de Sologne" in textSection
        if typeCode == "wikicode":
            # Vérification sources WEB dans texte généré
            urlMinFi = config.get('Extraction', 'dataGouvFr.Comptes')
            assert urlMinFi in textSection
            urlMinFiGroupements = config.get('Extraction', 'dataGouvFr.ComptesGroupements')
            assert urlMinFiGroupements in textSection

        if typeCode != "wikicode":
            assert "CC des Portes de Sologne" in textSection
            assert '200005932' in textSection
        assert "4831000" in textSection # charges de fonctionnement
        assert "1727000" in textSection # emplois d'investissement
        
    database.closeDatabase(connDB, False)
Exemplo n.º 9
0
def test_genCodeGraphiques_OK(isComplet, isWikicode):
    """ Test la génération de tous les graphiques """

    config = configparser.RawConfigParser()
    config.read('FinancesLocales.properties')

    # Création répertoire de sortie des graphiques
    repOutGraphique = config.get('Test',
                                 'genHTMLCodeGraphiques.pathOutputTest')
    if not os.path.isdir(repOutGraphique):
        os.mkdir(repOutGraphique)

    # récup données de test
    pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
    pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
    if os.path.isfile(pathDatabaseMini):
        print("Destruction de la base de test :", pathDatabaseMini)
        os.remove(pathDatabaseMini)

    # Insertion dans la table ville des villes à traiter
    # Création base
    connDB = database.createDatabase(config, pathDatabaseMini, False)
    connDB.executemany(
        """
        INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
        VALUES (?, ?, ?, ?)
        """, (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
    connDB.commit()

    # Création de la création de la base de test
    param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
    updateDataMinFi.main(param)
    assert os.path.isfile(pathDatabaseMini)

    # Lit dans la base les infos concernant la ville à traiter
    listeVilleWalheim = [
        ville
        for ville in database.getListeVilles4Departement(connDB, '068', False)
        if ville[0] == '068376'
    ]
    ville = listeVilleWalheim[0]

    # Recup des annees de données fiscales por WALHEIN
    dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
        connDB, 'V', ville[0], False)
    listAnnees = database.getListeAnneesDataMinFi4Entite(
        connDB, 'V', ville[0], False)
    assert len(listAnnees) == 3

    # Agglomère certaines grandeurs et complète dictAllGrandeur
    genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, True,
                                  False)

    # Lecture du modèle
    nomBaseModele = config.get('Modele', 'modele.nomBaseModele')
    typeSortie = config.get('GenCode', 'gen.idFicDetail')
    modele = nomBaseModele + '_' + typeSortie + '.txt'
    textSection = utilitaires.lectureFiltreModele(modele, isComplet, False)

    # Generation des graphiques pour une ville
    textSection = genCodeGraphiques.genCodeGraphiques(config, repOutGraphique,
                                                      dictAllGrandeur,
                                                      textSection, ville[1],
                                                      listAnnees, isComplet,
                                                      isWikicode, True, True)

    # Test des valeurs générées
    if isWikicode:
        assert "Graphique polygonal" in textSection
    else:
        assert ".svg" in textSection
Exemplo n.º 10
0
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)
Exemplo n.º 11
0
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)
Exemplo n.º 12
0
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)
Exemplo n.º 13
0
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)
Exemplo n.º 14
0
def test_genGraphique(courbesTest):
    """
        teste generation de courbe
    """

    config = configparser.RawConfigParser()
    config.read('FinancesLocales.properties')

    # récup données de test
    pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
    pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
    if os.path.isfile(pathDatabaseMini):
        print("destruction de la base :", pathDatabaseMini)
        os.remove(pathDatabaseMini)

    # Insertion dans la table ville des villes à traiter
    # Création base
    connDB = database.createDatabase(config, pathDatabaseMini, False)
    connDB.executemany(
        """
        INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
        VALUES (?, ?, ?, ?)
        """, (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
    connDB.commit()

    # Création de la création de la base de test
    param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
    updateDataMinFi.main(param)
    assert os.path.isfile(pathDatabaseMini)

    # Lit dans la base les infos concernant la ville à traiter
    listeVilleWalheim = [
        ville
        for ville in database.getListeVilles4Departement(connDB, '068', False)
        if ville[0] == '068376'
    ]
    ville = listeVilleWalheim[0]

    # Recup des annees de données fiscales por WALHEIN
    dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
        connDB, 'V', ville[0], False)
    listAnnees = database.getListeAnneesDataMinFi4Entite(
        connDB, 'V', ville[0], False)
    assert len(listAnnees) == 3
    # Agglomère certaines grandeurs et complète dictAllGrandeur
    genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, True,
                                  False)

    # Test calcul des valeurs
    nbCourbeOrig = len(courbesTest)
    anneesOK = genCodeGraphiques.controleSeries(dictAllGrandeur, courbesTest,
                                                listAnnees, False)

    # Détermination de l'arrondi à utiliser et à afficher
    listeCles = [
        courbe['cle'] for courbe in courbesTest
        if courbe['sousCle'] == "Valeur totale"
    ]
    if listeCles:
        arrondi, arrondiStr, arrondiStrAffiche = \
                utilitaires.setArrondi(dictAllGrandeur["Valeur totale"], anneesOK,
                                       1000.0, listeCles, False)
    else:
        arrondi = 1.0
        arrondiStr = "%"
        arrondiStrAffiche = arrondiStr

    # Generation des graphiques
    graphiqueWiki, legendeVille, legendeStrate = \
            genWikiCodeGraphiques.genGraphique(config, dictAllGrandeur,
                                               ville[1], anneesOK,
                                               courbesTest,
                                               'graph.largeurPage',
                                               arrondi,
                                               arrondiStrAffiche,
                                               True)
    for annee in anneesOK:
        assert str(annee) in graphiqueWiki
    for courbe in courbesTest:
        assert courbe['libelle'] in legendeVille

    for courbe in courbesTest:
        for annee in anneesOK:
            if courbe['cle'].startswith('Taux'):
                valeurData = \
                    round(dictAllGrandeur['Taux'][courbe['cle']][annee])
            elif courbe['sousCle'] == "":
                valeurData = round(dictAllGrandeur[courbe['cle']][annee])
            else:
                valeurData = round(
                    dictAllGrandeur[courbe['sousCle']][courbe['cle']][annee] *
                    arrondi)
            assert str(valeurData) in graphiqueWiki

    # Fermeture base
    database.closeDatabase(connDB, True)
def test_genereTableau(isWikicode, isComplet):
    """
        teste la génération des données tableau pour 1 ville : Wittenheim 68)
        Wittenheim et les années 2013 à 2015 pour comparaison avec
        http://marielaure.monde.free.fr/Finances_Locales_Web/Departement_68/Wittenheim/Wittenheim.html
    """

    config = configparser.RawConfigParser()
    config.read('FinancesLocales.properties')

    # récup données de test
    pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
    pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
    if os.path.isfile(pathDatabaseMini):
        print("destruction de la base :", pathDatabaseMini)
        os.remove(pathDatabaseMini)

    # Insertion dans la table ville des villes à traiter
    # Création base
    connDB = database.createDatabase(config, pathDatabaseMini, False)
    connDB.executemany(
        """
        INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
        VALUES (?, ?, ?, ?)
        """, (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
    connDB.commit()

    # Création de la création de la base de test
    param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
    updateDataMinFi.main(param)
    assert os.path.isfile(pathDatabaseMini)

    nomTableau = "PRINCIPAL"
    listeVilleWalheim = [
        ville
        for ville in database.getListeVilles4Departement(connDB, '068', False)
        if ville[0] == '068376'
    ]
    ville = listeVilleWalheim[0]
    # Recup des annees de données fiscales por WALHEIN
    listAnnees = database.getListeAnneesDataMinFi4Entite(
        connDB, 'V', ville[0], False)
    assert len(listAnnees) == 3
    nbAnneesTableau = min(
        int(config.get('GenWIkiCode', 'gen.nbLignesTableauxEuros')),
        len(listAnnees))

    couleurStrate = config.get('Tableaux', 'tableaux.couleurStrate')
    couleurTitres = config.get('Tableaux', 'tableaux.couleurTitres')
    couleurSolde = config.get('Tableaux', 'tableaux.couleurSolde')
    couleurRecettes = config.get('Tableaux', 'tableaux.couleurRecettes')
    couleurCharges = config.get('Tableaux', 'tableaux.couleurCharges')
    couleurDettesCAF = config.get('Tableaux', 'tableaux.couleurDettesCAF')
    couleurEmploisInvest = config.get('Tableaux',
                                      'tableaux.couleurEmploisInvest')
    couleurRessourcesInvest = config.get('Tableaux',
                                         'tableaux.couleurRessourcesInvest')

    verbose = True
    listeValeurs = [
        [
            "total des produits de fonctionnement",
            genCodeCommon.genLien(
                config, ["Recettes publiques", "Produits de fonctionnement"],
                isWikicode, verbose), couleurRecettes
        ],
        [
            "total des charges de fonctionnement",
            genCodeCommon.genLien(
                config, ["Dépenses publiques", "Charges de fonctionnement"],
                isWikicode, verbose), couleurCharges
        ],
        [
            "resultat comptable",
            genCodeCommon.genLien(config, [
                "Résultat fiscal en France",
                "Solde de la section de fonctionnement"
            ], isWikicode, verbose), couleurSolde
        ],
        [
            "total des emplois investissement",
            genCodeCommon.genLien(config,
                                  ["Investissement", "Emplois investissement"],
                                  isWikicode, verbose), couleurEmploisInvest
        ],
        [
            "total des ressources d'investissement",
            genCodeCommon.genLien(
                config, ["Investissement", "Ressources d'investissement"],
                isWikicode, verbose), couleurRessourcesInvest
        ],
        [
            "besoin ou capacité de financement de la section investissement",
            genCodeCommon.genLien(config, [
                "Résultat fiscal en France",
                "Solde de la section d'investissement"
            ], isWikicode, verbose), couleurSolde
        ],
    ]

    # Récupère toutes les valeurs pour cette ville pour les grandeurs demandées
    dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
        connDB, 'V', ville[0], verbose)
    # Test de la generation tableau
    if isWikicode:
        ligne = genWikiCodeTableaux.genereTableau(
            nomTableau, listAnnees, nbAnneesTableau, listeValeurs,
            dictAllGrandeur, couleurTitres, couleurStrate, isComplet, verbose)
    else:
        ligne = genHTMLCodeTableaux.genereTableau(
            nomTableau, listAnnees, nbAnneesTableau, listeValeurs,
            dictAllGrandeur, couleurTitres, couleurStrate, isComplet, verbose)

    # Test valeur des charges en 2015
    # (cle charge) : 12659.65
    assert "12660" in ligne

    # Test valeur des charges par habitant en 2015
    # (cle fcharge) : 858.63
    assert "859" in ligne

    if isComplet:
        # Test valeur des charges de la strate en 2015
        # (cle mcharge) : 1223.21
        assert "1223" in ligne
Exemplo n.º 16
0
def genereCode1Ville(config, connDB, repVille, ville, nomProg, typeCode,
                     isMatplotlibOk, verbose):
    """ Génère le Wikicode pour une ville """
    if verbose:
        print("Entree dans genereWikicode1Ville")
        print("repVille=", repVille)
        print('ville =', ville)
        print('typeCode =', typeCode)
        print('isMatplotlibOk', isMatplotlibOk)

    nomBaseModele = config.get('Modele', 'modele.nomBaseModele')
    if typeCode == "wikiArticle":
        cle = 'gen.idFicDetail'
        isWikicode = True
    elif typeCode == "wikiSection":
        cle = 'gen.idFicSection'
        isWikicode = True
    else:
        cle = 'gen.idFicHTML'
        isWikicode = False
    typeSortie = config.get('GenCode', cle)
    modele = nomBaseModele + '_' + typeSortie + '.txt'

    # v2.1.0 : pour cas particulier Paris : Strate = Ville -> pas de strate dans les sorties
    if ville[1] == 'Paris':
        isComplet = False
    else:
        isComplet = (config.get('Modele', 'modele.type') == 'complet')
    isGroupement = False

    # Lecture et filtrage du fichier modèle
    textSection = utilitaires.lectureFiltreModele(modele, isComplet, verbose)

    # Récupère toutes les données concernant cette ville
    dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
        connDB, "V", ville[0], verbose)
    listAnnees = database.getListeAnneesDataMinFi4Entite(
        connDB, 'V', ville[0], verbose)
    infosGroupement = database.getListeVilleGroupement(connDB, ville[0],
                                                       verbose)

    # Agglomère certaines grandeurs et complète dictAllGrandeur
    genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees,
                                  isWikicode, verbose)

    # Modification des valeurs simples
    textSection = genCodeTexte.genTexte(config, dictAllGrandeur,
                                        infosGroupement, modele, textSection,
                                        ville, listAnnees, nomProg, isWikicode,
                                        verbose)

    # Définit le contenu des tableaux picto
    grandeursAnalyse = genCodeTableaux.defTableauxPicto(
        config, dictAllGrandeur, listAnnees, isWikicode, verbose)

    # Génération des tableaux pictogrammes
    textSection = genCodeCommon.genCodeTableauxPicto(
        config, dictAllGrandeur, grandeursAnalyse, textSection, listAnnees,
        isComplet, isWikicode, True, isGroupement, verbose)
    # Génération des tableaux
    textSection = genCodeTableaux.genCodeTableaux(config, dictAllGrandeur,
                                                  textSection, listAnnees,
                                                  isComplet, isWikicode,
                                                  verbose)

    # Generation des graphiques
    textSection = genCodeGraphiques.genCodeGraphiques(
        config, repVille, dictAllGrandeur, textSection, ville[1], listAnnees,
        isComplet, isWikicode, isMatplotlibOk, verbose)

    if verbose:
        print("Sortie de genereCode1Ville")

    return textSection
Exemplo n.º 17
0
def genereCode1Groupement(config, connDB, repGroupement, groupement, nomProg,
                          typeCode, isMatplotlibOk, verbose):
    """ Génère le Wikicode pour un groupement """
    if verbose:
        print("Entree dans genereWikicode1Groupement")
        print("repGroupement=", repGroupement)
        print("typeCode=", typeCode)
        print('groupement =', groupement)
        print('isMatplotlibOk', isMatplotlibOk)

    isWikicode = (typeCode == "wikicode")
    modele = 'modele_groupement_' + typeCode + '.txt'
    isComplet = False
    isGroupement = True

    # Lecture du fichier modèle
    with open(modele, 'r', encoding='utf-8') as modelefile:
        textSection = modelefile.read()

        # Récupère toutes les données concernant ce groupement
        dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
            connDB, "GC", groupement[0], verbose)

        # On ne génère pas les communauté de communes sans donnée MinFi
        if "Valeur totale" in dictAllGrandeur:
            listAnnees = database.getListeAnneesDataMinFi4Entite(
                connDB, 'GC', groupement[0], verbose)

            # Agglomère certaines grandeurs et complète dictAllGrandeur
            genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees,
                                          isWikicode, verbose)

            # Modification des valeurs simples
            textSection = genCodeGroupementTexte.genTexte(
                config, dictAllGrandeur, modele, textSection, groupement,
                listAnnees, nomProg, isWikicode, verbose)

            # Définit le contenu des tableaux picto
            grandeursAnalyse = genCodeGroupementTableaux.defTableauxGroupementPicto(
                config, dictAllGrandeur, listAnnees, isWikicode, verbose)

            # Génération des tableaux pictogrammes
            textSection = genCodeCommon.genCodeTableauxPicto(
                config, dictAllGrandeur, grandeursAnalyse, textSection,
                listAnnees, isComplet, isWikicode, False, isGroupement,
                verbose)
            # Génération des tableaux
            textSection = genCodeTableaux.genCodeTableaux(
                config, dictAllGrandeur, textSection, listAnnees, False,
                isWikicode, verbose)

            # Generation des graphiques
            textSection = genCodeGraphiques.genCodeGraphiques(
                config, repGroupement, dictAllGrandeur, textSection,
                groupement[2], listAnnees, False, isWikicode, isMatplotlibOk,
                verbose)

            # Suppression chaine ratio dont je ne trouve pas l'origine
            textSection = textSection.replace(', ratio ', '')

    if verbose:
        print("Sortie de genereCode1Groupement")

    return textSection