ajoute l'imputation de la variable effectif_entreprise à partir de l'erfs 2019

.config/openfisca-survey-manager/config.ini

@@ -5,7 +5,7 @@ openfisca_erfs_fpr = /mnt/data-out/openfisca-france-data/master/data_collections
 leximpact = /mnt/data-out/leximpact-prepare-data/data_collections/leximpact.json
 
 [data]
-output_directory = /mnt/data-out/leximpact-prepare-data/pipeline_output_data/
+output_directory = /mnt/data-out/leximpact-prepare-data/pipeline_output_data/erfs2022_pote2022/
 tmp_directory = /mnt/data-out/leximpact-prepare-data/tmp
 figures_directory = /mnt/data-out/leximpact-prepare-data/figures_directory
 

leximpact_prepare_data/pipeline_survey_scenario.py

@@ -18,6 +18,10 @@
 from leximpact_prepare_data.scenario_tools.calcul_loyers_moyens import (
     creer_table_loyers_moyens,
 )
+from leximpact_prepare_data.scenario_tools.calcul_nombre_salaries_entreprise import (
+    creer_part_petites_entreprises,
+)
+
 from leximpact_survey_scenario.leximpact_survey_scenario import (
     LeximpactErfsSurveyScenario,
 )
@@ -95,6 +99,69 @@ def build_imputation(self, year):
                 if t_b_variable not in variables_to_keep:
                     self.simulations["baseline"].delete_arrays(t_b_variable, period=y)
 
+    def build_imputation_effectif_entreprise(self):
+        part_entreprise_moins_50 = creer_part_petites_entreprises()
+
+        variables = [
+            "person_id",
+            "weight_individus",
+            "categorie_salarie",
+            "salaire_de_base",
+            "noindiv",
+        ]
+        table_tot = self.simulations["baseline"].create_data_frame_by_entity(
+            variables, merge=True
+        )
+
+        table_salaries = table_tot[
+            table_tot.categorie_salarie < 2
+        ]  # on ne garde que les salariés du privé cadre et non cadre
+        table_salaries["quantiles"] = np.minimum(
+            np.ceil(
+                10
+                * table_salaries.weight_individus.cumsum()
+                / table_salaries.weight_individus.sum()
+            ),
+            10,
+        )
+        table_salaries = pd.merge(
+            table_salaries,
+            part_entreprise_moins_50,
+            on=["quantiles", "categorie_salarie"],
+        )
+        table_salaries["aleat"] = np.random.rand(len(table_salaries))
+        table_salaries["effectif_entreprise"] = np.where(
+            table_salaries.aleat < table_salaries.part_entreprises_moins_50_salaries,
+            10,
+            60,
+        )
+        table_tot = pd.merge(
+            table_tot,
+            table_salaries[["effectif_entreprise", "person_id"]],
+            on="person_id",
+            how="outer",
+        )
+        table_tot["effectif_entreprise"] = table_tot.effectif_entreprise.fillna(0)
+        table_tot = table_tot.sort_values("person_id")
+
+        assert (
+            table_tot[table_tot.categorie_salarie >= 2].effectif_entreprise == 0
+        ).all()
+        assert (
+            table_tot[table_tot.categorie_salarie < 2].effectif_entreprise.isin(
+                [10, 60]
+            )
+        ).all()
+
+        # injecter sur 3 ans
+        years = [self.period - 2, self.period - 1, self.period]
+
+        for year in years:
+            self.simulations["baseline"].delete_arrays("loyer", year)
+            self.simulations["baseline"].set_input(
+                "effectif_entreprise", year, table_tot.effectif_entreprise
+            )
+
     def build_imputation_loyers(self):
 
         # --- Créer la table des loyers moyens ---

leximpact_prepare_data/run_pipeline.py

@@ -59,9 +59,12 @@ def run_pipeline(
         baseline_tax_benefit_system=pipeline_tbs,
     )
 
-    # Imputation des loyers
+    # Imputation des loyers à partir de l'erfs 2019
     survey_scenario.build_imputation_loyers()
 
+    # Imputation des effectif d'entreprise à partir de l'erfs 2019
+    survey_scenario.build_imputation_effectif_entreprise()
+
     # Mensualisation : boucle annees n, n-1, n-2
     for year in [annee_de_calcul, annee_de_calcul - 1, annee_de_calcul - 2]:
         variables = survey_scenario.used_as_input_variables

leximpact_prepare_data/scenario_tools/calcul_nombre_salaries_entreprise.py

+#  --- Imports ---
+
+import numpy as np
+import os
+from leximpact_survey_scenario.leximpact_survey_scenario import (
+    LeximpactErfsSurveyScenario,
+)
+from leximpact_common_python_libraries.config import Configuration
+
+
+def creer_part_petites_entreprises():
+    # calcul la part d'entreprise de moins de 50 salariés dans l'erfs fpr 2019 pour l'injecter dans les millésimes suivants dans lesquels la donnée n'existe plus
+
+    # --- Fichier config.ini ---
+    config = Configuration(project_folder="leximpact-prepare-data")
+    config_files_directory = os.path.join(
+        config.project_module_path, ".config", "openfisca-survey-manager"
+    )
+
+    # Charger le survey scenario
+    survey_scenario = LeximpactErfsSurveyScenario(
+        config_files_directory=config_files_directory,
+        annee_donnees=2019,
+        period=2019,
+        collection="openfisca_erfs_fpr",
+        survey_name="openfisca_erfs_fpr_2019",
+    )
+
+    # Simulation
+    simulation = survey_scenario.simulations["baseline"].create_data_frame_by_entity(
+        [
+            "person_id",
+            "weight_individus",
+            "effectif_entreprise",
+            "categorie_salarie",
+            "salaire_de_base",
+        ],
+        period="2019",
+        merge=True,
+    )
+
+    # comme ce qui importe c'est le seuil de 50 salariés pour les cotisations, on crée uniquement deux catégories, en dessus ou dessous du seuil
+    simulation["effectif_entreprise"] = np.where(
+        simulation["effectif_entreprise"] >= 50, 60, 10
+    )
+    simulation[simulation.categorie_salarie < 2].groupby(
+        ["categorie_salarie", "effectif_entreprise"]
+    ).weight_individus.sum() / 1e6
+
+    quantiles = simulation[simulation.categorie_salarie < 2].sort_values(
+        "salaire_de_base", ascending=True
+    )
+    quantiles["quantiles"] = np.minimum(
+        np.ceil(
+            10 * quantiles.weight_individus.cumsum() / quantiles.weight_individus.sum()
+        ),
+        10,
+    )
+    quantiles = (
+        quantiles.groupby(["quantiles", "categorie_salarie", "effectif_entreprise"])
+        .weight_individus.sum()
+        .reset_index()
+    )
+    quantiles["tot_nb"] = quantiles.groupby(
+        ["quantiles", "categorie_salarie"]
+    ).weight_individus.transform("sum")
+    quantiles["part_entreprises_moins_50_salaries"] = (
+        quantiles.weight_individus / quantiles.tot_nb
+    )
+
+    return quantiles[quantiles.effectif_entreprise == 10][
+        ["quantiles", "categorie_salarie", "part_entreprises_moins_50_salaries"]
+    ]