예제 #1
0
def test_updateScoreWikipedia():
    """
        Test génération database à prtir liste de ville
    """
    config = configparser.RawConfigParser()
    config.read('FinancesLocales.properties')

    # Init base
    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 de 2 villes
    connDB = database.createDatabase(config, pathDatabaseMini, False)
    connDB.executemany("""INSERT INTO villes(codeCommune, nomWkpFr)
                            VALUES (?, ?)""",
                       (('046204', 'Rocamadour'),
                        ('046003', 'Alvignac')))
    connDB.commit()

    # Insertion des scores dans la table des villes du Lot
    param = ['updateScoreWikipedia.py', '-v', pathDatabaseMini]
    updateScoreWikipedia.main(param)

    # Test villes insérées
    cursor = connDB.cursor()
    cursor.execute("SELECT codeCommune, score FROM villes ORDER BY codeCommune")
    listVilles = cursor.fetchall()
    assert len(listVilles) == 2
    assert listVilles == [('046003', 13), ('046204', 10)]
    cursor.close()
    connDB.close()
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)
예제 #3
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)
예제 #4
0
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_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_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)
예제 #7
0
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()
예제 #9
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)
예제 #10
0
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)
예제 #12
0
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)
예제 #13
0
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)
예제 #14
0
def main(argv=None):
    """
        Met à jour la base de données avec les scores Wikipedia.
    """
    # Valeur par défaut des options
    verbose = False
    isFast = 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:], "huvVf",
                                   ["help", "usage", "version", "verbose",
                                    "fast"])
    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'])
        verbose = verbose or verboseOpt
        if sortiePgm:
            sys.exit(0)

        if opt[0] in ("-f", "--fast"):
            print("mode fast : ne traite que les villes de scores inconnus")
            isFast = True

    utilitaires.checkPythonVersion(config, verbose)

    # Récuperation et analyse des paramètres
    if len(args) != 1:
        msg = __doc__ + "\nDonnez 1 paramètre :\n"  + \
                "chemin base .db !" + \
                "\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)

    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
    listeCodeCommuneNomWkp = database.getListeCodeCommuneNomWkp(connDB,
                                                                isFast,
                                                                "score",
                                                                verbose)
    if not listeCodeCommuneNomWkp:
        msg = "Erreur : La base de données :\n" + databasePath + \
                "\n ne contient aucune ville à extraire, lancer extractionWikipediaFr"
        print(msg, file=sys.stderr)

    # Calcule les scores pour chaque commune
    scoresVille = recupScoreDataVilles(config, listeCodeCommuneNomWkp, verbose)

    # Met à jour la base de données
    database.updateScoresVille(connDB, scoresVille, verbose)

    print("Sortie de", nomProg)
예제 #15
0
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)
예제 #16
0
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)
예제 #17
0
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from flask.ext.compress import Compress

from app import app, api
import database
from user import User
from video import Video
from notification import NotificationModel, RegisteredNotificationUserModel, Notification

application = app
database.createDatabase()

if __name__ == "__main__":
    app.debug = app.config["DEBUG"]
    compress = Compress()
    compress.init_app(app)
    http_server = HTTPServer(WSGIContainer(app))

    http_server.bind(5000)
    http_server.start()
    IOLoop.instance().start()
예제 #18
0
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)
예제 #19
0
def main(argv=None):
    """
        Met à jour la base de données avec les
        infos sur les regroupements de communes.
    """
    # Valeur par défaut des options
    verbose = False
    isFast = 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:], "huvVf",
                                   ["help", "usage", "version", "verbose",
                                    "fast"])
    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'])
        verbose = verbose or verboseOpt
        if sortiePgm:
            sys.exit(0)

        if opt[0] in ("-f", "--fast"):
            print("\nMode fast : ne traite que les villes (non anciennes)\n"
                  "\tdont les numéros de SIREN sont inconnus")
            isFast = True

    utilitaires.checkPythonVersion(config, verbose)

    # Récuperation et analyse des paramètres
    if len(args) not in [1, 2]:
        print(f'{__doc__}\nDonnez 1 ou 2 paramètres :\n'
              "chemin base .db\nOptionnel : nb max de villes à traiter !"
              f"\nau lieu de : {len(args)}", 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"):
        print(f'{__doc__}\nNom de base de données non valide :\n'
              f'il doit se terminer par .db : {databasePath}',
              file=sys.stderr)
        sys.exit(2)

    nbMaxVille = 0
    if len(args) == 2:
        nbMaxVille = int(args[1])

    print('Début de', nomProg, "database=", databasePath,
          ', nbMaxVille=', nbMaxVille)

    # Ouvre la base de données
    connDB = database.createDatabase(config, databasePath, verbose)

    # Récupère la liste des villes et des années présentes dans la base
    listeCodeCommuneNomWkp = \
            database.getListeCodeCommuneNomWkp(connDB,
                                               isFast,
                                               "sirenGroupement",
                                               verbose)
    if not listeCodeCommuneNomWkp:
        print(f'Erreur : La base de données :\n{databasePath}'
              "\n ne contient aucune ville à extraire, lancer extractionWikipediaFr",
              file=sys.stderr)
    if nbMaxVille > 0:
        print(f'Attention : seulement {nbMaxVille} communes traitées !'
              "\nUtilisez l'option -f au prochain run.")
        listeCodeCommuneNomWkp = listeCodeCommuneNomWkp[:nbMaxVille]

    print("\nCodes utilisés :\n"
          "- . Extraction d'une page Wikipédia ;\n"
          "- Z Attente pour ne pas surcharger Wikipédia ;\n"
          "- A Ancienne commune : ignorée et marquée dans la base ;\n"
          "- R Page de redirection traversée ;\n")

    print("Récuperation des noms des groupements des villes...")
    nomCCVilles = recupNomCCVilles(config, listeCodeCommuneNomWkp, verbose)

    print("Récupération des infos sur les communautés de communes...")
    # Récupération des infos sur les communautés de communes
    listeSirenCodeCommune, dictSirenInfoCC = recupInfosCC(config, nomCCVilles, verbose)

    # Met à jour la base de données
    print("Enregistrement dans la base...")
    database.updateInfosGroupement(connDB, listeSirenCodeCommune,
                                   dictSirenInfoCC, verbose)

    print("Sortie de", nomProg)
예제 #20
0
def setup_app():
    database.createDatabase(environment="MYSQLURL")
    session = database.DBSession()
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
예제 #22
0
 def getDatabase(self):
     return database.createDatabase(self.config)
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_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_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
    "guesed_Letters": [],
    "tried_Letters": [],
    "stages_index": 0,
    "guessed_number": 1
}

cmdOptions_list = [
    "/help", "/exit", "/score", "/logout", "/profile", "/scoreboard",
    "/account", "/register", "/printword", "/stages_index", "/logged_in",
    "/value", "/deleteaccount", "/levels", "/database"
]

print(hangman_art)

#Create database.db if it doesn't exist
database.createDatabase()

random_word = fileHandling.pickWord(words, word)
letters_List = generateList()

logged_in = login_system.login()

once = True

while logged_in[0] and value["chances"]:
    while once:
        console.showHelp(True)
        once = False
    #print("The word is {}".format(random_word))
    print(*letters_List, sep=" ")
    #updateAccount()
예제 #28
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
예제 #29
0
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)
예제 #30
0
from flask import Flask, session, request, render_template, redirect, url_for
from database import createDatabase, createUserModel, loginUser, usernameExists, createUser, createToDoModel
from database import createToDo, getToDos, deleteToDo
import bcrypt
import os

dbPath = "db.sqlite3"
createDatabase(dbPath)
createUserModel(dbPath)
createToDoModel(dbPath)
app = Flask(__name__)

app.secret_key = os.urandom(12)


@app.route("/")
def title():
    return render_template("title.html")


@app.route("/index", methods=["GET", "POST"])
def index():
    try:
        session["logged_in"]
    except KeyError:
        session["logged_in"] = False
    if session["logged_in"]:
        if request.method == "POST":
            description = request.form["description"]
            createToDo(session["user_id"], description, dbPath)
            return redirect(url_for("index"))
예제 #31
0
print('\nWelcome to the texted based game database of your games')
print('\nPlease enter a number to select an option')

# user selection of options 
while option != 0:
	print('\nExit program = 0 \nNew database = 1\nEdit database = 2 \nDelete database = 3')
	
	# remember the sqlit3 file name 
	sqlite_file = sqlite_file
	
	#Get user input for menu select
	option = intCheck.int_check(input('\nEnter number: ')) # get user input and check it is an intager
	if option in option_list:
		option = option
		if option == 1:
			sqlite_file = database.createDatabase()
		elif option == 2:
			database.editDatabase(sqlite_file)
		elif option == 3:
			print("\nThis is where you would delete a database, but not yet.")
		elif option == 0:
			
			print("\nThanks for playing")
		else:
			print("\nother option") # temp line
	else:
		print("\nPlease re-enter a valid number")


# add to the columes in the database to make them equel for the game and game expasion so I can use the same gameVaule to input both. 
예제 #32
0
This file contains process
for the database organisation
"""

import database
import trashlib


"""
Create database for one langage (to start)
"""

print "/-----------------------------\\"
print "|     DATABASE CREATION       |"
print "\\-----------------------------/"
database.createDatabase("DATA/database/test.db")
print "/-----------------------------\\"
print "|     DATABASE INSERTION      |"
print "\\-----------------------------/"
dataFile = open("DATA/testUrl.data", "r")
for line in dataFile:
	url = line.replace("\n", "")
	code = trashlib.collectCodeFromSOF(url)
	header = trashlib.collectTitleFromSOF(url)
	titleInArray = header[0].split("-")
	title = titleInArray[0]
	subtitle = ""
	if len(titleInArray) > 1:
		subtitle = titleInArray[1]

	codeToInsert = ""
def process():

    # Defines a function to translate the notification type into a string
    def getNotificationTitle(type, sender):
        type_r = ""
        if type == string_constants.kServerNotificationsTypeConnectionsRequest:
            type_r = string_constants.kServerNotificationsTypeConnectionsRequestTitle % (sender)
        elif type == string_constants.kServerNotificationsTypeConnectionsRequestConfirmation:
            type_r = string_constants.kServerNotificationsTypeConnectionsRequestConfirmationTitle % (sender)
        elif type == string_constants.kServerNotificationsTypeNewVideo:
            type_r = string_constants.kServerNotificationsTypeNewVideoTitle % (sender)
        return type_r

    if len(sys.argv) > 1:
        a = sys.argv[1]
        b = sys.argv[2]
        c = sys.argv[3]
        d = sys.argv[4]
        database.createDatabase(a, b)
        sandbox = False
    else:
        database.createDatabase()
        c = "certs/apns-dev-cert.pem"
        d = "certs/apns-dev-key-noenc.pem"
        sandbox = True

    # database.createDatabase()
    session = database.DBSession()

    pendingNotifications = (
        session.query(NotificationModel)
        .filter(NotificationModel.notification_sent == 0)
        .order_by(desc(NotificationModel.notification_date))
        .all()
    )

    if len(pendingNotifications) < 1:
        return

    apns = APNs(use_sandbox=sandbox, cert_file=c, key_file=d)

    # Send multiple notifications in a single transmission
    frame = Frame()
    identifier = 1
    expiry = time.time() + 3600
    priority = 10

    for notification in pendingNotifications:
        _payload = notification.notification_payload
        display_name = _payload[string_constants.kServerNotificationsUser_NameKey]
        _payload[string_constants.kServerNotificationsUser_NameKey] = None
        if _payload is None:
            _payload = {}
        token_hex = notification.registered_notification_user_model.registered_user_token
        if token_hex is not None:
            payload = Payload(
                alert=getNotificationTitle(
                    notification.notification_payload[string_constants.kServerNotificationsType], display_name
                ),
                sound="default",
                badge=1,
                custom=_payload,
            )

            frame.add_item(token_hex, payload, identifier, expiry, priority)
        session.query(NotificationModel).filter(
            NotificationModel.notification_id == notification.notification_id
        ).update({"notification_sent": 1})

    apns.gateway_server.send_notification_multiple(frame)

    # Get feedback messages
    for (token_hex, fail_time) in apns.feedback_server.items():
        print token_hex
        print fail_time

    # Remove all pending notifications that were just sent and close the DB session
    session.commit()
    session.close()
예제 #34
0
import database as db

db = db.Database("python_crud_oop")
db.setLocalhost("localhost")
db.setUsername("root")
db.setPassword("")
db.createDatabase()

db.setTableName("customers")
db.createTable()
def process(access_key=None, secret_key=None, bucket_name=None, video_path=None, video=None):

    for_deleting = False

    if len(sys.argv) > 1:
        a = sys.argv[1]
        ACCESS_KEY = sys.argv[2]
        SECRET_KEY = sys.argv[3]
        BUCKET_NAME = sys.argv[4]
        database.createDatabase(a)
    else:
        for_deleting = True
        ACCESS_KEY = access_key
        SECRET_KEY = secret_key
        BUCKET_NAME = bucket_name
        database.createDatabase()

    aws_s3_connection = S3Connection(ACCESS_KEY, SECRET_KEY)
    aws_s3_bucket = Bucket(aws_s3_connection, BUCKET_NAME)

    session = database.DBSession()

    object_keys = []

    # This is if the CRON job is running and is removing flagged videos
    if for_deleting is False:
        flagged_content = session.query(FlaggedVideoModel).all()
        if len(flagged_content) > 0:
            time_stamp_now = calendar.timegm(datetime.utcnow().timetuple())
            for content in flagged_content:
                if content.timeStamp <= time_stamp_now:
                    video = content.video
                    favourites_of_video = session.query(VideoFavourite).filter(VideoFavourite.video_id == video.video_id).all()
                    for key in aws_s3_bucket.list(prefix=content.video_path):
                        object_keys.append(key)

                    if len(favourites_of_video) > 0:
                        for fv in favourites_of_video:
                            session.delete(fv)
                    session.delete(content)
                    session.delete(video)
    # This is for when you are deleting a video from the timeline
    elif for_deleting is True and video is not None and video_path is not '' and video_path is not None:
        favourites_of_video = session.query(VideoFavourite).filter(VideoFavourite.video_id == video.video_id).all()
        flags_for_video = session.query(FlaggedVideoModel).filter(FlaggedVideoModel.video_id == video.video_id).all()

        # Collect the AWS S3 objects to delete
        for key in aws_s3_bucket.list(prefix=video_path):
            object_keys.append(key)
        # Collect the Video Favourites
        if len(favourites_of_video) > 0:
            for fv in favourites_of_video:
                session.delete(fv)
        # Collect the Video Flags
        if len(flags_for_video) > 0:
            for fv in flags_for_video:
                session.delete(fv)

    try:
        if len(object_keys) > 0:
            aws_s3_bucket.delete_keys(object_keys)
        session.commit()
        session.close()
        return True
    except exc.SQLAlchemyError:
        session.close()
        return False