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 _rsa_socle(self, age_holder, smic55_holder, activite_holder, nb_par, rmi = law.minim.rmi):
'''
Rsa socle / Rmi
'fam'
'''
age_parents = self.split_by_roles(age_holder, roles = [CHEF, PART])
activite_parents = self.split_by_roles(activite_holder, roles = [CHEF, PART])
age_enf = self.split_by_roles(age_holder, roles = ENFS)
smic55_enf = self.split_by_roles(smic55_holder, roles = ENFS)
nbp = nb_par + nb_enf(age_enf, smic55_enf, 0, rmi.age_pac)
eligib = (
(age_parents[CHEF] >= rmi.age_pac)
*
not_(activite_parents[CHEF] == 2)
) | (
(age_parents[PART] >= rmi.age_pac) * not_(activite_parents[PART] == 2)
)
taux = (1 + (nbp >= 2) * rmi.txp2
+ (nbp >= 3) * rmi.txp3
+ (nbp >= 4) * ((nb_par == 1) * rmi.txps + (nb_par != 1) * rmi.txp3)
+ max_(nbp - 4, 0) * rmi.txps)
return eligib * rmi.rmi * taux * 12
def function(famille, period, legislation):
period = period.this_month
al = legislation(period).prestations.aides_logement
couple = famille('al_couple', period)
al_nb_pac = famille('al_nb_personnes_a_charge', period)
residence_dom = famille.demandeur.menage('residence_dom')
TF_metropole = (
al.taux_participation_fam.taux_1_adulte * (not_(couple)) *
(al_nb_pac == 0) + al.taux_participation_fam.taux_2_adulte *
(couple) * (al_nb_pac == 0) +
al.taux_participation_fam.taux_1_enf * (al_nb_pac == 1) +
al.taux_participation_fam.taux_2_enf * (al_nb_pac == 2) +
al.taux_participation_fam.taux_3_enf * (al_nb_pac == 3) +
al.taux_participation_fam.taux_4_enf * (al_nb_pac >= 4) +
al.taux_participation_fam.taux_enf_supp * (al_nb_pac > 4) *
(al_nb_pac - 4))
TF_dom = (al.taux_participation_fam.dom.taux1 * (not_(couple)) *
(al_nb_pac == 0) + al.taux_participation_fam.dom.taux2 *
(couple) * (al_nb_pac == 0) +
al.taux_participation_fam.dom.taux3 * (al_nb_pac == 1) +
al.taux_participation_fam.dom.taux4 * (al_nb_pac == 2) +
al.taux_participation_fam.dom.taux5 * (al_nb_pac == 3) +
al.taux_participation_fam.dom.taux6 * (al_nb_pac == 4) +
al.taux_participation_fam.dom.taux7 * (al_nb_pac == 5) +
al.taux_participation_fam.dom.taux8 * (al_nb_pac >= 6))
return period, where(residence_dom, TF_dom, TF_metropole)
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 _saldom2(nb_pac2, f7db, f7dg, f7dl, f7dq, _P):
'''
Crédit d’impôt emploi d’un salarié à domicile (cases 7DB, 7DG)
2007-
'''
P = _P.ir.reductions_impots.saldom
isinvalid = f7dg
if _P.datesim.year in (2007, 2008):
nbpacmin = nb_pac2 + f7dl
maxBase = P.max1
maxDuMaxNonInv = P.max2
maxNonInv = min_(maxBase + P.pac * nbpacmin, maxDuMaxNonInv)
maxEffectif = maxNonInv * not_(isinvalid) + P.max3 * isinvalid
elif _P.datesim.year in (2009, 2010):
annee1 = f7dq
nbpacmin = nb_pac2 + f7dl
maxBase = P.max1 * not_(annee1) + P.max1_1ereAnnee * annee1
maxDuMaxNonInv = P.max2 * not_(annee1) + P.max2_1ereAnnee * annee1
maxNonInv = min_(maxBase + P.pac * nbpacmin, maxDuMaxNonInv)
maxEffectif = maxNonInv * not_(isinvalid) + P.max3 * isinvalid
elif _P.datesim.year >= 2011:
# TODO:
maxEffectif = 0
return P.taux * min_(f7db, maxEffectif)
def function(self, simulation, period):
period = period.this_month
al = simulation.legislation_at(period.start).al
couple = simulation.calculate('al_couple', period)
al_nb_pac = simulation.calculate('al_nb_personnes_a_charge', period)
residence_dom = simulation.calculate('residence_dom')
TF_metropole = (
al.TF.taux1 * (not_(couple)) * (al_nb_pac == 0) +
al.TF.taux2 * (couple) * (al_nb_pac == 0) +
al.TF.taux3 * (al_nb_pac == 1) +
al.TF.taux4 * (al_nb_pac == 2) +
al.TF.taux5 * (al_nb_pac == 3) +
al.TF.taux6 * (al_nb_pac >= 4) +
al.TF.taux7 * (al_nb_pac > 4) * (al_nb_pac - 4)
)
TF_dom = (
al.TF.dom.taux1 * (not_(couple)) * (al_nb_pac == 0) +
al.TF.dom.taux2 * (couple) * (al_nb_pac == 0) +
al.TF.dom.taux3 * (al_nb_pac == 1) +
al.TF.dom.taux4 * (al_nb_pac == 2) +
al.TF.dom.taux5 * (al_nb_pac == 3) +
al.TF.dom.taux6 * (al_nb_pac == 4) +
al.TF.dom.taux7 * (al_nb_pac == 5) +
al.TF.dom.taux8 * (al_nb_pac >= 6)
)
return period, where(residence_dom, TF_dom, TF_metropole)
def function(self, simulation, period):
period = period.this_month
asi_elig_holder = simulation.compute('asi_eligibilite', period)
aspa_elig_holder = simulation.compute('aspa_eligibilite', period)
maries = simulation.calculate('maries', period)
en_couple = simulation.calculate('en_couple', period)
asi_aspa_nb_alloc = simulation.calculate('asi_aspa_nb_alloc', period)
base_ressources = simulation.calculate('asi_aspa_base_ressources',
period)
P = simulation.legislation_at(period.start).minim
asi_eligibilite = self.split_by_roles(asi_elig_holder,
roles=[CHEF, PART])
aspa_eligibilite = self.split_by_roles(aspa_elig_holder,
roles=[CHEF, PART])
# Un seul éligible
elig1 = ((asi_aspa_nb_alloc == 1) &
(asi_eligibilite[CHEF] | asi_eligibilite[PART]))
# Couple d'éligibles mariés
elig2 = asi_eligibilite[CHEF] & asi_eligibilite[PART] & maries
# Couple d'éligibles non mariés
elig3 = asi_eligibilite[CHEF] & asi_eligibilite[PART] & not_(maries)
# Un seul éligible et époux éligible ASPA
elig4 = ((asi_eligibilite[CHEF] & aspa_eligibilite[PART]) |
(asi_eligibilite[PART] & aspa_eligibilite[CHEF])) & maries
# Un seul éligible et conjoint non marié éligible ASPA
elig5 = (
(asi_eligibilite[CHEF] & aspa_eligibilite[PART]) |
(asi_eligibilite[PART] & aspa_eligibilite[CHEF])) & not_(maries)
elig = elig1 | elig2 | elig3 | elig4 | elig5
montant_max = (
elig1 * P.asi.montant_seul + elig2 * P.asi.montant_couple +
elig3 * 2 * P.asi.montant_seul + elig4 *
(P.asi.montant_couple / 2 + P.aspa.montant_couple / 2) + elig5 *
(P.asi.montant_seul + P.aspa.montant_couple / 2)) / 12
ressources = base_ressources + montant_max
plafond_ressources = (
elig1 *
(P.asi.plaf_seul * not_(en_couple) + P.asi.plaf_couple * en_couple)
+ elig2 * P.asi.plaf_couple + elig3 * P.asi.plaf_couple +
elig4 * P.aspa.plaf_couple + elig5 * P.aspa.plaf_couple) / 12
depassement = max_(ressources - plafond_ressources, 0)
diff = ((elig1 | elig2 | elig3) * (montant_max - depassement) + elig4 *
(P.asi.montant_couple / 12 / 2 - depassement / 2) + elig5 *
(P.asi.montant_seul / 12 - depassement / 2))
# Montant mensuel servi (sous réserve d'éligibilité)
montant_servi_asi = max_(diff, 0)
# TODO: Faute de mieux, on verse l'asi à la famille plutôt qu'aux individus
# asi[CHEF] = asi_eligibilite[CHEF]*montant_servi_asi*(elig1*1 + elig2/2 + elig3/2)
# asi[PART] = asi_eligibilite[PART]*montant_servi_asi*(elig1*1 + elig2/2 + elig3/2)
return period, elig * montant_servi_asi
def function(self, simulation, period):
period = period.start.offset('first-of', 'month').period('month')
age_holder = simulation.compute('age', period)
smic55_holder = simulation.compute('smic55', period)
activite_holder = simulation.compute('activite', period)
nb_par = simulation.calculate('nb_par', period)
rmi = simulation.legislation_at(period.start).minim.rmi
age_parents = self.split_by_roles(age_holder, roles = [CHEF, PART])
activite_parents = self.split_by_roles(activite_holder, roles = [CHEF, PART])
age_enf = self.split_by_roles(age_holder, roles = ENFS)
smic55_enf = self.split_by_roles(smic55_holder, roles = ENFS)
nbp = nb_par + nb_enf(age_enf, smic55_enf, 0, rmi.age_pac)
eligib = (
(age_parents[CHEF] >= rmi.age_pac)
&
not_(activite_parents[CHEF] == 2)
) | (
(age_parents[PART] >= rmi.age_pac) & not_(activite_parents[PART] == 2)
)
taux = (
1 + (nbp >= 2) * rmi.txp2 +
(nbp >= 3) * rmi.txp3 +
(nbp >= 4) * ((nb_par == 1) * rmi.txps + (nb_par != 1) * rmi.txp3) +
max_(nbp - 4, 0) * rmi.txps
)
return period, eligib * rmi.rmi * taux
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):
'''
type de menage
'men'
TODO: prendre les enfants du ménage et non ceux de la famille
'''
period = period.this_year
en_couple_holder = simulation.compute('en_couple', period)
af_nbenf_holder = simulation.compute('af_nbenf', period)
af_nbenf = self.cast_from_entity_to_role(af_nbenf_holder, role = CHEF)
af_nbenf = self.sum_by_entity(af_nbenf)
isole = not_(self.cast_from_entity_to_role(en_couple_holder, role = CHEF))
isole = self.sum_by_entity(isole)
_0_kid = af_nbenf == 0
_1_kid = af_nbenf == 1
_2_kid = af_nbenf == 2
_3_kid = af_nbenf >= 3
return period, (0 * (isole & _0_kid) + # Célibataire
1 * (not_(isole) & _0_kid) + # Couple sans enfants
2 * (not_(isole) & _1_kid) + # Couple un enfant
3 * (not_(isole) & _2_kid) + # Couple deux enfants
4 * (not_(isole) & _3_kid) + # Couple trois enfants et plus
5 * (isole & _1_kid) + # Famille monoparentale un enfant
6 * (isole & _2_kid) + # Famille monoparentale deux enfants
7 * (isole & _3_kid)) # Famille monoparentale trois enfants et plus
def _aspa_pure(aspa_elig, marpac, maries, asi_aspa_nb_alloc, br_mv, _P, _option = {'aspa_elig': [CHEF, PART]}):
'''
Calcule l'ASPA lorsqu'il y a un ou deux bénéficiaire de l'ASPA et aucun bénéficiaire de l'ASI
'''
# La notion de couple change au 1er janvier 2007 (réforme de 2006)
if _P.datesim.year >= 2007:
couple = marpac
else:
couple = maries
P = _P.minim
elig1 = ((asi_aspa_nb_alloc == 1) & (aspa_elig[CHEF] | aspa_elig[PART]))
elig2 = (aspa_elig[CHEF] & aspa_elig[PART]) * couple # couple d'allocataire
# elig = elig1 | elig2
#
# montant_max = elig1 * P.aspa.montant_seul + elig2 * P.aspa.montant_couple
# ressources = elig * (br_mv + montant_max)
# plafond_ressources = elig1 * (P.aspa.plaf_seul * not_(couple) + P.aspa.plaf_couple * couple) + elig2 * P.aspa.plaf_couple
# depassement = ressources - plafond_ressources
#
# montant_servi_aspa = max_(montant_max - depassement, 0) / 12
diff_plaf = P.aspa.plaf_couple - P.aspa.plaf_seul
plafond_ressources = (elig1 * not_(couple)) * P.aspa.plaf_seul + (elig2 | elig1 * couple) * P.aspa.plaf_couple
montant_max = (elig1 * not_(couple)) * P.aspa.montant_seul + elig2 * P.aspa.montant_couple + (elig1 * couple) * ((br_mv <= diff_plaf) * (P.aspa.montant_seul + br_mv) + (br_mv > diff_plaf) * P.aspa.montant_couple)
montant_servi_aspa = max_(montant_max - br_mv, 0) * (br_mv <= plafond_ressources) / 12
# TODO: Faute de mieux, on verse l'aspa à la famille plutôt qu'aux individus
# aspa[CHEF] = aspa_elig[CHEF]*montant_servi_aspa*(elig1 + elig2/2)
# aspa[PART] = aspa_elig[PART]*montant_servi_aspa*(elig1 + elig2/2)
return 12 * (aspa_elig[CHEF] + aspa_elig[PART]) * montant_servi_aspa * (elig1 + elig2 / 2) # annualisé
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):
period = period.start.offset('first-of', 'month').period('month')
age_holder = simulation.compute('age', period)
# smic55_holder = simulation.compute('smic55', period)
activite_holder = simulation.compute('activite', period)
nb_par = simulation.calculate('nb_par', period)
rmi = simulation.legislation_at(period.start).minim.rmi
age_parents = self.split_by_roles(age_holder, roles=[CHEF, PART])
activite_parents = self.split_by_roles(activite_holder,
roles=[CHEF, PART])
# age_enf = self.split_by_roles(age_holder, roles = ENFS)
# smic55_enf = self.split_by_roles(smic55_holder, roles = ENFS)
nbp = nb_par
eligib = ((age_parents[CHEF] >= rmi.age_pac) *
not_(activite_parents[CHEF] == 2)) | (
(age_parents[PART] >= rmi.age_pac) *
not_(activite_parents[PART] == 2))
taux = (1 + (nbp >= 2) * rmi.txp2 + (nbp >= 3) * rmi.txp3 +
(nbp >= 4) * ((nb_par == 1) * rmi.txps +
(nb_par != 1) * rmi.txp3) +
max_(nbp - 4, 0) * rmi.txps)
return period, eligib * rmi.rmi * taux
def function__2009(self, simulation, period):
"""
Allocation de parent isolé
"""
period = period.this_month
age_en_mois_holder = simulation.compute('age_en_mois', period)
age_holder = simulation.compute('age', period)
autonomie_financiere_holder = simulation.compute('autonomie_financiere', period)
isole = not_(simulation.calculate('en_couple', period))
rsa_forfait_logement = simulation.calculate('rsa_forfait_logement', period)
rsa_base_ressources = simulation.calculate('rsa_base_ressources', period)
af_majoration = simulation.calculate('af_majoration', period)
rsa = simulation.calculate('rsa', period)
af = simulation.legislation_at(period.start).fam.af
api = simulation.legislation_at(period.start).minim.api
age = self.split_by_roles(age_holder, roles = ENFS)
age_en_mois = self.split_by_roles(age_en_mois_holder, roles = ENFS)
autonomie_financiere = self.split_by_roles(autonomie_financiere_holder, roles = ENFS)
# TODO:
# Majoration pour isolement
# Si vous êtes parent isolé, c’est-à-dire célibataire, divorcé(e), séparé(e) ou veuf(ve) avec des enfants
# à charge ou enceinte, le montant forfaitaire garanti est majoré.
# Ce montant forfaitaire majoré est accordé à partir du mois au cours duquel survient l'un des événements
# suivants :
# - déclaration de grossesse,
# - naissance d'un enfant,
# - prise en charge d'un enfant,
# - séparation, veuvage,
# - dépôt de la demande si l’événement est antérieur.
#
# Le montant forfaitaire majoré peut être accordé pendant 12 mois, continus ou discontinus, au cours
# d’une période de 18 mois suivant l’événement.
# Si votre plus jeune enfant à charge a moins de 3 ans, le montant forfaitaire majoré vous est accordé
# jusqu'à ses 3 ans.
benjamin = age_en_mois_benjamin(age_en_mois)
enceinte = (benjamin < 0) * (benjamin > -6)
# TODO: quel mois mettre ?
# TODO: pas complètement exact
# L'allocataire perçoit l'API :
# jusqu'�� ce que le plus jeune enfant ait 3 ans,
# ou pendant 12 mois consécutifs si les enfants sont âgés de plus de 3 ans
# et s'il a présenté sa demande dans les 6 mois à partir du moment où il
# assure seul la charge de l'enfant.
# TODO: API courte gens pour les gens qui ont divorcés dans l'année
# Le droit à l'allocation est réétudié tous les 3 mois.
# # Calcul de l'année et mois de naissance du benjamin
condition = (floor(benjamin / 12) <= api.age - 1)
eligib = isole * ((enceinte != 0) | (nb_enf(age, autonomie_financiere, 0, api.age - 1) > 0)) * condition
# moins de 20 ans avant inclusion dans rsa
# moins de 25 ans après inclusion dans rsa
api1 = eligib * af.bmaf * (api.base + api.enf_sup * nb_enf(age, autonomie_financiere, af.age1, api.age_pac - 1))
rsa = (api.age_pac >= 25) # dummy passage au rsa majoré
br_api = rsa_base_ressources + af_majoration * not_(rsa)
# On pourrait mensualiser RMI, BRrmi et forfait logement
api = max_(0, api1 - rsa_forfait_logement / 12 - br_api / 12 - rsa / 12)
# L'API est exonérée de CRDS
return period, api # annualisé
def ouvre_droit_majoration():
enceinte_fam = simulation.calculate('enceinte_fam', period)
isole = not_(simulation.calculate('en_couple', period))
isolement_recent = simulation.calculate('rsa_isolement_recent', period)
presence_autres_enfants = self.sum_by_entity(enfant * not_(autonomie_financiere) * (age <= P_rsa.age_pac), entity = "famille") > 1
return self.cast_from_entity_to_roles(not_(enceinte_fam) * isole * isolement_recent * not_(presence_autres_enfants), entity = 'famille')
def _saldom2(nb_pac2, f7db, f7dg, f7dl, f7dq, _P):
'''
Crédit d’impôt emploi d’un salarié à domicile (cases 7DB, 7DG)
2007-
'''
P = _P.ir.reductions_impots.saldom
isinvalid = f7dg
if _P.datesim.year in (2007, 2008):
nbpacmin = nb_pac2 + f7dl
maxBase = P.max1
maxDuMaxNonInv = P.max2
maxNonInv = min_(maxBase + P.pac * nbpacmin, maxDuMaxNonInv)
maxEffectif = maxNonInv * not_(isinvalid) + P.max3 * isinvalid
elif _P.datesim.year in (2009, 2010):
annee1 = f7dq
nbpacmin = nb_pac2 + f7dl
maxBase = P.max1 * not_(annee1) + P.max1_1ereAnnee * annee1
maxDuMaxNonInv = P.max2 * not_(annee1) + P.max2_1ereAnnee * annee1
maxNonInv = min_(maxBase + P.pac * nbpacmin, maxDuMaxNonInv)
maxEffectif = maxNonInv * not_(isinvalid) + P.max3 * isinvalid
elif _P.datesim.year >= 2011:
# TODO:
maxEffectif = 0
return P.taux * min_(f7db, maxEffectif)
def function(famille, period, legislation):
period = period.this_month
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 == 2) * not_(loyer),
(statut_occupation_logement == 6) * 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 = legislation(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(famille, period, parameters):
nb_personnes = famille.nb_persons()
personnes_a_charge = famille('al_nb_personnes_a_charge', period)
personne_seule = (famille.nb_persons(Famille.PARENT)
== 1) * (personnes_a_charge == 0)
# Jeune ménage : Couple marié, concubins ou pacsés, sans personne à charge,
# dont la somme des âges des deux conjoints est inférieure ou égale à 55 ans
age = famille.members('age', period)
sum_age = famille.sum(age, role=Famille.PARENT)
jeune_menage = (not_(personne_seule) * (sum_age <= 55))
return select(
[
personne_seule,
# Deux personnes ne comportant aucune personne à charge, à l'exclusion des jeunes ménages.
((nb_personnes == 2) *
(personnes_a_charge == 0) * not_(jeune_menage)),
# Trois personnes, ou une personne seule avec une personne à charge, ou jeune ménage sans personne à charge.
(personnes_a_charge == 1) + (jeune_menage *
(personnes_a_charge == 0)),
# Quatre personnes, ou une personne seule avec deux personnes à charge.
(personnes_a_charge == 2),
# Cinq personnes, ou une personne seule avec trois personnes à charge.
(personnes_a_charge == 3)
],
[
CategorieMenageLogementSocial.categorie_1,
CategorieMenageLogementSocial.categorie_2,
CategorieMenageLogementSocial.categorie_3,
CategorieMenageLogementSocial.categorie_4,
CategorieMenageLogementSocial.categorie_5
],
default=CategorieMenageLogementSocial.categorie_6)
def _asi_pure(asi_elig,
marpac,
maries,
asi_aspa_nb_alloc,
br_mv,
_P,
_option={'asi_elig': [CHEF, PART]}):
'''
Calcule l'ASI lorsqu'il y a un ou deux bénéficiaire de l'ASI et aucun bénéficiaire de l'ASPA
'''
P = _P.minim
# 1 A Un ou deux bénéficiaire(s) de l'ASI et aucun bénéficiaire de l'ASPA
elig1 = ((asi_aspa_nb_alloc == 1) & (asi_elig[CHEF] | asi_elig[PART])
) # un seul éligible
elig2 = (asi_elig[CHEF]
& asi_elig[PART]) * maries # couple d'éligible marié
elig3 = (asi_elig[CHEF] & asi_elig[PART]) * (
marpac & not_(maries)) # couple d'éligible non marié
elig = elig1 | elig2
montant_max = elig1 * P.asi.montant_seul + elig2 * P.asi.montant_couple + elig3 * 2 * P.asi.montant_seul
ressources = elig * (br_mv + montant_max)
plafond_ressources = elig1 * (
P.asi.plaf_seul * not_(marpac) + P.aspa.plaf_couple *
marpac) + elig2 * P.aspa.plaf_couple + elig3 * P.asi.plaf_couple
depassement = ressources - plafond_ressources
montant_servi_asi = max_(montant_max - depassement, 0) / 12
# Faute de mieux, on verse l'asi à la famille plutôt qu'aux individus
# asi[CHEF] = asi_elig[CHEF]*montant_servi_asi*(elig1*1 + elig2/2 + elig3/2)
# asi[PART] = asi_elig[PART]*montant_servi_asi*(elig1*1 + elig2/2 + elig3/2)
return 12 * (asi_elig[CHEF] + asi_elig[PART]) * montant_servi_asi * (
elig1 * 1 + elig2 / 2 + elig3 / 2) # annualisé
def function(self, simulation, period):
'''
Type de menage
TODO: prendre les enfants du ménage et non ceux de la famille
'''
period = period.this_year
en_couple_holder = simulation.compute('en_couple', period)
af_nbenf_holder = simulation.compute('af_nbenf', period)
af_nbenf = self.cast_from_entity_to_role(af_nbenf_holder, role = CHEF)
af_nbenf = self.sum_by_entity(af_nbenf)
isole = not_(self.cast_from_entity_to_role(en_couple_holder, role = CHEF))
isole = self.sum_by_entity(isole)
_0_kid = af_nbenf == 0
_1_kid = af_nbenf == 1
_2_kid = af_nbenf == 2
_3_kid = af_nbenf >= 3
return period, (
0 * (isole & _0_kid) + # Célibataire
1 * (not_(isole) & _0_kid) + # Couple sans enfants
2 * (not_(isole) & _1_kid) + # Couple un enfant
3 * (not_(isole) & _2_kid) + # Couple deux enfants
4 * (not_(isole) & _3_kid) + # Couple trois enfants et plus
5 * (isole & _1_kid) + # Famille monoparentale un enfant
6 * (isole & _2_kid) + # Famille monoparentale deux enfants
7 * (isole & _3_kid)) # Famille monoparentale trois enfants et plus
def function(self, simulation, period):
period = period.start.offset("first-of", "month").period("month")
age_holder = simulation.compute("age", period)
# smic55_holder = simulation.compute('smic55', period)
activite_holder = simulation.compute("activite", period)
nb_par = simulation.calculate("nb_par", period)
rmi = simulation.legislation_at(period.start).minim.rmi
age_parents = self.split_by_roles(age_holder, roles=[CHEF, PART])
activite_parents = self.split_by_roles(activite_holder, roles=[CHEF, PART])
# age_enf = self.split_by_roles(age_holder, roles = ENFS)
# smic55_enf = self.split_by_roles(smic55_holder, roles = ENFS)
nbp = nb_par
eligib = ((age_parents[CHEF] >= rmi.age_pac) * not_(activite_parents[CHEF] == 2)) | (
(age_parents[PART] >= rmi.age_pac) * not_(activite_parents[PART] == 2)
)
taux = (
1
+ (nbp >= 2) * rmi.txp2
+ (nbp >= 3) * rmi.txp3
+ (nbp >= 4) * ((nb_par == 1) * rmi.txps + (nb_par != 1) * rmi.txp3)
+ max_(nbp - 4, 0) * rmi.txps
)
return period, eligib * rmi.rmi * taux
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 function(famille, period, legislation):
"""
Allocation de parent isolé
"""
period = period.this_month
isole = not_(famille('en_couple', period))
rsa_forfait_logement = famille('rsa_forfait_logement', period)
rsa_base_ressources = famille('rsa_base_ressources', period)
af_majoration = famille('af_majoration', period)
rsa = famille('rsa', period)
af = legislation(period).prestations.prestations_familiales.af
api = legislation(period).prestations.minima_sociaux.api
# TODO:
# Majoration pour isolement
# Si vous êtes parent isolé, c’est-à-dire célibataire, divorcé(e), séparé(e) ou veuf(ve) avec des enfants
# à charge ou enceinte, le montant forfaitaire garanti est majoré.
# Ce montant forfaitaire majoré est accordé à partir du mois au cours duquel survient l'un des événements
# suivants :
# - déclaration de grossesse,
# - naissance d'un enfant,
# - prise en charge d'un enfant,
# - séparation, veuvage,
# - dépôt de la demande si l’événement est antérieur.
#
# Le montant forfaitaire majoré peut être accordé pendant 12 mois, continus ou discontinus, au cours
# d’une période de 18 mois suivant l’événement.
# Si votre plus jeune enfant à charge a moins de 3 ans, le montant forfaitaire majoré vous est accordé
# jusqu'à ses 3 ans.
age_en_mois_i = famille.members('age_en_mois', period)
age_en_mois_benjamin = famille.min(age_en_mois_i, role=Famille.ENFANT)
enceinte = (age_en_mois_benjamin < 0) * (age_en_mois_benjamin > -6)
# TODO: quel mois mettre ?
# TODO: pas complètement exact
# L'allocataire perçoit l'API :
# jusqu'�� ce que le plus jeune enfant ait 3 ans,
# ou pendant 12 mois consécutifs si les enfants sont âgés de plus de 3 ans
# et s'il a présenté sa demande dans les 6 mois à partir du moment où il
# assure seul la charge de l'enfant.
# TODO: API courte gens pour les gens qui ont divorcés dans l'année
# Le droit à l'allocation est réétudié tous les 3 mois.
# # Calcul de l'année et mois de naissance du benjamin
condition = (floor(age_en_mois_benjamin / 12) <= api.age_limite - 1)
eligib = isole * (
(enceinte != 0) |
(nb_enf(famille, period, 0, api.age_limite - 1) > 0)) * condition
# moins de 20 ans avant inclusion dans rsa
# moins de 25 ans après inclusion dans rsa
api1 = eligib * af.bmaf * (
api.base + api.supplement_par_enfant *
nb_enf(famille, period, af.age1, api.age_pac - 1))
rsa = (api.age_pac >= 25) # dummy passage au rsa majoré
br_api = rsa_base_ressources + af_majoration * not_(rsa)
# On pourrait mensualiser RMI, BRrmi et forfait logement
api = max_(0,
api1 - rsa_forfait_logement / 12 - br_api / 12 - rsa / 12)
# L'API est exonérée de CRDS
return period, api # annualisé
def function(famille, period, legislation):
period = period.this_month
al = legislation(period).prestations.aides_logement
couple = famille('al_couple', period)
al_nb_pac = famille('al_nb_personnes_a_charge', period)
residence_dom = famille.demandeur.menage('residence_dom')
TF_metropole = (
al.taux_participation_fam.taux_1_adulte * (not_(couple)) * (al_nb_pac == 0) +
al.taux_participation_fam.taux_2_adulte * (couple) * (al_nb_pac == 0) +
al.taux_participation_fam.taux_1_enf * (al_nb_pac == 1) +
al.taux_participation_fam.taux_2_enf * (al_nb_pac == 2) +
al.taux_participation_fam.taux_3_enf * (al_nb_pac == 3) +
al.taux_participation_fam.taux_4_enf * (al_nb_pac >= 4) +
al.taux_participation_fam.taux_enf_supp * (al_nb_pac > 4) * (al_nb_pac - 4)
)
TF_dom = (
al.taux_participation_fam.dom.taux1 * (not_(couple)) * (al_nb_pac == 0) +
al.taux_participation_fam.dom.taux2 * (couple) * (al_nb_pac == 0) +
al.taux_participation_fam.dom.taux3 * (al_nb_pac == 1) +
al.taux_participation_fam.dom.taux4 * (al_nb_pac == 2) +
al.taux_participation_fam.dom.taux5 * (al_nb_pac == 3) +
al.taux_participation_fam.dom.taux6 * (al_nb_pac == 4) +
al.taux_participation_fam.dom.taux7 * (al_nb_pac == 5) +
al.taux_participation_fam.dom.taux8 * (al_nb_pac >= 6)
)
return period, where(residence_dom, TF_dom, TF_metropole)
def function_2016(individu, period):
period = period.this_month
last_3_months = period.last_3_months
# Note Auto-entrepreneurs:
# D'après les caisses, le revenu pris en compte pour les AE pour le RSA ne prend en compte que
# l'abattement standard sur le CA, mais pas les cotisations pour charges sociales.
types_revenus_activite = [
'salaire_net',
'indemnites_chomage_partiel',
'indemnites_volontariat',
'revenus_stage_formation_pro',
'bourse_recherche',
'hsup',
'etr',
'tns_auto_entrepreneur_benefice',
'rsa_indemnites_journalieres_activite',
]
has_ressources_substitution = individu(
'rsa_has_ressources_substitution', period)
# Les revenus pros interrompus au mois M sont neutralisés s'il n'y a pas de revenus de substitution.
return period, sum(
individu(type_revenu, last_3_months, options=[ADD]) *
not_((individu(type_revenu, period.this_month) == 0) *
(individu(type_revenu, period.last_month) > 0) *
not_(has_ressources_substitution))
for type_revenu in types_revenus_activite) / 3
def function(self, simulation, period):
period = period.this_month
last_3_months = period.last_3_months
# Note Auto-entrepreneurs:
# D'après les caisses, le revenu pris en compte pour les AE pour le RSA ne prend en compte que
# l'abattement standard sur le CA, mais pas les cotisations pour charges sociales.
types_revenus_activite = [
'salaire_net',
'indemnites_chomage_partiel',
'indemnites_volontariat',
'revenus_stage_formation_pro',
'bourse_recherche',
'hsup',
'etr',
'tns_auto_entrepreneur_benefice',
'rsa_indemnites_journalieres_activite',
]
has_ressources_substitution = simulation.calculate('rsa_has_ressources_substitution', period)
# Les revenus pros interrompus au mois M sont neutralisés s'il n'y a pas de revenus de substitution.
return period, sum(
simulation.calculate_add(type_revenu, last_3_months) * not_(
(simulation.calculate(type_revenu, period.this_month) == 0) *
(simulation.calculate(type_revenu, period.last_month) > 0) *
not_(has_ressources_substitution)
)
for type_revenu in types_revenus_activite
) / 3
def function(self, simulation, period):
'''
type de menage
'men'
TODO: prendre les enfants du ménage et non ceux de la famille
'''
period = period.start.offset('first-of', 'month').period('year')
isol_holder = simulation.compute('isol', period)
af_nbenf_holder = simulation.compute('af_nbenf', period)
af_nbenf = self.cast_from_entity_to_role(af_nbenf_holder, role=CHEF)
af_nbenf = self.sum_by_entity(af_nbenf)
isol = self.cast_from_entity_to_role(isol_holder, role=CHEF)
isol = self.sum_by_entity(isol)
_0_kid = af_nbenf == 0
_1_kid = af_nbenf == 1
_2_kid = af_nbenf == 2
_3_kid = af_nbenf >= 3
return period, (
0 * (isol & _0_kid) + # Célibataire
1 * (not_(isol) & _0_kid) + # Couple sans enfants
2 * (not_(isol) & _1_kid) + # Couple un enfant
3 * (not_(isol) & _2_kid) + # Couple deux enfants
4 * (not_(isol) & _3_kid) + # Couple trois enfants et plus
5 * (isol & _1_kid) + # Famille monoparentale un enfant
6 * (isol & _2_kid) + # Famille monoparentale deux enfants
7 * (isol & _3_kid)) # Famille monoparentale trois enfants et plus
def _br_al(etu, boursier, br_pf_i, rev_coll, biact, _P ,_option = {'boursier': [CHEF, PART], 'etu': [CHEF, PART], 'br_pf_i': [CHEF, PART]}):
'''
Base ressource des allocations logement
'''
# On ne considère que les revenus des 2 conjoints et les revenus non
# individualisables
# 0 - non étudiant
# 1 - étudiant non boursier
# 2 - éutidant boursier
# revCatvous et self.conj : somme des revenus catégoriel après abatement
# revColl : autres revenus du ménage non individualisable
# ALabat : abatement prix en compte pour le calcul de la base ressources
# des allocattions logement
# plancher de ressources pour les etudiants
P = _P
Pr = P.al.ressources
etuC = (etu[CHEF]) & (not_(etu[PART]))
etuP = not_(etu[CHEF]) & (etu[PART])
etuCP = (etu[CHEF]) & (etu[PART])
# Boursiers
# TODO: distinguer boursier foyer/boursier locatif
etuCB = etu[CHEF]&boursier[CHEF]
etuPB = etu[PART]&boursier[PART]
# self.etu = (self.etu[CHEF]>=1)|(self.etuP>=1)
revCatVous = max_(br_pf_i[CHEF],etuC*(Pr.dar_4-(etuCB)*Pr.dar_5))
revCatConj = max_(br_pf_i[PART],etuP*(Pr.dar_4-(etuPB)*Pr.dar_5))
revCatVsCj = not_(etuCP)*(revCatVous + revCatConj) + \
etuCP*max_(br_pf_i[CHEF] + br_pf_i[PART], Pr.dar_4 -(etuCB|etuPB)*Pr.dar_5 + Pr.dar_7)
# TODO: ajouter les paramètres pour les étudiants en foyer (boursier et non boursier), les inclure dans le calcul
# somme des revenus catégoriels après abatement
revCat = revCatVsCj + rev_coll
# TODO: charges déductibles : pension alimentaires et abatements spéciaux
revNet = revCat
# On ne considère pas l'abattement sur les ressources de certaines
# personnes (enfant, ascendants ou grands infirmes).
# abattement forfaitaire double activité
abatDoubleAct = biact*Pr.dar_1
# TODO: neutralisation des ressources
# ...
# TODO: abbattement sur les ressources
# ...
# TODO: évaluation forfaitaire des ressources (première demande)
# TODO :double résidence pour raisons professionnelles
# Base ressource des aides au logement (arrondies aux 100 euros supérieurs)
br_al = ceil(max_(revNet - abatDoubleAct,0)/100)*100
return br_al
def function(self, simulation, period):
period = period.start.offset('first-of', 'month').period('month')
three_previous_months = period.start.period('month', 3).offset(-3)
aspa_elig = simulation.calculate('aspa_elig', period)
aspa_couple_holder = simulation.compute('aspa_couple', period)
salaire_de_base = simulation.calculate('salaire_de_base', three_previous_months)
chonet = simulation.calculate('chonet', three_previous_months)
rstbrut = simulation.calculate('rstbrut', three_previous_months)
pensions_alimentaires_percues = simulation.calculate('pensions_alimentaires_percues', three_previous_months)
rto_declarant1 = simulation.calculate_add_divide('rto_declarant1', three_previous_months)
rpns = simulation.calculate_add_divide('rpns', three_previous_months)
rev_cap_bar_holder = simulation.compute_add_divide('rev_cap_bar', three_previous_months)
rev_cap_lib_holder = simulation.compute_add_divide('rev_cap_lib', three_previous_months)
rfon_ms = simulation.calculate_add_divide('rfon_ms', three_previous_months)
div_ms = simulation.calculate_add_divide('div_ms', three_previous_months)
revenus_stage_formation_pro = simulation.calculate('revenus_stage_formation_pro', three_previous_months)
allocation_securisation_professionnelle = simulation.calculate('allocation_securisation_professionnelle', three_previous_months)
prime_forfaitaire_mensuelle_reprise_activite = simulation.calculate('prime_forfaitaire_mensuelle_reprise_activite', three_previous_months)
dedommagement_victime_amiante = simulation.calculate('dedommagement_victime_amiante', three_previous_months)
prestation_compensatoire = simulation.calculate('prestation_compensatoire', three_previous_months)
pensions_invalidite = simulation.calculate('pensions_invalidite', three_previous_months)
gains_exceptionnels = simulation.calculate('gains_exceptionnels', three_previous_months)
indemnites_journalieres_maternite = simulation.calculate('indemnites_journalieres_maternite', three_previous_months)
indemnites_journalieres_maladie = simulation.calculate('indemnites_journalieres_maladie', three_previous_months)
indemnites_journalieres_maladie_professionnelle = simulation.calculate('indemnites_journalieres_maladie_professionnelle', three_previous_months)
indemnites_journalieres_accident_travail = simulation.calculate('indemnites_journalieres_accident_travail', three_previous_months)
indemnites_chomage_partiel = simulation.calculate('indemnites_chomage_partiel', three_previous_months)
indemnites_volontariat = simulation.calculate('indemnites_volontariat', three_previous_months)
tns_total_revenus = simulation.calculate_add('tns_total_revenus', three_previous_months)
rsa_base_ressources_patrimoine_i = simulation.calculate_add('rsa_base_ressources_patrimoine_i', three_previous_months)
aah = simulation.calculate('aah', three_previous_months)
legislation = simulation.legislation_at(period.start)
leg_1er_janvier = simulation.legislation_at(period.start.offset('first-of', 'year'))
aspa_couple = self.cast_from_entity_to_role(aspa_couple_holder, role = VOUS)
rev_cap_bar = self.cast_from_entity_to_role(rev_cap_bar_holder, role = VOUS)
rev_cap_lib = self.cast_from_entity_to_role(rev_cap_lib_holder, role = VOUS)
# Inclus l'AAH si conjoint non pensionné ASPA, retraite et pension invalidité
aah = aah * not_(aspa_elig)
# Abattement sur les salaires (appliqué sur une base trimestrielle)
abattement_forfaitaire_base = leg_1er_janvier.cotsoc.gen.smic_h_b * legislation.minim.aspa.abattement_forfaitaire_nb_h
abattement_forfaitaire_taux = (aspa_couple * legislation.minim.aspa.abattement_forfaitaire_tx_couple +
not_(aspa_couple) * legislation.minim.aspa.abattement_forfaitaire_tx_seul
)
abattement_forfaitaire = abattement_forfaitaire_base * abattement_forfaitaire_taux
salaire_de_base = max_(0, salaire_de_base - abattement_forfaitaire)
return period, (salaire_de_base + chonet + rstbrut + pensions_alimentaires_percues + rto_declarant1 + rpns +
max_(0, rev_cap_bar) + max_(0, rev_cap_lib) + max_(0, rfon_ms) + max_(0, div_ms) +
# max_(0,etr) +
revenus_stage_formation_pro + allocation_securisation_professionnelle + prime_forfaitaire_mensuelle_reprise_activite +
dedommagement_victime_amiante + prestation_compensatoire + pensions_invalidite + gains_exceptionnels +
indemnites_journalieres_maternite + indemnites_journalieres_maladie + indemnites_journalieres_maladie_professionnelle +
indemnites_journalieres_accident_travail + indemnites_chomage_partiel + indemnites_volontariat + tns_total_revenus +
rsa_base_ressources_patrimoine_i + aah
) / 3
def compare(self, seuil_abs = 100, seuil_rel = 0.10):
'''
Fonction qui comparent les calculs d'OF et et de TaxIPP
Gestion des outputs
'''
dta_output = self.paths['dta_output']
ipp_output = read_stata(dta_output).fillna(0)
dta_input = self.paths['dta_input']
ipp_input = read_stata(dta_input).fillna(0)
openfisca_output = self.openfisca_outputput.fillna(0)
openfisca_input = self.simulation.input_table.table
ipp2of_output_variables = self.dic_var_output
check_list = ['csg_sal_ded', 'irpp_net_foy', 'af_foys'] # 'csg_sal_ded',
print self.dic_param
for ipp_var in check_list:
of_var = ipp2of_output_variables[ipp_var]
entity = self.simulation.prestation_by_name[of_var].entity
if entity == 'ind':
conflict = ((ipp_output[ipp_var] - openfisca_output[of_var].abs()).abs() < THRESHOLD)
print conflict.to_string()
print ipp_output.loc[not_(conflict), ipp_var].to_string()
print openfisca_output.loc[not_(conflict), of_var].to_string()
print ipp_input.loc[not_(conflict), ].to_string()
print openfisca_input.loc[not_(conflict), self.relevant_input_variables()].to_string()
#error_diag()
# TODO: finish by calling error_diag
elif entity == "fam":
pass
elif entity == "foy":
openfisca_foy = openfisca_output.loc[ openfisca_input.quifoy == 0, of_var]
ipp_foy = ipp_output.loc[ openfisca_input.quifoy == 0, ipp_var]
print ipp_foy
conflict = ((ipp_foy - openfisca_foy.abs()).abs() > THRESHOLD)
print conflict.to_string()
elif entity == "men":
pass
def _diff(seuil_abs, seuil_rel):
for k, v in dic.items() :
diff_abs = ipp_output[k].mean() - openfisca_output[v].mean()
if diff_abs > seuil_abs :
print " Différence absolue pour ", k, ' : ', diff_abs
diff_rel = (ipp_output.loc[(ipp_output[k] != 0) & (openfisca_output[v] != 0), k] /openfisca_output.loc[(ipp_output[k] != 0) & (openfisca_output[v] != 0), v] ).mean()
if (diff_rel > seuil_rel) & (diff_rel is not None) :
print " Différence relative pour ", k, ' : ', diff_rel
def function(famille, period):
period = period.this_month
pensions_alimentaires_percues = famille.members('pensions_alimentaires_percues', period)
pas_de_pensions = not_(famille.sum(pensions_alimentaires_percues))
isole = not_(famille('en_couple', period))
residence_mayotte = famille.demandeur.menage('residence_mayotte', period)
return period, not_(residence_mayotte) * isole * pas_de_pensions # Parent isolé et ne résident pas à Mayotte
def function(self, simulation, period):
period = period.start.offset('first-of', 'month').period('month')
pensions_alimentaires_percues_holder = simulation.compute('pensions_alimentaires_percues', period)
pensions_alimentaires_percues = self.sum_by_entity(pensions_alimentaires_percues_holder)
isol = simulation.calculate('isol', period)
residence_mayotte = simulation.calculate('residence_mayotte', period)
return period, not_(residence_mayotte) * isol * not_(pensions_alimentaires_percues) # Parent isolé et ne résident pas à Mayotte
def function(famille, period):
period = period.this_month
pensions_alimentaires_percues = famille.members('pensions_alimentaires_percues', period)
pas_de_pensions = not_(famille.sum(pensions_alimentaires_percues))
isole = not_(famille('en_couple', period))
residence_mayotte = famille.demandeur.menage('residence_mayotte', period)
return period, not_(residence_mayotte) * isole * pas_de_pensions # Parent isolé et ne résident pas à Mayotte
def function(self, simulation, period):
period = period.start.offset('first-of', 'month').period('month')
two_years_ago = period.start.offset('first-of', 'year').period('year').offset(-2)
etu_holder = simulation.compute('etu', period)
boursier_holder = simulation.compute('boursier', period)
br_pf_i_holder = simulation.compute('br_pf_i', two_years_ago)
rev_coll_holder = simulation.compute('rev_coll', two_years_ago)
biact = simulation.calculate('biact', period)
Pr = simulation.legislation_at(period.start).al.ressources
boursier = self.split_by_roles(boursier_holder, roles = [CHEF, PART])
br_pf_i = self.split_by_roles(br_pf_i_holder, roles = [CHEF, PART])
etu = self.split_by_roles(etu_holder, roles = [CHEF, PART])
rev_coll = self.sum_by_entity(rev_coll_holder)
etuC = (etu[CHEF]) & (not_(etu[PART]))
etuP = not_(etu[CHEF]) & (etu[PART])
etuCP = (etu[CHEF]) & (etu[PART])
# Boursiers
# TODO: distinguer boursier foyer/boursier locatif
etuCB = etu[CHEF] & boursier[CHEF]
etuPB = etu[PART] & boursier[PART]
# self.etu = (self.etu[CHEF]>=1)|(self.etuP>=1)
revCatVous = max_(br_pf_i[CHEF], etuC * (Pr.dar_4 - (etuCB) * Pr.dar_5))
revCatConj = max_(br_pf_i[PART], etuP * (Pr.dar_4 - (etuPB) * Pr.dar_5))
revCatVsCj = (
not_(etuCP) * (revCatVous + revCatConj) +
etuCP * max_(br_pf_i[CHEF] + br_pf_i[PART], Pr.dar_4 - (etuCB | etuPB) * Pr.dar_5 + Pr.dar_7)
)
# TODO: ajouter les paramètres pour les étudiants en foyer (boursier et non boursier),
# les inclure dans le calcul somme des revenus catégoriels après abatement
revCat = revCatVsCj + rev_coll
# TODO: charges déductibles : pension alimentaires et abatements spéciaux
revNet = revCat
# On ne considère pas l'abattement sur les ressources de certaines
# personnes (enfant, ascendants ou grands infirmes).
# abattement forfaitaire double activité
abatDoubleAct = biact * Pr.dar_1
# TODO: neutralisation des ressources
# ...
# TODO: abbattement sur les ressources
# ...
# TODO: évaluation forfaitaire des ressources (première demande)
# TODO :double résidence pour raisons professionnelles
# Base ressource des aides au logement (arrondies aux 100 euros supérieurs)
br_al = ceil(max_(revNet - abatDoubleAct, 0) / 100) * 100
return period, br_al
def function(self, simulation, period):
period = period.this_month
pensions_alimentaires_percues_holder = simulation.compute('pensions_alimentaires_percues', period)
pensions_alimentaires_percues = self.sum_by_entity(pensions_alimentaires_percues_holder)
isole = not_(simulation.calculate('en_couple', period))
residence_mayotte = simulation.calculate('residence_mayotte', period)
return period, not_(residence_mayotte) * isole * not_(pensions_alimentaires_percues) # Parent isolé et ne résident pas à Mayotte
def ouvre_droit_majoration():
famille = individu.famille
enceinte_fam = famille('enceinte_fam', period)
isole = not_(famille('en_couple', period))
isolement_recent = famille('rsa_isolement_recent', period)
presence_autres_enfants = famille.sum(enfant * not_(autonomie_financiere) * (age <= age_pac)) > 1
# individu.famille.sum retourne un résultat qui n'est pas implicitement projeté sur l'individu.
return not_(enceinte_fam) * isole * isolement_recent * not_(famille.project(presence_autres_enfants))
def function(self, simulation, period):
period = period.start.period('month').offset('first-of')
cmu_c = simulation.calculate('cmu_c', period)
cmu_base_ressources = simulation.calculate('cmu_base_ressources', period)
acs_plafond = simulation.calculate('acs_plafond', period)
acs_montant = simulation.calculate('acs_montant', period)
residence_mayotte = simulation.calculate('residence_mayotte', period)
return period, not_(residence_mayotte) * not_(cmu_c) * (cmu_base_ressources <= acs_plafond) * acs_montant / 12
def _als_nonet(self, al, al_pac, etu_holder, so_holder, proprietaire_proche_famille):
'''
Allocation logement sociale (non étudiante)
'''
# variable ménage à redistribuer
so = self.cast_from_entity_to_roles(so_holder)
so = self.filter_role(so, role = CHEF)
etu = self.split_by_roles(etu_holder, roles = [CHEF, PART])
return (al_pac == 0) * (so != 3) * not_(proprietaire_proche_famille) * not_(etu[CHEF] | etu[PART]) * al
def function(individu, period, legislation):
period = period.this_month
# Revenus professionels
types_revenus_pros = [
'chomage_net',
'retraite_nette',
]
has_ressources_substitution = individu('rsa_has_ressources_substitution', period)
# Les revenus pros interrompus au mois M sont neutralisés s'il n'y a pas de revenus de substitution.
revenus_pro = sum(
individu(type_revenu, period.last_3_months, options = [ADD]) * not_(
(individu(type_revenu, period.this_month) == 0) *
(individu(type_revenu, period.last_month) > 0) *
not_(has_ressources_substitution)
)
for type_revenu in types_revenus_pros
)
types_revenus_non_pros = [
'allocation_aide_retour_emploi',
'allocation_securisation_professionnelle',
'dedommagement_victime_amiante',
'div_ms',
'gains_exceptionnels',
'pensions_alimentaires_percues',
'pensions_invalidite',
'prestation_compensatoire',
'prime_forfaitaire_mensuelle_reprise_activite',
'revenus_fonciers_minima_sociaux',
'rsa_base_ressources_patrimoine_individu',
'rsa_indemnites_journalieres_hors_activite',
]
# Les revenus non-pro interrompus au mois M sont neutralisés dans la limite d'un montant forfaitaire,
# sans condition de revenu de substitution.
neutral_max_forfaitaire = 3 * legislation(period).prestations.minima_sociaux.rmi.rmi
revenus_non_pros = sum(
max_(0, individu(type_revenu, period.last_3_months, options = [ADD]) - neutral_max_forfaitaire * (
(individu(type_revenu, period.this_month) == 0) *
(individu(type_revenu, period.last_month) > 0)
))
for type_revenu in types_revenus_non_pros
)
# Revenus du foyer fiscal que l'on projette sur le premier invidividus
rev_cap_bar = max_(0, individu.foyer_fiscal('rev_cap_bar', period.last_3_months, options = [ADD]))
rev_cap_lib = max_(0, individu.foyer_fiscal('rev_cap_lib', period.last_3_months, options = [ADD]))
retraite_titre_onereux = individu.foyer_fiscal('retraite_titre_onereux', period.last_3_months, options = [ADD])
revenus_foyer_fiscal = rev_cap_bar + rev_cap_lib + retraite_titre_onereux
revenus_foyer_fiscal_projetes = revenus_foyer_fiscal * individu.has_role(FoyerFiscal.DECLARANT_PRINCIPAL)
return period, (revenus_pro + revenus_non_pros + revenus_foyer_fiscal_projetes) / 3
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)
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 period, eligible * (montant_max / 24) * coefficient_proratisation * non_cumulee
def function(self, simulation, period):
period = period.this_month
age = simulation.calculate('age', period)
autonomie_financiere = simulation.calculate('autonomie_financiere', period)
date_naissance = simulation.calculate('date_naissance', period)
ne_avant_2014 = datetime64('2014-04-01') > date_naissance
age_limite = simulation.legislation_at(period.start).fam.paje.base.age
# L'allocation de base est versée jusqu'au dernier jour du mois civil précédant
# celui au cours duquel l'enfant atteint l'âge de 3 ans.
return period, (age < age_limite) * not_(autonomie_financiere) * not_(ne_avant_2014)
def formula(famille, period):
cmu_c = famille('cmu_c', period)
cmu_base_ressources = famille('cmu_base_ressources', period)
acs_plafond = famille('acs_plafond', period)
acs_montant = famille('acs_montant', period)
residence_mayotte = famille.demandeur.menage('residence_mayotte',
period)
cmu_acs_eligibilite = famille('cmu_acs_eligibilite', period)
return (cmu_acs_eligibilite * not_(residence_mayotte) * not_(cmu_c) *
(cmu_base_ressources <= acs_plafond) * acs_montant)
def function(self, simulation, period):
period = period.this_month
age = simulation.calculate('age', period)
smic55 = simulation.calculate('smic55', period)
birth = simulation.calculate('birth', period)
ne_avant_2014 = datetime64('2014-04-01') > birth
age_limite = simulation.legislation_at(period.start).fam.paje.base.age
# L'allocation de base est versée jusqu'au dernier jour du mois civil précédant
# celui au cours duquel l'enfant atteint l'âge de 3 ans.
return period, (age < age_limite) * not_(smic55) * not_(ne_avant_2014)
def age_aine(ages, smic55, ag1, ag2):
'''
renvoi un vecteur avec l'âge de l'ainé (au sens des allocations
familiales) de chaque famille
'''
ageaine = -9999
for key, age in ages.iteritems():
ispacaf = ((ag1 <= age) & (age <= ag2)) * not_(smic55[key])
isaine = ispacaf & (age > ageaine)
ageaine = isaine * age + not_(isaine) * ageaine
return ageaine
def function(individu, period, legislation):
period = period.this_month
age = individu('age', period)
autonomie_financiere = individu('autonomie_financiere', period)
date_naissance = individu('date_naissance', period)
ne_avant_2014 = datetime64('2014-04-01') > date_naissance
age_limite = legislation(period.start).prestations.prestations_familiales.paje.base.age_max_enfant
# L'allocation de base est versée jusqu'au dernier jour du mois civil précédant
# celui au cours duquel l'enfant atteint l'âge de 3 ans.
return period, (age < age_limite) * not_(autonomie_financiere) * not_(ne_avant_2014)
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)
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 period, eligible * (montant_max / 24) * coefficient_proratisation * non_cumulee
def age_aine(ages, smic55, ag1, ag2):
'''
renvoi un vecteur avec l'âge de l'ainé (au sens des allocations
familiales) de chaque famille
'''
ageaine = -9999
for key, age in ages.iteritems():
ispacaf = ((ag1 <= age) & (age <= ag2)) * not_(smic55[key])
isaine = ispacaf & (age > ageaine)
ageaine = isaine * age + not_(isaine) * ageaine
return ageaine
def function(self, simulation, period):
period = period.this_month
age = simulation.calculate('age', period)
autonomie_financiere = simulation.calculate('autonomie_financiere', period)
date_naissance = simulation.calculate('date_naissance', period)
ne_avant_2014 = datetime64('2014-04-01') > date_naissance
age_limite = simulation.legislation_at(period.start).prestations.prestations_familiales.paje.base.age_max_enfant
# L'allocation de base est versée jusqu'au dernier jour du mois civil précédant
# celui au cours duquel l'enfant atteint l'âge de 3 ans.
return period, (age < age_limite) * not_(autonomie_financiere) * not_(ne_avant_2014)
def ouvre_droit_majoration():
famille = individu.famille
enceinte_fam = famille('enceinte_fam', period)
isole = not_(famille('en_couple', period))
isolement_recent = famille('rsa_isolement_recent', period)
presence_autres_enfants = famille.sum(
enfant * not_(autonomie_financiere) * (age <= age_pac)) > 1
# individu.famille.sum retourne un résultat qui n'est pas implicitement projeté sur l'individu.
return not_(enceinte_fam) * isole * isolement_recent * not_(
famille.project(presence_autres_enfants))
def function(self, simulation, period):
period = period.this_month
cmu_c = simulation.calculate('cmu_c', period)
cmu_base_ressources = simulation.calculate('cmu_base_ressources',
period)
acs_plafond = simulation.calculate('acs_plafond', period)
acs_montant = simulation.calculate('acs_montant', period)
residence_mayotte = simulation.calculate('residence_mayotte', period)
return period, not_(residence_mayotte) * not_(cmu_c) * (
cmu_base_ressources <= acs_plafond) * acs_montant / 12
def function(self, simulation, period):
period = period.start.offset('first-of', 'month').period('month')
asi_elig_holder = simulation.compute('asi_elig', period)
aspa_elig_holder = simulation.compute('aspa_elig', period)
maries = simulation.calculate('maries', period)
concub = simulation.calculate('concub', period)
asi_aspa_nb_alloc = simulation.calculate('asi_aspa_nb_alloc', period)
br_mv = simulation.calculate('br_mv', period)
P = simulation.legislation_at(period.start).minim
asi_elig = self.split_by_roles(asi_elig_holder, roles = [CHEF, PART])
aspa_elig = self.split_by_roles(aspa_elig_holder, roles = [CHEF, PART])
# Un seul éligible
elig1 = ((asi_aspa_nb_alloc == 1) & (asi_elig[CHEF] | asi_elig[PART]))
# Couple d'éligibles mariés
elig2 = asi_elig[CHEF] & asi_elig[PART] & maries
# Couple d'éligibles non mariés
elig3 = asi_elig[CHEF] & asi_elig[PART] & not_(maries)
# Un seul éligible et époux éligible ASPA
elig4 = ((asi_elig[CHEF] & aspa_elig[PART]) | (asi_elig[PART] & aspa_elig[CHEF])) & maries
# Un seul éligible et conjoint non marié éligible ASPA
elig5 = ((asi_elig[CHEF] & aspa_elig[PART]) | (asi_elig[PART] & aspa_elig[CHEF])) & not_(maries)
elig = elig1 | elig2 | elig3 | elig4 | elig5
montant_max = (elig1 * P.asi.montant_seul +
elig2 * P.asi.montant_couple +
elig3 * 2 * P.asi.montant_seul +
elig4 * (P.asi.montant_couple / 2 + P.aspa.montant_couple / 2) +
elig5 * (P.asi.montant_seul + P.aspa.montant_couple / 2)) / 12
ressources = br_mv + montant_max
plafond_ressources = (elig1 * (P.asi.plaf_seul * not_(concub) + P.asi.plaf_couple * concub) +
elig2 * P.asi.plaf_couple +
elig3 * P.asi.plaf_couple +
elig4 * P.aspa.plaf_couple +
elig5 * P.aspa.plaf_couple) / 12
depassement = max_(ressources - plafond_ressources, 0)
diff = ((elig1 | elig2 | elig3) * (montant_max - depassement) +
elig4 * (P.asi.montant_couple / 12 / 2 - depassement / 2) +
elig5 * (P.asi.montant_seul / 12 - depassement / 2))
# Montant mensuel servi (sous réserve d'éligibilité)
montant_servi_asi = max_(diff, 0)
# TODO: Faute de mieux, on verse l'asi à la famille plutôt qu'aux individus
# asi[CHEF] = asi_elig[CHEF]*montant_servi_asi*(elig1*1 + elig2/2 + elig3/2)
# asi[PART] = asi_elig[PART]*montant_servi_asi*(elig1*1 + elig2/2 + elig3/2)
return period, elig * montant_servi_asi
def function(self, simulation, period):
period = period.this_month
pensions_alimentaires_percues_holder = simulation.compute(
'pensions_alimentaires_percues', period)
pensions_alimentaires_percues = self.sum_by_entity(
pensions_alimentaires_percues_holder)
isole = not_(simulation.calculate('en_couple', period))
residence_mayotte = simulation.calculate('residence_mayotte', period)
return period, not_(residence_mayotte) * isole * not_(
pensions_alimentaires_percues
) # Parent isolé et ne résident pas à Mayotte
def function(self, simulation, period):
period = period.start.offset('first-of', 'month').period('year')
this_month = period.start.period('month')
cmu_c = simulation.calculate('cmu_c', this_month)
cmu_base_ressources = simulation.calculate('cmu_base_ressources',
this_month)
acs_plafond = simulation.calculate('acs_plafond', this_month)
acs_montant = simulation.calculate('acs_montant', this_month)
residence_mayotte = simulation.calculate('residence_mayotte',
this_month)
return period, not_(residence_mayotte) * not_(cmu_c) * (
cmu_base_ressources <= acs_plafond) * acs_montant
def function(famille, period, legislation):
'''
L'allocation de base de la paje n'est pas cumulable avec le complément familial
'''
period = period.this_month
paje_base = famille('paje_base', period)
apje_avant_cumul = famille('apje_avant_cumul', period)
ape_avant_cumul = famille('ape_avant_cumul', period)
cf_montant = famille('cf_montant', period)
residence_mayotte = famille.demandeur.menage('residence_mayotte', period)
cf_brut = not_(paje_base) * (apje_avant_cumul <= cf_montant) * (ape_avant_cumul <= cf_montant) * cf_montant
return period, not_(residence_mayotte) * round(cf_brut, 2)
def function_2013_(self, simulation, period):
period = period.this_month
assiette_allegement = simulation.calculate('assiette_allegement', period)
jeune_entreprise_innovante = simulation.calculate('jeune_entreprise_innovante', period)
smic_proratise = simulation.calculate('smic_proratise', period)
stagiaire = simulation.calculate('stagiaire', period)
legislation = simulation.legislation_at(period.start)
taux_cice = taux_exo_cice(assiette_allegement, smic_proratise, legislation)
credit_impot_competitivite_emploi = taux_cice * assiette_allegement
non_cumul = not_(stagiaire)
association = simulation.calculate('entreprise_est_association_non_lucrative', period)
return period, credit_impot_competitivite_emploi * non_cumul * not_(association)
def function(self, simulation, period):
period = period.this_month
aide_logement_montant = simulation.calculate('aide_logement_montant', period)
al_nb_pac = simulation.calculate('al_nb_personnes_a_charge', period)
etudiant_holder = simulation.compute('etudiant', period)
statut_occupation_logement = simulation.calculate('statut_occupation_logement_famille', period)
proprietaire_proche_famille = simulation.calculate('proprietaire_proche_famille', period)
etudiant = self.split_by_roles(etudiant_holder, roles = [CHEF, PART])
return period, (
(al_nb_pac == 0) * (statut_occupation_logement != 3) * not_(proprietaire_proche_famille) *
not_(etudiant[CHEF] | etudiant[PART]) * aide_logement_montant
)
def function(self, simulation, period):
'''
L'allocation de base de la paje n'est pas cumulable avec le complément familial
'''
period = period.this_month
paje_base = simulation.calculate('paje_base', period)
apje_avant_cumul = simulation.calculate('apje_avant_cumul', period)
ape_avant_cumul = simulation.calculate('ape_avant_cumul', period)
cf_montant = simulation.calculate('cf_montant', period)
residence_mayotte = simulation.calculate('residence_mayotte', period)
cf_brut = not_(paje_base) * (apje_avant_cumul <= cf_montant) * (
ape_avant_cumul <= cf_montant) * cf_montant
return period, not_(residence_mayotte) * round(cf_brut, 2)
def function(famille, period):
period = period.this_month
aide_logement_montant = famille('aide_logement_montant', period)
al_nb_pac = famille('al_nb_personnes_a_charge', period)
statut_occupation_logement = famille.demandeur.menage(
'statut_occupation_logement', period)
proprietaire_proche_famille = famille('proprietaire_proche_famille',
period)
etudiant = famille.members('etudiant', period)
no_parent_etudiant = not_(famille.any(etudiant, role=Famille.PARENT))
return period, ((al_nb_pac == 0) * (statut_occupation_logement != 3) *
not_(proprietaire_proche_famille) *
no_parent_etudiant * aide_logement_montant)
def _aspa_pure(aspa_elig,
marpac,
concub,
maries,
asi_aspa_nb_alloc,
br_mv,
_P,
_option={'aspa_elig': [CHEF, PART]}):
'''
Calcule l'ASPA lorsqu'il y a un ou deux bénéficiaire de l'ASPA et aucun bénéficiaire de l'ASI
'''
# La notion de couple change au 1er janvier 2007 (réforme de 2006)
if _P.datesim.year >= 2007:
couple = marpac | concub
else:
couple = maries
P = _P.minim
elig1 = ((asi_aspa_nb_alloc == 1) & (aspa_elig[CHEF] | aspa_elig[PART]))
elig2 = (aspa_elig[CHEF]
& aspa_elig[PART]) * couple # couple d'allocataire
# elig = elig1 | elig2
#
# montant_max = elig1 * P.aspa.montant_seul + elig2 * P.aspa.montant_couple
# ressources = elig * (br_mv + montant_max)
# plafond_ressources = elig1 * (P.aspa.plaf_seul * not_(couple) + P.aspa.plaf_couple * couple) + elig2 * P.aspa.plaf_couple
# depassement = ressources - plafond_ressources
#
# montant_servi_aspa = max_(montant_max - depassement, 0) / 12
diff_plaf = P.aspa.plaf_couple - P.aspa.plaf_seul
plafond_ressources = (elig1 * not_(couple)) * P.aspa.plaf_seul + (
elig2 | elig1 * couple) * P.aspa.plaf_couple
montant_max = (elig1 * not_(couple)
) * P.aspa.montant_seul + elig2 * P.aspa.montant_couple + (
elig1 * couple) * (
(br_mv <= diff_plaf) *
(P.aspa.montant_seul + br_mv) +
(br_mv > diff_plaf) * P.aspa.montant_couple)
montant_servi_aspa = max_(montant_max - br_mv,
0) * (br_mv <= plafond_ressources) / 12
# TODO: Faute de mieux, on verse l'aspa à la famille plutôt qu'aux individus
# aspa[CHEF] = aspa_elig[CHEF]*montant_servi_aspa*(elig1 + elig2/2)
# aspa[PART] = aspa_elig[PART]*montant_servi_aspa*(elig1 + elig2/2)
elig_indiv = (aspa_elig[CHEF] + aspa_elig[PART])
return 12 * elig_indiv * montant_servi_aspa * (elig1 + elig2) # annualisé
