def _salbrut_from_salnet(salnet, hsup, type_sal, _defaultP):
'''
Calcule le salaire brut à partir du salaire net
Renvoie 0 sauf pour les salariés non cadres, cadres (TODO: et les contractuels de la fonction publique ?)
'''
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
salarie = scaleBaremes(BaremeDict('sal', _defaultP.cotsoc.sal), plaf_ss)
csg_deduc = scaleBaremes(_defaultP.csg.act.deduc, plaf_ss)
csg_impos = scaleBaremes(_defaultP.csg.act.deduc, plaf_ss)
crds = scaleBaremes(_defaultP.crds.act, plaf_ss)
salarie['noncadre'].update(salarie['commun'])
salarie['cadre'].update(salarie['commun'])
# Salariés du privé
prive_non_cadre = combineBaremes(salarie['noncadre'])
prive_cadre = combineBaremes(salarie['cadre'])
# On ajoute la CSG deductible et imposable
for bareme in [prive_non_cadre, prive_cadre]:
bareme.addBareme(csg_deduc)
bareme.addBareme(csg_impos)
bareme.addBareme(crds)
inversed_bareme = {'prive_non_cadre': prive_non_cadre.inverse(),
'prive_cadre' : prive_cadre.inverse()}
salbrut = zeros(len(salnet))
for category in ['prive_non_cadre', 'prive_cadre']:
salbrut += inversed_bareme[category].calc(salnet) * (type_sal == CAT[category])
return salbrut + hsup
def _salbrut_from_salnet(salnet, hsup, type_sal, _defaultP):
'''
Calcule le salaire brut à partir du salaire net
Renvoie 0 sauf pour les salariés non cadres, cadres (TODO: et les contractuels de la fonction publique ?)
'''
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
salarie = scaleBaremes(BaremeDict('sal', _defaultP.cotsoc.sal), plaf_ss)
csg = scaleBaremes(BaremeDict('csg', _defaultP.csg), plaf_ss)
crds = scaleBaremes(BaremeDict('crds', _defaultP.crds), plaf_ss)
salarie['noncadre'].update(salarie['commun'])
salarie['cadre'].update(salarie['commun'])
# Salariés du privé
prive_non_cadre = combineBaremes(salarie['noncadre'])
prive_cadre = combineBaremes(salarie['cadre'])
# On ajoute la CSG deductible et imposable
for bareme in [prive_non_cadre, prive_cadre]:
bareme.addBareme(csg['act']['deduc'])
bareme.addBareme(csg['act']['impos'])
bareme.addBareme(crds['act'])
inversed_bareme = {
'prive_non_cadre': prive_non_cadre.inverse(),
'prive_cadre': prive_cadre.inverse()
}
salbrut = zeros(len(salnet))
for category in ['prive_non_cadre', 'prive_cadre']:
salbrut += inversed_bareme[category].calc(salnet) * (type_sal
== CAT[category])
return salbrut + hsup
def _csgsali(salbrut, hsup, _P):
'''
CSG imposable sur les salaires
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(_P.csg.act.impos, plaf_ss)
return -csg.calc(salbrut - hsup)
def _csgsald(salbrut, hsup, _P):
'''
CSG deductible sur les salaires
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(_P.csg.act.deduc, plaf_ss)
return -csg.calc(salbrut - hsup)
def _crdssal(salbrut, hsup, _P):
'''
CRDS sur les salaires
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
crds = scaleBaremes(_P.crds.act, plaf_ss)
return -crds.calc(salbrut - hsup)
def _csgsali(salbrut, hsup, primes, indemnite_residence, supp_familial_traitement, _P):
'''
CSG imposable sur les salaires
'''
plaf_ss = _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(_P.csg.act.impos, plaf_ss)
return -12 * csg.calc((salbrut + primes + indemnite_residence + supp_familial_traitement - hsup) / 12)
def _csgsali(salbrut, hsup, primes, indemnite_residence, supp_familial_traitement, _P):
'''
CSG imposable sur les salaires
'''
plaf_ss = _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(_P.csg.act.impos, plaf_ss)
return -12 * csg.calc((salbrut + primes + indemnite_residence + supp_familial_traitement - hsup) / 12)
def _crdsrst(rstbrut, _P):
'''
CRDS sur les pensions
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
crds = scaleBaremes(BaremeDict('crds', _P.crds.rst), plaf_ss)
return -crds['rst'].calc(rstbrut)
def _crdsrst(rstbrut, _P):
'''
CRDS sur les pensions
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
crds = scaleBaremes(BaremeDict('crds', _P.crds.rst), plaf_ss)
return -crds['rst'].calc(rstbrut)
def _csgsald(salbrut, primes, indemnite_residence, hsup, _P):
'''
CSG deductible sur les salaires
'''
plaf_ss = _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(_P.csg.act.deduc, plaf_ss)
return -12 * csg.calc((salbrut + primes + indemnite_residence - hsup) / 12)
def _csgsali(salbrut, hsup, _P):
'''
CSG imposable sur les salaires
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(_P.csg.act.impos, plaf_ss)
return -csg.calc(salbrut - hsup)
def _crdssal(salbrut, hsup, primes, indemnite_residence, supp_familial_traitement, _P):
'''
CRDS sur les salaires
'''
plaf_ss = _P.cotsoc.gen.plaf_ss
crds = scaleBaremes(_P.crds.act, plaf_ss)
return -12 * crds.calc((salbrut - hsup + primes + indemnite_residence + supp_familial_traitement) / 12)
def _crdssal(salbrut, hsup, _P):
'''
CRDS sur les salaires
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
crds = scaleBaremes(_P.crds.act, plaf_ss)
return -crds.calc(salbrut - hsup)
def _chobrut(choi, csg_rempl, _defaultP):
"""
Calcule les allocations chômage brute à partir des allocations imposables
"""
# TODO: ajouter la crds ? Malka Louise
P = _defaultP.csg.chom
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict("csg", P), plaf_ss)
taux_plein = csg["plein"]
taux_reduit = csg["reduit"]
chom_plein = taux_plein.inverse()
chom_reduit = taux_reduit.inverse()
# log.info(chom_plein)
# log.info(chom_reduit)
chobrut = (
(csg_rempl == 1) * choi + (csg_rempl == 2) * chom_reduit.calc(choi) + (csg_rempl == 3) * chom_plein.calc(choi)
)
# isexo = exo_csg_chom(choi, _defaultP)
# chobrut = not_(isexo)*chobrut + (isexo)*choi
# print P.plein.impos, P.plein.deduc
# print "taux réduit : "
# print P.reduit.impos, P.reduit.deduc
return chobrut
def crdscho_sans_exo(chobrut, csg_rempl, _P):
'''
CRDS sur les allocations chômage sans exo
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
crds = scaleBaremes(_P.crds.act, plaf_ss)
return -crds.calc(chobrut) * (2 <= csg_rempl)
def crdscho_sans_exo(chobrut, csg_rempl, _P):
'''
CRDS sur les allocations chômage sans exo
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
crds = scaleBaremes(_P.crds.act, plaf_ss)
return -crds.calc(chobrut) * (2 <= csg_rempl)
def _crdssal(salbrut, hsup, primes, indemnite_residence, supp_familial_traitement, _P):
'''
CRDS sur les salaires
'''
plaf_ss = _P.cotsoc.gen.plaf_ss
crds = scaleBaremes(_P.crds.act, plaf_ss)
return -12 * crds.calc((salbrut - hsup + primes + indemnite_residence + supp_familial_traitement) / 12)
def _csgsald(salbrut, hsup, _P):
'''
CSG deductible sur les salaires
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(_P.csg.act.deduc, plaf_ss)
return -csg.calc(salbrut - hsup)
def crdscho_sans_exo(chobrut, csg_rempl, _P):
'''
CRDS sur les allocations chômage sans exo
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
crds = scaleBaremes(_P.crds.act, plaf_ss) # TODO: Assiette crds éq pour les salariés et les chômeurs en 2014 mais check before
return -crds.calc(chobrut) * (2 <= csg_rempl)
def _rstbrut_from_rstnet(rstnet, csg_rempl, _defaultP):
'''
Calcule les pensions de retraites brutes à partir des pensions nettes
'''
P = _defaultP.csg.retraite
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict('csg', P), plaf_ss)
crds = scaleBaremes(BaremeDict('crds', _defaultP.crds), plaf_ss)
# TODO: rajouter la non déductible dans param
taux_plein = combineBaremes(csg['plein'])
taux_reduit = combineBaremes(csg['reduit'])
taux_plein.addBareme(crds)
taux_reduit.addBareme(crds)
rst_plein = taux_plein.inverse()
rst_reduit = taux_reduit.inverse()
rstbrut = (csg_rempl == 2) * rst_reduit.calc(rstnet) + (csg_rempl == 3) * rst_plein.calc(rstnet)
return rstbrut
def _crdsrst(rstbrut, csg_rempl, _P):
'''
CRDS sur les pensions
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
crds = scaleBaremes(BaremeDict('crds', _P.crds.rst), plaf_ss)
isexo = (csg_rempl == 1)
return -crds['rst'].calc(rstbrut) * not_(isexo)
def _crdsrst(rstbrut, csg_rempl, _P):
'''
CRDS sur les pensions
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
crds = scaleBaremes(BaremeDict('crds', _P.crds.rst), plaf_ss)
isexo = (csg_rempl == 1)
return -crds['rst'].calc(rstbrut) * not_(isexo)
def _crdsrst(rstbrut, csg_rempl, _P):
"""
CRDS sur les pensions
"""
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
crds = scaleBaremes(BaremeDict("crds", _P.crds.rst), plaf_ss)
isexo = csg_rempl == 1
return -crds["rst"].calc(rstbrut) * not_(isexo)
def _salbrut(sali, hsup, type_sal, _defaultP):
# indemnite_residence, sup_familial
'''
Calcule le salaire brut à partir du salaire imposable
sauf pour les fonctionnaires où il renvoie le tratement indiciaire brut
Note : le supplément familial de traitement est imposable
'''
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
salarie = scaleBaremes(BaremeDict('sal', _defaultP.cotsoc.sal), plaf_ss)
csg = scaleBaremes(BaremeDict('csg', _defaultP.csg), plaf_ss)
salarie['noncadre'].update(salarie['commun'])
salarie['cadre'].update(salarie['commun'])
noncadre = combineBaremes(salarie['noncadre'])
cadre = combineBaremes(salarie['cadre'])
public_etat = combineBaremes(salarie['fonc']["etat"])
public_colloc = combineBaremes(salarie['fonc']["colloc"])
# On ajoute la CSG deductible
noncadre.addBareme(csg['act']['deduc'])
cadre.addBareme(csg['act']['deduc'])
public_etat.addBareme(csg['act']['deduc'])
nca = noncadre.inverse()
cad = cadre.inverse()
etat = public_etat.inverse()
# TODO: complete this to deal with the fonctionnaire
brut_nca = nca.calc(sali)
brut_cad = cad.calc(sali)
brut_etat = etat.calc(sali)
salbrut = brut_nca * (type_sal == CAT['prive_non_cadre'])
salbrut += brut_cad * (type_sal == CAT['prive_cadre'])
supp_familial_traitement = 0 # TODO: dépend de salbrut
indemnite_residence = 0 # TODO: fix bug
prime = 0
salbrut += (brut_etat * (type_sal == CAT['public_titulaire_etat']) -
prime - supp_familial_traitement - indemnite_residence
) # TODO: fonctionnaire
return salbrut + hsup
def _rstbrut_from_rstnet(rstnet, csg_rempl, _defaultP):
'''
Calcule les pensions de retraites brutes à partir des pensions nettes
'''
P = _defaultP.csg.retraite
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict('csg', P), plaf_ss)
crds = scaleBaremes(BaremeDict('crds', _defaultP.crds), plaf_ss)
# TODO: rajouter la non déductible dans param
taux_plein = combineBaremes(csg['plein'])
taux_reduit = combineBaremes(csg['reduit'])
taux_plein.addBareme(crds)
taux_reduit.addBareme(crds)
rst_plein = taux_plein.inverse()
rst_reduit = taux_reduit.inverse()
rstbrut = (csg_rempl == 2) * rst_reduit.calc(rstnet) + (
csg_rempl == 3) * rst_plein.calc(rstnet)
return rstbrut
def _cot_sal_pension_civile(salbrut, type_sal, _P):
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
sal = scaleBaremes(BaremeDict('sal', _P.cotsoc.sal), plaf_ss)
terr_or_hosp = (type_sal == CAT['public_titulaire_territoriale']) + (type_sal == CAT['public_titulaire_hospitaliere'])
cot_sal_pension_civile = (
(type_sal == CAT['public_titulaire_etat']) * sal['fonc']['etat']['pension'].calc(salbrut)
+ terr_or_hosp * sal['fonc']['colloc']['cnracl1'].calc(salbrut)
)
return -cot_sal_pension_civile
def _salbrut(sali, hsup, type_sal, _defaultP):
# indemnite_residence, sup_familial
'''
Calcule le salaire brut à partir du salaire imposable
sauf pour les fonctionnaires où il renvoie le tratement indiciaire brut
Note : le supplément familial de traitement est imposable
'''
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
salarie = scaleBaremes(BaremeDict('sal', _defaultP.cotsoc.sal), plaf_ss)
csg = scaleBaremes(BaremeDict('csg', _defaultP.csg), plaf_ss)
salarie['noncadre'].update(salarie['commun'])
salarie['cadre'].update(salarie['commun'])
noncadre = combineBaremes(salarie['noncadre'])
cadre = combineBaremes(salarie['cadre'])
public_etat = combineBaremes(salarie['fonc']["etat"])
public_colloc = combineBaremes(salarie['fonc']["colloc"])
# On ajoute la CSG deductible
noncadre.addBareme(csg['act']['deduc'])
cadre.addBareme(csg['act']['deduc'])
public_etat.addBareme(csg['act']['deduc'])
nca = noncadre.inverse()
cad = cadre.inverse()
etat = public_etat.inverse()
# TODO: complete this to deal with the fonctionnaire
brut_nca = nca.calc(sali)
brut_cad = cad.calc(sali)
brut_etat = etat.calc(sali)
salbrut = brut_nca * (type_sal == CAT['prive_non_cadre'])
salbrut += brut_cad * (type_sal == CAT['prive_cadre'])
supp_familial_traitement = 0 # TODO: dépend de salbrut
indemnite_residence = 0 # TODO: fix bug
prime = 0
salbrut += (brut_etat * (type_sal == CAT['public_titulaire_etat'])
- prime - supp_familial_traitement - indemnite_residence) # TODO: fonctionnaire
return salbrut + hsup
def build_pat(_P):
'''
Construit le dictionnaire de barèmes des cotisations patronales
à partir des informations contenues dans P.cotsoc.pat
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
pat = scaleBaremes(BaremeDict('pat', _P.cotsoc.pat), plaf_ss)
pat['noncadre'].update(pat['commun'])
pat['cadre'].update(pat['commun'])
pat['fonc']['contract'].update(pat['commun'])
# Renaiming
pat['prive_non_cadre'] = pat.pop('noncadre')
pat['prive_cadre'] = pat.pop('cadre')
log.info("Le dictionnaire des barèmes des cotisations patronales des non cadres contient: \n %s", pat['prive_non_cadre'].keys())
log.info("Le dictionnaire des barèmes des cotisations patronales des cadres contient: \n %s", pat['prive_cadre'].keys())
# Rework commun to deal with public employees
for var in ["maladie", "apprentissage", "apprentissage2", "vieillesseplaf", "vieillessedeplaf", "formprof", "chomfg", "construction", "assedic"]:
del pat['commun'][var]
for var in ["apprentissage", "apprentissage2", "formprof", "chomfg", "construction", "assedic"]:
del pat['fonc']['contract'][var]
pat['fonc']['etat'].update(pat['commun'])
pat['fonc']['colloc'].update(pat['commun'])
del pat['commun']
pat['etat_t'] = pat['fonc']['etat']
pat['colloc_t'] = pat['fonc']['colloc']
pat['contract'] = pat['fonc']['contract']
for var in ['etat', 'colloc', 'contract' ]:
del pat['fonc'][var]
# Renaiming
pat['public_titulaire_etat'] = pat.pop('etat_t')
del pat['public_titulaire_etat']['rafp']
pat['public_titulaire_territoriale'] = pat.pop('colloc_t')
import copy
pat['public_titulaire_hospitaliere'] = copy.deepcopy(pat['public_titulaire_territoriale'])
for category in ['territoriale', 'hospitaliere']:
for name, bareme in pat['public_titulaire_' + category][category].iteritems():
pat['public_titulaire_' + category][name] = bareme
for category in ['territoriale', 'hospitaliere']:
del pat['public_titulaire_territoriale'][category]
del pat['public_titulaire_hospitaliere'][category]
pat['public_non_titulaire'] = pat.pop('contract')
log.info("Le dictionnaire des barèmes cotisations patronales %s contient : \n %s \n" % (DEBUG_SAL_TYPE, pat[DEBUG_SAL_TYPE].keys()))
return pat
def _csgrstd(rstbrut, csg_rempl, _P):
"""
CSG déductible sur les retraites
"""
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict("csg", _P.csg.retraite), plaf_ss)
taux_plein = csg["plein"]["deduc"].calc(rstbrut)
taux_reduit = csg["reduit"]["deduc"].calc(rstbrut)
csgrstd = (csg_rempl == 3) * taux_plein + (csg_rempl == 2) * taux_reduit
return -csgrstd
def _csgrsti(rstbrut, csg_rempl, _P):
'''
CSG imposable sur les pensions de retraite
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict('csg', _P.csg.retraite), plaf_ss)
taux_plein = csg['plein']['impos'].calc(rstbrut)
taux_reduit = csg['reduit']['impos'].calc(rstbrut)
csgrsti = (csg_rempl == 3) * taux_plein + (csg_rempl == 2) * taux_reduit
return -csgrsti
def _csgrsti(rstbrut, csg_rempl, _P):
"""
CSG imposable sur les pensions de retraite
"""
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict("csg", _P.csg.retraite), plaf_ss)
taux_plein = csg["plein"]["impos"].calc(rstbrut)
taux_reduit = csg["reduit"]["impos"].calc(rstbrut)
csgrsti = (csg_rempl == 3) * taux_plein + (csg_rempl == 2) * taux_reduit
return -csgrsti
def csgchoi_sans_exo(chobrut, csg_rempl, _P):
"""
CSG imposable sur les allocations chômage sans exo
"""
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict("csg", _P.csg.chom), plaf_ss)
taux_plein = csg["plein"]["impos"].calc(chobrut)
taux_reduit = csg["reduit"]["impos"].calc(chobrut)
csgchoi = (csg_rempl == 2) * taux_reduit + (csg_rempl == 3) * taux_plein
return -csgchoi
def _csgrsti(rstbrut, csg_rempl, _P):
'''
CSG imposable sur les pensions de retraite
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict('csg', _P.csg.retraite), plaf_ss)
taux_plein = csg['plein']['impos'].calc(rstbrut)
taux_reduit = csg['reduit']['impos'].calc(rstbrut)
csgrsti = (csg_rempl == 3) * taux_plein + (csg_rempl == 2) * taux_reduit
return -csgrsti
def _csgrstd(rstbrut, csg_rempl, _P):
'''
CSG déductible sur les retraites
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict('csg', _P.csg.retraite), plaf_ss)
taux_plein = csg['plein']['deduc'].calc(rstbrut)
taux_reduit = csg['reduit']['deduc'].calc(rstbrut)
csgrstd = (csg_rempl == 3) * taux_plein + (csg_rempl == 2) * taux_reduit
return -csgrstd
def _csgrstd(rstbrut, csg_rempl, _P):
'''
CSG déductible sur les retraites
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict('csg', _P.csg.retraite), plaf_ss)
taux_plein = csg['plein']['deduc'].calc(rstbrut)
taux_reduit = csg['reduit']['deduc'].calc(rstbrut)
csgrstd = (csg_rempl == 3) * taux_plein + (csg_rempl == 2) * taux_reduit
return -csgrstd
def _chobrut_from_chonet(chonet, csg_rempl, _defaultP):
'''
Calcule les allocations chômage brute à partir des allocations imposables
'''
P = _defaultP.csg.chom
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict('csg', P), plaf_ss)
crds = scaleBaremes(BaremeDict('crds', _defaultP.crds), plaf_ss)
taux_plein = combineBaremes(csg['plein'])
taux_reduit = combineBaremes(csg['reduit'])
taux_plein.addBareme(crds)
taux_reduit.addBareme(crds)
chom_plein = taux_plein.inverse()
chom_reduit = taux_reduit.inverse()
chobrut = (csg_rempl == 1) * chonet + (csg_rempl == 2) * chom_reduit.calc(chonet) + (csg_rempl == 3) * chom_plein.calc(chonet)
return chobrut
def csgchoi_sans_exo(chobrut, csg_rempl, _P):
'''
CSG imposable sur les allocations chômage sans exo
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict('csg', _P.csg.chom), plaf_ss)
taux_plein = csg['plein']['impos'].calc(chobrut)
taux_reduit = csg['reduit']['impos'].calc(chobrut)
csgchoi = (csg_rempl == 2) * taux_reduit + (csg_rempl == 3) * taux_plein
return -csgchoi
def csgchoi_sans_exo(chobrut, csg_rempl, _P):
'''
CSG imposable sur les allocations chômage sans exo
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict('csg', _P.csg.chom), plaf_ss)
taux_plein = csg['plein']['impos'].calc(chobrut)
taux_reduit = csg['reduit']['impos'].calc(chobrut)
csgchoi = (csg_rempl == 2) * taux_reduit + (csg_rempl == 3) * taux_plein
return -csgchoi
def _chobrut_from_chonet(chonet, csg_rempl, _defaultP):
'''
Calcule les allocations chômage brute à partir des allocations imposables
'''
P = _defaultP.csg.chom
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict('csg', P), plaf_ss)
crds = scaleBaremes(BaremeDict('crds', _defaultP.crds), plaf_ss)
taux_plein = combineBaremes(csg['plein'])
taux_reduit = combineBaremes(csg['reduit'])
taux_plein.addBareme(crds)
taux_reduit.addBareme(crds)
chom_plein = taux_plein.inverse()
chom_reduit = taux_reduit.inverse()
chobrut = (csg_rempl == 1) * chonet + (csg_rempl == 2) * chom_reduit.calc(
chonet) + (csg_rempl == 3) * chom_plein.calc(chonet)
return chobrut
def build_pat(_P):
'''
Construit le dictionnaire de barèmes des cotisations patronales
à partir des informations contenues dans P.cotsoc.pat
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
pat = scaleBaremes(BaremeDict('pat', _P.cotsoc.pat), plaf_ss)
pat['noncadre'].update(pat['commun'])
pat['cadre'].update(pat['commun'])
pat['fonc']['contract'].update(pat['commun'])
# Renaiming
pat['prive_non_cadre'] = pat.pop('noncadre')
pat['prive_cadre'] = pat.pop('cadre')
log.info("Le dictionnaire des barèmes des cotisations patronales des non cadres contient: \n %s", pat['prive_non_cadre'].keys())
log.info("Le dictionnaire des barèmes des cotisations patronales des cadres contient: \n %s", pat['prive_cadre'].keys())
# Rework commun to deal with public employees
for var in ["maladie", "apprentissage", "apprentissage2", "vieillesseplaf", "vieillessedeplaf", "formprof", "chomfg", "construction", "assedic"]:
del pat['commun'][var]
for var in ["apprentissage", "apprentissage2", "formprof", "chomfg", "construction", "assedic"]:
del pat['fonc']['contract'][var]
pat['fonc']['etat'].update(pat['commun'])
pat['fonc']['colloc'].update(pat['commun'])
del pat['commun']
pat['etat_t'] = pat['fonc']['etat']
pat['colloc_t'] = pat['fonc']['colloc']
pat['contract'] = pat['fonc']['contract']
for var in ['etat', 'colloc', 'contract' ]:
del pat['fonc'][var]
# Renaiming
pat['public_titulaire_etat'] = pat.pop('etat_t')
del pat['public_titulaire_etat']['rafp']
pat['public_titulaire_territoriale'] = pat.pop('colloc_t')
import copy
pat['public_titulaire_hospitaliere'] = copy.deepcopy(pat['public_titulaire_territoriale'])
for category in ['territoriale', 'hospitaliere']:
for name, bareme in pat['public_titulaire_' + category][category].iteritems():
pat['public_titulaire_' + category][name] = bareme
for category in ['territoriale', 'hospitaliere']:
del pat['public_titulaire_territoriale'][category]
del pat['public_titulaire_hospitaliere'][category]
pat['public_non_titulaire'] = pat.pop('contract')
log.info("Le dictionnaire des barèmes cotisations patronales %s contient : \n %s \n" % (DEBUG_SAL_TYPE, pat[DEBUG_SAL_TYPE].keys()))
return pat
def _chobrut_from_chonet(chonet, csg_rempl, _defaultP):
'''
Calcule les allocations chômage brute à partir des allocations imposables
'''
P = _defaultP.csg.chom
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict('csg', P), plaf_ss)
crds = scaleBaremes(_defaultP.crds.rst, plaf_ss) # crds.rst est la CRDS sur les revenus de remplacement donc valable aussi pour le chômage
taux_plein = combineBaremes(csg['plein'])
taux_reduit = combineBaremes(csg['reduit'])
taux_plein.addBareme(crds)
taux_reduit.addBareme(crds)
chom_plein = taux_plein.inverse()
chom_reduit = taux_reduit.inverse()
chobrut = (csg_rempl == 1) * chonet + (csg_rempl == 2) * chom_reduit.calc(chonet) + (csg_rempl == 3) * chom_plein.calc(chonet)
isexo = exo_csg_chom(chobrut, csg_rempl, _defaultP)
chobrut = not_(isexo) * chobrut + (isexo) * chonet
return chobrut
def _cot_pat_pension_civile(salbrut, type_sal, _P):
"""
Pension civile part patronale
Note : salbrut est égal au traitement indiciaire brut
"""
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
pat = scaleBaremes(BaremeDict('pat', _P.cotsoc.pat), plaf_ss)
terr_or_hosp = (type_sal == CAT['public_titulaire_territoriale']) + (type_sal == CAT['public_titulaire_hospitaliere'])
cot_pat_pension_civile = (
(type_sal == CAT['public_titulaire_etat']) * pat['fonc']['etat']['pension'].calc(salbrut)
+ terr_or_hosp * pat['fonc']['colloc']['cnracl'].calc(salbrut)
)
return -cot_pat_pension_civile
def _salbrut_from_salnet(salnet, hsup, type_sal, _defaultP):
"""
Calcule le salaire brut à partir du salaire net
Renvoie 0 sauf pour les salariés non cadres, cadres (TODO: et les contractuels de la fonction publique ?)
"""
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
salarie = scaleBaremes(BaremeDict("sal", _defaultP.cotsoc.sal), plaf_ss)
csg = scaleBaremes(BaremeDict("csg", _defaultP.csg), plaf_ss)
crds = scaleBaremes(BaremeDict("csrds", _defaultP.crds), plaf_ss)
salarie["noncadre"].update(salarie["commun"])
salarie["cadre"].update(salarie["commun"])
noncadre = combineBaremes(salarie["noncadre"])
cadre = combineBaremes(salarie["cadre"])
fonc = combineBaremes(salarie["fonc"])
# On ajoute la CSG deductible+imosable et la CRDS
for baremes in [noncadre, cadre, fonc]:
baremes.addBareme(csg["act"]["deduc"])
baremes.addBareme(csg["act"]["impos"])
baremes.addBareme(crds["act"])
nca = noncadre.inverse()
cad = cadre.inverse()
fon = fonc.inverse()
# TODO: complete this to deal with the fonctionnaire
brut_nca = nca.calc(salnet)
brut_cad = cad.calc(salnet)
brut_fon = fon.calc(salnet)
salbrut = (
brut_nca * (type_sal == CAT["prive_non_cadre"])
+ brut_cad * (type_sal == CAT["prive_cadre"])
+ brut_fon * (type_sal == CAT["public_titulaire_etat"])
)
return salbrut + hsup
def build_pat(_P):
'''
Construit le dictionnaire de barèmes des cotisations patronales
à partir des informations contenues dans P.cotsoc.pat
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
pat = scaleBaremes(BaremeDict('pat', _P.cotsoc.pat), plaf_ss)
pat['noncadre'].update(pat['commun'])
pat['cadre'].update(pat['commun'])
pat['fonc']['contract'].update(pat['commun'])
# Renaiming
pat['prive_non_cadre'] = pat.pop('noncadre')
pat['prive_cadre'] = pat.pop('cadre')
log.info("Le dictionnaire des barèmes des cotisations patronales des non cadres contient: \n %s", pat['prive_non_cadre'].keys())
log.info("Le dictionnaire des barèmes des cotisations patronales des cadres contient: \n %s", pat['prive_cadre'].keys())
# Rework commun to deal with public employees
for var in ["maladie", "apprentissage", "apprentissage2", "vieillesseplaf", "vieillessedeplaf", "formprof", "chomfg", "construction", "assedic"]:
del pat['commun'][var]
for var in ["apprentissage", "apprentissage2", "formprof", "chomfg", "construction", "assedic"]:
del pat['fonc']['contract'][var]
pat['fonc']['etat'].update(pat['commun'])
pat['fonc']['colloc'].update(pat['commun'])
del pat['commun']
pat['etat_t'] = pat['fonc']['etat']
pat['colloc_t'] = pat['fonc']['colloc']
pat['contract'] = pat['fonc']['contract']
for var in ['etat', 'colloc', 'contract' ]:
del pat['fonc'][var]
# Renaiming
pat['public_titulaire_etat'] = pat.pop('etat_t')
del pat['public_titulaire_etat']['rafp']
pat['public_titulaire_territoriale'] = pat.pop('colloc_t')
pat['public_titulaire_hospitaliere'] = pat['public_titulaire_territoriale']
pat['public_non_titulaire'] = pat.pop('contract')
log.info("Le dictionnaire des barèmes des cotisations patronales des salariés titulaires de l'etat contient : \n %s", pat['public_titulaire_etat'].keys())
log.info("Le dictionnaire des barèmes des cotisations patronales titulaires des collectivités locales contient : \n %s", pat['public_titulaire_territoriale'].keys())
log.info("Le dictionnaire des barèmes des cotisations patronales titulaires hospitaliers contient : \n %s", pat['public_titulaire_hospitaliere'].keys())
log.error("Le dictionnaire des barèmes des cotisations patronales du public contractuels contient : \n %s", pat['public_non_titulaire'].keys())
return pat
def _chobrut_from_chonet(chonet, csg_rempl, _defaultP):
"""
Calcule les allocations chômage brute à partir des allocations imposables
"""
P = _defaultP.csg.chom
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict("csg", P), plaf_ss)
crds = scaleBaremes(BaremeDict("crds", _defaultP.crds), plaf_ss)
taux_plein = combineBaremes(csg["plein"])
taux_reduit = combineBaremes(csg["reduit"])
taux_plein.addBareme(crds)
taux_reduit.addBareme(crds)
chom_plein = taux_plein.inverse()
chom_reduit = taux_reduit.inverse()
chobrut = (
(csg_rempl == 1) * chonet
+ (csg_rempl == 2) * chom_reduit.calc(chonet)
+ (csg_rempl == 3) * chom_plein.calc(chonet)
)
return chobrut
def _rstbrut_from_rstnet(rstnet, csg_rempl, _defaultP):
'''
Calcule les pensions de retraites brutes à partir des pensions nettes
'''
P = _defaultP.csg.retraite
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict('csg', P), plaf_ss)
crds = scaleBaremes(_defaultP.crds.rst, plaf_ss)
taux_plein = combineBaremes(csg['plein'])
taux_reduit = combineBaremes(csg['reduit'])
taux_plein.addBareme(crds)
taux_reduit.addBareme(crds)
if hasattr(_defaultP.prelsoc, 'add_ret'):
casa = Bareme(name = "casa")
casa.addTranche(0, _defaultP.prelsoc.add_ret)
taux_plein.addBareme(casa)
taux_reduit.addBareme(casa)
rst_plein = taux_plein.inverse()
rst_reduit = taux_reduit.inverse()
rstbrut = (csg_rempl == 2) * rst_reduit.calc(rstnet) + (csg_rempl == 3) * rst_plein.calc(rstnet)
return rstbrut
def _cot_pat_rafp(salbrut, type_sal, primes, supp_familial_traitement, indemnite_residence, _P):
'''
Part patronale de la retraite additionelle de la fonction publique
TODO: ajouter la gipa qui n'est pas affectée par le plafond d'assiette
Note: salbrut est le traitement indiciaire brut pour les fonctionnaires
'''
eligibles = ((type_sal == CAT['public_titulaire_etat'])
+ (type_sal == CAT['public_titulaire_territoriale'])
+ (type_sal == CAT['public_titulaire_hospitaliere']))
tib = salbrut * eligibles / 12
plaf_ass = _P.cotsoc.sal.fonc.etat.rafp_plaf_assiette
base_imposable = primes + supp_familial_traitement + indemnite_residence
plaf_ss = _P.cotsoc.gen.plaf_ss # TODO: use build_pat
pat = scaleBaremes(BaremeDict('pat', _P.cotsoc.pat), plaf_ss)
assiette = min_(base_imposable / 12, plaf_ass * tib)
cot_pat_rafp = eligibles * pat['fonc']['etat']['rafp'].calc(assiette)
return -12 * cot_pat_rafp
def build_sal(_P):
'''
Construit le dictionnaire de barèmes des cotisations salariales
à partir des informations contenues dans P.cotsoc.sal
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
sal = scaleBaremes(BaremeDict('sal', _P.cotsoc.sal), plaf_ss)
sal['noncadre'].update(sal['commun'])
sal['cadre'].update(sal['commun'])
# Renaiming
sal['prive_non_cadre'] = sal.pop('noncadre')
sal['prive_cadre'] = sal.pop('cadre')
sal['etat_t'] = sal['fonc']['etat']
sal['colloc_t'] = sal['fonc']['colloc']
sal['contract'] = sal['fonc']['contract']
sal['contract'].update(sal['commun'])
del sal['contract']['arrco']
del sal['contract']['assedic']
sal['contract']['solidarite'] = sal['fonc']['commun']['solidarite']
del sal['fonc']['etat']
del sal['fonc']['colloc']
del sal['fonc']['contract']
del sal['commun']
# Renaiming
sal['public_titulaire_etat'] = sal.pop('etat_t')
sal['public_titulaire_territoriale'] = sal.pop('colloc_t')
# pat['public_titulaire_hospitalière'] = pat.pop('colloc') TODO: fix ths
sal['public_non_titulaire'] = sal.pop('contract')
log.info(
"Le dictionnaire des barèmes des salariés titualires de l'etat contient %s",
sal['public_titulaire_etat'].keys())
log.info(
"Le dictionnaire des barèmes des salariés titualires des collectivités locales contient %s",
sal['public_titulaire_territoriale'].keys())
log.info(
"Le dictionnaire des barèmes des salariés du public contractuels contient %s",
sal['public_non_titulaire'].keys())
return sal
def _chobrut(choi, csg_rempl, _defaultP):
'''
Calcule les allocations chômage brute à partir des allocations imposables
'''
# TODO: ajouter la crds ?
P = _defaultP.csg.chom
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict('csg', P), plaf_ss)
taux_plein = csg['plein']['deduc']
taux_reduit = csg['reduit']['deduc']
chom_plein = taux_plein.inverse()
chom_reduit = taux_reduit.inverse()
chobrut_temp = ((csg_rempl == 1) * choi +
(csg_rempl == 2) * chom_reduit.calc(choi) +
(csg_rempl == 3) * chom_plein.calc(choi))
isexo = exo_csg_chom(chobrut_temp, csg_rempl, _defaultP)
chobrut = not_(isexo) * chobrut_temp + (isexo) * choi
return chobrut
def build_sal(_P):
'''
Construit le dictionnaire de barèmes des cotisations salariales
à partir des informations contenues dans P.cotsoc.sal
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
sal = scaleBaremes(BaremeDict('sal', _P.cotsoc.sal), plaf_ss)
sal['noncadre'].update(sal['commun'])
sal['cadre'].update(sal['commun'])
# Renaiming
sal['prive_non_cadre'] = sal.pop('noncadre')
sal['prive_cadre'] = sal.pop('cadre')
sal['public_titulaire_etat'] = sal['fonc']['etat']
sal['public_titulaire_territoriale'] = sal['fonc']['colloc']
sal['public_titulaire_hospitaliere'] = sal['fonc']['colloc']
sal['public_non_titulaire'] = sal['fonc']['contract']
for type_sal_category in ['public_titulaire_etat', 'public_titulaire_territoriale', 'public_titulaire_hospitaliere',
'public_non_titulaire']:
sal[type_sal_category]['excep_solidarite'] = sal['fonc']['commun']['solidarite']
sal['public_non_titulaire'].update(sal['commun'])
del sal['public_non_titulaire']['arrco']
del sal['public_non_titulaire']['assedic']
# Cleaning
del sal['commun']
del sal['fonc']['etat']
del sal['fonc']['colloc']
del sal['fonc']['contract']
log.info("Le dictionnaire des barèmes des salariés %s contient : \n %s \n" % (DEBUG_SAL_TYPE, sal[DEBUG_SAL_TYPE].keys()))
return sal
def _chobrut(choi, csg_rempl, _defaultP):
'''
Calcule les allocations chômage brute à partir des allocations imposables
'''
# TODO: ajouter la crds ? Malka Louise
P = _defaultP.csg.chom
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
csg = scaleBaremes(BaremeDict('csg', P), plaf_ss)
taux_plein = combineBaremes(csg['plein'])
taux_reduit = combineBaremes(csg['reduit'])
chom_plein = taux_plein.inverse()
chom_reduit = taux_reduit.inverse()
# log.info(chom_plein)
# log.info(chom_reduit)
chobrut = (csg_rempl == 1) * choi + (csg_rempl == 2) * chom_reduit.calc(
choi) + (csg_rempl == 3) * chom_plein.calc(choi)
# isexo = exo_csg_chom(choi, _defaultP)
# chobrut = not_(isexo)*chobrut + (isexo)*choi
# print P.plein.impos, P.plein.deduc
# print "taux réduit : "
# print P.reduit.impos, P.reduit.deduc
return chobrut
def _salbrut(sali, hsup, type_sal, _defaultP):
# indemnite_residence, sup_familial
'''
Calcule le salaire brut à partir du salaire imposable
sauf pour les fonctionnaires où il renvoie le tratement indiciaire brut
Note : le supplément familial de traitement est imposable
'''
plaf_ss = 12 * _defaultP.cotsoc.gen.plaf_ss
salarie = scaleBaremes(BaremeDict('sal', _defaultP.cotsoc.sal), plaf_ss)
csg = scaleBaremes(BaremeDict('csg', _defaultP.csg), plaf_ss)
salarie['noncadre'].update(salarie['commun'])
salarie['cadre'].update(salarie['commun'])
log.info(
"Le dictionnaire des barèmes des cotisations salariés des titualires de l'Etat contien : \n %s",
salarie['fonc']["etat"])
# Salariés du privé
noncadre = combineBaremes(salarie['noncadre'])
cadre = combineBaremes(salarie['cadre'])
# On ajoute la CSG deductible
noncadre.addBareme(csg['act']['deduc'])
cadre.addBareme(csg['act']['deduc'])
nca = noncadre.inverse()
cad = cadre.inverse()
brut_nca = nca.calc(sali)
brut_cad = cad.calc(sali)
salbrut = brut_nca * (type_sal == CAT['prive_non_cadre'])
salbrut += brut_cad * (type_sal == CAT['prive_cadre'])
# public etat
# TODO: modifier la contribution exceptionelle de solidarité
# en fixant son seuil de non imposition dans le barème (à corriger dans param.xml
# et en tenant compte des éléments de l'assiette
salarie['fonc']["etat"].update(
{'excep_solidarite': salarie['fonc']['commun']['solidarite']})
public_etat = salarie['fonc']["etat"]['pension']
# public_colloc = combineBaremes(salarie['fonc']["colloc"]) TODO:
# Pour a fonction publique la csg est calculée sur l'ensemble salbrut(=TIB) + primes
# Imposable = TIB - csg( (1+taux_prime)*TIB ) - pension(TIB) + taux_prime*TIB
bareme_csg_titulaire_etat = (csg['act']['deduc']).multTaux(
1 + TAUX_DE_PRIME, inplace=False, new_name="csg deduc titutaire etat")
public_etat.addBareme(bareme_csg_titulaire_etat)
bareme_prime = Bareme(name="taux de prime")
bareme_prime.addTranche(
0, -TAUX_DE_PRIME) # barème équivalent à taux_prime*TIB
public_etat.addBareme(bareme_prime)
etat = public_etat.inverse()
# TODO: complete this to deal with the fonctionnaire
supp_familial_traitement = 0 # TODO: dépend de salbrut
indemnite_residence = 0 # TODO: fix bug
# print 'sali', sali / 12
brut_etat = etat.calc(sali)
# print 'impot', public_etat.calc(brut_etat) / 12
# print 'brut_etat', brut_etat / 12
salbrut_etat = (brut_etat)
# # TODO: fonctionnaire
# print 'salbrut_etat', salbrut_etat / 12
salbrut += salbrut_etat * (type_sal == CAT['public_titulaire_etat'])
# # <NODE desc= "Supplément familial de traitement " shortname="Supp. fam." code= "supp_familial_traitement" color = "0,99,143"/>
# # <NODE desc= "Indemnité de résidence" shortname="Ind. rés." code= "indemenite_residence" color = "0,99,143"/>
return salbrut + hsup
def build_pat(_P):
'''
Construit le dictionnaire de barèmes des cotisations patronales
à partir des informations contenues dans P.cotsoc.pat
'''
plaf_ss = 12 * _P.cotsoc.gen.plaf_ss
pat = scaleBaremes(BaremeDict('pat', _P.cotsoc.pat), plaf_ss)
pat['noncadre'].update(pat['commun'])
pat['cadre'].update(pat['commun'])
pat['fonc']['contract'].update(pat['commun'])
# Renaiming
pat['prive_non_cadre'] = pat.pop('noncadre')
pat['prive_cadre'] = pat.pop('cadre')
log.info(
"Le dictionnaire des barèmes des cotisations patronales des non cadres contient %s",
pat['prive_non_cadre'].keys())
log.info(
"Le dictionnaire des barèmes des cotisations patronales des cadres contient %s",
pat['prive_cadre'].keys())
# Rework commun to deal with public employees
for var in [
"maladie", "apprentissage", "apprentissage2", "vieillesseplaf",
"vieillessedeplaf", "formprof", "chomfg", "construction",
"assedic", "transport"
]:
del pat['commun'][var]
for var in [
"apprentissage", "apprentissage2", "formprof", "chomfg",
"construction", "assedic"
]:
del pat['fonc']['contract'][var]
pat['fonc']['etat'].update(pat['commun'])
pat['fonc']['colloc'].update(pat['commun'])
del pat['commun']
pat['etat_t'] = pat['fonc']['etat']
pat['colloc_t'] = pat['fonc']['colloc']
pat['contract'] = pat['fonc']['contract']
for var in ['etat', 'colloc', 'contract']:
del pat['fonc'][var]
# Renaiming
pat['public_titulaire_etat'] = pat.pop('etat_t')
pat['public_titulaire_territoriale'] = pat.pop('colloc_t')
# pat['public_titulaire_hospitalière'] = pat.pop('colloc') TODO: fix ths
pat['public_non_titulaire'] = pat.pop('contract')
log.info(
"Le dictionnaire des barèmes des cotisations patronales des salariés titulaires de l'etat contient %s",
pat['public_titulaire_etat'].keys())
log.info(
"Le dictionnaire des barèmes des cotisations patronales titulaires des collectivités locales contient %s",
pat['public_titulaire_territoriale'].keys())
log.info(
"Le dictionnaire des barèmes des cotisations patronales du public contractuels contient %s",
pat['public_non_titulaire'].keys())
return pat
