Revenu_de_base_par_IRPP.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "import json\n",
    "\n",
    "import openfisca_france\n",
    "from openfisca_france.model.base import *\n",
    "\n",
    "#importer numpy permet de coller deux sections de courbes (nécessaire quand on fait varier le salaire de base en-dessous du SMIC mensuel)\n",
    "import numpy as np\n",
    "from numpy import round\n",
    "\n",
    "# to debug / trace\n",
    "from openfisca_core import periods, tools\n",
    "from openfisca_core.reforms import Reform"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Système socio-fiscal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tax_benefit_system = openfisca_france.FranceTaxBenefitSystem()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Réforme : 2. Revenu de base financé par l'IRPP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from numpy import logical_not as not_, minimum as min_, maximum as max_, logical_and as and_, logical_or as or_\n",
    "\n",
    "#- MISE EN PLACE DU RDB\n",
    "#- Mise en place d'un revenu de base adulte égal à RSA socle célibataire - forfait logement célibataire,\n",
    "#-                dont on déduit l'AAH jusqu'à sa hauteur\n",
    "#- Mise en place d'un crédit d'impot familles monoparentales montant ??? (150€)\n",
    "#- Supprimer le RSA\n",
    "#- Supprimer la prime d'activité\n",
    "#- Création du RdB enfant\n",
    "\n",
    "\n",
    "#- CHANGEMENT DE L'ASSIETTE DE L'IRPP\n",
    "\n",
    "#- Réforme de l'abattement pour frais professionnels :\n",
    "#- le taux d'abattement pour frais professionnels est réduit à 0%\n",
    "#- seuls 30% de frais réels donnent droit à un abattement\n",
    "#- le taux d'abattement sur les pensions est réduit à 0%\n",
    "\n",
    "#- La CSG déductible sur les salaires ne l'est plus\n",
    "#- La CSG déductible sur le chômage ne l'est plus\n",
    "#- La CSG déductible sur les pensions ne l'est plus\n",
    "\n",
    "\n",
    "#- Les charges déductibles (abattements) suivantes sont supprimées : cd_deddiv, cd_doment, cd_eparet, cd_grorep, cd_percap\n",
    "#- Les charges déductibles (abattements) suivantes sont maintenues : cd_acc75a, cd_penali\n",
    "#- La CSG déductible sur le patrimoine ne l'est plus\n",
    "#- Les réductions d'impôts suivants sont remplacés par des abattements : cotsyn, dfppce, donapd, garext \n",
    "#- Les crédits d'impôt suivants sont remplacés par des abattements : aidper, ci_garext, quaenv, saldom2\n",
    "\n",
    "#- le revenu de base adulte et le crédit d'impot familles monoparentales sont ajoutés au revenu imposable\n",
    "\n",
    "\n",
    "#- CHANGEMENT DU CALCUL DE L'IRPP\n",
    "#- le barème est modifié avec les tranches 0%, 30%, 41%, 45%\n",
    "#- les tranches sont modifiées : RDB adulte, XXXXX €, XXXXX €\n",
    "#- la décote est annulée (ou non prise en compte)\n",
    "\n",
    "#- les enfants sont retirés du nombre de parts (maintien du quotient conjugal et de la demi-part pour familles monoparentales)\n",
    "#- Le revenu de base et le crédit familles monoparentales sont intégres au revenu imposable\n",
    "\n",
    "#- Les réductions d'impôt suivantes sont supprimées : accult, adhcga, assvie, cappme, creaen, daepad, deffor, doment, domlog, domsoc, duflot, ecodev, ecpess, intagr, intcon, intemp, invfor, invlst, invrev, ip_net, locmeu, mecena, mohist, patnat, prcomp, reduction_impot_exceptionnelle, repsoc, resimm, rsceha, saldom, scelli, sofica, sofipe, spfcpi\n",
    "#- Seules 30% des réductions d'impôt suivantes sont prise en compte : (vide)\n",
    "\n",
    "#- Les crédits d'impôt suivants sont supprimés : accult, acqgpl, aidmob, assloy, autent, cotsyn, creimp, creimp_exc_2008, direpa, divide, drbail, inthab, jeunes, mecena, percvm, preetu, prlire\n",
    "\n",
    "#- Intégrer le revenu de base au revenu disponible\n",
    "\n",
    "\n",
    "#-Visualisation graphique en abscisse salaire brut et en ordonnée variation du revenu disponible \n",
    "# pour un célibataire sans enfant\n",
    "# pour un couple sans enfant\n",
    "# une famille monoparentale\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#- Les paramètres de taux d'abattement sont annulés\n",
    "\n",
    "#- paramètre abattement_minimum : l'abattemnt minimum est réduit à 0\n",
    "#- paramètre abatpro.taux : le taux d'abattement pour frais professionnels est réduit à 0%\n",
    "#- paramètre abatpen.taux : le taux d'abattement sur les pensions est réduit à 0%\n",
    "\n",
    "\n",
    "def modify_legislation_json(reference_legislation_json_copy):\n",
    "    for value_json in reference_legislation_json_copy['children']['ir']['children']['tspr']['children']['abatpro']['children']['taux']['values']:\n",
    "        value_json['value'] = 0\n",
    "    for value_json in reference_legislation_json_copy['children']['ir']['children']['tspr']['children']['abatpen']['children']['taux']['values']:\n",
    "        value_json['value'] = 0\n",
    "    return reference_legislation_json_copy\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#- Variable salaire_imposable (individus)\n",
    "#- La CSG déductible sur les salaires ne l'est plus\n",
    "\n",
    "class salaire_imposable(Variable):\n",
    "\n",
    "    def function(self, simulation, period):\n",
    "        period = period.start.period(u'month').offset('first-of')\n",
    "        salaire_de_base = simulation.calculate('salaire_de_base', period)\n",
    "        primes_salaires = simulation.calculate('primes_salaires', period)\n",
    "        primes_fonction_publique = simulation.calculate('primes_fonction_publique', period)\n",
    "        indemnite_residence = simulation.calculate('indemnite_residence', period)\n",
    "        supp_familial_traitement = simulation.calculate('supp_familial_traitement', period)\n",
    "        csg_deductible_salaire = simulation.calculate('csg_deductible_salaire', period)\n",
    "        cotisations_salariales = simulation.calculate('cotisations_salariales', period)\n",
    "        remuneration_principale = simulation.calculate('remuneration_principale', period)\n",
    "        hsup = simulation.calculate('hsup', period)\n",
    "        rev_microsocial_declarant1 = simulation.calculate_divide('rev_microsocial_declarant1', period)\n",
    "        indemnite_fin_contrat = simulation.calculate('indemnite_fin_contrat', period)\n",
    "\n",
    "        return period, (\n",
    "            salaire_de_base + primes_salaires + remuneration_principale +\n",
    "            primes_fonction_publique + indemnite_residence + supp_familial_traitement +\n",
    "            cotisations_salariales - hsup + rev_microsocial_declarant1 + indemnite_fin_contrat\n",
    "            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#- Variable chomage_imposable (individus)\n",
    "#- La CSG déductible sur le chômage ne l'est plus\n",
    "\n",
    "class chomage_imposable(Variable):\n",
    "    \n",
    "    def function(self, simulation, period):\n",
    "        period = period\n",
    "        chomage_brut = simulation.calculate('chomage_brut', period)\n",
    "        csg_deductible_chomage = simulation.calculate_add('csg_deductible_chomage', period)\n",
    "\n",
    "        return period, chomage_brut\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#- Variable retraite_imposable (individus)\n",
    "#- La CSG déductible sur les pensions de retraite ne l'est plus\n",
    "\n",
    "class retraite_imposable(Variable):\n",
    "    \n",
    "    def function(self, simulation, period):\n",
    "        period = period\n",
    "        retraite_brute = simulation.calculate_add('retraite_brute', period)\n",
    "        csg_deductible_retraite = simulation.calculate_add('csg_deductible_retraite', period)\n",
    "\n",
    "        return period, retraite_brute\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#- variable revenu_assimile_salaire_apres_abattements (Individu) :\n",
    "#- seuls 30% de frais réels donnent droit à un abattement\n",
    "\n",
    "class revenu_assimile_salaire_apres_abattements(Variable):\n",
    "\n",
    "    def function(self, simulation, period):\n",
    "        '''\n",
    "        blabla\n",
    "        '''\n",
    "        period = period.this_year\n",
    "        revenu_assimile_salaire = simulation.calculate('revenu_assimile_salaire', period)\n",
    "        chomeur_longue_duree = simulation.calculate('chomeur_longue_duree', period)\n",
    "        frais_reels = simulation.calculate('frais_reels', period)\n",
    "        abatpro = simulation.legislation_at(period.start).ir.tspr.abatpro\n",
    "\n",
    "        abattement_minimum = abatpro.min * not_(chomeur_longue_duree) + abatpro.min2 * chomeur_longue_duree\n",
    "        abatfor = round(min_(max_(abatpro.taux * revenu_assimile_salaire, abattement_minimum), abatpro.max))\n",
    "\n",
    "        return period, (frais_reels > abatfor) * (revenu_assimile_salaire - frais_reels/3) + (frais_reels <= abatfor) * max_(0, revenu_assimile_salaire - abatfor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#- variable cd1 (FoyersFiscaux) : \n",
    "#- Les charges déductibles (abattements) suivantes sont supprimées : cd_deddiv, cd_doment, cd_eparet, cd_grorep, cd_percap\n",
    "#- Les charges déductibles (abattements) suivantes sont maintenues : cd_acc75a, cd_penali\n",
    "    \n",
    "class cd1(Variable):\n",
    "\n",
    "    def function(self, simulation, period):\n",
    "\n",
    "        '''\n",
    "        Renvoie la liste des charges déductibles avant rbg_int pour 2014\n",
    "        '''\n",
    "        period = period.this_year\n",
    "        cd_penali = simulation.calculate('cd_penali', period)\n",
    "        cd_acc75a = simulation.calculate('cd_acc75a', period)\n",
    "        cd_deddiv = simulation.calculate('cd_deddiv', period)\n",
    "        cd_eparet = simulation.calculate('cd_eparet', period)\n",
    "        cd_grorep = simulation.calculate('cd_grorep', period)\n",
    "\n",
    "        niches1 = cd_penali + cd_acc75a \n",
    "        # log.error(\"Charges déductibles to be checked because not defined for %s\", 2014)\n",
    "        return period, niches1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#- CHANGEMENT DE L'ASSIETTE DE L'IRPP \n",
    "\n",
    "#- variable rng (FoyersFiscaux): \n",
    "#- La CSG déductible sur le patrimoine ne l'est plus\n",
    "#- Les réductions d'impôts suivantes sont remplacées par des abattements : dfppce (dons aux oeuvres), donapd (dons aide à la personne), garext (frais de garde extérieur) \n",
    "#- Les crédits d'impôt suivants sont remplacés par des abattements : aidper, ci_garext, quaenv, saldom2\n",
    "\n",
    "#- Le revenu de base et le crédit familles monoparentales sont intégrés au revenu imposable\n",
    "\n",
    "class rng(Variable):\n",
    "\n",
    "    def function(self, simulation, period):\n",
    "        ''' \n",
    "        Revenu net global (total 20) \n",
    "        '''\n",
    "        period = period.this_year\n",
    "        rbg = simulation.calculate('rbg', period)\n",
    "        csg_deduc = simulation.calculate('csg_deduc', period)\n",
    "        charges_deduc = simulation.calculate('charges_deduc', period)\n",
    "\n",
    "        '''\n",
    "        Renvoie la somme des réductions d'impôt à intégrer pour l'année 2014 et + (non vérifiée)\n",
    "        '''\n",
    "        period = period.this_year\n",
    "        accult = simulation.calculate('accult', period)\n",
    "        adhcga = simulation.calculate('adhcga', period)\n",
    "        cappme = simulation.calculate('cappme', period)\n",
    "        creaen = simulation.calculate('creaen', period)\n",
    "        daepad = simulation.calculate('daepad', period)\n",
    "        deffor = simulation.calculate('deffor', period)\n",
    "        dfppce = simulation.calculate('dfppce', period)\n",
    "        doment = simulation.calculate('doment', period)\n",
    "        domlog = simulation.calculate('domlog', period)\n",
    "        donapd = simulation.calculate('donapd', period)\n",
    "        duflot = simulation.calculate('duflot', period)\n",
    "        ecpess = simulation.calculate('ecpess', period)\n",
    "        garext = simulation.calculate('garext', period)\n",
    "        intagr = simulation.calculate('intagr', period)\n",
    "        invfor = simulation.calculate('invfor', period)\n",
    "        invlst = simulation.calculate('invlst', period)\n",
    "        ip_net = simulation.calculate('ip_net', period)\n",
    "        locmeu = simulation.calculate('locmeu', period)\n",
    "        mecena = simulation.calculate('mecena', period)\n",
    "        mohist = simulation.calculate('mohist', period)\n",
    "        patnat = simulation.calculate('patnat', period)\n",
    "        prcomp = simulation.calculate('prcomp', period)\n",
    "        reduction_impot_exceptionnelle = simulation.calculate('reduction_impot_exceptionnelle', period)\n",
    "        repsoc = simulation.calculate('repsoc', period)\n",
    "        resimm = simulation.calculate('resimm', period)\n",
    "        rsceha = simulation.calculate('rsceha', period)\n",
    "        saldom = simulation.calculate('saldom', period)\n",
    "        scelli = simulation.calculate('scelli', period)\n",
    "        sofica = simulation.calculate('sofica', period)\n",
    "        spfcpi = simulation.calculate('spfcpi', period)\n",
    "\n",
    "        \"\"\" Crédits d'impôt crédités l'impôt sur les revenus de 2014 et + (non vérifié)\"\"\"\n",
    "        period = period.this_year\n",
    "        accult = simulation.calculate('accult', period)\n",
    "        aidper = simulation.calculate('aidper', period)\n",
    "        assloy = simulation.calculate('assloy', period)\n",
    "        autent = simulation.calculate('autent', period)\n",
    "        ci_garext = simulation.calculate('ci_garext', period)\n",
    "        cotsyn = simulation.calculate('cotsyn', period)\n",
    "        creimp = simulation.calculate('creimp', period)\n",
    "        direpa = simulation.calculate('direpa', period)\n",
    "        drbail = simulation.calculate('drbail', period)\n",
    "        inthab = simulation.calculate('inthab', period)\n",
    "        mecena = simulation.calculate('mecena', period)\n",
    "        preetu = simulation.calculate('preetu', period)\n",
    "        prlire = simulation.calculate('prlire', period)\n",
    "        quaenv = simulation.calculate('quaenv', period)\n",
    "        saldom2 = simulation.calculate('saldom2', period)\n",
    "\n",
    "        \"\"\"agrégation des RDB adultes + supplément famille monoparentale\"\"\"\n",
    "        rdb = self.sum_by_entity(rdb_holder)\n",
    "        sum_rdb_adulte = self.sum_by_entity(tspr_holder)\n",
    "\n",
    "        credit_impot_monoparentales_holder = simulation.calculate_add('credit_impot_monoparentales', period)\n",
    "\n",
    "\n",
    "        return period, max_(0, rbg + sum_rdb_adulte + credit_impot_monoparentales_holder - charges_deduc - (dfppce + donapd * garext) - (aidper, ci_garext, quaenv, saldom2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#- variable ip_net -  irpp après décote (foyer fiscal):\n",
    "#- la décote est évacuée du calcul de l'impôt\n",
    "\n",
    "class ip_net(Variable):\n",
    "\n",
    "    def function(self, simulation, period):\n",
    "        '''\n",
    "        irpp après décote\n",
    "        '''\n",
    "        period = period.this_year\n",
    "        ir_plaf_qf = simulation.calculate('ir_plaf_qf', period)\n",
    "        cncn_info_holder = simulation.compute('cncn_info', period)\n",
    "        decote = simulation.calculate('decote', period)\n",
    "        taux = simulation.legislation_at(period.start).ir.rpns.taux16\n",
    "\n",
    "        return period, max_(0, ir_plaf_qf + self.sum_by_entity(cncn_info_holder) * taux)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#- variable reductions (Foyers Fiscaux) :\n",
    "#- Les réductions d'impôt sont toutes supprimées : accult, adhcga, assvie, cappme, creaen, daepad, deffor, doment, domlog, domsoc, duflot, ecodev, ecpess, intagr, intcon, intemp, invfor, invlst, invrev, ip_net, locmeu, mecena, mohist, patnat, prcomp, reduction_impot_exceptionnelle, repsoc, resimm, rsceha, saldom, scelli, sofica, sofipe, spfcpi\n",
    "#- Rappelons que les réductions d'impôt suivantes avaient été basculées vers des abattements :  dfppce (dons aux oeuvres), donapd (dons aide à la personne), garext (frais de garde extérieur) \n",
    "\n",
    "class reductions(Variable):\n",
    "\n",
    "    @dated_function(start = date(2014, 1, 1))  # Not checked\n",
    "    def function_2014__(self, simulation, period):\n",
    "        '''\n",
    "        Renvoie la somme des réductions d'impôt à intégrer pour l'année 2014 et + (non vérifiée)\n",
    "        '''\n",
    "        period = period.this_year\n",
    "        accult = simulation.calculate('accult', period)\n",
    "        adhcga = simulation.calculate('adhcga', period)\n",
    "        cappme = simulation.calculate('cappme', period)\n",
    "        creaen = simulation.calculate('creaen', period)\n",
    "        daepad = simulation.calculate('daepad', period)\n",
    "        deffor = simulation.calculate('deffor', period)\n",
    "        dfppce = simulation.calculate('dfppce', period)\n",
    "        doment = simulation.calculate('doment', period)\n",
    "        domlog = simulation.calculate('domlog', period)\n",
    "        donapd = simulation.calculate('donapd', period)\n",
    "        duflot = simulation.calculate('duflot', period)\n",
    "        ecpess = simulation.calculate('ecpess', period)\n",
    "        garext = simulation.calculate('garext', period)\n",
    "        intagr = simulation.calculate('intagr', period)\n",
    "        invfor = simulation.calculate('invfor', period)\n",
    "        invlst = simulation.calculate('invlst', period)\n",
    "        ip_net = simulation.calculate('ip_net', period)\n",
    "        locmeu = simulation.calculate('locmeu', period)\n",
    "        mecena = simulation.calculate('mecena', period)\n",
    "        mohist = simulation.calculate('mohist', period)\n",
    "        patnat = simulation.calculate('patnat', period)\n",
    "        prcomp = simulation.calculate('prcomp', period)\n",
    "        reduction_impot_exceptionnelle = simulation.calculate('reduction_impot_exceptionnelle', period)\n",
    "        repsoc = simulation.calculate('repsoc', period)\n",
    "        resimm = simulation.calculate('resimm', period)\n",
    "        rsceha = simulation.calculate('rsceha', period)\n",
    "        saldom = simulation.calculate('saldom', period)\n",
    "        scelli = simulation.calculate('scelli', period)\n",
    "        sofica = simulation.calculate('sofica', period)\n",
    "        spfcpi = simulation.calculate('spfcpi', period)\n",
    "\n",
    "        total_reductions = 0\n",
    "        return period, min_(ip_net, total_reductions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#- variable credits_impot (Foyers Fiscaux) :\n",
    "#- Les crédits d'impôt sont tous supprimés : accult, acqgpl, aidmob, assloy, autent, cotsyn, creimp, creimp_exc_2008, direpa, divide, drbail, inthab, jeunes, mecena, percvm, preetu, prlire\n",
    "#- Rappelons que les crédits d'impôt suivants savaient été basculés vers des abattements : aidper, ci_garext, quaenv, saldom2\n",
    "\n",
    "class credits_impot(Variable):\n",
    "\n",
    "    def function(self, simulation, period):\n",
    "\n",
    "            \"\"\" Crédits d'impôt crédités l'impôt sur les revenus de 2014 et + (non vérifié)\"\"\"\n",
    "            period = period.this_year\n",
    "            accult = simulation.calculate('accult', period)\n",
    "            aidper = simulation.calculate('aidper', period)\n",
    "            assloy = simulation.calculate('assloy', period)\n",
    "            autent = simulation.calculate('autent', period)\n",
    "            ci_garext = simulation.calculate('ci_garext', period)\n",
    "            cotsyn = simulation.calculate('cotsyn', period)\n",
    "            creimp = simulation.calculate('creimp', period)\n",
    "            direpa = simulation.calculate('direpa', period)\n",
    "            drbail = simulation.calculate('drbail', period)\n",
    "            inthab = simulation.calculate('inthab', period)\n",
    "            mecena = simulation.calculate('mecena', period)\n",
    "            preetu = simulation.calculate('preetu', period)\n",
    "            prlire = simulation.calculate('prlire', period)\n",
    "            quaenv = simulation.calculate('quaenv', period)\n",
    "            saldom2 = simulation.calculate('saldom2', period)\n",
    "\n",
    "            return period, 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'Individus' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-8db7d23e4b8a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[1;32mclass\u001b[0m \u001b[0mrdb\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mVariable\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m     \u001b[0mcolumn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mFloatCol\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0mentity_class\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mIndividus\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-14-8db7d23e4b8a>\u001b[0m in \u001b[0;36mrdb\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[1;32mclass\u001b[0m \u001b[0mrdb\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mVariable\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0mcolumn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mFloatCol\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m     \u001b[0mentity_class\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mIndividus\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m     \u001b[0mlabel\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34mu\"Revenu de base\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'Individus' is not defined"
     ]
    }
   ],
   "source": [
    "#- Mise en place d'un revenu de base adulte égal à RSA socle célibataire - forfait logement célibataire\n",
    "#- Pour les personnes en situation de handicap, le revenu de base est inclus dans l'Allocation Adulte Handicapé (AAH)\n",
    "\n",
    "\n",
    "class rdb(Variable):\n",
    "    column = FloatCol\n",
    "    entity_class = Individus\n",
    "    label = u\"Revenu de base\"\n",
    "\n",
    "    def function(self, simulation, period):\n",
    "        period = period.start.offset('first-of', 'month').period('month')\n",
    "        age = simulation.calculate('age') \n",
    "        rmi = simulation.legislation_at(period.start).minim.rmi\n",
    "        retraite_brute = simulation.calculate('retraite_brute',period)\n",
    "        chomage_brut = simulation.calculate('chomage_brut',period)\n",
    "        aah = simulation.calculate('aah',period)\n",
    "\n",
    "        return period, max_(((age >= 18)* rmi.rmi * ( 1 -rmi.forfait_logement.taux1) + not_(age >= 18) * 0) - aah, 0)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# On enlève les enfants du calcul du nbptr (quotient_familial.enf*)\n",
    "class nbptr(Variable):\n",
    "    def function(self, simulation, period):\n",
    "        '''\n",
    "        Nombre de parts du foyer\n",
    "        'foy'\n",
    "        note 1 enfants et résidence alternée (formulaire 2041 GV page 10)\n",
    "\n",
    "        quotient_familial.conj : nb part associées au conjoint d'un couple marié ou pacsé\n",
    "        quotient_familial.enf1 : nb part 2 premiers enfants\n",
    "        quotient_familial.enf2 : nb part enfants de rang 3 ou plus\n",
    "        quotient_familial.inv1 : nb part supp enfants invalides (I, G)\n",
    "        quotient_familial.inv2 : nb part supp adultes invalides (R)\n",
    "        quotient_familial.not31 : nb part supp note 3 : cases W ou G pour veuf, celib ou div\n",
    "        quotient_familial.not32 : nb part supp note 3 : personne seule ayant élevé des enfants\n",
    "        quotient_familial.not41 : nb part supp adultes invalides (vous et/ou conjoint) note 4\n",
    "        quotient_familial.not42 : nb part supp adultes anciens combattants (vous et/ou conjoint) note 4\n",
    "        quotient_familial.not6 : nb part supp note 6\n",
    "        quotient_familial.isol : demi-part parent isolé (T)\n",
    "        quotient_familial.edcd : enfant issu du mariage avec conjoint décédé;\n",
    "        '''\n",
    "        period = period.start.offset('first-of', 'month').period('year')\n",
    "        nb_pac = simulation.calculate('nb_pac', period)\n",
    "        maries_ou_pacses = simulation.calculate('maries_ou_pacses', period)\n",
    "        celibataire_ou_divorce = simulation.calculate('celibataire_ou_divorce', period)\n",
    "        veuf = simulation.calculate('veuf', period)\n",
    "        jeune_veuf = simulation.calculate('jeune_veuf', period)\n",
    "        nbF = simulation.calculate('nbF', period)\n",
    "        nbG = simulation.calculate('nbG', period)\n",
    "        nbH = simulation.calculate('nbH', period)\n",
    "        nbI = simulation.calculate('nbI', period)\n",
    "        nbR = simulation.calculate('nbR', period)\n",
    "        nbJ = simulation.calculate('nbJ', period)\n",
    "        caseP = simulation.calculate('caseP', period)\n",
    "        caseW = simulation.calculate('caseW', period)\n",
    "        caseG = simulation.calculate('caseG', period)\n",
    "        caseE = simulation.calculate('caseE', period)\n",
    "        caseK = simulation.calculate('caseK', period)\n",
    "        caseN = simulation.calculate('caseN', period)\n",
    "        caseF = simulation.calculate('caseF', period)\n",
    "        caseS = simulation.calculate('caseS', period)\n",
    "        caseL = simulation.calculate('caseL', period)\n",
    "        caseT = simulation.calculate('caseT', period)\n",
    "        quotient_familial = simulation.legislation_at(period.start).ir.quotient_familial\n",
    "\n",
    "        no_pac = nb_pac == 0  # Aucune personne à charge en garde exclusive\n",
    "        has_pac = not_(no_pac)\n",
    "        no_alt = nbH == 0  # Aucun enfant à charge en garde alternée\n",
    "        has_alt = not_(no_alt)\n",
    "\n",
    "        # # nombre de parts liées aux enfants à charge\n",
    "        # que des enfants en résidence alternée\n",
    "        enf1 = (no_pac & has_alt) * (quotient_familial.enf1 * min_(nbH, 2) * 0.5\n",
    "                                     + quotient_familial.enf2 * max_(nbH - 2, 0) * 0.5)\n",
    "        # pas que des enfants en résidence alternée\n",
    "        enf2 = (has_pac & has_alt) * ((nb_pac == 1) * (quotient_familial.enf1 * min_(nbH, 1) * 0.5\n",
    "            + quotient_familial.enf2 * max_(nbH - 1, 0) * 0.5) + (nb_pac > 1) * (quotient_familial.enf2 * nbH * 0.5))\n",
    "        # pas d'enfant en résidence alternée\n",
    "        enf3 = quotient_familial.enf1 * min_(nb_pac, 2) + quotient_familial.enf2 * max_((nb_pac - 2), 0)\n",
    "\n",
    "        enf = enf1 + enf2 + enf3\n",
    "        # # note 2 : nombre de parts liées aux invalides (enfant + adulte)\n",
    "        n2 = quotient_familial.inv1 * (nbG + nbI / 2) + quotient_familial.inv2 * nbR\n",
    "\n",
    "        # # note 3 : Pas de personne à charge\n",
    "        # - invalide\n",
    "\n",
    "        n31a = quotient_familial.not31a * (no_pac & no_alt & caseP)\n",
    "        # - ancien combatant\n",
    "        n31b = quotient_familial.not31b * (no_pac & no_alt & (caseW | caseG))\n",
    "        n31 = max_(n31a, n31b)\n",
    "        # - personne seule ayant élevé des enfants\n",
    "        n32 = quotient_familial.not32 * (no_pac & no_alt & ((caseE | caseK) & not_(caseN)))\n",
    "        n3 = max_(n31, n32)\n",
    "        # # note 4 Invalidité de la personne ou du conjoint pour les mariés ou\n",
    "        # # jeunes veuf(ve)s\n",
    "        n4 = max_(quotient_familial.not41 * (1 * caseP + 1 * caseF), quotient_familial.not42 * (caseW | caseS))\n",
    "\n",
    "        # # note 5\n",
    "        #  - enfant du conjoint décédé\n",
    "        n51 = quotient_familial.cdcd * (caseL & ((nbF + nbJ) > 0))\n",
    "        #  - enfant autre et parent isolé\n",
    "        n52 = quotient_familial.isol * caseT * (((no_pac & has_alt) * ((nbH == 1) * 0.5 + (nbH >= 2))) + 1 * has_pac)\n",
    "        n5 = max_(n51, n52)\n",
    "\n",
    "        # # note 6 invalide avec personne à charge\n",
    "        n6 = quotient_familial.not6 * (caseP & (has_pac | has_alt))\n",
    "\n",
    "        # # note 7 Parent isolé\n",
    "        n7 = quotient_familial.isol * caseT * ((no_pac & has_alt) * ((nbH == 1) * 0.5 + (nbH >= 2)) + 1 * has_pac)\n",
    "\n",
    "        # # Régime des mariés ou pacsés\n",
    "        #m = 1 + quotient_familial.conj + enf + n2 + n4\n",
    "        m = 1 + quotient_familial.conj + n2 + n4\n",
    "        \n",
    "        # # veufs  hors jeune_veuf\n",
    "        # v = 1 + enf + n2 + n3 + n5 + n6\n",
    "        v = 1 + n2 + n3 + n5 + n6\n",
    "        \n",
    "        # # celib div\n",
    "        #c = 1 + enf + n2 + n3 + n6 + n7\n",
    "        c = 1 + n2 + n3 + n6 + n7\n",
    "\n",
    "        return period, (maries_ou_pacses | jeune_veuf) * m + (veuf & not_(jeune_veuf)) * v + celibataire_ou_divorce * c\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Suppression des allocations familiales\n",
    "\n",
    "class af(Variable):\n",
    "\n",
    "    def function(self, simulation, period):\n",
    "        period = period.this_month\n",
    "        af_base = simulation.calculate('af_base', period)\n",
    "        af_majoration = simulation.calculate('af_majoration', period)\n",
    "        af_allocation_forfaitaire = simulation.calculate('af_allocation_forfaitaire', period)\n",
    "\n",
    "        #return period, af_base + af_majoration + af_allocation_forfaitaire\n",
    "        return period, af_base * 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Suppression du complément familial\n",
    "\n",
    "class cf(Variable):\n",
    "\n",
    "    def function(self, simulation, period):\n",
    "        '''\n",
    "        L'allocation de base de la paje n'est pas cumulable avec le complément familial\n",
    "        '''\n",
    "        period = period.this_month\n",
    "        paje_base = simulation.calculate('paje_base', period)\n",
    "        apje_temp = simulation.calculate('apje_temp', period)\n",
    "        ape_temp = simulation.calculate('ape_temp', period)\n",
    "        cf_montant = simulation.calculate('cf_montant', period)\n",
    "        residence_mayotte = simulation.calculate('residence_mayotte', period)\n",
    "\n",
    "        cf_brut = not_(paje_base) * (apje_temp <= cf_montant) * (ape_temp <= cf_montant) * cf_montant\n",
    "        # return period, not_(residence_mayotte) * round(cf_brut, 2)\n",
    "        return period, not_(residence_mayotte) * round(cf_brut, 2) * 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Suppression de l'allocation de rentrée scolaire\n",
    "\n",
    "class ars(Variable):\n",
    "\n",
    "    def function(self, simulation, period):\n",
    "        '''\n",
    "        Allocation de rentrée scolaire brute de CRDS\n",
    "        '''\n",
    "        period_br = period.this_year\n",
    "        return period_br, self.zeros()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Création d'un revenu de base enfant - Version individus au niveau des allocations familiales actuelles\n",
    "\n",
    "class rdb_enf(Variable):\n",
    "    column = FloatCol\n",
    "    entity_class = Individus\n",
    "    label = u\"Revenu de base enfant\"\n",
    "\n",
    "    def function(self, simulation, period):\n",
    "        period = period.start.offset('first-of', 'month').period('month')\n",
    "        age = simulation.calculate('age')\n",
    "        P = simulation.legislation_at(period.start).fam.af        \n",
    "        bmaf = P.bmaf\n",
    "\n",
    "        return period, ((age < 14) * 0.41 + not_(age < 14) * 0.57) * bmaf * (age <= 18)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#- Mise en place d'un crédit d'impot familles monoparentales montant (150€)\n",
    "class credit_impot_monoparentales(Variable):\n",
    "    column = FloatCol\n",
    "    entity_class = Menages\n",
    "    label = u\"credit_impot_monoparentales\"\n",
    "\n",
    "    def function(self, simulation, period):\n",
    "        period = period.start.offset('first-of', 'month').period('month')\n",
    "        nb_enf_a_charge = simulation.calculate('nombre_enfants_a_charge_menage',period)\n",
    "        caseT = simulation.calculate('caseT',period) #Egal True si le parent est isolé\n",
    "      \n",
    "        \n",
    "        #return period, or_(and_(age_holder >= 18, nb_enf_a_charge > 0, caseT), or_(age_holder < 18, nb_enf_a_charge <= 0, not_(caseT)) * 0) * 100\n",
    "        return period, (nb_enf_a_charge > 0) * (caseT) * 150\n",
    "    #Si le parent est isolé, avec au moins un enfant, et qu'il est majeur il reçoit la pension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#- Supprimer le RSA\n",
    "class rsa_socle(Variable):\n",
    "\n",
    "    def function(self, simulation, period):\n",
    "        period = period.this_month\n",
    "        nb_par = simulation.calculate('nb_par', period)\n",
    "        eligib = simulation.calculate('rsa_eligibilite', period)\n",
    "        nb_enfant_rsa = simulation.calculate('nb_enfant_rsa', period)\n",
    "        rmi = simulation.legislation_at(period.start).minim.rmi\n",
    "\n",
    "        nbp = nb_par + nb_enfant_rsa\n",
    "\n",
    "        taux = (\n",
    "            1 +\n",
    "            (nbp >= 2) * rmi.txp2 +\n",
    "            (nbp >= 3) * rmi.txp3 +\n",
    "            (nbp >= 4) * ((nb_par == 1) * rmi.txps + (nb_par != 1) * rmi.txp3) +\n",
    "            max_(nbp - 4, 0) * rmi.txps\n",
    "        )\n",
    "        #on met à zéro\n",
    "        return period, eligib * rmi.rmi * taux * 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#- Supprimer la prime d'activité (PPA)\n",
    "class ppa(DatedVariable):\n",
    "\n",
    "    @dated_function(start = date(2016, 1, 1))\n",
    "    def function(self, simulation, period):\n",
    "        period = period.this_month\n",
    "        seuil_non_versement = simulation.legislation_at(period.start).minim.ppa.seuil_non_versement\n",
    "        # éligibilité étudiants\n",
    "\n",
    "        ppa_eligibilite_etudiants = simulation.calculate('ppa_eligibilite_etudiants', period)\n",
    "        m_1 = period.last_month\n",
    "        m_2 = m_1.last_month\n",
    "        m_3 = m_2.last_month\n",
    "        ppa = sum(simulation.calculate('ppa_fictive', period2, extra_params = [period])\n",
    "            for period2 in [m_1, m_2, m_3]) / 3\n",
    "        ppa = ppa * ppa_eligibilite_etudiants * (ppa >= seuil_non_versement)\n",
    "\n",
    "        return period, ppa*0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#- Intégrer le revenu de base au revenu disponible\n",
    "#- (la ppe est maintenue dans cette simulation, jusqu'à sa disparition en 2016)\n",
    "\n",
    "class revdisp(Variable):\n",
    "\n",
    "    def function(self, simulation, period):\n",
    "        '''\n",
    "        Revenu disponible - ménage\n",
    "        'men'\n",
    "        '''\n",
    "        period = period.start.period('year').offset('first-of')\n",
    "        rev_trav_holder = simulation.compute('rev_trav', period)\n",
    "        pen_holder = simulation.compute('pen', period)\n",
    "        rev_cap_holder = simulation.compute('rev_cap', period)\n",
    "        psoc_holder = simulation.compute('psoc', period)\n",
    "        ppe_holder = simulation.compute('ppe', period)\n",
    "        impo = simulation.calculate('impo', period)\n",
    "        rdb_holder = simulation.calculate_add('rdb', period)\n",
    "        credit_impot_monoparentales_holder = simulation.calculate_add('credit_impot_monoparentales', period)\n",
    "        rdb_enf_holder = simulation.calculate_add('rdb_enf', period)\n",
    "\n",
    "        pen = self.sum_by_entity(pen_holder)\n",
    "        ppe = self.cast_from_entity_to_role(ppe_holder, role = VOUS)\n",
    "        ppe = self.sum_by_entity(ppe)\n",
    "        psoc = self.cast_from_entity_to_role(psoc_holder, role = CHEF)\n",
    "        psoc = self.sum_by_entity(psoc)\n",
    "        rev_cap = self.sum_by_entity(rev_cap_holder)\n",
    "        rev_trav = self.sum_by_entity(rev_trav_holder)\n",
    "        rdb = self.sum_by_entity(rdb_holder)\n",
    "        rdb_enf = self.sum_by_entity(rdb_enf_holder)\n",
    "        \n",
    "        return period, rev_trav + pen + rev_cap + psoc + ppe + impo + rdb + credit_impot_monoparentales_holder + rdb_enf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Legislation JSON related helpers\n",
    "\n",
    "from openfisca_core import legislations, periods\n",
    "\n",
    "\n",
    "def get_node(legislation_json, path):\n",
    "    '''\n",
    "    Return a node in the `legislation_json` tree at the given `path`.\n",
    "    '''\n",
    "    node = legislation_json\n",
    "    for key in path:\n",
    "        assert 'children' in node, 'Expected \"children\" key, got: {}'.format(legislation_json.keys())\n",
    "        assert key in node['children'], 'Expected \"{}\" key, got: {}'.format(key, legislation_json['children'].keys())\n",
    "        node = node['children'][key]\n",
    "    return node\n",
    "\n",
    "\n",
    "def is_scale(node):\n",
    "    '''\n",
    "    Returns True if the given `node` is a \"Scale\" (Barème in French).\n",
    "    '''\n",
    "    return node.get('@type') == 'Scale' and isinstance(node.get('brackets'), list)\n",
    "\n",
    "\n",
    "def replace_rate(scale_node, period, new_rate, old_rate=None, bracket_index=None):\n",
    "    '''\n",
    "    In a given `scale_node`, for a given `period`, replace either:\n",
    "        - an `old_rate` by a `new_rate`\n",
    "        - a `new_rate` given a `bracket_index`\n",
    "    Modifies the `scale_node`.\n",
    "    '''\n",
    "    assert bool(old_rate is not None) ^ bool(bracket_index is not None), 'You must provide either `old_rate` or `bracket_index`'\n",
    "    assert is_scale(scale_node), 'Scale node expected'\n",
    "    period = periods.period(period)\n",
    "    if bracket_index is not None:\n",
    "        bracket = scale_node['brackets'][bracket_index]\n",
    "        for rate in bracket['rate']:\n",
    "            if rate['start'] >= str(period.start) and ('stop' not in rate or rate['stop'] <= str(period.stop)):\n",
    "                rate['value'] = new_rate\n",
    "    elif old_rate is not None:\n",
    "        for bracket in scale_node['brackets']:\n",
    "            for rate in bracket['rate']:\n",
    "                if rate['value'] == old_rate and rate['start'] >= str(period.start) and (\n",
    "                    'stop' not in rate or rate['stop'] <= str(period.stop)):\n",
    "                    rate['value'] = new_rate\n",
    "\n",
    "                    \n",
    "def at_instant(node, instant):\n",
    "    instant = str(periods.instant(instant))\n",
    "    dated_node = legislations.generate_dated_node_json(node, instant)\n",
    "    return dated_node\n",
    "\n",
    "\n",
    "def print_json(node):\n",
    "    print(json.dumps(node, indent=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# #- CHANGEMENT DU CALCUL DE L'IRPP\n",
    "# #- le barème est modifié avec les tranches 0%, 30%, 41%, 45%\n",
    "# #- les tranches sont modifiées : RDB adulte, XXXXX €, XXXXX €\n",
    "\n",
    "# def modify_legislation_json(reference_legislation_json):\n",
    "#     ir_bareme = get_node(reference_legislation_json, ['ir', 'bareme'])\n",
    "#     assert is_scale(ir_bareme)\n",
    "#     period = periods.period(2016)\n",
    "#     # print_json(at_instant(ir_bareme, period.start))\n",
    "\n",
    "#     replace_rate(ir_bareme, period=period, bracket_index=0, new_rate=0.3)\n",
    "#     replace_rate(ir_bareme, period=period, bracket_index=1, new_rate=0.3)\n",
    "#     replace_rate(ir_bareme, period=period, bracket_index=2, new_rate=0.3)\n",
    "\n",
    "#     # print_json(at_instant(ir_bareme, period.start))\n",
    "#     return reference_legislation_json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def create_scale_for_period(period, brackets):\n",
    "    start = str(period.start)\n",
    "    stop = str(period.stop)\n",
    "    return {\n",
    "        \"@type\": \"Scale\",\n",
    "        \"brackets\": [\n",
    "            {\n",
    "                \"threshold\": [{\"start\": start, \"stop\": stop, \"value\": threshold}],\n",
    "                \"rate\": [{\"start\": start, \"stop\": stop, \"value\": rate}]\n",
    "                }\n",
    "            for (threshold, rate) in brackets\n",
    "            ],\n",
    "        }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "period = periods.period(2016)\n",
    "ir_bareme = create_scale_for_period(\n",
    "    period=period,\n",
    "    brackets=[\n",
    "        (0, 0.25),\n",
    "        (10000, 0.30),\n",
    "        (300000, 0.50),\n",
    "        ],\n",
    "    )\n",
    "print json.dumps(ir_bareme, indent=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# - CHANGEMENT DU CALCUL DE L'IRPP\n",
    "#- le barème est généré avec les tranches 0%, 30%, 41%, 45%\n",
    "#- les tranches sont générées : RDB adulte, XXXXX €, XXXXX €\n",
    "\n",
    "def modify_legislation_json(reference_legislation_json):\n",
    "    period = periods.period(2016)\n",
    "\n",
    "    ir_bareme = create_scale_for_period(\n",
    "        period=period,\n",
    "        brackets=[\n",
    "            (0, 0.25),\n",
    "            (10000, 0.30),\n",
    "            (300000, 0.50),\n",
    "            ],\n",
    "        )\n",
    "    print ir_bareme\n",
    "#     print_json(at_instant(ir_bareme, period.start))\n",
    "    return reference_legislation_json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class ReformeRevenuDeBase_IRPP(Reform):\n",
    "    name = u\"Réforme Revenu de base par IRPP\"\n",
    "    \n",
    "    # On écrit dans la parenthèse ci-dessous toutes les variables que l'on a redéfinies\n",
    "    def apply(self):\n",
    "        for variable in [salaire_imposable, chomage_imposable, retraite_imposable, revenu_assimile_salaire_apres_abattements, credits_impot, cd1, rng, ip_net, rdb, nbptr, af, cf, ars, rdb_enf, credit_impot_monoparentales, rsa_socle, ppa, revdisp]:\n",
    "            self.update_variable(variable)\n",
    "        self.modify_legislation_json(modifier_function = modify_legislation_json)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "reform = ReformeRevenuDeBase_IRPP(tax_benefit_system)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "parent1_salaire_de_base = 60000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "scenario_ref_individu_seul = tax_benefit_system.new_scenario().init_single_entity(\n",
    "    period = 2014,\n",
    "    parent1 = dict(\n",
    "        date_naissance = date(1980, 1, 1),\n",
    "        salaire_de_base = parent1_salaire_de_base,\n",
    "        statut_marital = u'Célibataire',\n",
    "        ),\n",
    "    foyer_fiscal = dict(\n",
    "        caseT = True,\n",
    "        ),\n",
    "    enfants = [\n",
    "        dict(\n",
    "            date_naissance = date(2010, 1, 1),\n",
    "            ),\n",
    "        ],\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "simulation_ref_individu_seul = scenario_ref_individu_seul.new_simulation(debug = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "scenario_rdb_individu_seul = reform.new_scenario().init_single_entity(\n",
    "    period = 2014,\n",
    "    parent1 = dict(\n",
    "        date_naissance = date(1980, 1, 1),\n",
    "        salaire_de_base = parent1_salaire_de_base,\n",
    "        statut_marital = u'Célibataire',\n",
    "        ),\n",
    "    foyer_fiscal = dict(\n",
    "        caseT = True,\n",
    "        ),\n",
    "    enfants = [\n",
    "        dict(\n",
    "            date_naissance = date(2010, 1, 1),\n",
    "            ),\n",
    "        ],\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "simulation_rdb_individu_seul = scenario_rdb_individu_seul.new_simulation(debug = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculs de référence (revenu disponible, IR, RSA, CSG imposable/deductible, impot total) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "simulation_ref_individu_seul.calculate('irpp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "simulation_rdb_individu_seul.calculate('irpp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "simulation_ref_individu_seul.calculate_add('rsa')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "simulation_ref_individu_seul.calculate_add('csg_imposable_salaire')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "simulation_ref_individu_seul.calculate_add('csg_deductible_salaire')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "simulation_ref_individu_seul.calculate_add('tot_impot')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculs avec réforme RDB (revenu disponible, IR, RSA, CSG imposable/deductible, impot total) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "simulation_rdb_individu_seul.calculate('revdisp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "simulation_rdb_individu_seul.calculate('irpp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "simulation_rdb_individu_seul.calculate('csg_deductible_salaire', '2014-01')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "simulation_rdb_individu_seul.calculate('tot_impot')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# trace\n",
    "simulation_rdb_individu_seul.calculate('tot_impot')\n",
    "#print web_tools.get_trace_tool_link(scenario, ['tot_impot'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}