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)
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_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)
def a_voir_test_genereCode1Ville_55(typeCode):
"""
test génération des données pour une ville du département 55
qui pose des problèmes au 21/11/2021 : donnees incompletes
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
nomProg = "test_genereCode1Ville"
# Création répertoire de sortie hebergeant les villes
repVilles = config.get('Test', 'genCode.pathVilles55')
if not os.path.isdir(repVilles):
os.mkdir(repVilles)
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini55')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini55')
if os.path.isfile(pathDatabaseMini):
print("Destruction de la base de test :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('055039', 'BEAUMONT-EN-VERDUNOIS', 'Beaumont-en-Verdunois',
'Beaumont-en-Verdunois'), ))
connDB.commit()
# Création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVille = database.getListeVilles4Departement(connDB, '055', True)
ville = listeVille[0]
# Test fonction de génération
genereCode1Ville.genereCode1Ville(config, connDB, repVilles, ville,
nomProg, typeCode, True, True)
# Fermeture base
database.closeDatabase(connDB, False)
def test_createDbDataMinFi():
"""
Test génération database avec un fichier CSV réduit à 2 villes
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# récup données de test
pathDatabaseMini = config.get('Test', 'updateDataMinFi.pathDatabaseMini')
pathCSVMini = config.get('Test', 'updateDataMinFi.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("destruction de la base :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi)
VALUES (?, ?)
""", (('068356', 'WALHEIM'), ('040281', 'ST PIERRE DU MONT')))
connDB.commit()
database.closeDatabase(connDB, True)
# Appel programme
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Test info ville 1
connDB = sqlite3.connect(pathDatabaseMini)
cursor = connDB.cursor()
cursor.execute(
"SELECT codeCommune, nomMinFi, nomStrate FROM villes ORDER BY codeCommune"
)
listVilles = cursor.fetchall()
assert len(listVilles) == 2
assert listVilles[0][0] == '040281'
assert listVilles[0][1] == 'ST PIERRE DU MONT'
assert listVilles[0][2] == "n'appartenant à aucun groupement fiscalisé"
assert listVilles[1][0] == '068356'
assert listVilles[1][1] == 'WALHEIM'
assert listVilles[1][2] == "n'appartenant à aucun groupement fiscalisé"
cursor.close()
connDB.close()
def test_getTendanceRatioDetteCAF():
""" Test calcule de tendance du rapport dette/CAF """
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Recup chemin base de test et ménage
databasePathDir = config.get('Test', 'database.testDir')
databasePath = os.path.join(databasePathDir, config.get('Test', 'database.testName'))
if not os.path.isdir(databasePathDir):
os.mkdir(databasePathDir)
if os.path.isfile(databasePath):
os.remove(databasePath)
# Création base vide
connDB = database.createDatabase(config, databasePath, False)
assert os.path.isfile(databasePath)
assert connDB
# Insertion données dette et CAF pour une commune
codeDette = config['cleFi3Valeurs']["clefi.encours de la dette au 31 12 n"]
codeCAF = config['cleFi3Valeurs']["clefi.capacité autofinancement caf"]
connDB.executemany("""
INSERT INTO dataFi(codeCommune, annee, codeCle, valeur)
VALUES (?, ?, ?, ?)
""",
(
('001008', 2000, codeCAF, 1), ('001008', 2001, codeCAF, 1),
('001008', 2002, codeCAF, 1),
('001008', 2000, codeDette, 25), ('001008', 2001, codeDette, 23),
('001008', 2002, codeDette, 24)
))
connDB.commit()
# Récupère toutes les données concernant cette ville
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(connDB, 'V',
'001008', False)
listAnnees = database.getListeAnneesDataMinFi4Entite(connDB, 'V',
'001008', False)
# Test
tendanceRatio, dicoRatio = ratioTendance.getTendanceRatioDetteCAF(config, dictAllGrandeur,
True, True)
assert "est constant et élevé (supérieur à" in tendanceRatio
database.closeDatabase(connDB, True)
def test_getColumnPosition_Pb():
""" Test cas d'erreur fonction de validation d'un répertoire contenant les données
issues du site gouvernemental
"""
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Recup chemin base de test
databasePathDir = config.get('Test', 'database.testDir')
databasePath = os.path.join(databasePathDir, config.get('Test', 'database.testName'))
# Création base
connDB = database.createDatabase(config, databasePath, True)
with pytest.raises(ValueError,
match=r".*Entete CSV non valide.*"):
dictPositionColumns, listMissingKeys = \
updateDataMinFiCommon.getColumnPosition("Entete tout moisi",
"V", connDB, True)
database.closeDatabase(connDB, True)
def test_analyseLigneGroupement(ligneGroupement, header, dictVerif):
""" Récupération des valeurs dans une ligne de valeur pour une ville """
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Recup chemin base de test
databasePathDir = config.get('Test', 'database.testDir')
databasePath = os.path.join(databasePathDir, config.get('Test', 'database.testName'))
# Création base
connDB = database.createDatabase(config, databasePath, False)
dictPositionColumns, listMissingKeys = \
updateDataMinFiCommon.getColumnPosition(header, "GC", connDB, False)
dictValues = updateDataMinFiGroupementCommunes.analyseLigneGroupement(ligneGroupement,
dictPositionColumns,
True)
assert dictValues == dictVerif
# Fermeture base
database.closeDatabase(connDB, True)
def test_getColumnPosition(headerTest, dictKeyOk, missingKey):
""" Récupération position des mots clés de la table dans l'entête de test """
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Recup chemin base de test
databasePathDir = config.get('Test', 'database.testDir')
databasePath = os.path.join(databasePathDir, config.get('Test', 'database.testName'))
# Création base
connDB = database.createDatabase(config, databasePath, True)
dictPositionColumns, listMissingKeys = \
updateDataMinFiCommon.getColumnPosition(headerTest, "V", connDB, True)
# Controle des clés présentes et de leur position dans headerTest
for keyOk in dictKeyOk:
assert dictPositionColumns[keyOk] == dictKeyOk[keyOk]
if listMissingKeys:
assert missingKey in listMissingKeys
else:
assert not missingKey
database.closeDatabase(connDB, True)
def main(argv=None):
""" Génère le Wikicode et du HTML pour les villes d'un département """
# Valeur par défaut des options
verbose = False
# Lecture du fichier de propriétés
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
#############################
# Analyse des arguments reçus
#############################
if argv is None:
argv = sys.argv
nomProg = os.path.basename(argv[0])
# parse command line options
try:
opts, args = getopt.getopt(argv[1:], "huvV",
["help", "usage", "version", "verbose"])
except getopt.error as msg:
print(msg)
print("To get help use --help ou -h")
sys.exit(1)
# process options
for opt in opts:
verboseOpt, sortiePgm = \
utilitaires.traiteOptionStd(config, opt[0], nomProg, __doc__,
["../database/minfi.db ../Resultats",])
verbose = verbose or verboseOpt
if sortiePgm:
sys.exit(0)
utilitaires.checkPythonVersion(config, verbose)
isMatplotlibOk = utilitaires.checkMatplolibOK()
if len(args) != 2:
print(f'{__doc__}\nDonnez 2 paramètres :\n'
"chemin base .db et chemin des résultats !"
f"\nau lieu de : {len(args)}")
sys.exit(1)
databasePath = args[0]
if not os.path.isfile(databasePath):
raise ValueError(
f"Le fichier base de données {databasePath} n'existe pas !")
if not args[1]:
raise ValueError("Donnez un chemin de répertoire résultat !")
resultatsPath = os.path.normcase(args[1])
print('Début de', nomProg)
print("databasePath =", databasePath)
print("resultatsPath =", resultatsPath)
genCodeCommon.createResultDir(config, resultatsPath)
# Ouvre la base de données
connDB = database.createDatabase(config, databasePath, verbose)
# Récup et traitement des départements
traiteDepartement(config, nomProg, isMatplotlibOk, connDB, resultatsPath,
verbose)
# Ferme la base de données
database.closeDatabase(connDB, verbose)
def 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)
def test_genCodeProg(verbose):
"""
Teste le programme de génération du code Wiki et HTML
sur base de test 1 ville et 3 années.
"""
# Contournement OS X and Linux : invalide locale
if platform.system() in ('Darwin', 'Linux'):
locale.setlocale(locale.LC_ALL, os.getenv('LANG'))
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Ménage répertoire de sortie
pathOutput = config.get('Test', 'genCode.pathOutput')
resultatsPath = pathOutput
print("resultatsPath =", resultatsPath)
if os.path.isdir(resultatsPath):
print("Effacement de :", resultatsPath)
shutil.rmtree(resultatsPath)
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("Destruction de la base de test :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Test du programme genCode
if verbose:
param = ['genCode.py', '-v', pathDatabaseMini, resultatsPath]
else:
param = ['genCode.py', pathDatabaseMini, resultatsPath]
genCode.main(param)
# Vérif des résultats
assert os.path.isdir(resultatsPath)
assert os.path.isdir(os.path.join(resultatsPath, "Departement_068"))
assert os.path.isfile(
os.path.join(resultatsPath, "Departement_068", "index.html"))
assert os.path.isdir(
os.path.join(resultatsPath, "Departement_068", "Wittenheim"))
assert os.path.isfile(
os.path.join(resultatsPath, "Departement_068", "Wittenheim",
"Wittenheim.html"))
assert os.path.isfile(
os.path.join(resultatsPath, "Departement_068", "Wittenheim",
"Wittenheim_wikicode.html"))
assert os.path.isfile(
os.path.join(resultatsPath, "Departement_068", "Wittenheim",
"CHARGES_FINANCIERES_SUBVENTIONS_VERSEES.svg"))
# Fermeture base
database.closeDatabase(connDB, False)
def 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)
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()
def main(argv=None):
"""
Met à jour les données de groupement de communes de
la base de données du ministère des finances
à partir des fichiers .csv du répertoire passé en paramètres.
"""
# Valeur par défaut des options
verbose = False
# Lecture du fichier de propriétés
config = configparser.RawConfigParser()
ficProperties = 'FinancesLocales.properties'
config.read(ficProperties)
#############################
# Analyse des arguments reçus
#############################
if argv is None:
argv = sys.argv
nomProg = os.path.basename(argv[0])
# parse command line options
try:
opts, args = getopt.getopt(argv[1:], "huvV",
["help", "usage", "version", "verbose"])
except getopt.error as msg:
print(msg)
print("Pour avoir de l'aide : --help ou -h", file=sys.stderr)
sys.exit(1)
# process options
for opt in opts:
verboseOpt, sortiePgm = \
utilitaires.traiteOptionStd(config, opt[0], nomProg, __doc__, \
['database/minfi.db ../recup_data_gouv_fr_colectivite/comptes-groupements.csv'])
verbose = verbose or verboseOpt
if sortiePgm:
sys.exit(0)
utilitaires.checkPythonVersion(config, verbose)
# Récuperation et analyse des paramètres
if len(args) != 2:
msg = __doc__ + "\nDonnez au moins 2 paramètres :\n" + \
"chemin base .db et fichier .csv !" + \
"\nau lieu de : " + str(len(args))
print(msg, file=sys.stderr)
sys.exit(1)
# Vérifie et récupère le nom de la base à mettre à jour
databasePath = args[0]
if not databasePath.endswith(".db"):
msg = __doc__ + "Erreur : Le nom de la base de donnée doit se terminer par .db :\n" + \
databasePath
print(msg, file=sys.stderr)
sys.exit(2)
# Vérifie et récupère les noms des fichiers de données du ministère des finances
pathCSVDataGouvFr = args[1]
if not os.path.isfile(pathCSVDataGouvFr):
msg = __doc__ + "Erreur : paramètre fichier .csv !\n" + \
"Ce fichiers .csv doit être récupérés sur\n" + \
config.get('Extraction', 'dataGouvFr.ComptesComptesGroupements') + ":\n" + \
pathCSVDataGouvFr
print(msg, file=sys.stderr)
sys.exit(3)
print('Début de', nomProg)
# Crée la base de données si elle n'existe pas
connDB = database.createDatabase(config, databasePath, verbose)
# Récupère les numéros de SIREN des groupements dans la base
# ainsi que leurs noms et années des infos financières déjà enregistrées.
dictSirenInfos = database.getSirenInfosGroupementsAnnees(connDB, verbose)
if not dictSirenInfos:
msg = "Erreur : La base de données :\n" + databasePath + \
"\n ne contient aucun groupement de commune à extraire," +\
"lancer updateGroupementsCommunes"
print(msg, file=sys.stderr)
# Met à jour la base de données le fichier .CSV passé en paramètres
print("Traitement de :", pathCSVDataGouvFr, "...")
with open(pathCSVDataGouvFr,
mode='rt',
buffering=config.getint('Extraction',
'updateDataMinFi.bufferReadingSize'),
encoding='utf-8') as hFicMinFi:
# Analyse l'entête du fichier
header = hFicMinFi.readline().strip()
dictPositionColumns, listMissingKeys = \
updateDataMinFiCommon.getColumnPosition(header, "GC",
connDB, verbose)
# Print missing columns
if len(listMissingKeys) > 0:
print("Attention : les motcles suivants n'ont pas été trouvés :\n",
";".join(listMissingKeys))
# Enregistre si nécessaire chaque ligne du fichier
numLine = 1
numGroupement = 0
for ligneVille in hFicMinFi:
numLine += 1
dictValues = analyseLigneGroupement(ligneVille,
dictPositionColumns, verbose)
# Analyse et enregistre les valeurs de cette ligne
if "siren" in dictValues and dictValues["siren"].isdigit() and \
len(dictValues["siren"]) == 9 and \
"exer" in dictValues and dictValues["exer"].isdigit() and \
len(dictValues["exer"]) == 4 and \
dictValues["siren"] in dictSirenInfos and \
int(dictValues["exer"]) not in dictSirenInfos[dictValues["siren"]][2]:
numGroupement += 1
database.enregistreLigneGroupementMinFi(
dictValues, connDB, verbose)
print('.', end='', flush=True)
else:
print('X', end='', flush=True)
print("\n", numLine - 1, "lignes traitées,", numGroupement,
"groupements enregistrés")
# Ferme la base de données
database.closeDatabase(connDB, verbose)
def 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)
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
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()
def test_genCodeGraphiques_OK(isComplet, isWikicode):
""" Test la génération de tous les graphiques """
config = configparser.RawConfigParser()
config.read('FinancesLocales.properties')
# Création répertoire de sortie des graphiques
repOutGraphique = config.get('Test',
'genHTMLCodeGraphiques.pathOutputTest')
if not os.path.isdir(repOutGraphique):
os.mkdir(repOutGraphique)
# récup données de test
pathDatabaseMini = config.get('Test', 'genCode.pathDatabaseMini')
pathCSVMini = config.get('Test', 'genCode.pathCSVMini')
if os.path.isfile(pathDatabaseMini):
print("Destruction de la base de test :", pathDatabaseMini)
os.remove(pathDatabaseMini)
# Insertion dans la table ville des villes à traiter
# Création base
connDB = database.createDatabase(config, pathDatabaseMini, False)
connDB.executemany(
"""
INSERT INTO villes(codeCommune, nomMinFi, nom, nomWkpFr)
VALUES (?, ?, ?, ?)
""", (('068376', 'WITTENHEIM', 'Wittenheim', 'Wittenheim'), ))
connDB.commit()
# Création de la création de la base de test
param = ['updateDataMinFi.py', pathDatabaseMini, pathCSVMini]
updateDataMinFi.main(param)
assert os.path.isfile(pathDatabaseMini)
# Lit dans la base les infos concernant la ville à traiter
listeVilleWalheim = [
ville
for ville in database.getListeVilles4Departement(connDB, '068', False)
if ville[0] == '068376'
]
ville = listeVilleWalheim[0]
# Recup des annees de données fiscales por WALHEIN
dictAllGrandeur = database.getAllValeursDataMinFi4Entite(
connDB, 'V', ville[0], False)
listAnnees = database.getListeAnneesDataMinFi4Entite(
connDB, 'V', ville[0], False)
assert len(listAnnees) == 3
# Agglomère certaines grandeurs et complète dictAllGrandeur
genCodeCommon.calculeGrandeur(config, dictAllGrandeur, listAnnees, True,
False)
# Lecture du modèle
nomBaseModele = config.get('Modele', 'modele.nomBaseModele')
typeSortie = config.get('GenCode', 'gen.idFicDetail')
modele = nomBaseModele + '_' + typeSortie + '.txt'
textSection = utilitaires.lectureFiltreModele(modele, isComplet, False)
# Generation des graphiques pour une ville
textSection = genCodeGraphiques.genCodeGraphiques(config, repOutGraphique,
dictAllGrandeur,
textSection, ville[1],
listAnnees, isComplet,
isWikicode, True, True)
# Test des valeurs générées
if isWikicode:
assert "Graphique polygonal" in textSection
else:
assert ".svg" in textSection
def test_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)
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"))
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.
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()
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
