def function(self, simulation, period): period = period.this_month chomage_brut = simulation.calculate('chomage_brut', period) csg_imposable_chomage = simulation.calculate('csg_imposable_chomage', period) taux_csg_remplacement = simulation.calculate('taux_csg_remplacement', period) law = simulation.legislation_at(period.start) montant_csg = montant_csg_crds( base_avec_abattement=chomage_brut, indicatrice_taux_plein=(taux_csg_remplacement == 3), indicatrice_taux_reduit=(taux_csg_remplacement == 2), law_node=law.csg.chomage.deductible, plafond_securite_sociale=law.cotsoc.gen.plafond_securite_sociale, ) nbh_travail = 35 * 52 / 12 # = 151.67 # TODO: depuis 2001 mais avant ? cho_seuil_exo = law.csg.chomage.min_exo * nbh_travail * law.cotsoc.gen.smic_h_b csg_deductible_chomage = max_( -montant_csg - max_( cho_seuil_exo - (chomage_brut + csg_imposable_chomage + montant_csg), 0), 0, ) return period, -csg_deductible_chomage
def calculate(self, base, getT = False): ''' Computes the tax using a a nonlinear tax scale using marginal tax rates Note: base is the base of the tax, in column ''' k = self.nb n = len(base) if not self._linear_avg_rate: assi = np.tile(base, (k, 1)).T seui = np.tile(np.hstack((self.thresholds, np.inf)), (n, 1)) a = max_(min_(assi, seui[:, 1:]) - seui[:, :-1], 0) i = np.dot(self.rates, a.T) if getT: t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0)) return i, t else: return i else: if len(self.rates_average) == 1: i = base * self.rates_average[0] else: assi = np.tile(base, (k - 1, 1)).T seui = np.tile(np.hstack(self.thresholds), (n, 1)) k = self.t_x().T a = (assi >= seui[:, :-1]) * (assi < seui[:, 1:]) A = np.dot(a, self.t_x().T) B = np.dot(a, np.array(self.thresholds[1:])) C = np.dot(a, np.array(self.rates_average[:-1])) i = base * (A * (base - B) + C) + max_(base - self.thresholds[-1], 0) * self.rates_average[-1] + (base >= self.thresholds[-1]) * self.thresholds[-1] * self.rates_average[-2] if getT: t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0)) return i, t else: return i
def calc(self, assiette, getT = False): ''' Calcule un impôt selon le barême non linéaire exprimé en tranches de taux marginaux. 'assiette' est l'assiette de l'impôt, en colonne ''' k = self.nb n = len(assiette) if not self._linear_taux_moy: assi = np.tile(assiette, (k, 1)).T seui = np.tile(np.hstack((self.seuils, np.inf)), (n, 1)) a = max_(min_(assi, seui[:, 1:]) - seui[:, :-1], 0) i = np.dot(self.taux, a.T) if getT: t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0)) return i, t else: return i else: if len(self.tauxM) == 1: i = assiette * self.tauxM[0] else: assi = np.tile(assiette, (k - 1, 1)).T seui = np.tile(np.hstack(self.seuils), (n, 1)) k = self.t_x().T a = (assi >= seui[:, :-1]) * (assi < seui[:, 1:]) A = np.dot(a, self.t_x().T) B = np.dot(a, np.array(self.seuils[1:])) C = np.dot(a, np.array(self.tauxM[:-1])) i = assiette * (A * (assiette - B) + C) + max_(assiette - self.seuils[-1], 0) * self.tauxM[-1] + (assiette >= self.seuils[-1]) * self.seuils[-1] * self.tauxM[-2] if getT: t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0)) return i, t else: return i
def _aged(age, smic55, br_pf, ape_taux_partiel, dep_trim, _P, _option={ 'age': ENFS, 'smic55': ENFS }): ''' Allocation garde d'enfant à domicile ''' # TODO: trimestrialiser # les deux conjoints actif et revenu min requis # A complêter P = _P.fam nbenf = nb_enf(age, smic55, 0, P.aged.age1 - 1) nbenf2 = nb_enf(age, smic55, 0, P.aged.age2 - 1) elig1 = (nbenf > 0) elig2 = not_(elig1) * (nbenf2 > 0) * ape_taux_partiel depenses = 4 * dep_trim # gérer les dépenses trimestrielles aged3 = elig1 * ( max_(P.aged.remb_plaf1 - P.aged.remb_taux1 * depenses, 0) * (br_pf > P.aged.revenus_plaf) + (br_pf <= P.aged.revenus_plaf) * max_(P.aged.remb_taux2 * depenses - P.aged.remb_plaf1, 0)) aged6 = elig2 * max_(P.aged.remb_taux2 * depenses - P.aged.remb_plaf2, 0) return 12 * (aged3 + aged6) # annualisé
def _ars(age, smic55, br_pf, _P, _option={'age': ENFS, 'smic55': ENFS}): ''' Allocation de rentrée scolaire ''' # TODO convention sur la mensualisation # On tient compte du fait qu'en cas de léger dépassement du plafond, une allocation dégressive # (appelée allocation différentielle), calculée en fonction des revenus, peut être versée. # TODO à partir de 2008, les taux sont différenciés suivant l'âge. P = _P.fam bmaf = P.af.bmaf # On prend l'âge en septembre enf_05 = nb_enf(age, smic55, P.ars.agep - 1, P.ars.agep - 1) # 6 ans avant le 31 janvier # Un enfant scolarisé qui n'a pas encore atteint l'âge de 6 ans # avant le 1er février 2012 peut donner droit à l'ARS à condition qu'il # soit inscrit à l'école primaire. Il faudra alors présenter un # certificat de scolarité. enf_primaire = enf_05 + nb_enf(age, smic55, P.ars.agep, P.ars.agec - 1) enf_college = nb_enf(age, smic55, P.ars.agec, P.ars.agel - 1) enf_lycee = nb_enf(age, smic55, P.ars.agel, P.ars.ages) arsnbenf = enf_primaire + enf_college + enf_lycee ars_plaf_res = P.ars.plaf * (1 + arsnbenf * P.ars.plaf_enf_supp) arsbase = bmaf * (P.ars.tx0610 * enf_primaire + P.ars.tx1114 * enf_college + P.ars.tx1518 * enf_lycee) # Forme de l'ARS en fonction des enfants a*n - (rev-plaf)/n ars = max_( 0, (ars_plaf_res + arsbase * arsnbenf - max_(br_pf, ars_plaf_res)) / max_(1, arsnbenf)) return ars * (ars >= P.ars.seuil_nv)
def _apje(br_pf, age, smic55, isol, biact, _P, _option={ 'age': ENFS, 'smic55': ENFS }): ''' Allocation pour jeune enfant ''' # TODO: APJE courte voir doc ERF 2006 P = _P.fam nbenf = nb_enf(age, smic55, 0, P.apje.age - 1) bmaf = P.af.bmaf bmaf_n_2 = P.af.bmaf_n_2 base = round(P.apje.taux * bmaf, 2) base2 = round(P.apje.taux * bmaf_n_2, 2) plaf_tx = (nbenf > 0) + P.apje.plaf_tx1 * min_( nbenf, 2) + P.apje.plaf_tx2 * max_(nbenf - 2, 0) majo = isol | biact plaf = P.apje.plaf * plaf_tx + P.apje.plaf_maj * majo plaf2 = plaf + 12 * base2 apje = (nbenf >= 1) * ((br_pf <= plaf) * base + (br_pf > plaf) * max_(plaf2 - br_pf, 0) / 12.0) # Non cummul APE APJE CF # - L’allocation parentale d’éducation (APE), sauf pour les femmes enceintes. # L’APJE est alors versée du 5ème mois de grossesse jusqu’à la naissance de l’enfant. # - Le CF return 12 * apje # annualisé
def function(individu, period, legislation): period = period.this_month chomage_brut = individu('chomage_brut', period) csg_imposable_chomage = individu('csg_imposable_chomage', period) taux_csg_remplacement = individu('taux_csg_remplacement', period) legislation = legislation(period.start) montant_csg = montant_csg_crds( base_avec_abattement=chomage_brut, indicatrice_taux_plein=(taux_csg_remplacement == 3), indicatrice_taux_reduit=(taux_csg_remplacement == 2), law_node=legislation.prelevements_sociaux.contributions.csg. chomage.deductible, plafond_securite_sociale=legislation.cotsoc.gen. plafond_securite_sociale, ) nbh_travail = 35 * 52 / 12 # = 151.67 # TODO: depuis 2001 mais avant ? cho_seuil_exo = ( legislation.prelevements_sociaux.contributions.csg.chomage.min_exo * nbh_travail * legislation.cotsoc.gen.smic_h_b) csg_deductible_chomage = max_( -montant_csg - max_( cho_seuil_exo - (chomage_brut + csg_imposable_chomage + montant_csg), 0), 0, ) return period, -csg_deductible_chomage
def function(self, simulation, period): period = period.this_month chomage_brut = simulation.calculate('chomage_brut', period) csg_deductible_chomage = simulation.calculate('csg_deductible_chomage', period) csg_imposable_chomage = simulation.calculate('csg_imposable_chomage', period) taux_csg_remplacement = simulation.calculate('taux_csg_remplacement', period) law = simulation.legislation_at(period.start) smic_h_b = law.cotsoc.gen.smic_h_b # salaire_mensuel_reference = chomage_brut / .7 # heures_mensuelles = min_(salaire_mensuel_reference / smic_h_b, 35 * 52 / 12) # TODO: depuis 2001 mais avant ? heures_mensuelles = 35 * 52 / 12 cho_seuil_exo = law.csg.chomage.min_exo * heures_mensuelles * smic_h_b montant_crds = montant_csg_crds( base_avec_abattement = chomage_brut, law_node = law.crds.activite, plafond_securite_sociale = law.cotsoc.gen.plafond_securite_sociale, ) * (2 <= taux_csg_remplacement) crds_chomage = max_( -montant_crds - max_( cho_seuil_exo - (chomage_brut + csg_imposable_chomage + csg_deductible_chomage + montant_crds), 0 ), 0 ) return period, -crds_chomage
def _aidper(marpac, nb_pac2, f7wf, f7wi, f7wj, f7wl, f7sf, f7si, _P): ''' Crédits d’impôt pour dépenses en faveur de l’aide aux personnes (cases 7WI, 7WJ, 7WL et 7SF). 2002- ''' P = _P.ir.credits_impot.aidper n = nb_pac2 if _P.datesim.year <= 2005: max0 = P.max * (1 + marpac) + P.pac1 * (n >= 1) + P.pac2 * ( n >= 2) + P.pac2 * (max_(n - 2, 0)) elif _P.datesim.year >= 2006: max0 = P.max * (1 + marpac) + P.pac1 * n if _P.datesim.year in (2002, 2003): return P.taux_wi * min_(f7wi, max0) # TODO: enfant en résidence altérnée elif _P.datesim.year <= 2009: max1 = max_(0, max0 - f7wj) return (P.taux_wj * min_(f7wj, max0) + P.taux_wi * min_(f7wi, max1)) elif _P.datesim.year == 2010: max1 = max_(0, max0 - f7wl) max2 = max_(0, max1 - f7sf) max3 = max_(0, max2 - f7wj) return (P.taux_wl * min_(f7wl, max0) + P.taux_sf * min_(f7sf, max1) + P.taux_wj * min_(f7wj, max2) + P.taux_wi * min_(f7si, max3)) else: return 0 * marpac # TODO 2011, 2012, 2013
def function(self, simulation, period): period = period.this_month rev_coll_holder = simulation.compute('rev_coll', period.n_2) rev_coll = self.sum_by_entity(rev_coll_holder) biact = simulation.calculate('biact', period) Pr = simulation.legislation_at(period.start).al.ressources br_pf_i_holder = simulation.compute('br_pf_i', period) br_pf_parents = self.sum_by_entity(br_pf_i_holder, roles = [CHEF, PART]) abattement_chomage_indemnise_holder = simulation.compute('aide_logement_abattement_chomage_indemnise', period) abattement_chomage_indemnise = self.sum_by_entity(abattement_chomage_indemnise_holder, roles = [CHEF, PART]) abattement_depart_retraite_holder = simulation.compute('aide_logement_abattement_depart_retraite', period) abattement_depart_retraite = self.sum_by_entity(abattement_depart_retraite_holder, roles = [CHEF, PART]) neutralisation_rsa = simulation.calculate('aide_logement_neutralisation_rsa', period) abattement_ressources_enfant = simulation.legislation_at(period.n_2.stop).minim.aspa.plaf_seul * 1.25 br_enfants = self.sum_by_entity( max_(0, br_pf_i_holder.array - abattement_ressources_enfant), roles = ENFS) ressources = ( br_pf_parents + br_enfants + rev_coll - (abattement_chomage_indemnise + abattement_depart_retraite + neutralisation_rsa) ) # Abattement forfaitaire pour double activité abattement_double_activite = biact * Pr.dar_1 # Arrondi aux 100 euros supérieurs result = max_(ressources - abattement_double_activite, 0) return period, result
def _plus_value_nette(plus_value_brute, dur_det_immo, _P): """ Calcul de la plus value immobilière nette """ # 40. ABATTEMENT POUR DUREE DE DETENTION # 41. NOMBRE D’ANNEES DE DETENTION AU-DELA DE LA 5EME ANNEE P = _P.irpp.pv_immo if P.datesim: # TODO: taux_reduc = max_(dur_det_immo - P.ann_det1, 0) * P.taux1 else: taux_reduc = ( max_(dur_det_immo - P.ann_det3, 0) * P.taux3 + max_(min_(dur_det_immo, P.ann_det3) - P.ann_det2, 0) * P.taux2 + max_(min_(dur_det_immo, P.ann_det2) - P.ann_det1, 0) * P.taux1) taux_reduc = min_(taux_reduc, 1.0) pv_impos = (1 - taux_reduc) * plus_value_brute # 45. MONTANT DE LA PLUS-VALUE BENEFICIANT, SOUS CONDITIONS, DE L’EXONERATION AU TITRE DE LA # PREMIERE CESSION D’UN LOGEMENT EN VUE DE L’ACQUISITION DE LA RESIDENCE PRINCIPALE # (CGI, 1° BIS DU II DE L’ARTICLE 150 U) TODO: exo = 0 pv_net_impos = max_( pv_impos - exo, 0 ) #46. PLUS-VALUE NETTE IMPOSABLE [LIGNE 44 OU (LIGNE 44 – LIGNE 45)] = € # 50. PLUS-VALUE NETTE IMPOSABLE GLOBALE = # (LIGNE 46 OU TOTAL DES LIGNES 46 SI PLUSIEURS 2048-IMM-SD PAGE 2) #Lorsqu’une même cession porte sur des biens pour lesquels sont prévues des règles différentes (acquisitions successives de fractions divises ou indivises notamment), #il convient de remplir les lignes 10 à 46 pour chacune des fractions (utiliser plusieurs 2048-IMM-SD page 2). return pv_net_impos
def _aspa_coexist_asi(asi_aspa_elig, maries, marpac, br_mv, _P): ''' Montant de l'ASPA quand une personne perçoit l'ASPA et l'autre l'ASI ''' P = _P.minim # Une personne peçoit l'ASI et l'autre l'ASPA # Les persones sont mariées index = asi_aspa_elig * maries montant_max = where( index, (.5 * P.asi.montant_couple + .5 * P.aspa.montant_couple), 0) ressources = where(index, br_mv + montant_max, 0) plafond_ressources = where(index, P.aspa.plaf_couple, 0) depassement = ressources - plafond_ressources montant_servi_aspa_m = where( index, max_(.5 * P.aspa.montant_couple - 0.5 * depassement, 0), 0) / 12 # Les deux persones ne sont pas mariées mais concubins ou pacsés index = asi_aspa_elig * (marpac & not_(maries)) montant_max = where(index, P.asi.montant_seul + .5 * P.aspa.montant_couple, 0) ressources = where(index, br_mv + montant_max, 0) plafond_ressources = where(index, P.aspa.plaf_couple, 0) depassement = ressources - plafond_ressources montant_servi_aspa_c = where( index, max_(.5 * P.aspa.montant_couple - 0.5 * depassement, 0), 0) / 12 return 12 * (montant_servi_aspa_m + montant_servi_aspa_c) # annualisé
def function(famille, period, legislation): period = period.this_month af_nbenf = famille('af_nbenf', period) af_forfaitaire_nbenf = famille('af_allocation_forfaitaire_nb_enfants', period) pfam = legislation(period).prestations.prestations_familiales.af nb_enf_tot = af_nbenf + af_forfaitaire_nbenf base_ressources = famille('prestations_familiales_base_ressources', period) af_allocation_forfaitaire = famille('af_allocation_forfaitaire', period) modulation = pfam.modulation plafond1 = modulation.plafond_tranche_1 + max_( af_nbenf - 2, 0) * modulation.majoration_plafond_par_enfant_supplementaire plafond2 = modulation.plafond_tranche_2 + max_( af_nbenf - 2, 0) * modulation.majoration_plafond_par_enfant_supplementaire depassement_plafond1 = max_(0, base_ressources - plafond1) depassement_plafond2 = max_(0, base_ressources - plafond2) depassement_mensuel = ( (depassement_plafond2 == 0) * depassement_plafond1 + (depassement_plafond2 > 0) * depassement_plafond2) / 12 return period, max_(0, af_allocation_forfaitaire - depassement_mensuel) * (depassement_mensuel > 0)
def _rev_cat_rvcm(marpac, deficit_rcm, f2ch, f2dc, f2ts, f2ca, f2fu, f2go, f2gr, f2tr, _P): ''' REVENUS DES VALEURS ET CAPITAUX MOBILIERS ''' P = _P.ir.rvcm if _P.datesim.year > 2004: f2gr = 0 ## Calcul du revenu catégoriel #1.2 Revenus des valeurs et capitaux mobiliers b12 = min_(f2ch, P.abat_assvie*(1 + marpac)) TOT1 = f2ch-b12 # Part des frais s'imputant sur les revenus déclarés case DC den = ((f2dc + f2ts)!=0)*(f2dc + f2ts) + ((f2dc + f2ts)==0) F1 = f2ca/den*f2dc # Revenus de capitaux mobiliers nets de frais, ouvrant droit à abattement # partie négative (à déduire des autres revenus nets de frais d'abattements g12a = - min_(f2dc*P.abatmob_taux - F1,0) # partie positive g12b = max_(f2dc*P.abatmob_taux - F1,0) rev = g12b + f2gr + f2fu*P.abatmob_taux # Abattements, limité au revenu h12 = P.abatmob*(1 + marpac) TOT2 = max_(0,rev - h12) i121= -min_(0,rev - h12) # Pars des frais s'imputant sur les revenus déclarés ligne TS F2 = f2ca - F1 TOT3 = (f2ts - F2) + f2go*P.majGO + f2tr - g12a DEF = deficit_rcm return max_(TOT1 + TOT2 + TOT3 - DEF, 0)
def function_2009__(self, simulation, period): period = period.start.offset('first-of', 'year').period('year') age_holder = simulation.compute('age', period) smic55_holder = simulation.compute('smic55', period) af_nbenf = simulation.calculate('af_nbenf', period) nb_par = simulation.calculate('nb_par', period) ass = simulation.calculate('ass', period) aer_holder = simulation.compute('aer', period) api = simulation.calculate('api', period) rsa = simulation.calculate('rsa', period) P = simulation.legislation_at(period.start).minim.aefa af = simulation.legislation_at(period.start).fam.af age = self.split_by_roles(age_holder, roles = ENFS) aer = self.sum_by_entity(aer_holder) smic55 = self.split_by_roles(smic55_holder, roles = ENFS) dummy_ass = ass > 0 dummy_aer = aer > 0 dummy_api = api > 0 dummy_rmi = rsa > 0 maj = 0 # TODO condition = (dummy_ass + dummy_aer + dummy_api + dummy_rmi > 0) if hasattr(af, "age3"): nbPAC = nb_enf(age, smic55, af.age1, af.age3) else: nbPAC = af_nbenf # TODO check nombre de PAC pour une famille aefa = condition * P.mon_seul * ( 1 + (nb_par == 2) * P.tx_2p + nbPAC * P.tx_supp * (nb_par <= 2) + nbPAC * P.tx_3pac * max_(nbPAC - 2, 0) ) aefa_maj = P.mon_seul * maj aefa = max_(aefa_maj, aefa) return period, aefa
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 _aefa(age, smic55, af_nbenf, nb_par, ass ,aer, api, rsa, _P, _option = {'age': ENFS, 'smic55': ENFS}): ''' Aide exceptionelle de fin d'année (prime de Noël) ''' # Insituée en 1998 # Apparaît sous le nom de complément de rmi dans les ERF P = _P dummy_ass = ass > 0 dummy_aer = aer > 0 dummy_api = api > 0 dummy_rmi = rsa > 0 # Le montant de l’aide mentionnée à l’article 1er versée aux bénéficiaires de l’allocation de solidarité # spécifique à taux majoré servie aux allocataires âgés de cinquante-cinq ans ou plus justifiant de vingt années # d’activité salariée, aux allocataires âgés de cinquante-sept ans et demi ou plus justifiant de dix années d’activité # salariée ainsi qu’aux allocataires justifiant d’au moins 160 trimestres validés dans les régimes d’assurance # vieillesse ou de périodes reconnues équivalentes est égal à maj = 0 # TODO condition = (dummy_ass+dummy_aer+dummy_api+dummy_rmi > 0) if hasattr(P.fam.af,"age3"): nbPAC = nb_enf(age, smic55, P.fam.af.age1,P.fam.af.age3) else: nbPAC = af_nbenf # TODO check nombre de PAC pour une famille P = _P.minim aefa = condition*P.aefa.mon_seul*(1 + (nb_par==2)*P.aefa.tx_2p + nbPAC*P.aefa.tx_supp*(nb_par<=2) + nbPAC*P.aefa.tx_3pac*max_(nbPAC-2,0)) if _P.datesim.year==2008: aefa += condition*P.aefa.forf2008 aefa_maj = P.aefa.mon_seul*maj aefa = max_(aefa_maj,aefa) return aefa
def _plus_values(f3vg, f3vh, f3vl, f3vm, f3vi, f3vf, f3vd, f3sd, f3si, f3sf, f3sa, rpns_pvce, _P): """ Taxation des plus value TODO: f3vt, 2013 f3Vg au barème / tout refaire """ P = _P.ir.plus_values # revenus taxés à un taux proportionnel rdp = max_(0, f3vg - f3vh) + f3vl + rpns_pvce + f3vm + f3vi + f3vf out = (P.pvce * rpns_pvce + P.taux1 * max_(0, f3vg - f3vh) + P.caprisque * f3vl + P.pea * f3vm + P.taux3 * f3vi + P.taux4 * f3vf) if _P.datesim.year >= 2008: # revenus taxés à un taux proportionnel rdp += f3vd out += P.taux1 * f3vd if _P.datesim.year == 2012: out = P.taux2 * f3vd + P.taux3 * f3vi + P.taux4 * f3vf + P.taux1 * max_(0, f3vg - f3vh) out = (P.taux2 * (f3vd + f3sd) + P.taux3 * (f3vi + f3si) + P.taux4 * (f3vf + f3sf) + P.taux1 * max_(0, f3vg - f3vh) + P.pvce * f3sa) # TODO: chek this rpns missing ? if _P.datesim.year > 2012: out = f3vg * 0 # TODO: completely undone return round(out)
def _apje(br_pf, age, smic55, isol, biact, _P, _option={'age': ENFS, 'smic55': ENFS}): ''' Allocation pour jeune enfant ''' # TODO: APJE courte voir doc ERF 2006 P = _P.fam nbenf = nb_enf(age, smic55, 0, P.apje.age - 1) bmaf = P.af.bmaf bmaf_n_2 = P.af.bmaf_n_2 base = round(P.apje.taux * bmaf, 2) base2 = round(P.apje.taux * bmaf_n_2, 2) plaf_tx = (nbenf > 0) + P.apje.plaf_tx1 * min_(nbenf, 2) + P.apje.plaf_tx2 * max_(nbenf - 2, 0) majo = isol | biact plaf = P.apje.plaf * plaf_tx + P.apje.plaf_maj * majo plaf2 = plaf + 12 * base2 apje = (nbenf >= 1) * ((br_pf <= plaf) * base + (br_pf > plaf) * max_(plaf2 - br_pf, 0) / 12.0) # Pour bénéficier de cette allocation, il faut que tous les enfants du foyer soient nés, adoptés, ou recueillis en vue d’une adoption avant le 1er janvier 2004, et qu’au moins l’un d’entre eux ait moins de 3 ans. # Cette allocation est verséE du 5ème mois de grossesse jusqu’au mois précédant le 3ème anniversaire de l’enfant. # Non cumul APE APJE CF # - L’allocation parentale d’éducation (APE), sauf pour les femmes enceintes. # L’APJE est alors versée du 5ème mois de grossesse jusqu’à la naissance de l’enfant. # - Le CF return 12*apje # annualisé
def function(self, simulation, period): period = period.this_month biactivite = simulation.calculate('biactivite', period) Pr = simulation.legislation_at(period.start).prestations.aides_logement.ressources base_ressources_holder = simulation.compute('prestations_familiales_base_ressources_individu', period) base_ressources_parents = self.sum_by_entity(base_ressources_holder, roles = [CHEF, PART]) abattement_chomage_indemnise_holder = simulation.compute('aide_logement_abattement_chomage_indemnise', period) abattement_chomage_indemnise = self.sum_by_entity(abattement_chomage_indemnise_holder, roles = [CHEF, PART]) abattement_depart_retraite_holder = simulation.compute('aide_logement_abattement_depart_retraite', period) abattement_depart_retraite = self.sum_by_entity(abattement_depart_retraite_holder, roles = [CHEF, PART]) neutralisation_rsa = simulation.calculate('aide_logement_neutralisation_rsa', period) abattement_ressources_enfant = simulation.legislation_at(period.n_2.stop).prestations.minima_sociaux.aspa.plafond_ressources_seul * 1.25 br_enfants = self.sum_by_entity( max_(0, base_ressources_holder.array - abattement_ressources_enfant), roles = ENFS) # Revenus du foyer fiscal rev_coll = simulation.famille.demandeur.foyer_fiscal('rev_coll', period.n_2) ressources = ( base_ressources_parents + br_enfants + rev_coll - (abattement_chomage_indemnise + abattement_depart_retraite + neutralisation_rsa) ) # Abattement forfaitaire pour double activité abattement_double_activite = biactivite * Pr.dar_1 # Arrondi aux 100 euros supérieurs result = max_(ressources - abattement_double_activite, 0) return period, result
def function(famille, period, legislation, mois_demande): period = period.this_month forfait_logement = famille('rsa_forfait_logement', mois_demande) ppa_majoree_eligibilite = famille('rsa_majore_eligibilite', mois_demande) elig = famille('ppa_eligibilite', period, extra_params = [mois_demande]) pente = legislation(mois_demande).prestations.minima_sociaux.ppa.pente mff_non_majore = famille( 'ppa_montant_forfaitaire_familial_non_majore', period, extra_params = [mois_demande]) mff_majore = famille( 'ppa_montant_forfaitaire_familial_majore', period, extra_params = [mois_demande]) montant_forfaitaire_familialise = where(ppa_majoree_eligibilite, mff_majore, mff_non_majore) ppa_base_ressources = famille('ppa_base_ressources', period, extra_params = [mois_demande]) ppa_revenu_activite = famille('ppa_revenu_activite', period, extra_params = [mois_demande]) bonification_i = famille.members('ppa_bonification', period, extra_params = [mois_demande]) bonification = famille.sum(bonification_i) ppa_montant_base = ( montant_forfaitaire_familialise + bonification + pente * ppa_revenu_activite - ppa_base_ressources - forfait_logement ) ppa_deduction = ( montant_forfaitaire_familialise - ppa_base_ressources - forfait_logement ) ppa_fictive = ppa_montant_base - max_(ppa_deduction, 0) ppa_fictive = max_(ppa_fictive, 0) return period, elig * ppa_fictive
def function(self, simulation, period): period = period.start.offset('first-of', 'month').period('month') apl = simulation.calculate('apl', period) als = simulation.calculate('als', period) alf = simulation.calculate('alf', period) return period, max_(max_(apl, als), alf)
def function(self, simulation, period): period = period.this_month apl = simulation.calculate('apl', period) als = simulation.calculate('als', period) alf = simulation.calculate('alf', period) return period, max_(max_(apl, als), alf)
def function__2008_(self, simulation, period): period = period.this_year af_nbenf = simulation.calculate('af_nbenf', period) nb_parents = simulation.calculate('nb_parents', period) ass = simulation.calculate_add('ass', period) aer_holder = simulation.compute('aer', period) api = simulation.calculate_add('api', period) rsa = simulation.calculate('rsa', period) P = simulation.legislation_at(period.start).prestations.minima_sociaux.aefa af = simulation.legislation_at(period.start).prestations.prestations_familiales.af aer = self.sum_by_entity(aer_holder) dummy_ass = ass > 0 dummy_aer = aer > 0 dummy_api = api > 0 dummy_rmi = rsa > 0 maj = 0 # TODO condition = (dummy_ass + dummy_aer + dummy_api + dummy_rmi > 0) if hasattr(af, "age3"): nbPAC = nb_enf(simulation.famille, period, af.age1, af.age3) else: nbPAC = af_nbenf # TODO check nombre de PAC pour une famille aefa = condition * P.mon_seul * ( 1 + (nb_parents == 2) * P.tx_2p + nbPAC * P.tx_supp * (nb_parents <= 2) + nbPAC * P.tx_3pac * max_(nbPAC - 2, 0) ) aefa_maj = P.mon_seul * maj aefa = max_(aefa_maj, aefa) return period, aefa
def function__2008_(famille, period, legislation): period = period.this_year af_nbenf = famille('af_nbenf', period) nb_parents = famille('nb_parents', period) ass = famille('ass', period, options=[ADD]) api = famille('api', period, options=[ADD]) rsa = famille('rsa', period) P = legislation(period).prestations.minima_sociaux.aefa af = legislation(period).prestations.prestations_familiales.af aer_i = famille.members('aer', period) aer = famille.sum(aer_i) dummy_ass = ass > 0 dummy_aer = aer > 0 dummy_api = api > 0 dummy_rmi = rsa > 0 maj = 0 # TODO condition = (dummy_ass + dummy_aer + dummy_api + dummy_rmi > 0) if hasattr(af, "age3"): nbPAC = nb_enf(famille, period, af.age1, af.age3) else: nbPAC = af_nbenf # TODO check nombre de PAC pour une famille aefa = condition * P.mon_seul * ( 1 + (nb_parents == 2) * P.tx_2p + nbPAC * P.tx_supp * (nb_parents <= 2) + nbPAC * P.tx_3pac * max_(nbPAC - 2, 0)) aefa_maj = P.mon_seul * maj aefa = max_(aefa_maj, aefa) return period, aefa
def _aged(age, smic55, br_pf, ape_taux_partiel, dep_trim, _P, _option={ 'age': ENFS, 'smic55': ENFS }): ''' Allocation garde d'enfant à domicile ''' # TODO: trimestrialiser # les deux conjoints actif et revenu min requis, jusqu'aux 6 ans de l'enfant né avant le 01/01/2004, emploi d'une garde A DOMICILE # cette allocation consiste en une prise en charge partielle des charges sociales inhérentes à l'emploi d'une personne à domicile. # Si vous avez au moins un enfant de moins de 3 ans gardé au domicile, 2 cas : # Revenus 2005 > 37 241 € : la CAF prend en charge 50% des charges sociales (plafonné à 1 106 € par trimestre), # Revenus 2005 < 37 341 € : la CAF prend en charge 75% des charges sociales (plafonné à 1 659 € par trimestre). # Si vous avez un enfant de plus de 3 ans gardé au domicile (1 seul cas, sans condition de ressources) : # la CAF prend en charge 50% des charges sociales (plafonné à 553 € par trimestre) P = _P.fam nbenf = nb_enf(age, smic55, 0, P.aged.age1 - 1) nbenf2 = nb_enf(age, smic55, 0, P.aged.age2 - 1) elig1 = (nbenf > 0) elig2 = not_(elig1) * (nbenf2 > 0) * ape_taux_partiel depenses = 4 * dep_trim # gérer les dépenses trimestrielles aged3 = elig1 * ( max_(P.aged.remb_plaf1 - P.aged.remb_taux1 * depenses, 0) * (br_pf > P.aged.revenus_plaf) + (br_pf <= P.aged.revenus_plaf) * max_(P.aged.remb_taux2 * depenses - P.aged.remb_plaf1, 0)) aged6 = elig2 * max_(P.aged.remb_taux2 * depenses - P.aged.remb_plaf2, 0) return 12 * (aged3 + aged6) # annualisé
def function_2005_07_01(self, simulation, period): period = period.this_month law = simulation.legislation_at(period.start).prestations garantie_ressources = law.minima_sociaux.caah.garantie_ressources aah_montant = law.minima_sociaux.aah.montant aah = simulation.calculate('aah', period) asi_eligibilite = simulation.calculate('asi_eligibilite', period) asi_holder = simulation.compute('asi', period) # montant asi de la famille asi = self.cast_from_entity_to_roles( asi_holder) # attribué à tous les membres de la famille benef_asi = (asi_eligibilite * (asi > 0)) al_holder = simulation.compute( 'aide_logement_montant', period) # montant allocs logement de la famille al = self.cast_from_entity_to_roles( al_holder) # attribué à tout individu membre de la famille elig_cpl = ((aah > 0) | (benef_asi > 0)) # TODO: & logement indépendant & inactif 12 derniers mois # & capa de travail < 5% & taux d'incapacité >= 80% compl_ress = elig_cpl * max_(garantie_ressources - aah_montant, 0) elig_mva = (al > 0) * ((aah > 0) | (benef_asi > 0)) # TODO: & logement indépendant & pas de revenus professionnels # propres & capa de travail < 5% & taux d'incapacité >= 80% mva = 0.0 * elig_mva # TODO: rentrer mva dans paramètres. mva (mensuelle) = 104,77 en 2015, était de 101,80 en 2006, et de 119,72 en 2007 return period, max_(compl_ress, mva)
def _ars(self, age_holder, af_nbenf, smic55_holder, br_pf, P = law.fam): ''' Allocation de rentrée scolaire brute de CRDS ''' # TODO: convention sur la mensualisation # On tient compte du fait qu'en cas de léger dépassement du plafond, une allocation dégressive # (appelée allocation différentielle), calculée en fonction des revenus, peut être versée. age = self.split_by_roles(age_holder, roles = ENFS) smic55 = self.split_by_roles(smic55_holder, roles = ENFS) bmaf = P.af.bmaf # On doit prendre l'âge en septembre enf_05 = nb_enf(age, smic55, P.ars.agep - 1, P.ars.agep - 1) # 5 ans et 6 ans avant le 31 décembre # enf_05 = 0 # Un enfant scolarisé qui n'a pas encore atteint l'âge de 6 ans # avant le 1er février 2012 peut donner droit à l'ARS à condition qu'il # soit inscrit à l'école primaire. Il faudra alors présenter un # certificat de scolarité. enf_primaire = enf_05 + nb_enf(age, smic55, P.ars.agep, P.ars.agec - 1) enf_college = nb_enf(age, smic55, P.ars.agec, P.ars.agel - 1) enf_lycee = nb_enf(age, smic55, P.ars.agel, P.ars.ages) arsnbenf = enf_primaire + enf_college + enf_lycee # Plafond en fonction du nb d'enfants A CHARGE (Cf. article R543) ars_plaf_res = P.ars.plaf * (1 + af_nbenf * P.ars.plaf_enf_supp) arsbase = bmaf * (P.ars.tx0610 * enf_primaire + P.ars.tx1114 * enf_college + P.ars.tx1518 * enf_lycee) # Forme de l'ARS en fonction des enfants a*n - (rev-plaf)/n # ars_diff = (ars_plaf_res + arsbase - br_pf) / arsnbenf ars = (arsnbenf > 0) * max_(0, arsbase - max_(0, (br_pf - ars_plaf_res) / max_(1, arsnbenf))) # Calcul net de crds : ars_net = (P.ars.enf0610 * enf_primaire + P.ars.enf1114 * enf_college + P.ars.enf1518 * enf_lycee) return ars * (ars >= P.ars.seuil_nv)
def attribution(self, assiette, getT = False): ''' renvoie un vecteur associant les bonnes valeurs de la variable (selon génération) ''' k = self.nb n = len(assiette) if not self._linear_taux_moy: assi = np.tile(assiette, (k, 1)).T seui = np.tile(np.hstack((self.seuils, np.inf)), (n, 1)) a = max_(min_(assi, seui[:, 1:]) - seui[:, :-1], 0) i = np.dot(self.taux, a.T) if getT: t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0)) return i, t else: return i else: if len(self.tauxM) == 1: i = assiette * self.tauxM[0] else: assi = np.tile(assiette, (k - 1, 1)).T seui = np.tile(np.hstack(self.seuils), (n, 1)) k = self.t_x().T a = (assi >= seui[:, :-1]) * (assi < seui[:, 1:]) A = np.dot(a, self.t_x().T) B = np.dot(a, np.array(self.seuils[1:])) C = np.dot(a, np.array(self.tauxM[:-1])) i = assiette * (A * (assiette - B) + C) + max_(assiette - self.seuils[-1], 0) * self.tauxM[-1] + (assiette >= self.seuils[-1]) * self.seuils[-1] * self.tauxM[-2] if getT: t = np.squeeze(max_(np.dot((a > 0), np.ones((k, 1))) - 1, 0)) return i, t else: return i
def _ars(age, smic55, br_pf, _P, _option={'age': ENFS, 'smic55': ENFS}): ''' Allocation de rentrée scolaire ''' # TODO: convention sur la mensualisation # On tient compte du fait qu'en cas de léger dépassement du plafond, une allocation dégressive # (appelée allocation différentielle), calculée en fonction des revenus, peut être versée. P = _P.fam bmaf = P.af.bmaf # On doit prendre l'âge en septembre enf_05 = nb_enf(age, smic55, P.ars.agep - 1, P.ars.agep - 1) # 6 ans avant le 31 décembre #enf_05 = 0 # Un enfant scolarisé qui n'a pas encore atteint l'âge de 6 ans # avant le 1er février 2012 peut donner droit à l'ARS à condition qu'il # soit inscrit à l'école primaire. Il faudra alors présenter un # certificat de scolarité. enf_primaire = enf_05 + nb_enf(age, smic55, P.ars.agep, P.ars.agec - 1) enf_college = nb_enf(age, smic55, P.ars.agec, P.ars.agel - 1) enf_lycee = nb_enf(age, smic55, P.ars.agel, P.ars.ages) arsnbenf = enf_primaire + enf_college + enf_lycee ars_plaf_res = P.ars.plaf * (1 + arsnbenf * P.ars.plaf_enf_supp) arsbase = bmaf * (P.ars.tx0610 * enf_primaire + P.ars.tx1114 * enf_college + P.ars.tx1518 * enf_lycee) # Forme de l'ARS en fonction des enfants a*n - (rev-plaf)/n ars = max_(0, (ars_plaf_res + arsbase * arsnbenf - max_(br_pf, ars_plaf_res)) / max_(1, arsnbenf)) return ars * (ars >= P.ars.seuil_nv)
def _isf_apres_plaf(tot_impot, revetproduits, isf_avant_plaf, _P): """ Impôt sur la fortune après plafonnement """ ## si ISF avant plafonnement n'excède pas seuil 1= la limitation du plafonnement ne joue pas ## ## si entre les deux seuils; l'allègement est limité au 1er seuil ## ## si ISF avant plafonnement est supérieur au 2nd seuil, l'allègement qui résulte du plafonnement est limité à 50% de l'ISF ## P = _P.isf.plaf # Plafonnement supprimé pour l'année 2012 if _P.datesim.year <= 2011: plafonnement = max_(tot_impot - revetproduits, 0) limitationplaf = ( (isf_avant_plaf <= P.seuil1) * plafonnement + (P.seuil1 <= isf_avant_plaf) * (isf_avant_plaf <= P.seuil2) * min_(plafonnement, P.seuil1) + (isf_avant_plaf >= P.seuil2) * min_(isf_avant_plaf * P.taux, plafonnement)) return max_(isf_avant_plaf - limitationplaf, 0) elif _P.datesim.year == 2012: return isf_avant_plaf else: plafond = max_(0, tot_impot - revetproduits) # case PU sur la déclaration d'impôt return max_(isf_avant_plaf - plafond, 0)
def function_2005_07_01(self, simulation, period): period = period.this_month law = simulation.legislation_at(period.start) grph = law.minim.caah.grph aah_montant = law.minim.aah.montant aah = simulation.calculate('aah', period) asi_eligibilite = simulation.calculate('asi_eligibilite', period) asi_holder = simulation.compute('asi', period) # montant asi de la famille asi = self.cast_from_entity_to_roles(asi_holder) # attribué à tous les membres de la famille benef_asi = (asi_eligibilite * (asi > 0)) al_holder = simulation.compute('aide_logement_montant', period) # montant allocs logement de la famille al = self.cast_from_entity_to_roles(al_holder) # attribué à tout individu membre de la famille elig_cpl = ((aah > 0) | (benef_asi > 0)) # TODO: & logement indépendant & inactif 12 derniers mois # & capa de travail < 5% & taux d'incapacité >= 80% compl_ress = elig_cpl * max_(grph - aah_montant, 0) elig_mva = (al > 0) * ((aah > 0) | (benef_asi > 0)) # TODO: & logement indépendant & pas de revenus professionnels # propres & capa de travail < 5% & taux d'incapacité >= 80% mva = 0.0 * elig_mva # TODO: rentrer mva dans paramètres. mva (mensuelle) = 104,77 en 2015, était de 101,80 en 2006, et de 119,72 en 2007 return period, max_(compl_ress, mva)
def _prcomp(f7wm, f7wn, f7wo, f7wp, _P): """ Prestations compensatoires 2002-2010 """ P = _P.ir.reductions_impots.prcomp div = (f7wo == 0) * 1 + f7wo # Pour éviter les divisions par zéro return ( (f7wm == 0) * ( (f7wn == f7wo) * P.taux * min_(f7wn, P.seuil) + (f7wn < f7wo) * (f7wo <= P.seuil) * P.taux * f7wn + max_(0, (f7wn < f7wo) * (f7wo > P.seuil) * P.taux * P.seuil * f7wn / div) + P.taux * f7wp ) + (f7wm != 0) * ( (f7wn == f7wm) * (f7wo <= P.seuil) * P.taux * f7wm + max_(0, (f7wn == f7wm) * (f7wo >= P.seuil) * P.taux * f7wm / div) + (f7wn > f7wm) * (f7wo <= P.seuil) * P.taux * f7wn + max_(0, (f7wn > f7wm) * (f7wo >= P.seuil) * P.taux * f7wn / div) ) + P.taux * f7wp )
def function(self, simulation, period): period = period.start.offset('first-of', 'year').period('year') frag_impo = simulation.calculate('frag_impo', period) nrag_impg = simulation.calculate('nrag_impg', period) nbic_impn = simulation.calculate('nbic_impn', period) nbic_imps = simulation.calculate('nbic_imps', period) nbic_defn = simulation.calculate('nbic_defn', period) nbic_defs = simulation.calculate('nbic_defs', period) nacc_impn = simulation.calculate('nacc_impn', period) nacc_meup = simulation.calculate('nacc_meup', period) nacc_defn = simulation.calculate('nacc_defn', period) nacc_defs = simulation.calculate('nacc_defs', period) nbnc_impo = simulation.calculate('nbnc_impo', period) nbnc_defi = simulation.calculate('nbnc_defi', period) P = simulation.legislation_at(period.start).ir.rpns nbic_timp = (nbic_impn + nbic_imps) - (nbic_defn + nbic_defs) # C revenus industriels et commerciaux non professionnels # (revenus accesoires du foyers en nomenclature INSEE) nacc_timp = max_(0, (nacc_impn + nacc_meup) - (nacc_defn + nacc_defs)) # régime de la déclaration contrôlée ne bénéficiant pas de l'abattement association agréée nbnc_timp = nbnc_impo - nbnc_defi # Totaux ntimp = nrag_impg + nbic_timp + nacc_timp + nbnc_timp return period, max_(0, P.cga_taux2 * (ntimp + frag_impo))
def _aidper(marpac, nb_pac2, f7wf, f7wi, f7wj, f7wl, f7sf, f7si, _P): ''' Crédits d’impôt pour dépenses en faveur de l’aide aux personnes (cases 7WI, 7WJ, 7WL et 7SF). 2002- ''' P = _P.ir.credits_impot.aidper n = nb_pac2 if _P.datesim.year <= 2005: max0 = P.max * (1 + marpac) + P.pac1 * (n >= 1) + P.pac2 * (n >= 2) + P.pac2 * (max_(n - 2, 0)) elif _P.datesim.year >= 2006: max0 = P.max * (1 + marpac) + P.pac1 * n if _P.datesim.year in (2002, 2003): return P.taux_wi * min_(f7wi, max0) # TODO: enfant en résidence altérnée elif _P.datesim.year <= 2009: max1 = max_(0, max0 - f7wj) return (P.taux_wj * min_(f7wj, max0) + P.taux_wi * min_(f7wi, max1)) elif _P.datesim.year == 2010: max1 = max_(0, max0 - f7wl) max2 = max_(0, max1 - f7sf) max3 = max_(0, max2 - f7wj) return (P.taux_wl * min_(f7wl, max0) + P.taux_sf * min_(f7sf, max1) + P.taux_wj * min_(f7wj, max2) + P.taux_wi * min_(f7si, max3)) else: return 0 * marpac # TODO 2011, 2012, 2013
def function_2009__(self, simulation, period): period = period.this_year age_holder = simulation.compute('age', period) smic55_holder = simulation.compute('smic55', period, accept_other_period = True) af_nbenf = simulation.calculate('af_nbenf', period) nb_par = simulation.calculate('nb_par', period) ass = simulation.calculate_add('ass', period) aer_holder = simulation.compute('aer', period) api = simulation.calculate_add('api', period) rsa = simulation.calculate_add('rsa', period) P = simulation.legislation_at(period.start).minim.aefa af = simulation.legislation_at(period.start).fam.af age = self.split_by_roles(age_holder, roles = ENFS) aer = self.sum_by_entity(aer_holder) smic55 = self.split_by_roles(smic55_holder, roles = ENFS) dummy_ass = ass > 0 dummy_aer = aer > 0 dummy_api = api > 0 dummy_rmi = rsa > 0 maj = 0 # TODO condition = (dummy_ass + dummy_aer + dummy_api + dummy_rmi > 0) if hasattr(af, "age3"): nbPAC = nb_enf(age, smic55, af.age1, af.age3) else: nbPAC = af_nbenf # TODO check nombre de PAC pour une famille aefa = condition * P.mon_seul * ( 1 + (nb_par == 2) * P.tx_2p + nbPAC * P.tx_supp * (nb_par <= 2) + nbPAC * P.tx_3pac * max_(nbPAC - 2, 0) ) aefa_maj = P.mon_seul * maj aefa = max_(aefa_maj, aefa) return period, aefa
def function(self, simulation, period, reference_period): period = period.this_month forfait_logement = simulation.calculate('rsa_forfait_logement', reference_period) ppa_majoree_eligibilite = simulation.calculate('rsa_majore_eligibilite', reference_period) elig = simulation.calculate('ppa_eligibilite', period) pente = simulation.legislation_at(period.start).minim.ppa.pente mff_non_majore = simulation.calculate('ppa_montant_forfaitaire_familial_non_majore', period) mff_majore = simulation.calculate('ppa_montant_forfaitaire_familial_majore', period) montant_forfaitaire_familialise = where(ppa_majoree_eligibilite, mff_majore, mff_non_majore) ppa_base_ressources = simulation.calculate('ppa_base_ressources', period, extra_params = [reference_period]) ppa_revenu_activite = simulation.calculate('ppa_revenu_activite', period) bonification_individus = simulation.compute('ppa_bonification', period) bonification = self.sum_by_entity(bonification_individus) ppa_montant_base = ( montant_forfaitaire_familialise + bonification + pente * ppa_revenu_activite - ppa_base_ressources - forfait_logement ) ppa_deduction = ( montant_forfaitaire_familialise - ppa_base_ressources - forfait_logement ) ppa_fictive = ppa_montant_base - max_(ppa_deduction,0) ppa_fictive = max_(ppa_fictive, 0) return period, elig * ppa_fictive
def _plus_value_nette(period, plus_value_brute, dur_det_immo, pv_immo = law.ir.pv_immo): """ Calcul de la plus value immobilière nette """ # 40. ABATTEMENT POUR DUREE DE DETENTION # 41. NOMBRE D’ANNEES DE DETENTION AU-DELA DE LA 5EME ANNEE if period.start: # TODO: taux_reduc = max_(dur_det_immo - pv_immo.ann_det1, 0) * pv_immo.taux1 else: taux_reduc = (max_(dur_det_immo - pv_immo.ann_det3, 0) * pv_immo.taux3 + max_(min_(dur_det_immo, pv_immo.ann_det3) - pv_immo.ann_det2, 0) * pv_immo.taux2 + max_(min_(dur_det_immo, pv_immo.ann_det2) - pv_immo.ann_det1, 0) * pv_immo.taux1) taux_reduc = min_(taux_reduc, 1.0) pv_impos = (1 - taux_reduc) * plus_value_brute # 45. MONTANT DE LA PLUS-VALUE BENEFICIANT, SOUS CONDITIONS, DE L’EXONERATION AU TITRE DE LA # PREMIERE CESSION D’UN LOGEMENT EN VUE DE L’ACQUISITION DE LA RESIDENCE PRINCIPALE # (CGI, 1° BIS DU II DE L’ARTICLE 150 U) TODO: exo = 0 pv_net_impos = max_(pv_impos - exo, 0) # 46. PLUS-VALUE NETTE IMPOSABLE [LIGNE 44 OU (LIGNE 44 – LIGNE 45)] = € # 50. PLUS-VALUE NETTE IMPOSABLE GLOBALE = # (LIGNE 46 OU TOTAL DES LIGNES 46 SI PLUSIEURS 2048-IMM-SD PAGE 2) # Lorsqu’une même cession porte sur des biens pour lesquels sont prévues des règles différentes (acquisitions # successives de fractions divises ou indivises notamment), il convient de remplir les lignes 10 à 46 pour chacune # des fractions (utiliser plusieurs 2048-IMM-SD page 2). return pv_net_impos
def _cf(age, br_pf, isol, biact, smic55, _P, _option={'age': ENFS, 'smic55': ENFS}): """ Complément familial Vous avez au moins 3 enfants à charge tous âgés de plus de 3 ans. Vos ressources ne dépassent pas certaines limites. Vous avez peut-être droit au Complément Familial à partir du mois suivant les 3 ans du 3ème, 4ème, etc. enfant. # TODO: # En théorie, il faut comparer les revenus de l'année n-2 à la bmaf de # l'année n-2 pour déterminer l'éligibilité avec le cf_seuil. Il faudrait # pouvoir déflater les revenus de l'année courante pour en tenir compte. """ P = _P.fam bmaf = P.af.bmaf bmaf2 = P.af.bmaf_n_2 cf_nbenf = nb_enf(age, smic55, P.cf.age1, P.cf.age2) cf_base_n_2 = P.cf.tx * bmaf2 cf_base = P.cf.tx * bmaf cf_plaf_tx = 1 + P.cf.plaf_tx1 * min_(cf_nbenf, 2) + P.cf.plaf_tx2 * max_(cf_nbenf - 2, 0) cf_majo = isol | biact cf_plaf = P.cf.plaf * cf_plaf_tx + P.cf.plaf_maj * cf_majo cf_plaf2 = cf_plaf + 12 * cf_base_n_2 cf = (cf_nbenf >= 3) * ((br_pf <= cf_plaf) * cf_base + (br_pf > cf_plaf) * max_(cf_plaf2 - br_pf, 0) / 12.0) return 12 * cf
def _aged(self, age_holder, smic55_holder, br_pf, ape_taux_partiel, dep_trim, P = law.fam): ''' Allocation garde d'enfant à domicile les deux conjoints actif et revenu min requis, jusqu'aux 6 ans de l'enfant né avant le 01/01/2004, emploi d'une garde A DOMICILE cette allocation consiste en une prise en charge partielle des charges sociales inhérentes à l'emploi d'une personne à domicile. Si vous avez au moins un enfant de moins de 3 ans gardé au domicile, 2 cas : Revenus 2005 > 37 241 € : la CAF prend en charge 50% des charges sociales (plafonné à 1 106 € par trimestre), Revenus 2005 < 37 341 € : la CAF prend en charge 75% des charges sociales (plafonné à 1 659 € par trimestre). Si vous avez un enfant de plus de 3 ans gardé au domicile (1 seul cas, sans condition de ressources) : la CAF prend en charge 50% des charges sociales (plafonné à 553 € par trimestre) ''' # TODO: trimestrialiser age = self.split_by_roles(age_holder, roles = ENFS) smic55 = self.split_by_roles(smic55_holder, roles = ENFS) nbenf = nb_enf(age, smic55, 0, P.aged.age1 - 1) nbenf2 = nb_enf(age, smic55, 0, P.aged.age2 - 1) elig1 = (nbenf > 0) elig2 = not_(elig1) * (nbenf2 > 0) * ape_taux_partiel depenses = 4 * dep_trim # gérer les dépenses trimestrielles aged3 = elig1 * (max_(P.aged.remb_plaf1 - P.aged.remb_taux1 * depenses, 0) * (br_pf > P.aged.revenus_plaf) + (br_pf <= P.aged.revenus_plaf) * max_(P.aged.remb_taux2 * depenses - P.aged.remb_plaf1, 0)) aged6 = elig2 * max_(P.aged.remb_taux2 * depenses - P.aged.remb_plaf2, 0) return 12 * (aged3 + aged6) # annualisé
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 function(self, simulation, period): period = period.start.period(u'month').offset('first-of') type_sal = simulation.calculate('type_sal', period) traitement_indiciaire_brut = simulation.calculate('traitement_indiciaire_brut', period) af_nbenf_holder = simulation.compute('af_nbenf', period) _P = simulation.legislation_at(period.start) fonc_nbenf = self.cast_from_entity_to_role(af_nbenf_holder, role = CHEF) P = _P.fonc.supp_fam part_fixe_1 = P.fixe.enf1 part_fixe_2 = P.fixe.enf2 part_fixe_supp = P.fixe.enfsupp part_fixe = ( part_fixe_1 * (fonc_nbenf == 1) + part_fixe_2 * (fonc_nbenf == 2) + part_fixe_supp * max_(0, fonc_nbenf - 2) ) # pct_variable_1 = 0 pct_variable_2 = P.prop.enf2 pct_variable_3 = P.prop.enf3 pct_variable_supp = P.prop.enfsupp pct_variable = ( pct_variable_2 * (fonc_nbenf == 2) + (pct_variable_3) * (fonc_nbenf == 3) + pct_variable_supp * max_(0, fonc_nbenf - 3)) indice_maj_min = P.IM_min indice_maj_max = P.IM_max traitement_brut_mensuel_min = _traitement_brut_mensuel(indice_maj_min, _P) plancher_mensuel_1 = part_fixe plancher_mensuel_2 = part_fixe + traitement_brut_mensuel_min * pct_variable_2 plancher_mensuel_3 = part_fixe + traitement_brut_mensuel_min * pct_variable_3 plancher_mensuel_supp = traitement_brut_mensuel_min * pct_variable_supp plancher = (plancher_mensuel_1 * (fonc_nbenf == 1) + plancher_mensuel_2 * (fonc_nbenf == 2) + plancher_mensuel_3 * (fonc_nbenf >= 3) + plancher_mensuel_supp * max_(0, fonc_nbenf - 3)) traitement_brut_mensuel_max = _traitement_brut_mensuel(indice_maj_max, _P) plafond_mensuel_1 = part_fixe plafond_mensuel_2 = part_fixe + traitement_brut_mensuel_max * pct_variable_2 plafond_mensuel_3 = part_fixe + traitement_brut_mensuel_max * pct_variable_3 plafond_mensuel_supp = traitement_brut_mensuel_max * pct_variable_supp plafond = (plafond_mensuel_1 * (fonc_nbenf == 1) + plafond_mensuel_2 * (fonc_nbenf == 2) + plafond_mensuel_3 * (fonc_nbenf == 3) + plafond_mensuel_supp * max_(0, fonc_nbenf - 3)) sft = min_(max_(part_fixe + pct_variable * traitement_indiciaire_brut, plancher), plafond) * (type_sal >= 2) # Nota Bene: # type_sal is an EnumCol which enum is: # CAT = Enum(['prive_non_cadre', # 'prive_cadre', # 'public_titulaire_etat', # 'public_titulaire_militaire', # 'public_titulaire_territoriale', # 'public_titulaire_hospitaliere', # 'public_non_titulaire']) return period, sft
def _salcho_imp(rev_sal, cho_ld, fra, abatpro = law.ir.tspr.abatpro): """ Salaires après abattements 'ind' """ amin = abatpro.min * not_(cho_ld) + abatpro.min2 * cho_ld abatfor = round(min_(max_(abatpro.taux * rev_sal, amin), abatpro.max)) return (fra > abatfor) * (rev_sal - fra) + (fra <= abatfor) * max_(0, rev_sal - abatfor)
def function(famille, period): period = period.this_month rsa = famille('rsa', period, period) rsa_base_ressources = famille('rsa_base_ressources', period) rsa_socle = famille('rsa_socle', period) rsa_forfait_logement = famille('rsa_forfait_logement', period) rmi = max_(0, rsa_socle - rsa_forfait_logement - rsa_base_ressources) return period, max_(rsa - rmi, 0)
def _salcho_imp(rev_sal, cho_ld, fra, _P): """ Salaires après abattements 'ind' """ P = _P.ir.tspr.abatpro amin = P.min * not_(cho_ld) + P.min2 * cho_ld abatfor = round(min_(max_(P.taux * rev_sal, amin), P.max)) return (fra > abatfor) * (rev_sal - fra) + (fra <= abatfor) * max_(0, rev_sal - abatfor)
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 _ppe_elig(rfr, ppe_coef, ppe_rev, marpac, veuf, celdiv, nbptr, ppe = law.ir.credits_impot.ppe): ''' PPE: eligibilité à la ppe, condition sur le revenu fiscal de référence 'foy' CF ligne 1: http://bofip.impots.gouv.fr/bofip/3913-PGP.html ''' seuil = (veuf | celdiv) * (ppe.eligi1 + 2 * max_(nbptr - 1, 0) * ppe.eligi3) \ + marpac * (ppe.eligi2 + 2 * max_(nbptr - 2, 0) * ppe.eligi3) return (rfr * ppe_coef) <= seuil
def _supp_familial_traitement(type_sal, salbrut, af_nbenf, _P): ''' Supplément familial de traitement Attention : par hypothèse ne peut êre attribué qu'à la tête du ménage TODO: gérer le cas encore problématique du conjoint fonctionnaire ''' # TODO: un seul sft par couple où est présent un fonctionnaire fonc_nbenf = af_nbenf P = _P.fonc.supp_fam part_fixe_1 = P.fixe.enf1 part_fixe_2 = P.fixe.enf2 part_fixe_supp = P.fixe.enfsupp part_fixe = (part_fixe_1 * (fonc_nbenf == 1) + part_fixe_2 * (fonc_nbenf == 2) + part_fixe_supp * max_(0, fonc_nbenf - 2)) # pct_variable_1 = 0 pct_variable_2 = P.prop.enf2 pct_variable_3 = P.prop.enf3 pct_variable_supp = P.prop.enfsupp pct_variable = (pct_variable_2 * (fonc_nbenf == 2) + (pct_variable_3) * (fonc_nbenf == 3) + pct_variable_supp * max_(0, fonc_nbenf - 3)) indice_maj_min = P.IM_min indice_maj_max = P.IM_max plancher_mensuel_1 = part_fixe plancher_mensuel_2 = part_fixe + _traitement_brut_mensuel(indice_maj_min, _P) * pct_variable_2 plancher_mensuel_3 = part_fixe + _traitement_brut_mensuel(indice_maj_min, _P) * pct_variable_3 plancher_mensuel_supp = _traitement_brut_mensuel(indice_maj_min, _P) * pct_variable_supp plancher = (plancher_mensuel_1 * (fonc_nbenf == 1) + plancher_mensuel_2 * (fonc_nbenf == 2) + plancher_mensuel_3 * (fonc_nbenf >= 3) + plancher_mensuel_supp * max_(0, fonc_nbenf - 3)) plafond_mensuel_1 = part_fixe plafond_mensuel_2 = part_fixe + _traitement_brut_mensuel(indice_maj_max, _P) * pct_variable_2 plafond_mensuel_3 = part_fixe + _traitement_brut_mensuel(indice_maj_max, _P) * pct_variable_3 plafond_mensuel_supp = _traitement_brut_mensuel(indice_maj_max, _P) * pct_variable_supp plafond = (plafond_mensuel_1 * (fonc_nbenf == 1) + plafond_mensuel_2 * (fonc_nbenf == 2) + plafond_mensuel_3 * (fonc_nbenf == 3) + plafond_mensuel_supp * max_(0, fonc_nbenf - 3)) sft = min_(max_(part_fixe + pct_variable * salbrut / 12, plancher), plafond) * (type_sal >= 2) # Nota Bene: # type_sal is an EnumCol which enum is: # CAT = Enum(['prive_non_cadre', # 'prive_cadre', # 'public_titulaire_etat', # 'public_titulaire_militaire', # 'public_titulaire_territoriale', # 'public_titulaire_hospitaliere', # 'public_non_titulaire']) return 12 * sft
def function(self, simulation, period): period = period.this_month mois_precedent = period.offset(-1) last_day_reference_year = period.n_2.stop base_ressources_defaut = simulation.calculate( 'aide_logement_base_ressources_defaut', period) base_ressources_eval_forfaitaire = simulation.calculate( 'aide_logement_base_ressources_eval_forfaitaire', period) en_couple = simulation.calculate('en_couple', period) aah_holder = simulation.compute('aah', mois_precedent) aah = self.sum_by_entity(aah_holder, roles=[CHEF, PART]) age_holder = simulation.compute('age', period) age = self.split_by_roles(age_holder, roles=[CHEF, PART]) smic_horaire_brut_n2 = simulation.legislation_at( last_day_reference_year).cotsoc.gen.smic_h_b salaire_imposable_holder = simulation.compute('salaire_imposable', period.offset(-1)) somme_salaires = self.sum_by_entity(salaire_imposable_holder, roles=[CHEF, PART]) plafond_eval_forfaitaire = 1015 * smic_horaire_brut_n2 plafond_salaire_jeune_isole = simulation.legislation_at( period.start).prestations.aides_logement.ressources.dar_8 plafond_salaire_jeune_couple = simulation.legislation_at( period.start).prestations.aides_logement.ressources.dar_9 plafond_salaire_jeune = where(en_couple, plafond_salaire_jeune_couple, plafond_salaire_jeune_isole) neutral_jeune = or_(age[CHEF] < 25, and_(en_couple, age[PART] < 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 = simulation.legislation_at( period.start).prestations.aides_logement.ressources etudiant_holder = simulation.compute('etudiant', period) boursier_holder = simulation.compute('boursier', period) etudiant = self.split_by_roles(etudiant_holder, roles=[CHEF, PART]) boursier = self.split_by_roles(boursier_holder, roles=[CHEF, PART]) montant_plancher_ressources = max_( 0, etudiant[CHEF] * Pr.dar_4 - boursier[CHEF] * Pr.dar_5) ressources = max_(ressources, montant_plancher_ressources) # Arrondi aux 100 euros supérieurs ressources = ceil(ressources / 100) * 100 return period, ressources