def load_cached_data():
global cached_data
if cached_data is None: # Dictionary of communes is only loaded once
communes = load_dgcl_file()
colonnes_a_garder = {
"Informations générales - Code INSEE de la commune": "code",
"Informations générales - Nom de la commune": "name",
"Informations générales - Code département de la commune": "code_departement",
"Informations générales - Population INSEE Année N ": "habitants",
"Potentiel fiscal et financier des communes - Potentiel financier par habitant": "potentielFinancierParHab"
}
df_base = communes[list(colonnes_a_garder.keys())]
# Translation of fields towards less cumbersome names
df_base.columns = [colonnes_a_garder[col] for col in df_base.columns]
# Make sure the department code has at least two characters
df_base["code_departement"] = df_base["code_departement"].astype(str).apply(lambda x: str(x).zfill(2))
# Le fichier de liste des départements est présent en ligne sur :
# https://www.data.gouv.fr/fr/datasets/r/70cef74f-70b1-495a-8500-c089229c0254
path_assets = path_folder_assets()
liste_departements = pd.read_csv(path_assets + "/data/departements-france.csv", dtype=str)
communes_avec_departement = df_base.merge(liste_departements, how="left", on="code_departement")
communes_avec_departement.loc[communes_avec_departement["nom_departement"].isnull(), "nom_departement"] = communes_avec_departement["code_departement"]
communes_avec_departement.columns = [col if col != "nom_departement" else "departement" for col in communes_avec_departement.columns]
# On trie les communes par longueur de nom croissante afin d'être sûrs de pouvoir obtenir toutes les communes (comme les résultats sont limités)
communes_avec_departement = communes_avec_departement.reindex(communes_avec_departement.name.str.len().sort_values().index)
dict_result = communes_avec_departement[["code", "name", "habitants", "potentielFinancierParHab", "departement"]].to_dict(orient="records")
cached_data = dict_result
return cached_data
def loaded_data():
return load_dgcl_file()
def print_eligible_comparison():
PERIOD = "2019"
print(f"{MOUTARDE}DGCL", PERIOD, STOP_COULEUR)
data_dgcl = load_dgcl_file(path_folder_assets() +
"/data/2019-communes-criteres-repartition.csv")
data_calc_dgcl = get_dgcl_results(data_dgcl)
data_sim = adapt_dgcl_data(data_dgcl)
# Insertion des garanties au titre de la DSU (non calculées explicitement dans OFDL)
data_sim = insert_dsu_garanties(data_sim, PERIOD)
# Insertion des garanties communes nouvelles au titre de la DSR (non calculées explicitement dans OFDL)
data_sim = insert_dsr_garanties_communes_nouvelles(data_sim, PERIOD)
TBS = CountryTaxBenefitSystem()
results_last_year = load_dgcl_file(
path_folder_assets() + "/data/2018-communes-criteres-repartition.csv")
# On rajoute à la main la population majorée
results_last_year[
"Dotation forfaitaire - Population DGF major�e"] = results_last_year[
"Informations générales - Population DGF 2018"]
results_last_year = get_last_year_dotations(results_last_year)
data_last_year = results_last_year[[
code_comm, "dsu_montant_eligible",
"dsr_montant_eligible_fraction_bourg_centre",
"dsr_montant_eligible_fraction_perequation",
"dsr_montant_hors_garanties_fraction_cible", "population_dgf_majoree",
"dotation_forfaitaire"
]]
sim = simulation_from_dgcl_csv(PERIOD, data_sim, TBS, data_last_year)
# on va recalculer nous même toutes les colonnes (sauf le code commune)
colonnes_to_compute = list(data_calc_dgcl.columns[1:])
for variable_to_compute in colonnes_to_compute:
data_sim[variable_to_compute] = sim.calculate(variable_to_compute,
PERIOD)
# Merge DGCL results with data_sim
previous_length_data = len(data_sim)
data_sim = data_sim.merge(data_calc_dgcl,
how="inner",
on=code_comm,
suffixes=["", "_precalc"])
assert (len(data_sim) == previous_length_data)
summary_variables = {} # récupère les R²
for nom_ofdl in colonnes_to_compute:
print(f"{BLEU_CLAIR}Comparaison DGCL vs nous pour le calcul de",
nom_ofdl, STOP_COULEUR)
if data_sim[nom_ofdl].dtypes.name == 'bool':
print(
compare_results_bool(data_sim, nom_ofdl,
nom_ofdl + "_precalc"))
else:
# On va printer de manière quelque peu désordonnées diverses métriques nous informant
# sur la précision de notre calcul
resultats_comparaison = compare_results_real(
data_sim, nom_ofdl, nom_ofdl + "_precalc")
print("***Différence de valeur nul/non nul***")
print(resultats_comparaison["boolean differences"])
print("***Statistiques de base (variable à prédire)***")
print("Moyenne base", resultats_comparaison["Moyenne base"])
print("Ecart-type", resultats_comparaison["variance"]**0.5)
print("***R² : pourcentage de la variance expliqué***")
print(f"{BLEU_CLAIR}",
"{:.4f}%".format(
resultats_comparaison["pourcentage expliqué"] * 100),
STOP_COULEUR,
sep="")
summary_variables[
nom_ofdl] = resultats_comparaison["pourcentage expliqué"] * 100
print("***Différence entre prédit et précalculé***")
for cle in ["L1", "L2", "L∞"]:
print(cle, ": ", resultats_comparaison[cle])
print(
"***Différence entre prédit et précalculé : répartition des écarts***"
)
for cle in ["min", "max"]:
print("ecart", cle, resultats_comparaison[cle])
print('***Différence entre prédit et précalculé : "identiques"***')
for cle in ["differents", "identiques"]:
print(cle, resultats_comparaison[cle])
print(
"***Répartition des écarts ordonnés par quantiles d'erreur***")
for quantile_borne in resultats_comparaison["quantiles"]:
rang, valeur = resultats_comparaison["quantiles"][
quantile_borne]
# le rang représente la quantité de communes concernées
print("{}% (rang {})\t {:.2f}".format(
int(quantile_borne * 100), rang, valeur))
erreur_totale = 100 * len(summary_variables) - sum(
summary_variables.values())
print(f"{BLEU_CLAIR}")
print("Résumé des pourcentages expliqués :")
largeur_justify_name = max([len(nom) for nom in summary_variables]) + 3
for variable, pourcentage_explique_variable in summary_variables.items():
print("{}{:>8.4f}".format(variable.ljust(largeur_justify_name, ' '),
pourcentage_explique_variable))
print("Total des erreurs qui a peu de sens mathématique :")
print(erreur_totale)
print(STOP_COULEUR)
def resultfromreforms(dict_ref=None, to_compute_res=("dsr_eligible_fraction_bourg_centre", "dsr_eligible_fraction_perequation", "dsr_eligible_fraction_cible")):
PERIOD = "2021"
path_assets = path_folder_assets()
# some of these can be preloaded in memory to improve performance.
DATA = adapt_dgcl_data(load_dgcl_file(path_assets + "/data/{}-communes-criteres-repartition.csv".format(int(PERIOD) - 1)))
DATA = insert_dsu_garanties(DATA, PERIOD, path_assets + "/data/garanties_dsu.csv")
DATA = insert_dsr_garanties_communes_nouvelles(DATA, PERIOD, folder=path_assets + "/data/")
results_last_year = get_last_year_dotations(load_dgcl_file(path_assets + "/data/{}-communes-criteres-repartition.csv".format(int(PERIOD) - 1)))
data_last_year = results_last_year[
[
code_comm,
"dsu_montant_eligible",
"dsr_montant_eligible_fraction_bourg_centre",
"dsr_montant_eligible_fraction_perequation",
"dsr_montant_hors_garanties_fraction_cible",
"dotation_forfaitaire",
"population_dgf_majoree",
]
]
TBS = CountryTaxBenefitSystem()
dict_sims = {"base": simulation_from_dgcl_csv(PERIOD, DATA, TBS, data_last_year)}
# création d'un dictionnaire contenant une simulation par output
if dict_ref is not None:
for nom_scenario, reforme_scenario in dict_ref.items():
TBS_Modified = DotationReform(TBS, reforme_scenario, PERIOD)
dict_sims[nom_scenario] = simulation_from_dgcl_csv(PERIOD, DATA, TBS_Modified, data_last_year)
# stockage des résulats dans un dataframe
for nom_scenario, sim in dict_sims.items():
for champ in to_compute_res:
DATA[champ + "_" + nom_scenario] = sim.calculate(champ, PERIOD)
if DATA[champ + "_" + nom_scenario].dtype == np.float32:
DATA[champ + "_" + nom_scenario] = DATA[champ + "_" + nom_scenario].astype(np.float64)
# Determination d'une metrique non calculée dans OFDL
# Le nombre d'années nécessaires à la convergence de la DSR, métrique
# qui passionne le tout Paris d'après les CR d'entretiens utilisateurs
# La DSR est composée de 3 fractions, chacune d'entre elle ne peut varier que dans une certaine mesure (entre -10% et +20%)
# Si tous les champs nécessaires au calcul sont présentes dans les résultats calculés, on inclut
# les metrics calculées à la main
required_variables = [
"dsr_montant_eligible_fraction_bourg_centre",
"dsr_montant_eligible_fraction_perequation",
"dsr_montant_hors_garanties_fraction_cible",
"dsr_montant_hors_garanties_fraction_perequation",
"dsr_montant_hors_garanties_fraction_bourg_centre",
"dsr_montant_garantie_non_eligible_fraction_bourg_centre",
"dsr_montant_garantie_non_eligible_fraction_cible"
]
required_columns = [k + "_" + nom_scenario for k in required_variables]
missing_columns = len([k for k in required_columns if k not in DATA.columns])
ZERO_FOR_FLOATS = 0.1
if not missing_columns:
data_convergence = DATA[[code_comm] + required_columns]
data_convergence["rapport_bc"] = np.where(data_convergence["dsr_montant_eligible_fraction_bourg_centre" + "_" + nom_scenario] > 0, data_convergence["dsr_montant_hors_garanties_fraction_bourg_centre" + "_" + nom_scenario] / data_convergence["dsr_montant_eligible_fraction_bourg_centre" + "_" + nom_scenario], 1)
data_convergence["rapport_pq"] = np.where(data_convergence["dsr_montant_eligible_fraction_perequation" + "_" + nom_scenario] > 0, data_convergence["dsr_montant_hors_garanties_fraction_perequation" + "_" + nom_scenario] / data_convergence["dsr_montant_eligible_fraction_perequation" + "_" + nom_scenario], 1)
# calcul des années de fin pour chaque garantie
data_convergence["annee_bc"] = np.where((data_convergence["rapport_bc"] != 1) & (data_convergence["rapport_bc"] > ZERO_FOR_FLOATS), np.ceil(np.maximum(np.log(data_convergence["rapport_bc"]) / np.log(0.9), np.log(data_convergence["rapport_bc"]) / np.log(1.2))), 0) + 1
data_convergence["annee_bc"] = np.where((data_convergence["dsr_montant_eligible_fraction_bourg_centre" + "_" + nom_scenario] == 0) & (data_convergence["dsr_montant_garantie_non_eligible_fraction_bourg_centre" + "_" + nom_scenario] > 0), 2, data_convergence["annee_bc"])
data_convergence["annee_cible"] = np.where((data_convergence["dsr_montant_garantie_non_eligible_fraction_cible" + "_" + nom_scenario] > 0), 2, 1)
data_convergence["annee_pq"] = np.where((data_convergence["rapport_pq"] != 1) & (data_convergence["rapport_pq"] > ZERO_FOR_FLOATS), np.ceil(np.maximum(np.log(data_convergence["rapport_pq"]) / np.log(0.9), np.log(data_convergence["rapport_pq"]) / np.log(1.2))), 0) + 1
DATA["annee_convergence_dsr_" + nom_scenario] = np.maximum(np.maximum(data_convergence["annee_cible"], data_convergence["annee_bc"]), data_convergence["annee_pq"])
return DATA
"Informations générales - Population DGF Année N'"
)
def get_strate_2(data):
return sort_by_column(
data.loc[data["Informations générales - Population DGF Année N'"] >= 10_000],
"Informations générales - Population DGF Année N'"
)
# strates par nombre d'habitants
# strates_leximpact = [500, 1000, 2000, 3500, 5000, 7500, 10_000, 15_000, 20_000, 35_000, 50_000, 75_000, 100_000]
# strates_dsu = [5000, 10_000] # 5000+, 10_000+
data = load_dgcl_file()
data_adapted = adapt_dgcl_data(data)
data_adapted_min = get_minimum_data(data)
period = 2021
simulation = new_simulation(period, data_adapted)
dsu_montant_eligible = simulation.calculate('dsu_montant_eligible', period)
dsu_montant = simulation.calculate('dsu_montant', period)
strate_0_data = get_strate_0(data_adapted_min)
strate_1_data = get_strate_1(data_adapted_min)
strate_2_data = get_strate_2(data_adapted_min)
# communes sortantes de la DSU (baisse de population)
# dsu_strate_0 = strate_0_data['Dotation de solidarité urbaine - Montant total réparti']