Fix deciles quand somme a 0

Simulation_engine/simulate_pop_from_reform.py

@@ -251,6 +251,7 @@ def calcule_personnes_touchees(factor: Dict, impots_par_reforme):
     """
     ::factor:: Contient le facteur de correction/callage {"avant": factor_avant,"plf": factor_plf,"apres": factor_plf}
     """
+    logging.debug(f"calcule_personnes_touchees factor={factor}")
     # On fait tous les passages possibles entre les resultats:
     simus_passages = liste_noms_reformes_avec_apres
     # simus_passages = ['avant', 'plf', 'apres']
@@ -302,7 +303,7 @@ def dataframe_pondere(dictionnaire_simulations: Dict) -> pandas.DataFrame:
 
 
 def compare(period: str, dictionnaire_simulations, compute_deciles=True):
-    logging.debug("Compare.")
+    logging.debug(f"Compare. compute_deciles={compute_deciles} period={period}")
     res: Total = {}
     if (
         "avant" not in dictionnaire_simulations
@@ -331,7 +332,6 @@ def compare(period: str, dictionnaire_simulations, compute_deciles=True):
         ).sum()
     total: Total = res
     if compute_deciles:
-        logging.debug("Calcule des déciles.")
         # On rajoute les simulations par défaut à la liste des colonnes sur lesquelles calculer les déciles,
         # On en a besoin si ces colonnes ne sont pas déjà dans le dictionnaire_simulations (par exemple
         # dans le cas d'un compare avec isdecile = True)
@@ -347,6 +347,7 @@ def compare(period: str, dictionnaire_simulations, compute_deciles=True):
             set(dictionnaire_simulations.keys()) | set(liste_noms_reformes_sans_apres)
         )
         totweight = impots_par_reforme["wprm"].sum()
+        logging.debug(f"compare - Calcule des déciles - totweight={totweight}")
         nbd = 10
         decilweights = [i / nbd * totweight for i in range(nbd + 1)]
         numdecile = 1
@@ -386,14 +387,20 @@ def compare(period: str, dictionnaire_simulations, compute_deciles=True):
                         # Dans ce cas, curr_sum est la somme de l'IRPP
                         un_decile['sum_irpp_' + key] = curr_sum
                         un_decile['avg_irpp_' + key] = curr_sum / nb_foy
+                        # Evite la division par zéro
+                        if sum_rfr < 1:
+                            un_decile['irpp_on_rfr_' + key] = 0
+                        else:
                             un_decile['irpp_on_rfr_' + key] = curr_sum / sum_rfr
+                        if un_decile["avg_rfr"] < 1:
+                            un_decile['avg_irpp_on_avg_rfr_' + key] = 0
+                        else:
                             un_decile['avg_irpp_on_avg_rfr_' + key] = un_decile['avg_irpp_' + key] / un_decile["avg_rfr"]
                 decdiffres += [un_decile]
                 sum_rfr = 0
                 nb_foy = 0
                 frontieres_deciles += [row["keysort"]]
                 numdecile += 1
-
         total = adjust_total(factor, total)
         deciles = decdiffres
 
@@ -415,7 +422,7 @@ def compare(period: str, dictionnaire_simulations, compute_deciles=True):
         dic_nbptr = nbptr_par_reforme.to_dict()
         del dic_nbptr["wprm"]
         resultat = {"total": total, "res_brut": dic_res_brut, "nbreParts": dic_nbptr}
-
+    logging.debug(f"compare - Terminé resultat={resultat.get('total')} nb_decile={len(resultat.get('deciles', []))}")
     return resultat
 
 
@@ -466,6 +473,7 @@ def adjust_total(factor: dict, total: dict, ignore_keys: Optional[List[str]] = N
     Pour la faire classe, on calibre le modèle sur un paramètre
     (facteur d'ajustement de l'impôt de chacun des ménages).
     """
+    logging.debug(f"adjust_total factor={factor}")
     if ignore_keys is None:
         ignore_keys = ["poids"]
     # res = {}
@@ -1040,8 +1048,10 @@ def CompareOldNew(taux=None, isdecile=True, dictreform=None, castypedesc=None):
         # On ne crée qu'une simulation, le moteur de calcul ayant précalculé les autres.
         simulation_reform = simulation(PERIOD, data, reform)
         # On n'envoie à simuler que le "apres"
+        logging.debug("CompareOldNew calcul décile...")
         return compare(PERIOD, {"apres": simulation_reform}, isdecile)
 
+    logging.debug("CompareOldNew calcul cas type...")
     # Pour les cas-types, on n'utilise pas de resultats précalculés
     # donc on inclut aussi les simulations par défaut
     data, default_sims = (

server/handlers/cas_types.py

+from asyncio.log import logger
 from Simulation_engine.simulate_pop_from_reform import (
     desc_cas_types,
     CompareOldNew,
@@ -17,6 +18,7 @@ def error_as_dict(errormessage):
 
 def simpop_stream(dbod):
     yield "\n"
+    logger.debug("simpop_stream : Appel de CompareOldNew avec isdecile=True")
     dic_resultat = CompareOldNew(
         taux=None, isdecile=True, dictreform=dbod["reforme"], castypedesc=None
     )
@@ -37,6 +39,10 @@ class CasTypes(object):
 
 class SimulationRunner(object):
     def simulereforme(**params: dict) -> tuple:
+        '''
+        Answer to the endpoint /calculate/compare
+        '''
+        logger.debug("In SimulationRunner->simulereforme")
         dbod = params["body"]
         dct = None
         if "description_cas_types" in dbod:
@@ -46,6 +52,7 @@ class SimulationRunner(object):
         if "reforme" not in dbod:
             return error_as_dict("missing 'reforme' field in body of your request"), 400
         try:
+            logger.debug("SimulationRunner->simulereforme : Appel de CompareOldNew")
             dic_resultat = CompareOldNew(
                 taux=None, isdecile=False, dictreform=dbod["reforme"], castypedesc=dct
             )
@@ -54,10 +61,13 @@ class SimulationRunner(object):
 
         if "timestamp" in dbod:
             dic_resultat["timestamp"] = dbod["timestamp"]
-        return (dic_resultat, 201)
+        return (dic_resultat, 200)
 
     @with_session
     def simuledeciles(session, **params: dict) -> Response:
+        '''
+        Answer to the endpoint /calculate/simpop
+        '''
         dbod = params["body"]
         if "reforme" not in dbod:
             return Response(
@@ -81,6 +91,14 @@ class SimulationRunner(object):
                 ),
                 status=400,
             )
-        return Response(
-            simpop_stream(dbod), status=200, content_type="application/json"
+        logger.debug("SimulationRunner->simuledeciles : Appel de simpop_stream")
+        # return Response(
+        #     simpop_stream(dbod), status=200, content_type="application/json"
+        # )
+        dic_resultat = CompareOldNew(
+            taux=None, isdecile=True, dictreform=dbod["reforme"], castypedesc=None
         )
+        if "timestamp" in dbod:
+            dic_resultat["timestamp"] = dbod["timestamp"]
+        logger.debug(f"SimulationRunner->simuledeciles : Retourne le résultat={dic_resultat.get('total')} nb_decile={len(dic_resultat.get('deciles', []))}")
+        return Response(json.dumps(dic_resultat), status=200, content_type="application/json")