def function(self, simulation, period): residence_guadeloupe = simulation.calculate('residence_guadeloupe', period) residence_martinique = simulation.calculate('residence_martinique', period) residence_guyane = simulation.calculate('residence_guyane', period) residence_reunion = simulation.calculate('residence_reunion', period) residence_mayotte = simulation.calculate('residence_mayotte', period) return period, or_(or_(residence_guadeloupe, residence_martinique), or_(or_(residence_reunion, residence_guyane), residence_mayotte))
def function_2009(self, simulation, period): ''' Prime de solidarité active (exceptionnelle, 200€ versés une fois en avril 2009) Versement en avril 2009 d’une prime de solidarité active (Psa) aux familles modestes qui ont bénéficié en janvier, février ou mars 2009 du Rmi, de l’Api (du Rsa expérimental, du Cav ou du Rma pour les ex-bénéficiaires du Rmi ou de l’Api), de la prime forfaitaire mensuelle au titre du Rmi ou de l’Api ou enfin d’une aide au logement (à condition d’exercer une activité professionnelle et d’être âgé de plus de 25 ans ou d’avoir au moins un enfant à charge). La Psa, prime exceptionnelle, s’élève à 200 euros par foyer bénéficiaire. ''' period = period.start.offset('first-of', 'year').offset(3, 'month').period('month') api = simulation.calculate('api', period) rsa = simulation.calculate('rsa', period) activite_holder = simulation.compute('activite', period) af_nbenf = simulation.calculate('af_nbenf', period) aide_logement = simulation.calculate('aide_logement', period) P = simulation.legislation_at(period.start).minim.rmi activite = self.split_by_roles(activite_holder, roles = [CHEF, PART]) dummy_api = api > 0 dummy_rmi = rsa > 0 dummy_al = and_(aide_logement > 0, or_(af_nbenf > 0, or_(activite[CHEF] == 0, activite[PART] == 0))) condition = (dummy_api + dummy_rmi + dummy_al > 0) psa = condition * P.psa return period, psa
def abbattement_chomage(): indemnites_journalieres_maladie = individu( 'indemnites_journalieres_maladie', period) chomage = individu('activite', period) == TypesActivite.chomeur indemnites_chomage_partiel = individu('indemnites_chomage_partiel', period) chomage_net = individu('chomage_net', period) ass = individu('ass', period) revenus_stage_formation_pro = individu( 'revenus_stage_formation_pro', period) condition_ij_maladie = indemnites_journalieres_maladie > 0 condition_chomage = chomage * ( (indemnites_chomage_partiel + chomage_net) > 0) condition_ass = ass > 0 condition_revenus_formation_pro = revenus_stage_formation_pro > 0 eligibilite_abattement_chomage = or_( condition_ij_maladie, or_(condition_chomage, or_(condition_ass, condition_revenus_formation_pro))) salaire_net = individu('salaire_net', previous_year, options=[ADD]) return eligibilite_abattement_chomage * salaire_net * P.abattement_chomage
def function_2009(self, simulation, period): """ Prime de solidarité active (exceptionnelle, 200€ versés une fois en avril 2009) Versement en avril 2009 d’une prime de solidarité active (Psa) aux familles modestes qui ont bénéficié en janvier, février ou mars 2009 du Rmi, de l’Api (du Rsa expérimental, du Cav ou du Rma pour les ex-bénéficiaires du Rmi ou de l’Api), de la prime forfaitaire mensuelle au titre du Rmi ou de l’Api ou enfin d’une aide au logement (à condition d’exercer une activité professionnelle et d’être âgé de plus de 25 ans ou d’avoir au moins un enfant à charge). La Psa, prime exceptionnelle, s’élève à 200 euros par foyer bénéficiaire. """ period = period.start.offset("first-of", "month").period("month") api = simulation.calculate("api", period) rsa = simulation.calculate("rsa", period) activite_holder = simulation.compute("activite", period) af_nbenf = simulation.calculate("af_nbenf", period) aide_logement = simulation.calculate("aide_logement", period) P = simulation.legislation_at(period.start).minim.rmi activite = self.split_by_roles(activite_holder, roles=[CHEF, PART]) dummy_api = api > 0 dummy_rmi = rsa > 0 dummy_al = and_(aide_logement > 0, or_(af_nbenf > 0, or_(activite[CHEF] == 0, activite[PART] == 0))) condition = dummy_api + dummy_rmi + dummy_al > 0 psa = condition * P.psa return period, psa
def _psa(api, rsa, activite, af_nbenf, al, _P, _option={"activite": [CHEF, PART]}): ''' Prime de solidarité active (exceptionnelle, 200€ versés une fois en avril 2009) ''' # Versement en avril 2009 d’une prime de solidarité active (Psa) aux familles modestes qui ont bénéficié en janvier, # février ou mars 2009 du Rmi, de l’Api (du Rsa expérimental, du Cav ou du Rma pour les ex-bénéficiaires du Rmi ou de l’Api), # de la prime forfaitaire mensuelle au titre du Rmi ou de l’Api # ou enfin d’une aide au logement (à condition d’exercer une activité professionnelle et d’être âgé de plus de 25 ans # ou d’avoir au moins un enfant à charge). # La Psa, prime exceptionnelle, s’élève à 200 euros par foyer bénéficiaire. dummy_api = api > 0 dummy_rmi = rsa > 0 dummy_al = and_( al > 0, or_(af_nbenf > 0, or_(activite[CHEF] == 0, activite[PART] == 0))) condition = (dummy_api + dummy_rmi + dummy_al > 0) P = _P.minim.rmi psa = condition * P.psa return psa
def _enceinte_fam(self, agem_holder, enceinte_holder): agem_enf = self.split_by_roles(agem_holder, roles = ENFS) enceinte = self.split_by_roles(enceinte_holder, roles = [CHEF, PART]) benjamin = age_en_mois_benjamin(agem_enf) enceinte_compat = and_(benjamin < 0, benjamin > -6) return or_(or_(enceinte_compat, enceinte[CHEF]), enceinte[PART])
def function(self, simulation, period): period = period agem_holder = simulation.compute('agem', period) enceinte_holder = simulation.compute('enceinte', period) agem_enf = self.split_by_roles(agem_holder, roles = ENFS) enceinte = self.split_by_roles(enceinte_holder, roles = [CHEF, PART]) benjamin = age_en_mois_benjamin(agem_enf) enceinte_compat = and_(benjamin < 0, benjamin > -6) return period, or_(or_(enceinte_compat, enceinte[CHEF]), enceinte[PART])
def function(self, simulation, period): residence_guadeloupe = simulation.calculate('residence_guadeloupe', period) residence_martinique = simulation.calculate('residence_martinique', period) residence_guyane = simulation.calculate('residence_guyane', period) residence_reunion = simulation.calculate('residence_reunion', period) residence_mayotte = simulation.calculate('residence_mayotte', period) return period, or_( or_(residence_guadeloupe, residence_martinique), or_(or_(residence_reunion, residence_guyane), residence_mayotte))
def function(self, simulation, period): period = period age_en_mois_holder = simulation.compute('age_en_mois', period) enceinte_holder = simulation.compute('enceinte', period) age_en_mois_enf = self.split_by_roles(age_en_mois_holder, roles = ENFS) enceinte = self.split_by_roles(enceinte_holder, roles = [CHEF, PART]) benjamin = age_en_mois_benjamin(age_en_mois_enf) enceinte_compat = and_(benjamin < 0, benjamin > -6) return period, or_(or_(enceinte_compat, enceinte[CHEF]), enceinte[PART])
def formula(individu, period, parameters): depcom_entreprise = individu('depcom_entreprise', period) effectif_entreprise = individu('effectif_entreprise', period) categorie_salarie = individu('categorie_salarie', period) seuil_effectif = parameters( period).cotsoc.versement_transport.seuil_effectif preload_taux_versement_transport() public = ( (categorie_salarie == TypesCategorieSalarie.public_titulaire_etat) + (categorie_salarie == TypesCategorieSalarie.public_titulaire_militaire) + (categorie_salarie == TypesCategorieSalarie.public_titulaire_territoriale) + (categorie_salarie == TypesCategorieSalarie.public_titulaire_hospitaliere) + (categorie_salarie == TypesCategorieSalarie.public_non_titulaire) + (categorie_salarie == TypesCategorieSalarie.non_pertinent)) taux_versement_transport = fromiter( (get_taux_versement_transport(code_commune, period) for code_commune in depcom_entreprise), dtype='float', ) # "L'entreprise emploie-t-elle plus de 9 ou 10 salariés dans le périmètre de l'Autorité organisatrice de transport # (AOT) suivante ou syndicat mixte de transport (SMT)" return taux_versement_transport * or_( effectif_entreprise >= seuil_effectif, public) / 100
def formula(famille, period): cmu_c_plafond = famille('cmu_c_plafond', period) cmu_base_ressources = famille('cmu_base_ressources', period) residence_mayotte = famille.demandeur.menage('residence_mayotte', period) cmu_acs_eligibilite = famille('cmu_acs_eligibilite', period) if period.start.date >= date(2016, 1, 1): eligibilite_rsa = famille('rsa', period) > 0 else: # Avant 2016, seules les bénéficiaires du RSA socle avait le droit d'office à la CMU. rsa_socle = famille('rsa_socle', period) rsa_socle_majore = famille('rsa_socle_majore', period) rsa_forfait_logement = famille('rsa_forfait_logement', period) rsa_base_ressources = famille('rsa_base_ressources', period) socle = max_(rsa_socle, rsa_socle_majore) rsa = famille('rsa', period) eligibilite_rsa = (rsa > 0) * (rsa_base_ressources < socle - rsa_forfait_logement) eligibilite_basique = cmu_base_ressources <= cmu_c_plafond return ( cmu_acs_eligibilite * not_(residence_mayotte) * or_(eligibilite_basique, eligibilite_rsa) )
def formula(famille, period, parameters): eligibilite_base = famille('af_eligibilite_base', period) eligibilite_dom = famille('af_eligibilite_dom', period) af_nbenf = famille('af_nbenf', period) pfam = parameters(period).prestations.prestations_familiales.af eligibilite = or_(eligibilite_base, eligibilite_dom) un_seul_enfant = ( eligibilite_dom * (af_nbenf == 1) * pfam.af_dom.taux_enfant_seul ) deux_enfants = (af_nbenf >= 2) * pfam.taux.enf2 plus_de_trois_enfants = max_(af_nbenf - 2, 0) * pfam.taux.enf3 taux_total = un_seul_enfant + deux_enfants + plus_de_trois_enfants montant_base = eligibilite * round_(pfam.bmaf * taux_total, 2) coeff_garde_alternee = famille('af_coeff_garde_alternee', period) montant_base = montant_base * coeff_garde_alternee af_taux_modulation = famille('af_taux_modulation', period) montant_base_module = montant_base * af_taux_modulation return montant_base_module
def abbattement_chomage(): indemnites_chomage_partiel = individu('indemnites_chomage_partiel', previous_year, options = [ADD]) salaire_net = individu('salaire_net', previous_year, options = [ADD]) chomage_last_month = individu('chomage_net', last_month) condition = or_(chomage_last_month > 0, revenus_stage_formation_pro_last_month > 0) assiette = indemnites_chomage_partiel + salaire_net return condition * assiette * P.abattement_chomage
def function(self, simulation, period): period = period.start.offset('first-of', 'month').period('year') rfr = simulation.calculate('rfr', period.start.offset('first-of', 'year').period('year').offset(-2)) age_holder = simulation.compute('age', period) scolarite_holder = simulation.compute('scolarite', period) P = simulation.legislation_at(period.start).bourses_education.bourse_college ages = self.split_by_roles(age_holder, roles = ENFS) nb_enfants = zeros(len(rfr)) for age in ages.itervalues(): nb_enfants += age >= 0 plafond_taux_1 = P.plafond_taux_1 + P.plafond_taux_1 * nb_enfants * P.coeff_enfant_supplementaire plafond_taux_2 = P.plafond_taux_2 + P.plafond_taux_2 * nb_enfants * P.coeff_enfant_supplementaire plafond_taux_3 = P.plafond_taux_3 + P.plafond_taux_3 * nb_enfants * P.coeff_enfant_supplementaire eligible_taux_3 = rfr < plafond_taux_3 eligible_taux_2 = not_(eligible_taux_3) * (rfr < plafond_taux_2) eligible_taux_1 = not_(or_(eligible_taux_2, eligible_taux_3)) * (rfr < plafond_taux_1) scolarites = self.split_by_roles(scolarite_holder, roles = ENFS) nb_enfants_college = zeros(len(rfr)) for scolarite in scolarites.itervalues(): nb_enfants_college += scolarite == SCOLARITE_COLLEGE montant = ( eligible_taux_3 * P.montant_taux_3 + eligible_taux_2 * P.montant_taux_2 + eligible_taux_1 * P.montant_taux_1 ) montant *= nb_enfants_college return period, montant
def function(self, simulation, period): period = period.this_month ass_base_ressources = simulation.calculate('ass_base_ressources', period) ass_eligibilite_i_holder = simulation.compute( 'ass_eligibilite_individu', period) en_couple = simulation.calculate('en_couple', period) ass_params = simulation.legislation_at( period.start).prestations.minima_sociaux.ass ass_eligibilite_i = self.split_by_roles(ass_eligibilite_i_holder, roles=[CHEF, PART]) elig = or_(ass_eligibilite_i[CHEF], ass_eligibilite_i[PART]) montant_journalier = ass_params.montant_plein montant_mensuel = 30 * montant_journalier plafond_mensuel = montant_journalier * ( ass_params.plaf_seul * not_(en_couple) + ass_params.plaf_coup * en_couple) revenus = ass_base_ressources / 12 ass = min_(montant_mensuel, plafond_mensuel - revenus) ass = max_(ass, 0) ass = ass * elig ass = ass * not_( ass < ass_params.montant_plein ) # pas d'ASS si montant mensuel < montant journalier de base return period, ass
def formula_2017_09_01(individu, period, parameters): ''' Reference : https://www.legifrance.gouv.fr/eli/decret/2017/5/5/ETSD1708117D/jo/article_2 ''' age_max = parameters(period).prestations.minima_sociaux.ass.age_max sous_age_limite = individu('age_en_mois', period) <= age_max aah_eligible = individu('aah', period) > 0 demandeur_emploi_non_indemnise = and_( individu('activite', period) == TypesActivite.chomeur, individu('chomage_net', period) == 0) eligible_cumul_ass = individu('ass_eligibilite_cumul_individu', period) demandeur_emploi_non_indemnise_et_cumul_accepte = or_( demandeur_emploi_non_indemnise, not_(demandeur_emploi_non_indemnise) * eligible_cumul_ass) # Indique que l'individu a travaillé 5 ans au cours des 10 dernieres années. ass_precondition_remplie = individu('ass_precondition_remplie', period) return not_( aah_eligible ) * demandeur_emploi_non_indemnise_et_cumul_accepte * ass_precondition_remplie * sous_age_limite
def function(self, simulation, period): period = period.start.period(u'month').offset('first-of') depcom_entreprise = simulation.calculate('depcom_entreprise', period) effectif_entreprise = simulation.calculate('effectif_entreprise', period) categorie_salarie = simulation.calculate('categorie_salarie', period) seuil_effectif = simulation.legislation_at( period.start).cotsoc.versement_transport.seuil_effectif preload_taux_versement_transport() public = (categorie_salarie >= 2) default_value = 0.0 taux_aot = fromiter( (taux_aot_by_depcom.get(depcom_cell, default_value) for depcom_cell in depcom_entreprise), dtype='float', ) taux_smt = fromiter( (taux_smt_by_depcom.get(depcom_cell, default_value) for depcom_cell in depcom_entreprise), dtype='float', ) # "L'entreprise emploie-t-elle plus de 9 salariés dans le périmètre de l'Autorité organisatrice de transport # (AOT) suivante ou syndicat mixte de transport (SMT)" return period, (taux_aot + taux_smt) * or_( effectif_entreprise >= seuil_effectif, public) / 100
def function(self, simulation, period): period = period.this_month eligibilite_base = simulation.calculate('cf_eligibilite_base', period) eligibilite_dom = simulation.calculate('cf_eligibilite_dom', period) ressources = simulation.calculate('cf_ressources', period) plafond = simulation.calculate('cf_plafond', period) pfam = simulation.legislation_at(period.start).fam eligibilite_sous_condition = or_(eligibilite_base, eligibilite_dom) # Montant montant = pfam.af.bmaf * (pfam.cf.tx * eligibilite_base + pfam.cf.tx_dom * eligibilite_dom) # Complément familial eligibilite = eligibilite_sous_condition * (ressources <= plafond) # Complément familial différentiel plafond_diff = plafond + 12 * montant eligibilite_diff = not_(eligibilite) * eligibilite_sous_condition * ( ressources <= plafond_diff) montant_diff = (plafond_diff - ressources) / 12 return period, max_(eligibilite * montant, eligibilite_diff * montant_diff)
def function(famille, period, legislation): period = period.this_month eligibilite_base = famille('cf_eligibilite_base', period) eligibilite_dom = famille('cf_eligibilite_dom', period) ressources = famille('cf_ressources', period) plafond = famille('cf_plafond', period) pfam = legislation(period).prestations.prestations_familiales eligibilite_sous_condition = or_(eligibilite_base, eligibilite_dom) # Montant montant = pfam.af.bmaf * (pfam.cf.taux_cf_base * eligibilite_base + pfam.cf.taux_base_dom * eligibilite_dom) # Complément familial eligibilite = eligibilite_sous_condition * (ressources <= plafond) # Complément familial différentiel plafond_diff = plafond + 12 * montant eligibilite_diff = not_(eligibilite) * eligibilite_sous_condition * ( ressources <= plafond_diff) montant_diff = (plafond_diff - ressources) / 12 return period, max_(eligibilite * montant, eligibilite_diff * montant_diff)
def function(individu, period, legislation): period = period.this_month pfam_enfant_a_charge = individu('prestations_familiales_enfant_a_charge', period) age = individu('age', period) garde_alternee = individu('garde_alternee', period) af_nbenf = individu.famille('af_nbenf', period) af_base = individu.famille('af_base', period) age_aine = individu.famille('af_age_aine', period) pfam = legislation(period).prestations.prestations_familiales montant_enfant_seul = pfam.af.bmaf * ( (pfam.af.af_dom.age_1er_enf_tranche_1_dom <= age) * (age < pfam.af.af_dom.age_1er_enf_tranche_2_dom) * pfam.af.af_dom.taux_1er_enf_tranche_1_dom + (pfam.af.af_dom.age_1er_enf_tranche_2_dom <= age) * pfam.af.af_dom.taux_1er_enf_tranche_2_dom ) montant_plusieurs_enfants = pfam.af.bmaf * ( (pfam.af.maj_age_deux_enfants.age1 <= age) * (age < pfam.af.maj_age_deux_enfants.age2) * pfam.af.maj_age_deux_enfants.taux1 + (pfam.af.maj_age_deux_enfants.age2 <= age) * pfam.af.maj_age_deux_enfants.taux2 ) montant = (af_nbenf == 1) * montant_enfant_seul + (af_nbenf > 1) * montant_plusieurs_enfants # Attention ! Ne fonctionne pas pour les enfants du même âge (typiquement les jumeaux...) pas_aine = or_(af_nbenf != 2, (af_nbenf == 2) * not_(age == age_aine)) coeff_garde_alternee = where(garde_alternee, pfam.af.facteur_garde_alternee, 1) return period, pfam_enfant_a_charge * (af_base > 0) * pas_aine * montant * coeff_garde_alternee
def formula(famille, period, parameters): eligibilite_base = famille('cf_eligibilite_base', period) eligibilite_dom = famille('cf_eligibilite_dom', period) ressources = famille('cf_base_ressources', period) plafond = famille('cf_plafond', period) pfam = parameters(period).prestations.prestations_familiales eligibilite_sous_condition = or_(eligibilite_base, eligibilite_dom) # Montant montant = ( pfam.af.bmaf * ( pfam.cf.taux_cf_base * eligibilite_base + pfam.cf.taux_base_dom * eligibilite_dom ) ) # Complément familial eligibilite = eligibilite_sous_condition * (ressources <= plafond) # Complément familial différentiel plafond_diff = plafond + 12 * montant eligibilite_diff = ( not_(eligibilite) * eligibilite_sous_condition * (ressources <= plafond_diff) ) montant_diff = (plafond_diff - ressources) / 12 return max_(eligibilite * montant, eligibilite_diff * montant_diff)
def formula(famille, period, parameters): np_pers = famille('nb_parents', period) + famille('rsa_nb_enfants', period) aide_logement = famille('aide_logement', period) statut_occupation_logement = famille.demandeur.menage('statut_occupation_logement', period) participation_frais = famille.demandeur.menage('participation_frais', period) loyer = famille.demandeur.menage('loyer', period) # 1 = Accédant à la propriété # 2 = Propriétaire (non accédant) du logement # 6 = Logé gratuitement par des parents, des amis ou l'employeur avantage_nature = or_( ((statut_occupation_logement == 1) + (statut_occupation_logement == 2)) * not_(loyer), (statut_occupation_logement == 6) * not_(participation_frais) ) avantage_al = aide_logement > 0 params = parameters(period).prestations.minima_sociaux.rsa montant_base = famille('ppa_montant_forfaitaire_familial_non_majore', period, extra_params = [period]) montant_forfait = montant_base * ( (np_pers == 1) * params.forfait_logement.taux_1_personne + (np_pers == 2) * params.forfait_logement.taux_2_personnes + (np_pers >= 3) * params.forfait_logement.taux_3_personnes_ou_plus ) montant_al = avantage_al * min_(aide_logement, montant_forfait) montant_nature = avantage_nature * montant_forfait return max_(montant_al, montant_nature)
def function(self, simulation, period): period = period.this_month pfam_enfant_a_charge = simulation.calculate('prestations_familiales_enfant_a_charge', period) age = simulation.calculate('age', period) garde_alternee = simulation.calculate('garde_alternee', period) age_aine_holder = simulation.compute('af_age_aine', period) age_aine = self.cast_from_entity_to_roles(age_aine_holder, roles = ENFS) af_nbenf_holder = simulation.compute('af_nbenf', period) af_nbenf = self.cast_from_entity_to_roles(af_nbenf_holder, roles = ENFS) af_base_holder = simulation.compute('af_base', period) af_base = self.cast_from_entity_to_roles(af_base_holder, roles = ENFS) pfam = simulation.legislation_at(period.start).fam montant_enfant_seul = pfam.af.bmaf * ( (pfam.af.maj_age_un_enfant.age1 <= age) * (age < pfam.af.maj_age_un_enfant.age2) * pfam.af.maj_age_un_enfant.taux1 + (pfam.af.maj_age_un_enfant.age2 <= age) * pfam.af.maj_age_un_enfant.taux2 ) montant_plusieurs_enfants = pfam.af.bmaf * ( (pfam.af.maj_age_deux_enfants.age1 <= age) * (age < pfam.af.maj_age_deux_enfants.age2) * pfam.af.maj_age_deux_enfants.taux1 + (pfam.af.maj_age_deux_enfants.age2 <= age) * pfam.af.maj_age_deux_enfants.taux2 ) montant = (af_nbenf == 1) * montant_enfant_seul + (af_nbenf > 1) * montant_plusieurs_enfants # Attention ! Ne fonctionne pas pour les enfants du même âge (typiquement les jumeaux...) pas_aine = or_(af_nbenf != 2, (af_nbenf == 2) * not_(age == age_aine)) coeff_garde_alternee = where(garde_alternee, pfam.af.facteur_garde_alternee, 1) return period, pfam_enfant_a_charge * (af_base > 0) * pas_aine * montant * coeff_garde_alternee
def function(self, simulation, period): period = period.this_month af_enfant_a_charge = simulation.calculate('af_enfant_a_charge', period) age = simulation.calculate('age', period) garde_alternee = simulation.calculate('garde_alternee', period) age_aine_holder = simulation.compute('af_age_aine', period) age_aine = self.cast_from_entity_to_roles(age_aine_holder, roles = ENFS) af_nbenf_holder = simulation.compute('af_nbenf', period) af_nbenf = self.cast_from_entity_to_roles(af_nbenf_holder, roles = ENFS) af_base_holder = simulation.compute('af_base', period) af_base = self.cast_from_entity_to_roles(af_base_holder, roles = ENFS) pfam = simulation.legislation_at(period.start).fam montant_enfant_seul = pfam.af.bmaf * ( (pfam.af.maj_age_un_enfant.age1 <= age) * (age < pfam.af.maj_age_un_enfant.age2) * pfam.af.maj_age_un_enfant.taux1 + (pfam.af.maj_age_un_enfant.age2 <= age) * pfam.af.maj_age_un_enfant.taux2 ) montant_plusieurs_enfants = pfam.af.bmaf * ( (pfam.af.maj_age_deux_enfants.age1 <= age) * (age < pfam.af.maj_age_deux_enfants.age2) * pfam.af.maj_age_deux_enfants.taux1 + (pfam.af.maj_age_deux_enfants.age2 <= age) * pfam.af.maj_age_deux_enfants.taux2 ) montant = (af_nbenf == 1) * montant_enfant_seul + (af_nbenf > 1) * montant_plusieurs_enfants # Attention ! Ne fonctionne pas pour les enfants du même âge (typiquement les jumeaux...) pas_aine = or_(af_nbenf != 2, (af_nbenf == 2) * not_(age == age_aine)) coeff_garde_alternee = where(garde_alternee, pfam.af.facteur_garde_alternee, 1) return period, af_enfant_a_charge * (af_base > 0) * pas_aine * montant * coeff_garde_alternee
def formula(famille, period, parameters): np_pers = famille('nb_parents', period) + famille( 'rsa_nb_enfants', period) aide_logement = famille('aide_logement', period) statut_occupation_logement = famille.demandeur.menage( 'statut_occupation_logement', period) participation_frais = famille.demandeur.menage('participation_frais', period) loyer = famille.demandeur.menage('loyer', period) avantage_nature = or_( ((statut_occupation_logement == TypesStatutOccupationLogement.primo_accedant) + (statut_occupation_logement == TypesStatutOccupationLogement.proprietaire)) * not_(loyer), (statut_occupation_logement == TypesStatutOccupationLogement.loge_gratuitement) * not_(participation_frais)) avantage_al = aide_logement > 0 params = parameters(period).prestations.minima_sociaux.rsa montant_base = famille('ppa_montant_forfaitaire_familial_non_majore', period, extra_params=[period]) montant_forfait = montant_base * ( (np_pers == 1) * params.forfait_logement.taux_1_personne + (np_pers == 2) * params.forfait_logement.taux_2_personnes + (np_pers >= 3) * params.forfait_logement.taux_3_personnes_ou_plus) montant_al = avantage_al * min_(aide_logement, montant_forfait) montant_nature = avantage_nature * montant_forfait return max_(montant_al, montant_nature)
def _quaenv_2010_2011(marpac, nb_pac2, f7we, f7wf, f7wg, f7wh, f7wk, f7wq, f7sb, f7sd, f7se, f7sh, rfr, _P): ''' Crédits d’impôt pour dépenses en faveur de la qualité environnementale (cases 7WF, 7WH, 7WK, 7WQ, 7SB, 7SD, 7SE et 7SH) 2010-2011 ''' P = _P.ir.credits_impot.quaenv max0 = P.max * (1 + marpac) + P.pac1 * nb_pac2 max1 = max_(0, max0 - f7wf) max2 = max_(0, max1 - f7se) max3 = max_(0, max2 - f7wk) max4 = max_(0, max3 - f7sd) max5 = max_(0, max4 - f7wh) max6 = max_(0, max5 - f7sb) max7 = max_(0, max6 - f7wq) return not_(f7wg) * or_(not_(f7we), (rfr < 45000)) * ( P.taux_wf * min_(f7wf, max0) + P.taux_se * min_(f7se, max1) + P.taux_wk * min_(f7wk, max2) + P.taux_sd * min_(f7sd, max3) + P.taux_wh * min_(f7wh, max4) + P.taux_sb * min_(f7sb, max5) + P.taux_wq * min_(f7wq, max6) + P.taux_sh * min_(f7sh, max7))
def abbattement_chomage(): indemnites_chomage_partiel = simulation.calculate('indemnites_chomage_partiel', previous_year) salaire_net = simulation.calculate_add('salaire_net', previous_year) chomage_last_month = simulation.calculate('chomage_net', last_month) condition = or_(chomage_last_month > 0, revenus_stage_formation_pro_last_month > 0) assiette = indemnites_chomage_partiel + salaire_net return condition * assiette * P.abattement_chomage
def function(self, simulation, period): period = period.this_month ressortissant_eee = simulation.calculate("ressortissant_eee", period) duree_possession_titre_sejour = simulation.calculate("duree_possession_titre_sejour", period) duree_min_titre_sejour = simulation.legislation_at(period.start).minim.rmi.duree_min_titre_sejour return period, or_(ressortissant_eee, duree_possession_titre_sejour >= duree_min_titre_sejour)
def function(self, simulation, period): period = period.this_month ressortissant_eee = simulation.calculate('ressortissant_eee', period) duree_possession_titre_sejour = simulation.calculate('duree_possession_titre_sejour', period) duree_min_titre_sejour = simulation.legislation_at(period.start).prestations.minima_sociaux.rsa.duree_min_titre_sejour return period, or_(ressortissant_eee, duree_possession_titre_sejour >= duree_min_titre_sejour)
def function(self, simulation, period): period = period.start.offset("first-of", "month").period("month") af_enfant_a_charge = simulation.calculate("af_enfant_a_charge", period) age = simulation.calculate("age", period) age_aine_holder = simulation.compute("af_age_aine", period) age_aine = self.cast_from_entity_to_roles(age_aine_holder, roles=ENFS) af_nbenf_holder = simulation.compute("af_nbenf", period) af_nbenf = self.cast_from_entity_to_roles(af_nbenf_holder, roles=ENFS) af_base_holder = simulation.compute("af_base", period) af_base = self.cast_from_entity_to_roles(af_base_holder, roles=ENFS) pfam = simulation.legislation_at(period.start).fam montant_enfant_seul = pfam.af.bmaf * ( (pfam.af.maj_age_un_enfant.age1 <= age) * (age < pfam.af.maj_age_un_enfant.age2) * pfam.af.maj_age_un_enfant.taux1 + (pfam.af.maj_age_un_enfant.age2 <= age) * pfam.af.maj_age_un_enfant.taux2 ) montant_plusieurs_enfants = pfam.af.bmaf * ( (pfam.af.maj_age_deux_enfants.age1 <= age) * (age < pfam.af.maj_age_deux_enfants.age2) * pfam.af.maj_age_deux_enfants.taux1 + (pfam.af.maj_age_deux_enfants.age2 <= age) * pfam.af.maj_age_deux_enfants.taux2 ) montant = (af_nbenf == 1) * montant_enfant_seul + (af_nbenf > 1) * montant_plusieurs_enfants # Attention ! Ne fonctionne pas pour les enfants du même âge (typiquement les jumeaux...) pas_aine = or_(af_nbenf != 2, (af_nbenf == 2) * not_(age == age_aine)) return period, af_enfant_a_charge * (af_base > 0) * pas_aine * montant
def formula(individu, period, parameters): ressortissant_eee = individu('ressortissant_eee', period) ressortissant_suisse = individu('nationalite', period) == b'CH' duree_possession_titre_sejour = individu('duree_possession_titre_sejour', period) duree_min_titre_sejour = parameters(period).prestations.minima_sociaux.aspa.duree_min_titre_sejour return or_(ressortissant_eee, ressortissant_suisse, duree_possession_titre_sejour >= duree_min_titre_sejour)
def formula(famille, period, parameters): eligibilite_base = famille('cf_eligibilite_base', period) eligibilite_dom = famille('cf_eligibilite_dom', period) ressources = famille('cf_ressources', period) plafond = famille('cf_plafond', period) pfam = parameters(period).prestations.prestations_familiales eligibilite_sous_condition = or_(eligibilite_base, eligibilite_dom) # Montant montant = (pfam.af.bmaf * (pfam.cf.taux_cf_base * eligibilite_base + pfam.cf.taux_base_dom * eligibilite_dom)) # Complément familial eligibilite = eligibilite_sous_condition * (ressources <= plafond) # Complément familial différentiel plafond_diff = plafond + 12 * montant eligibilite_diff = (not_(eligibilite) * eligibilite_sous_condition * (ressources <= plafond_diff)) montant_diff = (plafond_diff - ressources) / 12 return max_(eligibilite * montant, eligibilite_diff * montant_diff)
def formula(famille, period, parameters): np_pers = famille('nb_parents', period) + famille( 'rsa_nb_enfants', period) aide_logement = famille('aide_logement', period) statut_occupation_logement = famille.demandeur.menage( 'statut_occupation_logement', period) participation_frais = famille.demandeur.menage('participation_frais', period) loyer = famille.demandeur.menage('loyer', period) avantage_nature = or_( ((statut_occupation_logement == TypesStatutOccupationLogement.primo_accedant) + (statut_occupation_logement == TypesStatutOccupationLogement.proprietaire)) * not_(loyer), (statut_occupation_logement == TypesStatutOccupationLogement.loge_gratuitement) * not_(participation_frais)) avantage_al = aide_logement > 0 # Les parametres ont changé de nom au moment où le RMI est devenu le RSA # Pour le RSA, on utilise les taux des textes de lois, pour le RMI ils sont déjà aggrégés # Il faudrait uniformiser, mais les taux légaux pour le RMI commencent par "1", et ne passent pas en python if period.start.date >= date(2009, 6, 01): params = parameters(period).prestations.minima_sociaux.rsa montant_base = params.montant_de_base_du_rsa taux_2p = 1 + params.majoration_rsa.taux_deuxieme_personne taux_3p = taux_2p + params.majoration_rsa.taux_troisieme_personne forf_logement_taux_1p = params.forfait_logement.taux_1_personne forf_logement_taux_2p = params.forfait_logement.taux_2_personnes * taux_2p forf_logement_taux_3p = params.forfait_logement.taux_3_personnes_ou_plus * taux_3p
def formula_2009_04(famille, period, parameters): ''' Prime de solidarité active (exceptionnelle, 200€ versés une fois en avril 2009) Versement en avril 2009 d’une prime de solidarité active (Psa) aux familles modestes qui ont bénéficié en janvier, février ou mars 2009 du Rmi, de l’Api (du Rsa expérimental, du Cav ou du Rma pour les ex-bénéficiaires du Rmi ou de l’Api), de la prime forfaitaire mensuelle au titre du Rmi ou de l’Api ou enfin d’une aide au logement (à condition d’exercer une activité professionnelle et d’être âgé de plus de 25 ans ou d’avoir au moins un enfant à charge). La Psa, prime exceptionnelle, s’élève à 200 euros par foyer bénéficiaire. ''' P = parameters(period).prestations.minima_sociaux.rmi api = famille('api', period) rsa = famille('rsa', period) af_nbenf = famille('af_nbenf', period) aide_logement = famille('aide_logement', period) personne_en_activite_i = (famille.members('activite', period) == TypesActivite.actif) parent_en_activite = famille.any(personne_en_activite_i, role = Famille.PARENT) dummy_api = api > 0 dummy_rmi = rsa > 0 dummy_al = and_(aide_logement > 0, or_(af_nbenf > 0, parent_en_activite)) condition = (dummy_api + dummy_rmi + dummy_al > 0) psa = condition * P.psa return psa
def formula_2009_04(famille, period, parameters): ''' Prime de solidarité active (exceptionnelle, 200€ versés une fois en avril 2009) Versement en avril 2009 d’une prime de solidarité active (Psa) aux familles modestes qui ont bénéficié en janvier, février ou mars 2009 du Rmi, de l’Api (du Rsa expérimental, du Cav ou du Rma pour les ex-bénéficiaires du Rmi ou de l’Api), de la prime forfaitaire mensuelle au titre du Rmi ou de l’Api ou enfin d’une aide au logement (à condition d’exercer une activité professionnelle et d’être âgé de plus de 25 ans ou d’avoir au moins un enfant à charge). La Psa, prime exceptionnelle, s’élève à 200 euros par foyer bénéficiaire. ''' P = parameters(period).prestations.minima_sociaux.rmi api = famille('api', period) rsa = famille('rsa', period) af_nbenf = famille('af_nbenf', period) aide_logement = famille('aide_logement', period) personne_en_activite_i = (famille.members( 'activite', period) == TypesActivite.actif) parent_en_activite = famille.any(personne_en_activite_i, role=Famille.PARENT) dummy_api = api > 0 dummy_rmi = rsa > 0 dummy_al = and_(aide_logement > 0, or_(af_nbenf > 0, parent_en_activite)) condition = (dummy_api + dummy_rmi + dummy_al > 0) psa = condition * P.psa return psa
def function(self, simulation, period): period = period.start.offset("first-of", "month").period("month") forf_logement = simulation.legislation_at(period.start).minim.rmi.forfait_logement rmi = simulation.legislation_at(period.start).minim.rmi.rmi rmi_nbp = simulation.calculate("rmi_nbp", period) statut_occupation_holder = simulation.compute("statut_occupation", period) aide_logement = simulation.calculate("aide_logement", period) statut_occupation = self.cast_from_entity_to_roles(statut_occupation_holder) statut_occupation = self.filter_role(statut_occupation, role=CHEF) avantage_nature = or_(statut_occupation == 2, statut_occupation == 6) avantage_al = aide_logement > 0 montant_forfait = rmi * ( (rmi_nbp == 1) * forf_logement.taux1 + (rmi_nbp == 2) * forf_logement.taux2 + (rmi_nbp >= 3) * forf_logement.taux3 ) montant_al = avantage_al * min_(aide_logement, montant_forfait) montant_nature = avantage_nature * montant_forfait return period, max_(montant_al, montant_nature)
def formula_2015_06_09(self, simulation, period): effectif_entreprise = simulation.calculate('effectif_entreprise', period) apprenti = simulation.calculate('apprenti', period) contrat_de_travail_duree = simulation.calculate( 'contrat_de_travail_duree', period) contrat_de_travail_debut = simulation.calculate( 'contrat_de_travail_debut', period) contrat_de_travail_fin = simulation.calculate('contrat_de_travail_fin', period) coefficient_proratisation = simulation.calculate( 'coefficient_proratisation', period) exoneration_cotisations_employeur_jei = simulation.calculate( 'exoneration_cotisations_employeur_jei', period) # Cette aide est temporaire. # TODO : Si toutefois elle est reconduite et modifiée pour 2017, les dates et le montant seront à # implémenter comme des params xml. eligible_contrat = and_( contrat_de_travail_debut >= datetime64("2015-06-09"), contrat_de_travail_debut <= datetime64("2016-12-31")) # Si CDD, durée du contrat doit être > 1 an eligible_duree = or_( # durée indéterminée contrat_de_travail_duree == 0, # durée déterminée supérieure à 1 an and_( contrat_de_travail_duree == 1, # CDD # > 6 mois (contrat_de_travail_fin - contrat_de_travail_debut ).astype('timedelta64[M]') >= timedelta64(6, 'M') # Initialement, la condition était d'un contrat >= 12 mois, # pour les demandes transmises jusqu'au 26 janvier. )) eligible_date = datetime64(period.offset( -24, 'month').start) < contrat_de_travail_debut eligible = \ (effectif_entreprise == 1) * not_(apprenti) * eligible_contrat * eligible_duree * eligible_date # somme sur 24 mois, à raison de 500 € maximum par trimestre montant_max = 4000 # non cumul avec le dispositif Jeune Entreprise Innovante (JEI) non_cumulee = not_(exoneration_cotisations_employeur_jei) # TODO comment implémenter la condition "premier employé" ? L'effectif est insuffisant en cas de rupture # d'un premier contrat # Condition : l’entreprise n’a pas conclu de contrat de travail avec un salarié, # au-delà de la période d’essai, dans les 12 mois précédant la nouvelle # embauche. # Si le salarié est embauché à temps partiel, # l’aide est proratisée en fonction de sa durée de travail. # TODO cette multiplication par le coefficient de proratisation suffit-elle pour le cas du temps partiel ? # A tester return eligible * (montant_max / 24) * coefficient_proratisation * non_cumulee
def function(self, simulation, period): ''' L’Allocation de Solidarité Spécifique (ASS) est une allocation versée aux personnes ayant épuisé leurs droits à bénéficier de l'assurance chômage. Le prétendant doit avoir épuisé ses droits à l’assurance chômage. Il doit être inscrit comme demandeur d’emploi et justifier de recherches actives. Il doit être apte à travailler. Il doit justifier de 5 ans d’activité salariée au cours des 10 ans précédant le chômage. À partir de 60 ans, il doit répondre à des conditions particulières. Les ressources prises en compte pour apprécier ces plafonds, comprennent l'allocation de solidarité elle-même ainsi que les autres ressources de l'intéressé, et de son conjoint, partenaire pacsé ou concubin, soumises à impôt sur le revenu. Ne sont pas prises en compte, pour déterminer le droit à ASS : l'allocation d'assurance chômage précédemment perçue, les prestations familiales, l'allocation de logement, la majoration de l'ASS, la prime forfaitaire mensuelle de retour à l'emploi, la pension alimentaire ou la prestation compensatoire due par l'intéressé. Conditions de versement de l'ASS majorée Pour les allocataires admis au bénéfice de l'ASS majorée (avant le 1er janvier 2004), le montant de l'ASS majorée est fixé à 22,07 € par jour. Pour mémoire, jusqu'au 31 décembre 2003, pouvaient bénéficier de l'ASS majorée, les allocataires : âgés de 55 ans ou plus et justifiant d'au moins 20 ans d'activité salariée, ou âgés de 57 ans et demi ou plus et justifiant de 10 ans d'activité salariée, ou justifiant d'au moins 160 trimestres de cotisation retraite. ''' period = period.start.offset('first-of', 'month').period('year') ass_base_ressources = simulation.calculate('ass_base_ressources', period) ass_eligibilite_i_holder = simulation.compute('ass_eligibilite_i', period) concub = simulation.calculate('concub', period) ass_params = simulation.legislation_at(period.start).minim.ass ass_eligibilite_i = self.split_by_roles(ass_eligibilite_i_holder, roles=[CHEF, PART]) majo = 0 # TODO elig = or_(ass_eligibilite_i[CHEF], ass_eligibilite_i[PART]) plafond_mensuel = ass_params.plaf_seul * not_( concub) + ass_params.plaf_coup * concub plafond = plafond_mensuel * 12 montant_mensuel = 30 * (ass_params.montant_plein * not_(majo) + majo * ass_params.montant_maj) revenus = ass_base_ressources + 12 * montant_mensuel ass = 12 * montant_mensuel * ( revenus <= plafond) + (revenus > plafond) * max_( plafond + 12 * montant_mensuel - revenus, 0) ass = ass * elig ass = ass * not_( ass / 12 < ass_params.montant_plein ) # pas d'ASS si montant mensuel < montant journalier de base return period, ass
def function(self, simulation, period): period = period.start.period(u'month').offset('first-of') depcom_entreprise = simulation.calculate('depcom_entreprise', period) effectif_entreprise = simulation.calculate('effectif_entreprise', period) categorie_salarie = simulation.calculate('categorie_salarie', period) seuil_effectif = simulation.legislation_at(period.start).cotsoc.versement_transport.seuil_effectif preload_taux_versement_transport() public = (categorie_salarie >= 2) default_value = 0.0 taux_aot = fromiter( ( taux_aot_by_depcom.get(depcom_cell, default_value) for depcom_cell in depcom_entreprise ), dtype = 'float', ) taux_smt = fromiter( ( taux_smt_by_depcom.get(depcom_cell, default_value) for depcom_cell in depcom_entreprise ), dtype = 'float', ) # "L'entreprise emploie-t-elle plus de 9 salariés dans le périmètre de l'Autorité organisatrice de transport # (AOT) suivante ou syndicat mixte de transport (SMT)" return period, (taux_aot + taux_smt) * or_(effectif_entreprise >= seuil_effectif, public) / 100
def function(self, simulation, period): period = period.start.offset('first-of', 'month').period('month') rfr = simulation.calculate('rfr', period.start.offset('first-of', 'year').period('year').offset(-2)) age_holder = simulation.compute('age', period) scolarite_holder = simulation.compute('scolarite', period) P = simulation.legislation_at(period.start).bourses_education.bourse_college ages = self.split_by_roles(age_holder, roles = ENFS) nb_enfants = zeros(len(rfr)) for age in ages.itervalues(): nb_enfants += age >= 0 plafond_taux_1 = P.plafond_taux_1 + P.plafond_taux_1 * nb_enfants * P.coeff_enfant_supplementaire plafond_taux_2 = P.plafond_taux_2 + P.plafond_taux_2 * nb_enfants * P.coeff_enfant_supplementaire plafond_taux_3 = P.plafond_taux_3 + P.plafond_taux_3 * nb_enfants * P.coeff_enfant_supplementaire eligible_taux_3 = rfr < plafond_taux_3 eligible_taux_2 = not_(eligible_taux_3) * (rfr < plafond_taux_2) eligible_taux_1 = not_(or_(eligible_taux_2, eligible_taux_3)) * (rfr < plafond_taux_1) scolarites = self.split_by_roles(scolarite_holder, roles = ENFS) nb_enfants_college = zeros(len(rfr)) for scolarite in scolarites.itervalues(): nb_enfants_college += scolarite == SCOLARITE_COLLEGE montant = nb_enfants_college * ( eligible_taux_3 * P.montant_taux_3 + eligible_taux_2 * P.montant_taux_2 + eligible_taux_1 * P.montant_taux_1 ) return period, montant / 12
def function(self, simulation, period): # Note : Cette variable est calculée pour un an, mais si elle est demandée pour une période plus petite, elle # répond pour la période demandée. this_month = period.this_month this_rolling_year = this_month.start.period('year') if period.stop > this_rolling_year.stop: period = this_rolling_year else: period = this_month cmu_c_plafond = simulation.calculate('cmu_c_plafond', this_month) cmu_base_ressources = simulation.calculate('cmu_base_ressources', this_month) residence_mayotte = simulation.calculate('residence_mayotte', this_month) rsa_socle = simulation.calculate('rsa_socle', this_month) rsa_socle_majore = simulation.calculate('rsa_socle_majore', this_month) rsa_forfait_logement = simulation.calculate('rsa_forfait_logement', this_month) rsa_base_ressources = simulation.calculate('rsa_base_ressources', this_month) socle = max_(rsa_socle, rsa_socle_majore) rsa = simulation.calculate('rsa', this_month) eligibilite_basique = cmu_base_ressources <= cmu_c_plafond eligibilite_rsa = (rsa > 0) * (rsa_base_ressources < socle - rsa_forfait_logement) return period, not_(residence_mayotte) * or_(eligibilite_basique, eligibilite_rsa)
def formula(individu, period, parameters): depcom_entreprise = individu('depcom_entreprise', period) effectif_entreprise = individu('effectif_entreprise', period) categorie_salarie = individu('categorie_salarie', period) seuil_effectif = parameters(period).cotsoc.versement_transport.seuil_effectif preload_taux_versement_transport() public = ( (categorie_salarie == TypesCategorieSalarie.public_titulaire_etat) + (categorie_salarie == TypesCategorieSalarie.public_titulaire_militaire) + (categorie_salarie == TypesCategorieSalarie.public_titulaire_territoriale) + (categorie_salarie == TypesCategorieSalarie.public_titulaire_hospitaliere) + (categorie_salarie == TypesCategorieSalarie.public_non_titulaire) + (categorie_salarie == TypesCategorieSalarie.non_pertinent) ) taux_versement_transport = fromiter( ( get_taux_versement_transport(code_commune, period) for code_commune in depcom_entreprise ), dtype = 'float', ) # "L'entreprise emploie-t-elle plus de 9 ou 10 salariés dans le périmètre de l'Autorité organisatrice de transport # (AOT) suivante ou syndicat mixte de transport (SMT)" return taux_versement_transport * or_(effectif_entreprise >= seuil_effectif, public) / 100
def formula(famille, period, parameters): mois_precedent = period.offset(-1) last_day_reference_year = period.n_2.stop base_ressources_defaut = famille( 'aide_logement_base_ressources_defaut', period) base_ressources_eval_forfaitaire = famille( 'aide_logement_base_ressources_eval_forfaitaire', period) en_couple = famille('en_couple', period) aah_i = famille.members('aah', mois_precedent) aah = famille.sum(aah_i, role=Famille.PARENT) age_demandeur = famille.demandeur('age', period) age_conjoint = famille.conjoint('age', period) smic_horaire_brut_n2 = parameters( last_day_reference_year).cotsoc.gen.smic_h_b salaire_imposable_i = famille.members('salaire_imposable', period.offset(-1)) somme_salaires = famille.sum(salaire_imposable_i, role=Famille.PARENT) plafond_eval_forfaitaire = 1015 * smic_horaire_brut_n2 plafond_salaire_jeune_isole = parameters( period).prestations.aides_logement.ressources.dar_8 plafond_salaire_jeune_couple = parameters( period).prestations.aides_logement.ressources.dar_9 plafond_salaire_jeune = where(en_couple, plafond_salaire_jeune_couple, plafond_salaire_jeune_isole) neutral_jeune = or_(age_demandeur < 25, and_(en_couple, age_conjoint < 25)) neutral_jeune &= somme_salaires < plafond_salaire_jeune eval_forfaitaire = base_ressources_defaut <= plafond_eval_forfaitaire eval_forfaitaire &= base_ressources_eval_forfaitaire > 0 eval_forfaitaire &= aah == 0 eval_forfaitaire &= not_(neutral_jeune) ressources = where(eval_forfaitaire, base_ressources_eval_forfaitaire, base_ressources_defaut) # Planchers de ressources pour étudiants # Seul le statut étudiant (et boursier) du demandeur importe, pas celui du conjoint Pr = parameters(period).prestations.aides_logement.ressources demandeur_etudiant = famille.demandeur('etudiant', period) demandeur_boursier = famille.demandeur('boursier', period) montant_plancher_ressources = max_( 0, demandeur_etudiant * Pr.dar_4 - demandeur_boursier * Pr.dar_5) ressources = max_(ressources, montant_plancher_ressources) # Arrondi au centime, pour éviter qu'une petite imprécision liée à la recombinaison d'une valeur annuelle éclatée ne fasse monter d'un cran l'arrondi au 100€ supérieur. ressources = round_(ressources * 100) / 100 # Arrondi aux 100 euros supérieurs ressources = ceil(ressources / 100) * 100 return ressources
def formula(individu, period): base_ressources = individu( 'prestations_familiales_base_ressources_individu', period) est_enfant_dans_famille = individu('est_enfant_dans_famille', period) cf_enfant_a_charge = individu('cf_enfant_a_charge', period) return or_(not_(est_enfant_dans_famille), cf_enfant_a_charge) * base_ressources
def function(self, simulation, period): period = period.start.offset('first-of', 'month').period('month') br_pf_i = simulation.calculate('br_pf_i', period) est_enfant_dans_famille = simulation.calculate('est_enfant_dans_famille', period) cf_enfant_a_charge = simulation.calculate('cf_enfant_a_charge', period) return period, or_(not_(est_enfant_dans_famille), cf_enfant_a_charge) * br_pf_i
def formula_2009_06_01(individu, period, parameters): ressortissant_eee = individu('ressortissant_eee', period) duree_possession_titre_sejour = individu( 'duree_possession_titre_sejour', period) duree_min_titre_sejour = parameters( period).prestations.minima_sociaux.rsa.duree_min_titre_sejour return or_(ressortissant_eee, duree_possession_titre_sejour >= duree_min_titre_sejour)
def function(self, simulation, period): period = period.this_month br_pf_i = simulation.calculate('br_pf_i', period) est_enfant_dans_famille = simulation.calculate('est_enfant_dans_famille', period) pfam_enfant_a_charge = simulation.calculate('pfam_enfant_a_charge', period) return period, or_(not_(est_enfant_dans_famille), pfam_enfant_a_charge) * br_pf_i
def function(self, simulation, period): period = period.this_month base_ressources = simulation.calculate('prestations_familiales_base_ressources_individu', period) est_enfant_dans_famille = simulation.calculate('est_enfant_dans_famille', period) cf_enfant_a_charge = simulation.calculate('cf_enfant_a_charge', period) return period, or_(not_(est_enfant_dans_famille), cf_enfant_a_charge) * base_ressources
def function(individu, period): period = period.this_month base_ressources = individu('prestations_familiales_base_ressources_individu', period) est_enfant_dans_famille = individu('est_enfant_dans_famille', period) cf_enfant_a_charge = individu('cf_enfant_a_charge', period) return period, or_(not_(est_enfant_dans_famille), cf_enfant_a_charge) * base_ressources
def formula_2009_06_01(famille, period): rsa_revenu_activite_i = famille.members('rsa_revenu_activite_individu', period) rsa_enfant_a_charge_i = famille.members('rsa_enfant_a_charge', period) enfant_i = famille.members('est_enfant_dans_famille', period) return famille.sum( or_(not_(enfant_i), rsa_enfant_a_charge_i) * rsa_revenu_activite_i)
def function(self, simulation, period): period = period.this_month effectif_entreprise = simulation.calculate('effectif_entreprise', period) apprenti = simulation.calculate('apprenti', period) contrat_de_travail_duree = simulation.calculate('contrat_de_travail_duree', period) contrat_de_travail_debut = simulation.calculate('contrat_de_travail_debut', period) contrat_de_travail_fin = simulation.calculate('contrat_de_travail_fin', period) coefficient_proratisation = simulation.calculate('coefficient_proratisation', period) smic_proratise = simulation.calculate('smic_proratise', period) salaire_de_base = simulation.calculate('salaire_de_base', period) # Cette aide est temporaire. # Si toutefois elle est reconduite et modifiée pour 2017, les dates et le montant seront à implémenter comme # des params xml. # jusqu’à 1,3 fois le Smic eligible_salaire = salaire_de_base <= (1.3 * smic_proratise) # pour les PME eligible_effectif = effectif_entreprise < 250 # non cumulable avec l'aide pour la première embauche # qui est identique, si ce n'est qu'elle couvre tous les salaires non_cumulee = effectif_entreprise > 1 eligible_contrat = and_( contrat_de_travail_debut >= datetime64("2016-01-18"), contrat_de_travail_debut <= datetime64("2016-12-31") ) # Si CDD, durée du contrat doit être > 1 an eligible_duree = or_( # durée indéterminée contrat_de_travail_duree == 0, # durée déterminée supérieure à 1 an and_( # CDD contrat_de_travail_duree == 1, # > 6 mois (contrat_de_travail_fin - contrat_de_travail_debut).astype('timedelta64[M]') >= timedelta64(6, 'M') ) ) # Valable 2 ans seulement eligible_date = datetime64(period.offset(-24, 'month').start) < contrat_de_travail_debut eligible = ( eligible_salaire * eligible_effectif * non_cumulee * eligible_contrat * eligible_duree * eligible_date * not_(apprenti) ) # somme sur 24 mois, à raison de 500 € maximum par trimestre montant_max = 4000 # Si le salarié est embauché à temps partiel, # l’aide est proratisée en fonction de sa durée de travail. # TODO cette multiplication par le coefficient de proratisation suffit-elle pour le cas du temps partiel ? # A tester return period, eligible * (montant_max / 24) * coefficient_proratisation
def function(self, simulation, period): # u"temps_plein", # u"temps_partiel", # u"forfait_heures_semaines", # u"forfait_heures_mois", # u"forfait_heures_annee", # u"forfait_jours_annee", contrat_de_travail = simulation.calculate('contrat_de_travail', period) contrat_de_travail_debut = simulation.calculate('contrat_de_travail_debut', period) contrat_de_travail_fin = simulation.calculate('contrat_de_travail_fin', period) forfait_heures_remunerees_volume = simulation.calculate('forfait_heures_remunerees_volume', period) forfait_jours_remuneres_volume = simulation.calculate('forfait_jours_remuneres_volume', period) heures_duree_collective_entreprise = simulation.calculate('heures_duree_collective_entreprise', period) heures_remunerees_volume = simulation.calculate('heures_remunerees_volume', period) heures_non_remunerees_volume = simulation.calculate('heures_non_remunerees_volume', period) # Décompte des jours en début et fin de contrat # http://www.gestiondelapaie.com/flux-paie/?1029-la-bonne-premiere-paye busday_count = partial(original_busday_count, holidays = holidays) debut_mois = datetime64(period.start.offset('first-of', 'month')) fin_mois = datetime64(period.start.offset('last-of', 'month')) + timedelta64(1, 'D') mois_incomplet = or_(contrat_de_travail_debut > debut_mois, contrat_de_travail_fin < fin_mois) jours_travailles = busday_count( max_(contrat_de_travail_debut, debut_mois), min_(contrat_de_travail_fin, fin_mois) ) duree_legale = 35 * 52 / 12 # mensuelle_temps_plein heures_temps_plein = ( (heures_duree_collective_entreprise == 0) * duree_legale + heures_duree_collective_entreprise ) # heures remunerees avant conges sans soldes/ijss heures_remunerees_volume = ( (contrat_de_travail == 0) * ( heures_temps_plein * not_(mois_incomplet) + # 151.67 jours_travailles * 7 * mois_incomplet # TODO: 7 = heures / jours ) + (contrat_de_travail == 1) * heures_remunerees_volume ) heures_realisees = heures_remunerees_volume - heures_non_remunerees_volume coefficient = ( # Salariés à temps plein (contrat_de_travail == 0) * heures_realisees / heures_temps_plein + # Salariés à temps partiel : plafond proratisé en fonction du ratio durée travaillée / durée du temps plein # Salariés sans convention de forfait à temps partiel (contrat_de_travail == 1) * heures_realisees / heures_temps_plein + # Salariés avec convention de forfait # Forfait en heures (contrat_de_travail >= 2) * (contrat_de_travail <= 3) * ( forfait_heures_remunerees_volume / 45.7 * 52 / 12 ) + # Forfait en jours (contrat_de_travail == 4) * forfait_jours_remuneres_volume / 218 ) return period, coefficient
def function(self, simulation, period): categorie_salarie = simulation.calculate('categorie_salarie', period) cotisation = apply_bareme( simulation, period, cotisation_type = 'employeur', bareme_name = 'financement_organisations_syndicales', variable_name = self.__class__.__name__, ) return period, cotisation * or_(categorie_salarie <= 1, categorie_salarie == 6)
def _psa(api, rsa, activite, af_nbenf, al, _P, _option = {"activite" : [CHEF, PART]}): ''' Prime de solidarité active (exceptionnelle, 200€ versés une fois en avril 2009) ''' # Versement en avril 2009 d’une prime de solidarité active (Psa) aux familles modestes qui ont bénéficié en janvier, # février ou mars 2009 du Rmi, de l’Api (du Rsa expérimental, du Cav ou du Rma pour les ex-bénéficiaires du Rmi ou de l’Api), # de la prime forfaitaire mensuelle au titre du Rmi ou de l’Api # ou enfin d’une aide au logement (à condition d’exercer une activité professionnelle et d’être âgé de plus de 25 ans # ou d’avoir au moins un enfant à charge). # La Psa, prime exceptionnelle, s’élève à 200 euros par foyer bénéficiaire. dummy_api = api > 0 dummy_rmi = rsa > 0 dummy_al = and_(al > 0, or_(af_nbenf > 0, or_(activite[CHEF] == 0, activite[PART] == 0))) condition = (dummy_api + dummy_rmi + dummy_al > 0) P = _P.minim.rmi psa = condition * P.psa return psa
def _alleg_cice(period, salbrut, sal_h_b, type_sal, taille_entreprise, cotsoc = law.cotsoc): ''' Crédit d'imôt pour la compétitivité et l'emploi ''' if period.start.year >= 2013: taux_cice = taux_exo_cice(sal_h_b, cotsoc) alleg_cice = (taux_cice * salbrut * or_((type_sal == CAT['prive_non_cadre']), (type_sal == CAT['prive_cadre']))) return alleg_cice else: return 0 * salbrut
def formula_2015_06_09(individu, period, parameters): effectif_entreprise = individu('effectif_entreprise', period) apprenti = individu('apprenti', period) contrat_de_travail_duree = individu('contrat_de_travail_duree', period) TypesContratDeTravailDuree = contrat_de_travail_duree.possible_values contrat_de_travail_debut = individu('contrat_de_travail_debut', period) contrat_de_travail_fin = individu('contrat_de_travail_fin', period) coefficient_proratisation = individu('coefficient_proratisation', period) exoneration_cotisations_employeur_jei = individu('exoneration_cotisations_employeur_jei', period) # Cette aide est temporaire. # TODO : Si toutefois elle est reconduite et modifiée pour 2017, les dates et le montant seront à # implémenter comme des params xml. eligible_contrat = and_( contrat_de_travail_debut >= datetime64("2015-06-09"), contrat_de_travail_debut <= datetime64("2016-12-31") ) # Si CDD, durée du contrat doit être > 1 an eligible_duree = or_( # durée indéterminée contrat_de_travail_duree == TypesContratDeTravailDuree.cdi, # durée déterminée supérieure à 1 an and_( contrat_de_travail_duree == TypesContratDeTravailDuree.cdd, # > 6 mois (contrat_de_travail_fin - contrat_de_travail_debut).astype('timedelta64[M]') >= timedelta64(6, 'M') # Initialement, la condition était d'un contrat >= 12 mois, # pour les demandes transmises jusqu'au 26 janvier. ) ) eligible_date = datetime64(period.offset(-24, 'month').start) < contrat_de_travail_debut eligible = \ (effectif_entreprise == 1) * not_(apprenti) * eligible_contrat * eligible_duree * eligible_date # somme sur 24 mois, à raison de 500 € maximum par trimestre montant_max = 4000 # non cumul avec le dispositif Jeune Entreprise Innovante (JEI) non_cumulee = not_(exoneration_cotisations_employeur_jei) # TODO comment implémenter la condition "premier employé" ? L'effectif est insuffisant en cas de rupture # d'un premier contrat # Condition : l’entreprise n’a pas conclu de contrat de travail avec un salarié, # au-delà de la période d’essai, dans les 12 mois précédant la nouvelle # embauche. # Si le salarié est embauché à temps partiel, # l’aide est proratisée en fonction de sa durée de travail. # TODO cette multiplication par le coefficient de proratisation suffit-elle pour le cas du temps partiel ? # A tester return eligible * (montant_max / 24) * coefficient_proratisation * non_cumulee