def test_check(): for employee_type, test_parameters in test_case_by_employee_type.iteritems(): period = test_parameters.get("period", default_period) parent1 = dict( birth = datetime.date(periods.period(period).start.year - 40, 1, 1), ) parent1.update(test_parameters['input_variables']) simulation = tax_benefit_system.new_scenario().init_single_entity( period = period, parent1 = parent1, ).new_simulation(debug = True) for variable, amounts in test_parameters['output_variables'].iteritems(): if isinstance(amounts, dict): for period_str, amount in amounts.iteritems(): output = simulation.calculate(variable, period = periods.period(period_str)) variable_message = "{} at {}".format(variable, period_str) yield assert_variable, variable_message, employee_type, amount, output else: output = simulation.calculate(variable) variable_message = variable amount = amounts yield assert_variable, variable_message, employee_type, amount, output
def create_simulation(year = 2014, bareme = False): simulation_period = periods.period('year', year) reform = prime_activite.build_reform(tax_benefit_system) parent1 = dict( birth = datetime.date(year - 40, 1, 1), salaire_de_base = 10000 if bareme is False else None, ) # parent2 = dict( # birth = datetime.date(year - 40, 1, 1), # salaire_de_base = 0, # ) # Adding a husband/wife on the same tax sheet (foyer) menage = dict( loyer = 1000, so = 4, ) axes = [ dict( count = 200, name = 'salaire_de_base', max = 300000, min = 0, ), ] scenario = reform.new_scenario().init_single_entity( axes = axes if bareme else None, # menage = menage, parent1 = parent1, # parent2 = parent2, period = periods.period('year', year), ) reference_simulation = scenario.new_simulation(debug = True, reference = True) reform_simulation = scenario.new_simulation(debug = True) return reform_simulation, reference_simulation
def test_check(): for employee_type, test_parameters in test_case_by_employee_type.iteritems(): Reform = reforms.make_reform( key = u'smic_h_b_9_euros', name = u"Réforme pour simulation ACOSS SMIC horaire brut fixe à 9 euros", reference = tax_benefit_system, ) reform = Reform() reform.modify_legislation_json(modifier_function = modify_legislation_json) simulation_period = 2011 parent1 = dict( birth = datetime.date(periods.period(simulation_period).start.year - 40, 1, 1), ) parent1.update(test_parameters['input_variables']) simulation = reform.new_scenario().init_single_entity( period = simulation_period, parent1 = parent1, ).new_simulation(debug = True) for variable, amounts in test_parameters['output_variables'].iteritems(): if isinstance(amounts, dict): for period_str, amount in sorted(amounts.iteritems()): output = simulation.calculate_add_divide(variable, period = periods.period(period_str)) variable_message = "{} at {}".format(variable, period_str) yield assert_variable, variable_message, employee_type, amount, output else: output = simulation.calculate(variable) variable_message = variable amount = amounts yield assert_variable, variable_message, employee_type, amount, output
def test_cesthra_invalidee(): year = 2012 reform = cesthra_invalidee.build_reform(base.tax_benefit_system) scenario = reform.new_scenario().init_single_entity( axes = [ dict( count = 10, max = 30000, min = 0, name = 'sal', ), ], period = periods.period('year', year), parent1 = dict(birth = datetime.date(year - 40, 1, 1)), parent2 = dict(birth = datetime.date(year - 40, 1, 1)), enfants = [ dict(birth = datetime.date(year - 9, 1, 1)), dict(birth = datetime.date(year - 9, 1, 1)), ], ) reference_simulation = scenario.new_simulation(debug = True, reference = True) reference_impo = reference_simulation.calculate('impo') reference_revdisp = reference_simulation.calculate('revdisp', period = periods.period('year', year)) reform_impo = reference_simulation.calculate('impo') reform_revdisp = reference_simulation.calculate('revdisp', period = periods.period('year', year))
def create_randomly_initialized_survey_scenario_from_table(nb_persons, nb_groups, salary_max_value, rent_max_value, collection): variable_generators_by_period = { periods.period('2017-01'): [ { 'variable': 'salary', 'max_value': salary_max_value, }, { 'variable': 'rent', 'max_value': rent_max_value, } ], periods.period('2018-01'): [ { 'variable': 'salary', 'max_value': salary_max_value, }, ], } table_by_entity_by_period = random_data_generator(tax_benefit_system, nb_persons, nb_groups, variable_generators_by_period, collection) survey_scenario = AbstractSurveyScenario() survey_scenario.set_tax_benefit_systems(tax_benefit_system = tax_benefit_system) survey_scenario.used_as_input_variables = ['salary', 'rent', 'housing_occupancy_status'] survey_scenario.year = 2017 survey_scenario.collection = collection data = { 'input_data_table_by_entity_by_period': table_by_entity_by_period } survey_scenario.init_from_data(data = data) return survey_scenario
def init_variable_values(self, entity, instance_object, instance_id): for variable_name, variable_values in instance_object.items(): path_in_json = [entity.plural, instance_id, variable_name] try: entity.check_variable_defined_for_entity(variable_name) except ValueError as e: # The variable is defined for another entity raise SituationParsingError(path_in_json, e.args[0]) except VariableNotFound as e: # The variable doesn't exist raise SituationParsingError(path_in_json, str(e), code = 404) instance_index = self.get_ids(entity.plural).index(instance_id) if not isinstance(variable_values, dict): if self.default_period is None: raise SituationParsingError(path_in_json, "Can't deal with type: expected object. Input variables should be set for specific periods. For instance: {'salary': {'2017-01': 2000, '2017-02': 2500}}, or {'birth_date': {'ETERNITY': '1980-01-01'}}.") variable_values = {self.default_period: variable_values} for period_str, value in variable_values.items(): try: period(period_str) except ValueError as e: raise SituationParsingError(path_in_json, e.args[0]) variable = entity.get_variable(variable_name) self.add_variable_value(entity, variable, instance_index, instance_id, period_str, value)
def test_check(): reform = smic_h_b_9_euros(tax_benefit_system) for employee_type, test_parameters in test_case_by_employee_type.iteritems(): simulation_period = 2013 parent1 = dict( date_naissance = datetime.date(periods.period(simulation_period).start.year - 40, 1, 1), ) parent1.update(test_parameters['input_variables']) simulation = reform.new_scenario().init_single_entity( period = simulation_period, parent1 = parent1, ).new_simulation() for variable, amounts in test_parameters['output_variables'].iteritems(): if isinstance(amounts, dict): for period_str, amount in sorted(amounts.iteritems()): output = simulation.calculate_add_divide(variable, period = periods.period(period_str)) variable_message = "{} at {}".format(variable, period_str) yield assert_variable, variable_message, employee_type, amount, output else: output = simulation.calculate(variable) variable_message = variable amount = amounts yield assert_variable, variable_message, employee_type, amount, output
def get(self, period): if self.is_eternal: period = periods.period(ETERNITY) period = periods.period(period) values = self._arrays.get(period) if values is None: return None if isinstance(values, dict): return next(iter(values.values())) return values
def put(self, value, period): if self.is_eternal: period = periods.period(ETERNITY) period = periods.period(period) filename = str(period) path = os.path.join(self.storage_dir, filename) + '.npy' if isinstance(value, EnumArray): self._enums[path] = value.possible_values value = value.view(np.ndarray) np.save(path, value) self._files[period] = path
def delete(self, period = None): if period is None: self._arrays = {} return if self.is_eternal: period = periods.period(ETERNITY) period = periods.period(period) self._arrays = { period_item: value for period_item, value in self._arrays.items() if not period.contains(period_item) }
def create_simulation(year = 2014, bareme = False): simulation_period = periods.period('year', year) reference_legislation_json = tax_benefit_system.legislation_json reform_legislation_json = reforms.update_legislation( legislation_json = reference_legislation_json, path = ('children', 'ir', 'children', 'bareme', 'slices', 0, 'rate'), period = simulation_period, value = 1, ) Reform = reforms.make_reform( name = u"Imposition à 100% dès le premier euro et jusqu'à la fin de la 1ère tranche", legislation_json = reform_legislation_json, reference = tax_benefit_system ) reform = Reform() parent1 = dict( birth = datetime.date(year - 40, 1, 1), salaire_de_base = 10000 if bareme is False else None, type_sal = 0, ) # parent2 = dict( # birth = datetime.date(year - 40, 1, 1), # salaire_de_base = 0, # ) # Adding a husband/wife on the same tax sheet (foyer) menage = dict( loyer = 1000, statut_occupation = 4, ) axes = [ dict( count = 200, name = 'salaire_de_base', max = 300000, min = 0, ), ] scenario = reform.new_scenario().init_single_entity( axes = axes if bareme else None, menage = menage, parent1 = parent1, # parent2 = parent2, period = periods.period('year', year), ) reference_simulation = scenario.new_simulation(debug = True, reference = True) reform_simulation = scenario.new_simulation(debug = True) return reform_simulation, reference_simulation
def create_simulations(year, ind_variables, foy_variables): # couple simulation_couple = base.tax_benefit_system.new_scenario().init_single_entity( axes = axe(), parent1 = parent(2010, 1), parent2 = parent(2010, 1), menage = dict(statut_occupation = 4), period = periods.period('year', year), ).new_simulation(debug = True, reference = True) # couple_enfant simulation_couple_enfant = base.tax_benefit_system.new_scenario().init_single_entity( axes = axe(), parent1 = parent(2010, 1), parent2 = parent(2010, 1), enfants = [enfant(2010), enfant(2010)], menage = dict(statut_occupation = 4), period = periods.period('year', year), ).new_simulation(debug = True, reference = True) # celibataire simulation_celib = base.tax_benefit_system.new_scenario().init_single_entity( axes = axe(), parent1 = parent(2010, 1), menage = dict(statut_occupation = 4), period = periods.period('year', year) ).new_simulation(debug = True, reference = True) # celibataire avec 1 enfant simulation_celib_enfant = base.tax_benefit_system.new_scenario().init_single_entity( axes = axe(), parent1 = parent(2010, 1), enfants = [enfant(2010)], menage = dict(statut_occupation = 4), period = periods.period('year', year), ).new_simulation(debug = True, reference = True) d_couple = make_sim(simulation_couple, ind_variables=ind_variables, foy_variables = foy_variables) d_couple_enfant = make_sim(simulation_couple_enfant, ind_variables=ind_variables, foy_variables = foy_variables) d_celib = make_sim(simulation_celib, ind_variables=ind_variables, foy_variables=foy_variables) d_celib_enfant = make_sim(simulation_celib_enfant, ind_variables=ind_variables, foy_variables=foy_variables) df_by_type_menage = dict() df_by_type_menage['couple'] = d_couple df_by_type_menage['couple_enfant'] = d_couple_enfant df_by_type_menage['celib'] = d_celib df_by_type_menage['celib_enfant'] = d_celib_enfant return df_by_type_menage
def test_parametric_reform(year = 2014): reference_legislation_json = tax_benefit_system.legislation_json reform_legislation_json = copy.deepcopy(reference_legislation_json) assert reform_legislation_json['children']['ir']['children']['bareme']['slices'][0]['rate'] == 0 reform_legislation_json['children']['ir']['children']['bareme']['slices'][0]['rate'] = 1 reform = reforms.Reform( name = "IR_100_tranche_1", label = u"Imposition à 100% dès le premier euro et jusqu'à la fin de la 1ère tranche", legislation_json = reform_legislation_json, reference_legislation_json = reference_legislation_json ) scenario = tax_benefit_system.new_scenario().init_single_entity( axes = [ dict( count = 3, name = 'sali', max = 100000, min = 0, ), ], period = periods.period('year', year), parent1 = dict(birth = datetime.date(year - 40, 1, 1)), ) simulation = scenario.new_simulation(debug = True) assert max(abs(simulation.calculate('impo') - [0, -7889.20019531, -23435.52929688])) < .01 reform_simulation = reform.new_simulation(debug = True, scenario = scenario) assert reform_simulation.compact_legislation is not None assert max(abs(reform_simulation.calculate('impo') - [0., -13900.20019531, -29446.52929688])) < .0001
def check_sal(type_sal, year = 2014): period = periods.period("{}-01".format(year)) single_entity_kwargs = dict( axes = [dict(count = 101, max = 2000, min = 40, name = 'salaire_de_base')], # TODO: min = 0 period = period, parent1 = dict( birth = datetime.date(year - 40, 1, 1), type_sal = type_sal, ), ) simulation = tax_benefit_system.new_scenario().init_single_entity( **single_entity_kwargs ).new_simulation(debug = False) brut = simulation.get_holder('salaire_de_base').array smic_horaire = simulation.legislation_at(period.start).cotsoc.gen.smic_h_b smic_mensuel = smic_horaire * 35 * 52 / 12 brut = simulation.get_holder('salaire_de_base').array simulation.get_or_new_holder('contrat_de_travail').array = brut < smic_mensuel # temps plein ou temps partiel simulation.get_or_new_holder('heures_remunerees_volume').array = brut // smic_horaire # temps plein ou partiel imposable = simulation.calculate('salaire_imposable') inversion_reform = inversion_revenus.build_reform(tax_benefit_system) inverse_simulation = inversion_reform.new_scenario().init_single_entity( **single_entity_kwargs).new_simulation(debug = True) inverse_simulation.get_holder('salaire_de_base').delete_arrays() inverse_simulation.get_or_new_holder('salaire_imposable_pour_inversion').array = imposable.copy() inverse_simulation.get_or_new_holder('contrat_de_travail').array = brut < smic_mensuel # temps plein ou partiel inverse_simulation.get_or_new_holder('heures_remunerees_volume').array = ( (brut // smic_horaire) * (brut < smic_mensuel) ) new_brut = inverse_simulation.calculate('salaire_de_base') assert_near(new_brut, brut, absolute_error_margin = 1)
def test_cesthra_invalidee(): year = 2012 period = periods.period(year) reform = cesthra_invalidee(tax_benefit_system) scenario = init_single_entity(reform.new_scenario(), axes = [[ dict( count = 10, max = 30000, min = 0, name = 'salaire_imposable', ), ]], period = period, parent1 = dict(date_naissance = datetime.date(year - 40, 1, 1)), parent2 = dict(date_naissance = datetime.date(year - 40, 1, 1)), enfants = [ dict(date_naissance = datetime.date(year - 9, 1, 1)), dict(date_naissance = datetime.date(year - 9, 1, 1)), ], ) reference_simulation = scenario.new_simulation(use_baseline = True) reference_impo = reference_simulation.calculate('impots_directs', period = period) assert reference_impo is not None reference_revenu_disponible = reference_simulation.calculate('revenu_disponible', period = period) assert reference_revenu_disponible is not None reform_simulation = scenario.new_simulation() reform_impots_directs = reform_simulation.calculate('impots_directs', period = period) assert reform_impots_directs is not None reform_revenu_disponible = reform_simulation.calculate('revenu_disponible', period = period) assert reform_revenu_disponible is not None
def test(): year = 2013 reform = landais_piketty_saez(tax_benefit_system) scenario = reform.new_scenario().init_single_entity( axes = [ dict( count = 3, max = 30000, min = 0, name = 'salaire_de_base', ), ], period = periods.period('year', year), parent1 = dict(date_naissance = datetime.date(year - 40, 1, 1)), # parent2 = dict(date_naissance = datetime.date(year - 40, 1, 1)), # enfants = [ # dict(date_naissance = datetime.date(year - 9, 1, 1)), # dict(date_naissance = datetime.date(year - 9, 1, 1)), # ], ) # reference_simulation = scenario.new_simulation(reference = True) # reform_simulation = scenario.new_simulation() reform_assiette_csg = reform_simulation.calculate('assiette_csg') reform_impot_revenu_lps = reform_simulation.calculate('impot_revenu_lps') assert_near( -reform_impot_revenu_lps, ((reform_assiette_csg - 10000) * .25 / 30000 + .25) * reform_assiette_csg, absolute_error_margin = 0.01, )
def net_plot(revenu, count = 11, max_revenu = 5000, min_revenu = 0): year = 2014 period = periods.period("{}-01".format(year)) if revenu == 'chomage': brut_name = 'chobrut' net_name = 'chonet' elif revenu == 'retraite': brut_name = 'rstbrut' net_name = 'rstnet' elif revenu == 'salaire': brut_name = 'salaire_de_base' net_name = 'salaire_net' else: return single_entity_kwargs = dict( axes = [[ dict(count = count, max = max_revenu, min = min_revenu, name = brut_name) ]], period = period, parent1 = dict( birth = datetime.date(year - 40, 1, 1), ), ) simulation = tax_benefit_system.new_scenario().init_single_entity( **single_entity_kwargs).new_simulation(debug = True) smic_horaire = simulation.legislation_at(period.start).cotsoc.gen.smic_h_b smic_mensuel = smic_horaire * 35 * 52 / 12 brut = simulation.get_holder(brut_name).array simulation.get_or_new_holder('contrat_de_travail').array = brut < smic_mensuel # temps plein ou temps partiel simulation.get_or_new_holder('heures_remunerees_volume').array = brut // smic_horaire # temps plein ou temps partiel net = simulation.calculate(net_name) inversion_reform = inversion_revenus.build_reform(tax_benefit_system) inverse_simulation = inversion_reform.new_scenario().init_single_entity( **single_entity_kwargs).new_simulation(debug = True) inverse_simulation.get_holder(brut_name).delete_arrays() inverse_simulation.get_or_new_holder(net_name).array = net.copy() inverse_simulation.get_or_new_holder('contrat_de_travail').array = brut < smic_mensuel # temps plein ou temps partiel inverse_simulation.get_or_new_holder('heures_remunerees_volume').array = ( (brut // smic_horaire) * (brut < smic_mensuel) ) print inverse_simulation.get_or_new_holder('contrat_de_travail').array print inverse_simulation.get_or_new_holder('heures_remunerees_volume').array new_brut = inverse_simulation.calculate(brut_name) pyplot.subplot(2, 1, 1) pyplot.plot(brut, net, 'ro', label = "direct") pyplot.plot(new_brut, net, 'db', label = "inversed") pyplot.legend() pyplot.subplot(2, 1, 2) pyplot.plot(brut, new_brut - brut, 'r-') pyplot.show() assert_near(new_brut, brut, absolute_error_margin = 1)
def create_simulation(data, period): result = simulations.Simulation(debug=False, period=period, tax_benefit_system=model.tax_benefit_system) # Initialize entities, assuming there is only one person and one of each other entities ("familles", # "foyers fiscaux", etc). for entity in result.entity_by_key_plural.itervalues(): entity.count = 1 entity.roles_count = 1 entity.step_size = 1 # Link person to its entities using ID & role. for entity in result.entity_by_key_plural.itervalues(): if not entity.is_persons_entity: holder = result.get_or_new_holder(entity.index_for_person_variable_name) holder.set_array(period, np.array([0])) holder = result.get_or_new_holder(entity.role_for_person_variable_name) holder.set_array(period, np.array([0])) # Inject all variables from query string into arrays. for column_name, value in data.iteritems(): column = model.tax_benefit_system.column_by_name[column_name] holder = result.get_or_new_holder(column_name) if period.unit == "year": holder.set_array(period, np.array([value], dtype=column.dtype)) elif period.unit == "month": # Inject inputs for all months of year year = period.start.year month_index = 1 while month_index <= 12: month = periods.period("{}-{:02d}".format(year, month_index)) holder.set_array(month, np.array([value], dtype=column.dtype)) month_index += 1 return result
def test_check_rsa(): '''test rsa pour un célibataire avec différent sali''' tests_list = [ {"year": 2014, "amount": 0, "rsa": 439}, {"year": 2014, "amount": 5000, "rsa": 281}, {"year": 2014, "amount": 10000, "rsa": 123}, {"year": 2014, "amount": 12000, "rsa": 59}, {"year": 2014, "amount": 13000, "rsa": 28}, {"year": 2014, "amount": 14000, "rsa": 0}, {"year": 2014, "amount": 15000, "rsa": 0}, {"year": 2014, "amount": 20000, "rsa": 0}, ] error_margin = 1 year = 2014 age = 29 revenu = "sali" for test in tests_list: print test amount = test["amount"] TaxBenefitSystem = openfisca_france.init_country() tax_benefit_system = TaxBenefitSystem() simulation = tax_benefit_system.new_scenario().init_single_entity( period = periods.period('year', year), parent1 = { 'birth': datetime.date(year - age + 1, 1, 1), revenu: amount, }, ).new_simulation(debug = True) calculated_rsa = simulation.calculate('rsa') / 12 assert abs(calculated_rsa - test['rsa']) < error_margin, \ 'calculated_rsa {} is not equal to expected value {}'.format(test['rsa'], calculated_rsa)
def custom_initialize(self, simulation): three_year_span_variables = [ 'categorie_salarie', # 'chomage_brut', 'chomage_imposable', 'contrat_de_travail', 'effectif_entreprise', 'heures_remunerees_volume', # 'hsup', 'pensions_alimentaires_percues', 'retraite_brute', 'retraite_imposable', 'salaire_de_base', ] for offset in [-1, -2]: for variable in three_year_span_variables: assert variable in self.used_as_input_variables, \ '{} is not a in the input_varaibles to be used {}'.format( variable, self.used_as_input_variables) holder = simulation.get_holder(variable) try: holder.set_input(simulation.period.offset(offset), simulation.calculate_add( variable, period = self.year)) except TypeError: # TODO Should explicitly test about Enums, avoid enums sum which is forbidden holder.set_input(simulation.period.offset(offset), simulation.calculate( variable, period = periods.period(self.year).first_month))
def run(reform_key, year): max_sal = 18000 count = 2 people = 1 reform = base.get_cached_reform( reform_key = reform_key, tax_benefit_system = base.tax_benefit_system, ) scenario = reform.new_scenario().init_single_entity( axes = [ dict( count = count, max = max_sal, min = 0, name = 'salaire_imposable', ), ], period = periods.period('year', year), parent1 = dict(date_naissance = datetime.date(year - 40, 1, 1)), parent2 = dict(date_naissance = datetime.date(year - 40, 1, 1)) if people >= 2 else None, enfants = [ dict(date_naissance = datetime.date(year - 9, 1, 1)) if people >= 3 else None, dict(date_naissance = datetime.date(year - 9, 1, 1)) if people >= 4 else None, ] if people >= 3 else None, ) reference_simulation = scenario.new_simulation(reference = True) reform_simulation = scenario.new_simulation() # error_margin = 1 impo = reference_simulation.calculate('impo') reform_impo = reform_simulation.calculate('impo')
def test(): year = 2013 reform = landais_piketty_saez.build_reform(tax_benefit_system) scenario = reform.new_scenario().init_single_entity( axes = [ dict( count = 3, max = 30000, min = 0, name = 'sali', ), ], period = periods.period('year', year), parent1 = dict(birth = datetime.date(year - 40, 1, 1)), # parent2 = dict(birth = datetime.date(year - 40, 1, 1)), # enfants = [ # dict(birth = datetime.date(year - 9, 1, 1)), # dict(birth = datetime.date(year - 9, 1, 1)), # ], ) # reference_simulation = scenario.new_simulation(debug = True, reference = True) # error_margin = 0.01 reform_simulation = scenario.new_simulation(debug = True) reform_assiette_csg = reform_simulation.calculate('assiette_csg') reform_impot_revenu_lps = reform_simulation.calculate('impot_revenu_lps') assert ((abs( -reform_impot_revenu_lps - ((reform_assiette_csg - 10000) * .25 / 30000 + .25) * reform_assiette_csg )) < error_margin).all(), "Error in LPS reform"
def finalize_variables_init(self, population): # Due to set_input mechanism, we must bufferize all inputs, then actually set them, # so that the months are set first and the years last. plural_key = population.entity.plural if plural_key in self.entity_counts: population.count = self.get_count(plural_key) population.ids = self.get_ids(plural_key) if plural_key in self.memberships: population.members_entity_id = np.array(self.get_memberships(plural_key)) population.members_role = np.array(self.get_roles(plural_key)) for variable_name in self.input_buffer.keys(): try: holder = population.get_holder(variable_name) except ValueError: # Wrong entity, we can just ignore that continue buffer = self.input_buffer[variable_name] periods = [period(period_str) for period_str in self.input_buffer[variable_name].keys()] # We need to handle small periods first for set_input to work sorted_periods = sorted(periods, key=key_period_size) for period_value in sorted_periods: values = buffer[str(period_value)] # Hack to replicate the values in the persons entity # when we have an axis along a group entity but not persons array = np.tile(values, population.count // len(values)) variable = holder.variable # TODO - this duplicates the check in Simulation.set_input, but # fixing that requires improving Simulation's handling of entities if (variable.end is None) or (period_value.start.date <= variable.end): holder.set_input(period_value, array)
def test(year = 2014): reform = plf2015.build_reform(base.tax_benefit_system) scenario = reform.new_scenario().init_single_entity( axes = [ dict( count = 10, max = 30000, min = 0, name = 'sali', ), ], period = periods.period('year', year), parent1 = dict(birth = datetime.date(year - 40, 1, 1)), # parent2 = dict(birth = datetime.date(year - 40, 1, 1)), # enfants = [ # dict(birth = datetime.date(year - 9, 1, 1)), # dict(birth = datetime.date(year - 9, 1, 1)), # ], ) reference_simulation = scenario.new_simulation(debug = True, reference = True) error_margin = 0.01 impo = reference_simulation.calculate('impo') print impo reform_simulation = scenario.new_simulation(debug = True) reform_impo = reform_simulation.calculate('impo') print reform_impo
def test_agem_from_age(): year = 2013 simulation = tax_benefit_system.new_scenario().init_single_entity( period = periods.period('year', year), parent1 = dict(age = 40), ).new_simulation(debug = True) assert_equal(simulation.calculate('agem'), 40 * 12)
def define_scenario(year = 2013): scenario = tax_benefit_system.new_scenario() scenario.init_single_entity( period = periods.period('year', year), parent1 = dict( activite = u'Actif occupé', birth = 1970, sali = 24000, statmarit = u'Célibataire', ), enfants = [ dict( activite = u'Étudiant, élève', birth = '2002-02-01', ), dict( activite = u'Étudiant, élève', birth = '2000-04-17', ), ], foyer_fiscal = dict( f8ta = 3000, ), ) scenario.suggest() return scenario
def test(year = 2013): max_sal = 18000 count = 2 people = 1 reform = plfr2014(tax_benefit_system) scenario = reform.new_scenario().init_single_entity( axes = [ dict( count = count, max = max_sal, min = 0, name = 'salaire_imposable', ), ], period = periods.period(year), parent1 = dict(date_naissance = datetime.date(year - 40, 1, 1)), parent2 = dict(date_naissance = datetime.date(year - 40, 1, 1)) if people >= 2 else None, enfants = [ dict(date_naissance = datetime.date(year - 9, 1, 1)) if people >= 3 else None, dict(date_naissance = datetime.date(year - 9, 1, 1)) if people >= 4 else None, ] if people >= 3 else None, ) reference_simulation = scenario.new_simulation(use_baseline = True) reform_simulation = scenario.new_simulation() # error_margin = 1 impots_directs = reference_simulation.calculate('impots_directs', period = year) # noqa F841 reform_impots_directs = reform_simulation.calculate('impots_directs', period = year) # noqa F841
def test(): year = 2013 reform = landais_piketty_saez.build_reform(base.tax_benefit_system) scenario = reform.new_scenario().init_single_entity( axes = [ dict( count = 10, max = 30000, min = 0, name = 'sali', ), ], period = periods.period('year', year), parent1 = dict(birth = datetime.date(year - 40, 1, 1)), parent2 = dict(birth = datetime.date(year - 40, 1, 1)), enfants = [ dict(birth = datetime.date(year - 9, 1, 1)), dict(birth = datetime.date(year - 9, 1, 1)), ], ) reference_simulation = scenario.new_simulation(debug = True, reference = True) error_margin = 0.01 af = reference_simulation.calculate('af') expected_af = [1532.16] * 10 assert_less(max(abs(expected_af - af)), error_margin) revdisp = reference_simulation.calculate('revdisp') reform_simulation = scenario.new_simulation(debug = True) reform_af = reform_simulation.calculate('af') assert_less(max(abs(expected_af - reform_af)), error_margin) reform_revdisp = reform_simulation.calculate('revdisp')
def test(year = 2013): max_sal = 18000 count = 2 people = 1 reform = plf2015(tax_benefit_system) scenario = reform.new_scenario().init_single_entity( axes = [ dict( count = count, max = max_sal, min = 0, name = 'salaire_imposable', ), ], period = periods.period(year), parent1 = dict(date_naissance = datetime.date(year - 40, 1, 1)), parent2 = dict(date_naissance = datetime.date(year - 40, 1, 1)) if people >= 2 else None, enfants = [ dict(date_naissance = datetime.date(year - 9, 1, 1)) if people >= 3 else None, dict(date_naissance = datetime.date(year - 9, 1, 1)) if people >= 4 else None, ] if people >= 3 else None, ) reference_simulation = scenario.new_simulation(use_baseline = True) reform_simulation = scenario.new_simulation() error_margin = 1 impots_directs = reference_simulation.calculate('impots_directs', period = year) reform_impots_directs = reform_simulation.calculate('impots_directs', period = year) ir_plaf_qf = reference_simulation.calculate('ir_plaf_qf', period = year) reform_ir_plaf_qf = reform_simulation.calculate('ir_plaf_qf', period = year) assert max(abs([0, 918] - ir_plaf_qf)) < error_margin assert max(abs([0, 911.4] - reform_ir_plaf_qf)) < error_margin assert max(abs([0, -869] - impots_directs)) < error_margin assert max(abs([0, -911.4 + (1135 - 911.4)] - reform_impots_directs)) < error_margin
def test_charge_loyer(): year = 2013 reform = base.get_cached_reform( reform_key = 'trannoy_wasmer', tax_benefit_system = base.tax_benefit_system, ) scenario = reform.new_scenario().init_single_entity( axes = [ dict( count = 10, max = 30000, min = 0, name = 'salaire_de_base', ), ], period = periods.period('year', year), parent1 = dict(date_naissance = datetime.date(year - 40, 1, 1)), parent2 = dict(date_naissance = datetime.date(year - 40, 1, 1)), enfants = [ dict(date_naissance = datetime.date(year - 9, 1, 1)), dict(date_naissance = datetime.date(year - 9, 1, 1)), ], menage = dict( loyer = 1000, ), ) reform_simulation = scenario.new_simulation() absolute_error_margin = 0.01 reform_charge_loyer = reform_simulation.calculate('charge_loyer') assert_near(reform_charge_loyer, [1000] * 10, absolute_error_margin = absolute_error_margin)
def test_check(): for employee_type, test_parameters in test_case_by_employee_type.iteritems( ): reference_legislation_json = tax_benefit_system.legislation_json reform_legislation_json = reforms.update_legislation( legislation_json=reference_legislation_json, path=('children', 'cotsoc', 'children', 'gen', 'children', 'smic_h_b', 'values'), period=periods.period("year", "2011"), value=9, ) reform = reforms.Reform( name=u'smic_h_b_9_euros', label= u"Réforme pour simulation ACOSS SMIC horaire brut fixe à 9 euros", legislation_json=reform_legislation_json, reference=tax_benefit_system, ) simulation_period = 2011 parent1 = dict(birth=datetime.date( periods.period(simulation_period).start.year - 40, 1, 1), ) parent1.update(test_parameters['input_variables']) simulation = reform.new_scenario().init_single_entity( period=simulation_period, parent1=parent1, ).new_simulation(debug=True) for variable, amounts in test_parameters['output_variables'].iteritems( ): if isinstance(amounts, dict): for period_str, amount in sorted(amounts.iteritems()): output = simulation.calculate( variable, period=periods.period(period_str)) variable_message = "{} at {}".format(variable, period_str) yield assert_variable, variable_message, employee_type, amount, output else: output = simulation.calculate(variable) variable_message = variable amount = amounts yield assert_variable, variable_message, employee_type, amount, output
def modify_legislation_json(reference_legislation_json_copy): # FIXME update_legislation is deprecated. reform_legislation_json = reforms.update_legislation( legislation_json=reference_legislation_json_copy, path=('children', 'cotsoc', 'children', 'gen', 'children', 'smic_h_b', 'values'), period=periods.period("year", "2013"), value=9, ) return reform_legislation_json
def modifier_un_parametre(self, parameters): print("modifier_un_parametre: {}".format(self.ppa_pente)) # Ceci décrit la periode sur laquelle va s'appliquer ce changement reform_year = 2018 reform_period = periods.period(reform_year) # Cette partie propose un changement de taux pour le barème 1 (le second) de l'impôt sur le revenu à partir du début 2017 parameters.prestations.minima_sociaux.ppa.pente.update(reform_period, value=self.ppa_pente) return parameters
def restore(self): self._files = files = {} # Restore self._files from content of storage_dir. for filename in os.listdir(self.storage_dir): if not filename.endswith('.npy'): continue path = os.path.join(self.storage_dir, filename) filename_core = filename.rsplit('.', 1)[0] period = periods.period(filename_core) files[period] = path
def __init__(self, tax_benefit_system=None, baseline_tax_benefit_system=None, data=None, year=None): super(CoteDIvoireSurveyScenario, self).__init__() if tax_benefit_system is None: tax_benefit_system = CoteDIvoireTaxBenefitSystem() self.set_tax_benefit_systems( tax_benefit_system=tax_benefit_system, baseline_tax_benefit_system=baseline_tax_benefit_system, ) assert year is not None self.year = year if data is None: return if 'input_data_frame_by_entity_by_period' in data: period = periods.period(year) dataframe_variables = set() assert period in data[ 'input_data_frame_by_entity_by_period'], "Period {} is not found in the data. Period(s) available(s) are {}".format( period, [ str(key) for key in data['input_data_frame_by_entity_by_period'].keys() ]) for entity_dataframe in data[ 'input_data_frame_by_entity_by_period'][period].values(): if not isinstance(entity_dataframe, pd.DataFrame): continue dataframe_variables = dataframe_variables.union( set(entity_dataframe.columns)) self.used_as_input_variables = list( set(tax_benefit_system.variables.keys()).intersection( dataframe_variables)) else: variables_from_stata_files = stata_files_to_data_frames( data, period=year) self.used_as_input_variables = list( set(tax_benefit_system.variables.keys()).intersection( set(variables_from_stata_files))) period = data["input_data_frame_by_entity_by_period"].keys()[0] input_data_frame_by_entity = data[ "input_data_frame_by_entity_by_period"].values()[0] person_data_frame = input_data_frame_by_entity['person'] person_data_frame['household_id'] = person_data_frame.id person_data_frame['person_id'] = person_data_frame.id person_data_frame['household_role_index'] = 0 data["input_data_frame_by_entity_by_period"][period] = dict( person=person_data_frame) self.init_from_data(data=data)
def calculate(self, variable_name, period, **parameters): """ Calculate the variable ``variable_name`` for the period ``period``, using the variable formula if it exists. :returns: A numpy array containing the result of the calculation """ entity = self.get_variable_entity(variable_name) holder = entity.get_holder(variable_name) variable = self.tax_benefit_system.get_variable(variable_name) if period is not None and not isinstance(period, periods.Period): period = periods.period(period) if self.trace: self.tracer.record_calculation_start(variable.name, period, **parameters) self._check_period_consistency(period, variable) extra_params = parameters.get('extra_params', ()) # First look for a value already cached cached_array = holder.get_array(period, extra_params) if cached_array is not None: if self.trace: self.tracer.record_calculation_end(variable.name, period, cached_array, **parameters) return cached_array max_nb_cycles = parameters.get('max_nb_cycles') if max_nb_cycles is not None: self.max_nb_cycles = max_nb_cycles # First, try to run a formula array = self._run_formula(variable, entity, period, extra_params, max_nb_cycles) # If no result, try a base function if array is None and variable.base_function: array = variable.base_function(holder, period, *extra_params) # If no result, use the default value if array is None: array = holder.default_array() self._clean_cycle_detection_data(variable.name) if max_nb_cycles is not None: self.max_nb_cycles = None holder.put_in_cache(array, period, extra_params) if self.trace: self.tracer.record_calculation_end(variable.name, period, array, **parameters) return array
def modify_legislation_json(reference_legislation_json_copy): reform_legislation_json = update_legislation( legislation_json=reference_legislation_json_copy, path=[ 'children', 'cotsoc', 'children', 'gen', 'children', 'smic_h_b', 'values' ], period=periods.period(2013), value=9, ) return reform_legislation_json
def _scenario(reform: Reform, count: int, _max: int, _min: int, name: str, year: int, people: int) -> object: return init_single_entity( reform.new_scenario(), axes=axes(count, _max, _min, name), period=periods.period(year), parent1=parent1(year), parent2=parent2(year, people), enfants=enfants(year, people), )
def test_without_annualize(monthly_variable): period = periods.period(2019) person = PopulationMock(monthly_variable) yearly_sum = sum( person('monthly_variable', month) for month in period.get_subperiods(MONTH)) assert monthly_variable.calculation_count == 11 assert yearly_sum == 1200
def put(self, value, period, extra_params=None): if self.is_eternal: period = periods.period(ETERNITY) period = periods.period(period) filename = str(period) if extra_params: extra_params = tuple(str(param) for param in extra_params) filename = '{}_{}'.format(filename, '_'.join(extra_params)) path = os.path.join(self.storage_dir, filename) + '.npy' if isinstance(value, EnumArray): self._enums[path] = value.possible_values value = value.view(np.ndarray) np.save(path, value) if not extra_params: self._files[period] = path else: if self._files.get(period) is None: self._files[period] = {} self._files[period][extra_params] = path
def modify_legislation_json(reference_legislation_json_copy): reform_year = 2016 reform_period = periods.period(reform_year) reference_legislation_json_copy = update_legislation( legislation_json=reference_legislation_json_copy, path=('children', 'ir', 'children', 'bareme', 'brackets', 3, 'rate'), period=reform_period, value=.27, ) return reference_legislation_json_copy
def export_node_to_csv(node, output_dir): check_for_doublons(node) csv_params = { param.metadata['ipp_csv_id']: param for param in node.get_descendants() if param.metadata.get('ipp_csv_id') } all_dates = extract_dates(csv_params) first_month = period(f"{all_dates[0].split('-')[0]}-01") last_month = period("2018-12") with open(f'{output_dir}/{node.name}.csv', mode='w') as csv_file: fieldnames = ['date'] + list(csv_params.keys()) writer = csv.DictWriter(csv_file, fieldnames=fieldnames) writer.writeheader() current_month = first_month while current_month <= last_month: writer.writerow(get_row(csv_params, current_month)) current_month = current_month.offset(1, MONTH)
def test_get_memory_usage(single): simulation = single salary_holder = simulation.person.get_holder('salary') memory_usage = salary_holder.get_memory_usage() assert memory_usage['total_nb_bytes'] == 0 salary_holder.set_input(periods.period(2017), numpy.asarray([30000])) memory_usage = salary_holder.get_memory_usage() assert memory_usage['nb_cells_by_array'] == 1 assert memory_usage['cell_size'] == 4 # float 32 assert memory_usage['nb_cells_by_array'] == 1 # one person assert memory_usage['nb_arrays'] == 12 # 12 months assert memory_usage['total_nb_bytes'] == 4 * 12 * 1
def test_set_input_dispatch_by_period(single): simulation = single variable = simulation.tax_benefit_system.get_variable( 'housing_occupancy_status') entity = simulation.household holder = Holder(variable, entity) holders.set_input_dispatch_by_period(holder, periods.period(2019), 'owner') assert holder.get_array('2019-01') == holder.get_array( '2019-12') # Check the feature assert holder.get_array('2019-01') is holder.get_array( '2019-12' ) # Check that the vectors are the same in memory, to avoid duplication
def poverty_rate(sim, period="2020-01-06", population="people", mode="ahc"): pop = sim.calculate("household_weight", period) * sim.calculate( f"{population}_in_household", period ) total = np.sum(pop) in_poverty = np.sum( pop * sim.calculate( f"in_poverty_{mode}", periods.period(period).first_week ) ) return in_poverty / total
def zip_period_with_values(period_str, values): period = periods.period(period_str) size = period.size if not isinstance(values, list): assert is_number(values) casted_values = [values / size] * size else: if size < len(values) and size == 1: size = len(values) casted_values = values period_list = [str(period.start.period(period.unit).offset(index)) for index in range(size)] return dict(zip(period_list, casted_values))
def set_table_in_survey(input_dataframe, entity, period, collection, survey_name, survey_label = None, table_label = None, table_name = None): period = periods.period(period) if table_name is None: table_name = entity + '_' + str(period) if table_label is None: table_label = "Input data for entity {} at period {}".format(entity, period) try: survey_collection = SurveyCollection.load(collection = collection) except configparser.NoOptionError: survey_collection = SurveyCollection(name = collection) except configparser.NoSectionError: # For tests data_dir = os.path.join( pkg_resources.get_distribution('openfisca-survey-manager').location, 'openfisca_survey_manager', 'tests', 'data_files', ) survey_collection = SurveyCollection( name = collection, config_files_directory = data_dir, ) try: survey = survey_collection.get_survey(survey_name) except AssertionError: survey = Survey( name = survey_name, label = survey_label or None, survey_collection = survey_collection, ) if survey.hdf5_file_path is None: config = survey.survey_collection.config directory_path = config.get("data", "output_directory") if not os.path.isdir(directory_path): log.warn("{} who should be the HDF5 data directory does not exist: we create the directory".format( directory_path)) os.makedirs(directory_path) survey.hdf5_file_path = os.path.join(directory_path, survey.name + '.h5') assert survey.hdf5_file_path is not None survey.insert_table(label = table_label, name = table_name, dataframe = input_dataframe) survey_collection.surveys = [ kept_survey for kept_survey in survey_collection.surveys if kept_survey.name != survey_name ] survey_collection.surveys.append(survey) collections_directory = survey_collection.config.get('collections', 'collections_directory') assert os.path.isdir(collections_directory), """{} who should be the collections' directory does not exist. Fix the option collections_directory in the collections section of your config file.""".format(collections_directory) collection_json_path = os.path.join(collections_directory, "{}.json".format(collection)) survey_collection.dump(json_file_path = collection_json_path)
def test_get_memory_usage_with_trace(single): simulation = single simulation.trace = True salary_holder = simulation.person.get_holder('salary') salary_holder.set_input(periods.period(2017), numpy.asarray([30000])) simulation.calculate('salary', '2017-01') simulation.calculate('salary', '2017-01') simulation.calculate('salary', '2017-02') simulation.calculate_add('salary', '2017') # 12 calculations memory_usage = salary_holder.get_memory_usage() assert memory_usage['nb_requests'] == 15 assert memory_usage[ 'nb_requests_by_array'] == 1.25 # 15 calculations / 12 arrays
def cleanup_period_in_json_or_python(value, state=None): if value is None: return None, None value = value.copy() if 'date' not in value: year = value.pop('year', None) if year is not None: value['date'] = year if 'period' not in value: date = value.pop('date', None) if date is not None: value['period'] = periods.period(date) return value, None
def stata_files_to_data_frames(data, period=None): assert period is not None period = periods.period(period) stata_file_by_entity = data.get('stata_file_by_entity') if stata_file_by_entity is None: return variables_from_stata_files = list() input_data_frame_by_entity_by_period = dict() input_data_frame_by_entity_by_period[periods.period( period)] = input_data_frame_by_entity = dict() for entity, file_path in stata_file_by_entity.items(): assert os.path.exists(file_path), "Invalid file path: {}".format( file_path) entity_data_frame = input_data_frame_by_entity[entity] = pd.read_stata( file_path) variables_from_stata_files += list(entity_data_frame.columns) data[ 'input_data_frame_by_entity_by_period'] = input_data_frame_by_entity_by_period return variables_from_stata_files
def calculate(self, variable_name, period): if period is not None and not isinstance(period, periods.Period): period = periods.period(period) self.tracer.enter_calculation(variable_name, period) try: result = self._calculate(variable_name, period) self.tracer.record_calculation_result(result) return result finally: self.tracer.exit_calculation() self.purge_cache_of_invalid_values()
def create_randomly_initialized_survey_scenario_from_table( nb_persons, nb_groups, salary_max_value, rent_max_value, collection, use_marginal_tax_rate): variable_generators_by_period = { periods.period('2017-01'): [{ 'variable': 'salary', 'max_value': salary_max_value, }, { 'variable': 'rent', 'max_value': rent_max_value, }], periods.period('2018-01'): [ { 'variable': 'salary', 'max_value': salary_max_value, }, ], } table_by_entity_by_period = random_data_generator( tax_benefit_system, nb_persons, nb_groups, variable_generators_by_period, collection) survey_scenario = AbstractSurveyScenario() survey_scenario.set_tax_benefit_systems( tax_benefit_system=tax_benefit_system) survey_scenario.used_as_input_variables = [ 'salary', 'rent', 'housing_occupancy_status' ] survey_scenario.year = 2017 survey_scenario.collection = collection data = { 'survey': 'input', 'input_data_table_by_entity_by_period': table_by_entity_by_period } survey_scenario.varying_variable = 'salary' survey_scenario.init_from_data(data=data, use_marginal_tax_rate=use_marginal_tax_rate) return survey_scenario
def test_allocations_familiales_imposables(): year = 2012 reform = base.get_cached_reform( reform_key='allocations_familiales_imposables', tax_benefit_system=base.tax_benefit_system, ) scenario = reform.new_scenario().init_single_entity( axes=[ dict( count=10, max=30000, min=0, name='salaire_imposable', ), ], period=periods.period('year', year), parent1=dict(date_naissance=datetime.date(year - 40, 1, 1)), parent2=dict(date_naissance=datetime.date(year - 40, 1, 1)), enfants=[ dict(date_naissance=datetime.date(year - 9, 1, 1)), dict(date_naissance=datetime.date(year - 9, 1, 1)), ], ) reference_simulation = scenario.new_simulation(reference=True) absolute_error_margin = 0.01 af = reference_simulation.calculate_add('af') expected_af = [(12 * 399.0) * .32 ] * 10 # Pas de hangement de BMAF en cours d'année assert_near(expected_af, af, absolute_error_margin=absolute_error_margin) rbg = reference_simulation.calculate('rbg') reform_simulation = scenario.new_simulation() reform_af = reform_simulation.calculate_add('af') assert_near(expected_af, reform_af, absolute_error_margin=absolute_error_margin) reform_af_imposables = reform_simulation.calculate( 'allocations_familiales_imposables') assert_near(expected_af, reform_af_imposables, absolute_error_margin=absolute_error_margin) reform_rbg = reform_simulation.calculate('rbg') assert_near(reform_rbg, rbg + af, absolute_error_margin=absolute_error_margin)
def test_basic_scenario(): period = periods.period('2015') scenario = tax_benefit_system.new_scenario() scenario.init_single_entity( period=period, parent1=dict( date_de_naissance=datetime.date(1972, 1, 1), salaire=50000, ), ) simulation = scenario.new_simulation() salaire = simulation.calculate('salaire', period) assert_equal(salaire, [50000]) impot_revenu = simulation.calculate('impot_revenu', period) assert_near(impot_revenu, [15000], absolute_error_margin=0.01)
def simple_check(tests): for test_parameters in tests: name = test_parameters["name"] period = test_parameters["period"] parent1 = dict(birth=datetime.date( periods.period(period).start.year - 40, 1, 1), ) parent1.update(test_parameters['input_variables']) simulation = tax_benefit_system.new_scenario().init_single_entity( period=period, parent1=parent1, ).new_simulation(debug=True) for variable, monthly_amount in test_parameters[ 'output_variables'].iteritems(): check_variable(simulation, variable, name, monthly_amount)
def test_check(): for test_parameters in iter_scenarios(): test_name = test_parameters["name"] period = test_parameters["period"] parent1 = dict(birth=datetime.date( periods.period(period).start.year - 40, 1, 1), ) parent1.update(test_parameters['input_variables']) simulation = tax_benefit_system.new_scenario().init_single_entity( period=period, parent1=parent1, ).new_simulation(debug=True) for variable_name, expected_value in test_parameters[ 'output_variables'].iteritems(): yield check_variable, simulation, variable_name, test_name, expected_value
def calculate(self, variable_name, period): """Calculate ``variable_name`` for ``period``.""" if period is not None and not isinstance(period, Period): period = periods.period(period) self.tracer.record_calculation_start(variable_name, period) try: result = self._calculate(variable_name, period) self.tracer.record_calculation_result(result) return result finally: self.tracer.record_calculation_end() self.purge_cache_of_invalid_values()
def test_nb_enfants(): test_case = deepcopy(TEST_CASE_AGES) year = 2013 test_case['period'] = year simulation = tax_benefit_system.new_scenario().init_from_dict( test_case).new_simulation() from openfisca_france.model.prestations.prestations_familiales.base_ressource import nb_enf month = periods.period(year).first_month assert_near(nb_enf(simulation.famille, month, 3, 18), [2, 0]) assert_near(nb_enf(simulation.famille, month, 19, 50), [0, 1]) # Adults don't count test_case['individus']['ind5']['autonomie_financiere'] = True simulation_2 = new_simulation(test_case) assert_near(nb_enf(simulation_2.famille, month, 19, 50), [0, 0])
def modify_legislation_json(reference_legislation_json_copy): reform_legislation_subtree = { "@type": "Node", "description": u"PLF 2015 sur revenus 2013 (Décote)", "children": { "seuil_celib": { "@type": "Parameter", "description": u"Seuil de la décote pour un célibataire", "format": "integer", "unit": "currency", "values": [ {'start': u'2014-01-01', }, {'start': u'2013-01-01', 'value': 1135}, ], }, "seuil_couple": { "@type": "Parameter", "description": u"Seuil de la décote pour un couple", "format": "integer", "unit": "currency", "values": [ {'start': u'2014-01-01', }, {'start': u'2013-01-01', 'value': 1870}, ], }, }, } reform_year = 2013 reform_period = periods.period(reform_year) reference_legislation_json_copy = update_legislation( legislation_json = reference_legislation_json_copy, path = ('children', 'impot_revenu', 'children', 'bareme', 'brackets', 1, 'rate'), period = reform_period, value = 0, ) reference_legislation_json_copy = update_legislation( legislation_json = reference_legislation_json_copy, path = ('children', 'impot_revenu', 'children', 'bareme', 'brackets', 2, 'threshold'), period = reform_period, value = 9690, ) reference_legislation_json_copy['children']['plf2015'] = reform_legislation_subtree return reference_legislation_json_copy
def test_check(): for test_parameters in tests: name = test_parameters["name"] period = test_parameters["period"] parent1 = dict(birth=datetime.date( periods.period(period).start.year - 40, 1, 1), ) foyer_fiscal = dict() foyer_fiscal.update(test_parameters['input_variables']) simulation = tax_benefit_system.new_scenario().init_single_entity( period=period, parent1=parent1, foyer_fiscal=foyer_fiscal, ).new_simulation(debug=True) for variable, monthly_amount in test_parameters[ 'output_variables'].iteritems(): output = simulation.calculate(variable) yield assert_variable, variable, name, monthly_amount, output