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)