def test_get_memory_usage(tax_benefit_system):
simulation = SimulationBuilder().build_from_entities(
tax_benefit_system, single)
simulation.calculate('disposable_income', '2017-01')
memory_usage = simulation.get_memory_usage(variables=['salary'])
assert (memory_usage['total_nb_bytes'] > 0)
assert (len(memory_usage['by_variable']) == 1)
def test_from_person_variable_to_group(tax_benefit_system):
persons_ids: Iterable = [2, 0, 1, 4, 3]
households_ids: Iterable = ['c', 'a', 'b']
persons_households: Iterable = ['c', 'a', 'a', 'b', 'a']
persons_salaries: Iterable = [6000, 2000, 1000, 1500, 1500]
households_rents = [1036.6667, 781.6667, 271.6667]
period = '2018-12'
simulation_builder = SimulationBuilder()
simulation_builder.create_entities(tax_benefit_system)
simulation_builder.declare_person_entity('person', persons_ids)
household_instance = simulation_builder.declare_entity(
'household', households_ids)
simulation_builder.join_with_persons(household_instance,
persons_households,
['first_parent'] * 5)
simulation = simulation_builder.build(tax_benefit_system)
simulation.set_input('salary', period, persons_salaries)
simulation.set_input('rent', period, households_rents)
total_taxes = simulation.calculate('total_taxes', period)
assert total_taxes == pytest.approx(households_rents)
assert total_taxes / simulation.calculate('rent',
period) == pytest.approx(1)
def simulation(tax_benefit_system, month):
simulation_builder = SimulationBuilder()
simulation_builder.default_period = month
simulation = simulation_builder.build_from_variables(
tax_benefit_system, {'choice': numpy.random.randint(2, size=1000) + 1})
simulation.debug = True
return simulation
def test_clone(tax_benefit_system):
simulation = SimulationBuilder().build_from_entities(
tax_benefit_system, {
"persons": {
"bill": {
"salary": {
"2017-01": 3000
}
},
},
"households": {
"household": {
"parents": ["bill"]
}
}
})
simulation_clone = simulation.clone()
assert simulation != simulation_clone
for entity_id, entity in simulation.populations.items():
assert entity != simulation_clone.populations[entity_id]
assert simulation.persons != simulation_clone.persons
salary_holder = simulation.person.get_holder('salary')
salary_holder_clone = simulation_clone.person.get_holder('salary')
assert salary_holder != salary_holder_clone
assert salary_holder_clone.simulation == simulation_clone
assert salary_holder_clone.population == simulation_clone.persons
def test_dump(tax_benefit_system):
directory = tempfile.mkdtemp(prefix = "openfisca_")
simulation = SimulationBuilder().build_from_entities(tax_benefit_system, situation_examples.couple)
calculated_value = simulation.calculate('disposable_income', '2018-01')
simulation_dumper.dump_simulation(simulation, directory)
simulation_2 = simulation_dumper.restore_simulation(directory, tax_benefit_system)
# Check entities structure have been restored
testing.assert_array_equal(simulation.person.ids, simulation_2.person.ids)
testing.assert_array_equal(simulation.person.count, simulation_2.person.count)
testing.assert_array_equal(simulation.household.ids, simulation_2.household.ids)
testing.assert_array_equal(simulation.household.count, simulation_2.household.count)
testing.assert_array_equal(simulation.household.members_position, simulation_2.household.members_position)
testing.assert_array_equal(simulation.household.members_entity_id, simulation_2.household.members_entity_id)
testing.assert_array_equal(simulation.household.members_role, simulation_2.household.members_role)
# Check calculated values are in cache
disposable_income_holder = simulation_2.person.get_holder('disposable_income')
cached_value = disposable_income_holder.get_array('2018-01')
assert cached_value is not None
testing.assert_array_equal(cached_value, calculated_value)
shutil.rmtree(directory)
def test_add_unknown_enum_variable_value(persons, enum_variable):
instance_index = 0
simulation_builder = SimulationBuilder()
simulation_builder.entity_counts['persons'] = 1
with pytest.raises(SituationParsingError):
simulation_builder.add_variable_value(persons, enum_variable,
instance_index, 'Alicia',
'2018-11', 'baz')
def test_get_memory_usage(tax_benefit_system):
test_case = deepcopy(situation_examples.single)
test_case["persons"]["Alicia"]["salary"] = {"2017-01": 0}
simulation = SimulationBuilder().build_from_dict(tax_benefit_system, test_case)
simulation.calculate('disposable_income', '2017-01')
memory_usage = simulation.person.get_memory_usage(variables = ['salary'])
assert(memory_usage['total_nb_bytes'] > 0)
assert(len(memory_usage['by_variable']) == 1)
def new_simulation(self,
debug=False,
opt_out_cache=False,
use_baseline=False,
trace=False):
# Legacy from scenarios, used in reforms
tax_benefit_system = self.tax_benefit_system
if use_baseline:
while True:
baseline = tax_benefit_system.baseline
if baseline is None:
break
tax_benefit_system = baseline
builder = SimulationBuilder()
if self.attributes:
variables = self.attributes.get('input_variables') or {}
period = self.attributes.get('period')
builder.set_default_period(period)
simulation = builder.build_from_variables(
tax_benefit_system, variables)
else:
builder.set_default_period(self.period)
simulation = builder.build_from_entities(
tax_benefit_system, self.dict)
simulation.trace = trace
simulation.debug = debug
simulation.opt_out_cache = opt_out_cache
return simulation
def test_add_axis_on_a_non_existing_variable(persons):
simulation_builder = SimulationBuilder()
simulation_builder.add_person_entity(persons, {'Alicia': {}})
simulation_builder.add_parallel_axis({'count': 3, 'name': 'ubi', 'min': 0, 'max': 3000, 'period': '2018-11'})
with pytest.raises(KeyError):
simulation_builder.expand_axes()
def test_person_variable_with_constructor(tax_benefit_system):
simulation_yaml = """
persons:
bill:
salary:
2017-11: 1500
2017-12: 2000
bob:
salary: {}
claudia:
salary:
2017-11: 3000
2017-12: 4000
janet: {}
tom: {}
households:
first_household:
parents:
- bill
- bob
children:
- janet
- tom
second_household:
parents:
- claudia
"""
simulation = SimulationBuilder().build_from_dict(tax_benefit_system, test_runner.yaml.safe_load(simulation_yaml))
person = simulation.person
tools.assert_near(person('salary', "2017-11"), [1500, 0, 3000, 0, 0])
tools.assert_near(person('salary', "2017-12"), [2000, 0, 4000, 0, 0])
def test_entity_structure_with_constructor(tax_benefit_system):
simulation_yaml = """
persons:
bill: {}
bob: {}
claudia: {}
janet: {}
tom: {}
households:
first_household:
parents:
- bill
- bob
children:
- janet
- tom
second_household:
parents:
- claudia
"""
simulation = SimulationBuilder().build_from_dict(tax_benefit_system, test_runner.yaml.safe_load(simulation_yaml))
household = simulation.household
tools.assert_near(household.members_entity_id, [0, 0, 1, 0, 0])
assert((household.members_role == [FIRST_PARENT, SECOND_PARENT, FIRST_PARENT, CHILD, CHILD]).all())
tools.assert_near(household.members_position, [0, 1, 0, 2, 3])
def test_entity_variables_with_constructor(tax_benefit_system):
simulation_yaml = """
persons:
bill: {}
bob: {}
claudia: {}
janet: {}
tom: {}
households:
first_household:
parents:
- bill
- bob
children:
- janet
- tom
rent:
2017-06: 800
second_household:
parents:
- claudia
rent:
2017-06: 600
"""
simulation = SimulationBuilder().build_from_dict(tax_benefit_system, test_runner.yaml.safe_load(simulation_yaml))
household = simulation.household
tools.assert_near(household('rent', "2017-06"), [800, 600])
def test_fail_on_date_parsing(persons, date_variable):
instance_index = 0
simulation_builder = SimulationBuilder()
simulation_builder.entity_counts['persons'] = 1
with pytest.raises(SituationParsingError) as excinfo:
simulation_builder.add_variable_value(persons, date_variable,
instance_index, 'Alicia',
'2018-11', '2019-02-30')
assert excinfo.value.error == {
'persons': {
'Alicia': {
'datevar': {
'2018-11': "Can't deal with date: '2019-02-30'."
}
}
}
}
def test_nb_persons_in_households(tax_benefit_system):
persons_ids: Iterable = [2, 0, 1, 4, 3]
households_ids: Iterable = ['c', 'a', 'b']
persons_households: Iterable = ['c', 'a', 'a', 'b', 'a']
simulation_builder = SimulationBuilder()
simulation_builder.create_entities(tax_benefit_system)
simulation_builder.declare_person_entity('person', persons_ids)
household_instance = simulation_builder.declare_entity(
'household', households_ids)
simulation_builder.join_with_persons(household_instance,
persons_households,
['first_parent'] * 5)
persons_in_households = simulation_builder.nb_persons('household')
assert persons_in_households.tolist() == [1, 3, 1]
def test_build_default_simulation(tax_benefit_system):
one_person_simulation = SimulationBuilder().build_default_simulation(
tax_benefit_system, 1)
assert one_person_simulation.persons.count == 1
assert one_person_simulation.household.count == 1
assert one_person_simulation.household.members_entity_id == [0]
assert one_person_simulation.household.members_role == entities.Household.FIRST_PARENT
several_persons_simulation = SimulationBuilder().build_default_simulation(
tax_benefit_system, 4)
assert several_persons_simulation.persons.count == 4
assert several_persons_simulation.household.count == 4
assert (several_persons_simulation.household.members_entity_id == [
0, 1, 2, 3
]).all()
assert (several_persons_simulation.household.members_role ==
entities.Household.FIRST_PARENT).all()
def test_add_person_values_with_default_period_old_syntax(persons):
persons_json = {'Alicia': {'salary': 3000}, 'Javier': {}}
simulation_builder = SimulationBuilder()
simulation_builder.set_default_period('month:2018-11')
simulation_builder.add_person_entity(persons, persons_json)
tools.assert_near(simulation_builder.get_input('salary', '2018-11'),
[3000, 0])
def test_fail_on_wrong_data(persons):
salary = persons.get_variable('salary')
instance_index = 0
simulation_builder = SimulationBuilder()
simulation_builder.entity_counts['persons'] = 1
with pytest.raises(SituationParsingError) as excinfo:
simulation_builder.add_variable_value(persons, salary, instance_index,
'Alicia', '2018-11', 'alicia')
assert excinfo.value.error == {
'persons': {
'Alicia': {
'salary': {
'2018-11':
"Can't deal with value: expected type number, received 'alicia'."
}
}
}
}
def simulation(tax_benefit_system, request):
variables, period = request.param
return _simulation(
SimulationBuilder(),
tax_benefit_system,
variables,
period,
)
def test_fail_on_integer_overflow(persons, int_variable):
instance_index = 0
simulation_builder = SimulationBuilder()
simulation_builder.entity_counts['persons'] = 1
with pytest.raises(SituationParsingError) as excinfo:
simulation_builder.add_variable_value(persons, int_variable,
instance_index, 'Alicia',
'2018-11', 9223372036854775808)
assert excinfo.value.error == {
'persons': {
'Alicia': {
'intvar': {
'2018-11':
"Can't deal with value: '9223372036854775808', it's too large for type 'integer'."
}
}
}
}
def test_fail_on_ill_formed_expression(persons):
salary = persons.get_variable('salary')
instance_index = 0
simulation_builder = SimulationBuilder()
simulation_builder.entity_counts['persons'] = 1
with pytest.raises(SituationParsingError) as excinfo:
simulation_builder.add_variable_value(persons, salary, instance_index,
'Alicia', '2018-11',
'2 * / 1000')
assert excinfo.value.error == {
'persons': {
'Alicia': {
'salary': {
'2018-11':
"I couldn't understand '2 * / 1000' as a value for 'salary'"
}
}
}
}
def test_one_person_without_household(tax_benefit_system):
simulation_dict = {'persons': {'Alicia': {}}}
simulation = SimulationBuilder().build_from_dict(tax_benefit_system,
simulation_dict)
assert simulation.household.count == 1
parents_in_households = simulation.household.nb_persons(
role=entities.Household.PARENT)
assert parents_in_households.tolist() == [
1
] # household member default role is first_parent
def test_calculate_full_tracer(tax_benefit_system):
simulation = SimulationBuilder().build_default_simulation(
tax_benefit_system)
simulation.trace = True
simulation.calculate('income_tax', '2017-01')
income_tax_node = simulation.tracer.trees[0]
assert income_tax_node.name == 'income_tax'
assert str(income_tax_node.period) == '2017-01'
assert income_tax_node.value == 0
salary_node = income_tax_node.children[0]
assert salary_node.name == 'salary'
assert str(salary_node.period) == '2017-01'
assert salary_node.parameters == []
assert len(income_tax_node.parameters) == 1
assert income_tax_node.parameters[0].name == 'taxes.income_tax_rate'
assert income_tax_node.parameters[0].period == '2017-01-01'
assert income_tax_node.parameters[0].value == 0.15
def test_inconsistent_input(tax_benefit_system):
input_yaml = """
salary:
2016-10: [12000, 20000]
income_tax:
2016-10: [100, 200, 300]
"""
with pytest.raises(ValueError) as error:
SimulationBuilder().build_from_dict(
tax_benefit_system, test_runner.yaml.safe_load(input_yaml))
assert "its length is 3 while there are 2" in error.value.args[0]
def test_single_entity_shortcut(tax_benefit_system):
input_yaml = """
persons:
Alicia: {}
Javier: {}
household:
parents: [Alicia, Javier]
"""
simulation = SimulationBuilder().build_from_dict(
tax_benefit_system, test_runner.yaml.safe_load(input_yaml))
assert simulation.household.count == 1
def test_some_person_without_household(tax_benefit_system):
input_yaml = """
persons: {'Alicia': {}, 'Bob': {}}
household: {'parents': ['Alicia']}
"""
simulation = SimulationBuilder().build_from_dict(
tax_benefit_system, test_runner.yaml.safe_load(input_yaml))
assert simulation.household.count == 2
parents_in_households = simulation.household.nb_persons(
role=entities.Household.PARENT)
assert parents_in_households.tolist() == [
1, 1
] # household member default role is first_parent
def test_input_with_wrong_period(tax_benefit_system):
year = str(PERIOD.this_year)
variables = {"basic_income": {year: 12000}}
simulation_builder = SimulationBuilder()
simulation_builder.set_default_period(PERIOD)
with pytest.raises(ValueError):
simulation_builder.build_from_variables(tax_benefit_system, variables)
def test_canonicalize_period_keys(persons):
persons_json = {'Alicia': {'salary': {'year:2018-01': 100}}}
simulation_builder = SimulationBuilder()
simulation_builder.add_person_entity(persons, persons_json)
population = Population(persons)
simulation_builder.finalize_variables_init(population)
tools.assert_near(
population.get_holder('salary').get_array('2018-12'), [100])
def test_simulation(tax_benefit_system):
input_yaml = """
salary:
2016-10: 12000
"""
simulation = SimulationBuilder().build_from_dict(
tax_benefit_system, test_runner.yaml.safe_load(input_yaml))
assert simulation.get_array("salary", "2016-10") == 12000
simulation.calculate("income_tax", "2016-10")
simulation.calculate("total_taxes", "2016-10")
def test_simulation_with_axes(tax_benefit_system):
input_yaml = """
persons:
Alicia: {salary: {2018-11: 0}}
Javier: {}
Tom: {}
households:
housea:
parents: [Alicia, Javier]
houseb:
parents: [Tom]
axes:
-
- count: 2
name: rent
min: 0
max: 3000
period: 2018-11
"""
data = test_runner.yaml.safe_load(input_yaml)
simulation = SimulationBuilder().build_from_dict(tax_benefit_system, data)
assert simulation.get_array('salary', '2018-11') == pytest.approx([0, 0, 0, 0, 0, 0])
assert simulation.get_array('rent', '2018-11') == pytest.approx([0, 0, 3000, 0])
def test_add_variable_value_as_expression(persons):
salary = persons.get_variable('salary')
instance_index = 0
simulation_builder = SimulationBuilder()
simulation_builder.entity_counts['persons'] = 1
simulation_builder.add_variable_value(persons, salary, instance_index,
'Alicia', '2018-11', '3 * 1000')
input_array = simulation_builder.get_input('salary', '2018-11')
assert input_array[instance_index] == pytest.approx(3000)
