def test_no_period(): year = 2016 buggy_tbf = CountryTaxBenefitSystem() buggy_tbf.add_variable(income_tax_no_period) simulation = buggy_tbf.new_scenario().init_from_attributes( period=year, input_variables=dict(salary=2000, ), ).new_simulation() simulation.calculate_add('income_tax_no_period', year)
def test_inflate_scale(): """ Test parameters inflator on a scale parameter as the social security contributions tax_scale """ tax_benefit_system = CountryTaxBenefitSystem() parameters = tax_benefit_system.parameters inflate_parameters(parameters, inflator=.3, base_year=2015, last_year=2016) for (threshold_2016, threshold_2015) in zip( parameters.taxes.social_security_contribution(2016).thresholds, parameters.taxes.social_security_contribution(2015).thresholds): assert threshold_2016 == threshold_2015 * 1.3
def test_inflate_simple_parameter(): """ Test parameters inflator on a simple parameter as the basic income """ tax_benefit_system = CountryTaxBenefitSystem() parameters = tax_benefit_system.parameters basic_income_2016 = parameters.benefits.basic_income(2016) basic_income_2017 = parameters.benefits.basic_income(2017) assert basic_income_2017 == basic_income_2016 inflate_parameters(parameters, inflator=.1, base_year=2016, last_year=2017) assert basic_income_2016 == parameters.benefits.basic_income(2016) assert 1.1 * basic_income_2016 == parameters.benefits.basic_income(2017)
def test_variable_with_reference(make_isolated_simulation): tax_benefit_system = CountryTaxBenefitSystem() # Work in isolation simulation_base = make_isolated_simulation(tax_benefit_system, {'salary': 4000}) revenu_disponible_avant_reforme = simulation_base.calculate( 'disposable_income', "2016-01") assert (revenu_disponible_avant_reforme > 0) class disposable_income(Variable): definition_period = MONTH def formula(household, period): return household.empty_array() tax_benefit_system.update_variable(disposable_income) simulation_reform = make_isolated_simulation(tax_benefit_system, {'salary': 4000}) revenu_disponible_apres_reforme = simulation_reform.calculate( 'disposable_income', "2016-01") assert (revenu_disponible_apres_reforme == 0)
def test_variable_with_reference(): tax_benefit_system = CountryTaxBenefitSystem() # Work in isolation def new_simulation(): return tax_benefit_system.new_scenario().init_from_attributes( period="2016-01", input_variables=dict(salary=4000, ), ).new_simulation() revenu_disponible_avant_reforme = new_simulation().calculate( 'disposable_income', "2016-01") assert (revenu_disponible_avant_reforme > 0) class disposable_income(Variable): definition_period = MONTH def formula(self, simulation, period): return self.zeros() tax_benefit_system.update_variable(disposable_income) revenu_disponible_apres_reforme = new_simulation().calculate( 'disposable_income', "2016-01") assert (revenu_disponible_apres_reforme == 0)
def test_asof_scale_parameters(): """ Test parameters_asof on a scale parameter """ tax_benefit_system = CountryTaxBenefitSystem() parameters = tax_benefit_system.parameters social_security_contribution_2016 = parameters.taxes.social_security_contribution( 2016).thresholds[1] social_security_contribution_2017 = parameters.taxes.social_security_contribution( 2017).thresholds[1] assert social_security_contribution_2016 != social_security_contribution_2017 parameters_asof(parameters, instant="2016") assert parameters.taxes.social_security_contribution( 2016).thresholds[1] == social_security_contribution_2016 assert parameters.taxes.social_security_contribution( 2017).thresholds[1] == social_security_contribution_2016
def test_asof_simple_annual_parameter(): """ Test parameters_asof on a simple parameter """ tax_benefit_system = CountryTaxBenefitSystem() parameters = tax_benefit_system.parameters income_tax_rate_2014 = parameters.taxes.income_tax_rate(2014) income_tax_rate_2015 = parameters.taxes.income_tax_rate(2015) assert income_tax_rate_2015 != income_tax_rate_2014 parameters_asof(parameters, instant="2014") assert parameters.taxes.income_tax_rate( 2014) == income_tax_rate_2014, "{} != {}".format( parameters.taxes.income_tax_rate(2014), income_tax_rate_2014) assert parameters.taxes.income_tax_rate( 2015) == income_tax_rate_2014, "{} != {}".format( parameters.taxes.income_tax_rate(2015), income_tax_rate_2014)
def test_inflate_scale_with_changing_number_of_brackets(): """ Test parameters inflator on a scale parameter when the number of brackets changes Use parameters_asof to use the present legislation the future pre-inflated legislation Test on the social security contributions tax_scale """ tax_benefit_system = CountryTaxBenefitSystem() parameters = tax_benefit_system.parameters parameters_asof( parameters, instant=periods.instant(2016)) # Remove post 2016 legislation changes inflate_parameters(parameters, inflator=.3, base_year=2016, last_year=2017) for (threshold_2017, threshold_2016) in zip( parameters.taxes.social_security_contribution(2017).thresholds, parameters.taxes.social_security_contribution(2016).thresholds): assert threshold_2017 == threshold_2016 * 1.3, "{} != {}".format( threshold_2017, threshold_2016 * 1.3)
def formula(self, simulation, period, choice): return self.zeros() + choice class formula_4(Variable): value_type = bool entity = Person base_function = requested_period_last_value definition_period = MONTH def formula(self, simulation, period, choice): return self.zeros() + choice # TaxBenefitSystem instance declared after formulas tax_benefit_system = CountryTaxBenefitSystem() tax_benefit_system.add_variables(formula_1, formula_2, formula_3, formula_4) reference_period = periods.period(u'2013-01') simulation = tax_benefit_system.new_scenario().init_from_attributes( period = reference_period.first_month, ).new_simulation(debug = True) formula_1_result = simulation.calculate('formula_1', period = reference_period) formula_2_result = simulation.calculate('formula_2', period = reference_period) formula_3_holder = simulation.person.get_holder('formula_3') def test_cache(): assert_near(formula_1_result, [0]) assert_near(formula_2_result, [1])
# december cotisation depending on november value class cotisation(Variable): value_type = int entity = Person definition_period = MONTH def formula(person, period): if period.start.month == 12: return 2 * person('cotisation', period.last_month) else: return person.empty_array() + 1 # TaxBenefitSystem instance declared after formulas tax_benefit_system = CountryTaxBenefitSystem() tax_benefit_system.add_variables(variable1, variable2, variable3, variable4, variable5, variable6, variable7, cotisation) def test_pure_cycle(simulation, reference_period): with raises(CycleError): simulation.calculate('variable1', period = reference_period) def test_spirals_result_in_default_value(simulation, reference_period): variable3 = simulation.calculate('variable3', period = reference_period) assert_near(variable3, [0]) def test_spiral_heuristic(simulation, reference_period):
import pytest from openfisca_country_template import CountryTaxBenefitSystem original_tbs = CountryTaxBenefitSystem() def test_load_extension(): tbs = original_tbs.clone() assert tbs.get_variable('local_town_child_allowance') is None tbs.load_extension('openfisca_extension_template') assert tbs.get_variable('local_town_child_allowance') is not None assert original_tbs.get_variable('local_town_child_allowance') is None def test_access_to_parameters(): tbs = original_tbs.clone() tbs.load_extension('openfisca_extension_template') assert tbs.parameters('2016-01').local_town.child_allowance.amount == 100.0 assert tbs.parameters.local_town.child_allowance.amount('2016-01') == 100.0 def test_failure_to_load_extension_when_directory_doesnt_exist(): with pytest.raises(ValueError): original_tbs.load_extension('/this/is/not/a/real/path')
definition_period = MONTH def formula(person, period): choice = person('choice', period) result = switch( choice, { 1: 80, 2: 90, }, ) return result # TaxBenefitSystem instance declared after formulas our_tbs = CountryTaxBenefitSystem() our_tbs.add_variables(choice, uses_multiplication, uses_switch, returns_scalar) @fixture def month(): return '2013-01' @fixture def simulation(month): builder = SimulationBuilder() builder.default_period = month simulation = builder.build_from_variables( our_tbs, {'choice': np.random.randint(2, size=1000) + 1}) simulation.debug = True
# -*- coding: utf-8 -*- from openfisca_country_template import CountryTaxBenefitSystem from openfisca_core.formulas import Formula from openfisca_core.simulations import Simulation tax_benefit_system = CountryTaxBenefitSystem() scenario = tax_benefit_system.new_scenario().init_from_attributes( period=2014 ) def test_calculate_with_trace(): simulation = scenario.new_simulation(trace=True) simulation.calculate('disposable_income', "2014-01") def test_calculate__holder_attribute_content(): simulation = scenario.new_simulation() variable_name = 'disposable_income' period = "2014-01" simulation.calculate(variable_name, period) # numpy.ndarray simulation_holder = simulation.person.get_holder(variable_name) assert issubclass(simulation_holder.formula.__class__, Formula) assert len(simulation_holder.formula.dated_formulas) > 0 # contains formulas instances def test_clone():
import numpy as np import pandas from openfisca_core.simulation_builder import SimulationBuilder from openfisca_country_template import CountryTaxBenefitSystem from income_tax_rate_editable_reform import income_tax_rate_editable_reform tax_benefit_system = CountryTaxBenefitSystem() period = '2020-01' salaries = np.array([1500, 2500, 3500]) # Calculate income tax according to current tax rate simulation_builder = SimulationBuilder() simulation_1 = simulation_builder.build_default_simulation(tax_benefit_system, count=3) simulation_1.set_input('salary', '2020-01', salaries) print("> current income_tax_rate", tax_benefit_system.parameters(period).taxes.income_tax_rate) income_tax = simulation_1.calculate('income_tax', period) print("income_tax", income_tax) # Calculate income tax according to csv tax rates csv_data = pandas.read_csv('./income_tax_rates.csv') for income_tax_rate in csv_data.income_tax_rate: print("> reform income_tax_rate", income_tax_rate) specific_legislation = income_tax_rate_editable_reform(tax_benefit_system, income_tax_rate) simulation_builder = SimulationBuilder()
def formula(person, period, parameters, choice): return person.empty_array() + choice class formula_4(Variable): value_type = bool entity = Person base_function = requested_period_last_value definition_period = MONTH def formula(person, period, parameters, choice): return person.empty_array() + choice # TaxBenefitSystem instance declared after formulas tax_benefit_system = CountryTaxBenefitSystem() tax_benefit_system.add_variables(formula_1, formula_2, formula_3, formula_4) reference_period = periods.period('2013-01') def get_simulation(): return tax_benefit_system.new_scenario().init_from_attributes( period=reference_period.first_month, ).new_simulation() def test_cache(): simulation = get_simulation() formula_1_result = simulation.calculate('formula_1', period=reference_period) formula_2_result = simulation.calculate('formula_2',
def tax_benefit_system(): return CountryTaxBenefitSystem()
# december cotisation depending on november value class cotisation(Variable): value_type = int entity = Person definition_period = MONTH def formula(person, period): if period.start.month == 12: return 2 * person('cotisation', period.last_month) else: return person.empty_array() + 1 # TaxBenefitSystem instance declared after formulas tax_benefit_system = CountryTaxBenefitSystem() tax_benefit_system.add_variables(variable1, variable2, variable3, variable4, variable5, variable6, variable7, cotisation) def test_pure_cycle(simulation, reference_period): with raises(CycleError): simulation.calculate('variable1', period=reference_period) def test_spirals_result_in_default_value(simulation, reference_period): variable3 = simulation.calculate('variable3', period=reference_period) assert_near(variable3, [0]) def test_spiral_heuristic(simulation, reference_period):
def get_filled_tbs(): tax_benefit_system = CountryTaxBenefitSystem() tax_benefit_system.add_variables(input, intermediate, output) return tax_benefit_system
if index <= 1: famille.setdefault('parents', []).append(id) else: famille.setdefault('children', []).append(id) conv.check(self.make_json_or_python_to_attributes())(dict( axes=axes, period=period, test_case=dict( households=[famille], persons=individus, ), )) return self tax_benefit_system = CountryTaxBenefitSystem() tax_benefit_system.Scenario = AxesScenario # Test introduced following a bug with set_input in the case of parallel axes def test_set_input_parallel_axes(): year = "2016-01" simulation = tax_benefit_system.new_scenario().init_single_entity( axes=[ [ dict( count=3, index=0, name='salary', max=100000, min=0,
def test_parameters_as_of(): tax_benefit_system = CountryTaxBenefitSystem() parameters = tax_benefit_system.parameters instant = periods.instant("2012-12-31") parameters_asof(parameters, instant) check_max_instant(parameters, instant)
def test_variables_as_of(): tax_benefit_system = CountryTaxBenefitSystem() instant = periods.instant("2015-12-31") variables_asof(tax_benefit_system, instant)
class variable_with_calculate_output_add(Variable): entity = Person definition_period = MONTH value_type = int calculate_output = calculate_output_add class variable_with_calculate_output_divide(Variable): entity = Person definition_period = YEAR value_type = int calculate_output = calculate_output_divide tax_benefit_system = CountryTaxBenefitSystem() tax_benefit_system.add_variables(simple_variable, variable_with_calculate_output_add, variable_with_calculate_output_divide) @raises(ValueError) def test_calculate_output_default(): simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=single) simulation.calculate_output('simple_variable', 2017) def test_calculate_output_add(): simulation = Simulation(tax_benefit_system=tax_benefit_system, simulation_json=single)
def get_filled_tbs(): tax_benefit_system = CountryTaxBenefitSystem() tax_benefit_system.add_variables(input, intermediate, output) return tax_benefit_system
class variable_with_calculate_output_add(Variable): entity = Person definition_period = MONTH value_type = int calculate_output = calculate_output_add class variable_with_calculate_output_divide(Variable): entity = Person definition_period = YEAR value_type = int calculate_output = calculate_output_divide tax_benefit_system = CountryTaxBenefitSystem() tax_benefit_system.add_variables( simple_variable, variable_with_calculate_output_add, variable_with_calculate_output_divide ) def test_calculate_output_default(simulation): with raises(ValueError): simulation.calculate_output('simple_variable', 2017) def test_calculate_output_add(simulation): simulation.set_input('variable_with_calculate_output_add', '2017-01', [10]) simulation.set_input('variable_with_calculate_output_add', '2017-05', [20])
definition_period = MONTH def formula(self, simulation, period): choice = simulation.calculate('choice', period) result = switch( choice, { 1: 80, 2: 90, }, ) return result # TaxBenefitSystem instance declared after formulas tax_benefit_system = CountryTaxBenefitSystem() tax_benefit_system.add_variables(choice, uses_multiplication, uses_switch) month = '2013-01' scenario = tax_benefit_system.new_scenario().init_from_attributes( period=month, input_variables={ # 'choice': [1, 1, 1, 2], 'choice': np.random.randint(2, size=1000) + 1, }, ) def test_switch(): simulation = scenario.new_simulation(debug=True) uses_switch = simulation.calculate('uses_switch', period=month) assert isinstance(uses_switch, np.ndarray)
from __future__ import unicode_literals, print_function, division, absolute_import from nose.tools import raises from openfisca_country_template import CountryTaxBenefitSystem tbs = CountryTaxBenefitSystem() def test_extension_not_already_loaded(): assert tbs.get_variable('local_town_child_allowance') is None def test_load_extension(): tbs.load_extension('openfisca_extension_template') assert tbs.get_variable('local_town_child_allowance') is not None def test_unload_extensions(): tbs = CountryTaxBenefitSystem() assert tbs.get_variable('local_town_child_allowance') is None @raises(ValueError) def test_failure_to_load_extension_when_directory_doesnt_exist(): tbs.load_extension('/this/is/not/a/real/path')
# -*- coding: utf-8 -*- import warnings from pytest import fixture, raises from openfisca_core import periods from openfisca_core.periods import Instant from openfisca_core.simulation_builder import SimulationBuilder from openfisca_core.tools import assert_near from openfisca_core.parameters import ValuesHistory, ParameterNode from openfisca_country_template.entities import Household, Person from openfisca_core.model_api import * # noqa analysis:ignore from openfisca_country_template import CountryTaxBenefitSystem tax_benefit_system = CountryTaxBenefitSystem() @fixture def make_simulation(): def _make_simulation(tbs, period, data): builder = SimulationBuilder() builder.default_period = period return builder.build_from_variables(tbs, data) return _make_simulation class goes_to_school(Variable): value_type = bool default_value = True entity = Person label = "The person goes to school (only relevant for children)"
def test_unload_extensions(): tbs = CountryTaxBenefitSystem() assert tbs.get_variable('local_town_child_allowance') is None
'salary': { '2011-01': 1000 } }, 'Paul': {}, 'Leila': {}, 'Javier': {} }, 'households': { 'h1': { 'children': ['Leila'], 'parents': ['Ari', 'Paul'], 'rent': { '2011-01': 300 } }, 'h2': { 'parents': ['Javier'] } }, } tax_benefit_system = CountryTaxBenefitSystem() simulation_builder = SimulationBuilder() simulation = simulation_builder.build_from_entities(tax_benefit_system, TEST_CASE) housing_allowance = simulation.calculate('housing_allowance', '2011-01') print("housing_allowance", housing_allowance)
def isolated_tax_benefit_system(): return CountryTaxBenefitSystem()