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()
