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(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(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 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 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 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 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 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(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
